@genesislcap/ai-assistant 14.467.1 → 14.467.2-GENC-1369.2

package/dist/dts/utils/flatten-sub-agent-messages.d.ts

@@ -0,0 +1,51 @@
+import type { ChatMessage } from '@genesislcap/foundation-ai';
+/**
+ * A chat message lifted into the debug-log timeline as a `kind: 'message'` entry.
+ *
+ * @beta
+ */
+export type TimelineMessage = ChatMessage & {
+    kind: 'message';
+    /**
+     * Set only on entries hoisted out of a `subAgentTrace`: the sub-agent's own
+     * (un-breadcrumbed) `agentName`, kept for filtering since the displayed
+     * `agentName` is rewritten to a `"<parent> › <sub-agent>"` breadcrumb.
+     */
+    subAgentName?: string;
+    /** Delegation depth — absent/0 for top-level, 1 for a sub-agent, 2 for a sub-agent's sub-agent, … */
+    subAgentDepth?: number;
+    /** Id of the parent tool call that spawned this run — correlates a hoisted message back to its delegation. */
+    subAgentOf?: string;
+};
+/**
+ * Flatten sub-agent conversations into a single top-level message stream for the
+ * debug-log timeline.
+ *
+ * A tool call that delegates to a sub-agent carries the sub-agent's entire
+ * conversation on `toolCall.subAgentTrace`. The live UI reads that nested shape,
+ * but a top-to-bottom timeline reads far better with those messages inline next to
+ * the turn that produced them. This walks the list and, for every tool call with a
+ * `subAgentTrace`, hoists the sub-agent's messages up as their own timeline
+ * entries while **removing** the nested copy from the emitted parent tool call — a
+ * move, not a copy. The data is relocated, never duplicated: the export stays the
+ * same size and a naive `sum(timeline[].cost)` does not double-count (the
+ * canonical `sumCosts` total still reads the un-flattened history).
+ *
+ * Hoisted entries are:
+ * - **breadcrumbed**: `agentName` becomes `"<parent> › <sub-agent>"`, composing for
+ *   nested sub-agents (`"<parent> › <sub> › <subsub>"`); the raw sub-agent name is
+ *   preserved on `subAgentName`.
+ * - **depth-tagged** (`subAgentDepth`) and **correlated** to the spawning tool call
+ *   (`subAgentOf`), so the delegation tree is reconstructable even when two
+ *   sub-agents run within the same parent turn.
+ *
+ * Top-level messages (depth 0) are emitted unchanged apart from the trace strip.
+ * Order is preserved within each list; the caller sorts the whole timeline by
+ * timestamp afterwards, and every sub-agent message carries its own timestamp, so
+ * hoisted entries interleave chronologically between the parent's tool-call and
+ * tool-result messages.
+ *
+ * @internal
+ */
+export declare function flattenSubAgentMessages(messages: readonly ChatMessage[], prefix?: string, depth?: number, subAgentOf?: string): TimelineMessage[];
+//# sourceMappingURL=flatten-sub-agent-messages.d.ts.map

package/dist/dts/utils/flatten-sub-agent-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-sub-agent-messages.d.ts","sourceRoot":"","sources":["../../../src/utils/flatten-sub-agent-messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG;IAC1C,IAAI,EAAE,SAAS,CAAC;IAChB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qGAAqG;IACrG,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,8GAA8G;IAC9G,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,MAAM,SAAK,EACX,KAAK,SAAI,EACT,UAAU,CAAC,EAAE,MAAM,GAClB,eAAe,EAAE,CA+BnB"}

package/dist/dts/utils/flatten-sub-agent-messages.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=flatten-sub-agent-messages.test.d.ts.map

package/dist/dts/utils/flatten-sub-agent-messages.test.d.ts.map

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

package/dist/dts/utils/strip-agent-handlers.d.ts

@@ -0,0 +1,29 @@
+import type { AgentConfig } from '../config/config';
+/**
+ * Project an `AgentConfig` down to a JSON-serializable shape for the redux
+ * session store. Drops two kinds of field:
+ *
+ * 1. **Directly function-valued** — the lifecycle/dispatch hooks (`onActivate`,
+ *    `onDeactivate`, `getDebugSnapshot`, `onUnresolvedTool`) and the function
+ *    form of the per-turn resolvers (`systemPrompt`, `toolDefinitions`,
+ *    `displayName`, `provider`, `temperature`, `toolChoice`, `toolHandlers`).
+ * 2. **Object "handler bags" whose *values* are functions** — `toolHandlers` in
+ *    its object form is `{ name: handler }`, so `typeof` is `'object'`, not
+ *    `'function'`. A by-value check on the field alone misses it, leaking a live
+ *    handler into store state and tripping redux's serializability check (the
+ *    regression this guards against — top-level agents tend to use the factory
+ *    function form, but sub-agents commonly declare an object literal).
+ *
+ * `subAgents` are projected recursively. Static forms (string / number / array /
+ * plain data object) pass through unchanged.
+ *
+ * Filtering by value rather than an explicit field list means a new
+ * function-valued field on `AgentConfig` is handled automatically — no denylist
+ * to maintain. The live config on the driver stays the source of truth; the
+ * slice only holds this serializable projection and functions are never read
+ * back from it.
+ *
+ * @internal
+ */
+export declare function stripAgentHandlers(agent: AgentConfig): Omit<AgentConfig, 'toolHandlers'>;
+//# sourceMappingURL=strip-agent-handlers.d.ts.map

package/dist/dts/utils/strip-agent-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-agent-handlers.d.ts","sourceRoot":"","sources":["../../../src/utils/strip-agent-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,CAuBxF"}

package/dist/dts/utils/strip-agent-handlers.test.d.ts

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

package/dist/dts/utils/strip-agent-handlers.test.d.ts.map

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

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

@@ -2,7 +2,8 @@ import { __awaiter } from "tslib";
 import { isObservableAIProviderRegistry, MalformedFunctionCallError, } from '@genesislcap/foundation-ai';
 import { agenticActivityBus } from '../../channel/ai-activity-bus';
 import { resolveChatProvider } from '../../config/validate-providers';
-import { recordMetaEvent, recordTurnError, recordTurnRetry } from '../../state/debug-event-log';
+import { clearSession, getMetaEvents, mergeMetaEvents, recordMetaEvent, recordTurnError, recordTurnRetry, } from '../../state/debug-event-log';
+import { applyCondensation } from '../../utils/condense-history';
 import { applyHistoryCap } from '../../utils/history-transform';
 import { logger } from '../../utils/logger';
 import { TOOL_FOLD_SYMBOL } from '../../utils/tool-fold';
@@ -32,6 +33,22 @@ const MAX_EMPTY_RESPONSE_RETRIES = 3;
 // SAME iteration up to this many times before propagating, rather than tearing down the turn.
 const MAX_SETUP_TRANSPORT_RETRIES = 3;
 const SUGGESTIONS_HISTORY_WINDOW = 8;
+/**
+ * Sub-agent meta events worth folding into the parent's debug timeline: the
+ * per-attempt and per-failure signals that do NOT otherwise surface in the
+ * sub-agent's (now hoisted) messages — a retried-away malformed/empty attempt
+ * produces no message, and the stale-vs-hallucinated/streak diagnostics live only
+ * on the event. High-volume, message-derivable events (turn.start/turn.end,
+ * provider.selected, context.updated) are intentionally excluded: read the
+ * sub-agent's hoisted messages for model/tokens/cost and turn-by-turn activity.
+ * See `ChatDriver.invokeSubAgent`.
+ */
+const HARVESTED_SUBAGENT_EVENTS = new Set([
+    'turn.retry',
+    'turn.error',
+    'tool.failed',
+    'tool.unresolved',
+]);
 /** Name reserved for the cross-agent handoff tool — injected by OrchestratingDriver. */
 export const REQUEST_CONTINUATION_TOOL = 'request_continuation';
 /** Paired in history for each `request_continuation` so tool_calls stay balanced for the provider. */
@@ -59,6 +76,40 @@ export class ChatDriver extends EventTarget {
         /** Epoch ms when the current turn loop began — drives the `turn.end` duration. */
         this.turnStartedAt = 0;
         this.pendingInteractions = new Map();
+        /**
+         * Tool-declared condensation policies, keyed by tool-call id. Populated by
+         * `condenseWhen` (first-wins per call); read by `applyCondensation` before each
+         * provider call to collapse stale payloads from the model-bound history only.
+         * Accumulates across agents on a shared driver (a superseded read collapses no
+         * matter which agent made it) and is never cleared — it dies with the driver.
+         */
+        this.condensePolicies = new Map();
+        /**
+         * Monotonic model-call counter for the driver's whole lifetime — the age clock
+         * for `condenseWhen({ on: { kind: 'age' } })`. The per-`sendMessage` `iterations`
+         * loop counter resets to 0 every turn, so it can only measure age WITHIN a
+         * single turn; this never resets, so `age` counts model-calls since the result
+         * appeared across turn boundaries (each short turn still advances it ≥ 1).
+         * Bumped once per tool-loop iteration (provider call).
+         */
+        this.modelCallSeq = 0;
+        /**
+         * Monotonic turn counter — the `turnEnd` clock. Bumped once per `sendMessage`
+         * (a user turn; NOT per handoff continuation, which is the same request), never
+         * reset. `turnEnd` collapses a payload once `turnSeq` exceeds the turn it was
+         * created in.
+         */
+        this.turnSeq = 0;
+        /**
+         * Monotonic agent-activation counter — the `agentEnd` clock. Advances when the
+         * active flow ends: a swap to a different-named agent (`applyAgent`) OR an
+         * explicit `releaseAgent` / `completeSubAgent`. A stateful agent re-resolving
+         * the same name across turns keeps one activation. `agentEnd` fires for a
+         * payload once a LATER activation is current (`callActivation < currentActivation`)
+         * — so a re-run of a released agent gets a fresh activation and is NOT
+         * collapsed until IT ends.
+         */
+        this.currentActivation = 0;
         /** Stack of fold frames — grows when a fold opens, shrinks when it closes. */
         this.foldStack = [];
         /** Consecutive fold open/close ops without a real tool call. Reset on real tool execution. */
@@ -264,6 +315,12 @@ export class ChatDriver extends EventTarget {
      */
     applyAgent(config) {
         var _a, _b, _c;
+        // A real swap to a different agent begins a NEW activation — the prior agent's
+        // flow is over, so its `agentEnd`-tagged payloads become collapsible. Guarded
+        // on a name change so re-applying the same agent (e.g. a per-turn re-resolve)
+        // does not spuriously advance the clock and prematurely drop its payloads.
+        if (config.name !== this.activeAgentName)
+            this.currentActivation += 1;
         this.systemPrompt = config.systemPrompt;
         if (typeof config.toolDefinitions === 'function') {
             this.toolDefinitionsFactory = config.toolDefinitions;
@@ -857,6 +914,9 @@ export class ChatDriver extends EventTarget {
                 return { reason: 'done' };
             this.busy = true;
             this.beginTurn();
+            // A new user turn — advances the `turnEnd` clock (continuations after a
+            // handoff stay on the same turn; they go through `continueFromHistory`).
+            this.turnSeq += 1;
             this.subAgentCompletion = undefined;
             this.subAgentFailure = undefined;
             this.agentReleaseRequested = false;
@@ -902,11 +962,15 @@ export class ChatDriver extends EventTarget {
      * Centralised here so fold shortcut dispatch and the main tool loop use the
      * same context without duplication.
      *
+     * @param activeToolCallId - The id of the tool call this context belongs to, so
+     *   `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.
      */
-    buildHandlerContext(traceCapture) {
+    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)
@@ -920,6 +984,9 @@ export class ChatDriver extends EventTarget {
                     return;
                 }
                 this.subAgentCompletion = { result };
+                // This activation's flow has ended — advance the clock so its
+                // `agentEnd` payloads collapse and a re-run starts a fresh activation.
+                this.currentActivation += 1;
             }, releaseAgent: () => {
                 var _a;
                 if (this.agentReleaseRequested) {
@@ -927,6 +994,42 @@ export class ChatDriver extends EventTarget {
                     return;
                 }
                 this.agentReleaseRequested = true;
+                // The stateful flow has wrapped up — advance the clock so its `agentEnd`
+                // payloads collapse and a re-run starts a fresh activation.
+                this.currentActivation += 1;
+            }, condenseWhen: (policy) => {
+                var _a, _b, _c;
+                // No addressable tool call (e.g. fold-close handler) — nothing to attach to.
+                if (!activeToolCallId)
+                    return;
+                if (!(policy === null || policy === void 0 ? void 0 : policy.args) && !(policy === null || policy === void 0 ? void 0 : policy.response)) {
+                    logger.warn(`ChatDriver(${(_a = this.activeAgentName) !== null && _a !== void 0 ? _a : 'unknown'}): condenseWhen called with neither args nor response — ignoring`);
+                    return;
+                }
+                const triggers = Array.isArray(policy.on) ? policy.on : [policy.on];
+                const validTrigger = (t) => (t === null || t === void 0 ? void 0 : t.kind) === 'superseded'
+                    ? typeof t.by === 'string' && t.by.length > 0
+                    : (t === null || t === void 0 ? void 0 : t.kind) === 'age'
+                        ? typeof t.turns === 'number' && t.turns >= 1
+                        : (t === null || t === void 0 ? void 0 : t.kind) === 'turnEnd' || (t === null || t === void 0 ? void 0 : t.kind) === 'agentEnd';
+                if (triggers.length === 0 || !triggers.every(validTrigger)) {
+                    logger.warn(`ChatDriver(${(_b = this.activeAgentName) !== null && _b !== void 0 ? _b : 'unknown'}): condenseWhen called with an invalid trigger — ignoring`);
+                    return;
+                }
+                // First-wins: a handler declares its policy once per call. A second
+                // declaration for the same tool call is a handler bug, not a refinement.
+                if (this.condensePolicies.has(activeToolCallId)) {
+                    logger.error(`ChatDriver(${(_c = this.activeAgentName) !== null && _c !== void 0 ? _c : 'unknown'}): condenseWhen called more than once for the same tool call — keeping the first policy, ignoring this one`);
+                    return;
+                }
+                // Stamp the three clocks NOW (read straight off the driver — the handler
+                // runs during the current model-call's tool batch).
+                this.condensePolicies.set(activeToolCallId, {
+                    policy,
+                    iteration: this.modelCallSeq,
+                    turn: this.turnSeq,
+                    activation: this.currentActivation,
+                });
             } });
     }
     /**
@@ -937,7 +1040,7 @@ export class ChatDriver extends EventTarget {
      */
     invokeSubAgent(name, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             const subConfig = this.subAgentsMap.get(name);
             if (!subConfig) {
                 const available = [...this.subAgentsMap.keys()].join(', ') || '(none)';
@@ -960,7 +1063,13 @@ export class ChatDriver extends EventTarget {
                 ...contextMessages,
                 ...((_b = subConfig.primerHistory) !== null && _b !== void 0 ? _b : []),
             ];
-            const child = new ChatDriver(this.providerRegistry);
+            // Unique per-invocation id — reused for the lifecycle event bracket below —
+            // and a child session key derived from it. The child files its meta events
+            // under this own bucket (rather than the shared empty-key sink), so they can
+            // be harvested into THIS session on completion and then discarded.
+            const invocationId = crypto.randomUUID();
+            const childSessionKey = `${this.sessionKey}::sub:${invocationId}`;
+            const child = new ChatDriver(this.providerRegistry, {}, [], undefined, undefined, undefined, undefined, undefined, childSessionKey);
             // Mark before the first turn so the child forces tool use and reports a
             // typed failure (rather than user-facing text) if it never completes.
             child.markAsSubAgent();
@@ -994,9 +1103,6 @@ export class ChatDriver extends EventTarget {
             };
             child.addEventListener('history-updated', forwardTrace);
             child.addEventListener('provider-changed', forwardProviderChanged);
-            // Unique per-invocation id so listeners can pair start/stop reliably even
-            // when the same sub-agent runs multiple times in parallel.
-            const invocationId = crypto.randomUUID();
             const chatInputDuringExecution = options === null || options === void 0 ? void 0 : options.chatInputDuringExecution;
             const lifecycleDetail = { name, invocationId, chatInputDuringExecution };
             this.dispatchEvent(new CustomEvent('sub-agent-start', { detail: lifecycleDetail }));
@@ -1056,13 +1162,30 @@ export class ChatDriver extends EventTarget {
                 // settled) lifecycle, so the snapshot/completion reads below still work.
                 child.dispose();
                 this.dispatchEvent(new CustomEvent('sub-agent-stop', { detail: lifecycleDetail }));
+                // Capture the child's diagnostics into THIS session, then ALWAYS discard its
+                // transient bucket — done in the `finally` so an unexpected `sendMessage`
+                // rejection (which propagates out of this method) can't orphan the bucket in
+                // the registry, and a crashed sub-agent still leaves its turns/events behind.
+                // Forward the child's per-LLM-call snapshots so they show as `kind:'turn'`
+                // entries in the exported debug log, re-numbered under the activating parent turn.
+                this.forwardSubAgentSnapshots(child.getTurnSnapshots());
+                // Fold the sub-agent's high-value meta events (retries/errors/tool failures —
+                // see HARVESTED_SUBAGENT_EVENTS) into THIS session, preserving their original
+                // timestamps so they interleave within the subagent.started→completed/failed
+                // bracket. Each is breadcrumbed `"<parent> › <sub-agent>"`, composing for a
+                // nested sub-agent whose own breadcrumb the child already merged.
+                const parentName = (_c = this.activeAgentName) !== null && _c !== void 0 ? _c : '?';
+                const harvested = getMetaEvents(childSessionKey)
+                    .filter((e) => HARVESTED_SUBAGENT_EVENTS.has(e.type))
+                    .map((e) => {
+                    var _a;
+                    const existing = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.subAgent;
+                    return Object.assign(Object.assign({}, e), { detail: Object.assign(Object.assign({}, e.detail), { subAgent: `${parentName} › ${existing !== null && existing !== void 0 ? existing : name}` }) });
+                });
+                mergeMetaEvents(this.sessionKey, harvested);
+                clearSession(childSessionKey);
             }
             const trace = child.getHistory();
-            // Forward the child's per-LLM-call snapshots onto this (parent) driver's
-            // buffer so they show as `kind:'turn'` entries in the exported debug log,
-            // re-numbered under the activating parent turn. Runs for both success and
-            // failure so the sub-agent's turns are always visible.
-            this.forwardSubAgentSnapshots(child.getTurnSnapshots());
             if (timedOut) {
                 // Same failure shape as any other non-completion — the parent handler
                 // recovers on its existing `{ ok: false }` branch. Recorded under THIS
@@ -1081,7 +1204,7 @@ export class ChatDriver extends EventTarget {
             // provider ignored forced tool use and returned text). The previous
             // final-text fallback is intentionally gone — sub-agents return a
             // structured outcome only, and the parent handler decides how to recover.
-            const reason = (_d = (_c = child.getSubAgentFailure()) === null || _c === void 0 ? void 0 : _c.reason) !== null && _d !== void 0 ? _d : 'max_iterations';
+            const reason = (_e = (_d = child.getSubAgentFailure()) === null || _d === void 0 ? void 0 : _d.reason) !== null && _e !== void 0 ? _e : 'max_iterations';
             // Record under THIS (parent) driver's session so the failure lands on the
             // user-visible debug-log timeline — the child ran under its own session key.
             // This is also the only telemetry for the defensive default above, where the
@@ -1215,7 +1338,7 @@ export class ChatDriver extends EventTarget {
         this.toolHandlers = newHandlers;
     }
     /** Open a fold: push a stack frame, swap the tool set, return the response message. */
-    openFold(foldName, fold, args) {
+    openFold(foldName, fold, args, activeToolCallId) {
         // Shortcut dispatch: model passed inner tool args directly, e.g.
         // trading_tools({ search_trades: { side: "BUY" } })
         for (const key of Object.keys(args)) {
@@ -1229,7 +1352,7 @@ export class ChatDriver extends EventTarget {
                 const innerArgs = typeof args[key] === 'object' && args[key] !== null
                     ? args[key]
                     : {};
-                return innerHandler(innerArgs, this.buildHandlerContext()).then((r) => typeof r === 'string' ? r : JSON.stringify(r));
+                return innerHandler(innerArgs, this.buildHandlerContext(activeToolCallId)).then((r) => typeof r === 'string' ? r : JSON.stringify(r));
             }
         }
         // Normal two-step open
@@ -1308,6 +1431,10 @@ export class ChatDriver extends EventTarget {
             let firstLlmCall = !!currentInput;
             while (iterations < this.maxToolIterations) {
                 iterations += 1;
+                // Monotonic across the driver's life — the age clock. Unlike `iterations`,
+                // it is NOT reset per turn and NOT decremented for folds, so `age` keeps
+                // counting model-calls once a turn ends. (See the `modelCallSeq` field.)
+                this.modelCallSeq += 1;
                 // A cancel (or dispose) that landed while the previous iteration's tool
                 // batch was running takes effect here — before issuing another LLM call.
                 // An abort during the call itself is handled by the catch below.
@@ -1376,9 +1503,19 @@ export class ChatDriver extends EventTarget {
                 const primer = [...((_b = this.primerHistory) !== null && _b !== void 0 ? _b : []), ...(transientPrimer !== null && transientPrimer !== void 0 ? transientPrimer : [])];
                 const baseHistory = firstLlmCall ? this.history.slice(0, -1) : this.history;
                 firstLlmCall = false;
+                // Collapse stale tool payloads this agent declared via `condenseWhen`, then
+                // pipe through any externally-set transform (e.g. multi-agent masking).
+                // Both run on a copy — stored history is untouched.
+                const condensedHistory = applyCondensation([...baseHistory], this.condensePolicies, {
+                    modelCall: this.modelCallSeq,
+                    turn: this.turnSeq,
+                    // A call's activation has ended once a later activation is current — a
+                    // swap or release/complete both advance the counter.
+                    activationEnded: (activation) => activation < this.currentActivation,
+                }, (detail) => recordMetaEvent(this.sessionKey, 'context.condensed', detail));
                 const historyForProvider = this.providerHistoryTransform
-                    ? this.providerHistoryTransform([...baseHistory])
-                    : baseHistory;
+                    ? this.providerHistoryTransform(condensedHistory)
+                    : condensedHistory;
                 const historyForCall = [...primer, ...historyForProvider];
                 const systemPrompt = malformedAttempts > 0
                     ? `${baseSystemPrompt !== null && baseSystemPrompt !== void 0 ? baseSystemPrompt : ''}\n\nIMPORTANT: Use only the structured function-call API to invoke tools. Do not write Python code or use Python-style syntax to call tools.`
@@ -1589,7 +1726,7 @@ export class ChatDriver extends EventTarget {
                                 });
                                 return;
                             }
-                            const content = yield this.openFold(tc.name, fold, tc.args);
+                            const content = yield this.openFold(tc.name, fold, tc.args, tc.id);
                             executedById.set(tc.id, { toolCallId: tc.id, content });
                             // Fold open/close does NOT count as a real iteration — decrement to compensate
                             iterations -= 1;
@@ -1700,7 +1837,7 @@ export class ChatDriver extends EventTarget {
                         // Real tool execution
                         try {
                             const traceCapture = {};
-                            const result = yield handler(tc.args, this.buildHandlerContext(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,