agent-kitchen 0.8.0 → 0.9.0

package/README.md

@@ -48,7 +48,8 @@ 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 --pieces               # cambia qué piezas usa el repo (solo en una terminal)
@@ -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

@@ -21,18 +21,20 @@ const PACKAGE = "agent-kitchen";
 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.
 
@@ -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,7 +7,10 @@ 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;
 }
@@ -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, claude-cloud,
  * 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";
@@ -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,18 @@ 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 () => (work.kind === "pr" && wrote ? openPr(work, commitLabels([], true), [], progress, out) : 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,8 +440,8 @@ 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);
@@ -400,40 +465,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/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/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,7 +37,7 @@ 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;
     /** A new piece left out because no one was asked about it. */
     undecided: (names: string[]) => string;
@@ -47,4 +47,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

@@ -136,4 +136,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-kitchen",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "One command to install, update and check a repo's agent tooling: the issue flow and its skills, the general skills, Claude cloud sessions, claude-repo-guard and the installed-versions rule in AGENTS.md.",
   "license": "MIT",
   "type": "module",

package/dist/git-finish.d.ts

@@ -1,53 +0,0 @@
-/** What to do with the changes: leave them, commit on the base, on a branch, or a branch with a PR. */
-export type FinishChoice = "leave" | "base" | "branch" | "pr";
-/**
- * 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;
-/**
- * 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[];
-/**
- * Checks, before any step, that the repo has no changes and is on its base branch.
- * @param root - The repo.
- * @param base - The base branch.
- * @throws KitError saying what is wrong and what to do.
- */
-export declare function checkReady(root: string, base: string): void;
-/**
- * The branch for today's changes: a new name, also against origin's branches git knows of.
- * @param root - The repo.
- * @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;
-/** What `finish` needs to know. */
-export interface FinishOptions {
-    base: string;
-    branch: string;
-    steps: string[];
-    paths: string[];
-    manager: string;
-    packageChanged?: boolean;
-}
-/**
- * Does what the person chose with the changes.
- * @param root - The repo, on the base, with the changes of the run.
- * @param choice - What to do.
- * @param options - The base, the new branch's name, the steps that ran, the files to commit (the ones shown), the package manager and whether package.json changed.
- * @returns The lines to show and whether it all worked.
- * @example await finish(root, "pr", { base: "main", branch: "chore/agent-kitchen-apply-2026-11-01", steps, manager: "npm" })
- */
-export declare function finish(root: string, choice: FinishChoice, options: FinishOptions): Promise<{
-    ok: boolean;
-    lines: string[];
-}>;

package/dist/git-finish.js

@@ -1,252 +0,0 @@
-/**
- * @file What `apply --commit` does with git: before any step, it checks that the repo has no
- * changes (the repo's worktrees under it do not count) and is on its base branch; after the
- * steps, it commits what changed where the person chose. A new branch is made by passing
- * through it for the length of the command: `git switch -c`, the commit there (so a hook that
- * forbids commits on the base does not stop it), the push and the PR if asked, and back to
- * the base, which never moves. git runs its hooks; nothing here skips them.
- */
-import { spawnSync } from "node:child_process";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { 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";
-/**
- * Runs git in the repo.
- * @param root - The repo.
- * @param args - The arguments.
- * @param inherit - True to show its output on the terminal, for a push that may ask for credentials.
- * @returns How it went.
- */
-function git(root, args, inherit = false) {
-    const result = spawnSync("git", args, { cwd: root, encoding: "utf8", stdio: inherit ? "inherit" : "pipe" });
-    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";
-}
-/**
- * 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;
-}
-/**
- * Checks, before any step, that the repo has no changes and is on its base branch.
- * @param root - The repo.
- * @param base - The base branch.
- * @throws KitError saying what is wrong and what to do.
- */
-export function checkReady(root, base) {
-    const branch = git(root, ["branch", "--show-current"]).out;
-    if (branch === "")
-        throw new KitError(`--commit necesita estar en ${base}, y HEAD no está en ninguna rama.`);
-    if (branch !== base)
-        throw new KitError(`--commit necesita estar en ${base}, la rama base, y estás en ${branch}.`);
-    const paths = changedPaths(root);
-    if (paths.length > 0)
-        throw new KitError(`--commit necesita el repo sin cambios, y hay cambios en: ${paths.join(", ")}. Commitéalos o guárdalos aparte y corre otra vez.`);
-}
-/**
- * The branch for today's changes: a new name, also against origin's branches git knows of.
- * @param root - The repo.
- * @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}`;
-}
-/**
- * Stages the files shown to the person, taken literally, and commits them, with the hooks.
- * @param root - The repo.
- * @param paths - The files.
- * @param steps - The steps that ran, for the body.
- * @returns How git went.
- */
-function commit(root, paths, steps) {
-    const add = git(root, ["--literal-pathspecs", "add", "-A", "--", ...paths]);
-    if (!add.ok)
-        return add;
-    return git(root, ["commit", "-q", "-m", TITLE, "-m", steps.map((step) => `- ${step}`).join("\n")]);
-}
-/**
- * The version of github-rest to open the PR with: the repo's exact one, or npm's latest.
- * @param root - The repo.
- * @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 with github-rest, without GH_REPO, so the repo is origin's.
- * @param root - The repo, on the branch.
- * @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, branch, base, steps) {
-    const version = await githubRestVersion(root);
-    if (version === null)
-        return { error: `no sé qué versión de ${GITHUB_REST} usar.` };
-    const dir = mkdtempSync(join(tmpdir(), "agent-kitchen-pr-"));
-    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], ["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 "..."`;
-}
-/**
- * Pushes the branch and opens its PR, saying what to run if either fails.
- * @param root - The repo, on the branch.
- * @param branch - The branch.
- * @param base - The base.
- * @param steps - The steps, for the body.
- * @param lines - Where to add what happened.
- * @returns Whether both worked.
- */
-async function pushAndOpen(root, branch, base, steps, lines) {
-    const pushed = git(root, ["push", "-u", "origin", branch], true);
-    if (!pushed.ok) {
-        lines.push(`No pude subir la rama. Falta: git push -u origin ${branch}, y luego ${prCommand(branch, base)}`);
-        return false;
-    }
-    const pr = await openPr(root, branch, base, steps);
-    if ("url" in pr) {
-        lines.push(`PR: ${pr.url}`);
-        return true;
-    }
-    lines.push(`La rama está en origin, pero no pude abrir el PR: ${pr.error}`, `Falta: ${prCommand(branch, base)}`);
-    return false;
-}
-/**
- * Does what the person chose with the changes.
- * @param root - The repo, on the base, with the changes of the run.
- * @param choice - What to do.
- * @param options - The base, the new branch's name, the steps that ran, the files to commit (the ones shown), the package manager and whether package.json changed.
- * @returns The lines to show and whether it all worked.
- * @example await finish(root, "pr", { base: "main", branch: "chore/agent-kitchen-apply-2026-11-01", steps, manager: "npm" })
- */
-export async function finish(root, choice, options) {
-    const { base, branch, steps, paths } = options;
-    if (choice === "leave")
-        return { ok: true, lines: ["Falta: revisa el diff y haz commit."] };
-    if (choice === "base") {
-        const done = commit(root, paths, steps);
-        if (!done.ok)
-            return { ok: false, lines: [`No pude commitear en ${base}; los cambios quedan sin commit.`, done.err || done.out] };
-        return { ok: true, lines: [`Commit en ${base}. Falta: git push cuando quieras.`] };
-    }
-    const moved = git(root, ["switch", "-q", "-c", branch]);
-    if (!moved.ok)
-        return { ok: false, lines: [`No pude crear la rama ${branch}; los cambios quedan sin commit.`, moved.err] };
-    const lines = [];
-    let ok = true;
-    let committed = false;
-    try {
-        const done = commit(root, paths, steps);
-        if (!done.ok) {
-            ok = false;
-            lines.push("No pude commitear.", done.err || done.out);
-        }
-        else {
-            committed = true;
-            lines.push(`Commit en la rama ${branch}.`);
-            if (choice === "pr")
-                ok = await pushAndOpen(root, branch, base, steps, lines);
-        }
-    }
-    finally {
-        const back = git(root, ["switch", "-q", base]);
-        if (!back.ok) {
-            ok = false;
-            lines.push(`No pude volver a ${base}: ${back.err}. Sigues en ${branch}.`);
-        }
-        else if (!committed) {
-            git(root, ["branch", "-q", "-d", branch]);
-            lines.push(`Vuelves a ${base} con los cambios sin commit.`);
-        }
-        else
-            lines.push(`Vuelves a ${base}, sin los cambios: están en ${branch}.`);
-    }
-    if (!committed)
-        return { ok: false, lines };
-    if (options.packageChanged === true)
-        lines.push(`node_modules quedó con lo de la rama; si sigues en ${base}, corre '${options.manager} install'.`);
-    return { ok, lines };
-}