@qwen-code/qwen-code 0.22.2-preview.0 → 0.22.2

package/chunks/{create-sub-session-SAOMTP62.js → create-sub-session-JKZAYZX7.js}

@@ -1,100 +1,103 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  isReservedStandaloneSessionSourceType
+} from "./chunk-2TNL5KPM.js";
 import {
   SessionNotFoundError
-} from "./chunk-624NHDGB.js";
+} from "./chunk-ERFDKH32.js";
 import "./chunk-6PLDPT2C.js";
-import "./chunk-RUQBJS34.js";
-import "./chunk-LRLMDV5X.js";
-import "./chunk-LRKMQPMD.js";
+import "./chunk-KUX5D6DK.js";
+import "./chunk-3DXFGHAJ.js";
+import "./chunk-CQH5KTKC.js";
 import "./chunk-LJZSMWOH.js";
-import "./chunk-H2MDBYLL.js";
-import "./chunk-JLGFGPZJ.js";
-import "./chunk-SKNVVYIJ.js";
-import "./chunk-UCSV2IZW.js";
-import "./chunk-T2HMXHYA.js";
-import "./chunk-3FSBMAYD.js";
-import "./chunk-XJS54K4A.js";
+import "./chunk-6LFTG244.js";
+import "./chunk-PKAYJDB3.js";
+import "./chunk-6IUNAPLR.js";
+import "./chunk-OIVXBW3W.js";
+import "./chunk-4CDSK5AZ.js";
+import "./chunk-XQFT3QUF.js";
+import "./chunk-VTHREBQM.js";
 import "./chunk-ZPJWUGCS.js";
-import "./chunk-ZWKGZB2K.js";
-import "./chunk-OX44MOAN.js";
+import "./chunk-H2WDGQ6D.js";
+import "./chunk-MIIVI25Q.js";
 import {
   SessionService,
   stripTerminalControlSequences
-} from "./chunk-D6XO27Z5.js";
+} from "./chunk-TGWAQ5RB.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-CQ35AJ4Z.js";
-import "./chunk-3UZCLCXR.js";
-import "./chunk-TOF4UZHH.js";
-import "./chunk-O3BUXIPM.js";
-import "./chunk-ZLTEQYNC.js";
+import "./chunk-EKSCLBBF.js";
+import "./chunk-P2SU6ZTI.js";
+import "./chunk-IZIVM7LZ.js";
+import "./chunk-SFPGAQUL.js";
 import "./chunk-6PVPNMXU.js";
-import "./chunk-AYVIGUUK.js";
+import "./chunk-JB4JIVTJ.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
-import "./chunk-JECO75XD.js";
+import "./chunk-D5LUXLUH.js";
 import "./chunk-O6GEWCJA.js";
 import "./chunk-T26EAKDL.js";
-import "./chunk-LJP2BBMK.js";
+import "./chunk-EOGELB3H.js";
 import "./chunk-CPBF7KYF.js";
-import "./chunk-5Y2JCJAH.js";
-import "./chunk-T2CRBIDJ.js";
-import "./chunk-77TOMRBG.js";
-import "./chunk-DEYPMJPD.js";
-import "./chunk-T6OODF2U.js";
-import "./chunk-27ONXAFY.js";
-import "./chunk-ZEADBZLO.js";
-import "./chunk-FN5C6C7G.js";
-import "./chunk-BVE5EMIG.js";
+import "./chunk-EFUM7RVY.js";
+import "./chunk-TTX2JUE6.js";
+import "./chunk-43GGFFLY.js";
+import "./chunk-SMPR7SPO.js";
+import "./chunk-JWALNCLT.js";
+import "./chunk-NIFYWDYN.js";
+import "./chunk-3AFMQUTI.js";
+import "./chunk-WKK5BQNP.js";
+import "./chunk-V5J4J5TP.js";
 import "./chunk-MLXTMF7H.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-FVDQ5E67.js";
-import "./chunk-V3GINY6K.js";
+import "./chunk-3JGZSIDA.js";
+import "./chunk-VVW4ZNFY.js";
 import "./chunk-QHMLYMMS.js";
-import "./chunk-SDVF6A42.js";
+import "./chunk-7DJCPZE3.js";
 import "./chunk-P3QQPMQA.js";
-import "./chunk-ILPXSKGQ.js";
+import "./chunk-HVEYF6VT.js";
 import "./chunk-VNOVK4I7.js";
 import "./chunk-SAH4BD2J.js";
-import "./chunk-ZKAZP2ZG.js";
-import "./chunk-DP7LABIB.js";
+import "./chunk-PDMJ3KGS.js";
+import "./chunk-CMHFCLBU.js";
 import "./chunk-S6LOFUVP.js";
 import "./chunk-2LD5U7Q3.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-I6VVOZDK.js";
+import "./chunk-J2OSJFP3.js";
 import "./chunk-K2OJUPOE.js";
 import "./chunk-CFKIH3D3.js";
-import "./chunk-EB4VDXNI.js";
-import "./chunk-FJWICLG7.js";
-import "./chunk-UX3IFLJM.js";
+import "./chunk-4FTKQNWJ.js";
+import "./chunk-Y3QL45LS.js";
+import "./chunk-L2M46FP5.js";
 import "./chunk-YRLW2MSX.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-WBT3STGU.js";
-import "./chunk-PVBT5QPD.js";
-import "./chunk-IPQA4SR5.js";
+import "./chunk-3I6UTTDX.js";
+import "./chunk-6PJOTWAN.js";
+import "./chunk-BWORX6FA.js";
 import "./chunk-WZAD4ZNJ.js";
 import "./chunk-FPGTNKCP.js";
-import "./chunk-SLEWBQWM.js";
-import "./chunk-4X5GYZFO.js";
+import "./chunk-6DIGWMGT.js";
+import "./chunk-Z7FLBQPR.js";
 import "./chunk-XZA32HII.js";
-import "./chunk-7QGEJI7M.js";
-import "./chunk-GTUKW3I6.js";
+import "./chunk-23RFD54N.js";
+import "./chunk-PPKZ7JOE.js";
 import "./chunk-HHJLM3WQ.js";
-import "./chunk-6US7BF3G.js";
+import "./chunk-L6BZRIUL.js";
 import "./chunk-74TONY4F.js";
-import "./chunk-VL4YX3FH.js";
-import "./chunk-JUIJ3FXC.js";
-import "./chunk-E6FGMDFQ.js";
+import "./chunk-XF63PKEN.js";
+import "./chunk-CAJTKR6W.js";
+import "./chunk-ZU4UDIWX.js";
 import {
   escapeXml
 } from "./chunk-AQ37AY7B.js";
-import "./chunk-RRKNX553.js";
-import "./chunk-KOJ6MHD5.js";
+import "./chunk-PDQGMSZK.js";
+import "./chunk-UTLCH2FK.js";
 import {
   createDebugLogger
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   writeStderrLine
 } from "./chunk-KGJGEEVR.js";
@@ -291,7 +294,7 @@ async function awaitSentCompletionAcceptance(bridge, parentSessionId, notificati
   throw stopSignal.reason;
 }
 __name(awaitSentCompletionAcceptance, "awaitSentCompletionAcceptance");
-async function deliverSentCompletion(bridge, boundWorkspace, parentSessionId, notification, stopSignal, isolatedWorkspace) {
+async function deliverSentCompletion(bridge, boundWorkspace, parentSessionId, notification, stopSignal, isolatedWorkspace, standaloneService) {
   const deadline = Date.now() + RECOVERED_PARENT_NOTIFICATION_TIMEOUT_MS;
   const initialDelivery = await awaitSentCompletionAcceptance(
     bridge,
@@ -301,6 +304,56 @@ async function deliverSentCompletion(bridge, boundWorkspace, parentSessionId, no
     deadline
   );
   if (initialDelivery === "accepted") return;
+  if (standaloneService) {
+    await standaloneService.resume(parentSessionId);
+    let ownerBridge;
+    let ownerSessionId = "";
+    let lastEventId = 0;
+    let eventEpoch = "";
+    const recoveredDelivery = await standaloneService.continueSession(
+      parentSessionId,
+      async (runtime, canonicalSessionId) => {
+        ownerBridge = runtime.bridge;
+        ownerSessionId = canonicalSessionId;
+        lastEventId = runtime.bridge.getSessionLastEventId(canonicalSessionId);
+        eventEpoch = runtime.bridge.getSessionEventEpoch(canonicalSessionId);
+        return awaitSentCompletionAcceptance(
+          runtime.bridge,
+          canonicalSessionId,
+          notification,
+          stopSignal,
+          deadline
+        );
+      }
+    );
+    if (recoveredDelivery === "missing" || !ownerBridge || !ownerSessionId) {
+      throw new SessionNotFoundError(parentSessionId);
+    }
+    void awaitRecoveredParentNotification(
+      ownerBridge,
+      ownerSessionId,
+      notification,
+      lastEventId,
+      eventEpoch,
+      stopSignal
+    ).then(
+      (continuationCompleted) => {
+        if (!continuationCompleted && !stopSignal.aborted) {
+          writeStderrLine(
+            `qwen serve: restored parent ${parentSessionId} accepted completion for sub-session ${notification.taskId}, but its automatic continuation did not reach an end-turn boundary; leaving recovery attachment for the idle reaper`
+          );
+        }
+      },
+      (error) => {
+        if (!stopSignal.aborted) {
+          writeStderrLine(
+            `qwen serve: restored parent ${parentSessionId} accepted completion for sub-session ${notification.taskId}, but its automatic continuation could not be observed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    );
+    return;
+  }
   let restoredParent;
   const isolatedCwd = isolatedWorkspace ? await isolatedWorkspace.materializeDirectory(parentSessionId) : void 0;
   let materializedDirectoryUnused = isolatedCwd !== void 0;
@@ -477,6 +530,7 @@ __name(awaitFirstTurn, "awaitFirstTurn");
 function createSubSessionLauncher(opts) {
   const {
     getBridge,
+    getStandaloneSessionService,
     boundWorkspace,
     notifySentCompletion = false,
     isolatedWorkspace
@@ -517,6 +571,11 @@ function createSubSessionLauncher(opts) {
       throw new Error("Session bridge is not available.");
     }
     const caller = bridge.getSessionSummary(info.callerSessionId);
+    const standalone = isReservedStandaloneSessionSourceType(caller.sourceType);
+    const standaloneService = standalone ? getStandaloneSessionService?.() : void 0;
+    if (standalone && !standaloneService) {
+      throw new Error("Standalone session service is unavailable.");
+    }
     if (spawnedSessionIds.has(info.callerSessionId) || caller.parentSessionId !== void 0) {
       throw new Error(
         "A sub-session cannot create further sub-sessions (nesting is capped at one level)."
@@ -545,18 +604,38 @@ function createSubSessionLauncher(opts) {
     let spawnedSession;
     let promptDispatched = false;
     try {
-      const sub = await bridge.spawnOrAttach({
-        workspaceCwd: boundWorkspace,
-        sessionScope: "thread",
-        // force a fresh top-level session, never attach
-        // Record the caller as the sub-session's parent so the UI can link it
-        // back. Persisted into the sub-session's transcript at spawn time.
-        parentSessionId: info.callerSessionId,
-        ...info.model ? { modelServiceId: info.model } : {}
-      });
+      const promptId = randomUUID();
+      let lastEventId;
+      let turn;
+      let sub;
+      if (standalone) {
+        const created = await standaloneService.createChildWithInitialPrompt(
+          {
+            sessionId: randomUUID(),
+            parentSessionId: info.callerSessionId,
+            promptId,
+            ...info.model ? { modelServiceId: info.model } : {}
+          },
+          info.prompt
+        );
+        sub = created.session;
+        lastEventId = created.initialPrompt.lastEventId;
+        turn = created.initialPrompt.turn;
+        promptDispatched = true;
+      } else {
+        sub = await bridge.spawnOrAttach({
+          workspaceCwd: boundWorkspace,
+          sessionScope: "thread",
+          // force a fresh top-level session, never attach
+          // Record the caller as the sub-session's parent so the UI can link it
+          // back. Persisted into the sub-session's transcript at spawn time.
+          parentSessionId: info.callerSessionId,
+          ...info.model ? { modelServiceId: info.model } : {}
+        });
+      }
       spawnedSession = sub;
       const sessionId = sub.sessionId;
-      if (isolatedWorkspace) {
+      if (isolatedWorkspace && !standalone) {
         const isolatedCwd = await isolatedWorkspace.materializeDirectory(sessionId);
         const changed = await bridge.changeSessionCwd(sessionId, {
           path: isolatedCwd,
@@ -577,18 +656,19 @@ function createSubSessionLauncher(opts) {
       } catch (err) {
         log.debug("sub-session: updateSessionMetadata failed", sessionId, err);
       }
-      const lastEventId = bridge.getSessionLastEventId(sessionId);
-      const promptId = randomUUID();
-      const turn = bridge.sendPrompt(
-        sessionId,
-        {
+      if (!standalone) {
+        lastEventId = bridge.getSessionLastEventId(sessionId);
+        turn = bridge.sendPrompt(
           sessionId,
-          prompt: [{ type: "text", text: info.prompt }]
-        },
-        void 0,
-        { promptId }
-      );
-      promptDispatched = true;
+          {
+            sessionId,
+            prompt: [{ type: "text", text: info.prompt }]
+          },
+          void 0,
+          { promptId }
+        );
+        promptDispatched = true;
+      }
       void turn.catch((err) => {
         log.debug("sub-session: sendPrompt rejected", sessionId, String(err));
       });
@@ -652,7 +732,8 @@ function createSubSessionLauncher(opts) {
                 info.callerSessionId,
                 notification,
                 stopAc.signal,
-                isolatedWorkspace
+                isolatedWorkspace,
+                standaloneService
               );
             } catch (notificationError) {
               if (!stopAc.signal.aborted) {
@@ -705,7 +786,7 @@ function createSubSessionLauncher(opts) {
       }
     } catch (err) {
       releaseOnce();
-      if (spawnedSession !== void 0 && isolatedWorkspace) {
+      if (spawnedSession !== void 0 && isolatedWorkspace && !standalone) {
         let sessionClosed = false;
         try {
           if (spawnedSession.attached) {
@@ -754,7 +835,7 @@ function createSubSessionLauncher(opts) {
             );
           }
         }
-      } else if (spawnedSession !== void 0) {
+      } else if (spawnedSession !== void 0 && !standalone) {
         try {
           void bridge.closeSession(spawnedSession.sessionId).catch(() => {
           });

package/chunks/{cron-create-IJGVR5R2.js → cron-create-KJ4IY6PP.js}

@@ -9,16 +9,21 @@ import {
 } from "./chunk-QHWCP53L.js";
 import {
   CRON_TASKS_DISPLAY_PATH
-} from "./chunk-JECO75XD.js";
+} from "./chunk-D5LUXLUH.js";
+import {
+  promptIdContext
+} from "./chunk-O6GEWCJA.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-7QGEJI7M.js";
+import "./chunk-23RFD54N.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-KOJ6MHD5.js";
-import "./chunk-2NNTE2ED.js";
+} from "./chunk-UTLCH2FK.js";
+import {
+  getErrorMessage
+} from "./chunk-UHQFIS7N.js";
 import "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims
@@ -64,23 +69,55 @@ var CronCreateInvocation = class extends BaseToolInvocation {
     return "ask";
   }
   async execute() {
-    const scheduler = this.config.getCronScheduler();
     const recurring = this.params.recurring !== false;
     const durable = this.params.durable === true;
+    const useCurrentSession = this.params.sessionMode === "current";
     const prompt = this.params.prompt.trim();
+    if (durable && this.config.getSessionSourceType?.() === "standalone") {
+      const message = "Durable cron jobs are not supported in standalone sessions.";
+      return {
+        llmContent: message,
+        returnDisplay: message,
+        error: { message }
+      };
+    }
+    const scheduler = this.config.getCronScheduler();
     try {
       parseCron(this.params.cron);
       nextFireTime(this.params.cron, /* @__PURE__ */ new Date());
-      const job = durable ? await scheduler.createDurable(this.params.cron, prompt, recurring) : scheduler.create(this.params.cron, prompt, recurring);
+      if (useCurrentSession && !durable) {
+        throw new Error(
+          "Current-session scheduling requires durable: true because session-only jobs cannot survive a daemon session switch."
+        );
+      }
+      let job;
+      if (useCurrentSession) {
+        const creator = this.config.getCurrentSessionScheduledTaskCreator();
+        const promptId = promptIdContext.getStore();
+        if (!creator || !promptId) {
+          throw new Error(
+            "current_session_scheduling_unavailable: Current-session scheduling requires an active daemon prompt."
+          );
+        }
+        const created = await creator({
+          cron: this.params.cron,
+          prompt,
+          recurring,
+          promptId
+        });
+        job = { id: created.id, cronExpr: created.cron };
+      } else {
+        job = durable ? await scheduler.createDurable(this.params.cron, prompt, recurring) : scheduler.create(this.params.cron, prompt, recurring);
+      }
       const display = humanReadableCron(job.cronExpr);
-      const returnDisplay = `Scheduled ${job.id} (${display})${durable ? " [durable]" : ""}`;
-      const where = durable ? `Persisted to ${CRON_TASKS_DISPLAY_PATH}` : "Session-only (not written to disk, dies when Qwen Code exits)";
+      const returnDisplay = `Scheduled ${job.id} (${display})${durable ? " [durable]" : ""}${useCurrentSession ? " [current conversation]" : ""}`;
+      const where = durable ? `Persisted to ${CRON_TASKS_DISPLAY_PATH}${useCurrentSession ? " and bound to the current conversation" : ""}` : "Session-only (not written to disk, dies when Qwen Code exits)";
       const maxAgeDays = this.config.getCronRecurringMaxAgeDays();
       const expiry = Number.isFinite(maxAgeDays) ? `Auto-expires after ${formatDays(maxAgeDays)}. Use CronDelete to cancel sooner.` : "Never auto-expires. Use CronDelete to cancel.";
       const llmContent = recurring ? `Scheduled recurring job ${job.id} (${job.cronExpr}). ${where}. ` + expiry : `Scheduled one-shot task ${job.id} (${job.cronExpr}). ${where}. It will fire once then auto-delete.`;
       return { llmContent, returnDisplay };
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
+      const message = getErrorMessage(error);
       return {
         llmContent: `Error creating cron job: ${message}`,
         returnDisplay: message,
@@ -124,6 +161,10 @@ Only use minute 0 or 30 when the user names that exact time and clearly means it
 
 By default (durable: false) the job lives only in this Qwen Code session \u2014 nothing is written to disk, and the job is gone when Qwen Code exits. Pass durable: true to write to ${CRON_TASKS_DISPLAY_PATH} so the job survives restarts. Only use durable: true when the user explicitly asks for persistence ("keep doing this every day", "set this up permanently"). Most "remind me in 5 minutes" requests should stay session-only.
 
+## Session binding
+
+By default (sessionMode: "unbound") a durable task stays unbound and uses the existing per-project scheduler owner; it does not reuse this conversation. Use sessionMode: "current" only when the user explicitly wants future runs to continue in this conversation. Current-session mode requires durable: true and an active daemon-backed prompt.
+
 ## Runtime behavior
 
 Jobs only fire while the REPL is idle (not mid-query). The scheduler adds a small deterministic jitter on top of whatever you pick: recurring tasks fire up to 10% of their period late (max 15 min); one-shot tasks landing on :00 or :30 fire up to 90 s early. Picking an off-minute is still the bigger lever.
@@ -150,6 +191,11 @@ Returns a job ID you can pass to CronDelete.`,
           durable: {
             type: "boolean",
             description: `true = persist to ${CRON_TASKS_DISPLAY_PATH} and survive restarts. false (default) = in-memory only, dies when Qwen Code exits. Use true only when the user asks the task to survive across sessions.`
+          },
+          sessionMode: {
+            type: "string",
+            enum: ["unbound", "current"],
+            description: "unbound (default) = preserve the existing unbound durable scheduler behavior. current = bind a durable task to this daemon conversation; requires durable: true."
           }
         },
         required: ["cron", "prompt"],
@@ -193,7 +239,8 @@ Returns a job ID you can pass to CronDelete.`,
       cron: params.cron,
       prompt: params.prompt,
       recurring: params.recurring ?? true,
-      durable: params.durable ?? false
+      durable: params.durable ?? false,
+      sessionMode: params.sessionMode ?? "unbound"
     };
   }
 };

package/chunks/{cron-delete-4N5BI6GL.js → cron-delete-MBLQCAYY.js}

@@ -3,18 +3,18 @@
 import {
   CRON_TASKS_DISPLAY_PATH,
   removeCronTasks
-} from "./chunk-JECO75XD.js";
+} from "./chunk-D5LUXLUH.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-7QGEJI7M.js";
+import "./chunk-23RFD54N.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-KOJ6MHD5.js";
+} from "./chunk-UTLCH2FK.js";
 import {
   getErrorMessage
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims

package/chunks/{cron-list-2CATIPUX.js → cron-list-DWH2PQ47.js}

@@ -7,16 +7,16 @@ import {
   CRON_TASKS_DISPLAY_PATH,
   readCronTasks,
   taskHasLegacyCondition
-} from "./chunk-JECO75XD.js";
+} from "./chunk-D5LUXLUH.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-7QGEJI7M.js";
+import "./chunk-23RFD54N.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-KOJ6MHD5.js";
-import "./chunk-2NNTE2ED.js";
+} from "./chunk-UTLCH2FK.js";
+import "./chunk-UHQFIS7N.js";
 import "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims

package/chunks/{daemon-NAYK4XXU.js → daemon-MJQUO7RA.js}

@@ -9750,7 +9750,9 @@ function clearActiveAssistant(state, event) {
 }
 __name(clearActiveAssistant, "clearActiveAssistant");
 function applyAssistantUsage(state, event) {
-  const block = getWritableBlockById(state, state.activeAssistantBlockId);
+  if (isLegacySubagentUsageDuplicate(state, event)) return;
+  const activeBlockId = state.activeAssistantBlockId ?? (event.parentToolCallId ? void 0 : latestTopLevelAssistantBlockIdInCurrentTurn(state));
+  const block = getWritableBlockById(state, activeBlockId);
   if (!block || block.kind !== "assistant") return;
   const prev = block.usage;
   block.usage = {
@@ -9761,6 +9763,31 @@ function applyAssistantUsage(state, event) {
   block.updatedAt = state.now;
 }
 __name(applyAssistantUsage, "applyAssistantUsage");
+function isLegacySubagentUsageDuplicate(state, event) {
+  if (event.parentToolCallId || !event.sourceRecordIds?.length) return false;
+  const sourceRecordIds = new Set(event.sourceRecordIds);
+  for (let i = state.blocks.length - 1; i >= 0; i -= 1) {
+    const block = state.blocks[i];
+    if (block.kind === "user" && !block.parentToolCallId) return false;
+    if (block.kind !== "tool" || !block.sourceRecordIds?.some((id) => sourceRecordIds.has(id))) {
+      continue;
+    }
+    const rawOutput = isRecord2(block.rawOutput) ? block.rawOutput : void 0;
+    const summary = rawOutput && isRecord2(rawOutput["executionSummary"]) ? rawOutput["executionSummary"] : void 0;
+    return summary?.["inputTokens"] === event.usage.inputTokens && summary["outputTokens"] === event.usage.outputTokens && (summary["cachedTokens"] ?? 0) === (event.usage.cachedTokens ?? 0);
+  }
+  return false;
+}
+__name(isLegacySubagentUsageDuplicate, "isLegacySubagentUsageDuplicate");
+function latestTopLevelAssistantBlockIdInCurrentTurn(state) {
+  for (let i = state.blocks.length - 1; i >= 0; i -= 1) {
+    const block = state.blocks[i];
+    if (block.kind === "user" && !block.parentToolCallId) return void 0;
+    if (block.kind === "assistant" && !block.parentToolCallId) return block.id;
+  }
+  return void 0;
+}
+__name(latestTopLevelAssistantBlockIdInCurrentTurn, "latestTopLevelAssistantBlockIdInCurrentTurn");
 function applySubagentUsageToParentTool(state, event) {
   if (!event.parentToolCallId) return;
   const block = getWritableBlockById(