@genesislcap/ai-assistant 15.10.6 → 15.12.0

package/dist/dts/utils/usage-rows.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=usage-rows.test.d.ts.map

package/dist/dts/utils/usage-rows.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage-rows.test.d.ts","sourceRoot":"","sources":["../../../src/utils/usage-rows.test.ts"],"names":[],"mappings":""}

package/dist/esm/chat-driver-node.js

@@ -35,7 +35,42 @@ export { AnthropicProvider, AnthropicTransport, GeminiProvider, GeminiTransport,
 // foundation-ai's REAL list instead of maintaining a parallel hardcoded copy that silently drifts
 // as the platform adds models (a valid new model would otherwise look like a misconfiguration).
 // GENC-1461, create PR #1644 review.
-SUPPORTED_ANTHROPIC_MODEL_IDS, SUPPORTED_GEMINI_MODEL_IDS, isObservableAIProviderRegistry, } from '@genesislcap/foundation-ai';
+SUPPORTED_ANTHROPIC_MODEL_IDS, SUPPORTED_GEMINI_MODEL_IDS, isObservableAIProviderRegistry, 
+// Request pricing. Re-exported HERE, not left to a direct `@genesislcap/foundation-ai`
+// import, for the same reason as everything above it: a headless host that adds its own
+// foundation-ai dependency gets a second copy, and the driver's malformed/truncated
+// handling does `instanceof` on the transports' error classes. Reaching the pricing
+// should not cost a consumer that guarantee.
+//
+// These take RAW provider usage rather than a `ChatMessage` — see the foundation-ai
+// module docs. They are for the path where nothing stamped a cost (a proxied or
+// server-side call holding a usage block); when a message already carries `cost`, use
+// it, because it was computed with the per-TTL cache split the message no longer has.
+ANTHROPIC_CACHE_READ_MULTIPLIER, ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER, ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER, anthropicRatesFor, anthropicTokenCost, GEMINI_CACHED_INPUT_MULTIPLIER, GEMINI_LONG_CONTEXT_THRESHOLD, geminiRatesFor, geminiTokenCost, 
+// Resolves a model id to its vendor, so a caller holding only `message.model` can pick
+// between the two cost functions above without maintaining its own model→vendor map.
+vendorOfModel, } from '@genesislcap/foundation-ai';
+// Usage/cost summation. A headless consumer attributing spend to a run has no other route to it:
+// the transports' `getLifetimeCost()` is per-instance and lifetime-scoped, so a shared registry
+// makes it unattributable, and re-deriving cost from token counts is wrong in the one direction
+// that matters (`inputTokens` is total prompt size INCLUDING the cached part, so re-pricing charges
+// every cached token at full rate). `sumUsage` reads the per-request cost the transports already
+// stamped, and recurses into `toolCalls[].subAgentTrace` — where the entire spend of a delegating
+// agent lives — and into `compaction.rolledUpUsage`, which is spend whose messages no longer exist.
+// Both are invisible when omitted: the total is merely too low, which reads as a cheap run.
+//
+// `addUsage`/`emptyUsage` are the composition primitives for a conversation that CONTINUES across
+// rounds — see the guidance on `sumUsage` itself. `totalTokens` exists because the four buckets of
+// an `AggregateUsage` are disjoint and safe to add, which the per-message fields are NOT.
+export { addUsage, emptyUsage, sumUsage, totalTokens } from './utils/sum-usage';
+// Per-call projection, for the cases an aggregate cannot serve: usage rows for
+// per-project attribution, a cost dashboard, or auditing which turns came back
+// unpriced. `usageRows` is guaranteed to reconcile with `sumUsage` — including spend a
+// compaction banked, which has no message of its own and which a naive per-message walk
+// therefore drops while the total keeps it. Both take RAW history; `UsageRow` is
+// deliberately not a `ChatMessage`, so passing rows back into `sumUsage` (which recurses
+// itself, and would double-count) does not compile.
+export { usageRows } from './utils/usage-rows';
 // Debug-log harvesting (GENC-1461 unified diagnostics). A headless consumer collates its driver's
 // log — `buildTimelineEntries({ turnSnapshots: driver.getTurnSnapshots(), messages:
 // driver.getHistory(), metaEvents: getMetaEvents(sessionKey) })` → `DiagnosticEntry[]` — ships it to

package/dist/esm/components/chat-driver/chat-driver.js

@@ -584,6 +584,7 @@ export class ChatDriver extends EventTarget {
         this.activeTemperatureInput = config.temperature;
         this.activeToolChoiceInput = config.toolChoice;
         this.activeCachePolicyInput = config.cachePolicy;
+        this.activeThinkingPolicyInput = config.thinkingPolicy;
         this.activeTailContextInput = config.tailContext;
         this.activeResponseSchemaInput = config.responseSchema;
         this.activeFallbacks = config.fallbacks;
@@ -1403,15 +1404,29 @@ export class ChatDriver extends EventTarget {
      *   `condenseWhen` can register against the right call (it stamps the clocks
      *   straight off the driver). Absent for dispatch paths with no addressable tool
      *   call (e.g. the fold-close handler), where `condenseWhen` is a no-op.
-     * @param traceCapture - Optional per-invocation slot. When provided, the trace
-     *   from any sub-agent call is written here rather than to shared instance state,
-     *   so parallel tool calls each capture their own trace independently.
+     * @param traceCapture - Optional per-tool-call accumulator. When provided, every
+     *   sub-agent call's trace is **appended** here rather than written to shared
+     *   instance state, so parallel tool calls each capture their own traces
+     *   independently.
+     *
+     *   Deliberately a list of traces, not one slot. A single handler may call
+     *   `requestSubAgent` more than once — a code-driven scheduler dispatching a
+     *   dependency graph, a retry of a timed-out child, any fan-out helper — and a
+     *   single slot kept only the last, so every other child ran, was billed by the
+     *   provider, and then vanished from history. The loss was silent in the worst
+     *   way: `sumUsage` and `usageRows` both recurse into the trace, so they summed a
+     *   truncated input and still agreed with each other. Measured at 1 of 7 traces
+     *   kept on a seven-way fan-out, reporting ~2.3x under the real cost, with the
+     *   error growing as the fan-out widens.
      */
     buildHandlerContext(activeToolCallId, traceCapture) {
         return Object.assign(Object.assign({ requestInteraction: (componentName, data, options) => this.requestInteraction(componentName, data, options) }, (this.subAgentsMap.size > 0 && {
             requestSubAgent: (name, options) => this.invokeSubAgent(name, options).then(({ outcome, trace }) => {
-                if (traceCapture)
-                    traceCapture.trace = trace;
+                // Append, never assign: see `traceCapture` on `buildHandlerContext`. Order
+                // is completion order, which is fine — every message carries its own
+                // timestamp and the timeline sorts on that.
+                if (traceCapture && trace)
+                    traceCapture.traces.push(trace);
                 return outcome;
             }),
         })), { completeSubAgent: (result) => {
@@ -1908,6 +1923,18 @@ export class ChatDriver extends EventTarget {
             // `iterations` because fold operations decrement iterations, which would incorrectly
             // re-trigger the slice on subsequent calls after a fold open/close.
             let firstLlmCall = !!currentInput;
+            // Thinking posture for this WHOLE turn, resolved on the first model call and then held.
+            //
+            // Unlike temperature or toolChoice, this one cannot vary per iteration: a tool-use loop is
+            // a single assistant turn, and Anthropic requires one thinking mode for its duration.
+            // Toggling mid-loop does not error — the API silently disables thinking for that request
+            // and strips blocks that would leave the turn structure invalid, so an `'auto' -> 'off'`
+            // switch loses the reasoning continuity the opening call established while an
+            // `'off' -> 'auto'` switch simply does not deliver the reasoning asked for. It also
+            // invalidates the prompt cache, which costs more than the reasoning it was meant to save.
+            // Resolved per USER turn instead, which is where the docs say to choose it.
+            let pinnedThinkingPolicy;
+            let thinkingPolicyPinned = false;
             while (iterations < this.maxToolIterations) {
                 iterations += 1;
                 // Monotonic across the driver's life — the age clock. Unlike `iterations`,
@@ -2071,7 +2098,7 @@ export class ChatDriver extends EventTarget {
                 // provider is resolved — static value or a function of the turn context
                 // (which carries the live state for stateful agents). Resolved before the
                 // snapshot so the debug log records the exact request config the model saw.
-                const [resolvedTemperature, resolvedToolChoice, resolvedCachePolicy, resolvedTailContext, resolvedResponseSchema,] = 
+                const [resolvedTemperature, resolvedToolChoice, resolvedCachePolicy, resolvedTailContext, resolvedResponseSchema, firstResolvedThinkingPolicy,] = 
                 // oxlint-disable-next-line no-await-in-loop
                 yield Promise.all([
                     this.resolveTurnInput(this.activeTemperatureInput, promptCtx),
@@ -2079,7 +2106,16 @@ export class ChatDriver extends EventTarget {
                     this.resolveTurnInput(this.activeCachePolicyInput, promptCtx),
                     this.resolveTurnInput(this.activeTailContextInput, promptCtx),
                     this.resolveTurnInput(this.activeResponseSchemaInput, promptCtx),
+                    // Only consulted on the first iteration (see `pinnedThinkingPolicy`); resolved
+                    // alongside the others so a resolver still sees the same turn context.
+                    thinkingPolicyPinned
+                        ? Promise.resolve(undefined)
+                        : this.resolveTurnInput(this.activeThinkingPolicyInput, promptCtx),
                 ]);
+                if (!thinkingPolicyPinned) {
+                    pinnedThinkingPolicy = firstResolvedThinkingPolicy;
+                    thinkingPolicyPinned = true;
+                }
                 // The system prompt is always just the agent's resolved prompt — byte-stable, so it can be
                 // cached. The framework's volatile additions (fold suffix, retry nudge) and the agent's tail
                 // context all go to the framed tail: one uniform channel, no cache-scope branch. On a normal
@@ -2124,6 +2160,12 @@ export class ChatDriver extends EventTarget {
                     // Prompt-cache policy for this turn (Anthropic places breakpoints per scope; Gemini
                     // caches implicitly regardless). Undefined → no caching requested.
                     cachePolicy: resolvedCachePolicy,
+                    // Extended-thinking posture, pinned for the whole tool loop (one assistant turn) rather
+                    // than re-resolved per iteration — see `pinnedThinkingPolicy`. Undefined — unset, or the
+                    // resolver's answer for this turn — is NOT "off": it leaves the model on its own default,
+                    // so agents that never set this are priced exactly as before. Transports clamp models
+                    // that can't honour it.
+                    thinkingPolicy: pinnedThinkingPolicy,
                     // Framed volatile context injected at the message tail (never stored). Undefined → none.
                     tailContext,
                     // Structured-output schema for this turn (agent/state-resolved). When set, the transport
@@ -2303,8 +2345,15 @@ export class ChatDriver extends EventTarget {
                 // leaves the key off entirely rather than carrying it as `undefined`.
                 // JSON.stringify already drops undefined from the exported log, so this is
                 // chiefly about keeping the in-memory message shape honest.
-                if (this.lastResolvedModel !== undefined)
+                // Fill, never overwrite — but still only when there is something to fill with.
+                // A transport that already stamped a model knows something the driver does not:
+                // `lastResolvedModel` is the model we ASKED for, so overwriting would relabel a
+                // fallback-served turn as the requested model and misattribute its spend.
+                // Written as a guard rather than `??=` because `??=` ASSIGNS undefined, which
+                // would create the key and break the omit-when-unresolved contract above.
+                if (response.model === undefined && this.lastResolvedModel !== undefined) {
                     response.model = this.lastResolvedModel;
+                }
                 if (this.lastResolvedProvider !== undefined)
                     response.provider = this.lastResolvedProvider;
                 if (this.lastResolvedProviderName !== undefined) {
@@ -2517,15 +2566,26 @@ export class ChatDriver extends EventTarget {
                             }
                             return;
                         }
-                        // Real tool execution
+                        // Real tool execution.
+                        //
+                        // The accumulator is declared OUTSIDE the try so the catch can attach it
+                        // too: a handler that ran sub-agents and then threw (post-processing their
+                        // results failed, say) has already spent real money on children that
+                        // completed. Losing their traces on the error path would under-report the
+                        // run exactly as the single-slot bug did — and just as silently, since
+                        // `sumUsage` and `usageRows` would still agree with each other.
+                        const traceCapture = { traces: [] };
+                        const capturedTrace = () => traceCapture.traces.length ? traceCapture.traces.flat() : undefined;
                         try {
-                            const traceCapture = {};
                             const result = yield handler(tc.args, this.buildHandlerContext(tc.id, traceCapture));
                             const content = typeof result === 'string' ? result : JSON.stringify(result);
                             executedById.set(tc.id, {
                                 toolCallId: tc.id,
                                 content,
-                                subAgentTrace: traceCapture.trace,
+                                // Concatenated when a handler invoked several children, so none is lost.
+                                // Stays `undefined` when nothing was captured — readers key off presence,
+                                // and an empty array is a different claim from "no sub-agent ran".
+                                subAgentTrace: capturedTrace(),
                             });
                             anyRealToolExecuted = true;
                         }
@@ -2541,6 +2601,9 @@ export class ChatDriver extends EventTarget {
                                 // Structured recovery hint so the model retries or routes around a tool
                                 // failure instead of apologising and giving up.
                                 content: `Tool error: ${e.message}\nRECOVERY: this tool failed once — you may retry it, or take a different valid action to make progress. Do NOT abandon the task, ask the user to rephrase, or claim you cannot make changes. If a planning tool failed, retry it or proceed with the information you already have.`,
+                                // Children that completed before the throw were still billed — keep
+                                // their traces so the run's cost stays whole.
+                                subAgentTrace: capturedTrace(),
                             });
                             anyRealToolExecuted = true; // treat errors as real work for fold op counting
                         }

package/dist/esm/components/chat-driver/chat-driver.thinking-policy.test.js

@@ -0,0 +1,137 @@
+import { __awaiter } from "tslib";
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+// Side-effect import — MUST come before `./chat-driver` so the driver subclasses
+// jsdom's EventTarget rather than Node's native one. Mirrors chat-driver.test.ts.
+import './align-event-globals';
+import { ChatDriver } from './chat-driver';
+// ---------------------------------------------------------------------------
+// Per-turn `thinkingPolicy` resolution.
+//
+// The cost case for this option is the SHAPE of a tool loop, not a single call: the
+// opening turn is a real decision and worth reasoning over, while the iterations that
+// follow mostly pick the next tool from a narrow set — and on a thinking model each of
+// those bills reasoning at the full output rate. That saving only exists if the
+// resolver runs per iteration, so these tests assert the sequence across a loop, not
+// just that one value arrives.
+//
+// The other half is the undefined case. Every agent written before this option leaves
+// it unset, and a resolver may answer `undefined` on any given turn; both must reach
+// the transport as `undefined` so the model keeps its own default. `undefined` reaching
+// the wire as `'off'` would be a silent capability regression, and as `'auto'` a silent
+// bill increase — so it is asserted explicitly rather than assumed.
+// ---------------------------------------------------------------------------
+/** Captures the policy seen on each model call; calls one tool, then finishes. */
+const capturingProvider = () => {
+    const seen = [];
+    let turns = 0;
+    return {
+        seen,
+        chat: (_history, _userMessage, options) => __awaiter(void 0, void 0, void 0, function* () {
+            seen.push(options === null || options === void 0 ? void 0 : options.thinkingPolicy);
+            turns += 1;
+            // Two tool calls, so the loop runs three model calls in total — enough for a
+            // per-turn resolver to say something different on the later ones.
+            if (turns <= 2) {
+                return {
+                    role: 'assistant',
+                    content: '',
+                    toolCalls: [{ id: `t${turns}`, name: 'step', args: {} }],
+                };
+            }
+            return { role: 'assistant', content: 'done' };
+        }),
+    };
+};
+const makeRegistry = (provider) => ({
+    get: () => provider,
+    default: () => provider,
+    defaultName: () => 'test',
+    names: () => ['test'],
+    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
+});
+const agent = (overrides) => (Object.assign({ name: 'worker', description: 'test agent', toolDefinitions: [
+        { name: 'step', description: 'step', parameters: { type: 'object', properties: {} } },
+    ], toolHandlers: { step: () => __awaiter(void 0, void 0, void 0, function* () { return 'stepped'; }) } }, overrides));
+/** Run one user turn through a driver carrying `config`, and return the policies seen. */
+const policiesFor = (config) => __awaiter(void 0, void 0, void 0, function* () {
+    const provider = capturingProvider();
+    const driver = new ChatDriver(makeRegistry(provider), {
+        maxToolIterations: 10,
+        maxFoldOperations: 5,
+        sessionKey: '',
+    });
+    driver.applyAgent(agent(config));
+    yield driver.sendMessage('go');
+    return provider.seen;
+});
+const suite = createLogicSuite('ChatDriver thinkingPolicy');
+suite('leaves the policy undefined when the agent does not set one', () => __awaiter(void 0, void 0, void 0, function* () {
+    // The compatibility case: every existing agent. Undefined must reach the transport
+    // as undefined so each model keeps its own default posture — not silently coerced
+    // to 'off' (a capability regression) or 'auto' (a bill increase).
+    const seen = yield policiesFor({});
+    assert.ok(seen.length >= 3, `expected a multi-call loop, got ${seen.length}`);
+    assert.equal(seen.filter((p) => p !== undefined), [], 'no turn invents a policy');
+}));
+suite('applies a static policy to every turn of the loop', () => __awaiter(void 0, void 0, void 0, function* () {
+    const seen = yield policiesFor({ thinkingPolicy: 'off' });
+    assert.ok(seen.length >= 3);
+    assert.equal([...new Set(seen)], ['off'], 'a static value is not just a first-turn setting');
+}));
+suite('pins the resolved policy for the whole tool loop', () => __awaiter(void 0, void 0, void 0, function* () {
+    // A tool-use loop is ONE assistant turn and Anthropic requires a single thinking mode
+    // for its duration. Toggling part-way does not error — the API silently disables
+    // thinking for that request and strips blocks that would leave the turn structure
+    // invalid, so an 'auto' -> 'off' switch loses the continuity the opening call
+    // established and 'off' -> 'auto' never delivers the reasoning asked for. It also
+    // invalidates the prompt cache, costing more than the reasoning it meant to save.
+    //
+    // So a resolver that changes its mind mid-loop must NOT be honoured mid-loop. This
+    // asserts the opposite of what it looks like it should: the later values are ignored.
+    let call = 0;
+    const seen = yield policiesFor({
+        thinkingPolicy: () => {
+            call += 1;
+            return call === 1 ? 'auto' : 'off';
+        },
+    });
+    assert.ok(seen.length >= 3, `expected a multi-call loop, got ${seen.length}`);
+    assert.equal([...new Set(seen)], ['auto'], 'the first call decides; later resolutions do not take effect until the next user turn');
+}));
+suite('re-resolves on the next user turn', () => __awaiter(void 0, void 0, void 0, function* () {
+    // The flip side: pinning is per turn, not for the driver's lifetime, so a state change
+    // between turns still lands.
+    const provider = capturingProvider();
+    const driver = new ChatDriver(makeRegistry(provider), {
+        maxToolIterations: 10,
+        maxFoldOperations: 5,
+        sessionKey: '',
+    });
+    let turn = 0;
+    driver.applyAgent(agent({
+        thinkingPolicy: () => (turn === 0 ? 'auto' : 'off'),
+    }));
+    yield driver.sendMessage('go');
+    const firstTurn = [...provider.seen];
+    turn = 1;
+    yield driver.sendMessage('again');
+    const secondTurn = provider.seen.slice(firstTurn.length);
+    assert.equal([...new Set(firstTurn)], ['auto'], 'turn one holds its posture');
+    assert.equal([...new Set(secondTurn)], ['off'], 'turn two picks up the new one');
+}));
+suite('passes undefined through when the resolver declines to choose', () => __awaiter(void 0, void 0, void 0, function* () {
+    // A resolver may answer on some turns and not others. `undefined` is its third answer —
+    // "leave this model alone" — and must not be normalised into a value. Asserted across
+    // the whole loop because the first call's answer is the one that gets pinned.
+    const seen = yield policiesFor({ thinkingPolicy: () => undefined });
+    assert.ok(seen.length >= 3);
+    assert.equal(seen.filter((p) => p !== undefined), [], 'declining is not the same as choosing');
+}));
+suite('awaits an async resolver', () => __awaiter(void 0, void 0, void 0, function* () {
+    const seen = yield policiesFor({
+        thinkingPolicy: () => __awaiter(void 0, void 0, void 0, function* () { return 'off'; }),
+    });
+    assert.equal([...new Set(seen)], ['off'], 'a promise is resolved, not passed through');
+}));
+suite.run();

package/dist/esm/components/chat-driver/chat-driver.trace-capture.test.js

@@ -0,0 +1,200 @@
+import { __awaiter } from "tslib";
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { sumUsage } from '../../utils/sum-usage';
+import { usageRows } from '../../utils/usage-rows';
+// Side-effect import — MUST come before `./chat-driver` so the driver subclasses
+// jsdom's EventTarget rather than Node's native one. Mirrors chat-driver.test.ts.
+import './align-event-globals';
+import { ChatDriver } from './chat-driver';
+// ---------------------------------------------------------------------------
+// Sub-agent trace capture when ONE tool call invokes SEVERAL sub-agents.
+//
+// The capture slot used to be a single `{ trace?: ChatMessage[] }` per tool call,
+// assigned by each `requestSubAgent`. That covers N tool calls × 1 sub-agent — the
+// case its docblock named — but not 1 tool call × N sub-agents, which is what a
+// code-driven scheduler or a retry produces. All but the last trace was dropped, so
+// those children ran, were billed, and then had no record in history.
+//
+// The failure was invisible to every existing check: `sumUsage` and `usageRows` both
+// recurse into `subAgentTrace`, so they summed a truncated input and still reconciled
+// with each other perfectly. Measured at 1 of 7 traces kept on a seven-way fan-out,
+// ~2.3x under the true cost.
+//
+// These tests assert the traces SURVIVE, which is upstream of any cost assertion.
+// ---------------------------------------------------------------------------
+/** Answers by rule: concurrent children under one turn make a FIFO queue nondeterministic. */
+const ruleProvider = () => {
+    let parentTurns = 0;
+    return {
+        chat: (_history, _userMessage, options) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const tools = ((_a = options === null || options === void 0 ? void 0 : options.tools) !== null && _a !== void 0 ? _a : []).map((t) => t.name);
+            // Child turn: finishes via its completion tool, and reports usage so the
+            // reconciliation assertions have something to add up.
+            if (tools.includes('work')) {
+                return {
+                    role: 'assistant',
+                    content: '',
+                    model: 'claude-sonnet-5',
+                    cost: 0.01,
+                    inputTokens: 100,
+                    outputTokens: 20,
+                    toolCalls: [{ id: 'w1', name: 'work', args: {} }],
+                };
+            }
+            if (tools.includes('delegate') && parentTurns === 0) {
+                parentTurns += 1;
+                return {
+                    role: 'assistant',
+                    content: '',
+                    model: 'claude-sonnet-5',
+                    cost: 0.02,
+                    inputTokens: 200,
+                    outputTokens: 30,
+                    toolCalls: [{ id: 'd0', name: 'delegate', args: {} }],
+                };
+            }
+            return { role: 'assistant', content: 'done', model: 'claude-sonnet-5' };
+        }),
+    };
+};
+const makeRegistry = (provider) => ({
+    get: () => provider,
+    default: () => provider,
+    defaultName: () => 'test',
+    names: () => ['test'],
+    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
+});
+const agent = (overrides) => (Object.assign({ description: 'test agent' }, overrides));
+/** A child that reports one unit of usage and completes. */
+const worker = (name) => agent({
+    name,
+    toolDefinitions: [
+        { name: 'work', description: 'work', parameters: { type: 'object', properties: {} } },
+    ],
+    toolHandlers: {
+        work: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            (_a = ctx.completeSubAgent) === null || _a === void 0 ? void 0 : _a.call(ctx, { ok: true });
+            return 'worked';
+        }),
+    },
+});
+/**
+ * A parent whose single `delegate` tool call invokes `names` in turn — the shape a
+ * code-driven scheduler produces, and the one the old single slot truncated.
+ */
+const boss = (children, invoke) => agent({
+    name: 'boss',
+    subAgents: children,
+    toolDefinitions: [
+        { name: 'delegate', description: 'delegate', parameters: { type: 'object', properties: {} } },
+    ],
+    toolHandlers: {
+        delegate: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+            yield Promise.all(invoke.map((n) => ctx.requestSubAgent(n, { task: 'go' })));
+            return 'delegated';
+        }),
+    },
+});
+const run = (config) => __awaiter(void 0, void 0, void 0, function* () {
+    const driver = new ChatDriver(makeRegistry(ruleProvider()), {
+        maxToolIterations: 20,
+        maxFoldOperations: 5,
+        sessionKey: '',
+    });
+    driver.applyAgent(config);
+    yield driver.sendMessage('go');
+    return driver.getHistory();
+});
+const tracesIn = (history) => history.flatMap((m) => { var _a; return ((_a = m.toolCalls) !== null && _a !== void 0 ? _a : []).flatMap((tc) => (tc.subAgentTrace ? [tc.subAgentTrace] : [])); });
+const suite = createLogicSuite('ChatDriver sub-agent trace capture');
+// ---------------------------------------------------------------------------
+suite('keeps every trace when one tool call invokes three sub-agents', () => __awaiter(void 0, void 0, void 0, function* () {
+    const names = ['gen_a', 'gen_b', 'gen_c'];
+    const history = yield run(boss(names.map(worker), names));
+    const traces = tracesIn(history);
+    assert.is(traces.length, 1, 'one tool call, so one concatenated trace');
+    // Each child contributes at least its own assistant turn. Before the fix this was
+    // one child's worth regardless of how many ran.
+    const seen = new Set(traces[0].map((m) => m.agentName).filter(Boolean));
+    assert.equal([...seen].sort(), names, `every invoked child must appear — got ${JSON.stringify([...seen])}`);
+}));
+suite('prices every child — usageRows emits a row per child and reconciles', () => __awaiter(void 0, void 0, void 0, function* () {
+    // The reconciliation test extended to a fan-out. The single-child version passed
+    // before the fix AND after it, which is exactly why it did not catch this.
+    const names = ['gen_a', 'gen_b', 'gen_c'];
+    const history = yield run(boss(names.map(worker), names));
+    const rows = usageRows(history);
+    const childRows = rows.filter((r) => r.subAgentDepth === 1);
+    assert.is(childRows.length, names.length, 'one row per child that ran');
+    const rowTotal = rows.reduce((n, r) => { var _a, _b; return n + ((_a = r.costUsd) !== null && _a !== void 0 ? _a : 0) + ((_b = r.externalCostUsd) !== null && _b !== void 0 ? _b : 0); }, 0);
+    assert.ok(Math.abs(rowTotal - sumUsage(history).costUsd) < 1e-12, `rows ${rowTotal} vs sumUsage ${sumUsage(history).costUsd}`);
+    // Parent turn ($0.02) + three children ($0.01 each). Asserted as a number so a
+    // regression that silently drops a child fails here rather than only in the
+    // reconciliation above, which would still agree with a truncated input.
+    assert.ok(Math.abs(rowTotal - 0.05) < 1e-12, `expected 0.05, got ${rowTotal}`);
+}));
+suite('keeps both traces when the same sub-agent is invoked twice (a retry)', () => __awaiter(void 0, void 0, void 0, function* () {
+    // The retry shape: one handler, one child name, two invocations. Under the old slot
+    // the first attempt's trace was overwritten by the second.
+    const history = yield run(boss([worker('gen_a')], ['gen_a', 'gen_a']));
+    const traces = tracesIn(history);
+    assert.is(traces.length, 1);
+    const childTurns = traces[0].filter((m) => m.agentName === 'gen_a' && m.cost != null);
+    assert.is(childTurns.length, 2, 'both attempts survive, not just the last');
+    const rows = usageRows(history).filter((r) => r.subAgentDepth === 1);
+    assert.is(rows.length, 2, 'and both are priced');
+}));
+suite('keeps child traces when the parent handler throws after they ran', () => __awaiter(void 0, void 0, void 0, function* () {
+    // Children that completed were billed by the provider. If the error path drops
+    // their traces, the run under-reports exactly as the single-slot bug did — and
+    // just as silently, since `sumUsage` and `usageRows` would still agree with each
+    // other over the truncated input. PR review.
+    const names = ['gen_a', 'gen_b'];
+    const parent = agent({
+        name: 'boss',
+        subAgents: names.map(worker),
+        toolDefinitions: [
+            { name: 'delegate', description: 'delegate', parameters: { type: 'object', properties: {} } },
+        ],
+        toolHandlers: {
+            delegate: (_args, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                yield Promise.all(names.map((n) => ctx.requestSubAgent(n, { task: 'go' })));
+                throw new Error('post-processing the children failed');
+            }),
+        },
+    });
+    const history = yield run(parent);
+    const traces = tracesIn(history);
+    assert.is(traces.length, 1, 'the failed tool call still carries its trace');
+    const seen = [...new Set(traces[0].map((m) => m.agentName).filter(Boolean))].sort();
+    assert.equal(seen, names, 'both children survive the throw');
+    const childRows = usageRows(history).filter((r) => r.subAgentDepth === 1);
+    assert.is(childRows.length, 2, 'and both are still priced');
+}));
+suite('leaves subAgentTrace undefined when no sub-agent ran', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    // Presence is the signal readers key off (`usage-rows.ts`, the UI's `when(...)`),
+    // so an empty array would be a different and wrong claim.
+    const history = yield run(agent({
+        name: 'boss',
+        subAgents: [worker('gen_a')],
+        toolDefinitions: [
+            {
+                name: 'delegate',
+                description: 'delegate',
+                parameters: { type: 'object', properties: {} },
+            },
+        ],
+        toolHandlers: { delegate: () => __awaiter(void 0, void 0, void 0, function* () { return 'did it myself'; }) },
+    }));
+    for (const m of history) {
+        for (const tc of (_a = m.toolCalls) !== null && _a !== void 0 ? _a : []) {
+            assert.is(tc.subAgentTrace, undefined, 'not an empty array');
+        }
+    }
+    assert.equal(usageRows(history).filter((r) => r.subAgentDepth === 1), [], 'no child rows');
+}));
+suite.run();

package/dist/esm/components/settings-modal/settings-modal.styles.js

@@ -306,6 +306,28 @@ export const settingsModalStyles = css `
     color: var(--neutral-foreground-rest);
   }
 
+  /* Freshness footer (GENC-1464): refresh button + label under the vendor
+     rows, left-aligned — a footnote to the figures above it. The button's
+     inline padding is pinned and cancelled by the container margin so the
+     ICON GLYPH (not the button box) sits flush with the budget labels'
+     left edge, whatever the density tokens say. */
+  .settings-budget-toolbar {
+    display: flex;
+    justify-content: flex-start;
+    align-items: center;
+    gap: 4px;
+    margin-inline-start: -4px;
+  }
+
+  .settings-budget-refresh::part(control) {
+    padding-inline: 4px;
+  }
+
+  .settings-budget-updated {
+    color: var(--neutral-foreground-hint);
+    font-size: 11px;
+  }
+
   /*
    * ONE rhythm for every meter row. The outer wrapper holds the context
    * indicator and the budget meter; the inner one holds the budget meter's

package/dist/esm/components/settings-modal/settings-modal.template.js

@@ -120,7 +120,7 @@ const platformContextUsageTemplate = (progressTag) => html `
  * the bar clamps — both computed in `settingsBudgetRows`, so the bindings here
  * stay pure reads and the arithmetic is unit-testable.
  */
-const platformBudgetUsageTemplate = (progressTag) => html `
+const platformBudgetUsageTemplate = (progressTag, buttonTag, iconTag) => html `
   ${when((x) => x.settingsBudgetUsageVisible, html `
       <div class="settings-budget-usage" part="budget-usage">
         ${repeat((x) => x.settingsBudgetRows, html `
@@ -135,6 +135,26 @@ const platformBudgetUsageTemplate = (progressTag) => html `
               ></${progressTag}>
             </div>
           `)}
+        <!--
+          Freshness footer (GENC-1464): the rows above update per turn and at
+          the wall, which reads as "stale" to anyone watching the modal — the
+          label says when the figures arrived, the button asks the host for new
+          ones (see FoundationAiAssistant.requestBudgetRefresh). Below the rows
+          and left-aligned, reading as a footnote to the figures it describes.
+        -->
+        <div class="settings-budget-toolbar" part="budget-toolbar">
+          <${buttonTag}
+            appearance="stealth"
+            class="settings-budget-refresh"
+            part="budget-refresh"
+            title="Refresh budget figures"
+            aria-label="Refresh budget figures"
+            @click=${(x) => x.requestBudgetRefresh()}
+          >
+            <${iconTag} name="arrows-rotate"></${iconTag}>
+          </${buttonTag}>
+          <span class="settings-budget-updated">${(x) => x.settingsBudgetUpdatedLabel}</span>
+        </div>
       </div>
     `)}
 `;
@@ -159,10 +179,11 @@ const platformBudgetUsageTemplate = (progressTag) => html `
  *
  * @internal
  */
-export const settingsUsageMetersTemplate = (progressTag) => html `
+export const settingsUsageMetersTemplate = (progressTag, buttonTag, iconTag) => html `
   ${when((x) => x.settingsContextUsageVisible || x.settingsBudgetUsageVisible, html `
       <div class="settings-usage-meters">
-        ${platformContextUsageTemplate(progressTag)} ${platformBudgetUsageTemplate(progressTag)}
+        ${platformContextUsageTemplate(progressTag)}
+        ${platformBudgetUsageTemplate(progressTag, buttonTag, iconTag)}
       </div>
     `)}
 `;
@@ -511,7 +532,7 @@ export const SettingsModalTemplate = (designSystemPrefix) => {
         </h3>
         <div class="settings-modal-section-body">
           <slot name="settings-model" ${slotted('settingsModelSlotted')}></slot>
-          ${settingsUsageMetersTemplate(progressTag)}
+          ${settingsUsageMetersTemplate(progressTag, buttonTag, iconTag)}
         </div>
       </section>
       <!--

package/dist/esm/components/settings-modal/settings-modal.template.test.js

@@ -25,7 +25,7 @@ FoundationAiAssistant;
 // only), for the reason budget-meter.test.ts gives: connecting subscribes to
 // `agenticActivityBus` and leaves the runner's event loop open.
 const Suite = createLogicSuite('settings-modal usage meters structure');
-const template = settingsUsageMetersTemplate('test-progress');
+const template = settingsUsageMetersTemplate('test-progress', 'test-button', 'test-icon');
 let storeSeq = 0;
 /** A fresh (unconnected) element wired to its own real session store. */
 function element() {