@yagni-app/code 1.0.0 → 1.0.1

package/dist/extension/condensedTools.js

@@ -0,0 +1,392 @@
+/**
+ * Condensed, Claude Code-style rendering for pi's seven built-in tools.
+ *
+ * pi resolves renderers per slot (`toolDefinition.renderCall ?? builtIn.renderCall`),
+ * so re-registering a built-in by name with the SAME factory-made definition
+ * spread underneath swaps ONLY the presentation: name, description, parameters,
+ * prompt metadata, and execution semantics stay byte-identical with the
+ * built-in (execution delegates to the same `create*ToolDefinition` the session
+ * would have built, including the settings-driven bash shellPath/commandPrefix
+ * and read image auto-resize). pi 0.84.1 registers such overrides silently —
+ * there is no built-in-override startup warning in this version (verified
+ * against dist; the extensions.md claim is stale).
+ *
+ * Rendering contract per row (renderShell "self", so no tinted Box):
+ *  - renderCall paints the TITLE slot: a live "● Tool(arg)" line while running,
+ *    a "● Tool(arg)" line for visible rows, the run summary line for the tail
+ *    of a completed quiet run, or nothing (a zero-line component removes the
+ *    row entirely, including its spacer).
+ *  - renderResult paints the BODY slot: condensed write/edit previews, bash
+ *    error/partial output tails, or nothing. Expanded (ctrl+o) shows full
+ *    output for every row.
+ *
+ * String assembly is pure over {@link RenderTheme} (subagentRender.ts's
+ * pattern) so tests run against plain text. Renderer exceptions are swallowed
+ * by pi (degrading to the built-in fallback), so everything stays total.
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, getAgentDir, getLanguageFromPath, highlightCode, renderDiff, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { Container, Text } from "@earendil-works/pi-tui";
+import { isQuiet, kindForTool, ToolRunTracker } from "./toolRuns.js";
+/** Lines of write content shown collapsed (mirrors Claude Code's preview). */
+export const WRITE_PREVIEW_LINES = 8;
+/** Visual lines of a diff shown collapsed. */
+export const DIFF_PREVIEW_LINES = 12;
+/** Output tail lines shown under a failed shell command. */
+export const ERROR_TAIL_LINES = 5;
+/** Output tail lines shown under a still-running shell command. */
+export const PARTIAL_TAIL_LINES = 3;
+/** Hard cap on expanded body lines so a huge output cannot stall a repaint. */
+const EXPANDED_MAX_LINES = 1000;
+/** Title arg preview width. */
+const ARG_PREVIEW_MAX = 96;
+const BUILTIN_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
+const TITLE_BY_NAME = {
+    read: "Read",
+    bash: "Bash",
+    edit: "Edit",
+    write: "Write",
+    grep: "Grep",
+    find: "Find",
+    ls: "List",
+};
+/** Collapse whitespace and clip to `max`, appending an ellipsis when cut. */
+function clip(text, max) {
+    const collapsed = text.replace(/\s+/g, " ").trim();
+    if (collapsed.length <= max)
+        return collapsed;
+    return `${collapsed.slice(0, max - 1)}…`;
+}
+/** Forward slashes for comparison and display, on every platform. */
+function slashed(p) {
+    return p.replace(/\\/g, "/");
+}
+/** Home-collapse, and prefer cwd-relative for paths inside the project. */
+export function displayPath(rawPath, cwd) {
+    if (!rawPath)
+        return rawPath;
+    let display = slashed(rawPath);
+    if (cwd) {
+        // Resolve BOTH sides so a POSIX-style cwd and Windows' drive-letter
+        // absolute paths compare in the same space.
+        const absolute = slashed(path.resolve(cwd, rawPath));
+        const base = slashed(path.resolve(cwd)).replace(/\/+$/, "");
+        if (absolute.startsWith(`${base}/`))
+            return absolute.slice(base.length + 1);
+        display = absolute;
+    }
+    const home = slashed(os.homedir());
+    return display.startsWith(home) ? `~${display.slice(home.length)}` : display;
+}
+/** Whether a tool-call path targets the session scratchpad. */
+export function isScratchpadPath(rawPath, scratchpadDir, cwd) {
+    if (typeof rawPath !== "string" || !rawPath || !scratchpadDir)
+        return false;
+    const absolute = slashed(path.resolve(cwd ?? process.cwd(), rawPath));
+    const base = slashed(path.resolve(scratchpadDir)).replace(/\/+$/, "");
+    return absolute === base || absolute.startsWith(`${base}/`);
+}
+/** The one argument worth showing in a title: path, command, or pattern. */
+export function primaryArg(name, args, cwd) {
+    const a = args ?? {};
+    const str = (v) => (typeof v === "string" ? v : "");
+    switch (name) {
+        case "bash":
+            return clip(str(a.command) || "…", ARG_PREVIEW_MAX);
+        case "grep": {
+            const pattern = str(a.pattern) || "…";
+            const where = str(a.path);
+            return clip(where ? `${pattern} in ${displayPath(where, cwd)}` : pattern, ARG_PREVIEW_MAX);
+        }
+        case "find":
+            return clip(str(a.pattern) || "…", ARG_PREVIEW_MAX);
+        case "ls":
+            return clip(displayPath(str(a.path) || ".", cwd), ARG_PREVIEW_MAX);
+        default: {
+            const p = str(a.path);
+            let display = p ? displayPath(p, cwd) : "…";
+            if (name === "read" && (a.offset !== undefined || a.limit !== undefined)) {
+                const start = typeof a.offset === "number" ? a.offset : 1;
+                const end = typeof a.limit === "number" ? start + a.limit - 1 : undefined;
+                display += `:${start}${end !== undefined ? `-${end}` : ""}`;
+            }
+            return clip(display, ARG_PREVIEW_MAX);
+        }
+    }
+}
+function statusDot(status, theme) {
+    if (status === "error")
+        return theme.fg("error", "●");
+    if (status === "running")
+        return theme.fg("accent", "●");
+    return theme.fg("success", "●");
+}
+/** `● Tool(arg)` — the visible-row (and live-row) title line. */
+export function formatRowTitle(name, args, status, theme, cwd) {
+    const title = theme.bold(theme.fg("toolTitle", TITLE_BY_NAME[name]));
+    return `${statusDot(status, theme)} ${title}(${theme.fg("accent", primaryArg(name, args, cwd))})`;
+}
+/** Extract "Command exited with code N" from a bash error body, if present. */
+export function splitBashError(outputText) {
+    const match = outputText.match(/\n*(Command exited with code \d+)\s*$/);
+    if (!match)
+        return { output: outputText.trimEnd(), exitLine: undefined };
+    return { output: outputText.slice(0, match.index).trimEnd(), exitLine: match[1] };
+}
+function indent(lines, pad) {
+    return lines.map((line) => pad + line);
+}
+/** `⎿ exit line` + a dim tail of output under a failed shell command. */
+export function formatBashErrorBody(outputText, theme) {
+    const { output, exitLine } = splitBashError(outputText);
+    const lines = [];
+    lines.push(`  ${theme.fg("muted", "⎿")} ${theme.fg("error", exitLine ?? "Command failed")}`);
+    const tail = output.split("\n").filter((l) => l.length > 0).slice(-ERROR_TAIL_LINES);
+    lines.push(...indent(tail.map((l) => theme.fg("toolOutput", l)), "     "));
+    return lines;
+}
+/** A dim tail of live output under a still-running shell command. */
+export function formatBashPartialBody(outputText, theme) {
+    const tail = outputText.split("\n").filter((l) => l.length > 0).slice(-PARTIAL_TAIL_LINES);
+    return indent(tail.map((l) => theme.fg("dim", l)), "     ");
+}
+/** Count added lines in a unified patch (edit summaries surface "+N"). */
+export function countPatchAdditions(patch) {
+    if (!patch)
+        return 0;
+    let added = 0;
+    for (const line of patch.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++"))
+            added += 1;
+    }
+    return added;
+}
+function countPatchRemovals(patch) {
+    if (!patch)
+        return 0;
+    let removed = 0;
+    for (const line of patch.split("\n")) {
+        if (line.startsWith("-") && !line.startsWith("---"))
+            removed += 1;
+    }
+    return removed;
+}
+const EXPAND_HINT = "(ctrl+o to expand)";
+/**
+ * `⎿ Wrote N lines to path` + a numbered, syntax-highlighted preview.
+ * `highlight` is injectable so tests stay independent of pi's theme state.
+ */
+export function formatWriteBody(rawPath, content, expanded, theme, cwd, highlight = highlightForPath) {
+    const allLines = content.replace(/\n$/, "").split("\n");
+    const total = allLines.length;
+    const shownCount = expanded ? Math.min(total, EXPANDED_MAX_LINES) : Math.min(total, WRITE_PREVIEW_LINES);
+    const head = `  ${theme.fg("muted", "⎿")} Wrote ${total} ${total === 1 ? "line" : "lines"} to ${theme.fg("accent", displayPath(rawPath, cwd))}`;
+    const shown = allLines.slice(0, shownCount);
+    const painted = highlight(shown.join("\n"), rawPath);
+    const numberWidth = String(shownCount).length;
+    const body = painted
+        .slice(0, shownCount)
+        .map((line, i) => `     ${theme.fg("dim", String(i + 1).padStart(numberWidth))} ${line}`);
+    const lines = [head, ...body];
+    if (total > shownCount) {
+        lines.push(`     ${theme.fg("muted", `… +${total - shownCount} lines ${EXPAND_HINT}`)}`);
+    }
+    return lines;
+}
+/** Default highlighter: pi's theme-backed syntax highlighting, failing to plain lines. */
+function highlightForPath(code, filePath) {
+    try {
+        return highlightCode(code, getLanguageFromPath(filePath));
+    }
+    catch {
+        return code.split("\n");
+    }
+}
+/**
+ * `⎿ Updated path (+A -R)` + a colored diff preview.
+ * `paintDiff` is injectable for the same reason as `highlight` above.
+ */
+export function formatEditBody(rawPath, details, expanded, theme, cwd, paintDiff = defaultPaintDiff) {
+    const added = countPatchAdditions(details?.patch);
+    const removed = countPatchRemovals(details?.patch);
+    const counts = added || removed
+        ? ` (${[added ? theme.fg("success", `+${added}`) : "", removed ? theme.fg("error", `-${removed}`) : ""]
+            .filter(Boolean)
+            .join(" ")})`
+        : "";
+    const head = `  ${theme.fg("muted", "⎿")} Updated ${theme.fg("accent", displayPath(rawPath, cwd))}${counts}`;
+    const diffText = details?.diff;
+    if (!diffText)
+        return [head];
+    const diffLines = paintDiff(diffText).split("\n");
+    const cap = expanded ? EXPANDED_MAX_LINES : DIFF_PREVIEW_LINES;
+    const lines = [head, ...indent(diffLines.slice(0, cap), "     ")];
+    if (diffLines.length > cap) {
+        lines.push(`     ${theme.fg("muted", `… +${diffLines.length - cap} lines ${EXPAND_HINT}`)}`);
+    }
+    return lines;
+}
+function defaultPaintDiff(diffText) {
+    try {
+        return renderDiff(diffText);
+    }
+    catch {
+        return diffText;
+    }
+}
+/** Expanded body: the raw output, dimmed and capped. */
+export function formatExpandedOutput(outputText, theme) {
+    const lines = outputText.replace(/\n$/, "").split("\n");
+    const shown = lines.slice(0, EXPANDED_MAX_LINES).map((l) => theme.fg("toolOutput", l));
+    if (lines.length > EXPANDED_MAX_LINES) {
+        shown.push(theme.fg("muted", `… +${lines.length - EXPANDED_MAX_LINES} lines`));
+    }
+    return shown;
+}
+function textOf(result) {
+    return (result?.content ?? [])
+        .filter((c) => c.type === "text" && typeof c.text === "string")
+        .map((c) => c.text)
+        .join("\n");
+}
+function hasImages(result) {
+    return (result?.content ?? []).some((c) => c.type === "image");
+}
+function empty() {
+    return new Container();
+}
+function textComponent(lines) {
+    return lines.length === 0 ? empty() : new Text(lines.join("\n"), 0, 0);
+}
+function defaultLoadSettings(cwd) {
+    return SettingsManager.create(cwd, getAgentDir());
+}
+/**
+ * Re-register the seven built-ins with condensed renderers. Returns the
+ * tracker so callers (and tests) can feed message boundaries into it.
+ */
+export function registerCondensedTools(pi, deps = {}) {
+    const tracker = new ToolRunTracker();
+    const registrationCwd = deps.cwd ?? process.cwd();
+    // Assistant/user prose breaks a run; toolResult messages must not (they are
+    // interleaved between the very rows a run aggregates).
+    pi.on("message_start", (event) => {
+        const role = event.message?.role;
+        if (role === "assistant" || role === "user")
+            tracker.markBreak();
+    });
+    let toolOptions;
+    try {
+        const settings = (deps.loadSettings ?? defaultLoadSettings)(registrationCwd);
+        toolOptions = {
+            bash: { shellPath: settings.getShellPath(), commandPrefix: settings.getShellCommandPrefix() },
+            read: { autoResizeImages: settings.getImageAutoResize() },
+        };
+    }
+    catch {
+        toolOptions = { bash: {}, read: {} };
+    }
+    const buildDefinitions = (cwd) => ({
+        read: createReadToolDefinition(cwd, toolOptions.read),
+        bash: createBashToolDefinition(cwd, toolOptions.bash),
+        edit: createEditToolDefinition(cwd),
+        write: createWriteToolDefinition(cwd),
+        grep: createGrepToolDefinition(cwd),
+        find: createFindToolDefinition(cwd),
+        ls: createLsToolDefinition(cwd),
+    });
+    const definitionsByCwd = new Map();
+    const definitionsFor = (cwd) => {
+        let defs = definitionsByCwd.get(cwd);
+        if (!defs) {
+            defs = buildDefinitions(cwd);
+            definitionsByCwd.set(cwd, defs);
+        }
+        return defs;
+    };
+    definitionsByCwd.set(registrationCwd, buildDefinitions(registrationCwd));
+    for (const name of BUILTIN_NAMES) {
+        const base = definitionsFor(registrationCwd)[name];
+        const kind = kindForTool(name);
+        const upsertFromCall = (context) => {
+            const args = context.args;
+            return tracker.upsert(context.toolCallId, {
+                kind,
+                scratchpad: isScratchpadPath(args?.path, deps.scratchpadDir, context.cwd),
+                error: context.isError,
+                final: !context.isPartial,
+                invalidate: context.invalidate,
+            });
+        };
+        pi.registerTool({
+            ...base,
+            renderShell: "self",
+            execute(toolCallId, params, signal, onUpdate, ctx) {
+                const cwd = ctx?.cwd ?? registrationCwd;
+                return definitionsFor(cwd)[name].execute(toolCallId, params, signal, onUpdate, ctx);
+            },
+            renderCall(args, theme, context) {
+                const slice = context;
+                const row = upsertFromCall(slice);
+                const status = slice.isError ? "error" : slice.isPartial ? "running" : "ok";
+                const argsRecord = args;
+                if (slice.expanded || !isQuiet(row)) {
+                    return new Text(formatRowTitle(name, argsRecord, status, theme, slice.cwd), 0, 0);
+                }
+                if (!row.final) {
+                    return new Text(formatRowTitle(name, argsRecord, "running", theme, slice.cwd), 0, 0);
+                }
+                const summary = tracker.summaryFor(row.id);
+                return summary ? new Text(theme.fg("muted", summary), 0, 0) : empty();
+            },
+            renderResult(result, options, theme, context) {
+                const slice = context;
+                const args = (slice.args ?? {});
+                const row = tracker.upsert(slice.toolCallId, {
+                    kind,
+                    final: !options.isPartial,
+                    error: slice.isError,
+                    images: hasImages(result),
+                    added: name === "write" && typeof args.content === "string"
+                        ? args.content.replace(/\n$/, "").split("\n").length
+                        : name === "edit"
+                            ? countPatchAdditions(result.details?.patch)
+                            : 0,
+                });
+                if (options.expanded) {
+                    if (name === "write" && typeof args.path === "string" && typeof args.content === "string" && !slice.isError) {
+                        return textComponent(formatWriteBody(args.path, args.content, true, theme, slice.cwd));
+                    }
+                    if (name === "edit" && typeof args.path === "string" && !slice.isError && result.details) {
+                        return textComponent(formatEditBody(args.path, result.details, true, theme, slice.cwd));
+                    }
+                    const output = textOf(result);
+                    return output ? textComponent(formatExpandedOutput(output, theme)) : empty();
+                }
+                if (name === "bash" && options.isPartial) {
+                    return textComponent(formatBashPartialBody(textOf(result), theme));
+                }
+                if (isQuiet(row))
+                    return empty();
+                if (slice.isError) {
+                    if (name === "bash")
+                        return textComponent(formatBashErrorBody(textOf(result), theme));
+                    const message = textOf(result).split("\n").filter(Boolean).slice(-ERROR_TAIL_LINES);
+                    return textComponent(message.map((l, i) => (i === 0 ? `  ${theme.fg("muted", "⎿")} ${theme.fg("error", l)}` : `     ${theme.fg("toolOutput", l)}`)));
+                }
+                if (name === "write" && typeof args.path === "string" && typeof args.content === "string") {
+                    return textComponent(formatWriteBody(args.path, args.content, false, theme, slice.cwd));
+                }
+                if (name === "edit" && typeof args.path === "string") {
+                    return textComponent(formatEditBody(args.path, result.details, false, theme, slice.cwd));
+                }
+                // Visible for another reason (e.g. an image read): title already
+                // painted by renderCall; images render themselves below the row.
+                return empty();
+            },
+        });
+    }
+    return tracker;
+}
+//# sourceMappingURL=condensedTools.js.map

package/dist/extension/diffStat.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Committed branch diff stat for the footer's git badge.
+ *
+ * Counting follows Codex (`tui/src/branch_summary.rs`), not Kimi: it sums the
+ * line delta between `HEAD` and the merge base with the repository's *default*
+ * branch, so the badge answers "what does this branch contain" — the same
+ * number a GitHub PR UI would show. Uncommitted working-tree edits are
+ * intentionally ignored (Codex: "the status-line item summarizes the checked-
+ * out branch, not the current dirty worktree").
+ *
+ * Display follows Kimi: `[+N -M]` appended to the branch, dim grey.
+ *
+ * Refresh reuses Kimi's synchronous TTL model: re-read at most every 15s,
+ * demanded on each footer render. The only divergence from Codex is that their
+ * probe is `async`; ours is `spawnSync` because the footer render path is
+ * synchronous.
+ */
+/** Committed branch delta relative to the default branch. */
+export interface BranchDiffStat {
+    readonly added: number;
+    readonly deleted: number;
+}
+/** Diff-stat source with a workDir, callable on demand. */
+export interface DiffStatCache {
+    /** Current stat, or `null` when workDir isn't a git repo. */
+    get(): BranchDiffStat | null;
+}
+/**
+ * Injectable git runner seam (tests stub it; production shells out to `git`).
+ * Returns stdout, or `null` on any failure.
+ */
+export type GitRunner = (args: string[], cwd: string) => string | null;
+/** True when `cwd` is inside a git work tree. Never throws. */
+export declare function detectGitRepo(run: GitRunner, cwd: string): boolean;
+/** Codex's `parseDiffNumstatCount`-equivalent: `-` (binary) → 0; non-numeric → 0. */
+export declare function parseNumstatCount(value: string | undefined): number;
+/**
+ * Resolve the default branch name, preferring remote-tracking refs over local
+ * branches so a stale local `main` doesn't inflate the diff (Codex's ordering).
+ * Falls back to common local names when no remote advertises a default.
+ * Returns null when nothing resolves.
+ */
+export declare function resolveDefaultBranch(run: GitRunner, cwd: string): string | null;
+/**
+ * Sum the committed line delta between `HEAD` and the merge base with the
+ * default branch: `git diff --numstat <merge-base>..HEAD`. Returns null when
+ * the default branch or merge base can't be resolved (hide the badge).
+ */
+export declare function readDiffStat(run: GitRunner, cwd: string): BranchDiffStat | null;
+/**
+ * Kimi-style display: `+N -M`, or null when the branch is even with its base
+ * (a fresh/unchanged branch shows no badge). Both-zero still renders nothing,
+ * matching "our style" (Kimi hides a clean tree; Codex would say "No changes").
+ */
+export declare function formatDiffStat(diff: BranchDiffStat | null): string | null;
+/**
+ * Time-bucketed cache: `get()` re-reads git only when the last read was more
+ * than 15s ago, null off-repo. All git failures → null (badge hidden), never
+ * throws.
+ */
+export declare function createDiffStatCache(workDir: string, run?: GitRunner): DiffStatCache;
+//# sourceMappingURL=diffStat.d.ts.map

package/dist/extension/diffStat.js

@@ -0,0 +1,158 @@
+/**
+ * Committed branch diff stat for the footer's git badge.
+ *
+ * Counting follows Codex (`tui/src/branch_summary.rs`), not Kimi: it sums the
+ * line delta between `HEAD` and the merge base with the repository's *default*
+ * branch, so the badge answers "what does this branch contain" — the same
+ * number a GitHub PR UI would show. Uncommitted working-tree edits are
+ * intentionally ignored (Codex: "the status-line item summarizes the checked-
+ * out branch, not the current dirty worktree").
+ *
+ * Display follows Kimi: `[+N -M]` appended to the branch, dim grey.
+ *
+ * Refresh reuses Kimi's synchronous TTL model: re-read at most every 15s,
+ * demanded on each footer render. The only divergence from Codex is that their
+ * probe is `async`; ours is `spawnSync` because the footer render path is
+ * synchronous.
+ */
+import { spawnSync } from "node:child_process";
+/** Status refresh interval — same value Kimi uses (STATUS_TTL_MS). */
+const STATUS_TTL_MS = 15_000;
+/** git spawn timeout — same value Kimi uses (SPAWN_TIMEOUT_MS). */
+const SPAWN_TIMEOUT_MS = 500;
+const SPAWN_MAX_BUFFER = 4 * 1024 * 1024;
+/** Production runner: `spawnSync` with a short timeout, all errors → null. */
+function runGit(args, cwd) {
+    try {
+        const r = spawnSync("git", ["--no-optional-locks", ...args], {
+            cwd,
+            encoding: "utf8",
+            timeout: SPAWN_TIMEOUT_MS,
+            maxBuffer: SPAWN_MAX_BUFFER,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        if (r.error || r.status !== 0)
+            return null;
+        return r.stdout;
+    }
+    catch {
+        return null;
+    }
+}
+/** True when `cwd` is inside a git work tree. Never throws. */
+export function detectGitRepo(run, cwd) {
+    const out = run(["rev-parse", "--is-inside-work-tree"], cwd);
+    return out !== null && out.trim() === "true";
+}
+/** Codex's `parseDiffNumstatCount`-equivalent: `-` (binary) → 0; non-numeric → 0. */
+export function parseNumstatCount(value) {
+    if (value === undefined || value === "-")
+        return 0;
+    const n = Number.parseInt(value, 10);
+    return Number.isFinite(n) && n > 0 ? n : 0;
+}
+/** List remotes, `origin` first (mirrors Codex's `get_git_remotes`). */
+function gitRemotes(run, cwd) {
+    const out = run(["remote"], cwd);
+    if (out === null)
+        return [];
+    const remotes = out.split("\n").map((l) => l.trim()).filter(Boolean);
+    const originIdx = remotes.indexOf("origin");
+    if (originIdx > 0) {
+        remotes.splice(originIdx, 1);
+        remotes.unshift("origin");
+    }
+    return remotes;
+}
+/**
+ * Resolve the default branch name, preferring remote-tracking refs over local
+ * branches so a stale local `main` doesn't inflate the diff (Codex's ordering).
+ * Falls back to common local names when no remote advertises a default.
+ * Returns null when nothing resolves.
+ */
+export function resolveDefaultBranch(run, cwd) {
+    // Tier 1: remote default via `refs/remotes/<remote>/HEAD` symbolic ref.
+    for (const remote of gitRemotes(run, cwd)) {
+        const out = run(["symbolic-ref", "--quiet", `refs/remotes/${remote}/HEAD`], cwd);
+        if (out === null)
+            continue;
+        const ref = out.trim();
+        if (!ref)
+            continue;
+        // `refs/remotes/origin/main` → `main`.
+        const name = ref.replace(/^refs\/remotes\/[^/]+\//, "");
+        if (name && name !== "HEAD")
+            return name;
+    }
+    // Tier 2: local main/master/trunk/develop.
+    for (const candidate of ["main", "master", "trunk", "develop"]) {
+        const out = run(["rev-parse", "--verify", "--quiet", candidate], cwd);
+        if (out !== null && out.trim())
+            return candidate;
+    }
+    return null;
+}
+/**
+ * Sum the committed line delta between `HEAD` and the merge base with the
+ * default branch: `git diff --numstat <merge-base>..HEAD`. Returns null when
+ * the default branch or merge base can't be resolved (hide the badge).
+ */
+export function readDiffStat(run, cwd) {
+    const defaultBranch = resolveDefaultBranch(run, cwd);
+    if (defaultBranch === null)
+        return null;
+    const mergeBase = run(["merge-base", "HEAD", defaultBranch], cwd);
+    if (mergeBase === null || !mergeBase.trim())
+        return null;
+    const out = run(["diff", "--numstat", `${mergeBase.trim()}..HEAD`, "--"], cwd);
+    if (out === null)
+        return null;
+    let added = 0;
+    let deleted = 0;
+    for (const line of out.split("\n")) {
+        if (!line)
+            continue;
+        const [addedText, deletedText] = line.split("\t");
+        added += parseNumstatCount(addedText);
+        deleted += parseNumstatCount(deletedText);
+    }
+    return { added, deleted };
+}
+/**
+ * Kimi-style display: `+N -M`, or null when the branch is even with its base
+ * (a fresh/unchanged branch shows no badge). Both-zero still renders nothing,
+ * matching "our style" (Kimi hides a clean tree; Codex would say "No changes").
+ */
+export function formatDiffStat(diff) {
+    if (diff === null)
+        return null;
+    const parts = [];
+    if (diff.added > 0)
+        parts.push(`+${String(diff.added)}`);
+    if (diff.deleted > 0)
+        parts.push(`-${String(diff.deleted)}`);
+    return parts.length > 0 ? parts.join(" ") : null;
+}
+/**
+ * Time-bucketed cache: `get()` re-reads git only when the last read was more
+ * than 15s ago, null off-repo. All git failures → null (badge hidden), never
+ * throws.
+ */
+export function createDiffStatCache(workDir, run = runGit) {
+    const isRepo = detectGitRepo(run, workDir);
+    let cached = null;
+    let fetchedAt = 0;
+    return {
+        get() {
+            if (!isRepo)
+                return null;
+            const now = Date.now();
+            if (cached === null || now - fetchedAt >= STATUS_TTL_MS) {
+                cached = readDiffStat(run, workDir);
+                fetchedAt = now;
+            }
+            return cached;
+        },
+    };
+}
+//# sourceMappingURL=diffStat.js.map

package/dist/extension/footer.d.ts

@@ -96,6 +96,8 @@ export declare function renderFooterLines(input: {
     model: string;
     /** Current permission mode; shown on line 2 to the left of the model as "<mode> mode". */
     mode?: PermissionMode | null;
+    /** Formatted `+N -M` / `±`, or null when clean — appended to the branch as `[ … ]`. */
+    diff?: string | null;
     usage: UsageTotals;
     contextPercent: number | null;
     statuses: string[];