@yagni-app/code-staging 1.0.1-staging.1204.1 → 1.0.2-staging.1211.1

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/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/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";
@@ -187,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.
@@ -232,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):
@@ -242,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.
@@ -359,6 +365,7 @@ export async function registerYagni(pi, deps = {}) {
         guardianLimits,
         guardianTier,
         guardianDisabled,
+        childUsage,
         guardianReview: (command, deps) => reviewCommand(command, { ...deps, modelTier: guardianTier }),
         onGuardianReview: (ev) => {
             guardianLogSink(ev);
@@ -900,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,6 +565,10 @@ export function registerPermissionGate(pi, deps = {}) {
                             ctx.ui.setStatus?.("yagni-guardian", undefined);
                     }
                     const durationMs = Date.now() - startMs;
+                    // 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;

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/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-staging",
-  "version": "1.0.1-staging.1204.1",
+  "version": "1.0.2-staging.1211.1",
   "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": "d2a776fc46ede83ad273ea3dcfeeea03aa8e3292"
+  "yagniSourceSha": "2feaf4da115b5f9322ccc20e175837fdb69d3e6c"
 }