agent-kitchen 0.6.0 → 0.8.0

package/README.md

@@ -59,7 +59,7 @@ npx agent-kitchen doctor                       # revisa cada pieza con su propio
 
 - **Sin terminal y sin `--yes`** (por ejemplo, desde un agente), solo muestra lo que ofrecería.
 - **Corre en el checkout principal,** no en un worktree, y desde tu terminal. Dentro de una sesión de Claude, el sandbox de `claude-repo-guard` no deja escribir `.claude/settings.json`.
-- **Al terminar,** corre el `install` de tu gestor de paquetes, revisa el diff y haz commit. O usa `--commit`.
+- **Al terminar,** si los pasos cambiaron `package.json`, corre el `install` de tu gestor de paquetes. Te queda revisar el diff y hacer commit. O usa `--commit`.
 
 **`--commit`** deja los cambios commiteados sin que lo haga un agente:
 

package/dist/commands/sync.d.ts

@@ -1,4 +1,5 @@
 import { type Output } from "../output.js";
+import type { Step } from "../piece.js";
 /** Options of the command. */
 export interface SyncOptions {
     cwd: string;
@@ -26,13 +27,13 @@ export declare function pieceNames(): string[];
 export declare function noStepsMessage(why: "leave" | "none", wrote: boolean): string;
 /**
  * What the commit of `--commit` lists: the steps that worked, and the decisions file if this
- * run wrote it.
- * @param done - The labels of the steps that worked.
+ * run wrote it, in the commit's texts (not the interface's).
+ * @param done - The steps that worked.
  * @param wrote - Whether the decisions file was written in this run.
- * @returns The labels.
+ * @returns The lines.
  * @example commitLabels([], true) // ["Guardar qué piezas usa el repo en .agents/kitchen.json"]
  */
-export declare function commitLabels(done: string[], wrote: boolean): string[];
+export declare function commitLabels(done: Pick<Step, "text">[], wrote: boolean): string[];
 /**
  * Runs the command; see the file's header.
  * @param options - The options.

package/dist/commands/sync.js

@@ -11,7 +11,8 @@
  * flow's version), one line each, with the
  * tools' output only when one fails; one that fails does not stop the rest. With `--yes`
  * it does what is suggested without asking (and keeps the repo's own skills); without a
- * terminal it only shows the steps. With `--commit` it first checks the repo is clean and on
+ * terminal it only shows the steps. Without `--commit`, it installs at the end if the steps
+ * changed package.json. With `--commit` it first checks the repo is clean and on
  * its base branch, and at the end installs if package.json changed and asks what to do with
  * the changes (see git-finish.ts), also when the only change is the decisions file below;
  * the steps then show as plain lines, since a spinner before a question leaves it deaf.
@@ -23,7 +24,6 @@
  * `--pieces` (terminal only, not with `--yes` or `--dry-run`) first asks which pieces the repo
  * uses, writes all of them to the file, and then goes on as usual.
  */
-import { spinner } from "@clack/prompts";
 import { DECIDABLE, decide, DECISIONS, off, readDecisions, undecided, writeDecisions } from "../decisions.js";
 import { baseBranch, branchName, changedPaths, checkReady, finish } from "../git-finish.js";
 import { askFinish, askPath, askPieces, askReplace, askSkills, askSteps } from "../menu.js";
@@ -34,8 +34,11 @@ import { issueFlowStatus, NAME as FLOW } from "../pieces/issue-flow.js";
 import { keepOwn, NAME as SKILLS, ownInPick, skillsStatus } from "../pieces/skills.js";
 import { agentsMdStatus, NAME as AGENTS_MD } from "../pieces/agents-md.js";
 import { NAME as SKILLS_MANAGER, skillsManagerStatus } from "../pieces/skills-manager.js";
-import { mainCheckout, packageManager } from "../repo.js";
+import { mainCheckout, packageManager, packageText } from "../repo.js";
 import { download, failedOutput, runInstall, setVerbose } from "../tools.js";
+import { commitLine, DECISIONS_LINE } from "../commit-texts.js";
+import { progressFor } from "../progress.js";
+import { phrases, stepLabel, ui } from "../texts/index.js";
 /** Every piece, in the order its steps run. */
 const PIECES = [SKILLS_MANAGER, FLOW, CLOUD, GUARD, SKILLS, AGENTS_MD];
 /**
@@ -115,9 +118,7 @@ function saveDecisions(root, saved, statuses, chosen, commits, out) {
  * @example noStepsMessage("none", true) // "No elegiste pasos; solo guardé qué piezas usa el repo.\n"
  */
 export function noStepsMessage(why, wrote) {
-    if (why === "leave")
-        return wrote ? "No corrí ningún paso; solo guardé qué piezas usa el repo.\n" : "No se cambió nada.\n";
-    return wrote ? "No elegiste pasos; solo guardé qué piezas usa el repo.\n" : "No elegiste nada; no se cambió nada.\n";
+    return `${ui.noSteps(why, wrote)}\n`;
 }
 /**
  * The line that says the decisions were saved.
@@ -125,20 +126,19 @@ export function noStepsMessage(why, wrote) {
  * @returns The line.
  */
 function savedMessage(commits) {
-    return `Guardé qué piezas usa el repo en ${DECISIONS}${commits ? "" : "; commitéalo"}.\n`;
+    return `${ui.saved(DECISIONS, commits)}\n`;
 }
-/** The line the commit of `--commit` adds for the decisions file. */
-const DECISIONS_STEP = `Guardar qué piezas usa el repo en ${DECISIONS}`;
 /**
  * What the commit of `--commit` lists: the steps that worked, and the decisions file if this
- * run wrote it.
- * @param done - The labels of the steps that worked.
+ * run wrote it, in the commit's texts (not the interface's).
+ * @param done - The steps that worked.
  * @param wrote - Whether the decisions file was written in this run.
- * @returns The labels.
+ * @returns The lines.
  * @example commitLabels([], true) // ["Guardar qué piezas usa el repo en .agents/kitchen.json"]
  */
 export function commitLabels(done, wrote) {
-    return wrote ? [...done, DECISIONS_STEP] : done;
+    const lines = done.map((step) => commitLine(step.text));
+    return wrote ? [...lines, DECISIONS_LINE] : lines;
 }
 /**
  * Asks which pieces the repo uses and writes the answer for every decidable piece.
@@ -149,7 +149,7 @@ export function commitLabels(done, wrote) {
  * @returns False if the person cancelled.
  */
 async function choosePieces(root, saved, commits, out) {
-    out.stdout("Revisando el repo y las últimas versiones…\n");
+    out.stdout(`${ui.checking}\n`);
     // No skip here: an installed, undecided piece passed in --skip still starts ticked.
     const statuses = await statusesOf(root, []);
     const ticked = DECIDABLE.filter((name) => saved?.pieces[name] === true || (saved?.pieces[name] === undefined && statuses.some((status) => status.name === name && status.installed)));
@@ -173,7 +173,7 @@ function keepOwnSkills(root, step, out) {
     if (own.length === 0)
         return;
     Object.assign(step.skills, keepOwn(step.skills, own));
-    out.stdout(`Se dejan fuera las skills que el repo ya tiene como propias: ${own.join(", ")}. Para reemplazarlas, corre agent-kitchen apply en una terminal.\n`);
+    out.stdout(`${ui.ownSkillsKept(own)}\n`);
 }
 /**
  * Asks, for a step that installs skills, which ones, and whether to replace the repo's own.
@@ -217,14 +217,13 @@ async function chooseSteps(root, steps, options, out) {
     const suggested = steps.filter((step) => step.checked);
     if (options.yes) {
         if (suggested.length === 0)
-            out.stdout(`Todo al día. Opcional, para elegir en una terminal: ${steps.map((step) => step.label).join("; ")}.\n`);
+            out.stdout(`${ui.onlyOptional(steps.map(stepLabel))}\n`);
         for (const step of suggested)
             keepOwnSkills(root, step, out);
         return suggested;
     }
     if (options.dryRun || !out.interactive) {
-        const hint = options.dryRun ? "" : " (para hacerlos, corre agent-kitchen apply en una terminal, o con --yes)";
-        out.stdout(`Pasos sugeridos${hint}:\n${steps.map((step) => `  [${step.checked ? "x" : " "}] ${step.label}\n`).join("")}`);
+        out.stdout(`${ui.suggested(options.dryRun)}\n${steps.map((step) => `  [${step.checked ? "x" : " "}] ${stepLabel(step)}\n`).join("")}`);
         return null;
     }
     for (const step of suggested)
@@ -242,22 +241,6 @@ async function chooseSteps(root, steps, options, out) {
     }
     return chosen;
 }
-/**
- * How progress is shown: a spinner in a terminal (unless the tools print with
- * `--verbose`), plain lines otherwise. Only for the steps, after every question: a spinner
- * shown before a question leaves the second question deaf to the keyboard (@clack/prompts
- * 1.8.1).
- * @param out - Where to write.
- * @param verbose - Whether the tools print on the terminal.
- * @returns The progress.
- */
-function progressFor(out, verbose) {
-    if (out.interactive && !verbose) {
-        const spin = spinner();
-        return { start: (text) => spin.start(text), stop: (text, ok) => (ok ? spin.stop(text) : spin.error(text)) };
-    }
-    return { start: (text) => out.stdout(`→ ${text}\n`), stop: (text, ok) => out.stdout(`${ok ? "✓" : "✗"} ${text}\n`) };
-}
 /**
  * Runs one step and shows how it went: its notes, and what to do if it failed.
  * @param root - The repo.
@@ -275,19 +258,21 @@ async function runStep(root, step, progress, out) {
         note: (text) => notes.push(text),
         fail: (text, output) => failures.push(`  ${text}\n${output === undefined ? "" : failedOutput(output)}`),
     };
-    progress.start(step.label);
-    await Promise.all(step.downloads.map((spec) => download(root, spec)));
+    progress.start(step.text);
     let ok;
     try {
+        await Promise.all(step.downloads.map((spec) => download(root, spec)));
         ok = await step.run(context);
     }
     catch (error) {
-        if (!(error instanceof KitError))
+        if (!(error instanceof KitError)) {
+            progress.stop(step.text, false);
             throw error;
+        }
         failures.push(`  ${error.message}\n`);
         ok = false;
     }
-    progress.stop(step.label, ok);
+    progress.stop(step.text, ok);
     for (const note of notes)
         out.stdout(`  · ${note}\n`);
     for (const failure of failures)
@@ -333,32 +318,33 @@ export async function sync(options, out) {
     const asks = out.interactive && !options.yes && !options.dryRun;
     const saves = asks && options.skip.length === 0;
     if (out.interactive)
-        out.stdout("Revisando el repo y las últimas versiones…\n");
+        out.stdout(`${ui.checking}\n`);
     let statuses = await statusesOf(root, skip);
     if (saved !== null && !asks && !options.dryRun) {
         const left = undecided(saved).filter((name) => statuses.some((status) => status.name === name && !status.installed));
         if (left.length > 0) {
             skip.push(...left);
             statuses = await statusesOf(root, skip);
-            out.stdout(`Pieza nueva sin decisión: ${left.join(", ")}. Corre agent-kitchen apply en una terminal para elegir.\n`);
+            out.stdout(`${ui.undecided(left)}\n`);
         }
     }
     if (saved !== null) {
         const fresh = undecided(saved);
         for (const status of statuses.filter((each) => fresh.includes(each.name))) {
-            status.state += " (nueva)";
+            status.state += ui.fresh;
             for (const step of status.steps)
-                step.label += " (nueva)";
+                step.fresh = true;
         }
     }
     printStatus(statuses, off(saved).filter((name) => !options.skip.includes(name)), out);
     const steps = statuses.flatMap((status) => status.steps);
     // With --commit, a run that only wrote the decisions file still ends with the question.
-    const endWithoutSteps = async () => (base !== null && wrote ? commitChanges(root, base, commitLabels([], true), [], options, out) : 0);
+    const progress = progressFor(out, options.verbose, base !== null);
+    const endWithoutSteps = async () => (base !== null && wrote ? commitChanges(root, base, commitLabels([], true), [], progress, options, out) : 0);
     if (steps.length === 0) {
         if (saves)
             wrote = saveDecisions(root, saved, statuses, [], base !== null, out) || wrote;
-        out.stdout("Todo al día: no hay nada que instalar ni actualizar.\n");
+        out.stdout(`${ui.upToDate}\n`);
         return endWithoutSteps();
     }
     const chosen = await chooseSteps(root, steps, options, out);
@@ -382,31 +368,51 @@ export async function sync(options, out) {
             out.stdout(noStepsMessage("none", wrote));
         return endWithoutSteps();
     }
-    const progress = progressFor(out, options.verbose || base !== null);
-    const failed = [];
+    const pkgBefore = packageText(root);
+    const failedSteps = [];
     for (const step of chosen) {
         if (!(await runStep(root, step, progress, out)))
-            failed.push(step.label);
+            failedSteps.push(step);
     }
+    const failed = failedSteps.map(stepLabel);
     if (base !== null)
-        return commitChanges(root, base, commitLabels(chosen.filter((step) => !failed.includes(step.label)).map((step) => step.label), wrote), failed, options, out);
-    const next = `Falta: corre '${packageManager(root)} install', revisa el diff y haz commit.`;
-    out.stdout(`\n${failed.length === 0 ? "Listo." : `Terminó, pero fallaron: ${failed.join("; ")}.`} ${next}\n`);
+        return commitChanges(root, base, commitLabels(chosen.filter((step) => !failedSteps.includes(step)), wrote), failed, progress, options, out);
+    const installFailed = packageText(root) !== pkgBefore ? !(await install(root, progress, out)) : false;
+    if (installFailed)
+        failed.push(phrases({ kind: "install-deps", manager: packageManager(root) }).menu);
+    out.stdout(`\n${ui.summary(failed)} ${ui.next(installFailed ? packageManager(root) : null)}\n`);
     return failed.length === 0 ? 0 : 1;
 }
+/**
+ * Runs the repo's install with the same progress as a step, and shows its output if it fails.
+ * @param root - The repo.
+ * @param progress - How progress is shown.
+ * @param out - Where to write.
+ * @returns Whether it worked.
+ */
+async function install(root, progress, out) {
+    const text = { kind: "install-deps", manager: packageManager(root) };
+    progress.start(text);
+    const installed = await runInstall(root, text.manager);
+    progress.stop(text, installed.ok);
+    if (!installed.ok)
+        out.stderr(failedOutput(installed.output));
+    return installed.ok;
+}
 /**
  * The end of `--commit`: the install if package.json changed, the changes, the question (or
  * the branch with a PR under --yes) and what git did.
  * @param root - The repo.
  * @param base - The base branch.
- * @param done - What the commit lists: the labels of the steps that worked, and the decisions file if written.
- * @param failed - The labels of the steps that failed.
+ * @param done - What the commit lists: the steps that worked, and the decisions file if written.
+ * @param failed - The steps that failed, as the interface names them.
+ * @param progress - How progress is shown, for the install.
  * @param options - The options.
  * @param out - Where to write and ask.
  * @returns 0, or 1 if a step, the install or git failed.
  */
-async function commitChanges(root, base, done, failed, options, out) {
-    const summary = failed.length === 0 ? "Listo." : `Terminó, pero fallaron: ${failed.join("; ")}.`;
+async function commitChanges(root, base, done, failed, progress, options, out) {
+    const summary = ui.summary(failed);
     const changed = changedPaths(root);
     if (changed.length === 0) {
         out.stdout(`\n${summary} No cambió ningún archivo: no hay nada que commitear.\n`);
@@ -414,16 +420,9 @@ async function commitChanges(root, base, done, failed, options, out) {
     }
     const manager = packageManager(root);
     const packageChanged = changed.includes("package.json");
-    if (packageChanged) {
-        const label = `Instalar las dependencias con ${manager}`;
-        out.stdout(`→ ${label}\n`);
-        const installed = await runInstall(root, manager);
-        out.stdout(`${installed.ok ? "✓" : "✗"} ${label}\n`);
-        if (!installed.ok) {
-            out.stderr(failedOutput(installed.output));
-            out.stdout(`\n${summary} No commiteé: el install falló y los cambios quedan sin commit.\n`);
-            return 1;
-        }
+    if (packageChanged && !(await install(root, progress, out))) {
+        out.stdout(`\n${summary} No commiteé: el install falló y los cambios quedan sin commit.\n`);
+        return 1;
     }
     const paths = changedPaths(root);
     out.stdout(`\n${summary} Cambios:\n${paths.map((path) => `  ${path}`).join("\n")}\n`);

package/dist/commit-texts.d.ts

@@ -0,0 +1,18 @@
+import type { StepText } from "./texts/step-text.js";
+/** The subject of the commit and the title of the PR. */
+export declare const COMMIT_TITLE = "chore: agent-kitchen apply";
+/** The line of the decisions file. */
+export declare const DECISIONS_LINE = "Guardar qu\u00E9 piezas usa el repo en .agents/kitchen.json";
+/**
+ * A step's line in the commit and the PR.
+ * @param text - What the step does.
+ * @returns The line, without the dash.
+ * @example commitLine({ kind: "flow-install", version: "0.2.0" }) // "Instalar issue-flow 0.2.0: config del flujo, hooks y scripts"
+ */
+export declare function commitLine(text: StepText): string;
+/**
+ * The body of the PR.
+ * @param lines - What the commit lists.
+ * @returns The body.
+ */
+export declare function prBody(lines: string[]): string;

package/dist/commit-texts.js

@@ -0,0 +1,29 @@
+/**
+ * @file The texts of the commit and the PR of `apply --commit`. They are always in Spanish,
+ * whatever language the interface shows: a repo's history should not change language with the
+ * terminal of whoever ran the command. A step reads as its Spanish menu order.
+ */
+import { DECISIONS } from "./decisions.js";
+import { es } from "./texts/es.js";
+import { phrasesIn } from "./texts/index.js";
+/** The subject of the commit and the title of the PR. */
+export const COMMIT_TITLE = "chore: agent-kitchen apply";
+/** The line of the decisions file. */
+export const DECISIONS_LINE = `Guardar qué piezas usa el repo en ${DECISIONS}`;
+/**
+ * A step's line in the commit and the PR.
+ * @param text - What the step does.
+ * @returns The line, without the dash.
+ * @example commitLine({ kind: "flow-install", version: "0.2.0" }) // "Instalar issue-flow 0.2.0: config del flujo, hooks y scripts"
+ */
+export function commitLine(text) {
+    return phrasesIn(es, text).menu;
+}
+/**
+ * The body of the PR.
+ * @param lines - What the commit lists.
+ * @returns The body.
+ */
+export function prBody(lines) {
+    return `Cambios de \`agent-kitchen apply\`:\n\n${lines.map((line) => `- ${line}`).join("\n")}\n`;
+}

package/dist/git-finish.js

@@ -10,12 +10,11 @@ import { spawnSync } from "node:child_process";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, relative } from "node:path";
+import { COMMIT_TITLE as TITLE, prBody } from "./commit-texts.js";
 import { KitError } from "./output.js";
 import { FLOW_CONFIG } from "./piece.js";
 import { dependencyVersion, readJson } from "./repo.js";
 import { captureNpxWithout, isRelease, npmLatest } from "./tools.js";
-/** The subject of the commit and the title of the PR. */
-const TITLE = "chore: agent-kitchen apply";
 /** github-rest on npm, which opens the PR (REST, never gh's GraphQL). */
 const GITHUB_REST = "@ramon-sg/github-rest";
 /**
@@ -153,7 +152,7 @@ async function openPr(root, branch, base, steps) {
         return { error: `no sé qué versión de ${GITHUB_REST} usar.` };
     const dir = mkdtempSync(join(tmpdir(), "agent-kitchen-pr-"));
     const bodyFile = join(dir, "body.md");
-    writeFileSync(bodyFile, `Cambios de \`agent-kitchen apply\`:\n\n${steps.map((step) => `- ${step}`).join("\n")}\n`);
+    writeFileSync(bodyFile, prBody(steps));
     try {
         const result = await captureNpxWithout(root, [`${GITHUB_REST}@${version}`, "pr", "create", "--head", branch, "--base", base, "--title", TITLE, "--body-file", bodyFile], ["GH_REPO"]);
         const url = result.out.trim().split("\n").at(-1) ?? "";

package/dist/menu.js

@@ -6,6 +6,7 @@
  */
 import { styleText } from "node:util";
 import { confirm, groupMultiselect, isCancel, MULTISELECT_INSTRUCTIONS, multiselect, select, SELECT_INSTRUCTIONS } from "@clack/prompts";
+import { stepLabel } from "./texts/index.js";
 /** Width a skill's description is cut to in the menu. */
 const DESCRIPTION_WIDTH = 70;
 /**
@@ -24,7 +25,7 @@ function spanishKeys() {
  */
 export function menuOptions(steps) {
     return {
-        options: steps.map((step, index) => ({ value: index, label: step.label })),
+        options: steps.map((step, index) => ({ value: index, label: stepLabel(step) })),
         initialValues: steps.flatMap((step, index) => (step.checked ? [index] : [])),
     };
 }

package/dist/piece.d.ts

@@ -7,6 +7,7 @@
  * writes the few lines that join two pieces, the one line of AGENTS.md, which has no tool,
  * and the version of skills-manager in package.json, which agent-kitchen is the one to run.
  */
+import type { StepText } from "./texts/step-text.js";
 /** The issue flow on npm. */
 export declare const FLOW_PACKAGE = "@ramon-sg/issue-flow";
 /** The GitHub repo of the issue flow, which is also the catalog of its skills. */
@@ -36,10 +37,15 @@ export interface SkillPick {
     picked: string[];
     replace: string[];
 }
-/** One step a piece offers: what it does, what it downloads, and how it runs. */
+/**
+ * One step a piece offers: what it does (as data; texts/ turns it into words for each place
+ * it shows), what it downloads, and how it runs. `fresh` marks a step of a piece the repo has
+ * not decided on yet.
+ */
 export interface Step {
     piece: string;
-    label: string;
+    text: StepText;
+    fresh?: boolean;
     checked: boolean;
     downloads: string[];
     skills?: SkillPick;

package/dist/pieces/agents-md.js

@@ -100,10 +100,8 @@ export async function agentsMdStatus(root, flowComing) {
     const summary = "regla de versiones instaladas en AGENTS.md";
     if (!lack.rule && !lack.import)
         return { name: NAME, summary, installed: true, state: "al día", steps: [] };
-    const files = [...(lack.rule ? ["AGENTS.md"] : []), ...(lack.import ? ["CLAUDE.md"] : [])];
-    const label = lack.rule ? `Agregar a AGENTS.md la regla de versiones instaladas${lack.import ? " (y @AGENTS.md en CLAUDE.md)" : ""}` : "Agregar @AGENTS.md a CLAUDE.md, para que Claude Code lea AGENTS.md";
     const state = lack.rule ? "falta la regla" : "CLAUDE.md no importa AGENTS.md";
-    return { name: NAME, summary, installed: !lack.rule, state, steps: [{ piece: NAME, checked: true, downloads: [], label: `${label}: ${files.join(", ")}`, run: async (context) => write(context) }] };
+    return { name: NAME, summary, installed: !lack.rule, state, steps: [{ piece: NAME, checked: true, downloads: [], text: { kind: "agents-md", rule: lack.rule, claudeImport: lack.import }, run: async (context) => write(context) }] };
 }
 /**
  * Whether AGENTS.md has the rule and CLAUDE.md, if there is one, imports it. Only noted.

package/dist/pieces/cloud.js

@@ -28,7 +28,7 @@ function stepFor(config, latest) {
             piece: NAME,
             checked: true,
             downloads: [spec],
-            label: `Instalar claude-cloud ${latest ?? "1.x"}: prepara las sesiones en la nube de Claude`,
+            text: { kind: "cloud-install", version: latest },
             run: async (context) => {
                 const run = await runNpx(context.root, [spec, "init"]);
                 if (run.ok)
@@ -44,7 +44,7 @@ function stepFor(config, latest) {
         piece: NAME,
         checked: true,
         downloads: [],
-        label: `Actualizar claude-cloud ${version ?? "?"} → ${latest} (la versión que fija ${CONFIG})`,
+        text: { kind: "cloud-update", from: version, to: latest, config: CONFIG },
         run: async (context) => {
             const current = readJson(context.root, CONFIG) ?? {};
             const schema = typeof current.$schema === "string" ? current.$schema.replace(/@ramon-sg\/claude-cloud@[^/]+\//, `${PACKAGE}@${latest}/`) : undefined;

package/dist/pieces/guard.js

@@ -141,11 +141,11 @@ function installedVersion(root) {
  */
 function stepFor(root, installed, latest, flowComing) {
     if (installed === undefined)
-        return { piece: NAME, checked: true, downloads: [guardSpec(latest)], label: `Instalar claude-repo-guard ${latest ?? "(main)"}: modo auto con sandbox, y un documento de qué protege`, run: (context) => install(context, latest) };
+        return { piece: NAME, checked: true, downloads: [guardSpec(latest)], text: { kind: "guard-install", version: latest }, run: (context) => install(context, latest) };
     if (latest !== null && (installed === null || compareVersions(latest, installed) > 0))
-        return { piece: NAME, checked: true, downloads: [guardSpec(latest)], label: `Actualizar claude-repo-guard ${installed ?? "?"} → ${latest}`, run: (context) => install(context, latest) };
+        return { piece: NAME, checked: true, downloads: [guardSpec(latest)], text: { kind: "guard-update", from: installed, to: latest }, run: (context) => install(context, latest) };
     if (flowComing || guardOptions(root, process.platform).changes.length > 0)
-        return { piece: NAME, checked: true, downloads: [guardSpec(installed)], label: "Ajustar claude-repo-guard a lo que necesita el flujo de issues", run: (context) => addOptions(context, installed) };
+        return { piece: NAME, checked: true, downloads: [guardSpec(installed)], text: { kind: "guard-adjust" }, run: (context) => addOptions(context, installed) };
     return null;
 }
 /**

package/dist/pieces/issue-flow.js

@@ -197,7 +197,7 @@ async function missingLabels(root, version) {
  * @returns The step.
  */
 function labelsStep(version, missing) {
-    return { piece: NAME, checked: true, downloads: [`${FLOW_PACKAGE}@${version}`], label: `Crear en GitHub los labels que faltan: ${missing.join(", ")}`, run: async (context) => {
+    return { piece: NAME, checked: true, downloads: [`${FLOW_PACKAGE}@${version}`], text: { kind: "flow-labels", missing }, run: async (context) => {
             if (flowVersion(context.root) !== version) {
                 context.note(`no se crearon: el repo no tiene issue-flow ${version}`);
                 return true;
@@ -233,7 +233,7 @@ function restStep(root, version, minimum) {
     const current = dependencyVersion(readJson(root, "package.json"), GITHUB_REST);
     if (!below(current))
         return null;
-    return { piece: NAME, checked: true, downloads: [], label: `Subir github-rest ${current} → ${minimum}, el mínimo de issue-flow ${version}`, run: async (context) => {
+    return { piece: NAME, checked: true, downloads: [], text: { kind: "github-rest-bump", from: current, to: minimum, flow: version }, run: async (context) => {
             if (flowVersion(context.root) !== version)
                 context.note(`no se subió: el repo no tiene issue-flow ${version}`);
             else if (!below(dependencyVersion(readJson(context.root, "package.json"), GITHUB_REST)))
@@ -256,16 +256,16 @@ function restStep(root, version, minimum) {
 function stepFor(installed, latest, root, repair) {
     if (installed === null && latest !== null) {
         const run = usesApply(latest) ? async (context) => (await applyFlow(context, latest)) && (await moveSkills(context, latest)) : (context) => runFlow(context, latest, ["init", "--yes"]);
-        return { piece: NAME, checked: true, downloads: [`${FLOW_PACKAGE}@${latest}`], label: `Instalar issue-flow ${latest}: config del flujo, hooks y scripts`, run };
+        return { piece: NAME, checked: true, downloads: [`${FLOW_PACKAGE}@${latest}`], text: { kind: "flow-install", version: latest }, run };
     }
     if (installed !== null && latest !== null && compareVersions(latest, installed) > 0) {
         const update = (context) => (usesApply(latest) ? applyFlow(context, latest) : runFlow(context, latest, ["upgrade"]));
-        return { piece: NAME, checked: true, downloads: [`${FLOW_PACKAGE}@${latest}`], label: `Actualizar issue-flow ${installed} → ${latest}, con sus hooks y sus skills`, run: async (context) => (await update(context)) && (await moveSkills(context, latest)) };
+        return { piece: NAME, checked: true, downloads: [`${FLOW_PACKAGE}@${latest}`], text: { kind: "flow-update", from: installed, to: latest }, run: async (context) => (await update(context)) && (await moveSkills(context, latest)) };
     }
     if (installed !== null && repair)
-        return { piece: NAME, checked: true, downloads: [`${FLOW_PACKAGE}@${installed}`], label: `Reparar issue-flow ${installed}: hooks y $schema`, run: async (context) => (await applyFlow(context, installed)) && (skillsOff(context.root, installed).length === 0 || (await moveSkills(context, installed))) };
+        return { piece: NAME, checked: true, downloads: [`${FLOW_PACKAGE}@${installed}`], text: { kind: "flow-repair", version: installed }, run: async (context) => (await applyFlow(context, installed)) && (skillsOff(context.root, installed).length === 0 || (await moveSkills(context, installed))) };
     if (installed !== null && skillsOff(root, installed).length > 0)
-        return { piece: NAME, checked: true, downloads: [], label: `Poner las skills del flujo en v${installed}, la versión de issue-flow`, run: (context) => moveSkills(context, installed) };
+        return { piece: NAME, checked: true, downloads: [], text: { kind: "flow-skills", version: installed }, run: (context) => moveSkills(context, installed) };
     return null;
 }
 /**

package/dist/pieces/skills-manager.js

@@ -66,7 +66,7 @@ export function skillsManagerStatus(root, withSkills, flowComing) {
             piece: NAME,
             checked: true,
             downloads: [`${SKILLS_MANAGER}@${MIN_VERSION}`],
-            label: `Crear package.json con skills-manager ${MIN_VERSION}`,
+            text: { kind: "skills-manager-create", version: MIN_VERSION },
             run: async (context) => {
                 if (readJson(context.root, "package.json") === null)
                     writeJson(context.root, "package.json", { private: true, devDependencies: { [SKILLS_MANAGER]: MIN_VERSION } });
@@ -85,13 +85,13 @@ export function skillsManagerStatus(root, withSkills, flowComing) {
     }
     if (now.kind === "exact" && !below(now.version))
         return { name: NAME, summary, installed: true, state: `${now.version}, al día`, steps: [] };
-    const label = now.kind === "missing" ? `Agregar skills-manager ${MIN_VERSION} a package.json` : `Subir skills-manager ${now.version} → ${MIN_VERSION}, el mínimo de agent-kitchen`;
+    const text = now.kind === "missing" ? { kind: "skills-manager-add", version: MIN_VERSION } : { kind: "skills-manager-bump", from: now.version, to: MIN_VERSION };
     const state = now.kind === "missing" ? "no está en package.json" : `${now.version}, bajo ${MIN_VERSION}`;
     const step = {
         piece: NAME,
         checked: true,
         downloads: [`${SKILLS_MANAGER}@${MIN_VERSION}`],
-        label,
+        text,
         run: async (context) => {
             const current = pinned(context.root);
             if (current.kind === "missing" || (current.kind === "exact" && below(current.version))) {

package/dist/pieces/skills.js

@@ -174,7 +174,7 @@ async function updateStep(root, catalog, ref) {
         piece: NAME,
         checked: true,
         downloads: [skillsManagerSpec(root)],
-        label: `Actualizar skills de ${catalog} ${from} → v${latest}: ${behind.map((skill) => skill.name).join(", ")}`,
+        text: { kind: "skills-update", catalog, from, to: latest, names: behind.map((skill) => skill.name) },
         run: async (context) => {
             if (ref !== null)
                 pinCatalog(context.root, catalog, `v${latest}`);
@@ -215,10 +215,9 @@ export async function skillsStatus(root, withFlow) {
         });
         const offered = candidates ?? fallback;
         const catalogs = [...new Set(offered.map((candidate) => candidate.catalog))];
-        const label = `Instalar ${offered.length} skills de ${catalogs.join(" y ")}`;
         const skills = { candidates: offered, picked: offered.map((candidate) => candidate.id), replace: [] };
         const state = candidates === null ? "no instaladas (no se pudieron leer los catálogos)" : "no instaladas";
-        return { name: NAME, summary, installed: false, state, steps: [{ piece: NAME, checked: true, downloads: [], label, skills, run: (context) => install(context, skills) }] };
+        return { name: NAME, summary, installed: false, state, steps: [{ piece: NAME, checked: true, downloads: [], text: { kind: "skills-install", count: offered.length, catalogs }, skills, run: (context) => install(context, skills) }] };
     }
     const general = manifestCatalogs(root).filter((source) => source.catalog !== FLOW_CATALOG);
     const steps = (await Promise.all(general.map((source) => updateStep(root, source.catalog, source.ref)))).flatMap((step) => step ?? []);
@@ -227,7 +226,7 @@ export async function skillsStatus(root, withFlow) {
     const fresh = (candidates ?? []).filter((candidate) => locked[candidate.name] === undefined);
     if (fresh.length > 0) {
         const skills = { candidates: fresh, picked: [], replace: [] };
-        steps.push({ piece: NAME, checked: false, downloads: [skillsManagerSpec(root)], label: `Agregar skills nuevas (${fresh.length}): ${fresh.map((candidate) => candidate.name).join(", ")}`, skills, run: (context) => install(context, skills) });
+        steps.push({ piece: NAME, checked: false, downloads: [skillsManagerSpec(root)], text: { kind: "skills-add", names: fresh.map((candidate) => candidate.name) }, skills, run: (context) => install(context, skills) });
     }
     const count = manifestCatalogs(root).reduce((total, source) => total + catalogSkills(root, source.catalog).length, 0);
     const behind = steps.filter((step) => step.checked).length;

package/dist/progress.d.ts

@@ -0,0 +1,30 @@
+import type { Output } from "./output.js";
+import type { StepText } from "./texts/step-text.js";
+/** How a step's progress is shown. */
+export interface Progress {
+    start: (text: StepText) => void;
+    stop: (text: StepText, ok: boolean) => void;
+}
+/**
+ * Progress as plain lines: the start (marked ◒, like the spinner), a line now and then while it
+ * runs, and the end (marked ✓ or ✗).
+ * @param out - Where to write.
+ * @param options - Whether to print while it runs, how often, and the clock.
+ * @returns The progress.
+ * @example plainProgress(out, { ticks: true }).start({ kind: "guard-adjust" })
+ */
+export declare function plainProgress(out: Output, options: {
+    ticks: boolean;
+    tickMs?: number;
+    now?: () => number;
+}): Progress;
+/**
+ * How progress is shown: a spinner in a terminal, plain lines otherwise or when `plain` asks
+ * for them. Only for the steps, after every question: a spinner shown before a question
+ * leaves the second question deaf to the keyboard (@clack/prompts 1.8.1).
+ * @param out - Where to write.
+ * @param verbose - Whether the tools print on the terminal.
+ * @param plain - Whether a question may come after the steps (`--commit`).
+ * @returns The progress.
+ */
+export declare function progressFor(out: Output, verbose: boolean, plain: boolean): Progress;

package/dist/progress.js

@@ -0,0 +1,76 @@
+/**
+ * @file How a step's progress is shown. Its start says what is happening ("Actualizando…") and
+ * its end what is left, with how long it took. In a terminal, a spinner; otherwise plain
+ * lines, and a step that takes a while prints how long it has been running, so it does not
+ * look stuck (unless the tools print their own output, with `--verbose`).
+ */
+import { spinner } from "@clack/prompts";
+import { phrases, ui } from "./texts/index.js";
+/** How often a plain step says it is still running. */
+const TICK_MS = 10_000;
+/**
+ * The end line of a step.
+ * @param text - What the step does.
+ * @param ok - Whether it worked.
+ * @param ms - How long it took.
+ * @returns The line, without the mark.
+ */
+function endLine(text, ok, ms) {
+    const said = phrases(text);
+    return `${ok ? said.done : ui.failed(said.menu)} (${ui.duration(ms)})`;
+}
+/**
+ * Progress as plain lines: the start (marked ◒, like the spinner), a line now and then while it
+ * runs, and the end (marked ✓ or ✗).
+ * @param out - Where to write.
+ * @param options - Whether to print while it runs, how often, and the clock.
+ * @returns The progress.
+ * @example plainProgress(out, { ticks: true }).start({ kind: "guard-adjust" })
+ */
+export function plainProgress(out, options) {
+    const now = options.now ?? Date.now;
+    let started = 0;
+    let timer;
+    return {
+        start: (text) => {
+            started = now();
+            out.stdout(`◒ ${phrases(text).doing}\n`);
+            if (options.ticks)
+                timer = setInterval(() => out.stdout(`${ui.still(ui.duration(now() - started))}\n`), options.tickMs ?? TICK_MS);
+        },
+        stop: (text, ok) => {
+            clearInterval(timer);
+            timer = undefined;
+            out.stdout(`${ok ? "✓" : "✗"} ${endLine(text, ok, now() - started)}\n`);
+        },
+    };
+}
+/**
+ * How progress is shown: a spinner in a terminal, plain lines otherwise or when `plain` asks
+ * for them. Only for the steps, after every question: a spinner shown before a question
+ * leaves the second question deaf to the keyboard (@clack/prompts 1.8.1).
+ * @param out - Where to write.
+ * @param verbose - Whether the tools print on the terminal.
+ * @param plain - Whether a question may come after the steps (`--commit`).
+ * @returns The progress.
+ */
+export function progressFor(out, verbose, plain) {
+    if (out.interactive && !verbose && !plain) {
+        const spin = spinner();
+        let started = 0;
+        return {
+            start: (text) => {
+                started = Date.now();
+                spin.start(phrases(text).doing);
+            },
+            stop: (text, ok) => {
+                const line = endLine(text, ok, Date.now() - started);
+                if (ok)
+                    spin.stop(line);
+                else
+                    spin.error(line);
+            },
+        };
+    }
+    return plainProgress(out, { ticks: !verbose });
+}

package/dist/repo.d.ts

@@ -46,6 +46,13 @@ export declare function dependencyVersion(pkg: Record<string, unknown> | null, n
  * @example packageManager(root) // "pnpm"
  */
 export declare function packageManager(root: string): string;
+/**
+ * The text of the repo's package.json, to tell later whether a run changed it.
+ * @param root - The repo.
+ * @returns Its text, or null if there is none.
+ * @example packageText(root) // '{ "devDependencies": … }'
+ */
+export declare function packageText(root: string): string | null;
 /**
  * The version of a package installed in the repo's `node_modules`.
  * @param root - The repo.

package/dist/repo.js

@@ -115,6 +115,16 @@ export function packageManager(root) {
         return field;
     return LOCKFILES.find(([file]) => existsSync(join(root, file)))?.[1] ?? "npm";
 }
+/**
+ * The text of the repo's package.json, to tell later whether a run changed it.
+ * @param root - The repo.
+ * @returns Its text, or null if there is none.
+ * @example packageText(root) // '{ "devDependencies": … }'
+ */
+export function packageText(root) {
+    const file = join(root, "package.json");
+    return existsSync(file) ? readFileSync(file, "utf8") : null;
+}
 /**
  * The version of a package installed in the repo's `node_modules`.
  * @param root - The repo.

package/dist/texts/catalog.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @file The shape of a catalog of the texts the person sees while `apply` runs its steps.
+ * Every language implements `Catalog`; the compiler then asks for every kind of step and every
+ * message. The interface uses `ui`; the commit and the PR do not (see commit-texts.ts).
+ */
+import type { StepKind, StepOf } from "./step-text.js";
+/** One step's texts, one per place it shows. */
+export interface StepPhrases {
+    /** In the menu and the lists of steps, as an order: "Actualizar issue-flow 0.2.7 → 0.3.0". */
+    menu: string;
+    /** While it runs: "Actualizando issue-flow de 0.2.7 a 0.3.0…". */
+    doing: string;
+    /** When it worked, saying what is left: "issue-flow actualizado de 0.2.7 a 0.3.0". */
+    done: string;
+}
+/** Every text of `apply` around its steps. */
+export interface Catalog {
+    /** Each kind of step's texts. */
+    steps: {
+        [K in StepKind]: (step: StepOf<K>) => StepPhrases;
+    };
+    /** Added to a step of a piece the repo has not decided on yet. */
+    fresh: string;
+    /** The end line of a step that failed, from its menu text. */
+    failed: (menu: string) => string;
+    /** A duration, short: "0,4 s", "12 s", "1 min 5 s". */
+    duration: (ms: number) => string;
+    /** The line a long step prints while it runs, so it does not look stuck. */
+    still: (elapsed: string) => string;
+    /** The line before looking at the pieces. */
+    checking: string;
+    /** Nothing to install or update. */
+    upToDate: string;
+    /** With --yes and nothing suggested: the optional steps. */
+    onlyOptional: (menus: string[]) => string;
+    /** The heading of the steps listed without running them. */
+    suggested: (dryRun: boolean) => string;
+    /** The last line when every step worked or some failed. */
+    summary: (failed: string[]) => string;
+    /** What is left to do by hand after the steps, without --commit; with the manager if its install failed. */
+    next: (failedInstall: string | null) => string;
+    /** A new piece left out because no one was asked about it. */
+    undecided: (names: string[]) => string;
+    /** The repo's own skills left out of a pick. */
+    ownSkillsKept: (names: string[]) => string;
+    /** The decisions were saved. */
+    saved: (file: string, commits: boolean) => string;
+    /** The closing line when no step ran: the person left, or picked none. */
+    noSteps: (why: "leave" | "none", wrote: boolean) => string;
+}

package/dist/texts/catalog.js

@@ -0,0 +1 @@
+export {};

package/dist/texts/es.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file The texts in Spanish. The menu orders ("Actualizar"), progress says what is happening
+ * ("Actualizando") and the end line says what is left ("actualizado").
+ */
+import type { Catalog } from "./catalog.js";
+/** The texts in Spanish. */
+export declare const es: Catalog;

package/dist/texts/es.js

@@ -0,0 +1,139 @@
+/**
+ * A list of names, joined with commas.
+ * @param names - The names.
+ * @returns The list.
+ */
+const list = (names) => names.join(", ");
+/** The texts in Spanish. */
+export const es = {
+    steps: {
+        "skills-manager-create": ({ version }) => ({
+            menu: `Crear package.json con skills-manager ${version}`,
+            doing: `Creando package.json con skills-manager ${version}…`,
+            done: `package.json creado con skills-manager ${version}`,
+        }),
+        "skills-manager-add": ({ version }) => ({
+            menu: `Agregar skills-manager ${version} a package.json`,
+            doing: `Agregando skills-manager ${version} a package.json…`,
+            done: `skills-manager ${version} agregado a package.json`,
+        }),
+        "skills-manager-bump": ({ from, to }) => ({
+            menu: `Subir skills-manager ${from} → ${to}, el mínimo de agent-kitchen`,
+            doing: `Subiendo skills-manager de ${from} a ${to}…`,
+            done: `skills-manager subido de ${from} a ${to}`,
+        }),
+        "flow-install": ({ version }) => ({
+            menu: `Instalar issue-flow ${version}: config del flujo, hooks y scripts`,
+            doing: `Instalando issue-flow ${version}…`,
+            done: `issue-flow ${version} instalado: config del flujo, hooks y scripts`,
+        }),
+        "flow-update": ({ from, to }) => ({
+            menu: `Actualizar issue-flow ${from} → ${to}, con sus hooks y sus skills`,
+            doing: `Actualizando issue-flow de ${from} a ${to}…`,
+            done: `issue-flow actualizado de ${from} a ${to}, con sus hooks y sus skills`,
+        }),
+        "flow-repair": ({ version }) => ({
+            menu: `Reparar issue-flow ${version}: hooks y $schema`,
+            doing: `Reparando issue-flow ${version}…`,
+            done: `issue-flow ${version} reparado: hooks y $schema`,
+        }),
+        "flow-skills": ({ version }) => ({
+            menu: `Poner las skills del flujo en v${version}, la versión de issue-flow`,
+            doing: `Poniendo las skills del flujo en v${version}…`,
+            done: `Skills del flujo en v${version}, la versión de issue-flow`,
+        }),
+        "flow-labels": ({ missing }) => ({
+            menu: `Crear en GitHub los labels que faltan: ${list(missing)}`,
+            doing: `Creando en GitHub los labels que faltan: ${list(missing)}…`,
+            done: `Labels creados en GitHub: ${list(missing)}`,
+        }),
+        "github-rest-bump": ({ from, to, flow }) => ({
+            menu: `Subir github-rest ${from} → ${to}, el mínimo de issue-flow ${flow}`,
+            doing: `Subiendo github-rest de ${from} a ${to}…`,
+            done: `github-rest subido de ${from} a ${to}, el mínimo de issue-flow ${flow}`,
+        }),
+        "cloud-install": ({ version }) => ({
+            menu: `Instalar claude-cloud ${version ?? "1.x"}: prepara las sesiones en la nube de Claude`,
+            doing: `Instalando claude-cloud ${version ?? "1.x"}…`,
+            done: `claude-cloud ${version ?? "1.x"} instalado: prepara las sesiones en la nube de Claude`,
+        }),
+        "cloud-update": ({ from, to, config }) => ({
+            menu: `Actualizar claude-cloud ${from ?? "?"} → ${to} (la versión que fija ${config})`,
+            doing: `Actualizando claude-cloud de ${from ?? "?"} a ${to}…`,
+            done: `claude-cloud actualizado de ${from ?? "?"} a ${to} en ${config}`,
+        }),
+        "guard-install": ({ version }) => ({
+            menu: `Instalar claude-repo-guard ${version ?? "(main)"}: modo auto con sandbox, y un documento de qué protege`,
+            doing: `Instalando claude-repo-guard ${version ?? "(main)"}…`,
+            done: `claude-repo-guard ${version ?? "(main)"} instalado: modo auto con sandbox, y un documento de qué protege`,
+        }),
+        "guard-update": ({ from, to }) => ({
+            menu: `Actualizar claude-repo-guard ${from ?? "?"} → ${to}`,
+            doing: `Actualizando claude-repo-guard de ${from ?? "?"} a ${to}…`,
+            done: `claude-repo-guard actualizado de ${from ?? "?"} a ${to}`,
+        }),
+        "guard-adjust": () => ({
+            menu: "Ajustar claude-repo-guard a lo que necesita el flujo de issues",
+            doing: "Ajustando claude-repo-guard al flujo de issues…",
+            done: "claude-repo-guard ajustado a lo que necesita el flujo de issues",
+        }),
+        "skills-install": ({ count, catalogs }) => ({
+            menu: `Instalar ${count} skills de ${catalogs.join(" y ")}`,
+            doing: `Instalando ${count} skills de ${catalogs.join(" y ")}…`,
+            done: `${count} skills instaladas de ${catalogs.join(" y ")}`,
+        }),
+        "skills-update": ({ catalog, from, to, names }) => ({
+            menu: `Actualizar skills de ${catalog} ${from} → v${to}: ${list(names)}`,
+            doing: `Actualizando skills de ${catalog} de ${from} a v${to}…`,
+            done: `Skills de ${catalog} actualizadas a v${to}: ${list(names)}`,
+        }),
+        "skills-add": ({ names }) => ({
+            menu: `Agregar skills nuevas (${names.length}): ${list(names)}`,
+            doing: `Agregando skills nuevas: ${list(names)}…`,
+            done: `Skills nuevas agregadas: ${list(names)}`,
+        }),
+        "agents-md": ({ rule, claudeImport }) => {
+            const files = [...(rule ? ["AGENTS.md"] : []), ...(claudeImport ? ["CLAUDE.md"] : [])].join(", ");
+            if (!rule)
+                return {
+                    menu: `Agregar @AGENTS.md a CLAUDE.md, para que Claude Code lea AGENTS.md: ${files}`,
+                    doing: "Agregando @AGENTS.md a CLAUDE.md…",
+                    done: "@AGENTS.md agregado a CLAUDE.md: Claude Code lee AGENTS.md",
+                };
+            const also = claudeImport ? " (y @AGENTS.md en CLAUDE.md)" : "";
+            return {
+                menu: `Agregar a AGENTS.md la regla de versiones instaladas${also}: ${files}`,
+                doing: `Agregando a AGENTS.md la regla de versiones instaladas${also}…`,
+                done: `Regla de versiones instaladas agregada a AGENTS.md${also}`,
+            };
+        },
+        "install-deps": ({ manager }) => ({
+            menu: `Instalar las dependencias con ${manager}`,
+            doing: `Instalando las dependencias con ${manager}…`,
+            done: `Dependencias instaladas con ${manager}`,
+        }),
+    },
+    fresh: " (nueva)",
+    failed: (menu) => `Falló: ${menu}`,
+    duration: (ms) => {
+        if (ms < 10_000)
+            return `${(ms / 1000).toFixed(1).replace(".", ",")} s`;
+        const seconds = Math.round(ms / 1000);
+        return seconds < 60 ? `${seconds} s` : `${Math.floor(seconds / 60)} min${seconds % 60 === 0 ? "" : ` ${seconds % 60} s`}`;
+    },
+    still: (elapsed) => `  … sigue (${elapsed})`,
+    checking: "Revisando el repo y las últimas versiones…",
+    upToDate: "Todo al día: no hay nada que instalar ni actualizar.",
+    onlyOptional: (menus) => `Todo al día. Opcional, para elegir en una terminal: ${menus.join("; ")}.`,
+    suggested: (dryRun) => `Pasos sugeridos${dryRun ? "" : " (para hacerlos, corre agent-kitchen apply en una terminal, o con --yes)"}:`,
+    summary: (failed) => (failed.length === 0 ? "Listo." : `Terminó, pero fallaron: ${failed.join("; ")}.`),
+    next: (failedInstall) => `Falta: ${failedInstall === null ? "" : `corre '${failedInstall} install', `}revisa el diff y haz commit.`,
+    undecided: (names) => `Pieza nueva sin decisión: ${list(names)}. Corre agent-kitchen apply en una terminal para elegir.`,
+    ownSkillsKept: (names) => `Se dejan fuera las skills que el repo ya tiene como propias: ${list(names)}. Para reemplazarlas, corre agent-kitchen apply en una terminal.`,
+    saved: (file, commits) => `Guardé qué piezas usa el repo en ${file}${commits ? "" : "; commitéalo"}.`,
+    noSteps: (why, wrote) => {
+        if (why === "leave")
+            return wrote ? "No corrí ningún paso; solo guardé qué piezas usa el repo." : "No se cambió nada.";
+        return wrote ? "No elegiste pasos; solo guardé qué piezas usa el repo." : "No elegiste nada; no se cambió nada.";
+    },
+};

package/dist/texts/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file The interface's texts, and how a step reads in a list. Another language is a file
+ * like es.ts that implements `Catalog`, chosen here.
+ */
+import type { Step } from "../piece.js";
+import type { Catalog, StepPhrases } from "./catalog.js";
+import type { StepText } from "./step-text.js";
+/** The catalog the interface uses. */
+export declare const ui: Catalog;
+/**
+ * A step's texts in a catalog.
+ * @param catalog - The catalog.
+ * @param text - What the step does.
+ * @returns Its texts.
+ * @example phrasesIn(es, { kind: "guard-adjust" }).doing // "Ajustando claude-repo-guard al flujo de issues…"
+ */
+export declare function phrasesIn(catalog: Catalog, text: StepText): StepPhrases;
+/**
+ * A step's texts in the interface.
+ * @param text - What the step does.
+ * @returns Its texts.
+ */
+export declare function phrases(text: StepText): StepPhrases;
+/**
+ * How a step reads in the menu and in lists: its order, marked if its piece is new.
+ * @param step - The step.
+ * @returns The text.
+ * @example stepLabel(step) // "Actualizar issue-flow 0.2.7 → 0.3.0, con sus hooks y sus skills"
+ */
+export declare function stepLabel(step: Pick<Step, "text" | "fresh">): string;

package/dist/texts/index.js

@@ -0,0 +1,31 @@
+import { es } from "./es.js";
+/** The catalog the interface uses. */
+export const ui = es;
+/**
+ * A step's texts in a catalog.
+ * @param catalog - The catalog.
+ * @param text - What the step does.
+ * @returns Its texts.
+ * @example phrasesIn(es, { kind: "guard-adjust" }).doing // "Ajustando claude-repo-guard al flujo de issues…"
+ */
+export function phrasesIn(catalog, text) {
+    const render = catalog.steps[text.kind];
+    return render(text);
+}
+/**
+ * A step's texts in the interface.
+ * @param text - What the step does.
+ * @returns Its texts.
+ */
+export function phrases(text) {
+    return phrasesIn(ui, text);
+}
+/**
+ * How a step reads in the menu and in lists: its order, marked if its piece is new.
+ * @param step - The step.
+ * @returns The text.
+ * @example stepLabel(step) // "Actualizar issue-flow 0.2.7 → 0.3.0, con sus hooks y sus skills"
+ */
+export function stepLabel(step) {
+    return `${phrases(step.text).menu}${step.fresh === true ? ui.fresh : ""}`;
+}

package/dist/texts/step-text.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @file What a step does, as data: its kind, the piece's versions and what it brings. No
+ * words here; each place that shows a step (the menu, the start and end of its progress, the
+ * commit) turns this into its own text, so the interface can change language without the
+ * commits changing too.
+ */
+/** A version that may be unknown (`null`), shown as `?` or as the place it comes from. */
+type MaybeVersion = string | null;
+/** What a step does, one kind per thing a piece can offer. */
+export type StepText = {
+    kind: "skills-manager-create";
+    version: string;
+} | {
+    kind: "skills-manager-add";
+    version: string;
+} | {
+    kind: "skills-manager-bump";
+    from: string;
+    to: string;
+} | {
+    kind: "flow-install";
+    version: string;
+} | {
+    kind: "flow-update";
+    from: string;
+    to: string;
+} | {
+    kind: "flow-repair";
+    version: string;
+} | {
+    kind: "flow-skills";
+    version: string;
+} | {
+    kind: "flow-labels";
+    missing: string[];
+} | {
+    kind: "github-rest-bump";
+    from: string;
+    to: string;
+    flow: string;
+} | {
+    kind: "cloud-install";
+    version: MaybeVersion;
+} | {
+    kind: "cloud-update";
+    from: MaybeVersion;
+    to: string;
+    config: string;
+} | {
+    kind: "guard-install";
+    version: MaybeVersion;
+} | {
+    kind: "guard-update";
+    from: MaybeVersion;
+    to: string;
+} | {
+    kind: "guard-adjust";
+} | {
+    kind: "skills-install";
+    count: number;
+    catalogs: string[];
+} | {
+    kind: "skills-update";
+    catalog: string;
+    from: string;
+    to: string;
+    names: string[];
+} | {
+    kind: "skills-add";
+    names: string[];
+} | {
+    kind: "agents-md";
+    rule: boolean;
+    claudeImport: boolean;
+} | {
+    kind: "install-deps";
+    manager: string;
+};
+/** The kinds of step. */
+export type StepKind = StepText["kind"];
+/** The data of one kind of step. */
+export type StepOf<K extends StepKind> = Extract<StepText, {
+    kind: K;
+}>;
+export {};

package/dist/texts/step-text.js

@@ -0,0 +1,7 @@
+/**
+ * @file What a step does, as data: its kind, the piece's versions and what it brings. No
+ * words here; each place that shows a step (the menu, the start and end of its progress, the
+ * commit) turns this into its own text, so the interface can change language without the
+ * commits changing too.
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-kitchen",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "One command to install, update and check a repo's agent tooling: the issue flow and its skills, the general skills, Claude cloud sessions, claude-repo-guard and the installed-versions rule in AGENTS.md.",
   "license": "MIT",
   "type": "module",