@yagni-app/code-staging 1.1.0-staging.1328.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/index.js

@@ -49,6 +49,7 @@ import { makeDecisionCapture } from "./decisionCapture.js";
 import { registerAmbientRecall } from "./recall.js";
 import { resilientFetch } from "./resilientFetch.js";
 import { installUncaughtExceptionMonitor, makeCrashReporter, runningUnderTest } from "./crashReport.js";
+import { createToolOutcomeBatcher } from "./toolOutcomes.js";
 import { flushSpool as defaultFlushSpool } from "./spool.js";
 import { makeAuthedFetch, makeTokenProvider } from "./tokenProvider.js";
 import { attributionHeaders, fetchCatalog as defaultFetchCatalog, fetchContextBrief as defaultFetchContextBrief, getToken, getTokenExpiresAt as defaultGetTokenExpiresAt, getWorkspaceId as defaultGetWorkspaceId, isDriverCaller, resolveBaseUrl, tokenExpiryNotice, } from "./config.js";
@@ -430,6 +431,30 @@ export async function registerYagni(pi, deps = {}) {
             previousMode = m;
         });
     }
+    // Tool-outcome counts for the fleet dashboards (toolOutcomes.ts): which
+    // tool failures are the model's normal business and which are the tool
+    // machinery breaking. Counts and a closed reason vocabulary only; off in
+    // eval mode and under the crash-report opt-out; posted on a timer and at
+    // session shutdown, fail-soft throughout.
+    const toolOutcomes = createToolOutcomeBatcher({
+        baseUrl,
+        getToken: getTokenFn,
+        headers: attributionHeaders(deps.env),
+        fetchImpl: deps.fetchImpl,
+        env: deps.env,
+        enabled: !evalMode,
+    });
+    pi.on("tool_execution_start", (event) => {
+        if (event?.toolCallId && event?.toolName)
+            toolOutcomes.toolStart(event.toolCallId, event.toolName);
+    });
+    pi.on("tool_execution_end", (event) => {
+        if (event?.toolCallId)
+            toolOutcomes.toolEnd(event.toolCallId, { isError: !!event.isError, result: event.result });
+    });
+    pi.on("session_shutdown", async () => {
+        await toolOutcomes.close();
+    });
     const footerInvalidateHandle = { invalidateGit: () => { }, requestRender: () => { } };
     const guardianState = makeGuardianState();
     // Disabled by the local env override OR the workspace kill switch

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/extension/toolOutcomes.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Tool-call outcome telemetry: counts per (tool family, outcome, reason),
+ * batched and posted to the backend's /api/yagni-code/tool-outcomes so the
+ * fleet dashboards can tell a NORMAL tool failure (the model ran a command
+ * that exited 1, read a file that is not there, tried an edit that did not
+ * match) from the tool machinery actually breaking (an MCP transport, an
+ * internal exception, a timeout).
+ *
+ * Content never leaves the machine: the classifier reads the result text
+ * locally and emits only a closed reason vocabulary, and tool names collapse
+ * to a closed family list HERE, before buffering, so an MCP server name never
+ * reaches the wire. The payload is family, outcome, reason, count, summed
+ * duration. Opt-out and test suppression follow the crash reporter
+ * (`YAGNI_DISABLE_CRASH_REPORTS=1` turns both off), eval mode is off like
+ * every other external side effect, and everything is fail-soft: one
+ * attempt, short timeout, never throws, never blocks a turn. A failed post is
+ * counted and written to the local error trail (source `telemetry`) so "why
+ * is the dashboard empty" has something to read.
+ */
+export type ToolOutcome = "ok" | "expected_error" | "real_error";
+export type ToolOutcomeReason = "ok" | "exit_nonzero" | "not_found" | "no_match" | "denied" | "cancelled" | "invalid_input" | "timeout" | "mcp_transport" | "internal" | "unknown";
+export declare const TOOL_FAMILIES: readonly ["bash", "read", "edit", "write", "grep", "find", "ls", "mcp", "subagent", "web", "other"];
+export type ToolFamily = (typeof TOOL_FAMILIES)[number];
+/** Collapse a tool name to its family. Never returns anything outside TOOL_FAMILIES. */
+export declare function toolFamilyOf(toolName: string): ToolFamily;
+export interface ToolOutcomeClass {
+    outcome: ToolOutcome;
+    reason: ToolOutcomeReason;
+}
+/** Best-effort text from a pi tool result (string, content blocks, or an Error). */
+export declare function toolResultText(result: unknown): string;
+/**
+ * Classify one tool call. The order matters: transport and internal faults
+ * win over the softer patterns because a stack trace can mention a file.
+ */
+export declare function classifyToolOutcome(input: {
+    toolName: string;
+    isError: boolean;
+    result?: unknown;
+}): ToolOutcomeClass;
+export interface ToolOutcomeSample {
+    /** A TOOL_FAMILIES value, never the raw tool name. */
+    tool: ToolFamily;
+    outcome: ToolOutcome;
+    reason: ToolOutcomeReason;
+    count: number;
+    durationMsSum: number;
+}
+export interface ToolOutcomeBatcherOpts {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    /** Attribution headers (`x-yagni-caller` / session / run) from config.ts. */
+    headers?: Record<string, string>;
+    fetchImpl?: typeof fetch;
+    env?: NodeJS.ProcessEnv;
+    /** Flush cadence; the interval timer is unref'd so it never holds the process. */
+    flushIntervalMs?: number;
+    timeoutMs?: number;
+    now?: () => number;
+    /** Disabled entirely (eval mode, tests). */
+    enabled?: boolean;
+    /** Local trail sink for a failed post (defaults to the unified error sink). */
+    logSink?: (event: {
+        event: string;
+        fields: Record<string, unknown>;
+    }) => void;
+}
+export interface ToolOutcomeBatcher {
+    toolStart(toolCallId: string, toolName: string): void;
+    toolEnd(toolCallId: string, outcome: {
+        isError: boolean;
+        result?: unknown;
+    }): void;
+    /** Post whatever is buffered. Resolves on every outcome; never throws. */
+    flush(): Promise<void>;
+    /** Stop the timer and flush once. */
+    close(): Promise<void>;
+    /** Test/introspection seam: the buffered samples. */
+    pending(): ToolOutcomeSample[];
+    /** Batches that failed to post (network, non-2xx, no token) since start. */
+    dropped(): number;
+}
+export declare const TOOL_OUTCOME_FLUSH_INTERVAL_MS = 60000;
+export declare const TOOL_OUTCOME_TIMEOUT_MS = 2000;
+export declare function createToolOutcomeBatcher(opts: ToolOutcomeBatcherOpts): ToolOutcomeBatcher;
+//# sourceMappingURL=toolOutcomes.d.ts.map

package/dist/extension/toolOutcomes.js

@@ -0,0 +1,240 @@
+/**
+ * Tool-call outcome telemetry: counts per (tool family, outcome, reason),
+ * batched and posted to the backend's /api/yagni-code/tool-outcomes so the
+ * fleet dashboards can tell a NORMAL tool failure (the model ran a command
+ * that exited 1, read a file that is not there, tried an edit that did not
+ * match) from the tool machinery actually breaking (an MCP transport, an
+ * internal exception, a timeout).
+ *
+ * Content never leaves the machine: the classifier reads the result text
+ * locally and emits only a closed reason vocabulary, and tool names collapse
+ * to a closed family list HERE, before buffering, so an MCP server name never
+ * reaches the wire. The payload is family, outcome, reason, count, summed
+ * duration. Opt-out and test suppression follow the crash reporter
+ * (`YAGNI_DISABLE_CRASH_REPORTS=1` turns both off), eval mode is off like
+ * every other external side effect, and everything is fail-soft: one
+ * attempt, short timeout, never throws, never blocks a turn. A failed post is
+ * counted and written to the local error trail (source `telemetry`) so "why
+ * is the dashboard empty" has something to read.
+ */
+import { crashReportsSuppressed } from "./crashReport.js";
+import { logEvent } from "./errorSink.js";
+import { isDesktopSurface } from "./surface.js";
+export const TOOL_FAMILIES = ["bash", "read", "edit", "write", "grep", "find", "ls", "mcp", "subagent", "web", "other"];
+/** Collapse a tool name to its family. Never returns anything outside TOOL_FAMILIES. */
+export function toolFamilyOf(toolName) {
+    const name = toolName.toLowerCase();
+    if (name.startsWith("mcp__") || name.startsWith("mcp:"))
+        return "mcp";
+    if (name === "bash" || name === "shell" || name === "exec")
+        return "bash";
+    if (name === "read" || name === "read_file" || name === "view")
+        return "read";
+    if (name === "edit" || name === "multiedit" || name === "str_replace")
+        return "edit";
+    if (name === "write" || name === "write_file" || name === "create")
+        return "write";
+    if (name === "grep" || name === "search")
+        return "grep";
+    if (name === "find" || name === "glob")
+        return "find";
+    if (name === "ls" || name === "list")
+        return "ls";
+    if (name.includes("subagent") || name === "agent" || name === "task")
+        return "subagent";
+    if (name.startsWith("web") || name.includes("fetch") || name.includes("browser"))
+        return "web";
+    return "other";
+}
+/** Only this much of a result is inspected; the classifier is pattern-based. */
+const CLASSIFY_TEXT_CAP = 4_000;
+/** Best-effort text from a pi tool result (string, content blocks, or an Error). */
+export function toolResultText(result) {
+    if (typeof result === "string")
+        return result.slice(0, CLASSIFY_TEXT_CAP);
+    if (result instanceof Error)
+        return `${result.name}: ${result.message}`.slice(0, CLASSIFY_TEXT_CAP);
+    if (typeof result !== "object" || result === null)
+        return "";
+    const r = result;
+    if (typeof r.text === "string")
+        return r.text.slice(0, CLASSIFY_TEXT_CAP);
+    if (typeof r.error === "string")
+        return r.error.slice(0, CLASSIFY_TEXT_CAP);
+    if (typeof r.message === "string")
+        return r.message.slice(0, CLASSIFY_TEXT_CAP);
+    if (Array.isArray(r.content)) {
+        const parts = [];
+        let size = 0;
+        for (const block of r.content) {
+            const text = typeof block === "string" ? block : block?.text;
+            if (typeof text !== "string")
+                continue;
+            parts.push(text);
+            size += text.length;
+            if (size >= CLASSIFY_TEXT_CAP)
+                break;
+        }
+        return parts.join("\n").slice(0, CLASSIFY_TEXT_CAP);
+    }
+    return "";
+}
+const NOT_FOUND_RE = /no such file|not found|does not exist|enoent|cannot find|unknown file|no matches? found/i;
+const NO_MATCH_RE = /old_string|did not match|not unique|could not find the (?:string|text)|no occurrences|nothing to replace/i;
+const DENIED_RE = /permission denied|denied by|blocked by|not allowed|not permitted|refused|guardian|plan mode|requires approval|eacces|eperm/i;
+const CANCELLED_RE = /cancel+ed|aborted|interrupted|user (?:declined|rejected|stopped)/i;
+const INVALID_RE = /invalid (?:argument|input|json|parameter)|missing required|expected .* to be|is required|malformed|validation/i;
+const TIMEOUT_RE = /timed? ?out|deadline exceeded|etimedout/i;
+const MCP_RE = /mcp|transport|econnrefused|econnreset|socket hang up|server (?:closed|disconnected|unavailable)|jsonrpc|connection (?:closed|lost|refused)/i;
+const INTERNAL_RE = /^(?:type|reference|range|syntax)error\b|internal error|unhandled|stack trace|cannot read propert|is not a function|undefined is not/i;
+const EXIT_RE = /exit(?:ed)? (?:with )?(?:code|status)[: ]+(\d+)|command failed|non-zero exit|\bexit code\b/i;
+/**
+ * Classify one tool call. The order matters: transport and internal faults
+ * win over the softer patterns because a stack trace can mention a file.
+ */
+export function classifyToolOutcome(input) {
+    if (!input.isError)
+        return { outcome: "ok", reason: "ok" };
+    const text = toolResultText(input.result);
+    // Accepts a raw tool name or an already-collapsed family (the batcher
+    // classifies by family).
+    const mcp = input.toolName === "mcp" || toolFamilyOf(input.toolName) === "mcp";
+    if (INTERNAL_RE.test(text))
+        return { outcome: "real_error", reason: "internal" };
+    if (mcp && MCP_RE.test(text))
+        return { outcome: "real_error", reason: "mcp_transport" };
+    if (TIMEOUT_RE.test(text))
+        return { outcome: "real_error", reason: "timeout" };
+    if (CANCELLED_RE.test(text))
+        return { outcome: "expected_error", reason: "cancelled" };
+    if (DENIED_RE.test(text))
+        return { outcome: "expected_error", reason: "denied" };
+    if (NO_MATCH_RE.test(text))
+        return { outcome: "expected_error", reason: "no_match" };
+    if (NOT_FOUND_RE.test(text))
+        return { outcome: "expected_error", reason: "not_found" };
+    if (INVALID_RE.test(text))
+        return { outcome: "expected_error", reason: "invalid_input" };
+    if (EXIT_RE.test(text) || input.toolName === "bash")
+        return { outcome: "expected_error", reason: "exit_nonzero" };
+    if (!mcp && MCP_RE.test(text))
+        return { outcome: "real_error", reason: "mcp_transport" };
+    return { outcome: "real_error", reason: "unknown" };
+}
+export const TOOL_OUTCOME_FLUSH_INTERVAL_MS = 60_000;
+export const TOOL_OUTCOME_TIMEOUT_MS = 2_000;
+const MAX_TRACKED_STARTS = 512;
+export function createToolOutcomeBatcher(opts) {
+    const env = opts.env ?? process.env;
+    const now = opts.now ?? Date.now;
+    const enabled = (opts.enabled ?? true) && !crashReportsSuppressed(env);
+    const logSink = opts.logSink ??
+        ((e) => logEvent({ source: "telemetry", level: "warn", event: e.event, fields: e.fields, sessionId: env.YAGNI_SESSION_ID }));
+    const starts = new Map();
+    const buffer = new Map();
+    let timer;
+    let closed = false;
+    let droppedBatches = 0;
+    const key = (tool, outcome, reason) => `${tool}|${outcome}|${reason}`;
+    const record = (tool, cls, durationMs) => {
+        const k = key(tool, cls.outcome, cls.reason);
+        const existing = buffer.get(k);
+        if (existing) {
+            existing.count += 1;
+            existing.durationMsSum += durationMs;
+            return;
+        }
+        buffer.set(k, { tool, outcome: cls.outcome, reason: cls.reason, count: 1, durationMsSum: durationMs });
+    };
+    const drop = (samples, fields) => {
+        droppedBatches += 1;
+        try {
+            logSink({ event: "tool_outcomes_post_failed", fields: { ...fields, samples: samples.length, droppedBatches } });
+        }
+        catch {
+            // the trail is best-effort
+        }
+    };
+    const flush = async () => {
+        if (!enabled || buffer.size === 0)
+            return;
+        const samples = [...buffer.values()];
+        buffer.clear();
+        try {
+            // The token getter is fail-soft too: a throwing provider must not
+            // reject the timer's `void flush()` or surface at shutdown.
+            const token = opts.getToken();
+            if (!token) {
+                drop(samples, { kind: "no_token" });
+                return;
+            }
+            const fetchImpl = opts.fetchImpl ?? fetch;
+            const controller = new AbortController();
+            const t = setTimeout(() => controller.abort(), opts.timeoutMs ?? TOOL_OUTCOME_TIMEOUT_MS);
+            t.unref?.();
+            try {
+                const res = await fetchImpl(`${opts.baseUrl.replace(/\/$/, "")}/api/yagni-code/tool-outcomes`, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        authorization: `Bearer ${token}`,
+                        ...(opts.headers ?? {}),
+                    },
+                    body: JSON.stringify({
+                        client: isDesktopSurface() ? "desktop" : "cli",
+                        clientVersion: env.YAGNI_CODE_VERSION?.trim() || "unknown",
+                        samples,
+                    }),
+                    signal: controller.signal,
+                });
+                if (!res.ok)
+                    drop(samples, { kind: "http", status: res.status });
+            }
+            finally {
+                clearTimeout(t);
+            }
+        }
+        catch (err) {
+            drop(samples, { kind: "network", error: err instanceof Error ? err.name : "unknown" });
+        }
+    };
+    if (enabled) {
+        timer = setInterval(() => { void flush(); }, opts.flushIntervalMs ?? TOOL_OUTCOME_FLUSH_INTERVAL_MS);
+        timer.unref?.();
+    }
+    return {
+        toolStart(toolCallId, toolName) {
+            if (!enabled || closed)
+                return;
+            if (starts.size >= MAX_TRACKED_STARTS)
+                starts.clear();
+            starts.set(toolCallId, { family: toolFamilyOf(toolName), startedAt: now() });
+        },
+        toolEnd(toolCallId, outcome) {
+            if (!enabled || closed)
+                return;
+            const slot = starts.get(toolCallId);
+            starts.delete(toolCallId);
+            const family = slot?.family ?? "other";
+            const durationMs = slot ? Math.max(0, now() - slot.startedAt) : 0;
+            try {
+                record(family, classifyToolOutcome({ toolName: family, isError: outcome.isError, result: outcome.result }), durationMs);
+            }
+            catch {
+                // classification must never break a tool result
+            }
+        },
+        flush,
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            if (timer)
+                clearInterval(timer);
+            await flush();
+        },
+        pending: () => [...buffer.values()],
+        dropped: () => droppedBatches,
+    };
+}
+//# sourceMappingURL=toolOutcomes.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.1328.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": "34b64c98d42aa85f408a4f85de7ef103722038f7"
+  "yagniSourceSha": "b7b91c0bf94f197fc16643cb9a5c5f580e896001"
 }