@genesislcap/ai-assistant 15.84.2 → 15.85.0

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

@@ -8,8 +8,10 @@ import { transformHistoryForAgent } from '../../utils/history-transform';
 import { logger } from '../../utils/logger';
 import { messageUsage } from '../../utils/sum-usage';
 import { BaseDriverDecorator } from '../ai-driver/base-driver-decorator';
-import { ChatDriver, REQUEST_CONTINUATION_TOOL, } from '../chat-driver/chat-driver';
+import { ChatDriver } from '../chat-driver/chat-driver';
+import { frameCopy, handBackNote, handOffNote, parseHandOffFrames } from './hand-off';
 const DEFAULT_MAX_HANDOFFS = 3;
+const DEFAULT_MAX_HAND_OFF_DEPTH = 1;
 const DEFAULT_CLASSIFIER_HISTORY_LENGTH = 4;
 const DEFAULT_CLASSIFIER_RETRIES = 2;
 /**
@@ -24,30 +26,27 @@ const DEFAULT_CLASSIFIER_RETRIES = 2;
  */
 const CLASSIFIER_MESSAGE_CHARS = 600;
 const CLASSIFIER_TRANSCRIPT_CHARS = 3000;
-const REQUEST_CONTINUATION_DEFINITION = {
-    name: REQUEST_CONTINUATION_TOOL,
-    description: "Call this when you have completed your part of the task but fulfilling the user's full request requires capabilities outside your domain. Do not call this if you can complete the request yourself. Pass a plain-language description of what still needs to be done — another specialist will be selected automatically.",
-    parameters: {
-        type: 'object',
-        required: ['summary', 'remaining_task'],
-        properties: {
-            summary: {
-                type: 'string',
-                description: 'What you found or did — passed as context to the next specialist.',
-            },
-            remaining_task: {
-                type: 'string',
-                description: 'What still needs to be done, in plain language. Used to route to the right specialist.',
-            },
-        },
-    },
-};
 function isSpecialist(agent) {
     return !agent.fallback;
 }
 function isFallback(agent) {
     return agent.fallback === true;
 }
+/** Whether an agent holds a flow of its own, which takes the flow lock when it activates. */
+function isStateful(agent) {
+    return !!(agent.onActivate || agent.onDeactivate);
+}
+/** Run an agent's hand-off hook, logging rather than propagating a throw, as the session does. */
+function callHandOffHook(agent, hook, run) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield run();
+        }
+        catch (e) {
+            logger.warn(`OrchestratingDriver: ${hook}("${agent}") threw:`, e);
+        }
+    });
+}
 /**
  * Flatten a `contextReserve` declaration to the two numbers the gate reads
  * (GENC-1582), or `undefined` when the agent declared nothing.
@@ -95,7 +94,7 @@ export const UNROUTABLE_PLACEHOLDER = '{{unroutable}}';
  * A fallback prompt written by a consumer reliably covers two cases — small talk, and a request
  * that belongs to a specialist — because those are the ones you think of when you write it. The
  * case it exists FOR is the third: a substantive request that no specialist covers, and no way to
- * act on it, because a fallback holds no tools and is denied the continuation tool as a leaf.
+ * act on it, because a fallback holds no tools.
  *
  * Create's fallback prompt is the worked example (GENC-1573). It covered chit-chat and
  * "out of scope, here are the specialists", said nothing about a request nothing can serve, and
@@ -143,24 +142,6 @@ function buildFallbackSystemPrompt(fallback, specialists) {
     }
     return `You are a helpful assistant. You cannot directly help with the user's request, but the following specialists are available:\n\n${agentList}\n\nPolitely let the user know what you can help with and invite them to rephrase their request.\n\n${UNROUTABLE_INSTRUCTION}`;
 }
-/**
- * The note a handoff's continuation ends on, so the request closes on a user turn (see the call in
- * `runOrchestratedTurn`).
- *
- * The fallback's note names no work, because its routing note already says the work is nobody's
- * here, and the same work restated last would read as a work order — the shape that drew blank
- * turns from it (GENC-1573). A specialist gets what remains or, when the agent handing off did not
- * say, the user's request, which is also what the re-classify routed on.
- */
-function handoffTailNote(agent, remainingTask) {
-    if (isFallback(agent)) {
-        return '[Hand-off]: no specialist here can take on what remains. Reply to the user now, as the routing note says.';
-    }
-    const work = remainingTask === null || remainingTask === void 0 ? void 0 : remainingTask.trim();
-    return work
-        ? `[Hand-off]: the previous agent passed the rest of this request to you. What remains: ${work}`
-        : "[Hand-off]: the previous agent passed the rest of this request to you without saying what remains. Carry on with the user's request above.";
-}
 /**
  * Orchestrates multiple specialist agents. Sits between `FoundationAiAssistant`
  * and `ChatDriver`, classifying each user message and routing it to the right
@@ -202,32 +183,42 @@ export class OrchestratingDriver extends BaseDriverDecorator {
         return this.agentSession.getActive();
     }
     constructor(providerRegistry, agents, options = {}) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         super(OrchestratingDriver.createInner(providerRegistry, agents, options));
         this.providerRegistry = providerRegistry;
         this.agents = agents;
         /**
-         * Set by `cancel()` for the duration of a `sendMessage` run. Breaks the
-         * handoff loop so we don't classify or start another agent turn after the
-         * user stops. Reset at the start of each `sendMessage`.
+         * Set by `cancel()` for the duration of a run. Stops it before the next agent
+         * runs — a hand-off's target or a hand-back's caller — so nothing more is asked
+         * of a provider after the user stops. Reset at the start of each run.
          */
         this.cancelled = false;
         /**
          * Whether the CURRENT turn's user message has reached the inner driver's
          * history. False through the pre-first-turn classify (where the only echo of
          * the message is an optimistic `history-updated` dispatch), true from the
-         * moment `chatDriver.sendMessage` is entered — including through every later
-         * handoff classify. Read by the budget-wall catch in `sendMessage` to decide
+         * moment `chatDriver.sendMessage` is entered. Read by the budget-wall catch in
+         * `sendMessage` to decide
          * whether `reportBudgetExhausted` must append the message itself: appending
          * it when already appended duplicated it; not appending it when unappended
          * made it vanish. Reset at the top of each `runOrchestratedTurn`.
          */
         this.userMessageAppended = false;
+        /**
+         * The hand-offs in progress, oldest first (GENC-1737). The top frame's target is the active agent
+         * and holds the flow lock; each caller waits, suspended, for the target above it. Saved with the
+         * session through {@link OrchestratingDriver.getHandOffStack}.
+         */
+        this.handOffStack = [];
+        /** Hand-offs and hand-backs this user turn, against `maxHandoffs`. */
+        this.handOffsThisTurn = 0;
         this.sessionKey = (_a = options.sessionKey) !== null && _a !== void 0 ? _a : '';
         this.maxHandoffs = (_b = options.maxHandoffs) !== null && _b !== void 0 ? _b : DEFAULT_MAX_HANDOFFS;
+        this.maxHandOffDepth = (_c = options.maxHandOffDepth) !== null && _c !== void 0 ? _c : DEFAULT_MAX_HAND_OFF_DEPTH;
+        this.chatDriver.setHandOffCheck((request, caller) => this.checkHandOff(request, caller));
         this.classifierHistoryLength =
-            (_c = options.classifierHistoryLength) !== null && _c !== void 0 ? _c : DEFAULT_CLASSIFIER_HISTORY_LENGTH;
-        this.classifierRetries = (_d = options.classifierRetries) !== null && _d !== void 0 ? _d : DEFAULT_CLASSIFIER_RETRIES;
+            (_d = options.classifierHistoryLength) !== null && _d !== void 0 ? _d : DEFAULT_CLASSIFIER_HISTORY_LENGTH;
+        this.classifierRetries = (_e = options.classifierRetries) !== null && _e !== void 0 ? _e : DEFAULT_CLASSIFIER_RETRIES;
         // Specialists drive the classifier. `excludeFromClassifier` agents are still
         // resolvable by name (so manual pinning works) but never auto-routed.
         this.specialists = agents.filter(isSpecialist).filter((a) => !a.excludeFromClassifier);
@@ -257,7 +248,7 @@ export class OrchestratingDriver extends BaseDriverDecorator {
             activityBus: options.activityBus,
             budgetExhaustedMessage: options.budgetExhaustedMessage,
             aiServiceErrorMessages: options.aiServiceErrorMessages,
-            // A release ends this driver's handoff loop, so it acts on the flag itself; see the option.
+            // A release can hand back to a waiting caller, so this driver acts on the flag itself.
             deferAgentRelease: true,
         });
     }
@@ -293,15 +284,10 @@ export class OrchestratingDriver extends BaseDriverDecorator {
                 // the driver that owns the transcript, which appends the user-facing copy
                 // and returns the same terminal result an in-loop wall would.
                 //
-                // The user's message rides along ONLY while it is genuinely unappended.
-                // `classify()` runs at two seams: before the first agent turn — where the
-                // `history-updated` dispatch in `runOrchestratedTurn` is optimistic only
-                // and the real append lives inside `chatDriver.sendMessage`, which the
-                // wall prevents from ever running — and again at the END of every handoff
-                // iteration, by which point `chatDriver.sendMessage` HAS appended it.
-                // Passing the message unconditionally duplicated it on the handoff seam:
-                // `['user','assistant','tool','user','assistant']` in the transcript, the
-                // snapshot, and the history sent to the model once the budget is raised.
+                // The user's message rides along ONLY while it is genuinely unappended: the
+                // `history-updated` dispatch in `runOrchestratedTurn` is optimistic only, and
+                // the real append lives inside `chatDriver.sendMessage`, which a wall in the
+                // classify prevents from ever running.
                 const pendingUserMessage = this.userMessageAppended
                     ? undefined
                     : Object.assign(Object.assign({ role: 'user', content: input }, (attachments ? { attachments } : {})), delegated);
@@ -318,15 +304,20 @@ export class OrchestratingDriver extends BaseDriverDecorator {
     }
     runOrchestratedTurn(input, attachments, options, delegated) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             this.cancelled = false;
             this.userMessageAppended = false;
+            this.handOffsThisTurn = 0;
+            // A restored hand-back whose resumed turn the host withdrew is over: its caller is active.
+            if ((_a = this.pendingHandBack) === null || _a === void 0 ? void 0 : _a.resumed)
+                this.pendingHandBack = undefined;
             const history = this.chatDriver.getHistory();
             // Emit the user message immediately so the UI reflects it during the classify
             // round-trip — without this the chat appears frozen until classify returns.
             this.dispatchEvent(new CustomEvent('history-updated', {
                 detail: [...history, Object.assign({ role: 'user', content: input, attachments }, delegated)],
             }));
-            // What the turn is routed on — and routed on again after a handoff that names no remaining task.
+            // What the turn is routed on.
             const routingInput = delegated.delegate
                 ? frameDelegatedContent(input, delegated.delegateFraming)
                 : input;
@@ -346,151 +337,107 @@ export class OrchestratingDriver extends BaseDriverDecorator {
             else {
                 routed = yield this.classify(routingInput, history, this.activeAgent);
             }
-            let currentAgent = routed.agent;
-            let isHandoff = false;
-            let handoffs = 0;
-            let handoffSummary = '';
-            let remainingTask = '';
-            /**
-             * Specialists that have already handled part of THIS turn and handed on. Fed to each
-             * re-classify so the remaining work cannot be routed back to an agent that just declined it
-             * — see the `excludeAgents` parameter on `classify`.
-             */
-            const attempted = [];
-            // The outcome of the agent turn that ENDS the loop — see the return below.
             let lastResult;
-            while (true) {
-                // Cancelled before a (next) agent turn started — e.g. during classify.
-                // The chat driver appends its own "Stopped." marker when a turn it was
-                // running is cancelled, so we just stop here without a duplicate.
-                if (this.cancelled)
-                    break;
-                // oxlint-disable-next-line no-await-in-loop
-                yield this.installAgent(currentAgent, pin);
-                // A Stop that landed while the agent was being installed, after the check above. The inner
-                // driver was idle, so nothing else would stop it: the call below would run the next agent,
-                // and a continuation would even give it a scope of its own.
-                if (this.cancelled)
-                    break;
-                let result;
-                if (isHandoff) {
-                    const contextPrimer = handoffSummary
-                        ? [{ role: 'user', content: `[Context from previous agent]: ${handoffSummary}` }]
-                        : [];
-                    // A handoff that reaches the fallback is the one case where routing has genuinely run out
-                    // of options, and it used to be the worst-served: the fallback holds no tools (it is
-                    // denied the continuation tool as a leaf), so it was handed a remaining task phrased as
-                    // work — "debug and fix the null pointer in the event handler" — with no instruction for
-                    // what to do when nothing can. Measured (GENC-1573), it answered with three consecutive
-                    // blank turns.
-                    //
-                    // Naming the situation is what it was missing. The remaining task and the fact that no
-                    // specialist covers it are both real, useful things to tell a user, and an agent told
-                    // them plainly has something to say instead of nothing. Transient primer, so it steers
-                    // this turn without becoming a permanent instruction in the transcript.
-                    if (isFallback(currentAgent)) {
-                        // `remainingTask` is model-supplied — it arrives from `request_continuation`'s
-                        // `remaining_task` through an unvalidated cast — and this is the one primer where a
-                        // degraded input is already known to be in play, since it exists because the fallback
-                        // answered this path with three blank turns. Name the situation without the clause
-                        // rather than render "the remaining work: undefined".
-                        const work = (remainingTask === null || remainingTask === void 0 ? void 0 : remainingTask.trim()) || (handoffSummary === null || handoffSummary === void 0 ? void 0 : handoffSummary.trim());
-                        contextPrimer.push({
-                            role: 'user',
-                            content: (work
-                                ? `[Routing note]: no specialist is available for the remaining work: ${work}\n`
-                                : '[Routing note]: no specialist is available for the work that remains.\n') +
-                                'Tell the user plainly what was established, that this part falls outside what any ' +
-                                'specialist here can do, and what they could do next. Do not claim you will do it ' +
-                                'yourself, and do not return an empty response.',
-                        });
-                    }
-                    // The primer LEADS the request, and the history after it closes on the previous agent's
-                    // turn: its `request_continuation` call, flattened to assistant prose for an agent that did
-                    // not make it (`transformHistoryForAgent`). A request ending on an assistant turn is a
-                    // prefill, which Anthropic refuses outright: a handoff on Claude ended in "Sorry, something
-                    // went wrong" unless the agent reached had a tail context of its own, and Gemini, which
-                    // tolerates it, never showed it. The tail note lands after the history as a user turn. It
-                    // rides the first model call only, so the primer stays where it is: it has to outlast that
-                    // call, for the whole tool loop.
-                    // oxlint-disable-next-line no-await-in-loop
-                    result = yield this.chatDriver.continueFromHistory(contextPrimer, {
-                        tailNote: handoffTailNote(currentAgent, remainingTask),
-                    });
-                }
-                else {
-                    // From here the inner driver owns the user message — it appends it as
-                    // its first act, before any provider call can throw. Set BEFORE the
-                    // await so a wall raised anywhere inside the turn (or on a later
-                    // handoff classify) sees the append as done.
+            // Cancelled during the classify. The chat driver appends its own "Stopped." marker when a turn
+            // it was running is cancelled, so we just stop here without a duplicate.
+            if (!this.cancelled) {
+                yield this.endOrphanedHandOffs(routed.agent);
+                yield this.installAgent(routed.agent);
+                // A Stop that landed while the agent was being installed. The inner driver was idle, so
+                // nothing else would stop it.
+                if (!this.cancelled) {
+                    // From here the inner driver owns the user message — it appends it as its first act,
+                    // before any provider call can throw. Set BEFORE the await so a wall raised anywhere
+                    // inside the turn sees the append as done.
                     this.userMessageAppended = true;
-                    // oxlint-disable-next-line no-await-in-loop
-                    result = yield this.chatDriver.sendMessage(input, attachments, options);
-                }
-                lastResult = result;
-                // Release check: a stateful agent called `releaseAgent` from a terminal
-                // tool handler. Fire onDeactivate, clear the pin, drop the user back to
-                // classifier-mode. The LLM has already emitted its final wrap-up message
-                // by the time we get here — release is purely a teardown.
-                if (this.chatDriver.getAgentReleaseRequested()) {
-                    // oxlint-disable-next-line no-await-in-loop
-                    yield this.releaseActiveAgent();
-                    break;
-                }
-                // Pinned agents never hand off — the continuation tool is filtered out in
-                // installAgent, but this guards against a model hallucinating a handoff result.
-                if (result.reason !== 'agent-handoff' || isFallback(currentAgent) || pinned) {
-                    break;
+                    lastResult = yield this.carryOn(yield this.chatDriver.sendMessage(input, attachments, options));
                 }
-                // A Stop that landed in a batch which also handed off. The loop's own check would stop the
-                // next agent, but only after the classify that picks it: a provider call after the user
-                // pressed Stop.
-                if (this.cancelled)
-                    break;
-                handoffs += 1;
-                if (handoffs > this.maxHandoffs) {
-                    this.appendInlineMessage(`I wasn't able to fully complete your request — the task required more hand-offs between specialists than allowed. Please try breaking your request into smaller steps.`);
-                    break;
-                }
-                handoffSummary = result.summary;
-                remainingTask = result.remainingTask;
-                isHandoff = true;
-                if (isSpecialist(currentAgent) && !attempted.includes(currentAgent.name)) {
-                    attempted.push(currentAgent.name);
-                }
-                const updatedHistory = this.chatDriver.getHistory();
-                this.dispatchEvent(new CustomEvent('orchestrating-start'));
-                // The tool schema requires `remaining_task`, but nothing holds a model to `required`: Claude
-                // handed off with a `summary` alone, and an empty task is a classifier request with no
-                // message in it, which Anthropic refuses — on every attempt, so the turn fell to the fallback
-                // as `classifier-failed`. Route on the request the turn began with instead. The agent that
-                // just declined it is off the ballot, so the question put is the right one: who else.
-                // oxlint-disable-next-line no-await-in-loop
-                routed = yield this.classify((remainingTask === null || remainingTask === void 0 ? void 0 : remainingTask.trim()) || routingInput, updatedHistory, undefined, attempted);
-                currentAgent = routed.agent;
             }
-            // The orchestrated turn reports the outcome of the agent turn that ENDED it.
-            // The hardcoded `{ reason: 'done' }` that used to live here made every
-            // typed failure unreachable for an agents-configured host — including
-            // `'budget-exhausted'`, which the element latches its blocked state off.
-            //
-            // "Last wins" cannot hide an earlier failure behind a later success: a
-            // failing inner turn always ends the loop, because the loop only continues
-            // on `reason === 'agent-handoff'`. The two breaks that hold a non-'done'
-            // result (the handoff cap, and the pinned/fallback break) both carry
-            // `'agent-handoff'`, which is an internal routing protocol that must never
-            // escape to the host — the collapse below strips it. A cancel before the
-            // first turn leaves `lastResult` undefined; the release break returns the
-            // inner turn's real result, which is correct, because that turn ran.
-            // A Stop before any agent turn took the message — in the first classify, or the first agent's
-            // install — leaves it shown only by the optimistic dispatch above, and it would vanish on the
-            // next update and from a reload. Kept, as the budget wall keeps it (see sendMessage).
+            // A Stop before any agent turn took the message — in the classify, or the agent's install —
+            // leaves it shown only by the optimistic dispatch above, and it would vanish on the next update
+            // and from a reload. Kept, as the budget wall keeps it (see sendMessage).
             if (this.cancelled && !this.userMessageAppended) {
                 this.chatDriver.reportStoppedBeforeTurn(Object.assign(Object.assign({ role: 'user', content: input }, (attachments ? { attachments } : {})), delegated));
             }
-            return (lastResult === null || lastResult === void 0 ? void 0 : lastResult.reason) === 'done' ? lastResult : { reason: 'done' };
+            // The outcome of the agent call that ended the turn; a cancel before the first leaves none.
+            return lastResult !== null && lastResult !== void 0 ? lastResult : { reason: 'done' };
+        });
+    }
+    /**
+     * Act on what the agent call that just ended asked for, and run the next agent in the same user
+     * turn while there is one (GENC-1737): a `handOff` runs its target with the brief, and a target
+     * that releases hands back to its caller. Returns the last call's result.
+     *
+     * A failed call ends the turn there, as a Stop does: what it asked for still happens, and the
+     * next agent runs on the next message. Running it now would meet the same wall (a budget, a
+     * refused account, a full context window), or build on a reply that never came.
+     */
+    carryOn(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let last = result;
+            let tailNote = yield this.afterAgentCall();
+            while (tailNote !== undefined && !this.cancelled && !last.failureReason) {
+                // oxlint-disable-next-line no-await-in-loop
+                last = yield this.chatDriver.continueFromHistory(undefined, { tailNote });
+                // oxlint-disable-next-line no-await-in-loop
+                tailNote = yield this.afterAgentCall();
+            }
+            return last;
+        });
+    }
+    /**
+     * After one agent call: start the hand-off it asked for, or release it and, when it was a
+     * hand-off's target, hand back. Returns the tail note for the agent to run next, or `undefined`
+     * when the turn ends here.
+     *
+     * A plain target hands back when its call ends, released or not, as a plain agent is done once
+     * it has answered. A stateful one holds the hand-off until it releases, as it holds its flow.
+     */
+    afterAgentCall() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = this.chatDriver.getHandOffRequest();
+            if (request)
+                return this.startHandOff(request);
+            const active = this.agentSession.getActive();
+            if (!active)
+                return undefined;
+            const frame = this.topFrameFor(active.name);
+            const released = this.chatDriver.getAgentReleaseRequested();
+            if (!released && !(frame && !isStateful(active))) {
+                if (!isStateful(active))
+                    this.endPlainTurn(active);
+                return undefined;
+            }
+            if (!frame) {
+                yield this.releaseActiveAgent();
+                return undefined;
+            }
+            // On the frame before the release, whose `onDeactivate` may take a while: a save in between
+            // then hands back after a reload, rather than leaving a frame nothing ends.
+            frame.outcome = this.outcomeOf(frame);
+            yield this.releaseActiveAgent();
+            return this.handBack(frame, frame.outcome);
         });
     }
+    /** How the target of `frame` finished: with `completeHandOff`, or a release and its last reply. */
+    outcomeOf(frame) {
+        const completion = this.chatDriver.getHandOffCompletion();
+        if (completion) {
+            return Object.assign({ kind: 'completed', message: completion.message }, (completion.data !== undefined && { data: completion.data }));
+        }
+        const finalReply = this.lastReply(frame);
+        return Object.assign({ kind: 'released' }, (finalReply ? { message: finalReply } : {}));
+    }
+    /**
+     * A plain agent is done once it has answered (GENC-1737): the data a one-way hand-off gave it ends
+     * with its turn, and so does a flow lock no hand-off holds, such as one a restore left on a
+     * target whose hand-off it could not resume.
+     */
+    endPlainTurn(agent) {
+        this.agentSession.setHandOffData(agent.name, undefined);
+        if (this.agentSession.getFlowOwner() === agent.name)
+            this.agentSession.dropFlowLock();
+    }
     /** {@inheritDoc AiDriver.canRestoreFlowOwner} */
     canRestoreFlowOwner(agentName) {
         return this.agents.some((a) => a.name === agentName);
@@ -514,6 +461,8 @@ export class OrchestratingDriver extends BaseDriverDecorator {
      */
     resumeRestoredFlow(resumeNote) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.pendingHandBack)
+                return this.resumeHandBack(resumeNote);
             // The FLOW owner only — not a bare user pin. Only a stateful agent holds a flow, and only its
             // state was restored; activating a pinned plain agent here would do nothing useful.
             const owner = this.agentSession.getFlowOwner();
@@ -521,12 +470,30 @@ export class OrchestratingDriver extends BaseDriverDecorator {
             if (!agent)
                 return undefined;
             this.cancelled = false;
+            this.handOffsThisTurn = 0;
             yield this.installAgent(agent);
             if (!resumeNote || agent.resumeOnRestore === false || this.cancelled)
                 return undefined;
-            const result = yield this.chatDriver.continueFromHistory(undefined, { tailNote: resumeNote });
-            yield this.releaseIfRequested();
-            return result;
+            return this.carryOn(yield this.chatDriver.continueFromHistory(undefined, { tailNote: resumeNote }));
+        });
+    }
+    /**
+     * The hand-back a restore found due (GENC-1737). The first call, inside the host's restore gate,
+     * makes the caller active again and tells it the outcome; the call with the note runs its turn.
+     */
+    resumeHandBack(note) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pending = this.pendingHandBack;
+            this.cancelled = false;
+            if (!pending.resumed) {
+                pending.resumed = true;
+                yield this.handBack(pending.frame, pending.frame.outcome);
+            }
+            if (!note || this.cancelled)
+                return undefined;
+            this.pendingHandBack = undefined;
+            this.handOffsThisTurn = 0;
+            return this.carryOn(yield this.chatDriver.continueFromHistory(undefined, { tailNote: note }));
         });
     }
     /**
@@ -536,17 +503,9 @@ export class OrchestratingDriver extends BaseDriverDecorator {
      */
     continueFromHistory(transientPrimer, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const result = yield this.chatDriver.continueFromHistory(transientPrimer, options);
-            yield this.releaseIfRequested();
-            return result;
-        });
-    }
-    /** Release the flow if the turn that just ended asked to, and an agent is still active to release. */
-    releaseIfRequested() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.chatDriver.getAgentReleaseRequested() && this.agentSession.getActive()) {
-                yield this.releaseActiveAgent();
-            }
+            this.cancelled = false;
+            this.handOffsThisTurn = 0;
+            return this.carryOn(yield this.chatDriver.continueFromHistory(transientPrimer, options));
         });
     }
     /**
@@ -555,22 +514,20 @@ export class OrchestratingDriver extends BaseDriverDecorator {
      * Two cases, because routing has two modes and they need opposite answers.
      */
     getContextReserve() {
-        // LOCKED — a user pin or a flow-owner lock. `handleTurn` routes straight to
-        // this agent and the handoff branch at the bottom of the routing loop refuses
-        // to route away while a lock is held, so no other agent's headroom can come
-        // into play until it clears. Its reserve is the whole requirement.
+        // LOCKED — a user pin or a flow-owner lock. The turn routes straight to this
+        // agent, so no other agent's headroom can come into play until it clears,
+        // unless it hands off. Its reserve is the whole requirement.
         const locked = this.resolvePinnedAgent();
         if (locked) {
             const reserve = normalizeContextReserve(locked.contextReserve);
             return reserve == null ? undefined : Object.assign(Object.assign({}, reserve), { agentName: locked.name, basis: 'locked' });
         }
-        // AUTOMATIC — the classifier picks a specialist, may fall through to the
-        // fallback, and may hand off and re-classify more than once inside the one
-        // turn. Any of them could be the agent that runs, and the send is allowed or
-        // refused before we know which, so the requirement is the largest reserve
+        // AUTOMATIC — the classifier picks a specialist, or falls through to the
+        // fallback. Any of them could be the agent that runs, and the send is allowed
+        // or refused before we know which, so the requirement is the largest reserve
         // among them: the turn has to fit whichever way it routes.
         //
-        // The MAX, not the sum, even though a handoff chain really does add each leg's
+        // The MAX, not the sum, even though a hand-off chain really does add each leg's
         // growth on top of the last. Summing every reachable agent would reserve room
         // for a journey nobody is taking and strand most of the window on a two-line
         // question; the mid-loop context guard is what bounds a chain that does run
@@ -603,53 +560,32 @@ export class OrchestratingDriver extends BaseDriverDecorator {
         }
         return winner ? Object.assign(Object.assign({}, winner), { agentName, basis: 'reachable-max' }) : undefined;
     }
-    /**
-     * `pin` stands in for the user-pin when given, as for
-     * {@link OrchestratingDriver.resolvePinnedAgent}.
-     */
-    installAgent(agent, pin) {
+    /** Make `agent` active through the session, firing its hooks, and install it. */
+    installAgent(agent) {
         return __awaiter(this, void 0, void 0, function* () {
             // The transition — handoff record, lifecycle hooks, restored state, flow lock — belongs to
-            // the session, and the inner driver raises its events (GENC-1485). What is left below is this
-            // driver's own job: what the agent may route to, and what the transcript says happened.
+            // the session, and the inner driver raises its events (GENC-1485).
             const { previousAgent } = yield this.agentSession.activate(agent);
-            // Terminal agents do not get the cross-agent handoff tool. Four cases:
-            //   • fallback     — already a leaf; handoff would loop
-            //   • user-pinned  — user explicitly selected this agent; do not auto-route away
-            //   • flow-owner   — a stateful flow is mid-stream; do not auto-route away
-            //   • stateful     — agents with lifecycle hooks own state for the duration of
-            //                    their flow. Initiating a handoff mid-flow would abandon
-            //                    that state with no clean exit and dump the user into the
-            //                    classifier mid-machine. Capture the tool loop until the
-            //                    user (or the agent itself, via `releaseAgent`) releases.
-            const isTerminal = isFallback(agent) ||
-                (pin === undefined ? this.agentSession.getPinned() : pin) !== null ||
-                this.agentSession.getFlowOwner() !== null ||
-                !!(agent.onActivate || agent.onDeactivate);
-            let agentToApply = agent;
-            if (!isTerminal) {
-                const declaredTools = agent.toolDefinitions;
-                agentToApply = Object.assign(Object.assign({}, agent), { toolDefinitions: typeof declaredTools === 'function'
-                        ? (ctx) => __awaiter(this, void 0, void 0, function* () {
-                            return [
-                                ...(yield declaredTools(ctx)),
-                                REQUEST_CONTINUATION_DEFINITION,
-                            ];
-                        })
-                        : [...(declaredTools !== null && declaredTools !== void 0 ? declaredTools : []), REQUEST_CONTINUATION_DEFINITION] });
-            }
-            if (previousAgent && previousAgent.name !== agent.name) {
-                const rawHistory = this.chatDriver.getHistory();
-                this.chatDriver.loadHistory([
-                    ...rawHistory,
-                    { role: 'system-event', content: agent.name, timestamp: new Date().toISOString() },
-                ]);
-            }
-            this.chatDriver.setProviderHistoryTransform((h) => transformHistoryForAgent(h, agent.name));
-            this.chatDriver.installAgent(agentToApply);
-            this.dispatchEvent(new CustomEvent('orchestrating-stop'));
+            this.applyAgent(agent, previousAgent === null || previousAgent === void 0 ? void 0 : previousAgent.name);
         });
     }
+    /**
+     * Install an agent the session has already made active on the inner driver: the transcript's
+     * divider when another agent spoke before it, and its own view of the history. What is left here
+     * is this driver's own job, the transcript; the session owns the lifecycle.
+     */
+    applyAgent(agent, previousName) {
+        if (previousName && previousName !== agent.name) {
+            const rawHistory = this.chatDriver.getHistory();
+            this.chatDriver.loadHistory([
+                ...rawHistory,
+                { role: 'system-event', content: agent.name, timestamp: new Date().toISOString() },
+            ]);
+        }
+        this.chatDriver.setProviderHistoryTransform((h) => transformHistoryForAgent(h, agent.name));
+        this.chatDriver.installAgent(agent);
+        this.dispatchEvent(new CustomEvent('orchestrating-stop'));
+    }
     /**
      * Release the current stateful agent: fire `onDeactivate` and clear the flow-owner lock. The
      * inner driver raises the events from the session's transition, so the host (and Redux) reflect
@@ -666,10 +602,277 @@ export class OrchestratingDriver extends BaseDriverDecorator {
             yield this.agentSession.release();
         });
     }
+    /** The agent named `name` as this driver installs it: the fallback with its prompt built. */
+    agentNamed(name) {
+        var _a;
+        if (((_a = this.fallback) === null || _a === void 0 ? void 0 : _a.name) === name)
+            return this.fallback;
+        return this.agents.find((a) => a.name === name);
+    }
+    /**
+     * End the hand-offs when a turn runs an agent other than the top target (GENC-1737): the lock
+     * that kept turns on the target was taken away, by a host clearing `flowOwnerAgentName` say,
+     * and its caller would otherwise wait for good.
+     */
+    endOrphanedHandOffs(agent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const top = this.handOffStack[this.handOffStack.length - 1];
+            if (!top || top.outcome || top.target === agent.name)
+                return;
+            yield this.unwindHandOffs('cleared');
+            // No teardown follows, as one does on Clear, so the callers that waited are deactivated here.
+            yield this.agentSession.endSuspended();
+        });
+    }
+    /**
+     * Check a handler's `handOff` when it is made (GENC-1737), so a refusal reaches its model. Checked
+     * against the agents and the stack as they are now; the hand-off itself starts after the call.
+     */
+    checkHandOff(request, caller) {
+        var _a;
+        const target = this.agentNamed(request.to);
+        if (!target)
+            return { ok: false, reason: 'unknown-agent' };
+        const allowed = (_a = this.agents.find((a) => a.name === caller)) === null || _a === void 0 ? void 0 : _a.handOffTargets;
+        if (allowed && !allowed.includes(target.name))
+            return { ok: false, reason: 'not-allowed' };
+        if (target.name === caller ||
+            this.handOffStack.some((f) => f.caller === target.name || f.target === target.name)) {
+            return { ok: false, reason: 're-entry' };
+        }
+        if (request.returnTo !== false && this.handOffStack.length >= this.maxHandOffDepth) {
+            return { ok: false, reason: 'depth' };
+        }
+        if (this.handOffsThisTurn >= this.maxHandoffs)
+            return { ok: false, reason: 'limit' };
+        return { ok: true };
+    }
+    /**
+     * Start the hand-off the agent call just made, and return the target's tail note (GENC-1737).
+     *
+     * - `returnTo` (the default): push a frame. The caller waits without being deactivated, its
+     *   `agentEnd` payloads suspended, and the target takes the flow lock.
+     * - One-way from a hand-off's target: that frame's caller now waits for the new target instead.
+     * - One-way with nobody waiting: a plain switch, the caller deactivated as on any swap.
+     *
+     * Either way the brief is recorded as a message the caller sent on the user's behalf.
+     */
+    startHandOff(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const caller = this.agentSession.getActive();
+            const target = this.agentNamed(request.to);
+            if (!caller || !target)
+                return undefined;
+            this.handOffsThisTurn += 1;
+            const frame = Object.assign(Object.assign({ id: crypto.randomUUID(), caller: caller.name, target: target.name, returnTo: request.returnTo !== false, message: request.message }, (request.data !== undefined && { data: request.data })), { startedAt: new Date().toISOString() });
+            const top = this.handOffStack[this.handOffStack.length - 1];
+            if (frame.returnTo) {
+                this.handOffStack.push(frame);
+                yield callHandOffHook(caller.name, 'onHandOffStart', () => { var _a; return (_a = caller.onHandOffStart) === null || _a === void 0 ? void 0 : _a.call(caller, frameCopy(frame)); });
+                this.chatDriver.suspendActivation(caller.name);
+                yield this.agentSession.handOff(target, { suspendCaller: true });
+            }
+            else if ((top === null || top === void 0 ? void 0 : top.target) === caller.name) {
+                top.target = target.name;
+                yield this.agentSession.handOff(target, { suspendCaller: false });
+            }
+            else {
+                yield this.agentSession.activate(target);
+            }
+            this.applyAgent((_a = this.agentSession.getActive()) !== null && _a !== void 0 ? _a : target, caller.name);
+            // For the target's handlers, one-way or not, until its activation ends. A copy of its own.
+            this.agentSession.setHandOffData(target.name, frameCopy(frame).data);
+            this.recordDelegated(caller.name, frame.message, `Handed over by ${caller.name}`);
+            this.dispatchEvent(new CustomEvent('handoff-started', { detail: frameCopy(frame) }));
+            return handOffNote(caller.name);
+        });
+    }
+    /**
+     * Hand back to `frame`'s caller with `outcome`, and return its tail note (GENC-1737). The outcome
+     * is kept on the frame until the caller is active again and its `onHandOffReturn` has run, so a
+     * reload in between still hands back; the frame then goes, before the caller's model call.
+     */
+    handBack(frame, outcome) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            frame.outcome = outcome;
+            this.handOffsThisTurn += 1;
+            const remaining = this.handOffStack.filter((f) => f !== frame);
+            const caller = this.agentNamed(frame.caller);
+            if (!caller) {
+                this.handOffStack = remaining;
+                this.unwound(frame, 'agent-removed');
+                return undefined;
+            }
+            yield this.agentSession.resume(caller, remaining.length > 0 || isStateful(caller));
+            // The live instance, when it waited live: its closures hold its state.
+            const live = (_a = this.agentSession.getActive()) !== null && _a !== void 0 ? _a : caller;
+            this.applyAgent(live, frame.target);
+            // In the transcript, as the brief is, so the caller reads it whenever it next runs: in this
+            // turn, or on the next message when this turn stops or a reload does not resume it.
+            if (outcome.kind === 'completed' && outcome.message) {
+                this.recordDelegated(frame.target, outcome.message, `Handed back by ${frame.target}`);
+            }
+            yield callHandOffHook(live.name, 'onHandOffReturn', () => { var _a; return (_a = live.onHandOffReturn) === null || _a === void 0 ? void 0 : _a.call(live, structuredClone(outcome), frameCopy(frame)); });
+            this.handOffStack = remaining;
+            this.dispatchEvent(new CustomEvent('handoff-returned', { detail: frameCopy(frame) }));
+            return handBackNote(frame, outcome);
+        });
+    }
+    /** The top frame, when `agent` is its target. */
+    topFrameFor(agent) {
+        const top = this.handOffStack[this.handOffStack.length - 1];
+        return (top === null || top === void 0 ? void 0 : top.target) === agent ? top : undefined;
+    }
+    /** The target's last reply since its brief, for a target that released without a summary. */
+    lastReply(frame) {
+        var _a;
+        const history = this.chatDriver.getHistory();
+        for (let i = history.length - 1; i >= 0; i -= 1) {
+            const m = history[i];
+            if (m.role === 'user' && m.delegate === frame.caller)
+                return undefined;
+            if (m.role === 'assistant' &&
+                m.agentName === frame.target &&
+                reachesProvider(m) &&
+                ((_a = m.content) === null || _a === void 0 ? void 0 : _a.trim())) {
+                return m.content;
+            }
+        }
+        return undefined;
+    }
+    /** The brief, in the transcript as a message the caller sent on the user's behalf. */
+    recordDelegated(from, message, framing) {
+        const history = this.chatDriver.getHistory();
+        this.chatDriver.loadHistory([
+            ...history,
+            {
+                role: 'user',
+                content: message,
+                delegate: from,
+                delegateFraming: framing,
+                timestamp: new Date().toISOString(),
+            },
+        ]);
+        this.dispatchEvent(new CustomEvent('history-updated', { detail: this.chatDriver.getHistory() }));
+    }
+    /** End `frame` with `kind` and no hand-back, for the host. */
+    unwound(frame, kind) {
+        frame.outcome = { kind };
+        this.dispatchEvent(new CustomEvent('handoff-unwound', { detail: frameCopy(frame) }));
+    }
+    /** {@inheritDoc AiDriver.getHandOffStack} */
+    getHandOffStack() {
+        return this.handOffStack.map(frameCopy);
+    }
+    /** {@inheritDoc AiDriver.restoreHandOffStack} */
+    restoreHandOffStack(saved, savedStates, interrupted) {
+        this.handOffStack = [];
+        this.pendingHandBack = undefined;
+        const kept = [];
+        const unwoundTargets = new Set();
+        for (const frame of parseHandOffFrames(saved)) {
+            const caller = this.agents.find((a) => a.name === frame.caller);
+            const outcome = frame.outcome;
+            if (!caller) {
+                this.unwound(frame, 'agent-removed');
+            }
+            else if (interrupted || (caller.serialize && (savedStates === null || savedStates === void 0 ? void 0 : savedStates[caller.name]) === undefined)) {
+                // The caller's state is gone: a frozen save drops every agent's, so nothing can resume it.
+                this.unwound(frame, 'state-lost');
+            }
+            else {
+                kept.push(frame);
+                continue;
+            }
+            // Its activation is over, and with it the data it was handed.
+            this.agentSession.setHandOffData(frame.caller, undefined);
+            unwoundTargets.add(frame.target);
+            // The caller below waited for this one, which cannot resume: it waits for this frame's
+            // target instead, as after a one-way hand-off, and is handed back what this one would be.
+            const below = kept[kept.length - 1];
+            if ((below === null || below === void 0 ? void 0 : below.target) === frame.caller) {
+                below.target = frame.target;
+                if (outcome)
+                    below.outcome = outcome;
+            }
+        }
+        const top = kept[kept.length - 1];
+        if (top && !top.outcome && !this.agents.some((a) => a.name === top.target)) {
+            top.outcome = { kind: 'agent-removed' };
+        }
+        this.handOffStack = kept;
+        this.chatDriver.suspendRestoredActivations(kept.map((f) => f.caller));
+        // A plain target held its lock only for an unwound hand-off, so the saved lock goes too.
+        const droppedLocks = [...unwoundTargets].filter((name) => {
+            const target = this.agents.find((a) => a.name === name);
+            return !!target && !isStateful(target) && !kept.some((f) => f.target === name);
+        });
+        const dropped = droppedLocks.length ? { droppedLocks } : {};
+        if (!(top === null || top === void 0 ? void 0 : top.outcome))
+            return dropped;
+        this.pendingHandBack = { frame: top, resumed: false };
+        return Object.assign(Object.assign({}, dropped), { resume: { agent: top.caller, note: handBackNote(top, top.outcome) } });
+    }
+    /** {@inheritDoc AiDriver.unwindHandOffs} */
+    unwindHandOffs(kind) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const frames = [...this.handOffStack].reverse();
+            this.handOffStack = [];
+            this.pendingHandBack = undefined;
+            this.chatDriver.endSuspendedActivations();
+            for (const frame of frames) {
+                this.unwound(frame, kind);
+                // A cleared caller is still live, until the teardown that follows deactivates it.
+                const live = this.agentSession.getSuspended().find((a) => a.name === frame.caller);
+                if (kind === 'cleared' && live) {
+                    // oxlint-disable-next-line no-await-in-loop
+                    yield callHandOffHook(live.name, 'onHandOffReturn', () => { var _a; return (_a = live.onHandOffReturn) === null || _a === void 0 ? void 0 : _a.call(live, structuredClone(frame.outcome), frameCopy(frame)); });
+                }
+            }
+        });
+    }
+    /** {@inheritDoc AiDriver.getHandOffData} */
+    getHandOffData() {
+        // Every caller on the stack, live or not: after a reload none is live until it resumes.
+        const live = [this.agentSession.getFlowOwner(), ...this.handOffStack.map((f) => f.caller)];
+        const saved = {};
+        for (const name of live) {
+            const data = name ? this.agentSession.getHandOffData(name) : undefined;
+            if (name && data !== undefined)
+                saved[name] = data;
+        }
+        return saved;
+    }
+    /** {@inheritDoc AiDriver.restoreHandOffData} */
+    restoreHandOffData(saved, interrupted) {
+        if (interrupted || !saved || typeof saved !== 'object' || Array.isArray(saved))
+            return;
+        for (const [name, data] of Object.entries(saved))
+            this.agentSession.setHandOffData(name, data);
+    }
+    /** {@inheritDoc AiDriver.serializeWaitingCallers} */
+    serializeWaitingCallers() {
+        const states = {};
+        for (const caller of this.agentSession.getSuspended()) {
+            if (!caller.serialize)
+                continue;
+            try {
+                const state = caller.serialize();
+                if (state !== undefined)
+                    states[caller.name] = state;
+            }
+            catch (e) {
+                logger.error(`OrchestratingDriver: serialize("${caller.name}") threw:`, e);
+            }
+        }
+        return states;
+    }
     /**
      * Stop the current turn (user "stop" button). Cancels the inner chat driver's
-     * in-flight request and breaks the handoff loop so no further agent turn or
-     * classify runs. The driver stays usable for the next message.
+     * in-flight request, and no further agent runs this turn, not even a hand-off's
+     * target or a hand-back. The driver stays usable for the next message.
      */
     cancel() {
         this.cancelled = true;
@@ -748,15 +951,9 @@ export class OrchestratingDriver extends BaseDriverDecorator {
         }
         return lines.join('\n');
     }
-    classify(input_1, history_1, contextAgent_1) {
-        return __awaiter(this, arguments, void 0, function* (input, history, contextAgent, 
-        /**
-         * Specialists to leave off the ballot — the agents that have already handled (and handed off)
-         * part of this turn. Without it a re-classify can hand the remaining work straight back to
-         * the agent that just declined it, and in the worst case ping-pong until `maxHandoffs`.
-         */
-        excludeAgents = []) {
-            var _a, _b, _c;
+    classify(input, history, contextAgent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             // Started before every early return, and EVERY exit below reports against it — so
             // `durationMs` is present on every `routing.decided`, and a decision that made no call says so
             // with a ~0ms reading rather than an absent field. Uniform on purpose: a field that is always
@@ -794,35 +991,14 @@ export class OrchestratingDriver extends BaseDriverDecorator {
                 this.recordRouting('no-specialists', leaf, { durationMs: Date.now() - classifyStartedAt });
                 return { agent: leaf, decision: 'no-specialists' };
             }
-            // The ballot for THIS classification. Indices are positions in `ballot`, not in
-            // `this.specialists`, so an exclusion cannot silently shift what an index means.
-            const ballot = excludeAgents.length
-                ? this.specialists.filter((a) => !excludeAgents.includes(a.name))
-                : this.specialists;
-            if (ballot.length === 0) {
-                // Every specialist has already had a go at this turn. Asking again can only return one of
-                // them, so go straight to the escape hatch. `durationMs` is reported even though it is ~0,
-                // because that is the documented signal for "no network call happened" — omitting it left a
-                // reader with no way to tell this record from a truncated one.
-                const leaf = (_b = this.fallback) !== null && _b !== void 0 ? _b : this.specialists[0];
-                this.recordRouting('ballot-exhausted', leaf, {
-                    excluded: excludeAgents,
-                    durationMs: Date.now() - classifyStartedAt,
-                });
-                return { agent: leaf, decision: 'ballot-exhausted' };
-            }
+            // The ballot: indices in the classifier's answer are positions in it.
+            const ballot = this.specialists;
             const agentList = ballot.map((a, i) => `${i}: ${a.name} — ${a.description}`).join('\n');
             const recentMessages = this.classifierTranscript(history);
-            const continuationHint = contextAgent && isSpecialist(contextAgent) && !excludeAgents.includes(contextAgent.name)
+            const continuationHint = contextAgent && isSpecialist(contextAgent)
                 ? `\n\nThe previous turn was handled by "${contextAgent.name}". If the new message is a refinement, correction, or continuation of that work, prefer "${contextAgent.name}" — unless the topic has clearly shifted to another specialist's domain.`
                 : '';
-            // Naming what has already been tried, rather than just removing it from the list, so the
-            // model can tell "nobody here covers this" from "I haven't looked hard enough" — the latter
-            // is what makes a classifier pick a poor closest match.
-            const attemptedHint = excludeAgents.length
-                ? `\n\nAlready attempted this turn and handed the work on, so not listed above: ${excludeAgents.join(', ')}. Do not expect another agent to repeat their part.`
-                : '';
-            const classifierPrompt = `You are a routing classifier. Call select_agent with the index of the best matching agent for the user message. Use -1 only if the request is entirely unrelated to every agent listed — prefer the closest match when in doubt. If the request spans multiple agents, pick the one that should act first; I will re-classify and route again once that agent is done.\n\nAgents:\n${agentList}${continuationHint}${attemptedHint}${recentMessages ? `\n\nRecent conversation:\n${recentMessages}` : ''}`;
+            const classifierPrompt = `You are a routing classifier. Call select_agent with the index of the best matching agent for the user message. Use -1 only if the request is entirely unrelated to every agent listed — prefer the closest match when in doubt. If the request spans multiple agents, pick the one that should act first.\n\nAgents:\n${agentList}${continuationHint}${recentMessages ? `\n\nRecent conversation:\n${recentMessages}` : ''}`;
             const routingTool = {
                 name: 'select_agent',
                 description: 'Select the most appropriate agent for the user message.',
@@ -862,12 +1038,17 @@ export class OrchestratingDriver extends BaseDriverDecorator {
                     // oxlint-disable-next-line no-await-in-loop
                     const response = yield classifierProvider.chat([], input, options);
                     lastResponse = response;
-                    const tc = (_c = response.toolCalls) === null || _c === void 0 ? void 0 : _c[0];
+                    const tc = (_b = response.toolCalls) === null || _b === void 0 ? void 0 : _b[0];
                     const index = (tc === null || tc === void 0 ? void 0 : tc.name) === 'select_agent' ? tc.args.agent_index : -1;
                     if (index >= 0 && index < ballot.length) {
                         const chosen = ballot[index];
-                        this.recordRouting('classified', chosen, Object.assign({ index,
-                            attempts, durationMs: Date.now() - classifyStartedAt, response, ballot: ballot.map((a) => a.name) }, (excludeAgents.length ? { excluded: excludeAgents } : {})));
+                        this.recordRouting('classified', chosen, {
+                            index,
+                            attempts,
+                            durationMs: Date.now() - classifyStartedAt,
+                            response,
+                            ballot: ballot.map((a) => a.name),
+                        });
                         return { agent: chosen, decision: 'classified' };
                     }
                     // index === -1 — fall through to fallback
@@ -898,7 +1079,7 @@ export class OrchestratingDriver extends BaseDriverDecorator {
             // `durationMs` is the whole ladder: a decision that reached this point in a few tens of
             // milliseconds did not make a network call at all, and that gap between "the classifier
             // declined" and "the classifier never ran" is precisely what an exported log could not show.
-            const routingDetail = Object.assign(Object.assign(Object.assign({ attempts, durationMs: Date.now() - classifyStartedAt, ballot: ballot.map((a) => a.name) }, (lastError ? { error: lastError } : {})), (lastResponse ? { response: lastResponse } : {})), (excludeAgents.length ? { excluded: excludeAgents } : {}));
+            const routingDetail = Object.assign(Object.assign({ attempts, durationMs: Date.now() - classifyStartedAt, ballot: ballot.map((a) => a.name) }, (lastError ? { error: lastError } : {})), (lastResponse ? { response: lastResponse } : {}));
             if (this.fallback) {
                 this.recordRouting(decision, this.fallback, routingDetail);
                 return { agent: this.fallback, decision };
@@ -938,7 +1119,7 @@ export class OrchestratingDriver extends BaseDriverDecorator {
         return match;
     }
     /**
-     * Append prose the ORCHESTRATOR wrote — the handoff cap, the no-specialist apology. Flagged
+     * Append prose the ORCHESTRATOR wrote — the no-specialist apology. Flagged
      * `excludeFromProvider` for the same reason the driver's own notices are: it is not something a
      * model said, and feeding it back invites the model to echo it. See
      * `ChatMessage.excludeFromProvider`.