@ashx-j/lunr 0.2.19 → 0.2.20

package/dist/node-runtime/{chunk-4FX25LWP.js → chunk-K3646JTM.js}

@@ -5,7 +5,7 @@ import {
 import {
   isPlanModeActive,
   requestPlanApproval
-} from "./chunk-J26TSGDL.js";
+} from "./chunk-6N22HULO.js";
 import {
   ashxj_tui_default
 } from "./chunk-JHYKXIMM.js";
@@ -49,12 +49,12 @@ function readMemory() {
   let file = memoryFile();
   return existsSync(file) ? readFileSync(file, "utf-8") : "";
 }
-function writeMemoryRaw(text2) {
-  ensureDir(), writeFileSync(memoryFile(), text2, "utf-8");
+function writeMemoryRaw(text) {
+  ensureDir(), writeFileSync(memoryFile(), text, "utf-8");
 }
 function memoryLines() {
-  let text2 = readMemory();
-  return text2.trim() ? text2.split(`
+  let text = readMemory();
+  return text.trim() ? text.split(`
 `).filter((l) => l.trim().length > 0) : [];
 }
 function clampCap(n) {
@@ -1089,11 +1089,11 @@ function lunr_todos_default(pi) {
       return;
     }
     ctx.ui.setWidget(WIDGET_KEY, (_tui, theme) => {
-      let text2 = new Text(lines.map((l) => colorize(l, theme)).join(`
+      let text = new Text(lines.map((l) => colorize(l, theme)).join(`
 `), 1, 0);
       return {
-        render: (width) => text2.render(width),
-        invalidate: () => text2.invalidate?.(),
+        render: (width) => text.render(width),
+        invalidate: () => text.invalidate?.(),
         handleClick: () => (expanded = !expanded, refreshWidget(), !0)
       };
     }, { placement: "aboveEditor" });
@@ -1135,12 +1135,12 @@ function lunr_todos_default(pi) {
       }))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      let text2 = (t) => ({ content: [{ type: "text", text: t }] });
+      let text = (t) => ({ content: [{ type: "text", text: t }] });
       return todos = (Array.isArray(params?.todos) ? params.todos : []).filter((t) => t && typeof t.content == "string" && t.content.trim().length > 0).map((t, i) => ({
         id: typeof t.id == "string" && t.id ? t.id : String(i + 1),
         content: t.content.trim(),
         status: t.status === "in_progress" || t.status === "completed" ? t.status : "pending"
-      })), lastCtx = ctx, refreshWidget(), text2(summarizeTodos(todos));
+      })), lastCtx = ctx, refreshWidget(), text(summarizeTodos(todos));
     },
     renderCall(args, theme) {
       let n = Array.isArray(args?.todos) ? args.todos.length : 0, detail = n === 0 ? "clear" : `${n} item${n === 1 ? "" : "s"}`;
@@ -1184,8 +1184,8 @@ function lunr_plan_tools_default(pi) {
     renderResult(result, { isPartial }, theme) {
       if (isPartial)
         return new Text2(theme.fg("warning", "Presenting plan..."), 0, 0);
-      let first = result?.content?.[0], text2 = first?.type === "text" ? first.text : "";
-      return new Text2(theme.fg("dim", text2), 0, 0);
+      let first = result?.content?.[0], text = first?.type === "text" ? first.text : "";
+      return new Text2(theme.fg("dim", text), 0, 0);
     }
   });
 }
@@ -1198,106 +1198,6 @@ function lunr_skill_creator_default(pi) {
   pi.on("resources_discover", async () => ({ skillPaths: [SKILLS_DIR] }));
 }
 
-// packages/coding-agent/dist/builtin-extensions/lunr-settings-tools.js
-var SETTINGS_BRIDGE = /* @__PURE__ */ Symbol.for("@lunr/settings-tools"), MODEL_TIERS_BRIDGE = /* @__PURE__ */ Symbol.for("@lunr/model-tiers"), DETAILED_SETTINGS_TOOL_NAMES = [
-  "settings_model_tiers",
-  "settings_subscriptions",
-  "settings_rollback",
-  "settings_session_retention"
-];
-function settingsBridge() {
-  let bridge = globalThis[SETTINGS_BRIDGE];
-  if (!bridge)
-    throw new Error("Settings are unavailable in this runtime. Reload lunR and try again.");
-  return bridge;
-}
-function text(value, guidance) {
-  return {
-    content: [{ type: "text", text: `${JSON.stringify(value, null, 2)}
-
-${guidance}` }],
-    details: value
-  };
-}
-var thinking = typebox_exports.Union([
-  typebox_exports.Literal("off"),
-  typebox_exports.Literal("minimal"),
-  typebox_exports.Literal("low"),
-  typebox_exports.Literal("medium"),
-  typebox_exports.Literal("high"),
-  typebox_exports.Literal("xhigh"),
-  typebox_exports.Literal("max"),
-  typebox_exports.Null()
-], { description: "Per-tier thinking level. null inherits the parent session thinking level." });
-function lunrSettingsTools(pi) {
-  let loaded = !1, registerDetailedTools = () => {
-    loaded || (loaded = !0, pi.registerTool({
-      name: "settings_model_tiers",
-      label: "Model tiers",
-      description: "Read or partially update light, standard, and heavy subagent model routes and their thinking levels. Models use provider/model ids. Omitted fields are unchanged.",
-      parameters: typebox_exports.Object({
-        enabled: typebox_exports.Optional(typebox_exports.Boolean({ description: "Enable or disable tier-based child routing." })),
-        light: typebox_exports.Optional(typebox_exports.String({ minLength: 1, description: "Model route for light work." })),
-        standard: typebox_exports.Optional(typebox_exports.String({ minLength: 1, description: "Model route for standard work." })),
-        heavy: typebox_exports.Optional(typebox_exports.String({ minLength: 1, description: "Model route for heavy work." })),
-        lightThinking: typebox_exports.Optional(thinking),
-        standardThinking: typebox_exports.Optional(thinking),
-        heavyThinking: typebox_exports.Optional(thinking)
-      }, { additionalProperties: !1 }),
-      async execute(_id, params) {
-        let bridge = settingsBridge();
-        return Object.keys(params).length > 0 && (bridge.setModelTiers(params), globalThis[MODEL_TIERS_BRIDGE]?.refreshToolDescription?.()), text(bridge.getModelTiers(), Object.keys(params).length > 0 ? "Tier routes are saved and apply to the next child launch; the subagent schema guidance is refreshed now." : "Pass only the fields you want to change. Child launches still validate model availability and authentication.");
-      }
-    }), pi.registerTool({
-      name: "settings_subscriptions",
-      label: "Subscription management",
-      description: "Read or update automatic management of multiple stored provider subscriptions. Omit enabled to read without changing it.",
-      parameters: typebox_exports.Object({ enabled: typebox_exports.Optional(typebox_exports.Boolean()) }, { additionalProperties: !1 }),
-      async execute(_id, params) {
-        let bridge = settingsBridge();
-        return params.enabled !== void 0 && bridge.setAutoManageSubscriptions(params.enabled), text({ enabled: bridge.getAutoManageSubscriptions() }, params.enabled === void 0 ? "Set enabled to change automatic subscription selection." : "The setting is saved and applies to subsequent provider requests.");
-      }
-    }), pi.registerTool({
-      name: "settings_rollback",
-      label: "Rollback",
-      description: "Read or partially update rollback behavior: enabled, retained turns, capture strategy, and scope. Omitted fields are unchanged. Auto permission mode force-enables rollback for its current session.",
-      parameters: typebox_exports.Object({
-        enabled: typebox_exports.Optional(typebox_exports.Boolean()),
-        turns: typebox_exports.Optional(typebox_exports.Integer({ minimum: 1, maximum: 20 })),
-        capture: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Literal("copies"), typebox_exports.Literal("shadow-git"), typebox_exports.Literal("hybrid")])),
-        scope: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Literal("tools"), typebox_exports.Literal("tree")]))
-      }, { additionalProperties: !1 }),
-      async execute(_id, params) {
-        let bridge = settingsBridge();
-        Object.keys(params).length > 0 && bridge.setRollback(params);
-        let current = bridge.getRollback();
-        return text(current, current.forcedByAuto ? "Saved settings apply normally, but rollback remains force-enabled for this Auto-mode session." : Object.keys(params).length > 0 ? "Rollback settings are saved and live for subsequent tool calls." : "Pass only the fields you want to change.");
-      }
-    }), pi.registerTool({
-      name: "settings_session_retention",
-      label: "Session retention",
-      description: "Read or update how many days saved sessions are retained. Set days to 0 to keep sessions forever. Cleanup applies on a later launch, not retroactively in this turn.",
-      parameters: typebox_exports.Object({ days: typebox_exports.Optional(typebox_exports.Integer({ minimum: 0, maximum: 36500 })) }, { additionalProperties: !1 }),
-      async execute(_id, params) {
-        let bridge = settingsBridge();
-        return params.days !== void 0 && bridge.setSessionRetentionDays(params.days), text({ days: bridge.getSessionRetentionDays() }, params.days === void 0 ? "Set days to change retention; 0 keeps sessions forever." : "The setting is saved. Session cleanup uses it on a later launch.");
-      }
-    }));
-  };
-  pi.registerTool({
-    name: "settings_load",
-    label: "Settings",
-    description: "Load four narrow agent-managed settings tools for model tiers, subscription management, rollback, and session retention. Call only when the task requires inspecting or changing those settings.",
-    promptSnippet: "Load narrow settings controls on demand",
-    promptGuidelines: ["Call settings_load only when the user asks to inspect or change model tiers, subscription management, rollback, or session retention."],
-    parameters: typebox_exports.Object({}, { additionalProperties: !1 }),
-    async execute() {
-      let alreadyLoaded = loaded;
-      return registerDetailedTools(), pi.setActiveTools([.../* @__PURE__ */ new Set([...pi.getActiveTools(), ...DETAILED_SETTINGS_TOOL_NAMES])]), text({ activated: [...DETAILED_SETTINGS_TOOL_NAMES], alreadyLoaded }, "The four tools are active for the next model step and remain active in this runtime. A new runtime starts with only settings_load visible.");
-    }
-  });
-}
-
 // packages/coding-agent/dist/builtin-extensions/index.js
 function ext(name, factory) {
   return { name, factory };
@@ -1311,15 +1211,14 @@ var lightBuiltinExtensions = [
   ext("lunr-local-providers", lunrLocalProviders),
   ext("lunr-todos", lunr_todos_default),
   ext("lunr-plan-tools", lunr_plan_tools_default),
-  ext("lunr-skill-creator", lunr_skill_creator_default),
-  ext("lunr-settings-tools", lunrSettingsTools)
+  ext("lunr-skill-creator", lunr_skill_creator_default)
 ], DEFERRED_BUILTIN_LOADERS = [
   { name: "pi-ollama-cloud", load: () => import("./pi-ollama-cloud-2F3Y2QNM.js") },
   { name: "narumiruna-pi-goal", load: () => import("./goal-NJEE5CTU.js") },
-  { name: "lunr-cron", load: () => import("./lunr-cron-QPBTKBGI.js") },
-  { name: "pi-intercom", load: () => import("./pi-intercom-EEMBGQID.js") },
+  { name: "lunr-cron", load: () => import("./lunr-cron-NNYTWTGF.js") },
+  { name: "pi-intercom", load: () => import("./pi-intercom-DDQMRNPJ.js") },
   { name: "pi-prompt-template-model", load: () => import("./pi-prompt-template-model-QWTCGLJU.js") },
-  { name: "pi-subagents", load: () => import("./pi-subagents-7YJ3I4VE.js") },
+  { name: "pi-subagents", load: () => import("./pi-subagents-T5WMMLBB.js") },
   { name: "pi-web-access", load: () => import("./pi-web-access-2CQGFLT2.js") },
   { name: "pi-lsp-extension", load: () => import("./src-BPQFJR76.js") },
   { name: "pi-mcp-adapter", load: () => import("./pi-mcp-adapter-GUFZWW54.js") }

package/dist/node-runtime/{chunk-PNJSG3IZ.js → chunk-LTYWTR3V.js}

@@ -1,8 +1,4 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
-import {
-  CONFIG_DIR_NAME,
-  getAgentDir
-} from "./chunk-FQMM2EZ2.js";
 
 // packages/coding-agent/dist/core/usage-adapters/shared.js
 async function fetchWithTimeout(url, init, timeoutMs = 1e4) {
@@ -435,373 +431,9 @@ function getUsageServiceBridge() {
   return globalThis[USAGE_SERVICE_BRIDGE_SYMBOL];
 }
 
-// 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, normalize, resolve } from "node:path";
-var ROLLBACK_BASE = join(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 = join(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 = join(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 = join(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 = join(turnDir, "manifest.json"), manifest = readManifest(manifestPath), entry = { existed: snap.existed, createdByTool: snap.createdByTool };
-    if (snap.content) {
-      let snapFile = snapFileName(absPath);
-      writeFileSync(join(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 = join(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 = join(sessionDir, dirName), manifest = readManifest(join(turnDir, "manifest.json")), files = /* @__PURE__ */ new Map();
-      for (let [absPath, meta] of Object.entries(manifest.files)) {
-        let content;
-        if (meta.snapFile)
-          try {
-            content = readFileSync(join(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 join(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,
-    join(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)
-    join(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 = join(ROLLBACK_BASE, oldSessionId), newDir = join(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 = join(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 = join(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`;
-}
-
 export {
   getAllPlanUsageResults,
   clearPlanUsageCache,
   registerUsageServiceBridge,
-  getUsageServiceBridge,
-  setRollbackWarningHandler,
-  initRollback,
-  isRollbackEnabled,
-  isRollbackSessionForceEnabled,
-  enableRollbackForSession,
-  disableRollbackForSession,
-  beginTurn,
-  rollbackSnapshotBeforeWrite,
-  captureTreeChanges,
-  peekRollbackTurnsConsumed,
-  rollbackLastTurn,
-  migrateRollbackSession,
-  clearRollback
+  getUsageServiceBridge
 };