agent-cloud-kit 1.0.0-rc.7 → 1.0.0-rc.8

package/README.md

@@ -161,6 +161,20 @@ A Node version that is not exact (`22`, `22.1`, `lts/iron`, `lts/*` or `node`) i
 Environment variables: `AGENT_CLOUD_KIT_DIR` overrides `/opt/agent-cloud-kit` and `AGENT_CLOUD_KIT_HOME`
 overrides `/home/user`; both exist mainly for tests.
 
+### Language and Kuro
+
+The terminal speaks Spanish by default. `--lang en` (with any command) switches it to English for
+one run, and `AGENT_CLOUD_KIT_LANG=en|es` fixes it; `--lang` wins over the variable. `LANG` and
+`LC_ALL` are not read. Only the terminal changes: what is written in the repo (`docs/agent-cloud.md`,
+`.claude/cloud-notes.md`, the `cloud-ready` skill, the commit) and the prompts for Claude stay in
+Spanish. `setup` passes the language on to the version it relaunches, and `session` to the one it
+delegates to.
+
+In a terminal, the final messages (the end of `doctor`, `prepare` and `verify`, and the screen
+before Claude opens) come in a block with Kuro, the mascot of issue-flow and agent-kitchen.
+`NO_COLOR` removes the color and keeps Kuro. Outside a terminal (logs, pipes, the `SessionStart`
+hook) the lines keep the plain `agent-cloud-kit: ` prefix.
+
 ### The `SessionStart` hook
 
 `init` adds this hook. Outside a cloud session it does nothing, and it calls the copy of the

package/dist/block.js

@@ -0,0 +1,76 @@
+/**
+ * @file The block of the final messages, like issue-flow's: a title with a status mark, a few
+ * aligned rows and free lines, with Kuro (the mascot) beside it. It is drawn only in a terminal;
+ * logs, pipes and Claude's context keep the plain `agent-cloud-kit: ` lines.
+ */
+/** Kuro, the drawing of issue-flow, without trailing spaces. */
+export const KURO = ["    ▄█████▄", " ≋≋██▀▀▀▀▀██", "    █ ▄  ▄ █   ╱", "    ▀█▄▄▄▄█▀  ╱"];
+/** Column where the text begins, after Kuro. */
+const TEXT_COLUMN = 26;
+/** Indent of the text without Kuro. */
+const INDENT = 2;
+/** ASCII mark of each mood. */
+const MARKS = { ok: "[ok]", error: "[!]", question: "[?]", next: "[>]" };
+/** SGR color of each mood. */
+const MOOD_COLOR = { ok: "32", error: "31", question: "33", next: "36" };
+/**
+ * Wraps a text in an SGR code when color is on.
+ *
+ * @param on - Whether color is on.
+ * @param code - SGR code.
+ * @param text - Text.
+ * @returns The text, colored or not.
+ * @example
+ * paint(false, "1", "x"); // "x"
+ */
+function paint(on, code, text) {
+    return on ? `\x1b[${code}m${text}\x1b[0m` : text;
+}
+/**
+ * Visible width of a text: characters, without ANSI codes.
+ *
+ * @param text - Text.
+ * @returns The width.
+ * @example
+ * width("\x1b[1mab\x1b[0m"); // 2
+ */
+function width(text) {
+    return [...text.replace(/\x1b\[[0-9;]*m/g, "")].length;
+}
+/**
+ * Renders a block. Values are never cut or wrapped: a command to copy must stay whole.
+ *
+ * @param block - What to say.
+ * @param opts - Whether to draw Kuro and whether to color.
+ * @returns The lines, with a blank line before and after.
+ * @example
+ * renderBlock({ mood: "ok", title: "Listo" }, { art: false, color: false }); // ["", "  [ok] Listo", ""]
+ */
+export function renderBlock(block, opts) {
+    const code = MOOD_COLOR[block.mood];
+    const text = [`${paint(opts.color, code, MARKS[block.mood])} ${paint(opts.color, `1;${code}`, block.title)}`];
+    if (block.rows?.length) {
+        const column = Math.max(...block.rows.map(([label]) => width(label))) + 2;
+        text.push("");
+        for (const [label, value] of block.rows)
+            text.push(`${paint(opts.color, "2", label)}${" ".repeat(column - width(label))}${value}`);
+    }
+    if (block.lines?.length)
+        text.push("", ...block.lines);
+    const out = [];
+    if (opts.art) {
+        // NOTE: Kuro takes rows 0-3 and the text starts on row 1, next to the head.
+        const total = Math.max(KURO.length, text.length + 1);
+        for (let row = 0; row < total; row++) {
+            const left = KURO[row] ?? "";
+            const drawn = left ? paint(opts.color, "35", left) : "";
+            const right = text[row - 1];
+            out.push(right === undefined || right === "" ? drawn : `${drawn}${" ".repeat(TEXT_COLUMN - width(left))}${right}`);
+        }
+    }
+    else {
+        for (const line of text)
+            out.push(line === "" ? "" : `${" ".repeat(INDENT)}${line}`);
+    }
+    return ["", ...out.map((line) => line.trimEnd()), ""];
+}

package/dist/cli.js

@@ -2,46 +2,28 @@
 /**
  * @file Command line entry point of agent-cloud-kit: wires `setup`, `session`, `docker`, `doctor`,
  * `init`, `manual`, `prepare` and `verify` to their modules, relaunching or delegating to the version each
- * repo pins.
+ * repo pins. It picks the language of the terminal once (`--lang`, then `AGENT_CLOUD_KIT_LANG`).
  */
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { pathToFileURL } from "node:url";
+import { renderBlock } from "./block.js";
 import { readConfig } from "./config.js";
 import { CONFIG_FILE, DOCKERD_LOG, OUTPUT_PREFIX, RUNNING_PACKAGE_ROOT, homeDir, toolsDir } from "./constants.js";
-import { doctor } from "./doctor.js";
+import { doctor, doctorBlock } from "./doctor.js";
 import { dockerResponds, realDocker } from "./docker.js";
 import { init } from "./init.js";
+import { LANG_ENV, LangError, resolveLang, splitLang } from "./lang.js";
 import { findRepos, packageBin, planSetup, relaunch } from "./launcher.js";
 import { MANUAL_FILE, writeManual } from "./manual.js";
+import { stepLabel, t, useLang } from "./messages/index.js";
 import { EXIT_INTERRUPTED, InterruptedError, branchDay, prepare, verifyBranch } from "./prepare/index.js";
 import { captureProcess, runProcess } from "./run.js";
 import { chooseTerminal } from "./select.js";
 import { session } from "./session.js";
 import { setupRepo } from "./setup.js";
-/** Help text shown by `--help`. */
-const HELP = `${OUTPUT_PREFIX}prepara repos para las sesiones cloud de Claude Code.
-
-Uso: agent-cloud-kit <comando>
-
-Comandos:
-  setup [--repo <path>]  prepara la máquina para cada repo del directorio home (o solo <path>)
-  session                informa el estado de la máquina y conecta las herramientas a la sesión
-  docker                 inicia el demonio de Docker y espera a que responda
-  doctor                 revisa los dominios permitidos, las herramientas, Docker y el estado de la máquina
-  init                   crea .claude/cloud.json y registra el hook SessionStart
-  manual                 escribe docs/agent-cloud.md a partir de .claude/cloud.json
-  prepare [--pr|--here|--resume]
-                         corre en local: deja el repo listo para la nube, en un PR nuevo (--pr) o en la
-                         rama actual sin commit (--here); sin opción, pregunta dónde
-  verify                 corre en local: lanza una sesión cloud que verifica la rama actual (ya subida)
-
-Opciones:
-  --help                 muestra esta ayuda
-  --version              muestra la versión del paquete
-`;
 /** Environment variable with the project dir that Claude Code passes to hooks. */
 const PROJECT_DIR_VAR = "CLAUDE_PROJECT_DIR";
 /** Environment marker set on a delegated `session`, so it never delegates again. */
@@ -93,7 +75,7 @@ async function runOne(repo, deps) {
     for (const error of errors)
         deps.print(`${OUTPUT_PREFIX}${repo}: ${error}`);
     if (config && config.version !== deps.packageVersion) {
-        deps.print(`${OUTPUT_PREFIX}corriendo la versión ${deps.packageVersion}, aunque ${CONFIG_FILE} pide la ${config.version}`);
+        deps.print(OUTPUT_PREFIX + t().cli.versionMismatch(deps.packageVersion, CONFIG_FILE, config.version));
     }
     const state = await setupRepo(repo, {
         toolsDir: toolsDir(deps.env),
@@ -103,9 +85,8 @@ async function runOne(repo, deps) {
         docker: deps.docker,
         packageRoot: deps.packageRoot,
     });
-    const failed = state.steps.filter((s) => !s.ok).map((s) => s.name);
-    const detail = failed.length ? ` (${failed.join(", ")})` : "";
-    deps.print(`${OUTPUT_PREFIX}setup ${repo}: ${state.steps.length} pasos, ${failed.length} fallaron${detail}`);
+    const failed = state.steps.filter((s) => !s.ok).map((s) => stepLabel(s.name));
+    deps.print(OUTPUT_PREFIX + t().cli.setupSummary(repo, state.steps.length, failed.length, failed));
 }
 /**
  * Carries out one item of the setup plan; may throw, the caller reports it and moves on.
@@ -115,19 +96,19 @@ async function runOne(repo, deps) {
  */
 async function runPlanItem(item, deps) {
     if (item.action === "skip") {
-        deps.print(`${OUTPUT_PREFIX}se omite ${item.repo}: ${item.reason ?? ""}`);
+        deps.print(OUTPUT_PREFIX + t().cli.skip(item.repo, item.reason ?? ""));
         return;
     }
     if (item.action === "run" || !item.version) {
         await runOne(item.repo, deps);
         return;
     }
-    deps.print(`${OUTPUT_PREFIX}relanzando con la versión ${item.version} para ${item.repo}`);
+    deps.print(OUTPUT_PREFIX + t().cli.relaunching(item.version, item.repo));
     try {
-        await relaunch(item.repo, item.version, deps.run, deps.env);
+        await relaunch(item.repo, item.version, deps.run, langEnv(deps.env));
     }
     catch (err) {
-        deps.print(`${OUTPUT_PREFIX}falló el relanzamiento con la versión ${item.version} para ${item.repo}: ${message(err)}`);
+        deps.print(OUTPUT_PREFIX + t().cli.relaunchFailed(item.version, item.repo, message(err)));
     }
 }
 /**
@@ -144,25 +125,25 @@ async function setupCommand(args, deps) {
         if (at >= 0) {
             const value = args[at + 1];
             if (!value || value.startsWith("-"))
-                deps.print(`${OUTPUT_PREFIX}${REPO_OPTION} necesita una ruta`);
+                deps.print(OUTPUT_PREFIX + t().cli.repoNeedsPath(REPO_OPTION));
             else
                 await runOne(resolve(deps.cwd, value), deps);
             return EXIT_OK;
         }
         const repos = findRepos(homeDir(deps.env));
         if (!repos.length)
-            deps.print(`${OUTPUT_PREFIX}no se encontraron repos en ${homeDir(deps.env)}`);
+            deps.print(OUTPUT_PREFIX + t().cli.noRepos(homeDir(deps.env)));
         for (const item of planSetup(repos, deps.packageVersion, readConfig)) {
             try {
                 await runPlanItem(item, deps);
             }
             catch (err) {
-                deps.print(`${OUTPUT_PREFIX}error en setup de ${item.repo}: ${message(err)}`);
+                deps.print(OUTPUT_PREFIX + t().cli.setupErrorFor(item.repo, message(err)));
             }
         }
     }
     catch (err) {
-        deps.print(`${OUTPUT_PREFIX}error en setup: ${message(err)}`);
+        deps.print(OUTPUT_PREFIX + t().cli.setupError(message(err)));
     }
     return EXIT_OK;
 }
@@ -203,10 +184,10 @@ async function sessionCommand(deps) {
     const delegated = deps.env[DELEGATED_ENV] === DELEGATED_VALUE;
     if (!delegated && wanted && wanted !== deps.packageVersion && existsSync(packageBin(tools, wanted))) {
         try {
-            await deps.run(packageBin(tools, wanted), ["session"], { env: { ...deps.env, [DELEGATED_ENV]: DELEGATED_VALUE } });
+            await deps.run(packageBin(tools, wanted), ["session"], { env: { ...langEnv(deps.env), [DELEGATED_ENV]: DELEGATED_VALUE } });
         }
         catch (err) {
-            deps.print(`${OUTPUT_PREFIX}falló session con la versión ${wanted}: ${message(err)}`);
+            deps.print(OUTPUT_PREFIX + t().cli.sessionDelegateFailed(wanted, message(err)));
         }
         return EXIT_OK;
     }
@@ -224,7 +205,7 @@ async function sessionCommand(deps) {
 async function dockerCommand(deps) {
     if (await deps.docker.ensure().catch(() => false))
         return EXIT_OK;
-    deps.print(`${OUTPUT_PREFIX}dockerd no arrancó; revisa ${DOCKERD_LOG}`);
+    deps.print(OUTPUT_PREFIX + t().docker.didNotStart(DOCKERD_LOG));
     return EXIT_FAIL;
 }
 /**
@@ -242,6 +223,10 @@ async function doctorCommand(deps) {
     });
     for (const line of result.lines)
         deps.print(line);
+    const art = deps.stdoutTty ?? process.stdout.isTTY === true;
+    if (art)
+        for (const line of renderBlock(doctorBlock(result.counts), { art, color: !deps.env.NO_COLOR }))
+            deps.print(line);
     return result.ok ? EXIT_OK : EXIT_FAIL;
 }
 /**
@@ -277,7 +262,7 @@ function manualCommand(deps) {
         deps.print(`${OUTPUT_PREFIX}${message(err)}`);
         return EXIT_FAIL;
     }
-    deps.print(`${OUTPUT_PREFIX}se escribió ${MANUAL_FILE}`);
+    deps.print(OUTPUT_PREFIX + t().cli.manualWritten(MANUAL_FILE));
     return EXIT_OK;
 }
 /**
@@ -353,11 +338,11 @@ async function prepareCommand(args, deps) {
     const known = [RESUME_OPTION, PR_OPTION, HERE_OPTION];
     const unknown = args.filter((arg) => !known.includes(arg));
     if (unknown.length) {
-        deps.print(`${OUTPUT_PREFIX}opción desconocida para prepare: ${unknown.join(" ")}`);
+        deps.print(OUTPUT_PREFIX + t().cli.unknownOption("prepare", unknown.join(" ")));
         return EXIT_FAIL;
     }
     if (args.filter((arg) => known.includes(arg)).length > 1) {
-        deps.print(`${OUTPUT_PREFIX}usa solo una de ${known.join(", ")}`);
+        deps.print(OUTPUT_PREFIX + t().cli.onlyOne(known.join(", ")));
         return EXIT_FAIL;
     }
     const place = args.includes(PR_OPTION) ? "pr" : args.includes(HERE_OPTION) ? "here" : undefined;
@@ -372,7 +357,7 @@ async function prepareCommand(args, deps) {
  */
 async function verifyCommand(args, deps) {
     if (args.length) {
-        deps.print(`${OUTPUT_PREFIX}opción desconocida para verify: ${args.join(" ")}`);
+        deps.print(OUTPUT_PREFIX + t().cli.unknownOption("verify", args.join(" ")));
         return EXIT_FAIL;
     }
     return verifyBranch(deps.cwd, prepareDeps(deps));
@@ -395,10 +380,34 @@ function prepareDeps(deps) {
         packageRoot: deps.packageRoot ?? RUNNING_PACKAGE_ROOT,
         today: deps.today ?? branchDay(new Date()),
         isTty: deps.isTty ?? (process.stdin.isTTY === true && process.stdout.isTTY === true),
-        color: deps.isTty === undefined && process.stdout.isTTY === true && !deps.env.NO_COLOR,
+        color: prepareArt(deps) && !deps.env.NO_COLOR,
+        art: prepareArt(deps),
         onInterrupt: deps.onInterrupt ?? onProcessInterrupt,
     };
 }
+/** Language of this run, set by `main`. */
+let currentLang = "es";
+/**
+ * The environment for another version of this package: the same, with the language of this run,
+ * so a `--lang` given here reaches the relaunched setup or the delegated session.
+ *
+ * @param env - Process environment.
+ * @returns A new environment.
+ * @example
+ * langEnv({}); // { AGENT_CLOUD_KIT_LANG: "es" }
+ */
+function langEnv(env) {
+    return { ...env, [LANG_ENV]: currentLang };
+}
+/**
+ * Whether `prepare` and `verify` draw Kuro: stdout is a terminal (and no test said otherwise).
+ *
+ * @param deps - CLI dependencies.
+ * @returns True in a terminal.
+ */
+function prepareArt(deps) {
+    return deps.stdoutTty ?? (deps.isTty === undefined && process.stdout.isTTY === true);
+}
 /**
  * Runs the CLI.
  *
@@ -409,7 +418,20 @@ function prepareDeps(deps) {
  * process.exitCode = await main(["setup"], realDeps());
  */
 export async function main(argv, deps) {
-    const [command, ...rest] = argv;
+    const { args, flag } = splitLang(argv);
+    try {
+        currentLang = resolveLang(flag, deps.env);
+    }
+    catch (err) {
+        if (!(err instanceof LangError))
+            throw err;
+        currentLang = "es";
+        useLang(currentLang);
+        deps.print(OUTPUT_PREFIX + t().lang.invalid(err.source, err.value));
+        return EXIT_FAIL;
+    }
+    useLang(currentLang);
+    const [command, ...rest] = args;
     if (command === "setup")
         return setupCommand(rest, deps);
     if (command === "session")
@@ -430,7 +452,7 @@ export async function main(argv, deps) {
         deps.print(deps.packageVersion);
         return EXIT_OK;
     }
-    deps.print(HELP);
+    deps.print(t().help);
     return command === undefined || command === "--help" ? EXIT_OK : EXIT_FAIL;
 }
 /**

package/dist/config.js

@@ -4,6 +4,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { CONFIG_FILE } from "./constants.js";
+import { t } from "./messages/index.js";
 /** Top-level key that editors use to point at the JSON schema; allowed but not part of the config. */
 const SCHEMA_KEY = "$schema";
 /** Exact semver: no ranges, no prefixes. */
@@ -78,12 +79,12 @@ function parseDocker(value, errors) {
     if (value === undefined)
         return { pull: PULL_AUTO };
     if (!isRecord(value)) {
-        errors.push(fail('"docker" debe ser un objeto'));
+        errors.push(fail(t().config.dockerNotObject));
         return { pull: PULL_AUTO };
     }
     for (const key of Object.keys(value)) {
         if (!DOCKER_KEYS.includes(key)) {
-            errors.push(fail(`campo desconocido "docker.${key}"`));
+            errors.push(fail(t().config.unknownField(`docker.${key}`)));
         }
     }
     const pull = value.pull;
@@ -91,7 +92,7 @@ function parseDocker(value, errors) {
         return { pull: PULL_AUTO };
     if (pull === false || isStringList(pull))
         return { pull };
-    errors.push(fail('"docker.pull" debe ser "auto", false o un arreglo de strings'));
+    errors.push(fail(t().config.badPull));
     return { pull: PULL_AUTO };
 }
 /**
@@ -108,7 +109,7 @@ function parseList(raw, key, errors) {
         return [];
     if (isStringList(value))
         return value;
-    errors.push(fail(`"${key}" debe ser un arreglo de strings`));
+    errors.push(fail(t().config.notStringList(key)));
     return [];
 }
 /**
@@ -124,13 +125,13 @@ function parseDomains(value, errors) {
     if (value === undefined)
         return [];
     if (!isStringList(value)) {
-        errors.push(fail('"domains" debe ser un arreglo de strings'));
+        errors.push(fail(t().config.notStringList("domains")));
         return [];
     }
     return value.filter((host) => {
         const valid = isHostName(host);
         if (!valid)
-            errors.push(fail(`"domains" tiene un host inválido: ${JSON.stringify(host)}`));
+            errors.push(fail(t().config.badHost(JSON.stringify(host))));
         return valid;
     });
 }
@@ -145,11 +146,11 @@ function parseConfig(raw, errors) {
     const known = [...CONFIG_KEYS, SCHEMA_KEY];
     for (const key of Object.keys(raw)) {
         if (!known.includes(key))
-            errors.push(fail(`campo desconocido "${key}"`));
+            errors.push(fail(t().config.unknownField(key)));
     }
     const version = raw.version;
     if (typeof version !== "string" || !EXACT_SEMVER.test(version)) {
-        errors.push(fail('"version" debe ser un semver exacto, como "1.0.0"'));
+        errors.push(fail(t().config.badVersion));
         return undefined;
     }
     const lists = Object.fromEntries(LIST_KEYS.map((key) => [key, parseList(raw, key, errors)]));
@@ -166,7 +167,7 @@ function parseConfig(raw, errors) {
     if (typeof raw.notes === "string")
         config.notes = raw.notes;
     else if (raw.notes !== undefined)
-        errors.push(fail('"notes" debe ser un string'));
+        errors.push(fail(t().config.notesNotString));
     return config;
 }
 /**
@@ -187,10 +188,10 @@ export function readConfig(repo) {
     }
     catch (error) {
         const reason = error instanceof Error ? error.message : String(error);
-        return { errors: [fail(`no se pudo leer el archivo: ${reason}`)] };
+        return { errors: [fail(t().config.unreadable(reason))] };
     }
     if (!isRecord(raw))
-        return { errors: [fail("debe contener un objeto JSON")] };
+        return { errors: [fail(t().config.notObject)] };
     const errors = [];
     const config = parseConfig(raw, errors);
     return config ? { config, errors } : { errors };

package/dist/docker.js

@@ -4,14 +4,13 @@
 import { execFileSync, spawn } from "node:child_process";
 import { closeSync, openSync } from "node:fs";
 import { DOCKERD_LOG, DOCKER_WAIT_SECONDS } from "./constants.js";
+import { t } from "./messages/index.js";
 /** Timeout of each probe command, in milliseconds. */
 const PROBE_TIMEOUT_MS = 10_000;
 /** Delay between readiness checks, in milliseconds. */
 const POLL_MS = 1000;
 /** Milliseconds in a second. */
 const MS_PER_SECOND = 1000;
-/** Message returned when there is no `dockerd` executable on PATH. */
-export const DOCKERD_MISSING = "dockerd no está instalado";
 /**
  * Tells whether a command exits with code 0.
  *
@@ -33,7 +32,7 @@ function succeeds(cmd, args) {
  *
  * @returns True when `docker info` succeeds.
  * @example
- * if (!dockerResponds()) console.log("docker is down");
+ * if (!dockerResponds()) await ensureDocker();
  */
 export function dockerResponds() {
     return succeeds("docker", ["info"]);
@@ -43,7 +42,7 @@ export function dockerResponds() {
  * answers or when one is already running. Never throws.
  *
  * @param probe - Command probe; the real one when omitted (tests inject a fake).
- * @returns `DOCKERD_MISSING` when there is no `dockerd` on PATH, another error message when the
+ * @returns The "dockerd is not installed" message when there is no `dockerd` on PATH, another error message when the
  *   daemon could not be started, undefined otherwise.
  * @example
  * const problem = startDockerDetached();
@@ -52,7 +51,7 @@ export function startDockerDetached(probe = succeeds) {
     if (probe("docker", ["info"]))
         return undefined;
     if (!probe("sh", ["-c", "command -v dockerd"]))
-        return DOCKERD_MISSING;
+        return t().docker.missing;
     if (probe("pgrep", ["-x", "dockerd"]))
         return undefined;
     try {
@@ -78,7 +77,7 @@ export function startDockerDetached(probe = succeeds) {
  * @param probe - Command probe; the real one when omitted (tests inject a fake).
  * @returns True when Docker answers in time; false when it never does or cannot start.
  * @example
- * if (await ensureDocker()) console.log("docker is up");
+ * const up = await ensureDocker();
  */
 export async function ensureDocker(probe = succeeds) {
     if (startDockerDetached(probe))

package/dist/doctor.js

@@ -8,6 +8,7 @@ import { readConfig } from "./config.js";
 import { CONFIG_FILE, OUTPUT_PREFIX } from "./constants.js";
 import { TOOLS, readToolVersions } from "./detect.js";
 import { isValidRequest, toolExecutable } from "./installers.js";
+import { stepLabel, t } from "./messages/index.js";
 import { expectedFingerprint } from "./session.js";
 import { SKILL_DIR, skillVersion } from "./skill.js";
 import { readState } from "./state.js";
@@ -49,10 +50,10 @@ async function checkDomain(host, capture) {
     try {
         const status = (await capture("curl", args)).trim();
         const ok = status !== BLOCKED_STATUS && status !== NO_ANSWER_STATUS;
-        return { text: `red ${host}: ${ok ? "ok" : "bloqueado"}`, level: verdict(ok) };
+        return { text: t().doctor.domain(host, ok), level: verdict(ok) };
     }
     catch {
-        return { text: `red ${host}: bloqueado`, level: "fail" };
+        return { text: t().doctor.domain(host, false), level: "fail" };
     }
 }
 /**
@@ -82,12 +83,12 @@ function checkTools(repo, toolsDir, state) {
         if (!version)
             return [];
         if (!isValidRequest(tool, version))
-            return [{ text: `herramienta ${tool} ${version}: versión inválida`, level: "fail" }];
+            return [{ text: t().doctor.toolInvalid(tool, version), level: "fail" }];
         const executable = toolExecutable(tool, version, toolsDir, state?.resolved ?? {});
         if (!executable)
-            return [{ text: `herramienta ${tool} ${version}: sin resolver (setup no la instaló)`, level: "fail" }];
+            return [{ text: t().doctor.toolUnresolved(tool, version), level: "fail" }];
         const present = existsSync(executable);
-        return [{ text: `herramienta ${tool} ${version}: ${present ? "ok" : "falta"}`, level: verdict(present) }];
+        return [{ text: t().doctor.tool(tool, version, present), level: verdict(present) }];
     });
 }
 /**
@@ -99,19 +100,19 @@ function checkTools(repo, toolsDir, state) {
  */
 function checkState(repo, ctx) {
     if (!existsSync(join(repo, CONFIG_FILE)))
-        return [{ text: `${CONFIG_FILE}: falta`, level: "fail" }];
+        return [{ text: t().doctor.fileMissing(CONFIG_FILE), level: "fail" }];
     const { config, errors } = readConfig(repo);
     const out = errors.map((text) => ({ text: `${CONFIG_FILE}: ${text}`, level: "fail" }));
     if (!config)
         return out;
     const state = readState(ctx.toolsDir, repo);
     if (!state)
-        return [...out, { text: "estado: falta (setup no corrió)", level: "fail" }];
+        return [...out, { text: t().doctor.stateMissing, level: "fail" }];
     const same = expectedFingerprint(repo, config, state) === state.fingerprint;
-    out.push({ text: `huella: ${same ? "ok" : "distinta"}`, level: verdict(same) });
+    out.push({ text: t().doctor.fingerprint(same), level: verdict(same) });
     for (const s of state.steps) {
         const seconds = (s.ms / MS_PER_SECOND).toFixed(DURATION_DECIMALS);
-        out.push({ text: `paso ${s.name}: ${s.ok ? "ok" : "falló"} (${seconds}s)`, level: verdict(s.ok) });
+        out.push({ text: t().doctor.step(stepLabel(s.name), s.ok, seconds), level: verdict(s.ok) });
     }
     return out;
 }
@@ -132,10 +133,7 @@ function checkPlugins(repo) {
             return [];
         return Object.entries(plugins)
             .filter(([, enabled]) => enabled === true)
-            .map(([name]) => ({
-            text: `aviso: el plugin ${name} está activado pero no está en el repo; no llegará a la nube (copia sus skills con skills-manager)`,
-            level: "warn",
-        }));
+            .map(([name]) => ({ text: t().doctor.plugin(name), level: "warn" }));
     }
     catch {
         return [];
@@ -154,12 +152,7 @@ function checkSkill(repo, packageVersion) {
     const installed = skillVersion(repo);
     if (installed === undefined || installed === packageVersion)
         return [];
-    return [
-        {
-            text: `aviso: ${SKILL_DIR} está en ${installed} y el paquete en ${packageVersion}; corre npx agent-cloud-kit@${packageVersion} init`,
-            level: "warn",
-        },
-    ];
+    return [{ text: t().doctor.skill(SKILL_DIR, installed, packageVersion), level: "warn" }];
 }
 /**
  * Runs one group of checks, turning anything it throws into a failed check.
@@ -173,7 +166,7 @@ async function guarded(name, fn) {
         return await fn();
     }
     catch (err) {
-        return [{ text: `${name}: error: ${err instanceof Error ? err.message : String(err)}`, level: "fail" }];
+        return [{ text: t().doctor.groupError(name, err instanceof Error ? err.message : String(err)), level: "fail" }];
     }
 }
 /**
@@ -187,14 +180,32 @@ async function guarded(name, fn) {
  */
 export async function doctor(repo, ctx) {
     const checks = [];
-    checks.push(...(await guarded("red", async () => Promise.all(domainsToProbe(repo).map((host) => checkDomain(host, ctx.capture))))));
-    checks.push(...(await guarded("herramientas", () => checkTools(repo, ctx.toolsDir, readState(ctx.toolsDir, repo)))));
-    checks.push(...(await guarded("docker", () => {
+    const groups = t().doctor.groups;
+    checks.push(...(await guarded(groups.network, async () => Promise.all(domainsToProbe(repo).map((host) => checkDomain(host, ctx.capture))))));
+    checks.push(...(await guarded(groups.tools, () => checkTools(repo, ctx.toolsDir, readState(ctx.toolsDir, repo)))));
+    checks.push(...(await guarded(groups.docker, () => {
         const docker = ctx.dockerInfo();
-        return [{ text: `docker: ${docker ? "ok" : "falta"}`, level: verdict(docker) }];
+        return [{ text: t().doctor.docker(docker), level: verdict(docker) }];
     })));
-    checks.push(...(await guarded("estado", () => checkState(repo, ctx))));
-    checks.push(...(await guarded("plugins", () => checkPlugins(repo))));
-    checks.push(...(await guarded("skill", () => checkSkill(repo, ctx.packageVersion))));
-    return { lines: checks.map((c) => OUTPUT_PREFIX + c.text), ok: checks.every((c) => c.level !== "fail") };
+    checks.push(...(await guarded(groups.state, () => checkState(repo, ctx))));
+    checks.push(...(await guarded(groups.plugins, () => checkPlugins(repo))));
+    checks.push(...(await guarded(groups.skill, () => checkSkill(repo, ctx.packageVersion))));
+    const failed = checks.filter((c) => c.level === "fail").length;
+    const warnings = checks.filter((c) => c.level === "warn").length;
+    return { lines: checks.map((c) => OUTPUT_PREFIX + c.text), ok: failed === 0, counts: { total: checks.length, failed, warnings } };
+}
+/**
+ * The final block of `doctor`, shown with Kuro in a terminal.
+ *
+ * @param counts - Checks that ran, failed and warned.
+ * @returns What the block says.
+ * @example
+ * doctorBlock({ total: 9, failed: 0, warnings: 0 }); // { mood: "ok", title: "Todo en orden" }
+ */
+export function doctorBlock(counts) {
+    const m = t().doctor;
+    const lines = counts.warnings ? [m.warnings(counts.warnings)] : [];
+    if (!counts.failed)
+        return { mood: "ok", title: m.allOk, lines };
+    return { mood: "error", title: m.someFailed(counts.failed, counts.total), lines: [...lines, m.failedHint] };
 }