agent-kitchen 0.8.0 → 0.10.0

package/README.md

@@ -26,7 +26,7 @@ Al arrancar revisa si npm tiene una versión más nueva de sí mismo. Si la hay,
 |---|---|---|---|---|---|
 | `skills-manager` | La versión de [`@ramon-sg/skills-manager`](https://github.com/ramon-sg/skills-manager) que corre `agent-kitchen`: como mínimo 1.2.0. Si falta la agrega y si es menor la sube; nunca la baja. Un rango o `workspace:` no se toca, y avisa si la versión que corre queda bajo el mínimo. Solo en repos que usan skills y tienen `package.json`, o donde issue-flow se instala en la misma corrida: entonces crea el `package.json` | `package.json` | — | La agrega `agent-kitchen` | La sube `agent-kitchen` |
 | `issue-flow` | Flujo de issues ([`@ramon-sg/issue-flow`](https://github.com/ramon-sg/issue-flow)): rama, worktree y PR en draft por issue, y sus 5 skills | `package.json` | npm | `issue-flow apply` (`init` antes de 0.3.0), y sus skills a la misma tag | `issue-flow apply` en la versión nueva (`upgrade` antes de 0.3.0), y sus skills a la misma tag. Desde 0.3.0, si su doctor ve hooks o el `$schema` atrás, `apply` en la versión del repo. Desde 0.3.0, si `github-rest` es una versión exacta bajo el mínimo que pide esa versión del flujo, la sube. Desde 0.2.6, si a GitHub le faltan labels del flujo (`spike`, `P1`–`P4`…), `issue-flow labels sync` los crea |
-| `claude-cloud` | Sesiones en la nube ([`@ramon-sg/claude-cloud`](https://github.com/ramon-sg/claude-cloud)): herramientas, Docker y el clone completo | `.claude/cloud.json` | npm | `claude-cloud init` | Cambia la versión que fija `.claude/cloud.json` |
+| `agent-cloud-kit` | Sesiones en la nube ([`agent-cloud-kit`](https://github.com/ramon-sg/agent-cloud-kit)): herramientas, Docker y el clone completo | `.claude/cloud.json`, `.agents/skills/cloud-ready/` | npm | `agent-cloud-kit init` | Cambia la versión que fija `.claude/cloud.json` y corre el `init` de la versión nueva, para que la skill `cloud-ready` quede igual. Al terminar `apply` sugiere `npx agent-cloud-kit prepare` |
 | `claude-repo-guard` | Barandas ([`claude-repo-guard`](https://github.com/ramon-sg/claude-repo-guard)): modo auto con sandbox, escribe solo en su worktree | `.claude/repo-guard.manifest.json` | Tags `vX.Y.Z` de GitHub | `apply` en esa tag (`install` antes de 0.5.0) | `apply` en la tag nueva |
 | `skills` | Skills con [`skills-manager`](https://github.com/ramon-sg/skills-manager): las del flujo y las de [`agent-skills`](https://github.com/ramon-sg/agent-skills) (planes, auditoría de código y de tests) | `.agents/skills.lock.json` | Tags del catálogo | `skills-manager init --select` con las elegidas | `skills-manager update` |
 | `agents-md` | Una línea en `AGENTS.md` que le pide al agente mirar la versión instalada de una biblioteca antes de usarla. Si el repo tiene `CLAUDE.md`, le agrega `@AGENTS.md`, porque si no Claude Code no lee `AGENTS.md`. Solo en repos con `package.json` | `AGENTS.md` | — | La escribe `agent-kitchen` | — |
@@ -48,9 +48,10 @@ Si npm o GitHub no responden, la pieza se muestra pero no se ofrece actualizarla
 npx agent-kitchen apply                        # pregunta, en una terminal (Enter: todo lo sugerido)
 npx agent-kitchen apply --dry-run              # solo muestra qué haría
 npx agent-kitchen apply --yes                  # hace lo sugerido sin preguntar
-npx agent-kitchen apply --commit               # al final, pregunta si commitear, en una rama o con PR
+npx agent-kitchen apply --pr                   # en una copia de origin, y abre un PR en draft
+npx agent-kitchen apply --here                 # en tu copia, sin commit
 npx agent-kitchen apply --verbose              # muestra la salida de cada herramienta
-npx agent-kitchen apply --skip claude-cloud    # deja fuera una pieza (o varias, con comas)
+npx agent-kitchen apply --skip agent-cloud-kit    # deja fuera una pieza (o varias, con comas)
 npx agent-kitchen apply --pieces               # cambia qué piezas usa el repo (solo en una terminal)
 npx agent-kitchen doctor                       # revisa cada pieza con su propio doctor
 ```
@@ -59,14 +60,16 @@ npx agent-kitchen doctor                       # revisa cada pieza con su propio
 
 - **Sin terminal y sin `--yes`** (por ejemplo, desde un agente), solo muestra lo que ofrecería.
 - **Corre en el checkout principal,** no en un worktree, y desde tu terminal. Dentro de una sesión de Claude, el sandbox de `claude-repo-guard` no deja escribir `.claude/settings.json`.
-- **Al terminar,** si los pasos cambiaron `package.json`, corre el `install` de tu gestor de paquetes. Te queda revisar el diff y hacer commit. O usa `--commit`.
+**Dónde trabaja.** En una terminal, sin `--pr` ni `--here`, lo primero que pregunta es dónde aplicar los cambios. Con `--yes`, sin terminal o sin remoto `origin`, trabaja en tu copia.
 
-**`--commit`** deja los cambios commiteados sin que lo haga un agente:
+**`--pr`** deja los cambios en un PR sin tocar tu copia:
 
-- **Antes de cualquier paso,** exige el repo sin cambios (también sin seguimiento; los worktrees de `.claude/worktrees/` no cuentan) y en la rama base: `baseBranch` de `.agents/flow.json`, si no la rama por defecto de `origin`, si no `main`. Con `--dry-run` hace solo esta revisión y lista los pasos.
-- **Al terminar,** si cambió `package.json`, corre el `install` de tu gestor para que el lockfile entre en el commit. Muestra los archivos cambiados y pregunta: dejarlos sin commit (por defecto), commit en la base, commit en una rama nueva `chore/agent-kitchen-apply-<fecha>`, o rama nueva con push y PR (con `@ramon-sg/github-rest`).
-- **Con rama,** la copia principal pasa por la rama solo mientras corre el comando: commitea ahí (los hooks de git corren, y uno que prohíbe commitear en la base no la frena) y vuelve a la base sin los cambios. Si el push o el PR fallan, la rama queda y la salida dice qué correr.
-- **Con `--yes`,** elige la rama con PR. Si algún paso falló, no commitea.
+- **Parte de origin, no de tu copia.** Hace `git fetch` y clona el repo en una carpeta temporal en `origin/<base>`: `baseBranch` de `.agents/flow.json`, si no la rama por defecto de `origin`, si no `main`. Da igual si tu copia está atrás, en otra rama o con cambios: ni sus archivos ni su `node_modules` cambian. Es un clon y no un worktree porque `issue-flow apply` no corre en un worktree; el clon comparte los objetos del repo, así que no copia el historial.
+- **Al terminar,** instala las dependencias en el clon (los hooks del repo pueden necesitarlas) y hace el commit con los hooks, el nombre y la firma de tu repo. El lockfile entra solo si cambió `package.json`.
+- **Sube la rama directo a origin.** Tu repo empuja el commit a `chore/agent-kitchen-apply-<fecha>` sin crear una rama local, y abre el PR en draft con `@ramon-sg/github-rest`. Tras el merge, `git fetch --prune` limpia la referencia `origin/chore/…`.
+- **Si algo falla antes del push** (un paso, el install o el commit), no sube nada y deja el clon para revisarlo; la salida dice dónde está. Si el push funciona y el PR falla, la salida dice qué correr.
+
+**`--here`** trabaja en tu copia, como `ng update` o `copier update`. Avisa si tu copia tiene cambios sin commit o si tu rama está atrás de origin según el último fetch. Si los pasos cambiaron `package.json`, corre el `install` de tu gestor de paquetes al final. Te queda revisar el diff y hacer commit.
 
 **`doctor`** corre el doctor de cada herramienta en la versión del repo: `issue-flow doctor --json`, `skills-manager check` y `claude-repo-guard doctor --json`. Además revisa que `skills-manager` esté al menos en 1.2.0, que las skills del flujo estén en la tag de su CLI, qué labels del flujo le faltan a GitHub (con `·`), que `.claude/cloud.json` fije una versión exacta y, en macOS, `weakerNetworkIsolation`. En un repo con `package.json`, también la línea de `AGENTS.md` y, si hay `CLAUDE.md`, su `@AGENTS.md`. Lo que no está instalado o tiene una versión nueva solo se anota con `·`. Sale con 1 si algo falla (`✗`).
 

package/dist/cli.js

@@ -14,25 +14,27 @@ import { KitError, processOutput, UsageError } from "./output.js";
 import { FLOW_PACKAGE, GENERAL_CATALOGS } from "./piece.js";
 import { PACKAGE as CLOUD_PACKAGE } from "./pieces/cloud.js";
 import { REPO as GUARD_REPO } from "./pieces/guard.js";
-import { compareVersions, isRelease, latestTag, npmLatest } from "./tools.js";
+import { compareVersions, isRelease, latestTag, npmLatest, npmLatestExact } from "./tools.js";
 /** This package on npm. */
 const PACKAGE = "agent-kitchen";
 /** Set in the run that a newer agent-kitchen was handed to, so it never hands over again. */
 const HANDED_OVER = "AGENT_KITCHEN_HANDED_OVER";
 /** Usage text. */
 const USAGE = `Uso:
-  agent-kitchen apply [--yes | --dry-run] [--commit] [--verbose] [--skip <pieza>,...]
-  agent-kitchen apply --pieces [--commit]
+  agent-kitchen apply [--yes | --dry-run] [--pr | --here] [--verbose] [--skip <pieza>,...]
+  agent-kitchen apply --pieces [--pr | --here]
   agent-kitchen doctor
 
 agent-kitchen revisa cada pieza de las herramientas de agentes del repo (${pieceNames().join(", ")}),
 muestra qué tiene el repo y la última versión de cada una, y apply ofrece instalar lo que falta
 y actualizar lo que está atrasado. En una terminal pregunta una vez: hacer todo lo sugerido,
 o elegir los pasos y las skills. --yes hace lo sugerido sin preguntar; sin terminal solo lo
-muestra. --verbose muestra la salida de cada herramienta. --commit exige el repo sin cambios
-y en la rama base; al final instala si cambió package.json y pregunta si dejar los cambios,
-commitearlos en la base, en una rama nueva, o en una rama nueva con push y PR (con --yes,
-esto último). apply --pieces elige qué piezas usa el repo y lo guarda en .agents/kitchen.json
+muestra. --verbose muestra la salida de cada herramienta.
+--pr trabaja en una copia temporal de origin/<base> recién bajada, sin tocar tu copia: instala
+las dependencias, hace el commit, sube una rama nueva a origin y abre un PR en draft. --here
+trabaja en tu copia y deja los cambios sin commit; si los pasos cambiaron package.json, corre
+el install. En una terminal, sin ninguna de las dos, pregunta; con --yes o sin terminal, usa
+--here. apply --pieces elige qué piezas usa el repo y lo guarda en .agents/kitchen.json
 (en una terminal, sin --yes ni --dry-run). Córrelo en la copia principal del
 repo, desde tu terminal. Sin subcomando hace lo mismo que apply, por ahora.
 
@@ -50,7 +52,7 @@ function ownVersion() {
  */
 function startLookups() {
     void npmLatest(FLOW_PACKAGE);
-    void npmLatest(CLOUD_PACKAGE);
+    void npmLatestExact(CLOUD_PACKAGE);
     void latestTag(GUARD_REPO);
     for (const catalog of GENERAL_CATALOGS)
         void latestTag(catalog);
@@ -82,7 +84,7 @@ async function main(argv) {
     const { values, positionals } = parseArgs({
         args: argv,
         allowPositionals: true,
-        options: { yes: { type: "boolean" }, "dry-run": { type: "boolean" }, commit: { type: "boolean" }, verbose: { type: "boolean", short: "v" }, skip: { type: "string" }, pieces: { type: "boolean" }, help: { type: "boolean", short: "h" }, version: { type: "boolean" } },
+        options: { yes: { type: "boolean" }, "dry-run": { type: "boolean" }, commit: { type: "boolean" }, pr: { type: "boolean" }, here: { type: "boolean" }, verbose: { type: "boolean", short: "v" }, skip: { type: "string" }, pieces: { type: "boolean" }, help: { type: "boolean", short: "h" }, version: { type: "boolean" } },
     });
     if (values.help === true) {
         out.stdout(`${USAGE}\n`);
@@ -100,14 +102,16 @@ async function main(argv) {
     if (rest.length > 0 || (command !== undefined && command !== "doctor" && command !== "apply"))
         throw new UsageError(`no existe el comando ${positionals.join(" ")}.`);
     if (command === "doctor") {
-        if (values.yes !== undefined || values["dry-run"] !== undefined || values.skip !== undefined || values.verbose !== undefined || values.commit !== undefined || values.pieces !== undefined)
+        if (values.yes !== undefined || values["dry-run"] !== undefined || values.skip !== undefined || values.verbose !== undefined || values.commit !== undefined || values.pr !== undefined || values.here !== undefined || values.pieces !== undefined)
             throw new UsageError("doctor no lleva opciones.");
         return doctor(process.cwd(), out);
     }
+    if (values.commit !== undefined)
+        throw new UsageError("--commit ya no existe: usa --pr para abrir un PR desde una copia de origin, o --here para dejar los cambios sin commit en tu copia.");
     if (command === undefined)
         out.stderr("agent-kitchen: usa 'agent-kitchen apply'; sin subcomando dejará de instalar en una versión mayor.\n");
     const skip = (values.skip ?? "").split(",").map((name) => name.trim()).filter((name) => name !== "");
-    return sync({ cwd: process.cwd(), yes: values.yes ?? false, dryRun: values["dry-run"] ?? false, verbose: values.verbose ?? false, skip, commit: values.commit ?? false, pieces: values.pieces ?? false }, out);
+    return sync({ cwd: process.cwd(), yes: values.yes ?? false, dryRun: values["dry-run"] ?? false, verbose: values.verbose ?? false, skip, pr: values.pr ?? false, here: values.here ?? false, pieces: values.pieces ?? false }, out);
 }
 try {
     process.exitCode = await main(process.argv.slice(2));

package/dist/commands/sync.d.ts

@@ -7,14 +7,17 @@ export interface SyncOptions {
     dryRun: boolean;
     verbose: boolean;
     skip: string[];
-    commit: boolean;
+    /** Work in a clone of origin and open a PR. */
+    pr: boolean;
+    /** Work in the checkout, leaving the changes uncommitted. */
+    here: boolean;
     /** Ask which pieces the repo uses, save the answer, then go on as usual. */
     pieces: boolean;
 }
 /**
  * The names `--skip` takes.
  * @returns The pieces' names.
- * @example pieceNames() // ["skills-manager", "issue-flow", "claude-cloud", "claude-repo-guard", "skills", "agents-md"]
+ * @example pieceNames() // ["skills-manager", "issue-flow", "agent-cloud-kit", "claude-repo-guard", "skills", "agents-md"]
  */
 export declare function pieceNames(): string[];
 /**
@@ -26,7 +29,7 @@ export declare function pieceNames(): string[];
  */
 export declare function noStepsMessage(why: "leave" | "none", wrote: boolean): string;
 /**
- * What the commit of `--commit` lists: the steps that worked, and the decisions file if this
+ * What the commit of `--pr` lists: the steps that worked, and the decisions file if this
  * run wrote it, in the commit's texts (not the interface's).
  * @param done - The steps that worked.
  * @param wrote - Whether the decisions file was written in this run.
@@ -40,6 +43,6 @@ export declare function commitLabels(done: Pick<Step, "text">[], wrote: boolean)
  * @param out - Where to write and ask.
  * @returns 0, or 1 if a step failed or the person cancelled.
  * @throws KitError outside the main checkout or with a broken file; UsageError for an unknown piece.
- * @example await sync({ cwd, yes: false, dryRun: true, verbose: false, skip: [], commit: false, pieces: false }, out)
+ * @example await sync({ cwd, yes: false, dryRun: true, verbose: false, skip: [], pr: false, here: false, pieces: false }, out)
  */
 export declare function sync(options: SyncOptions, out: Output): Promise<number>;

package/dist/commands/sync.js

@@ -1,7 +1,11 @@
 /**
- * @file `agent-kitchen apply [--yes] [--dry-run] [--commit] [--verbose] [--skip <piece>,...]`: the one command
- * that changes the repo (and, for now, also the bare `agent-kitchen`).
- * It looks at each piece (the version of skills-manager, the issue flow, claude-cloud,
+ * @file `agent-kitchen apply [--yes] [--dry-run] [--pr | --here] [--verbose] [--skip <piece>,...]`:
+ * the one command that changes the repo (and, for now, also the bare `agent-kitchen`).
+ * First it settles where to work: `--pr` in a clone of `origin/<base>` that ends in a PR in
+ * draft (see pr-clone.ts), `--here` in the person's checkout, leaving the changes uncommitted.
+ * In a terminal, without either, it asks; with `--yes` or without a terminal, or without an
+ * origin, it works here. Here it warns if the checkout has changes or is behind its upstream.
+ * Then it looks at each piece (the version of skills-manager, the issue flow, agent-cloud-kit,
  * claude-repo-guard, the skills, the rule in AGENTS.md) with
  * every lookup at once, shows what the repo has, and offers the steps that install what is
  * missing or update what is behind. In a terminal it asks first, all in one go: everything
@@ -11,11 +15,10 @@
  * flow's version), one line each, with the
  * tools' output only when one fails; one that fails does not stop the rest. With `--yes`
  * it does what is suggested without asking (and keeps the repo's own skills); without a
- * terminal it only shows the steps. Without `--commit`, it installs at the end if the steps
- * changed package.json. With `--commit` it first checks the repo is clean and on
- * its base branch, and at the end installs if package.json changed and asks what to do with
- * the changes (see git-finish.ts), also when the only change is the decisions file below;
- * the steps then show as plain lines, since a spinner before a question leaves it deaf.
+ * terminal it only shows the steps. Here, it installs at the end if the steps changed
+ * package.json. In the clone it always installs (the repo's hooks may need node_modules),
+ * commits, pushes and opens the PR, also when the only change is the decisions file below;
+ * if a step, the install or the commit fails, nothing is pushed and the clone is kept.
  * What the repo decided of each piece, in `.agents/kitchen.json`, is respected: a piece set to
  * false is left out as with `--skip`, and one with no decision is marked as new. Without
  * asking (`--yes` or no terminal), a new piece that is not installed is left out for the run.
@@ -25,8 +28,8 @@
  * uses, writes all of them to the file, and then goes on as usual.
  */
 import { DECIDABLE, decide, DECISIONS, off, readDecisions, undecided, writeDecisions } from "../decisions.js";
-import { baseBranch, branchName, changedPaths, checkReady, finish } from "../git-finish.js";
-import { askFinish, askPath, askPieces, askReplace, askSkills, askSteps } from "../menu.js";
+import { behindUpstream, baseBranch, changedPaths, cloneFromOrigin, originUrl, publish, removeClone } from "../pr-clone.js";
+import { askPath, askPieces, askPlace, askReplace, askSkills, askSteps } from "../menu.js";
 import { KitError, UsageError, warn } from "../output.js";
 import { cloudStatus, NAME as CLOUD } from "../pieces/cloud.js";
 import { guardStatus, NAME as GUARD } from "../pieces/guard.js";
@@ -34,7 +37,7 @@ import { issueFlowStatus, NAME as FLOW } from "../pieces/issue-flow.js";
 import { keepOwn, NAME as SKILLS, ownInPick, skillsStatus } from "../pieces/skills.js";
 import { agentsMdStatus, NAME as AGENTS_MD } from "../pieces/agents-md.js";
 import { NAME as SKILLS_MANAGER, skillsManagerStatus } from "../pieces/skills-manager.js";
-import { mainCheckout, packageManager, packageText } from "../repo.js";
+import { mainCheckout, packageManager, packageText, readJson } from "../repo.js";
 import { download, failedOutput, runInstall, setVerbose } from "../tools.js";
 import { commitLine, DECISIONS_LINE } from "../commit-texts.js";
 import { progressFor } from "../progress.js";
@@ -44,7 +47,7 @@ const PIECES = [SKILLS_MANAGER, FLOW, CLOUD, GUARD, SKILLS, AGENTS_MD];
 /**
  * The names `--skip` takes.
  * @returns The pieces' names.
- * @example pieceNames() // ["skills-manager", "issue-flow", "claude-cloud", "claude-repo-guard", "skills", "agents-md"]
+ * @example pieceNames() // ["skills-manager", "issue-flow", "agent-cloud-kit", "claude-repo-guard", "skills", "agents-md"]
  */
 export function pieceNames() {
     return [...PIECES];
@@ -96,7 +99,7 @@ function printStatus(statuses, decidedOff, out) {
  * @param saved - What was read, or null if there is no file.
  * @param statuses - What each piece found.
  * @param chosen - The steps the person picked.
- * @param commits - Whether `--commit` asks about the changes at the end.
+ * @param commits - Whether the run ends in a PR, so the file need not be committed by hand.
  * @param out - Where to write.
  * @returns True if the file was written.
  */
@@ -122,14 +125,14 @@ export function noStepsMessage(why, wrote) {
 }
 /**
  * The line that says the decisions were saved.
- * @param commits - Whether `--commit` asks about the changes at the end, so the file need not be committed by hand.
+ * @param commits - Whether the run ends in a PR, so the file need not be committed by hand.
  * @returns The line.
  */
 function savedMessage(commits) {
     return `${ui.saved(DECISIONS, commits)}\n`;
 }
 /**
- * What the commit of `--commit` lists: the steps that worked, and the decisions file if this
+ * What the commit of `--pr` lists: the steps that worked, and the decisions file if this
  * run wrote it, in the commit's texts (not the interface's).
  * @param done - The steps that worked.
  * @param wrote - Whether the decisions file was written in this run.
@@ -144,7 +147,7 @@ export function commitLabels(done, wrote) {
  * Asks which pieces the repo uses and writes the answer for every decidable piece.
  * @param root - The repo.
  * @param saved - What was read, or null if there is no file.
- * @param commits - Whether `--commit` asks about the changes at the end.
+ * @param commits - Whether the run ends in a PR.
  * @param out - Where to write.
  * @returns False if the person cancelled.
  */
@@ -279,13 +282,45 @@ async function runStep(root, step, progress, out) {
         out.stderr(failure);
     return ok;
 }
+/**
+ * Settles where to work: the flag, or the person's answer in a terminal, or the checkout.
+ * @param root - The repo.
+ * @param options - The options.
+ * @param out - Where to write and ask.
+ * @returns The place, or null if the person cancelled.
+ * @throws KitError with `--pr` and no origin.
+ */
+async function choosePlace(root, options, out) {
+    if (options.pr) {
+        if (originUrl(root) === null)
+            throw new KitError("--pr necesita un remoto origin, y este repo no tiene. Usa --here.");
+        return "pr";
+    }
+    if (options.here || options.yes || options.dryRun || !out.interactive || originUrl(root) === null)
+        return "here";
+    return askPlace(baseBranch(root));
+}
+/**
+ * Warns about what the checkout already has before working on it: changes that will mix with
+ * the run's, or a branch behind its upstream.
+ * @param root - The repo.
+ * @param out - Where to write.
+ */
+function warnHere(root, out) {
+    const changed = changedPaths(root);
+    if (changed.length > 0)
+        warn(out, `tu copia tiene cambios sin commit (${changed.length === 1 ? changed[0] : `${changed.length} archivos`}); los de apply se mezclarán con ellos.`);
+    const behind = behindUpstream(root);
+    if (behind > 0)
+        warn(out, `tu rama está ${behind} ${behind === 1 ? "commit" : "commits"} atrás de origin, según el último fetch; corre git pull antes, o usa --pr.`);
+}
 /**
  * Runs the command; see the file's header.
  * @param options - The options.
  * @param out - Where to write and ask.
  * @returns 0, or 1 if a step failed or the person cancelled.
  * @throws KitError outside the main checkout or with a broken file; UsageError for an unknown piece.
- * @example await sync({ cwd, yes: false, dryRun: true, verbose: false, skip: [], commit: false, pieces: false }, out)
+ * @example await sync({ cwd, yes: false, dryRun: true, verbose: false, skip: [], pr: false, here: false, pieces: false }, out)
  */
 export async function sync(options, out) {
     const unknown = options.skip.find((name) => !pieceNames().includes(name));
@@ -293,21 +328,51 @@ export async function sync(options, out) {
         throw new UsageError(`no existe la pieza ${unknown}; son ${pieceNames().join(", ")}.`);
     if (options.yes && options.dryRun)
         throw new UsageError("usa --yes o --dry-run, no los dos.");
+    if (options.pr && options.here)
+        throw new UsageError("usa --pr o --here, no los dos.");
     if (options.pieces && (options.yes || options.dryRun))
         throw new UsageError("usa --pieces solo, sin --yes ni --dry-run.");
     if (options.pieces && !out.interactive)
         throw new UsageError("--pieces pregunta qué piezas usa el repo; córrelo en una terminal.");
     const root = mainCheckout(options.cwd, "agent-kitchen apply");
-    const base = options.commit ? baseBranch(root) : null;
-    if (base !== null)
-        checkReady(root, base);
     setVerbose(options.verbose);
+    const place = await choosePlace(root, options, out);
+    if (place === null) {
+        out.stdout("No se cambió nada.\n");
+        return 1;
+    }
+    if (place === "here") {
+        if (!options.dryRun)
+            warnHere(root, out);
+        return applyIn({ kind: "here", root }, options, out);
+    }
+    const base = baseBranch(root);
+    out.stdout(`${ui.cloning(base)}\n`);
+    const work = { kind: "pr", root: cloneFromOrigin(root, base), repo: root, base, keep: false };
+    try {
+        return await applyIn(work, options, out);
+    }
+    finally {
+        if (!work.keep)
+            removeClone(work.root);
+    }
+}
+/**
+ * Looks at the pieces, asks, runs the steps and ends as the place says.
+ * @param work - Where to work.
+ * @param options - The options.
+ * @param out - Where to write and ask.
+ * @returns 0, or 1 if a step failed or the person cancelled.
+ */
+async function applyIn(work, options, out) {
+    const { root } = work;
+    const pr = work.kind === "pr";
     let saved = readDecisions(root);
     let wrote = false;
     for (const warning of saved?.warnings ?? [])
         warn(out, warning);
     if (options.pieces) {
-        if (!(await choosePieces(root, saved, base !== null, out))) {
+        if (!(await choosePieces(root, saved, pr, out))) {
             out.stdout("No se cambió nada.\n");
             return 0;
         }
@@ -338,18 +403,24 @@ export async function sync(options, out) {
     }
     printStatus(statuses, off(saved).filter((name) => !options.skip.includes(name)), out);
     const steps = statuses.flatMap((status) => status.steps);
-    // With --commit, a run that only wrote the decisions file still ends with the question.
-    const progress = progressFor(out, options.verbose, base !== null);
-    const endWithoutSteps = async () => (base !== null && wrote ? commitChanges(root, base, commitLabels([], true), [], progress, options, out) : 0);
+    const progress = progressFor(out, options.verbose);
+    // In a clone, a run that only wrote the decisions file still ends in a PR.
+    const endWithoutSteps = async () => {
+        if (work.kind === "pr")
+            return wrote ? openPr(work, commitLabels([], true), [], progress, out) : 0;
+        if (!options.dryRun)
+            printCloudNext(root, skip, out);
+        return 0;
+    };
     if (steps.length === 0) {
         if (saves)
-            wrote = saveDecisions(root, saved, statuses, [], base !== null, out) || wrote;
+            wrote = saveDecisions(root, saved, statuses, [], pr, out) || wrote;
         out.stdout(`${ui.upToDate}\n`);
         return endWithoutSteps();
     }
     const chosen = await chooseSteps(root, steps, options, out);
     if (saves && Array.isArray(chosen))
-        wrote = saveDecisions(root, saved, statuses, chosen, base !== null, out) || wrote;
+        wrote = saveDecisions(root, saved, statuses, chosen, pr, out) || wrote;
     if (chosen === "leave") {
         out.stdout(noStepsMessage("leave", wrote));
         return endWithoutSteps();
@@ -375,14 +446,26 @@ export async function sync(options, out) {
             failedSteps.push(step);
     }
     const failed = failedSteps.map(stepLabel);
-    if (base !== null)
-        return commitChanges(root, base, commitLabels(chosen.filter((step) => !failedSteps.includes(step)), wrote), failed, progress, options, out);
+    if (work.kind === "pr")
+        return openPr(work, commitLabels(chosen.filter((step) => !failedSteps.includes(step)), wrote), failed, progress, out);
     const installFailed = packageText(root) !== pkgBefore ? !(await install(root, progress, out)) : false;
     if (installFailed)
         failed.push(phrases({ kind: "install-deps", manager: packageManager(root) }).menu);
     out.stdout(`\n${ui.summary(failed)} ${ui.next(installFailed ? packageManager(root) : null)}\n`);
+    if (!options.dryRun)
+        printCloudNext(root, skip, out);
     return failed.length === 0 ? 0 : 1;
 }
+/**
+ * Says what to run next for the cloud, if agent-cloud-kit is installed and was not left out.
+ * @param root - The repo.
+ * @param skip - The pieces left out.
+ * @param out - Where to write.
+ */
+function printCloudNext(root, skip, out) {
+    if (!skip.includes(CLOUD) && readJson(root, ".claude/cloud.json") !== null)
+        out.stdout(`${ui.cloudNext}\n`);
+}
 /**
  * Runs the repo's install with the same progress as a step, and shows its output if it fails.
  * @param root - The repo.
@@ -400,40 +483,42 @@ async function install(root, progress, out) {
     return installed.ok;
 }
 /**
- * The end of `--commit`: the install if package.json changed, the changes, the question (or
- * the branch with a PR under --yes) and what git did.
- * @param root - The repo.
- * @param base - The base branch.
+ * The end of a run in a clone: the install, the changes, the commit, the push and the PR.
+ * Nothing is pushed if a step, the install or the commit failed; the clone is kept then.
+ * @param work - The clone.
  * @param done - What the commit lists: the steps that worked, and the decisions file if written.
  * @param failed - The steps that failed, as the interface names them.
  * @param progress - How progress is shown, for the install.
- * @param options - The options.
- * @param out - Where to write and ask.
- * @returns 0, or 1 if a step, the install or git failed.
+ * @param out - Where to write.
+ * @returns 0, or 1 if a step, the install, git or the PR failed.
  */
-async function commitChanges(root, base, done, failed, progress, options, out) {
+async function openPr(work, done, failed, progress, out) {
     const summary = ui.summary(failed);
-    const changed = changedPaths(root);
-    if (changed.length === 0) {
-        out.stdout(`\n${summary} No cambió ningún archivo: no hay nada que commitear.\n`);
+    const before = changedPaths(work.root);
+    if (before.length === 0) {
+        out.stdout(`\n${summary} ${ui.noChanges}\n`);
         return failed.length === 0 ? 0 : 1;
     }
-    const manager = packageManager(root);
-    const packageChanged = changed.includes("package.json");
-    if (packageChanged && !(await install(root, progress, out))) {
-        out.stdout(`\n${summary} No commiteé: el install falló y los cambios quedan sin commit.\n`);
+    if (failed.length > 0) {
+        work.keep = true;
+        out.stdout(`\n${summary} ${ui.prNotOpened("step", work.root)}\n`);
         return 1;
     }
-    const paths = changedPaths(root);
-    out.stdout(`\n${summary} Cambios:\n${paths.map((path) => `  ${path}`).join("\n")}\n`);
-    if (failed.length > 0 && options.yes) {
-        out.stdout("No commiteé porque algún paso falló; los cambios quedan sin commit.\n");
+    // A clone starts without node_modules, and the repo's hooks may need them.
+    if (packageText(work.root) !== null && !(await install(work.root, progress, out))) {
+        work.keep = true;
+        out.stdout(`\n${summary} ${ui.prNotOpened("install", work.root)}\n`);
         return 1;
     }
-    const branch = branchName(root, new Date());
-    const choice = options.yes ? "pr" : await askFinish(base, branch, failed.length > 0);
-    const result = await finish(root, choice, { base, branch, steps: done, paths, manager, packageChanged });
+    // Only a changed package.json brings the lockfile along; an install that only rewrites it stays out.
+    const paths = before.includes("package.json") ? changedPaths(work.root) : before;
+    out.stdout(`\n${summary} ${ui.changes}\n${paths.map((path) => `  ${path}`).join("\n")}\n`);
+    const result = await publish(work.repo, work.root, { base: work.base, steps: done, paths });
     for (const line of result.lines)
         out.stdout(`${line}\n`);
-    return result.ok && failed.length === 0 ? 0 : 1;
+    if (!result.pushed) {
+        work.keep = true;
+        out.stdout(`${ui.prNotOpened("git", work.root)}\n`);
+    }
+    return result.ok ? 0 : 1;
 }

package/dist/commit-texts.js

@@ -1,5 +1,5 @@
 /**
- * @file The texts of the commit and the PR of `apply --commit`. They are always in Spanish,
+ * @file The texts of the commit and the PR of `apply --pr`. They are always in Spanish,
  * whatever language the interface shows: a repo's history should not change language with the
  * terminal of whoever ran the command. A step reads as its Spanish menu order.
  */

package/dist/decisions.d.ts

@@ -24,7 +24,7 @@ export declare function readDecisions(root: string): Saved | null;
  * The decidable pieces with no decision yet.
  * @param saved - What was read, or null if there is no file.
  * @returns Their names; all of them without a file.
- * @example undecided(null) // ["issue-flow", "claude-cloud", ...]
+ * @example undecided(null) // ["issue-flow", "agent-cloud-kit", ...]
  */
 export declare function undecided(saved: Saved | null): string[];
 /**

package/dist/decisions.js

@@ -43,7 +43,7 @@ export function readDecisions(root) {
  * The decidable pieces with no decision yet.
  * @param saved - What was read, or null if there is no file.
  * @returns Their names; all of them without a file.
- * @example undecided(null) // ["issue-flow", "claude-cloud", ...]
+ * @example undecided(null) // ["issue-flow", "agent-cloud-kit", ...]
  */
 export function undecided(saved) {
     return DECIDABLE.filter((name) => saved?.pieces[name] === undefined);

package/dist/menu.d.ts

@@ -1,4 +1,3 @@
-import type { FinishChoice } from "./git-finish.js";
 import type { Candidate, Step } from "./piece.js";
 /** What the person wants after seeing the table. */
 export type Path = "all" | "pick" | "leave";
@@ -77,13 +76,12 @@ export declare function askSkills(candidates: Candidate[], ticked: string[]): Pr
  * @example await askReplace(["planning"])
  */
 export declare function askReplace(own: string[]): Promise<boolean | null>;
+/** Where apply works: a PR from a clone of origin, or the person's checkout. */
+export type Place = "pr" | "here";
 /**
- * Asks, after the steps, what to do with the changes. Leaving them is the default, and
- * cancelling leaves them too.
+ * Asks, before anything else, where to apply the changes.
  * @param base - The base branch.
- * @param branch - The name of the new branch.
- * @param failed - Whether a step failed, to warn above the question.
- * @returns The answer.
- * @example await askFinish("main", "chore/agent-kitchen-apply-2026-11-01", false) // "pr"
+ * @returns The answer, or null if the person cancelled.
+ * @example await askPlace("main") // "pr"
  */
-export declare function askFinish(base: string, branch: string, failed: boolean): Promise<FinishChoice>;
+export declare function askPlace(base: string): Promise<Place | null>;

package/dist/menu.js

@@ -1,8 +1,8 @@
 /**
- * @file The questions, in Spanish (`@clack/prompts`), all asked before any step runs: the
- * quick path (do everything suggested, pick, or leave), the checkbox menu of the steps, the
- * skills of a step grouped by catalog with their description, and whether to replace the
- * repo's own skills. They only run with a terminal.
+ * @file The questions, in Spanish (`@clack/prompts`), all asked before any step runs: where to
+ * apply (a PR or the checkout), the quick path (do everything suggested, pick, or leave), the
+ * checkbox menu of the steps, the skills of a step grouped by catalog with their description,
+ * and whether to replace the repo's own skills. They only run with a terminal.
  */
 import { styleText } from "node:util";
 import { confirm, groupMultiselect, isCancel, MULTISELECT_INSTRUCTIONS, multiselect, select, SELECT_INSTRUCTIONS } from "@clack/prompts";
@@ -123,25 +123,20 @@ export async function askReplace(own) {
     return isCancel(answer) ? null : answer;
 }
 /**
- * Asks, after the steps, what to do with the changes. Leaving them is the default, and
- * cancelling leaves them too.
+ * Asks, before anything else, where to apply the changes.
  * @param base - The base branch.
- * @param branch - The name of the new branch.
- * @param failed - Whether a step failed, to warn above the question.
- * @returns The answer.
- * @example await askFinish("main", "chore/agent-kitchen-apply-2026-11-01", false) // "pr"
+ * @returns The answer, or null if the person cancelled.
+ * @example await askPlace("main") // "pr"
  */
-export async function askFinish(base, branch, failed) {
+export async function askPlace(base) {
     spanishKeys();
     const answer = await select({
-        message: failed ? "Algún paso falló. ¿Qué hago con los cambios?" : "¿Qué hago con los cambios?",
-        initialValue: "leave",
+        message: "¿Dónde aplico los cambios?",
+        initialValue: "pr",
         options: [
-            { value: "leave", label: "Dejarlos sin commit" },
-            { value: "base", label: `Commit en ${base}` },
-            { value: "branch", label: `Commit en una rama nueva, ${branch}`, hint: `${base} queda como está` },
-            { value: "pr", label: "Commit en una rama nueva, push y PR", hint: `contra ${base}` },
+            { value: "pr", label: "En un PR nuevo", hint: `recomendado · parte de origin/${base}, no toca tu copia` },
+            { value: "here", label: "En tu copia, sin commit", hint: "los revisas con git diff y haces commit tú" },
         ],
     });
-    return isCancel(answer) ? "leave" : answer;
+    return isCancel(answer) ? null : answer;
 }

package/dist/output.d.ts

@@ -24,6 +24,6 @@ export declare function processOutput(): Output;
  * Prints a warning on stderr with the program's name.
  * @param out - Where to write.
  * @param text - The warning.
- * @example warn(out, "claude-cloud init failed")
+ * @example warn(out, "agent-cloud-kit init failed")
  */
 export declare function warn(out: Output, text: string): void;

package/dist/output.js

@@ -24,7 +24,7 @@ export function processOutput() {
  * Prints a warning on stderr with the program's name.
  * @param out - Where to write.
  * @param text - The warning.
- * @example warn(out, "claude-cloud init failed")
+ * @example warn(out, "agent-cloud-kit init failed")
  */
 export function warn(out, text) {
     out.stderr(`agent-kitchen: ${text}\n`);

package/dist/piece.d.ts

@@ -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