@yagni-app/code-staging 1.1.1-staging.1338.1 → 1.1.1-staging.1340.1

package/dist/cli.d.ts

@@ -55,15 +55,47 @@ interface SessionWorktreeModule {
     /** Optional so a stale bundled extension (without the exit prompt support) degrades to the durable summary. */
     removeSessionWorktree?: (worktreePath: string, branch: string, deps: {
         repoCwd: string;
+        discardIgnored?: string[];
     }) => Promise<{
         removed: boolean;
         branchRemoved: boolean;
         note?: string;
         branchUnmerged?: boolean;
+        ignoredDiscarded?: string[];
+    }>;
+    /** Optional pre-prompt scan of ignored content, so the prompt can name what removal discards. */
+    inspectIgnoredContent?: (worktreePath: string, deps: {
+        repoCwd: string;
+    }) => Promise<{
+        disposable: string[];
+        keepworthy: string[];
+        error?: string;
     }>;
 }
-/** Seams `handleWorktreeExit` needs; the real one lives in the extension. */
+/** Seams `handleWorktreeExit` needs; the real ones live in the extension. */
 type WorktreeRemover = NonNullable<SessionWorktreeModule["removeSessionWorktree"]>;
+type WorktreeIgnoredInspector = NonNullable<SessionWorktreeModule["inspectIgnoredContent"]>;
+/**
+ * Pure: quoted, bounded rendering of an ignored-path list for one output line.
+ * Deliberately mirrors the extension's own helper rather than importing it: the
+ * launcher must be able to render this even against a stale bundled extension.
+ */
+export declare function previewIgnoredPaths(paths: string[]): string;
+/**
+ * Pure: how the Remove option and its warning read given the pre-prompt scan.
+ * With nothing at risk (the normal case: dependencies, build output, and env
+ * files copied from the main checkout), Remove is unadorned and removal is a
+ * single keypress. With entries that exist only here, the option names the
+ * count and a note names them, so discarding is always a deliberate choice.
+ * "Entries", not "files": a trailing-slash entry is a whole directory.
+ */
+export declare function removeOptionCopy(report: {
+    keepworthy: string[];
+    error?: string;
+}): {
+    removeLabel?: string;
+    notes: string[];
+};
 /** Minimal stream shapes for testability (process.stdin/stderr satisfy these). */
 interface WriteOnlyStream {
     write(chunk: string): unknown;
@@ -91,6 +123,7 @@ export declare function handleWorktreeExit(deps: {
     stderr: WriteOnlyStream;
     cwd: string;
     removeWorktree?: WorktreeRemover;
+    inspectIgnored?: WorktreeIgnoredInspector;
     prompt?: typeof promptKeepOrRemoveWorktree;
 }): Promise<void>;
 export declare const HELP_TEXT: string;

package/dist/cli.js

@@ -504,9 +504,47 @@ async function runWorktreeLaunch(passthroughArgs, worktreeName, loadSessionWorkt
         stderr: process.stderr,
         cwd: process.cwd(),
         removeWorktree: sessionWorktree.removeSessionWorktree,
+        inspectIgnored: sessionWorktree.inspectIgnoredContent,
     });
     return exitCode;
 }
+/** How many ignored paths a prompt note or summary line names before "+N more". */
+const IGNORED_PREVIEW = 5;
+/**
+ * Pure: quoted, bounded rendering of an ignored-path list for one output line.
+ * Deliberately mirrors the extension's own helper rather than importing it: the
+ * launcher must be able to render this even against a stale bundled extension.
+ */
+export function previewIgnoredPaths(paths) {
+    const preview = paths.slice(0, IGNORED_PREVIEW).map((path) => JSON.stringify(path)).join(", ");
+    return paths.length > IGNORED_PREVIEW ? `${preview} (+${paths.length - IGNORED_PREVIEW} more)` : preview;
+}
+/**
+ * Pure: how the Remove option and its warning read given the pre-prompt scan.
+ * With nothing at risk (the normal case: dependencies, build output, and env
+ * files copied from the main checkout), Remove is unadorned and removal is a
+ * single keypress. With entries that exist only here, the option names the
+ * count and a note names them, so discarding is always a deliberate choice.
+ * "Entries", not "files": a trailing-slash entry is a whole directory.
+ */
+export function removeOptionCopy(report) {
+    if (report.error !== undefined) {
+        // Never let "I could not look" render as the same clean prompt as "I looked
+        // and there is nothing to lose". Removal re-checks and refuses on its own.
+        return { notes: [`could not check what removal would discard: ${report.error.replace(/\s+/g, " ").trim()}`] };
+    }
+    const count = report.keepworthy.length;
+    if (count === 0)
+        return { notes: [] };
+    const noun = count === 1 ? "entry" : "entries";
+    return {
+        removeLabel: `Remove worktree and ${count} ignored ${noun}`,
+        notes: [
+            `${count} ignored ${noun} ${count === 1 ? "exists" : "exist"} only here and would be lost: ` +
+                previewIgnoredPaths(report.keepworthy),
+        ],
+    };
+}
 /** Pure: the one-line worktree summary for the kept path. */
 export function worktreeKeptSummary(worktreePath, branch, existed) {
     return (`[yagni] worktree ${existed ? "resumed" : "created"}: ${worktreePath}\n` +
@@ -521,10 +559,25 @@ export function worktreeKeptSummary(worktreePath, branch, existed) {
  * 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 { worktreePath, branch, existed, outputFormat, remainingArgs, stdin, stderr, cwd, removeWorktree, inspectIgnored, } = deps;
     const prompt = deps.prompt ?? promptKeepOrRemoveWorktree;
     const canPrompt = canPromptWorktreeCleanup(outputFormat, remainingArgs, stdin.isTTY === true) &&
         removeWorktree !== undefined;
+    // Scan before asking, so the prompt itself can say what removal would discard.
+    // A scan that fails says so in the prompt; a missing one (stale extension)
+    // leaves the prompt unadorned. Either way the remover runs the same check
+    // again and refuses on its own if anything unique is in there.
+    let report = { keepworthy: [] };
+    if (canPrompt && inspectIgnored) {
+        try {
+            report = await inspectIgnored(worktreePath, { repoCwd: cwd });
+        }
+        catch (err) {
+            report = { keepworthy: [], error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    const keepworthy = report.error === undefined ? report.keepworthy : [];
+    const { removeLabel, notes } = removeOptionCopy(report);
     let choice;
     if (canPrompt) {
         try {
@@ -532,6 +585,8 @@ export async function handleWorktreeExit(deps) {
                 input: stdin,
                 output: stderr,
                 label: `${worktreePath} — keep or remove?`,
+                ...(removeLabel ? { removeLabel } : {}),
+                ...(notes.length > 0 ? { notes } : {}),
             });
         }
         catch (err) {
@@ -548,7 +603,12 @@ export async function handleWorktreeExit(deps) {
     }
     let outcome;
     try {
-        outcome = await removeWorktree(worktreePath, branch, { repoCwd: cwd });
+        // The user chose Remove while looking at `keepworthy`, so pass exactly that
+        // list as acknowledged; anything that appeared since still blocks.
+        outcome = await removeWorktree(worktreePath, branch, {
+            repoCwd: cwd,
+            ...(keepworthy.length > 0 ? { discardIgnored: keepworthy } : {}),
+        });
     }
     catch (err) {
         // The remover throwing (vs returning removed:false) still keeps the work;
@@ -565,8 +625,20 @@ export async function handleWorktreeExit(deps) {
         return;
     }
     stderr.write(`[yagni] worktree removed\n` +
+        ignoredDiscardedMessage(outcome.ignoredDiscarded ?? []) +
         branchKeptMessage(outcome, branch, worktreePath));
 }
+/**
+ * The "and this went with it" line. Ignored content is deleted silently by
+ * `git worktree remove`, so removal says what it took: dependencies and build
+ * state are regenerable, but the user should still see the list, not guess.
+ */
+function ignoredDiscardedMessage(discarded) {
+    if (discarded.length === 0)
+        return "";
+    const noun = discarded.length === 1 ? "entry" : "entries";
+    return `[yagni] discarded ${discarded.length} ignored ${noun}: ${previewIgnoredPaths(discarded)}\n`;
+}
 /**
  * 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,

package/dist/extension/mineBeat.js

@@ -189,7 +189,7 @@ export async function maybeOfferMiningBeat(ctx, opts) {
             return { offered: true, accepted: true, banked: 0 };
         const banked = typeof body.banked === "number" ? body.banked : 0;
         const noun = banked === 1 ? "decision" : "decisions";
-        ctx.ui.notify(`Banked ${banked} ${noun} read from this repo's docs. Review them: ${opts.baseUrl}/knowledge/decisions`, "info");
+        ctx.ui.notify(`Banked ${banked} ${noun} read from this repo's docs. Review them: ${opts.baseUrl}/decisions`, "info");
         return { offered: true, accepted: true, banked };
     }
     catch {

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

@@ -25,6 +25,39 @@
  * (both gitignored in-repo). PR refs (`#N`, GitHub PR URLs) map to `pr-<N>` and
  * base on `FETCH_HEAD`.
  */
+/** What an ignored-content scan found in a worktree that is up for removal. */
+export interface IgnoredContentReport {
+    /** Safe to delete: regenerable build state, or a copy the main checkout still has. */
+    disposable: string[];
+    /** Exists ONLY here: deleting it loses something git cannot give back. */
+    keepworthy: string[];
+    /** Set when the scan itself failed; both lists are then empty. */
+    error?: string;
+}
+/**
+ * True when an ignored path is dependency/build state something regenerates.
+ *
+ * `git ls-files --directory` collapses a fully-ignored directory to
+ * `node_modules/`, but a partially-ignored tree yields deeper paths, so every
+ * DIRECTORY segment is checked (a file merely named `out` is not build output).
+ * Generic build names need `hasPackageManifest` to confirm a build tool owns
+ * the directory they sit in, the repo root included; without the seam every
+ * generic name answers false, which is the safe direction.
+ */
+export declare function isRegenerableIgnoredPath(path: string, hasPackageManifest?: (relDir: string) => boolean): boolean;
+/** Render an ignored-path list for a user-facing note: quoted and bounded. */
+export declare function previewIgnoredPaths(paths: string[]): string;
+/**
+ * Scan a worktree's ignored content and split it into what cleanup may delete
+ * on its own and what it must be told to discard first.
+ *
+ * Exported so the launcher can run it BEFORE the Keep/Remove prompt and name
+ * the at-risk files in the prompt itself, instead of refusing after the fact.
+ */
+export declare function inspectIgnoredContent(worktreePath: string, deps: {
+    repoCwd: string;
+    gitImpl?: SessionGit;
+}): Promise<IgnoredContentReport>;
 export interface RemoveSessionWorktreeResult {
     /** True when the worktree directory is gone from disk. */
     removed: boolean;
@@ -36,6 +69,9 @@ export interface RemoveSessionWorktreeResult {
      * case the recovery hint describes); false when it was kept for another
      * reason (checked out elsewhere, git error) — the note carries that. */
     branchUnmerged?: boolean;
+    /** Ignored entries (dependency/build state, copied env files) deleted with the
+     * worktree, so the caller can report what went with it. Empty when nothing was. */
+    ignoredDiscarded?: string[];
 }
 export interface SessionWorktreeResult {
     /** Absolute destination (under `<mainRepo>/.worktrees/<slug>`). */
@@ -83,13 +119,19 @@ export declare function createOrResume(name: string | undefined, deps: CreateOrR
  *
  *  - 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.
+ *  - Sort ignored content (which Git's dirty check does not cover) into what a
+ *    bootstrap regenerates or the main checkout still holds a copy of, and what
+ *    exists only here. The first kind goes with the worktree; the second kind
+ *    blocks cleanup unless the caller passes it in `discardIgnored`, which is
+ *    how the launcher forwards an explicit "and discard these" from the user.
  *  - `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.
+ * A keepworthy PATH that appears after the caller's own scan is unacknowledged
+ * and still blocks, but acknowledging a directory entry (`scratch/`) covers
+ * whatever it holds when the removal runs, not only what the scan saw in it.
  *
  * `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
@@ -99,5 +141,6 @@ export declare function createOrResume(name: string | undefined, deps: CreateOrR
 export declare function removeSessionWorktree(worktreePath: string, branch: string, deps: {
     repoCwd: string;
     gitImpl?: SessionGit;
+    discardIgnored?: string[];
 }): Promise<RemoveSessionWorktreeResult>;
 //# sourceMappingURL=sessionWorktree.d.ts.map

package/dist/extension/pipeline/sessionWorktree.js

@@ -26,7 +26,7 @@
  * base on `FETCH_HEAD`.
  */
 import { execFile } from "node:child_process";
-import { existsSync, mkdirSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, isAbsolute, join } from "node:path";
 import { bootstrapWorktree } from "./worktree.js";
 /** Cap on the slug half (keeps refs & dirs readable). */
@@ -40,6 +40,158 @@ const GIT_NO_PROMPT_ENV = {
     GIT_TERMINAL_PROMPT: "0",
     GIT_ASKPASS: "",
 };
+/**
+ * Directory names that mean "a tool put this here" wherever they appear. A
+ * bootstrapped worktree is FULL of these, so treating all ignored content as
+ * precious made "Remove worktree" refuse essentially every real worktree.
+ */
+const TOOL_DIRS = new Set([
+    "node_modules",
+    ".pnpm-store",
+    ".yarn",
+    ".npm",
+    ".bun",
+    ".turbo",
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    ".astro",
+    ".vite",
+    ".parcel-cache",
+    ".cache",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".gradle",
+    "playwright-report",
+    "test-results",
+]);
+/**
+ * Build-output names generic enough to be someone's own folder ("research/out"),
+ * so they only count as regenerable NEXT TO A PACKAGE MANIFEST, the repo root
+ * included: that is what makes a build tool, rather than a person, the author.
+ * `tmp` is deliberately absent — a scratch directory is where people put things
+ * they would hate to lose quietly, whatever sits beside it.
+ */
+const BUILD_DIRS = new Set(["dist", "build", "out", "coverage", "target"]);
+/** Manifests that mark a directory as something a build tool writes output into. */
+const PACKAGE_MANIFESTS = [
+    "package.json",
+    "Cargo.toml",
+    "go.mod",
+    "pyproject.toml",
+    "setup.py",
+    "build.gradle",
+    "build.gradle.kts",
+    "pom.xml",
+];
+/** Ignored file names/extensions that are equally regenerable. */
+const REGENERABLE_FILES = /(?:^|\/)(?:\.DS_Store|\.eslintcache|Thumbs\.db)$|\.(?:log|tsbuildinfo|pid)$/;
+/** Above this, comparing a file against the main checkout is not worth the read. */
+const MIRROR_MAX_BYTES = 4 * 1024 * 1024;
+/** How many ignored entries a user-facing note names before it says "+N more". */
+const IGNORED_PREVIEW = 5;
+/**
+ * True when an ignored path is dependency/build state something regenerates.
+ *
+ * `git ls-files --directory` collapses a fully-ignored directory to
+ * `node_modules/`, but a partially-ignored tree yields deeper paths, so every
+ * DIRECTORY segment is checked (a file merely named `out` is not build output).
+ * Generic build names need `hasPackageManifest` to confirm a build tool owns
+ * the directory they sit in, the repo root included; without the seam every
+ * generic name answers false, which is the safe direction.
+ */
+export function isRegenerableIgnoredPath(path, hasPackageManifest = () => false) {
+    const isDirEntry = path.endsWith("/");
+    const segments = path.split("/").filter(Boolean);
+    const dirSegments = isDirEntry ? segments : segments.slice(0, -1);
+    for (const [index, segment] of dirSegments.entries()) {
+        if (TOOL_DIRS.has(segment))
+            return true;
+        if (BUILD_DIRS.has(segment) && hasPackageManifest(dirSegments.slice(0, index).join("/")))
+            return true;
+    }
+    return !isDirEntry && REGENERABLE_FILES.test(path);
+}
+/**
+ * True when the main checkout still holds a byte-identical copy of this file.
+ * That is how `.env` and friends reach a worktree in the first place (copied in
+ * by `worktree-setup.sh` or the bootstrap), and deleting a copy loses nothing.
+ *
+ * The main-checkout side is `lstat`ed: a symlink there could point back INTO
+ * the worktree, which would make a file look like a copy of itself.
+ */
+function isMirroredInMainRepo(repoRoot, worktreePath, rel) {
+    if (rel.endsWith("/"))
+        return false; // a directory, not a copied file
+    if (repoRoot === worktreePath)
+        return false; // nothing to mirror against but itself
+    try {
+        const here = statSync(join(worktreePath, rel));
+        const there = lstatSync(join(repoRoot, rel));
+        if (!here.isFile() || !there.isFile())
+            return false;
+        if (here.size !== there.size || here.size > MIRROR_MAX_BYTES)
+            return false;
+        return readFileSync(join(worktreePath, rel)).equals(readFileSync(join(repoRoot, rel)));
+    }
+    catch {
+        return false; // no counterpart in the main checkout: treat as unique
+    }
+}
+/** Render an ignored-path list for a user-facing note: quoted and bounded. */
+export function previewIgnoredPaths(paths) {
+    const preview = paths.slice(0, IGNORED_PREVIEW).map((path) => JSON.stringify(path)).join(", ");
+    return paths.length > IGNORED_PREVIEW ? `${preview} (+${paths.length - IGNORED_PREVIEW} more)` : preview;
+}
+/**
+ * Scan a worktree's ignored content and split it into what cleanup may delete
+ * on its own and what it must be told to discard first.
+ *
+ * Exported so the launcher can run it BEFORE the Keep/Remove prompt and name
+ * the at-risk files in the prompt itself, instead of refusing after the fact.
+ */
+export async function inspectIgnoredContent(worktreePath, deps) {
+    const gitImpl = deps.gitImpl ?? defaultGit;
+    try {
+        const repoRoot = await resolveMainRepo(gitImpl, deps.repoCwd);
+        return await scanIgnoredContent(gitImpl, worktreePath, repoRoot);
+    }
+    catch (err) {
+        return { disposable: [], keepworthy: [], error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/** The shared scan behind {@link inspectIgnoredContent} and the removal guard. */
+async function scanIgnoredContent(gitImpl, worktreePath, repoRoot) {
+    // `--no-empty-directory`: an empty ignored dir holds nothing to lose, and
+    // reporting one as at-risk content is exactly the false alarm this fixes.
+    const ignored = await gitImpl(["ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "--no-empty-directory", "-z"], worktreePath);
+    const manifestCache = new Map();
+    const hasPackageManifest = (relDir) => {
+        const cached = manifestCache.get(relDir);
+        if (cached !== undefined)
+            return cached;
+        const dir = relDir === "" ? worktreePath : join(worktreePath, relDir);
+        const found = PACKAGE_MANIFESTS.some((manifest) => existsSync(join(dir, manifest)));
+        manifestCache.set(relDir, found);
+        return found;
+    };
+    const disposable = [];
+    const keepworthy = [];
+    for (const path of ignored.split("\0").filter(Boolean)) {
+        if (isRegenerableIgnoredPath(path, hasPackageManifest) ||
+            isMirroredInMainRepo(repoRoot, worktreePath, path)) {
+            disposable.push(path);
+        }
+        else {
+            keepworthy.push(path);
+        }
+    }
+    return { disposable, keepworthy };
+}
 /** Turn arbitrary name text into a git-ref-safe slug. Empty input → "worktree". */
 export function slugify(name) {
     const slug = name
@@ -232,13 +384,19 @@ export async function createOrResume(name, deps) {
  *
  *  - 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.
+ *  - Sort ignored content (which Git's dirty check does not cover) into what a
+ *    bootstrap regenerates or the main checkout still holds a copy of, and what
+ *    exists only here. The first kind goes with the worktree; the second kind
+ *    blocks cleanup unless the caller passes it in `discardIgnored`, which is
+ *    how the launcher forwards an explicit "and discard these" from the user.
  *  - `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.
+ * A keepworthy PATH that appears after the caller's own scan is unacknowledged
+ * and still blocks, but acknowledging a directory entry (`scratch/`) covers
+ * whatever it holds when the removal runs, not only what the scan saw in it.
  *
  * `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
@@ -250,18 +408,22 @@ export async function removeSessionWorktree(worktreePath, branch, deps) {
     // 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);
+    let ignoredDiscarded;
     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)` : "";
+        const ignored = await scanIgnoredContent(gitImpl, worktreePath, repoRoot);
+        const acknowledged = new Set(deps.discardIgnored ?? []);
+        const unacknowledged = ignored.keepworthy.filter((path) => !acknowledged.has(path));
+        if (unacknowledged.length > 0) {
             return {
                 removed: false,
                 branchRemoved: false,
-                note: `worktree contains ignored content: ${preview}${more}; review and remove it manually before retrying cleanup`,
+                note: `worktree contains ignored files the main checkout does not have: ${previewIgnoredPaths(unacknowledged)}; ` +
+                    `move them out, or confirm discarding them, before retrying cleanup`,
             };
         }
+        // Keepworthy first: the bounded preview must spend its slots on the entries
+        // that mattered, not on the dozen node_modules trees that always lead.
+        ignoredDiscarded = [...ignored.keepworthy, ...ignored.disposable];
         const headRef = await gitImpl(["rev-parse", "--symbolic-full-name", "HEAD"], worktreePath);
         if (headRef !== `refs/heads/${branch}`) {
             return {
@@ -285,7 +447,7 @@ export async function removeSessionWorktree(worktreePath, branch, deps) {
     // 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 };
+        return { removed: true, branchRemoved: true, ignoredDiscarded };
     }
     catch (err) {
         // Distinguish the benign case (unmerged branch, deliberately kept) from
@@ -296,6 +458,7 @@ export async function removeSessionWorktree(worktreePath, branch, deps) {
             removed: true,
             branchRemoved: false,
             branchUnmerged: unmerged,
+            ignoredDiscarded,
             ...(unmerged ? {} : { note: message }),
         };
     }

package/dist/worktreeExitPrompt.d.ts

@@ -3,12 +3,18 @@
  *
  * 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).
+ * first), navigation is directional so no single keystroke can move onto the
+ * destructive option unless it means "down", 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`.
+ *
+ * The caller may rename the Remove option and print notes above the list (the
+ * launcher uses both to name ignored files that removal would discard). Notes
+ * survive the choice: only the two option lines are erased.
  */
 export type WorktreeExitChoice = "keep" | "remove";
 /** Minimal stream shape the prompt needs (satisfied by process.stdin/stderr). */
@@ -22,6 +28,9 @@ export interface ExitPromptKey {
     ctrl?: boolean;
 }
 export type ExitPromptAction = {
+    type: "select";
+    index: 0 | 1;
+} | {
     type: "toggle";
 } | {
     type: "confirm";
@@ -31,10 +40,12 @@ export type ExitPromptAction = {
     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.
+ * Map a keypress to its prompt action (pure, unit-tested). Arrows (and k/j)
+ * are DIRECTIONAL, never a toggle: up always lands on Keep, down always on
+ * Remove. That matters because the toggle made typing "keep" (k, then space)
+ * select Remove and confirm it in two keystrokes. Tab still cycles; 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.
  */
 export declare function exitPromptAction(key: ExitPromptKey): ExitPromptAction;
 /**
@@ -50,5 +61,9 @@ export declare function promptKeepOrRemoveWorktree(opts: {
     };
     output: ExitPromptStream;
     label: string;
+    /** Overrides the Remove option text so it can name what else goes with it. */
+    removeLabel?: string;
+    /** Lines printed under the header, before the options (e.g. what removal discards). */
+    notes?: string[];
 }): Promise<WorktreeExitChoice | undefined>;
 //# sourceMappingURL=worktreeExitPrompt.d.ts.map

package/dist/worktreeExitPrompt.js

@@ -3,30 +3,40 @@
  *
  * 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).
+ * first), navigation is directional so no single keystroke can move onto the
+ * destructive option unless it means "down", 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`.
+ *
+ * The caller may rename the Remove option and print notes above the list (the
+ * launcher uses both to name ignored files that removal would discard). Notes
+ * survive the choice: only the two option lines are erased.
  */
 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.
+ * Map a keypress to its prompt action (pure, unit-tested). Arrows (and k/j)
+ * are DIRECTIONAL, never a toggle: up always lands on Keep, down always on
+ * Remove. That matters because the toggle made typing "keep" (k, then space)
+ * select Remove and confirm it in two keystrokes. Tab still cycles; 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.
  */
 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":
+            return { type: "select", index: 0 };
+        case "down":
         case "j":
+            return { type: "select", index: 1 };
         case "tab":
             return { type: "toggle" };
         case "return":
@@ -40,10 +50,10 @@ export function exitPromptAction(key) {
             return { type: "noop" };
     }
 }
-function renderOptions(output, index) {
+function renderOptions(output, index, removeLabel) {
     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`);
+    output.write(`\r\x1b[2K${marker(1)}${removeLabel}\n`);
 }
 /** Erase the two option lines, leaving the cursor just below where they were. */
 function eraseOptions(output) {
@@ -58,12 +68,15 @@ function eraseOptions(output) {
  */
 export async function promptKeepOrRemoveWorktree(opts) {
     const { input, output, label } = opts;
+    const removeLabel = opts.removeLabel ?? OPTION_REMOVE;
     // 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);
+    for (const note of opts.notes ?? [])
+        output.write(`[yagni] ${note}\n`);
+    renderOptions(output, index, removeLabel);
     const canRawMode = typeof input.setRawMode === "function";
     const wasRaw = canRawMode ? input.isRaw === true : false;
     if (canRawMode)
@@ -80,10 +93,13 @@ export async function promptKeepOrRemoveWorktree(opts) {
                 const action = exitPromptAction(key ?? {});
                 if (action.type === "noop")
                     return;
-                if (action.type === "toggle") {
-                    index = index === 0 ? 1 : 0;
+                if (action.type === "select" || action.type === "toggle") {
+                    const next = action.type === "select" ? action.index : index === 0 ? 1 : 0;
+                    if (next === index)
+                        return; // already there: no flicker, no re-render
+                    index = next;
                     eraseOptions(output);
-                    renderOptions(output, index);
+                    renderOptions(output, index, removeLabel);
                     return;
                 }
                 cleanup();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.1.1-staging.1338.1",
+  "version": "1.1.1-staging.1340.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": "da5698917cce69e1ffcf27803c8209bd41bf48a0"
+  "yagniSourceSha": "f7830683d5c8212894c4b2e53ed7f3d122701251"
 }