nolo-cli 0.147.0-alpha.2 → 0.149.0-alpha.1

package/{handleSendMessageAction-2M57WHLO.js → handleSendMessageAction-DQAD5ERJ.js}

@@ -4,8 +4,11 @@ import {
 import {
   buildForegroundTurnAdmissionFetchInit,
   consumeAgentRunStream,
-  projectDesktopToolUiContent
-} from "./chunk-YYKMFBK7.js";
+  mergeAgentToolsWithRuntime,
+  projectDesktopToolUiContent,
+  resolveTurnToolContext
+} from "./chunk-TB3MIBRC.js";
+import "./chunk-O2OWEFII.js";
 import {
   CONTEXT_OVERFLOW_ACTIONS,
   CONTEXT_TOO_LARGE_ACTIONS,
@@ -13,14 +16,20 @@ import {
 } from "./chunk-OCZKATRC.js";
 import {
   performServerProxyFetchWithRetry
-} from "./chunk-JK5XW3NO.js";
+} from "./chunk-HTVYCXBP.js";
 import {
   createSSEParser,
   resolveAgentRequiredPackIds,
   waitForAbortableDelay
-} from "./chunk-BJ3KD73I.js";
+} from "./chunk-ATLTFRYJ.js";
 import "./chunk-NF64D32W.js";
 import "./chunk-3L2WKC3W.js";
+import "./chunk-TXH4IWJL.js";
+import "./chunk-XPRWFQQK.js";
+import "./chunk-UQNS32WZ.js";
+import "./chunk-MEYIRKDN.js";
+import "./chunk-36KZDDO5.js";
+import "./chunk-ZJ7UHBJS.js";
 import {
   initMsgs,
   messageStreamEnd,
@@ -32,14 +41,14 @@ import {
   setMessages,
   setStreamingMessageId,
   updateToolMessage
-} from "./chunk-PZ3HKBET.js";
+} from "./chunk-ACQD6YI2.js";
 import "./chunk-523DITKR.js";
 import "./chunk-YYLHWIW6.js";
 import "./chunk-6O4IK4V2.js";
 import {
   streamAgentChatTurn
-} from "./chunk-UC3Q7X3J.js";
-import "./chunk-D76D3RTR.js";
+} from "./chunk-TZZ2WRBL.js";
+import "./chunk-Z4CSIXYP.js";
 import "./chunk-5RGU3J7P.js";
 import "./chunk-M76ECQRD.js";
 import {
@@ -49,6 +58,8 @@ import {
 } from "./chunk-B6SAMB33.js";
 import "./chunk-YDH3FDFQ.js";
 import "./chunk-MX574M24.js";
+import "./chunk-4DPP773Q.js";
+import "./chunk-VIDPVFP3.js";
 import "./chunk-AGGIDPCZ.js";
 import "./chunk-B2XUQXQX.js";
 import {
@@ -56,8 +67,9 @@ import {
 } from "./chunk-6TPOEJMQ.js";
 import "./chunk-AUDNYVRC.js";
 import "./chunk-KHCLMKZZ.js";
-import "./chunk-ZSPC3ZTC.js";
-import "./chunk-ELYEQNUI.js";
+import "./chunk-PQWU42UQ.js";
+import "./chunk-AKG5W4LG.js";
+import "./chunk-RYZINGPM.js";
 import "./chunk-PSCNXBYA.js";
 import "./chunk-L36OWPP3.js";
 import "./chunk-BYXBJQAS.js";
@@ -66,9 +78,11 @@ import "./chunk-7KVZ5LDQ.js";
 import "./chunk-HNMXYYJR.js";
 import "./chunk-3BXNTXYI.js";
 import "./chunk-W7XHHYWM.js";
-import "./chunk-B7ANJQWZ.js";
+import "./chunk-RSEEDUMS.js";
 import "./chunk-UAD2WT54.js";
 import "./chunk-ZWQUWF6W.js";
+import "./chunk-HDLLCBRF.js";
+import "./chunk-4VJAC32I.js";
 import {
   canonicalizeToolName
 } from "./chunk-XUWRURDF.js";
@@ -79,22 +93,22 @@ import {
 } from "./chunk-Y3PMXGLH.js";
 import {
   selectCurrentServer
-} from "./chunk-3IYMTWYZ.js";
+} from "./chunk-SONWNI3L.js";
 import "./chunk-Y5GCAMGP.js";
 import "./chunk-QDSINZM3.js";
 import "./chunk-KX6YBIHG.js";
 import {
   readAndWait,
   selectById
-} from "./chunk-QALRKMHF.js";
-import "./chunk-ETZWFV6M.js";
+} from "./chunk-HYZIYH2H.js";
+import "./chunk-7CHC4W22.js";
 import {
   createDialogMessageKeyAndId
 } from "./chunk-3AH7LNUB.js";
 import "./chunk-WWC7I6TA.js";
 import "./chunk-QSJ3HFEF.js";
-import "./chunk-EFZKILX6.js";
-import "./chunk-AUXHZ2M5.js";
+import "./chunk-IAESIMK7.js";
+import "./chunk-WIWM4FE3.js";
 import {
   getIsDesktopApp
 } from "./chunk-QOKAKDPE.js";
@@ -117,13 +131,8 @@ import "./chunk-CF7PE763.js";
 import "./chunk-G3SUCT4W.js";
 import "./chunk-4VNS5WPM.js";
 
-// packages/ai/agent/serverOwnedWebForegroundEligibility.ts
-var DURABLE_WEB_FOREGROUND_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "ask_user",
-  "exa_search",
-  "fetchWebpage"
-]);
-function readToolName(value) {
+// packages/ai/tools/effectiveToolSurface.ts
+function readEffectiveToolName(value) {
   if (typeof value === "string") {
     const name2 = canonicalizeToolName(value.trim());
     return name2 || null;
@@ -134,12 +143,28 @@ function readToolName(value) {
   const name = canonicalizeToolName(candidate.trim());
   return name || null;
 }
-function configuredToolNames(agent) {
-  const values = [];
-  if (Array.isArray(agent.tools)) values.push(...agent.tools);
-  if (Array.isArray(agent.toolNames)) values.push(...agent.toolNames);
+function valuesOf(iterable) {
+  return iterable ? [...iterable] : [];
+}
+function resolveEffectiveToolSurface(input) {
+  const agent = input.agent ?? {};
+  const byName = /* @__PURE__ */ new Map();
+  const add = (values, source) => {
+    for (const value of values) {
+      const name = readEffectiveToolName(value);
+      if (!name) continue;
+      let sources = byName.get(name);
+      if (!sources) {
+        sources = /* @__PURE__ */ new Set();
+        byName.set(name, sources);
+      }
+      sources.add(source);
+    }
+  };
+  add(Array.isArray(agent.tools) ? agent.tools : [], "explicit");
+  add(Array.isArray(agent.toolNames) ? agent.toolNames : [], "explicit");
   const requiredPackIds = resolveAgentRequiredPackIds(agent);
-  values.push(...expandEnabledPacks(requiredPackIds));
+  add(expandEnabledPacks(requiredPackIds), "required-pack");
   const policies = [
     agent.runtimeToolPolicy,
     agent.runtimeBinding?.runtimeToolPolicy,
@@ -147,38 +172,152 @@ function configuredToolNames(agent) {
   ];
   for (const policy of policies) {
     if (!policy || typeof policy !== "object") continue;
-    if (Array.isArray(policy.agentTools)) values.push(...policy.agentTools);
-    if (Array.isArray(policy.runtimeTools)) values.push(...policy.runtimeTools);
+    add(Array.isArray(policy.agentTools) ? policy.agentTools : [], "runtime-policy");
+    add(Array.isArray(policy.runtimeTools) ? policy.runtimeTools : [], "runtime-policy");
   }
-  return [...new Set(values.map(readToolName).filter((name) => !!name))];
-}
-function hasSupportedDurableToolSurface(agent) {
-  const policies = [
-    agent.runtimeToolPolicy,
-    agent.runtimeBinding?.runtimeToolPolicy,
-    agent.runtimeBinding?.runtimeToolPolicySnapshot
+  add(Array.isArray(agent.referencedTools) ? agent.referencedTools : [], "reference");
+  add(valuesOf(input.referencedToolNames), "reference");
+  add(valuesOf(input.mentionedToolNames), "mention");
+  add(valuesOf(input.hostInjectedToolNames), "host-injected");
+  add(valuesOf(input.runtimeExtraToolNames), "runtime-extra");
+  const disabled = new Set(
+    (Array.isArray(agent.disabledTools) ? agent.disabledTools : []).map(readEffectiveToolName).filter((name) => !!name)
+  );
+  for (const name of disabled) byName.delete(name);
+  const entries = [...byName.entries()].map(
+    ([name, sources]) => ({ name, sources: [...sources] })
+  );
+  const requestedSources = /* @__PURE__ */ new Set([
+    "explicit",
+    "required-pack",
+    "runtime-policy",
+    "reference",
+    "mention",
+    "runtime-extra"
+  ]);
+  const requestedNames = entries.filter((entry) => entry.sources.some((source) => requestedSources.has(source))).map((entry) => entry.name);
+  const hostInjectedNames = entries.filter((entry) => entry.sources.includes("host-injected")).map((entry) => entry.name);
+  const shellEnabled = policies.some(
+    (policy) => policy && typeof policy === "object" && policy.shell?.enabled === true
+  );
+  const workspaceModes = [
+    ...new Set(
+      policies.map(
+        (policy) => policy && typeof policy === "object" && typeof policy.workspace?.mode === "string" ? policy.workspace.mode.trim() : ""
+      ).filter(Boolean)
+    )
   ];
-  if (policies.some(
-    (policy) => policy && typeof policy === "object" && (policy.shell?.enabled === true || policy.workspace?.mode === "lease")
-  )) {
+  return {
+    names: entries.map((entry) => entry.name),
+    entries,
+    requestedNames,
+    hostInjectedNames,
+    shellEnabled,
+    workspaceModes,
+    workspaceLease: workspaceModes.includes("lease")
+  };
+}
+
+// packages/ai/agent/serverOwnedWebForegroundEligibility.ts
+var DURABLE_WEB_FOREGROUND_INTERACTIVE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "ask_user"
+]);
+var DURABLE_WEB_FOREGROUND_READ_ONLY_TOOL_NAMES = /* @__PURE__ */ new Set([
+  // Network read-only tools.
+  "exa_search",
+  "fetchWebpage",
+  // Dialog search backed by the server workspace executor.
+  "searchDialogMessages",
+  // Nolo workspace read/query tools.
+  "listDialogs",
+  "readDialog",
+  "queryDialogsBySubjectRef",
+  "listAgents",
+  "readAgent",
+  "listSpaces",
+  "readSpace",
+  "readDoc",
+  "readSkillDoc",
+  "listTables",
+  "queryTableRows"
+]);
+var DURABLE_WEB_FOREGROUND_TOOL_NAMES = /* @__PURE__ */ new Set([
+  ...DURABLE_WEB_FOREGROUND_INTERACTIVE_TOOL_NAMES,
+  ...DURABLE_WEB_FOREGROUND_READ_ONLY_TOOL_NAMES
+]);
+var AUDITED_WEB_FOREGROUND_HOST_BASELINE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  // TOOL_PACKS.CORE
+  "read",
+  "readFile",
+  "createDoc",
+  "updateDoc",
+  "search_workspace",
+  "updateSelf",
+  "ask_user",
+  "createAgentAutomation",
+  "updateAgentAutomation",
+  "deleteAgentAutomation",
+  "notifyUser",
+  // ALWAYS_ON_PACK_IDS: long-term-memory + skills
+  "queryMemory",
+  "rememberMemory",
+  "deleteMemory",
+  "loadSkill",
+  "readSkillDoc",
+  // Default system capabilities
+  "exa_search",
+  "fetchWebpage",
+  "setTodoList",
+  "startAgentRun",
+  "controlAgentRun",
+  "listAgents"
+]);
+function isDurableRequestedToolName(name) {
+  return typeof name === "string" && DURABLE_WEB_FOREGROUND_TOOL_NAMES.has(canonicalizeToolName(name));
+}
+function hasSupportedDurableToolSurface(agent, suppliedSurface) {
+  const surface = suppliedSurface ?? resolveEffectiveToolSurface({
+    agent
+  });
+  if (surface.shellEnabled || surface.workspaceLease) return false;
+  if (!surface.requestedNames.every(isDurableRequestedToolName)) {
     return false;
   }
-  const names = configuredToolNames(agent);
-  return names.length === 0 || names.every((name) => DURABLE_WEB_FOREGROUND_TOOL_NAMES.has(name));
+  return surface.hostInjectedNames.every(
+    (name) => AUDITED_WEB_FOREGROUND_HOST_BASELINE_TOOL_NAMES.has(canonicalizeToolName(name))
+  );
 }
 function shouldUseServerOwnedWebForegroundTurn(input) {
   if (input.surface !== "web") return false;
   if (input.isDesktopApp) return false;
   if (!input.currentServer?.trim() || !input.token?.trim()) return false;
   if (typeof input.userInput !== "string" || !input.userInput.trim()) return false;
+  if (input.turnToolContext) {
+    if (!input.turnToolContext.complete) return false;
+    if (input.turnToolContext.unresolvedReasons?.length) return false;
+    if (!input.effectiveToolSurface) {
+      const lateBound = [
+        ...input.turnToolContext.referencedToolNames,
+        ...input.turnToolContext.mentionedToolNames
+      ];
+      if (lateBound.some((name) => !isDurableRequestedToolName(name))) {
+        return false;
+      }
+    }
+  }
   const agent = input.agentConfig;
   if (!agent) return false;
   if (agent.useServerProxy === false) return false;
   if (agent.apiSource === "cli") return false;
   if (agent.runtimeBinding?.machineId) return false;
-  if (!hasSupportedDurableToolSurface(agent)) return false;
+  if (!hasSupportedDurableToolSurface(agent, input.effectiveToolSurface)) return false;
   const runtimeOptions = input.runtimeOptions;
-  if (runtimeOptions?.extraTools?.length) return false;
+  if (runtimeOptions?.extraTools?.length) {
+    if (!input.effectiveToolSurface) return false;
+    if (runtimeOptions.extraTools.some((name) => !isDurableRequestedToolName(name))) {
+      return false;
+    }
+  }
   if (runtimeOptions?.editingTarget) return false;
   if (runtimeOptions?.imageConfigOverride) return false;
   if (runtimeOptions?.quickChatModelOverride) return false;
@@ -331,19 +470,55 @@ function createServerOwnedToolProjection(args) {
 }
 
 // packages/ai/agent/serverOwnedWebForegroundHandoff.ts
+function normalizeComparableText(value) {
+  if (typeof value === "string") {
+    return value.replace(/\r\n/g, "\n").trimEnd();
+  }
+  if (!Array.isArray(value)) return "";
+  return value.flatMap((part) => {
+    if (!part || typeof part !== "object") return [];
+    const record = part;
+    if (record.type === "text" && typeof record.text === "string") {
+      return [record.text];
+    }
+    return [];
+  }).join("").replace(/\r\n/g, "\n").trimEnd();
+}
 function assistantText(message) {
-  return typeof message.content === "string" ? message.content : "";
+  return normalizeComparableText(message.content);
 }
-function findNewCanonicalAssistant(messages, initialMessageIds, transientId, expectedText) {
+function assistantThinking(message) {
+  const value = typeof message.thinkContent === "string" ? message.thinkContent : typeof message.reasoning_content === "string" ? message.reasoning_content : "";
+  return normalizeComparableText(value);
+}
+function assistantAgentKey(message) {
+  const value = message.agentKey ?? message.cybotKey;
+  return typeof value === "string" ? value : "";
+}
+function findNewCanonicalAssistant(messages, initialMessageIds, transientId, expectedText, expectedThinking, expectedAgentKey) {
   const transient = messages.find((message) => message?.id === transientId);
-  const completedText = expectedText || (transient ? assistantText(transient) : "");
-  for (const message of messages) {
-    if (!message?.id || message.id === transientId) continue;
-    if (initialMessageIds.has(message.id)) continue;
-    if (message.role !== "assistant") continue;
-    if (message.isStreaming) continue;
-    if (completedText && assistantText(message) !== completedText) continue;
-    return message;
+  const completedText = normalizeComparableText(
+    expectedText !== void 0 ? expectedText : transient ? assistantText(transient) : ""
+  );
+  const completedThinking = normalizeComparableText(
+    expectedThinking !== void 0 ? expectedThinking : transient ? assistantThinking(transient) : ""
+  );
+  const candidates = messages.filter((message) => {
+    if (!message?.id || message.id === transientId) return false;
+    if (initialMessageIds.has(message.id)) return false;
+    if (message.role !== "assistant") return false;
+    if (message.isStreaming) return false;
+    if (completedText) return assistantText(message) === completedText;
+    if (completedThinking) return assistantThinking(message) === completedThinking;
+    return false;
+  });
+  if (candidates.length === 0) return null;
+  if (candidates.length === 1) return candidates[0] ?? null;
+  if (expectedAgentKey) {
+    const agentMatches = candidates.filter(
+      (message) => assistantAgentKey(message) === expectedAgentKey
+    );
+    if (agentMatches.length === 1) return agentMatches[0] ?? null;
   }
   return null;
 }
@@ -356,7 +531,9 @@ async function waitForNewCanonicalAssistant(args) {
       args.readMessages(),
       args.initialMessageIds,
       args.transientId,
-      args.expectedText
+      args.expectedText,
+      args.expectedThinking,
+      args.expectedAgentKey
     );
     if (canonical) return canonical;
     if (Date.now() >= deadline) return null;
@@ -364,18 +541,106 @@ async function waitForNewCanonicalAssistant(args) {
   }
 }
 
+// packages/ai/agent/serverOwnedWebEffectiveToolSurface.ts
+function resolveServerOwnedWebEffectiveToolSurface(args) {
+  const referencedToolNames = args.turnToolContext?.referencedToolNames ?? [];
+  const mentionedToolNames = args.turnToolContext?.mentionedToolNames ?? [];
+  const requested = resolveEffectiveToolSurface({
+    agent: args.agentConfig,
+    referencedToolNames,
+    mentionedToolNames,
+    runtimeExtraToolNames: args.runtimeOptions?.extraTools ?? []
+  });
+  const mergedAgent = mergeAgentToolsWithRuntime(
+    args.agentConfig,
+    referencedToolNames,
+    mentionedToolNames,
+    args.runtimeOptions ?? void 0,
+    args.state
+  );
+  const rawNames = (Array.isArray(mergedAgent.tools) ? mergedAgent.tools : []).map(readEffectiveToolName).filter((name) => typeof name === "string" && !!name);
+  const finalNames = Array.from(new Set(rawNames));
+  const finalSet = new Set(finalNames);
+  const requestedSet = new Set(requested.requestedNames);
+  const requestedNames = requested.requestedNames.filter((name) => finalSet.has(name));
+  const hostInjectedNames = finalNames.filter((name) => !requestedSet.has(name));
+  const hostResolved = resolveEffectiveToolSurface({
+    agent: args.agentConfig,
+    referencedToolNames,
+    mentionedToolNames,
+    hostInjectedToolNames: hostInjectedNames,
+    runtimeExtraToolNames: args.runtimeOptions?.extraTools ?? []
+  });
+  const entryByName = new Map(hostResolved.entries.map((entry) => [entry.name, entry]));
+  const entries = finalNames.flatMap((name) => {
+    const entry = entryByName.get(name);
+    return entry ? [entry] : [];
+  });
+  return {
+    names: finalNames,
+    entries,
+    requestedNames,
+    hostInjectedNames,
+    shellEnabled: hostResolved.shellEnabled,
+    workspaceModes: hostResolved.workspaceModes,
+    workspaceLease: hostResolved.workspaceLease
+  };
+}
+
+// packages/ai/agent/serverOwnedAssistantStream.ts
+var EMPTY_SERVER_OWNED_ASSISTANT_STREAM = {
+  text: "",
+  thinking: "",
+  segmentText: "",
+  segmentThinking: ""
+};
+function applyServerOwnedAssistantStreamPayload(state, payload) {
+  if (payload?.type === "thinking" && typeof payload.content === "string") {
+    return {
+      ...state,
+      thinking: state.thinking + payload.content,
+      segmentThinking: state.segmentThinking + payload.content
+    };
+  }
+  if (payload?.type === "text" && typeof payload.content === "string") {
+    return {
+      ...state,
+      text: state.text + payload.content,
+      segmentText: state.segmentText + payload.content
+    };
+  }
+  if (payload?.type === "assistant_tool_calls") {
+    if (!state.segmentText && !state.segmentThinking) return state;
+    return {
+      ...state,
+      segmentText: "",
+      segmentThinking: ""
+    };
+  }
+  return state;
+}
+
 // packages/ai/agent/serverOwnedWebForegroundTurn.ts
+function resolveServerOwnedWebAllowedToolNames(toolNames) {
+  return Array.from(
+    new Set(
+      toolNames.filter((name) => typeof name === "string").map((name) => canonicalizeToolName(name)).filter((name) => DURABLE_WEB_FOREGROUND_TOOL_NAMES.has(name))
+    )
+  );
+}
 function detectServerOwnedCandidateSurface() {
   return typeof window !== "undefined" && typeof document !== "undefined" ? "web" : "non-web";
 }
 async function canRunServerOwnedWebForegroundTurn(args, thunk) {
   try {
+    let state;
     let currentServer;
     let token;
     try {
-      const state = thunk.getState();
+      state = thunk.getState();
       currentServer = selectCurrentServer(state);
-      token = selectIdentityToken(state);
+      const rawToken = selectIdentityToken(state);
+      token = typeof rawToken === "string" ? rawToken : void 0;
     } catch {
       return { eligible: false };
     }
@@ -383,23 +648,47 @@ async function canRunServerOwnedWebForegroundTurn(args, thunk) {
     let agentConfig = args.agentConfig ?? void 0;
     if (!agentConfig) {
       try {
-        const { readAndWait: readAndWait2 } = await import("./dbSlice-HFPIJT5P.js");
+        const { readAndWait: readAndWait2 } = await import("./dbSlice-DQ32LYTJ.js");
         agentConfig = await thunk.dispatch(readAndWait2(args.agentKey)).unwrap();
       } catch {
         return { eligible: false };
       }
     }
+    if (!agentConfig) return { eligible: false };
+    const turnToolContext = await resolveTurnToolContext({
+      agentConfig,
+      dialogConfig: args.dialogConfig,
+      userInput: args.userInput,
+      state,
+      dispatch: thunk.dispatch,
+      runtimeOptions: args.runtimeOptions
+    });
+    const effectiveToolSurface = resolveServerOwnedWebEffectiveToolSurface({
+      agentConfig,
+      runtimeOptions: args.runtimeOptions,
+      state,
+      turnToolContext
+    });
+    const eligible = shouldUseServerOwnedWebForegroundTurn({
+      surface: detectServerOwnedCandidateSurface(),
+      agentConfig,
+      effectiveToolSurface,
+      turnToolContext,
+      userInput: args.userInput,
+      runtimeOptions: args.runtimeOptions,
+      currentServer,
+      token,
+      isDesktopApp: getIsDesktopApp()
+    });
+    if (!eligible) {
+      return { eligible: false, agentConfig };
+    }
     return {
-      eligible: shouldUseServerOwnedWebForegroundTurn({
-        surface: detectServerOwnedCandidateSurface(),
-        agentConfig,
-        userInput: args.userInput,
-        runtimeOptions: args.runtimeOptions,
-        currentServer,
-        token,
-        isDesktopApp: getIsDesktopApp()
-      }),
-      agentConfig
+      eligible: true,
+      agentConfig: {
+        ...agentConfig,
+        tools: resolveServerOwnedWebAllowedToolNames(effectiveToolSurface.names)
+      }
     };
   } catch {
     return { eligible: false };
@@ -428,8 +717,9 @@ async function runServerOwnedWebForegroundTurn(args, thunk) {
   const { key: transientKey, messageId: transientId } = createDialogMessageKeyAndId(dialogId);
   const controller = new AbortController();
   const loopKey = `server-owned:${dialogId}:${transientId}`;
-  let accumulated = "";
+  let assistantStream = EMPTY_SERVER_OWNED_ASSISTANT_STREAM;
   let sawDone = false;
+  let clientControllerReleased = false;
   const toolProjection = createServerOwnedToolProjection({
     dialogId,
     dispatch: thunk.dispatch,
@@ -441,18 +731,68 @@ async function runServerOwnedWebForegroundTurn(args, thunk) {
     supportedToolNames: DURABLE_WEB_FOREGROUND_TOOL_NAMES,
     keepReadOnlyUntilCanonical: ["ask_user"]
   });
+  const projectAssistant = () => {
+    thunk.dispatch(
+      messageStreaming({
+        id: transientId,
+        dialogId,
+        dbKey: transientKey,
+        role: "assistant",
+        content: assistantStream.text,
+        thinkContent: assistantStream.thinking,
+        cybotKey: args.agentKey,
+        agentKey: args.agentKey,
+        userId
+      })
+    );
+  };
+  const releaseClientController = () => {
+    if (clientControllerReleased) return;
+    clientControllerReleased = true;
+    thunk.dispatch(removeActiveController({ messageId: loopKey, dialogKey }));
+  };
+  const finishTransientImmediately = () => {
+    const transient = selectAllMsgs(thunk.getState(), dialogId).find((message) => message?.id === transientId);
+    if (transient) {
+      thunk.dispatch(
+        setMessages({
+          dialogId,
+          messages: [{
+            ...transient,
+            content: assistantStream.text,
+            thinkContent: assistantStream.thinking,
+            isStreaming: false
+          }]
+        })
+      );
+    }
+    setStreamingMessageId(dialogId, null);
+  };
+  const removeTransientWhenCanonicalArrives = () => {
+    void waitForNewCanonicalAssistant({
+      readMessages: () => selectAllMsgs(thunk.getState(), dialogId),
+      initialMessageIds,
+      transientId,
+      // The server persists a new assistant trace segment after every tool
+      // boundary. Fingerprint only the final segment here; the live transient
+      // intentionally keeps the concatenated presentation until canonical rows
+      // replace it.
+      expectedText: assistantStream.segmentText,
+      expectedThinking: assistantStream.segmentThinking,
+      expectedAgentKey: args.agentKey,
+      timeoutMs: 6e4,
+      pollMs: 100
+    }).then((canonical) => {
+      if (!canonical) return;
+      toolProjection.cleanup();
+      thunk.dispatch(removeTransientMessage({ id: transientId, dialogId }));
+    }).catch(() => {
+    });
+  };
   thunk.dispatch(addActiveController({ messageId: loopKey, controller, dialogKey }));
-  thunk.dispatch(
-    messageStreaming({
-      id: transientId,
-      dialogId,
-      dbKey: transientKey,
-      role: "assistant",
-      content: "",
-      cybotKey: args.agentKey,
-      agentKey: args.agentKey,
-      userId
-    })
+  projectAssistant();
+  const allowedToolNames = resolveServerOwnedWebAllowedToolNames(
+    Array.isArray(args.agentConfig.tools) ? args.agentConfig.tools : []
   );
   const body = JSON.stringify({
     agentKey: args.agentKey,
@@ -472,6 +812,11 @@ async function runServerOwnedWebForegroundTurn(args, thunk) {
         "client-user-prepersisted",
         "durable-tool-cards"
       ],
+      // This is the exact post-filter surface produced during admission, not a
+      // global durable superset. Server-private defaults and machine tools are
+      // injected before this constraint, then intersected back to this turn's
+      // admitted names. Direct run() callers are sanitized again above.
+      allowedToolNames,
       ...args.dialogConfig.agentMode === "auto" ? { dialogAgentMode: "auto" } : { dialogAgentMode: "fixed" }
     },
     ...args.runtimeOptions ? { runtimeOptions: args.runtimeOptions } : {},
@@ -526,20 +871,13 @@ async function runServerOwnedWebForegroundTurn(args, thunk) {
           return { reject: payload.message || "Agent execution failed" };
         }
         toolProjection.handlePayload(payload);
-        if (payload?.type === "text" && typeof payload.content === "string") {
-          accumulated += payload.content;
-          thunk.dispatch(
-            messageStreaming({
-              id: transientId,
-              dialogId,
-              dbKey: transientKey,
-              role: "assistant",
-              content: accumulated,
-              cybotKey: args.agentKey,
-              agentKey: args.agentKey,
-              userId
-            })
-          );
+        const nextAssistantStream = applyServerOwnedAssistantStreamPayload(
+          assistantStream,
+          payload
+        );
+        if (nextAssistantStream !== assistantStream) {
+          assistantStream = nextAssistantStream;
+          projectAssistant();
         }
       }
     });
@@ -547,6 +885,7 @@ async function runServerOwnedWebForegroundTurn(args, thunk) {
     if (outcome.outcome === "rejected") throw new Error(outcome.message);
     if (!outcome.sawDone) return { serverOwned: true, detached: true };
     sawDone = true;
+    finishTransientImmediately();
     let canonicalVisible = false;
     try {
       await thunk.dispatch(initMsgs({ dialogId })).unwrap();
@@ -554,7 +893,11 @@ async function runServerOwnedWebForegroundTurn(args, thunk) {
         readMessages: () => selectAllMsgs(thunk.getState(), dialogId),
         initialMessageIds,
         transientId,
-        expectedText: accumulated
+        expectedText: assistantStream.segmentText,
+        expectedThinking: assistantStream.segmentThinking,
+        expectedAgentKey: args.agentKey,
+        timeoutMs: 350,
+        pollMs: 25
       });
     } catch (error) {
       console.warn("[chat] server-owned canonical handoff refresh failed", {
@@ -567,24 +910,15 @@ async function runServerOwnedWebForegroundTurn(args, thunk) {
       thunk.dispatch(removeTransientMessage({ id: transientId, dialogId }));
     } else {
       toolProjection.cleanup();
-      const transient = selectAllMsgs(thunk.getState(), dialogId).find((message) => message?.id === transientId);
-      if (transient) {
-        thunk.dispatch(
-          setMessages({
-            dialogId,
-            messages: [{ ...transient, isStreaming: false }]
-          })
-        );
-      }
-      setStreamingMessageId(dialogId, null);
+      removeTransientWhenCanonicalArrives();
       console.warn(
-        "[chat] server-owned canonical message not visible after done; keeping transient projection",
+        "[chat] server-owned canonical message not visible after done; keeping finished transient until canonical arrives",
         { dialogId, transientId }
       );
     }
     return { serverOwned: true };
   } finally {
-    thunk.dispatch(removeActiveController({ messageId: loopKey, dialogKey }));
+    releaseClientController();
     if (!sawDone) {
       toolProjection.cleanup();
       thunk.dispatch(removeTransientMessage({ id: transientId, dialogId }));