@ashx-j/lunr 0.2.25 → 0.2.27

package/dist/node-runtime/{chunk-VQFSUJJG.js → chunk-ZDJUR45D.js}

@@ -1,37 +1,40 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
-import {
-  TODO_TOOL_NAMES
-} from "./chunk-CCCN2UCX.js";
 import {
   DefaultResourceLoader,
   createSyntheticSourceInfo,
   expandPromptTemplate,
   formatSkillsForPrompt
-} from "./chunk-YCUZEGJG.js";
+} from "./chunk-DQSCFU7R.js";
+import {
+  TODO_TOOL_NAMES
+} from "./chunk-CCCN2UCX.js";
 import {
   stripFrontmatter
-} from "./chunk-QFWG2RVL.js";
+} from "./chunk-IXG6F4NT.js";
 import {
+  SUBAGENT_CHILD_PERMISSION_ENV,
   createAllToolDefinitions,
   createLocalBashOperations,
   createToolDefinitionFromAgentTool,
+  isSubagentChildProcess,
+  resolveChildRuntimePermissionMode,
   wrapToolDefinition
-} from "./chunk-YDO2F2IA.js";
+} from "./chunk-ZEVFBFNF.js";
+import {
+  stripAnsi
+} from "./chunk-6ZZHGUSA.js";
 import {
   DEFAULT_MAX_BYTES,
   truncateTail
 } from "./chunk-53YJI7JU.js";
-import {
-  stripAnsi
-} from "./chunk-5ZQXRPMC.js";
 import {
   ModelRuntime,
   isAuthInvalidError,
   isUsageLimitError
-} from "./chunk-KJ6DWS3K.js";
+} from "./chunk-XEOCUEUJ.js";
 import {
   SettingsManager
-} from "./chunk-6XL67VVY.js";
+} from "./chunk-HUD2RFJW.js";
 import {
   DEFAULT_THINKING_LEVEL,
   calculateContextTokens,
@@ -43,46 +46,56 @@ import {
   generateBranchSummary,
   prepareCompaction,
   shouldCompact
-} from "./chunk-GYIXXQAO.js";
+} from "./chunk-FIRA54AC.js";
 import {
   ExtensionRunner,
   emitSessionShutdownEvent
-} from "./chunk-GJ2RDBRL.js";
+} from "./chunk-BYC6RKCN.js";
 import {
   getSubagentCancellation
 } from "./chunk-BBUVIEZB.js";
 import {
-  gateToolCall
-} from "./chunk-ZXSGTGJ6.js";
+  AUTO_MODE_ADDENDUM,
+  READ_ONLY_MODE_ADDENDUM,
+  deletePermissionContext,
+  gateToolCall,
+  getPermissionMode,
+  initializePermissionContext,
+  setPermissionMode
+} from "./chunk-APVM5NEU.js";
 import {
   isUserInstructionsPath,
   loadSelectedUserInstructions
-} from "./chunk-M3LZLQW2.js";
+} from "./chunk-BDRGN3L2.js";
 import {
   list
-} from "./chunk-KKUTQQV7.js";
+} from "./chunk-RYRGL7P4.js";
 import {
   sanitizeBinaryOutput
-} from "./chunk-CSFI6YXL.js";
+} from "./chunk-ES6PBSIE.js";
 import {
   SessionTransferError
-} from "./chunk-I54LGHWM.js";
+} from "./chunk-I2H5QMWW.js";
 import {
   CURRENT_SESSION_VERSION,
   SessionManager,
   getDefaultSessionDir,
   getLatestCompactionEntry
-} from "./chunk-2KIPT4HJ.js";
+} from "./chunk-EPR2F3GU.js";
 import {
   convertToLlm
 } from "./chunk-FVDOXRUD.js";
 import {
   MEMORY_TOOL_NAMES
 } from "./chunk-UJOCPOMX.js";
+import {
+  getUsageServiceBridge
+} from "./chunk-HNNHHJAB.js";
 import {
   SessionOwnership,
-  canonicalSessionPath
-} from "./chunk-UAEOTO52.js";
+  canonicalSessionPath,
+  writeSessionJson
+} from "./chunk-MNQXDFPV.js";
 import {
   measureStartup,
   time
@@ -90,7 +103,7 @@ import {
 import {
   getThemeByName,
   theme
-} from "./chunk-RDDAZOMU.js";
+} from "./chunk-JL4HYQXK.js";
 import {
   CONFIG_DIR_NAME,
   getAgentDir,
@@ -98,7 +111,7 @@ import {
   getExamplesPath,
   getReadmePath,
   resolvePath
-} from "./chunk-FQMM2EZ2.js";
+} from "./chunk-64XTQNLA.js";
 
 // packages/coding-agent/dist/core/agent-session-services.js
 import { join as join7 } from "node:path";
@@ -232,6 +245,10 @@ var ModelRegistry = class {
   constructor(runtime) {
     this.runtime = runtime;
   }
+  /** Owner-bound usage bridge for deferred footer rendering. */
+  getUsageServiceBridge() {
+    return getUsageServiceBridge(this.runtime);
+  }
   /** Reload models.json asynchronously. Await before making synchronous registry reads. */
   refresh() {
     return this.runtime.reloadConfig();
@@ -343,15 +360,20 @@ function disableRollbackForSession(sessionId) {
 }
 function pruneTurns(ctx) {
   let maxTurns = ctx.settingsManager?.getRollbackTurns() ?? 2;
-  for (; ctx.turns.length > maxTurns; ) {
-    let old = ctx.turns.shift();
-    old && cleanupTurnFiles(ctx, old);
+  for (; ctx.turns.filter((turn) => !turn.recovery).length > maxTurns; ) {
+    let index = ctx.turns.findIndex((turn) => !turn.recovery);
+    if (index < 0)
+      break;
+    let [old] = ctx.turns.splice(index, 1);
+    cleanupTurnFiles(ctx, old);
   }
 }
 function beginTurn(cwd, sessionId) {
   let ctx = getContext(sessionId);
   if (!isRollbackEnabled(ctx.sessionId))
     return;
+  for (let pending of ctx.turns.filter((turn2) => turn2.recovery))
+    pending.recovery.newerTurnStarted = !0, persistRecoveryProgress(ctx, pending);
   cwd && (ctx.lastCwd = cwd), ctx.currentTurnIndex++;
   let turn = { turnIndex: ctx.currentTurnIndex, cwd, files: /* @__PURE__ */ new Map() };
   ctx.turns.push(turn), pruneTurns(ctx), cwd && ctx.settingsManager?.getRollbackScope() === "tree" && captureTreeBaseline(ctx, cwd);
@@ -496,6 +518,7 @@ function readManifest(path) {
       let files = parsed.files;
       return {
         cwd: typeof parsed.cwd == "string" ? parsed.cwd : void 0,
+        recovery: parseRecoveryProgress(parsed.recovery),
         files: files && typeof files == "object" && !Array.isArray(files) ? files : {}
       };
     }
@@ -504,6 +527,31 @@ function readManifest(path) {
     return { files: {} };
   }
 }
+function parseRecoveryProgress(value) {
+  if (!value || typeof value != "object")
+    return;
+  let progress = value;
+  if (!(typeof progress.turnsToConsume != "number" || !Number.isInteger(progress.turnsToConsume) || progress.turnsToConsume < 1 || !Array.isArray(progress.completed) || !progress.completed.every((path) => typeof path == "string")))
+    return {
+      targetUserId: typeof progress.targetUserId == "string" ? progress.targetUserId : void 0,
+      turnsToConsume: progress.turnsToConsume,
+      completed: progress.completed,
+      pending: typeof progress.pending == "string" ? progress.pending : void 0,
+      newerTurnStarted: progress.newerTurnStarted === !0
+    };
+}
+function persistRecoveryProgress(ctx, turn) {
+  let turnDir = getTurnDir(ctx, turn.turnIndex);
+  mkdirSync(turnDir, { recursive: !0 });
+  let manifest = { cwd: turn.cwd, recovery: turn.recovery, files: {} };
+  for (let [path, snap] of turn.files)
+    manifest.files[path] = {
+      existed: snap.existed,
+      createdByTool: snap.createdByTool,
+      snapFile: snap.existed ? snapFileName(path) : void 0
+    };
+  writeSessionJson(join3(turnDir, "manifest.json"), manifest);
+}
 function loadPersistedTurns(ctx) {
   try {
     let sessionDir = join3(ROLLBACK_BASE, ctx.sessionId);
@@ -525,7 +573,7 @@ function loadPersistedTurns(ctx) {
           }
         files.set(absPath, { existed: meta.existed, content, createdByTool: meta.createdByTool });
       }
-      loaded.push({ turnIndex, cwd: manifest.cwd, files });
+      loaded.push({ turnIndex, cwd: manifest.cwd, files, recovery: manifest.recovery });
     }
     loaded.sort((a, b) => a.turnIndex - b.turnIndex), ctx.turns = loaded, ctx.currentTurnIndex = loaded.length > 0 ? loaded[loaded.length - 1].turnIndex : -1, pruneTurns(ctx);
   } catch {
@@ -564,42 +612,99 @@ function warnExternalModification(ctx, message) {
     }
   }
 }
+function recoveryTurn(ctx) {
+  return ctx.turns.find((turn) => turn.recovery) ?? [...ctx.turns].reverse().find((turn) => turn.files.size > 0);
+}
+function getRollbackTargetUserId(sessionId) {
+  return recoveryTurn(getContext(sessionId))?.recovery?.targetUserId;
+}
+function getRollbackRecoveryBlockReason(sessionId) {
+  let ctx = getContext(sessionId), pending = ctx.turns.find((turn) => turn.recovery);
+  if (pending?.recovery && (pending.recovery.newerTurnStarted || ctx.turns.some((turn) => turn.turnIndex > pending.turnIndex + pending.recovery.turnsToConsume - 1)))
+    return "Automatic rollback retry is unavailable after newer turns. Chat and files are unchanged. Use /new to continue in a separate chat; this does not repair the retained recovery. Snapshots remain available for manual recovery.";
+}
 function peekRollbackTurnsConsumed(sessionId) {
   let ctx = getContext(sessionId);
-  if (!isRollbackEnabled(ctx.sessionId) || ctx.turns.length === 0)
+  if (!isRollbackEnabled(ctx.sessionId))
     return 0;
-  let consumed = 0;
-  for (let i = ctx.turns.length - 1; i >= 0 && (consumed++, !(ctx.turns[i].files.size > 0)); i--)
-    ;
-  return consumed;
+  let turn = recoveryTurn(ctx);
+  return turn?.recovery?.turnsToConsume ?? (turn ? ctx.turns.length - ctx.turns.indexOf(turn) : ctx.turns.length);
+}
+function commitRollbackTurn(sessionId, turnIndex) {
+  let ctx = getContext(sessionId), blocked = getRollbackRecoveryBlockReason(sessionId);
+  if (blocked)
+    throw new Error(blocked);
+  let index = ctx.turns.findIndex((turn2) => turn2.turnIndex === turnIndex);
+  if (index < 0)
+    return;
+  let turn = ctx.turns[index];
+  if (!turn.recovery || [...turn.files.keys()].some((path) => !turn.recovery?.completed.includes(path)))
+    throw new Error("Rollback still has unrestored files.");
+  let count = 1;
+  for (; index + count < ctx.turns.length && ctx.turns[index + count].files.size === 0; )
+    count++;
+  for (let removed of ctx.turns.splice(index, count))
+    cleanupTurnFiles(ctx, removed);
 }
-function rollbackLastTurn(sessionId) {
-  let ctx = getContext(sessionId), empty = { restored: [], deleted: [], turnsConsumed: 0 };
+function rollbackLastTurn(sessionId, options = {}) {
+  let ctx = getContext(sessionId), result = { restored: [], deleted: [], failed: [], complete: !0, turnsConsumed: 0 };
   if (!isRollbackEnabled(ctx.sessionId))
-    return empty;
-  let turnsConsumed = 0;
-  for (; ctx.turns.length > 0 && ctx.turns[ctx.turns.length - 1].files.size === 0; ) {
-    let skipped = ctx.turns.pop();
-    skipped && (cleanupTurnFiles(ctx, skipped), turnsConsumed++);
-  }
-  if (ctx.turns.length === 0)
-    return empty;
-  turnsConsumed++;
-  let turn = ctx.turns[ctx.turns.length - 1], capture = ctx.settingsManager?.getRollbackCapture() ?? "copies", restored = [], deleted = [];
-  for (let [absPath, snap] of turn.files)
+    return result;
+  let blocked = getRollbackRecoveryBlockReason(ctx.sessionId);
+  if (blocked)
+    throw new Error(blocked);
+  let turn = recoveryTurn(ctx) ?? (options.deferCommit ? ctx.turns[0] : void 0);
+  if (!turn) {
+    for (let empty of ctx.turns.splice(0))
+      cleanupTurnFiles(ctx, empty);
+    return result;
+  }
+  result.turnIndex = turn.turnIndex, turn.recovery ??= {
+    turnsToConsume: peekRollbackTurnsConsumed(ctx.sessionId),
+    completed: [],
+    targetUserId: options.targetUserId
+  }, turn.recovery.targetUserId ??= options.targetUserId, persistRecoveryProgress(ctx, turn);
+  let capture = ctx.settingsManager?.getRollbackCapture() ?? "copies";
+  for (let [absPath, snap] of turn.files) {
+    if (turn.recovery.completed.includes(absPath))
+      continue;
+    let wasPending = turn.recovery.pending === absPath;
     try {
-      if (!isWithinAllowedRoots(absPath, turn)) {
-        warnExternalModification(ctx, `Rollback skipped ${absPath}: outside the session working directory or lunR config dir.`);
+      if (turn.recovery.pending === absPath) {
+        if (!(snap.existed ? snap.content && existsSync(absPath) && readFileSync(absPath).equals(snap.content) : !existsSync(absPath))) {
+          result.failed.push({
+            path: absPath,
+            error: "Previous recovery outcome is uncertain. Restore this path from its retained snapshot before retrying."
+          });
+          continue;
+        }
+        turn.recovery.completed.push(absPath), turn.recovery.pending = void 0, persistRecoveryProgress(ctx, turn);
         continue;
       }
-      if (snap.existed && snap.content) {
-        if (!snap.createdByTool && existsSync(absPath) && readFileSync(absPath).equals(snap.content))
-          continue;
-        mkdirSync(dirname(absPath), { recursive: !0 }), writeFileSync(absPath, snap.content), restored.push(absPath);
-      } else snap.existed || (snap.createdByTool || capture === "hybrid" || capture === "shadow-git") && existsSync(absPath) && (unlinkSync(absPath), deleted.push(absPath));
-    } catch {
+      if (!isWithinAllowedRoots(absPath, turn))
+        throw warnExternalModification(ctx, `Rollback skipped ${absPath}: outside the session working directory or lunR config dir.`), new Error("Outside the allowed rollback roots.");
+      if (turn.recovery.pending) {
+        result.failed.push({
+          path: absPath,
+          error: "Resolve the uncertain recovery path before continuing this turn."
+        });
+        continue;
+      }
+      if (snap.existed && !snap.content)
+        throw new Error("Snapshot content is unavailable.");
+      turn.recovery.pending = absPath, persistRecoveryProgress(ctx, turn), snap.existed && snap.content ? !snap.createdByTool && existsSync(absPath) && readFileSync(absPath).equals(snap.content) || (mkdirSync(dirname(absPath), { recursive: !0 }), writeFileSync(absPath, snap.content), result.restored.push(absPath)) : (snap.createdByTool || capture === "hybrid" || capture === "shadow-git") && existsSync(absPath) && (unlinkSync(absPath), result.deleted.push(absPath)), turn.recovery.completed.push(absPath), turn.recovery.pending = void 0, persistRecoveryProgress(ctx, turn);
+    } catch (error) {
+      if (!wasPending && turn.recovery.pending === absPath) {
+        turn.recovery.pending = void 0;
+        try {
+          persistRecoveryProgress(ctx, turn);
+        } catch {
+        }
+      }
+      result.failed.push({ path: absPath, error: error instanceof Error ? error.message : String(error) });
     }
-  return cleanupTurnFiles(ctx, turn), ctx.turns.pop(), { restored, deleted, turnsConsumed };
+  }
+  return result.complete = result.failed.length === 0, result.complete && !options.deferCommit && (result.turnsConsumed = turn.recovery.turnsToConsume, commitRollbackTurn(ctx.sessionId, turn.turnIndex)), result;
 }
 function migrateRollbackSession(oldSessionId, newSessionId) {
   if (oldSessionId === newSessionId)
@@ -805,7 +910,12 @@ var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"
   _retryAbortController = void 0;
   _retryAttempt = 0;
   // Bash execution state
-  _bashAbortController = void 0;
+  _bashOperations = /* @__PURE__ */ new Map();
+  _operations = /* @__PURE__ */ new Set();
+  _closing = !1;
+  _disposed = !1;
+  _drainPromise;
+  _shutdownPromise;
   _pendingBashMessages = [];
   // Extension system
   _extensionRunner;
@@ -838,12 +948,14 @@ var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"
   _baseSystemPrompt = "";
   _baseSystemPromptOptions;
   _systemPromptOverride;
-  // lunr: core-owned system-prompt append (read-only mode addendum) applied on top of base/override
+  // Optional host-owned prompt append, separate from session permission guidance.
   _systemPromptAppend;
   // lunr: core-owned tool-call gates (read-only mode) checked before extension tool_call handlers
   _toolCallGates = [];
   constructor(config) {
-    this.agent = config.agent, this.sessionManager = config.sessionManager, this.settingsManager = config.settingsManager, this._scopedModels = config.scopedModels ?? [], this._resourceLoader = config.resourceLoader, this._customTools = config.customTools ?? [], this._cwd = config.cwd, this._agentDir = config.agentDir ?? getAgentDir(), this._modelRuntime = config.modelRuntime, this._syncOpenAIServiceTier(), this._extensionRunnerRef = config.extensionRunnerRef, this._initialActiveToolNames = config.initialActiveToolNames, this._allowedToolNames = config.allowedToolNames ? new Set(config.allowedToolNames) : void 0, this._excludedToolNames = config.excludedToolNames ? new Set(config.excludedToolNames) : void 0, this._baseToolsOverride = config.baseToolsOverride, this._sessionStartEvent = config.sessionStartEvent ?? { type: "session_start", reason: "startup" };
+    this.agent = config.agent, this.sessionManager = config.sessionManager, this.settingsManager = config.settingsManager;
+    let permissionMode = config.permissionMode ?? (isSubagentChildProcess() ? resolveChildRuntimePermissionMode(process.env[SUBAGENT_CHILD_PERMISSION_ENV]) : void 0) ?? this.sessionManager.getPermissionMode() ?? this.settingsManager.getDefaultPermissionMode();
+    initializePermissionContext(this.sessionId, permissionMode, config.permissionMode), this._scopedModels = config.scopedModels ?? [], this._resourceLoader = config.resourceLoader, this._customTools = config.customTools ?? [], this._cwd = config.cwd, this._agentDir = config.agentDir ?? getAgentDir(), this._modelRuntime = config.modelRuntime, this._syncOpenAIServiceTier(), this._extensionRunnerRef = config.extensionRunnerRef, this._initialActiveToolNames = config.initialActiveToolNames, this._allowedToolNames = config.allowedToolNames ? new Set(config.allowedToolNames) : void 0, this._excludedToolNames = config.excludedToolNames ? new Set(config.excludedToolNames) : void 0, this._baseToolsOverride = config.baseToolsOverride, this._sessionStartEvent = config.sessionStartEvent ?? { type: "session_start", reason: "startup" };
     let waitInterruptionOwner = { register: () => this._registerSubagentWaitInterruption() };
     for (let identity of new Set([this.sessionId, this.sessionFile].filter((value) => !!value)))
       this._unregisterSubagentWaitInterruptionOwners.push(registerSubagentWaitInterruptionOwner(identity, waitInterruptionOwner));
@@ -1031,7 +1143,7 @@ var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"
         }
       }
     }
-    if (await this._emitExtensionEvent(event), this._emit(event.type === "agent_end" ? { ...event, willRetry: this._willRetryAfterAgentEnd(event) } : event), event.type === "message_end" && (event.message.role === "custom" ? this.sessionManager.appendCustomMessageEntry(event.message.customType, event.message.content, event.message.display, event.message.details) : (event.message.role === "user" || event.message.role === "assistant" || event.message.role === "toolResult") && this.sessionManager.appendMessage(event.message), event.message.role === "assistant")) {
+    if (event.type === "message_end" && this._activePromptRun?.completion?.messages.push(event.message), await this._emitExtensionEvent(event), this._emit(event.type === "agent_end" ? { ...event, willRetry: this._willRetryAfterAgentEnd(event) } : event), event.type === "message_end" && (event.message.role === "custom" ? this.sessionManager.appendCustomMessageEntry(event.message.customType, event.message.content, event.message.display, event.message.details) : (event.message.role === "user" || event.message.role === "assistant" || event.message.role === "toolResult") && this.sessionManager.appendMessage(event.message), event.message.role === "assistant")) {
       this._lastAssistantMessage = event.message;
       let assistantMsg = event.message;
       assistantMsg.stopReason !== "error" && (this._overflowRecoveryAttempted = !1), assistantMsg.stopReason !== "error" && this._retryAttempt > 0 && (this._emit({
@@ -1182,18 +1294,53 @@ var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"
     this.transferring = value, value && this._invalidateWaitPromptHandoffs("Session transfer interrupted the pending prompt.");
   }
   assertCanStartWork() {
-    if (this.sessionManager.assertWritable(), this.transferring)
+    if (this.sessionManager.assertWritable(), this._closing)
+      throw new Error("Session is closing. New work is not accepted.");
+    if (this.transferring)
       throw new Error("Session transfer is in progress. Wait or reclaim the session.");
   }
-  dispose() {
-    this._invalidateWaitPromptHandoffs("Session closed before the pending prompt could run.");
-    for (let unregister of this._unregisterSubagentWaitInterruptionOwners.splice(0))
-      unregister();
+  /** Stop admission synchronously, retaining listeners and session ownership. */
+  stopAdmission() {
+    this._closing = !0, this._invalidateWaitPromptHandoffs("Session closed before the pending prompt could run.");
+  }
+  async _trackOperation(operation) {
+    let settle = () => {
+    }, completion = new Promise((resolve3) => {
+      settle = resolve3;
+    });
+    this._operations.add(completion);
     try {
-      this.abortRetry(), this.abortCompaction(), this.abortBranchSummary(), this.abortBash(), this.agent.abort();
-    } catch {
+      return await operation();
+    } finally {
+      this._operations.delete(completion), settle();
+    }
+  }
+  /** Cancel owned work and wait for final persistence before extension shutdown. */
+  drain() {
+    return this._drainPromise ? this._drainPromise : (this.stopAdmission(), this._activePromptRun && (this._activePromptRun.gracefulStopRequested = !0), this.abortRetry(), this.abortCompaction(), this.abortBranchSummary(), this.abortBash(), this.clearQueue(), this.agent.abort(), this._drainPromise = (async () => {
+      await Promise.all([...this._operations]), await this.waitForIdle(), await this.agent.waitForIdle(), this._flushPendingBashMessages();
+    })(), this._drainPromise);
+  }
+  /** Await cancellation and persistence, then release listeners and ownership. */
+  shutdown() {
+    return this._shutdownPromise || (this._shutdownPromise = this.drain().then(() => this._disposeSettled())), this._shutdownPromise;
+  }
+  /** Compatibility wrapper. Use await shutdown() when release must be complete. */
+  dispose() {
+    if (this._operations.size === 0 && !this._isAgentRunActive && !this.agent.state.isStreaming) {
+      this.stopAdmission(), this._disposeSettled();
+      return;
+    }
+    this.shutdown().catch(() => {
+    });
+  }
+  _disposeSettled() {
+    if (!this._disposed) {
+      this._disposed = !0;
+      for (let unregister of this._unregisterSubagentWaitInterruptionOwners.splice(0))
+        unregister();
+      this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload()."), this._disconnectFromAgent(), this._eventListeners = [], cleanupSessionResources(this.sessionId), deletePermissionContext(this.sessionId), this.sessionManager.dispose();
     }
-    this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload()."), this._disconnectFromAgent(), this._eventListeners = [], cleanupSessionResources(this.sessionId), this.sessionManager.dispose();
   }
   // =========================================================================
   // Read-only State Access
@@ -1245,10 +1392,20 @@ var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"
     let next = text && text.trim().length > 0 ? text : void 0;
     next !== this._systemPromptAppend && (this._systemPromptAppend = next, this.agent.state.systemPrompt = this._withSystemPromptAppend(this._systemPromptOverride ?? this._baseSystemPrompt));
   }
+  get permissionMode() {
+    return getPermissionMode(this.sessionId);
+  }
+  _permissionAddendum(mode) {
+    return mode === "read-only" ? READ_ONLY_MODE_ADDENDUM : mode === "auto" ? AUTO_MODE_ADDENDUM : void 0;
+  }
+  /** Update the same permission context consulted by headless and interactive tools. */
+  setPermissionMode(mode) {
+    this.assertCanStartWork(), setPermissionMode(mode, this.sessionId), this.sessionManager.setPermissionMode(mode), this.agent.state.systemPrompt = this._withSystemPromptAppend(this._systemPromptOverride ?? this._baseSystemPrompt);
+  }
   _withSystemPromptAppend(prompt) {
-    return this._systemPromptAppend ? `${prompt}
+    return [prompt, this._permissionAddendum(this.permissionMode), this._systemPromptAppend].filter(Boolean).join(`
 
-${this._systemPromptAppend}` : prompt;
+`);
   }
   /** Current retry attempt (0 if not retrying) */
   get retryAttempt() {
@@ -1410,24 +1567,46 @@ ${this._systemPromptAppend}` : prompt;
     for (let reservation of handoff.reservations.splice(0))
       reservation.reject(error);
   }
-  async _runAgentPrompt(messages) {
+  _reservePromptRun() {
+    if (this.assertCanStartWork(), this._isAgentRunActive || this._manualCompactionPromise)
+      throw new Error("Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.");
     let run = { waits: /* @__PURE__ */ new Set(), gracefulStopRequested: !1 };
-    this._activePromptRun = run, this._isAgentRunActive = !0;
-    try {
-      for (await this.agent.prompt(messages); await this._handlePostAgentRun(run); )
-        await this.agent.continue();
-    } finally {
-      this._activePromptRun === run && (this._activePromptRun = void 0), this._systemPromptOverride = void 0, this._flushPendingBashMessages(), await this._emitAgentSettled();
-    }
+    return this._activePromptRun = run, this._isAgentRunActive = !0, run;
+  }
+  async _releasePromptRun(run) {
+    this._activePromptRun === run && (this._activePromptRun = void 0, this._systemPromptOverride = void 0, this._flushPendingBashMessages(), await this._emitAgentSettled());
+  }
+  async _runAgentPrompt(messages, owner) {
+    let run = owner ?? this._reservePromptRun();
+    await this._trackOperation(async () => {
+      try {
+        if (this.assertCanStartWork(), run.gracefulStopRequested)
+          throw new Error("Prompt was cancelled during preparation.");
+        for (await this.agent.prompt(Array.isArray(messages) ? messages : [messages], {
+          consumeFollowUps: !run.completion
+        }); await this._handlePostAgentRun(run) && !(run.gracefulStopRequested || this._closing || run.completion?.cancelled); )
+          await this.agent.continue({ consumeFollowUps: !run.completion });
+        if (run.completion) {
+          let completion = run.completion;
+          run.completion = void 0, completion.detach?.();
+          let hasQueuedWork = !run.gracefulStopRequested && !this._closing && this.agent.hasQueuedMessages();
+          if (hasQueuedWork || await this._releasePromptRun(run), completion.settle(), hasQueuedWork)
+            for (await this.agent.continueQueued(); await this._handlePostAgentRun(run) && !(run.gracefulStopRequested || this._closing); )
+              await this.agent.continue();
+        }
+      } finally {
+        await this._releasePromptRun(run);
+      }
+    });
   }
   async _handlePostAgentRun(run) {
     let msg = this._lastAssistantMessage;
-    return this._lastAssistantMessage = void 0, !msg || run.gracefulStopRequested ? !1 : msg.stopReason === "error" && this._isRotationError(msg) && await this._tryRotateSubscriptionKey(msg) || this._isRetryableError(msg) && await this._prepareRetry(msg) || msg.stopReason === "error" && this._isRetryableError(msg) && await this._tryRotateSubscriptionKey(msg) || (msg.stopReason === "error" && this._retryAttempt > 0 && (this._emit({
+    return this._lastAssistantMessage = void 0, !msg || run.gracefulStopRequested || run.completion?.signal?.aborted ? !1 : msg.stopReason === "error" && this._isRotationError(msg) && await this._tryRotateSubscriptionKey(msg) || this._isRetryableError(msg) && await this._prepareRetry(msg) || msg.stopReason === "error" && this._isRetryableError(msg) && await this._tryRotateSubscriptionKey(msg) || (msg.stopReason === "error" && this._retryAttempt > 0 && (this._emit({
       type: "auto_retry_end",
       success: !1,
       attempt: this._retryAttempt,
       finalError: msg.errorMessage
-    }), this._retryAttempt = 0), await this._checkCompaction(msg)) ? !0 : this.agent.hasQueuedMessages();
+    }), this._retryAttempt = 0), await this._checkCompaction(msg)) ? !0 : !run.completion && this.agent.hasQueuedMessages();
   }
   /**
    * Send a prompt to the agent.
@@ -1440,23 +1619,72 @@ ${this._systemPromptAppend}` : prompt;
    */
   async prompt(text, options) {
     this.assertCanStartWork();
-    let preflightResult = options?.preflightResult, prepared, messages;
-    try {
-      if (prepared = await this._preparePromptInput(text, options, this.isStreaming ? options?.streamingBehavior : void 0), !prepared) {
-        preflightResult?.(!0);
-        return;
+    let commandName = text.startsWith("/") ? text.slice(1).split(" ")[0] : void 0;
+    if ((options?.expandPromptTemplates ?? !0) && commandName && this._extensionRunner.getCommand(commandName)) {
+      try {
+        await this._tryExecuteExtensionCommand(text), options?.preflightResult?.(!0);
+      } catch (error) {
+        throw options?.preflightResult?.(!1), error;
       }
-      if (this.isStreaming) {
+      return;
+    }
+    return this._trackOperation(() => this._prompt(text, options));
+  }
+  async _prompt(text, options, completion) {
+    let run, accepted = !1;
+    try {
+      this.assertCanStartWork();
+      let wasStreaming = this.isStreaming;
+      if (wasStreaming) {
         if (!options?.streamingBehavior)
           throw new Error("Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.");
-        options.streamingBehavior === "followUp" ? await this._queueFollowUp(prepared.text, prepared.images) : await this._queueSteer(prepared.text, prepared.images), preflightResult?.(!0);
+      } else if (run = this._reservePromptRun(), run.completion = completion, completion?.signal) {
+        let owner = run, cancel = () => {
+          this._activePromptRun !== owner || owner.completion !== completion || (completion.cancelled = !0, this.agent.abort(), this.abortRetry(), this._autoCompactionAbortController?.abort());
+        };
+        completion.signal.addEventListener("abort", cancel, { once: !0 }), completion.detach = () => completion.signal?.removeEventListener("abort", cancel), completion.signal.throwIfAborted();
+      }
+      let prepared = await this._preparePromptInput(text, options, wasStreaming ? options?.streamingBehavior : void 0);
+      if (this.assertCanStartWork(), run?.completion?.signal?.throwIfAborted(), run?.gracefulStopRequested)
+        throw new Error("Prompt was cancelled during preparation.");
+      if (!prepared) {
+        accepted = !0, options?.preflightResult?.(!0);
+        return;
+      }
+      if (wasStreaming && this.isStreaming) {
+        options?.streamingBehavior === "followUp" ? await this._queueFollowUp(prepared.text, prepared.images) : await this._queueSteer(prepared.text, prepared.images), accepted = !0, options?.preflightResult?.(!0);
         return;
       }
-      messages = await this._createPromptMessages(prepared);
+      run ??= this._reservePromptRun(), run.completion = completion;
+      let messages = await this._createPromptMessages(prepared);
+      if (this.assertCanStartWork(), run.completion?.signal?.throwIfAborted(), run.gracefulStopRequested)
+        throw new Error("Prompt was cancelled during preparation.");
+      accepted = !0, options?.preflightResult?.(!0), await this._runAgentPrompt(messages, run);
     } catch (error) {
-      throw preflightResult?.(!1), error;
+      throw accepted || options?.preflightResult?.(!1), error;
+    } finally {
+      completion?.detach?.(), run && await this._releasePromptRun(run);
     }
-    preflightResult?.(!0), await this._runAgentPrompt(messages);
+  }
+  /**
+   * Admit one scheduled request, including steering, retries and compaction.
+   * Completes before later follow-ups; signal cancellation belongs only to this request.
+   */
+  async promptWithCompletion(text, options) {
+    if (this.assertCanStartWork(), !this.isIdle || this.isBashRunning || this.isCompacting || this.pendingMessageCount > 0)
+      throw new Error("Session is busy. Retry the scheduled prompt after its work settles.");
+    text.startsWith("/") && (options?.expandPromptTemplates ?? !0) && this._throwIfExtensionCommand(text), options?.signal?.throwIfAborted();
+    let messages = [];
+    return new Promise((resolve3, reject) => {
+      let completion = {
+        messages,
+        signal: options?.signal,
+        settle: () => {
+          completion.cancelled ? reject(completion.signal?.reason) : resolve3({ messages });
+        }
+      };
+      this._trackOperation(() => this._prompt(text, options, completion)).then(completion.settle, reject);
+    });
   }
   async _preparePromptInput(text, options, streamingBehavior) {
     let expandPromptTemplates = options?.expandPromptTemplates ?? !0;
@@ -1503,7 +1731,8 @@ ${this._systemPromptAppend}` : prompt;
     return result?.systemPrompt !== void 0 ? (this._systemPromptOverride = result.systemPrompt, this.agent.state.systemPrompt = this._withSystemPromptAppend(result.systemPrompt)) : (this._systemPromptOverride = void 0, this.agent.state.systemPrompt = this._withSystemPromptAppend(this._baseSystemPrompt)), messages;
   }
   async interruptSubagentWaitWithPrompt(text, options) {
-    let acceptance = this._waitPromptAcceptance.then(() => this._reserveWaitPrompt(text, options));
+    this.assertCanStartWork();
+    let previousAcceptance = this._waitPromptAcceptance, acceptance = this._trackOperation(() => previousAcceptance.then(() => this._reserveWaitPrompt(text, options)));
     return this._waitPromptAcceptance = acceptance.then(() => {
     }, () => {
     }), acceptance;
@@ -1528,6 +1757,8 @@ ${this._systemPromptAppend}` : prompt;
     } catch (error) {
       throw handoff.reservations.length === 0 && this._waitPromptHandoff === handoff && (this._waitPromptHandoff = void 0), error;
     }
+    if (this.assertCanStartWork(), handoff.generation !== this._waitPromptGeneration)
+      throw new Error("Pending prompt was cancelled during preparation.");
     if (!prepared)
       return handoff.reservations.length === 0 && this._waitPromptHandoff === handoff && (this._waitPromptHandoff = void 0), { completion: Promise.resolve() };
     let resolveCompletion = () => {
@@ -1539,15 +1770,15 @@ ${this._systemPromptAppend}` : prompt;
   }
   async _drainWaitPromptHandoff(handoff) {
     for (await this.waitForIdle(); this._waitPromptHandoff === handoff && handoff.generation === this._waitPromptGeneration && handoff.reservations.length > 0; ) {
-      let reservation = handoff.reservations[0];
+      let reservation = handoff.reservations[0], run;
       try {
-        this.assertCanStartWork();
+        this.assertCanStartWork(), run = this._reservePromptRun();
         let messages = await this._createPromptMessages(reservation.input);
-        handoff.accepting = !1, await this._runAgentPrompt(messages), reservation.resolve();
+        handoff.accepting = !1, await this._runAgentPrompt(messages, run), reservation.resolve();
       } catch (error) {
         reservation.reject(error);
       } finally {
-        handoff.reservations[0] === reservation && handoff.reservations.shift();
+        run && await this._releasePromptRun(run), handoff.reservations[0] === reservation && handoff.reservations.shift();
       }
     }
     handoff.accepting = !1, this._waitPromptHandoff === handoff && (this._waitPromptHandoff = void 0);
@@ -1734,7 +1965,9 @@ ${args}` : skillBlock;
    * Abort current operation and wait for agent to become idle.
    */
   async abort() {
-    this._invalidateWaitPromptHandoffs("The active run was aborted before the pending prompt could run."), this.abortRetry(), this.agent.abort(), await this.waitForIdle();
+    this._invalidateWaitPromptHandoffs("The active run was aborted before the pending prompt could run."), this.abortRetry(), this._activePromptRun && !this.agent.signal && (this._activePromptRun.gracefulStopRequested = !0);
+    let bash = [...this._bashOperations.values()];
+    this.abortBash(), this.agent.abort(), await this.waitForIdle(), await Promise.all(bash);
   }
   async waitForIdle() {
     this.isIdle || await this._getIdleWaitPromise();
@@ -1896,12 +2129,13 @@ ${args}` : skillBlock;
    * @param customInstructions Optional instructions for the compaction summary
    */
   async compact(customInstructions) {
+    this.assertCanStartWork();
     let existing = this._latestCompactionResult();
     if (existing)
       return existing;
     if (this._manualCompactionPromise)
       return this._manualCompactionPromise;
-    let promise = this._compact(customInstructions);
+    let promise = this._trackOperation(() => this._compact(customInstructions));
     this._manualCompactionPromise = promise;
     try {
       return await promise;
@@ -1910,13 +2144,13 @@ ${args}` : skillBlock;
     }
   }
   async _compact(customInstructions) {
-    this._disconnectFromAgent(), await this.abort();
+    await this.abort(), this.assertCanStartWork();
     let existing = this._latestCompactionResult();
     if (existing)
-      return this._reconnectToAgent(), existing;
-    this._compactionAbortController = new AbortController(), this._emit({ type: "compaction_start", reason: "manual" });
+      return existing;
+    this._disconnectFromAgent(), this._compactionAbortController = new AbortController();
     try {
-      if (!this.model)
+      if (this._emit({ type: "compaction_start", reason: "manual" }), !this.model)
         throw new Error(formatNoModelSelectedMessage());
       let { apiKey, headers, env } = await this._getSummarizationRequestAuth(this.model), pathEntries = this.sessionManager.getBranch(), settings = this.settingsManager.getCompactionSettings(), preparation = prepareCompaction(pathEntries, settings);
       if (!preparation)
@@ -2122,7 +2356,7 @@ ${args}` : skillBlock;
         let messages = this.agent.state.messages, lastMsg = messages[messages.length - 1];
         return lastMsg?.role === "assistant" && lastMsg.stopReason === "error" && (this.agent.state.messages = messages.slice(0, -1)), !0;
       }
-      return this.agent.hasQueuedMessages();
+      return !this._activePromptRun?.completion && this.agent.hasQueuedMessages();
     } catch (error) {
       let errorMessage = error instanceof Error ? error.message : "compaction failed";
       return started && this._emit({
@@ -2303,6 +2537,7 @@ ${args}` : skillBlock;
     }, {
       getModel: () => this.resolvedCatalogModel(),
       isIdle: () => this.isIdle,
+      promptWithCompletion: (text, options) => this.promptWithCompletion(text, options),
       isProjectTrusted: () => this.settingsManager.isProjectTrusted(),
       getSignal: () => this.agent.signal,
       abort: () => {
@@ -2476,16 +2711,13 @@ ${args}` : skillBlock;
    * false when rotation is impossible, leaving the error as the final message.
    */
   async _tryRotateSubscriptionKey(message) {
-    let model = this.model;
-    if (!model)
+    let requestKey = this._modelRuntime.getRequestSubscriptionKey(message);
+    if (!requestKey)
       return !1;
-    let providerId = model.provider;
+    let providerId = requestKey.providerId;
     if (this._modelRuntime.hasRuntimeApiKey(providerId))
       return !1;
-    let manager = this._modelRuntime.subscriptionManager;
-    if ((await manager.list(providerId)).length < 2)
-      return !1;
-    let errorMessage = message.errorMessage ?? "Unknown error", entry = await manager.rotateOnFailure(providerId, errorMessage);
+    let manager = this._modelRuntime.subscriptionManager, errorMessage = message.errorMessage ?? "Unknown error", entry = await manager.rotateOnFailure(providerId, errorMessage, requestKey.fingerprint);
     if (!entry)
       return !1;
     this._retryAttempt > 0 && this._emit({ type: "auto_retry_end", success: !0, attempt: this._retryAttempt }), this._retryAttempt = 0;
@@ -2523,17 +2755,21 @@ ${args}` : skillBlock;
    * @param options.operations Custom BashOperations for remote execution
    */
   async executeBash(command, onChunk, options) {
-    this.assertCanStartWork(), this._bashAbortController = new AbortController();
-    let prefix = this.settingsManager.getShellCommandPrefix(), shellPath = this.settingsManager.getShellPath(), resolvedCommand = prefix ? `${prefix}
-${command}` : command;
+    this.assertCanStartWork();
+    let controller = new AbortController(), settle = () => {
+    }, completion = new Promise((resolve3) => {
+      settle = resolve3;
+    });
+    this._bashOperations.set(controller, completion), this._operations.add(completion);
     try {
-      let result = await executeBashWithOperations(resolvedCommand, this.sessionManager.getCwd(), options?.operations ?? createLocalBashOperations({ shellPath, sessionId: this.sessionId }), {
+      let prefix = this.settingsManager.getShellCommandPrefix(), shellPath = this.settingsManager.getShellPath(), resolvedCommand = prefix ? `${prefix}
+${command}` : command, result = await executeBashWithOperations(resolvedCommand, this.sessionManager.getCwd(), options?.operations ?? createLocalBashOperations({ shellPath, sessionId: this.sessionId }), {
         onChunk,
-        signal: this._bashAbortController.signal
+        signal: controller.signal
       });
       return this.recordBashResult(command, result, options), result;
     } finally {
-      this._bashAbortController = void 0;
+      this._bashOperations.delete(controller), this._operations.delete(completion), settle();
     }
   }
   /**
@@ -2555,14 +2791,15 @@ ${command}` : command;
     this.isStreaming ? this._pendingBashMessages.push(bashMessage) : (this.agent.state.messages.push(bashMessage), this.sessionManager.appendMessage(bashMessage));
   }
   /**
-   * Cancel running bash command.
+   * Cancel every running direct bash operation.
    */
   abortBash() {
-    this._bashAbortController?.abort();
+    for (let controller of this._bashOperations.keys())
+      controller.abort();
   }
   /** Whether a bash command is currently running */
   get isBashRunning() {
-    return this._bashAbortController !== void 0;
+    return this._bashOperations.size > 0;
   }
   /** Whether there are pending bash messages waiting to be flushed */
   get hasPendingBashMessages() {
@@ -2605,6 +2842,11 @@ ${command}` : command;
    * @returns Result with editorText (if user message) and cancelled status
    */
   async navigateTree(targetId, options = {}) {
+    if (this.assertCanStartWork(), this._branchSummaryAbortController)
+      throw new Error("Tree navigation is already in progress.");
+    return this._trackOperation(() => this._navigateTree(targetId, options));
+  }
+  async _navigateTree(targetId, options = {}) {
     let oldLeafId = this.sessionManager.getLeafId();
     if (targetId === oldLeafId)
       return { cancelled: !1 };
@@ -2658,6 +2900,8 @@ ${command}` : command;
           modifiedFiles: result.modifiedFiles || []
         };
       } else extensionSummary && (summaryText = extensionSummary.summary, summaryDetails = extensionSummary.details);
+      if (this._branchSummaryAbortController.signal.aborted)
+        return { cancelled: !0, aborted: !0 };
       let newLeafId, editorText, editorImages;
       targetEntry.type === "message" && targetEntry.message.role === "user" ? (newLeafId = targetEntry.parentId, editorText = this._extractUserMessageText(targetEntry.message.content), editorImages = this._extractUserMessageImages(targetEntry.message.content)) : targetEntry.type === "custom_message" ? (newLeafId = targetEntry.parentId, editorText = typeof targetEntry.content == "string" ? targetEntry.content : targetEntry.content.filter((c) => c.type === "text").map((c) => c.text).join("")) : newLeafId = targetId;
       let summaryEntry;
@@ -2780,7 +3024,7 @@ ${command}` : command;
    */
   async exportToHtml(outputPath) {
     let [{ exportSessionToHtml }, { createToolHtmlRenderer }] = await Promise.all([
-      import("./export-html-VM4J2MNR.js"),
+      import("./export-html-BRWF5AHI.js"),
       import("./tool-renderer-MV5O452K.js")
     ]), configuredThemeName = this.settingsManager.getTheme(), themeName = configuredThemeName && getThemeByName(configuredThemeName) ? configuredThemeName : void 0, toolRenderer = createToolHtmlRenderer({
       getToolDefinition: (name) => this.getToolDefinition(name),
@@ -2946,13 +3190,36 @@ var AgentSessionRuntime = class {
   _modelFallbackMessage;
   detached = !1;
   transferring = !1;
+  replacement;
+  teardown;
+  closing = !1;
+  async withReplacement(operation) {
+    if (this.closing || this.replacement || this.transferring)
+      throw new Error("Session lifecycle change is already in progress.");
+    let promise = Promise.resolve().then(operation);
+    this.replacement = promise;
+    try {
+      return await promise;
+    } finally {
+      this.replacement === promise && (this.replacement = void 0);
+    }
+  }
   get isDetached() {
     return this.detached;
   }
+  /** Correlated prompt entry for scheduled hosts; never queues across a lifecycle change. */
+  promptWithCompletion(text, options) {
+    return this.detached || this.closing || this.replacement || this.transferring ? Promise.reject(new Error("Session lifecycle change is in progress. Retry the scheduled prompt later.")) : this.session.promptWithCompletion(text, options);
+  }
   async releaseForTransfer(options = {}) {
+    if (this.closing || this.replacement || this.transferring)
+      throw new SessionTransferError("Session transfer is already in progress.", "busy");
+    return this.withReplacement(() => this.releaseForTransferOwned(options));
+  }
+  async releaseForTransferOwned(options) {
     if (options.signal?.throwIfAborted(), this.detached)
       return;
-    if (this.transferring)
+    if (this.closing || this.transferring)
       throw new SessionTransferError("Session transfer is already in progress.", "busy");
     this.transferring = !0, this.session.setTransferring(!0);
     let hasAttachedWork = () => getSubagentCancellation(this.session.sessionId)?.hasActiveRuns() || getSubagentCancellation(this.session.sessionFile ?? "")?.hasActiveRuns() || list().some((entry) => entry.status !== "exited" && (!entry.sessionId || entry.sessionId === this.session.sessionId)), busy = () => this.session.isStreaming || this.session.isCompacting || this.session.isBashRunning || this.session.isRetrying || this.session.pendingMessageCount > 0;
@@ -3023,12 +3290,28 @@ var AgentSessionRuntime = class {
       ...options
     }))?.cancel === !0 } : { cancelled: !1 };
   }
-  async teardownCurrent(reason, targetSessionFile) {
-    this.detached || (await emitSessionShutdownEvent(this.session.extensionRunner, {
-      type: "session_shutdown",
-      reason,
-      targetSessionFile
-    }), this.beforeSessionInvalidate?.(reason), this.session.dispose(), this.detached = !0);
+  teardownCurrent(reason, targetSessionFile) {
+    if (this.teardown)
+      return this.teardown;
+    if (this.detached)
+      return Promise.resolve();
+    let session = this.session;
+    return session.stopAdmission(), this.teardown = (async () => {
+      await session.drain();
+      try {
+        await emitSessionShutdownEvent(session.extensionRunner, {
+          type: "session_shutdown",
+          reason,
+          targetSessionFile
+        });
+      } finally {
+        try {
+          this.beforeSessionInvalidate?.(reason);
+        } finally {
+          await session.shutdown(), this.detached = !0;
+        }
+      }
+    })(), this.teardown;
   }
   async teardownForReplacement(reason, sessionManager) {
     try {
@@ -3038,12 +3321,15 @@ var AgentSessionRuntime = class {
     }
   }
   apply(result) {
-    this.detached = !1, this._session = result.session, this._services = result.services, this._diagnostics = result.diagnostics, this._modelFallbackMessage = result.modelFallbackMessage, this.onRuntimeApplied?.(result);
+    this.detached = !1, this.teardown = void 0, this._session = result.session, this.closing && this._session.stopAdmission(), this._services = result.services, this._diagnostics = result.diagnostics, this._modelFallbackMessage = result.modelFallbackMessage, this.onRuntimeApplied?.(result);
   }
   async finishSessionReplacement(withSession) {
     this.rebindSession && await this.rebindSession(this.session), withSession && await withSession(this.session.createReplacedSessionContext());
   }
   async switchSession(sessionPath, options) {
+    return this.withReplacement(() => this.switchSessionOwned(sessionPath, options));
+  }
+  async switchSessionOwned(sessionPath, options) {
     if (!this.detached && this.session.sessionFile && canonicalSessionPath(sessionPath) === canonicalSessionPath(this.session.sessionFile))
       return { cancelled: !1 };
     let beforeResult = this.detached ? { cancelled: !1 } : await this.emitBeforeSwitch("resume", sessionPath);
@@ -3064,6 +3350,9 @@ var AgentSessionRuntime = class {
     })), await this.finishSessionReplacement(options?.withSession), { cancelled: !1 };
   }
   async newSession(options) {
+    return this.withReplacement(() => this.newSessionOwned(options));
+  }
+  async newSessionOwned(options) {
     let beforeResult = await this.emitBeforeSwitch("new");
     if (beforeResult.cancelled)
       return beforeResult;
@@ -3076,6 +3365,9 @@ var AgentSessionRuntime = class {
     })), options?.setup && (await options.setup(this.session.sessionManager), this.session.agent.state.messages = this.session.sessionManager.buildSessionContext().messages), await this.finishSessionReplacement(options?.withSession), { cancelled: !1 };
   }
   async fork(entryId, options) {
+    return this.withReplacement(() => this.forkOwned(entryId, options));
+  }
+  async forkOwned(entryId, options) {
     let position = options?.position ?? "before";
     if ((await this.emitBeforeFork(entryId, { position })).cancelled)
       return { cancelled: !0 };
@@ -3132,6 +3424,9 @@ var AgentSessionRuntime = class {
    * @throws {MissingSessionCwdError} When the imported session cwd cannot be resolved and no override is provided.
    */
   async importFromJsonl(inputPath, cwdOverride) {
+    return this.withReplacement(() => this.importFromJsonlOwned(inputPath, cwdOverride));
+  }
+  async importFromJsonlOwned(inputPath, cwdOverride) {
     let resolvedPath = resolvePath(inputPath);
     if (!existsSync4(resolvedPath))
       throw new SessionImportFileNotFoundError(resolvedPath);
@@ -3163,7 +3458,8 @@ var AgentSessionRuntime = class {
     })), await this.finishSessionReplacement(), { cancelled: !1 };
   }
   async dispose() {
-    await this.teardownCurrent("quit");
+    this.closing = !0, this.session.stopAdmission(), this.replacement && await this.replacement.catch(() => {
+    }), await this.teardownCurrent("quit");
   }
 };
 async function createAgentSessionRuntime(createRuntime, options) {
@@ -3285,7 +3581,8 @@ async function createOwnedAgentSession(options) {
     allowedToolNames,
     excludedToolNames,
     extensionRunnerRef,
-    sessionStartEvent: options.sessionStartEvent
+    sessionStartEvent: options.sessionStartEvent,
+    permissionMode: options.permissionMode
   }), extensionsResult = resourceLoader.getExtensions();
   return {
     session,
@@ -3377,7 +3674,8 @@ async function createAgentSessionFromServices(options) {
     excludeTools: options.excludeTools,
     noTools: options.noTools,
     customTools: options.customTools,
-    sessionStartEvent: options.sessionStartEvent
+    sessionStartEvent: options.sessionStartEvent,
+    permissionMode: options.permissionMode
   });
 }
 
@@ -3394,7 +3692,10 @@ export {
   disableRollbackForSession,
   beginTurn,
   captureTreeChanges,
+  getRollbackTargetUserId,
+  getRollbackRecoveryBlockReason,
   peekRollbackTurnsConsumed,
+  commitRollbackTurn,
   rollbackLastTurn,
   migrateRollbackSession,
   clearRollback,