agent-cloud-kit 1.0.0-rc.1 → 1.0.0-rc.2

package/README.md

@@ -35,17 +35,23 @@ platform does not tell you:
 ## The flow
 
 1. **Install your agent tooling** with agent-kitchen (config, hook and skill arrive in the repo).
-2. **Run `npx agent-cloud-kit prepare`** in a local terminal. It asks nothing up front: it
-   creates a worktree on a dated branch, runs `init`, and opens
-   Claude locally with the `cloud-ready` skill so it can write the cloud preparation with you. Then
-   it writes the manual, commits, pushes and opens a draft PR.
+2. **Run `npx agent-cloud-kit prepare`** in a local terminal. It asks where to work, with the
+   same menu as agent-kitchen (`--pr` or `--here` skip it):
+   - **En un PR nuevo** (default): creates a worktree on a dated branch from `origin`, so your
+     branch and uncommitted files are untouched; runs `init`, opens Claude locally with the
+     `cloud-ready` skill so it can write the cloud preparation with you, then writes the manual,
+     commits, pushes and opens a draft PR.
+   - **En la rama actual, sin commit:** does the same in your checkout and stops there; you review
+     with `git diff`, commit, push, and then run `npx agent-cloud-kit verify`.
 3. **Configure the environment in claude.ai** following `docs/agent-cloud.md`, which `prepare`
    generated from your `.claude/cloud.json`. The document keeps growing: when the skill, locally
    or in the cloud, finds that a domain or an environment variable is missing, it adds it to
    `.claude/cloud.json`, regenerates the document and tells you in the session what to add in
    claude.ai.
-4. **Verification in the cloud:** `prepare` launches `claude --cloud` on that branch, so a real
-   cloud session runs `cloud-ready verify`, fixes what fails and reports in the PR.
+4. **Verification in the cloud:** `prepare` (new PR) or `verify` (current branch, once pushed)
+   launches `claude --cloud` on that branch, so a real cloud session runs `cloud-ready verify`,
+   fixes what fails and reports in the PR. Run `npx agent-cloud-kit verify` again whenever you
+   change the environment.
 
 `claude --cloud` uses the environment chosen with `/remote-env` in `claude`, and the Claude GitHub
 App must be installed on the repo (without it the session cannot push). Inside the cloud, `gh api`
@@ -145,7 +151,8 @@ A Node version that is not exact (`22`, `22.1`, `lts/iron`, `lts/*` or `node`) i
 | `agent-cloud-kit doctor`         | Checks that the proxy lets the needed hosts through, that the pinned tools are installed, that Docker answers, and the recorded state (fingerprint and each step). Exits 1 if any check fails.                                       |
 | `agent-cloud-kit init`           | Creates `.claude/cloud.json` if missing, adds the `SessionStart` hook to `.claude/settings.json` (keeping the hooks already there), copies the `cloud-ready` skill to `.agents/skills/cloud-ready` when its version differs, and links it from `.claude/skills/cloud-ready`. Safe to run again.                                                                           |
 | `agent-cloud-kit manual`         | Writes `docs/agent-cloud.md` from `.claude/cloud.json`, deterministically: the exact setup script (`agent-cloud-kit@<major>`, or the exact version for a release candidate), domains, variable names, how to verify the environment. |
-| `agent-cloud-kit prepare [--resume]` | Local only, needs an interactive terminal: sets the repo up for the cloud on a new branch in a worktree, opens the PR and verifies it in a real cloud session (see "The flow"). `--resume` continues in the existing worktree. |
+| `agent-cloud-kit prepare [--pr\|--here\|--resume]` | Local only, needs an interactive terminal: sets the repo up for the cloud, in a new PR or in the current branch without committing (asks when no option is given; see "The flow"). `--resume` continues in the existing worktree. |
+| `agent-cloud-kit verify`         | Local only, needs an interactive terminal: launches a cloud session that runs `cloud-ready verify` on the current branch, which must be prepared and pushed. |
 
 Environment variables: `AGENT_CLOUD_KIT_DIR` overrides `/opt/agent-cloud-kit` and `AGENT_CLOUD_KIT_HOME`
 overrides `/home/user`; both exist mainly for tests.
@@ -158,7 +165,7 @@ package that `setup` left on the saved machine, so it needs no network and no `n
 ```json
 {
   "type": "command",
-  "command": "[ \"$CLAUDE_CODE_REMOTE\" = true ] || exit 0; /opt/agent-cloud-kit/bin/agent-cloud-kit session || echo 'agent-cloud-kit: the environment setup did not run; see npx agent-cloud-kit doctor'",
+  "command": "[ \"$CLAUDE_CODE_REMOTE\" = true ] || exit 0; /opt/agent-cloud-kit/bin/agent-cloud-kit session || echo 'agent-cloud-kit: el setup del entorno no corrió; revisa con npx agent-cloud-kit doctor'",
   "timeout": 600
 }
 ```
@@ -169,8 +176,8 @@ When the repo pins another version than the one that is running and that version
 ### Machine fingerprint
 
 `setup` stores a fingerprint of the config, the pinned versions, the images and the package
-version. If the repo changes afterwards, `session` warns that "the machine was prepared with
-another configuration". The saved machine is rebuilt by claude.ai about every 7 days, or when you
+version. If the repo changes afterwards, `session` warns that "la máquina se preparó con
+otra configuración". The saved machine is rebuilt by claude.ai about every 7 days, or when you
 edit the setup script field.
 
 ## The proxy CA and `docker build`

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * @file Command line entry point of agent-cloud-kit: wires `setup`, `session`, `docker`, `doctor`,
- * `init`, `manual` and `prepare` to their modules, relaunching or delegating to the version each
+ * `init`, `manual`, `prepare` and `verify` to their modules, relaunching or delegating to the version each
  * repo pins.
  */
 import { execFileSync } from "node:child_process";
@@ -16,27 +16,31 @@ import { dockerResponds, realDocker } from "./docker.js";
 import { init } from "./init.js";
 import { findRepos, packageBin, planSetup, relaunch } from "./launcher.js";
 import { MANUAL_FILE, writeManual } from "./manual.js";
-import { EXIT_INTERRUPTED, InterruptedError, branchDay, prepare } from "./prepare/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}prepares Claude Code cloud sessions.
+const HELP = `${OUTPUT_PREFIX}prepara repos para las sesiones cloud de Claude Code.
 
-Usage: agent-cloud-kit <command>
+Uso: agent-cloud-kit <comando>
 
-Commands:
-  setup [--repo <path>]  prepare the machine for every repo in the home dir (or only <path>)
-  session                report the machine state and wire the tools into the session
-  docker                 start the Docker daemon and wait until it answers
-  doctor                 check the network allowlist, tools, Docker and the machine state
-  init                   create .claude/cloud.json and register the SessionStart hook
-  manual                 write docs/agent-cloud.md from .claude/cloud.json
-  prepare [--resume]     run locally: set the repo up for the cloud on a new branch and verify it in a cloud session
+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)
 
-Options:
-  --help                 show this help
-  --version              print the package version
+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";
@@ -50,6 +54,10 @@ const REPO_OPTION = "--repo";
 const GIT_TIMEOUT_MS = 10_000;
 /** Option of `prepare` that continues in an existing prepare worktree. */
 const RESUME_OPTION = "--resume";
+/** Option of `prepare`: work in a new worktree that ends in a PR, without asking. */
+const PR_OPTION = "--pr";
+/** Option of `prepare`: work in the current checkout, without committing and without asking. */
+const HERE_OPTION = "--here";
 /** Exit code for success. */
 const EXIT_OK = 0;
 /** Exit code for failure or wrong usage. */
@@ -85,7 +93,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}running ${deps.packageVersion} although ${CONFIG_FILE} asks for ${config.version}`);
+        deps.print(`${OUTPUT_PREFIX}corriendo la versión ${deps.packageVersion}, aunque ${CONFIG_FILE} pide la ${config.version}`);
     }
     const state = await setupRepo(repo, {
         toolsDir: toolsDir(deps.env),
@@ -97,7 +105,7 @@ async function runOne(repo, deps) {
     });
     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} steps, ${failed.length} failed${detail}`);
+    deps.print(`${OUTPUT_PREFIX}setup ${repo}: ${state.steps.length} pasos, ${failed.length} fallaron${detail}`);
 }
 /**
  * Carries out one item of the setup plan; may throw, the caller reports it and moves on.
@@ -107,19 +115,19 @@ async function runOne(repo, deps) {
  */
 async function runPlanItem(item, deps) {
     if (item.action === "skip") {
-        deps.print(`${OUTPUT_PREFIX}skipping ${item.repo}: ${item.reason ?? ""}`);
+        deps.print(`${OUTPUT_PREFIX}se omite ${item.repo}: ${item.reason ?? ""}`);
         return;
     }
     if (item.action === "run" || !item.version) {
         await runOne(item.repo, deps);
         return;
     }
-    deps.print(`${OUTPUT_PREFIX}relaunching with ${item.version} for ${item.repo}`);
+    deps.print(`${OUTPUT_PREFIX}relanzando con la versión ${item.version} para ${item.repo}`);
     try {
         await relaunch(item.repo, item.version, deps.run, deps.env);
     }
     catch (err) {
-        deps.print(`${OUTPUT_PREFIX}relaunch with ${item.version} for ${item.repo} failed: ${message(err)}`);
+        deps.print(`${OUTPUT_PREFIX}falló el relanzamiento con la versión ${item.version} para ${item.repo}: ${message(err)}`);
     }
 }
 /**
@@ -136,25 +144,25 @@ async function setupCommand(args, deps) {
         if (at >= 0) {
             const value = args[at + 1];
             if (!value || value.startsWith("-"))
-                deps.print(`${OUTPUT_PREFIX}${REPO_OPTION} needs a path`);
+                deps.print(`${OUTPUT_PREFIX}${REPO_OPTION} necesita una ruta`);
             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 repos found in ${homeDir(deps.env)}`);
+            deps.print(`${OUTPUT_PREFIX}no se encontraron repos en ${homeDir(deps.env)}`);
         for (const item of planSetup(repos, deps.packageVersion, readConfig)) {
             try {
                 await runPlanItem(item, deps);
             }
             catch (err) {
-                deps.print(`${OUTPUT_PREFIX}setup error for ${item.repo}: ${message(err)}`);
+                deps.print(`${OUTPUT_PREFIX}error en setup de ${item.repo}: ${message(err)}`);
             }
         }
     }
     catch (err) {
-        deps.print(`${OUTPUT_PREFIX}setup error: ${message(err)}`);
+        deps.print(`${OUTPUT_PREFIX}error en setup: ${message(err)}`);
     }
     return EXIT_OK;
 }
@@ -198,7 +206,7 @@ async function sessionCommand(deps) {
             await deps.run(packageBin(tools, wanted), ["session"], { env: { ...deps.env, [DELEGATED_ENV]: DELEGATED_VALUE } });
         }
         catch (err) {
-            deps.print(`${OUTPUT_PREFIX}session ${wanted} failed: ${message(err)}`);
+            deps.print(`${OUTPUT_PREFIX}falló session con la versión ${wanted}: ${message(err)}`);
         }
         return EXIT_OK;
     }
@@ -216,7 +224,7 @@ async function sessionCommand(deps) {
 async function dockerCommand(deps) {
     if (await deps.docker.ensure().catch(() => false))
         return EXIT_OK;
-    deps.print(`${OUTPUT_PREFIX}dockerd did not start; see ${DOCKERD_LOG}`);
+    deps.print(`${OUTPUT_PREFIX}dockerd no arrancó; revisa ${DOCKERD_LOG}`);
     return EXIT_FAIL;
 }
 /**
@@ -269,7 +277,7 @@ function manualCommand(deps) {
         deps.print(`${OUTPUT_PREFIX}${message(err)}`);
         return EXIT_FAIL;
     }
-    deps.print(`${OUTPUT_PREFIX}wrote ${MANUAL_FILE}`);
+    deps.print(`${OUTPUT_PREFIX}se escribió ${MANUAL_FILE}`);
     return EXIT_OK;
 }
 /**
@@ -282,7 +290,7 @@ function manualCommand(deps) {
  * @returns The raw answer.
  * @throws InterruptedError on Ctrl+C.
  * @example
- * await askTerminal("Include these changes in the commit? [y/N]", ""); // "y"
+ * await askTerminal("¿Incluir estos cambios en el commit? [s/N]", ""); // "y"
  */
 const askTerminal = async (question, suggestion) => {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -319,7 +327,7 @@ function onProcessInterrupt(handler) {
  *
  * @param text - Text to show.
  * @example
- * await waitTerminal("Press Enter");
+ * await waitTerminal("Presiona Enter");
  */
 async function waitTerminal(text) {
     await askTerminal(text, "");
@@ -332,15 +340,45 @@ async function waitTerminal(text) {
  * @returns 0 when the cloud session was started, 130 after Ctrl+C, 1 otherwise.
  */
 async function prepareCommand(args, deps) {
-    const unknown = args.filter((arg) => arg !== RESUME_OPTION);
+    const known = [RESUME_OPTION, PR_OPTION, HERE_OPTION];
+    const unknown = args.filter((arg) => !known.includes(arg));
     if (unknown.length) {
-        deps.print(`${OUTPUT_PREFIX}unknown option for prepare: ${unknown.join(" ")}`);
+        deps.print(`${OUTPUT_PREFIX}opción desconocida para prepare: ${unknown.join(" ")}`);
         return EXIT_FAIL;
     }
-    return prepare(deps.cwd, {
+    if (args.filter((arg) => known.includes(arg)).length > 1) {
+        deps.print(`${OUTPUT_PREFIX}usa solo una de ${known.join(", ")}`);
+        return EXIT_FAIL;
+    }
+    const place = args.includes(PR_OPTION) ? "pr" : args.includes(HERE_OPTION) ? "here" : undefined;
+    return prepare(deps.cwd, prepareDeps(deps), { resume: args.includes(RESUME_OPTION), place });
+}
+/**
+ * Runs `verify`: launches the cloud verification of the current branch.
+ *
+ * @param args - Arguments after `verify` (none allowed).
+ * @param deps - CLI dependencies.
+ * @returns 0 when the cloud session was started, 1 otherwise.
+ */
+async function verifyCommand(args, deps) {
+    if (args.length) {
+        deps.print(`${OUTPUT_PREFIX}opción desconocida para verify: ${args.join(" ")}`);
+        return EXIT_FAIL;
+    }
+    return verifyBranch(deps.cwd, prepareDeps(deps));
+}
+/**
+ * Builds the dependencies of `prepare` and `verify` from the CLI ones, with terminal defaults.
+ *
+ * @param deps - CLI dependencies.
+ * @returns The dependencies.
+ */
+function prepareDeps(deps) {
+    return {
         run: deps.run,
         capture: deps.capture ?? captureProcess,
         ask: deps.ask ?? askTerminal,
+        choose: deps.choose ?? chooseTerminal,
         waitEnter: deps.waitEnter ?? waitTerminal,
         print: deps.print,
         packageVersion: deps.packageVersion,
@@ -348,7 +386,7 @@ async function prepareCommand(args, deps) {
         today: deps.today ?? branchDay(new Date()),
         isTty: deps.isTty ?? (process.stdin.isTTY === true && process.stdout.isTTY === true),
         onInterrupt: deps.onInterrupt ?? onProcessInterrupt,
-    }, { resume: args.includes(RESUME_OPTION) });
+    };
 }
 /**
  * Runs the CLI.
@@ -375,6 +413,8 @@ export async function main(argv, deps) {
         return manualCommand(deps);
     if (command === "prepare")
         return prepareCommand(rest, deps);
+    if (command === "verify")
+        return verifyCommand(rest, deps);
     if (command === "--version") {
         deps.print(deps.packageVersion);
         return EXIT_OK;

package/dist/config.js

@@ -78,12 +78,12 @@ function parseDocker(value, errors) {
     if (value === undefined)
         return { pull: PULL_AUTO };
     if (!isRecord(value)) {
-        errors.push(fail('"docker" must be an object'));
+        errors.push(fail('"docker" debe ser un objeto'));
         return { pull: PULL_AUTO };
     }
     for (const key of Object.keys(value)) {
         if (!DOCKER_KEYS.includes(key)) {
-            errors.push(fail(`unknown field "docker.${key}"`));
+            errors.push(fail(`campo desconocido "docker.${key}"`));
         }
     }
     const pull = value.pull;
@@ -91,7 +91,7 @@ function parseDocker(value, errors) {
         return { pull: PULL_AUTO };
     if (pull === false || isStringList(pull))
         return { pull };
-    errors.push(fail('"docker.pull" must be "auto", false or an array of strings'));
+    errors.push(fail('"docker.pull" debe ser "auto", false o un arreglo de strings'));
     return { pull: PULL_AUTO };
 }
 /**
@@ -108,7 +108,7 @@ function parseList(raw, key, errors) {
         return [];
     if (isStringList(value))
         return value;
-    errors.push(fail(`"${key}" must be an array of strings`));
+    errors.push(fail(`"${key}" debe ser un arreglo de strings`));
     return [];
 }
 /**
@@ -124,13 +124,13 @@ function parseDomains(value, errors) {
     if (value === undefined)
         return [];
     if (!isStringList(value)) {
-        errors.push(fail('"domains" must be an array of strings'));
+        errors.push(fail('"domains" debe ser un arreglo de strings'));
         return [];
     }
     return value.filter((host) => {
         const valid = isHostName(host);
         if (!valid)
-            errors.push(fail(`"domains" has an invalid host: ${JSON.stringify(host)}`));
+            errors.push(fail(`"domains" tiene un host inválido: ${JSON.stringify(host)}`));
         return valid;
     });
 }
@@ -145,11 +145,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(`unknown field "${key}"`));
+            errors.push(fail(`campo desconocido "${key}"`));
     }
     const version = raw.version;
     if (typeof version !== "string" || !EXACT_SEMVER.test(version)) {
-        errors.push(fail('"version" must be an exact semver string such as "1.0.0"'));
+        errors.push(fail('"version" debe ser un semver exacto, como "1.0.0"'));
         return undefined;
     }
     const lists = Object.fromEntries(LIST_KEYS.map((key) => [key, parseList(raw, key, errors)]));
@@ -166,7 +166,7 @@ function parseConfig(raw, errors) {
     if (typeof raw.notes === "string")
         config.notes = raw.notes;
     else if (raw.notes !== undefined)
-        errors.push(fail('"notes" must be a string'));
+        errors.push(fail('"notes" debe ser un string'));
     return config;
 }
 /**
@@ -187,10 +187,10 @@ export function readConfig(repo) {
     }
     catch (error) {
         const reason = error instanceof Error ? error.message : String(error);
-        return { errors: [fail(`cannot read file: ${reason}`)] };
+        return { errors: [fail(`no se pudo leer el archivo: ${reason}`)] };
     }
     if (!isRecord(raw))
-        return { errors: [fail("must contain a JSON object")] };
+        return { errors: [fail("debe contener un objeto JSON")] };
     const errors = [];
     const config = parseConfig(raw, errors);
     return config ? { config, errors } : { errors };

package/dist/docker.js

@@ -11,7 +11,7 @@ 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 not installed";
+export const DOCKERD_MISSING = "dockerd no está instalado";
 /**
  * Tells whether a command exits with code 0.
  *

package/dist/doctor.js

@@ -49,10 +49,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: `network ${host}: ${ok ? "ok" : "blocked"}`, level: verdict(ok) };
+        return { text: `red ${host}: ${ok ? "ok" : "bloqueado"}`, level: verdict(ok) };
     }
     catch {
-        return { text: `network ${host}: blocked`, level: "fail" };
+        return { text: `red ${host}: bloqueado`, level: "fail" };
     }
 }
 /**
@@ -82,12 +82,12 @@ function checkTools(repo, toolsDir, state) {
         if (!version)
             return [];
         if (!isValidRequest(tool, version))
-            return [{ text: `tool ${tool} ${version}: invalid version`, level: "fail" }];
+            return [{ text: `herramienta ${tool} ${version}: versión inválida`, level: "fail" }];
         const executable = toolExecutable(tool, version, toolsDir, state?.resolved ?? {});
         if (!executable)
-            return [{ text: `tool ${tool} ${version}: not resolved (setup did not install it)`, level: "fail" }];
+            return [{ text: `herramienta ${tool} ${version}: sin resolver (setup no la instaló)`, level: "fail" }];
         const present = existsSync(executable);
-        return [{ text: `tool ${tool} ${version}: ${present ? "ok" : "missing"}`, level: verdict(present) }];
+        return [{ text: `herramienta ${tool} ${version}: ${present ? "ok" : "falta"}`, level: verdict(present) }];
     });
 }
 /**
@@ -99,19 +99,19 @@ function checkTools(repo, toolsDir, state) {
  */
 function checkState(repo, ctx) {
     if (!existsSync(join(repo, CONFIG_FILE)))
-        return [{ text: `${CONFIG_FILE}: missing`, level: "fail" }];
+        return [{ text: `${CONFIG_FILE}: falta`, 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: "state: missing (setup did not run)", level: "fail" }];
+        return [...out, { text: "estado: falta (setup no corrió)", level: "fail" }];
     const same = expectedFingerprint(repo, config, state) === state.fingerprint;
-    out.push({ text: `fingerprint: ${same ? "ok" : "mismatch"}`, level: verdict(same) });
+    out.push({ text: `huella: ${same ? "ok" : "distinta"}`, level: verdict(same) });
     for (const s of state.steps) {
         const seconds = (s.ms / MS_PER_SECOND).toFixed(DURATION_DECIMALS);
-        out.push({ text: `step ${s.name}: ${s.ok ? "ok" : "failed"} (${seconds}s)`, level: verdict(s.ok) });
+        out.push({ text: `paso ${s.name}: ${s.ok ? "ok" : "falló"} (${seconds}s)`, level: verdict(s.ok) });
     }
     return out;
 }
@@ -122,7 +122,7 @@ function checkState(repo, ctx) {
  * @param repo - Repo root.
  * @returns One warning per enabled plugin.
  * @example
- * checkPlugins("/home/user/app"); // [{ text: "plugin x@m is enabled but ...", level: "warn" }]
+ * checkPlugins("/home/user/app"); // [{ text: "aviso: el plugin x@m está activado pero ...", level: "warn" }]
  */
 function checkPlugins(repo) {
     try {
@@ -133,7 +133,7 @@ function checkPlugins(repo) {
         return Object.entries(plugins)
             .filter(([, enabled]) => enabled === true)
             .map(([name]) => ({
-            text: `warn: plugin ${name} is enabled but is not in the repo; it will not reach the cloud (copy its skills with skills-manager)`,
+            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",
         }));
     }
@@ -148,7 +148,7 @@ function checkPlugins(repo) {
  * @param packageVersion - Version of this package.
  * @returns A warning, or nothing when there is no skill or the versions match.
  * @example
- * checkSkill("/home/user/app", "1.0.0"); // [{ text: "warn: .agents/skills/cloud-ready is 0.9.0, ...", level: "warn" }]
+ * checkSkill("/home/user/app", "1.0.0"); // [{ text: "aviso: .agents/skills/cloud-ready está en 0.9.0, ...", level: "warn" }]
  */
 function checkSkill(repo, packageVersion) {
     const installed = skillVersion(repo);
@@ -156,7 +156,7 @@ function checkSkill(repo, packageVersion) {
         return [];
     return [
         {
-            text: `warn: ${SKILL_DIR} is ${installed}, the package is ${packageVersion}; run npx agent-cloud-kit@${packageVersion} init`,
+            text: `aviso: ${SKILL_DIR} está en ${installed} y el paquete en ${packageVersion}; corre npx agent-cloud-kit@${packageVersion} init`,
             level: "warn",
         },
     ];
@@ -187,13 +187,13 @@ async function guarded(name, fn) {
  */
 export async function doctor(repo, ctx) {
     const checks = [];
-    checks.push(...(await guarded("network", async () => Promise.all(domainsToProbe(repo).map((host) => checkDomain(host, ctx.capture))))));
-    checks.push(...(await guarded("tools", () => checkTools(repo, ctx.toolsDir, readState(ctx.toolsDir, repo)))));
+    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 docker = ctx.dockerInfo();
-        return [{ text: `docker: ${docker ? "ok" : "missing"}`, level: verdict(docker) }];
+        return [{ text: `docker: ${docker ? "ok" : "falta"}`, level: verdict(docker) }];
     })));
-    checks.push(...(await guarded("state", () => checkState(repo, ctx))));
+    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") };

package/dist/init.js

@@ -15,7 +15,7 @@ const HOOK_TIMEOUT_SECONDS = 600;
 /** Indentation of the files written. */
 const JSON_INDENT = 2;
 /** Command of the SessionStart hook: does nothing outside cloud sessions. */
-const HOOK_COMMAND = "[ \"$CLAUDE_CODE_REMOTE\" = true ] || exit 0; /opt/agent-cloud-kit/bin/agent-cloud-kit session || echo 'agent-cloud-kit: the environment setup did not run; see npx agent-cloud-kit doctor'";
+const HOOK_COMMAND = "[ \"$CLAUDE_CODE_REMOTE\" = true ] || exit 0; /opt/agent-cloud-kit/bin/agent-cloud-kit session || echo 'agent-cloud-kit: el setup del entorno no corrió; revisa con npx agent-cloud-kit doctor'";
 /** The hook `init` registers. */
 const HOOK = { type: "command", command: HOOK_COMMAND, timeout: HOOK_TIMEOUT_SECONDS };
 /**
@@ -36,7 +36,7 @@ function isRecord(value) {
  */
 function addByHand(reason) {
     const entry = JSON.stringify({ hooks: [HOOK] });
-    return { line: `${SETTINGS_FILE} ${reason}, left untouched; add this entry to hooks.SessionStart by hand: ${entry}`, ok: false };
+    return { line: `${SETTINGS_FILE} ${reason}; no se tocó. Agrega esta entrada a hooks.SessionStart a mano: ${entry}`, ok: false };
 }
 /**
  * Writes a JSON file with a trailing newline, creating its folder.
@@ -70,7 +70,7 @@ function hasHook(entries) {
 function scaffoldConfig(repo, packageVersion) {
     const file = join(repo, CONFIG_FILE);
     if (existsSync(file))
-        return `${CONFIG_FILE} already exists, left as is`;
+        return `${CONFIG_FILE} ya existe; se dejó como estaba`;
     writeJson(file, {
         $schema: `https://unpkg.com/${PACKAGE}@${packageVersion}/schema.json`,
         version: packageVersion,
@@ -82,7 +82,7 @@ function scaffoldConfig(repo, packageVersion) {
         requiredEnv: [],
         domains: [],
     });
-    return `created ${CONFIG_FILE}`;
+    return `se creó ${CONFIG_FILE}`;
 }
 /**
  * Adds the SessionStart hook to `.claude/settings.json`, keeping everything else.
@@ -98,21 +98,21 @@ function registerHook(repo) {
             settings = JSON.parse(readFileSync(file, "utf8"));
         }
         catch {
-            return addByHand("is not valid JSON");
+            return addByHand("no es JSON válido");
         }
     }
     if (!isRecord(settings))
-        return addByHand("is not a JSON object");
+        return addByHand("no es un objeto JSON");
     const hooks = settings.hooks ?? {};
     if (!isRecord(hooks))
-        return addByHand('has a "hooks" that is not an object');
+        return addByHand('tiene un "hooks" que no es un objeto');
     const entries = hooks.SessionStart ?? [];
     if (!Array.isArray(entries))
-        return addByHand('has a "hooks.SessionStart" that is not an array');
+        return addByHand('tiene un "hooks.SessionStart" que no es un arreglo');
     if (hasHook(entries))
-        return { line: `${SETTINGS_FILE} already has the SessionStart hook`, ok: true };
+        return { line: `${SETTINGS_FILE} ya tiene el hook SessionStart`, ok: true };
     writeJson(file, { ...settings, hooks: { ...hooks, SessionStart: [...entries, { hooks: [HOOK] }] } });
-    return { line: `added the SessionStart hook to ${SETTINGS_FILE}`, ok: true };
+    return { line: `se agregó el hook SessionStart a ${SETTINGS_FILE}`, ok: true };
 }
 /**
  * Sets a repo up for agent-cloud-kit; safe to run again. It is the only place that copies the

package/dist/installers.js

@@ -123,7 +123,7 @@ async function nodeExpectedHash(run, env, dir, version, file) {
     await run("curl", ["-fsSL", "-o", path, "--", url], { env, timeoutMs: TOOL_INSTALL_TIMEOUT_MS });
     const hash = parseShasums(readFileSync(path, "utf8"), file);
     if (!hash)
-        throw new Error(`${file} is not listed in ${NODE_SHASUMS_FILE}`);
+        throw new Error(`${file} no aparece en ${NODE_SHASUMS_FILE}`);
     return hash;
 }
 /**
@@ -138,7 +138,7 @@ async function nodeExpectedHash(run, env, dir, version, file) {
 export function nodeArch(arch) {
     const mapped = NODE_ARCHS[arch];
     if (!mapped)
-        throw new Error(`unsupported architecture for node: ${arch}`);
+        throw new Error(`arquitectura no soportada para node: ${arch}`);
     return mapped;
 }
 /**
@@ -153,7 +153,7 @@ export function nodeArch(arch) {
  */
 export function assertVersion(tool, version) {
     if (!VERSION_PATTERN.test(version))
-        throw new Error(`invalid version for ${tool}: ${version}`);
+        throw new Error(`versión inválida para ${tool}: ${version}`);
 }
 /**
  * Tells whether a version is safe to use.
@@ -254,7 +254,7 @@ export function curlNodeIndex(run, env) {
             await run("curl", ["-fsSL", "--max-time", NODE_INDEX_TIMEOUT_SECONDS, "-o", file, "--", NODE_INDEX_URL], { env });
             const parsed = JSON.parse(readFileSync(file, "utf8"));
             if (!Array.isArray(parsed))
-                throw new Error("the node release index is not a list");
+                throw new Error("el índice de versiones de node no es una lista");
             return parsed.filter((r) => typeof r === "object" && r !== null && typeof r.version === "string" && (r.lts === false || typeof r.lts === "string"));
         }
         finally {
@@ -283,7 +283,7 @@ export async function resolveVersions(versions, fetchIndex) {
     const result = await step(`node ${requested}`, async () => {
         exact = resolveNodeVersion(requested, await fetchIndex());
         if (!exact)
-            throw new Error(`no node release matches ${requested}`);
+            throw new Error(`ninguna versión de node coincide con ${requested}`);
     });
     if (!exact)
         return { resolved, results: [result] };
@@ -403,7 +403,7 @@ export async function installTools(versions, toolsDir, run, env) {
         }
         if (tool === "node" && !NODE_EXACT.test(version)) {
             results.push(await step(`${tool} ${version}`, async () => {
-                throw new Error(`node ${version} must be resolved to an exact version first`);
+                throw new Error(`node ${version} debe resolverse primero a una versión exacta`);
             }));
             continue;
         }

package/dist/launcher.js

@@ -58,7 +58,7 @@ export function planSetup(repos, current, read) {
     return repos.map((repo) => {
         const { config, errors } = read(repo);
         if (!config)
-            return { repo, action: "skip", reason: errors.length ? errors.join("; ") : `no ${CONFIG_FILE}` };
+            return { repo, action: "skip", reason: errors.length ? errors.join("; ") : `no hay ${CONFIG_FILE}` };
         if (config.version === current)
             return { repo, action: "run", version: current };
         return { repo, action: "relaunch", version: config.version };