@genesislcap/ai-assistant 15.58.2 → 15.60.0

package/dist/chat-driver.cjs

@@ -4109,6 +4109,10 @@ var META_EVENT_IMPORTANCE = {
   "interaction.outcome": "normal",
   // An outcome that could not be recorded: the widget goes on showing only the answer.
   "interaction.outcome-dropped": "high",
+  // A claimant handing a pending interaction to the person, or taking it back.
+  "interaction.held": "normal",
+  // A claim on a `userOnly` interaction, refused. Expected when an interceptor claims broadly.
+  "interaction.claim-refused": "low",
   "external-diagnostics.folded": "normal",
   "session.cleared": "normal",
   "session.switched": "low",
@@ -4320,6 +4324,14 @@ function projectCompaction(history, cut, summaryTokens = COMPACTION_SUMMARY_TOKE
   };
 }
 
+// src/utils/delegated-message.ts
+var DEFAULT_DELEGATE_FRAMING = "Sent on the user's behalf.";
+function frameDelegatedContent(content, framing) {
+  return `(${framing ?? DEFAULT_DELEGATE_FRAMING})
+
+${content}`;
+}
+
 // src/utils/logger.ts
 var logger2 = createLogger("ai-assistant");
 
@@ -4371,7 +4383,9 @@ Additional guidance: "${prompt2}"` : "";
   }
   const conversationContext = history.filter(
     (m) => reachesProvider(m) && (m.role === "user" || m.role === "assistant") && !m.toolCalls?.length && !m.thinking && !!m.content?.trim()
-  ).slice(-HISTORY_WINDOW).map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n");
+  ).slice(-HISTORY_WINDOW).map(
+    (m) => m.role === "user" ? `User: ${m.delegate ? frameDelegatedContent(m.content ?? "", m.delegateFraming) : m.content}` : `Assistant: ${m.content}`
+  ).join("\n");
   return `<conversation_history>
 ${conversationContext}
 </conversation_history>
@@ -4761,7 +4775,8 @@ function renderMessageForSummary(m) {
     case "compacted-summary":
       return `[Earlier summary] ${m.content}`;
     case "user":
-      return m.content ? `User: ${m.content}` : "";
+      if (!m.content) return "";
+      return `User: ${m.delegate ? frameDelegatedContent(m.content, m.delegateFraming) : m.content}`;
     case "assistant": {
       if (m.category === "reasoning") {
         return m.content ? `Thinking: ${m.content}` : "";
@@ -4793,6 +4808,9 @@ Summarize the conversation above so it can be dropped from context while preserv
 }
 function normalizeForProvider(history) {
   return history.map((m) => {
+    if (m.role === "user" && m.delegate) {
+      return { ...m, content: frameDelegatedContent(m.content ?? "", m.delegateFraming) };
+    }
     if (m.role !== "compacted-summary") return m;
     return {
       ...m,
@@ -5007,6 +5025,7 @@ var AgentSession = class {
       transition.flowOwnerChangedTo = agent.name;
     }
     this.active = agent;
+    if (switched) this.reportTransition(transition);
     return transition;
   }
   /**
@@ -5028,8 +5047,21 @@ var AgentSession = class {
       this.flowOwner = null;
       transition.flowOwnerChangedTo = null;
     }
+    this.reportTransition(transition);
     return transition;
   }
+  /**
+   * Hand a transition to the owner. A throwing listener is logged rather than propagated, for the
+   * same reason a throwing hook is: the transition has already happened, and failing the caller
+   * would leave it believing it had not.
+   */
+  reportTransition(transition) {
+    try {
+      this.deps.onTransition?.(transition);
+    } catch (e) {
+      logger2.warn(`${WARN_PREFIX}: onTransition threw:`, e);
+    }
+  }
   /**
    * Fire `onDeactivate` on the active agent and abort pending lifecycle work, for session
    * teardown, so machines release resources cleanly. The session is not reusable afterwards: the
@@ -5255,8 +5287,12 @@ function createInteractionContext(interactionId) {
   const listeners = /* @__PURE__ */ new Set();
   const disposers = /* @__PURE__ */ new Set();
   let disposed = false;
+  let heldBy = "user";
   const context = {
     interactionId,
+    get heldBy() {
+      return heldBy;
+    },
     state,
     once(key, factory) {
       if (onceCache.has(key)) return onceCache.get(key);
@@ -5308,11 +5344,18 @@ function createInteractionContext(interactionId) {
       disposers.clear();
       listeners.clear();
       onceCache.clear();
+    },
+    setHeldBy(holder) {
+      if (disposed || holder === heldBy) return false;
+      heldBy = holder;
+      context.notify();
+      return true;
     }
   };
 }
 
 // src/components/chat-driver/interaction-controller.ts
+var DEFAULT_DECISION_FRAMING = "Decided on the user's behalf";
 var STOPPED = {
   status: "timeout",
   message: "The turn was stopped before this was answered."
@@ -5330,6 +5373,94 @@ var InteractionController = class {
      * one-interaction-at-a-time guard in `request`).
      */
     this.contexts = /* @__PURE__ */ new Map();
+    /**
+     * Told about every interaction this controller opens (GENC-1660), in registration order. Only
+     * the root's are ever consulted: a sub-agent's request is opened by the root.
+     */
+    this.interceptors = [];
+  }
+  /** See `ChatDriver.addInteractionInterceptor`. Returns a remover. */
+  addInterceptor(interceptor) {
+    if (!interceptor.id || interceptor.id === "user") {
+      throw new Error(
+        `addInteractionInterceptor: an interceptor needs an id other than 'user' (got "${interceptor.id}").`
+      );
+    }
+    this.interceptors.push(interceptor);
+    return () => {
+      const index = this.interceptors.indexOf(interceptor);
+      if (index >= 0) this.interceptors.splice(index, 1);
+    };
+  }
+  /**
+   * Offer a new interaction to the interceptors and record who ends up holding it.
+   *
+   * **Outermost first.** A decorator installs its interceptor on the driver it wraps when it is
+   * constructed, and decorators are constructed innermost first, so registration order is
+   * innermost first and the walk runs it backwards. The first claim wins; later interceptors still
+   * see the interaction but their `hold` does nothing. A claim on a `userOnly` interaction is
+   * refused.
+   *
+   * Runs before the interaction's message is appended, so the widget's first render already knows
+   * its holder and nothing appears only to disappear.
+   */
+  offer(handle, opened) {
+    let claimant;
+    for (const interceptor of [...this.interceptors].reverse()) {
+      const hold = this.holdFor(handle, interceptor, () => claimant === interceptor);
+      let answer;
+      try {
+        answer = interceptor.onInteractionOpened({ ...opened, ctx: handle.context, hold });
+      } catch (e) {
+        logger2.warn(`InteractionController: interceptor "${interceptor.id}" threw:`, e);
+        continue;
+      }
+      if (answer !== "claim" || claimant) continue;
+      if (opened.userOnly) {
+        recordMetaEvent(this.deps.sessionKey, "interaction.claim-refused", {
+          interactionId: opened.interactionId,
+          claimant: interceptor.id,
+          reason: "userOnly"
+        });
+        continue;
+      }
+      claimant = interceptor;
+      handle.setHeldBy(interceptor.id);
+      const pending = this.pending.get(opened.interactionId);
+      if (pending) pending.claimant = interceptor;
+    }
+    return handle.context.heldBy;
+  }
+  /** The {@link InteractionHold} for one interceptor: it applies only while that one is the claimant. */
+  holdFor(handle, interceptor, isClaimant) {
+    return {
+      set: (holder) => {
+        if (!isClaimant()) return false;
+        const next = holder === "user" ? "user" : interceptor.id;
+        if (!handle.setHeldBy(next)) return false;
+        recordMetaEvent(this.deps.sessionKey, "interaction.held", {
+          interactionId: handle.context.interactionId,
+          heldBy: next,
+          claimant: interceptor.id
+        });
+        return true;
+      },
+      resolve: (result) => {
+        const { interactionId } = handle.context;
+        const pending = this.pending.get(interactionId);
+        if (!isClaimant() || !pending || handle.context.heldBy !== interceptor.id) return false;
+        pending.settledBy = interceptor.id;
+        this.resolve(interactionId, result);
+        return true;
+      },
+      recordDecision: (decision) => {
+        if (!isClaimant()) return false;
+        const pending = this.pending.get(handle.context.interactionId);
+        if (!pending) return false;
+        pending.decision = { choice: decision.choice, shownToUser: decision.shownToUser };
+        return true;
+      }
+    };
   }
   /** See `ChatDriver.setHostInteractionRequester`. */
   setHostRequester(fn, recordOutcome) {
@@ -5339,10 +5470,14 @@ var InteractionController = class {
   /**
    * See `ChatDriver.requestInteraction`. `onOpened` is told the id of the interaction this call
    * opens, wherever it opens it, so the caller can later record its outcome and no other's.
+   * `innerPath` is the owner path a sub-agent's request has gathered on its way up, and
+   * `onSettled` is told who answered, wherever it resolves (GENC-1660).
    */
-  request(componentName, data, options, onOpened) {
+  request(componentName, data, options, onOpened, innerPath = [], onSettled) {
+    const agent = this.deps.activeAgentName();
+    const ownerPath = agent ? [agent, ...innerPath] : [...innerPath];
     if (this.hostRequester) {
-      return this.hostRequester(componentName, data, options, onOpened);
+      return this.hostRequester(componentName, data, options, onOpened, ownerPath, onSettled);
     }
     if (this.pending.size > 0) {
       throw new Error(
@@ -5358,6 +5493,7 @@ var InteractionController = class {
       this.pending.set(interactionId, {
         resolve,
         reject,
+        onSettled,
         overrideId: chatInputDuringExecution ? interactionId : void 0,
         // Resolve the interaction with a timeout result if the user does not
         // respond in time. `resolve` runs the same teardown a normal resolution
@@ -5370,10 +5506,22 @@ var InteractionController = class {
           });
         }, timeoutMs) : void 0
       });
+      const handle = createInteractionContext(interactionId);
+      this.contexts.set(interactionId, handle);
+      const heldBy = this.offer(handle, {
+        interactionId,
+        componentName,
+        data,
+        ownerPath,
+        userOnly: options?.userOnly === true
+      });
       recordMetaEvent(this.deps.sessionKey, "interaction.requested", {
         interactionId,
         component: componentName,
-        agent: this.deps.activeAgentName()
+        agent: this.deps.activeAgentName(),
+        ownerPath,
+        heldBy,
+        ...options?.userOnly ? { userOnly: true } : {}
       });
       this.deps.activityBus.publish("interaction-requested", void 0);
       if (chatInputDuringExecution) {
@@ -5383,7 +5531,6 @@ var InteractionController = class {
           })
         );
       }
-      this.contexts.set(interactionId, createInteractionContext(interactionId));
       this.deps.appendToHistory({
         role: "assistant",
         content: "",
@@ -5394,6 +5541,11 @@ var InteractionController = class {
           ...presentation ? { presentation } : {}
         }
       });
+      const opened = this.pending.get(interactionId);
+      if (opened) {
+        opened.appended = true;
+        if (opened.early) this.resolve(interactionId, opened.early.result);
+      }
       const signal = options?.signal;
       if (signal) {
         const onAbort = () => this.resolve(interactionId, STOPPED);
@@ -5419,6 +5571,10 @@ var InteractionController = class {
       logger2.warn(`Interaction with ID ${interactionId} not found.`);
       return;
     }
+    if (!interaction.appended) {
+      interaction.early ??= { result };
+      return;
+    }
     if (interaction.timeoutHandle) clearTimeout(interaction.timeoutHandle);
     interaction.unlinkSignal?.();
     this.deps.foldDiagnostics(
@@ -5426,20 +5582,50 @@ var InteractionController = class {
       result?.diagnostics
     );
     const costUsd = typeof result?.costUsd === "number" && Number.isFinite(result.costUsd) && result.costUsd > 0 ? result.costUsd : void 0;
+    const unanswered = result?.status === "timeout";
+    const answeredBy = unanswered ? void 0 : interaction.settledBy ?? "user";
+    const decision = answeredBy && answeredBy !== "user" ? {
+      framing: interaction.claimant?.decisionFraming ?? DEFAULT_DECISION_FRAMING,
+      ...interaction.decision?.choice !== void 0 && {
+        choice: interaction.decision.choice
+      },
+      ...interaction.decision?.shownToUser !== void 0 && {
+        shownToUser: interaction.decision.shownToUser
+      }
+    } : void 0;
     const patched = this.deps.patchInteractionMessage(interactionId, (message) => ({
       ...message,
-      interaction: { ...message.interaction, resolved: result },
+      interaction: {
+        ...message.interaction,
+        resolved: result,
+        ...answeredBy ? { answeredBy } : {}
+      },
       ...costUsd != null ? { externalCostUsd: (message.externalCostUsd ?? 0) + costUsd } : {}
     }));
     if (patched) this.deps.notifyHistoryUpdated();
     if (typeof result?.userMessage === "string" && result.userMessage.trim()) {
-      this.deps.appendToHistory({ role: "synthetic-user", content: result.userMessage });
+      this.deps.appendToHistory(
+        answeredBy && answeredBy !== "user" ? {
+          role: "assistant",
+          content: result.userMessage,
+          delegate: answeredBy,
+          excludeFromProvider: true
+        } : { role: "synthetic-user", content: result.userMessage }
+      );
     }
     if (interaction.overrideId) {
       this.deps.emit(new CustomEvent("interaction-stop", { detail: { interactionId } }));
     }
-    recordMetaEvent(this.deps.sessionKey, "interaction.resolved", { interactionId });
+    recordMetaEvent(this.deps.sessionKey, "interaction.resolved", {
+      interactionId,
+      ...answeredBy ? { answeredBy } : {}
+    });
     this.deps.activityBus.publish("interaction-resolved", void 0);
+    try {
+      interaction.onSettled?.({ answeredBy, decision });
+    } catch (e) {
+      logger2.warn("InteractionController: onSettled threw:", e);
+    }
     interaction.resolve(result);
     this.pending.delete(interactionId);
     this.contexts.get(interactionId)?.dispose();
@@ -5838,6 +6024,18 @@ var budgetDetailOf = (e) => {
     ...e.otherVendorAvailable != null ? { otherVendorAvailable: e.otherVendorAvailable } : {}
   };
 };
+function withDelegatedDecisions(result, content, decisions, hasImages) {
+  if (decisions.length === 0) return content;
+  if (!hasImages && result !== null && typeof result === "object" && !Array.isArray(result)) {
+    return JSON.stringify({ ...result, decidedOnUsersBehalf: decisions });
+  }
+  return [content, ...decisions.map(describeDelegatedDecision)].join("\n\n");
+}
+function describeDelegatedDecision(decision) {
+  const choice = decision.choice !== void 0 ? `: "${decision.choice}"` : "";
+  const shown = decision.shownToUser ? ` What the user was shown, as your words: "${decision.shownToUser}"` : " Nothing was shown to the user about it.";
+  return `${decision.framing}${choice}.${shown}`;
+}
 function inFlightToolCallsAt(history) {
   for (let i = history.length - 1; i >= 0; i -= 1) {
     const message = history[i];
@@ -6003,6 +6201,8 @@ var ChatDriver = class _ChatDriver extends EventTarget {
      * on that one was reset by every handoff inside a single message.
      */
     this.messageController = new AbortController();
+    /** Capabilities provided on this driver by decorators (GENC-1660). Only the root's are used. */
+    this.handlerCapabilities = /* @__PURE__ */ new Map();
     /**
      * Caches validated provider lookups per name within the current agent. Cleared
      * by `installAgent` so each new agent's static/function-resolved names are
@@ -6026,9 +6226,17 @@ var ChatDriver = class _ChatDriver extends EventTarget {
      * the point: two would let `getActiveAgent()` disagree between the outer and inner driver.
      * `@internal` rather than private so that reach is legal without six delegating one-liners.
      *
+     * **This driver raises the lifecycle events for every transition of the session**, whoever made
+     * it: itself, through {@link ChatDriver.activateAgent} or a release, or the orchestrator reaching
+     * through (GENC-1485). Before, only the orchestrator dispatched them, so a host on a bare
+     * `ChatDriver` never learned its flow owner.
+     *
      * @internal
      */
-    this.agentSession = new AgentSession({ sessionKey: () => this.sessionKey });
+    this.agentSession = new AgentSession({
+      sessionKey: () => this.sessionKey,
+      onTransition: (t) => this.dispatchAgentTransition(t)
+    });
     /**
      * A provider refusal was observed this turn, so the tool loop must not call the model again
      * (GENC-1506).
@@ -6537,6 +6745,51 @@ var ChatDriver = class _ChatDriver extends EventTarget {
     await this.agentSession.activate(config);
     this.installAgent(config);
   }
+  /**
+   * {@inheritDoc AiDriver.resumeRestoredFlow}
+   *
+   * This driver holds no list of agents, so it resumes only the `agent` it is handed (GENC-1660):
+   * whoever runs a bare `ChatDriver` knows which agent that is, and after a reload only the name
+   * survived. Without one it does nothing, as a driver without this member did before; given one
+   * that is not the restored flow owner, it refuses.
+   *
+   * For headless callers: the shipped host restores and resumes through `OrchestratingDriver`,
+   * and a bare `ChatDriver` does not answer `canRestoreFlowOwner`, so the host never plans a resume
+   * for one.
+   *
+   * The orchestrator does not delegate here, because it installs a decorated config of its own;
+   * this is the bare-driver path.
+   *
+   * @beta
+   */
+  async resumeRestoredFlow(resumeNote, agent) {
+    if (!agent) return void 0;
+    const owner = this.agentSession.getFlowOwner();
+    if (owner !== null && owner !== agent.name) {
+      logger2.warn(
+        `ChatDriver: resumeRestoredFlow was handed "${agent.name}", but the flow belongs to "${owner}" \u2014 not resuming.`
+      );
+      return void 0;
+    }
+    await this.activateAgent(agent);
+    if (!resumeNote || agent.resumeOnRestore === false) return void 0;
+    return this.continueFromHistory(void 0, { tailNote: resumeNote });
+  }
+  /**
+   * Raise the host-facing lifecycle events for one session transition (GENC-1485), in the order
+   * the orchestrator raised them before it stopped doing so itself: the flow lock first, then the
+   * release, then the active agent.
+   */
+  dispatchAgentTransition(t) {
+    if (t.flowOwnerChangedTo !== void 0) {
+      this.dispatchEvent(new CustomEvent("flow-owner-changed", { detail: t.flowOwnerChangedTo }));
+    }
+    const active = this.agentSession.getActive();
+    if (!active && t.previousAgent) {
+      this.dispatchEvent(new CustomEvent("agent-released", { detail: t.previousAgent }));
+    }
+    this.dispatchEvent(new CustomEvent("agent-changed", { detail: active }));
+  }
   /**
    * {@inheritDoc AiDriver.getActiveAgent}
    *
@@ -6572,6 +6825,14 @@ var ChatDriver = class _ChatDriver extends EventTarget {
   setFlowOwner(name) {
     this.agentSession.setFlowOwner(name);
   }
+  /**
+   * {@inheritDoc AiDriver.getFlowOwner}
+   *
+   * @beta
+   */
+  getFlowOwner() {
+    return this.agentSession.getFlowOwner();
+  }
   /**
    * Install `config` as the active agent **without firing lifecycle hooks**.
    *
@@ -7145,8 +7406,84 @@ var ChatDriver = class _ChatDriver extends EventTarget {
    *   and `presentation` to control whether the host wraps the widget in a chat
    *   bubble and/or shows the "Assistant" label.
    */
-  async requestInteraction(componentName, data, options, onOpened) {
-    return this.interactions.request(componentName, data, options, onOpened);
+  async requestInteraction(componentName, data, options, onOpened, innerPath, onSettled) {
+    return this.interactions.request(
+      componentName,
+      data,
+      options,
+      onOpened,
+      innerPath,
+      onSettled
+    );
+  }
+  /**
+   * {@inheritDoc AiDriver.addInteractionInterceptor}
+   *
+   * Consulted only on the root driver, where every interaction opens: a sub-agent's request
+   * travels up to its root, carrying its owner path, and is offered there once.
+   *
+   * @beta
+   */
+  addInteractionInterceptor(interceptor) {
+    return this.interactions.addInterceptor(interceptor);
+  }
+  /**
+   * {@inheritDoc AiDriver.presentInteraction}
+   *
+   * @beta
+   */
+  presentInteraction(componentName, data, options) {
+    return this.requestInteraction(componentName, data, options);
+  }
+  /**
+   * {@inheritDoc AiDriver.provideHandlerCapability}
+   *
+   * Throws if `name` is already provided: two decorators answering to one name would leave a
+   * handler unable to tell which it is talking to.
+   *
+   * @beta
+   */
+  provideHandlerCapability(name, factory) {
+    if (this.handlerCapabilities.has(name)) {
+      throw new Error(`provideHandlerCapability: "${name}" is already provided.`);
+    }
+    this.handlerCapabilities.set(name, factory);
+    return () => {
+      if (this.handlerCapabilities.get(name) === factory) this.handlerCapabilities.delete(name);
+    };
+  }
+  /**
+   * The capabilities this driver's handlers see, and who they see them as: the root's factories,
+   * the root's flow owner, and the owner path from the root down to this driver's agent.
+   */
+  capabilityScope() {
+    const own = this.activeAgentName ? [this.activeAgentName] : [];
+    if (!this.capabilityParent) {
+      return {
+        factories: this.handlerCapabilities,
+        scope: { ownerPath: own, flowOwner: this.agentSession.getFlowOwner() }
+      };
+    }
+    const up = this.capabilityParent.capabilityScope();
+    return {
+      factories: up.factories,
+      scope: { ownerPath: [...up.scope.ownerPath, ...own], flowOwner: up.scope.flowOwner }
+    };
+  }
+  /** Build `context.capabilities` for one handler call, or `undefined` when nothing is provided. */
+  buildCapabilities() {
+    const { factories, scope } = this.capabilityScope();
+    if (factories.size === 0) return void 0;
+    const capabilities2 = {};
+    for (const [name, factory] of factories) {
+      try {
+        const value = factory(scope);
+        if (value !== void 0) capabilities2[name] = value;
+      } catch (e) {
+        logger2.warn(`ChatDriver: handler capability "${name}" threw \u2014 leaving it out:`, e);
+      }
+    }
+    return capabilities2;
   }
   /**
    * Record what came of an interaction, after it resolved, on its history message
@@ -7218,8 +7555,10 @@ var ChatDriver = class _ChatDriver extends EventTarget {
     this.history = [...messages];
     this.notifyHistoryUpdated();
   }
-  async sendMessage(userInput, attachments) {
+  async sendMessage(userInput, attachments, options) {
     if (this.busy || !userInput.trim() && !attachments?.length) return { reason: "done" };
+    const delegate = options?.delegate;
+    const delegateFraming = delegate ? options?.delegateFraming ?? DEFAULT_DELEGATE_FRAMING : void 0;
     this.busy = true;
     this.beginTurn();
     this.beginMessage();
@@ -7236,7 +7575,12 @@ var ChatDriver = class _ChatDriver extends EventTarget {
     this.aiServiceWall = void 0;
     this.aiServiceNoticesShown.clear();
     this.aiServiceNoticesQueued = [];
-    this.appendToHistory({ role: "user", content: userInput, attachments });
+    this.appendToHistory({
+      role: "user",
+      content: userInput,
+      attachments,
+      ...delegate ? { delegate, delegateFraming } : {}
+    });
     this.turnStartedAt = Date.now();
     recordMetaEvent(this.sessionKey, "turn.start", {
       phase: "sendMessage",
@@ -7245,7 +7589,10 @@ var ChatDriver = class _ChatDriver extends EventTarget {
     this.activityBus.publish("tool-loop-start", void 0);
     let result = { reason: "done" };
     try {
-      result = await this.runToolLoop(userInput, attachments);
+      result = await this.runToolLoop(
+        delegate ? frameDelegatedContent(userInput, delegateFraming) : userInput,
+        attachments
+      );
       return result;
     } catch (e) {
       logger2.error("ChatDriver error:", e);
@@ -7298,13 +7645,25 @@ var ChatDriver = class _ChatDriver extends EventTarget {
    *   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) {
+  buildHandlerContext(activeToolCallId, traceCapture, decisions) {
     let opened;
     let recorded = false;
+    const capabilities2 = this.buildCapabilities();
     return {
-      requestInteraction: (componentName, data, options) => this.requestInteraction(componentName, data, options, (interactionId) => {
-        opened = interactionId;
-      }),
+      ...capabilities2 && { capabilities: capabilities2 },
+      requestInteraction: (componentName, data, options) => this.requestInteraction(
+        componentName,
+        data,
+        options,
+        (interactionId) => {
+          opened = interactionId;
+        },
+        void 0,
+        // An interaction an interceptor answered is reported in THIS call's result (GENC-1660).
+        (settled) => {
+          if (settled.decision) decisions?.push(settled.decision);
+        }
+      ),
       recordInteractionOutcome: (outcome) => {
         if (!opened) return false;
         if (recorded) {
@@ -7423,11 +7782,12 @@ var ChatDriver = class _ChatDriver extends EventTarget {
     }
     child.installAgent({ ...subConfig, primerHistory: effectivePrimer });
     child.setHostInteractionRequester(
-      (componentName, data, opts, onOpened) => this.requestInteraction(componentName, data, opts, onOpened),
+      (componentName, data, opts, onOpened, ownerPath, onSettled) => this.requestInteraction(componentName, data, opts, onOpened, ownerPath, onSettled),
       // An outcome goes where its interaction went.
       (interactionId, outcome) => this.recordInteractionOutcome(interactionId, outcome)
     );
     child.hostAIServiceNotice = (code) => this.noticeAIServiceRefusal(code);
+    child.capabilityParent = this;
     const forwardTrace = (e) => {
       this.dispatchEvent(
         new CustomEvent("sub-agent-history-updated", {
@@ -8138,10 +8498,19 @@ ${tailBody}
             }
             const traceCapture = { traces: [] };
             const capturedTrace = () => traceCapture.traces.length ? traceCapture.traces.flat() : void 0;
+            const decisions = [];
             try {
-              const result = await handler(tc.args, this.buildHandlerContext(tc.id, traceCapture));
+              const result = await handler(
+                tc.args,
+                this.buildHandlerContext(tc.id, traceCapture, decisions)
+              );
               const resultImages = toolResultImages(result);
-              const content = resultImages ? typeof result.content === "string" ? result.content : JSON.stringify({ ...result, attachments: void 0 }) : typeof result === "string" ? result : JSON.stringify(result);
+              const content = withDelegatedDecisions(
+                result,
+                resultImages ? typeof result.content === "string" ? result.content : JSON.stringify({ ...result, attachments: void 0 }) : typeof result === "string" ? result : JSON.stringify(result),
+                decisions,
+                !!resultImages
+              );
               executedById.set(tc.id, {
                 toolCallId: tc.id,
                 content,
@@ -8341,6 +8710,189 @@ RECOVERY: this tool failed once \u2014 you may retry it, or take a different val
   }
 };
 
+// src/components/ai-driver/ai-driver.ts
+var AI_DRIVER_EVENT_TYPES = Object.keys({
+  "history-updated": true,
+  "sub-agent-history-updated": true,
+  "sub-agent-start": true,
+  "sub-agent-stop": true,
+  "interaction-start": true,
+  "interaction-stop": true,
+  "provider-changed": true,
+  "external-cost-recorded": true,
+  "agent-changed": true,
+  "agent-released": true,
+  "flow-owner-changed": true,
+  "orchestrating-start": true,
+  "orchestrating-stop": true
+});
+
+// src/components/ai-driver/base-driver-decorator.ts
+var BaseDriverDecorator = class _BaseDriverDecorator extends EventTarget {
+  constructor(inner) {
+    super();
+    this.inner = inner;
+    /** Undoes this layer's hold on its inner driver; see {@link BaseDriverDecorator.detach}. */
+    this.detachers = [];
+    for (const type of AI_DRIVER_EVENT_TYPES) {
+      const forward = (e) => {
+        this.dispatchEvent(new CustomEvent(type, { detail: e.detail }));
+      };
+      inner.addEventListener(type, forward);
+      this.onDetach(() => inner.removeEventListener(type, forward));
+    }
+  }
+  /**
+   * Let go of the inner driver WITHOUT disposing it: stop forwarding its events, and undo whatever
+   * a subclass registered through {@link BaseDriverDecorator.onDetach} (its interceptors, its
+   * capabilities, its own listeners). For dropping or replacing a decorator while the driver it
+   * wrapped lives on — otherwise the old layer keeps re-dispatching every event and is never
+   * collected. Idempotent. `dispose()` detaches too.
+   */
+  detach() {
+    for (const undo of this.detachers.splice(0)) {
+      try {
+        undo();
+      } catch {
+      }
+    }
+  }
+  /** Register something {@link BaseDriverDecorator.detach} must undo. */
+  onDetach(undo) {
+    this.detachers.push(undo);
+  }
+  sendMessage(input, attachments, options) {
+    return this.inner.sendMessage(input, attachments, options);
+  }
+  continueFromHistory(transientPrimer, options) {
+    return this.inner.continueFromHistory(transientPrimer, options);
+  }
+  resolveInteraction(interactionId, result) {
+    this.inner.resolveInteraction(interactionId, result);
+  }
+  recordExternalCost(interactionId, costUsd) {
+    return this.inner.recordExternalCost?.(interactionId, costUsd) ?? false;
+  }
+  getInteractionContext(interactionId) {
+    return this.inner.getInteractionContext?.(interactionId);
+  }
+  loadHistory(messages) {
+    this.inner.loadHistory(messages);
+  }
+  primeRestoredAgentState(snapshots) {
+    this.inner.primeRestoredAgentState(snapshots);
+  }
+  canRestoreFlowOwner(agentName) {
+    return this.inner.canRestoreFlowOwner?.(agentName) ?? false;
+  }
+  canResumeRestoredFlow(agentName) {
+    return this.inner.canResumeRestoredFlow?.(agentName) ?? false;
+  }
+  resumeRestoredFlow(resumeNote, agent) {
+    return this.inner.resumeRestoredFlow?.(resumeNote, agent) ?? Promise.resolve(void 0);
+  }
+  getRawHistory() {
+    return this.inner.getRawHistory?.() ?? [];
+  }
+  getHistoryForPersistence() {
+    return this.inner.getHistoryForPersistence?.() ?? [...this.getRawHistory()];
+  }
+  getCondensePoliciesForPersistence(messages) {
+    return this.inner.getCondensePoliciesForPersistence?.(messages) ?? [];
+  }
+  restoreCondensePolicies(entries) {
+    return this.inner.restoreCondensePolicies?.(entries) ?? { restored: 0, awaitingReactivation: 0 };
+  }
+  getActiveAgent() {
+    return this.inner.getActiveAgent();
+  }
+  setPinnedAgent(name) {
+    this.inner.setPinnedAgent(name);
+  }
+  setFlowOwner(name) {
+    this.inner.setFlowOwner(name);
+  }
+  getFlowOwner() {
+    return this.inner.getFlowOwner?.() ?? null;
+  }
+  /**
+   * Forwarded, so an interceptor installed on any layer lands on the driver that opens the
+   * interactions. A decorator that answers interactions installs its own on `this.inner`.
+   */
+  addInteractionInterceptor(interceptor) {
+    return this.inner.addInteractionInterceptor?.(interceptor) ?? (() => void 0);
+  }
+  presentInteraction(componentName, data, options) {
+    return this.inner.presentInteraction?.(componentName, data, options) ?? Promise.reject(new Error("presentInteraction: the inner driver cannot show interactions."));
+  }
+  provideHandlerCapability(name, factory) {
+    return this.inner.provideHandlerCapability?.(name, factory) ?? (() => void 0);
+  }
+  getContextReserve() {
+    return this.inner.getContextReserve?.();
+  }
+  getPreambleTokens() {
+    return this.inner.getPreambleTokens?.();
+  }
+  setContextGuard(policy) {
+    this.inner.setContextGuard?.(policy);
+  }
+  compact(options) {
+    return this.inner.compact?.(options) ?? Promise.resolve(null);
+  }
+  getCompactionPlan(options) {
+    return this.inner.getCompactionPlan?.(options) ?? null;
+  }
+  canCompact(options) {
+    return this.inner.canCompact?.(options) ?? false;
+  }
+  isBusy() {
+    return this.inner.isBusy();
+  }
+  getSuggestions(history, prompt2, count, allAgentInfo) {
+    return this.inner.getSuggestions(history, prompt2, count, allAgentInfo);
+  }
+  getTurnSnapshots() {
+    return this.inner.getTurnSnapshots?.() ?? [];
+  }
+  /**
+   * The inner driver's entries. Diagnostics compose down the stack: a decorator with entries of
+   * its own overrides this and appends them to `super.getExternalDiagnostics()`.
+   */
+  getExternalDiagnostics() {
+    return this.inner.getExternalDiagnostics?.() ?? [];
+  }
+  getActiveProviderName() {
+    return this.inner.getActiveProviderName();
+  }
+  dispose() {
+    const disposed = this.inner.dispose?.();
+    this.detach();
+    return disposed;
+  }
+  cancel() {
+    this.inner.cancel?.();
+  }
+  /**
+   * Every driver in the stack, outermost first: `driver`, then each inner driver down to the one
+   * that is not a decorator.
+   *
+   * For diagnostics and labelling only: behaviour must go through `AiDriver` members, which every
+   * layer forwards, never through a concrete class found here.
+   *
+   * @internal
+   */
+  static layers(driver) {
+    const layers = [driver];
+    let current = driver;
+    while (current instanceof _BaseDriverDecorator) {
+      current = current.inner;
+      layers.push(current);
+    }
+    return layers;
+  }
+};
+
 // src/components/orchestrating-driver/orchestrating-driver.ts
 var DEFAULT_MAX_HANDOFFS = 3;
 var DEFAULT_CLASSIFIER_HISTORY_LENGTH = 4;
@@ -8403,9 +8955,9 @@ Politely let the user know what you can help with and invite them to rephrase th
 
 ${UNROUTABLE_INSTRUCTION}`;
 }
-var OrchestratingDriver = class extends EventTarget {
+var OrchestratingDriver = class _OrchestratingDriver extends BaseDriverDecorator {
   constructor(providerRegistry, agents, options = {}) {
-    super();
+    super(_OrchestratingDriver.createInner(providerRegistry, agents, options));
     this.providerRegistry = providerRegistry;
     this.agents = agents;
     /**
@@ -8429,7 +8981,6 @@ var OrchestratingDriver = class extends EventTarget {
     this.maxHandoffs = options.maxHandoffs ?? DEFAULT_MAX_HANDOFFS;
     this.classifierHistoryLength = options.classifierHistoryLength ?? DEFAULT_CLASSIFIER_HISTORY_LENGTH;
     this.classifierRetries = options.classifierRetries ?? DEFAULT_CLASSIFIER_RETRIES;
-    validateStaticAgentProviders(agents, providerRegistry);
     this.specialists = agents.filter(isSpecialist).filter((a) => !a.excludeFromClassifier);
     const fallbacks = agents.filter(isFallback);
     if (fallbacks.length > 1) {
@@ -8439,51 +8990,10 @@ var OrchestratingDriver = class extends EventTarget {
     }
     const rawFallback = fallbacks[0];
     this.fallback = rawFallback ? { ...rawFallback, systemPrompt: buildFallbackSystemPrompt(rawFallback, this.specialists) } : void 0;
-    this.chatDriver = new ChatDriver(providerRegistry, {
-      maxToolIterations: options.maxToolIterations,
-      maxFoldOperations: options.maxFoldOperations,
-      maxTurnSnapshots: options.maxTurnSnapshots,
-      sessionKey: this.sessionKey,
-      activityBus: options.activityBus,
-      budgetExhaustedMessage: options.budgetExhaustedMessage,
-      aiServiceErrorMessages: options.aiServiceErrorMessages,
-      // This driver releases after the turn so it can fire the host-facing events; see the option.
-      deferAgentRelease: true
-    });
-    this.chatDriver.addEventListener("history-updated", (e) => {
-      this.dispatchEvent(new CustomEvent("history-updated", { detail: e.detail }));
-    });
-    this.chatDriver.addEventListener("sub-agent-history-updated", (e) => {
-      this.dispatchEvent(
-        new CustomEvent("sub-agent-history-updated", { detail: e.detail })
-      );
-    });
-    this.chatDriver.addEventListener("sub-agent-start", (e) => {
-      this.dispatchEvent(new CustomEvent("sub-agent-start", { detail: e.detail }));
-    });
-    this.chatDriver.addEventListener("sub-agent-stop", (e) => {
-      this.dispatchEvent(new CustomEvent("sub-agent-stop", { detail: e.detail }));
-    });
-    this.chatDriver.addEventListener("interaction-start", (e) => {
-      this.dispatchEvent(
-        new CustomEvent("interaction-start", { detail: e.detail })
-      );
-    });
-    this.chatDriver.addEventListener("interaction-stop", (e) => {
-      this.dispatchEvent(
-        new CustomEvent("interaction-stop", { detail: e.detail })
-      );
-    });
-    this.chatDriver.addEventListener("provider-changed", (e) => {
-      this.dispatchEvent(
-        new CustomEvent("provider-changed", { detail: e.detail })
-      );
-    });
-    this.chatDriver.addEventListener("external-cost-recorded", (e) => {
-      this.dispatchEvent(
-        new CustomEvent("external-cost-recorded", { detail: e.detail })
-      );
-    });
+  }
+  /** The inner driver this one built and routes onto. */
+  get chatDriver() {
+    return this.inner;
   }
   /**
    * The stateful-agent contract (§7.1): active agent, user pin, flow lock, restored state, and
@@ -8507,108 +9017,23 @@ var OrchestratingDriver = class extends EventTarget {
   get activeAgent() {
     return this.agentSession.getActive();
   }
-  resolveInteraction(interactionId, result) {
-    this.chatDriver.resolveInteraction(interactionId, result);
-  }
-  /** Delegated for the same reason as `resolveInteraction`: the history that owns the
-   *  interaction — and therefore the cost — lives on the wrapped driver, not here. */
-  recordExternalCost(interactionId, costUsd) {
-    return this.chatDriver.recordExternalCost(interactionId, costUsd);
-  }
-  getInteractionContext(interactionId) {
-    return this.chatDriver.getInteractionContext(interactionId);
-  }
-  isBusy() {
-    return this.chatDriver.isBusy();
-  }
-  /** Currently active provider name from the underlying ChatDriver. */
-  getActiveProviderName() {
-    return this.chatDriver.getActiveProviderName();
-  }
-  /**
-   * Pins routing to a specific agent by name. While pinned, the classifier is
-   * skipped and the continuation tool is hidden from the agent's tool list, so
-   * the agent cannot quietly hand back to the orchestrator. Pass `null` to
-   * return to automatic routing.
-   */
-  setPinnedAgent(name) {
-    this.agentSession.setPinned(name);
-  }
-  /**
-   * Set the flow-owner lock — used to restore state from Redux on driver
-   * reconstruction (agents-array changes, pop-in/pop-out). Not intended for
-   * external callers to manipulate routing; that's what `setPinnedAgent` is
-   * for.
-   */
-  setFlowOwner(name) {
-    this.agentSession.setFlowOwner(name);
-  }
-  loadHistory(messages) {
-    this.chatDriver.loadHistory(messages);
-  }
-  getRawHistory() {
-    return this.chatDriver.getHistory();
-  }
   /**
-   * Delegates to the inner {@link ChatDriver} — condensation policies are registered there, so it
-   * is the only object that knows which payloads the model has stopped seeing (GENC-1566).
-   *
-   * **This forward is the whole feature, for any multi-agent host.** `AiDriver` declares
-   * `getHistoryForPersistence` optional, and `SessionPersister` calls it through `?.`, falling back
-   * to {@link OrchestratingDriver.getRawHistory}. This class does NOT extend `ChatDriver` — it
-   * wraps one — so without an explicit forward the optional call resolves to `undefined` and every
-   * host on an orchestrating driver silently keeps persisting the full payloads. Measured exactly
-   * that way on a Create run: 10 `context.condensed` events fired, and the session still stored
-   * the two largest `read_context` results at 26,907 and 23,060 chars. The method existed, the
-   * tests passed, and the feature did nothing.
-   */
-  getHistoryForPersistence() {
-    return this.chatDriver.getHistoryForPersistence();
-  }
-  /**
-   * Delegates to the inner {@link ChatDriver}, which owns the condensation registry and clocks
-   * (GENC-1632). The forward matters for the same reason as `getHistoryForPersistence` above: the
-   * persister reaches it through `?.`, so a missing forward would compile, pass the ChatDriver
-   * tests, and do nothing for every orchestrated host — which is every host with an agents array.
+   * Build the inner driver, after validating the agents' providers, so a bad config throws before
+   * a driver exists to subscribe to the registry. Static because it runs before `super()`.
    */
-  getCondensePoliciesForPersistence(messages) {
-    return this.chatDriver.getCondensePoliciesForPersistence(messages);
-  }
-  /**
-   * Delegates to the inner {@link ChatDriver} (GENC-1632). The deferred activation stamp it
-   * performs is taken by the inner driver's `installAgent`, which this driver's own
-   * `installAgent` always reaches, so nothing extra is needed here.
-   */
-  restoreCondensePolicies(entries) {
-    return this.chatDriver.restoreCondensePolicies(entries);
-  }
-  /** {@inheritDoc AiDriver.setContextGuard} */
-  setContextGuard(policy) {
-    this.chatDriver.setContextGuard(policy);
-  }
-  /** {@inheritDoc AiDriver.compact} */
-  compact(options) {
-    return this.chatDriver.compact(options);
-  }
-  /** {@inheritDoc AiDriver.canCompact} */
-  canCompact(options) {
-    return this.chatDriver.canCompact(options);
-  }
-  /** {@inheritDoc AiDriver.getPreambleTokens} */
-  getPreambleTokens() {
-    return this.chatDriver.getPreambleTokens();
-  }
-  /** {@inheritDoc AiDriver.getCompactionPlan} */
-  getCompactionPlan(options) {
-    return this.chatDriver.getCompactionPlan(options);
-  }
-  /** Delegates to the inner {@link ChatDriver} — turns are captured there. */
-  getTurnSnapshots() {
-    return this.chatDriver.getTurnSnapshots();
-  }
-  /** Delegates to the inner {@link ChatDriver} — interactions resolve there, so it holds the buffer. */
-  getExternalDiagnostics() {
-    return this.chatDriver.getExternalDiagnostics();
+  static createInner(providerRegistry, agents, options = {}) {
+    validateStaticAgentProviders(agents, providerRegistry);
+    return new ChatDriver(providerRegistry, {
+      maxToolIterations: options.maxToolIterations,
+      maxFoldOperations: options.maxFoldOperations,
+      maxTurnSnapshots: options.maxTurnSnapshots,
+      sessionKey: options.sessionKey ?? "",
+      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.
+      deferAgentRelease: true
+    });
   }
   async getSuggestions(history, prompt2, count, allAgentInfo) {
     const pinned = this.resolvePinnedAgent();
@@ -8623,14 +9048,19 @@ var OrchestratingDriver = class extends EventTarget {
     }));
     return this.chatDriver.getSuggestions(history, prompt2, count, agentInfo);
   }
-  async sendMessage(input, attachments) {
+  async sendMessage(input, attachments, options) {
+    const delegated = options?.delegate ? {
+      delegate: options.delegate,
+      delegateFraming: options.delegateFraming ?? DEFAULT_DELEGATE_FRAMING
+    } : {};
     try {
-      return await this.runOrchestratedTurn(input, attachments);
+      return await this.runOrchestratedTurn(input, attachments, options, delegated);
     } catch (e) {
       const pendingUserMessage = this.userMessageAppended ? void 0 : {
         role: "user",
         content: input,
-        ...attachments ? { attachments } : {}
+        ...attachments ? { attachments } : {},
+        ...delegated
       };
       if (e instanceof BudgetExhaustedError) {
         return this.chatDriver.reportBudgetExhausted(e, pendingUserMessage);
@@ -8641,13 +9071,13 @@ var OrchestratingDriver = class extends EventTarget {
       throw e;
     }
   }
-  async runOrchestratedTurn(input, attachments) {
+  async runOrchestratedTurn(input, attachments, options, delegated) {
     this.cancelled = false;
     this.userMessageAppended = false;
     const history = this.chatDriver.getHistory();
     this.dispatchEvent(
       new CustomEvent("history-updated", {
-        detail: [...history, { role: "user", content: input, attachments }]
+        detail: [...history, { role: "user", content: input, attachments, ...delegated }]
       })
     );
     const pinned = this.resolvePinnedAgent();
@@ -8657,7 +9087,11 @@ var OrchestratingDriver = class extends EventTarget {
       this.recordRouting("pinned", pinned, { durationMs: 0 });
       routed = { agent: pinned, decision: "pinned" };
     } else {
-      routed = await this.classify(input, history, this.activeAgent);
+      routed = await this.classify(
+        delegated.delegate ? frameDelegatedContent(input, delegated.delegateFraming) : input,
+        history,
+        this.activeAgent
+      );
     }
     let currentAgent = routed.agent;
     let isHandoff = false;
@@ -8684,7 +9118,7 @@ var OrchestratingDriver = class extends EventTarget {
         result = await this.chatDriver.continueFromHistory(contextPrimer);
       } else {
         this.userMessageAppended = true;
-        result = await this.chatDriver.sendMessage(input, attachments);
+        result = await this.chatDriver.sendMessage(input, attachments, options);
       }
       lastResult = result;
       if (this.chatDriver.getAgentReleaseRequested()) {
@@ -8717,18 +9151,12 @@ var OrchestratingDriver = class extends EventTarget {
       this.chatDriver.reportStoppedBeforeTurn({
         role: "user",
         content: input,
-        ...attachments ? { attachments } : {}
+        ...attachments ? { attachments } : {},
+        ...delegated
       });
     }
     return lastResult?.reason === "done" ? lastResult : { reason: "done" };
   }
-  async continueFromHistory(transientPrimer, options) {
-    return this.chatDriver.continueFromHistory(transientPrimer, options);
-  }
-  /** {@inheritDoc AiDriver.primeRestoredAgentState} */
-  primeRestoredAgentState(snapshots) {
-    this.agentSession.primeRestoredStates(snapshots);
-  }
   /** {@inheritDoc AiDriver.canRestoreFlowOwner} */
   canRestoreFlowOwner(agentName) {
     return this.agents.some((a) => a.name === agentName);
@@ -8745,6 +9173,10 @@ var OrchestratingDriver = class extends EventTarget {
    * to classify, and a restored lock already says which agent owns the flow. `continueFromHistory`
    * on its own would not do — it neither routes nor installs, so it would run on whatever agent
    * happened to be installed (none, straight after a reload).
+   *
+   * Looks the owner up in its own agents list, so the `agent` argument is not needed and is
+   * ignored; and does not delegate to the inner driver's resume, which would install the agent
+   * undecorated.
    */
   async resumeRestoredFlow(resumeNote) {
     const owner = this.agentSession.getFlowOwner();
@@ -8781,15 +9213,8 @@ var OrchestratingDriver = class extends EventTarget {
     }
     return winner ? { ...winner, agentName, basis: "reachable-max" } : void 0;
   }
-  /** {@inheritDoc AiDriver.getActiveAgent} */
-  getActiveAgent() {
-    return this.agentSession.getActive();
-  }
   async installAgent(agent) {
-    const { previousAgent, flowOwnerChangedTo } = await this.agentSession.activate(agent);
-    if (flowOwnerChangedTo !== void 0) {
-      this.dispatchEvent(new CustomEvent("flow-owner-changed", { detail: flowOwnerChangedTo }));
-    }
+    const { previousAgent } = await this.agentSession.activate(agent);
     const isTerminal = isFallback(agent) || this.agentSession.getPinned() !== null || this.agentSession.getFlowOwner() !== null || !!(agent.onActivate || agent.onDeactivate);
     let agentToApply = agent;
     if (!isTerminal) {
@@ -8812,12 +9237,11 @@ var OrchestratingDriver = class extends EventTarget {
     this.chatDriver.setProviderHistoryTransform((h) => transformHistoryForAgent(h, agent.name));
     this.chatDriver.installAgent(agentToApply);
     this.dispatchEvent(new CustomEvent("orchestrating-stop"));
-    this.dispatchEvent(new CustomEvent("agent-changed", { detail: agent }));
   }
   /**
-   * Release the current stateful agent: fire `onDeactivate`, clear the
-   * flow-owner lock, dispatch events so the host (and Redux) reflect the
-   * unlocked state. Called automatically when a tool handler invokes
+   * 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
+   * the unlocked state (GENC-1485). Called automatically when a tool handler invokes
    * `context.releaseAgent`.
    *
    * The user-pin (`pinnedAgentName`) is intentionally *not* cleared — a user
@@ -8826,15 +9250,7 @@ var OrchestratingDriver = class extends EventTarget {
    * routing through the classifier.
    */
   async releaseActiveAgent() {
-    const released = await this.agentSession.release();
-    if (!released) return;
-    if (released.flowOwnerChangedTo !== void 0) {
-      this.dispatchEvent(
-        new CustomEvent("flow-owner-changed", { detail: released.flowOwnerChangedTo })
-      );
-    }
-    this.dispatchEvent(new CustomEvent("agent-released", { detail: released.previousAgent }));
-    this.dispatchEvent(new CustomEvent("agent-changed", { detail: void 0 }));
+    await this.agentSession.release();
   }
   /**
    * Stop the current turn (user "stop" button). Cancels the inner chat driver's
@@ -8853,6 +9269,7 @@ var OrchestratingDriver = class extends EventTarget {
   async dispose() {
     await this.agentSession.dispose();
     await this.chatDriver.dispose();
+    this.detach();
   }
   /**
    * Record one routing decision on the debug timeline — what was chosen, why, what it cost, and
@@ -8894,7 +9311,7 @@ var OrchestratingDriver = class extends EventTarget {
   classifierTranscript(history) {
     const lines = history.filter((m) => (m.role === "user" || m.role === "assistant") && reachesProvider(m)).filter((m) => !!m.content?.trim()).slice(-this.classifierHistoryLength).map((m) => {
       const speaker = m.role === "user" ? "User" : "Assistant";
-      const content = m.content ?? "";
+      const content = m.role === "user" && m.delegate ? frameDelegatedContent(m.content ?? "", m.delegateFraming) : m.content ?? "";
       const body = content.length > CLASSIFIER_MESSAGE_CHARS ? `${content.slice(0, CLASSIFIER_MESSAGE_CHARS)}\u2026` : content;
       return `${speaker}: ${body}`;
     });