@zubriq/code 0.19.8-1 → 0.19.9-1

package/dist/chunks/{chunk-MJQFA66Z.js → chunk-FAATDXYS.js}

@@ -1,5 +1,21 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  LOAD_REPLAY_BULK_MODE,
+  LOAD_REPLAY_META_KEY,
+  LOAD_REPLAY_MODE_META_KEY,
+  LOAD_REPLAY_VERSION,
+  MID_TURN_QUEUE_DRAIN_METHOD
+} from "./chunk-AGHU5VRK.js";
+import {
+  DEFAULT_RING_SIZE,
+  EVENT_SCHEMA_VERSION,
+  EventBus,
+  serializedBridgeEventByteLength
+} from "./chunk-3UP777ZS.js";
+import {
+  normalizeCompactedReplayMaxBytes
+} from "./chunk-GLE2YUPU.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS
 } from "./chunk-P7M4GA57.js";
@@ -22,22 +38,10 @@ import {
   SessionShellDisabledError,
   WorkspaceMismatchError,
   isNotCurrentlyGeneratingCancelError
-} 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-AGHU5VRK.js";
+} from "./chunk-GGQQA4JW.js";
 import {
   canonicalizeWorkspace
 } from "./chunk-ER3BKOLB.js";
-import {
-  DEFAULT_RING_SIZE,
-  EVENT_SCHEMA_VERSION,
-  EventBus
-} from "./chunk-G7ZG7CA6.js";
 import {
   ClientSideConnection,
   PROTOCOL_VERSION,
@@ -45,7 +49,7 @@ import {
 } from "./chunk-VRDMOSQS.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-7AQTBTVY.js";
+} from "./chunk-EJP6Z7NU.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -54,15 +58,15 @@ import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-NHFBLJOI.js";
+} from "./chunk-Q3PQ5VGJ.js";
 import {
   ShellExecutionService,
   TrustGateError
-} from "./chunk-PDITONOB.js";
+} from "./chunk-5MRUKUOG.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-YRM6BC6H.js";
+} from "./chunk-27AYMAL6.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -79,6 +83,7 @@ import * as path3 from "node:path";
 init_esbuild_shims();
 var TURN_BOUNDARY_TYPES = /* @__PURE__ */ new Set(["turn_complete", "turn_error"]);
 var TRANSIENT_TYPES = /* @__PURE__ */ new Set([
+  "history_truncated",
   "slow_client_warning",
   "client_evicted",
   "replay_complete",
@@ -88,17 +93,28 @@ var LATEST_WINS_UPDATES = /* @__PURE__ */ new Set([
   "available_commands_update",
   "current_mode_update"
 ]);
+var REPLAY_SEGMENT_COMPACT_THRESHOLD = 64;
 var TurnBoundaryCompactionEngine = class {
   static {
     __name(this, "TurnBoundaryCompactionEngine");
   }
-  compactedTurns = [];
+  maxReplayBytes;
+  onReplayWindowEviction;
+  replaySegments = [];
+  replaySegmentStart = 0;
+  replayBytes = 0;
   liveJournal = [];
   lastEventId = 0;
   closed = false;
+  truncatedEvents = 0;
+  truncatedTurns = 0;
   slots = [];
   toolSlotIndex = /* @__PURE__ */ new Map();
   textSlotIndex = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.maxReplayBytes = normalizeCompactedReplayMaxBytes(opts.maxReplayBytes);
+    this.onReplayWindowEviction = opts.onReplayWindowEviction;
+  }
   ingest(event) {
     if (this.closed) return;
     if (event.id !== void 0) {
@@ -117,16 +133,39 @@ var TurnBoundaryCompactionEngine = class {
     this.slots.push({ kind: "misc", event });
   }
   snapshot() {
+    const compactedTurns = this.flattenReplaySegments();
+    if (this.truncatedEvents > 0) {
+      compactedTurns.unshift(
+        this.makeHistoryTruncatedEvent(compactedTurns.length)
+      );
+    }
     return {
-      compactedTurns: this.compactedTurns.slice(),
+      compactedTurns,
       liveJournal: this.liveJournal.slice(),
       lastEventId: this.lastEventId
     };
   }
   seed(snapshot) {
     if (this.closed) return;
-    this.compactedTurns = snapshot.compactedTurns.slice();
+    this.resetReplayWindow();
     this.lastEventId = snapshot.lastEventId;
+    for (const event of snapshot.compactedTurns) {
+      if (TRANSIENT_TYPES.has(event.type)) continue;
+      this.addReplaySegment([event], 0);
+    }
+    this.liveJournal = [];
+    this.slots = [];
+    this.toolSlotIndex.clear();
+    this.textSlotIndex.clear();
+  }
+  seedReplayEvents(events) {
+    if (this.closed) return;
+    this.resetReplayWindow();
+    for (const event of events) {
+      this.recordLastEventId(event);
+      if (TRANSIENT_TYPES.has(event.type)) continue;
+      this.addReplaySegment([event], 0);
+    }
     this.liveJournal = [];
     this.slots = [];
     this.toolSlotIndex.clear();
@@ -135,7 +174,7 @@ var TurnBoundaryCompactionEngine = class {
   close() {
     if (this.closed) return;
     this.closed = true;
-    this.compactedTurns = [];
+    this.resetReplayWindow();
     this.liveJournal = [];
     this.slots = [];
     this.toolSlotIndex.clear();
@@ -272,12 +311,94 @@ var TurnBoundaryCompactionEngine = class {
       }
     }
     compacted.push(boundaryEvent);
-    this.compactedTurns.push(...compacted);
+    this.addReplaySegment(compacted, 1);
     this.liveJournal = [];
     this.slots = [];
     this.toolSlotIndex.clear();
     this.textSlotIndex.clear();
   }
+  recordLastEventId(event) {
+    if (event.id !== void 0) {
+      this.lastEventId = event.id;
+    }
+  }
+  addReplaySegment(events, turnCount) {
+    if (events.length === 0) return;
+    const bytes = events.reduce(
+      (sum, event) => sum + serializedBridgeEventByteLength(event),
+      0
+    );
+    this.replaySegments.push({ events: events.slice(), bytes, turnCount });
+    this.replayBytes += bytes;
+    this.enforceReplayWindow();
+  }
+  enforceReplayWindow() {
+    let droppedSegmentCount = 0;
+    let droppedBytes = 0;
+    let droppedEvents = 0;
+    let droppedTurns = 0;
+    while (this.replayBytes > this.maxReplayBytes && this.activeReplaySegmentCount() > 1) {
+      const dropped = this.replaySegments[this.replaySegmentStart];
+      this.replaySegmentStart += 1;
+      droppedSegmentCount += 1;
+      droppedBytes += dropped.bytes;
+      droppedEvents += dropped.events.length;
+      droppedTurns += dropped.turnCount;
+      this.replayBytes -= dropped.bytes;
+      this.truncatedEvents += dropped.events.length;
+      this.truncatedTurns += dropped.turnCount;
+    }
+    if (droppedSegmentCount > 0) {
+      this.compactReplaySegmentQueueIfNeeded();
+      this.notifyReplayWindowEviction({
+        droppedBytes,
+        droppedEvents,
+        droppedSegments: droppedSegmentCount,
+        droppedTurns,
+        maxBytes: this.maxReplayBytes,
+        retainedBytes: this.replayBytes,
+        retainedEvents: this.flattenReplaySegments().length
+      });
+    }
+  }
+  flattenReplaySegments() {
+    return this.replaySegments.slice(this.replaySegmentStart).flatMap((segment) => segment.events);
+  }
+  activeReplaySegmentCount() {
+    return this.replaySegments.length - this.replaySegmentStart;
+  }
+  compactReplaySegmentQueueIfNeeded() {
+    if (this.replaySegmentStart < REPLAY_SEGMENT_COMPACT_THRESHOLD) return;
+    this.replaySegments.splice(0, this.replaySegmentStart);
+    this.replaySegmentStart = 0;
+  }
+  notifyReplayWindowEviction(eviction) {
+    try {
+      this.onReplayWindowEviction?.(eviction);
+    } catch {
+    }
+  }
+  makeHistoryTruncatedEvent(retainedEvents) {
+    return {
+      v: EVENT_SCHEMA_VERSION,
+      type: "history_truncated",
+      data: {
+        reason: "replay_window_exceeded",
+        truncatedEvents: this.truncatedEvents,
+        retainedEvents,
+        maxBytes: this.maxReplayBytes,
+        ...this.truncatedTurns > 0 ? { truncatedTurns: this.truncatedTurns } : {},
+        fullTranscriptAvailable: false
+      }
+    };
+  }
+  resetReplayWindow() {
+    this.replaySegments = [];
+    this.replaySegmentStart = 0;
+    this.replayBytes = 0;
+    this.truncatedEvents = 0;
+    this.truncatedTurns = 0;
+  }
 };
 function makeMergedSessionUpdateEvent(sessionUpdate, text, eventId, meta, envelopeMeta) {
   return {
@@ -3276,6 +3397,18 @@ function isBridgeAutoMemoryTopic(value) {
   return value === "user" || value === "feedback" || value === "project" || value === "reference";
 }
 __name(isBridgeAutoMemoryTopic, "isBridgeAutoMemoryTopic");
+function touchedScopesFromTopics(topics) {
+  const scopes = /* @__PURE__ */ new Set();
+  for (const topic of topics) {
+    scopes.add(topic === "user" || topic === "feedback" ? "user" : "project");
+  }
+  return ["user", "project"].filter((scope) => scopes.has(scope));
+}
+__name(touchedScopesFromTopics, "touchedScopesFromTopics");
+function isBridgeMemoryScope(value) {
+  return value === "user" || value === "project";
+}
+__name(isBridgeMemoryScope, "isBridgeMemoryScope");
 function parseWorkspaceMemoryForgetMatch(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return null;
@@ -3299,14 +3432,17 @@ function parseWorkspaceMemoryForgetResult(response) {
   const summary = record["summary"];
   const removedEntries = record["removedEntries"];
   const touchedTopics = record["touchedTopics"];
+  const touchedScopes = record["touchedScopes"];
   const parsedRemovedEntries = Array.isArray(removedEntries) ? removedEntries.map(parseWorkspaceMemoryForgetMatch) : [];
-  if (summary !== void 0 && typeof summary !== "string" || !Array.isArray(removedEntries) || parsedRemovedEntries.some((entry) => entry === null) || !Array.isArray(touchedTopics) || !touchedTopics.every(isBridgeAutoMemoryTopic)) {
+  if (summary !== void 0 && typeof summary !== "string" || !Array.isArray(removedEntries) || parsedRemovedEntries.some((entry) => entry === null) || !Array.isArray(touchedTopics) || !touchedTopics.every(isBridgeAutoMemoryTopic) || touchedScopes !== void 0 && (!Array.isArray(touchedScopes) || !touchedScopes.every(isBridgeMemoryScope))) {
     throw new Error("Malformed workspace memory forget response");
   }
+  const parsedTouchedTopics = touchedTopics;
   return {
     ...summary === void 0 ? {} : { summary },
     removedEntries: parsedRemovedEntries,
-    touchedTopics
+    touchedTopics: parsedTouchedTopics,
+    touchedScopes: touchedScopes === void 0 ? touchedScopesFromTopics(parsedTouchedTopics) : touchedScopes
   };
 }
 __name(parseWorkspaceMemoryForgetResult, "parseWorkspaceMemoryForgetResult");
@@ -3432,9 +3568,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({
@@ -3443,6 +3589,7 @@ function broadcastTurnError(entry, sessionId, err, promptId, originatorClientId)
         sessionId,
         message,
         ...code ? { code } : {},
+        ...errorKind ? { errorKind } : {},
         ...promptId ? { promptId } : {}
       },
       ...originatorClientId ? { originatorClientId } : {}
@@ -3512,6 +3659,18 @@ function createAcpSessionBridge(opts) {
   } else {
     maxSessions = opts.maxSessions;
   }
+  const reserveFreshSession = /* @__PURE__ */ __name((context) => opts.freshSessionAdmission?.(context), "reserveFreshSession");
+  const releaseFreshSessionReservation = /* @__PURE__ */ __name((reservation) => {
+    if (!reservation) return;
+    try {
+      reservation.release();
+    } catch (err) {
+      opts.onDiagnosticLine?.(
+        `qwen serve: fresh session admission release failed: ${err instanceof Error ? err.message : String(err)}`,
+        "warn"
+      );
+    }
+  }, "releaseFreshSessionReservation");
   if (defaultSessionScope !== "single" && defaultSessionScope !== "thread") {
     throw new TypeError(
       `Invalid sessionScope: ${JSON.stringify(defaultSessionScope)}. Expected 'single' or 'thread'.`
@@ -3523,6 +3682,9 @@ function createAcpSessionBridge(opts) {
       `Invalid eventRingSize: ${opts.eventRingSize}. Must be a positive integer in [1, ${MAX_EVENT_RING_SIZE}].`
     );
   }
+  const compactedReplayMaxBytes = normalizeCompactedReplayMaxBytes(
+    opts.compactedReplayMaxBytes
+  );
   const channelFactory = opts.channelFactory ?? defaultSpawnChannelFactory;
   const childEnvOverrides = opts.childEnvOverrides ? Object.freeze({ ...opts.childEnvOverrides }) : Object.freeze({});
   const initTimeoutMs = opts.initializeTimeoutMs ?? DEFAULT_INIT_TIMEOUT_MS;
@@ -3952,7 +4114,7 @@ function createAcpSessionBridge(opts) {
     }
   }
   __name(ensureChannel, "ensureChannel");
-  async function doSpawn(modelServiceId, effectiveScope, requestedClientId) {
+  async function doSpawn(modelServiceId, effectiveScope, requestedClientId, onSessionRegistered) {
     const ci = await ensureChannel();
     ci.sessionSpawnsInFlight++;
     let sessionRegistered = false;
@@ -3993,6 +4155,7 @@ function createAcpSessionBridge(opts) {
         boundWorkspace
       );
       sessionRegistered = true;
+      onSessionRegistered?.();
       seedSnapshotCaches(entry, newSessionResp);
       const clientId = registerClient(entry, requestedClientId);
       if (effectiveScope === "single" && !defaultEntry) defaultEntry = entry;
@@ -4269,7 +4432,18 @@ function createAcpSessionBridge(opts) {
       );
     }
   }, "broadcastWorkspaceEvent");
-  const createSessionEventBus = /* @__PURE__ */ __name(() => new EventBus(eventRingSize, void 0, new TurnBoundaryCompactionEngine()), "createSessionEventBus");
+  const createSessionEventBus = /* @__PURE__ */ __name(() => new EventBus(
+    eventRingSize,
+    void 0,
+    new TurnBoundaryCompactionEngine({
+      maxReplayBytes: compactedReplayMaxBytes,
+      onReplayWindowEviction: /* @__PURE__ */ __name((eviction) => {
+        teeServeDebugLine(
+          `replay window evicted ${JSON.stringify(eviction)}`
+        );
+      }, "onReplayWindowEviction")
+    })
+  ), "createSessionEventBus");
   const publishModelSwitched = /* @__PURE__ */ __name((entry, modelId, originatorClientId) => {
     entry.currentModelId = modelId;
     entry.modelPublishGeneration++;
@@ -4459,7 +4633,7 @@ function createAcpSessionBridge(opts) {
     }
     return { lastEventId: snapshot.lastEventId, ...replayStatus };
   }, "replayFieldsFor");
-  async function restoreSession(action, req) {
+  async function restoreSession(action, req, options = {}) {
     if (shuttingDown) {
       throw new Error("AcpSessionBridge is shutting down");
     }
@@ -4522,6 +4696,17 @@ function createAcpSessionBridge(opts) {
     let registeredEntry;
     let ci;
     const coalesceState = { count: 0 };
+    const admission = options.skipFreshSessionAdmission === true ? void 0 : reserveFreshSession({
+      operation: action,
+      workspaceCwd: workspaceKey,
+      sessionId: req.sessionId
+    });
+    let admissionReleased = false;
+    const releaseAdmissionOnce = /* @__PURE__ */ __name(() => {
+      if (admissionReleased) return;
+      admissionReleased = true;
+      releaseFreshSessionReservation(admission);
+    }, "releaseAdmissionOnce");
     const promise = (async () => {
       pendingRestoreEvents.set(req.sessionId, restoreEvents);
       ci = await ensureChannel();
@@ -4627,6 +4812,7 @@ function createAcpSessionBridge(opts) {
         restoreEvents,
         { drainEarlyEvents: replayUpdates.length === 0 }
       );
+      releaseAdmissionOnce();
       entry.restoreState = state;
       if (replayPartial === true) {
         entry.restoreReplayPartial = true;
@@ -4653,6 +4839,7 @@ function createAcpSessionBridge(opts) {
         ...replayFieldsFor(entry, action)
       };
     })().finally(async () => {
+      releaseAdmissionOnce();
       ci?.pendingRestoreIds.delete(req.sessionId);
       ci?.client.clearRestoreInFlight(req.sessionId);
       pendingRestoreEvents.delete(req.sessionId);
@@ -4777,6 +4964,7 @@ function createAcpSessionBridge(opts) {
           maxSessions: maxSessions === Infinity ? null : maxSessions,
           maxPendingPromptsPerSession: maxPendingPromptsPerSession === Infinity ? null : maxPendingPromptsPerSession,
           eventRingSize,
+          compactedReplayMaxBytes,
           channelIdleTimeoutMs: resolvedChannelIdleTimeoutMs(),
           sessionIdleTimeoutMs
         },
@@ -4906,12 +5094,28 @@ function createAcpSessionBridge(opts) {
       if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
         throw new SessionLimitExceededError(maxSessions);
       }
-      const promise = doSpawn(req.modelServiceId, effectiveScope, req.clientId);
+      const admission = reserveFreshSession({
+        operation: "spawn",
+        workspaceCwd: workspaceKey
+      });
+      let admissionReleased = false;
+      const releaseAdmissionOnce = /* @__PURE__ */ __name(() => {
+        if (admissionReleased) return;
+        admissionReleased = true;
+        releaseFreshSessionReservation(admission);
+      }, "releaseAdmissionOnce");
+      const promise = doSpawn(
+        req.modelServiceId,
+        effectiveScope,
+        req.clientId,
+        releaseAdmissionOnce
+      );
       const tracker = effectiveScope === "single" ? workspaceKey : `${workspaceKey}#${randomUUID2()}`;
       inFlightSpawns.set(tracker, promise);
       try {
         return await promise;
       } finally {
+        releaseAdmissionOnce();
         inFlightSpawns.delete(tracker);
       }
     },
@@ -5368,67 +5572,89 @@ function createAcpSessionBridge(opts) {
         if (byId.size + inFlightSpawns.size + inFlightRestores.size >= maxSessions) {
           throw new SessionLimitExceededError(maxSessions);
         }
-        const ci = await ensureChannel();
-        const result = await withTimeout(
-          ci.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionBranch, {
-            sessionId,
-            cwd: boundWorkspace,
-            name: req.name
-          }),
-          initTimeoutMs,
-          "branchSession"
-        );
-        if (!result || typeof result.newSessionId !== "string") {
-          throw new Error(
-            `branchSession: agent returned invalid response: ${JSON.stringify(result)}`
-          );
-        }
-        const rawBranchName = result.displayName ?? result.title;
-        const branchDisplayName = typeof rawBranchName === "string" ? rawBranchName : result.newSessionId.slice(0, 8);
-        let restored;
+        const admission = reserveFreshSession({
+          operation: "branch",
+          workspaceCwd: boundWorkspace,
+          sourceSessionId: sessionId
+        });
+        let admissionReleased = false;
+        const releaseAdmissionOnce = /* @__PURE__ */ __name(() => {
+          if (admissionReleased) return;
+          admissionReleased = true;
+          releaseFreshSessionReservation(admission);
+        }, "releaseAdmissionOnce");
         try {
-          restored = await restoreSession("load", {
-            sessionId: result.newSessionId,
-            workspaceCwd: boundWorkspace,
-            clientId: context?.clientId
-          });
-        } catch (restoreErr) {
-          writeStderrLine(
-            `qwen serve: branchSession load failed for ${result.newSessionId}, attempting cleanup...`
+          const ci = await ensureChannel();
+          const result = await withTimeout(
+            ci.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionBranch, {
+              sessionId,
+              cwd: boundWorkspace,
+              name: req.name
+            }),
+            initTimeoutMs,
+            "branchSession"
           );
+          if (!result || typeof result.newSessionId !== "string") {
+            throw new Error(
+              `branchSession: agent returned invalid response: ${JSON.stringify(result)}`
+            );
+          }
+          const rawBranchName = result.displayName ?? result.title;
+          const branchDisplayName = typeof rawBranchName === "string" ? rawBranchName : result.newSessionId.slice(0, 8);
+          let restored;
           try {
-            await ci.connection.extMethod(
-              SERVE_CONTROL_EXT_METHODS.sessionClose,
-              { sessionId: result.newSessionId, cwd: boundWorkspace }
+            restored = await restoreSession(
+              "load",
+              {
+                sessionId: result.newSessionId,
+                workspaceCwd: boundWorkspace,
+                clientId: context?.clientId
+              },
+              {
+                skipFreshSessionAdmission: true
+              }
             );
-          } catch (cleanupErr) {
+            releaseAdmissionOnce();
+          } catch (restoreErr) {
             writeStderrLine(
-              `qwen serve: branchSession cleanup of ${result.newSessionId} failed: ${cleanupErr instanceof Error ? cleanupErr.message : cleanupErr}`
+              `qwen serve: branchSession load failed for ${result.newSessionId}, attempting cleanup...`
             );
+            try {
+              await ci.connection.extMethod(
+                SERVE_CONTROL_EXT_METHODS.sessionClose,
+                { sessionId: result.newSessionId, cwd: boundWorkspace }
+              );
+            } catch (cleanupErr) {
+              writeStderrLine(
+                `qwen serve: branchSession cleanup of ${result.newSessionId} failed: ${cleanupErr instanceof Error ? cleanupErr.message : cleanupErr}`
+              );
+            }
+            throw restoreErr;
           }
-          throw restoreErr;
+          const newEntry = byId.get(result.newSessionId);
+          if (newEntry) newEntry.displayName = branchDisplayName;
+          const eventData = {
+            sourceSessionId: sessionId,
+            newSessionId: result.newSessionId,
+            displayName: branchDisplayName
+          };
+          const branchEnvelope = {
+            type: "session_branched",
+            data: eventData,
+            ...originatorClientId ? { originatorClientId } : {}
+          };
+          newEntry?.events.publish(branchEnvelope);
+          return {
+            ...restored,
+            displayName: branchDisplayName,
+            forkedFrom: {
+              sessionId,
+              displayName: entry.displayName ?? sessionId.slice(0, 8)
+            }
+          };
+        } finally {
+          releaseAdmissionOnce();
         }
-        const newEntry = byId.get(result.newSessionId);
-        if (newEntry) newEntry.displayName = branchDisplayName;
-        const eventData = {
-          sourceSessionId: sessionId,
-          newSessionId: result.newSessionId,
-          displayName: branchDisplayName
-        };
-        const branchEnvelope = {
-          type: "session_branched",
-          data: eventData,
-          ...originatorClientId ? { originatorClientId } : {}
-        };
-        newEntry?.events.publish(branchEnvelope);
-        return {
-          ...restored,
-          displayName: branchDisplayName,
-          forkedFrom: {
-            sessionId,
-            displayName: entry.displayName ?? sessionId.slice(0, 8)
-          }
-        };
       });
       entry.promptQueue = branchResult.then(
         () => void 0,
@@ -6833,6 +7059,7 @@ export {
   SessionArtifactValidationError,
   extractErrorMessage,
   extractErrorCode,
+  classifyTurnErrorKind,
   createAcpSessionBridge,
   createHttpAcpBridge
 };

package/dist/chunks/{chunk-DNV4FSN5.js → chunk-FBET5XZ2.js}

@@ -1,16 +1,18 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  DEFAULT_EXCLUDED_ENV_VARS,
-  HOME_ENV_BOOTSTRAP_KEYS,
-  PROJECT_ENV_HARDCODED_EXCLUSIONS,
   SETTINGS_DIRECTORY_NAME,
   V1_INDICATOR_KEYS,
   getGlobalQwenDirLite,
   getSystemDefaultsPath,
   getSystemSettingsPath,
   resolveEnvVarsInObject
-} from "./chunk-4RQIB5UZ.js";
+} from "./chunk-O2YT7VB4.js";
+import {
+  DEFAULT_EXCLUDED_ENV_VARS,
+  HOME_ENV_BOOTSTRAP_KEYS,
+  PROJECT_ENV_HARDCODED_EXCLUSIONS
+} from "./chunk-Z3I3QJK3.js";
 import {
   getPathComparisonVariants,
   isWithinRoot,

package/dist/chunks/{chunk-HTC4R67V.js → chunk-FES4YXJ3.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   handleAtCommand
-} from "./chunk-PWR5MVM3.js";
+} from "./chunk-SSP3UT5C.js";
 import {
   JsonOutputAdapter
-} from "./chunk-SM624MOZ.js";
+} from "./chunk-GWUN54UD.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-OCBJKHF2.js";
+} from "./chunk-KH2CZZDD.js";
 import {
   buildInitialSystemReminders,
   buildSystemMessage,
@@ -20,10 +20,10 @@ import {
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-XKYOIERV.js";
+} from "./chunk-BN5VYAOZ.js";
 import {
   RunBudgetEnforcer
-} from "./chunk-APYUOROB.js";
+} from "./chunk-W4CTWW7M.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -31,10 +31,10 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-6RSBRKF5.js";
+} from "./chunk-WN4YJJGH.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-4FQL7KUS.js";
+} from "./chunk-XWDHZP7P.js";
 import {
   ORPHAN_TOOL_USE_REPAIR_REASON,
   buildSyntheticToolResponseParts,
@@ -49,12 +49,12 @@ import {
   parseAndFormatApiError,
   promptIdContext,
   restoreWorktreeContext
-} from "./chunk-PDITONOB.js";
+} from "./chunk-5MRUKUOG.js";
 import {
   isTelemetrySdkInitialized,
   shutdownTelemetry,
   uiTelemetryService
-} from "./chunk-YRM6BC6H.js";
+} from "./chunk-27AYMAL6.js";
 import {
   ToolNames
 } from "./chunk-X3YGAX7V.js";