@yagni-app/code 1.0.1 → 1.0.2

package/dist/extension/askAdvisorTool.d.ts

@@ -29,6 +29,7 @@ import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-age
 import { type Component } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { type AdvisorLimits, type AdvisorStateHandle } from "./advisor.js";
+import type { ChildUsageHandle } from "./childUsage.js";
 import type { WorkingLineHandle } from "./workingLine.js";
 import { runStage as defaultRunStage } from "./pipeline/runner.js";
 import { type PipelineStage } from "./pipeline/types.js";
@@ -56,6 +57,12 @@ export interface MakeAskAdvisorToolOptions {
      * absent, the tool falls back to ui.setWorkingMessage directly.
      */
     workingLine?: WorkingLineHandle;
+    /**
+     * Session child-usage accumulator (childUsage.ts), so the footer's session
+     * totals include advisor consults — the spend the consult-cost line already
+     * prints. Absent = not wired (tests/harnesses): no recording.
+     */
+    childUsage?: ChildUsageHandle;
 }
 /**
  * Assemble the consult brief. The advisor's persona already tells it not to take

package/dist/extension/askAdvisorTool.js

@@ -129,7 +129,7 @@ export function makeAskAdvisorTool(opts) {
         renderShell: "self",
         renderCall: renderAdvisorCall,
         renderResult: renderSubagentResult,
-        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+        async execute(toolCallId, params, signal, onUpdate, ctx) {
             // Read the LIVE session model: pi's picker can change it after this tool
             // was registered, in both directions.
             const decision = decideConsult({
@@ -194,6 +194,10 @@ export function makeAskAdvisorTool(opts) {
             const cost = result.usage?.cost ?? 0;
             const state = opts.state.record(cost);
             finalizeTask(progress, result, Date.now());
+            // Footer session totals include the consult. Keyed by toolCallId — one
+            // consult per call, unique even for parallel consults minted in the same
+            // millisecond — so a re-fired finalize for the same call is a no-op.
+            opts.childUsage?.record("advisor", toolCallId, result.usage);
             if (result.exitCode !== 0 && !result.finalOutput.trim()) {
                 // Fail honestly rather than returning an empty recommendation. The
                 // consult still counts: it spawned, and it may well have spent.

package/dist/extension/askYagniTool.d.ts

@@ -12,7 +12,7 @@ export interface Citation {
  * AskStanding — mirrored locally by this extension's no-workspace-imports
  * convention, see costHud.ts).
  */
-export type AskStanding = "confirmed" | "asserted" | "inferred" | "no_position";
+export type AskStanding = "confirmed" | "asserted" | "inferred" | "no_position" | "contested";
 /** One line the TUI shows above the answer, per standing. */
 export declare const STANDING_LINES: Record<AskStanding, string>;
 /** Options for {@link makeAskYagniTool}. */

package/dist/extension/askYagniTool.js

@@ -10,6 +10,7 @@ export const STANDING_LINES = {
     asserted: "Grounded in a recorded assumption, not yet verified",
     inferred: "Inferred from workspace context, not a recorded decision",
     no_position: "No recorded position in this workspace",
+    contested: "Two recorded decisions conflict — escalate to a human",
 };
 function standingLine(value) {
     return typeof value === "string" && value in STANDING_LINES
@@ -141,11 +142,29 @@ export function makeAskYagniTool(opts) {
                     text = `${text}\n\n${suggestion}`;
                 }
             }
+            // P0 (Run 8 review): a contested answer must reach the MODEL, not just
+            // the TUI. The backend composes an ordinary answer and only overrides
+            // standing client-side, so without this the coding agent can act on one
+            // conflicting side without ever seeing the do-not-proceed instruction.
+            // The refusal + both positions are appended VERBATIM to tool content.
+            if (data.standing === "contested") {
+                const lines = [];
+                if (data.contestedInstruction)
+                    lines.push(data.contestedInstruction);
+                for (const p of data.contestedPositions ?? []) {
+                    lines.push(`- (${p.id}) ${p.question}: ${p.decision}`);
+                }
+                if (lines.length > 0) {
+                    text = `${data.answer}\n\n${lines.join("\n")}`;
+                }
+            }
             return {
                 content: [{ type: "text", text }],
                 details: {
                     citations: data.citations ?? [],
                     ...(data.standing ? { standing: data.standing } : {}),
+                    ...(data.contestedInstruction ? { contestedInstruction: data.contestedInstruction } : {}),
+                    ...(data.contestedPositions ? { contestedPositions: data.contestedPositions } : {}),
                 },
             };
         },

package/dist/extension/childUsage.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Session-scoped child-process usage accounting (YAG-383's honest-local
+ * counterpart for the FOOTER).
+ *
+ * `collectUsage` (footer.ts) reads pi's session entries, which only ever carry
+ * the DRIVER's own turns: subagents, advisor consults, Guardian reviews, and
+ * every /go stage run in a child process whose usage never lands in those
+ * entries. The per-child surfaces (subagent receipts, /go's run-cost note,
+ * advisor's consult-cost line) already fold each child's usage from its NDJSON
+ * stream — this module is the session-level SUM of those already-held figures,
+ * so the footer's totals can include what the receipts already printed.
+ *
+ * Same shape as `makeAdvisorState` (advisor.ts): a closure-held handle, `read()`
+ * snapshots, and an additive `record()`. Tokens ride along with cost so the
+ * footer's `↑in ↓out` figures stay honest too. `record()` is idempotent per
+ * (source, key): a re-fired completion for the same child must never
+ * double-count its spend, so each seam keys by the child's identity (one key
+ * per subagent task / consult / review / run attempt).
+ */
+/** Usage fields the footer's line-2 stats render. */
+export interface ChildUsageDelta {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cost: number;
+}
+export interface ChildUsageHandle {
+    read(): ChildUsageDelta;
+    /**
+     * Add one child's usage, deduped by `(source, key)`. A repeated record for
+     * the same key is a no-op (re-fire safety), not an overwrite: child spend is
+     * cumulative and never revised downward. `delta` may be absent (a degraded
+     * or stubbed runner that reported no usage): the key is still consumed and
+     * nothing is added — never a throw.
+     */
+    record(source: string, key: string, delta: Partial<ChildUsageDelta> | undefined): ChildUsageDelta;
+}
+export declare function makeChildUsageState(): ChildUsageHandle;
+//# sourceMappingURL=childUsage.d.ts.map

package/dist/extension/childUsage.js

@@ -0,0 +1,43 @@
+/**
+ * Session-scoped child-process usage accounting (YAG-383's honest-local
+ * counterpart for the FOOTER).
+ *
+ * `collectUsage` (footer.ts) reads pi's session entries, which only ever carry
+ * the DRIVER's own turns: subagents, advisor consults, Guardian reviews, and
+ * every /go stage run in a child process whose usage never lands in those
+ * entries. The per-child surfaces (subagent receipts, /go's run-cost note,
+ * advisor's consult-cost line) already fold each child's usage from its NDJSON
+ * stream — this module is the session-level SUM of those already-held figures,
+ * so the footer's totals can include what the receipts already printed.
+ *
+ * Same shape as `makeAdvisorState` (advisor.ts): a closure-held handle, `read()`
+ * snapshots, and an additive `record()`. Tokens ride along with cost so the
+ * footer's `↑in ↓out` figures stay honest too. `record()` is idempotent per
+ * (source, key): a re-fired completion for the same child must never
+ * double-count its spend, so each seam keys by the child's identity (one key
+ * per subagent task / consult / review / run attempt).
+ */
+const num = (n) => {
+    const v = n ?? 0;
+    return Number.isFinite(v) && v > 0 ? v : 0;
+};
+export function makeChildUsageState() {
+    const seen = new Set();
+    const totals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+    return {
+        read: () => ({ ...totals }),
+        record(source, key, delta) {
+            const dedupeKey = `${source}\u0000${key}`;
+            if (seen.has(dedupeKey))
+                return { ...totals };
+            seen.add(dedupeKey);
+            totals.input += num(delta?.input);
+            totals.output += num(delta?.output);
+            totals.cacheRead += num(delta?.cacheRead);
+            totals.cacheWrite += num(delta?.cacheWrite);
+            totals.cost += num(delta?.cost);
+            return { ...totals };
+        },
+    };
+}
+//# sourceMappingURL=childUsage.js.map

package/dist/extension/condensedTools.d.ts

@@ -35,6 +35,10 @@ export declare const DIFF_PREVIEW_LINES = 12;
 export declare const ERROR_TAIL_LINES = 5;
 /** Output tail lines shown under a still-running shell command. */
 export declare const PARTIAL_TAIL_LINES = 3;
+/** Left/right margin for self-rendered rows, matching pi's `outputPad` (1) so
+ * tool rows align with prose. Self-render rows bypass pi's pad (renderShell
+ * "self" → unpadded container), so we reapply it here. */
+export declare const OUTPUT_PAD = 1;
 declare const BUILTIN_NAMES: readonly ["read", "bash", "edit", "write", "grep", "find", "ls"];
 type BuiltinName = (typeof BUILTIN_NAMES)[number];
 export type RowStatus = "running" | "ok" | "error";

package/dist/extension/condensedTools.js

@@ -41,6 +41,10 @@ export const PARTIAL_TAIL_LINES = 3;
 const EXPANDED_MAX_LINES = 1000;
 /** Title arg preview width. */
 const ARG_PREVIEW_MAX = 96;
+/** Left/right margin for self-rendered rows, matching pi's `outputPad` (1) so
+ * tool rows align with prose. Self-render rows bypass pi's pad (renderShell
+ * "self" → unpadded container), so we reapply it here. */
+export const OUTPUT_PAD = 1;
 const BUILTIN_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
 const TITLE_BY_NAME = {
     read: "Read",
@@ -257,7 +261,7 @@ function empty() {
     return new Container();
 }
 function textComponent(lines) {
-    return lines.length === 0 ? empty() : new Text(lines.join("\n"), 0, 0);
+    return lines.length === 0 ? empty() : new Text(lines.join("\n"), OUTPUT_PAD, 0);
 }
 function defaultLoadSettings(cwd) {
     return SettingsManager.create(cwd, getAgentDir());
@@ -332,13 +336,13 @@ export function registerCondensedTools(pi, deps = {}) {
                 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);
+                    return new Text(formatRowTitle(name, argsRecord, status, theme, slice.cwd), OUTPUT_PAD, 0);
                 }
                 if (!row.final) {
-                    return new Text(formatRowTitle(name, argsRecord, "running", theme, slice.cwd), 0, 0);
+                    return new Text(formatRowTitle(name, argsRecord, "running", theme, slice.cwd), OUTPUT_PAD, 0);
                 }
                 const summary = tracker.summaryFor(row.id);
-                return summary ? new Text(theme.fg("muted", summary), 0, 0) : empty();
+                return summary ? new Text(theme.fg("muted", summary), OUTPUT_PAD, 0) : empty();
             },
             renderResult(result, options, theme, context) {
                 const slice = context;

package/dist/extension/footer.d.ts

@@ -39,6 +39,7 @@
  * — useful reference for what data to replicate and how to format it.
  */
 import type { ExtensionContext, ReadonlyFooterDataProvider, Theme } from "@earendil-works/pi-coding-agent";
+import type { ChildUsageHandle } from "./childUsage.js";
 import type { ModeHolder, PermissionMode } from "./permission/gate.js";
 export declare const BRANCH_MAX_WIDTH = 60;
 export declare function cyclePermissionMode(current: PermissionMode): PermissionMode;
@@ -99,6 +100,17 @@ export declare function renderFooterLines(input: {
     /** Formatted `+N -M` / `±`, or null when clean — appended to the branch as `[ … ]`. */
     diff?: string | null;
     usage: UsageTotals;
+    /**
+     * Session child-process spend (subagents, advisor consults, Guardian
+     * reviews, /go runs) — childUsage.ts's session accumulator. Added into
+     * the line-2 stats so the footer's totals include the spend the per-child
+     * receipts already print; absent/zero changes nothing.
+     */
+    childUsage?: {
+        input: number;
+        output: number;
+        cost: number;
+    };
     contextPercent: number | null;
     statuses: string[];
 }, theme: Pick<Theme, "fg">, width: number, padX?: number): string[];
@@ -111,7 +123,7 @@ export interface FooterInvalidateHandle {
     invalidateGit(): void;
     requestRender(): void;
 }
-export declare function createYagniFooterFactory(ctx: ExtensionContext, modeHolder?: ModeHolder, invalidateHandle?: FooterInvalidateHandle): (_tui: unknown, theme: Theme, footerData: ReadonlyFooterDataProvider) => {
+export declare function createYagniFooterFactory(ctx: ExtensionContext, modeHolder?: ModeHolder, invalidateHandle?: FooterInvalidateHandle, childUsage?: ChildUsageHandle): (_tui: unknown, theme: Theme, footerData: ReadonlyFooterDataProvider) => {
     render(width: number): string[];
     invalidate(): void;
     dispose(): void;

package/dist/extension/footer.js

@@ -245,13 +245,19 @@ export function renderFooterLines(input, theme, width, padX = 0) {
     }
     const line1 = pad + truncateToWidth(line1Parts.join(sep), contentWidth, dim("…"));
     // Line 2: [mode ·] model · ↑in ↓out $cost · ctx%
+    // Child-process spend (subagents, advisor, /go) joins the driver totals so
+    // the footer matches the per-child receipts and /cost's session scope.
+    const child = input.childUsage;
+    const totalIn = input.usage.input + (child?.input ?? 0);
+    const totalOut = input.usage.output + (child?.output ?? 0);
+    const totalCost = input.usage.cost + (child?.cost ?? 0);
     const statParts = [];
-    if (input.usage.input)
-        statParts.push(`↑${formatTokens(input.usage.input)}`);
-    if (input.usage.output)
-        statParts.push(`↓${formatTokens(input.usage.output)}`);
-    if (input.usage.cost)
-        statParts.push(`$${input.usage.cost.toFixed(3)}`);
+    if (totalIn)
+        statParts.push(`↑${formatTokens(totalIn)}`);
+    if (totalOut)
+        statParts.push(`↓${formatTokens(totalOut)}`);
+    if (totalCost)
+        statParts.push(`$${totalCost.toFixed(3)}`);
     const stats = statParts.join(" ");
     const percentText = input.contextPercent === null ? "?" : `${Math.round(input.contextPercent)}%`;
     const line2Parts = [];
@@ -272,7 +278,7 @@ export function renderFooterLines(input, theme, width, padX = 0) {
     }
     return lines;
 }
-export function createYagniFooterFactory(ctx, modeHolder, invalidateHandle) {
+export function createYagniFooterFactory(ctx, modeHolder, invalidateHandle, childUsage) {
     return (_tui, theme, footerData) => {
         let gitCache;
         let diffStatCache;
@@ -305,6 +311,7 @@ export function createYagniFooterFactory(ctx, modeHolder, invalidateHandle) {
                     mode: modeHolder?.get() ?? null,
                     diff: formatDiffStat(diffStatCache?.get() ?? null),
                     usage: collectUsage(ctx.sessionManager),
+                    childUsage: childUsage?.read(),
                     contextPercent: ctx.getContextUsage()?.percent ?? null,
                     statuses,
                 }, theme, width, resolveFooterPadX());

package/dist/extension/index.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { Text } from "@earendil-works/pi-tui";
 import { DEFAULT_ADVISOR_LIMITS, formatAdvisorSubtotal, makeAdvisorState } from "./advisor.js";
+import { makeChildUsageState } from "./childUsage.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";
@@ -40,12 +41,13 @@ import { registerDecisionCommands } from "./decisions.js";
 import { makeDecisionCapture } from "./decisionCapture.js";
 import { registerAmbientRecall } from "./recall.js";
 import { resilientFetch } from "./resilientFetch.js";
-import { installUncaughtExceptionMonitor, makeCrashReporter } from "./crashReport.js";
+import { installUncaughtExceptionMonitor, makeCrashReporter, runningUnderTest } from "./crashReport.js";
 import { flushSpool as defaultFlushSpool } from "./spool.js";
 import { makeAuthedFetch, makeTokenProvider } from "./tokenProvider.js";
 import { attributionHeaders, fetchCatalog as defaultFetchCatalog, fetchContextBrief as defaultFetchContextBrief, getToken, getTokenExpiresAt as defaultGetTokenExpiresAt, getWorkspaceId as defaultGetWorkspaceId, isDriverCaller, resolveBaseUrl, tokenExpiryNotice, } from "./config.js";
 import { buildYagniProvider } from "./provider.js";
 import { registerChipEditor } from "./chipEditor.js";
+import { registerSlashCommandFilter } from "./slashCommandFilter.js";
 import { defaultMineBeatGit, fileMineBeatMarkers, maybeOfferMiningBeat as defaultMaybeOfferMiningBeat, } from "./mineBeat.js";
 import { makeFlywheelState } from "./flywheel.js";
 import { registerSilentTurnReminder } from "./silentTurnReminder.js";
@@ -186,7 +188,11 @@ 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, workingLine });
+    // Session child-usage accumulator: every child process's spend (subagent
+    // tasks, advisor consults, Guardian reviews, /go runs) lands here so the
+    // footer's session totals include what the per-child receipts print.
+    const childUsage = makeChildUsageState();
+    const askAdvisorTool = makeAskAdvisorTool({ state: advisorState, workingLine, childUsage });
     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.
@@ -219,6 +225,11 @@ export async function registerYagni(pi, deps = {}) {
     // temp path, and registers the input transform that turns chips into image
     // attachments for the model. No-op outside TUI mode.
     registerChipEditor(pi);
+    // Hide pi's built-in slash commands that contradict YAGNI's single-provider,
+    // single-identity model (e.g. /share gist upload, /login <provider>) from
+    // slash-discovery. TUI autocomplete only; the desktop palette already
+    // excludes built-ins, and this is a no-op in RPC/print modes.
+    registerSlashCommandFilter(pi);
     // The general subagent tool: delegate self-contained tasks (optionally in
     // parallel) to fresh-context agents defined in .claude/agents / .pi/agents,
     // riding the /go pipeline's child runner. /agents lists what's available.
@@ -226,7 +237,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(), workingLine });
+    registerSubagents(pi, { isUltra: () => ultraHolder.get(), workingLine, childUsage });
     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):
@@ -236,6 +247,7 @@ export async function registerYagni(pi, deps = {}) {
     // The grounded multi-agent pipeline entry point: /go <ticket> runs
     // map → plan → implement → review → fix, each child grounded by inheritance.
     registerGoCommand(pi, {
+        childUsage,
         // /ultra is one dial for the whole session: the same holder the subagent
         // tool reads widens the implement diamond's parallel ceiling (4 -> 8) for
         // the fan and its fix turns. Read per run, so a toggle lands on the next /go.
@@ -326,7 +338,10 @@ export async function registerYagni(pi, deps = {}) {
         const { event: _ignored, ...fields } = payload;
         logEvent({
             source: "guardian",
-            level: event === "guardian_event_post_failed" ? "error" : "info",
+            // `malformed` is a real failure (this is the "unclear verdict" bug the
+            // whole capture exists to diagnose) — an error, not routine info. The
+            // failed-telemetry event is already an error.
+            level: event === "guardian_event_post_failed" || payload.outcome === "malformed" ? "error" : "info",
             event,
             sessionId: env.YAGNI_SESSION_ID ?? undefined,
             fields,
@@ -350,8 +365,45 @@ export async function registerYagni(pi, deps = {}) {
         guardianLimits,
         guardianTier,
         guardianDisabled,
+        childUsage,
         guardianReview: (command, deps) => reviewCommand(command, { ...deps, modelTier: guardianTier }),
-        onGuardianReview: (ev) => guardianLogSink(ev),
+        onGuardianReview: (ev) => {
+            guardianLogSink(ev);
+            // A malformed verdict is a real failure on our side that must reach
+            // Sentry for EVERY workspace (independent of the opt-in storage tier).
+            // Fire-and-forget to the dedicated telemetry endpoint; fail-soft, and
+            // suppressed under test/eval so a CI run never phones prod.
+            if (ev.outcome === "malformed" && !evalMode && !runningUnderTest(env)) {
+                void (async () => {
+                    try {
+                        const body = {
+                            outcome: ev.outcome,
+                            ...(ev.rawOutput ? { rawOutput: ev.rawOutput } : {}),
+                            ...(ev.durationMs !== undefined ? { durationMs: ev.durationMs } : {}),
+                            ...(ev.tier ? { tier: ev.tier } : {}),
+                        };
+                        const res = await resilientFetch(`${baseUrl}/api/yagni-code/guardian-error`, {
+                            method: "POST",
+                            headers: {
+                                "content-type": "application/json",
+                                authorization: `Bearer ${getTokenFn() ?? ""}`,
+                                ...attributionHeaders(deps.env),
+                            },
+                            body: JSON.stringify(body),
+                        }, {
+                            fetchImpl: authedFetch,
+                            policy: { maxAttempts: 1, backoffBaseMs: 0, backoffMaxMs: 0, timeoutMs: GUARDIAN_EVENT_TIMEOUT_MS, jitterRatio: 0 },
+                        });
+                        if (!res.ok) {
+                            guardianLogSink({ event: "guardian_error_post_failed", status: res.status });
+                        }
+                    }
+                    catch {
+                        guardianLogSink({ event: "guardian_error_post_failed", kind: "network" });
+                    }
+                })();
+            }
+        },
         grants: sessionGrants,
         resolveRepoKey,
         persistGrant: (grant) => {
@@ -855,7 +907,7 @@ export async function registerYagni(pi, deps = {}) {
             // context % on line 2, and extension statuses (brand, todos, mode) on
             // line 3. The factory captures ctx so the footer can read session data
             // (token stats, context usage) that isn't on the footerData provider.
-            ctx.ui?.setFooter?.((tui, theme, footerData) => createYagniFooterFactory(ctx, modeHolder, footerInvalidateHandle)(tui, theme, footerData));
+            ctx.ui?.setFooter?.((tui, theme, footerData) => createYagniFooterFactory(ctx, modeHolder, footerInvalidateHandle, childUsage)(tui, theme, footerData));
             ctx.ui?.onTerminalInput?.((data) => {
                 if (isShiftTab(data)) {
                     modeHolder.set(cyclePermissionMode(modeHolder.get()));

package/dist/extension/permission/gate.d.ts

@@ -151,6 +151,12 @@ export interface RegisterPermissionDeps {
     guardianState?: import("./guardian.js").GuardianStateHandle;
     /** Guardian limits (timeouts, circuit breaker). Defaults to DEFAULT_GUARDIAN_LIMITS. */
     guardianLimits?: import("./guardian.js").GuardianLimits;
+    /**
+     * Session child-usage accumulator (childUsage.ts): each completed Guardian
+     * review's spend is recorded so the footer's session totals include it.
+     * Absent = not wired: no recording, nothing else changes.
+     */
+    childUsage?: import("../childUsage.js").ChildUsageHandle;
     /** Override the Guardian model tier (default: efficient). */
     guardianTier?: string;
     /** Injectable Guardian review function (tests pass a stub). */

package/dist/extension/permission/gate.js

@@ -366,6 +366,10 @@ export function registerPermissionGate(pi, deps = {}) {
     const ERROR_ASK_CAP = 3;
     let errorFallbackAsks = 0;
     let breakerEscalationOffered = false;
+    // Uniquifies each Guardian review's childUsage key: parallel gated tool
+    // calls can start their reviews in the same millisecond, and a timestamp
+    // alone would silently drop the second review's spend as a "duplicate".
+    let reviewSpendSeq = 0;
     const emitGateEvent = (event) => {
         if (!deps.onGuardianEvent)
             return;
@@ -561,13 +565,18 @@ export function registerPermissionGate(pi, deps = {}) {
                             ctx.ui.setStatus?.("yagni-guardian", undefined);
                     }
                     const durationMs = Date.now() - startMs;
-                    const emitDiag = (outcome, rationale) => {
+                    // Footer session totals include the review's spend. Each review
+                    // records exactly once, right here, so the key only has to be unique
+                    // per review — the seq keeps same-millisecond parallel reviews apart.
+                    deps.childUsage?.record("guardian", `${startMs}#${reviewSpendSeq++}`, { cost: reviewResult.cost });
+                    const emitDiag = (outcome, rationale, rawOutput) => {
                         if (!deps.onGuardianReview)
                             return;
                         void Promise.resolve(deps.onGuardianReview(buildDiagnosticEvent(outcome, {
                             durationMs,
                             tier: guardianTier,
                             ...(rationale ? { rationale } : {}),
+                            ...(rawOutput ? { rawOutput } : {}),
                             debug: isDebug(),
                         }))).catch(() => { });
                     };
@@ -734,7 +743,7 @@ export function registerPermissionGate(pi, deps = {}) {
                     }
                     // Guardian failed (timeout/malformed/network/empty/aborted).
                     const error = reviewResult.error ?? "network";
-                    emitDiag(error);
+                    emitDiag(error, undefined, reviewResult.rawOutput);
                     if (error === "aborted" || ctx?.signal?.aborted) {
                         // The user aborted mid-consult — silent block: no dialog, no
                         // "Guardian unavailable" warning on a turn they deliberately

package/dist/extension/permission/guardian.d.ts

@@ -106,7 +106,20 @@ export interface ReviewResult {
     verdict: GuardianVerdict | null;
     error?: GuardianError;
     cost: number;
+    /**
+     * Scrubbed + capped copy of the model output when the verdict failed to
+     * parse (`error: "malformed"`). Present so the sink can capture the exact
+     * failure shape. Never contains the raw command unredacted: `scrubSecrets`
+     * removes secret-shaped values before this is stored.
+     */
+    rawOutput?: string;
 }
+/**
+ * Cap on the malformed-output capture. The model's unparseable verdict is
+ * usually a single short JSON-ish blob; this bounds a pathological output so
+ * it cannot balloon a log line or a Sentry payload.
+ */
+export declare const GUARDIAN_RAW_OUTPUT_CAP = 2048;
 export interface ReviewCommandDeps {
     runStage?: typeof defaultRunStage;
     cwd: string;
@@ -143,6 +156,12 @@ export interface GuardianDiagnosticEvent {
     commandHash?: string;
     /** Debug-only: the Guardian's rationale. */
     rationale?: string;
+    /**
+     * Scrubbed + capped copy of the unparseable model output, present only for
+     * `outcome: "malformed"`. Always-on (NOT debug-gated): it is already
+     * `scrubSecrets`-redacted and size-capped at the source.
+     */
+    rawOutput?: string;
 }
 /**
  * Create a sanitized diagnostic event. Never includes the raw command text
@@ -153,6 +172,7 @@ export declare function buildDiagnosticEvent(outcome: GuardianOutcome | Guardian
     tier?: string;
     rationale?: string;
     commandHash?: string;
+    rawOutput?: string;
     debug?: boolean;
 }): GuardianDiagnosticEvent;
 //# sourceMappingURL=guardian.d.ts.map

package/dist/extension/permission/guardian.js

@@ -28,6 +28,7 @@
  * alternating deny/ask.
  */
 import { runStage as defaultRunStage } from "../pipeline/runner.js";
+import { scrubSecrets } from "../pipeline/scrubSecrets.js";
 export const DEFAULT_GUARDIAN_LIMITS = {
     maxReviews: 120,
     maxConsecutiveDenials: 3,
@@ -161,6 +162,12 @@ export function formatGuardianSubtotal(state, limits) {
     const plural = state.reviews === 1 ? "review" : "reviews";
     return `Guardian: ${state.reviews} ${plural}.`;
 }
+/**
+ * Cap on the malformed-output capture. The model's unparseable verdict is
+ * usually a single short JSON-ish blob; this bounds a pathological output so
+ * it cannot balloon a log line or a Sentry payload.
+ */
+export const GUARDIAN_RAW_OUTPUT_CAP = 2048;
 /**
  * The synthetic stage a Guardian consult runs as. Borrows the `plan` StageId
  * (same pattern as the advisor) so it doesn't ripple into feed/reducers. The
@@ -231,7 +238,14 @@ export async function reviewCommand(command, deps) {
         }
         const verdict = parseVerdict(output);
         if (!verdict) {
-            return { verdict: null, error: "malformed", cost };
+            // Scrubbed + capped so the local sink and Sentry can see the exact
+            // failure shape without carrying a raw command or a secret it echoed.
+            return {
+                verdict: null,
+                error: "malformed",
+                cost,
+                rawOutput: scrubSecrets(output).slice(0, GUARDIAN_RAW_OUTPUT_CAP),
+            };
         }
         return { verdict, cost };
     }
@@ -261,6 +275,7 @@ export function buildDiagnosticEvent(outcome, opts) {
         outcome,
         ...(opts.durationMs !== undefined ? { durationMs: opts.durationMs } : {}),
         ...(opts.tier !== undefined ? { tier: opts.tier } : {}),
+        ...(opts.rawOutput !== undefined ? { rawOutput: opts.rawOutput } : {}),
     };
     if (opts.debug) {
         if (opts.rationale)

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

@@ -110,6 +110,14 @@ export interface RegisterGoDeps {
      * cares injects its own fake.
      */
     fetchRunSpend?: (runId: string, signal?: AbortSignal) => Promise<SpendResponse | null>;
+    /**
+     * Session child-usage accumulator (childUsage.ts). Each attempt's newly-run
+     * stage usage is recorded (keyed by runId + attempt start, because a resumed
+     * attempt's stages are new spend, never a replay) so the footer's session
+     * totals include /go spend — the same figure `runCostNote` already prints.
+     * Absent = not wired.
+     */
+    childUsage?: import("../childUsage.js").ChildUsageHandle;
     /** Injectable fs existence check (worktree adoption on resume). */
     exists?: (path: string) => boolean;
     /** Clock seam for registry rows + staleness. */

package/dist/extension/pipeline/goCommand.js

@@ -969,6 +969,14 @@ export function registerGoCommand(pi, deps = {}) {
                     if (result.stopReason === "clean" && runSignal.aborted) {
                         result = { ...result, stopReason: "aborted" };
                     }
+                    // Footer session totals include this run's spend. Keyed per ATTEMPT
+                    // (runId + this invocation's start), not per runId: `result.stages`
+                    // only ever holds the stages THIS attempt actually ran (a resume's
+                    // replayed spend lives in the checkpoint's priorUsage, never here),
+                    // so an abort → same-session resume must record both attempts — a
+                    // runId-only key would silently drop the resume's new spend. Partial
+                    // spend on an aborted attempt is still real spend worth counting.
+                    deps.childUsage?.record("go", `${runId}@${startedAt}`, aggregateRunUsage(result.stages, result.rounds));
                     // FINISH stage (spec §3c): ONLY on a clean stop. Commit the run's work
                     // (worktree always; --here only over a clean pre-run baseline) with the
                     // provenance trailer, and push + PR when --pr asked for it. Iron

package/dist/extension/slashCommandFilter.d.ts

@@ -0,0 +1,30 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+/**
+ * Slash-command filtering for the CLI.
+ *
+ * pi ships its own built-in slash commands (see `BUILTIN_SLASH_COMMANDS` in
+ * pi's `core/slash-commands.js`) and bakes them directly into its interactive
+ * autocomplete provider (`createBaseAutocompleteProvider`). Most are
+ * pi-generic and harmless (`/new`, `/compact`, `/settings`), but a subset
+ * contradict YAGNI's single-provider, single-identity model — or leak pi
+ * features YAGNI deliberately does not surface — and only confuse a YAGNI Code
+ * user. We hide those from slash-discovery.
+ *
+ * Scope note: this filters DISCOVERY only. pi dispatches built-in commands in
+ * its own private `onSubmit` chain (not from the autocomplete list), so a
+ * hidden command can still be typed by hand — the same bar pi itself draws for
+ * its easter-egg commands, which are also absent from autocomplete. Removing
+ * them from the list is the whole intent: a YAGNI user should not be offered
+ * `/share` (ships a transcript to a GitHub gist) or `/login <provider>` (pi
+ * provider auth) when YAGNI's model is a single `yagni` provider.
+ *
+ * The desktop palette is unaffected: pi's RPC `get_commands` (which the desktop
+ * app reads) already returns extension commands + prompt templates + skills and
+ * never includes built-ins. This wrapper is inert outside interactive TUI mode,
+ * where `addAutocompleteProvider` is handed a no-op factory.
+ */
+/** pi built-in slash commands hidden from YAGNI Code autocomplete. */
+export declare const HIDDEN_BUILTIN_SLASH_COMMANDS: readonly string[];
+/** Register the slash-command filter on `session_start` (TUI autocomplete only). */
+export declare function registerSlashCommandFilter(pi: ExtensionAPI): void;
+//# sourceMappingURL=slashCommandFilter.d.ts.map

package/dist/extension/slashCommandFilter.js

@@ -0,0 +1,89 @@
+/**
+ * Slash-command filtering for the CLI.
+ *
+ * pi ships its own built-in slash commands (see `BUILTIN_SLASH_COMMANDS` in
+ * pi's `core/slash-commands.js`) and bakes them directly into its interactive
+ * autocomplete provider (`createBaseAutocompleteProvider`). Most are
+ * pi-generic and harmless (`/new`, `/compact`, `/settings`), but a subset
+ * contradict YAGNI's single-provider, single-identity model — or leak pi
+ * features YAGNI deliberately does not surface — and only confuse a YAGNI Code
+ * user. We hide those from slash-discovery.
+ *
+ * Scope note: this filters DISCOVERY only. pi dispatches built-in commands in
+ * its own private `onSubmit` chain (not from the autocomplete list), so a
+ * hidden command can still be typed by hand — the same bar pi itself draws for
+ * its easter-egg commands, which are also absent from autocomplete. Removing
+ * them from the list is the whole intent: a YAGNI user should not be offered
+ * `/share` (ships a transcript to a GitHub gist) or `/login <provider>` (pi
+ * provider auth) when YAGNI's model is a single `yagni` provider.
+ *
+ * The desktop palette is unaffected: pi's RPC `get_commands` (which the desktop
+ * app reads) already returns extension commands + prompt templates + skills and
+ * never includes built-ins. This wrapper is inert outside interactive TUI mode,
+ * where `addAutocompleteProvider` is handed a no-op factory.
+ */
+/** pi built-in slash commands hidden from YAGNI Code autocomplete. */
+export const HIDDEN_BUILTIN_SLASH_COMMANDS = [
+    "share", // ships a session transcript to a secret GitHub gist (off-brand + privacy footgun)
+    "login", // pi provider auth; YAGNI auth is `yagni login`, one provider
+    "logout", // pi provider auth; YAGNI auth is `yagni logout`
+    "scoped-models", // pi multi-model Ctrl+P cycling; YAGNI pins a single tier
+    "fork", // pi session-fork feature YAGNI never surfaces
+    "clone", // pi session-clone feature YAGNI never surfaces
+    "tree", // pi session-tree feature YAGNI never surfaces
+    "trust", // pi project-trust prompt; collides with YAGNI guardrails
+    "changelog", // pi's own changelog, not YAGNI's
+];
+const HIDDEN = new Set(HIDDEN_BUILTIN_SLASH_COMMANDS);
+/**
+ * True when the text before the cursor is a slash-COMMAND name being typed —
+ * a leading `/` plus a name with no interior `/` or space. This mirrors pi's
+ * own slash-command detection (its `applyCompletion` treats a prefix with an
+ * interior `/` as a file path, e.g. the absolute path `/usr/local/...`), so we
+ * never strip a legitimate file-named completion.
+ */
+function isSlashCommandName(textBeforeCursor) {
+    return textBeforeCursor.startsWith("/")
+        && !textBeforeCursor.slice(1).includes("/")
+        && !textBeforeCursor.slice(1).includes(" ");
+}
+function filterHiddenSlashSuggestions(suggestions) {
+    const items = suggestions.items.filter((item) => !HIDDEN.has(item.value));
+    if (items.length === 0)
+        return null;
+    return { ...suggestions, items };
+}
+/** Wrap pi's built-in autocomplete provider so hidden built-ins never complete. */
+function makeYagniAutocompleteProvider(current) {
+    return {
+        triggerCharacters: current.triggerCharacters,
+        async getSuggestions(lines, cursorLine, cursorCol, options) {
+            const textBeforeCursor = (lines[cursorLine] ?? "").slice(0, cursorCol);
+            if (!isSlashCommandName(textBeforeCursor)) {
+                return current.getSuggestions(lines, cursorLine, cursorCol, options);
+            }
+            const suggestions = await current.getSuggestions(lines, cursorLine, cursorCol, options);
+            return suggestions ? filterHiddenSlashSuggestions(suggestions) : null;
+        },
+        applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+            return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+        },
+        shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+            return current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
+        },
+    };
+}
+/** Register the slash-command filter on `session_start` (TUI autocomplete only). */
+export function registerSlashCommandFilter(pi) {
+    pi.on("session_start", (_event, ctx) => {
+        if (ctx.mode !== "tui" || !ctx.hasUI)
+            return;
+        try {
+            ctx.ui.addAutocompleteProvider(makeYagniAutocompleteProvider);
+        }
+        catch {
+            // Filtering is cosmetic; a failure must never break session start.
+        }
+    });
+}
+//# sourceMappingURL=slashCommandFilter.js.map

package/dist/extension/subagents.d.ts

@@ -19,6 +19,7 @@
  */
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import type { ChildUsageHandle } from "./childUsage.js";
 import type { WorkingLineHandle } from "./workingLine.js";
 import { runStage } from "./pipeline/runner.js";
 import { type ModelTier, type PipelineStage } from "./pipeline/types.js";
@@ -103,6 +104,13 @@ export interface MakeSubagentToolDeps {
      * the tool falls back to setting ui.setWorkingMessage directly.
      */
     workingLine?: WorkingLineHandle;
+    /**
+     * Session child-usage accumulator (childUsage.ts). Each completed task's
+     * folded usage is recorded so the footer's session totals include the
+     * child spend the per-task receipt already prints. Absent = not wired
+     * (headless/eval harnesses): no recording, nothing else changes.
+     */
+    childUsage?: ChildUsageHandle;
 }
 export declare function makeSubagentTool(deps?: MakeSubagentToolDeps): {
     name: string;
@@ -120,7 +128,7 @@ export declare function makeSubagentTool(deps?: MakeSubagentToolDeps): {
     renderShell: "self";
     renderCall: typeof renderSubagentCall;
     renderResult: typeof renderSubagentResult;
-    execute(_toolCallId: string, params: SubagentParams, signal?: AbortSignal, onUpdate?: (update: {
+    execute(toolCallId: string, params: SubagentParams, signal?: AbortSignal, onUpdate?: (update: {
         content: Array<{
             type: "text";
             text: string;
@@ -151,6 +159,8 @@ export interface RegisterSubagentsDeps {
     isUltra?: () => boolean;
     /** Session working-line manager; see MakeSubagentToolDeps.workingLine. */
     workingLine?: WorkingLineHandle;
+    /** Session child-usage accumulator; see MakeSubagentToolDeps.childUsage. */
+    childUsage?: ChildUsageHandle;
 }
 /** Wire the subagent tool and the /agents listing command. */
 export declare function registerSubagents(pi: ExtensionAPI, deps?: RegisterSubagentsDeps): void;

package/dist/extension/subagents.js

@@ -33,6 +33,17 @@ import { applyChildEvent, finalizeTask, formatWorkingMessage, newTaskProgress, p
  * within the model proxy's 64-char caller-label limit.
  */
 const SUBAGENT_CALLER_PREFIX = "subagent:";
+/**
+ * Dedupe key for one task's childUsage record. Neither `startedAt` (parallel
+ * tasks on the same agent are minted in the same `resolved.map` pass and can
+ * share a millisecond) nor the per-invocation index (every invocation starts
+ * at 0) is unique alone; the pair is, because one tool call's task set is
+ * minted exactly once. A re-fired finalize for the same record lands on the
+ * same key, so the accumulator's (source, key) dedupe makes it a no-op.
+ */
+function progressKey(toolCallId, p, index) {
+    return `${toolCallId}/${index}/${p.agent}@${p.startedAt}`;
+}
 export const SUBAGENT_TOOL_NAME = "subagent";
 export const GENERAL_AGENT_NAME = "general";
 export const MAX_PARALLEL_SUBAGENTS = 4;
@@ -354,7 +365,7 @@ export function makeSubagentTool(deps = {}) {
         renderShell: "self",
         renderCall: renderSubagentCall,
         renderResult: renderSubagentResult,
-        async execute(_toolCallId, params, signal, onUpdate, ctx) {
+        async execute(toolCallId, params, signal, onUpdate, ctx) {
             const fail = (text) => ({
                 content: [{ type: "text", text }],
                 details: {},
@@ -428,6 +439,10 @@ export function makeSubagentTool(deps = {}) {
                         },
                     });
                     finalizeTask(progress, result, Date.now());
+                    // Record the child's spend into the session accumulator so the
+                    // footer totals include it (dedupe key: this progress record's
+                    // identity — per invocation, so parallel tasks never collide).
+                    deps.childUsage?.record("subagent", progressKey(toolCallId, progress, index), result.usage);
                     emit();
                     return { agent: def.name, task, result };
                 }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -41,5 +41,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "ba1d574af2d35bb9464a8b47d4e7d4a3caa3ebac"
+  "yagniSourceSha": "431d2548899146f7522a21fed3488b204b4e77d0"
 }