What gets translated

Goal: decide what needs translating before anything goes out in another language. One pass gives you:

• sensitive material that stays on your machine (Redaction);
• what you've already translated, reused at no cost (Content memory);
• every language held to the same bar as the source (Checks).

Each job runs ad-hoc on any file. A kapi project makes the pass repeatable, and its content memory and terms store grow with every run.

Desktop

1. See what goes out. Open a file from a content collection: the Blocks view is exactly the text a translation run works on; everything else is structure the round-trip preserves. Only blocks are translated.
2. Protect and reuse. Under Toolbox → Flows, put redact and recycle steps ahead of translate in the project's flow: sensitive spans become placeholders before any provider is called, and memory matches fill first, so a run pays only for what's new.
3. Hold every language to the bar. Bind the voice profile in Project Settings and commit the term list the recipe binds (kapi terms import writes it; Context → Terms shows it); the findings count on the project's Map then opens terminology and quality findings per block, and a locale doesn't reach its ship gate past a failing check.

Agent (Claude)

With kapi connected, ask for the outcomes:

Prepare this catalog for French: protect names, reuse what we've already translated, enforce our terms.

The assistant runs the same pass through kapi: the secure-translate flow for protection, recycle for reuse, check for the bar, then reports what was redacted, what came back from memory, and what still needs a person.

CLI

Protect sensitive content: redact, translate against placeholders, restore locally:

kapi run secure-translate -i src/locales/en.json --target-lang fr

Reuse past translations: fill from content memory first, translate only what's left (the deterministic version):

kapi exec recycle src/locales/en.json --target-lang fr

Keep terminology and quality consistent: import the term list once, then gate:

kapi terms import terms.json --name product-terms
kapi check src/locales/en.json --target src/locales/fr.json --target-lang fr

When a check flags a block, fix it through the inspect → apply loop (Edit content) and re-check. To make the pass one repeatable verb, name it as a flow in your project:

kapi.yaml

flows:
  prepare:
    steps:
      - tool: redact # protect sensitive content
      - tool: segmentation # per-sentence segments, so reuse and checks land precisely
      - tool: entity-extract # detect names so memory reuse generalizes over them
      - tool: recycle # reuse past translations
      - tool: translate # translate the remainder
      - tool: qa # gate on findings

kapi run prepare -i src/locales/en.json --target-lang fr

In a project

In a kapi project the same pass runs against the recipe's declared content and locales: kapi run prepare with no file argument resolves the sources from the project, and the content memory and terms store it builds are the project's own. For the model behind this, in which each step adds to one settled source and changes none of it, see Content preparation.

Next

• Redaction: rules files, entity detection, and the extract/merge path for human translators.
• Reuse what you've translated: the content-memory pass end to end.
• Keep terms consistent: terminology enforcement in full.