@yagni-app/code 0.3.5 → 1.0.1

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

@@ -0,0 +1,64 @@
+/**
+ * The unified local error/log sink for YAGNI Code (YAG-580).
+ *
+ * Replaces the previous ~9 hand-rolled JSONL writers (image-paste.log,
+ * ask-question.log, turn-lifecycle.log, guardian.log, cost-divergence.log,
+ * auth-events.log, cmux-bridge.log, hooks.log, *.stream.log) with ONE sink.
+ *
+ * Two storage layers, purpose-named so their roles stay clear:
+ *
+ *  1. The DURABLE TRAIL — one rotating per-day JSONL under
+ *     `~/.yagni-code/logs/errors-<date>.jsonl` (size-capped + 2 rotations).
+ *     This is the crash-survivable WAL: `turn_start` without a matching
+ *     `turn_end` still leaves a record even if the process is killed. Critical
+ *     events append SYNCHRONOUSLY for exactly that reason.
+ *
+ *  2. The IN-MEMORY CAPTURE — a byte-budgeted ring buffer (not line-counted).
+ *     This is the `/feedback` binding convenience, NOT durability (an in-memory
+ *     ring does not survive a crash). Mirrors Codex's CodexFeedback ring and
+ *     Claude's inMemoryErrorLog.
+ *
+ * Every line carries a REQUIRED `sessionId` and a `source`/`level`/`event`
+ * triple so a shared file stays filterable: `jq 'select(.source=="guardian")'`
+ * reproduces today's per-file tail exactly, and /feedback reads the trail
+ * filtered by sessionId (never the raw file) so one session's report never
+ * leaks another session's errors.
+ *
+ * Default-on vs DEBUG invariant (the thing that makes "log everything by
+ * default" safe): default-on == scrub-safe == upload-safe. Any field carrying
+ * raw content (tool arguments, partial/result bodies, provider payloads, raw
+ * key bytes) must be gated behind YAGNI_DEBUG, and the /feedback reader refuses
+ * to bind any `level: debug` line. DEBUG == may-contain-content == never-uploads.
+ */
+export type SinkLevel = "error" | "warn" | "info" | "debug";
+export interface SinkEvent {
+    /** Former filename / subsystem: tool, turn, guardian, image-paste, ask-question, cost, auth, cmux, hooks. */
+    source: string;
+    level: SinkLevel;
+    /** Stable machine name (e.g. "turn_start", "bash.exit_1", "denied"). */
+    event: string;
+    /** Additional structured fields. NEVER raw content on a non-debug line. */
+    fields?: Record<string, unknown>;
+    /** Session id so the trail is filterable and scoped per feedback. Defaults to YAGNI_SESSION_ID. */
+    sessionId?: string;
+    /** "sync" flushes immediately (critical events); "buffered" is fine for high-volume debug. */
+    flush?: "sync" | "buffered";
+}
+export declare function _setErrorSinkHomeForTest(dir: string | null): void;
+export declare function errorSinkPath(now?: Date): string;
+export declare function _clearErrorSinkRingForTest(): void;
+export declare function errorSinkInMemory(): string;
+/**
+ * Append one event to both the ring and the durable trail. Fail-soft: a logging
+ * failure must never break the session. `flush: "sync"` (default for
+ * error-level events and lifecycle turns) bypasses any future buffering so a
+ * turn that starts but never ends still leaves a durable `turn_start`.
+ */
+export declare function logEvent(ev: SinkEvent): void;
+/**
+ * Read recent trail lines for ONE session, filtered by `sessionId`, up to
+ * `maxBytes`. Never returns `level: debug` lines — the default-on tier is the
+ * upload-safe tier, and DEBUG may contain content that must not leave the machine.
+ */
+export declare function readSessionTrail(sessionId: string, maxBytes?: number): string;
+//# sourceMappingURL=errorSink.d.ts.map

package/dist/extension/errorSink.js

@@ -0,0 +1,180 @@
+/**
+ * The unified local error/log sink for YAGNI Code (YAG-580).
+ *
+ * Replaces the previous ~9 hand-rolled JSONL writers (image-paste.log,
+ * ask-question.log, turn-lifecycle.log, guardian.log, cost-divergence.log,
+ * auth-events.log, cmux-bridge.log, hooks.log, *.stream.log) with ONE sink.
+ *
+ * Two storage layers, purpose-named so their roles stay clear:
+ *
+ *  1. The DURABLE TRAIL — one rotating per-day JSONL under
+ *     `~/.yagni-code/logs/errors-<date>.jsonl` (size-capped + 2 rotations).
+ *     This is the crash-survivable WAL: `turn_start` without a matching
+ *     `turn_end` still leaves a record even if the process is killed. Critical
+ *     events append SYNCHRONOUSLY for exactly that reason.
+ *
+ *  2. The IN-MEMORY CAPTURE — a byte-budgeted ring buffer (not line-counted).
+ *     This is the `/feedback` binding convenience, NOT durability (an in-memory
+ *     ring does not survive a crash). Mirrors Codex's CodexFeedback ring and
+ *     Claude's inMemoryErrorLog.
+ *
+ * Every line carries a REQUIRED `sessionId` and a `source`/`level`/`event`
+ * triple so a shared file stays filterable: `jq 'select(.source=="guardian")'`
+ * reproduces today's per-file tail exactly, and /feedback reads the trail
+ * filtered by sessionId (never the raw file) so one session's report never
+ * leaks another session's errors.
+ *
+ * Default-on vs DEBUG invariant (the thing that makes "log everything by
+ * default" safe): default-on == scrub-safe == upload-safe. Any field carrying
+ * raw content (tool arguments, partial/result bodies, provider payloads, raw
+ * key bytes) must be gated behind YAGNI_DEBUG, and the /feedback reader refuses
+ * to bind any `level: debug` line. DEBUG == may-contain-content == never-uploads.
+ */
+import { appendFileSync, mkdirSync, readFileSync, renameSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { codeStateHome } from "./stateHome.js";
+import { scrubSecrets } from "./pipeline/scrubSecrets.js";
+const MAX_LOG_BYTES = 256 * 1024;
+const KEEP_ROTATIONS = 2;
+const RING_MAX_BYTES = 256 * 1024;
+/** Test seam: point the log at a tmpdir (mirrors _setDiagnosticsHomeForTest). */
+let homeOverride = null;
+export function _setErrorSinkHomeForTest(dir) {
+    homeOverride = dir;
+}
+function logDir() {
+    return join(codeStateHome(homeOverride), "logs");
+}
+function dayStamp(now = new Date()) {
+    return now.toISOString().slice(0, 10); // YYYY-MM-DD
+}
+export function errorSinkPath(now = new Date()) {
+    return join(logDir(), `errors-${dayStamp(now)}.jsonl`);
+}
+/** In-memory ring buffer, byte-budgeted (trailing bytes kept when over cap). */
+class RingBuffer {
+    maxBytes;
+    chunks = [];
+    bytes = 0;
+    constructor(maxBytes) {
+        this.maxBytes = maxBytes;
+    }
+    push(line) {
+        const b = Buffer.byteLength(line, "utf8");
+        if (b >= this.maxBytes) {
+            this.chunks = [line];
+            this.bytes = b;
+            return;
+        }
+        while (this.bytes + b > this.maxBytes && this.chunks.length > 0) {
+            const dropped = this.chunks.shift();
+            this.bytes -= Buffer.byteLength(dropped, "utf8");
+        }
+        this.chunks.push(line);
+        this.bytes += b;
+    }
+    snapshot() {
+        return this.chunks.join("");
+    }
+    clear() {
+        this.chunks = [];
+        this.bytes = 0;
+    }
+}
+const ring = new RingBuffer(RING_MAX_BYTES);
+export function _clearErrorSinkRingForTest() {
+    ring.clear();
+}
+export function errorSinkInMemory() {
+    return ring.snapshot();
+}
+function rotateIfNeeded(path) {
+    try {
+        if (!statSync(path).isFile() || statSync(path).size < MAX_LOG_BYTES)
+            return;
+        for (let i = KEEP_ROTATIONS; i >= 1; i--) {
+            const from = i === 1 ? path : `${path}.${i - 1}`;
+            const to = `${path}.${i}`;
+            try {
+                renameSync(from, to);
+            }
+            catch {
+                /* absent source — fine */
+            }
+        }
+    }
+    catch {
+        /* rotation is best-effort */
+    }
+}
+function isDebug(env = process.env) {
+    const v = env.YAGNI_DEBUG;
+    return v === "1" || v === "true";
+}
+function sessionIdFor(ev) {
+    return ev.sessionId ?? process.env.YAGNI_SESSION_ID ?? "";
+}
+function serialize(ev) {
+    const line = {
+        ts: new Date().toISOString(),
+        source: ev.source,
+        level: ev.level,
+        event: ev.event,
+        sessionId: sessionIdFor(ev),
+        ...(ev.fields ?? {}),
+    };
+    return JSON.stringify(line) + "\n";
+}
+/**
+ * Append one event to both the ring and the durable trail. Fail-soft: a logging
+ * failure must never break the session. `flush: "sync"` (default for
+ * error-level events and lifecycle turns) bypasses any future buffering so a
+ * turn that starts but never ends still leaves a durable `turn_start`.
+ */
+export function logEvent(ev) {
+    try {
+        if (process.env.NODE_TEST_CONTEXT && homeOverride === null)
+            return;
+        const line = serialize(ev);
+        ring.push(line);
+        const path = errorSinkPath();
+        mkdirSync(dirname(path), { recursive: true });
+        rotateIfNeeded(path);
+        appendFileSync(path, line, "utf8");
+    }
+    catch {
+        /* logging must never throw into the editor */
+    }
+}
+/**
+ * Read recent trail lines for ONE session, filtered by `sessionId`, up to
+ * `maxBytes`. Never returns `level: debug` lines — the default-on tier is the
+ * upload-safe tier, and DEBUG may contain content that must not leave the machine.
+ */
+export function readSessionTrail(sessionId, maxBytes = 64 * 1024) {
+    try {
+        const data = readFileSync(errorSinkPath(), "utf8");
+        // Defense-in-depth: scrub each kept line so /diagnostics and /feedback
+        // never surface a secret or local path, even if a future caller slipped a
+        // content-bearing value onto an always-on line.
+        const lines = data
+            .split("\n")
+            .filter((l) => l.length > 0)
+            .filter((l) => {
+            try {
+                const obj = JSON.parse(l);
+                return obj.sessionId === sessionId && obj.level !== "debug";
+            }
+            catch {
+                return false;
+            }
+        })
+            .map((l) => scrubSecrets(l))
+            .join("\n");
+        return lines.length > maxBytes ? lines.slice(lines.length - maxBytes) : lines;
+    }
+    catch {
+        return "";
+    }
+}
+//# sourceMappingURL=errorSink.js.map

package/dist/extension/feedbackCommand.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The `/feedback` (alias `/bug`) command + the `/diagnostics` companion
+ * (YAG-580).
+ *
+ * `/feedback` captures the session transcript (pi's own append-only JSONL, read
+ * via `ctx.sessionManager` — never reconstructed from YAGNI_SESSION_ID, which is
+ * the proxy-attribution id), the session-scoped error trail (from the unified
+ * sink), any child `/go` run transcripts, a sanitized `yagni doctor` report, and
+ * git metadata — sanitizes the whole bundle with the shared scrub contract, and
+ * POSTs it to the YAGNI backend (opt-in, gated, named-human).
+ *
+ * `/diagnostics` is the read-only companion: it prints the last N sink lines for
+ * THIS session so the user can see what failed before deciding to attach it.
+ *
+ * Both treat the transcript as best-effort enrichment: pi's flush-to-file timing
+ * at command-invoke is not guaranteed, so a report never claims the reporting
+ * turn is captured unless it verifiably is.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export interface FeedbackDeps {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+    env?: NodeJS.ProcessEnv;
+    /** Sanitized `yagni doctor` output (string), or undefined to omit. */
+    getDoctorReport?: () => Promise<string | undefined>;
+    /** Git facts for the report; undefined fields are omitted. */
+    getGitState?: (cwd: string) => Promise<{
+        branch?: string;
+        commit?: string;
+        remote?: string;
+        dirty?: boolean;
+    }>;
+    /** Child `/go` run transcripts keyed by run id, for the current run tree. */
+    getChildTranscripts?: (cwd: string, sessionFile: string | undefined) => Promise<Record<string, string>>;
+}
+export declare function registerFeedbackCommands(pi: ExtensionAPI, deps: FeedbackDeps): void;
+//# sourceMappingURL=feedbackCommand.d.ts.map

package/dist/extension/feedbackCommand.js

@@ -0,0 +1,151 @@
+/**
+ * The `/feedback` (alias `/bug`) command + the `/diagnostics` companion
+ * (YAG-580).
+ *
+ * `/feedback` captures the session transcript (pi's own append-only JSONL, read
+ * via `ctx.sessionManager` — never reconstructed from YAGNI_SESSION_ID, which is
+ * the proxy-attribution id), the session-scoped error trail (from the unified
+ * sink), any child `/go` run transcripts, a sanitized `yagni doctor` report, and
+ * git metadata — sanitizes the whole bundle with the shared scrub contract, and
+ * POSTs it to the YAGNI backend (opt-in, gated, named-human).
+ *
+ * `/diagnostics` is the read-only companion: it prints the last N sink lines for
+ * THIS session so the user can see what failed before deciding to attach it.
+ *
+ * Both treat the transcript as best-effort enrichment: pi's flush-to-file timing
+ * at command-invoke is not guaranteed, so a report never claims the reporting
+ * turn is captured unless it verifiably is.
+ */
+import { readFileSync } from "node:fs";
+import { scrubSecrets } from "./pipeline/scrubSecrets.js";
+import { readSessionTrail } from "./errorSink.js";
+const MAX_DESCRIPTION = 512;
+const MAX_TRANSCRIPT_READ_BYTES = 512 * 1024;
+const notify = (ctx, message, type) => {
+    if (ctx.hasUI)
+        ctx.ui.notify(message, type);
+};
+function redact(text) {
+    return scrubSecrets(text);
+}
+/**
+ * Read the durable transcript, clamped by byte size. Returns empty on any
+ * failure or when too large (mirrors Claude's MAX_TRANSCRIPT_READ_BYTES guard).
+ */
+function readTranscript(sessionFile) {
+    if (!sessionFile)
+        return "";
+    try {
+        const data = readFileSync(sessionFile, "utf8");
+        if (Buffer.byteLength(data, "utf8") > MAX_TRANSCRIPT_READ_BYTES)
+            return "";
+        return data;
+    }
+    catch {
+        return "";
+    }
+}
+async function handleFeedback(args, ctx, deps) {
+    const sessionId = ctx.sessionManager.getSessionId?.() ?? deps.env?.YAGNI_SESSION_ID ?? "";
+    const sessionFile = ctx.sessionManager.getSessionFile?.();
+    const cwd = ctx.cwd;
+    const description = args.trim()
+        ? args.trim()
+        : await ctx.ui.input("Describe the issue", "What went wrong, in one or two lines?");
+    if (!description || description.trim().length === 0) {
+        notify(ctx, "Feedback cancelled.", "info");
+        return;
+    }
+    if (!ctx.isIdle()) {
+        notify(ctx, "YAGNI Code is busy; wait for the current turn to finish before /feedback.", "warning");
+        return;
+    }
+    const transcript = readTranscript(sessionFile);
+    const trail = readSessionTrail(sessionId);
+    const doctorReport = deps.getDoctorReport
+        ? await deps.getDoctorReport().catch(() => undefined)
+        : undefined;
+    const git = deps.getGitState
+        ? await deps.getGitState(cwd).catch(() => ({}))
+        : {};
+    const childTranscripts = deps.getChildTranscripts
+        ? await deps.getChildTranscripts(cwd, sessionFile).catch(() => ({}))
+        : {};
+    // Consent: enumerate exactly what is about to leave the machine.
+    const lines = [
+        "Your feedback description",
+        `This session's transcript${transcript ? "" : " (could not be read — possibly one turn stale)"}`,
+        `${Object.keys(childTranscripts).length} child run transcript(s)`,
+        "Recent error trail for this session",
+        ...(doctorReport ? ["Sanitized yagni doctor report"] : []),
+        ...(git.branch ? ["Git metadata (branch/commit/remote/dirty)"] : []),
+    ];
+    const ok = await ctx.ui.confirm("Submit feedback?", lines.join("\n     - ") + "\n\nSend this report?");
+    if (!ok) {
+        notify(ctx, "Feedback cancelled.", "info");
+        return;
+    }
+    const payload = {
+        client: "cli",
+        clientVersion: deps.env?.YAGNI_CODE_VERSION?.trim() || "unknown",
+        platform: `${process.platform} ${process.arch}`,
+        description: redact(description).slice(0, MAX_DESCRIPTION),
+        sessionId,
+        ...(transcript ? { transcriptJsonl: redact(transcript) } : {}),
+        ...(trail ? { errorTrailJsonl: redact(trail) } : {}),
+        ...(Object.keys(childTranscripts).length > 0
+            ? { childTranscripts: Object.fromEntries(Object.entries(childTranscripts).map(([k, v]) => [k, redact(v)])) }
+            : {}),
+        ...(doctorReport ? { doctorReport: redact(doctorReport) } : {}),
+        ...(git.branch ? { gitBranch: git.branch } : {}),
+        ...(git.commit ? { gitCommit: git.commit } : {}),
+        ...(git.remote ? { gitRemote: git.remote } : {}),
+        ...(git.dirty !== undefined ? { gitDirty: git.dirty } : {}),
+    };
+    try {
+        const fetchImpl = deps.fetchImpl ?? fetch;
+        const res = await fetchImpl(`${deps.baseUrl.replace(/\/$/, "")}/api/yagni-code/feedback`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${deps.getToken() ?? ""}`,
+            },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (res.ok) {
+            notify(ctx, "Feedback submitted. Thank you!", "info");
+        }
+        else {
+            notify(ctx, "Could not submit feedback. Please try again.", "error");
+        }
+    }
+    catch {
+        notify(ctx, "Could not submit feedback (network error). Please try again.", "error");
+    }
+}
+export function registerFeedbackCommands(pi, deps) {
+    pi.registerCommand("feedback", {
+        description: "File a bug report with your session transcript + error trail attached.",
+        handler: (args, ctx) => handleFeedback(args, ctx, deps),
+    });
+    pi.registerCommand("bug", {
+        description: "Alias for /feedback.",
+        handler: (args, ctx) => handleFeedback(args, ctx, deps),
+    });
+    pi.registerCommand("diagnostics", {
+        description: "Show recent error-trail lines for this session.",
+        handler: async (_args, ctx) => {
+            const sessionId = ctx.sessionManager.getSessionId?.() ?? deps.env?.YAGNI_SESSION_ID ?? "";
+            const trail = readSessionTrail(sessionId, 16 * 1024);
+            if (!trail) {
+                notify(ctx, "No recent diagnostics for this session.", "info");
+                return;
+            }
+            const lines = trail.split("\n").filter(Boolean);
+            const tail = lines.slice(-20);
+            notify(ctx, `Recent diagnostics (${lines.length} events):\n${tail.join("\n")}`, "info");
+        },
+    });
+}
+//# sourceMappingURL=feedbackCommand.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[];