@qwen-code/qwen-code 0.19.6 → 0.19.7-nightly.20260708.394c1a289

package/chunks/{chunk-B236XPGF.js → chunk-NQKLOAVJ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -97,7 +97,33 @@ ${body}
 `;
 }
 __name(buildSkillLlmContent, "buildSkillLlmContent");
+var collectCache = /* @__PURE__ */ new WeakMap();
+var COLLECT_CACHE_TTL_MS = 2e3;
+function clearCollectedSkillEntriesCache(skillManager) {
+  if (skillManager) {
+    collectCache.delete(skillManager);
+  } else {
+    collectCache = /* @__PURE__ */ new WeakMap();
+  }
+}
+__name(clearCollectedSkillEntriesCache, "clearCollectedSkillEntriesCache");
 async function collectAvailableSkillEntries(skillManager, config) {
+  const cached = collectCache.get(skillManager);
+  if (cached && Date.now() - cached.ts < COLLECT_CACHE_TTL_MS) {
+    return cached.promise;
+  }
+  const promise = collectAvailableSkillEntriesUncached(skillManager, config);
+  collectCache.set(skillManager, { promise, ts: Date.now() });
+  promise.catch(() => {
+    const entry = collectCache.get(skillManager);
+    if (entry?.promise === promise) {
+      collectCache.delete(skillManager);
+    }
+  });
+  return promise;
+}
+__name(collectAvailableSkillEntries, "collectAvailableSkillEntries");
+async function collectAvailableSkillEntriesUncached(skillManager, config) {
   const allSkills = await skillManager.listSkills();
   const disabledNames = config.getDisabledSkillNames();
   const isDisabled = /* @__PURE__ */ __name((name) => disabledNames.has(name.toLowerCase()), "isDisabled");
@@ -136,7 +162,7 @@ async function collectAvailableSkillEntries(skillManager, config) {
     entries
   };
 }
-__name(collectAvailableSkillEntries, "collectAvailableSkillEntries");
+__name(collectAvailableSkillEntriesUncached, "collectAvailableSkillEntriesUncached");
 function compareSkillEntries(a, b) {
   const aGroup = a.level !== void 0 ? 0 : 1;
   const bGroup = b.level !== void 0 ? 0 : 1;
@@ -247,6 +273,7 @@ export {
   escapeXml,
   escapeSystemReminderTags,
   buildSkillLlmContent,
+  clearCollectedSkillEntriesCache,
   collectAvailableSkillEntries,
   renderAvailableSkillsBlock,
   applySkillAllowedTools,

package/chunks/{chunk-LXFCHX4X.js → chunk-OU6FPTJZ.js}

@@ -22,18 +22,22 @@ import {
   SessionShellDisabledError,
   WorkspaceMismatchError,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-T22H4V4R.js";
+} from "./chunk-B34OV7K2.js";
 import {
+  LOAD_REPLAY_BULK_MODE,
+  LOAD_REPLAY_META_KEY,
+  LOAD_REPLAY_MODE_META_KEY,
+  LOAD_REPLAY_VERSION,
   MID_TURN_QUEUE_DRAIN_METHOD
-} from "./chunk-EWALXUAD.js";
+} from "./chunk-AGHU5VRK.js";
 import {
   canonicalizeWorkspace
-} from "./chunk-SEZC2725.js";
+} from "./chunk-ER3BKOLB.js";
 import {
   DEFAULT_RING_SIZE,
   EVENT_SCHEMA_VERSION,
   EventBus
-} from "./chunk-ALX6BUYW.js";
+} from "./chunk-G7ZG7CA6.js";
 import {
   ClientSideConnection,
   PROTOCOL_VERSION,
@@ -41,7 +45,7 @@ import {
 } from "./chunk-VRDMOSQS.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-57NRQM3P.js";
+} from "./chunk-K34DD7FH.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -50,15 +54,15 @@ import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-7Z6UEJA4.js";
+} from "./chunk-ME344634.js";
 import {
   ShellExecutionService,
   TrustGateError
-} from "./chunk-AGZF43UV.js";
+} from "./chunk-E7HM76PR.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-JN2VJ33O.js";
+} from "./chunk-7I4MGFBN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -1198,7 +1202,7 @@ function sliceLineRange(content, startLine, endLine) {
 }
 __name(sliceLineRange, "sliceLineRange");
 var BridgeClient = class {
-  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true) {
+  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true, onTokenUsage) {
     this.resolveEntry = resolveEntry;
     this.resolvePendingRestoreEvents = resolvePendingRestoreEvents;
     this.mediator = mediator;
@@ -1209,6 +1213,7 @@ var BridgeClient = class {
     this.onModePromoted = onModePromoted;
     this.clientMcpSender = clientMcpSender;
     this.ownsSession = ownsSession;
+    this.onTokenUsage = onTokenUsage;
   }
   static {
     __name(this, "BridgeClient");
@@ -1271,11 +1276,27 @@ var BridgeClient = class {
     const entry = this.resolveEntry(params.sessionId);
     const events = entry?.events ?? this.resolvePendingRestoreEvents(params.sessionId);
     if (!events) return;
+    const prepared = this.prepareSessionUpdateFrames(params, entry);
+    for (const frame of prepared.frames) {
+      events.publish(frame);
+    }
+    try {
+      this.recordLiveTokenUsage(params, entry);
+    } catch {
+    }
+    if (entry && prepared.artifacts.length > 0) {
+      await this.upsertAndPublishArtifacts(entry, prepared.artifacts, {
+        trustedPublisher: prepared.trustedPublisher
+      });
+    }
+  }
+  prepareSessionUpdateFrames(params, entry) {
     const originator = entry?.activePromptOriginatorClientId ? { originatorClientId: entry.activePromptOriginatorClientId } : {};
+    const frames = [];
     const a2ui = extractA2uiToolUpdate(params);
     if (a2ui) {
       for (const surface of a2ui.surfaces) {
-        events.publish({
+        frames.push({
           type: "session_update",
           data: {
             sessionId: params.sessionId,
@@ -1304,19 +1325,70 @@ var BridgeClient = class {
       entry.sessionId
     ) : [];
     const publishParams = sanitizeSessionUpdateArtifacts(params, updateMeta);
-    events.publish({
+    frames.push({
       type: "session_update",
       data: publishParams,
       ...originator,
       ...serverTimestamp !== void 0 ? { _meta: { serverTimestamp } } : {}
     });
-    if (entry) {
-      if (artifacts.length > 0) {
-        await this.upsertAndPublishArtifacts(entry, artifacts, {
-          trustedPublisher: isTrustedArtifactToolUpdate(params, updateMeta)
+    return {
+      frames,
+      artifacts,
+      trustedPublisher: isTrustedArtifactToolUpdate(params, updateMeta)
+    };
+  }
+  async seedSessionUpdates(entry, updates) {
+    const frames = [];
+    const artifactBatches = [];
+    for (const update of updates) {
+      const prepared = this.prepareSessionUpdateFrames(
+        { sessionId: entry.sessionId, update },
+        entry
+      );
+      frames.push(...prepared.frames);
+      if (prepared.artifacts.length > 0) {
+        artifactBatches.push({
+          artifacts: prepared.artifacts,
+          trustedPublisher: prepared.trustedPublisher
         });
       }
     }
+    entry.events.seedReplayEvents(frames);
+    for (const batch of artifactBatches) {
+      await this.upsertAndPublishArtifacts(entry, batch.artifacts, {
+        trustedPublisher: batch.trustedPublisher
+      });
+    }
+  }
+  /**
+   * Daemon token-burn accounting for LIVE model turns. Called only from
+   * `sessionUpdate` (the live session/update fan-in), never from
+   * `seedSessionUpdates` — so batch load-replay never lands historical usage in
+   * the current metrics window. Additionally guarded on a live `entry`: a stray
+   * pending-restore frame (entry not yet registered) is skipped too, so replayed
+   * history can't post a phantom burn spike with no model call.
+   *
+   * Usage rides an otherwise-empty `agent_message_chunk` as `update._meta.usage`
+   * with per-round camelCase increments; subagent frames carry their own usage
+   * (tagged `parentToolCallId`) and are independent turns, so counting each
+   * frame once is the correct total. `_meta`/`usage` are optional and untyped.
+   */
+  recordLiveTokenUsage(params, entry) {
+    if (!this.onTokenUsage || !entry) return;
+    const updateMeta = params.update._meta;
+    const usage = updateMeta?.["usage"];
+    if (usage === null || typeof usage !== "object") return;
+    const inputTokens = usage.inputTokens;
+    const outputTokens = usage.outputTokens;
+    if (typeof inputTokens !== "number" && typeof outputTokens !== "number") {
+      return;
+    }
+    const durationMs = updateMeta?.["durationMs"];
+    this.onTokenUsage(
+      typeof inputTokens === "number" ? inputTokens : 0,
+      typeof outputTokens === "number" ? outputTokens : 0,
+      typeof durationMs === "number" ? durationMs : void 0
+    );
   }
   /**
    * Bounded early-event buffer. Frames are keyed by sessionId; each
@@ -3068,6 +3140,95 @@ var NOOP_BRIDGE_TELEMETRY = {
     return { ...request, _meta: nextMeta };
   }
 };
+var KNOWN_SESSION_UPDATE_TYPES = /* @__PURE__ */ new Set([
+  "user_message_chunk",
+  "agent_message_chunk",
+  "agent_thought_chunk",
+  "tool_call",
+  "tool_call_update",
+  "plan",
+  "available_commands_update",
+  "current_mode_update",
+  "config_option_update",
+  "session_info_update",
+  "usage_update"
+]);
+var MAX_BULK_REPLAY_UPDATES = 1e4;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord2, "isRecord");
+function isBulkReplayUpdate(value) {
+  if (!isRecord2(value)) return false;
+  const updateType = value["sessionUpdate"];
+  return typeof updateType === "string" && KNOWN_SESSION_UPDATE_TYPES.has(updateType);
+}
+__name(isBulkReplayUpdate, "isBulkReplayUpdate");
+function describeLoadReplayValue(value) {
+  if (Array.isArray(value)) return "array";
+  if (value === null) return "null";
+  return typeof value;
+}
+__name(describeLoadReplayValue, "describeLoadReplayValue");
+function extractLoadReplayResponse(state) {
+  const meta = isRecord2(state._meta) ? state._meta : void 0;
+  const replay = meta?.[LOAD_REPLAY_META_KEY];
+  if (replay === void 0) return { state, updates: [] };
+  if (!isRecord2(replay) || replay["v"] !== LOAD_REPLAY_VERSION) {
+    const version = isRecord2(replay) ? replay["v"] : void 0;
+    throw new Error(
+      `Invalid qwen.session.loadReplay payload (type=${describeLoadReplayValue(replay)}, version=${JSON.stringify(version)})`
+    );
+  }
+  const rawUpdates = replay["updates"];
+  if (!Array.isArray(rawUpdates)) {
+    throw new Error(
+      `Invalid qwen.session.loadReplay updates (version=${LOAD_REPLAY_VERSION}, count=not-array)`
+    );
+  }
+  if (rawUpdates.length > MAX_BULK_REPLAY_UPDATES) {
+    throw new Error(
+      `qwen.session.loadReplay updates exceed limit (${rawUpdates.length} > ${MAX_BULK_REPLAY_UPDATES})`
+    );
+  }
+  const partial = replay["partial"];
+  if (partial !== void 0 && partial !== true) {
+    throw new Error(
+      `Invalid qwen.session.loadReplay partial (version=${LOAD_REPLAY_VERSION}, partial=${JSON.stringify(partial)})`
+    );
+  }
+  const replayError = replay["replayError"];
+  if (replayError !== void 0 && typeof replayError !== "string") {
+    throw new Error(
+      `Invalid qwen.session.loadReplay replayError (version=${LOAD_REPLAY_VERSION}, replayError=${describeLoadReplayValue(replayError)})`
+    );
+  }
+  const invalidUpdateIndex = rawUpdates.findIndex(
+    (update) => !isBulkReplayUpdate(update)
+  );
+  if (invalidUpdateIndex !== -1) {
+    const invalidUpdate = rawUpdates[invalidUpdateIndex];
+    const discriminator = isRecord2(invalidUpdate) ? invalidUpdate["sessionUpdate"] : void 0;
+    throw new Error(
+      `Invalid qwen.session.loadReplay update at index ${invalidUpdateIndex} (version=${LOAD_REPLAY_VERSION}, count=${rawUpdates.length}, sessionUpdate=${JSON.stringify(discriminator)})`
+    );
+  }
+  const nextMeta = { ...meta ?? {} };
+  delete nextMeta[LOAD_REPLAY_META_KEY];
+  const cleanState = { ...state };
+  if (Object.keys(nextMeta).length > 0) {
+    cleanState._meta = nextMeta;
+  } else {
+    delete cleanState._meta;
+  }
+  return {
+    state: cleanState,
+    updates: rawUpdates,
+    ...partial === true ? { partial: true } : {},
+    ...typeof replayError === "string" ? { replayError } : {}
+  };
+}
+__name(extractLoadReplayResponse, "extractLoadReplayResponse");
 function isServeDebugLoggingEnabled() {
   const value = process.env["QWEN_SERVE_DEBUG"];
   if (!value) return false;
@@ -3271,9 +3432,19 @@ function extractErrorCode(err) {
   return void 0;
 }
 __name(extractErrorCode, "extractErrorCode");
+function classifyTurnErrorKind(message) {
+  return message.trim().toLowerCase() === "terminated" ? "model_stream_interrupted" : void 0;
+}
+__name(classifyTurnErrorKind, "classifyTurnErrorKind");
 function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId) {
   const message = extractErrorMessage(err);
   const code = extractErrorCode(err);
+  const errorKind = classifyTurnErrorKind(message);
+  if (errorKind) {
+    writeServeDebugLine(
+      `turn_error classified session=${JSON.stringify(sessionId)} message=${JSON.stringify(message)} errorKind=${JSON.stringify(errorKind)}` + (code ? ` code=${JSON.stringify(code)}` : "") + (promptId ? ` promptId=${JSON.stringify(promptId)}` : "")
+    );
+  }
   entry.retryAllowed = true;
   try {
     entry.events.publish({
@@ -3282,6 +3453,7 @@ function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId)
         sessionId,
         message,
         ...code ? { code } : {},
+        ...errorKind ? { errorKind } : {},
         ...promptId ? { promptId } : {}
       },
       ...originatorClientId ? { originatorClientId } : {}
@@ -3669,7 +3841,16 @@ function createAcpSessionBridge(opts) {
         // Mode A) never host a client MCP server, so the method stays
         // unreachable.
         opts.clientMcpSender,
-        (sessionId) => sessionIds.has(sessionId)
+        (sessionId) => sessionIds.has(sessionId),
+        // Daemon token-burn accounting: forward per-round token usage observed
+        // at the session/update fan-in to the daemon host's metrics ring via
+        // the telemetry seam. Optional-chained so non-daemon callers (tests,
+        // Mode A) that wire no `tokenUsage` metric are a silent no-op.
+        (inputTokens, outputTokens, durationMs) => telemetry.metrics?.tokenUsage?.(
+          inputTokens,
+          outputTokens,
+          durationMs
+        )
       );
       const connection = new ClientSideConnection(() => client, channel.stream);
       const info = {
@@ -3976,6 +4157,42 @@ function createAcpSessionBridge(opts) {
     );
     return response;
   }, "requestWorkspaceStatus");
+  const STALE_CHILD_RESOURCE_MS = 3e4;
+  let childResourceRefreshing = false;
+  const refreshChildResource = /* @__PURE__ */ __name(async () => {
+    if (childResourceRefreshing) return;
+    const info = liveChannelInfo();
+    if (!info) return;
+    childResourceRefreshing = true;
+    try {
+      const res = await requestWorkspaceStatus(SERVE_STATUS_EXT_METHODS.workspaceResource, () => ({}));
+      if (liveChannelInfo() !== info) return;
+      if (typeof res.rssBytes === "number" && Number.isFinite(res.rssBytes)) {
+        info.childRssBytes = res.rssBytes;
+      }
+      if (typeof res.cpuPercent === "number" && Number.isFinite(res.cpuPercent)) {
+        info.childCpuPercent = Math.min(100, Math.max(0, res.cpuPercent));
+      }
+      info.childResourceAt = Date.now();
+    } catch (err) {
+      teeServeDebugLine(
+        `child-resource refresh failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    } finally {
+      childResourceRefreshing = false;
+    }
+  }, "refreshChildResource");
+  const getChildResourceSnapshot = /* @__PURE__ */ __name(() => {
+    const info = liveChannelInfo();
+    if (!info || info.childResourceAt === void 0) return void 0;
+    if (Date.now() - info.childResourceAt > STALE_CHILD_RESOURCE_MS) {
+      return void 0;
+    }
+    return {
+      rssBytes: info.childRssBytes ?? 0,
+      cpuPercent: info.childCpuPercent ?? 0
+    };
+  }, "getChildResourceSnapshot");
   const requestSessionStatus = /* @__PURE__ */ __name(async (sessionId, method, params = {}) => {
     const entry = byId.get(sessionId);
     if (!entry) throw new SessionNotFoundError(sessionId);
@@ -4144,7 +4361,7 @@ function createAcpSessionBridge(opts) {
       if (rerun) void reconcileAfterRoundtrip(entry, target);
     }
   }, "reconcileAfterRoundtrip");
-  const createSessionEntry = /* @__PURE__ */ __name((ci, sessionId, workspaceCwd, events = createSessionEventBus()) => {
+  const createSessionEntry = /* @__PURE__ */ __name((ci, sessionId, workspaceCwd, events = createSessionEventBus(), options = {}) => {
     const entry = {
       sessionId,
       workspaceCwd,
@@ -4173,7 +4390,9 @@ function createAcpSessionBridge(opts) {
     byId.set(entry.sessionId, entry);
     touchActivity();
     telemetry.metrics?.sessionLifecycle("spawn");
-    ci.client.drainEarlyEvents(entry.sessionId, entry);
+    if (options.drainEarlyEvents !== false) {
+      ci.client.drainEarlyEvents(entry.sessionId, entry);
+    }
     return entry;
   }, "createSessionEntry");
   const publishArtifactChanges = /* @__PURE__ */ __name((entry, changes, originatorClientId) => {
@@ -4233,22 +4452,30 @@ function createAcpSessionBridge(opts) {
     return typeof maybe.message === "string" && maybe.message === `Resource not found: ${expectedUri}`;
   }, "isAcpSessionResourceNotFound");
   const replayFieldsFor = /* @__PURE__ */ __name((entry, action) => {
+    const replayStatus = action === "load" && entry.restoreReplayPartial === true ? {
+      partial: true,
+      ...typeof entry.restoreReplayError === "string" ? { replayError: entry.restoreReplayError } : {}
+    } : {};
     const snapshot = entry.events.snapshotReplay();
-    if (!snapshot) return { lastEventId: entry.events.lastEventId };
+    if (!snapshot) {
+      return { lastEventId: entry.events.lastEventId, ...replayStatus };
+    }
     if (action === "load") {
       return {
         compactedReplay: snapshot.compactedTurns,
         liveJournal: snapshot.liveJournal,
-        lastEventId: snapshot.lastEventId
+        lastEventId: snapshot.lastEventId,
+        ...replayStatus
       };
     }
-    return { lastEventId: snapshot.lastEventId };
+    return { lastEventId: snapshot.lastEventId, ...replayStatus };
   }, "replayFieldsFor");
   async function restoreSession(action, req) {
     if (shuttingDown) {
       throw new Error("AcpSessionBridge is shutting down");
     }
     const workspaceKey = resolveWorkspaceKey(req.workspaceCwd);
+    const historyReplay = action === "load" ? req.historyReplay ?? "stream" : "stream";
     const existing = byId.get(req.sessionId);
     if (existing) {
       existing.attachCount++;
@@ -4268,7 +4495,7 @@ function createAcpSessionBridge(opts) {
     }
     const inFlight = inFlightRestores.get(req.sessionId);
     if (inFlight) {
-      if (action !== inFlight.action) {
+      if (action !== inFlight.action || historyReplay !== inFlight.historyReplay) {
         throw new RestoreInProgressError(
           req.sessionId,
           inFlight.action,
@@ -4317,6 +4544,9 @@ function createAcpSessionBridge(opts) {
       transportClosed.catch(() => {
       });
       let state;
+      let replayUpdates = [];
+      let replayPartial;
+      let replayError;
       try {
         if (action === "load") {
           state = await Promise.race([
@@ -4329,7 +4559,12 @@ function createAcpSessionBridge(opts) {
                 // the agent side. The SDK's `RestoreSessionRequest`
                 // intentionally has no `mcpServers` field for the
                 // same reason.
-                mcpServers: []
+                mcpServers: [],
+                ...historyReplay === "response" ? {
+                  _meta: {
+                    [LOAD_REPLAY_MODE_META_KEY]: LOAD_REPLAY_BULK_MODE
+                  }
+                } : {}
               }),
               initTimeoutMs,
               "loadSession"
@@ -4350,6 +4585,13 @@ function createAcpSessionBridge(opts) {
             transportClosed
           ]);
         }
+        if (action === "load" && historyReplay === "response") {
+          const extracted = extractLoadReplayResponse(state);
+          state = extracted.state;
+          replayUpdates = extracted.updates;
+          replayPartial = extracted.partial;
+          replayError = extracted.replayError;
+        }
       } catch (err) {
         restoreEvents.close();
         if (isAcpSessionResourceNotFound(err, req.sessionId)) {
@@ -4393,10 +4635,21 @@ function createAcpSessionBridge(opts) {
         ci,
         req.sessionId,
         workspaceKey,
-        restoreEvents
+        restoreEvents,
+        { drainEarlyEvents: replayUpdates.length === 0 }
       );
       entry.restoreState = state;
+      if (replayPartial === true) {
+        entry.restoreReplayPartial = true;
+      }
+      if (replayError !== void 0) {
+        entry.restoreReplayError = replayError;
+      }
       seedSnapshotCaches(entry, state);
+      if (replayUpdates.length > 0) {
+        await ci.client.seedSessionUpdates(entry, replayUpdates);
+        ci.client.drainEarlyEvents(entry.sessionId, entry);
+      }
       const clientId = registerClient(entry, req.clientId);
       entry.attachCount = coalesceState.count;
       registeredEntry = entry;
@@ -4416,13 +4669,28 @@ function createAcpSessionBridge(opts) {
       pendingRestoreEvents.delete(req.sessionId);
       if (!registeredEntry) {
         restoreEvents.close();
+        let removedRestoreEntry = false;
+        if (byId.get(req.sessionId)?.events === restoreEvents) {
+          byId.delete(req.sessionId);
+          ci?.sessionIds.delete(req.sessionId);
+          removedRestoreEntry = true;
+        }
+        if (removedRestoreEntry && ci && hasNoChannelWork(ci)) {
+          ci.emptyReapPending = true;
+          ci.isDying = true;
+        }
         ci?.client.markSessionClosed(req.sessionId);
       }
       if (ci) {
         await reapPendingEmptyChannel(ci);
       }
     });
-    inFlightRestores.set(req.sessionId, { action, promise, coalesceState });
+    inFlightRestores.set(req.sessionId, {
+      action,
+      historyReplay,
+      promise,
+      coalesceState
+    });
     try {
       return await promise;
     } finally {
@@ -4548,6 +4816,19 @@ function createAcpSessionBridge(opts) {
     get sessionCount() {
       return byId.size;
     },
+    get pendingPromptTotal() {
+      let total = 0;
+      for (const entry of byId.values()) {
+        for (const pending of entry.pendingPromptList) {
+          if (pending.state === "queued") total += 1;
+        }
+      }
+      return total;
+    },
+    // Daemon Status child-resource: sync cache read for the sampler + the async
+    // refresh it fires each tick to update that cache.
+    getChildResourceSnapshot,
+    refreshChildResource,
     get activePromptCount() {
       return activePromptCounter;
     },
@@ -5007,6 +5288,11 @@ function createAcpSessionBridge(opts) {
       if (!entry) throw new SessionNotFoundError(sessionId);
       return entry.events.lastEventId;
     },
+    getSessionReplaySnapshot(sessionId) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      return entry.events.snapshotReplay();
+    },
     respondToPermission(requestId, response, context) {
       const sessionId = permissionMediator.peekSessionFor(requestId);
       if (sessionId === void 0 || !byId.has(sessionId)) {
@@ -6558,6 +6844,7 @@ export {
   SessionArtifactValidationError,
   extractErrorMessage,
   extractErrorCode,
+  classifyTurnErrorKind,
   createAcpSessionBridge,
   createHttpAcpBridge
 };

package/chunks/{chunk-HTWHAN44.js → chunk-PC4ZXHU2.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-TLRYABYP.js";
 import {
   createDebugLogger
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-3X76L4UF.js → chunk-PLGONYEL.js}

@@ -5,19 +5,19 @@ import {
 } from "./chunk-3GONHQOA.js";
 import {
   getErrorMessage
-} from "./chunk-OIFSBXSP.js";
+} from "./chunk-SJHAUELE.js";
 import {
   loadSettings
-} from "./chunk-CEYA7K7C.js";
+} from "./chunk-QHT5USLK.js";
 import {
   getCurrentLanguage,
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-6QVRLKTZ.js";
+} from "./chunk-TBLJNMI7.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-V6NH3CUC.js";
+} from "./chunk-MOQOAH7N.js";
 import {
   writeStderrLine,
   writeStdoutLine
@@ -29,7 +29,7 @@ import {
   redactUrlCredentials,
   require_prompts,
   stripAnsi
-} from "./chunk-AGZF43UV.js";
+} from "./chunk-E7HM76PR.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-WXUDZHOJ.js → chunk-PVXPDMGP.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-O2RJARYU.js";
+} from "./chunk-KKWO4IX2.js";
 import {
   parseAndFormatApiError
-} from "./chunk-AGZF43UV.js";
+} from "./chunk-E7HM76PR.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -399,6 +399,14 @@ ${event.value}`, null);
         this.appendText(state, errorText, null);
         break;
       }
+      case "model_fallback" /* ModelFallback */:
+        this.emitSystemMessage("model_fallback", {
+          fromModel: event.fromModel,
+          toModel: event.toModel,
+          statusCode: event.statusCode,
+          fallbackIndex: event.fallbackIndex
+        });
+        break;
       default:
         break;
     }

package/chunks/{chunk-ZO5EA3XJ.js → chunk-QCSLZO6J.js}

@@ -60,7 +60,7 @@ async function runExitCleanup(options = {}) {
 }
 __name(runExitCleanup, "runExitCleanup");
 async function cleanupCheckpoints() {
-  const { Storage } = await import("./src-HITDGVRM.js");
+  const { Storage } = await import("./src-NLEX4CUC.js");
   const storage = new Storage(process.cwd());
   const tempDir = storage.getProjectTempDir();
   const checkpointsDir = join(tempDir, "checkpoints");