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

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 };

package/dist/manual.js

@@ -5,7 +5,7 @@
 import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { readConfig } from "./config.js";
-import { CONFIG_FILE, OUTPUT_PREFIX, PACKAGE } from "./constants.js";
+import { CONFIG_FILE, OUTPUT_PREFIX, PACKAGE, packageSpec } from "./constants.js";
 /** Path of the manual, relative to the repo. */
 export const MANUAL_FILE = "docs/agent-cloud.md";
 /** Marker that opens the generated block. */
@@ -16,17 +16,28 @@ export const END = "<!-- agent-cloud-kit:end -->";
 const FINDINGS = "## Hallazgos\n\n_Lo que el agente descubra de la nube va aquí._\n";
 /** Prefix of an https URL. */
 const HTTPS_PREFIX = "https://";
-/** Setup script the environment must run, in a `bash` block. */
-const SETUP_SCRIPT = `#!/bin/bash\nnpx -y ${PACKAGE}@1 setup`;
+/**
+ * Setup script the environment must run, for a `bash` block.
+ *
+ * @param packageVersion - Version of the running package.
+ * @returns The script.
+ * @example
+ * setupScript("1.2.0"); // "#!/bin/bash\nnpx -y agent-cloud-kit@1 setup"
+ */
+function setupScript(packageVersion) {
+    return `#!/bin/bash\nnpx -y ${packageSpec(packageVersion)} setup`;
+}
 /** The "how it works" section, five lines. */
 const HOW_IT_WORKS = [
     "## Cómo funciona",
     "",
     "1. agent-kitchen instala las herramientas y los ganchos en el repo.",
-    `2. \`${PACKAGE} prepare\` configura el repo con la skill y deja lista la lista de dominios y variables.`,
+    `2. \`${PACKAGE} prepare\` configura el repo con la skill y genera este documento.`,
     "3. Tú configuras el entorno en claude.ai con lo que indica la siguiente sección.",
     "4. Una sesión en la nube verifica que el entorno quedó bien.",
     "5. El PR guarda el resultado.",
+    "",
+    "Este documento se va actualizando. Cuando la skill `cloud-ready`, en local o en la nube, detecta que hace falta un dominio o una variable de entorno nueva, la agrega a `.claude/cloud.json`, regenera este archivo y te lo dice en la sesión. Cuando cambie la sección \"Configurar el entorno en claude.ai\", aplica lo nuevo en claude.ai y vuelve a verificar con `npx agent-cloud-kit verify` desde la rama.",
 ].join("\n");
 /**
  * Extracts the host of an apt repo URL.
@@ -62,11 +73,12 @@ function allowedHosts(config) {
  * Renders the "Configurar el entorno en claude.ai" section.
  *
  * @param config - Repo config.
+ * @param packageVersion - Version of the running package, for the setup script.
  * @returns The section, without a trailing newline.
  * @example
- * renderEnvironmentSection(config).startsWith("## Configurar el entorno en claude.ai"); // true
+ * renderEnvironmentSection(config, "1.0.0").startsWith("## Configurar el entorno en claude.ai"); // true
  */
-export function renderEnvironmentSection(config) {
+export function renderEnvironmentSection(config, packageVersion) {
     const hosts = allowedHosts(config);
     const lines = [
         "## Configurar el entorno en claude.ai",
@@ -82,7 +94,7 @@ export function renderEnvironmentSection(config) {
         "### Setup script",
         "",
         "```bash",
-        SETUP_SCRIPT,
+        setupScript(packageVersion),
         "```",
         "",
         "### Variables de entorno",
@@ -154,7 +166,7 @@ export function renderManual(input) {
         `<!-- Generado por ${PACKAGE} ${input.packageVersion}. No edites entre las marcas. -->`,
         "# Nube de Claude Code",
         HOW_IT_WORKS,
-        renderEnvironmentSection(input.config),
+        renderEnvironmentSection(input.config, input.packageVersion),
         VERIFY_SECTION,
         `## Qué corre en la nube\n\n${notes?.trim() ? notes.trim() : "Nada anotado."}`,
         END,
@@ -193,7 +205,7 @@ export function mergeManual(existing, block) {
 export function writeManual(repo, packageVersion) {
     const { config, errors } = readConfig(repo);
     if (!config)
-        throw new Error(errors[0] ?? `${CONFIG_FILE} not found; run init first`);
+        throw new Error(errors[0] ?? `no existe ${CONFIG_FILE}; corre init primero`);
     const file = join(repo, MANUAL_FILE);
     const existing = existsSync(file) ? readFileSync(file, "utf8") : undefined;
     const block = renderManual({ config, packageVersion, notes: resolveNotes(repo, config.notes) });

package/dist/prepare/detect.js

@@ -1,57 +1,28 @@
 /**
- * @file Pure parts of `prepare`: secret-name suggestions and preflight checks.
+ * @file Pure parts of `prepare`: preflight checks.
  */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-/** File, in the repo root, whose keys are suggested as secret names. */
-const ENV_EXAMPLE_FILE = ".env.example";
-/** Matches a `KEY=value` line (optionally prefixed by `export`) and captures the key. */
-const ENV_LINE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/;
 /** Flag `claude` must advertise in its help to launch cloud sessions. */
 const CLOUD_FLAG = "--cloud";
 /**
- * Suggests secret names from the keys of `.env.example` in the repo root.
- *
- * @param repo Repo root.
- * @returns Keys in file order, without duplicates; empty when the file does not exist.
- * @example
- * suggestSecrets("/repo"); // ["API_TOKEN", "DB_URL"]
- */
-export function suggestSecrets(repo) {
-    const file = join(repo, ENV_EXAMPLE_FILE);
-    if (!existsSync(file))
-        return [];
-    const keys = [];
-    for (const line of readFileSync(file, "utf8").split(/\r?\n/)) {
-        if (line.trimStart().startsWith("#"))
-            continue;
-        const key = ENV_LINE.exec(line)?.[1];
-        if (key !== undefined && !keys.includes(key))
-            keys.push(key);
-    }
-    return keys;
-}
-/**
- * Checks that `prepare` can run.
+ * Checks that `prepare` (or `verify`) can run.
  *
  * @param probe What was observed about the environment.
- * @returns Problems in English, in a fixed order; empty when everything is fine.
+ * @param command Command named in the messages.
+ * @returns Problems in Spanish, in a fixed order; empty when everything is fine.
  * @example
- * preflight({ isTty: false, hasOrigin: true, clean: true }); // ["prepare needs an interactive terminal", ...]
+ * preflight({ isTty: false, hasOrigin: true }); // ["prepare necesita una terminal interactiva", ...]
  */
-export function preflight(probe) {
+export function preflight(probe, command = "prepare") {
     const problems = [];
     if (!probe.isTty)
-        problems.push("prepare needs an interactive terminal");
+        problems.push(`${command} necesita una terminal interactiva (corre el comando directamente en tu terminal)`);
     if (probe.gitRoot === undefined)
-        problems.push("not inside a git repository");
+        problems.push(`esto no es un repositorio git; corre ${command} dentro del repo`);
     if (!probe.hasOrigin)
-        problems.push("the repository has no 'origin' remote");
-    if (!probe.clean)
-        problems.push("the working tree has uncommitted changes; commit or stash them first");
+        problems.push(`el repositorio no tiene el remoto 'origin'; ${command} necesita subir una rama a GitHub`);
     if (probe.claudeHelp === undefined)
-        problems.push("claude is not installed or not on the PATH");
+        problems.push(`claude no está instalado o no está en el PATH; instala Claude Code y vuelve a correr ${command}`);
     else if (!probe.claudeHelp.includes(CLOUD_FLAG))
-        problems.push("claude does not support --cloud; update Claude Code");
+        problems.push(`tu versión de claude no soporta --cloud; actualiza Claude Code y vuelve a correr ${command}`);
     return problems;
 }

package/dist/prepare/index.js

@@ -9,10 +9,9 @@ import { readConfig } from "../config.js";
 import { CONFIG_FILE, OUTPUT_PREFIX, PACKAGE } from "../constants.js";
 import { defaultBranch } from "../detect.js";
 import { init } from "../init.js";
-import { renderEnvironmentSection, writeManual } from "../manual.js";
-import { preflight, suggestSecrets } from "./detect.js";
+import { MANUAL_FILE, renderEnvironmentSection, writeManual } from "../manual.js";
+import { preflight } from "./detect.js";
 import { configurePrompt, verifyPrompt } from "./prompts.js";
-import { askAll } from "./questions.js";
 /** Prefix of the branch `prepare` creates; the day follows it. */
 const BRANCH_PREFIX = "chore/cloud-ready-";
 /** Suffix added to the repo folder name to name the worktree folder, next to the repo. */
@@ -30,13 +29,13 @@ const KNOWN_PATHS = [
 /** Project file of the test-audit skill, committed too when it exists. */
 const TEST_AUDIT_PROJECT_FILE = ".agents/skills/test-audit/project.md";
 /** Message of the commit `prepare` makes. */
-const COMMIT_MESSAGE = "chore: prepare the repo for the Claude Code cloud";
+const COMMIT_MESSAGE = "chore: prepara el repo para la nube de Claude Code";
 /** Question asked before committing changes outside the known files. */
-const INCLUDE_QUESTION = "Include these changes in the commit? [y/N]";
+const INCLUDE_QUESTION = "¿Incluir estos cambios en el commit? [s/N]";
 /** Answers to `INCLUDE_QUESTION` that mean yes. */
-const YES_ANSWER = /^y(es)?$/i;
+const YES_ANSWER = /^(s|si|sí|y|yes)$/i;
 /** Text shown while the user configures the environment in claude.ai. */
-const WAIT_TEXT = "Configure the environment in claude.ai, then press Enter";
+const WAIT_TEXT = "Configura el entorno en claude.ai y luego presiona Enter";
 /** Matches a GitHub remote URL (https or ssh) and captures `owner/repo`. */
 const GITHUB_REMOTE = /github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?\/?$/;
 /** Matches a pull request URL and captures its number. */
@@ -44,7 +43,13 @@ const PR_URL = /\/pull\/(\d+)/;
 /** Command that continues a prepare run; `npx` because a first-time user does not have the binary on PATH. */
 const RESUME_COMMAND = `npx ${PACKAGE} prepare --resume`;
 /** Printed just before the local agent starts: `prepare` continues only when `claude` exits. */
-const EXIT_CLAUDE_HINT = `${OUTPUT_PREFIX}when the skill says configure is done, exit claude (/exit) and prepare will commit, push and open the PR`;
+const EXIT_CLAUDE_HINT = `${OUTPUT_PREFIX}cuando la skill diga que configure terminó, sal de claude (/exit) y prepare hará el commit, el push y abrirá el PR`;
+/** Printed before the local agent starts in the current branch: nothing is committed. */
+const EXIT_CLAUDE_HINT_HERE = `${OUTPUT_PREFIX}cuando la skill diga que configure terminó, sal de claude (/exit)`;
+/** Question of the place menu. */
+const PLACE_QUESTION = "¿Dónde preparo el repo?";
+/** Command that launches the cloud verification of the current branch. */
+const VERIFY_COMMAND = `npx ${PACKAGE} verify`;
 /** Exit code for success. */
 const EXIT_OK = 0;
 /** Exit code for failure. */
@@ -57,7 +62,7 @@ const PR_NUMBER = /^\d+$/;
 export class InterruptedError extends Error {
     /** Builds the error. */
     constructor() {
-        super("interrupted");
+        super("interrumpido");
         this.name = "InterruptedError";
     }
 }
@@ -80,10 +85,10 @@ export function branchDay(date) {
  * @param worktree - Worktree folder.
  * @returns The line to print.
  * @example
- * resumeLine("interrupted", "/home/u/app-cloud-ready"); // "interrupted; the worktree is at ...; run ... --resume there"
+ * resumeLine("interrumpido", "/home/u/app-cloud-ready"); // "interrumpido; el worktree está en ...; corre ... --resume ahí para continuar"
  */
 function resumeLine(reason, worktree) {
-    return `${reason}; the worktree is at ${worktree}; run ${RESUME_COMMAND} there`;
+    return `${reason}; el worktree está en ${worktree}; corre ${RESUME_COMMAND} ahí para continuar`;
 }
 /**
  * Runs a capture and trims its output; never throws.
@@ -154,7 +159,7 @@ function worktreePath(repo) {
 function configureProblem(worktree) {
     const { config, errors } = readConfig(worktree);
     if (!config || errors.length)
-        return errors[0] ?? `${CONFIG_FILE} not found`;
+        return errors[0] ?? `no existe ${CONFIG_FILE}`;
     const notes = config.notes ?? DEFAULT_NOTES_FILE;
     const rel = relative(worktree, join(worktree, notes));
     const inside = !isAbsolute(notes) && rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`);
@@ -165,7 +170,7 @@ function configureProblem(worktree) {
     catch {
         // NOTE: a missing file is reported below.
     }
-    return `the notes file ${notes} does not exist`;
+    return `no existe el archivo de notas ${notes}`;
 }
 /**
  * Lists the paths of `git status --porcelain=v1 -z` output.
@@ -235,7 +240,7 @@ async function findResume(repo, deps) {
     return undefined;
 }
 /**
- * Steps 2–5: asks the questions, creates the worktree, installs the kit and runs the local agent.
+ * Steps 2–5: creates the worktree, installs the kit and runs the local agent.
  *
  * @param repo - Git root of the repo.
  * @param branch - Branch to create.
@@ -243,20 +248,18 @@ async function findResume(repo, deps) {
  * @param deps - Dependencies.
  * @param progress - Gets the worktree once it exists.
  * @returns True when the worktree is ready to commit.
- * @throws InterruptedError when the user presses Ctrl+C during the questions.
  * @example
  * await createAndConfigure("/home/u/app", "chore/cloud-ready-20261102", "/home/u/app-cloud-ready", deps, {});
  */
 async function createAndConfigure(repo, branch, worktree, deps, progress) {
     if (existsSync(worktree)) {
-        deps.print(`${OUTPUT_PREFIX}${worktree} already exists; remove it (git worktree remove ${worktree}) or continue there with ${RESUME_COMMAND}`);
+        deps.print(`${OUTPUT_PREFIX}${worktree} ya existe; bórralo (git worktree remove ${worktree}) o continúa ahí con ${RESUME_COMMAND}`);
         return false;
     }
     if ((await tryCapture(deps, "git", ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], repo)) !== undefined) {
-        deps.print(`${OUTPUT_PREFIX}branch ${branch} already exists; delete it (git branch -D ${branch}) or run prepare another day`);
+        deps.print(`${OUTPUT_PREFIX}la rama ${branch} ya existe; bórrala (git branch -D ${branch}) o corre prepare otro día`);
         return false;
     }
-    const answers = await askAll(deps.ask, { secrets: suggestSecrets(repo) }, deps.print);
     const base = `origin/${defaultBranch(repo)}`;
     try {
         await deps.run("git", ["fetch", "-q", "origin"], { cwd: repo });
@@ -264,10 +267,10 @@ async function createAndConfigure(repo, branch, worktree, deps, progress) {
         progress.worktree = worktree;
     }
     catch (err) {
-        deps.print(`${OUTPUT_PREFIX}could not create the worktree: ${message(err)}`);
+        deps.print(`${OUTPUT_PREFIX}no se pudo crear el worktree: ${message(err)}`);
         return false;
     }
-    const stopped = resumeLine("the local agent stopped", worktree);
+    const stopped = resumeLine("el agente local se detuvo", worktree);
     try {
         const result = init(worktree, deps.packageVersion, deps.packageRoot);
         for (const line of result.lines)
@@ -284,7 +287,7 @@ async function createAndConfigure(repo, branch, worktree, deps, progress) {
     }
     deps.print(EXIT_CLAUDE_HINT);
     try {
-        await runInteractive(deps, progress, [configurePrompt(answers)], worktree);
+        await runInteractive(deps, progress, [configurePrompt()], worktree);
     }
     catch {
         deps.print(stopped);
@@ -292,8 +295,8 @@ async function createAndConfigure(repo, branch, worktree, deps, progress) {
     }
     const problem = configureProblem(worktree);
     if (problem !== undefined) {
-        deps.print(`${OUTPUT_PREFIX}configure did not finish: ${problem}`);
-        deps.print(resumeLine("prepare stopped", worktree));
+        deps.print(`${OUTPUT_PREFIX}configure no terminó: ${problem}`);
+        deps.print(resumeLine("prepare se detuvo", worktree));
         return false;
     }
     return true;
@@ -320,7 +323,7 @@ async function commitAndPush(worktree, branch, deps) {
         const status = await deps.capture("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], { cwd: worktree });
         const others = statusPaths(status).filter((path) => !covered(path, known));
         if (others.length) {
-            deps.print(`${OUTPUT_PREFIX}the local agent also changed:`);
+            deps.print(`${OUTPUT_PREFIX}el agente local también cambió:`);
             for (const path of others)
                 deps.print(`  ${path}`);
             if (YES_ANSWER.test((await deps.ask(INCLUDE_QUESTION, "")).trim())) {
@@ -328,48 +331,49 @@ async function commitAndPush(worktree, branch, deps) {
             }
             else {
                 await deps.run("git", ["reset", "-q", "--", ...others], { cwd: worktree });
-                deps.print(`${OUTPUT_PREFIX}left uncommitted in ${worktree}`);
+                deps.print(`${OUTPUT_PREFIX}quedó sin commitear en ${worktree}`);
             }
         }
         const staged = await deps.capture("git", ["diff", "--cached", "--name-only"], { cwd: worktree });
         if (staged.trim())
             await deps.run("git", ["commit", "-m", COMMIT_MESSAGE], { cwd: worktree });
         else
-            deps.print(`${OUTPUT_PREFIX}nothing new to commit`);
+            deps.print(`${OUTPUT_PREFIX}no hay nada nuevo que commitear`);
         await deps.run("git", ["push", "-u", "origin", branch], { cwd: worktree });
     }
     catch (err) {
         if (err instanceof InterruptedError)
             throw err;
-        deps.print(`${OUTPUT_PREFIX}could not commit and push: ${message(err)}; fix it in ${worktree} and run ${RESUME_COMMAND} there`);
+        deps.print(`${OUTPUT_PREFIX}no se pudo hacer commit y push: ${message(err)}; corrígelo en ${worktree} y corre ${RESUME_COMMAND} ahí`);
         return false;
     }
     const existing = await tryCapture(deps, "gh", ["pr", "view", branch, "--json", "number", "--jq", ".number"], worktree);
     if (existing !== undefined && PR_NUMBER.test(existing)) {
-        deps.print(`${OUTPUT_PREFIX}reusing the open PR #${existing}`);
+        deps.print(`${OUTPUT_PREFIX}se reutiliza el PR abierto #${existing}`);
         return { pr: existing };
     }
     try {
         const url = await deps.capture("gh", ["pr", "create", "--draft", "--fill"], { cwd: worktree });
-        deps.print(`${OUTPUT_PREFIX}draft PR: ${url.trim()}`);
+        deps.print(`${OUTPUT_PREFIX}PR en borrador: ${url.trim()}`);
         return { pr: PR_URL.exec(url)?.[1] };
     }
     catch {
         const origin = await tryCapture(deps, "git", ["remote", "get-url", "origin"], worktree);
         const link = compareLink(origin, branch);
-        deps.print(`${OUTPUT_PREFIX}could not open the PR with gh; open it by hand${link ? `: ${link}` : ` from branch ${branch}`}`);
+        deps.print(`${OUTPUT_PREFIX}no se pudo abrir el PR con gh; ábrelo a mano${link ? `: ${link}` : ` desde la rama ${branch}`}`);
         return {};
     }
 }
 /**
- * Prepares a repo for Claude Code cloud sessions: checks, asks, creates a worktree on a new
- * branch, runs the local agent with the `cloud-ready` skill, commits, pushes, opens a draft PR,
+ * Prepares a repo for Claude Code cloud sessions: checks, asks where to work (a new PR or the
+ * current branch, see `prepareHere`), creates a worktree on a new branch, runs the local agent with the `cloud-ready` skill, commits, pushes, opens a draft PR,
  * waits while the user configures the environment and starts a cloud session that verifies it.
  *
  * @param repo - Folder where the user runs `prepare` (inside the repo, or the worktree with resume).
  * @param deps - Dependencies.
  * @param options - `resume` continues in an existing prepare worktree.
- * @returns 0 when the cloud session was started, 130 after Ctrl+C at a question, 1 otherwise.
+ * @returns 0 when the cloud session was started (or, in the current branch, when it is prepared),
+ *   130 after Ctrl+C at a question, 1 otherwise.
  * @example
  * process.exitCode = await prepare(process.cwd(), deps);
  */
@@ -377,9 +381,8 @@ export async function prepare(repo, deps, options = {}) {
     const gitRoot = await tryCapture(deps, "git", ["rev-parse", "--show-toplevel"], repo);
     const cwd = gitRoot ?? repo;
     const hasOrigin = (await tryCapture(deps, "git", ["remote", "get-url", "origin"], cwd)) !== undefined;
-    const clean = options.resume ? true : (await tryCapture(deps, "git", ["status", "--porcelain"], cwd)) === "";
     const claudeHelp = await tryCapture(deps, "claude", ["--help"], cwd);
-    const problems = preflight({ isTty: deps.isTty, gitRoot, hasOrigin, clean, claudeHelp });
+    const problems = preflight({ isTty: deps.isTty, gitRoot, hasOrigin, claudeHelp });
     if (problems.length || gitRoot === undefined) {
         for (const problem of problems)
             deps.print(`${OUTPUT_PREFIX}${problem}`);
@@ -433,10 +436,12 @@ async function runInteractive(deps, progress, args, cwd) {
  * @param progress - What exists so far.
  * @returns The line.
  * @example
- * interruptedLine({}); // "agent-cloud-kit: interrupted; nothing was created"
+ * interruptedLine({}); // "agent-cloud-kit: interrumpido; no se creó nada"
  */
 function interruptedLine(progress) {
-    return progress.worktree === undefined ? `${OUTPUT_PREFIX}interrupted; nothing was created` : resumeLine("interrupted", progress.worktree);
+    if (progress.here)
+        return `${OUTPUT_PREFIX}interrumpido; lo que alcanzó a cambiar quedó sin commit en tu rama`;
+    return progress.worktree === undefined ? `${OUTPUT_PREFIX}interrumpido; no se creó nada` : resumeLine("interrumpido", progress.worktree);
 }
 /**
  * Everything after the preflight: resume or create the worktree, commit, wait, launch.
@@ -456,18 +461,25 @@ async function prepareSteps(gitRoot, deps, options, progress) {
     if (options.resume) {
         const found = await findResume(gitRoot, deps);
         if (!found) {
-            deps.print(`${OUTPUT_PREFIX}nothing to resume: run it in the ${WORKTREE_SUFFIX} worktree on a ${BRANCH_PREFIX}* branch`);
+            deps.print(`${OUTPUT_PREFIX}no hay nada que reanudar: corre prepare --resume en el worktree *${WORKTREE_SUFFIX}, sobre una rama ${BRANCH_PREFIX}*`);
             return EXIT_FAIL;
         }
         ({ worktree, branch } = found);
         progress.worktree = worktree;
         const problem = configureProblem(worktree);
         if (problem) {
-            deps.print(`${OUTPUT_PREFIX}configure is not finished in ${worktree}: ${problem}; run claude "/cloud-ready configure" there first, then ${RESUME_COMMAND}`);
+            deps.print(`${OUTPUT_PREFIX}configure no terminó en ${worktree}: ${problem}; corre claude "/cloud-ready configure" ahí primero y luego ${RESUME_COMMAND}`);
             return EXIT_FAIL;
         }
     }
     else {
+        const place = options.place ?? (await askPlace(gitRoot, deps));
+        if (place === null) {
+            deps.print(`${OUTPUT_PREFIX}no se cambió nada`);
+            return EXIT_FAIL;
+        }
+        if (place === "here")
+            return prepareHere(gitRoot, deps, progress);
         branch = `${BRANCH_PREFIX}${deps.today}`;
         worktree = worktreePath(gitRoot);
         if (!(await createAndConfigure(gitRoot, branch, worktree, deps, progress)))
@@ -478,15 +490,145 @@ async function prepareSteps(gitRoot, deps, options, progress) {
         return EXIT_FAIL;
     const config = readConfig(worktree).config;
     if (config)
-        deps.print(renderEnvironmentSection(config));
+        deps.print(renderEnvironmentSection(config, deps.packageVersion));
     await deps.waitEnter(WAIT_TEXT);
     try {
         await runInteractive(deps, progress, ["--cloud", verifyPrompt({ branch, pr: pushed.pr })], worktree);
     }
     catch (err) {
-        deps.print(`${OUTPUT_PREFIX}claude --cloud failed: ${message(err)}; run ${RESUME_COMMAND} in ${worktree} to try again`);
+        deps.print(`${OUTPUT_PREFIX}falló claude --cloud: ${message(err)}; corre ${RESUME_COMMAND} en ${worktree} para reintentar`);
         return EXIT_FAIL;
     }
-    deps.print(`${OUTPUT_PREFIX}the cloud session will report back as a push to ${branch} and a comment on the PR`);
+    deps.print(`${OUTPUT_PREFIX}la sesión cloud avisará con un push a ${branch} y un comentario en el PR`);
+    return EXIT_OK;
+}
+/**
+ * Asks where to work, with the same options as agent-kitchen.
+ *
+ * @param gitRoot - Git root.
+ * @param deps - Dependencies.
+ * @returns The place, or null when cancelled.
+ * @example
+ * await askPlace("/home/u/app", deps); // "pr"
+ */
+async function askPlace(gitRoot, deps) {
+    return deps.choose(PLACE_QUESTION, [
+        { value: "pr", label: "En un PR nuevo", hint: `recomendado · parte de origin/${defaultBranch(gitRoot)}, no toca tu rama ni tus archivos` },
+        { value: "here", label: "En la rama actual, sin commit", hint: `los revisas con git diff, haces commit y push, y luego corres ${VERIFY_COMMAND}` },
+    ], "pr");
+}
+/**
+ * The "current branch" place: installs the kit, runs the local agent and writes the manual in the
+ * checkout, without committing. The cloud verification comes later, with `verify`, once pushed.
+ *
+ * @param gitRoot - Git root (the current checkout).
+ * @param deps - Dependencies.
+ * @param progress - Marks the checkout as changed.
+ * @returns The exit code.
+ * @example
+ * await prepareHere("/home/u/app", deps, {}); // 0
+ */
+async function prepareHere(gitRoot, deps, progress) {
+    progress.here = true;
+    const stopped = `${OUTPUT_PREFIX}prepare se detuvo; lo que alcanzó a cambiar quedó sin commit en tu rama`;
+    try {
+        const result = init(gitRoot, deps.packageVersion, deps.packageRoot);
+        for (const line of result.lines)
+            deps.print(line);
+        if (!result.ok) {
+            deps.print(stopped);
+            return EXIT_FAIL;
+        }
+    }
+    catch (err) {
+        deps.print(`${OUTPUT_PREFIX}${message(err)}`);
+        deps.print(stopped);
+        return EXIT_FAIL;
+    }
+    deps.print(EXIT_CLAUDE_HINT_HERE);
+    try {
+        await runInteractive(deps, progress, [configurePrompt()], gitRoot);
+    }
+    catch {
+        deps.print(stopped);
+        return EXIT_FAIL;
+    }
+    const problem = configureProblem(gitRoot);
+    if (problem !== undefined) {
+        deps.print(`${OUTPUT_PREFIX}configure no terminó: ${problem}; corre claude "/cloud-ready configure" y luego prepare otra vez`);
+        return EXIT_FAIL;
+    }
+    try {
+        writeManual(gitRoot, deps.packageVersion);
+    }
+    catch (err) {
+        deps.print(`${OUTPUT_PREFIX}no se pudo escribir ${MANUAL_FILE}: ${message(err)}`);
+        return EXIT_FAIL;
+    }
+    const config = readConfig(gitRoot).config;
+    if (config)
+        deps.print(renderEnvironmentSection(config, deps.packageVersion));
+    deps.print(`${OUTPUT_PREFIX}listo, sin commit. Revisa los cambios con git diff, haz commit y push, configura el entorno en claude.ai (${MANUAL_FILE}) y corre ${VERIFY_COMMAND}`);
+    return EXIT_OK;
+}
+/**
+ * Launches the cloud verification of the current branch: checks that the preparation is there
+ * and pushed (the cloud only sees origin), then starts `claude --cloud` with `cloud-ready verify`.
+ *
+ * @param repo - Folder where the user runs `verify`.
+ * @param deps - Dependencies (`ask`, `choose`, `waitEnter` and `today` are not used).
+ * @returns 0 when the cloud session was started, 1 otherwise.
+ * @example
+ * process.exitCode = await verifyBranch(process.cwd(), deps);
+ */
+export async function verifyBranch(repo, deps) {
+    const gitRoot = await tryCapture(deps, "git", ["rev-parse", "--show-toplevel"], repo);
+    const cwd = gitRoot ?? repo;
+    const hasOrigin = (await tryCapture(deps, "git", ["remote", "get-url", "origin"], cwd)) !== undefined;
+    const claudeHelp = await tryCapture(deps, "claude", ["--help"], cwd);
+    const problems = preflight({ isTty: deps.isTty, gitRoot, hasOrigin, claudeHelp }, "verify");
+    if (problems.length || gitRoot === undefined) {
+        for (const problem of problems)
+            deps.print(`${OUTPUT_PREFIX}${problem}`);
+        return EXIT_FAIL;
+    }
+    const branch = await tryCapture(deps, "git", ["rev-parse", "--abbrev-ref", "HEAD"], gitRoot);
+    if (branch === undefined || branch === "HEAD") {
+        deps.print(`${OUTPUT_PREFIX}no estás en una rama; cámbiate a la rama que quieres verificar`);
+        return EXIT_FAIL;
+    }
+    const problem = configureProblem(gitRoot);
+    if (problem !== undefined) {
+        deps.print(`${OUTPUT_PREFIX}el repo no está preparado (${problem}); corre npx ${PACKAGE} prepare primero`);
+        return EXIT_FAIL;
+    }
+    const notes = readConfig(gitRoot).config?.notes ?? DEFAULT_NOTES_FILE;
+    const files = [CONFIG_FILE, MANUAL_FILE, notes].filter((path) => entryExists(join(gitRoot, path)));
+    const dirty = await tryCapture(deps, "git", ["status", "--porcelain", "--", ...files], gitRoot);
+    if (dirty) {
+        deps.print(`${OUTPUT_PREFIX}hay cambios sin commit en la preparación; haz commit y push: la nube solo ve lo que está en origin`);
+        return EXIT_FAIL;
+    }
+    const head = await tryCapture(deps, "git", ["rev-parse", "HEAD"], gitRoot);
+    const remote = (await tryCapture(deps, "git", ["ls-remote", "origin", `refs/heads/${branch}`], gitRoot))?.split(/\s/)[0];
+    if (!head || remote !== head) {
+        deps.print(`${OUTPUT_PREFIX}la rama ${branch} no está subida o tiene commits sin subir; haz git push y vuelve a correr verify`);
+        return EXIT_FAIL;
+    }
+    const found = await tryCapture(deps, "gh", ["pr", "view", branch, "--json", "number", "--jq", ".number"], gitRoot);
+    const pr = found !== undefined && PR_NUMBER.test(found) ? found : undefined;
+    const progress = {};
+    const stop = deps.onInterrupt?.(() => !progress.childOwnsTerminal);
+    try {
+        await runInteractive(deps, progress, ["--cloud", verifyPrompt({ branch, pr })], gitRoot);
+    }
+    catch (err) {
+        deps.print(`${OUTPUT_PREFIX}falló claude --cloud: ${message(err)}`);
+        return EXIT_FAIL;
+    }
+    finally {
+        stop?.();
+    }
+    deps.print(`${OUTPUT_PREFIX}la sesión cloud avisará con un push a ${branch}${pr ? " y un comentario en el PR" : ""}`);
     return EXIT_OK;
 }