reasonix 0.0.4 → 0.0.6

package/dist/index.js

@@ -1,8 +1,258 @@
-import {
-  DeepSeekClient,
-  Usage,
-  fetchWithRetry
-} from "./chunk-Y7L6L5QS.js";
+// src/client.ts
+import { createParser } from "eventsource-parser";
+
+// src/retry.ts
+var DEFAULT_RETRYABLE_STATUSES = [408, 429, 500, 502, 503, 504];
+async function fetchWithRetry(fetchFn, url, init, opts = {}) {
+  const maxAttempts = opts.maxAttempts ?? 4;
+  const initial = opts.initialBackoffMs ?? 500;
+  const cap = opts.maxBackoffMs ?? 1e4;
+  const retryable = new Set(opts.retryableStatuses ?? DEFAULT_RETRYABLE_STATUSES);
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (opts.signal?.aborted) throw new Error("aborted");
+    try {
+      const resp = await fetchFn(url, init);
+      if (resp.ok || !retryable.has(resp.status)) return resp;
+      if (attempt === maxAttempts - 1) return resp;
+      await resp.text().catch(() => void 0);
+      const waitMs = computeWait(attempt, initial, cap, resp.headers.get("Retry-After"));
+      opts.onRetry?.({ attempt: attempt + 1, reason: `http ${resp.status}`, waitMs });
+      await sleep(waitMs, opts.signal);
+    } catch (err) {
+      lastError = err;
+      if (isAbortError(err) || opts.signal?.aborted) throw err;
+      if (attempt === maxAttempts - 1) throw err;
+      const waitMs = computeWait(attempt, initial, cap, null);
+      opts.onRetry?.({
+        attempt: attempt + 1,
+        reason: `network: ${messageOf(err)}`,
+        waitMs
+      });
+      await sleep(waitMs, opts.signal);
+    }
+  }
+  throw lastError ?? new Error("fetchWithRetry: loop exited unexpectedly");
+}
+function computeWait(attempt, initial, cap, retryAfter) {
+  if (retryAfter) {
+    const seconds = Number.parseFloat(retryAfter);
+    if (Number.isFinite(seconds) && seconds > 0) {
+      return Math.min(seconds * 1e3, cap);
+    }
+  }
+  const exp = initial * 2 ** attempt;
+  const jitter = exp * (0.75 + Math.random() * 0.5);
+  return Math.min(Math.max(jitter, 0), cap);
+}
+function sleep(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(resolve2, ms);
+    if (signal) {
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(new Error("aborted"));
+      };
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+function isAbortError(err) {
+  if (!err || typeof err !== "object") return false;
+  const name = err.name;
+  return name === "AbortError";
+}
+function messageOf(err) {
+  if (err instanceof Error) return err.message;
+  try {
+    return String(err);
+  } catch {
+    return "unknown error";
+  }
+}
+
+// src/client.ts
+var Usage = class _Usage {
+  constructor(promptTokens = 0, completionTokens = 0, totalTokens = 0, promptCacheHitTokens = 0, promptCacheMissTokens = 0) {
+    this.promptTokens = promptTokens;
+    this.completionTokens = completionTokens;
+    this.totalTokens = totalTokens;
+    this.promptCacheHitTokens = promptCacheHitTokens;
+    this.promptCacheMissTokens = promptCacheMissTokens;
+  }
+  promptTokens;
+  completionTokens;
+  totalTokens;
+  promptCacheHitTokens;
+  promptCacheMissTokens;
+  get cacheHitRatio() {
+    const denom = this.promptCacheHitTokens + this.promptCacheMissTokens;
+    return denom > 0 ? this.promptCacheHitTokens / denom : 0;
+  }
+  static fromApi(raw) {
+    const u = raw ?? {};
+    return new _Usage(
+      u.prompt_tokens ?? 0,
+      u.completion_tokens ?? 0,
+      u.total_tokens ?? 0,
+      u.prompt_cache_hit_tokens ?? 0,
+      u.prompt_cache_miss_tokens ?? 0
+    );
+  }
+};
+var DeepSeekClient = class {
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  retry;
+  _fetch;
+  constructor(opts = {}) {
+    const apiKey = opts.apiKey ?? process.env.DEEPSEEK_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "DEEPSEEK_API_KEY is not set. Put it in .env or pass apiKey to DeepSeekClient."
+      );
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = (opts.baseUrl ?? process.env.DEEPSEEK_BASE_URL ?? "https://api.deepseek.com").replace(/\/+$/, "");
+    this.timeoutMs = opts.timeoutMs ?? 12e4;
+    this._fetch = opts.fetch ?? globalThis.fetch.bind(globalThis);
+    this.retry = opts.retry ?? {};
+  }
+  buildPayload(opts, stream) {
+    const payload = {
+      model: opts.model,
+      messages: opts.messages,
+      stream
+    };
+    if (opts.tools?.length) payload.tools = opts.tools;
+    if (opts.temperature !== void 0) payload.temperature = opts.temperature;
+    if (opts.maxTokens !== void 0) payload.max_tokens = opts.maxTokens;
+    if (opts.responseFormat) payload.response_format = opts.responseFormat;
+    return payload;
+  }
+  async chat(opts) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    const signal = opts.signal ?? ctrl.signal;
+    try {
+      const resp = await fetchWithRetry(
+        this._fetch,
+        `${this.baseUrl}/chat/completions`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(this.buildPayload(opts, false)),
+          signal
+        },
+        { ...this.retry, signal }
+      );
+      if (!resp.ok) {
+        throw new Error(`DeepSeek ${resp.status}: ${await resp.text()}`);
+      }
+      const data = await resp.json();
+      const choice = data.choices?.[0]?.message ?? {};
+      return {
+        content: choice.content ?? "",
+        reasoningContent: choice.reasoning_content ?? null,
+        toolCalls: choice.tool_calls ?? [],
+        usage: Usage.fromApi(data.usage),
+        raw: data
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async *stream(opts) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    const signal = opts.signal ?? ctrl.signal;
+    let resp;
+    try {
+      resp = await fetchWithRetry(
+        this._fetch,
+        `${this.baseUrl}/chat/completions`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            Accept: "text/event-stream"
+          },
+          body: JSON.stringify(this.buildPayload(opts, true)),
+          signal
+        },
+        { ...this.retry, signal }
+      );
+    } catch (err) {
+      clearTimeout(timer);
+      throw err;
+    }
+    if (!resp.ok || !resp.body) {
+      clearTimeout(timer);
+      throw new Error(`DeepSeek ${resp.status}: ${await resp.text().catch(() => "")}`);
+    }
+    const queue = [];
+    let done = false;
+    const parser = createParser({
+      onEvent: (ev) => {
+        if (!ev.data || ev.data === "[DONE]") {
+          done = true;
+          return;
+        }
+        try {
+          const json = JSON.parse(ev.data);
+          const delta = json.choices?.[0]?.delta ?? {};
+          const finishReason = json.choices?.[0]?.finish_reason ?? void 0;
+          const chunk = { raw: json, finishReason };
+          if (typeof delta.content === "string" && delta.content.length > 0) {
+            chunk.contentDelta = delta.content;
+          }
+          if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
+            chunk.reasoningDelta = delta.reasoning_content;
+          }
+          if (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) {
+            const tc = delta.tool_calls[0];
+            chunk.toolCallDelta = {
+              index: tc.index ?? 0,
+              id: tc.id,
+              name: tc.function?.name,
+              argumentsDelta: tc.function?.arguments
+            };
+          }
+          if (json.usage) {
+            chunk.usage = Usage.fromApi(json.usage);
+          }
+          queue.push(chunk);
+        } catch {
+        }
+      }
+    });
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        if (queue.length > 0) {
+          yield queue.shift();
+          continue;
+        }
+        if (done) break;
+        const { value, done: streamDone } = await reader.read();
+        if (streamDone) break;
+        parser.feed(decoder.decode(value, { stream: true }));
+      }
+      while (queue.length > 0) yield queue.shift();
+    } finally {
+      clearTimeout(timer);
+      reader.releaseLock();
+    }
+  }
+};
 
 // src/harvest.ts
 function emptyPlanState() {
@@ -94,6 +344,66 @@ function sanitizeArray(raw, maxItems, maxItemLen) {
   return out;
 }
 
+// src/consistency.ts
+var defaultSelector = (samples) => {
+  if (samples.length === 0) throw new Error("defaultSelector: samples is empty");
+  return samples.slice().sort((a, b) => {
+    const uDiff = a.planState.uncertainties.length - b.planState.uncertainties.length;
+    if (uDiff !== 0) return uDiff;
+    const aLen = a.response.content?.length ?? 0;
+    const bLen = b.response.content?.length ?? 0;
+    return aLen - bLen;
+  })[0];
+};
+async function runBranches(client, request, opts = {}) {
+  const budget = Math.max(1, opts.budget ?? 1);
+  const temperatures = resolveTemperatures(budget, opts.temperatures);
+  const selector = opts.selector ?? defaultSelector;
+  const samples = await Promise.all(
+    temperatures.map(async (temperature, index) => {
+      const response = await client.chat({ ...request, temperature });
+      const planState = await harvest(response.reasoningContent, client, opts.harvestOptions);
+      const sample = { index, temperature, response, planState };
+      try {
+        opts.onSampleDone?.(sample);
+      } catch {
+      }
+      return sample;
+    })
+  );
+  return { chosen: selector(samples), samples };
+}
+function aggregateBranchUsage(samples) {
+  let promptTokens = 0;
+  let completionTokens = 0;
+  let totalTokens = 0;
+  let promptCacheHitTokens = 0;
+  let promptCacheMissTokens = 0;
+  for (const s of samples) {
+    promptTokens += s.response.usage.promptTokens;
+    completionTokens += s.response.usage.completionTokens;
+    totalTokens += s.response.usage.totalTokens;
+    promptCacheHitTokens += s.response.usage.promptCacheHitTokens;
+    promptCacheMissTokens += s.response.usage.promptCacheMissTokens;
+  }
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    promptCacheHitTokens,
+    promptCacheMissTokens
+  };
+}
+function resolveTemperatures(budget, custom) {
+  if (custom && custom.length >= budget) return [...custom.slice(0, budget)];
+  if (budget === 1) return [0];
+  const out = [];
+  for (let i = 0; i < budget; i++) {
+    out.push(Number((i / (budget - 1)).toFixed(2)));
+  }
+  return out;
+}
+
 // src/memory.ts
 import { createHash } from "crypto";
 var ImmutablePrefix = class {
@@ -468,6 +778,93 @@ function signature2(call) {
   return `${call.function?.name ?? ""}::${call.function?.arguments ?? ""}`;
 }
 
+// src/session.ts
+import {
+  appendFileSync,
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  unlinkSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function sessionsDir() {
+  return join(homedir(), ".reasonix", "sessions");
+}
+function sessionPath(name) {
+  return join(sessionsDir(), `${sanitizeName(name)}.jsonl`);
+}
+function sanitizeName(name) {
+  const cleaned = name.replace(/[^\w\-\u4e00-\u9fa5]/g, "_").slice(0, 64);
+  return cleaned || "default";
+}
+function loadSessionMessages(name) {
+  const path = sessionPath(name);
+  if (!existsSync(path)) return [];
+  try {
+    const raw = readFileSync(path, "utf8");
+    const out = [];
+    for (const line of raw.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const msg = JSON.parse(trimmed);
+        if (msg && typeof msg === "object" && "role" in msg) out.push(msg);
+      } catch {
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function appendSessionMessage(name, message) {
+  const path = sessionPath(name);
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(message)}
+`, "utf8");
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+function listSessions() {
+  const dir = sessionsDir();
+  if (!existsSync(dir)) return [];
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+    return files.map((file) => {
+      const path = join(dir, file);
+      const stat = statSync(path);
+      const name = file.replace(/\.jsonl$/, "");
+      const messageCount = countLines(path);
+      return { name, path, size: stat.size, messageCount, mtime: stat.mtime };
+    }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+  } catch {
+    return [];
+  }
+}
+function deleteSession(name) {
+  const path = sessionPath(name);
+  try {
+    unlinkSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function countLines(path) {
+  try {
+    const raw = readFileSync(path, "utf8");
+    return raw.split(/\r?\n/).filter((l) => l.trim()).length;
+  } catch {
+    return 0;
+  }
+}
+
 // src/telemetry.ts
 var DEEPSEEK_PRICING = {
   "deepseek-chat": { inputCacheHit: 0.07, inputCacheMiss: 0.27, output: 1.1 },
@@ -611,27 +1008,92 @@ var CacheFirstLoop = class {
   client;
   prefix;
   tools;
-  model;
   maxToolIters;
-  stream;
-  harvestEnabled;
-  harvestOptions;
   log = new AppendOnlyLog();
   scratch = new VolatileScratch();
   stats = new SessionStats();
   repair;
+  // Mutable via configure() — slash commands in the TUI / library callers tweak
+  // these mid-session so users don't have to restart to try harvest or branch.
+  model;
+  stream;
+  harvestEnabled;
+  harvestOptions;
+  branchEnabled;
+  branchOptions;
+  sessionName;
+  /** Number of messages that were pre-loaded from the session file. */
+  resumedMessageCount;
   _turn = 0;
+  _streamPreference;
   constructor(opts) {
     this.client = opts.client;
     this.prefix = opts.prefix;
     this.tools = opts.tools ?? new ToolRegistry();
     this.model = opts.model ?? "deepseek-chat";
     this.maxToolIters = opts.maxToolIters ?? 8;
-    this.stream = opts.stream ?? true;
-    this.harvestEnabled = opts.harvest === true || typeof opts.harvest === "object" && opts.harvest !== null;
-    this.harvestOptions = typeof opts.harvest === "object" && opts.harvest !== null ? opts.harvest : {};
+    if (typeof opts.branch === "number") {
+      this.branchOptions = { budget: opts.branch };
+    } else if (opts.branch && typeof opts.branch === "object") {
+      this.branchOptions = opts.branch;
+    } else {
+      this.branchOptions = {};
+    }
+    this.branchEnabled = (this.branchOptions.budget ?? 1) > 1;
+    const harvestForced = this.branchEnabled;
+    this.harvestEnabled = harvestForced || opts.harvest === true || typeof opts.harvest === "object" && opts.harvest !== null;
+    this.harvestOptions = typeof opts.harvest === "object" && opts.harvest !== null ? opts.harvest : this.branchOptions.harvestOptions ?? {};
+    this._streamPreference = opts.stream ?? true;
+    this.stream = this.branchEnabled ? false : this._streamPreference;
     const allowedNames = /* @__PURE__ */ new Set([...this.prefix.toolSpecs.map((s) => s.function.name)]);
     this.repair = new ToolCallRepair({ allowedToolNames: allowedNames });
+    this.sessionName = opts.session ?? null;
+    if (this.sessionName) {
+      const prior = loadSessionMessages(this.sessionName);
+      for (const msg of prior) this.log.append(msg);
+      this.resumedMessageCount = prior.length;
+    } else {
+      this.resumedMessageCount = 0;
+    }
+  }
+  appendAndPersist(message) {
+    this.log.append(message);
+    if (this.sessionName) {
+      try {
+        appendSessionMessage(this.sessionName, message);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Reconfigure model/harvest/branch/stream mid-session. The loop's log,
+   * scratch, and stats are preserved — only the per-turn behavior changes.
+   * Used by the TUI's slash commands and by library callers who want to
+   * flip a knob between turns.
+   */
+  configure(opts) {
+    if (opts.model !== void 0) this.model = opts.model;
+    if (opts.stream !== void 0) this._streamPreference = opts.stream;
+    if (opts.branch !== void 0) {
+      if (typeof opts.branch === "number") {
+        this.branchOptions = { budget: opts.branch };
+      } else if (opts.branch && typeof opts.branch === "object") {
+        this.branchOptions = opts.branch;
+      } else {
+        this.branchOptions = {};
+      }
+      this.branchEnabled = (this.branchOptions.budget ?? 1) > 1;
+    }
+    if (opts.harvest !== void 0) {
+      const want = opts.harvest === true || typeof opts.harvest === "object" && opts.harvest !== null;
+      this.harvestEnabled = want || this.branchEnabled;
+      if (typeof opts.harvest === "object" && opts.harvest !== null) {
+        this.harvestOptions = opts.harvest;
+      }
+    } else if (this.branchEnabled) {
+      this.harvestEnabled = true;
+    }
+    this.stream = this.branchEnabled ? false : this._streamPreference;
   }
   buildMessages(pendingUser) {
     const msgs = [...this.prefix.toMessages(), ...this.log.toMessages()];
@@ -649,8 +1111,85 @@ var CacheFirstLoop = class {
       let reasoningContent = "";
       let toolCalls = [];
       let usage = null;
+      let branchSummary;
+      let preHarvestedPlanState;
       try {
-        if (this.stream) {
+        if (this.branchEnabled) {
+          const budget = this.branchOptions.budget ?? 1;
+          yield {
+            turn: this._turn,
+            role: "branch_start",
+            content: "",
+            branchProgress: {
+              completed: 0,
+              total: budget,
+              latestIndex: -1,
+              latestTemperature: -1,
+              latestUncertainties: -1
+            }
+          };
+          const queue = [];
+          let waiter = null;
+          const onSampleDone = (sample) => {
+            if (waiter) {
+              const w = waiter;
+              waiter = null;
+              w(sample);
+            } else {
+              queue.push(sample);
+            }
+          };
+          const branchPromise = runBranches(
+            this.client,
+            {
+              model: this.model,
+              messages,
+              tools: toolSpecs.length ? toolSpecs : void 0
+            },
+            {
+              ...this.branchOptions,
+              harvestOptions: this.harvestOptions,
+              onSampleDone
+            }
+          );
+          for (let k = 0; k < budget; k++) {
+            const sample = queue.shift() ?? await new Promise((resolve2) => {
+              waiter = resolve2;
+            });
+            yield {
+              turn: this._turn,
+              role: "branch_progress",
+              content: "",
+              branchProgress: {
+                completed: k + 1,
+                total: budget,
+                latestIndex: sample.index,
+                latestTemperature: sample.temperature,
+                latestUncertainties: sample.planState.uncertainties.length
+              }
+            };
+          }
+          const result = await branchPromise;
+          assistantContent = result.chosen.response.content;
+          reasoningContent = result.chosen.response.reasoningContent ?? "";
+          toolCalls = result.chosen.response.toolCalls;
+          const agg = aggregateBranchUsage(result.samples);
+          usage = new Usage(
+            agg.promptTokens,
+            agg.completionTokens,
+            agg.totalTokens,
+            agg.promptCacheHitTokens,
+            agg.promptCacheMissTokens
+          );
+          preHarvestedPlanState = result.chosen.planState;
+          branchSummary = summarizeBranch(result.chosen, result.samples);
+          yield {
+            turn: this._turn,
+            role: "branch_done",
+            content: "",
+            branch: branchSummary
+          };
+        } else if (this.stream) {
           const callBuf = /* @__PURE__ */ new Map();
           for await (const chunk of this.client.stream({
             model: this.model,
@@ -710,29 +1249,26 @@ var CacheFirstLoop = class {
         };
         return;
       }
-      const turnStats = this.stats.record(
-        this._turn,
-        this.model,
-        usage ?? new (await import("./client-KEA2D52Q.js")).Usage()
-      );
+      const turnStats = this.stats.record(this._turn, this.model, usage ?? new Usage());
       if (pendingUser !== null) {
-        this.log.append({ role: "user", content: pendingUser });
+        this.appendAndPersist({ role: "user", content: pendingUser });
         pendingUser = null;
       }
       this.scratch.reasoning = reasoningContent || null;
-      const planState = this.harvestEnabled ? await harvest(reasoningContent || null, this.client, this.harvestOptions) : emptyPlanState();
+      const planState = preHarvestedPlanState ? preHarvestedPlanState : this.harvestEnabled ? await harvest(reasoningContent || null, this.client, this.harvestOptions) : emptyPlanState();
       const { calls: repairedCalls, report } = this.repair.process(
         toolCalls,
         reasoningContent || null
       );
-      this.log.append(this.assistantMessage(assistantContent, repairedCalls));
+      this.appendAndPersist(this.assistantMessage(assistantContent, repairedCalls));
       yield {
         turn: this._turn,
         role: "assistant_final",
         content: assistantContent,
         stats: turnStats,
         planState,
-        repair: report
+        repair: report,
+        branch: branchSummary
       };
       if (repairedCalls.length === 0) {
         yield { turn: this._turn, role: "done", content: assistantContent };
@@ -742,7 +1278,7 @@ var CacheFirstLoop = class {
         const name = call.function?.name ?? "";
         const args = call.function?.arguments ?? "{}";
         const result = await this.tools.dispatch(name, args);
-        this.log.append({
+        this.appendAndPersist({
           role: "tool",
           tool_call_id: call.id ?? "",
           name,
@@ -768,14 +1304,22 @@ var CacheFirstLoop = class {
     return msg;
   }
 };
+function summarizeBranch(chosen, samples) {
+  return {
+    budget: samples.length,
+    chosenIndex: chosen.index,
+    uncertainties: samples.map((s) => s.planState.uncertainties.length),
+    temperatures: samples.map((s) => s.temperature)
+  };
+}
 
 // src/env.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { resolve } from "path";
 function loadDotenv(path = ".env") {
   let raw;
   try {
-    raw = readFileSync(resolve(process.cwd(), path), "utf8");
+    raw = readFileSync2(resolve(process.cwd(), path), "utf8");
   } catch {
     return;
   }
@@ -794,15 +1338,15 @@ function loadDotenv(path = ".env") {
 }
 
 // src/config.ts
-import { chmodSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2 } from "path";
 function defaultConfigPath() {
-  return join(homedir(), ".reasonix", "config.json");
+  return join2(homedir2(), ".reasonix", "config.json");
 }
 function readConfig(path = defaultConfigPath()) {
   try {
-    const raw = readFileSync2(path, "utf8");
+    const raw = readFileSync3(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -810,10 +1354,10 @@ function readConfig(path = defaultConfigPath()) {
   return {};
 }
 function writeConfig(cfg, path = defaultConfigPath()) {
-  mkdirSync(dirname(path), { recursive: true });
+  mkdirSync2(dirname2(path), { recursive: true });
   writeFileSync(path, JSON.stringify(cfg, null, 2), "utf8");
   try {
-    chmodSync(path, 384);
+    chmodSync2(path, 384);
   } catch {
   }
 }
@@ -850,24 +1394,34 @@ export {
   Usage,
   VERSION,
   VolatileScratch,
+  aggregateBranchUsage,
   analyzeSchema,
+  appendSessionMessage,
   claudeEquivalentCost,
   costUsd,
   defaultConfigPath,
+  defaultSelector,
+  deleteSession,
   emptyPlanState,
   fetchWithRetry,
   flattenSchema,
   harvest,
   isPlanStateEmpty,
   isPlausibleKey,
+  listSessions,
   loadApiKey,
   loadDotenv,
+  loadSessionMessages,
   nestArguments,
   readConfig,
   redactKey,
   repairTruncatedJson,
+  runBranches,
+  sanitizeName as sanitizeSessionName,
   saveApiKey,
   scavengeToolCalls,
+  sessionPath,
+  sessionsDir,
   writeConfig
 };
 //# sourceMappingURL=index.js.map