@yagni-app/code 0.3.5 → 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/crashReport.js

@@ -27,6 +27,7 @@
 import { spawn } from "node:child_process";
 import { scrubSecrets } from "./pipeline/scrubSecrets.js";
 import { isDesktopSurface } from "./surface.js";
+import { logEvent } from "./errorSink.js";
 const defaultSpawn = (command, args, options) => spawn(command, args, options);
 export const CRASH_REPORT_DISABLE_ENV = "YAGNI_DISABLE_CRASH_REPORTS";
 export const CRASH_REPORT_TIMEOUT_MS = 1_500;
@@ -267,6 +268,17 @@ export function reportFatalCrash(error, opts, context) {
 export function installUncaughtExceptionMonitor(opts, proc = process) {
     proc.on("uncaughtExceptionMonitor", (err) => {
         reportFatalCrash(err, opts, "uncaught-exception");
+        // Also seed the local error trail (best-effort): the crash report is a
+        // sanitized POST, but the ON-DISK trail is what /feedback binds for a
+        // report someone files next session.
+        logEvent({
+            source: "tool",
+            level: "error",
+            event: "uncaught_exception",
+            sessionId: process.env.YAGNI_SESSION_ID ?? undefined,
+            flush: "sync",
+            fields: { errorClass: err instanceof Error ? err.name || "Error" : "Error" },
+        });
     });
 }
 //# sourceMappingURL=crashReport.js.map

package/dist/extension/decisionCapture.js

@@ -17,6 +17,7 @@
  * never affects the tool call that triggered it.
  */
 import { bankDecision } from "./decisions.js";
+import { logEvent } from "./errorSink.js";
 /** At most one capture prompt per this window (spec: 10 minutes). */
 export const CAPTURE_DEBOUNCE_MS = 10 * 60 * 1000;
 /** Build a session-scoped decision capture (holds the debounce timestamp). */
@@ -54,10 +55,12 @@ export function makeDecisionCapture(deps) {
                     ctx.ui.notify("Saved the decision locally; it will sync automatically.", "info");
                 }
                 else {
+                    logEvent({ source: "decision-capture", level: "error", event: "capture_failed", fields: { kind: outcome.kind } });
                     ctx.ui.notify(outcome.message, "error");
                 }
             }
             catch {
+                logEvent({ source: "decision-capture", level: "error", event: "capture_failed", fields: { kind: "threw" } });
                 /* fail-soft: a capture failure never affects the tool call */
             }
         },

package/dist/extension/decisions.js

@@ -20,6 +20,7 @@
 import { randomUUID } from "node:crypto";
 import { friendlyFetchError, METERED_POST_FETCH_POLICY, resilientFetch } from "./resilientFetch.js";
 import { sendOrSpool } from "./spool.js";
+import { logEvent } from "./errorSink.js";
 /**
  * Bank a `cli_correction` decision durably. Every logical write carries a
  * generated idempotencyKey; the backend dedups on it, so a spool replay or a
@@ -151,6 +152,7 @@ export function registerDecisionCommands(pi, opts) {
                 notify(notice.message, notice.type);
             }
             catch (err) {
+                logEvent({ source: "decisions", level: "error", event: "decide_failed", fields: { op: "decide" } });
                 notify(`Could not record the decision: ${err instanceof Error ? err.message : String(err)}`, "error");
             }
         },
@@ -183,6 +185,7 @@ export function registerDecisionCommands(pi, opts) {
                     notify(`Superseded decision ${shortId(id)}.`, "info");
                 }
                 catch (err) {
+                    logEvent({ source: "decisions", level: "error", event: "supersede_failed", fields: { op: "supersede" } });
                     notify(`Could not supersede decision: ${err instanceof Error ? err.message : String(err)}`, "error");
                 }
                 return;
@@ -192,6 +195,7 @@ export function registerDecisionCommands(pi, opts) {
                 await pi.sendUserMessage(formatDecisionsList(items));
             }
             catch (err) {
+                logEvent({ source: "decisions", level: "error", event: "list_failed", fields: { op: "list" } });
                 notify(`Could not list decisions: ${err instanceof Error ? err.message : String(err)}`, "error");
             }
         },

package/dist/extension/diagnostics.d.ts

@@ -12,7 +12,9 @@
  * A support flow can tail this file and POST it with the user's consent;
  * nothing is uploaded automatically.
  */
+import { readSessionTrail } from "./errorSink.js";
 export declare function _setDiagnosticsHomeForTest(dir: string | null): void;
+/** Active unified-sink path (one rotating per-day JSONL for all sources). */
 export declare function diagnosticsLogPath(): string;
 /** Layer A: verbose mode. `YAGNI_DEBUG=1` (or "true") turns on extra detail. */
 export declare function isDebug(env?: NodeJS.ProcessEnv): boolean;
@@ -34,8 +36,37 @@ export interface ImagePasteEvent {
  * prompt. `detail` is included only when YAGNI_DEBUG is on.
  */
 export declare function logImagePaste(ev: ImagePasteEvent): void;
+export interface AskQuestionEvent {
+    /** Stable event name: "key" | "finish" | "render" | "navigate" | "other_key". */
+    event: string;
+    /** Human-readable description; NEVER user-typed text or question content. */
+    detail?: string;
+    selectedIndex?: number;
+    otherIndex?: number;
+    otherLen?: number;
+    /** Raw key bytes, escaped (only for debug). */
+    key?: string;
+    /** Resolution status when the tool finishes: selected | other | cancelled. */
+    status?: string;
+    /** Whether the question is multiSelect at the time of the event. */
+    multi?: boolean;
+    /** 0-based index of the question within this tool call (multi-question runs). */
+    qIndex?: number;
+    /** Whether the "Other" row auto-check is on (multi-select). */
+    checked?: boolean;
+}
+/**
+ * Append one sanitized ask-user-question event to the unified sink
+ * (source:"ask-question").
+ * Fail-soft and hermetically gated under `node --test` exactly like
+ * `logImagePaste`. Never logs user-typed text, question text, or option labels
+ * — only indices, lengths, key bytes (escaped), and resolution status.
+ */
+export declare function logAskQuestion(ev: AskQuestionEvent): void;
 /** Read the most recent log content (for a user-triggered report). */
 export declare function readRecentDiagnostics(maxBytes?: number): string;
 /** List existing diagnostic log files (active + rotations), for a report. */
 export declare function listDiagnosticFiles(): string[];
+/** Re-export the session-scoped trail reader for the /feedback flow. */
+export { readSessionTrail };
 //# sourceMappingURL=diagnostics.d.ts.map

package/dist/extension/diagnostics.js

@@ -12,22 +12,19 @@
  * A support flow can tail this file and POST it with the user's consent;
  * nothing is uploaded automatically.
  */
-import { appendFileSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, } from "node:fs";
+import { readFileSync, readdirSync } from "node:fs";
 import { dirname, join, basename } from "node:path";
-import { codeStateHome } from "./stateHome.js";
+import { _setErrorSinkHomeForTest, logEvent, errorSinkPath, readSessionTrail, } from "./errorSink.js";
 /** Test seam (mirrors `_setYagniCodeHomeForTest`): point the log at a tmpdir. */
 let homeOverride = null;
 export function _setDiagnosticsHomeForTest(dir) {
     homeOverride = dir;
+    _setErrorSinkHomeForTest(dir);
 }
-function yagniCodeHome() {
-    return codeStateHome(homeOverride);
-}
+/** Active unified-sink path (one rotating per-day JSONL for all sources). */
 export function diagnosticsLogPath() {
-    return join(yagniCodeHome(), "logs", "image-paste.log");
+    return errorSinkPath();
 }
-const MAX_LOG_BYTES = 256 * 1024; // rotate the active file past this
-const KEEP_ROTATIONS = 2; // keep image-paste.log.1 and .2 alongside the active file
 /** Layer A: verbose mode. `YAGNI_DEBUG=1` (or "true") turns on extra detail. */
 export function isDebug(env = process.env) {
     const v = env.YAGNI_DEBUG;
@@ -38,56 +35,55 @@ export function isDebug(env = process.env) {
  * prompt. `detail` is included only when YAGNI_DEBUG is on.
  */
 export function logImagePaste(ev) {
-    try {
-        // Hermetic under `node --test`: never touch the real home dir from a test
-        // unless the test explicitly stubbed it. Writing to the runner's $HOME made
-        // the suite's exit depend on the CI filesystem (a read-only or slow $HOME
-        // could stall the write), which is the leading suspect for the CI hang.
-        if (process.env.NODE_TEST_CONTEXT && homeOverride === null)
-            return;
-        const line = {
-            ts: new Date().toISOString(),
-            event: ev.event,
-            ...(ev.outcome !== undefined ? { outcome: ev.outcome } : {}),
-            ...(ev.mimeType !== undefined ? { mimeType: ev.mimeType } : {}),
-            ...(ev.bytes !== undefined ? { bytes: ev.bytes } : {}),
-            ...(ev.imageCount !== undefined ? { imageCount: ev.imageCount } : {}),
-            ...(ev.file !== undefined ? { file: basename(ev.file) } : {}),
-            ...(ev.detail !== undefined && isDebug() ? { detail: ev.detail } : {}),
-        };
-        const path = diagnosticsLogPath();
-        mkdirSync(dirname(path), { recursive: true });
-        rotateIfNeeded(path);
-        appendFileSync(path, JSON.stringify(line) + "\n", "utf8");
-    }
-    catch {
-        /* logging must never throw into the editor */
-    }
+    // The unified sink: content-free fields are always-on, the debug-only
+    // `detail` rides level:debug (never bound by /feedback).
+    const fields = {
+        ...(ev.outcome !== undefined ? { outcome: ev.outcome } : {}),
+        ...(ev.mimeType !== undefined ? { mimeType: ev.mimeType } : {}),
+        ...(ev.bytes !== undefined ? { bytes: ev.bytes } : {}),
+        ...(ev.imageCount !== undefined ? { imageCount: ev.imageCount } : {}),
+        ...(ev.file !== undefined ? { file: basename(ev.file) } : {}),
+        ...(ev.detail !== undefined && isDebug() ? { detail: ev.detail } : {}),
+    };
+    logEvent({
+        source: "image-paste",
+        level: ev.detail !== undefined && isDebug() ? "debug" : "info",
+        event: ev.event,
+        fields,
+    });
 }
-/** Shift image-paste.log -> .1 -> .2 once the active file passes the size cap. */
-function rotateIfNeeded(path) {
-    try {
-        if (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 */
-    }
+/**
+ * Append one sanitized ask-user-question event to the unified sink
+ * (source:"ask-question").
+ * Fail-soft and hermetically gated under `node --test` exactly like
+ * `logImagePaste`. Never logs user-typed text, question text, or option labels
+ * — only indices, lengths, key bytes (escaped), and resolution status.
+ */
+export function logAskQuestion(ev) {
+    // Raw key bytes (`key`) and `detail` are content-ish: gate them behind DEBUG.
+    const debug = isDebug();
+    const fields = {
+        ...(ev.selectedIndex !== undefined ? { selectedIndex: ev.selectedIndex } : {}),
+        ...(ev.otherIndex !== undefined ? { otherIndex: ev.otherIndex } : {}),
+        ...(ev.otherLen !== undefined ? { otherLen: ev.otherLen } : {}),
+        ...(ev.status !== undefined ? { status: ev.status } : {}),
+        ...(ev.multi !== undefined ? { multi: ev.multi } : {}),
+        ...(ev.qIndex !== undefined ? { qIndex: ev.qIndex } : {}),
+        ...(ev.checked !== undefined ? { checked: ev.checked } : {}),
+        ...(ev.key !== undefined && debug ? { key: ev.key } : {}),
+        ...(ev.detail !== undefined && debug ? { detail: ev.detail } : {}),
+    };
+    logEvent({
+        source: "ask-question",
+        level: debug ? "debug" : "info",
+        event: ev.event,
+        fields,
+    });
 }
 /** Read the most recent log content (for a user-triggered report). */
 export function readRecentDiagnostics(maxBytes = 64 * 1024) {
     try {
-        const data = readFileSync(diagnosticsLogPath(), "utf8");
+        const data = readFileSync(errorSinkPath(), "utf8");
         return data.length > maxBytes ? data.slice(data.length - maxBytes) : data;
     }
     catch {
@@ -97,9 +93,9 @@ export function readRecentDiagnostics(maxBytes = 64 * 1024) {
 /** List existing diagnostic log files (active + rotations), for a report. */
 export function listDiagnosticFiles() {
     try {
-        const dir = dirname(diagnosticsLogPath());
+        const dir = dirname(errorSinkPath());
         return readdirSync(dir)
-            .filter((f) => f.startsWith("image-paste.log"))
+            .filter((f) => f.startsWith("errors-"))
             .sort()
             .map((f) => join(dir, f));
     }
@@ -107,4 +103,6 @@ export function listDiagnosticFiles() {
         return [];
     }
 }
+/** Re-export the session-scoped trail reader for the /feedback flow. */
+export { readSessionTrail };
 //# sourceMappingURL=diagnostics.js.map