@ashx-j/lunr 0.2.19 → 0.2.20

package/dist/node-runtime/{chunk-ATGA2WLC.js → chunk-JYNNB7DU.js}

@@ -53,12 +53,11 @@ import {
   convertToLlm
 } from "./chunk-FVDOXRUD.js";
 import {
-  clearPlanUsageCache,
-  rollbackSnapshotBeforeWrite
-} from "./chunk-PNJSG3IZ.js";
+  clearPlanUsageCache
+} from "./chunk-LTYWTR3V.js";
 import {
   gateToolCall
-} from "./chunk-J26TSGDL.js";
+} from "./chunk-6N22HULO.js";
 import {
   isUserInstructionsPath,
   loadSelectedUserInstructions
@@ -75,6 +74,7 @@ import {
   theme
 } from "./chunk-RNBHABBA.js";
 import {
+  CONFIG_DIR_NAME,
   VERSION,
   getAgentDir,
   getDocsPath,
@@ -89,7 +89,7 @@ import {
 } from "./chunk-BRJX2PRC.js";
 
 // packages/coding-agent/dist/core/agent-session-services.js
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 
 // packages/coding-agent/dist/core/model-runtime.js
 import { dirname as dirname5, join as join7 } from "node:path";
@@ -2891,23 +2891,23 @@ async function refreshModelCandidatesForInit(runtime) {
 }
 
 // packages/coding-agent/dist/core/sdk.js
-import { join as join12 } from "node:path";
+import { join as join13 } 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 existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename, dirname as dirname6, join as join10, resolve } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename, dirname as dirname7, join as join11, 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) => {
+  return new Promise((resolve4, reject) => {
     if (signal?.aborted) {
       reject(new Error("Aborted"));
       return;
     }
-    let timeout = setTimeout(resolve3, ms);
+    let timeout = setTimeout(resolve4, ms);
     signal?.addEventListener("abort", () => {
       clearTimeout(timeout), reject(new Error("Aborted"));
     });
@@ -3085,6 +3085,357 @@ var ModelRegistry = class {
   }
 };
 
+// packages/coding-agent/dist/core/rollback.js
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync, readFileSync as readFileSync5, renameSync as renameSync4, rmSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname6, join as join10, normalize, resolve } from "node:path";
+var ROLLBACK_BASE = join10(homedir2(), ".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 = existsSync5(absPath), content;
+      existed && (content = readFileSync5(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 = join10(cwd, path);
+      if (!turn.files.has(abs))
+        try {
+          let existed = existsSync5(abs);
+          turn.files.set(abs, {
+            existed,
+            content: existed ? readFileSync5(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 = join10(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 = join10(cwd, source);
+              if (!turn.files.has(sourceAbs)) {
+                let headSrc = spawnSync2("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 = spawnSync2("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 = spawnSync2("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);
+    mkdirSync5(turnDir, { recursive: !0 });
+    let manifestPath = join10(turnDir, "manifest.json"), manifest = readManifest(manifestPath), entry = { existed: snap.existed, createdByTool: snap.createdByTool };
+    if (snap.content) {
+      let snapFile = snapFileName(absPath);
+      writeFileSync5(join10(turnDir, snapFile), snap.content), entry.snapFile = snapFile;
+    }
+    manifest.files[absPath] = entry, turn.cwd && (manifest.cwd = turn.cwd), writeFileSync5(manifestPath, JSON.stringify(manifest, null, 2));
+  } catch {
+  }
+}
+function readManifest(path) {
+  if (!existsSync5(path))
+    return { files: {} };
+  try {
+    let parsed = JSON.parse(readFileSync5(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 = join10(ROLLBACK_BASE, ctx.sessionId);
+    if (!existsSync5(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 = join10(sessionDir, dirName), manifest = readManifest(join10(turnDir, "manifest.json")), files = /* @__PURE__ */ new Map();
+      for (let [absPath, meta] of Object.entries(manifest.files)) {
+        let content;
+        if (meta.snapFile)
+          try {
+            content = readFileSync5(join10(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 join10(ROLLBACK_BASE, ctx.sessionId, `turn-${turnIndex}`);
+}
+function cleanupTurnFiles(ctx, turn) {
+  try {
+    let dir = getTurnDir(ctx, turn.turnIndex);
+    existsSync5(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,
+    join10(homedir2(), 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)
+    join10(dirname6(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 && existsSync5(absPath) && readFileSync5(absPath).equals(snap.content))
+          continue;
+        mkdirSync5(dirname6(absPath), { recursive: !0 }), writeFileSync5(absPath, snap.content), restored.push(absPath);
+      } else snap.existed || (snap.createdByTool || capture === "hybrid" || capture === "shadow-git") && existsSync5(absPath) && (unlinkSync4(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 = join10(ROLLBACK_BASE, oldSessionId), newDir = join10(ROLLBACK_BASE, newSessionId);
+    if (existsSync5(oldDir)) {
+      existsSync5(newDir) && rmSync(newDir, { recursive: !0, force: !0 });
+      try {
+        renameSync4(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 = join10(ROLLBACK_BASE, ctx2.sessionId);
+        existsSync5(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 = join10(ROLLBACK_BASE, sessionId);
+      existsSync5(sessionDir) && rmSync(sessionDir, { recursive: !0, force: !0 });
+    } catch {
+    }
+    contexts.delete(sessionId);
+  }
+}
+function snapFileName(absPath) {
+  return `${createHash3("sha1").update(absPath).digest("hex")}.snap`;
+}
+
 // 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 ? `
@@ -3315,14 +3666,14 @@ var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"
       if (permBlock)
         return { block: !0, reason: permBlock.reason };
       try {
-        let toolName = toolCall.name, argPath = args && typeof args == "object" && "path" in args ? resolve(this._cwd, String(args.path)) : void 0, pathsToSnapshot = [];
+        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(join10(dirname6(getAgentDir()), "simple-memory", "memory.md"));
+          pathsToSnapshot.push(join11(dirname7(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(join10(getAgentDir(), "cron", "jobs.json"));
+          (action === "create" || action === "update" || action === "remove") && pathsToSnapshot.push(join11(getAgentDir(), "cron", "jobs.json"));
         }
         for (let p of pathsToSnapshot)
           rollbackSnapshotBeforeWrite(p, this.sessionId);
@@ -3404,15 +3755,15 @@ var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"
     });
   }
   _getIdleWaitPromise() {
-    return this._idleWaitPromise || (this._idleWaitPromise = new Promise((resolve3) => {
-      this._resolveIdleWait = resolve3;
+    return this._idleWaitPromise || (this._idleWaitPromise = new Promise((resolve4) => {
+      this._resolveIdleWait = resolve4;
     })), this._idleWaitPromise;
   }
   _resolveIdleWaitIfIdle() {
     if (this._isAgentRunActive || !this._resolveIdleWait)
       return;
-    let resolve3 = this._resolveIdleWait;
-    this._idleWaitPromise = void 0, this._resolveIdleWait = void 0, resolve3();
+    let resolve4 = this._resolveIdleWait;
+    this._idleWaitPromise = void 0, this._resolveIdleWait = void 0, resolve4();
   }
   async _emitAgentSettled() {
     this._isAgentRunActive = !1;
@@ -3892,7 +4243,7 @@ ${this._systemPromptAppend}` : prompt;
     if (!skill)
       return text;
     try {
-      let content = readFileSync5(skill.filePath, "utf-8"), body = stripFrontmatter(content).trim(), skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">
+      let content = readFileSync6(skill.filePath, "utf-8"), body = stripFrontmatter(content).trim(), skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">
 References are relative to ${skill.baseDir}.
 
 ${body}
@@ -4526,7 +4877,7 @@ ${args}` : skillBlock;
   }
   buildExtensionResourcePaths(entries) {
     return entries.map((entry) => {
-      let source = this.getExtensionSourceLabel(entry.extensionPath), baseDir = entry.extensionPath.startsWith("<") ? void 0 : dirname6(entry.extensionPath);
+      let source = this.getExtensionSourceLabel(entry.extensionPath), baseDir = entry.extensionPath.startsWith("<") ? void 0 : dirname7(entry.extensionPath);
       return {
         path: entry.path,
         metadata: {
@@ -5108,8 +5459,8 @@ ${command}` : command;
    * @returns The resolved output file path.
    */
   exportToJsonl(outputPath) {
-    let filePath = resolvePath(outputPath ?? `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.jsonl`, process.cwd()), dir = dirname6(filePath);
-    existsSync5(dir) || mkdirSync5(dir, { recursive: !0 });
+    let filePath = resolvePath(outputPath ?? `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.jsonl`, process.cwd()), dir = dirname7(filePath);
+    existsSync6(dir) || mkdirSync6(dir, { recursive: !0 });
     let header = {
       type: "session",
       version: CURRENT_SESSION_VERSION,
@@ -5121,7 +5472,7 @@ ${command}` : command;
       let linear = { ...entry, parentId: prevId };
       lines.push(JSON.stringify(linear)), prevId = entry.id;
     }
-    return writeFileSync5(filePath, `${lines.join(`
+    return writeFileSync6(filePath, `${lines.join(`
 `)}
 `), filePath;
   }
@@ -5191,17 +5542,17 @@ function mergeProviderAttributionHeaders(model, _settingsManager, sessionId, ...
 }
 
 // packages/coding-agent/dist/core/agent-session-runtime.js
-import { copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync6 } from "node:fs";
-import { basename as basename2, join as join11, resolve as resolve2 } from "node:path";
+import { copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync7 } from "node:fs";
+import { basename as basename2, join as join12, resolve as resolve3 } from "node:path";
 
 // packages/coding-agent/dist/core/session-cwd.js
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 function getMissingSessionCwdIssue(sessionManager, fallbackCwd) {
   let sessionFile = sessionManager.getSessionFile();
   if (!sessionFile)
     return;
   let sessionCwd = sessionManager.getCwd();
-  if (!(!sessionCwd || existsSync6(sessionCwd)))
+  if (!(!sessionCwd || existsSync7(sessionCwd)))
     return {
       sessionFile,
       sessionCwd,
@@ -5367,7 +5718,7 @@ var AgentSessionRuntime = class {
           sessionStartEvent: { type: "session_start", reason: "fork", previousSessionFile }
         })), await this.finishSessionReplacement(options?.withSession), { cancelled: !1, selectedText };
       }
-      if (!existsSync7(currentSessionFile))
+      if (!existsSync8(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.open(currentSessionFile, sessionDir);
       if (!sessionManager2.createBranchedSession(targetLeafId))
@@ -5396,15 +5747,15 @@ var AgentSessionRuntime = class {
    */
   async importFromJsonl(inputPath, cwdOverride) {
     let resolvedPath = resolvePath(inputPath);
-    if (!existsSync7(resolvedPath))
+    if (!existsSync8(resolvedPath))
       throw new SessionImportFileNotFoundError(resolvedPath);
     let sessionDir = this.session.sessionManager.getSessionDir();
-    existsSync7(sessionDir) || mkdirSync6(sessionDir, { recursive: !0 });
-    let destinationPath = join11(sessionDir, basename2(resolvedPath)), beforeResult = await this.emitBeforeSwitch("resume", destinationPath);
+    existsSync8(sessionDir) || mkdirSync7(sessionDir, { recursive: !0 });
+    let destinationPath = join12(sessionDir, basename2(resolvedPath)), beforeResult = await this.emitBeforeSwitch("resume", destinationPath);
     if (beforeResult.cancelled)
       return beforeResult;
     let previousSessionFile = this.session.sessionFile;
-    resolve2(destinationPath) !== resolvedPath && copyFileSync(resolvedPath, destinationPath);
+    resolve3(destinationPath) !== resolvedPath && copyFileSync(resolvedPath, destinationPath);
     let sessionManager = SessionManager.open(destinationPath, sessionDir, cwdOverride);
     return assertSessionCwdExists(sessionManager, this.cwd), await this.teardownCurrent("resume", sessionManager.getSessionFile()), this.apply(await this.createRuntime({
       cwd: sessionManager.getCwd(),
@@ -5431,7 +5782,7 @@ 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(), resourceLoader = options.resourceLoader, authPath = options.agentDir ? join12(agentDir, "auth.json") : void 0, modelsPath = options.agentDir ? join12(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));
+  let cwd = resolvePath(options.cwd ?? options.sessionManager?.getCwd() ?? process.cwd()), agentDir = options.agentDir ? resolvePath(options.agentDir) : getDefaultAgentDir(), resourceLoader = options.resourceLoader, authPath = options.agentDir ? join13(agentDir, "auth.json") : void 0, modelsPath = options.agentDir ? join13(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) {
@@ -5570,8 +5921,8 @@ function applyExtensionFlagValues(resourceLoader, extensionFlagValues) {
 }
 async function createAgentSessionServices(options) {
   let cwd = resolvePath(options.cwd), agentDir = options.agentDir ? resolvePath(options.agentDir) : getAgentDir(), modelRuntime = options.modelRuntime ?? await ModelRuntime.create({
-    authPath: join13(agentDir, "auth.json"),
-    modelsPath: join13(agentDir, "models.json")
+    authPath: join14(agentDir, "auth.json"),
+    modelsPath: join14(agentDir, "models.json")
   });
   time("ModelRuntime.create");
   let settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir), resourceLoader = new DefaultResourceLoader({
@@ -5632,6 +5983,18 @@ export {
   wrapRegisteredTool,
   wrapRegisteredTools,
   ModelRegistry,
+  setRollbackWarningHandler,
+  initRollback,
+  isRollbackEnabled,
+  isRollbackSessionForceEnabled,
+  enableRollbackForSession,
+  disableRollbackForSession,
+  beginTurn,
+  captureTreeChanges,
+  peekRollbackTurnsConsumed,
+  rollbackLastTurn,
+  migrateRollbackSession,
+  clearRollback,
   parseSkillBlock,
   AgentSession,
   getMissingSessionCwdIssue,