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

package/dist/init.js

@@ -5,6 +5,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { CONFIG_FILE, OUTPUT_PREFIX, PACKAGE } from "./constants.js";
+import { t } from "./messages/index.js";
 import { installSkill, linkSkill } from "./skill.js";
 /** Path of the Claude Code settings file, relative to the repo root. */
 const SETTINGS_FILE = ".claude/settings.json";
@@ -35,8 +36,8 @@ function isRecord(value) {
  * @returns The failed outcome.
  */
 function addByHand(reason) {
-    const entry = JSON.stringify({ hooks: [HOOK] });
-    return { line: `${SETTINGS_FILE} ${reason}; no se tocó. Agrega esta entrada a hooks.SessionStart a mano: ${entry}`, ok: false };
+    const hook = JSON.stringify({ hooks: [HOOK] });
+    return { entry: { kind: "warn", text: t().init.byHand(SETTINGS_FILE, reason, hook) }, ok: false };
 }
 /**
  * Writes a JSON file with a trailing newline, creating its folder.
@@ -70,7 +71,7 @@ function hasHook(entries) {
 function scaffoldConfig(repo, packageVersion) {
     const file = join(repo, CONFIG_FILE);
     if (existsSync(file))
-        return `${CONFIG_FILE} ya existe; se dejó como estaba`;
+        return { kind: "same", text: t().init.configExists(CONFIG_FILE) };
     writeJson(file, {
         $schema: `https://unpkg.com/${PACKAGE}@${packageVersion}/schema.json`,
         version: packageVersion,
@@ -82,7 +83,7 @@ function scaffoldConfig(repo, packageVersion) {
         requiredEnv: [],
         domains: [],
     });
-    return `se creó ${CONFIG_FILE}`;
+    return { kind: "ok", text: t().init.configCreated(CONFIG_FILE) };
 }
 /**
  * Adds the SessionStart hook to `.claude/settings.json`, keeping everything else.
@@ -98,21 +99,21 @@ function registerHook(repo) {
             settings = JSON.parse(readFileSync(file, "utf8"));
         }
         catch {
-            return addByHand("no es JSON válido");
+            return addByHand(t().init.notJson);
         }
     }
     if (!isRecord(settings))
-        return addByHand("no es un objeto JSON");
+        return addByHand(t().init.notObject);
     const hooks = settings.hooks ?? {};
     if (!isRecord(hooks))
-        return addByHand('tiene un "hooks" que no es un objeto');
+        return addByHand(t().init.hooksNotObject);
     const entries = hooks.SessionStart ?? [];
     if (!Array.isArray(entries))
-        return addByHand('tiene un "hooks.SessionStart" que no es un arreglo');
+        return addByHand(t().init.sessionStartNotArray);
     if (hasHook(entries))
-        return { line: `${SETTINGS_FILE} ya tiene el hook SessionStart`, ok: true };
+        return { entry: { kind: "same", text: t().init.hookExists(SETTINGS_FILE) }, ok: true };
     writeJson(file, { ...settings, hooks: { ...hooks, SessionStart: [...entries, { hooks: [HOOK] }] } });
-    return { line: `se agregó el hook SessionStart a ${SETTINGS_FILE}`, ok: true };
+    return { entry: { kind: "ok", text: t().init.hookAdded(SETTINGS_FILE) }, ok: true };
 }
 /**
  * Sets a repo up for agent-cloud-kit; safe to run again. It is the only place that copies the
@@ -131,6 +132,6 @@ export function init(repo, packageVersion, packageRoot) {
     const hook = registerHook(repo);
     const skill = installSkill(repo, packageRoot, packageVersion);
     const link = linkSkill(repo);
-    const lines = [config, hook.line, skill, ...(link ? [link] : [])];
-    return { lines: lines.map((l) => OUTPUT_PREFIX + l), ok: hook.ok };
+    const entries = [config, hook.entry, skill, ...(link ? [{ kind: "ok", text: link }] : [])];
+    return { lines: entries.map((e) => OUTPUT_PREFIX + e.text), entries, ok: hook.ok };
 }

package/dist/installers.js

@@ -7,6 +7,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { TOOL_INSTALL_TIMEOUT_MS } from "./constants.js";
 import { TOOLS } from "./detect.js";
+import { t } from "./messages/index.js";
 import { step } from "./steps.js";
 /** Base URL of the Node.js distribution. */
 const NODE_DIST_URL = "https://nodejs.org/dist";
@@ -123,7 +124,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} no aparece en ${NODE_SHASUMS_FILE}`);
+        throw new Error(t().installers.notInShasums(file, NODE_SHASUMS_FILE));
     return hash;
 }
 /**
@@ -138,7 +139,7 @@ async function nodeExpectedHash(run, env, dir, version, file) {
 export function nodeArch(arch) {
     const mapped = NODE_ARCHS[arch];
     if (!mapped)
-        throw new Error(`arquitectura no soportada para node: ${arch}`);
+        throw new Error(t().installers.unsupportedArch(arch));
     return mapped;
 }
 /**
@@ -153,7 +154,7 @@ export function nodeArch(arch) {
  */
 export function assertVersion(tool, version) {
     if (!VERSION_PATTERN.test(version))
-        throw new Error(`versión inválida para ${tool}: ${version}`);
+        throw new Error(t().installers.invalidVersion(tool, version));
 }
 /**
  * Tells whether a version is safe to use.
@@ -254,7 +255,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("el índice de versiones de node no es una lista");
+                throw new Error(t().installers.indexNotList);
             return parsed.filter((r) => typeof r === "object" && r !== null && typeof r.version === "string" && (r.lts === false || typeof r.lts === "string"));
         }
         finally {
@@ -283,7 +284,7 @@ export async function resolveVersions(versions, fetchIndex) {
     const result = await step(`node ${requested}`, async () => {
         exact = resolveNodeVersion(requested, await fetchIndex());
         if (!exact)
-            throw new Error(`ninguna versión de node coincide con ${requested}`);
+            throw new Error(t().installers.noNodeMatch(requested));
     });
     if (!exact)
         return { resolved, results: [result] };
@@ -403,7 +404,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} debe resolverse primero a una versión exacta`);
+                throw new Error(t().installers.nodeMustResolve(version));
             }));
             continue;
         }

package/dist/lang.js

@@ -0,0 +1,84 @@
+/**
+ * @file The language of the terminal: `--lang`, then `AGENT_CLOUD_KIT_LANG`, then Spanish.
+ * `LANG` and `LC_ALL` are not read: on macOS they are often `en_US.UTF-8` for Spanish speakers.
+ */
+/** Environment variable that fixes the language. */
+export const LANG_ENV = "AGENT_CLOUD_KIT_LANG";
+/** Option that picks the language for one run. */
+export const LANG_OPTION = "--lang";
+/** A `--lang` or `AGENT_CLOUD_KIT_LANG` value that is neither `es` nor `en`. */
+export class LangError extends Error {
+    /** Where the value came from: `--lang` or `AGENT_CLOUD_KIT_LANG`. */
+    source;
+    /** The value. */
+    value;
+    /**
+     * Builds the error.
+     *
+     * @param source - Where the value came from.
+     * @param value - The value.
+     */
+    constructor(source, value) {
+        super(`${source}: ${value}`);
+        this.name = "LangError";
+        this.source = source;
+        this.value = value;
+    }
+}
+/**
+ * Tells whether a value is a language.
+ *
+ * @param value - The value.
+ * @returns True for `es` and `en`.
+ */
+function isLang(value) {
+    return value === "es" || value === "en";
+}
+/**
+ * The language of the terminal.
+ *
+ * @param flag - The `--lang` value, or undefined.
+ * @param env - The environment.
+ * @returns The flag, else `AGENT_CLOUD_KIT_LANG` (empty counts as unset), else `es`.
+ * @throws LangError when the value is neither `es` nor `en`.
+ * @example
+ * resolveLang(undefined, { AGENT_CLOUD_KIT_LANG: "en" }); // "en"
+ */
+export function resolveLang(flag, env) {
+    const fromEnv = env[LANG_ENV]?.trim() ? env[LANG_ENV] : undefined;
+    const value = flag ?? fromEnv;
+    if (value === undefined)
+        return "es";
+    const lang = value.trim().toLowerCase();
+    if (!isLang(lang))
+        throw new LangError(flag !== undefined ? LANG_OPTION : LANG_ENV, value);
+    return lang;
+}
+/**
+ * Takes `--lang <x>` or `--lang=<x>` out of the arguments, wherever it is.
+ *
+ * @param argv - Arguments after the executable name.
+ * @returns The other arguments and the value (empty string when `--lang` has no value).
+ * @example
+ * splitLang(["doctor", "--lang", "en"]); // { args: ["doctor"], flag: "en" }
+ */
+export function splitLang(argv) {
+    const args = [];
+    let flag;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === LANG_OPTION) {
+            const next = argv[i + 1];
+            flag = next !== undefined && !next.startsWith("-") ? next : "";
+            if (flag)
+                i++;
+        }
+        else if (arg.startsWith(`${LANG_OPTION}=`)) {
+            flag = arg.slice(LANG_OPTION.length + 1);
+        }
+        else {
+            args.push(arg);
+        }
+    }
+    return flag === undefined ? { args } : { args, flag };
+}

package/dist/launcher.js

@@ -5,6 +5,7 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { CONFIG_FILE, PACKAGE } from "./constants.js";
+import { t } from "./messages/index.js";
 /** Directory, inside the tools dir, that holds one installed copy of this package per version. */
 const PKG_DIR = "pkg";
 /** Name of the CLI executable. */
@@ -58,7 +59,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 hay ${CONFIG_FILE}` };
+            return { repo, action: "skip", reason: errors.length ? errors.join("; ") : t().config.missing(CONFIG_FILE) };
         if (config.version === current)
             return { repo, action: "run", version: current };
         return { repo, action: "relaunch", version: config.version };

package/dist/manual.js

@@ -6,6 +6,7 @@ import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync,
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { readConfig } from "./config.js";
 import { CONFIG_FILE, PACKAGE, packageSpec } from "./constants.js";
+import { es, t } from "./messages/index.js";
 /** Path of the manual, relative to the repo. */
 export const MANUAL_FILE = "docs/agent-cloud.md";
 /** Marker that opens the generated block. */
@@ -60,35 +61,43 @@ function allowedHosts(config) {
     return [...new Set([...config.domains, ...hosts])].sort();
 }
 /**
- * Renders the "Configurar el entorno en claude.ai" section.
+ * Renders the "Configurar el entorno en claude.ai" section: in Spanish for the manual, in the
+ * language of the terminal when `prepare` shows it.
  *
  * @param config - Repo config.
  * @param packageVersion - Version of the running package, for the setup script.
+ * @param text - Texts of the section; Spanish when omitted.
  * @returns The section, without a trailing newline.
  * @example
  * renderEnvironmentSection(config, "1.0.0").startsWith("## Configurar el entorno en claude.ai"); // true
  */
-export function renderEnvironmentSection(config, packageVersion) {
+export function renderEnvironmentSection(config, packageVersion, text = es.environment) {
     const hosts = allowedHosts(config);
     const code = (items) => items.map((item) => `\`${item}\``).join(", ");
     const lines = [
-        "## Configurar el entorno en claude.ai",
+        text.title,
         "",
-        "Elige el entorno con `/remote-env` y edítalo en claude.ai/code:",
+        text.intro,
         "",
-        `- **Network access:** Custom y marca "Also include default list of common package managers". Dominios extra: ${hosts.length ? code(hosts) : "ninguno"}.`,
-        `- **Variables:** ${config.requiredEnv.length ? `${code(config.requiredEnv)} (solo los nombres; los valores los pones tú)` : "ninguna"}.`,
-        "- **Claude GitHub App:** instalado en el repo, o la sesión no puede pushear.",
-        "- **Setup script:**",
+        text.network(hosts.length ? code(hosts) : text.none),
+        text.variables(config.requiredEnv.length ? text.namesOnly(code(config.requiredEnv)) : text.noneVariables),
+        text.githubApp,
+        text.setupScript,
         "",
         "```bash",
         setupScript(packageVersion),
         "```",
     ];
     if (config.requiredEnv.length)
-        lines.push("", "> ⚠️ Quien use el entorno puede leer las variables, y no llegan al setup script (solo a la sesión).");
+        lines.push("", text.variablesWarning);
     return lines.join("\n");
 }
+/** What to do when the tests change, one line. */
+const TESTS_CHANGE_SECTION = [
+    "## Si cambian los tests",
+    "",
+    `Si agregas tests (p. ej. de Electron) o cambias cómo se corren, corre \`npx ${PACKAGE} prepare\`: la skill \`cloud-ready\` los adapta a la nube sin cambiar lo que comprueban y actualiza este documento.`,
+].join("\n");
 /** The "how to verify" section, one line. */
 const VERIFY_SECTION = [
     "## Verificar",
@@ -143,6 +152,7 @@ export function renderManual(input) {
         renderEnvironmentSection(input.config, input.packageVersion),
         VERIFY_SECTION,
         `## Qué corre en la nube\n\n${notes?.trim() ? notes.trim() : "Nada anotado."}`,
+        TESTS_CHANGE_SECTION,
         END,
     ];
     return parts.join("\n\n");
@@ -179,7 +189,7 @@ export function mergeManual(existing, block) {
 export function writeManual(repo, packageVersion) {
     const { config, errors } = readConfig(repo);
     if (!config)
-        throw new Error(errors[0] ?? `no existe ${CONFIG_FILE}; corre init primero`);
+        throw new Error(errors[0] ?? t().manual.noConfig(CONFIG_FILE));
     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/messages/en.js

@@ -0,0 +1,226 @@
+/** Command that continues a prepare run. */
+const RESUME = "npx agent-cloud-kit prepare --resume";
+/** Command that launches the cloud verification. */
+const VERIFY = "npx agent-cloud-kit verify";
+export const en = {
+    help: `agent-cloud-kit: prepares repos for Claude Code cloud sessions.
+
+Usage: agent-cloud-kit <command> [--lang es|en]
+
+Commands:
+  setup [--repo <path>]  prepares the machine for every repo in the home dir (or only <path>)
+  session                reports the machine state and wires the tools into the session
+  docker                 starts the Docker daemon and waits until it answers
+  doctor                 checks the allowed domains, the tools, Docker and the machine state
+  init                   creates .claude/cloud.json and registers the SessionStart hook
+  manual                 writes docs/agent-cloud.md from .claude/cloud.json
+  prepare [--pr|--here|--resume]
+                         runs locally: gets the repo ready for the cloud, in a new PR (--pr) or on the
+                         current branch without committing (--here); with no option, it asks where
+  verify                 runs locally: starts a cloud session that verifies the current branch (already pushed)
+
+Options:
+  --lang es|en           language of the messages (Spanish by default; AGENT_CLOUD_KIT_LANG=es|en sets it)
+  --help                 shows this help
+  --version              shows the package version
+`,
+    lang: {
+        invalid: (source, value) => `${source} expects es or en: ${value}`,
+    },
+    cli: {
+        versionMismatch: (running, file, pinned) => `running version ${running}, although ${file} asks for ${pinned}`,
+        setupSummary: (repo, steps, failed, names) => `setup ${repo}: ${steps} steps, ${failed} failed${names.length ? ` (${names.join(", ")})` : ""}`,
+        skip: (repo, reason) => `skipping ${repo}: ${reason}`,
+        relaunching: (version, repo) => `relaunching with version ${version} for ${repo}`,
+        relaunchFailed: (version, repo, error) => `relaunching with version ${version} for ${repo} failed: ${error}`,
+        repoNeedsPath: (option) => `${option} needs a path`,
+        noRepos: (home) => `no repos found in ${home}`,
+        setupErrorFor: (repo, error) => `setup error in ${repo}: ${error}`,
+        setupError: (error) => `setup error: ${error}`,
+        sessionDelegateFailed: (version, error) => `session with version ${version} failed: ${error}`,
+        manualWritten: (file) => `wrote ${file}`,
+        unknownOption: (command, options) => `unknown option for ${command}: ${options}`,
+        onlyOne: (options) => `use only one of ${options}`,
+    },
+    config: {
+        dockerNotObject: '"docker" must be an object',
+        unknownField: (key) => `unknown field "${key}"`,
+        badPull: '"docker.pull" must be "auto", false or an array of strings',
+        notStringList: (key) => `"${key}" must be an array of strings`,
+        badHost: (host) => `"domains" has an invalid host: ${host}`,
+        badVersion: '"version" must be an exact semver, like "1.0.0"',
+        notesNotString: '"notes" must be a string',
+        unreadable: (reason) => `could not read the file: ${reason}`,
+        notObject: "must contain a JSON object",
+        missing: (file) => `no ${file}`,
+    },
+    run: {
+        timedOut: (cmd, ms) => `${cmd} went over the ${ms}ms limit`,
+        exitCode: (cmd, code) => `${cmd} exited with code ${code}`,
+        exitSignal: (cmd, signal) => `${cmd} was ended by signal ${signal}`,
+    },
+    docker: {
+        missing: "dockerd is not installed",
+        didNotStart: (log) => `dockerd did not start; check ${log}`,
+    },
+    doctor: {
+        domain: (host, ok) => `network ${host}: ${ok ? "ok" : "blocked"}`,
+        toolInvalid: (tool, version) => `tool ${tool} ${version}: invalid version`,
+        toolUnresolved: (tool, version) => `tool ${tool} ${version}: unresolved (setup did not install it)`,
+        tool: (tool, version, present) => `tool ${tool} ${version}: ${present ? "ok" : "missing"}`,
+        fileMissing: (file) => `${file}: missing`,
+        stateMissing: "state: missing (setup did not run)",
+        fingerprint: (same) => `fingerprint: ${same ? "ok" : "different"}`,
+        step: (name, ok, seconds) => `step ${name}: ${ok ? "ok" : "failed"} (${seconds}s)`,
+        docker: (ok) => `docker: ${ok ? "ok" : "missing"}`,
+        plugin: (name) => `warning: the plugin ${name} is enabled but is not in the repo; it will not reach the cloud (copy its skills with skills-manager)`,
+        skill: (dir, installed, version) => `warning: ${dir} is at ${installed} and the package at ${version}; run npx agent-cloud-kit@${version} init`,
+        groupError: (group, error) => `${group}: error: ${error}`,
+        groups: { network: "network", tools: "tools", docker: "docker", state: "state", plugins: "plugins", skill: "skill" },
+        allOk: "All good",
+        someFailed: (failed, total) => (failed === 1 ? `1 of ${total} checks failed` : `${failed} of ${total} checks failed`),
+        warnings: (count) => (count === 1 ? "1 warning" : `${count} warnings`),
+        failedHint: "look at the lines with missing, blocked or failed",
+    },
+    session: {
+        genericNote: "you are in a Claude Code cloud session. There are no open ports or previews: test against localhost. gh pr and gh issue fail (the GitHub proxy blocks GraphQL): use gh api (REST).",
+        setupNotRun: (repo, spec) => `the environment setup did not run for ${repo}. Set this as the environment setup script in claude.ai: npx -y ${spec} setup`,
+        setupFailed: (names) => `setup failed: ${names.join(", ")}. Run agent-cloud-kit doctor.`,
+        otherConfig: "the machine was prepared with another configuration. Edit the setup script field in claude.ai (any change) so it is rebuilt.",
+        slow: (time) => `setup took ${time}, close to the ~5 minute limit.`,
+        envFileFailed: (variable, file, error) => `could not write ${variable} (${file}): ${error}`,
+        stepTimedOut: (command) => `the session step went over the time limit: ${command}`,
+        stepFailed: (command) => `the session step failed: ${command}`,
+        missingEnv: (names) => `missing environment variables: ${names.join(", ")}`,
+        dockerFailed: (problem) => `could not start dockerd: ${problem}`,
+        error: (error) => `session error: ${error}`,
+    },
+    setup: {
+        aptRepoHttps: (prefix) => `the apt repo must be an ${prefix} URL`,
+        badDebianName: "invalid Debian package name",
+        badImage: "invalid image reference",
+        packageMismatch: (source, found, version) => `the package in ${source} is ${found ?? "unknown"}, not ${version}`,
+        noConfig: "no configuration",
+    },
+    steps: {
+        aptRepo: (url) => `apt repo ${url}`,
+        aptPackage: (name) => `apt package ${name}`,
+        selfInstall: (version) => `self install ${version}`,
+        writeState: "write state",
+        lane: (index) => `lane ${index}`,
+        config: "config",
+    },
+    installers: {
+        notInShasums: (file, shasums) => `${file} is not in ${shasums}`,
+        unsupportedArch: (arch) => `unsupported architecture for node: ${arch}`,
+        invalidVersion: (tool, version) => `invalid version for ${tool}: ${version}`,
+        indexNotList: "the node version index is not a list",
+        noNodeMatch: (requested) => `no node version matches ${requested}`,
+        nodeMustResolve: (version) => `node ${version} must first resolve to an exact version`,
+    },
+    init: {
+        byHand: (file, reason, entry) => `${file} ${reason}; it was left untouched. Add this entry to hooks.SessionStart by hand: ${entry}`,
+        notJson: "is not valid JSON",
+        notObject: "is not a JSON object",
+        hooksNotObject: 'has a "hooks" that is not an object',
+        sessionStartNotArray: 'has a "hooks.SessionStart" that is not an array',
+        configExists: (file) => `${file} already exists; left as it was`,
+        configCreated: (file) => `created ${file}`,
+        hookExists: (file) => `${file} already has the SessionStart hook`,
+        hookAdded: (file) => `added the SessionStart hook to ${file}`,
+    },
+    skill: {
+        current: (dir, version) => `${dir} is already at ${version}`,
+        missing: (path, root) => `${path}/SKILL.md not found in ${root}`,
+        installed: (dir, version) => `installed ${dir} ${version}`,
+        updated: (dir, from, to) => `updated ${dir} from ${from} to ${to}`,
+        linked: (link, dir) => `linked ${link} to ${dir}`,
+    },
+    manual: {
+        noConfig: (file) => `${file} does not exist; run init first`,
+    },
+    environment: {
+        title: "## Configure the environment in claude.ai",
+        intro: "Pick the environment with `/remote-env` and edit it in claude.ai/code:",
+        network: (hosts) => `- **Network access:** Limited (Custom) with "Also include default list of common package managers" turned on. Extra domains: ${hosts}.`,
+        variables: (names) => `- **Variables:** ${names}.`,
+        namesOnly: (names) => `${names} (only the names; you fill in the values)`,
+        none: "none",
+        noneVariables: "none",
+        githubApp: "- **Claude GitHub App:** installed on the repo, or the session cannot push.",
+        setupScript: "- **Setup script:**",
+        variablesWarning: "> ⚠️ Anyone who uses the environment can read the variables, and they do not reach the setup script (only the session).",
+    },
+    menu: {
+        cancelled: "Cancelled",
+    },
+    preflight: {
+        noTty: (command) => `${command} needs an interactive terminal (run the command directly in your terminal)`,
+        noGit: (command) => `this is not a git repository; run ${command} inside the repo`,
+        noOrigin: (command) => `the repository has no 'origin' remote; ${command} needs to push a branch to GitHub`,
+        noClaude: (command) => `claude is not installed or not on the PATH; install Claude Code and run ${command} again`,
+        noCloud: (command) => `your claude version does not support --cloud; update Claude Code and run ${command} again`,
+    },
+    banner: {
+        title: "Claude Code opens now",
+        subtitle: "with the cloud-ready skill",
+        step1: "Claude reviews the repo and proposes how to get it ready for the cloud",
+        step2: "Answer its questions",
+        step3: (done, exit, after) => `When it says ${done}, leave with ${exit} ${after}`,
+        configureDone: "configure finished",
+        afterPr: "→ prepare commits, pushes and opens a PR",
+        afterHere: "→ the changes stay uncommitted",
+        free: (script) => `It opens with ${script} (no sandbox nor permission prompts): the repo uses claude-repo-guard`,
+        enter: "opens Claude Code",
+        cancel: "· Ctrl+C cancels",
+        continue: "once you have configured the environment in claude.ai",
+        continueHint: "· opens the cloud session that verifies it",
+    },
+    prepare: {
+        interrupted: "interrupted",
+        resume: (reason, worktree) => `${reason}; the worktree is at ${worktree}; run ${RESUME} there to continue`,
+        noConfig: (file) => `${file} does not exist`,
+        noNotes: (file) => `the notes file ${file} does not exist`,
+        worktreeExists: (worktree) => `${worktree} already exists; remove it (git worktree remove ${worktree}) or continue there with ${RESUME}`,
+        branchExists: (branch) => `the branch ${branch} already exists; delete it (git branch -D ${branch}) or run prepare another day`,
+        worktreeCreated: (worktree, branch) => `created the worktree ${worktree} on the branch ${branch}`,
+        worktreeFailed: (error) => `could not create the worktree: ${error}`,
+        agentStopped: "the local agent stopped",
+        prepareStopped: "prepare stopped",
+        configureUnfinished: (problem) => `configure did not finish: ${problem}`,
+        otherChanges: "the local agent also changed:",
+        includeQuestion: "Include these changes in the commit? [y/N]",
+        leftUncommitted: (worktree) => `left uncommitted in ${worktree}`,
+        nothingToCommit: "nothing new to commit",
+        pushed: (branch) => `pushed the branch ${branch}`,
+        pushFailed: (error, worktree) => `could not commit and push: ${error}; fix it in ${worktree} and run ${RESUME} there`,
+        prReused: (pr) => `reusing the open PR #${pr}`,
+        prDraft: (url) => `draft PR: ${url}`,
+        prByHand: (link, branch) => `could not open the PR with gh; open it by hand${link ? `: ${link}` : ` from the branch ${branch}`}`,
+        interruptedHere: "interrupted; whatever changed is left uncommitted on your branch",
+        interruptedNothing: "interrupted; nothing was created",
+        nothingToResume: (suffix, prefix) => `nothing to resume: run prepare --resume in the *${suffix} worktree, on a ${prefix}* branch`,
+        resumeUnfinished: (worktree, problem) => `configure did not finish in ${worktree}: ${problem}; run claude "/cloud-ready configure" there first and then ${RESUME}`,
+        nothingChanged: "nothing was changed",
+        cloudFailedResume: (error, worktree) => `claude --cloud failed: ${error}; run ${RESUME} in ${worktree} to try again`,
+        placeQuestion: "Where do I prepare the repo?",
+        placePr: "In a new PR",
+        placePrHint: (base) => `recommended · starts from origin/${base}, does not touch your branch or your files`,
+        placeHere: "On the current branch, without committing",
+        placeHereHint: `you review them with git diff, commit and push, and then run ${VERIFY}`,
+        stoppedHere: "prepare stopped; whatever changed is left uncommitted on your branch",
+        hereUnfinished: (problem) => `configure did not finish: ${problem}; run claude "/cloud-ready configure" and then prepare again`,
+        manualFailed: (file, error) => `could not write ${file}: ${error}`,
+        hereTitle: "Done, without committing",
+        hereSteps: (manual) => ["Review the changes with git diff", "Commit and push", `Configure the environment in claude.ai (${manual})`, `Run ${VERIFY}`],
+        noBranch: "you are not on a branch; switch to the branch you want to verify",
+        notPrepared: (problem) => `the repo is not prepared (${problem}); run npx agent-cloud-kit prepare first`,
+        dirty: "the preparation has uncommitted changes; commit and push: the cloud only sees what is on origin",
+        notPushed: (branch) => `the branch ${branch} is not pushed or has unpushed commits; run git push and run verify again`,
+        cloudFailed: (error) => `claude --cloud failed: ${error}`,
+        cloudStarted: "The cloud session is running",
+        cloudWillReport: (branch, pr) => `the cloud session will report with a push to ${branch}${pr ? " and a comment on the PR" : ""}`,
+        rowBranch: "Branch",
+        rowPr: "PR",
+    },
+};