@yagni-app/code-staging 1.1.0-staging.1329.1 → 1.1.0-staging.1334.1

package/dist/cli.d.ts

@@ -12,6 +12,7 @@
  * plus a configured pi spawn. Everything that makes this "YAGNI Code" lives in
  * pi-extension-yagni and the YAGNI backend.
  */
+import { promptKeepOrRemoveWorktree } from "./worktreeExitPrompt.js";
 /**
  * Seed `editorPaddingX` into the per-profile pi `settings.json` so the prompt
  * input aligns with the chat/output area (`outputPad`) and the status bar.
@@ -42,6 +43,56 @@ export declare function seedCollapseChangelog(piAgentDir: string): void;
  * persists the user's choice, so this default is always reversible.
  */
 export declare function seedHideThinkingBlock(piAgentDir: string): boolean;
+/** The structural slice of the extension's session-worktree entry (by file path). */
+interface SessionWorktreeModule {
+    createOrResume: (name: string | undefined, deps: {
+        repoCwd: string;
+    }) => Promise<{
+        worktreePath: string;
+        branch: string;
+        existed: boolean;
+    }>;
+    /** Optional so a stale bundled extension (without the exit prompt support) degrades to the durable summary. */
+    removeSessionWorktree?: (worktreePath: string, branch: string, deps: {
+        repoCwd: string;
+    }) => Promise<{
+        removed: boolean;
+        branchRemoved: boolean;
+        note?: string;
+        branchUnmerged?: boolean;
+    }>;
+}
+/** Seams `handleWorktreeExit` needs; the real one lives in the extension. */
+type WorktreeRemover = NonNullable<SessionWorktreeModule["removeSessionWorktree"]>;
+/** Minimal stream shapes for testability (process.stdin/stderr satisfy these). */
+interface WriteOnlyStream {
+    write(chunk: string): unknown;
+    isTTY?: boolean;
+}
+interface ReadablePromptStream {
+    isTTY?: boolean;
+}
+/** Pure: the one-line worktree summary for the kept path. */
+export declare function worktreeKeptSummary(worktreePath: string, branch: string, existed: boolean): string;
+/**
+ * The post-session worktree exit: prompt Keep/Remove on interactive text
+ * sessions, perform the removal when chosen, and print exactly ONE summary
+ * (kept / not removed / removed) to stderr. Fail-safe in every direction:
+ * an aborted prompt, a refused removal, or an erroring remover all leave the
+ * worktree in place with the durable resume summary printed.
+ */
+export declare function handleWorktreeExit(deps: {
+    worktreePath: string;
+    branch: string;
+    existed: boolean;
+    outputFormat: string;
+    remainingArgs: string[];
+    stdin: ReadablePromptStream;
+    stderr: WriteOnlyStream;
+    cwd: string;
+    removeWorktree?: WorktreeRemover;
+    prompt?: typeof promptKeepOrRemoveWorktree;
+}): Promise<void>;
 export declare const HELP_TEXT: string;
 /** Parse `use <name> [--base-url <url>]` argv into its parts. */
 export declare function parseUseArgs(args: string[]): {
@@ -82,4 +133,5 @@ export declare function main(argv: string[]): Promise<number>;
  * test import (argv[1] points at the test runner) does not.
  */
 export declare function isEntrypoint(argv1: string | undefined, moduleUrl: string): boolean;
+export {};
 //# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -14,7 +14,7 @@
  */
 import { spawn } from "node:child_process";
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { PI_CONFIG_NAME } from "./branding.js";
@@ -38,7 +38,8 @@ import { currentCliVersion, maybeNudgeAndRefresh, upgradeCommand } from "./upgra
 import { maybeRefreshAtLaunch } from "./refresh.js";
 import { exitCodeFor, installSignalForwarding } from "./signalForward.js";
 import { PAD_X } from "./padding.js";
-import { parseWorktreeFlag, validateWorktreeLaunchArgs } from "./worktreeArgs.js";
+import { canPromptWorktreeCleanup, parseWorktreeFlag, validateWorktreeLaunchArgs, } from "./worktreeArgs.js";
+import { promptKeepOrRemoveWorktree } from "./worktreeExitPrompt.js";
 import { ensureShadowPiPackage } from "./piPackage.js";
 import { resolveExtensionPath, resolvePiCliPath, resolvePiPackageDir, resolveSessionWorktreePath } from "./paths.js";
 import { credentialsFromProfile, getActiveProfileName, listProfiles, migrateLegacyCredentials, persistProfileTokenRotation, profilePath, readActiveProfile, useProfile, } from "./profiles.js";
@@ -371,7 +372,8 @@ async function defaultLoadSessionWorktree() {
  *
  * Delegates all git behavior to the extension's `sessionWorktree` entry; this
  * launcher path only resolves credentials, builds the plan, and spawns pi with
- * `cwd` = the worktree. The worktree is DURABLE — nothing is ever removed.
+ * `cwd` = the worktree. Durable by default: nothing is removed unless the
+ * user explicitly picks Remove at the interactive exit prompt.
  */
 async function runWorktreeLaunch(passthroughArgs, worktreeName, loadSessionWorktree = defaultLoadSessionWorktree) {
     // Validate the name + argv before any side effect (slug guard + `-c`
@@ -486,13 +488,104 @@ async function runWorktreeLaunch(passthroughArgs, worktreeName, loadSessionWorkt
         outputFormat,
         cwd: result.worktreePath,
     });
-    // Durable by default: nothing is removed. Tell the user where their work
-    // lives (stderr only — never stdout, to keep json clean).
-    process.stderr.write(`[yagni] worktree ${result.existed ? "resumed" : "created"}: ${result.worktreePath}\n` +
-        `[yagni] branch: ${result.branch}\n` +
-        `[yagni] resume: cd ${result.worktreePath} && yagni\n`);
+    // Interactive text sessions get a Keep/Remove list (Claude Code parity).
+    // Machine-readable runs (`--output-format json|stream-json`), one-shot `-p`
+    // runs, and piped stdin keep the durable-by-default behavior: no prompt,
+    // nothing removed. A stale bundled extension without
+    // `removeSessionWorktree` also degrades to the durable summary. All output
+    // is stderr — stdout stays clean for every output format.
+    await handleWorktreeExit({
+        worktreePath: result.worktreePath,
+        branch: result.branch,
+        existed: result.existed,
+        outputFormat,
+        remainingArgs,
+        stdin: process.stdin,
+        stderr: process.stderr,
+        cwd: process.cwd(),
+        removeWorktree: sessionWorktree.removeSessionWorktree,
+    });
     return exitCode;
 }
+/** Pure: the one-line worktree summary for the kept path. */
+export function worktreeKeptSummary(worktreePath, branch, existed) {
+    return (`[yagni] worktree ${existed ? "resumed" : "created"}: ${worktreePath}\n` +
+        `[yagni] branch: ${branch}\n` +
+        `[yagni] resume: cd ${worktreePath} && yagni\n`);
+}
+/**
+ * The post-session worktree exit: prompt Keep/Remove on interactive text
+ * sessions, perform the removal when chosen, and print exactly ONE summary
+ * (kept / not removed / removed) to stderr. Fail-safe in every direction:
+ * an aborted prompt, a refused removal, or an erroring remover all leave the
+ * worktree in place with the durable resume summary printed.
+ */
+export async function handleWorktreeExit(deps) {
+    const { worktreePath, branch, existed, outputFormat, remainingArgs, stdin, stderr, cwd, removeWorktree, } = deps;
+    const prompt = deps.prompt ?? promptKeepOrRemoveWorktree;
+    const canPrompt = canPromptWorktreeCleanup(outputFormat, remainingArgs, stdin.isTTY === true) &&
+        removeWorktree !== undefined;
+    let choice;
+    if (canPrompt) {
+        try {
+            choice = await prompt({
+                input: stdin,
+                output: stderr,
+                label: `${worktreePath} — keep or remove?`,
+            });
+        }
+        catch (err) {
+            // A genuine prompt failure (stdin/raw-mode error) must not read as a
+            // silent no-op: say it failed, then keep the worktree as with any abort.
+            stderr.write(`[yagni] exit prompt failed: ${err instanceof Error ? err.message : String(err)}; worktree kept\n`);
+            choice = undefined;
+        }
+    }
+    if (choice !== "remove") {
+        // Keep (default), aborted prompt, or prompt suppressed: durable summary.
+        stderr.write(worktreeKeptSummary(worktreePath, branch, existed));
+        return;
+    }
+    let outcome;
+    try {
+        outcome = await removeWorktree(worktreePath, branch, { repoCwd: cwd });
+    }
+    catch (err) {
+        // The remover throwing (vs returning removed:false) still keeps the work;
+        // never let cleanup turn a successful session into a nonzero exit.
+        stderr.write(`[yagni] worktree NOT removed: ${err instanceof Error ? err.message : String(err)}\n` +
+            worktreeKeptSummary(worktreePath, branch, existed));
+        return;
+    }
+    if (!outcome.removed) {
+        // Git refused (dirty worktree) or failed — the work and the resume path
+        // are both intact, so say so and print the kept summary (not a duplicate).
+        stderr.write(`[yagni] worktree NOT removed${outcome.note ? `: ${outcome.note}` : ""}\n` +
+            worktreeKeptSummary(worktreePath, branch, existed));
+        return;
+    }
+    stderr.write(`[yagni] worktree removed\n` +
+        branchKeptMessage(outcome, branch, worktreePath));
+}
+/**
+ * The branch-status tail of the removed summary. The extension's safe `-d`
+ * (never `-D`) keeps an unmerged branch on disk when its worktree is removed,
+ * so the recovery hint points at an ABSOLUTE path (works from any cwd; a
+ * relative .worktrees/<slug> only resolves from the main repo root). A
+ * branch kept for another reason (checked out elsewhere, git error) states
+ * that reason itself instead of the generic unmerged framing.
+ */
+function branchKeptMessage(outcome, branch, worktreePath) {
+    if (outcome.branchRemoved)
+        return "";
+    const slug = branch.replace(/^agent\//, "");
+    const recovery = `[yagni] branch ${branch} kept — recover with: ` +
+        `git worktree add "${join(dirname(worktreePath), slug)}" ${branch}\n`;
+    if (outcome.branchUnmerged)
+        return recovery;
+    const reason = (outcome.note ?? "unknown reason").replace(/\s+/g, " ").trim();
+    return `[yagni] branch ${branch} kept: ${reason}\n` + recovery;
+}
 export const HELP_TEXT = [
     "YAGNI Code — a business-context-grounded terminal coding agent.",
     "",

package/dist/extension/pipeline/sessionWorktree.d.ts

@@ -10,6 +10,8 @@
  *  - **Add-only creation.** Every git op is `worktree add`, `fetch`, `show-ref`,
  *    `symbolic-ref`, or `rev-parse`. Nothing deletes, force-resets, or
  *    `branch -D`s — the worktree is DURABLE by default and never auto-removed.
+ *    The ONE removal path is `removeSessionWorktree`, which runs only after an
+ *    explicit "Remove worktree" choice at session exit (never automatic).
  *  - **Get-or-resume.** An existing worktree dir is resumed, never recreated.
  *  - **Lazy fetch.** Base `origin/<default>` is read from the local ref when
  *    present; `git fetch` only runs when that ref is absent, and always with
@@ -23,6 +25,18 @@
  * (both gitignored in-repo). PR refs (`#N`, GitHub PR URLs) map to `pr-<N>` and
  * base on `FETCH_HEAD`.
  */
+export interface RemoveSessionWorktreeResult {
+    /** True when the worktree directory is gone from disk. */
+    removed: boolean;
+    /** True when the `agent/<slug>` branch was also deleted (`-d`, safe delete). */
+    branchRemoved: boolean;
+    /** Non-fatal note when cleanup was attempted but could not finish. */
+    note?: string;
+    /** True when the branch was kept because it is not fully merged (the benign
+     * case the recovery hint describes); false when it was kept for another
+     * reason (checked out elsewhere, git error) — the note carries that. */
+    branchUnmerged?: boolean;
+}
 export interface SessionWorktreeResult {
     /** Absolute destination (under `<mainRepo>/.worktrees/<slug>`). */
     worktreePath: string;
@@ -61,4 +75,29 @@ export declare function parsePRReference(input: string): number | null;
  * branch/worktree: validation happens first, and `git worktree add` is atomic.
  */
 export declare function createOrResume(name: string | undefined, deps: CreateOrResumeDeps): Promise<SessionWorktreeResult>;
+/**
+ * Remove a session worktree the user explicitly chose to discard at exit.
+ *
+ * The user's only entry into this is the launcher's "Remove worktree" prompt;
+ * it is NEVER called automatically. Cleanup checks the worktree again at exit:
+ *
+ *  - Require the original branch: removing a clean detached HEAD would discard
+ *    its only reference and reflog, even without `--force`.
+ *  - Refuse ignored content, which Git's dirty check does not protect. This
+ *    includes dependency directories and local env files; review those manually.
+ *  - `git worktree remove` without `--force` refuses tracked changes and
+ *    non-ignored untracked files. `git branch -d` retains branches Git considers
+ *    unmerged (against their upstream, or the main checkout's HEAD).
+ *
+ * These checks do not lock out concurrent edits by other sessions or Git clients.
+ *
+ * `repoCwd` is only used to locate the repo (resolved to the main repo root
+ * before any git op, same as `createOrResume`): the user may have launched
+ * `yagni -w` from inside the worktree being removed, and after `git worktree
+ * remove` that cwd no longer exists on disk.
+ */
+export declare function removeSessionWorktree(worktreePath: string, branch: string, deps: {
+    repoCwd: string;
+    gitImpl?: SessionGit;
+}): Promise<RemoveSessionWorktreeResult>;
 //# sourceMappingURL=sessionWorktree.d.ts.map

package/dist/extension/pipeline/sessionWorktree.js

@@ -10,6 +10,8 @@
  *  - **Add-only creation.** Every git op is `worktree add`, `fetch`, `show-ref`,
  *    `symbolic-ref`, or `rev-parse`. Nothing deletes, force-resets, or
  *    `branch -D`s — the worktree is DURABLE by default and never auto-removed.
+ *    The ONE removal path is `removeSessionWorktree`, which runs only after an
+ *    explicit "Remove worktree" choice at session exit (never automatic).
  *  - **Get-or-resume.** An existing worktree dir is resumed, never recreated.
  *  - **Lazy fetch.** Base `origin/<default>` is read from the local ref when
  *    present; `git fetch` only runs when that ref is absent, and always with
@@ -103,7 +105,7 @@ async function resolveMainRepo(gitImpl, repoCwd) {
         topLevel = await gitImpl(["rev-parse", "--show-toplevel"], repoCwd);
     }
     catch (err) {
-        throw new Error(`Cannot create a worktree: not inside a git repository. ` +
+        throw new Error(`Cannot resolve the repository root: not inside a git repository. ` +
             `${err instanceof Error ? err.message : String(err)}`);
     }
     const common = await gitImpl(["rev-parse", "--git-common-dir"], repoCwd);
@@ -222,4 +224,80 @@ export async function createOrResume(name, deps) {
     }
     return { worktreePath, branch, existed: false };
 }
+/**
+ * Remove a session worktree the user explicitly chose to discard at exit.
+ *
+ * The user's only entry into this is the launcher's "Remove worktree" prompt;
+ * it is NEVER called automatically. Cleanup checks the worktree again at exit:
+ *
+ *  - Require the original branch: removing a clean detached HEAD would discard
+ *    its only reference and reflog, even without `--force`.
+ *  - Refuse ignored content, which Git's dirty check does not protect. This
+ *    includes dependency directories and local env files; review those manually.
+ *  - `git worktree remove` without `--force` refuses tracked changes and
+ *    non-ignored untracked files. `git branch -d` retains branches Git considers
+ *    unmerged (against their upstream, or the main checkout's HEAD).
+ *
+ * These checks do not lock out concurrent edits by other sessions or Git clients.
+ *
+ * `repoCwd` is only used to locate the repo (resolved to the main repo root
+ * before any git op, same as `createOrResume`): the user may have launched
+ * `yagni -w` from inside the worktree being removed, and after `git worktree
+ * remove` that cwd no longer exists on disk.
+ */
+export async function removeSessionWorktree(worktreePath, branch, deps) {
+    const gitImpl = deps.gitImpl ?? defaultGit;
+    // Resolve the MAIN repo root first: every later git op must run from a cwd
+    // that survives the removal (repoCwd may be the worktree being removed).
+    const repoRoot = await resolveMainRepo(gitImpl, deps.repoCwd);
+    try {
+        const ignored = await gitImpl(["ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "-z"], worktreePath);
+        if (ignored) {
+            const paths = ignored.split("\0").filter(Boolean);
+            const preview = paths.slice(0, 5).map((path) => JSON.stringify(path)).join(", ");
+            const more = paths.length > 5 ? ` (+${paths.length - 5} more)` : "";
+            return {
+                removed: false,
+                branchRemoved: false,
+                note: `worktree contains ignored content: ${preview}${more}; review and remove it manually before retrying cleanup`,
+            };
+        }
+        const headRef = await gitImpl(["rev-parse", "--symbolic-full-name", "HEAD"], worktreePath);
+        if (headRef !== `refs/heads/${branch}`) {
+            return {
+                removed: false,
+                branchRemoved: false,
+                note: headRef === "HEAD"
+                    ? "worktree HEAD is detached; preserve that work on a branch before retrying cleanup"
+                    : `worktree HEAD is ${JSON.stringify(headRef)}, no longer on branch ${branch}; preserve that work before retrying cleanup`,
+            };
+        }
+        await gitImpl(["worktree", "remove", worktreePath], repoRoot);
+    }
+    catch (err) {
+        return {
+            removed: false,
+            branchRemoved: false,
+            note: err instanceof Error ? err.message : String(err),
+        };
+    }
+    // Safe delete: only removes a fully-merged branch. Unmerged work stays
+    // recoverable on the branch — the directory is gone but the ref is not.
+    try {
+        await gitImpl(["branch", "-d", branch], repoRoot);
+        return { removed: true, branchRemoved: true };
+    }
+    catch (err) {
+        // Distinguish the benign case (unmerged branch, deliberately kept) from
+        // a git-level failure so the exit summary can say which it was.
+        const message = err instanceof Error ? err.message : String(err);
+        const unmerged = /not fully merged|unmerged/i.test(message);
+        return {
+            removed: true,
+            branchRemoved: false,
+            branchUnmerged: unmerged,
+            ...(unmerged ? {} : { note: message }),
+        };
+    }
+}
 //# sourceMappingURL=sessionWorktree.js.map

package/dist/worktreeArgs.d.ts

@@ -33,6 +33,17 @@ export declare function parsePRReference(input: string): number | null;
  * with a clear message (surfaced by the caller).
  */
 export declare function validateWorktreeSlug(slug: string): void;
+/**
+ * Whether a `-w` session exit can show the interactive Keep/Remove prompt.
+ *
+ * The prompt is an interactive-TUI-only affordance. It is suppressed for:
+ *  - `--output-format json|stream-json` (machine-readable stdout must stay a
+ *    single clean result object; a trailing readline prompt would corrupt it);
+ *  - `-p`/`--print` one-shot runs (they exit, they never linger for a prompt);
+ *  - non-TTY stdin (piped/CI runs must not hang on a question nobody answers).
+ * The default `text` format with a TTY is the only path that prompts.
+ */
+export declare function canPromptWorktreeCleanup(outputFormat: string, remainingArgs: string[], isTTY: boolean): boolean;
 /**
  * Validate the `-w` name + argv before any side effect. Returns a user-facing
  * error message when the launch should be refused, or `undefined` to proceed.

package/dist/worktreeArgs.js

@@ -73,6 +73,23 @@ export function validateWorktreeSlug(slug) {
         }
     }
 }
+/**
+ * Whether a `-w` session exit can show the interactive Keep/Remove prompt.
+ *
+ * The prompt is an interactive-TUI-only affordance. It is suppressed for:
+ *  - `--output-format json|stream-json` (machine-readable stdout must stay a
+ *    single clean result object; a trailing readline prompt would corrupt it);
+ *  - `-p`/`--print` one-shot runs (they exit, they never linger for a prompt);
+ *  - non-TTY stdin (piped/CI runs must not hang on a question nobody answers).
+ * The default `text` format with a TTY is the only path that prompts.
+ */
+export function canPromptWorktreeCleanup(outputFormat, remainingArgs, isTTY) {
+    if (outputFormat !== "text")
+        return false;
+    if (!isTTY)
+        return false;
+    return !remainingArgs.some((a) => a === "-p" || a === "--print" || a.startsWith("--print="));
+}
 /**
  * Validate the `-w` name + argv before any side effect. Returns a user-facing
  * error message when the launch should be refused, or `undefined` to proceed.

package/dist/worktreeExitPrompt.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The arrow-key Keep/Remove list shown after an interactive `-w` session exits.
+ *
+ * Claude Code parity: a two-option list navigated with the up/down arrows and
+ * confirmed with Enter — not a y/N question. Keep is the default (highlighted
+ * first), and every escape hatch — Esc, q, Ctrl+C, EOF, a non-TTY stream —
+ * fails safe to Keep (resolves `undefined`, which callers treat as keep).
+ *
+ * This module owns the raw-TTY interaction only. The gating (which launches
+ * may prompt at all) lives in `canPromptWorktreeCleanup` (worktreeArgs.ts),
+ * and the git behavior lives in the extension's `removeSessionWorktree`.
+ */
+export type WorktreeExitChoice = "keep" | "remove";
+/** Minimal stream shape the prompt needs (satisfied by process.stdin/stderr). */
+export interface ExitPromptStream {
+    write(chunk: string): unknown;
+    isTTY?: boolean;
+}
+/** The structural slice of a readline keypress event. */
+export interface ExitPromptKey {
+    name?: string;
+    ctrl?: boolean;
+}
+export type ExitPromptAction = {
+    type: "toggle";
+} | {
+    type: "confirm";
+} | {
+    type: "abort";
+} | {
+    type: "noop";
+};
+/**
+ * Map a keypress to its prompt action (pure, unit-tested). Arrows (plus
+ * k/j/tab) toggle between the two options; Enter or Space confirms; Esc, q,
+ * Ctrl+C, and Ctrl+D abort (fail-safe to Keep); anything else is ignored so
+ * stray keys can neither confirm nor abort by accident.
+ */
+export declare function exitPromptAction(key: ExitPromptKey): ExitPromptAction;
+/**
+ * Show the Keep/Remove list and resolve with the user's choice.
+ *
+ * Resolves `"keep"`/`"remove"` on Enter, or `undefined` when aborted
+ * (Esc/q/Ctrl+C/Ctrl+D/EOF) or when either stream is not a TTY — callers treat
+ * `undefined` exactly like `"keep"`: nothing is removed.
+ */
+export declare function promptKeepOrRemoveWorktree(opts: {
+    input: NodeJS.ReadStream & {
+        isTTY?: boolean;
+    };
+    output: ExitPromptStream;
+    label: string;
+}): Promise<WorktreeExitChoice | undefined>;
+//# sourceMappingURL=worktreeExitPrompt.d.ts.map

package/dist/worktreeExitPrompt.js

@@ -0,0 +1,108 @@
+/**
+ * The arrow-key Keep/Remove list shown after an interactive `-w` session exits.
+ *
+ * Claude Code parity: a two-option list navigated with the up/down arrows and
+ * confirmed with Enter — not a y/N question. Keep is the default (highlighted
+ * first), and every escape hatch — Esc, q, Ctrl+C, EOF, a non-TTY stream —
+ * fails safe to Keep (resolves `undefined`, which callers treat as keep).
+ *
+ * This module owns the raw-TTY interaction only. The gating (which launches
+ * may prompt at all) lives in `canPromptWorktreeCleanup` (worktreeArgs.ts),
+ * and the git behavior lives in the extension's `removeSessionWorktree`.
+ */
+import { emitKeypressEvents } from "node:readline";
+const OPTION_KEEP = "Keep worktree";
+const OPTION_REMOVE = "Remove worktree";
+/**
+ * Map a keypress to its prompt action (pure, unit-tested). Arrows (plus
+ * k/j/tab) toggle between the two options; Enter or Space confirms; Esc, q,
+ * Ctrl+C, and Ctrl+D abort (fail-safe to Keep); anything else is ignored so
+ * stray keys can neither confirm nor abort by accident.
+ */
+export function exitPromptAction(key) {
+    if (key.ctrl && (key.name === "c" || key.name === "d"))
+        return { type: "abort" };
+    switch (key.name) {
+        case "up":
+        case "down":
+        case "k":
+        case "j":
+        case "tab":
+            return { type: "toggle" };
+        case "return":
+        case "enter":
+        case "space":
+            return { type: "confirm" };
+        case "escape":
+        case "q":
+            return { type: "abort" };
+        default:
+            return { type: "noop" };
+    }
+}
+function renderOptions(output, index) {
+    const marker = (i) => (i === index ? "❯ " : "  ");
+    output.write(`\r\x1b[2K${marker(0)}${OPTION_KEEP}\n`);
+    output.write(`\r\x1b[2K${marker(1)}${OPTION_REMOVE}\n`);
+}
+/** Erase the two option lines, leaving the cursor just below where they were. */
+function eraseOptions(output) {
+    output.write("\x1b[2A\r\x1b[2K\x1b[1B\r\x1b[2K\x1b[1B");
+}
+/**
+ * Show the Keep/Remove list and resolve with the user's choice.
+ *
+ * Resolves `"keep"`/`"remove"` on Enter, or `undefined` when aborted
+ * (Esc/q/Ctrl+C/Ctrl+D/EOF) or when either stream is not a TTY — callers treat
+ * `undefined` exactly like `"keep"`: nothing is removed.
+ */
+export async function promptKeepOrRemoveWorktree(opts) {
+    const { input, output, label } = opts;
+    // Fail safe when the terminal cannot render an interactive list.
+    if (input.isTTY !== true || output.isTTY !== true)
+        return undefined;
+    let index = 0; // Keep is the default
+    output.write(`\n[yagni] ${label}\n`);
+    renderOptions(output, index);
+    const canRawMode = typeof input.setRawMode === "function";
+    const wasRaw = canRawMode ? input.isRaw === true : false;
+    if (canRawMode)
+        input.setRawMode(true);
+    emitKeypressEvents(input);
+    input.resume();
+    try {
+        return await new Promise((resolve) => {
+            const cleanup = () => {
+                input.removeListener("keypress", onKeypress);
+                input.removeListener("end", onEnd);
+            };
+            const onKeypress = (_str, key) => {
+                const action = exitPromptAction(key ?? {});
+                if (action.type === "noop")
+                    return;
+                if (action.type === "toggle") {
+                    index = index === 0 ? 1 : 0;
+                    eraseOptions(output);
+                    renderOptions(output, index);
+                    return;
+                }
+                cleanup();
+                eraseOptions(output);
+                resolve(action.type === "confirm" ? (index === 0 ? "keep" : "remove") : undefined);
+            };
+            // EOF (Ctrl+D is caught above as abort; a closed stdin arrives here).
+            const onEnd = () => {
+                cleanup();
+                resolve(undefined);
+            };
+            input.on("keypress", onKeypress);
+            input.on("end", onEnd);
+        });
+    }
+    finally {
+        if (canRawMode)
+            input.setRawMode(wasRaw);
+        input.pause();
+    }
+}
+//# sourceMappingURL=worktreeExitPrompt.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.1.0-staging.1329.1",
+  "version": "1.1.0-staging.1334.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "36a0344047224a979e0714451f6e710658d1454b"
+  "yagniSourceSha": "b7b91c0bf94f197fc16643cb9a5c5f580e896001"
 }