@qwen-code/qwen-code 0.20.2-jobbench-no-todo-write.0 → 0.21.0

package/chunks/{daemon-RAPSDJH7.js → daemon-YO6433NF.js}

@@ -381,6 +381,9 @@ var RestSseTransport = class {
       }
       if (opts.lastEventId !== void 0) {
         headers["Last-Event-ID"] = String(opts.lastEventId);
+        if (opts.epoch !== void 0) {
+          headers["X-Qwen-Event-Epoch"] = opts.epoch;
+        }
       }
       const fetchSignal = opts.signal ? composeAbortSignals([opts.signal, requestCtrl.signal]) : requestCtrl.signal;
       let url = `${this.baseUrl}/session/${encodeURIComponent(sessionId)}/events`;
@@ -439,6 +442,10 @@ var RestSseTransport = class {
       if (!res.body) {
         throw new Error("No SSE body");
       }
+      const responseEpoch = res.headers.get("x-qwen-event-epoch");
+      if (responseEpoch) {
+        opts.onEpoch?.(responseEpoch);
+      }
       yield* parseSseStream(res.body, fetchSignal);
     } finally {
       requestCtrl.abort();
@@ -590,6 +597,7 @@ var DEFAULT_SESSION_LIST_PAGE_SIZE = 20;
 var DEFAULT_FETCH_TIMEOUT_MS = 3e4;
 var VOICE_TRANSCRIPTION_DEFAULT_TIMEOUT_MS = 65e3;
 var GITHUB_SETUP_DEFAULT_TIMEOUT_MS = 9e4;
+var CHANNEL_NOTIFY_DEFAULT_TIMEOUT_MS = 35e3;
 var MAX_TIMER_DELAY_MS = 2147483647;
 var DEFAULT_MAX_PENDING_PROMPTS_PER_SESSION = 5;
 var MCP_RESTART_DEFAULT_TIMEOUT_MS = MCP_RESTART_SERVER_DEADLINE_MS + MCP_RESTART_CLIENT_HEADROOM_MS;
@@ -902,6 +910,25 @@ var DaemonClient = class {
       }
     );
   }
+  /**
+   * Send text directly through the primary workspace's channel worker.
+   * This does not create or prompt an Agent session. Pre-flight the
+   * `channel_delivery` capability before calling across mixed daemon versions.
+   * A successful capability check does not guarantee worker liveness; callers
+   * must treat 503 `channel_worker_unavailable` as an expected outcome.
+   */
+  async notify(req, opts) {
+    return await this.jsonRequest(
+      "/workspace/notify",
+      "POST /workspace/notify",
+      {
+        method: "POST",
+        body: req,
+        timeoutMs: opts?.timeoutMs ?? CHANNEL_NOTIFY_DEFAULT_TIMEOUT_MS,
+        mode: "rest"
+      }
+    );
+  }
   async requireCapability(capability) {
     const caps = await this.capabilities();
     if (!caps.features.includes(capability)) {
@@ -968,13 +995,13 @@ var DaemonClient = class {
       }
     );
   }
-  async reloadWorkspaceMcp() {
+  async reloadWorkspaceMcp(options = {}) {
     return await this.fetchWithTimeout(
       `${this.baseUrl}/workspace/mcp/reload`,
       {
         method: "POST",
         headers: this.headers({ "Content-Type": "application/json" }),
-        body: "{}"
+        body: JSON.stringify(options)
       },
       async (res) => {
         if (!res.ok) {
@@ -1628,9 +1655,47 @@ var DaemonClient = class {
       MCP_RESTART_DEFAULT_TIMEOUT_MS
     );
   }
-  async getWorkspaceAgent(agentType) {
+  async *generateContentEvents(path, label, body, opts, parse, requireTerminal) {
+    const res = await this.transport.fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: this.headers(
+        {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream"
+        },
+        opts?.clientId
+      ),
+      body: JSON.stringify(body),
+      signal: opts?.signal
+    });
+    if (!res.ok) throw await this.failOnError(res, label);
+    if (!res.body) throw new Error("Generation response body is missing");
+    let sawTerminal = false;
+    for await (const event of parseSseStream(res.body, opts?.signal)) {
+      const generationEvent = parse(event);
+      if (!generationEvent) continue;
+      sawTerminal = generationEvent.type === "done" || generationEvent.type === "error";
+      yield generationEvent;
+      if (requireTerminal && sawTerminal) return;
+    }
+    if (requireTerminal && !opts?.signal?.aborted && !sawTerminal) {
+      throw new Error("Stream ended without terminal event");
+    }
+  }
+  async *generateWorkspaceContent(prompt, opts) {
+    yield* this.generateContentEvents(
+      "/workspace/generate",
+      "POST /workspace/generate",
+      { prompt },
+      opts,
+      parseSessionGenerationEvent,
+      true
+    );
+  }
+  async getWorkspaceAgent(agentType, opts = {}) {
+    const url = opts.scope ? `${this.baseUrl}/workspace/agents/${urlEncode(agentType)}?scope=${urlEncode(opts.scope)}` : `${this.baseUrl}/workspace/agents/${urlEncode(agentType)}`;
     return await this.fetchWithTimeout(
-      `${this.baseUrl}/workspace/agents/${urlEncode(agentType)}`,
+      url,
       { headers: this.headers() },
       async (res) => {
         if (!res.ok) {
@@ -1766,7 +1831,8 @@ var DaemonClient = class {
           ...req.approvalMode !== void 0 ? { approvalMode: req.approvalMode } : {},
           ...req.sourceType !== void 0 ? { sourceType: req.sourceType } : {},
           ...req.sourceId !== void 0 ? { sourceId: req.sourceId } : {},
-          ...req.worktree !== void 0 ? { worktree: req.worktree } : {}
+          ...req.worktree !== void 0 ? { worktree: req.worktree } : {},
+          ...req.branch !== void 0 ? { branch: req.branch } : {}
         })
       },
       async (res) => {
@@ -1880,6 +1946,20 @@ var DaemonClient = class {
       }
     );
   }
+  async resolveSubagentSession(sessionId, toolCallId, clientId) {
+    return await this.jsonRequest(
+      `/session/${urlEncode(sessionId)}/subagents/${urlEncode(toolCallId)}`,
+      "GET /session/:id/subagents/:toolCallId",
+      { clientId, mode: "rest" }
+    );
+  }
+  async cancelSubagentSession(sessionId, toolCallId, clientId) {
+    return await this.jsonRequest(
+      `/session/${urlEncode(sessionId)}/subagents/${urlEncode(toolCallId)}/cancel`,
+      "POST /session/:id/subagents/:toolCallId/cancel",
+      { clientId, mode: "rest", method: "POST" }
+    );
+  }
   async resumeSession(sessionId, req = {}, clientId) {
     return this.restoreSession("resume", sessionId, req, clientId);
   }
@@ -2191,29 +2271,14 @@ var DaemonClient = class {
     return await res.json();
   }
   async *generateSessionContent(sessionId, prompt, opts) {
-    const res = await this.transport.fetch(
-      `${this.baseUrl}/session/${urlEncode(sessionId)}/generate`,
-      {
-        method: "POST",
-        headers: this.headers(
-          {
-            "Content-Type": "application/json",
-            Accept: "text/event-stream"
-          },
-          opts?.clientId
-        ),
-        body: JSON.stringify({ prompt }),
-        signal: opts?.signal
-      }
+    yield* this.generateContentEvents(
+      `/session/${urlEncode(sessionId)}/generate`,
+      "POST /session/:id/generate",
+      { prompt },
+      opts,
+      parseSessionGenerationEvent,
+      false
     );
-    if (!res.ok) {
-      throw await this.failOnError(res, "POST /session/:id/generate");
-    }
-    if (!res.body) throw new Error("Generation response body is missing");
-    for await (const event of parseSseStream(res.body, opts?.signal)) {
-      const generationEvent = parseSessionGenerationEvent(event);
-      if (generationEvent) yield generationEvent;
-    }
   }
   async btwSession(sessionId, question, opts) {
     const res = await this.transport.fetch(
@@ -2948,7 +3013,8 @@ var DaemonClient = class {
             accept.promptId,
             accept.lastEventId,
             signal,
-            clientId
+            clientId,
+            accept.eventEpoch
           );
         } finally {
           releasePromptSlot();
@@ -3002,12 +3068,16 @@ var DaemonClient = class {
     }
     return await res.json();
   }
-  async _awaitTurnComplete(sessionId, promptId, lastEventId, signal, clientId) {
+  async _awaitTurnComplete(sessionId, promptId, lastEventId, signal, clientId, eventEpoch) {
     const sseAbort = new AbortController();
     const composedSignal = signal ? composeAbortSignals2([signal, sseAbort.signal]) : sseAbort.signal;
     try {
       const events = this.subscribeEvents(sessionId, {
         lastEventId,
+        // Cursor and epoch both come from the 202 envelope: a daemon
+        // restart between the 202 and this subscribe is detected as an
+        // epoch mismatch instead of silently mis-resuming (DAEMON-001).
+        ...eventEpoch !== void 0 ? { epoch: eventEpoch } : {},
         signal: composedSignal
       });
       for await (const event of events) {
@@ -3073,6 +3143,8 @@ var DaemonClient = class {
   async *subscribeEvents(sessionId, opts = {}) {
     yield* this.transport.subscribeEvents(sessionId, {
       lastEventId: opts.lastEventId,
+      epoch: opts.epoch,
+      onEpoch: opts.onEpoch,
       maxQueued: opts.maxQueued,
       signal: opts.signal,
       connectTimeoutMs: this.fetchTimeoutMs || void 0
@@ -3469,6 +3541,24 @@ var WorkspaceDaemonClient = class {
   workspaceMcp() {
     return this.get("/mcp", "GET /workspaces/:workspace/mcp");
   }
+  /**
+   * Send text directly through this exact workspace's channel worker.
+   * A successful capability pre-flight does not guarantee worker liveness;
+   * callers must treat 503 `channel_worker_unavailable` as an expected outcome.
+   */
+  notify(req, opts) {
+    return this.client.workspaceJsonRequest(
+      this.workspaceSelector,
+      "/notify",
+      "POST /workspaces/:workspace/notify",
+      {
+        method: "POST",
+        body: req,
+        timeoutMs: opts?.timeoutMs ?? CHANNEL_NOTIFY_DEFAULT_TIMEOUT_MS,
+        mode: "rest"
+      }
+    );
+  }
   initializeWorkspaceMcp() {
     return this.post(
       "/mcp/initialize",
@@ -3476,11 +3566,11 @@ var WorkspaceDaemonClient = class {
       {}
     );
   }
-  reloadWorkspaceMcp() {
+  reloadWorkspaceMcp(options = {}) {
     return this.post(
       "/mcp/reload",
       "POST /workspaces/:workspace/mcp/reload",
-      {}
+      options
     );
   }
   workspaceVoice(clientId) {
@@ -4049,7 +4139,20 @@ var DaemonSessionClient = class _DaemonSessionClient {
   replaySnapshot;
   hasActivePrompt;
   historyHasMore;
+  /**
+   * True when the load response flagged the replay snapshot as degraded
+   * (`replayDegraded` — compaction failed at least once, so
+   * `replaySnapshot` may lag behind live events). Prefer the full
+   * transcript (see `fullTranscriptAvailable`) when set.
+   */
+  replayDegraded;
   lastSeenEventId;
+  /**
+   * Epoch token paired with {@link lastSeenEventId}. Seeded from the
+   * load/resume/create response when available, refreshed from every
+   * subscription's `X-Qwen-Event-Epoch` response header.
+   */
+  lastSeenEpoch;
   subscriptionActive = false;
   /** In-flight `reattach()` so concurrent prompts re-register only once. */
   reattaching;
@@ -4061,11 +4164,13 @@ var DaemonSessionClient = class _DaemonSessionClient {
     this.state = { ...opts.state ?? {} };
     this.hasActivePrompt = opts.hasActivePrompt ?? false;
     this.historyHasMore = opts.historyHasMore ?? false;
+    this.replayDegraded = opts.replayDegraded ?? false;
     this.replaySnapshot = opts.replaySnapshot ?? {
       compactedReplay: [],
       liveJournal: []
     };
     this.lastSeenEventId = validateLastEventId(opts.lastEventId);
+    this.lastSeenEpoch = opts.eventEpoch;
     this.promptLimit = opts.maxPendingPromptsPerSession === void 0 ? opts.client.maxPendingPromptsPerSession : normalizePendingPromptLimit(opts.maxPendingPromptsPerSession);
   }
   /**
@@ -4078,7 +4183,11 @@ var DaemonSessionClient = class _DaemonSessionClient {
       client,
       session,
       hasActivePrompt: session.hasActivePrompt,
-      lastEventId
+      lastEventId,
+      // Newer daemons may stamp the bus epoch on the create/attach
+      // response; older ones don't — the first subscription then learns it
+      // from the `X-Qwen-Event-Epoch` response header.
+      eventEpoch: session.eventEpoch
     });
   }
   /**
@@ -4093,7 +4202,9 @@ var DaemonSessionClient = class _DaemonSessionClient {
       compactedReplay,
       liveJournal,
       historyHasMore,
+      replayDegraded,
       lastEventId: serverLastEventId,
+      eventEpoch,
       ...session
     } = await client.loadSession(sessionId, req, clientId);
     return new _DaemonSessionClient({
@@ -4102,11 +4213,13 @@ var DaemonSessionClient = class _DaemonSessionClient {
       hasActivePrompt,
       state,
       lastEventId: serverLastEventId ?? 0,
+      eventEpoch,
       replaySnapshot: {
         compactedReplay: compactedReplay ?? [],
         liveJournal: liveJournal ?? []
       },
-      historyHasMore
+      historyHasMore,
+      replayDegraded
     });
   }
   /**
@@ -4120,6 +4233,7 @@ var DaemonSessionClient = class _DaemonSessionClient {
       state,
       hasActivePrompt,
       lastEventId: serverLastEventId,
+      eventEpoch,
       ...session
     } = await client.resumeSession(sessionId, req, clientId);
     return new _DaemonSessionClient({
@@ -4127,7 +4241,8 @@ var DaemonSessionClient = class _DaemonSessionClient {
       session,
       hasActivePrompt,
       state,
-      lastEventId: serverLastEventId ?? 0
+      lastEventId: serverLastEventId ?? 0,
+      eventEpoch
     });
   }
   get sessionId() {
@@ -4145,6 +4260,9 @@ var DaemonSessionClient = class _DaemonSessionClient {
   get worktree() {
     return this.session.worktree;
   }
+  get branch() {
+    return this.session.branch;
+  }
   get lastEventId() {
     return this.lastSeenEventId;
   }
@@ -4511,9 +4629,16 @@ var DaemonSessionClient = class _DaemonSessionClient {
     try {
       const { resume = true, ...subscribeOpts } = opts;
       const lastEventId = subscribeOpts.lastEventId ?? (resume ? this.lastSeenEventId : void 0);
+      const epoch = subscribeOpts.epoch ?? (resume ? this.lastSeenEpoch : void 0);
+      const callerOnEpoch = subscribeOpts.onEpoch;
       for await (const event of this.client.subscribeEvents(this.sessionId, {
         ...subscribeOpts,
-        lastEventId
+        lastEventId,
+        ...epoch !== void 0 ? { epoch } : {},
+        onEpoch: /* @__PURE__ */ __name((learned) => {
+          this.lastSeenEpoch = learned;
+          callerOnEpoch?.(learned);
+        }, "onEpoch")
       })) {
         this._dispatchTurnEvent(event);
         yield event;
@@ -4686,6 +4811,7 @@ var DAEMON_KNOWN_EVENT_TYPE_VALUES = [
   // consumers silently drop this event via `asKnownDaemonEvent`
   // returning undefined (no protocol bump required).
   "followup_suggestion",
+  "channel_delivery_result",
   "user_shell_command",
   "user_shell_result",
   "turn_complete",
@@ -4874,6 +5000,8 @@ function asKnownDaemonEvent(event) {
       return event.data != null && typeof event.data === "object" ? event : void 0;
     case "followup_suggestion":
       return isFollowupSuggestionData(event.data) ? event : void 0;
+    case "channel_delivery_result":
+      return isChannelDeliveryResultData(event.data) ? event : void 0;
     case "mcp_server_added":
       return isMcpServerAddedData(event.data) ? event : void 0;
     case "mcp_server_removed":
@@ -5187,6 +5315,7 @@ function reduceDaemonSessionEvent(state, rawEvent) {
     case PENDING_PROMPT_ADDED_EVENT:
     case PENDING_PROMPT_STARTED_EVENT:
     case PENDING_PROMPT_COMPLETED_EVENT:
+    case "channel_delivery_result":
       return base;
     case "session_rewound":
       return {
@@ -5610,6 +5739,38 @@ function isFollowupSuggestionData(value) {
   return isRecord(value) && isNonEmptyString(value["sessionId"]) && isNonEmptyString(value["suggestion"]) && isNonEmptyString(value["promptId"]);
 }
 __name(isFollowupSuggestionData, "isFollowupSuggestionData");
+var CHANNEL_DELIVERY_ERROR_CODES = /* @__PURE__ */ new Set([
+  "channel_worker_unavailable",
+  "channel_delivery_timeout",
+  "channel_delivery_invalid",
+  "channel_delivery_rejected",
+  "channel_delivery_queue_full",
+  "channel_delivery_failed"
+]);
+function isChannelDeliveryResultData(value) {
+  if (!isRecord(value) || !isNonEmptyString(value["sessionId"]) || !isNonEmptyString(value["deliveryId"]) || value["status"] !== "delivered" && value["status"] !== "failed" && value["status"] !== "skipped" || !Object.keys(value).every(
+    (key) => [
+      "sessionId",
+      "deliveryId",
+      "source",
+      "status",
+      "promptId",
+      "taskId",
+      "firedAt",
+      "code",
+      "error"
+    ].includes(key)
+  )) {
+    return false;
+  }
+  const correlationValid = value["source"] === "prompt" && isNonEmptyString(value["promptId"]) && value["taskId"] === void 0 && value["firedAt"] === void 0 || value["source"] === "scheduled" && isNonEmptyString(value["taskId"]) && isFiniteNumber(value["firedAt"]) && value["promptId"] === void 0;
+  if (!correlationValid) return false;
+  if (value["status"] === "failed") {
+    return typeof value["code"] === "string" && CHANNEL_DELIVERY_ERROR_CODES.has(value["code"]) && isNonEmptyString(value["error"]);
+  }
+  return value["code"] === void 0 && value["error"] === void 0;
+}
+__name(isChannelDeliveryResultData, "isChannelDeliveryResultData");
 function isMcpServerAddedData(value) {
   if (!isRecord(value)) return false;
   if (!isNonEmptyString(value["name"])) return false;
@@ -6351,26 +6512,43 @@ function extractServerTimestamp(event) {
   }
   if (isRecord2(event.data)) {
     const dataMeta = event.data["_meta"];
+    const update = event.data["update"];
+    const updateMeta = isRecord2(update) ? update["_meta"] : void 0;
     if (isRecord2(dataMeta)) {
       const ts = dataMeta["serverTimestamp"];
       if (typeof ts === "number" && Number.isFinite(ts)) return ts;
     }
-    const update = event.data["update"];
-    if (isRecord2(update)) {
-      const updateMeta = update["_meta"];
-      if (isRecord2(updateMeta)) {
-        const serverTs = updateMeta["serverTimestamp"];
-        if (typeof serverTs === "number" && Number.isFinite(serverTs)) {
-          return serverTs;
-        }
-        const ts = updateMeta["timestamp"];
-        if (typeof ts === "number" && Number.isFinite(ts)) return ts;
+    if (isRecord2(updateMeta)) {
+      const serverTs = updateMeta["serverTimestamp"];
+      if (typeof serverTs === "number" && Number.isFinite(serverTs)) {
+        return serverTs;
       }
     }
+    const timestampCandidates = [
+      isRecord2(updateMeta) ? updateMeta["timestamp"] : void 0,
+      isRecord2(update) ? update["timestamp"] : void 0,
+      isRecord2(dataMeta) ? dataMeta["timestamp"] : void 0,
+      event.data["timestamp"]
+    ];
+    for (const candidate of timestampCandidates) {
+      const timestamp = parseTimestamp(candidate);
+      if (timestamp !== void 0) return timestamp;
+    }
   }
   return void 0;
 }
 __name(extractServerTimestamp, "extractServerTimestamp");
+function parseTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "string") return void 0;
+  if (/^\d+$/.test(value)) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : void 0;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+__name(parseTimestamp, "parseTimestamp");
 function normalizeSessionUpdate(event, base, opts) {
   const update = getSessionUpdatePayload(event.data);
   if (!update) {
@@ -6563,7 +6741,8 @@ function normalizeToolUpdate(update, base) {
   const metadata = isRecord2(update["_meta"]) ? update["_meta"] : void 0;
   const toolName = getString2(update, "toolName") ?? getString2(update, "name") ?? (metadata ? getString2(metadata, "toolName") : void 0) ?? (metadata ? getString2(metadata, "name") : void 0);
   const toolKind = getString2(update, "kind");
-  const title = getString2(update, "title") ?? toolName ?? toolKind;
+  const explicitTitle = getString2(update, "title");
+  const title = explicitTitle ?? (getString2(update, "sessionUpdate") === "tool_call" ? toolName ?? toolKind : void 0);
   const rawInputSource = update["rawInput"] ?? update["input"] ?? update["args"];
   const rawOutputSource = update["rawOutput"] ?? update["output"] ?? update["result"];
   const rawInput = rawInputSource !== void 0 ? redactSensitiveFields(rawInputSource) : void 0;
@@ -7692,7 +7871,8 @@ function createDaemonTranscriptState(opts = {}) {
     resyncRequiredCount: 0,
     nextOrdinal: 1,
     now: opts.now ?? Date.now(),
-    maxBlocks: opts.maxBlocks ?? DEFAULT_MAX_BLOCKS
+    maxBlocks: opts.maxBlocks ?? DEFAULT_MAX_BLOCKS,
+    retainSubagentBlocks: opts.retainSubagentBlocks ?? true
   };
   if (opts.onTruncation) truncationCallbacks.set(state, opts.onTruncation);
   return state;
@@ -7811,6 +7991,7 @@ function applyDaemonTranscriptEvent(next, event) {
       break;
     }
     case "assistant.text.delta":
+      if (event.parentToolCallId && !next.retainSubagentBlocks) break;
       appendTextDelta(
         next,
         "assistant",
@@ -7826,9 +8007,14 @@ function applyDaemonTranscriptEvent(next, event) {
       }
       break;
     case "assistant.usage":
-      applyAssistantUsage(next, event);
+      if (event.parentToolCallId && !next.retainSubagentBlocks) {
+        applySubagentUsageToParentTool(next, event);
+      } else {
+        applyAssistantUsage(next, event);
+      }
       break;
     case "thought.text.delta":
+      if (event.parentToolCallId && !next.retainSubagentBlocks) break;
       appendTextDelta(
         next,
         "thought",
@@ -7838,6 +8024,10 @@ function applyDaemonTranscriptEvent(next, event) {
       );
       break;
     case "tool.update":
+      if (event.parentToolCallId && !next.retainSubagentBlocks) {
+        discardToolBlock(next, event.toolCallId);
+        break;
+      }
       upsertToolBlock(next, event);
       break;
     case "shell.output":
@@ -7993,6 +8183,35 @@ function applyAssistantUsage(state, event) {
   block.updatedAt = state.now;
 }
 __name(applyAssistantUsage, "applyAssistantUsage");
+function applySubagentUsageToParentTool(state, event) {
+  if (!event.parentToolCallId) return;
+  const block = getWritableBlockById(
+    state,
+    state.toolBlockByCallId[event.parentToolCallId]
+  );
+  if (block?.kind !== "tool") return;
+  const current = isRecord2(block.rawOutput) ? block.rawOutput : void 0;
+  const currentSummary = isRecord2(current?.["executionSummary"]) ? current["executionSummary"] : void 0;
+  const inputTokens = finiteNumber(currentSummary?.["inputTokens"]) + event.usage.inputTokens;
+  const outputTokens = finiteNumber(currentSummary?.["outputTokens"]) + event.usage.outputTokens;
+  const cachedTokens = finiteNumber(currentSummary?.["cachedTokens"]) + (event.usage.cachedTokens ?? 0);
+  block.rawOutput = {
+    ...current ?? { type: "task_execution", status: "running" },
+    executionSummary: {
+      ...currentSummary ?? {},
+      inputTokens,
+      outputTokens,
+      cachedTokens,
+      totalTokens: inputTokens + outputTokens
+    }
+  };
+  block.updatedAt = state.now;
+}
+__name(applySubagentUsageToParentTool, "applySubagentUsageToParentTool");
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+__name(finiteNumber, "finiteNumber");
 function clearActiveThought(state, event) {
   finalizeStreamingTextBlock(state, state.activeThoughtBlockId, event);
   state.activeThoughtBlockId = void 0;
@@ -8095,6 +8314,11 @@ function finishAssistant(state, event) {
 }
 __name(finishAssistant, "finishAssistant");
 function upsertToolBlock(state, event) {
+  const compactTaskOutput = !state.retainSubagentBlocks && isRecord2(event.rawOutput) && event.rawOutput["type"] === "task_execution";
+  let rawOutput = compactTaskExecutionOutput(
+    event.rawOutput,
+    state.retainSubagentBlocks
+  );
   const existingId = state.toolBlockByCallId[event.toolCallId];
   if (existingId === TRIMMED_TOOL_BLOCK_ID) {
     if (shouldRecreateTrimmedToolBlock(event)) {
@@ -8128,10 +8352,49 @@ function upsertToolBlock(state, event) {
     existing.updatedAt = state.now;
     if (event.eventId !== void 0) existing.eventId = event.eventId;
     if (event.details) existing.details = event.details;
-    if (event.content !== void 0) existing.content = event.content;
+    if (compactTaskOutput) delete existing.content;
+    else if (event.content !== void 0) existing.content = event.content;
     if (event.locations !== void 0) existing.locations = event.locations;
     if (event.rawInput !== void 0) existing.rawInput = event.rawInput;
-    if (event.rawOutput !== void 0) existing.rawOutput = event.rawOutput;
+    if (rawOutput !== void 0) {
+      if (compactTaskOutput && isRecord2(rawOutput) && isRecord2(existing.rawOutput)) {
+        const prevSummary = isRecord2(existing.rawOutput["executionSummary"]) ? existing.rawOutput["executionSummary"] : void 0;
+        const nextSummary = isRecord2(rawOutput["executionSummary"]) ? rawOutput["executionSummary"] : void 0;
+        if (prevSummary && nextSummary) {
+          const inputTokens = Math.max(
+            finiteNumber(prevSummary["inputTokens"]),
+            finiteNumber(nextSummary["inputTokens"])
+          );
+          const outputTokens = Math.max(
+            finiteNumber(prevSummary["outputTokens"]),
+            finiteNumber(nextSummary["outputTokens"])
+          );
+          rawOutput = {
+            ...rawOutput,
+            executionSummary: {
+              ...nextSummary,
+              inputTokens,
+              outputTokens,
+              cachedTokens: Math.max(
+                finiteNumber(prevSummary["cachedTokens"]),
+                finiteNumber(nextSummary["cachedTokens"])
+              ),
+              totalTokens: Math.max(
+                finiteNumber(prevSummary["totalTokens"]),
+                finiteNumber(nextSummary["totalTokens"]),
+                inputTokens + outputTokens
+              )
+            }
+          };
+        } else if (prevSummary) {
+          rawOutput = {
+            ...rawOutput,
+            executionSummary: { ...prevSummary }
+          };
+        }
+      }
+      existing.rawOutput = rawOutput;
+    }
     existing.sourceRecordIds = unionStrings(
       existing.sourceRecordIds,
       event.sourceRecordIds
@@ -8172,10 +8435,10 @@ function upsertToolBlock(state, event) {
     ...event.serverTimestamp !== void 0 ? { serverTimestamp: event.serverTimestamp } : {},
     ...event.sourceRecordIds ? { sourceRecordIds: [...event.sourceRecordIds] } : {},
     ...event.details ? { details: event.details } : {},
-    ...event.content !== void 0 ? { content: event.content } : {},
+    ...!compactTaskOutput && event.content !== void 0 ? { content: event.content } : {},
     ...event.locations !== void 0 ? { locations: event.locations } : {},
     ...event.rawInput !== void 0 ? { rawInput: event.rawInput } : {},
-    ...event.rawOutput !== void 0 ? { rawOutput: event.rawOutput } : {},
+    ...rawOutput !== void 0 ? { rawOutput } : {},
     ...event.toolName ? { toolName: event.toolName } : {},
     ...event.toolKind ? { toolKind: event.toolKind } : {},
     ...event.parentToolCallId ? { parentToolCallId: event.parentToolCallId } : {},
@@ -8196,6 +8459,38 @@ function upsertToolBlock(state, event) {
   clearActiveText(state, event.parentToolCallId);
 }
 __name(upsertToolBlock, "upsertToolBlock");
+function discardToolBlock(state, toolCallId) {
+  const blockId = state.toolBlockByCallId[toolCallId];
+  if (!blockId || blockId === TRIMMED_TOOL_BLOCK_ID) return;
+  takeBlocksOwnership(state);
+  state.blocks = state.blocks.filter((block) => block.id !== blockId);
+  state.blockIndexById = rebuildDaemonTranscriptBlockIndex(state.blocks);
+  delete state.toolBlockByCallId[toolCallId];
+  delete state.toolProgress[toolCallId];
+  if (state.currentToolCallId === toolCallId) {
+    state.currentToolCallId = void 0;
+  }
+}
+__name(discardToolBlock, "discardToolBlock");
+function compactTaskExecutionOutput(rawOutput, retainSubagentBlocks) {
+  if (retainSubagentBlocks || !isRecord2(rawOutput) || rawOutput["type"] !== "task_execution") {
+    return rawOutput;
+  }
+  const compact = { type: "task_execution" };
+  for (const key of [
+    "subagentName",
+    "subagentColor",
+    "taskDescription",
+    "status",
+    "terminateReason",
+    "tokenCount",
+    "executionSummary"
+  ]) {
+    if (rawOutput[key] !== void 0) compact[key] = rawOutput[key];
+  }
+  return compact;
+}
+__name(compactTaskExecutionOutput, "compactTaskExecutionOutput");
 function updateCurrentToolPointer(state, toolCallId, status) {
   if (status === void 0) return;
   if (IN_FLIGHT_TOOL_STATUSES.has(status)) {
@@ -8425,6 +8720,7 @@ function cloneTranscriptState(state, opts) {
     ...state,
     now: opts.now ?? Date.now(),
     maxBlocks: opts.maxBlocks ?? state.maxBlocks,
+    retainSubagentBlocks: opts.retainSubagentBlocks ?? state.retainSubagentBlocks,
     // Lazy copy-on-write for
     // `blocks` + `blockIndexById`. Eager `[...state.blocks]` defeated the
     // `sortedBlocksCache` / `childrenIndexCache` WeakMaps — every dispatch
@@ -8894,6 +9190,7 @@ function createDaemonTranscriptStore(seed = {}) {
     reset(nextSeed = {}) {
       state = createState({
         maxBlocks: nextSeed.maxBlocks ?? state.maxBlocks,
+        retainSubagentBlocks: nextSeed.retainSubagentBlocks ?? state.retainSubagentBlocks,
         ...nextSeed
       });
       scheduleNotify();
@@ -9003,7 +9300,7 @@ function daemonUiEventToTerminalText(event) {
     case "tool.update":
       return terminalLine(
         `tool ${event.status}`,
-        `${event.title}${event.details ? ` ${event.details}` : ""}`,
+        `${event.title ?? event.toolName ?? event.toolKind ?? "Tool"}${event.details ? ` ${event.details}` : ""}`,
         "38;5;75"
       );
     case "shell.output":