@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260731.702932cc7

package/chunks/{chunk-S3TWXGKA.js → chunk-JE7KQ2UP.js}

@@ -1,11 +1,13 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  require_mime_db
+} from "./chunk-K6KS3LTN.js";
 import {
   require_get_intrinsic,
-  require_mime_db,
   require_shams,
   require_type
-} from "./chunk-T2NCM2ET.js";
+} from "./chunk-T3CHYWJZ.js";
 import {
   require_function_bind,
   require_hasown

package/chunks/{chunk-PWTZEM3C.js → chunk-JXVC2PL3.js}

@@ -10,11 +10,11 @@ import {
 } from "./chunk-CPBF7KYF.js";
 import {
   atomicWriteJSON
-} from "./chunk-A5L3JMUA.js";
+} from "./chunk-HC45LTEN.js";
 import {
   Storage,
   isNodeError
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -88,21 +88,6 @@ function assignTeammateColor(existingMembers) {
   return TEAMMATE_COLORS[existingMembers.length % TEAMMATE_COLORS.length];
 }
 __name(assignTeammateColor, "assignTeammateColor");
-function clearTeammateColors(members) {
-  return members.map((m) => {
-    const { color: _, ...rest } = m;
-    return rest;
-  });
-}
-__name(clearTeammateColors, "clearTeammateColors");
-function setMemberActive(members, agentId, isActive) {
-  return members.map((m) => m.agentId === agentId ? { ...m, isActive } : m);
-}
-__name(setMemberActive, "setMemberActive");
-function findMemberById(members, agentId) {
-  return members.find((m) => m.agentId === agentId);
-}
-__name(findMemberById, "findMemberById");
 function findMemberByName(members, name) {
   const sanitized = sanitizeName(name);
   return members.find((m) => m.name === sanitized);
@@ -182,40 +167,21 @@ async function deleteTeamDirs(teamName) {
   ]);
 }
 __name(deleteTeamDirs, "deleteTeamDirs");
-async function listTeamNames() {
-  const teamsRoot = getTeamsRootDir();
-  try {
-    const entries = await fs.readdir(teamsRoot, {
-      withFileTypes: true
-    });
-    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
-  } catch {
-    return [];
-  }
-}
-__name(listTeamNames, "listTeamNames");
 
 export {
-  getTeamsRootDir,
   getTeamDir,
-  getTeamFilePath,
   getInboxesDir,
   getTasksDir,
   sanitizeName,
   formatAgentId,
   generateUniqueTeammateName,
   assignTeammateColor,
-  clearTeammateColors,
-  setMemberActive,
-  findMemberById,
   findMemberByName,
   classifyShutdownResponse,
-  readTeamFile,
   writeTeamFile,
   createTeamFile,
   tryReclaimStaleTeam,
-  deleteTeamDirs,
-  listTeamNames
+  deleteTeamDirs
 };
 /**
  * @license

package/chunks/chunk-JYBU6YUE.js

@@ -0,0 +1,378 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  SessionNotFoundError
+} from "./chunk-B4AJNNOL.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/workspace-registry.ts
+init_esbuild_shims();
+var WorkspaceGenerationClosedError = class extends Error {
+  static {
+    __name(this, "WorkspaceGenerationClosedError");
+  }
+  code = "workspace_generation_closed";
+  constructor(message = "Workspace runtime generation is no longer active.") {
+    super(message);
+    this.name = "WorkspaceGenerationClosedError";
+  }
+};
+function createWorkspaceGenerationGuard() {
+  let closed = false;
+  return {
+    get closed() {
+      return closed;
+    },
+    assertOpen() {
+      if (closed) throw new WorkspaceGenerationClosedError();
+    },
+    close() {
+      closed = true;
+    }
+  };
+}
+__name(createWorkspaceGenerationGuard, "createWorkspaceGenerationGuard");
+function createWorkspaceSessionOwnerIndex() {
+  const bySessionId = /* @__PURE__ */ new Map();
+  const register = /* @__PURE__ */ __name((sessionId, workspaceCwd) => {
+    let owners = bySessionId.get(sessionId);
+    if (!owners) {
+      owners = /* @__PURE__ */ new Set();
+      bySessionId.set(sessionId, owners);
+    }
+    owners.add(workspaceCwd);
+  }, "register");
+  const remove = /* @__PURE__ */ __name((sessionId, workspaceCwd) => {
+    if (workspaceCwd === void 0) {
+      bySessionId.delete(sessionId);
+      return;
+    }
+    const owners = bySessionId.get(sessionId);
+    if (!owners) return;
+    owners.delete(workspaceCwd);
+    if (owners.size === 0) {
+      bySessionId.delete(sessionId);
+    }
+  }, "remove");
+  return {
+    register,
+    remove,
+    getWorkspaceCwds: /* @__PURE__ */ __name((sessionId) => [...bySessionId.get(sessionId) ?? []], "getWorkspaceCwds"),
+    removeWorkspace: /* @__PURE__ */ __name((workspaceCwd) => {
+      for (const [sessionId, owners] of bySessionId) {
+        owners.delete(workspaceCwd);
+        if (owners.size === 0) bySessionId.delete(sessionId);
+      }
+    }, "removeWorkspace"),
+    handleBridgeSessionLifecycle: /* @__PURE__ */ __name((event) => {
+      if (event.type === "registered") {
+        register(event.sessionId, event.workspaceCwd);
+      } else {
+        remove(event.sessionId, event.workspaceCwd);
+      }
+    }, "handleBridgeSessionLifecycle")
+  };
+}
+__name(createWorkspaceSessionOwnerIndex, "createWorkspaceSessionOwnerIndex");
+function createWorkspaceRegistry(inputRuntimes, options = {}) {
+  if (inputRuntimes.length === 0) {
+    throw new Error(
+      "WorkspaceRegistry requires at least one workspace runtime."
+    );
+  }
+  const primaryRuntimes = inputRuntimes.filter((runtime) => runtime.primary);
+  if (primaryRuntimes.length !== 1) {
+    throw new Error(
+      "WorkspaceRegistry requires exactly one primary workspace runtime."
+    );
+  }
+  const byCwd = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  const createEntry = /* @__PURE__ */ __name((runtime, generationId) => ({
+    workspaceId: runtime.workspaceId,
+    workspaceCwd: runtime.workspaceCwd,
+    ...runtime.displayName !== void 0 ? { displayName: runtime.displayName } : {},
+    primary: runtime.primary,
+    removable: runtime.removable === true,
+    registrationIds: Object.freeze([...runtime.registrationIds ?? []]),
+    lastGenerationId: generationId,
+    state: "active",
+    current: {
+      generationId,
+      policyRevision: "boot",
+      runtime,
+      guard: runtime.generationGuard ?? createWorkspaceGenerationGuard()
+    },
+    configuredRevision: "boot",
+    appliedRevision: "boot"
+  }), "createEntry");
+  const entries = [];
+  for (const runtime of inputRuntimes) {
+    if (byCwd.has(runtime.workspaceCwd)) {
+      throw new Error(
+        `Duplicate workspace runtime cwd ${JSON.stringify(
+          runtime.workspaceCwd
+        )}.`
+      );
+    }
+    const entry = createEntry(runtime, 1);
+    byCwd.set(runtime.workspaceCwd, entry);
+    if (byId.has(runtime.workspaceId)) {
+      throw new Error(
+        `Duplicate workspace runtime id ${JSON.stringify(
+          runtime.workspaceId
+        )}.`
+      );
+    }
+    byId.set(runtime.workspaceId, entry);
+    entries.push(entry);
+  }
+  const primaryEntry = entries.find((entry) => entry.primary);
+  const entryForRuntime = /* @__PURE__ */ __name((runtime) => {
+    const entry = byId.get(runtime.workspaceId);
+    return entry?.current?.runtime === runtime ? entry : void 0;
+  }, "entryForRuntime");
+  const activeRuntime = /* @__PURE__ */ __name((entry) => entry?.state === "active" ? entry.current?.runtime : void 0, "activeRuntime");
+  const requirePrimaryRuntime = /* @__PURE__ */ __name(() => {
+    const runtime = primaryEntry.state === "active" ? primaryEntry.current?.runtime : void 0;
+    if (!runtime) {
+      throw new WorkspaceGenerationClosedError(
+        "Primary workspace runtime is unavailable."
+      );
+    }
+    return runtime;
+  }, "requirePrimaryRuntime");
+  const sessionOwnerIndex = options.sessionOwnerIndex;
+  const scanLiveOwners = /* @__PURE__ */ __name((sessionId) => {
+    const matches = [];
+    for (const entry of entries) {
+      const runtime = activeRuntime(entry);
+      if (!runtime) continue;
+      try {
+        runtime.bridge.getSessionSummary(sessionId);
+        matches.push(runtime);
+      } catch (err) {
+        if (err instanceof SessionNotFoundError) continue;
+        throw err;
+      }
+    }
+    for (const match of matches) {
+      sessionOwnerIndex?.register(sessionId, match.workspaceCwd);
+    }
+    if (matches.length === 0) return { kind: "not_found" };
+    if (matches.length === 1) {
+      return { kind: "found", runtime: matches[0] };
+    }
+    return { kind: "ambiguous", runtimes: matches };
+  }, "scanLiveOwners");
+  return {
+    get primary() {
+      return requirePrimaryRuntime();
+    },
+    primaryEntry,
+    // Return a frozen snapshot: `runtimes` is mutable internally (see `add`),
+    // but callers must not be able to push/splice into the registry's state.
+    list: /* @__PURE__ */ __name(() => Object.freeze(
+      entries.flatMap((entry) => {
+        const runtime = activeRuntime(entry);
+        return runtime ? [runtime] : [];
+      })
+    ), "list"),
+    listEntries: /* @__PURE__ */ __name(() => Object.freeze(
+      entries.filter((entry) => entry.state !== "removed")
+    ), "listEntries"),
+    listManaged: /* @__PURE__ */ __name(() => Object.freeze(
+      entries.flatMap(
+        (entry) => entry.current?.runtime ? [entry.current.runtime] : []
+      )
+    ), "listManaged"),
+    getEntryByWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => byCwd.get(workspaceCwd), "getEntryByWorkspaceCwd"),
+    getEntryByWorkspaceId: /* @__PURE__ */ __name((workspaceId) => byId.get(workspaceId), "getEntryByWorkspaceId"),
+    beginReplacement: /* @__PURE__ */ __name((entry, configuredRevision) => {
+      if (entry.state === "blocked") {
+        entry.configuredRevision = configuredRevision;
+        entry.state = "transitioning";
+        entry.current?.guard.close();
+        sessionOwnerIndex?.removeWorkspace(entry.workspaceCwd);
+        delete entry.applyError;
+        return true;
+      }
+      if (entry.state !== "active" || !entry.current) return false;
+      entry.configuredRevision = configuredRevision;
+      entry.state = "transitioning";
+      entry.current.guard.close();
+      sessionOwnerIndex?.removeWorkspace(entry.workspaceCwd);
+      delete entry.applyError;
+      return true;
+    }, "beginReplacement"),
+    activateReplacement: /* @__PURE__ */ __name((entry, runtime, policyRevision) => {
+      if (entry.state !== "transitioning") {
+        throw new Error(
+          "Replacement runtime can only activate a transitioning entry."
+        );
+      }
+      if (runtime.workspaceId !== entry.workspaceId || runtime.workspaceCwd !== entry.workspaceCwd || runtime.primary !== entry.primary) {
+        throw new Error("Replacement runtime identity does not match entry.");
+      }
+      if (entry.displayName === void 0) {
+        delete runtime.displayName;
+      } else {
+        runtime.displayName = entry.displayName;
+      }
+      runtime.registrationIds = [...entry.registrationIds];
+      const generationId = entry.lastGenerationId + 1;
+      const generation = {
+        generationId,
+        policyRevision,
+        runtime,
+        guard: runtime.generationGuard ?? createWorkspaceGenerationGuard()
+      };
+      entry.lastGenerationId = generationId;
+      entry.current = generation;
+      entry.configuredRevision = policyRevision;
+      entry.appliedRevision = policyRevision;
+      entry.state = "active";
+      delete entry.applyError;
+      return generation;
+    }, "activateReplacement"),
+    advancePolicyRevision: /* @__PURE__ */ __name((entry, policyRevision) => {
+      entry.configuredRevision = policyRevision;
+      entry.appliedRevision = policyRevision;
+      if (entry.current) {
+        entry.current = { ...entry.current, policyRevision };
+      }
+      delete entry.applyError;
+    }, "advancePolicyRevision"),
+    blockReplacement: /* @__PURE__ */ __name((entry, error) => {
+      entry.current?.guard.close();
+      entry.state = "blocked";
+      entry.appliedRevision = null;
+      entry.applyError = error;
+    }, "blockReplacement"),
+    getByWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => activeRuntime(byCwd.get(workspaceCwd)), "getByWorkspaceCwd"),
+    getByWorkspaceId: /* @__PURE__ */ __name((workspaceId) => activeRuntime(byId.get(workspaceId)), "getByWorkspaceId"),
+    getManagedByWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => byCwd.get(workspaceCwd)?.current?.runtime, "getManagedByWorkspaceCwd"),
+    getManagedByWorkspaceId: /* @__PURE__ */ __name((workspaceId) => byId.get(workspaceId)?.current?.runtime, "getManagedByWorkspaceId"),
+    syncRuntimeMetadata: /* @__PURE__ */ __name((runtime) => {
+      const entry = byCwd.get(runtime.workspaceCwd);
+      if (!entry || entry.workspaceId !== runtime.workspaceId) return;
+      if (runtime.displayName === void 0) {
+        delete entry.displayName;
+      } else {
+        entry.displayName = runtime.displayName;
+      }
+      entry.registrationIds = Object.freeze([
+        ...runtime.registrationIds ?? []
+      ]);
+      const current = entry.current?.runtime;
+      if (!current || current === runtime) return;
+      if (entry.displayName === void 0) {
+        delete current.displayName;
+      } else {
+        current.displayName = entry.displayName;
+      }
+      current.registrationIds = [...entry.registrationIds];
+    }, "syncRuntimeMetadata"),
+    resolveWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => workspaceCwd === void 0 ? activeRuntime(primaryEntry) : activeRuntime(byCwd.get(workspaceCwd)), "resolveWorkspaceCwd"),
+    add: /* @__PURE__ */ __name((runtime) => {
+      if (byCwd.has(runtime.workspaceCwd)) {
+        throw new Error(
+          `Duplicate workspace runtime cwd ${JSON.stringify(runtime.workspaceCwd)}.`
+        );
+      }
+      if (byId.has(runtime.workspaceId)) {
+        throw new Error(
+          `Duplicate workspace runtime id ${JSON.stringify(runtime.workspaceId)}.`
+        );
+      }
+      const entry = createEntry(runtime, 1);
+      byCwd.set(runtime.workspaceCwd, entry);
+      byId.set(runtime.workspaceId, entry);
+      entries.push(entry);
+    }, "add"),
+    beginDrain: /* @__PURE__ */ __name((runtime) => {
+      const entry = entryForRuntime(runtime);
+      if (!entry || runtime.primary || entry.state !== "active") return false;
+      entry.state = "draining";
+      return true;
+    }, "beginDrain"),
+    cancelDrain: /* @__PURE__ */ __name((runtime) => {
+      const entry = entryForRuntime(runtime);
+      if (entry?.state === "draining" && entry.current?.guard.closed !== true) {
+        entry.state = "active";
+      }
+    }, "cancelDrain"),
+    commitDrain: /* @__PURE__ */ __name((runtime) => {
+      const entry = entryForRuntime(runtime);
+      if (!entry || runtime.primary || entry.state !== "draining") return;
+      entry.current?.guard.close();
+      sessionOwnerIndex?.removeWorkspace(runtime.workspaceCwd);
+    }, "commitDrain"),
+    completeDrain: /* @__PURE__ */ __name((runtime) => {
+      const entry = entryForRuntime(runtime);
+      if (!entry || runtime.primary || entry.state !== "draining") return;
+      entry.current?.guard.close();
+      entry.state = "removed";
+      byCwd.delete(runtime.workspaceCwd);
+      byId.delete(runtime.workspaceId);
+      const index = entries.indexOf(entry);
+      if (index >= 0) entries.splice(index, 1);
+      sessionOwnerIndex?.removeWorkspace(runtime.workspaceCwd);
+    }, "completeDrain"),
+    resolveLiveSessionOwner: /* @__PURE__ */ __name((sessionId) => {
+      const indexedCwds = sessionOwnerIndex?.getWorkspaceCwds(sessionId) ?? [];
+      if (indexedCwds.length > 0) {
+        const matches = [];
+        for (const workspaceCwd of indexedCwds) {
+          const entry = byCwd.get(workspaceCwd);
+          const runtime = entry?.current?.runtime;
+          if (!entry || !runtime || entry.state === "removed") {
+            sessionOwnerIndex?.remove(sessionId, workspaceCwd);
+            continue;
+          }
+          if (entry.state !== "active") continue;
+          try {
+            runtime.bridge.getSessionSummary(sessionId);
+            matches.push(runtime);
+          } catch (err) {
+            if (err instanceof SessionNotFoundError) {
+              sessionOwnerIndex?.remove(sessionId, workspaceCwd);
+              continue;
+            }
+            throw err;
+          }
+        }
+        if (matches.length === 1) {
+          return { kind: "found", runtime: matches[0] };
+        }
+        if (matches.length > 1) {
+          return { kind: "ambiguous", runtimes: matches };
+        }
+      }
+      return options.scanUnindexedOwners !== false ? scanLiveOwners(sessionId) : { kind: "not_found" };
+    }, "resolveLiveSessionOwner")
+  };
+}
+__name(createWorkspaceRegistry, "createWorkspaceRegistry");
+function createSingleWorkspaceRegistry(runtime, options = {}) {
+  return createWorkspaceRegistry([runtime], options);
+}
+__name(createSingleWorkspaceRegistry, "createSingleWorkspaceRegistry");
+
+export {
+  WorkspaceGenerationClosedError,
+  createWorkspaceGenerationGuard,
+  createWorkspaceSessionOwnerIndex,
+  createWorkspaceRegistry,
+  createSingleWorkspaceRegistry
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-RF3EXIHJ.js → chunk-K3PFMM5U.js}

@@ -3,16 +3,16 @@
 import {
   settleChatRecording,
   subscribeToHeadlessChatRecordingFailures
-} from "./chunk-YPE6A4GC.js";
+} from "./chunk-RT7FNC2O.js";
 import {
   handleAtCommand
-} from "./chunk-VULLI6WQ.js";
+} from "./chunk-QIERF2GQ.js";
 import {
   JsonOutputAdapter
-} from "./chunk-3RN6GBKS.js";
+} from "./chunk-U5CODIJW.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-BKHWX6I2.js";
+} from "./chunk-A5BZ722X.js";
 import {
   buildInitialSystemReminders,
   buildSystemMessage,
@@ -24,11 +24,11 @@ import {
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-LB6DUZ26.js";
+} from "./chunk-BTWSGZCT.js";
 import {
   RunBudgetEnforcer,
   cleanupReviewWorktreeLeases
-} from "./chunk-TPRQ7RZH.js";
+} from "./chunk-76E5Y3UZ.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -36,10 +36,10 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-IKYJHJNF.js";
+} from "./chunk-VOMQ2P6B.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-KMQ33DO4.js";
+} from "./chunk-EDB7A72S.js";
 import {
   PLAN_MODE_ENTRY_SIBLING_SKIP_MESSAGE,
   buildSessionRecoveryPlanFromApiHistory,
@@ -55,32 +55,34 @@ import {
   markDuplicateProviderToolCallResponseSent,
   parseAndFormatApiError,
   partitionByConcurrencySafety,
-  promptIdContext,
   restoreWorktreeContext
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-FRXG4ARO.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
+import {
+  promptIdContext
+} from "./chunk-O6GEWCJA.js";
 import {
   isSystemReminderContent
-} from "./chunk-L26JL52R.js";
+} from "./chunk-CBBP4BMC.js";
 import {
   uiTelemetryService
-} from "./chunk-CIKQ7KKO.js";
+} from "./chunk-NVFSGPIF.js";
+import {
+  ToolNames
+} from "./chunk-MM7TH7ZM.js";
 import {
   isTelemetrySdkInitialized,
   shutdownTelemetry
-} from "./chunk-MB4MZHMJ.js";
-import {
-  ToolNames
-} from "./chunk-PR75REBZ.js";
+} from "./chunk-QARJNL2V.js";
 import {
   FatalInputError,
   createDebugLogger
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   registerCleanup
-} from "./chunk-PWVFN2LF.js";
+} from "./chunk-BP2H5K25.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -546,6 +548,7 @@ ${text}
           displayText,
           modelText,
           sendMessageType: "notification" /* Notification */,
+          todoWorkChainId: meta.todoWorkChainId,
           sdkNotification: {
             task_id: meta.agentId,
             tool_use_id: meta.toolUseId,
@@ -578,6 +581,7 @@ ${text}
               displayText,
               modelText,
               sendMessageType: "notification" /* Notification */,
+              todoWorkChainId: meta.todoWorkChainId,
               monitorId: meta.monitorId,
               sdkNotification: {
                 task_id: meta.monitorId,
@@ -763,6 +767,10 @@ ${text}
             abortController.signal,
             {
               recordToolResult: false,
+              onToolResultFullTurnModel: /* @__PURE__ */ __name((model) => {
+                if (inlineModelOverrideActive) return false;
+                return setModelOverride(model);
+              }, "onToolResultFullTurnModel"),
               outputUpdateHandler,
               onAllToolCallsComplete: /* @__PURE__ */ __name(async (completedCalls) => {
                 for (const call of completedCalls) {
@@ -972,6 +980,7 @@ ${text}
           repeatedDuplicateProviderToolCall: false
         };
       }, "processToolCallBatch");
+      let currentPromptId = prompt_id;
       while (true) {
         let isTeammateTurn = false;
         if (!isFirstTurn && pendingTeammateMessages.length > 0) {
@@ -1001,12 +1010,15 @@ ${text}
         } else {
           sendType = "toolResult" /* ToolResult */;
         }
+        if (isTeammateTurn) {
+          currentPromptId = `${prompt_id}/teammate/${turnCount}`;
+        }
         const toolCallRequests = [];
         const apiStartTime = Date.now();
         const responseStream = geminiClient.sendMessageStream(
           currentMessages[0]?.parts || [],
           abortController.signal,
-          prompt_id,
+          currentPromptId,
           {
             type: sendType,
             modelOverride,
@@ -1062,9 +1074,12 @@ ${text}
             responseParts: toolResponseParts,
             repeatedDuplicateProviderToolCall
           } = await processToolCallBatch(toolCallRequests, (override) => {
-            if (!inlineModelOverrideActive) {
-              modelOverride = override;
+            if (inlineModelOverrideActive) return false;
+            if (modelOverride?.endsWith("\0") && modelOverride !== override) {
+              return false;
             }
+            modelOverride = override;
+            return true;
           });
           if (structuredSubmission !== void 0) {
             return emitStructuredSuccess();
@@ -1126,7 +1141,7 @@ ${text}
             const targetType = localQueue[0].sendMessageType;
             let splitIdx = targetType === "cron" /* Cron */ ? 1 : 0;
             if (splitIdx === 0) {
-              while (splitIdx < localQueue.length && localQueue[splitIdx].sendMessageType === targetType) {
+              while (splitIdx < localQueue.length && localQueue[splitIdx].sendMessageType === targetType && localQueue[splitIdx].todoWorkChainId === localQueue[0].todoWorkChainId) {
                 splitIdx++;
               }
             }
@@ -1138,7 +1153,8 @@ ${text}
             const item = {
               displayText: batch.map((i) => i.displayText).join("; "),
               modelText: batch.map((i) => i.modelText).join("\n\n"),
-              sendMessageType: targetType
+              sendMessageType: targetType,
+              todoWorkChainId: batch[0]?.todoWorkChainId
             };
             turnCount++;
             if (config.getMaxSessionTurns() >= 0 && turnCount > config.getMaxSessionTurns()) {
@@ -1150,18 +1166,20 @@ ${text}
             ];
             let itemIsFirstTurn = true;
             let itemModelOverride;
+            const itemPromptId = `${prompt_id}/automatic/${turnCount}`;
             while (true) {
               const itemToolCallRequests = [];
               const itemApiStartTime = Date.now();
               const itemStream = geminiClient.sendMessageStream(
                 itemMessages[0]?.parts || [],
                 abortController.signal,
-                prompt_id,
+                itemPromptId,
                 {
                   type: itemIsFirstTurn ? item.sendMessageType : "toolResult" /* ToolResult */,
                   modelOverride: itemModelOverride,
                   ...itemIsFirstTurn && {
-                    notificationDisplayText: item.displayText
+                    notificationDisplayText: item.displayText,
+                    todoWorkChainId: item.todoWorkChainId
                   }
                 }
               );
@@ -1209,7 +1227,11 @@ ${text}
                 } = await processToolCallBatch(
                   itemToolCallRequests,
                   (override) => {
+                    if (itemModelOverride?.endsWith("\0") && itemModelOverride !== override) {
+                      return false;
+                    }
                     itemModelOverride = override;
+                    return true;
                   }
                 );
                 if (structuredSubmission !== void 0) {
@@ -1300,7 +1322,8 @@ ${text}
                 localQueue.push({
                   displayText: `${job.cronExpr === "@wakeup" ? "Loop" : "Cron"}: ${label}`,
                   modelText: job.prompt,
-                  sendMessageType: "cron" /* Cron */
+                  sendMessageType: "cron" /* Cron */,
+                  todoWorkChainId: job.todoWorkChainId
                 });
                 drainLocalQueue().then(checkCronDone, onDrainError);
               });