@ashx-j/lunr 0.2.21 → 0.2.23

package/dist/node-runtime/chunk-DQMGU675.js

@@ -0,0 +1,3409 @@
+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-TVJUOJZJ.js";
+import {
+  stripFrontmatter
+} from "./chunk-QFWG2RVL.js";
+import {
+  createAllToolDefinitions,
+  createLocalBashOperations,
+  createToolDefinitionFromAgentTool,
+  wrapToolDefinition
+} from "./chunk-YDO2F2IA.js";
+import {
+  DEFAULT_MAX_BYTES,
+  truncateTail
+} from "./chunk-53YJI7JU.js";
+import {
+  stripAnsi
+} from "./chunk-5ZQXRPMC.js";
+import {
+  ModelRuntime,
+  isAuthInvalidError,
+  isUsageLimitError
+} from "./chunk-GS66LV4M.js";
+import {
+  SettingsManager
+} from "./chunk-QAZOULTU.js";
+import {
+  DEFAULT_THINKING_LEVEL,
+  calculateContextTokens,
+  collectEntriesForBranchSummary,
+  compact,
+  estimateContextTokens,
+  estimateTokens,
+  findInitialModel,
+  generateBranchSummary,
+  prepareCompaction,
+  shouldCompact
+} from "./chunk-OFKSVRV7.js";
+import {
+  ExtensionRunner,
+  emitSessionShutdownEvent
+} from "./chunk-GJ2RDBRL.js";
+import {
+  getSubagentCancellation
+} from "./chunk-BBUVIEZB.js";
+import {
+  gateToolCall
+} from "./chunk-5D7LC2ZQ.js";
+import {
+  isUserInstructionsPath,
+  loadSelectedUserInstructions
+} from "./chunk-M3LZLQW2.js";
+import {
+  list
+} from "./chunk-KKUTQQV7.js";
+import {
+  sanitizeBinaryOutput
+} from "./chunk-CSFI6YXL.js";
+import {
+  SessionTransferError
+} from "./chunk-AZJHNQKQ.js";
+import {
+  CURRENT_SESSION_VERSION,
+  SessionManager,
+  getDefaultSessionDir,
+  getLatestCompactionEntry
+} from "./chunk-XLTL257W.js";
+import {
+  convertToLlm
+} from "./chunk-FVDOXRUD.js";
+import {
+  MEMORY_TOOL_NAMES
+} from "./chunk-UJOCPOMX.js";
+import {
+  SessionOwnership,
+  canonicalSessionPath
+} from "./chunk-UAEOTO52.js";
+import {
+  measureStartup,
+  time
+} from "./chunk-PVCDKGR6.js";
+import {
+  getThemeByName,
+  theme
+} from "./chunk-RDDAZOMU.js";
+import {
+  CONFIG_DIR_NAME,
+  getAgentDir,
+  getDocsPath,
+  getExamplesPath,
+  getReadmePath,
+  resolvePath
+} from "./chunk-FQMM2EZ2.js";
+
+// packages/coding-agent/dist/core/agent-session-services.js
+import { join as join7 } from "node:path";
+
+// packages/coding-agent/dist/core/sdk.js
+import { join as join6 } from "node:path";
+import { Agent } from "@ashx-j/lunr-agent";
+import { clampThinkingLevel as clampThinkingLevel2 } from "@ashx-j/lunr-ai";
+
+// packages/coding-agent/dist/core/agent-session.js
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename, dirname as dirname2, join as join4, resolve as resolve2 } from "node:path";
+import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, isRetryableAssistantError, modelsAreEqual, resetApiProviders, streamSimple } from "@ashx-j/lunr-ai/compat";
+
+// packages/coding-agent/dist/utils/sleep.js
+function sleep(ms, signal) {
+  return new Promise((resolve3, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Aborted"));
+      return;
+    }
+    let timeout = setTimeout(resolve3, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timeout), reject(new Error("Aborted"));
+    });
+  });
+}
+
+// packages/coding-agent/dist/core/auth-guidance.js
+import { join } from "node:path";
+var UNKNOWN_PROVIDER = "unknown";
+function getProviderLoginHelp() {
+  return [
+    "Use /login to log into a provider via OAuth or API key. See:",
+    `  ${join(getDocsPath(), "providers.md")}`,
+    `  ${join(getDocsPath(), "models.md")}`
+  ].join(`
+`);
+}
+function formatNoModelsAvailableMessage() {
+  return `No models available. ${getProviderLoginHelp()}`;
+}
+function formatNoModelSelectedMessage() {
+  return `No model selected.
+
+${getProviderLoginHelp()}
+
+Then use /model to select a model.`;
+}
+function formatNoApiKeyFoundMessage(provider) {
+  return `No API key found for ${provider === UNKNOWN_PROVIDER ? "the selected model" : provider}.
+
+${getProviderLoginHelp()}`;
+}
+
+// packages/coding-agent/dist/core/bash-executor.js
+import { randomBytes } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+async function executeBashWithOperations(command, cwd, operations, options) {
+  let outputChunks = [], outputBytes = 0, maxOutputBytes = 51200 * 2, tempFilePath, tempFileStream, totalBytes = 0, ensureTempFile = () => {
+    if (tempFilePath)
+      return;
+    let id = randomBytes(8).toString("hex");
+    tempFilePath = join2(tmpdir(), `lunr-bash-${id}.log`), tempFileStream = createWriteStream(tempFilePath);
+    for (let chunk of outputChunks)
+      tempFileStream.write(chunk);
+  }, decoder = new TextDecoder(), onData = (data) => {
+    totalBytes += data.length;
+    let text = sanitizeBinaryOutput(stripAnsi(decoder.decode(data, { stream: !0 }))).replace(/\r/g, "");
+    for (totalBytes > 51200 && ensureTempFile(), tempFileStream && tempFileStream.write(text), outputChunks.push(text), outputBytes += text.length; outputBytes > maxOutputBytes && outputChunks.length > 1; ) {
+      let removed = outputChunks.shift();
+      outputBytes -= removed.length;
+    }
+    options?.onChunk && options.onChunk(text);
+  };
+  try {
+    let result = await operations.exec(command, cwd, {
+      onData,
+      signal: options?.signal
+    }), fullOutput = outputChunks.join(""), truncationResult = truncateTail(fullOutput);
+    truncationResult.truncated && ensureTempFile(), tempFileStream && tempFileStream.end();
+    let cancelled = options?.signal?.aborted ?? !1;
+    return {
+      output: truncationResult.truncated ? truncationResult.content : fullOutput,
+      exitCode: cancelled ? void 0 : result.exitCode ?? void 0,
+      cancelled,
+      truncated: truncationResult.truncated,
+      fullOutputPath: tempFilePath
+    };
+  } catch (err) {
+    if (options?.signal?.aborted) {
+      let fullOutput = outputChunks.join(""), truncationResult = truncateTail(fullOutput);
+      return truncationResult.truncated && ensureTempFile(), tempFileStream && tempFileStream.end(), {
+        output: truncationResult.truncated ? truncationResult.content : fullOutput,
+        exitCode: void 0,
+        cancelled: !0,
+        truncated: truncationResult.truncated,
+        fullOutputPath: tempFilePath
+      };
+    }
+    throw tempFileStream && tempFileStream.end(), err;
+  }
+}
+
+// packages/coding-agent/dist/core/extensions/wrapper.js
+function wrapRegisteredTool(registeredTool, runner) {
+  let tool = wrapToolDefinition(registeredTool.definition, () => runner.createContext()), execute = tool.execute;
+  return {
+    ...tool,
+    execute: async (toolCallId, params, signal, onUpdate) => {
+      let activeBefore = runner.getActiveTools(), result = await execute(toolCallId, params, signal, onUpdate), activeAfter = runner.getActiveTools();
+      if (!activeBefore.every((name) => activeAfter.includes(name)))
+        return result;
+      let beforeNames = new Set(activeBefore), addedToolNames = activeAfter.filter((name) => !beforeNames.has(name));
+      return addedToolNames.length === 0 ? result : {
+        ...result,
+        addedToolNames: [.../* @__PURE__ */ new Set([...result.addedToolNames ?? [], ...addedToolNames])]
+      };
+    }
+  };
+}
+function wrapRegisteredTools(registeredTools, runner) {
+  return registeredTools.map((tool) => wrapRegisteredTool(tool, runner));
+}
+
+// packages/coding-agent/dist/core/model-registry.js
+var ModelRegistry = class {
+  runtime;
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  /** Reload models.json asynchronously. Await before making synchronous registry reads. */
+  refresh() {
+    return this.runtime.reloadConfig();
+  }
+  getError() {
+    return this.runtime.getError();
+  }
+  getAll() {
+    return [...this.runtime.getModels()];
+  }
+  getAvailable() {
+    return [...this.runtime.getAvailableSnapshot()];
+  }
+  find(provider, modelId) {
+    return this.runtime.getModel(provider, modelId);
+  }
+  hasConfiguredAuth(model) {
+    return this.runtime.hasConfiguredAuth(model.provider);
+  }
+  async getApiKeyAndHeaders(model) {
+    try {
+      let resolution = await this.runtime.getAuth(model);
+      if (!resolution) {
+        let compatibility = this.runtime.getCompatibilityRequestConfig(model);
+        return compatibility.authHeader ? { ok: !1, error: `No API key found for "${model.provider}"` } : { ok: !0, headers: compatibility.headers ? Object.fromEntries(Object.entries(compatibility.headers).filter((entry) => entry[1] !== null)) : void 0 };
+      }
+      let headers = resolution.auth.headers ? Object.fromEntries(Object.entries(resolution.auth.headers).filter((entry) => entry[1] !== null)) : void 0;
+      return { ok: !0, apiKey: resolution.auth.apiKey, headers, env: resolution.env };
+    } catch (error) {
+      let cause = error instanceof Error ? error.cause : void 0, message = cause instanceof Error ? cause.message : error instanceof Error ? error.message : String(error);
+      return {
+        ok: !1,
+        error: message === "authHeader requires a resolved API key" ? `No API key found for "${model.provider}"` : message
+      };
+    }
+  }
+  getProviderAuthStatus(provider) {
+    return this.runtime.getProviderAuthStatus(provider);
+  }
+  getProviderDisplayName(provider) {
+    return this.runtime.getProvider(provider)?.name ?? provider;
+  }
+  async getApiKeyForProvider(provider) {
+    try {
+      return (await this.runtime.getAuth(provider))?.auth.apiKey;
+    } catch {
+      return;
+    }
+  }
+  isUsingOAuth(model) {
+    return this.runtime.isUsingOAuth(model.provider);
+  }
+  registerProvider(providerName, config) {
+    this.runtime.registerProvider(providerName, config);
+  }
+  unregisterProvider(providerName) {
+    this.runtime.unregisterProvider(providerName);
+  }
+  getRegisteredProviderConfig(providerName) {
+    return this.runtime.getRegisteredProviderConfig(providerName);
+  }
+  getRegisteredProviderIds() {
+    return this.runtime.getRegisteredProviderIds();
+  }
+};
+
+// packages/coding-agent/dist/core/rollback.js
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join as join3, normalize, resolve } from "node:path";
+var ROLLBACK_BASE = join3(homedir(), ".lunr", "rollback"), contexts = /* @__PURE__ */ new Map(), lastSessionId, globalSettingsManager, warningHandler;
+function setRollbackWarningHandler(handler) {
+  warningHandler = handler;
+}
+function createContext(sessionId) {
+  return {
+    sessionId,
+    settingsManager: globalSettingsManager,
+    sessionForceEnabled: !1,
+    turns: [],
+    currentTurnIndex: -1,
+    repoWarningShown: !1,
+    externalModWarningShown: !1
+  };
+}
+function getContext(sessionId) {
+  let sid = sessionId ?? lastSessionId ?? "default", ctx = contexts.get(sid);
+  return ctx || (ctx = createContext(sid), contexts.set(sid, ctx)), ctx;
+}
+function initRollback(sm, sid) {
+  globalSettingsManager = sm, lastSessionId = sid, contexts.set(sid, createContext(sid));
+  let ctx = contexts.get(sid);
+  ctx.settingsManager = sm, loadPersistedTurns(ctx);
+}
+function isRollbackEnabled(sessionId) {
+  let ctx = getContext(sessionId);
+  return (ctx.settingsManager?.getRollbackEnabled() ?? !1) || ctx.sessionForceEnabled;
+}
+function isRollbackSessionForceEnabled(sessionId) {
+  return getContext(sessionId).sessionForceEnabled;
+}
+function enableRollbackForSession(sessionId) {
+  getContext(sessionId).sessionForceEnabled = !0;
+}
+function disableRollbackForSession(sessionId) {
+  getContext(sessionId).sessionForceEnabled = !1;
+}
+function pruneTurns(ctx) {
+  let maxTurns = ctx.settingsManager?.getRollbackTurns() ?? 2;
+  for (; ctx.turns.length > maxTurns; ) {
+    let old = ctx.turns.shift();
+    old && cleanupTurnFiles(ctx, old);
+  }
+}
+function beginTurn(cwd, sessionId) {
+  let ctx = getContext(sessionId);
+  if (!isRollbackEnabled(ctx.sessionId))
+    return;
+  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);
+}
+function rollbackSnapshotBeforeWrite(absPath, sessionId) {
+  let ctx = getContext(sessionId);
+  if (!isRollbackEnabled(ctx.sessionId))
+    return;
+  (ctx.currentTurnIndex < 0 || ctx.turns.length === 0) && beginTurn(ctx.lastCwd, ctx.sessionId);
+  let turn = ctx.turns[ctx.turns.length - 1];
+  if (turn && !turn.files.has(absPath))
+    try {
+      let existed = existsSync(absPath), content;
+      existed && (content = readFileSync(absPath)), turn.files.set(absPath, {
+        existed,
+        content,
+        createdByTool: !0
+      }), persistSnapshot(ctx, turn, absPath);
+    } catch {
+    }
+}
+function captureTreeBaseline(ctx, cwd) {
+  let turn = ctx.turns[ctx.turns.length - 1];
+  if (!turn)
+    return;
+  let entries = gitPorcelain(ctx, cwd);
+  if (entries)
+    for (let { path } of entries) {
+      if (!path)
+        continue;
+      let abs = join3(cwd, path);
+      if (!turn.files.has(abs))
+        try {
+          let existed = existsSync(abs);
+          turn.files.set(abs, {
+            existed,
+            content: existed ? readFileSync(abs) : void 0,
+            createdByTool: !1
+          }), persistSnapshot(ctx, turn, abs);
+        } catch {
+        }
+    }
+}
+function captureTreeChanges(cwd, sessionId) {
+  let ctx = getContext(sessionId);
+  if (!isRollbackEnabled(ctx.sessionId) || ctx.settingsManager?.getRollbackScope() !== "tree" || ctx.currentTurnIndex < 0 || ctx.turns.length === 0)
+    return;
+  let turn = ctx.turns[ctx.turns.length - 1];
+  if (!turn)
+    return;
+  let entries = gitPorcelain(ctx, cwd);
+  if (entries)
+    for (let { status, path, source } of entries) {
+      if (!path)
+        continue;
+      let abs = join3(cwd, path);
+      if (!turn.files.has(abs))
+        try {
+          if (status === "??" || status.includes("R")) {
+            if (turn.files.set(abs, { existed: !1, createdByTool: !1 }), persistSnapshot(ctx, turn, abs), status.includes("R") && source) {
+              let sourceAbs = join3(cwd, source);
+              if (!turn.files.has(sourceAbs)) {
+                let headSrc = spawnSync("git", ["show", `HEAD:${source}`], {
+                  cwd,
+                  timeout: 5e3,
+                  maxBuffer: 33554432
+                });
+                !headSrc.error && headSrc.status === 0 && headSrc.stdout && (turn.files.set(sourceAbs, {
+                  existed: !0,
+                  content: headSrc.stdout,
+                  createdByTool: !1
+                }), persistSnapshot(ctx, turn, sourceAbs));
+              }
+            }
+          } else {
+            let head = spawnSync("git", ["show", `HEAD:${path}`], {
+              cwd,
+              timeout: 5e3,
+              maxBuffer: 33554432
+            });
+            if (head.error || head.status !== 0 || !head.stdout)
+              continue;
+            turn.files.set(abs, {
+              existed: !0,
+              content: head.stdout,
+              createdByTool: !1
+            }), persistSnapshot(ctx, turn, abs);
+          }
+        } catch {
+        }
+    }
+}
+function gitPorcelain(ctx, cwd) {
+  try {
+    let result = spawnSync("git", ["status", "--porcelain", "-z"], { cwd, encoding: "utf8", timeout: 5e3 });
+    if (result.error || result.status !== 0) {
+      warnOnce(ctx, "Rollback tree scope: not a git repository (or git failed) \u2014 bash side-effects won't be captured.");
+      return;
+    }
+    let fields = (result.stdout ?? "").split("\0").filter((f) => f.length > 0), entries = [];
+    for (let i = 0; i < fields.length; i++) {
+      let field = fields[i], status = field.slice(0, 2), path = field.slice(3), source;
+      (status.includes("R") || status.includes("C")) && (source = fields[i + 1], i++), entries.push({ status, path, source });
+    }
+    return entries;
+  } catch {
+    warnOnce(ctx, "Rollback tree scope: not a git repository (or git failed) \u2014 bash side-effects won't be captured.");
+    return;
+  }
+}
+function warnOnce(ctx, message) {
+  if (!ctx.repoWarningShown) {
+    ctx.repoWarningShown = !0;
+    try {
+      warningHandler?.(message);
+    } catch {
+    }
+  }
+}
+function persistSnapshot(ctx, turn, absPath) {
+  try {
+    let snap = turn.files.get(absPath);
+    if (!snap)
+      return;
+    let turnDir = getTurnDir(ctx, turn.turnIndex);
+    mkdirSync(turnDir, { recursive: !0 });
+    let manifestPath = join3(turnDir, "manifest.json"), manifest = readManifest(manifestPath), entry = { existed: snap.existed, createdByTool: snap.createdByTool };
+    if (snap.content) {
+      let snapFile = snapFileName(absPath);
+      writeFileSync(join3(turnDir, snapFile), snap.content), entry.snapFile = snapFile;
+    }
+    manifest.files[absPath] = entry, turn.cwd && (manifest.cwd = turn.cwd), writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  } catch {
+  }
+}
+function readManifest(path) {
+  if (!existsSync(path))
+    return { files: {} };
+  try {
+    let parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (parsed && typeof parsed == "object" && !Array.isArray(parsed)) {
+      let files = parsed.files;
+      return {
+        cwd: typeof parsed.cwd == "string" ? parsed.cwd : void 0,
+        files: files && typeof files == "object" && !Array.isArray(files) ? files : {}
+      };
+    }
+    return { files: {} };
+  } catch {
+    return { files: {} };
+  }
+}
+function loadPersistedTurns(ctx) {
+  try {
+    let sessionDir = join3(ROLLBACK_BASE, ctx.sessionId);
+    if (!existsSync(sessionDir))
+      return;
+    let loaded = [];
+    for (let dirName of readdirSync(sessionDir)) {
+      let match = /^turn-(\d+)$/.exec(dirName);
+      if (!match)
+        continue;
+      let turnIndex = Number(match[1]), turnDir = join3(sessionDir, dirName), manifest = readManifest(join3(turnDir, "manifest.json")), files = /* @__PURE__ */ new Map();
+      for (let [absPath, meta] of Object.entries(manifest.files)) {
+        let content;
+        if (meta.snapFile)
+          try {
+            content = readFileSync(join3(turnDir, meta.snapFile));
+          } catch {
+            content = void 0;
+          }
+        files.set(absPath, { existed: meta.existed, content, createdByTool: meta.createdByTool });
+      }
+      loaded.push({ turnIndex, cwd: manifest.cwd, files });
+    }
+    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 {
+  }
+}
+function getTurnDir(ctx, turnIndex) {
+  return join3(ROLLBACK_BASE, ctx.sessionId, `turn-${turnIndex}`);
+}
+function cleanupTurnFiles(ctx, turn) {
+  try {
+    let dir = getTurnDir(ctx, turn.turnIndex);
+    existsSync(dir) && rmSync(dir, { recursive: !0, force: !0 });
+  } catch {
+  }
+}
+function isPathUnderRoot(absPath, root) {
+  let normRoot = normalize(root).replace(/\\$/g, ""), normPath = normalize(absPath).replace(/\\$/g, "");
+  return process.platform === "win32" && (normRoot = normRoot.toLowerCase(), normPath = normPath.toLowerCase()), normPath === normRoot || normPath.startsWith(`${normRoot}/`) || normPath.startsWith(`${normRoot}\\`);
+}
+function isWithinAllowedRoots(absPath, turn) {
+  return turn.cwd ? [
+    ROLLBACK_BASE,
+    join3(homedir(), CONFIG_DIR_NAME),
+    // lunr: agent settings / cron jobs.json live under the config dir
+    // lunr: simple-memory lives next to the lunr agent dir (~/.lunr/simple-memory)
+    join3(dirname(getAgentDir()), "simple-memory"),
+    resolve(turn.cwd)
+  ].some((root) => isPathUnderRoot(absPath, root)) : !0;
+}
+function warnExternalModification(ctx, message) {
+  if (!(ctx.externalModWarningShown || !warningHandler)) {
+    ctx.externalModWarningShown = !0;
+    try {
+      warningHandler(message);
+    } catch {
+    }
+  }
+}
+function peekRollbackTurnsConsumed(sessionId) {
+  let ctx = getContext(sessionId);
+  if (!isRollbackEnabled(ctx.sessionId) || ctx.turns.length === 0)
+    return 0;
+  let consumed = 0;
+  for (let i = ctx.turns.length - 1; i >= 0 && (consumed++, !(ctx.turns[i].files.size > 0)); i--)
+    ;
+  return consumed;
+}
+function rollbackLastTurn(sessionId) {
+  let ctx = getContext(sessionId), empty = { restored: [], deleted: [], 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)
+    try {
+      if (!isWithinAllowedRoots(absPath, turn)) {
+        warnExternalModification(ctx, `Rollback skipped ${absPath}: outside the session working directory or lunR config dir.`);
+        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 {
+    }
+  return cleanupTurnFiles(ctx, turn), ctx.turns.pop(), { restored, deleted, turnsConsumed };
+}
+function migrateRollbackSession(oldSessionId, newSessionId) {
+  if (oldSessionId === newSessionId)
+    return;
+  let ctx = contexts.get(oldSessionId);
+  ctx && (contexts.delete(oldSessionId), ctx.sessionId = newSessionId, contexts.set(newSessionId, ctx));
+  try {
+    let oldDir = join3(ROLLBACK_BASE, oldSessionId), newDir = join3(ROLLBACK_BASE, newSessionId);
+    if (existsSync(oldDir)) {
+      existsSync(newDir) && rmSync(newDir, { recursive: !0, force: !0 });
+      try {
+        renameSync(oldDir, newDir);
+      } catch {
+        cpSync(oldDir, newDir, { recursive: !0 }), rmSync(oldDir, { recursive: !0, force: !0 });
+      }
+    }
+  } catch {
+  }
+}
+function clearRollback(sessionId) {
+  if (sessionId === void 0) {
+    for (let ctx2 of contexts.values()) {
+      for (let turn of ctx2.turns)
+        cleanupTurnFiles(ctx2, turn);
+      try {
+        let sessionDir = join3(ROLLBACK_BASE, ctx2.sessionId);
+        existsSync(sessionDir) && rmSync(sessionDir, { recursive: !0, force: !0 });
+      } catch {
+      }
+    }
+    contexts.clear();
+    return;
+  }
+  let ctx = contexts.get(sessionId);
+  if (ctx) {
+    for (let turn of ctx.turns)
+      cleanupTurnFiles(ctx, turn);
+    try {
+      let sessionDir = join3(ROLLBACK_BASE, sessionId);
+      existsSync(sessionDir) && rmSync(sessionDir, { recursive: !0, force: !0 });
+    } catch {
+    }
+    contexts.delete(sessionId);
+  }
+}
+function snapFileName(absPath) {
+  return `${createHash("sha1").update(absPath).digest("hex")}.snap`;
+}
+
+// packages/coding-agent/dist/core/subagent-wait-interruption.js
+var SUBAGENT_WAIT_INTERRUPTION_SYMBOL = /* @__PURE__ */ Symbol.for("@lunr/subagent-wait-interruption");
+function getBridge() {
+  let globals = globalThis, existing = globals[SUBAGENT_WAIT_INTERRUPTION_SYMBOL];
+  if (existing)
+    return existing;
+  let bridge = { owners: /* @__PURE__ */ new Map() };
+  return globals[SUBAGENT_WAIT_INTERRUPTION_SYMBOL] = bridge, bridge;
+}
+function registerSubagentWaitInterruptionOwner(sessionId, owner) {
+  let owners = getBridge().owners;
+  return owners.set(sessionId, owner), () => {
+    owners.get(sessionId) === owner && owners.delete(sessionId);
+  };
+}
+
+// packages/coding-agent/dist/core/system-prompt.js
+function buildSystemPrompt(options) {
+  let { customPrompt, modelSlug, selectedTools, appendSystemPrompt, cwd, contextFiles: providedContextFiles, skills: providedSkills } = options, promptCwd = cwd.replace(/\\/g, "/"), appendSection = appendSystemPrompt ? `
+
+${appendSystemPrompt}` : "", contextFiles = providedContextFiles ?? [], skills = providedSkills ?? [];
+  if (customPrompt) {
+    let prompt2 = customPrompt;
+    if (appendSection && (prompt2 += appendSection), contextFiles.length > 0) {
+      prompt2 += `
+
+<project_context>
+
+`, prompt2 += `Project-specific instructions and guidelines:
+
+`;
+      for (let { path: filePath, content } of contextFiles)
+        prompt2 += `<project_instructions path="${filePath}">
+${content}
+</project_instructions>
+
+`;
+      prompt2 += `</project_context>
+`;
+    }
+    return (!selectedTools || selectedTools.includes("read")) && skills.length > 0 && (prompt2 += formatSkillsForPrompt(skills)), prompt2 += `
+Current working directory: ${promptCwd}`, prompt2;
+  }
+  let readmePath = getReadmePath(), docsPath = getDocsPath(), examplesPath = getExamplesPath(), currentModel = modelSlug?.trim() || "no model selected", hasRead = !selectedTools || selectedTools.includes("read"), todoGuideline = !selectedTools || selectedTools.includes("todo") ? `- Use todo for meaningful multi-step work. Every update must send the complete list, with exactly one item in progress at a time.
+` : "", prompt = `You are an expert coding assistant currently running ''${currentModel}'', operating inside lunR, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
+Current working directory: ''${promptCwd}''
+
+Behavior guidelines:
+- Default to writing no comments. Only add one if the why is non-obvious: a hidden constraint, a subtle invariant, a workaround for a specific bug, something that would surprise the reader. If removing the comment wouldn't confuse a future reader, don't write it.
+- Keep comments up to date! When making changes, it's important to keep things in sync. An outdated comment is worse than no comment at all.
+- Carefully consider the reversibility and blast radius of actions. Generally you can freely take local, reversible actions like editing files or running tests. But for actions that are hard to reverse, affect shared systems beyond your local environment, or could otherwise be risky or destructive, check with the user before proceeding.
+- Orchestrate subagents with intent! Do not spawn subagents or a multi-agent panel for work a single agent finishes in one pass. Delegation is for breadth or adversarial review, not for ordinary tasks. Use subagents as a tool when there is genuine benefit to it or the user explicitly asks for it.
+- When several agents work in parallel, state file ownership up front so they do not collide.
+- Tests are good! Endless smoke tests, regressions tests for feature deletions, etc, much less good. Tests should be focused, not slop.
+- Prefer editing existing files to creating new ones.
+- When a reusable excerpt, prompt, or code fragment should be click-to-copy, wrap only that payload in a fenced Markdown block with the info string \`lunr-copy\`. Keep explanation outside the block. Use a longer backtick or tilde fence when the payload contains fenced code.
+- Only use emojis if the user explicitly requests it.
+- Never exfil private data on public platforms like github or any other services under any circumstances.
+
+
+Guidelines:
+- Use bash for file operations like ls, rg, find
+- Use read to examine files instead of cat or sed.
+- Use edit for precise changes (edits[].oldText must match exactly)
+- When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls
+- Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.
+- Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.
+- Use write only for new files or complete rewrites.
+${todoGuideline}- Use subagents for independent parallel work, specialist analysis, or substantial research. Subagents start with fresh sessions. Use intercom instead to coordinate with an existing lunR session.
+- Resume a subagent only when its work is unfinished or the next task genuinely needs the context it built up. Otherwise launch a new subagent.
+- Use ast_search for structural code matches.
+- Use cron only when the user asks to schedule or manage unattended prompts.
+- For gateway work, inspect with \`lunr gateway status\` or \`lunr gateway doctor\`, configure with \`lunr gateway setup\`, and run \`lunr gateway start\` or \`lunr gateway stop\` only with user approval. Test by asking the user to send \`/whoami\` or a normal message to the bot; there is no arbitrary outbound send command. Keep bot tokens out of commands and output. See ${docsPath}/features.md for pairing, logs, and service details.
+- Memory stores established, durable facts and stable preferences. Do not store behavior instructions, transient task details, transcripts, guesses, or secrets. Change memory only with the memory tools.
+- ~/.lunr/agent/agents/ contains optional global and per-model AGENTS.md instructions written by the user. Never modify this tree, including through shell commands.
+- Use web search when information is current, uncertain, externally referenced, or research-heavy, and cite the sources used.
+- Use MCP only for capabilities exposed by configured MCP servers. Call native lunR tools directly.
+
+
+lunR documentation (read only when the user asks about lunR itself, or the task concerns lunR itself, its SDK, extensions, themes, skills, or TUI):
+- README: ${readmePath}
+- Documentation: ${docsPath}
+- Examples: ${examplesPath}
+- Always read lunR .md files completely and follow links to related docs (e.g., tui.md for TUI API details)`;
+  if (appendSection && (prompt += appendSection), contextFiles.length > 0) {
+    prompt += `
+
+<project_context>
+
+`, prompt += `Project-specific instructions and guidelines:
+
+`;
+    for (let { path: filePath, content } of contextFiles)
+      prompt += `<project_instructions path="${filePath}">
+${content}
+</project_instructions>
+
+`;
+    prompt += `</project_context>
+`;
+  }
+  return hasRead && skills.length > 0 && (prompt += formatSkillsForPrompt(skills)), prompt;
+}
+
+// packages/coding-agent/dist/core/agent-session.js
+function parseSkillBlock(text) {
+  let match = text.match(/^<skill name="([^"]+)" location="([^"]+)">\n([\s\S]*?)\n<\/skill>(?:\n\n([\s\S]+))?$/);
+  return match ? {
+    name: match[1],
+    location: match[2],
+    content: match[3],
+    userMessage: match[4]?.trim() || void 0
+  } : null;
+}
+function withoutDeletedHeaders(headers) {
+  return headers ? Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] !== null)) : void 0;
+}
+function estimateMessagesTokens(messages) {
+  let tokens = 0;
+  for (let message of messages)
+    tokens += estimateTokens(message);
+  return tokens;
+}
+var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"], AgentSession = class {
+  agent;
+  sessionManager;
+  settingsManager;
+  _scopedModels;
+  // Event subscription state
+  _unsubscribeAgent;
+  _eventListeners = [];
+  _isAgentRunActive = !1;
+  _idleWaitPromise;
+  _resolveIdleWait;
+  _activePromptRun;
+  _waitPromptHandoff;
+  _waitPromptAcceptance = Promise.resolve();
+  _waitPromptGeneration = 0;
+  _unregisterSubagentWaitInterruptionOwners = [];
+  /** Tracks pending steering messages for UI display. Removed when delivered. */
+  _steeringMessages = [];
+  /** Tracks pending follow-up messages for UI display. Removed when delivered. */
+  _followUpMessages = [];
+  /** Messages queued to be included with the next user prompt as context ("asides"). */
+  _pendingNextTurnMessages = [];
+  // Compaction state
+  _compactionAbortController = void 0;
+  _manualCompactionPromise = void 0;
+  _autoCompactionAbortController = void 0;
+  _overflowRecoveryAttempted = !1;
+  // Branch summarization state
+  _branchSummaryAbortController = void 0;
+  // Retry state
+  _retryAbortController = void 0;
+  _retryAttempt = 0;
+  // Bash execution state
+  _bashAbortController = void 0;
+  _pendingBashMessages = [];
+  // Extension system
+  _extensionRunner;
+  _turnIndex = 0;
+  _resourceLoader;
+  _customTools;
+  _baseToolDefinitions = /* @__PURE__ */ new Map();
+  _cwd;
+  _agentDir;
+  _extensionRunnerRef;
+  _initialActiveToolNames;
+  _allowedToolNames;
+  _excludedToolNames;
+  _baseToolsOverride;
+  _sessionStartEvent;
+  _extensionUIContext;
+  _extensionMode = "print";
+  _extensionCommandContextActions;
+  _extensionAbortHandler;
+  _extensionShutdownHandler;
+  _extensionErrorListener;
+  _extensionErrorUnsubscriber;
+  _modelRuntime;
+  // Tool registry for extension getTools/setTools
+  _toolRegistry = /* @__PURE__ */ new Map();
+  _toolDefinitions = /* @__PURE__ */ new Map();
+  _toolPromptSnippets = /* @__PURE__ */ new Map();
+  _toolPromptGuidelines = /* @__PURE__ */ new Map();
+  // Base system prompt (without extension appends) - used to apply fresh appends each turn
+  _baseSystemPrompt = "";
+  _baseSystemPromptOptions;
+  _systemPromptOverride;
+  // lunr: core-owned system-prompt append (plan mode addendum) applied on top of base/override
+  _systemPromptAppend;
+  // lunr: core-owned tool-call gates (plan 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" };
+    let waitInterruptionOwner = { register: () => this._registerSubagentWaitInterruption() };
+    for (let identity of new Set([this.sessionId, this.sessionFile].filter((value) => !!value)))
+      this._unregisterSubagentWaitInterruptionOwners.push(registerSubagentWaitInterruptionOwner(identity, waitInterruptionOwner));
+    this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent), this._installAgentToolHooks(), this._installAgentNextTurnRefresh(), this._buildRuntime({
+      activeToolNames: this._initialActiveToolNames,
+      includeAllExtensionTools: !0
+    });
+  }
+  get modelRuntime() {
+    return this._modelRuntime;
+  }
+  get openaiFastMode() {
+    return this.settingsManager.getOpenAIFastMode();
+  }
+  setOpenAIFastMode(enabled) {
+    this.settingsManager.setOpenAIFastMode(enabled), this._syncOpenAIServiceTier();
+  }
+  _syncOpenAIServiceTier() {
+    this.agent.serviceTier = this.agent.state.model.provider === "openai-codex" && this.settingsManager.getOpenAIFastMode() ? "fast" : void 0;
+  }
+  async _getRequiredRequestAuth(model) {
+    let result;
+    try {
+      result = await this._modelRuntime.getAuth(model);
+    } catch (error) {
+      let cause = error instanceof Error ? error.cause : void 0;
+      throw cause instanceof Error && cause.message === "authHeader requires a resolved API key" ? new Error(formatNoApiKeyFoundMessage(model.provider)) : error;
+    }
+    if (result?.auth.apiKey)
+      return {
+        apiKey: result.auth.apiKey,
+        headers: withoutDeletedHeaders(result.auth.headers),
+        env: result.env
+      };
+    throw this._modelRuntime.isUsingOAuth(model.provider) ? new Error(`Authentication failed for "${model.provider}". Credentials may have expired or network is unavailable. Run '/login ${model.provider}' to re-authenticate.`) : new Error(formatNoApiKeyFoundMessage(model.provider));
+  }
+  async _getSummarizationRequestAuth(model) {
+    if (this.agent.streamFn === streamSimple)
+      return this._getRequiredRequestAuth(model);
+    try {
+      let result = await this._modelRuntime.getAuth(model);
+      return result ? { apiKey: result.auth.apiKey, headers: withoutDeletedHeaders(result.auth.headers), env: result.env } : {};
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Install tool hooks once on the Agent instance.
+   *
+   * The callbacks read `this._extensionRunner` at execution time, so extension reload swaps in the
+   * new runner without reinstalling hooks. Extension-specific tool wrappers are still used to adapt
+   * registered tool execution to the extension context. Tool call and tool result interception now
+   * happens here instead of in wrappers.
+   */
+  _installAgentToolHooks() {
+    this.agent.beforeToolCall = async ({ toolCall, args, assistantMessage }) => {
+      let permBlock = await gateToolCall(toolCall.name, args, this._cwd, this.sessionId, {
+        confirmLargeSubagentLaunches: this.settingsManager.getConfirmLargeSubagentLaunches(),
+        assistantMessage
+      });
+      if (permBlock)
+        return { block: !0, reason: permBlock.reason };
+      try {
+        let toolName = toolCall.name, argPath = args && typeof args == "object" && "path" in args ? resolve2(this._cwd, String(args.path)) : void 0, pathsToSnapshot = [];
+        if (toolName === "edit" || toolName === "write")
+          argPath && pathsToSnapshot.push(argPath);
+        else if (toolName === "memory_add" || toolName === "memory_remove")
+          pathsToSnapshot.push(join4(dirname2(getAgentDir()), "simple-memory", "memory.md"));
+        else if (toolName === "cron" && args && typeof args == "object") {
+          let action = String(args.action ?? "");
+          (action === "create" || action === "update" || action === "remove") && pathsToSnapshot.push(join4(getAgentDir(), "cron", "jobs.json"));
+        }
+        for (let p of pathsToSnapshot)
+          rollbackSnapshotBeforeWrite(p, this.sessionId);
+      } catch {
+      }
+      for (let gate of this._toolCallGates) {
+        let gateResult = gate(toolCall.name, args);
+        if (gateResult?.block)
+          return { block: !0, reason: gateResult.reason };
+      }
+      let runner = this._extensionRunner;
+      if (runner.hasHandlers("tool_call"))
+        try {
+          return await runner.emitToolCall({
+            type: "tool_call",
+            toolName: toolCall.name,
+            toolCallId: toolCall.id,
+            input: args
+          });
+        } catch (err) {
+          throw err instanceof Error ? err : new Error(`Extension failed, blocking execution: ${String(err)}`);
+        }
+    }, this.agent.afterToolCall = async ({ toolCall, args, result, isError }) => {
+      let runner = this._extensionRunner;
+      if (!runner.hasHandlers("tool_result"))
+        return;
+      let hookResult = await runner.emitToolResult({
+        type: "tool_result",
+        toolName: toolCall.name,
+        toolCallId: toolCall.id,
+        input: args,
+        content: result.content,
+        details: result.details,
+        isError
+      });
+      if (hookResult)
+        return {
+          content: hookResult.content,
+          details: hookResult.details,
+          isError: hookResult.isError ?? isError
+        };
+    };
+  }
+  _installAgentNextTurnRefresh() {
+    let previousPrepareNextTurnWithContext = this.agent.prepareNextTurnWithContext ?? (this.agent.prepareNextTurn ? async (_turn, signal) => await this.agent.prepareNextTurn?.(signal) : void 0);
+    this.agent.prepareNextTurnWithContext = async (turn, signal) => {
+      let previousSnapshot = await previousPrepareNextTurnWithContext?.(turn, signal), previousContext = previousSnapshot?.context ?? turn.context, model = this.model, settings = this.settingsManager.getCompactionSettings();
+      if (model?.provider === "openai-codex" && settings.enabled && shouldCompact(estimateContextTokens(previousContext.messages).tokens, model.contextWindow, settings)) {
+        let previousCompactionId = getLatestCompactionEntry(this.sessionManager.getBranch())?.id;
+        await this._runAutoCompaction("threshold", !0);
+        let currentCompaction = getLatestCompactionEntry(this.sessionManager.getBranch());
+        currentCompaction && currentCompaction.id !== previousCompactionId && (previousContext = { ...previousContext, messages: this.agent.state.messages.slice() });
+      }
+      return {
+        ...previousSnapshot,
+        context: {
+          ...previousContext,
+          systemPrompt: this._withSystemPromptAppend(this._systemPromptOverride ?? this._baseSystemPrompt),
+          tools: this.agent.state.tools.slice()
+        },
+        model: this.agent.state.model,
+        thinkingLevel: this.agent.state.thinkingLevel
+      };
+    };
+  }
+  // =========================================================================
+  // Event Subscription
+  // =========================================================================
+  /** Emit an event to all listeners */
+  _emit(event) {
+    for (let l of this._eventListeners)
+      l(event);
+  }
+  _emitQueueUpdate() {
+    this._emit({
+      type: "queue_update",
+      steering: [...this._steeringMessages],
+      followUp: [...this._followUpMessages]
+    });
+  }
+  _getIdleWaitPromise() {
+    return this._idleWaitPromise || (this._idleWaitPromise = new Promise((resolve3) => {
+      this._resolveIdleWait = resolve3;
+    })), this._idleWaitPromise;
+  }
+  _resolveIdleWaitIfIdle() {
+    if (this._isAgentRunActive || !this._resolveIdleWait)
+      return;
+    let resolve3 = this._resolveIdleWait;
+    this._idleWaitPromise = void 0, this._resolveIdleWait = void 0, resolve3();
+  }
+  async _emitAgentSettled() {
+    this._isAgentRunActive = !1;
+    try {
+      await this._extensionRunner.emit({ type: "agent_settled" }), this._emit({ type: "agent_settled" });
+    } finally {
+      this._resolveIdleWaitIfIdle();
+    }
+  }
+  // Track last assistant message for auto-compaction check
+  _lastAssistantMessage = void 0;
+  /** Internal handler for agent events - shared by subscribe and reconnect */
+  _handleAgentEvent = async (event) => {
+    if (event.type === "message_start" && event.message.role === "user") {
+      this._overflowRecoveryAttempted = !1;
+      let messageText = this._getUserMessageText(event.message);
+      if (messageText) {
+        let steeringIndex = this._steeringMessages.indexOf(messageText);
+        if (steeringIndex !== -1)
+          this._steeringMessages.splice(steeringIndex, 1), this._emitQueueUpdate();
+        else {
+          let followUpIndex = this._followUpMessages.indexOf(messageText);
+          followUpIndex !== -1 && (this._followUpMessages.splice(followUpIndex, 1), this._emitQueueUpdate());
+        }
+      }
+    }
+    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")) {
+      this._lastAssistantMessage = event.message;
+      let assistantMsg = event.message;
+      assistantMsg.stopReason !== "error" && (this._overflowRecoveryAttempted = !1), assistantMsg.stopReason !== "error" && this._retryAttempt > 0 && (this._emit({
+        type: "auto_retry_end",
+        success: !0,
+        attempt: this._retryAttempt
+      }), this._retryAttempt = 0);
+    }
+  };
+  _willRetryAfterAgentEnd(event) {
+    let settings = this.settingsManager.getRetrySettings();
+    if (!settings.enabled || this._retryAttempt >= settings.maxRetries)
+      return !1;
+    for (let i = event.messages.length - 1; i >= 0; i--) {
+      let message = event.messages[i];
+      if (message.role === "assistant")
+        return this._isRetryableError(message);
+    }
+    return !1;
+  }
+  /** Extract text content from a message */
+  _getUserMessageText(message) {
+    if (message.role !== "user")
+      return "";
+    let content = message.content;
+    return typeof content == "string" ? content : content.filter((c) => c.type === "text").map((c) => c.text).join("");
+  }
+  /** Find the last assistant message in agent state (including aborted ones) */
+  _findLastAssistantMessage() {
+    let messages = this.agent.state.messages;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      let msg = messages[i];
+      if (msg.role === "assistant")
+        return msg;
+    }
+  }
+  _replaceMessageInPlace(target, replacement) {
+    if (target === replacement)
+      return;
+    let targetRecord = target;
+    for (let key of Object.keys(targetRecord))
+      delete targetRecord[key];
+    Object.assign(targetRecord, replacement);
+  }
+  /** Emit extension events based on agent events */
+  async _emitExtensionEvent(event) {
+    if (event.type === "agent_start")
+      this._turnIndex = 0, await this._extensionRunner.emit({ type: "agent_start" });
+    else if (event.type === "agent_end")
+      await this._extensionRunner.emit({ type: "agent_end", messages: event.messages });
+    else if (event.type === "turn_start") {
+      let extensionEvent = {
+        type: "turn_start",
+        turnIndex: this._turnIndex,
+        timestamp: Date.now()
+      };
+      await this._extensionRunner.emit(extensionEvent);
+    } else if (event.type === "turn_end") {
+      let extensionEvent = {
+        type: "turn_end",
+        turnIndex: this._turnIndex,
+        message: event.message,
+        toolResults: event.toolResults
+      };
+      await this._extensionRunner.emit(extensionEvent), this._turnIndex++;
+    } else if (event.type === "message_start") {
+      let extensionEvent = {
+        type: "message_start",
+        message: event.message
+      };
+      await this._extensionRunner.emit(extensionEvent);
+    } else if (event.type === "message_update") {
+      let extensionEvent = {
+        type: "message_update",
+        message: event.message,
+        assistantMessageEvent: event.assistantMessageEvent
+      };
+      await this._extensionRunner.emit(extensionEvent);
+    } else if (event.type === "message_end") {
+      let extensionEvent = {
+        type: "message_end",
+        message: event.message
+      }, replacement = await this._extensionRunner.emitMessageEnd(extensionEvent);
+      if (replacement) {
+        let normalized = (replacement.role === "user" || replacement.role === "assistant" || replacement.role === "toolResult" || replacement.role === "custom") && replacement.content == null ? { ...replacement, content: [] } : replacement;
+        this._replaceMessageInPlace(event.message, normalized);
+      }
+    } else if (event.type === "tool_execution_start") {
+      let extensionEvent = {
+        type: "tool_execution_start",
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        args: event.args
+      };
+      await this._extensionRunner.emit(extensionEvent);
+    } else if (event.type === "tool_execution_update") {
+      let extensionEvent = {
+        type: "tool_execution_update",
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        args: event.args,
+        partialResult: event.partialResult
+      };
+      await this._extensionRunner.emit(extensionEvent);
+    } else if (event.type === "tool_execution_end") {
+      let extensionEvent = {
+        type: "tool_execution_end",
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        result: event.result,
+        isError: event.isError
+      };
+      await this._extensionRunner.emit(extensionEvent);
+    }
+  }
+  /**
+   * Subscribe to agent events.
+   * Session persistence is handled internally (saves messages on message_end).
+   * Multiple listeners can be added. Returns unsubscribe function for this listener.
+   */
+  subscribe(listener) {
+    return this._eventListeners.push(listener), () => {
+      let index = this._eventListeners.indexOf(listener);
+      index !== -1 && this._eventListeners.splice(index, 1);
+    };
+  }
+  /**
+   * Temporarily disconnect from agent events.
+   * User listeners are preserved and will receive events again after resubscribe().
+   * Used internally during operations that need to pause event processing.
+   */
+  _disconnectFromAgent() {
+    this._unsubscribeAgent && (this._unsubscribeAgent(), this._unsubscribeAgent = void 0);
+  }
+  /**
+   * Reconnect to agent events after _disconnectFromAgent().
+   * Preserves all existing listeners.
+   */
+  _reconnectToAgent() {
+    this._unsubscribeAgent || (this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent));
+  }
+  /**
+   * Remove all listeners and disconnect from agent.
+   * Call this when completely done with the session.
+   */
+  transferring = !1;
+  setTransferring(value) {
+    this.transferring = value, value && this._invalidateWaitPromptHandoffs("Session transfer interrupted the pending prompt.");
+  }
+  assertCanStartWork() {
+    if (this.sessionManager.assertWritable(), 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();
+    try {
+      this.abortRetry(), this.abortCompaction(), this.abortBranchSummary(), this.abortBash(), this.agent.abort();
+    } catch {
+    }
+    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
+  // =========================================================================
+  /** Full agent state */
+  get state() {
+    return this.agent.state;
+  }
+  /** Current model (may be undefined if not yet selected) */
+  get model() {
+    return this.agent.state.model;
+  }
+  /** Current thinking level */
+  get thinkingLevel() {
+    return this.agent.state.thinkingLevel;
+  }
+  /** Whether the session is currently processing an agent run or post-run continuation. */
+  get isStreaming() {
+    return this._isAgentRunActive;
+  }
+  /** Whether the session has no active agent run, retry, auto-compaction, or queued continuation. */
+  get isIdle() {
+    return !this._isAgentRunActive;
+  }
+  /** Whether normal Enter is still being reserved for an interrupted wait handoff. */
+  get isWaitPromptHandoffActive() {
+    return this._waitPromptHandoff?.accepting === !0;
+  }
+  /** Current effective system prompt (includes any per-turn extension modifications) */
+  get systemPrompt() {
+    return this.agent.state.systemPrompt;
+  }
+  /**
+   * lunr: register a core-owned tool-call gate (plan mode). Gates run before extension
+   * tool_call handlers and even when no extension handles tool_call. Returns an
+   * unsubscribe function.
+   */
+  addToolCallGate(gate) {
+    return this._toolCallGates.push(gate), () => {
+      let index = this._toolCallGates.indexOf(gate);
+      index >= 0 && this._toolCallGates.splice(index, 1);
+    };
+  }
+  /**
+   * lunr: append (or clear, with undefined) a core-owned section on the effective system
+   * prompt. Applied on top of the base prompt and any per-turn extension override.
+   */
+  setSystemPromptAppend(text) {
+    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));
+  }
+  _withSystemPromptAppend(prompt) {
+    return this._systemPromptAppend ? `${prompt}
+
+${this._systemPromptAppend}` : prompt;
+  }
+  /** Current retry attempt (0 if not retrying) */
+  get retryAttempt() {
+    return this._retryAttempt;
+  }
+  /**
+   * Get the names of currently active tools.
+   * Returns the names of tools currently set on the agent.
+   */
+  getActiveToolNames() {
+    return this.agent.state.tools.map((t) => t.name);
+  }
+  /**
+   * Get all configured tools with name, description, parameter schema, prompt guidelines, and source metadata.
+   */
+  getAllTools() {
+    return Array.from(this._toolDefinitions.values()).map(({ definition, sourceInfo }) => ({
+      name: definition.name,
+      description: definition.description,
+      parameters: definition.parameters,
+      promptGuidelines: definition.promptGuidelines,
+      sourceInfo
+    }));
+  }
+  getToolDefinition(name) {
+    return this._toolDefinitions.get(name)?.definition;
+  }
+  /**
+   * Set active tools by name.
+   * Only tools in the registry can be enabled. Unknown tool names are ignored.
+   * Also rebuilds the system prompt to reflect the new tool set.
+   * Changes take effect on the next agent turn.
+   */
+  setActiveToolsByName(toolNames) {
+    let tools = [], validToolNames = [];
+    for (let name of toolNames) {
+      let tool = this._toolRegistry.get(name);
+      tool && (tools.push(tool), validToolNames.push(name));
+    }
+    this.agent.state.tools = tools, this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames), this.agent.state.systemPrompt = this._withSystemPromptAppend(this._systemPromptOverride ?? this._baseSystemPrompt);
+  }
+  /** Rebuild the registry after a settings-backed feature changes availability. */
+  refreshToolRegistry() {
+    this._refreshToolRegistry();
+  }
+  /** Whether compaction or branch summarization is currently running */
+  get isCompacting() {
+    return this._autoCompactionAbortController !== void 0 || this._compactionAbortController !== void 0 || this._branchSummaryAbortController !== void 0;
+  }
+  /** All messages including custom types like BashExecutionMessage */
+  get messages() {
+    return this.agent.state.messages;
+  }
+  /** Current steering mode */
+  get steeringMode() {
+    return this.agent.steeringMode;
+  }
+  /** Current follow-up mode */
+  get followUpMode() {
+    return this.agent.followUpMode;
+  }
+  /** Current session file path, or undefined if sessions are disabled */
+  get sessionFile() {
+    return this.sessionManager.getSessionFile();
+  }
+  /** Current session ID */
+  get sessionId() {
+    return this.sessionManager.getSessionId();
+  }
+  /** Current session display name, if set */
+  get sessionName() {
+    return this.sessionManager.getSessionName();
+  }
+  /** Scoped models for cycling (from --models flag) */
+  get scopedModels() {
+    return this._scopedModels;
+  }
+  /** Update scoped models for cycling */
+  setScopedModels(scopedModels) {
+    this._scopedModels = scopedModels;
+  }
+  /** File-based prompt templates */
+  get promptTemplates() {
+    return this._resourceLoader.getPrompts().prompts;
+  }
+  _normalizePromptSnippet(text) {
+    if (!text)
+      return;
+    let oneLine = text.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+    return oneLine.length > 0 ? oneLine : void 0;
+  }
+  _normalizePromptGuidelines(guidelines) {
+    if (!guidelines || guidelines.length === 0)
+      return [];
+    let unique = /* @__PURE__ */ new Set();
+    for (let guideline of guidelines) {
+      let normalized = guideline.trim();
+      normalized.length > 0 && unique.add(normalized);
+    }
+    return Array.from(unique);
+  }
+  _rebuildSystemPrompt(toolNames) {
+    let validToolNames = toolNames.filter((name) => this._toolRegistry.has(name)), toolSnippets = {}, promptGuidelines = [];
+    for (let name of validToolNames) {
+      let snippet = this._toolPromptSnippets.get(name);
+      snippet && (toolSnippets[name] = snippet);
+      let toolGuidelines = this._toolPromptGuidelines.get(name);
+      toolGuidelines && promptGuidelines.push(...toolGuidelines);
+    }
+    let loaderSystemPrompt = this._resourceLoader.getSystemPrompt(), loaderAppendSystemPrompt = this._resourceLoader.getAppendSystemPrompt(), appendSystemPrompt = loaderAppendSystemPrompt.length > 0 ? loaderAppendSystemPrompt.join(`
+
+`) : void 0, loadedSkills = this._resourceLoader.getSkills().skills, loadedContextFiles = this._resourceLoader.getAgentsFiles().agentsFiles, contextFiles = this._resourceLoader.contextFilesEnabled?.() === !1 ? [] : [
+      ...loadSelectedUserInstructions({
+        agentDir: this._agentDir,
+        settingsManager: this.settingsManager,
+        model: this.model
+      }),
+      ...loadedContextFiles.filter((file) => !isUserInstructionsPath(file.path, this._agentDir))
+    ];
+    return this._baseSystemPromptOptions = {
+      cwd: this._cwd,
+      modelSlug: this.model ? `${this.model.provider}/${this.model.id}` : void 0,
+      skills: loadedSkills,
+      contextFiles,
+      customPrompt: loaderSystemPrompt,
+      appendSystemPrompt,
+      selectedTools: validToolNames,
+      toolSnippets,
+      promptGuidelines
+    }, buildSystemPrompt(this._baseSystemPromptOptions);
+  }
+  _refreshSystemPromptForCurrentModel() {
+    this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames()), this.agent.state.systemPrompt = this._withSystemPromptAppend(this._systemPromptOverride ?? this._baseSystemPrompt);
+  }
+  // =========================================================================
+  // Prompting
+  // =========================================================================
+  _registerSubagentWaitInterruption() {
+    let run = this._activePromptRun, ownerSignal = this.agent.signal, wait = run && ownerSignal ? { controller: new AbortController(), interrupted: !1, ownerSignal } : void 0;
+    return run && wait && (run.waits.add(wait), run.gracefulStopRequested && (wait.interrupted = !0, wait.controller.abort())), {
+      signal: wait?.controller.signal ?? new AbortController().signal,
+      wasInterrupted: () => wait?.interrupted === !0,
+      unregister: () => {
+        wait && run?.waits.delete(wait);
+      }
+    };
+  }
+  _interruptSubagentWaits(run, ownerSignal) {
+    for (let wait of run.waits)
+      wait.ownerSignal === ownerSignal && (wait.interrupted = !0, wait.controller.abort());
+  }
+  _invalidateWaitPromptHandoffs(message) {
+    this._waitPromptGeneration++;
+    let handoff = this._waitPromptHandoff;
+    if (this._waitPromptHandoff = void 0, !handoff)
+      return;
+    let error = new Error(message);
+    for (let reservation of handoff.reservations.splice(0))
+      reservation.reject(error);
+  }
+  async _runAgentPrompt(messages) {
+    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();
+    }
+  }
+  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({
+      type: "auto_retry_end",
+      success: !1,
+      attempt: this._retryAttempt,
+      finalError: msg.errorMessage
+    }), this._retryAttempt = 0), await this._checkCompaction(msg)) ? !0 : this.agent.hasQueuedMessages();
+  }
+  /**
+   * Send a prompt to the agent.
+   * - Handles extension commands (registered via pi.registerCommand) immediately, even during streaming
+   * - Expands file-based prompt templates by default
+   * - During streaming, queues via steer() or followUp() based on streamingBehavior option
+   * - Validates model and API key before sending (when not streaming)
+   * @throws Error if streaming and no streamingBehavior specified
+   * @throws Error if no model selected or no API key available (when not streaming)
+   */
+  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;
+      }
+      if (this.isStreaming) {
+        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);
+        return;
+      }
+      messages = await this._createPromptMessages(prepared);
+    } catch (error) {
+      throw preflightResult?.(!1), error;
+    }
+    preflightResult?.(!0), await this._runAgentPrompt(messages);
+  }
+  async _preparePromptInput(text, options, streamingBehavior) {
+    let expandPromptTemplates = options?.expandPromptTemplates ?? !0;
+    if (expandPromptTemplates && text.startsWith("/") && await this._tryExecuteExtensionCommand(text))
+      return;
+    let currentText = text, currentImages = options?.images;
+    if (this._extensionRunner.hasHandlers("input")) {
+      let inputResult = await this._extensionRunner.emitInput(currentText, currentImages, options?.source ?? "interactive", streamingBehavior);
+      if (inputResult.action === "handled")
+        return;
+      inputResult.action === "transform" && (currentText = inputResult.text, currentImages = inputResult.images ?? currentImages);
+    }
+    return expandPromptTemplates && (currentText = this._expandSkillCommand(currentText), currentText = expandPromptTemplate(currentText, [...this.promptTemplates])), { text: currentText, images: currentImages };
+  }
+  async _createPromptMessages(input) {
+    if (this._flushPendingBashMessages(), !this.model)
+      throw new Error(formatNoModelSelectedMessage());
+    if (!(this._modelRuntime.hasConfiguredAuth(this.model.provider) || await this._modelRuntime.checkAuth(this.model.provider) !== void 0))
+      throw this._modelRuntime.isUsingOAuth(this.model.provider) ? new Error(`Authentication failed for "${this.model.provider}". Credentials may have expired or network is unavailable. Run '/login ${this.model.provider}' to re-authenticate.`) : new Error(formatNoApiKeyFoundMessage(this.model.provider));
+    let lastAssistant = this._findLastAssistantMessage();
+    lastAssistant && await this._checkCompaction(lastAssistant, !1);
+    let userContent = [{ type: "text", text: input.text }];
+    input.images && userContent.push(...input.images);
+    let messages = [
+      {
+        role: "user",
+        content: userContent,
+        timestamp: Date.now()
+      },
+      ...this._pendingNextTurnMessages
+    ];
+    this._pendingNextTurnMessages = [];
+    let result = await this._extensionRunner.emitBeforeAgentStart(input.text, input.images, this._baseSystemPrompt, this._baseSystemPromptOptions);
+    if (result?.messages)
+      for (let msg of result.messages)
+        messages.push({
+          role: "custom",
+          customType: msg.customType,
+          content: msg.content ?? [],
+          display: msg.display,
+          details: msg.details,
+          timestamp: Date.now()
+        });
+    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));
+    return this._waitPromptAcceptance = acceptance.then(() => {
+    }, () => {
+    }), acceptance;
+  }
+  async _reserveWaitPrompt(text, options) {
+    this.assertCanStartWork();
+    let activeRun = this._activePromptRun, existing = this._waitPromptHandoff, activeWait = activeRun?.waits.values().next().value, run = existing?.accepting ? existing.run : activeWait ? activeRun : void 0, ownerSignal = existing?.accepting ? existing.ownerSignal : activeWait?.ownerSignal;
+    if (!run || !ownerSignal)
+      return;
+    let handoff = existing?.run === run && existing.accepting ? existing : {
+      run,
+      ownerSignal,
+      generation: this._waitPromptGeneration,
+      reservations: [],
+      draining: !1,
+      accepting: !0
+    };
+    this._waitPromptHandoff = handoff;
+    let prepared;
+    try {
+      prepared = await this._preparePromptInput(text, options, void 0);
+    } catch (error) {
+      throw handoff.reservations.length === 0 && this._waitPromptHandoff === handoff && (this._waitPromptHandoff = void 0), error;
+    }
+    if (!prepared)
+      return handoff.reservations.length === 0 && this._waitPromptHandoff === handoff && (this._waitPromptHandoff = void 0), { completion: Promise.resolve() };
+    let resolveCompletion = () => {
+    }, rejectCompletion = (_error) => {
+    }, completion = new Promise((resolve3, reject) => {
+      resolveCompletion = resolve3, rejectCompletion = reject;
+    });
+    return handoff.reservations.push({ input: prepared, resolve: resolveCompletion, reject: rejectCompletion }), !run.gracefulStopRequested && this.agent.requestGracefulStop(handoff.ownerSignal) && (run.gracefulStopRequested = !0), this._interruptSubagentWaits(run, handoff.ownerSignal), handoff.draining || (handoff.draining = !0, this._drainWaitPromptHandoff(handoff)), { completion };
+  }
+  async _drainWaitPromptHandoff(handoff) {
+    for (await this.waitForIdle(); this._waitPromptHandoff === handoff && handoff.generation === this._waitPromptGeneration && handoff.reservations.length > 0; ) {
+      let reservation = handoff.reservations[0];
+      try {
+        this.assertCanStartWork();
+        let messages = await this._createPromptMessages(reservation.input);
+        handoff.accepting = !1, await this._runAgentPrompt(messages), reservation.resolve();
+      } catch (error) {
+        reservation.reject(error);
+      } finally {
+        handoff.reservations[0] === reservation && handoff.reservations.shift();
+      }
+    }
+    handoff.accepting = !1, this._waitPromptHandoff === handoff && (this._waitPromptHandoff = void 0);
+  }
+  /**
+   * Try to execute an extension command. Returns true if command was found and executed.
+   */
+  async _tryExecuteExtensionCommand(text) {
+    let spaceIndex = text.indexOf(" "), commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex), args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1), command = this._extensionRunner.getCommand(commandName);
+    if (!command)
+      return !1;
+    let ctx = this._extensionRunner.createCommandContext();
+    try {
+      return await command.handler(args, ctx), !0;
+    } catch (err) {
+      return this._extensionRunner.emitError({
+        extensionPath: `command:${commandName}`,
+        event: "command",
+        error: err instanceof Error ? err.message : String(err)
+      }), !0;
+    }
+  }
+  /**
+   * Expand skill commands (/skill:name args) to their full content.
+   * Returns the expanded text, or the original text if not a skill command or skill not found.
+   * Emits errors via extension runner if file read fails.
+   */
+  _expandSkillCommand(text) {
+    if (!text.startsWith("/skill:"))
+      return text;
+    let spaceIndex = text.indexOf(" "), skillName = spaceIndex === -1 ? text.slice(7) : text.slice(7, spaceIndex), args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim(), skill = this.resourceLoader.getSkills().skills.find((s) => s.name === skillName);
+    if (!skill)
+      return text;
+    try {
+      let content = readFileSync2(skill.filePath, "utf-8"), body = stripFrontmatter(content).trim(), skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">
+References are relative to ${skill.baseDir}.
+
+${body}
+</skill>`;
+      return args ? `${skillBlock}
+
+${args}` : skillBlock;
+    } catch (err) {
+      return this._extensionRunner.emitError({
+        extensionPath: skill.filePath,
+        event: "skill_expansion",
+        error: err instanceof Error ? err.message : String(err)
+      }), text;
+    }
+  }
+  /**
+   * Queue a steering message while the agent is running.
+   * Delivered after the current assistant turn finishes executing its tool calls,
+   * before the next LLM call.
+   * Expands skill commands and prompt templates. Errors on extension commands.
+   * @param images Optional image attachments to include with the message
+   * @throws Error if text is an extension command
+   */
+  async steer(text, images) {
+    this.assertCanStartWork(), text.startsWith("/") && this._throwIfExtensionCommand(text);
+    let expandedText = this._expandSkillCommand(text);
+    expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]), await this._queueSteer(expandedText, images);
+  }
+  /**
+   * Queue a follow-up message to be processed after the agent finishes.
+   * Delivered only when agent has no more tool calls or steering messages.
+   * Expands skill commands and prompt templates. Errors on extension commands.
+   * @param images Optional image attachments to include with the message
+   * @throws Error if text is an extension command
+   */
+  async followUp(text, images) {
+    this.assertCanStartWork(), text.startsWith("/") && this._throwIfExtensionCommand(text);
+    let expandedText = this._expandSkillCommand(text);
+    expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]), await this._queueFollowUp(expandedText, images);
+  }
+  /**
+   * Internal: Queue a steering message (already expanded, no extension command check).
+   */
+  async _queueSteer(text, images) {
+    this._steeringMessages.push(text), this._emitQueueUpdate();
+    let content = [{ type: "text", text }];
+    images && content.push(...images), this.agent.steer({
+      role: "user",
+      content,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Internal: Queue a follow-up message (already expanded, no extension command check).
+   */
+  async _queueFollowUp(text, images) {
+    this._followUpMessages.push(text), this._emitQueueUpdate();
+    let content = [{ type: "text", text }];
+    images && content.push(...images), this.agent.followUp({
+      role: "user",
+      content,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Throw an error if the text is an extension command.
+   */
+  _throwIfExtensionCommand(text) {
+    let spaceIndex = text.indexOf(" "), commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
+    if (this._extensionRunner.getCommand(commandName))
+      throw new Error(`Extension command "/${commandName}" cannot be queued. Use prompt() or execute the command when not streaming.`);
+  }
+  /**
+   * Send a custom message to the session. Creates a CustomMessageEntry.
+   *
+   * Handles three cases:
+   * - Streaming: queues message, processed when loop pulls from queue
+   * - Not streaming + triggerTurn: appends to state/session, starts new turn
+   * - Not streaming + no trigger: appends to state/session, no turn
+   *
+   * @param message Custom message with customType, content, display, details
+   * @param options.triggerTurn If true and not streaming, triggers a new LLM turn
+   * @param options.deliverAs Delivery mode: "steer", "followUp", or "nextTurn"
+   */
+  async sendCustomMessage(message, options) {
+    this.assertCanStartWork();
+    let appMessage = {
+      role: "custom",
+      customType: message.customType,
+      // Untyped extensions can pass null/missing content; normalize at ingestion.
+      content: message.content ?? [],
+      display: message.display,
+      details: message.details,
+      timestamp: Date.now()
+    };
+    options?.deliverAs === "nextTurn" ? this._pendingNextTurnMessages.push(appMessage) : this.isStreaming ? options?.deliverAs === "followUp" ? this.agent.followUp(appMessage) : this.agent.steer(appMessage) : options?.triggerTurn ? await this._runAgentPrompt(appMessage) : (this.agent.state.messages.push(appMessage), this.sessionManager.appendCustomMessageEntry(message.customType, message.content, message.display, message.details), this._emit({ type: "message_start", message: appMessage }), this._emit({ type: "message_end", message: appMessage }));
+  }
+  /**
+   * Send a user message to the agent. Always triggers a turn.
+   * When the agent is streaming, use deliverAs to specify how to queue the message.
+   *
+   * @param content User message content (string or content array)
+   * @param options.deliverAs Delivery mode when streaming: "steer" or "followUp"
+   */
+  async sendUserMessage(content, options) {
+    let text, images;
+    if (typeof content == "string")
+      text = content;
+    else {
+      let textParts = [];
+      images = [];
+      for (let part of content)
+        part.type === "text" ? textParts.push(part.text) : images.push(part);
+      text = textParts.join(`
+`), images.length === 0 && (images = void 0);
+    }
+    await this.prompt(text, {
+      expandPromptTemplates: !1,
+      streamingBehavior: options?.deliverAs,
+      images,
+      source: "extension"
+    });
+  }
+  /**
+   * Clear all queued messages and return them.
+   * Useful for restoring to editor when user aborts.
+   * @returns Object with steering and followUp arrays
+   */
+  clearQueue() {
+    let steering = [...this._steeringMessages], followUp = [...this._followUpMessages];
+    return this._steeringMessages = [], this._followUpMessages = [], this.agent.clearAllQueues(), this._emitQueueUpdate(), { steering, followUp };
+  }
+  /** Number of pending messages (includes both steering and follow-up) */
+  get pendingMessageCount() {
+    return this._steeringMessages.length + this._followUpMessages.length;
+  }
+  /** Get pending steering messages (read-only) */
+  getSteeringMessages() {
+    return this._steeringMessages;
+  }
+  /** Get pending follow-up messages (read-only) */
+  getFollowUpMessages() {
+    return this._followUpMessages;
+  }
+  get resourceLoader() {
+    return this._resourceLoader;
+  }
+  /**
+   * 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();
+  }
+  async waitForIdle() {
+    this.isIdle || await this._getIdleWaitPromise();
+  }
+  // =========================================================================
+  // Model Management
+  // =========================================================================
+  async _emitModelSelect(nextModel, previousModel, source) {
+    modelsAreEqual(previousModel, nextModel) || await this._extensionRunner.emit({
+      type: "model_select",
+      model: nextModel,
+      previousModel,
+      source
+    });
+  }
+  /**
+   * Set model directly.
+   * Validates that auth is configured, saves to session and settings.
+   * @throws Error if no auth is configured for the model
+   */
+  async setModel(model) {
+    if (!await this._modelRuntime.checkAuth(model.provider))
+      throw new Error(`No API key for ${model.provider}/${model.id}`);
+    let previousModel = this.model, thinkingLevel = this._getThinkingLevelForModelSwitch();
+    this.agent.state.model = model, this._syncOpenAIServiceTier(), this._refreshSystemPromptForCurrentModel(), this.sessionManager.appendModelChange(model.provider, model.id), this.settingsManager.setDefaultModelAndProvider(model.provider, model.id), this.setThinkingLevel(thinkingLevel), await this._emitModelSelect(model, previousModel, "set");
+  }
+  /**
+   * Cycle to next/previous model.
+   * Uses scoped models (from --models flag) if available, otherwise all available models.
+   * @param direction - "forward" (default) or "backward"
+   * @returns The new model info, or undefined if only one model available
+   */
+  async cycleModel(direction = "forward") {
+    return this._scopedModels.length > 0 ? this._cycleScopedModel(direction) : this._cycleAvailableModel(direction);
+  }
+  async _cycleScopedModel(direction) {
+    let scopedModels = (await Promise.all(this._scopedModels.map(async (scoped) => ({
+      scoped,
+      auth: await this._modelRuntime.checkAuth(scoped.model.provider)
+    })))).filter(({ auth }) => auth !== void 0).map(({ scoped }) => scoped);
+    if (scopedModels.length <= 1)
+      return;
+    let currentModel = this.model, currentIndex = scopedModels.findIndex((sm) => modelsAreEqual(sm.model, currentModel));
+    currentIndex === -1 && (currentIndex = 0);
+    let len = scopedModels.length, nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len, next = scopedModels[nextIndex], thinkingLevel = this._getThinkingLevelForModelSwitch(next.thinkingLevel);
+    return this.agent.state.model = next.model, this._syncOpenAIServiceTier(), this._refreshSystemPromptForCurrentModel(), this.sessionManager.appendModelChange(next.model.provider, next.model.id), this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id), this.setThinkingLevel(thinkingLevel), await this._emitModelSelect(next.model, currentModel, "cycle"), { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: !0 };
+  }
+  async _cycleAvailableModel(direction) {
+    let availableModels = await this._modelRuntime.getAvailable();
+    if (availableModels.length <= 1)
+      return;
+    let currentModel = this.model, currentIndex = availableModels.findIndex((m) => modelsAreEqual(m, currentModel));
+    currentIndex === -1 && (currentIndex = 0);
+    let len = availableModels.length, nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len, nextModel = availableModels[nextIndex], thinkingLevel = this._getThinkingLevelForModelSwitch();
+    return this.agent.state.model = nextModel, this._syncOpenAIServiceTier(), this._refreshSystemPromptForCurrentModel(), this.sessionManager.appendModelChange(nextModel.provider, nextModel.id), this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id), this.setThinkingLevel(thinkingLevel), await this._emitModelSelect(nextModel, currentModel, "cycle"), { model: nextModel, thinkingLevel: this.thinkingLevel, isScoped: !1 };
+  }
+  // =========================================================================
+  // Thinking Level Management
+  // =========================================================================
+  /**
+   * Set thinking level.
+   * Clamps to model capabilities based on available thinking levels.
+   * Saves to session and settings only if the level actually changes.
+   */
+  setThinkingLevel(level) {
+    let availableLevels = this.getAvailableThinkingLevels(), effectiveLevel = availableLevels.includes(level) ? level : this._clampThinkingLevel(level, availableLevels), previousLevel = this.agent.state.thinkingLevel, isChanging = effectiveLevel !== previousLevel;
+    this.agent.state.thinkingLevel = effectiveLevel, isChanging && (this.sessionManager.appendThinkingLevelChange(effectiveLevel), (this.supportsThinking() || effectiveLevel !== "off") && this.settingsManager.setDefaultThinkingLevel(effectiveLevel), this._emit({ type: "thinking_level_changed", level: effectiveLevel }), this._extensionRunner.emit({
+      type: "thinking_level_select",
+      level: effectiveLevel,
+      previousLevel
+    }));
+  }
+  /**
+   * Cycle to next thinking level.
+   * @returns New level, or undefined if model doesn't support thinking
+   */
+  cycleThinkingLevel() {
+    if (!this.supportsThinking())
+      return;
+    let levels = this.getAvailableThinkingLevels(), nextIndex = (levels.indexOf(this.thinkingLevel) + 1) % levels.length, nextLevel = levels[nextIndex];
+    return this.setThinkingLevel(nextLevel), nextLevel;
+  }
+  /**
+   * Get available thinking levels for current model.
+   * Uses the registry row when /refresh has a newer copy than the session object.
+   */
+  getAvailableThinkingLevels() {
+    let model = this.resolvedCatalogModel();
+    return model ? getSupportedThinkingLevels(model) : THINKING_LEVELS;
+  }
+  /** Replace the session model with the current registry copy after a catalog refresh. */
+  refreshModelFromRegistry() {
+    this._refreshCurrentModelFromRegistry();
+  }
+  resolvedCatalogModel() {
+    let current = this.model;
+    if (!current)
+      return;
+    let registry = this._modelRuntime.getModel(current.provider, current.id);
+    if (!registry || registry === current)
+      return current;
+    let thinkingLevelMap = current.thinkingLevelMap || registry.thinkingLevelMap ? { ...current.thinkingLevelMap, ...registry.thinkingLevelMap } : current.thinkingLevelMap;
+    return {
+      ...current,
+      ...registry,
+      compat: { ...current.compat, ...registry.compat },
+      thinkingLevelMap
+    };
+  }
+  /**
+   * Check if current model supports thinking/reasoning.
+   */
+  supportsThinking() {
+    return !!this.model?.reasoning;
+  }
+  _getThinkingLevelForModelSwitch(explicitLevel) {
+    return explicitLevel !== void 0 ? explicitLevel : this.supportsThinking() ? this.thinkingLevel : this.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+  }
+  _clampThinkingLevel(level, _availableLevels) {
+    return this.model ? clampThinkingLevel(this.model, level) : "off";
+  }
+  // =========================================================================
+  // Queue Mode Management
+  // =========================================================================
+  syncQueueModesFromSettings() {
+    this.agent.steeringMode = this.settingsManager.getSteeringMode(), this.agent.followUpMode = this.settingsManager.getFollowUpMode();
+  }
+  /**
+   * Set steering message mode.
+   * Saves to settings.
+   */
+  setSteeringMode(mode) {
+    this.agent.steeringMode = mode, this.settingsManager.setSteeringMode(mode);
+  }
+  /**
+   * Set follow-up message mode.
+   * Saves to settings.
+   */
+  setFollowUpMode(mode) {
+    this.agent.followUpMode = mode, this.settingsManager.setFollowUpMode(mode);
+  }
+  // =========================================================================
+  // Compaction
+  // =========================================================================
+  _latestCompactionResult() {
+    let pathEntries = this.sessionManager.getBranch(), lastEntry = pathEntries[pathEntries.length - 1];
+    if (lastEntry?.type === "compaction")
+      return {
+        summary: lastEntry.summary,
+        firstKeptEntryId: lastEntry.firstKeptEntryId,
+        tokensBefore: lastEntry.tokensBefore,
+        estimatedTokensAfter: estimateMessagesTokens(this.sessionManager.buildSessionContext().messages),
+        details: lastEntry.details
+      };
+  }
+  /**
+   * Manually compact the session context.
+   * Aborts current agent operation first.
+   * @param customInstructions Optional instructions for the compaction summary
+   */
+  async compact(customInstructions) {
+    let existing = this._latestCompactionResult();
+    if (existing)
+      return existing;
+    if (this._manualCompactionPromise)
+      return this._manualCompactionPromise;
+    let promise = this._compact(customInstructions);
+    this._manualCompactionPromise = promise;
+    try {
+      return await promise;
+    } finally {
+      this._manualCompactionPromise === promise && (this._manualCompactionPromise = void 0);
+    }
+  }
+  async _compact(customInstructions) {
+    this._disconnectFromAgent(), await this.abort();
+    let existing = this._latestCompactionResult();
+    if (existing)
+      return this._reconnectToAgent(), existing;
+    this._compactionAbortController = new AbortController(), this._emit({ type: "compaction_start", reason: "manual" });
+    try {
+      if (!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)
+        throw pathEntries[pathEntries.length - 1]?.type === "compaction" ? new Error("Already compacted") : new Error("Nothing to compact (session too small)");
+      let extensionCompaction, fromExtension = !1;
+      if (this._extensionRunner.hasHandlers("session_before_compact")) {
+        let result = await this._extensionRunner.emit({
+          type: "session_before_compact",
+          preparation,
+          branchEntries: pathEntries,
+          customInstructions,
+          reason: "manual",
+          willRetry: !1,
+          signal: this._compactionAbortController.signal
+        });
+        if (result?.cancel)
+          throw new Error("Compaction cancelled");
+        result?.compaction && (extensionCompaction = result.compaction, fromExtension = !0);
+      }
+      let summary, firstKeptEntryId, tokensBefore, details;
+      if (extensionCompaction)
+        summary = extensionCompaction.summary, firstKeptEntryId = extensionCompaction.firstKeptEntryId, tokensBefore = extensionCompaction.tokensBefore, details = extensionCompaction.details;
+      else {
+        let result = await compact(preparation, this.model, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel, this.agent.streamFn, env);
+        summary = result.summary, firstKeptEntryId = result.firstKeptEntryId, tokensBefore = result.tokensBefore, details = result.details;
+      }
+      if (this._compactionAbortController.signal.aborted)
+        throw new Error("Compaction cancelled");
+      this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
+      let newEntries = this.sessionManager.getEntries(), sessionContext = this.sessionManager.buildSessionContext();
+      this.agent.state.messages = sessionContext.messages;
+      let estimatedTokensAfter = estimateMessagesTokens(sessionContext.messages), savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
+      this._extensionRunner && savedCompactionEntry && await this._extensionRunner.emit({
+        type: "session_compact",
+        compactionEntry: savedCompactionEntry,
+        fromExtension,
+        reason: "manual",
+        willRetry: !1
+      });
+      let compactionResult = {
+        summary,
+        firstKeptEntryId,
+        tokensBefore,
+        estimatedTokensAfter,
+        details
+      };
+      return this._emit({
+        type: "compaction_end",
+        reason: "manual",
+        result: compactionResult,
+        aborted: !1,
+        willRetry: !1
+      }), compactionResult;
+    } catch (error) {
+      let message = error instanceof Error ? error.message : String(error), aborted = message === "Compaction cancelled" || error instanceof Error && error.name === "AbortError";
+      throw this._emit({
+        type: "compaction_end",
+        reason: "manual",
+        result: void 0,
+        aborted,
+        willRetry: !1,
+        errorMessage: aborted ? void 0 : `Compaction failed: ${message}`
+      }), error;
+    } finally {
+      this._compactionAbortController = void 0, this._reconnectToAgent();
+    }
+  }
+  /**
+   * Cancel in-progress compaction (manual or auto).
+   */
+  abortCompaction() {
+    this._compactionAbortController?.abort(), this._autoCompactionAbortController?.abort();
+  }
+  /**
+   * Cancel in-progress branch summarization.
+   */
+  abortBranchSummary() {
+    this._branchSummaryAbortController?.abort();
+  }
+  /**
+   * Check if compaction is needed and run it.
+   * Called after agent_end and before prompt submission.
+   *
+   * Two cases:
+   * 1. Overflow: LLM returned context overflow error, remove error message from agent state, compact, auto-retry
+   * 2. Threshold: Context over threshold, compact, NO auto-retry (user continues manually)
+   *
+   * @param assistantMessage The assistant message to check
+   * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
+   */
+  async _checkCompaction(assistantMessage, skipAbortedCheck = !0) {
+    let settings = this.settingsManager.getCompactionSettings();
+    if (!settings.enabled || skipAbortedCheck && assistantMessage.stopReason === "aborted")
+      return !1;
+    let contextWindow = this.model?.contextWindow ?? 0, sameModel = this.model && assistantMessage.provider === this.model.provider && assistantMessage.model === this.model.id, compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
+    if (compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime())
+      return !1;
+    if (sameModel && isContextOverflow(assistantMessage, contextWindow)) {
+      let willRetry = assistantMessage.stopReason !== "stop";
+      if (!willRetry)
+        return await this._runAutoCompaction("overflow", !1);
+      if (this._overflowRecoveryAttempted)
+        return this._emit({
+          type: "compaction_end",
+          reason: "overflow",
+          result: void 0,
+          aborted: !1,
+          willRetry: !1,
+          errorMessage: "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model."
+        }), !1;
+      this._overflowRecoveryAttempted = !0;
+      let messages = this.agent.state.messages;
+      return messages.length > 0 && messages[messages.length - 1].role === "assistant" && (this.agent.state.messages = messages.slice(0, -1)), await this._runAutoCompaction("overflow", willRetry);
+    }
+    let contextTokens, directContextTokens = assistantMessage.usage ? calculateContextTokens(assistantMessage.usage) : 0;
+    if (assistantMessage.stopReason === "error" || directContextTokens === 0) {
+      let messages = this.agent.state.messages, estimate = estimateContextTokens(messages);
+      if (estimate.lastUsageIndex === null)
+        return !1;
+      let usageMsg = messages[estimate.lastUsageIndex];
+      if (compactionEntry && usageMsg.role === "assistant" && usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime())
+        return !1;
+      contextTokens = estimate.tokens;
+    } else
+      contextTokens = directContextTokens;
+    return shouldCompact(contextTokens, contextWindow, settings) ? await this._runAutoCompaction("threshold", !1) : !1;
+  }
+  /**
+   * Internal: Run auto-compaction with events.
+   */
+  async _runAutoCompaction(reason, willRetry) {
+    if (!this.model || this._compactionAbortController || this._autoCompactionAbortController)
+      return !1;
+    let settings = this.settingsManager.getCompactionSettings(), started = !1;
+    try {
+      let apiKey, headers, env;
+      if (this.agent.streamFn === streamSimple) {
+        let authResult = await this._modelRuntime.getAuth(this.model);
+        if (!authResult?.auth.apiKey)
+          return !1;
+        apiKey = authResult.auth.apiKey, headers = withoutDeletedHeaders(authResult.auth.headers), env = authResult.env;
+      } else
+        ({ apiKey, headers, env } = await this._getSummarizationRequestAuth(this.model));
+      let pathEntries = this.sessionManager.getBranch(), preparation = prepareCompaction(pathEntries, settings);
+      if (!preparation)
+        return !1;
+      this._emit({ type: "compaction_start", reason }), this._autoCompactionAbortController = new AbortController(), started = !0;
+      let extensionCompaction, fromExtension = !1;
+      if (this._extensionRunner.hasHandlers("session_before_compact")) {
+        let extensionResult = await this._extensionRunner.emit({
+          type: "session_before_compact",
+          preparation,
+          branchEntries: pathEntries,
+          customInstructions: void 0,
+          reason,
+          willRetry,
+          signal: this._autoCompactionAbortController.signal
+        });
+        if (extensionResult?.cancel)
+          return this._emit({
+            type: "compaction_end",
+            reason,
+            result: void 0,
+            aborted: !0,
+            willRetry: !1
+          }), !1;
+        extensionResult?.compaction && (extensionCompaction = extensionResult.compaction, fromExtension = !0);
+      }
+      let summary, firstKeptEntryId, tokensBefore, details;
+      if (extensionCompaction)
+        summary = extensionCompaction.summary, firstKeptEntryId = extensionCompaction.firstKeptEntryId, tokensBefore = extensionCompaction.tokensBefore, details = extensionCompaction.details;
+      else {
+        let compactResult = await compact(preparation, this.model, apiKey, headers, void 0, this._autoCompactionAbortController.signal, this.thinkingLevel, this.agent.streamFn, env);
+        summary = compactResult.summary, firstKeptEntryId = compactResult.firstKeptEntryId, tokensBefore = compactResult.tokensBefore, details = compactResult.details;
+      }
+      if (this._autoCompactionAbortController.signal.aborted)
+        return this._emit({
+          type: "compaction_end",
+          reason,
+          result: void 0,
+          aborted: !0,
+          willRetry: !1
+        }), !1;
+      this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
+      let newEntries = this.sessionManager.getEntries(), sessionContext = this.sessionManager.buildSessionContext();
+      this.agent.state.messages = sessionContext.messages;
+      let estimatedTokensAfter = estimateMessagesTokens(sessionContext.messages), savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
+      this._extensionRunner && savedCompactionEntry && await this._extensionRunner.emit({
+        type: "session_compact",
+        compactionEntry: savedCompactionEntry,
+        fromExtension,
+        reason,
+        willRetry
+      });
+      let result = {
+        summary,
+        firstKeptEntryId,
+        tokensBefore,
+        estimatedTokensAfter,
+        details
+      };
+      if (this._emit({ type: "compaction_end", reason, result, aborted: !1, willRetry }), willRetry) {
+        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();
+    } catch (error) {
+      let errorMessage = error instanceof Error ? error.message : "compaction failed";
+      return started && this._emit({
+        type: "compaction_end",
+        reason,
+        result: void 0,
+        aborted: !1,
+        willRetry: !1,
+        errorMessage: reason === "overflow" ? `Context overflow recovery failed: ${errorMessage}` : `Auto-compaction failed: ${errorMessage}`
+      }), !1;
+    } finally {
+      this._autoCompactionAbortController = void 0;
+    }
+  }
+  /**
+   * Toggle auto-compaction setting.
+   */
+  setAutoCompactionEnabled(enabled) {
+    this.settingsManager.setCompactionEnabled(enabled);
+  }
+  /** Whether auto-compaction is enabled */
+  get autoCompactionEnabled() {
+    return this.settingsManager.getCompactionEnabled();
+  }
+  async bindExtensions(bindings) {
+    bindings.uiContext !== void 0 && (this._extensionUIContext = bindings.uiContext), bindings.mode !== void 0 && (this._extensionMode = bindings.mode), bindings.commandContextActions !== void 0 && (this._extensionCommandContextActions = bindings.commandContextActions), bindings.abortHandler !== void 0 && (this._extensionAbortHandler = bindings.abortHandler), bindings.shutdownHandler !== void 0 && (this._extensionShutdownHandler = bindings.shutdownHandler), bindings.onError !== void 0 && (this._extensionErrorListener = bindings.onError), this._applyExtensionBindings(this._extensionRunner), await this._extensionRunner.emit(this._sessionStartEvent), await this.extendResourcesFromExtensions(this._sessionStartEvent.reason === "reload" ? "reload" : "startup");
+  }
+  /**
+   * Load extra inline factories into the current runner after first paint.
+   * New factories receive the current session_start event so late tools/commands exist
+   * before the first prompt. Already-bound extensions are not restarted.
+   */
+  async attachInlineExtensions(factories) {
+    if (factories.length === 0)
+      return;
+    let attach = this._resourceLoader.attachInlineExtensions;
+    if (!attach)
+      throw new Error("Resource loader does not support attaching inline extensions");
+    let alreadyBound = new Set(this._extensionRunner.getExtensionPaths()), fresh = (await attach.call(this._resourceLoader, factories)).extensions.filter((extension) => !alreadyBound.has(extension.path));
+    fresh.length !== 0 && (this._extensionRunner.appendExtensions(fresh), this._applyExtensionBindings(this._extensionRunner), this.applyDeferredExtensionFlags(fresh), await this.emitSessionStartForExtensions(fresh), await this.extendResourcesFromExtensions(this._sessionStartEvent.reason === "reload" ? "reload" : "startup"), this._refreshToolRegistry({
+      activeToolNames: this.getActiveToolNames(),
+      includeAllExtensionTools: !0
+    }));
+  }
+  applyDeferredExtensionFlags(extensions) {
+    let runtime = this._resourceLoader.getExtensions().runtime, argv = process.argv;
+    for (let ext of extensions)
+      for (let [name, flag] of ext.flags) {
+        let prefix = `--${name}`, eqArg = argv.find((arg) => arg.startsWith(`${prefix}=`));
+        if (eqArg) {
+          runtime.flagValues.set(name, eqArg.slice(prefix.length + 1));
+          continue;
+        }
+        let idx = argv.indexOf(prefix);
+        if (idx < 0)
+          continue;
+        let next = argv[idx + 1];
+        flag.type === "string" && next && !next.startsWith("-") ? runtime.flagValues.set(name, next) : runtime.flagValues.set(name, !0);
+      }
+  }
+  async emitSessionStartForExtensions(extensions) {
+    let ctx = this._extensionRunner.createContext();
+    for (let ext of extensions) {
+      let handlers = ext.handlers.get("session_start");
+      if (handlers)
+        for (let handler of handlers)
+          try {
+            await measureStartup(`${ext.path} session_start`, () => handler(this._sessionStartEvent, ctx), "lifecycle");
+          } catch (err) {
+            let message = err instanceof Error ? err.message : String(err), stack = err instanceof Error ? err.stack : void 0;
+            this._extensionRunner.emitError({
+              extensionPath: ext.path,
+              event: "session_start",
+              error: message,
+              stack
+            });
+          }
+    }
+  }
+  async extendResourcesFromExtensions(reason) {
+    if (!this._extensionRunner.hasHandlers("resources_discover"))
+      return;
+    let { skillPaths, promptPaths, themePaths } = await this._extensionRunner.emitResourcesDiscover(this._cwd, reason);
+    if (skillPaths.length === 0 && promptPaths.length === 0 && themePaths.length === 0)
+      return;
+    let extensionPaths = {
+      skillPaths: this.buildExtensionResourcePaths(skillPaths),
+      promptPaths: this.buildExtensionResourcePaths(promptPaths),
+      themePaths: this.buildExtensionResourcePaths(themePaths)
+    };
+    this._resourceLoader.extendResources(extensionPaths), this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames()), this.agent.state.systemPrompt = this._withSystemPromptAppend(this._baseSystemPrompt);
+  }
+  buildExtensionResourcePaths(entries) {
+    return entries.map((entry) => {
+      let source = this.getExtensionSourceLabel(entry.extensionPath), baseDir = entry.extensionPath.startsWith("<") ? void 0 : dirname2(entry.extensionPath);
+      return {
+        path: entry.path,
+        metadata: {
+          source,
+          scope: "temporary",
+          origin: "top-level",
+          baseDir
+        }
+      };
+    });
+  }
+  getExtensionSourceLabel(extensionPath) {
+    return extensionPath.startsWith("<") ? `extension:${extensionPath.replace(/[<>]/g, "")}` : `extension:${basename(extensionPath).replace(/\.(ts|js)$/, "")}`;
+  }
+  _applyExtensionBindings(runner) {
+    runner.setUIContext(this._extensionUIContext, this._extensionMode), runner.bindCommandContext(this._extensionCommandContextActions), this._extensionErrorUnsubscriber?.(), this._extensionErrorUnsubscriber = this._extensionErrorListener ? runner.onError(this._extensionErrorListener) : void 0;
+  }
+  _refreshCurrentModelFromRegistry() {
+    let currentModel = this.model;
+    if (!currentModel)
+      return;
+    let refreshedModel = this._modelRuntime.getModel(currentModel.provider, currentModel.id);
+    !refreshedModel || refreshedModel === currentModel || (this.agent.state.model = refreshedModel, this._syncOpenAIServiceTier());
+  }
+  _bindExtensionCore(runner) {
+    let getCommands = () => {
+      let extensionCommands = runner.getRegisteredCommands().map((command) => ({
+        name: command.invocationName,
+        description: command.description,
+        source: "extension",
+        sourceInfo: command.sourceInfo
+      })), templates = this.promptTemplates.map((template) => ({
+        name: template.name,
+        description: template.description,
+        source: "prompt",
+        sourceInfo: template.sourceInfo
+      })), skills = this._resourceLoader.getSkills().skills.map((skill) => ({
+        name: `skill:${skill.name}`,
+        description: skill.description,
+        source: "skill",
+        sourceInfo: skill.sourceInfo
+      }));
+      return [...extensionCommands, ...templates, ...skills];
+    };
+    runner.bindCore({
+      sendMessage: (message, options) => {
+        this.sendCustomMessage(message, options).catch((err) => {
+          runner.emitError({
+            extensionPath: "<runtime>",
+            event: "send_message",
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      },
+      sendUserMessage: (content, options) => {
+        this.sendUserMessage(content, options).catch((err) => {
+          runner.emitError({
+            extensionPath: "<runtime>",
+            event: "send_user_message",
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      },
+      appendEntry: (customType, data) => {
+        let entryId = this.sessionManager.appendCustomEntry(customType, data), entry = this.sessionManager.getEntry(entryId);
+        entry && this._emit({ type: "entry_appended", entry });
+      },
+      setSessionName: (name) => {
+        this.setSessionName(name);
+      },
+      getSessionName: () => this.sessionManager.getSessionName(),
+      setLabel: (entryId, label) => {
+        this.sessionManager.appendLabelChange(entryId, label);
+      },
+      getActiveTools: () => this.getActiveToolNames(),
+      getAllTools: () => this.getAllTools(),
+      setActiveTools: (toolNames) => this.setActiveToolsByName(toolNames),
+      refreshTools: () => this._refreshToolRegistry(),
+      getCommands,
+      setModel: async (model) => this._modelRuntime.hasConfiguredAuth(model.provider) ? (await this.setModel(model), !0) : !1,
+      getThinkingLevel: () => this.thinkingLevel,
+      setThinkingLevel: (level) => this.setThinkingLevel(level)
+    }, {
+      getModel: () => this.resolvedCatalogModel(),
+      isIdle: () => this.isIdle,
+      isProjectTrusted: () => this.settingsManager.isProjectTrusted(),
+      getSignal: () => this.agent.signal,
+      abort: () => {
+        if (this._extensionAbortHandler) {
+          this._extensionAbortHandler();
+          return;
+        }
+        this.abort();
+      },
+      hasPendingMessages: () => this.pendingMessageCount > 0 || this.agent.hasQueuedMessages(),
+      shutdown: () => {
+        this._extensionShutdownHandler?.();
+      },
+      getContextUsage: () => this.getContextUsage(),
+      compact: (options) => {
+        (async () => {
+          try {
+            let result = await this.compact(options?.customInstructions);
+            options?.onComplete?.(result);
+          } catch (error) {
+            let err = error instanceof Error ? error : new Error(String(error));
+            options?.onError?.(err);
+          }
+        })();
+      },
+      getSystemPrompt: () => this.systemPrompt,
+      getSystemPromptOptions: () => this._baseSystemPromptOptions
+    }, {
+      registerProvider: (name, config) => {
+        this._modelRuntime.registerProvider(name, config), this._refreshCurrentModelFromRegistry();
+      },
+      unregisterProvider: (name) => {
+        this._modelRuntime.unregisterProvider(name), this._refreshCurrentModelFromRegistry();
+      }
+    });
+  }
+  _refreshToolRegistry(options) {
+    let previousRegistryNames = new Set(this._toolRegistry.keys()), previousActiveToolNames = this.getActiveToolNames(), allowedToolNames = this._allowedToolNames, excludedToolNames = this._excludedToolNames, isAllowedTool = (name) => (!allowedToolNames || allowedToolNames.has(name)) && !excludedToolNames?.has(name) && (this.settingsManager.getMemoryEnabled() || !MEMORY_TOOL_NAMES.has(name)) && (this.settingsManager.getTodosEnabled() || !TODO_TOOL_NAMES.has(name)) && (name !== "browser" || this.settingsManager.getBrowserEnabled()), allCustomTools = [
+      ...this._extensionRunner.getAllRegisteredTools(),
+      ...this._customTools.map((definition) => ({
+        definition,
+        sourceInfo: createSyntheticSourceInfo(`<sdk:${definition.name}>`, { source: "sdk" })
+      }))
+    ].filter((tool) => isAllowedTool(tool.definition.name)), definitionRegistry = new Map(Array.from(this._baseToolDefinitions.entries()).filter(([name]) => isAllowedTool(name)).map(([name, definition]) => [
+      name,
+      {
+        definition,
+        sourceInfo: createSyntheticSourceInfo(`<builtin:${name}>`, { source: "builtin" })
+      }
+    ]));
+    for (let tool of allCustomTools)
+      definitionRegistry.set(tool.definition.name, {
+        definition: tool.definition,
+        sourceInfo: tool.sourceInfo
+      });
+    this._toolDefinitions = definitionRegistry, this._toolPromptSnippets = new Map(Array.from(definitionRegistry.values()).map(({ definition }) => {
+      let snippet = this._normalizePromptSnippet(definition.promptSnippet);
+      return snippet ? [definition.name, snippet] : void 0;
+    }).filter((entry) => entry !== void 0)), this._toolPromptGuidelines = new Map(Array.from(definitionRegistry.values()).map(({ definition }) => {
+      let guidelines = this._normalizePromptGuidelines(definition.promptGuidelines);
+      return guidelines.length > 0 ? [definition.name, guidelines] : void 0;
+    }).filter((entry) => entry !== void 0));
+    let runner = this._extensionRunner, wrappedExtensionTools = wrapRegisteredTools(allCustomTools, runner), wrappedBuiltInTools = wrapRegisteredTools(Array.from(this._baseToolDefinitions.values()).filter((definition) => isAllowedTool(definition.name)).map((definition) => ({
+      definition,
+      sourceInfo: createSyntheticSourceInfo(`<builtin:${definition.name}>`, { source: "builtin" })
+    })), runner), toolRegistry = new Map(wrappedBuiltInTools.map((tool) => [tool.name, tool]));
+    for (let tool of wrappedExtensionTools)
+      toolRegistry.set(tool.name, tool);
+    this._toolRegistry = toolRegistry;
+    let nextActiveToolNames = (options?.activeToolNames ? [...options.activeToolNames] : [...previousActiveToolNames]).filter((name) => isAllowedTool(name));
+    if (allowedToolNames)
+      for (let toolName of this._toolRegistry.keys())
+        allowedToolNames.has(toolName) && nextActiveToolNames.push(toolName);
+    else if (options?.includeAllExtensionTools)
+      for (let tool of wrappedExtensionTools)
+        nextActiveToolNames.push(tool.name);
+    else if (!options?.activeToolNames)
+      for (let toolName of this._toolRegistry.keys())
+        previousRegistryNames.has(toolName) || nextActiveToolNames.push(toolName);
+    this.setActiveToolsByName([...new Set(nextActiveToolNames)]);
+  }
+  _buildRuntime(options) {
+    let autoResizeImages = this.settingsManager.getImageAutoResize(), shellCommandPrefix = this.settingsManager.getShellCommandPrefix(), shellPath = this.settingsManager.getShellPath(), baseToolDefinitions = this._baseToolsOverride ? Object.fromEntries(Object.entries(this._baseToolsOverride).map(([name, tool]) => [
+      name,
+      createToolDefinitionFromAgentTool(tool)
+    ])) : createAllToolDefinitions(this._cwd, {
+      read: { autoResizeImages },
+      bash: { commandPrefix: shellCommandPrefix, shellPath }
+    });
+    this._baseToolDefinitions = new Map(Object.entries(baseToolDefinitions).map(([name, tool]) => [name, tool]));
+    let extensionsResult = this._resourceLoader.getExtensions();
+    if (options.flagValues)
+      for (let [name, value] of options.flagValues)
+        extensionsResult.runtime.flagValues.set(name, value);
+    this._extensionRunner = new ExtensionRunner(extensionsResult.extensions, extensionsResult.runtime, this._cwd, this.sessionManager, new ModelRegistry(this._modelRuntime)), this._extensionRunnerRef && (this._extensionRunnerRef.current = this._extensionRunner), this._bindExtensionCore(this._extensionRunner), this._applyExtensionBindings(this._extensionRunner);
+    let defaultActiveToolNames = this._baseToolsOverride ? Object.keys(this._baseToolsOverride) : ["read", "bash", "edit", "write"], baseActiveToolNames = options.activeToolNames ?? defaultActiveToolNames;
+    this._refreshToolRegistry({
+      activeToolNames: baseActiveToolNames,
+      includeAllExtensionTools: options.includeAllExtensionTools
+    });
+  }
+  async reload(options) {
+    this._invalidateWaitPromptHandoffs("Extensions reloaded before the pending prompt could run.");
+    let previousFlagValues = this._extensionRunner.getFlagValues();
+    await emitSessionShutdownEvent(this._extensionRunner, { type: "session_shutdown", reason: "reload" }), await this.settingsManager.reload(), this.syncQueueModesFromSettings(), resetApiProviders(), await this._resourceLoader.reload(), this._buildRuntime({
+      activeToolNames: this.getActiveToolNames(),
+      flagValues: previousFlagValues,
+      includeAllExtensionTools: !0
+    }), (this._extensionUIContext || this._extensionCommandContextActions || this._extensionShutdownHandler || this._extensionErrorListener) && (await options?.beforeSessionStart?.(), await this._extensionRunner.emit({ type: "session_start", reason: "reload" }), await this.extendResourcesFromExtensions("reload"));
+  }
+  // =========================================================================
+  // Auto-Retry
+  // =========================================================================
+  /**
+   * Check if an error is retryable (overloaded, rate limit, server errors).
+   * Context overflow errors are NOT retryable (handled by compaction instead).
+   */
+  _isRetryableError(message) {
+    return isContextOverflow(message, this.model?.contextWindow ?? 0) ? !1 : isRetryableAssistantError(message);
+  }
+  /**
+   * Prepare a retryable error for continuation with exponential backoff.
+   * @returns true if the caller should continue the agent, false otherwise
+   */
+  async _prepareRetry(message) {
+    let settings = this.settingsManager.getRetrySettings();
+    if (!settings.enabled)
+      return !1;
+    if (this._retryAttempt++, this._retryAttempt > settings.maxRetries)
+      return this._retryAttempt--, !1;
+    let delayMs = settings.baseDelayMs * 2 ** (this._retryAttempt - 1);
+    this._emit({
+      type: "auto_retry_start",
+      attempt: this._retryAttempt,
+      maxAttempts: settings.maxRetries,
+      delayMs,
+      errorMessage: message.errorMessage || "Unknown error"
+    });
+    let messages = this.agent.state.messages;
+    messages.length > 0 && messages[messages.length - 1].role === "assistant" && (this.agent.state.messages = messages.slice(0, -1)), this._retryAbortController = new AbortController();
+    try {
+      await sleep(delayMs, this._retryAbortController.signal);
+    } catch {
+      let attempt = this._retryAttempt;
+      return this._retryAttempt = 0, this._emit({
+        type: "auto_retry_end",
+        success: !1,
+        attempt,
+        finalError: "Retry cancelled"
+      }), !1;
+    } finally {
+      this._retryAbortController = void 0;
+    }
+    return !0;
+  }
+  /**
+   * Cancel in-progress retry.
+   */
+  abortRetry() {
+    this._retryAbortController?.abort();
+  }
+  /** lunr: errors that mark a subscription key dead — rotate without same-key backoff. */
+  _isRotationError(message) {
+    let errorMessage = message.errorMessage ?? "";
+    return isUsageLimitError(errorMessage) || isAuthInvalidError(errorMessage);
+  }
+  /**
+   * lunr: multi-subscription rotation. When a run is about to fail final, switch
+   * the provider to the next pooled key (mirrored into the credential store by
+   * SubscriptionManager) and continue immediately — no backoff sleep. Returns
+   * false when rotation is impossible, leaving the error as the final message.
+   */
+  async _tryRotateSubscriptionKey(message) {
+    let model = this.model;
+    if (!model)
+      return !1;
+    let providerId = model.provider;
+    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);
+    if (!entry)
+      return !1;
+    this._retryAttempt > 0 && this._emit({ type: "auto_retry_end", success: !0, attempt: this._retryAttempt }), this._retryAttempt = 0;
+    let messages = this.agent.state.messages;
+    return messages.length > 0 && messages[messages.length - 1].role === "assistant" && (this.agent.state.messages = messages.slice(0, -1)), this._emit({
+      type: "subscription_rotation",
+      providerId,
+      keyName: entry.name,
+      errorMessage
+    }), !0;
+  }
+  /** Whether auto-retry is currently in progress */
+  get isRetrying() {
+    return this._retryAbortController !== void 0;
+  }
+  /** Whether auto-retry is enabled */
+  get autoRetryEnabled() {
+    return this.settingsManager.getRetryEnabled();
+  }
+  /**
+   * Toggle auto-retry setting.
+   */
+  setAutoRetryEnabled(enabled) {
+    this.settingsManager.setRetryEnabled(enabled);
+  }
+  // =========================================================================
+  // Bash Execution
+  // =========================================================================
+  /**
+   * Execute a bash command.
+   * Adds result to agent context and session.
+   * @param command The bash command to execute
+   * @param onChunk Optional streaming callback for output
+   * @param options.excludeFromContext If true, command output won't be sent to LLM (!! prefix)
+   * @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;
+    try {
+      let result = await executeBashWithOperations(resolvedCommand, this.sessionManager.getCwd(), options?.operations ?? createLocalBashOperations({ shellPath, sessionId: this.sessionId }), {
+        onChunk,
+        signal: this._bashAbortController.signal
+      });
+      return this.recordBashResult(command, result, options), result;
+    } finally {
+      this._bashAbortController = void 0;
+    }
+  }
+  /**
+   * Record a bash execution result in session history.
+   * Used by executeBash and by extensions that handle bash execution themselves.
+   */
+  recordBashResult(command, result, options) {
+    let bashMessage = {
+      role: "bashExecution",
+      command,
+      output: result.output,
+      exitCode: result.exitCode,
+      cancelled: result.cancelled,
+      truncated: result.truncated,
+      fullOutputPath: result.fullOutputPath,
+      timestamp: Date.now(),
+      excludeFromContext: options?.excludeFromContext
+    };
+    this.isStreaming ? this._pendingBashMessages.push(bashMessage) : (this.agent.state.messages.push(bashMessage), this.sessionManager.appendMessage(bashMessage));
+  }
+  /**
+   * Cancel running bash command.
+   */
+  abortBash() {
+    this._bashAbortController?.abort();
+  }
+  /** Whether a bash command is currently running */
+  get isBashRunning() {
+    return this._bashAbortController !== void 0;
+  }
+  /** Whether there are pending bash messages waiting to be flushed */
+  get hasPendingBashMessages() {
+    return this._pendingBashMessages.length > 0;
+  }
+  /**
+   * Flush pending bash messages to agent state and session.
+   * Called after agent turn completes to maintain proper message ordering.
+   */
+  _flushPendingBashMessages() {
+    if (this._pendingBashMessages.length !== 0) {
+      for (let bashMessage of this._pendingBashMessages)
+        this.agent.state.messages.push(bashMessage), this.sessionManager.appendMessage(bashMessage);
+      this._pendingBashMessages = [];
+    }
+  }
+  // =========================================================================
+  // Session Management
+  // =========================================================================
+  /**
+   * Set a display name for the current session.
+   */
+  setSessionName(name) {
+    this.sessionManager.appendSessionInfo(name);
+    let event = { type: "session_info_changed", name: this.sessionManager.getSessionName() };
+    this._emit(event), this._extensionRunner.emit(event);
+  }
+  // =========================================================================
+  // Tree Navigation
+  // =========================================================================
+  /**
+   * Navigate to a different node in the session tree.
+   * Unlike fork() which creates a new session file, this stays in the same file.
+   *
+   * @param targetId The entry ID to navigate to
+   * @param options.summarize Whether user wants to summarize abandoned branch
+   * @param options.customInstructions Custom instructions for summarizer
+   * @param options.replaceInstructions If true, customInstructions replaces the default prompt
+   * @param options.label Label to attach to the branch summary entry
+   * @returns Result with editorText (if user message) and cancelled status
+   */
+  async navigateTree(targetId, options = {}) {
+    let oldLeafId = this.sessionManager.getLeafId();
+    if (targetId === oldLeafId)
+      return { cancelled: !1 };
+    if (options.summarize && !this.model)
+      throw new Error("No model available for summarization");
+    let targetEntry = this.sessionManager.getEntry(targetId);
+    if (!targetEntry)
+      throw new Error(`Entry ${targetId} not found`);
+    let { entries: entriesToSummarize, commonAncestorId } = collectEntriesForBranchSummary(this.sessionManager, oldLeafId, targetId), customInstructions = options.customInstructions, replaceInstructions = options.replaceInstructions, label = options.label, preparation = {
+      targetId,
+      oldLeafId,
+      commonAncestorId,
+      entriesToSummarize,
+      userWantsSummary: options.summarize ?? !1,
+      customInstructions,
+      replaceInstructions,
+      label
+    };
+    this._branchSummaryAbortController = new AbortController();
+    try {
+      let extensionSummary, fromExtension = !1;
+      if (this._extensionRunner.hasHandlers("session_before_tree")) {
+        let result = await this._extensionRunner.emit({
+          type: "session_before_tree",
+          preparation,
+          signal: this._branchSummaryAbortController.signal
+        });
+        if (result?.cancel)
+          return { cancelled: !0 };
+        result?.summary && options.summarize && (extensionSummary = result.summary, fromExtension = !0), result?.customInstructions !== void 0 && (customInstructions = result.customInstructions), result?.replaceInstructions !== void 0 && (replaceInstructions = result.replaceInstructions), result?.label !== void 0 && (label = result.label);
+      }
+      let summaryText, summaryDetails;
+      if (options.summarize && entriesToSummarize.length > 0 && !extensionSummary) {
+        let model = this.model, { apiKey, headers, env } = await this._getSummarizationRequestAuth(model), branchSummarySettings = this.settingsManager.getBranchSummarySettings(), result = await generateBranchSummary(entriesToSummarize, {
+          model,
+          apiKey,
+          headers,
+          env,
+          signal: this._branchSummaryAbortController.signal,
+          customInstructions,
+          replaceInstructions,
+          reserveTokens: branchSummarySettings.reserveTokens,
+          streamFn: this.agent.streamFn
+        });
+        if (result.aborted)
+          return { cancelled: !0, aborted: !0 };
+        if (result.error)
+          throw new Error(result.error);
+        summaryText = result.summary, summaryDetails = {
+          readFiles: result.readFiles || [],
+          modifiedFiles: result.modifiedFiles || []
+        };
+      } else extensionSummary && (summaryText = extensionSummary.summary, summaryDetails = extensionSummary.details);
+      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;
+      if (summaryText) {
+        let summaryId = this.sessionManager.branchWithSummary(newLeafId, summaryText, summaryDetails, fromExtension);
+        summaryEntry = this.sessionManager.getEntry(summaryId), label && this.sessionManager.appendLabelChange(summaryId, label);
+      } else newLeafId === null ? this.sessionManager.resetLeaf() : this.sessionManager.branch(newLeafId);
+      label && !summaryText && this.sessionManager.appendLabelChange(targetId, label);
+      let sessionContext = this.sessionManager.buildSessionContext();
+      return this.agent.state.messages = sessionContext.messages, await this._extensionRunner.emit({
+        type: "session_tree",
+        newLeafId: this.sessionManager.getLeafId(),
+        oldLeafId,
+        summaryEntry,
+        fromExtension: summaryText ? fromExtension : void 0
+      }), { editorText, editorImages, cancelled: !1, summaryEntry };
+    } finally {
+      this._branchSummaryAbortController = void 0;
+    }
+  }
+  /**
+   * Get all user messages from session for fork selector.
+   */
+  getUserMessagesForForking() {
+    let entries = this.sessionManager.getEntries(), result = [];
+    for (let entry of entries) {
+      if (entry.type !== "message" || entry.message.role !== "user")
+        continue;
+      let text = this._extractUserMessageText(entry.message.content);
+      text && result.push({ entryId: entry.id, text });
+    }
+    return result;
+  }
+  _extractUserMessageText(content) {
+    return typeof content == "string" ? content : Array.isArray(content) ? content.filter((c) => c.type === "text").map((c) => c.text).join("") : "";
+  }
+  _extractUserMessageImages(content) {
+    if (typeof content == "string" || !Array.isArray(content))
+      return;
+    let images = content.filter((part) => part.type === "image" && typeof part.data == "string" && typeof part.mimeType == "string");
+    return images.length > 0 ? images : void 0;
+  }
+  /**
+   * Get session statistics. Aggregates over ALL session entries (including
+   * history that was compacted away), so token/cost totals reflect what was
+   * actually billed across the session.
+   */
+  getSessionStats() {
+    let userMessages = 0, assistantMessages = 0, toolResults = 0, totalMessages = 0, toolCalls = 0, totalInput = 0, totalOutput = 0, totalCacheRead = 0, totalCacheWrite = 0, totalCost = 0;
+    for (let entry of this.sessionManager.getEntries()) {
+      if (entry.type !== "message")
+        continue;
+      totalMessages++;
+      let message = entry.message;
+      if (message.role === "user")
+        userMessages++;
+      else if (message.role === "toolResult")
+        toolResults++;
+      else if (message.role === "assistant") {
+        assistantMessages++;
+        let assistantMsg = message;
+        Array.isArray(assistantMsg.content) && (toolCalls += assistantMsg.content.filter((c) => c.type === "toolCall").length);
+        let usage = assistantMsg.usage;
+        totalInput += usage.input, totalOutput += usage.output, totalCacheRead += usage.cacheRead, totalCacheWrite += usage.cacheWrite, totalCost += usage.cost.total;
+      }
+    }
+    return {
+      sessionFile: this.sessionFile,
+      sessionId: this.sessionId,
+      userMessages,
+      assistantMessages,
+      toolCalls,
+      toolResults,
+      totalMessages,
+      tokens: {
+        input: totalInput,
+        output: totalOutput,
+        cacheRead: totalCacheRead,
+        cacheWrite: totalCacheWrite,
+        total: totalInput + totalOutput + totalCacheRead + totalCacheWrite
+      },
+      cost: totalCost,
+      contextUsage: this.getContextUsage()
+    };
+  }
+  getContextUsage() {
+    let model = this.model;
+    if (!model)
+      return;
+    let contextWindow = model.contextWindow ?? 0;
+    if (contextWindow <= 0)
+      return;
+    let branchEntries = this.sessionManager.getBranch(), latestCompaction = getLatestCompactionEntry(branchEntries);
+    if (latestCompaction) {
+      let compactionIndex = branchEntries.lastIndexOf(latestCompaction), hasPostCompactionUsage = !1;
+      for (let i = branchEntries.length - 1; i > compactionIndex; i--) {
+        let entry = branchEntries[i];
+        if (entry.type === "message" && entry.message.role === "assistant") {
+          let assistant = entry.message;
+          if (assistant.stopReason !== "aborted" && assistant.stopReason !== "error" && calculateContextTokens(assistant.usage) > 0) {
+            hasPostCompactionUsage = !0;
+            break;
+          }
+        }
+      }
+      if (!hasPostCompactionUsage)
+        return { tokens: null, contextWindow, percent: null };
+    }
+    let estimate = estimateContextTokens(this.messages), percent = estimate.tokens / contextWindow * 100;
+    return {
+      tokens: estimate.tokens,
+      contextWindow,
+      percent
+    };
+  }
+  /**
+   * Export session to HTML.
+   * @param outputPath Optional output path (defaults to session directory)
+   * @returns Path to exported file
+   */
+  async exportToHtml(outputPath) {
+    let [{ exportSessionToHtml }, { createToolHtmlRenderer }] = await Promise.all([
+      import("./export-html-KSOIMVPI.js"),
+      import("./tool-renderer-MV5O452K.js")
+    ]), configuredThemeName = this.settingsManager.getTheme(), themeName = configuredThemeName && getThemeByName(configuredThemeName) ? configuredThemeName : void 0, toolRenderer = createToolHtmlRenderer({
+      getToolDefinition: (name) => this.getToolDefinition(name),
+      theme,
+      cwd: this.sessionManager.getCwd()
+    });
+    return await exportSessionToHtml(this.sessionManager, this.state, {
+      outputPath,
+      themeName,
+      toolRenderer
+    });
+  }
+  /**
+   * Export the current session branch to a JSONL file.
+   * Writes the session header followed by all entries on the current branch path.
+   * @param outputPath Target file path. If omitted, generates a timestamped file in cwd.
+   * @returns The resolved output file path.
+   */
+  exportToJsonl(outputPath) {
+    let filePath = resolvePath(outputPath ?? `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.jsonl`, process.cwd()), dir = dirname2(filePath);
+    existsSync2(dir) || mkdirSync2(dir, { recursive: !0 });
+    let header = {
+      type: "session",
+      version: CURRENT_SESSION_VERSION,
+      id: this.sessionManager.getSessionId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      cwd: this.sessionManager.getCwd()
+    }, branchEntries = this.sessionManager.getBranch(), lines = [JSON.stringify(header)], prevId = null;
+    for (let entry of branchEntries) {
+      let linear = { ...entry, parentId: prevId };
+      lines.push(JSON.stringify(linear)), prevId = entry.id;
+    }
+    return writeFileSync2(filePath, `${lines.join(`
+`)}
+`), filePath;
+  }
+  // =========================================================================
+  // Utilities
+  // =========================================================================
+  /**
+   * Get text content of last assistant message.
+   * Useful for /copy command.
+   * @returns Text content, or undefined if no assistant message exists
+   */
+  getLastAssistantText() {
+    let lastAssistant = this.messages.slice().reverse().find((m) => {
+      if (m.role !== "assistant")
+        return !1;
+      let msg = m;
+      return !(msg.stopReason === "aborted" && msg.content.length === 0);
+    });
+    if (!lastAssistant)
+      return;
+    let text = "";
+    for (let content of lastAssistant.content)
+      content.type === "text" && (text += content.text);
+    return text.trim() || void 0;
+  }
+  // =========================================================================
+  // Extension System
+  // =========================================================================
+  createReplacedSessionContext() {
+    let context = Object.defineProperties({}, Object.getOwnPropertyDescriptors(this._extensionRunner.createCommandContext()));
+    return context.sendMessage = (message, options) => this.sendCustomMessage(message, options), context.sendUserMessage = (content, options) => this.sendUserMessage(content, options), context;
+  }
+  /**
+   * Check if extensions have handlers for a specific event type.
+   */
+  hasExtensionHandlers(eventType) {
+    return this._extensionRunner.hasHandlers(eventType);
+  }
+  /**
+   * Get the extension runner (for setting UI context and error handlers).
+   */
+  get extensionRunner() {
+    return this._extensionRunner;
+  }
+};
+
+// packages/coding-agent/dist/core/provider-attribution.js
+var OPENCODE_HOST = "opencode.ai";
+function matchesHost(baseUrl, expectedHost) {
+  try {
+    return new URL(baseUrl).hostname === expectedHost;
+  } catch {
+    return !1;
+  }
+}
+function getSessionHeaders(model, sessionId) {
+  if (sessionId && !(model.provider !== "opencode" && model.provider !== "opencode-go" && !matchesHost(model.baseUrl, OPENCODE_HOST)))
+    return { "x-opencode-session": sessionId, "x-opencode-client": "pi" };
+}
+function mergeProviderAttributionHeaders(model, _settingsManager, sessionId, ...headerSources) {
+  let merged = {
+    ...getSessionHeaders(model, sessionId)
+  };
+  for (let headers of headerSources)
+    headers && Object.assign(merged, headers);
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+
+// packages/coding-agent/dist/core/agent-session-runtime.js
+import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "node:fs";
+import { basename as basename2, join as join5 } from "node:path";
+
+// packages/coding-agent/dist/core/session-cwd.js
+import { existsSync as existsSync3 } from "node:fs";
+function getMissingSessionCwdIssue(sessionManager, fallbackCwd) {
+  let sessionFile = sessionManager.getSessionFile();
+  if (!sessionFile)
+    return;
+  let sessionCwd = sessionManager.getCwd();
+  if (!(!sessionCwd || existsSync3(sessionCwd)))
+    return {
+      sessionFile,
+      sessionCwd,
+      fallbackCwd
+    };
+}
+function formatMissingSessionCwdError(issue) {
+  let sessionFile = issue.sessionFile ? `
+Session file: ${issue.sessionFile}` : "";
+  return `Stored session working directory does not exist: ${issue.sessionCwd}${sessionFile}
+Current working directory: ${issue.fallbackCwd}`;
+}
+function formatMissingSessionCwdPrompt(issue) {
+  return `cwd from session file does not exist
+${issue.sessionCwd}
+
+continue in current cwd
+${issue.fallbackCwd}`;
+}
+var MissingSessionCwdError = class extends Error {
+  issue;
+  constructor(issue) {
+    super(formatMissingSessionCwdError(issue)), this.name = "MissingSessionCwdError", this.issue = issue;
+  }
+};
+function assertSessionCwdExists(sessionManager, fallbackCwd) {
+  let issue = getMissingSessionCwdIssue(sessionManager, fallbackCwd);
+  if (issue)
+    throw new MissingSessionCwdError(issue);
+}
+
+// packages/coding-agent/dist/core/agent-session-runtime.js
+var SessionImportFileNotFoundError = class extends Error {
+  filePath;
+  constructor(filePath) {
+    super(`File not found: ${filePath}`), this.name = "SessionImportFileNotFoundError", this.filePath = filePath;
+  }
+};
+function extractUserMessageText(content) {
+  return typeof content == "string" ? content : content.filter((part) => part.type === "text" && typeof part.text == "string").map((part) => part.text).join("");
+}
+var AgentSessionRuntime = class {
+  rebindSession;
+  beforeSessionInvalidate;
+  _session;
+  _services;
+  createRuntime;
+  onRuntimeApplied;
+  _diagnostics;
+  _modelFallbackMessage;
+  detached = !1;
+  transferring = !1;
+  get isDetached() {
+    return this.detached;
+  }
+  async releaseForTransfer(options = {}) {
+    if (options.signal?.throwIfAborted(), this.detached)
+      return;
+    if (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;
+    try {
+      if (hasAttachedWork())
+        throw new SessionTransferError("Live children or processes cannot move between runtimes. Wait for them to finish or stop them and retry.", "busy");
+      if (busy() && !options.stop)
+        throw new SessionTransferError("Session is busy. Wait and retry, explicitly request stop, or cancel.", "busy");
+      if (busy() && (this.session.abortCompaction(), this.session.abortBranchSummary(), this.session.abortBash(), this.session.clearQueue(), await this.session.abort()), busy() || hasAttachedWork())
+        throw new SessionTransferError("Work has not stopped yet. Wait and retry.", "busy");
+      options.signal?.throwIfAborted(), this.session.sessionManager.flush(), await this.teardownCurrent("resume");
+    } finally {
+      this.transferring = !1, this.detached || this.session.setTransferring(!1);
+    }
+  }
+  constructor(_session, _services, createRuntime, _diagnostics = [], _modelFallbackMessage, onRuntimeApplied) {
+    this._session = _session, this._services = _services, this.createRuntime = createRuntime, this._diagnostics = _diagnostics, this._modelFallbackMessage = _modelFallbackMessage, this.onRuntimeApplied = onRuntimeApplied;
+  }
+  async createOwnedRuntime(options) {
+    try {
+      return await this.createRuntime(options);
+    } catch (error) {
+      throw options.sessionManager.dispose(), error;
+    }
+  }
+  get services() {
+    return this._services;
+  }
+  get session() {
+    return this._session;
+  }
+  get cwd() {
+    return this._services.cwd;
+  }
+  get diagnostics() {
+    return this._diagnostics;
+  }
+  get modelFallbackMessage() {
+    return this._modelFallbackMessage;
+  }
+  setRebindSession(rebindSession) {
+    this.rebindSession = rebindSession;
+  }
+  /**
+   * Set a synchronous callback that runs after `session_shutdown` handlers finish
+   * but before the current session is invalidated.
+   *
+   * This is for host-owned UI teardown that must not yield to the event loop,
+   * such as detaching extension-provided TUI components before the old extension
+   * context becomes stale.
+   */
+  setBeforeSessionInvalidate(beforeSessionInvalidate) {
+    this.beforeSessionInvalidate = beforeSessionInvalidate;
+  }
+  async emitBeforeSwitch(reason, targetSessionFile) {
+    let runner = this.session.extensionRunner;
+    return runner.hasHandlers("session_before_switch") ? { cancelled: (await runner.emit({
+      type: "session_before_switch",
+      reason,
+      targetSessionFile
+    }))?.cancel === !0 } : { cancelled: !1 };
+  }
+  async emitBeforeFork(entryId, options) {
+    let runner = this.session.extensionRunner;
+    return runner.hasHandlers("session_before_fork") ? { cancelled: (await runner.emit({
+      type: "session_before_fork",
+      entryId,
+      ...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);
+  }
+  async teardownForReplacement(reason, sessionManager) {
+    try {
+      await this.teardownCurrent(reason, sessionManager.getSessionFile());
+    } catch (error) {
+      throw sessionManager.dispose(), error;
+    }
+  }
+  apply(result) {
+    this.detached = !1, this._session = result.session, 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) {
+    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);
+    if (beforeResult.cancelled)
+      return beforeResult;
+    let previousSessionFile = this.session.sessionFile, sessionManager = SessionManager.open(sessionPath, void 0, options?.cwdOverride);
+    try {
+      assertSessionCwdExists(sessionManager, this.cwd);
+    } catch (error) {
+      throw sessionManager.dispose(), error;
+    }
+    return await this.teardownForReplacement("resume", sessionManager), this.apply(await this.createOwnedRuntime({
+      cwd: sessionManager.getCwd(),
+      agentDir: this.services.agentDir,
+      sessionManager,
+      sessionStartEvent: { type: "session_start", reason: "resume", previousSessionFile },
+      projectTrustContext: options?.projectTrustContextFactory?.(sessionManager.getCwd())
+    })), await this.finishSessionReplacement(options?.withSession), { cancelled: !1 };
+  }
+  async newSession(options) {
+    let beforeResult = await this.emitBeforeSwitch("new");
+    if (beforeResult.cancelled)
+      return beforeResult;
+    let previousSessionFile = this.session.sessionFile, sessionDir = this.session.sessionManager.getSessionDir(), sessionManager = this.session.sessionManager.isPersisted() ? SessionManager.create(this.cwd, sessionDir) : SessionManager.inMemory(this.cwd);
+    return options?.parentSession && sessionManager.newSession({ parentSession: options.parentSession }), await this.teardownForReplacement("new", sessionManager), this.apply(await this.createOwnedRuntime({
+      cwd: this.cwd,
+      agentDir: this.services.agentDir,
+      sessionManager,
+      sessionStartEvent: { type: "session_start", reason: "new", previousSessionFile }
+    })), 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) {
+    let position = options?.position ?? "before";
+    if ((await this.emitBeforeFork(entryId, { position })).cancelled)
+      return { cancelled: !0 };
+    let targetLeafId, selectedText, selectedEntry = this.session.sessionManager.getEntry(entryId);
+    if (!selectedEntry)
+      throw new Error("Invalid entry ID for forking");
+    if (position === "at")
+      targetLeafId = selectedEntry.id;
+    else {
+      if (selectedEntry.type !== "message" || selectedEntry.message.role !== "user")
+        throw new Error("Invalid entry ID for forking");
+      targetLeafId = selectedEntry.parentId, selectedText = extractUserMessageText(selectedEntry.message.content);
+    }
+    let previousSessionFile = this.session.sessionFile;
+    if (this.session.sessionManager.isPersisted()) {
+      let currentSessionFile = this.session.sessionFile;
+      if (!currentSessionFile)
+        throw new Error("Persisted session is missing a session file");
+      let sessionDir = this.session.sessionManager.getSessionDir();
+      if (!targetLeafId) {
+        let sessionManager3 = SessionManager.create(this.cwd, sessionDir);
+        return sessionManager3.newSession({ parentSession: currentSessionFile }), await this.teardownForReplacement("fork", sessionManager3), this.apply(await this.createOwnedRuntime({
+          cwd: this.cwd,
+          agentDir: this.services.agentDir,
+          sessionManager: sessionManager3,
+          sessionStartEvent: { type: "session_start", reason: "fork", previousSessionFile }
+        })), await this.finishSessionReplacement(options?.withSession), { cancelled: !1, selectedText };
+      }
+      if (!existsSync4(currentSessionFile))
+        throw new Error("This session has not been saved yet. Wait for the first assistant response before cloning or forking it.");
+      let sessionManager2 = SessionManager.forkBranch(currentSessionFile, targetLeafId, sessionDir);
+      if (!sessionManager2.getSessionFile())
+        throw new Error("Failed to create forked session");
+      return await this.teardownForReplacement("fork", sessionManager2), this.apply(await this.createOwnedRuntime({
+        cwd: sessionManager2.getCwd(),
+        agentDir: this.services.agentDir,
+        sessionManager: sessionManager2,
+        sessionStartEvent: { type: "session_start", reason: "fork", previousSessionFile }
+      })), await this.finishSessionReplacement(options?.withSession), { cancelled: !1, selectedText };
+    }
+    let sessionManager = this.session.sessionManager.copyInMemory();
+    return targetLeafId ? sessionManager.createBranchedSession(targetLeafId) : sessionManager.newSession({ parentSession: this.session.sessionFile }), await this.teardownForReplacement("fork", sessionManager), this.apply(await this.createOwnedRuntime({
+      cwd: this.cwd,
+      agentDir: this.services.agentDir,
+      sessionManager,
+      sessionStartEvent: { type: "session_start", reason: "fork", previousSessionFile }
+    })), await this.finishSessionReplacement(options?.withSession), { cancelled: !1, selectedText };
+  }
+  /**
+   * Import a session JSONL file and switch runtime state to the imported session.
+   *
+   * @returns `{ cancelled: true }` when cancelled by `session_before_switch`, otherwise `{ cancelled: false }`.
+   * @throws {SessionImportFileNotFoundError} When the input path does not exist.
+   * @throws {MissingSessionCwdError} When the imported session cwd cannot be resolved and no override is provided.
+   */
+  async importFromJsonl(inputPath, cwdOverride) {
+    let resolvedPath = resolvePath(inputPath);
+    if (!existsSync4(resolvedPath))
+      throw new SessionImportFileNotFoundError(resolvedPath);
+    let sessionDir = this.session.sessionManager.getSessionDir();
+    existsSync4(sessionDir) || mkdirSync3(sessionDir, { recursive: !0 });
+    let destinationPath = join5(sessionDir, basename2(resolvedPath)), beforeResult = await this.emitBeforeSwitch("resume", destinationPath);
+    if (beforeResult.cancelled)
+      return beforeResult;
+    let previousSessionFile = this.session.sessionFile;
+    if (canonicalSessionPath(destinationPath) !== canonicalSessionPath(resolvedPath)) {
+      let ownership = new SessionOwnership(destinationPath);
+      try {
+        copyFileSync(resolvedPath, destinationPath);
+      } finally {
+        ownership.release();
+      }
+    }
+    let sessionManager = SessionManager.open(destinationPath, sessionDir, cwdOverride);
+    try {
+      assertSessionCwdExists(sessionManager, this.cwd);
+    } catch (error) {
+      throw sessionManager.dispose(), error;
+    }
+    return await this.teardownForReplacement("resume", sessionManager), this.apply(await this.createOwnedRuntime({
+      cwd: sessionManager.getCwd(),
+      agentDir: this.services.agentDir,
+      sessionManager,
+      sessionStartEvent: { type: "session_start", reason: "resume", previousSessionFile }
+    })), await this.finishSessionReplacement(), { cancelled: !1 };
+  }
+  async dispose() {
+    await this.teardownCurrent("quit");
+  }
+};
+async function createAgentSessionRuntime(createRuntime, options) {
+  let result;
+  try {
+    assertSessionCwdExists(options.sessionManager, options.cwd), result = await createRuntime(options);
+  } catch (error) {
+    throw options.sessionManager.dispose(), error;
+  }
+  let runtime = new AgentSessionRuntime(result.session, result.services, createRuntime, result.diagnostics, result.modelFallbackMessage, options.onRuntimeApplied);
+  return options.onRuntimeApplied?.(result), runtime;
+}
+
+// packages/coding-agent/dist/core/sdk.js
+function getDefaultAgentDir() {
+  return getAgentDir();
+}
+async function createAgentSession(options = {}) {
+  let cwd = resolvePath(options.cwd ?? options.sessionManager?.getCwd() ?? process.cwd()), agentDir = options.agentDir ? resolvePath(options.agentDir) : getDefaultAgentDir(), sessionManager = options.sessionManager ?? SessionManager.create(cwd, getDefaultSessionDir(cwd, agentDir));
+  try {
+    return sessionManager.assertWritable(), await createOwnedAgentSession({ ...options, sessionManager });
+  } catch (error) {
+    throw sessionManager.dispose(), error;
+  }
+}
+async function createOwnedAgentSession(options) {
+  let cwd = resolvePath(options.cwd ?? options.sessionManager?.getCwd() ?? process.cwd()), agentDir = options.agentDir ? resolvePath(options.agentDir) : getDefaultAgentDir(), resourceLoader = options.resourceLoader, authPath = options.agentDir ? join6(agentDir, "auth.json") : void 0, modelsPath = options.agentDir ? join6(agentDir, "models.json") : void 0, modelRuntime = options.modelRuntime ?? await ModelRuntime.create({ authPath, modelsPath }), settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir), sessionManager = options.sessionManager ?? SessionManager.create(cwd, getDefaultSessionDir(cwd, agentDir));
+  resourceLoader || (resourceLoader = new DefaultResourceLoader({ cwd, agentDir, settingsManager }), await resourceLoader.reload(), time("resourceLoader.reload"));
+  let existingSession = sessionManager.buildSessionContext(), hasExistingSession = existingSession.messages.length > 0, hasThinkingEntry = sessionManager.getBranch().some((entry) => entry.type === "thinking_level_change"), model = options.model, modelFallbackMessage;
+  if (!model && hasExistingSession && existingSession.model) {
+    let restoredModel = modelRuntime.getModel(existingSession.model.provider, existingSession.model.modelId);
+    restoredModel && modelRuntime.hasConfiguredAuth(restoredModel.provider) && (model = restoredModel), model || (modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`);
+  }
+  model || (model = (await findInitialModel({
+    scopedModels: [],
+    isContinuing: hasExistingSession,
+    defaultProvider: settingsManager.getDefaultProvider(),
+    defaultModelId: settingsManager.getDefaultModel(),
+    defaultThinkingLevel: settingsManager.getDefaultThinkingLevel(),
+    modelRuntime
+  })).model, model ? modelFallbackMessage && (modelFallbackMessage += `. Using ${model.provider}/${model.id}`) : modelFallbackMessage = formatNoModelsAvailableMessage());
+  let thinkingLevel = options.thinkingLevel;
+  thinkingLevel === void 0 && hasExistingSession && (thinkingLevel = hasThinkingEntry ? existingSession.thinkingLevel : settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL), thinkingLevel === void 0 && (thinkingLevel = settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL), model ? thinkingLevel = clampThinkingLevel2(model, thinkingLevel) : thinkingLevel = "off";
+  let defaultActiveToolNames = ["read", "bash", "edit", "write"], allowedToolNames = options.tools ?? (options.noTools === "all" ? [] : void 0), excludedToolNames = options.excludeTools, excludedToolNameSet = excludedToolNames ? new Set(excludedToolNames) : void 0, initialActiveToolNames = (options.tools ? [...options.tools] : options.noTools ? [] : defaultActiveToolNames).filter((name) => !excludedToolNameSet?.has(name)), agent, convertToLlmWithBlockImages = (messages) => {
+    let converted = convertToLlm(messages);
+    return settingsManager.getBlockImages() ? converted.map((msg) => {
+      if (msg.role === "user" || msg.role === "toolResult") {
+        let content = msg.content;
+        if (Array.isArray(content) && content.some((c) => c.type === "image")) {
+          let filteredContent = content.map((c) => c.type === "image" ? { type: "text", text: "Image reading is disabled." } : c).filter((c, i, arr) => (
+            // Dedupe consecutive "Image reading is disabled." texts
+            !(c.type === "text" && c.text === "Image reading is disabled." && i > 0 && arr[i - 1].type === "text" && arr[i - 1].text === "Image reading is disabled.")
+          ));
+          return { ...msg, content: filteredContent };
+        }
+      }
+      return msg;
+    }) : converted;
+  }, extensionRunnerRef = {};
+  agent = new Agent({
+    initialState: {
+      systemPrompt: "",
+      model,
+      thinkingLevel,
+      tools: []
+    },
+    convertToLlm: convertToLlmWithBlockImages,
+    streamFn: async (model2, context, options2) => {
+      let providerRetrySettings = settingsManager.getProviderRetrySettings(), httpIdleTimeoutMs = settingsManager.getHttpIdleTimeoutMs(), effectiveTimeoutMs = httpIdleTimeoutMs === 0 ? 2147483647 : httpIdleTimeoutMs, timeoutMs = options2?.timeoutMs ?? providerRetrySettings.timeoutMs ?? effectiveTimeoutMs, websocketConnectTimeoutMs = options2?.websocketConnectTimeoutMs ?? settingsManager.getWebSocketConnectTimeoutMs(), headerRunner = extensionRunnerRef.current;
+      return modelRuntime.streamSimple(model2, context, {
+        ...options2,
+        timeoutMs,
+        websocketConnectTimeoutMs,
+        cacheRetention: settingsManager.getCacheRetention(),
+        maxRetries: options2?.maxRetries ?? providerRetrySettings.maxRetries,
+        maxRetryDelayMs: options2?.maxRetryDelayMs ?? providerRetrySettings.maxRetryDelayMs,
+        transformHeaders: async (requestHeaders) => {
+          let headers = mergeProviderAttributionHeaders(model2, settingsManager, options2?.sessionId, requestHeaders);
+          return headerRunner?.hasHandlers("before_provider_headers") ? headerRunner.emitBeforeProviderHeaders(headers ?? {}) : headers ?? {};
+        }
+      });
+    },
+    onPayload: async (payload, _model) => {
+      let runner = extensionRunnerRef.current;
+      return runner?.hasHandlers("before_provider_request") ? runner.emitBeforeProviderRequest(payload) : payload;
+    },
+    onResponse: async (response, _model) => {
+      let runner = extensionRunnerRef.current;
+      runner?.hasHandlers("after_provider_response") && await runner.emit({
+        type: "after_provider_response",
+        status: response.status,
+        headers: response.headers
+      });
+    },
+    sessionId: sessionManager.getSessionId(),
+    transformContext: async (messages) => {
+      let runner = extensionRunnerRef.current;
+      return runner ? runner.emitContext(messages) : messages;
+    },
+    steeringMode: settingsManager.getSteeringMode(),
+    followUpMode: settingsManager.getFollowUpMode(),
+    transport: settingsManager.getTransport(),
+    thinkingBudgets: settingsManager.getThinkingBudgets(),
+    maxRetryDelayMs: settingsManager.getProviderRetrySettings().maxRetryDelayMs
+  }), hasExistingSession ? (agent.state.messages = existingSession.messages, hasThinkingEntry || sessionManager.appendThinkingLevelChange(thinkingLevel)) : (model && sessionManager.appendModelChange(model.provider, model.id), sessionManager.appendThinkingLevelChange(thinkingLevel));
+  let session = new AgentSession({
+    agent,
+    sessionManager,
+    settingsManager,
+    cwd,
+    agentDir,
+    scopedModels: options.scopedModels,
+    resourceLoader,
+    customTools: options.customTools,
+    modelRuntime,
+    initialActiveToolNames,
+    allowedToolNames,
+    excludedToolNames,
+    extensionRunnerRef,
+    sessionStartEvent: options.sessionStartEvent
+  }), extensionsResult = resourceLoader.getExtensions();
+  return {
+    session,
+    extensionsResult,
+    modelFallbackMessage
+  };
+}
+
+// packages/coding-agent/dist/core/agent-session-services.js
+function applyExtensionFlagValues(resourceLoader, extensionFlagValues) {
+  if (!extensionFlagValues)
+    return [];
+  let diagnostics = [], extensionsResult = resourceLoader.getExtensions(), registeredFlags = /* @__PURE__ */ new Map();
+  for (let extension of extensionsResult.extensions)
+    for (let [name, flag] of extension.flags)
+      registeredFlags.set(name, { type: flag.type });
+  let unknownFlags = [], deferredFlags = /* @__PURE__ */ new Set(["mcp-config"]);
+  for (let [name, value] of extensionFlagValues) {
+    let flag = registeredFlags.get(name);
+    if (!flag) {
+      if (deferredFlags.has(name))
+        continue;
+      unknownFlags.push(name);
+      continue;
+    }
+    if (flag.type === "boolean") {
+      extensionsResult.runtime.flagValues.set(name, !0);
+      continue;
+    }
+    if (typeof value == "string") {
+      extensionsResult.runtime.flagValues.set(name, value);
+      continue;
+    }
+    diagnostics.push({
+      type: "error",
+      message: `Extension flag "--${name}" requires a value`
+    });
+  }
+  return unknownFlags.length > 0 && diagnostics.push({
+    type: "error",
+    message: `Unknown option${unknownFlags.length === 1 ? "" : "s"}: ${unknownFlags.map((name) => `--${name}`).join(", ")}`
+  }), diagnostics;
+}
+async function createAgentSessionServices(options) {
+  let cwd = resolvePath(options.cwd), agentDir = options.agentDir ? resolvePath(options.agentDir) : getAgentDir(), modelRuntime = options.modelRuntime ?? await ModelRuntime.create({
+    authPath: join7(agentDir, "auth.json"),
+    modelsPath: join7(agentDir, "models.json")
+  });
+  time("ModelRuntime.create");
+  let settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir), resourceLoader = new DefaultResourceLoader({
+    ...options.resourceLoaderOptions ?? {},
+    cwd,
+    agentDir,
+    settingsManager
+  });
+  await resourceLoader.reload(options.resourceLoaderReloadOptions), time("resourceLoader.reload");
+  let diagnostics = [], extensionsResult = resourceLoader.getExtensions();
+  for (let { name, config, extensionPath } of extensionsResult.runtime.pendingProviderRegistrations)
+    try {
+      modelRuntime.registerProvider(name, config);
+    } catch (error) {
+      let message = error instanceof Error ? error.message : String(error);
+      diagnostics.push({
+        type: "error",
+        message: `Extension "${extensionPath}" error: ${message}`
+      });
+    }
+  return extensionsResult.runtime.pendingProviderRegistrations = [], await modelRuntime.refresh({ allowNetwork: !1 }), time("modelRuntime.refresh(cache-only)"), diagnostics.push(...applyExtensionFlagValues(resourceLoader, options.extensionFlagValues)), {
+    cwd,
+    agentDir,
+    modelRuntime,
+    settingsManager,
+    resourceLoader,
+    diagnostics
+  };
+}
+async function createAgentSessionFromServices(options) {
+  return createAgentSession({
+    cwd: options.services.cwd,
+    agentDir: options.services.agentDir,
+    modelRuntime: options.services.modelRuntime,
+    settingsManager: options.services.settingsManager,
+    resourceLoader: options.services.resourceLoader,
+    sessionManager: options.sessionManager,
+    model: options.model,
+    thinkingLevel: options.thinkingLevel,
+    scopedModels: options.scopedModels,
+    tools: options.tools,
+    excludeTools: options.excludeTools,
+    noTools: options.noTools,
+    customTools: options.customTools,
+    sessionStartEvent: options.sessionStartEvent
+  });
+}
+
+export {
+  formatNoModelsAvailableMessage,
+  wrapRegisteredTool,
+  wrapRegisteredTools,
+  ModelRegistry,
+  setRollbackWarningHandler,
+  initRollback,
+  isRollbackEnabled,
+  isRollbackSessionForceEnabled,
+  enableRollbackForSession,
+  disableRollbackForSession,
+  beginTurn,
+  captureTreeChanges,
+  peekRollbackTurnsConsumed,
+  rollbackLastTurn,
+  migrateRollbackSession,
+  clearRollback,
+  parseSkillBlock,
+  AgentSession,
+  getMissingSessionCwdIssue,
+  formatMissingSessionCwdPrompt,
+  MissingSessionCwdError,
+  SessionImportFileNotFoundError,
+  AgentSessionRuntime,
+  createAgentSessionRuntime,
+  createAgentSession,
+  createAgentSessionServices,
+  createAgentSessionFromServices
+};