@ashx-j/lunr-dev 0.2.13-dev.7.1 → 0.2.16-dev.9.1

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

@@ -0,0 +1,864 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  CONFIG_DIR_NAME,
+  getAgentDir
+} from "./chunk-PCIGF2XK.js";
+
+// packages/coding-agent/dist/core/usage-adapters/shared.js
+async function fetchWithTimeout(url, init, timeoutMs = 1e4) {
+  let controller = new AbortController(), timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function asObject(value) {
+  if (!(!value || typeof value != "object" || Array.isArray(value)))
+    return value;
+}
+function asString(value) {
+  return typeof value == "string" && value.trim() ? value : void 0;
+}
+function asNumber(value) {
+  if (typeof value == "number" && Number.isFinite(value))
+    return value;
+  if (typeof value == "string" && value.trim()) {
+    let parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+}
+function clampPercent(value) {
+  return Math.max(0, Math.min(100, value));
+}
+function toEpochMs(value) {
+  let asNumberValue = asNumber(value);
+  if (asNumberValue !== void 0)
+    return asNumberValue < 1e12 ? Math.round(asNumberValue * 1e3) : Math.round(asNumberValue);
+  let asStringValue = asString(value);
+  if (asStringValue) {
+    let parsed = Date.parse(asStringValue);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+}
+function unwrapVal(value) {
+  let object = asObject(value);
+  return object && "val" in object ? asNumber(object.val) : asNumber(value);
+}
+function usedPercentFromRemaining(limit, remaining) {
+  let total = asNumber(limit), left = asNumber(remaining);
+  if (!(total === void 0 || left === void 0 || total <= 0))
+    return clampPercent(100 - left / total * 100);
+}
+function usedPercentFromUsed(total, used) {
+  let cap = asNumber(total), spent = asNumber(used);
+  if (!(cap === void 0 || spent === void 0 || cap <= 0))
+    return clampPercent(spent / cap * 100);
+}
+
+// packages/coding-agent/dist/core/usage-adapters/kimi-coding.js
+var KIMI_PROVIDER_ID = "kimi-coding", KIMI_USAGE_URL = "https://api.kimi.com/coding/v1/usages", TIME_UNIT_SECONDS = {
+  seconds: 1,
+  second: 1,
+  minutes: 60,
+  minute: 60,
+  hours: 3600,
+  hour: 3600,
+  days: 86400,
+  day: 86400,
+  weeks: 604800,
+  week: 604800
+};
+function durationLabel(duration, timeUnit) {
+  let amount = asNumber(duration), unit = typeof timeUnit == "string" ? timeUnit.toLowerCase() : void 0, seconds = amount !== void 0 && unit ? TIME_UNIT_SECONDS[unit] : void 0;
+  if (amount === void 0 || seconds === void 0)
+    return "Limit";
+  let totalSeconds = amount * seconds;
+  return totalSeconds >= 604800 ? "Weekly" : totalSeconds >= 86400 ? `${Math.round(totalSeconds / 86400)}d` : totalSeconds >= 3600 ? `${Math.round(totalSeconds / 3600)}h` : `${Math.max(1, Math.round(totalSeconds / 60))}m`;
+}
+function detailWindow(label, detail) {
+  let object = asObject(detail);
+  if (!object)
+    return;
+  let usedPercent = usedPercentFromRemaining(object.limit, object.remaining);
+  if (usedPercent !== void 0)
+    return { label, usedPercent, resetsAt: toEpochMs(object.resetTime) };
+}
+async function fetchKimiPlanUsage(runtime) {
+  let apiKey = (await runtime.getAuth(KIMI_PROVIDER_ID))?.auth.apiKey;
+  if (!apiKey)
+    return;
+  let response = await fetchWithTimeout(KIMI_USAGE_URL, {
+    headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" }
+  });
+  if (!response.ok)
+    return;
+  let payload = asObject(await response.json());
+  if (!payload)
+    return;
+  let windows = [], weekly = detailWindow("Weekly", payload.usage);
+  weekly && windows.push(weekly);
+  let limits = Array.isArray(payload.limits) ? payload.limits : [];
+  for (let item of limits) {
+    let limit = asObject(item);
+    if (!limit)
+      continue;
+    let window = detailWindow(durationLabel(asObject(limit.window)?.duration, asObject(limit.window)?.timeUnit), limit.detail);
+    window && windows.push(window);
+  }
+  if (windows.length !== 0)
+    return { provider: KIMI_PROVIDER_ID, windows };
+}
+
+// packages/coding-agent/dist/core/usage-adapters/openai-codex.js
+var CODEX_PROVIDER_ID = "openai-codex", CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage", MAX_ERROR_BODY_CHARS = 600;
+function normalizeBackendPayload(payload) {
+  let snapshots = [], planType = asString(payload.plan_type), primary = normalizeBackendSnapshot("codex", void 0, payload.rate_limit, payload.credits);
+  primary && snapshots.push(primary);
+  let additional = Array.isArray(payload.additional_rate_limits) ? payload.additional_rate_limits : [];
+  for (let item of additional) {
+    let additionalLimit = asObject(item);
+    if (!additionalLimit)
+      continue;
+    let limitId = asString(additionalLimit.metered_feature) ?? asString(additionalLimit.limit_name);
+    if (limitId)
+      try {
+        let snapshot = normalizeBackendSnapshot(limitId, asString(additionalLimit.limit_name), additionalLimit.rate_limit, void 0);
+        snapshot && snapshots.push(snapshot);
+      } catch {
+      }
+  }
+  if (snapshots.length === 0)
+    throw new Error("Codex usage endpoint returned no displayable usage data.");
+  return { planType, snapshots };
+}
+function normalizeBackendSnapshot(limitId, limitName, rateLimit, credits) {
+  if (rateLimit == null)
+    return normalizeBackendCredits(credits) ? { limitId, limitName } : void 0;
+  let details = asObject(rateLimit);
+  if (!details)
+    throw new Error("rate limit was not an object.");
+  let primary = normalizeBackendWindow(details.primary_window), secondary = normalizeBackendWindow(details.secondary_window);
+  if (!(!primary && !secondary && !normalizeBackendCredits(credits)))
+    return { limitId, limitName, primary, secondary };
+}
+function normalizeBackendWindow(value) {
+  if (value == null)
+    return;
+  let window = asObject(value);
+  if (!window)
+    throw new Error("rate-limit window was not an object.");
+  let usedPercent = asNumber(window.used_percent);
+  if (usedPercent === void 0)
+    return;
+  let limitSeconds = asNumber(window.limit_window_seconds);
+  return {
+    usedPercent,
+    windowMinutes: limitSeconds && limitSeconds > 0 ? Math.ceil(limitSeconds / 60) : void 0,
+    resetsAt: toEpochMs(window.reset_at)
+  };
+}
+function normalizeBackendCredits(value) {
+  let credits = asObject(value);
+  return credits ? credits.has_credits !== void 0 && credits.unlimited !== void 0 : !1;
+}
+async function resolveCodexHeaders(runtime) {
+  let candidates = [], seen = /* @__PURE__ */ new Set(), add = (model) => {
+    if (!model || model.provider !== CODEX_PROVIDER_ID)
+      return;
+    let key = `${model.provider}/${model.id}`;
+    seen.has(key) || (seen.add(key), candidates.push(model));
+  };
+  for (let model of runtime.getAvailableSnapshot())
+    add(model);
+  for (let model of runtime.getModels())
+    add(model);
+  for (let model of candidates) {
+    let resolution;
+    try {
+      resolution = await runtime.getAuth(model);
+    } catch {
+      continue;
+    }
+    if (!resolution)
+      continue;
+    let headers = {};
+    for (let [name, value] of Object.entries(resolution.auth.headers ?? {}))
+      value != null && (headers[name] = String(value));
+    if (!hasHeader(headers, "Authorization") && resolution.auth.apiKey && (headers.Authorization = `Bearer ${resolution.auth.apiKey}`), hasHeader(headers, "User-Agent") || (headers["User-Agent"] = "lunr-usage-service"), hasHeader(headers, "Authorization"))
+      return headers;
+  }
+}
+function hasHeader(headers, name) {
+  return Object.keys(headers).some((key) => key.toLowerCase() === name.toLowerCase());
+}
+function redactErrorBody(body) {
+  let redacted = body.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer <redacted>").replace(/"access_token"\s*:\s*"[^"]+"/gi, '"access_token":"<redacted>"').trim();
+  return redacted.length > MAX_ERROR_BODY_CHARS ? `${redacted.slice(0, MAX_ERROR_BODY_CHARS - 1)}\u2026` : redacted;
+}
+function windowLabel(window, fallback) {
+  let minutes = window.windowMinutes;
+  return minutes === void 0 ? fallback ?? "Limit" : minutes >= 10080 ? "Weekly" : minutes >= 1440 ? `${Math.round(minutes / 1440)}d` : minutes >= 60 ? `${Math.round(minutes / 60)}h` : `${minutes}m`;
+}
+function toPlanUsage(report) {
+  return report.snapshots.flatMap((snapshot, index) => {
+    let windows = [];
+    for (let window of [snapshot.secondary, snapshot.primary])
+      window && windows.push({
+        label: windowLabel(window, snapshot.limitName),
+        usedPercent: window.usedPercent,
+        resetsAt: window.resetsAt
+      });
+    return windows.length === 0 ? [] : [
+      {
+        provider: CODEX_PROVIDER_ID,
+        planLabel: index === 0 ? report.planType : snapshot.limitName ?? snapshot.limitId,
+        windows
+      }
+    ];
+  });
+}
+async function fetchCodexPlanUsage(runtime) {
+  let headers = await resolveCodexHeaders(runtime);
+  if (!headers)
+    return;
+  let response = await fetchWithTimeout(CODEX_USAGE_URL, { headers }), text = await response.text();
+  if (!response.ok)
+    throw new Error(`Codex usage endpoint returned ${response.status}: ${redactErrorBody(text)}`);
+  let payload = asObject(JSON.parse(text));
+  if (payload)
+    return toPlanUsage(normalizeBackendPayload(payload));
+}
+
+// packages/coding-agent/dist/core/usage-adapters/xai.js
+import { ModelsError } from "@ashx-j/lunr-ai";
+var XAI_PROVIDER_ID = "xai", XAI_BILLING_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+function currentPeriod(config) {
+  return asObject(config.currentPeriod) ?? asObject(config.current_period);
+}
+function weeklyWindow(config) {
+  let period = currentPeriod(config), raw = unwrapVal(config.creditUsagePercent ?? config.credit_usage_percent);
+  return raw === void 0 && !period ? void 0 : {
+    label: "Weekly",
+    usedPercent: raw === void 0 ? 0 : clampPercent(raw),
+    resetsAt: toEpochMs(period?.end)
+  };
+}
+async function fetchXaiPlanUsage(runtime) {
+  if (!runtime.isUsingOAuth(XAI_PROVIDER_ID))
+    return;
+  let accessToken = (await runtime.getAuth(XAI_PROVIDER_ID))?.auth.apiKey;
+  if (!accessToken)
+    return;
+  let response = await fetchWithTimeout(XAI_BILLING_URL, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      Accept: "application/json",
+      "x-xai-token-auth": "xai-grok-cli"
+    }
+  });
+  if (response.status === 401 || response.status === 403)
+    throw new ModelsError("oauth", `xAI billing rejected the session (HTTP ${response.status})`);
+  if (!response.ok)
+    return;
+  let payload = asObject(await response.json());
+  if (!payload)
+    return;
+  let config = asObject(payload.config) ?? payload, windows = [], weekly = weeklyWindow(config);
+  weekly && windows.push(weekly);
+  let onDemandCap = unwrapVal(config.onDemandCap);
+  if (onDemandCap !== void 0 && onDemandCap > 0) {
+    let usedPercent = usedPercentFromUsed(onDemandCap, unwrapVal(config.onDemandUsed) ?? 0);
+    usedPercent !== void 0 && windows.push({
+      label: "Extra",
+      usedPercent,
+      resetsAt: weekly?.resetsAt
+    });
+  }
+  if (windows.length === 0)
+    return;
+  let planLabel = asString(config.subscriptionTier) ?? asString(config.subscription_tier);
+  return { provider: XAI_PROVIDER_ID, planLabel, windows };
+}
+
+// packages/coding-agent/dist/core/usage-adapters/zai.js
+var ZAI_PROVIDER_ID = "zai", ZAI_QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
+function limitLabel(limit) {
+  let type = asString(limit.type);
+  if (type === "TIME_LIMIT")
+    return "Monthly";
+  if (type !== "TOKENS_LIMIT")
+    return;
+  let unit = asNumber(limit.unit), number = asNumber(limit.number);
+  return unit === 1 && number !== void 0 ? `${number}d` : unit === 3 && number !== void 0 ? `${number}h` : unit === 5 && number !== void 0 ? `${number}m` : unit === 6 ? "Weekly" : "Limit";
+}
+async function fetchZaiPlanUsage(runtime) {
+  let apiKey = (await runtime.getAuth(ZAI_PROVIDER_ID))?.auth.apiKey;
+  if (!apiKey)
+    return;
+  let response = await fetchWithTimeout(ZAI_QUOTA_URL, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      Accept: "application/json",
+      "Accept-Language": "en-US,en"
+    }
+  });
+  if (!response.ok)
+    return;
+  let payload = asObject(await response.json());
+  if (!payload || payload.success !== !0 || asNumber(payload.code) !== 200)
+    return;
+  let data = asObject(payload.data), limits = Array.isArray(data?.limits) ? data.limits : [], windows = [];
+  for (let item of limits) {
+    let limit = asObject(item);
+    if (!limit)
+      continue;
+    let label = limitLabel(limit), percentage = asNumber(limit.percentage);
+    !label || percentage === void 0 || windows.push({ label, usedPercent: clampPercent(percentage), resetsAt: toEpochMs(limit.nextResetTime) });
+  }
+  if (windows.length === 0)
+    return;
+  let planLabel = asString(data?.planName) ?? asString(data?.plan) ?? asString(data?.level);
+  return { provider: ZAI_PROVIDER_ID, planLabel, windows };
+}
+
+// packages/coding-agent/dist/core/usage-service.js
+var XAI_RELOGIN = "xAI login expired. Run /login xai.";
+function errorChain(error) {
+  let parts = [], current = error, seen = /* @__PURE__ */ new Set();
+  for (; current && typeof current == "object" && !seen.has(current); ) {
+    if (seen.add(current), current instanceof Error) {
+      parts.push(current.message), current = current.cause;
+      continue;
+    }
+    break;
+  }
+  return parts.join(" ");
+}
+function planUsageAuthError(error) {
+  let chain = errorChain(error);
+  if (!/timed out|aborted|cancelled|ECONN|ENOTFOUND|network/i.test(chain) && (/xai billing rejected the session \(HTTP 401\)/i.test(chain) || /invalid_grant|refresh token revoked/i.test(chain)))
+    return XAI_RELOGIN;
+}
+var ADAPTERS = {
+  "openai-codex": fetchCodexPlanUsage,
+  "kimi-coding": fetchKimiPlanUsage,
+  zai: fetchZaiPlanUsage,
+  xai: fetchXaiPlanUsage
+}, PLAN_USAGE_CACHE_TTL_MS = 60 * 1e3;
+function isWeeklyPlanWindow(window) {
+  return /week/i.test(window.label);
+}
+function isFiveHourPlanWindow(window) {
+  return /5h/i.test(window.label) || window.label === "5h";
+}
+function pickPlanWindow(usage, preferred) {
+  if (!usage?.windows.length)
+    return;
+  let usable = usage.windows.filter((w) => !/extra/i.test(w.label)), weekly = usable.find(isWeeklyPlanWindow), fiveH = usable.find(isFiveHourPlanWindow);
+  return preferred === "5h" ? fiveH ?? weekly ?? usable[0] ?? usage.windows[0] : weekly ?? fiveH ?? usable[0] ?? usage.windows[0];
+}
+function footerPlanLabel(window) {
+  return isFiveHourPlanWindow(window) ? "5h" : isWeeklyPlanWindow(window) ? "wk" : window.label.length <= 4 ? window.label : window.label.slice(0, 4);
+}
+var cache = /* @__PURE__ */ new Map(), inflight = /* @__PURE__ */ new Map();
+function hasPlanUsageAdapter(providerId) {
+  return providerId in ADAPTERS;
+}
+async function getPlanUsage(providerId, runtime) {
+  return (await getPlanUsageResult(providerId, runtime)).usage;
+}
+async function getPlanUsageResult(providerId, runtime) {
+  let adapter = ADAPTERS[providerId];
+  if (!adapter)
+    return {};
+  let now = Date.now(), cached = cache.get(providerId);
+  if (cached && cached.expiresAt > now)
+    return { usage: cached.value[0], usages: cached.value };
+  let pending = inflight.get(providerId);
+  if (pending)
+    return pending;
+  let task = (async () => {
+    try {
+      let value = await adapter(runtime), usages = value === void 0 ? [] : Array.isArray(value) ? value : [value];
+      return cache.set(providerId, { expiresAt: Date.now() + PLAN_USAGE_CACHE_TTL_MS, value: usages }), { usage: usages[0], usages };
+    } catch (error) {
+      let authError = planUsageAuthError(error);
+      return authError ? { error: authError } : (cache.set(providerId, { expiresAt: Date.now() + PLAN_USAGE_CACHE_TTL_MS, value: [] }), {});
+    } finally {
+      inflight.delete(providerId);
+    }
+  })();
+  return inflight.set(providerId, task), task;
+}
+async function getAllPlanUsageResults(currentProvider, runtime) {
+  let stored = new Set((await runtime.listCredentials()).map((credential) => credential.providerId)), providers = Object.keys(ADAPTERS).filter((providerId) => stored.has(providerId) || providerId === currentProvider), results = await Promise.all(providers.map((providerId) => getPlanUsageResult(providerId, runtime)));
+  return {
+    usages: results.flatMap((result) => result.usages ?? []),
+    errors: results.flatMap((result) => result.error ? [`${result.error}`] : [])
+  };
+}
+function peekPlanUsage(providerId) {
+  return cache.get(providerId)?.value[0];
+}
+function clearPlanUsageCache() {
+  cache.clear(), inflight.clear();
+}
+var USAGE_SERVICE_BRIDGE_SYMBOL = /* @__PURE__ */ Symbol.for("@lunr/usage-service"), activeRuntime, activeUsageSettings, onUsageUpdate;
+function preferredWindow() {
+  return activeUsageSettings?.getPlanUsageWindow() ?? "weekly";
+}
+var usageBridge = {
+  peek(providerId) {
+    return peekPlanUsage(providerId);
+  },
+  prefetch(providerId) {
+    !activeRuntime || !hasPlanUsageAdapter(providerId) || getPlanUsage(providerId, activeRuntime).then(() => onUsageUpdate?.());
+  },
+  setOnUpdate(fn) {
+    onUsageUpdate = fn;
+  },
+  getPreferredWindow() {
+    return preferredWindow();
+  },
+  pickForFooter(providerId) {
+    let window = pickPlanWindow(peekPlanUsage(providerId), preferredWindow());
+    if (window)
+      return { label: footerPlanLabel(window), usedPercent: window.usedPercent };
+  }
+};
+function registerUsageServiceBridge(runtime, settingsManager) {
+  activeRuntime = runtime, activeUsageSettings = settingsManager, globalThis[USAGE_SERVICE_BRIDGE_SYMBOL] = usageBridge;
+}
+function getUsageServiceBridge() {
+  return globalThis[USAGE_SERVICE_BRIDGE_SYMBOL];
+}
+
+// packages/coding-agent/dist/core/rollback.js
+import { spawnSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { closeSync, cpSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, normalize, relative, 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 getAllowedRoots(turn) {
+  return turn.cwd ? [
+    ROLLBACK_BASE,
+    join(homedir(), CONFIG_DIR_NAME),
+    join(dirname(getAgentDir()), "simple-memory"),
+    resolve(turn.cwd)
+  ] : [];
+}
+function findAllowedRoot(absPath, turn) {
+  return getAllowedRoots(turn).filter((root) => isPathUnderRoot(absPath, root)).sort((a, b) => b.length - a.length)[0];
+}
+function lstatIfPresent(path) {
+  try {
+    return lstatSync(path);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function safeRestoreParent(absPath, turn) {
+  let allowedRoot = findAllowedRoot(absPath, turn);
+  if (turn.cwd && !allowedRoot || lstatIfPresent(absPath)?.isSymbolicLink())
+    return;
+  if (!allowedRoot)
+    return dirname(absPath);
+  let rootEntry = lstatIfPresent(allowedRoot);
+  if (!rootEntry || !rootEntry.isDirectory() || rootEntry.isSymbolicLink())
+    return;
+  let parent = dirname(absPath), relativeParent = relative(allowedRoot, parent);
+  if (relativeParent.startsWith("..") || !isPathUnderRoot(parent, allowedRoot))
+    return;
+  let current = allowedRoot;
+  for (let segment of relativeParent.split(/[\\/]/).filter(Boolean)) {
+    current = join(current, segment);
+    let entry = lstatIfPresent(current);
+    if (entry) {
+      if (entry.isSymbolicLink() || !entry.isDirectory())
+        return;
+    } else
+      mkdirSync(current);
+  }
+  let realRoot = realpathSync.native(allowedRoot), realParent = realpathSync.native(parent);
+  if (isPathUnderRoot(realParent, realRoot) && !lstatIfPresent(absPath)?.isSymbolicLink())
+    return parent;
+}
+function restoreFileAtomically(absPath, content, turn) {
+  let parent = safeRestoreParent(absPath, turn);
+  if (!parent)
+    return !1;
+  let tempPath = join(parent, `.lunr-rollback-${randomUUID()}.tmp`), fd;
+  try {
+    return fd = openSync(tempPath, "wx", 384), writeFileSync(fd, content), fsyncSync(fd), closeSync(fd), fd = void 0, safeRestoreParent(absPath, turn) ? (renameSync(tempPath, absPath), !0) : !1;
+  } finally {
+    fd !== void 0 && closeSync(fd), rmSync(tempPath, { force: !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 (turn.cwd && !findAllowedRoot(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;
+        if (!restoreFileAtomically(absPath, snap.content, turn)) {
+          warnExternalModification(ctx, `Rollback skipped ${absPath}: a symlink or junction made the path unsafe.`);
+          continue;
+        }
+        restored.push(absPath);
+      } else if (!snap.existed && (snap.createdByTool || capture === "hybrid" || capture === "shadow-git") && lstatIfPresent(absPath)) {
+        if (!safeRestoreParent(absPath, turn)) {
+          warnExternalModification(ctx, `Rollback skipped ${absPath}: a symlink or junction made the path unsafe.`);
+          continue;
+        }
+        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
+};