nolo-cli 0.148.0-alpha.1 → 0.151.0-alpha.2

package/{handleSendMessageAction-EGNWHAUB.js → handleSendMessageAction-DVG5U26T.js}

@@ -7,130 +7,180 @@ import {
   mergeAgentToolsWithRuntime,
   projectDesktopToolUiContent,
   resolveTurnToolContext
-} from "./chunk-HUFPWXFW.js";
-import "./chunk-O2OWEFII.js";
+} from "./chunk-T6X3D7NB.js";
+import "./chunk-KFHQQ3NO.js";
 import {
   CONTEXT_OVERFLOW_ACTIONS,
   CONTEXT_TOO_LARGE_ACTIONS,
-  isContextOverflowText
-} from "./chunk-OCZKATRC.js";
-import {
+  extractErrorDiagnostics,
+  isContextOverflowText,
   performServerProxyFetchWithRetry
-} from "./chunk-T767MPHB.js";
+} from "./chunk-SMENBO3M.js";
 import {
   createSSEParser,
   resolveAgentRequiredPackIds,
   waitForAbortableDelay
-} from "./chunk-BKWMNZ2X.js";
+} from "./chunk-ES633ZS5.js";
 import "./chunk-NF64D32W.js";
-import "./chunk-3L2WKC3W.js";
-import "./chunk-T7F46O36.js";
-import "./chunk-XPRWFQQK.js";
-import "./chunk-UQNS32WZ.js";
-import "./chunk-MEYIRKDN.js";
-import "./chunk-QU5A4LYX.js";
-import "./chunk-ZJ7UHBJS.js";
+import "./chunk-XPWGOTBQ.js";
+import "./chunk-ZIWPQEFU.js";
+import "./chunk-CBHGZRCE.js";
+import "./chunk-SCMHQUMK.js";
+import "./chunk-RSHPU4PD.js";
+import "./chunk-VIDPVFP3.js";
+import "./chunk-AGIM7IMJ.js";
+import "./chunk-GQN2WLAI.js";
+import "./chunk-ZKZ5X2HS.js";
 import {
+  clearForegroundTurnSettledVisible,
   initMsgs,
+  markForegroundTurnSettledVisible,
   messageStreamEnd,
   messageStreaming,
   prepareAndPersistUserMessage,
+  protectTransientForCanonicalHandoff,
+  releaseTransientCanonicalHandoff,
   removeTransientMessage,
   resolveHandleSendMessageContext,
   selectAllMsgs,
   setMessages,
   setStreamingMessageId,
+  toolResultNeedsUserConfirmation,
   updateToolMessage
-} from "./chunk-42Z3EMC4.js";
+} from "./chunk-556RW72X.js";
 import "./chunk-523DITKR.js";
-import "./chunk-YYLHWIW6.js";
-import "./chunk-6O4IK4V2.js";
+import "./chunk-UKZX3NHN.js";
+import "./chunk-OFFL4DCR.js";
+import "./chunk-QYPE3TS3.js";
 import {
   streamAgentChatTurn
-} from "./chunk-LPVCRQMM.js";
-import "./chunk-Z4CSIXYP.js";
+} from "./chunk-IZ7OJB6K.js";
+import "./chunk-4JH2UMJR.js";
+import "./chunk-ZJ7UHBJS.js";
+import "./chunk-BYXBJQAS.js";
+import "./chunk-PLSVXHSA.js";
 import "./chunk-5RGU3J7P.js";
-import "./chunk-M76ECQRD.js";
 import {
   addActiveController,
   getActiveDialogKey,
   removeActiveController
-} from "./chunk-B6SAMB33.js";
+} from "./chunk-OWYYDMGJ.js";
+import "./chunk-ZRAU6T47.js";
+import "./chunk-4LCOCOR5.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 {
-  expandEnabledPacks
-} from "./chunk-6TPOEJMQ.js";
-import "./chunk-AUDNYVRC.js";
-import "./chunk-KHCLMKZZ.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";
-import "./chunk-DWLEOOGR.js";
-import "./chunk-7KVZ5LDQ.js";
-import "./chunk-HNMXYYJR.js";
-import "./chunk-3BXNTXYI.js";
-import "./chunk-W7XHHYWM.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";
-import "./chunk-5J3PYNUP.js";
-import "./chunk-CYSYR67N.js";
-import {
-  PLATFORM_LLM_BUSY_USER_MESSAGE
-} from "./chunk-Y3PMXGLH.js";
 import {
   selectCurrentServer
-} from "./chunk-SONWNI3L.js";
-import "./chunk-Y5GCAMGP.js";
-import "./chunk-QDSINZM3.js";
-import "./chunk-KX6YBIHG.js";
+} from "./chunk-QFEW2ULV.js";
+import "./chunk-XI7DGLUK.js";
+import "./chunk-EDX5XSJM.js";
+import "./chunk-UAD2WT54.js";
 import {
   readAndWait,
   selectById
-} from "./chunk-HYZIYH2H.js";
-import "./chunk-7CHC4W22.js";
-import {
-  createDialogMessageKeyAndId
-} from "./chunk-3AH7LNUB.js";
-import "./chunk-WWC7I6TA.js";
-import "./chunk-QSJ3HFEF.js";
-import "./chunk-IAESIMK7.js";
-import "./chunk-WIWM4FE3.js";
+} from "./chunk-74RAWNQN.js";
+import "./chunk-3PVYUPXK.js";
+import "./chunk-A4MW3YZL.js";
+import "./chunk-AIZE5TDM.js";
+import "./chunk-4YRTZIVN.js";
+import "./chunk-UEILX4EV.js";
+import "./chunk-IJERIUXS.js";
 import {
   getIsDesktopApp
-} from "./chunk-QOKAKDPE.js";
+} from "./chunk-6Q7UTJKR.js";
+import "./chunk-QQ56R7KS.js";
+import "./chunk-OW765XBU.js";
 import {
   selectIdentityToken,
   selectIdentityUserId
 } from "./chunk-SEJ5OS6F.js";
-import "./chunk-OW765XBU.js";
-import "./chunk-GBRG75BQ.js";
-import "./chunk-KUG52IAP.js";
-import "./chunk-BNGW5ASC.js";
+import "./chunk-D2MDMY2M.js";
+import "./chunk-HIQ4GF53.js";
+import {
+  expandEnabledPacks
+} from "./chunk-JZX2XLKC.js";
+import "./chunk-EUGTFFO6.js";
+import "./chunk-XETG4RIX.js";
+import "./chunk-GKXCHNTE.js";
+import "./chunk-GCKHQECX.js";
+import "./chunk-WJZOQR2J.js";
+import "./chunk-6CCFTVBP.js";
+import "./chunk-BPMPOFWP.js";
+import "./chunk-5MMAK75Q.js";
+import "./chunk-DWLEOOGR.js";
+import "./chunk-LIQJTQRN.js";
+import "./chunk-UHTDNB5Y.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-7DPNBQSV.js";
+import {
+  canonicalizeToolName
+} from "./chunk-5EBLANFT.js";
+import "./chunk-NYYFIKHI.js";
+import "./chunk-EZVK3N5L.js";
 import {
   extractCustomId
 } from "./chunk-M2EJHDJP.js";
-import "./chunk-3EUW3WEO.js";
+import {
+  createDialogMessageKeyAndId
+} from "./chunk-5EMSBTQ6.js";
+import "./chunk-I42VC5KR.js";
 import "./chunk-U6VC4MU4.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-PSCNXBYA.js";
+import "./chunk-UBUH2TCC.js";
+import "./chunk-I4SN4NUQ.js";
+import "./chunk-5BHQICF2.js";
+import "./chunk-KUG52IAP.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-HNMXYYJR.js";
 import "./chunk-LCBAMY2M.js";
 import "./chunk-4SN6J65J.js";
 import "./chunk-CF7PE763.js";
 import "./chunk-G3SUCT4W.js";
+import "./chunk-RVWMAFIT.js";
+import {
+  PLATFORM_LLM_BUSY_USER_MESSAGE
+} from "./chunk-CHCS6XPJ.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-ZWQUWF6W.js";
+import "./chunk-KHCLMKZZ.js";
+import "./chunk-VEA7H5FG.js";
+import "./chunk-4VJAC32I.js";
 import "./chunk-4VNS5WPM.js";
 
+// packages/ai/agent/foregroundTurnStageLog.ts
+var FOREGROUND_TURN_STAGE_LOG_PREFIX = "[foregroundTurn][latency]";
+var isStageLogEnabled = () => {
+  try {
+    if (globalThis.__NOLO_FOREGROUND_TURN_STAGE_LOG__ === true) {
+      return true;
+    }
+    const storage = globalThis.localStorage;
+    return typeof storage?.getItem === "function" ? storage.getItem("nolo.foregroundTurn.stageLog") === "1" : false;
+  } catch {
+    return false;
+  }
+};
+function createForegroundTurnStageLog(args) {
+  const t0 = Date.now();
+  const identity = `turn=${args.turnKey} runId=${args.runId} dialogId=${args.dialogId} dialogKey=${args.dialogKey} base=${args.base}`;
+  const marks = [];
+  return {
+    stage: (stage, detail) => {
+      const at = Date.now() - t0;
+      marks.push(`${stage}=+${at}ms`);
+      if (!isStageLogEnabled()) return;
+      console.info(
+        `${FOREGROUND_TURN_STAGE_LOG_PREFIX} stage=${stage} t=+${at}ms ${identity}${detail ? ` ${detail}` : ""}`
+      );
+    },
+    summary: (outcome, detail) => {
+      console.info(
+        `${FOREGROUND_TURN_STAGE_LOG_PREFIX} SUMMARY outcome=${outcome} total=+${Date.now() - t0}ms ${identity} marks=[${marks.join(" ")}]${detail ? ` ${detail}` : ""}`
+      );
+    }
+  };
+}
+
 // packages/ai/tools/effectiveToolSurface.ts
 function readEffectiveToolName(value) {
   if (typeof value === "string") {
@@ -184,6 +234,10 @@ function resolveEffectiveToolSurface(input) {
     (Array.isArray(agent.disabledTools) ? agent.disabledTools : []).map(readEffectiveToolName).filter((name) => !!name)
   );
   for (const name of disabled) byName.delete(name);
+  const selectableCount = typeof input.selectableRuntimeCount === "number" ? input.selectableRuntimeCount : typeof input.runtimeCatalog?.selectableCount === "number" ? input.runtimeCatalog.selectableCount : void 0;
+  if (selectableCount !== void 0 && selectableCount <= 1) {
+    byName.delete("listRuntimes");
+  }
   const entries = [...byName.entries()].map(
     ([name, sources]) => ({ name, sources: [...sources] })
   );
@@ -218,12 +272,186 @@ function resolveEffectiveToolSurface(input) {
   };
 }
 
-// packages/ai/agent/serverOwnedWebForegroundEligibility.ts
+// packages/ai/tools/toolExecutionSemantics.ts
+var UNKNOWN_TOOL_EXECUTION_CONTRACT = {
+  replay: "unknown",
+  sideEffects: "unknown",
+  locality: "unknown",
+  interaction: "unknown",
+  concurrency: "exclusive",
+  durableWebForeground: false
+};
+var serverPureRead = (durableWebForeground) => ({
+  replay: "pure",
+  sideEffects: "none",
+  locality: "server",
+  interaction: "none",
+  concurrency: "safe",
+  durableWebForeground
+});
+var serverExternalRead = (durableWebForeground) => ({
+  // Repeating the request should not mutate the target resource, but may spend
+  // provider quota/money and may observe newer remote state; it is not pure.
+  replay: "idempotent",
+  sideEffects: "observable",
+  locality: "server",
+  interaction: "none",
+  concurrency: "safe",
+  durableWebForeground
+});
+var serverConfirmedHandoffStep = () => ({
+  replay: "unsafe",
+  sideEffects: "observable",
+  locality: "server",
+  interaction: "handoff",
+  concurrency: "exclusive",
+  durableWebForeground: false
+});
+var TOOL_EXECUTION_CONTRACT = Object.freeze({
+  // Proven durable network reads. They execute on the server but touch external
+  // systems, so replay/cost semantics are intentionally not called "pure".
+  exa_search: serverExternalRead("read-only"),
+  fetchWebpage: serverExternalRead("read-only"),
+  // Proven durable server-hosted workspace reads/queries.
+  searchDialogMessages: serverPureRead("read-only"),
+  listDialogs: serverPureRead("read-only"),
+  readDialog: serverPureRead("read-only"),
+  queryDialogsBySubjectRef: serverPureRead("read-only"),
+  listAgents: serverPureRead("read-only"),
+  readAgent: serverPureRead("read-only"),
+  listSpaces: serverPureRead("read-only"),
+  readSpace: serverPureRead("read-only"),
+  readDoc: serverPureRead("read-only"),
+  readSkillDoc: serverPureRead("read-only"),
+  listTables: serverPureRead("read-only"),
+  queryTableRows: serverPureRead("read-only"),
+  // Read-only presentation payload. Actions remain inert; this adds no submit or
+  // open-app authority to server-owned projection.
+  show_interaction: {
+    replay: "pure",
+    sideEffects: "none",
+    locality: "server",
+    interaction: "none",
+    concurrency: "safe",
+    durableWebForeground: "read-only"
+  },
+  // Durable interactive boundary: the current execution ends and a later user
+  // choice starts a new execution. It is intentionally not modeled as a read.
+  ask_user: {
+    replay: "unsafe",
+    sideEffects: "observable",
+    locality: "server",
+    interaction: "blocking",
+    concurrency: "exclusive",
+    durableWebForeground: "interactive"
+  },
+  // Confirmed human hand-off boundary for the media step family. These tools
+  // do not start work needing authorization: they return
+  // `{ status: "requires_confirmation", ... }` and the run must stop and wait
+  // for the user. Registered explicitly (rather than inferred from any status)
+  // so a random tool echoing the same status never pauses the run, and kept out
+  // of the durable Web foreground plane on purpose (media ServerTool admission
+  // is owned elsewhere).
+  transcribe: serverConfirmedHandoffStep(),
+  translate: serverConfirmedHandoffStep(),
+  exportDocument: serverConfirmedHandoffStep(),
+  readArtifact: serverConfirmedHandoffStep(),
+  // Representative explicitly non-durable execution classes. These entries
+  // make the reason machine-readable; unlisted tools remain UNKNOWN.
+  execShell: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "workspace",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  readFile: {
+    replay: "idempotent",
+    sideEffects: "none",
+    locality: "device",
+    interaction: "none",
+    concurrency: "safe",
+    durableWebForeground: false
+  },
+  globFiles: {
+    replay: "idempotent",
+    sideEffects: "none",
+    locality: "device",
+    interaction: "none",
+    concurrency: "safe",
+    durableWebForeground: false
+  },
+  createDoc: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "server",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  updateDoc: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "server",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  deleteDialogs: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "server",
+    interaction: "confirm",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  loadSkill: {
+    replay: "unsafe",
+    sideEffects: "observable",
+    locality: "server",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  }
+});
+function resolveToolExecutionContract(toolName) {
+  if (typeof toolName !== "string" || !toolName.trim()) {
+    return UNKNOWN_TOOL_EXECUTION_CONTRACT;
+  }
+  const canonicalName = canonicalizeToolName(toolName);
+  return TOOL_EXECUTION_CONTRACT[canonicalName] ?? UNKNOWN_TOOL_EXECUTION_CONTRACT;
+}
+function collectDurableWebToolNames(durableClass) {
+  return new Set(
+    Object.entries(TOOL_EXECUTION_CONTRACT).filter(([, contract]) => contract.durableWebForeground === durableClass).map(([name]) => name)
+  );
+}
+var DURABLE_WEB_FOREGROUND_READ_ONLY_TOOL_NAMES = collectDurableWebToolNames("read-only");
+var DURABLE_WEB_FOREGROUND_INTERACTIVE_TOOL_NAMES = collectDurableWebToolNames("interactive");
 var DURABLE_WEB_FOREGROUND_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "ask_user",
-  "exa_search",
-  "fetchWebpage"
+  ...DURABLE_WEB_FOREGROUND_READ_ONLY_TOOL_NAMES,
+  ...DURABLE_WEB_FOREGROUND_INTERACTIVE_TOOL_NAMES
 ]);
+var CONFIRMED_HANDOFF_TOOL_NAMES = new Set(
+  Object.entries(TOOL_EXECUTION_CONTRACT).filter(([, contract]) => contract.interaction === "handoff").map(([name]) => name)
+);
+function hasProvenServerReadOnlySemantics(toolName) {
+  const contract = resolveToolExecutionContract(toolName);
+  return contract.durableWebForeground === "read-only" && (contract.replay === "pure" || contract.replay === "idempotent") && (contract.sideEffects === "none" || contract.sideEffects === "observable") && contract.locality === "server" && contract.interaction === "none";
+}
+function hasProvenDurableWebForegroundSemantics(toolName) {
+  const contract = resolveToolExecutionContract(toolName);
+  if (contract.durableWebForeground === "read-only") {
+    return hasProvenServerReadOnlySemantics(toolName);
+  }
+  if (contract.durableWebForeground === "interactive") {
+    return contract.locality === "server" && contract.interaction === "blocking" && contract.sideEffects === "observable";
+  }
+  return false;
+}
+
+// packages/ai/agent/serverOwnedWebForegroundEligibility.ts
 var AUDITED_WEB_FOREGROUND_HOST_BASELINE_TOOL_NAMES = /* @__PURE__ */ new Set([
   // TOOL_PACKS.CORE
   "read",
@@ -233,6 +461,8 @@ var AUDITED_WEB_FOREGROUND_HOST_BASELINE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "search_workspace",
   "updateSelf",
   "ask_user",
+  // show_interaction: CORE 宿主注入；服务端纯函数展示（parse + fallback，无 I/O、无客户端通道），只读展示语义，不执行卡片动作
+  "show_interaction",
   "createAgentAutomation",
   "updateAgentAutomation",
   "deleteAgentAutomation",
@@ -246,23 +476,24 @@ var AUDITED_WEB_FOREGROUND_HOST_BASELINE_TOOL_NAMES = /* @__PURE__ */ new Set([
   // Default system capabilities
   "exa_search",
   "fetchWebpage",
-  "setTodoList",
   "startAgentRun",
   "controlAgentRun",
   "listAgents"
 ]);
+function isDurableRequestedToolName(name) {
+  if (typeof name !== "string") return false;
+  return hasProvenDurableWebForegroundSemantics(canonicalizeToolName(name));
+}
 function hasSupportedDurableToolSurface(agent, suppliedSurface) {
   const surface = suppliedSurface ?? resolveEffectiveToolSurface({
     agent
   });
   if (surface.shellEnabled || surface.workspaceLease) return false;
-  if (!surface.requestedNames.every(
-    (name) => DURABLE_WEB_FOREGROUND_TOOL_NAMES.has(name)
-  )) {
+  if (!surface.requestedNames.every(isDurableRequestedToolName)) {
     return false;
   }
   return surface.hostInjectedNames.every(
-    (name) => AUDITED_WEB_FOREGROUND_HOST_BASELINE_TOOL_NAMES.has(name)
+    (name) => AUDITED_WEB_FOREGROUND_HOST_BASELINE_TOOL_NAMES.has(canonicalizeToolName(name))
   );
 }
 function shouldUseServerOwnedWebForegroundTurn(input) {
@@ -278,7 +509,7 @@ function shouldUseServerOwnedWebForegroundTurn(input) {
         ...input.turnToolContext.referencedToolNames,
         ...input.turnToolContext.mentionedToolNames
       ];
-      if (lateBound.some((name) => !DURABLE_WEB_FOREGROUND_TOOL_NAMES.has(name))) {
+      if (lateBound.some((name) => !isDurableRequestedToolName(name))) {
         return false;
       }
     }
@@ -292,15 +523,12 @@ function shouldUseServerOwnedWebForegroundTurn(input) {
   const runtimeOptions = input.runtimeOptions;
   if (runtimeOptions?.extraTools?.length) {
     if (!input.effectiveToolSurface) return false;
-    if (runtimeOptions.extraTools.some(
-      (name) => typeof name === "string" && !DURABLE_WEB_FOREGROUND_TOOL_NAMES.has(name)
-    )) {
+    if (runtimeOptions.extraTools.some((name) => !isDurableRequestedToolName(name))) {
       return false;
     }
   }
   if (runtimeOptions?.editingTarget) return false;
   if (runtimeOptions?.imageConfigOverride) return false;
-  if (runtimeOptions?.quickChatModelOverride) return false;
   if (runtimeOptions?.workspaceToolsHint) return false;
   if (runtimeOptions?.cwd) return false;
   if (runtimeOptions?.restrictShellToWorkspace) return false;
@@ -381,11 +609,7 @@ function createServerOwnedToolProjection(args) {
     if (!toolName || !supported.has(toolName)) return;
     const metadata = payload.metadata && typeof payload.metadata === "object" && !Array.isArray(payload.metadata) ? payload.metadata : void 0;
     const failed = isToolResultFailure(payload.content, metadata);
-    const content = toolName === "ask_user" ? typeof payload.content === "string" ? payload.content : "" : projectDesktopToolUiContent({
-      toolName,
-      content: payload.content,
-      metadata
-    });
+    const content = toolName === "ask_user" ? typeof payload.content === "string" ? payload.content : "" : projectDesktopToolUiContent({ toolName, content: payload.content, metadata });
     const base = existing ?? (() => {
       const { key, messageId } = createDialogMessageKeyAndId(args.dialogId);
       return {
@@ -406,17 +630,21 @@ function createServerOwnedToolProjection(args) {
         ...args.messageMetadata
       };
     })();
-    const staysReadOnly = keepReadOnly.has(toolName);
+    const staysReadOnly = !failed && keepReadOnly.has(toolName);
+    const awaitingUserConfirmation = toolResultNeedsUserConfirmation(toolName, payload.content);
     const toolPayload = {
       ...base.toolPayload ?? {},
       toolName,
-      status: staysReadOnly ? "running" : failed ? "failed" : "succeeded"
+      status: staysReadOnly ? "running" : awaitingUserConfirmation ? "pending" : failed ? "failed" : "succeeded"
     };
     const message = {
       ...base,
       content,
       isStreaming: staysReadOnly,
       toolName,
+      // F1: surface server-projected metadata (incl. executionLocation) on the
+      // message so tool rows can render the actual execution host.
+      ...metadata ? { metadata } : {},
       toolPayload
     };
     transientByCallId.set(callId, message);
@@ -435,7 +663,8 @@ function createServerOwnedToolProjection(args) {
           content,
           isStreaming: false,
           toolName,
-          toolPayload
+          toolPayload,
+          ...metadata ? { metadata } : {}
         }
       })
     );
@@ -450,19 +679,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 assistantThinking(message) {
+  const value = typeof message.thinkContent === "string" ? message.thinkContent : typeof message.reasoning_content === "string" ? message.reasoning_content : "";
+  return normalizeComparableText(value);
 }
-function findNewCanonicalAssistant(messages, initialMessageIds, transientId, expectedText) {
+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;
 }
@@ -475,7 +740,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;
@@ -529,7 +796,48 @@ function resolveServerOwnedWebEffectiveToolSurface(args) {
   };
 }
 
+// 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
+var SERVER_OWNED_CANONICAL_HANDOFF_PROTECT_MS = 65e3;
+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";
 }
@@ -550,7 +858,7 @@ async function canRunServerOwnedWebForegroundTurn(args, thunk) {
     let agentConfig = args.agentConfig ?? void 0;
     if (!agentConfig) {
       try {
-        const { readAndWait: readAndWait2 } = await import("./dbSlice-DQ32LYTJ.js");
+        const { readAndWait: readAndWait2 } = await import("./dbSlice-J37OGIXH.js");
         agentConfig = await thunk.dispatch(readAndWait2(args.agentKey)).unwrap();
       } catch {
         return { eligible: false };
@@ -571,19 +879,26 @@ async function canRunServerOwnedWebForegroundTurn(args, thunk) {
       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,
-        effectiveToolSurface,
-        turnToolContext,
-        userInput: args.userInput,
-        runtimeOptions: args.runtimeOptions,
-        currentServer,
-        token,
-        isDesktopApp: getIsDesktopApp()
-      }),
-      agentConfig
+      eligible: true,
+      agentConfig: {
+        ...agentConfig,
+        tools: resolveServerOwnedWebAllowedToolNames(effectiveToolSurface.names)
+      }
     };
   } catch {
     return { eligible: false };
@@ -612,8 +927,22 @@ 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;
+  let visibleFinalized = false;
+  let sawFirstDelta = false;
+  let observedExecutionId = "";
+  let canonicalVisible = false;
+  const stageLog = createForegroundTurnStageLog({
+    turnKey: loopKey,
+    // This path's server run identity IS the dialogId; executionId stays in the
+    // SUMMARY detail to tell multiple runs of the same dialog apart.
+    runId: dialogId,
+    dialogKey,
+    dialogId,
+    base: currentServer
+  });
   const toolProjection = createServerOwnedToolProjection({
     dialogId,
     dispatch: thunk.dispatch,
@@ -623,20 +952,85 @@ async function runServerOwnedWebForegroundTurn(args, thunk) {
       userId
     },
     supportedToolNames: DURABLE_WEB_FOREGROUND_TOOL_NAMES,
-    keepReadOnlyUntilCanonical: ["ask_user"]
+    keepReadOnlyUntilCanonical: ["ask_user", "show_interaction"]
   });
-  thunk.dispatch(addActiveController({ messageId: loopKey, controller, dialogKey }));
-  thunk.dispatch(
-    messageStreaming({
-      id: transientId,
+  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 }));
+    clearForegroundTurnSettledVisible(dialogId);
+    stageLog.stage("controller-release");
+  };
+  const finalizeVisibleProjectionOnDone = () => {
+    if (visibleFinalized) return;
+    visibleFinalized = true;
+    protectTransientForCanonicalHandoff(
       dialogId,
-      dbKey: transientKey,
-      role: "assistant",
-      content: "",
-      cybotKey: args.agentKey,
-      agentKey: args.agentKey,
-      userId
-    })
+      transientId,
+      SERVER_OWNED_CANONICAL_HANDOFF_PROTECT_MS
+    );
+    finishTransientImmediately();
+    markForegroundTurnSettledVisible(dialogId);
+  };
+  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(() => {
+    }).finally(() => {
+      releaseTransientCanonicalHandoff(dialogId, transientId);
+    });
+  };
+  thunk.dispatch(addActiveController({ messageId: loopKey, controller, dialogKey }));
+  projectAssistant();
+  const allowedToolNames = resolveServerOwnedWebAllowedToolNames(
+    Array.isArray(args.agentConfig.tools) ? args.agentConfig.tools : []
   );
   const body = JSON.stringify({
     agentKey: args.agentKey,
@@ -656,6 +1050,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 } : {},
@@ -671,6 +1070,10 @@ async function runServerOwnedWebForegroundTurn(args, thunk) {
     },
     signal: controller.signal
   });
+  stageLog.stage(
+    "run-fetch-start",
+    `endpoint=${currentServer}/api/agent/run agentKey=${args.agentKey}`
+  );
   try {
     let response;
     try {
@@ -688,12 +1091,16 @@ async function runServerOwnedWebForegroundTurn(args, thunk) {
       });
       return { serverOwned: true, detached: true };
     }
+    stageLog.stage("headers", `status=${response.status} ok=${response.ok}`);
     if (!response.ok) {
       const text = await response.text().catch(() => "");
       throw new Error(text || `Agent run failed (${response.status})`);
     }
     const reader = response.body?.getReader();
-    if (!reader) return { serverOwned: true, detached: true };
+    if (!reader) {
+      stageLog.stage("no-stream-body");
+      return { serverOwned: true, detached: true };
+    }
     const parseSSE = createSSEParser();
     const decoder = new TextDecoder();
     const outcome = await consumeAgentRunStream({
@@ -706,39 +1113,63 @@ async function runServerOwnedWebForegroundTurn(args, thunk) {
       onAbort: async () => {
       },
       onPayload: (payload) => {
+        if (payload?.type === "dialog") {
+          observedExecutionId = typeof payload.executionId === "string" ? payload.executionId.trim() : "";
+        }
         if (payload?.type === "error") {
           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();
+          if (!sawFirstDelta && payload?.type !== "done") {
+            sawFirstDelta = true;
+            stageLog.stage(
+              "first-delta",
+              `payloadType=${payload?.type} executionId=${observedExecutionId}`
+            );
+          }
+        }
+        if (payload?.type === "done" && !visibleFinalized) {
+          stageLog.stage("done-frame", `executionId=${observedExecutionId}`);
+          finalizeVisibleProjectionOnDone();
         }
       }
     });
+    stageLog.stage(
+      "eof",
+      outcome.outcome === "streamEnded" ? `outcome=streamEnded sawDone=${outcome.sawDone} executionId=${observedExecutionId}` : `outcome=${outcome.outcome}`
+    );
     if (outcome.outcome === "aborted") return { serverOwned: true, aborted: true };
     if (outcome.outcome === "rejected") throw new Error(outcome.message);
     if (!outcome.sawDone) return { serverOwned: true, detached: true };
     sawDone = true;
-    let canonicalVisible = false;
+    finalizeVisibleProjectionOnDone();
     try {
-      await thunk.dispatch(initMsgs({ dialogId })).unwrap();
+      stageLog.stage("init-msgs-start", `dialogKey=${dialogKey}`);
+      const initMsgsStartedAt = Date.now();
+      await thunk.dispatch(
+        initMsgs({
+          dialogId,
+          dialogKey,
+          preferredServerOrigin: currentServer
+        })
+      ).unwrap();
+      stageLog.stage("init-msgs-end", `ms=${Date.now() - initMsgsStartedAt}`);
       canonicalVisible = !!await waitForNewCanonicalAssistant({
         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", {
@@ -747,32 +1178,33 @@ async function runServerOwnedWebForegroundTurn(args, thunk) {
       });
     }
     if (canonicalVisible) {
+      releaseTransientCanonicalHandoff(dialogId, transientId);
       toolProjection.cleanup();
       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 }));
-    if (!sawDone) {
+    releaseClientController();
+    if (!sawDone && !visibleFinalized) {
+      releaseTransientCanonicalHandoff(dialogId, transientId);
       toolProjection.cleanup();
       thunk.dispatch(removeTransientMessage({ id: transientId, dialogId }));
     }
+    if (visibleFinalized && !sawDone) {
+      toolProjection.cleanup();
+      removeTransientWhenCanonicalArrives();
+    }
+    stageLog.summary(
+      controller.signal.aborted ? "aborted" : sawDone ? "done" : visibleFinalized ? "done-visible-only" : "no-done",
+      `runId=${dialogId} executionId=${observedExecutionId} canonicalVisible=${canonicalVisible} settledVisible=${visibleFinalized}`
+    );
   }
 }
 
@@ -877,6 +1309,22 @@ function parseSendError(errorInput) {
     domain = first ? asString(first.domain) : void 0;
   }
   const stage = resolveErrorStage(fullErrorText);
+  const inputRecord = asRecord(errorInput);
+  const authCode = asString(inputRecord?.authCode) ?? asString(inputRecord?.code);
+  const hasPlatformAuthCode = /^AUTH_[A-Z0-9_]+$/.test(authCode ?? "") || /\bAUTH_[A-Z0-9_]+\b/.test(fullErrorText);
+  const isPlatformProviderFailure = /\bplatform provider failed\b/i.test(fullErrorText);
+  const isLoginStatus = statusCode === void 0 || statusCode === 401;
+  const requiresLogin = isLoginStatus && !url && !/validation_required|api[_ -]?key/i.test(fullErrorText) && (hasPlatformAuthCode || isPlatformProviderFailure && statusCode === 401);
+  if (requiresLogin) {
+    return {
+      kind: "auth",
+      retryable: false,
+      stage,
+      summary: "\u9700\u8981\u767B\u5F55",
+      actionHint: "\u672A\u68C0\u6D4B\u5230\u767B\u5F55\u72B6\u6001\uFF0C\u8BF7\u5148\u767B\u5F55",
+      extraLinks: [{ text: "\u53BB\u767B\u5F55", url: "/login" }]
+    };
+  }
   const isPlatformBusy = fullErrorText.includes(PLATFORM_LLM_BUSY_USER_MESSAGE) || /PLATFORM_LLM_BUSY/i.test(fullErrorText);
   const busyUpstreamDetail = fullErrorText.match(
     /nolo\s+(?:HTTP\s*\d{3}|[A-Za-z]+Error)/
@@ -1161,7 +1609,9 @@ var finalizeSendFailureInDialog = async (dispatch, dialogConfig, agentKey, error
   const dialogId = dialogConfig.id ?? (dialogKey ? extractCustomId(dialogKey) : "");
   const { key: msgKey, messageId } = createDialogMessageKeyAndId(dialogId);
   const parsed = parseSendError(errorInput);
+  const diagnostics = extractErrorDiagnostics(errorInput);
   const errorMeta = {
+    ...diagnostics ? { diagnostics } : {},
     kind: parsed.kind,
     retryable: parsed.retryable,
     stage: parsed.stage,
@@ -1259,10 +1709,14 @@ var handleSendMessageAction = async (args, { dispatch, getState, rejectWithValue
         dialogKey: dialogConfig.dbKey
       });
     }
+    const selectedRuntimeTarget = dialogConfig.runtimeBinding?.target;
     const resolvedContext = resolveHandleSendMessageContext({
       dialogConfig,
       targetAgentKey: args.targetAgentKey,
-      runtimeOptions: args.runtimeOptions
+      runtimeOptions: {
+        ...args.runtimeOptions,
+        ...selectedRuntimeTarget && (selectedRuntimeTarget.kind === "server" || selectedRuntimeTarget.kind === "machine") ? { runtimeTarget: selectedRuntimeTarget } : {}
+      }
     });
     agentKeyToUse = resolvedContext.agentKeyToUse;
     const agentConfigToUse = resolvedContext.agentConfigToUse;