@yagni-app/code 0.3.5 → 1.0.1

package/dist/extension/footer.js

@@ -42,6 +42,7 @@ import { spawnSync } from "node:child_process";
 import { statSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { createDiffStatCache, formatDiffStat } from "./diffStat.js";
 export const BRANCH_MAX_WIDTH = 60;
 const WORKTREE_MAX_WIDTH = 30;
 /** Section separator: single space + middle dot + single space. */
@@ -229,13 +230,18 @@ export function renderFooterLines(input, theme, width, padX = 0) {
     // terminal edge. Truncation runs against the reduced content width.
     const pad = " ".repeat(Math.max(0, Math.min(3, Math.floor(padX))));
     const contentWidth = Math.max(1, width - pad.length);
-    // Line 1: folder · [worktree] · branch
+    // Line 1: folder · [worktree] · branch [+N -M]
     const line1Parts = [theme.fg("accent", input.git.folder)];
     if (input.git.inRepo) {
         if (input.git.worktree)
             line1Parts.push(theme.fg("warning", `[${input.git.worktree}]`));
-        if (input.git.branch)
-            line1Parts.push(theme.fg("border", truncateEnd(input.git.branch, BRANCH_MAX_WIDTH, dim("…"))));
+        if (input.git.branch) {
+            const branchSpan = theme.fg("border", truncateEnd(input.git.branch, BRANCH_MAX_WIDTH, dim("…")));
+            // Diff badge rides the branch segment (Kimi's `branch [ +N -M ]` shape),
+            // colored dim — the same grey as the cost stats on line 2.
+            const diffSpan = input.diff ? ` ${dim(`[${input.diff}]`)}` : "";
+            line1Parts.push(branchSpan + diffSpan);
+        }
     }
     const line1 = pad + truncateToWidth(line1Parts.join(sep), contentWidth, dim("…"));
     // Line 2: [mode ·] model · ↑in ↓out $cost · ctx%
@@ -269,17 +275,23 @@ export function renderFooterLines(input, theme, width, padX = 0) {
 export function createYagniFooterFactory(ctx, modeHolder, invalidateHandle) {
     return (_tui, theme, footerData) => {
         let gitCache;
-        const unsubscribeBranch = footerData.onBranchChange?.(() => {
+        let diffStatCache;
+        const clearCaches = () => {
             gitCache = undefined;
-        });
+            diffStatCache = undefined;
+        };
+        const unsubscribeBranch = footerData.onBranchChange?.(clearCaches);
         const gitInfo = () => {
             if (!gitCache) {
-                gitCache = detectGitInfo(ctx.sessionManager.getCwd(), process.env.HOME || process.env.USERPROFILE);
+                // Read cwd once; both the git info and the diff cache key off it.
+                const dir = ctx.sessionManager.getCwd();
+                gitCache = detectGitInfo(dir, process.env.HOME || process.env.USERPROFILE);
+                diffStatCache = createDiffStatCache(dir);
             }
             return gitCache;
         };
         if (invalidateHandle) {
-            invalidateHandle.invalidateGit = () => { gitCache = undefined; };
+            invalidateHandle.invalidateGit = clearCaches;
             invalidateHandle.requestRender = () => { _tui?.requestRender?.(); };
         }
         return {
@@ -291,13 +303,14 @@ export function createYagniFooterFactory(ctx, modeHolder, invalidateHandle) {
                     git: gitInfo(),
                     model: ctx.model?.id ?? "no-model",
                     mode: modeHolder?.get() ?? null,
+                    diff: formatDiffStat(diffStatCache?.get() ?? null),
                     usage: collectUsage(ctx.sessionManager),
                     contextPercent: ctx.getContextUsage()?.percent ?? null,
                     statuses,
                 }, theme, width, resolveFooterPadX());
             },
             invalidate() {
-                gitCache = undefined;
+                clearCaches();
             },
             dispose() {
                 unsubscribeBranch?.();

package/dist/extension/hooks.js

@@ -17,11 +17,12 @@
  * Fail-soft: a broken hook degrades to "no hook," never to "broken session."
  */
 import { spawn } from "node:child_process";
-import { mkdirSync, appendFileSync, existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import { homedir } from "node:os";
 import { codeStateHome } from "./stateHome.js";
 import { isDebug } from "./diagnostics.js";
+import { logEvent } from "./errorSink.js";
 const SUPPORTED_EVENTS = [
     "SessionStart",
     "UserPromptSubmit",
@@ -286,16 +287,15 @@ export function parseCompactCancel(stdout) {
 function logHookEvent(env, payload) {
     if (!isDebug(env))
         return;
-    try {
-        if (process.env.NODE_TEST_CONTEXT)
-            return;
-        const logPath = join(codeStateHome(null, env), "logs", "hooks.log");
-        mkdirSync(dirname(logPath), { recursive: true });
-        appendFileSync(logPath, JSON.stringify({ ts: new Date().toISOString(), ...payload }) + "\n", "utf8");
-    }
-    catch {
-        // logging must never break the session
-    }
+    const event = typeof payload.event === "string" ? payload.event : "hook_event";
+    const { event: _ignored, ...fields } = payload;
+    logEvent({
+        source: "hooks",
+        level: "debug",
+        event,
+        sessionId: env.YAGNI_SESSION_ID ?? undefined,
+        fields,
+    });
 }
 /** Filter hook groups by workspace trust: project-level groups are skipped when untrusted. */
 function filterByTrust(groups, isTrusted) {

package/dist/extension/index.d.ts

@@ -120,6 +120,7 @@ export default function (pi: ExtensionAPI): Promise<void>;
 export { makeAskYagniTool } from "./askYagniTool.js";
 export { makeFileTicketTool, makeUpdateTicketStatusTool } from "./ticketTools.js";
 export { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
+export { makeAskUserQuestionTool } from "./askUserQuestionTool.js";
 export { ADVISOR_TIER, DEFAULT_ADVISOR_LIMITS, decideConsult, formatAdvisorSubtotal, makeAdvisorState, } from "./advisor.js";
 export { DEFAULT_GUARDIAN_LIMITS, GUARDIAN_MODEL_TIER, formatGuardianSubtotal, makeGuardianState, resolveGuardianLimits, reviewCommand, deriveGuardianTimeoutMs, } from "./permission/guardian.js";
 export type { GuardianOutcome, GuardianVerdict, GuardianState, GuardianStateHandle, GuardianLimits, ReviewResult, ReviewCommandDeps, } from "./permission/guardian.js";
@@ -185,6 +186,12 @@ export { makeTokenProvider, makeAuthedFetch, persistRotationToProfile, PROACTIVE
 export type { TokenProvider, TokenProviderDeps, ScheduleFn } from "./tokenProvider.js";
 export { appendToSpool, loadSpool, flushSpool, sendOrSpool, spoolFile, MAX_SPOOL_AGE_MS, _setSpoolHomeForTest, } from "./spool.js";
 export type { SpoolEntry, SpoolClientOpts, FlushOutcome, JudgmentWriteOutcome } from "./spool.js";
+export { registerCondensedTools, displayPath, isScratchpadPath, primaryArg, formatRowTitle, formatWriteBody, formatEditBody, formatBashErrorBody, formatBashPartialBody, formatExpandedOutput, splitBashError, countPatchAdditions, WRITE_PREVIEW_LINES, DIFF_PREVIEW_LINES, } from "./condensedTools.js";
+export type { RegisterCondensedToolsDeps, RowStatus } from "./condensedTools.js";
+export { ToolRunTracker, summarizeRun, isQuiet, kindForTool } from "./toolRuns.js";
+export type { RowKind, ToolRow, ToolRowPatch } from "./toolRuns.js";
+export { registerWorkingLine, composeWorkingMessage, NULL_WORKING_LINE, WORKING_INDICATOR_FRAMES, WORKING_VERBS, } from "./workingLine.js";
+export type { WorkingLineHandle, RegisterWorkingLineDeps } from "./workingLine.js";
 export { crashReportsDisabled, installUncaughtExceptionMonitor, makeCrashReporter, reportFatalCrash, sanitizeCrashError, sanitizeCrashText, } from "./crashReport.js";
 export type { CrashReporter, CrashReporterOpts, FatalCrashOpts, SanitizedCrash } from "./crashReport.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/extension/index.js

@@ -1,13 +1,13 @@
 import { createHash } from "node:crypto";
-import { appendFileSync, mkdirSync } from "node:fs";
-import { dirname, join } from "node:path";
 import { Text } from "@earendil-works/pi-tui";
 import { DEFAULT_ADVISOR_LIMITS, formatAdvisorSubtotal, makeAdvisorState } from "./advisor.js";
 import { appendGrant, loadGrants, resolveRepoKey, storagePrefix } from "./permission/approvedPrefixes.js";
 import { redactCommand } from "./redact.js";
 import { formatGuardianSubtotal, GUARDIAN_MODEL_TIER, makeGuardianState, resolveGuardianLimits, reviewCommand, deriveGuardianTimeoutMs } from "./permission/guardian.js";
 import { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
+import { makeAskUserQuestionTool } from "./askUserQuestionTool.js";
 import { makeAskYagniTool } from "./askYagniTool.js";
+import { makeWebFetchTool } from "./webFetchTool.js";
 import { makeFileTicketTool, makeUpdateTicketStatusTool } from "./ticketTools.js";
 import { makeReviewBusinessMatchTool } from "./reviewTool.js";
 import { registerCmuxBridge } from "./cmux/index.js";
@@ -16,8 +16,11 @@ import { makeRecordDecisionTool } from "./recordDecisionTool.js";
 import { makeSuggestNextWorkTool } from "./nextWorkTool.js";
 import { BRAND_NAME, brandSystemPrompt, brandingDisabled, buildMastheadString, YAGNI_IDENTITY_DRIVER, YAGNI_IDENTITY_ULTRA } from "./branding.js";
 import { claudeRulesSection } from "./claudeRules.js";
+import { ensureScratchpadDir, SCRATCHPAD_TMPDIR_ENV, scratchpadDir as scratchpadDirFor, scratchpadSection } from "./scratchpad.js";
 import { registerCostCommand } from "./costHud.js";
 import { isDebug } from "./diagnostics.js";
+import { logEvent } from "./errorSink.js";
+import { registerFeedbackCommands } from "./feedbackCommand.js";
 import { droppedSessionRuns, sessionRunIds } from "./sessionRuns.js";
 import { codeStateHome } from "./stateHome.js";
 import { logTurnLifecycle } from "./turnLog.js";
@@ -46,6 +49,9 @@ import { registerChipEditor } from "./chipEditor.js";
 import { defaultMineBeatGit, fileMineBeatMarkers, maybeOfferMiningBeat as defaultMaybeOfferMiningBeat, } from "./mineBeat.js";
 import { makeFlywheelState } from "./flywheel.js";
 import { registerSilentTurnReminder } from "./silentTurnReminder.js";
+import { registerCondensedTools } from "./condensedTools.js";
+import { isDesktopSurface } from "./surface.js";
+import { registerWorkingLine, WORKING_INDICATOR_FRAMES } from "./workingLine.js";
 function isEvalMode(env = process.env) {
     return env.YAGNI_CODE_EVAL_MODE === "1";
 }
@@ -158,7 +164,15 @@ export async function registerYagni(pi, deps = {}) {
     // no-position record suggestions reach the model) and record_decision
     // (flywheel-attributed records send dedupe: true). Run 7.
     const flywheelState = makeFlywheelState();
+    // The composed streaming status line ("Shaping… (12m 54s · ↓ 47.5k tokens)").
+    // Registered before the subagent/advisor tools: they publish their live
+    // progress through this handle so the elapsed/token suffix survives their
+    // overrides. TUI-gated internally (agent_start checks ctx.mode).
+    const workingLine = registerWorkingLine(pi);
     pi.registerTool(makeAskYagniTool({ ...toolOpts, flywheel: flywheelState, getRepo: () => sessionRepo }));
+    // WebFetch (YAG-578): read an arbitrary URL as clean markdown + a
+    // standard-tier extraction, replacing the bash + curl + python dance.
+    pi.registerTool(makeWebFetchTool(toolOpts));
     // Ticket write-back (spec 2026-08-09): explicit user-intent writes to the
     // workspace tracker, attributed to the developer via per-user credentials.
     if (!evalMode) {
@@ -172,11 +186,14 @@ export async function registerYagni(pi, deps = {}) {
     // hide it forever from a session that switched TO Advanced. One state handle
     // per session, shared with /advise so they draw on the same cap.
     const advisorState = makeAdvisorState();
-    const askAdvisorTool = makeAskAdvisorTool({ state: advisorState });
+    const askAdvisorTool = makeAskAdvisorTool({ state: advisorState, workingLine });
     pi.registerTool(askAdvisorTool);
     // /advise runs the SAME tool, sharing the state handle, so a manual consult
     // draws on the same cap rather than opening a side channel around it.
     registerAdviseCommand(pi, askAdvisorTool);
+    // Structured human questions: the model poses a closed 2-4-option question
+    // and gets a clean machine-readable answer via ctx.ui.custom.
+    pi.registerTool(makeAskUserQuestionTool());
     // The differentiated business-grounded tools (loop bricks): review a change
     // for business fit, rank the next work by business priority, and record the
     // engineering rationale back onto the work-item.
@@ -209,7 +226,7 @@ export async function registerYagni(pi, deps = {}) {
     // driver's delegation identity for the diamond directive (see the
     // before_agent_start handler below) and widens the tool's fan-out ceiling.
     const ultraHolder = createUltraHolder();
-    registerSubagents(pi, { isUltra: () => ultraHolder.get() });
+    registerSubagents(pi, { isUltra: () => ultraHolder.get(), workingLine });
     registerUltraCommand(pi, ultraHolder);
     // Shared fetch timeout for the small, interactive display-path reads below
     // (/cost's spend + headroom, and Task 8's per-run spend for /go's summary):
@@ -244,6 +261,19 @@ export async function registerYagni(pi, deps = {}) {
     // M6 eval (report-only): /go-compare runs a ticket grounded vs blind and reports
     // the business-fit delta. Never wired to routing.
     registerGoCompareCommand(pi);
+    // YAG-580: /feedback (alias /bug) + /diagnostics. The capture/upload is the
+    // whole point, so it is gated to non-eval mode like every external side
+    // effect; the command's deps (doctor report, git state, child transcripts)
+    // are injected so the handler stays unit-testable without spawning git or
+    // reading the real session dir.
+    if (!evalMode) {
+        registerFeedbackCommands(pi, {
+            baseUrl,
+            getToken: getTokenFn,
+            fetchImpl: deps.fetchImpl,
+            env: deps.env,
+        });
+    }
     // W4 judgment loop: the decisions surface (/decide + /decisions) and the
     // bless-with-remember capture are the same product-intent write as the record
     // tools, so both are gated together (skipped in eval mode).
@@ -288,18 +318,19 @@ export async function registerYagni(pi, deps = {}) {
         ...(guardianMaxAttemptsAdvertised !== undefined ? { maxAttempts: guardianMaxAttemptsAdvertised } : {}),
     });
     guardianLimits.timeoutMs = guardianTimeoutMs;
-    // YAG-510: guardian.log stays the sanitized local debug sink (hash-only,
-    // never the command). The remote guardian-events stream below is the
-    // separate, opt-in, per-workspace analytics sink; the two are independent.
+    // YAG-510: Guardian events go to the unified sink under source:"guardian"
+    // (hash-only, never the command). The remote guardian-events stream below is
+    // the separate, opt-in, per-workspace analytics sink; the two are independent.
     const guardianLogSink = (payload) => {
-        try {
-            if (process.env.NODE_TEST_CONTEXT)
-                return;
-            const logPath = join(codeStateHome(null), "logs", "guardian.log");
-            mkdirSync(dirname(logPath), { recursive: true });
-            appendFileSync(logPath, JSON.stringify({ ts: new Date().toISOString(), ...payload }) + "\n", "utf8");
-        }
-        catch { /* logging must never break the session */ }
+        const event = typeof payload.event === "string" ? payload.event : "guardian_event";
+        const { event: _ignored, ...fields } = payload;
+        logEvent({
+            source: "guardian",
+            level: event === "guardian_event_post_failed" ? "error" : "info",
+            event,
+            sessionId: env.YAGNI_SESSION_ID ?? undefined,
+            fields,
+        });
     };
     // YAG-510: persisted "don't ask again" grants, per-repo keyed. Loaded once
     // at startup (grants added by other concurrent sessions appear next launch —
@@ -331,7 +362,8 @@ export async function registerYagni(pi, deps = {}) {
         // "off" → nothing (not even sent); "hash" → sha256 + family prefix +
         // metadata, no command content; "raw" → adds client-REDACTED command and
         // rationale. Fire-and-forget: one attempt, short timeout, failures logged
-        // fail-soft to guardian.log — a storage outage never touches the session.
+        // fail-soft to the unified sink (source:"guardian") — a storage outage
+        // never touches the session.
         onGuardianEvent: guardianStorageTier === "off" || evalMode
             ? undefined
             : (ev) => {
@@ -369,10 +401,10 @@ export async function registerYagni(pi, deps = {}) {
                             guardianLogSink({ event: "guardian_event_post_failed", status: res.status });
                         }
                     }
-                    catch (err) {
+                    catch {
                         guardianLogSink({
                             event: "guardian_event_post_failed",
-                            error: err instanceof Error ? err.message : "unknown",
+                            kind: "network",
                         });
                     }
                 })();
@@ -454,15 +486,13 @@ export async function registerYagni(pi, deps = {}) {
         onDivergence: (driverServerUsd, localUsd) => {
             if (!isDebug(env))
                 return;
-            try {
-                const path = join(codeStateHome(null, env), "logs", "cost-divergence.log");
-                mkdirSync(dirname(path), { recursive: true });
-                const line = { ts: new Date().toISOString(), driverServerUsd, localUsd };
-                appendFileSync(path, JSON.stringify(line) + "\n", "utf8");
-            }
-            catch {
-                /* a diagnostic must never break /cost */
-            }
+            logEvent({
+                source: "cost",
+                level: "debug",
+                event: "cost_divergence",
+                sessionId: env.YAGNI_SESSION_ID ?? undefined,
+                fields: { driverServerUsd, localUsd },
+            });
         },
         // Carry-over (/cost re-review): surfaces sessionRuns.ts's dropped-run-id
         // count as costHud's "Excludes N earlier /go runs." note.
@@ -572,6 +602,51 @@ export async function registerYagni(pi, deps = {}) {
     // pointers. Computed once per activation (rules are launch-time state, like
     // pi's own skill discovery); fail-soft to null.
     const rulesSection = claudeRulesSection(deps.env ?? process.env);
+    // YAG-575: session scratchpad — a permission-free dir the agent writes its
+    // working state to. Computed + ensured once at activation (like rulesSection,
+    // which must exist before the first before_agent_start), not on session_start,
+    // so the very first turn already carries the section. Fails closed: no
+    // sessionId (a bare pi run) or a failed mkdir means no section, and the mkdir
+    // failure is logged so a missing scratchpad is not silent.
+    const scratchpadDirPath = scratchpadDirFor({
+        sessionId: env.YAGNI_SESSION_ID ?? undefined,
+        cwd: process.cwd(),
+        tmp: env[SCRATCHPAD_TMPDIR_ENV] || undefined,
+    });
+    let scratchpadSectionText;
+    if (scratchpadDirPath) {
+        const ensured = ensureScratchpadDir(scratchpadDirPath);
+        if (ensured) {
+            scratchpadSectionText = scratchpadSection(ensured);
+        }
+        else {
+            logEvent({
+                source: "scratchpad",
+                level: "error",
+                event: "scratchpad_mkdir_failed",
+                sessionId: env.YAGNI_SESSION_ID ?? undefined,
+            });
+        }
+    }
+    // The condensed Claude Code-style transcript: the seven built-ins re-render
+    // as flat "● Tool(arg)" rows, quiet runs collapse into one "Read 2 files,
+    // ran 2 shell commands" summary line, and project writes/edits keep visible
+    // previews. Execution delegates to the same factory-made built-ins pi would
+    // have used (settings-honoring), so ONLY presentation changes — which is why
+    // eval mode keeps pi's stock registration (measured behavior stays
+    // byte-identical) and the desktop surface keeps the structured pipeline.
+    // YAGNI_CLASSIC_TOOL_ROWS=1 is the debugging escape hatch back to pi's
+    // boxed renderers.
+    if (!evalMode && !isDesktopSurface() && env.YAGNI_CLASSIC_TOOL_ROWS !== "1") {
+        try {
+            registerCondensedTools(pi, {
+                ...(scratchpadDirPath ? { scratchpadDir: scratchpadDirPath } : {}),
+            });
+        }
+        catch {
+            // Rendering must never break activation; pi's built-ins remain.
+        }
+    }
     // Own the identity + inject live company context (and repo rules) on every
     // turn. The extension loads identically in every pi process this app spawns —
     // the interactive driver AND every `/go` stage child, subagent, and advisor
@@ -596,6 +671,7 @@ export async function registerYagni(pi, deps = {}) {
                         : YAGNI_IDENTITY_DRIVER
                     : undefined,
                 rulesSection,
+                scratchpadSection: scratchpadSectionText,
             }),
         });
     // Turn-lifecycle WAL: a `turn_start` with no matching `turn_end` is the
@@ -691,21 +767,16 @@ export async function registerYagni(pi, deps = {}) {
                 // session token is expired and refresh failed — the most critical
                 // failure signal is no longer silently dropped.
                 void authReporter(new Error(`auth_401 on model path; refresh=${rotated ? "succeeded" : "failed"}`), "auth-failure").catch(() => { });
-                // YAG-500 Fix F: local diagnostics log under YAGNI_DEBUG.
-                if (isDebug(env)) {
-                    try {
-                        const logPath = join(codeStateHome(null, env), "logs", "auth-events.log");
-                        mkdirSync(dirname(logPath), { recursive: true });
-                        appendFileSync(logPath, JSON.stringify({
-                            ts: new Date().toISOString(),
-                            status: 401,
-                            refresh: rotated ? "succeeded" : "failed",
-                        }) + "\n", "utf8");
-                    }
-                    catch {
-                        // A diagnostic must never break the session.
-                    }
-                }
+                // YAG-500 Fix F: auth-401 signal is content-free (status + refresh
+                // boolean), so it is always-on and upload-safe by the default-on
+                // invariant. No message content, no tokens, no headers.
+                logEvent({
+                    source: "auth",
+                    level: "info",
+                    event: "auth_401",
+                    sessionId: env.YAGNI_SESSION_ID ?? undefined,
+                    fields: { status: 401, refresh: rotated ? "succeeded" : "failed" },
+                });
                 return { message: { ...msg, errorMessage: explanation } };
             }
             // YAG-460: the backend proxy answers an oversized conversation with an
@@ -759,6 +830,16 @@ export async function registerYagni(pi, deps = {}) {
     // and a "Pi can explain its own features…" line) with a YAGNI Code masthead,
     // set the terminal title, and add a footer brand mark. TUI only.
     pi.on("session_start", async (event, ctx) => {
+        // Surface Pi's native find/grep/ls on the driver. These are Pi's
+        // equivalents of Claude Code's Glob/Grep/LS; the /go stages and subagents
+        // already pass them explicitly, but the driver defaults to read/bash/edit/write
+        // and otherwise reaches for `bash` find/grep/ls.
+        try {
+            pi.setActiveTools([...pi.getActiveTools(), "grep", "find", "ls"]);
+        }
+        catch {
+            // Tool enrichment must never break session start.
+        }
         ctx.ui?.setTitle(BRAND_NAME);
         if (ctx.mode === "tui") {
             ctx.ui?.setStatus?.("brand", BRAND_NAME);
@@ -793,6 +874,14 @@ export async function registerYagni(pi, deps = {}) {
             catch {
                 // A label must never disrupt session start.
             }
+            // The pulsing star indicator that pairs with the composed working line.
+            // Fails closed to pi's default spinner.
+            try {
+                ctx.ui?.setWorkingIndicator?.({ frames: [...WORKING_INDICATOR_FRAMES], intervalMs: 140 });
+            }
+            catch {
+                // An indicator must never disrupt session start.
+            }
             // One-time hint naming what changed now that reasoning is collapsed by
             // default (option 2). Gated on the launcher's YAGNI_HIDE_THINKING_SEEDED
             // marker so it fires only on the launch that actually seeded the key — it
@@ -889,6 +978,30 @@ export async function registerYagni(pi, deps = {}) {
             footerInvalidateHandle.invalidateGit();
         }
     });
+    // Seed the unified error trail from tool-exec failures. A tool's SUCCESS
+    // is content (it lives in the transcript); its FAILURE is an error and belongs
+    // in the sink. We log only the tool name + error class — never args, partial
+    // results, or result bodies (those are content and stay out of the upload-safe
+    // tier). This is the tool-failure half of the error trail the ticket asks for.
+    pi.on("tool_execution_end", (event) => {
+        if (!event.isError)
+            return;
+        // `event.result` is any; its `.error`/message can echo a path or secret
+        // (a tool's own failure text). Keep the always-on trail content-free: use
+        // ONLY the Error subclass name, never the message or a String() of the
+        // result's error payload.
+        const errorClass = event.result instanceof Error
+            ? event.result.name || "Error"
+            : "tool_error";
+        logEvent({
+            source: "tool",
+            level: "error",
+            event: "tool_failed",
+            sessionId: sessionIdForLog(),
+            flush: "sync",
+            fields: { toolName: event.toolName, errorClass },
+        });
+    });
 }
 export default async function (pi) {
     await registerYagni(pi);
@@ -902,6 +1015,7 @@ export default async function (pi) {
 export { makeAskYagniTool } from "./askYagniTool.js";
 export { makeFileTicketTool, makeUpdateTicketStatusTool } from "./ticketTools.js";
 export { makeAskAdvisorTool, registerAdviseCommand } from "./askAdvisorTool.js";
+export { makeAskUserQuestionTool } from "./askUserQuestionTool.js";
 export { ADVISOR_TIER, DEFAULT_ADVISOR_LIMITS, decideConsult, formatAdvisorSubtotal, makeAdvisorState, } from "./advisor.js";
 export { DEFAULT_GUARDIAN_LIMITS, GUARDIAN_MODEL_TIER, formatGuardianSubtotal, makeGuardianState, resolveGuardianLimits, reviewCommand, deriveGuardianTimeoutMs, } from "./permission/guardian.js";
 export { makeReviewBusinessMatchTool } from "./reviewTool.js";
@@ -964,5 +1078,10 @@ export { makeTokenProvider, makeAuthedFetch, persistRotationToProfile, PROACTIVE
 // W4 trust plumbing: the durable write-spool for the judgment-capture tools
 // (idempotencyKey-replayed; server-side dedup makes flush safe).
 export { appendToSpool, loadSpool, flushSpool, sendOrSpool, spoolFile, MAX_SPOOL_AGE_MS, _setSpoolHomeForTest, } from "./spool.js";
+// The condensed Claude Code-style transcript: flat tool rows, run summaries,
+// and the composed streaming status line.
+export { registerCondensedTools, displayPath, isScratchpadPath, primaryArg, formatRowTitle, formatWriteBody, formatEditBody, formatBashErrorBody, formatBashPartialBody, formatExpandedOutput, splitBashError, countPatchAdditions, WRITE_PREVIEW_LINES, DIFF_PREVIEW_LINES, } from "./condensedTools.js";
+export { ToolRunTracker, summarizeRun, isQuiet, kindForTool } from "./toolRuns.js";
+export { registerWorkingLine, composeWorkingMessage, NULL_WORKING_LINE, WORKING_INDICATOR_FRAMES, WORKING_VERBS, } from "./workingLine.js";
 export { crashReportsDisabled, installUncaughtExceptionMonitor, makeCrashReporter, reportFatalCrash, sanitizeCrashError, sanitizeCrashText, } from "./crashReport.js";
 //# sourceMappingURL=index.js.map

package/dist/extension/mineBeat.js

@@ -20,6 +20,7 @@
 import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import { dirname, join } from "node:path";
+import { logEvent } from "./errorSink.js";
 import { METERED_POST_FETCH_POLICY, resilientFetch } from "./resilientFetch.js";
 /**
  * Client-side bounds on the mining corpus — mirror of the backend's
@@ -173,6 +174,12 @@ export async function maybeOfferMiningBeat(ctx, opts) {
         }, { fetchImpl: opts.fetchImpl, policy: METERED_POST_FETCH_POLICY });
         if (!res.ok) {
             // No marker: the offer stays available next session.
+            logEvent({
+                source: "mine-beat",
+                level: "error",
+                event: "mine_failed",
+                fields: { status: res.status },
+            });
             ctx.ui.notify("Seeding the decision ledger failed; YAGNI Code will offer again next session.", "error");
             return { offered: true, accepted: true };
         }
@@ -186,6 +193,12 @@ export async function maybeOfferMiningBeat(ctx, opts) {
         return { offered: true, accepted: true, banked };
     }
     catch {
+        logEvent({
+            source: "mine-beat",
+            level: "error",
+            event: "mine_failed",
+            fields: { kind: "network" },
+        });
         ctx.ui.notify("Seeding the decision ledger failed; YAGNI Code will offer again next session.", "error");
         return { offered: true, accepted: true };
     }

package/dist/extension/permission/execPolicy.js

@@ -727,12 +727,59 @@ function isPipeToShell(command) {
  * backticks, including inside double quotes). Matches FORBIDDEN rules only —
  * can upgrade the classification, never relax it.
  */
+const QUOTED_HEREDOC_OPEN = /^cat[ \t]+<<[ \t]*(?:'([^']+)'|"([^"]+)"|\\([A-Za-z_][A-Za-z0-9_]*))[ \t]*\r?\n/;
+/**
+ * Recognize the `cat <<'QUOTED' … QUOTED` idiom inside a command substitution.
+ *
+ * This is the one way to pass multi-line body content to `gh`/`git` as a
+ * literal string: the quoted delimiter (`<<'EOF'`, `<<"EOF"`, or `<<\EOF`)
+ * makes the heredoc body literal — no `$`/backtick expansion — and `cat` merely
+ * prints it. A body like `rm -rf /tmp/test-db` inside such a heredoc is PROSE,
+ * not a command; sweeping it for forbidden rules is a false positive.
+ *
+ * Returns true ONLY for the exact safe shape: the whole substitution is `cat`
+ * with no arguments, followed by a heredoc whose delimiter is quoted and whose
+ * terminator is the delimiter on its own final line. Any deviation (unquoted
+ * delimiter, extra args to `cat`, a second command after the terminator)
+ * returns false and falls through to the ordinary danger scan. Safety does not
+ * hinge on this exemption: the outer command (the `gh pr create`, the `rm`) is
+ * still classified on its own merits, heredoc or not.
+ */
+function isLiteralQuotedCatHeredoc(inner) {
+    const text = inner.trim();
+    const m = QUOTED_HEREDOC_OPEN.exec(text);
+    if (!m)
+        return false;
+    const delim = m[1] ?? m[2] ?? m[3];
+    const bodyStart = m[0].length;
+    const lines = text.slice(bodyStart).split(/\r?\n/);
+    if (lines.length === 0)
+        return false;
+    // The final line must be the bare delimiter (the closing `)` is already
+    // stripped by extractSubstitutions).
+    if (lines[lines.length - 1].trim() !== delim)
+        return false;
+    // No line BEFORE the terminator may equal the delimiter: in real bash, a
+    // delimiter line terminates the heredoc there, turning everything after it
+    // into an executed command (e.g. a body with a bare `EOF` line followed by
+    // `rm -rf /x` would run the `rm`). Reject that shape and fall to the scan.
+    for (const line of lines.slice(0, -1)) {
+        if (line.trim() === delim)
+            return false;
+    }
+    return true;
+}
 function dangerScanSubstitutions(command, policy, depth) {
     if (depth > MAX_SCAN_DEPTH)
         return null;
     for (const inner of extractSubstitutions(command)) {
         if (inner.trim().length === 0)
             continue;
+        // Quoted-heredoc cat: the body is literal data, not an executable
+        // command — skipping it avoids false "forbidden" hits on prose that happens
+        // to contain a forbidden-looking token. The outer command still classifies.
+        if (isLiteralQuotedCatHeredoc(inner))
+            continue;
         if (isPipeToShell(inner)) {
             return {
                 decision: "forbidden",

package/dist/extension/pipeline/goCommand.js

@@ -71,6 +71,7 @@ import { formatRunCostTable } from "./runCostTable.js";
 import { makeCombinedCheckpointStore, makeFileCheckpointStore, makePiJournalCheckpointStore, } from "./checkpoint.js";
 import { getToken as defaultGetToken, resolveBaseUrl } from "../config.js";
 import { makeCrashReporter } from "../crashReport.js";
+import { logEvent } from "../errorSink.js";
 import { scrubSecrets } from "./scrubSecrets.js";
 import { isDesktopSurface } from "../surface.js";
 import { runFinish as defaultRunFinish, verifyTrailerValue, } from "./finish.js";
@@ -1104,6 +1105,7 @@ export function registerGoCommand(pi, deps = {}) {
                     // return results instead) — report it, fire-and-forget. The default
                     // reporter never rejects; the catch guards an injected one.
                     void reportCrash(err, "go", runCwd).catch(() => { });
+                    logEvent({ source: "go", level: "error", event: "go_failed", fields: { runId } });
                     // The stopReason travels to the backend run record; scrub it like
                     // every other captured text (a raw error can echo a connection
                     // string or key).

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

@@ -65,9 +65,16 @@ export declare function buildStageInvocation(stage: PipelineStage, ctx: {
  * `yagni` provider) before a stage passthrough. Mirrors buildLaunch's
  * `userChoseProvider` guard so a passthrough that already chose a provider is
  * left untouched.
+ *
+ * `otelExtensionPath` (absent on a non-exporting launch) additionally loads
+ * pi-otel so child LLM spend is traced too — stage children are the bulk of a
+ * /go run's cost, and an OTel export that misses them undercounts. The path
+ * arrives via `YAGNI_OTEL_EXTENSION_PATH` from the launcher's gate (see the
+ * CLI's otel.ts); the capture-mode and endpoint env rides the inherited env.
  */
 export declare function groundedChildArgv(stageArgv: string[], opts: {
     piCli: string;
     extensionPath: string;
+    otelExtensionPath?: string;
 }): string[];
 //# sourceMappingURL=invocation.d.ts.map

package/dist/extension/pipeline/invocation.js

@@ -84,6 +84,12 @@ export function buildStageInvocation(stage, ctx) {
  * `yagni` provider) before a stage passthrough. Mirrors buildLaunch's
  * `userChoseProvider` guard so a passthrough that already chose a provider is
  * left untouched.
+ *
+ * `otelExtensionPath` (absent on a non-exporting launch) additionally loads
+ * pi-otel so child LLM spend is traced too — stage children are the bulk of a
+ * /go run's cost, and an OTel export that misses them undercounts. The path
+ * arrives via `YAGNI_OTEL_EXTENSION_PATH` from the launcher's gate (see the
+ * CLI's otel.ts); the capture-mode and endpoint env rides the inherited env.
  */
 export function groundedChildArgv(stageArgv, opts) {
     const userChoseProvider = stageArgv.includes("--provider");
@@ -91,6 +97,7 @@ export function groundedChildArgv(stageArgv, opts) {
         opts.piCli,
         "-e",
         opts.extensionPath,
+        ...(opts.otelExtensionPath ? ["-e", opts.otelExtensionPath] : []),
         ...(userChoseProvider ? [] : ["--provider", "yagni"]),
         ...stageArgv,
     ];