agent-kitchen 0.7.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,** corre el `install` de tu gestor de paquetes, revisa el diff y haz 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,10 +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. 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.
@@ -24,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";
@@ -33,11 +37,11 @@ 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 } from "../repo.js";
+import { mainCheckout, packageManager, packageText } from "../repo.js";
 import { download, failedOutput, runInstall, setVerbose } from "../tools.js";
 import { commitLine, DECISIONS_LINE } from "../commit-texts.js";
 import { progressFor } from "../progress.js";
-import { stepLabel, ui } from "../texts/index.js";
+import { phrases, stepLabel, ui } from "../texts/index.js";
 /** Every piece, in the order its steps run. */
 const PIECES = [SKILLS_MANAGER, FLOW, CLOUD, GUARD, SKILLS, AGENTS_MD];
 /**
@@ -95,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.
  */
@@ -121,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.
@@ -143,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.
  */
@@ -278,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));
@@ -292,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;
         }
@@ -337,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();
@@ -367,59 +433,74 @@ export async function sync(options, out) {
             out.stdout(noStepsMessage("none", wrote));
         return endWithoutSteps();
     }
+    const pkgBefore = packageText(root);
     const failedSteps = [];
     for (const step of chosen) {
         if (!(await runStep(root, step, progress, 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);
-    out.stdout(`\n${ui.summary(failed)} ${ui.next(packageManager(root))}\n`);
+    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`);
     return failed.length === 0 ? 0 : 1;
 }
 /**
- * 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.
+ * Runs the repo's install with the same progress as a step, and shows its output if it fails.
  * @param root - The repo.
- * @param base - The base branch.
+ * @param progress - How progress is shown.
+ * @param out - Where to write.
+ * @returns Whether it worked.
+ */
+async function install(root, progress, out) {
+    const text = { kind: "install-deps", manager: packageManager(root) };
+    progress.start(text);
+    const installed = await runInstall(root, text.manager);
+    progress.stop(text, installed.ok);
+    if (!installed.ok)
+        out.stderr(failedOutput(installed.output));
+    return installed.ok;
+}
+/**
+ * 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) {
-        const text = { kind: "install-deps", manager };
-        progress.start(text);
-        const installed = await runInstall(root, manager);
-        progress.stop(text, installed.ok);
-        if (!installed.ok) {
-            out.stderr(failedOutput(installed.output));
-            out.stdout(`\n${summary} No commiteé: el install falló y los cambios quedan sin commit.\n`);
-            return 1;
-        }
+    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[];
+}>;