agent-kitchen 0.8.0 → 0.10.0

package/dist/piece.js

@@ -1,6 +1,6 @@
 /**
  * @file What agent-kitchen knows of each piece it manages, and the names they share. A piece
- * (the version of skills-manager, the issue flow, claude-cloud, claude-repo-guard, the
+ * (the version of skills-manager, the issue flow, agent-cloud-kit, claude-repo-guard, the
  * skills, the rule in AGENTS.md) tells what the repo has and the steps that would install or
  * update it; agent-kitchen shows them, lets the person pick, and runs the picked ones in
  * order. Every step runs the piece's own tool, which owns its files: agent-kitchen only

package/dist/pieces/cloud.d.ts

@@ -1,17 +1,18 @@
 /**
- * @file Claude cloud sessions (`@ramon-sg/claude-cloud`). The repo's version is the one
+ * @file Claude cloud sessions (`agent-cloud-kit`). The repo's version is the one
  * `.claude/cloud.json` pins: the cloud machine runs exactly that one. Installing runs its
- * `init`; updating only moves that version (and a `$schema` pinned to a version), which is
- * how `claude-cloud` updates. Outside
- * the cloud its hook does nothing, so a repo nobody opens in the cloud loses nothing.
+ * `init`; updating moves that version (and a `$schema` pinned to a version) and then runs the
+ * new version's `init`, so the `cloud-ready` skill copied into the repo matches it (`init` is
+ * idempotent: it adds no second hook and keeps `.claude/cloud.json`). Outside the cloud its
+ * hook does nothing, so a repo nobody opens in the cloud loses nothing.
  */
 import type { Check, PieceStatus } from "../piece.js";
 /** The piece's name, as `--skip` takes it. */
-export declare const NAME = "claude-cloud";
+export declare const NAME = "agent-cloud-kit";
 /** The package on npm. */
-export declare const PACKAGE = "@ramon-sg/claude-cloud";
+export declare const PACKAGE = "agent-cloud-kit";
 /**
- * What the repo has of claude-cloud, and the step it needs.
+ * What the repo has of agent-cloud-kit, and the step it needs.
  * @param root - The repo.
  * @returns The piece's status.
  * @example (await cloudStatus(root)).state // "1.0.0, al día"

package/dist/pieces/cloud.js

@@ -1,18 +1,18 @@
 import { readJson, writeJson } from "../repo.js";
-import { compareVersions, isRelease, npmLatest, runNpx } from "../tools.js";
+import { compareSemver, isExactVersion, npmLatestExact, runNpx } from "../tools.js";
 /** The piece's name, as `--skip` takes it. */
-export const NAME = "claude-cloud";
+export const NAME = "agent-cloud-kit";
 /** The package on npm. */
-export const PACKAGE = "@ramon-sg/claude-cloud";
+export const PACKAGE = "agent-cloud-kit";
 /** Its config in the repo, which pins its version. */
 const CONFIG = ".claude/cloud.json";
 /**
- * The version `.claude/cloud.json` pins.
+ * The version `.claude/cloud.json` pins: exact semver, so a release candidate counts.
  * @param config - The config, or null.
  * @returns The version, or null if it has none.
  */
 function pinned(config) {
-    return typeof config?.version === "string" && isRelease(config.version) ? config.version : null;
+    return typeof config?.version === "string" && isExactVersion(config.version) ? config.version : null;
 }
 /**
  * The step the repo needs, if any.
@@ -33,35 +33,40 @@ function stepFor(config, latest) {
                 const run = await runNpx(context.root, [spec, "init"]);
                 if (run.ok)
                     return true;
-                context.fail(`claude-cloud init falló; corre 'npx ${spec} init'.`, run.output);
+                context.fail(`agent-cloud-kit init falló; corre 'npx ${spec} init'.`, run.output);
                 return false;
             },
         };
     }
-    if (latest === null || (version !== null && compareVersions(latest, version) <= 0))
+    if (latest === null || (version !== null && compareSemver(latest, version) <= 0))
         return null;
     return {
         piece: NAME,
         checked: true,
-        downloads: [],
+        downloads: [`${PACKAGE}@${latest}`],
         text: { kind: "cloud-update", from: version, to: latest, config: CONFIG },
         run: async (context) => {
             const current = readJson(context.root, CONFIG) ?? {};
-            const schema = typeof current.$schema === "string" ? current.$schema.replace(/@ramon-sg\/claude-cloud@[^/]+\//, `${PACKAGE}@${latest}/`) : undefined;
+            const schema = typeof current.$schema === "string" ? current.$schema.replace(/\/agent-cloud-kit@[^/]+\//, `/${PACKAGE}@${latest}/`) : undefined;
             writeJson(context.root, CONFIG, { ...current, ...(schema === undefined ? {} : { $schema: schema }), version: latest });
-            return true;
+            const spec = `${PACKAGE}@${latest}`;
+            const run = await runNpx(context.root, [spec, "init"]);
+            if (run.ok)
+                return true;
+            context.fail(`agent-cloud-kit init falló; corre 'npx ${spec} init'.`, run.output);
+            return false;
         },
     };
 }
 /**
- * What the repo has of claude-cloud, and the step it needs.
+ * What the repo has of agent-cloud-kit, and the step it needs.
  * @param root - The repo.
  * @returns The piece's status.
  * @example (await cloudStatus(root)).state // "1.0.0, al día"
  */
 export async function cloudStatus(root) {
     const config = readJson(root, CONFIG);
-    const latest = await npmLatest(PACKAGE);
+    const latest = await npmLatestExact(PACKAGE);
     const version = pinned(config);
     const step = stepFor(config, latest);
     const known = latest === null ? " (npm no responde)" : "";
@@ -79,10 +84,10 @@ export async function cloudChecks(root) {
     if (config === null)
         return [{ name: NAME, status: "info", detail: "no instalado" }];
     const version = pinned(config);
-    const latest = await npmLatest(PACKAGE);
+    const latest = await npmLatestExact(PACKAGE);
     if (version === null)
         return [{ name: NAME, status: "fail", detail: `${CONFIG} no fija una versión exacta: pon en "version" la que se usa, como "${latest ?? "1.0.0"}"` }];
-    if (latest !== null && compareVersions(latest, version) > 0)
+    if (latest !== null && compareSemver(latest, version) > 0)
         return [{ name: NAME, status: "info", detail: `${version}, hay ${latest}: corre npx agent-kitchen apply` }];
     return [{ name: NAME, status: "ok", detail: version }];
 }

package/dist/pr-clone.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The base branch, as issue-flow takes it: `baseBranch` of `.agents/flow.json`, or origin's
+ * default as git knows it, or `main`.
+ * @param root - The repo.
+ * @returns The branch.
+ * @example baseBranch(root) // "main"
+ */
+export declare function baseBranch(root: string): string;
+/**
+ * Origin's URL.
+ * @param root - The repo.
+ * @returns The URL, or null if the repo has no origin.
+ */
+export declare function originUrl(root: string): string | null;
+/**
+ * The files that differ from HEAD, tracked or not, one by one, without the repo's worktrees.
+ * @param root - The repo.
+ * @returns Their paths.
+ * @example changedPaths(root) // ["package.json", "package-lock.json"]
+ */
+export declare function changedPaths(root: string): string[];
+/**
+ * How many commits the current branch is behind its upstream, as the last fetch saw it.
+ * @param root - The repo.
+ * @returns The count, or 0 without an upstream.
+ */
+export declare function behindUpstream(root: string): number;
+/**
+ * The branch for today's changes: a new name, also against origin's branches.
+ * @param root - The repo, just fetched.
+ * @param date - Today.
+ * @returns `chore/agent-kitchen-apply-AAAA-MM-DD`, or with `-2`, `-3`… if taken.
+ * @example branchName(root, new Date()) // "chore/agent-kitchen-apply-2026-11-01"
+ */
+export declare function branchName(root: string, date: Date): string;
+/**
+ * Fetches origin and clones the repo at `origin/<base>` into a temporary folder.
+ * @param root - The repo.
+ * @param base - The base branch.
+ * @returns The clone's folder.
+ * @throws KitError if the repo has no origin, the fetch fails or origin has no such branch.
+ */
+export declare function cloneFromOrigin(root: string, base: string): string;
+/**
+ * Deletes the clone.
+ * @param clone - Its folder.
+ */
+export declare function removeClone(clone: string): void;
+/** What `publish` needs to know. */
+export interface PublishOptions {
+    base: string;
+    steps: string[];
+    paths: string[];
+}
+/**
+ * Commits the clone's changes, pushes them from the repo to a new branch of origin and opens
+ * the PR. Until the push works, the commit lives only in the clone, which the caller keeps.
+ * @param root - The repo.
+ * @param clone - The clone, with the changes.
+ * @param options - The base, the steps that ran (for the commit and the PR) and the files to commit (the ones shown).
+ * @returns The lines to show, whether it all worked and whether the changes reached origin.
+ * @example await publish(root, clone, { base: "main", steps, paths })
+ */
+export declare function publish(root: string, clone: string, options: PublishOptions): Promise<{
+    ok: boolean;
+    pushed: boolean;
+    lines: string[];
+}>;

package/dist/pr-clone.js

@@ -0,0 +1,254 @@
+/**
+ * @file What `apply --pr` does with git. It fetches origin and clones the repo into a temporary
+ * folder at `origin/<base>`, so the steps see what the base has today and the person's checkout
+ * is never touched: not its branch, its files, nor its node_modules. A clone and not a worktree,
+ * because `issue-flow apply` refuses to run in a worktree. The clone shares the repo's objects
+ * (`--shared`), points its origin where the repo's does, and commits with the repo's hooks,
+ * identity and signing. The commit goes from the clone into the repo's objects and the repo
+ * pushes it straight to a new branch of origin, with its own credentials, so no local branch
+ * is made. Then github-rest opens the PR in draft. git runs its hooks; nothing here skips them.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, relative } from "node:path";
+import { COMMIT_TITLE as TITLE, prBody } from "./commit-texts.js";
+import { KitError } from "./output.js";
+import { FLOW_CONFIG } from "./piece.js";
+import { dependencyVersion, readJson } from "./repo.js";
+import { captureNpxWithout, isRelease, npmLatest } from "./tools.js";
+/** github-rest on npm, which opens the PR (REST, never gh's GraphQL). */
+const GITHUB_REST = "@ramon-sg/github-rest";
+/** The settings of the repo a commit made in the clone needs: who signs it and how. */
+const IDENTITY = ["user.name", "user.email", "user.signingkey", "commit.gpgsign", "gpg.format", "gpg.program", "gpg.openpgp.program", "gpg.x509.program", "gpg.ssh.program", "gpg.ssh.allowedsignersfile"];
+/**
+ * Runs git in a folder.
+ * @param cwd - The folder.
+ * @param args - The arguments.
+ * @returns How it went.
+ */
+function git(cwd, args) {
+    const result = spawnSync("git", args, { cwd, encoding: "utf8" });
+    return { ok: result.status === 0, out: (result.stdout ?? "").trimEnd(), err: (result.stderr ?? "").trim() };
+}
+/**
+ * The base branch, as issue-flow takes it: `baseBranch` of `.agents/flow.json`, or origin's
+ * default as git knows it, or `main`.
+ * @param root - The repo.
+ * @returns The branch.
+ * @example baseBranch(root) // "main"
+ */
+export function baseBranch(root) {
+    const flow = readJson(root, FLOW_CONFIG);
+    if (typeof flow?.baseBranch === "string" && flow.baseBranch !== "")
+        return flow.baseBranch;
+    const head = git(root, ["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"]);
+    return head.ok && head.out.startsWith("origin/") ? head.out.slice("origin/".length) : "main";
+}
+/**
+ * Origin's URL.
+ * @param root - The repo.
+ * @returns The URL, or null if the repo has no origin.
+ */
+export function originUrl(root) {
+    const url = git(root, ["remote", "get-url", "origin"]);
+    return url.ok && url.out !== "" ? url.out : null;
+}
+/**
+ * The repo's other worktrees that live inside it, relative to it.
+ * @param root - The repo.
+ * @returns Their folders, like `.claude/worktrees/feat+1-x`.
+ */
+function innerWorktrees(root) {
+    const list = git(root, ["worktree", "list", "--porcelain"]);
+    if (!list.ok)
+        return [];
+    return list.out
+        .split("\n")
+        .filter((line) => line.startsWith("worktree "))
+        .map((line) => relative(root, line.slice("worktree ".length)))
+        .filter((path) => path !== "" && !path.startsWith(".."));
+}
+/**
+ * The files that differ from HEAD, tracked or not, one by one, without the repo's worktrees.
+ * @param root - The repo.
+ * @returns Their paths.
+ * @example changedPaths(root) // ["package.json", "package-lock.json"]
+ */
+export function changedPaths(root) {
+    const status = git(root, ["status", "--porcelain", "-uall", "-z"]);
+    if (!status.ok)
+        throw new KitError(`no pude leer git status: ${status.err}`);
+    const worktrees = innerWorktrees(root);
+    const entries = status.out.split("\0").filter((entry) => entry !== "");
+    const paths = [];
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index] ?? "";
+        if (/[RC]/.test(entry.slice(0, 2)))
+            index += 1;
+        const path = entry.slice(3).replace(/\/$/, "");
+        if (!worktrees.some((tree) => path === tree || path.startsWith(`${tree}/`)))
+            paths.push(path);
+    }
+    return paths;
+}
+/**
+ * How many commits the current branch is behind its upstream, as the last fetch saw it.
+ * @param root - The repo.
+ * @returns The count, or 0 without an upstream.
+ */
+export function behindUpstream(root) {
+    const count = git(root, ["rev-list", "--count", "HEAD..@{upstream}"]);
+    return count.ok ? Number(count.out) || 0 : 0;
+}
+/**
+ * The branch for today's changes: a new name, also against origin's branches.
+ * @param root - The repo, just fetched.
+ * @param date - Today.
+ * @returns `chore/agent-kitchen-apply-AAAA-MM-DD`, or with `-2`, `-3`… if taken.
+ * @example branchName(root, new Date()) // "chore/agent-kitchen-apply-2026-11-01"
+ */
+export function branchName(root, date) {
+    const pad = (n) => String(n).padStart(2, "0");
+    const name = `chore/agent-kitchen-apply-${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+    const taken = (candidate) => git(root, ["rev-parse", "-q", "--verify", `refs/heads/${candidate}`]).ok || git(root, ["rev-parse", "-q", "--verify", `refs/remotes/origin/${candidate}`]).ok;
+    if (!taken(name))
+        return name;
+    let n = 2;
+    while (taken(`${name}-${n}`))
+        n += 1;
+    return `${name}-${n}`;
+}
+/**
+ * The hooks the clone runs: the repo's `core.hooksPath` as is when it is relative and the
+ * folder is in the clone (committed, like `.githooks`), or else the folder the repo uses,
+ * absolute (`.git/hooks`, or a generated one like husky's).
+ * @param root - The repo.
+ * @param clone - The clone.
+ * @returns The folder.
+ */
+function hooksPath(root, clone) {
+    const own = git(root, ["config", "--get", "core.hooksPath"]);
+    if (own.ok && own.out !== "" && !isAbsolute(own.out) && existsSync(join(clone, own.out)))
+        return own.out;
+    return git(root, ["rev-parse", "--path-format=absolute", "--git-path", "hooks"]).out;
+}
+/**
+ * Fetches origin and clones the repo at `origin/<base>` into a temporary folder.
+ * @param root - The repo.
+ * @param base - The base branch.
+ * @returns The clone's folder.
+ * @throws KitError if the repo has no origin, the fetch fails or origin has no such branch.
+ */
+export function cloneFromOrigin(root, base) {
+    const url = originUrl(root);
+    if (url === null)
+        throw new KitError("--pr necesita un remoto origin, y este repo no tiene.");
+    const fetched = git(root, ["fetch", "-q", "--prune", "origin"]);
+    if (!fetched.ok)
+        throw new KitError(`no pude bajar origin con git fetch; revisa la conexión o las credenciales y corre otra vez.${fetched.err === "" ? "" : `\n${fetched.err}`}`);
+    const head = git(root, ["rev-parse", "-q", "--verify", `refs/remotes/origin/${base}^{commit}`]);
+    if (!head.ok)
+        throw new KitError(`origin no tiene la rama ${base}.`);
+    const clone = realpathSync(mkdtempSync(join(tmpdir(), "agent-kitchen-pr-")));
+    const steps = [
+        ["clone", "-q", "--shared", "--no-checkout", root, clone],
+        ["-C", clone, "remote", "set-url", "origin", url],
+        ["-C", clone, "update-ref", `refs/remotes/origin/${base}`, head.out],
+        ["-C", clone, "symbolic-ref", "refs/remotes/origin/HEAD", `refs/remotes/origin/${base}`],
+        ["-C", clone, "checkout", "-q", "--detach", head.out],
+    ];
+    for (const args of steps) {
+        const done = git(root, args);
+        if (!done.ok) {
+            rmSync(clone, { recursive: true, force: true });
+            throw new KitError(`no pude preparar la copia temporal: ${done.err}`);
+        }
+    }
+    for (const key of IDENTITY) {
+        const value = git(root, ["config", "--get", key]);
+        if (value.ok && value.out !== "")
+            git(clone, ["config", key, value.out]);
+    }
+    git(clone, ["config", "core.hooksPath", hooksPath(root, clone)]);
+    return clone;
+}
+/**
+ * Deletes the clone.
+ * @param clone - Its folder.
+ */
+export function removeClone(clone) {
+    rmSync(clone, { recursive: true, force: true });
+}
+/**
+ * The version of github-rest to open the PR with: the repo's exact one, or npm's latest.
+ * @param root - The checkout to read package.json from.
+ * @returns The version, or null if neither is known.
+ */
+async function githubRestVersion(root) {
+    const own = dependencyVersion(readJson(root, "package.json"), GITHUB_REST);
+    if (own !== null && isRelease(own))
+        return own;
+    return npmLatest(GITHUB_REST);
+}
+/**
+ * Opens the PR in draft with github-rest, without GH_REPO, so the repo is origin's.
+ * @param root - The repo.
+ * @param clone - The clone, whose package.json says which github-rest the base uses.
+ * @param branch - The branch.
+ * @param base - The base.
+ * @param steps - The steps, for the body.
+ * @returns The PR's URL, or why it failed.
+ */
+async function openPr(root, clone, branch, base, steps) {
+    const version = await githubRestVersion(clone);
+    if (version === null)
+        return { error: `no sé qué versión de ${GITHUB_REST} usar.` };
+    const dir = mkdtempSync(join(tmpdir(), "agent-kitchen-body-"));
+    const bodyFile = join(dir, "body.md");
+    writeFileSync(bodyFile, prBody(steps));
+    try {
+        const result = await captureNpxWithout(root, [`${GITHUB_REST}@${version}`, "pr", "create", "--head", branch, "--base", base, "--title", TITLE, "--body-file", bodyFile, "--draft"], ["GH_REPO"]);
+        const url = result.out.trim().split("\n").at(-1) ?? "";
+        return result.status === 0 && url !== "" ? { url } : { error: `${result.err}${result.out}`.trim() || "github-rest falló sin decir por qué." };
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+/**
+ * What the person can run to open the PR by hand.
+ * @param branch - The branch.
+ * @param base - The base.
+ * @returns The command.
+ */
+function prCommand(branch, base) {
+    return `npx @ramon-sg/github-rest pr create --head ${branch} --base ${base} --title "${TITLE}" --body "..." --draft`;
+}
+/**
+ * Commits the clone's changes, pushes them from the repo to a new branch of origin and opens
+ * the PR. Until the push works, the commit lives only in the clone, which the caller keeps.
+ * @param root - The repo.
+ * @param clone - The clone, with the changes.
+ * @param options - The base, the steps that ran (for the commit and the PR) and the files to commit (the ones shown).
+ * @returns The lines to show, whether it all worked and whether the changes reached origin.
+ * @example await publish(root, clone, { base: "main", steps, paths })
+ */
+export async function publish(root, clone, options) {
+    const { base, steps, paths } = options;
+    const add = git(clone, ["--literal-pathspecs", "add", "-A", "--", ...paths]);
+    const done = add.ok ? git(clone, ["commit", "-q", "-m", TITLE, "-m", steps.map((step) => `- ${step}`).join("\n")]) : add;
+    if (!done.ok)
+        return { ok: false, pushed: false, lines: ["No pude hacer el commit.", done.err || done.out].filter((line) => line !== "") };
+    const sha = git(clone, ["rev-parse", "HEAD"]).out;
+    const branch = branchName(root, new Date());
+    // git asks for credentials on the terminal itself, so its output can stay captured.
+    const fetched = git(root, ["fetch", "-q", clone, "HEAD"]);
+    const pushed = fetched.ok ? git(root, ["push", "-q", "origin", `${sha}:refs/heads/${branch}`]) : fetched;
+    if (!pushed.ok)
+        return { ok: false, pushed: false, lines: [`No pude subir la rama ${branch} a origin.`, pushed.err].filter((line) => line !== "") };
+    const pr = await openPr(root, clone, branch, base, steps);
+    if ("url" in pr)
+        return { ok: true, pushed: true, lines: [`PR en draft: ${pr.url}`] };
+    return { ok: false, pushed: true, lines: [`La rama ${branch} está en origin, pero no pude abrir el PR: ${pr.error}`, `Falta: ${prCommand(branch, base)}`] };
+}

package/dist/progress.d.ts

@@ -19,12 +19,11 @@ export declare function plainProgress(out: Output, options: {
     now?: () => number;
 }): Progress;
 /**
- * How progress is shown: a spinner in a terminal, plain lines otherwise or when `plain` asks
- * for them. Only for the steps, after every question: a spinner shown before a question
- * leaves the second question deaf to the keyboard (@clack/prompts 1.8.1).
+ * How progress is shown: a spinner in a terminal, plain lines otherwise. Only for the steps,
+ * after every question: a spinner shown before a question leaves the second question deaf to
+ * the keyboard (@clack/prompts 1.8.1).
  * @param out - Where to write.
  * @param verbose - Whether the tools print on the terminal.
- * @param plain - Whether a question may come after the steps (`--commit`).
  * @returns The progress.
  */
-export declare function progressFor(out: Output, verbose: boolean, plain: boolean): Progress;
+export declare function progressFor(out: Output, verbose: boolean): Progress;

package/dist/progress.js

@@ -46,16 +46,15 @@ export function plainProgress(out, options) {
     };
 }
 /**
- * How progress is shown: a spinner in a terminal, plain lines otherwise or when `plain` asks
- * for them. Only for the steps, after every question: a spinner shown before a question
- * leaves the second question deaf to the keyboard (@clack/prompts 1.8.1).
+ * How progress is shown: a spinner in a terminal, plain lines otherwise. Only for the steps,
+ * after every question: a spinner shown before a question leaves the second question deaf to
+ * the keyboard (@clack/prompts 1.8.1).
  * @param out - Where to write.
  * @param verbose - Whether the tools print on the terminal.
- * @param plain - Whether a question may come after the steps (`--commit`).
  * @returns The progress.
  */
-export function progressFor(out, verbose, plain) {
-    if (out.interactive && !verbose && !plain) {
+export function progressFor(out, verbose) {
+    if (out.interactive && !verbose) {
         const spin = spinner();
         let started = 0;
         return {

package/dist/texts/catalog.d.ts

@@ -37,8 +37,10 @@ export interface Catalog {
     suggested: (dryRun: boolean) => string;
     /** The last line when every step worked or some failed. */
     summary: (failed: string[]) => string;
-    /** What is left to do by hand after the steps, without --commit; with the manager if its install failed. */
+    /** What is left to do by hand after the steps, in the checkout; with the manager if its install failed. */
     next: (failedInstall: string | null) => string;
+    /** The step after apply when agent-cloud-kit is installed. */
+    cloudNext: string;
     /** A new piece left out because no one was asked about it. */
     undecided: (names: string[]) => string;
     /** The repo's own skills left out of a pick. */
@@ -47,4 +49,12 @@ export interface Catalog {
     saved: (file: string, commits: boolean) => string;
     /** The closing line when no step ran: the person left, or picked none. */
     noSteps: (why: "leave" | "none", wrote: boolean) => string;
+    /** With --pr, before the clone: from which branch of origin. */
+    cloning: (base: string) => string;
+    /** With --pr, the heading of the files that go in the PR. */
+    changes: string;
+    /** With --pr, nothing changed. */
+    noChanges: string;
+    /** With --pr, why no PR was opened and where the changes stay. */
+    prNotOpened: (why: "step" | "install" | "git", clone: string) => string;
 }

package/dist/texts/es.js

@@ -53,14 +53,14 @@ export const es = {
             done: `github-rest subido de ${from} a ${to}, el mínimo de issue-flow ${flow}`,
         }),
         "cloud-install": ({ version }) => ({
-            menu: `Instalar claude-cloud ${version ?? "1.x"}: prepara las sesiones en la nube de Claude`,
-            doing: `Instalando claude-cloud ${version ?? "1.x"}…`,
-            done: `claude-cloud ${version ?? "1.x"} instalado: prepara las sesiones en la nube de Claude`,
+            menu: `Instalar agent-cloud-kit ${version ?? "1.x"}: prepara las sesiones en la nube de Claude`,
+            doing: `Instalando agent-cloud-kit ${version ?? "1.x"}…`,
+            done: `agent-cloud-kit ${version ?? "1.x"} instalado: prepara las sesiones en la nube de Claude`,
         }),
         "cloud-update": ({ from, to, config }) => ({
-            menu: `Actualizar claude-cloud ${from ?? "?"} → ${to} (la versión que fija ${config})`,
-            doing: `Actualizando claude-cloud de ${from ?? "?"} a ${to}…`,
-            done: `claude-cloud actualizado de ${from ?? "?"} a ${to} en ${config}`,
+            menu: `Actualizar agent-cloud-kit ${from ?? "?"} → ${to} (la versión que fija ${config})`,
+            doing: `Actualizando agent-cloud-kit de ${from ?? "?"} a ${to}…`,
+            done: `agent-cloud-kit actualizado de ${from ?? "?"} a ${to} en ${config}`,
         }),
         "guard-install": ({ version }) => ({
             menu: `Instalar claude-repo-guard ${version ?? "(main)"}: modo auto con sandbox, y un documento de qué protege`,
@@ -128,6 +128,7 @@ export const es = {
     suggested: (dryRun) => `Pasos sugeridos${dryRun ? "" : " (para hacerlos, corre agent-kitchen apply en una terminal, o con --yes)"}:`,
     summary: (failed) => (failed.length === 0 ? "Listo." : `Terminó, pero fallaron: ${failed.join("; ")}.`),
     next: (failedInstall) => `Falta: ${failedInstall === null ? "" : `corre '${failedInstall} install', `}revisa el diff y haz commit.`,
+    cloudNext: "Siguiente paso para la nube: npx agent-cloud-kit prepare",
     undecided: (names) => `Pieza nueva sin decisión: ${list(names)}. Corre agent-kitchen apply en una terminal para elegir.`,
     ownSkillsKept: (names) => `Se dejan fuera las skills que el repo ya tiene como propias: ${list(names)}. Para reemplazarlas, corre agent-kitchen apply en una terminal.`,
     saved: (file, commits) => `Guardé qué piezas usa el repo en ${file}${commits ? "" : "; commitéalo"}.`,
@@ -136,4 +137,11 @@ export const es = {
             return wrote ? "No corrí ningún paso; solo guardé qué piezas usa el repo." : "No se cambió nada.";
         return wrote ? "No elegiste pasos; solo guardé qué piezas usa el repo." : "No elegiste nada; no se cambió nada.";
     },
+    cloning: (base) => `Trabajo en una copia temporal de origin/${base}; tu copia no se toca.`,
+    changes: "Cambios del PR:",
+    noChanges: "No cambió ningún archivo: no hay PR que abrir.",
+    prNotOpened: (why, clone) => {
+        const reason = { step: "No abrí el PR porque algún paso falló.", install: "No abrí el PR porque falló el install.", git: "" }[why];
+        return `${reason === "" ? "" : `${reason} `}Los cambios quedan en la copia temporal ${clone}; bórrala con rm -rf cuando termines.`;
+    },
 };

package/dist/tools.d.ts

@@ -19,13 +19,35 @@ export declare function compareVersions(left: string, right: string): number;
  * @example isRelease("1.2.3") // true
  */
 export declare function isRelease(version: string): boolean;
+/**
+ * Whether a version is exact semver: a release like 1.2.3, or one with a prerelease like 1.2.3-rc.0.
+ * @param version - The text.
+ * @returns True for an exact version; ranges, tags and build metadata are not.
+ * @example isExactVersion("1.0.0-rc.0") // true
+ */
+export declare function isExactVersion(version: string): boolean;
+/**
+ * Compares two exact versions by semver precedence, prereleases included.
+ * @param left - A version like 1.0.0-rc.0.
+ * @param right - Another.
+ * @returns Negative if left is older, 0 if equal, positive if newer.
+ * @example compareSemver("1.0.0-rc.1", "1.0.0") // -1
+ */
+export declare function compareSemver(left: string, right: string): number;
 /**
  * The latest version of a package on npm.
  * @param name - The package.
  * @returns The version, or null if npm cannot tell.
- * @example await npmLatest("@ramon-sg/claude-cloud") // "1.0.0"
+ * @example await npmLatest("agent-cloud-kit") // "1.0.0"
  */
 export declare function npmLatest(name: string): Promise<string | null>;
+/**
+ * The `latest` version of a package on npm, even if it is a prerelease like 1.0.0-rc.0.
+ * @param name - The package.
+ * @returns The version, or null if npm cannot tell or it is not exact semver.
+ * @example await npmLatestExact("agent-cloud-kit") // "1.0.0-rc.0"
+ */
+export declare function npmLatestExact(name: string): Promise<string | null>;
 /**
  * The dependencies a version of a package declares on npm.
  * @param spec - The package and its version, as `name@x.y.z`.
@@ -46,7 +68,7 @@ export declare function latestTag(repo: string): Promise<string | null>;
  * @param root - The repo.
  * @param spec - The package, as npx takes it.
  * @returns When it is done.
- * @example void download(root, "@ramon-sg/claude-cloud@1.0.0")
+ * @example void download(root, "agent-cloud-kit@1.0.0")
  */
 export declare function download(root: string, spec: string): Promise<void>;
 /** How a tool ended, and what it printed if it was kept. */
@@ -60,7 +82,7 @@ export interface ToolRun {
  * @param root - The repo.
  * @param args - The package and its arguments.
  * @returns Whether it exited 0, and what it printed.
- * @example await runNpx(root, ["@ramon-sg/claude-cloud@1.0.0", "init"])
+ * @example await runNpx(root, ["agent-cloud-kit@1.0.0", "init"])
  */
 export declare function runNpx(root: string, args: string[]): Promise<ToolRun>;
 /**