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

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

@@ -0,0 +1,903 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  createBranchSummaryMessage,
+  createCompactionSummaryMessage,
+  createCustomMessage
+} from "./chunk-FVDOXRUD.js";
+import {
+  getAgentDir,
+  getSessionsDir,
+  normalizePath,
+  resolvePath
+} from "./chunk-PCIGF2XK.js";
+
+// packages/coding-agent/dist/core/session-manager.js
+import { uuidv7 } from "@ashx-j/lunr-agent";
+import { randomUUID } from "crypto";
+import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readdirSync, readSync, statSync, writeFileSync } from "fs";
+import { readdir, stat } from "fs/promises";
+import { join, resolve } from "path";
+import { createInterface } from "readline";
+import { StringDecoder } from "string_decoder";
+var CURRENT_SESSION_VERSION = 3;
+function createSessionId() {
+  return uuidv7();
+}
+function assertValidSessionId(id) {
+  if (!/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(id))
+    throw new Error("Session id must be non-empty, contain only alphanumeric characters, '-', '_', and '.', and start and end with an alphanumeric character");
+}
+function generateId(byId) {
+  for (let i = 0; i < 100; i++) {
+    let id = randomUUID().slice(0, 8);
+    if (!byId.has(id))
+      return id;
+  }
+  return randomUUID();
+}
+function migrateV1ToV2(entries) {
+  let ids = /* @__PURE__ */ new Set(), prevId = null;
+  for (let entry of entries) {
+    if (entry.type === "session") {
+      entry.version = 2;
+      continue;
+    }
+    if (entry.id = generateId(ids), entry.parentId = prevId, prevId = entry.id, entry.type === "compaction") {
+      let comp = entry;
+      if (typeof comp.firstKeptEntryIndex == "number") {
+        let targetEntry = entries[comp.firstKeptEntryIndex];
+        targetEntry && targetEntry.type !== "session" && (comp.firstKeptEntryId = targetEntry.id), delete comp.firstKeptEntryIndex;
+      }
+    }
+  }
+}
+function migrateV2ToV3(entries) {
+  for (let entry of entries) {
+    if (entry.type === "session") {
+      entry.version = 3;
+      continue;
+    }
+    if (entry.type === "message") {
+      let msgEntry = entry;
+      msgEntry.message && msgEntry.message.role === "hookMessage" && (msgEntry.message.role = "custom");
+    }
+  }
+}
+function migrateToCurrentVersion(entries) {
+  let version = entries.find((e) => e.type === "session")?.version ?? 1;
+  return version >= CURRENT_SESSION_VERSION ? !1 : (version < 2 && migrateV1ToV2(entries), version < 3 && migrateV2ToV3(entries), !0);
+}
+function migrateSessionEntries(entries) {
+  migrateToCurrentVersion(entries);
+}
+function parseSessionEntries(content) {
+  let entries = [], lines = content.trim().split(`
+`);
+  for (let [index, line] of lines.entries()) {
+    if (!line.trim())
+      continue;
+    let entry = parseSessionEntryLine(line, `line ${index + 1}`);
+    entry && entries.push(entry);
+  }
+  return entries;
+}
+function getLatestCompactionEntry(entries) {
+  for (let i = entries.length - 1; i >= 0; i--)
+    if (entries[i].type === "compaction")
+      return entries[i];
+  return null;
+}
+function validateSessionGraph(entries) {
+  let index = /* @__PURE__ */ new Map();
+  for (let entry of entries) {
+    if (typeof entry.id != "string" || !entry.id)
+      throw new Error("Session graph is corrupt: every entry must have a non-empty id");
+    if (index.has(entry.id))
+      throw new Error(`Session graph is corrupt: duplicate entry id "${entry.id}"`);
+    index.set(entry.id, entry);
+  }
+  for (let entry of entries) {
+    if (entry.parentId === entry.id)
+      throw new Error(`Session graph is corrupt: entry "${entry.id}" links to itself`);
+    if (entry.parentId !== null && !index.has(entry.parentId))
+      throw new Error(`Session graph is corrupt: entry "${entry.id}" has missing parent "${entry.parentId}"`);
+  }
+  let complete = /* @__PURE__ */ new Set();
+  for (let entry of entries) {
+    if (complete.has(entry.id))
+      continue;
+    let path = [], positions = /* @__PURE__ */ new Map(), current = entry;
+    for (; current && !complete.has(current.id); ) {
+      let position = positions.get(current.id);
+      if (position !== void 0) {
+        let cycle = [...path.slice(position), current.id].join(" -> ");
+        throw new Error(`Session graph is corrupt: parent cycle detected (${cycle})`);
+      }
+      positions.set(current.id, path.length), path.push(current.id), current = current.parentId === null ? void 0 : index.get(current.parentId);
+    }
+    for (let id of path)
+      complete.add(id);
+  }
+}
+function buildEntryIndex(entries, byId) {
+  return byId || (validateSessionGraph(entries), new Map(entries.map((entry) => [entry.id, entry])));
+}
+function buildSessionPath(entries, leafId, byId) {
+  let index = buildEntryIndex(entries, byId), leaf;
+  if (leafId === null)
+    return [];
+  if (leafId && (leaf = index.get(leafId)), leaf ??= entries[entries.length - 1], !leaf)
+    return [];
+  let path = [], visited = /* @__PURE__ */ new Set(), current = leaf;
+  for (; current; ) {
+    if (visited.has(current.id))
+      throw new Error(`Session graph is corrupt: parent cycle detected at entry "${current.id}"`);
+    if (visited.add(current.id), path.push(current), current.parentId && !index.has(current.parentId))
+      throw new Error(`Session graph is corrupt: entry "${current.id}" has missing parent "${current.parentId}"`);
+    current = current.parentId ? index.get(current.parentId) : void 0;
+  }
+  return path.reverse(), path;
+}
+function getSessionContextSettings(path) {
+  let thinkingLevel = "off", model = null;
+  for (let entry of path)
+    entry.type === "thinking_level_change" ? thinkingLevel = entry.thinkingLevel : entry.type === "model_change" ? model = { provider: entry.provider, modelId: entry.modelId } : entry.type === "message" && entry.message.role === "assistant" && (model = { provider: entry.message.provider, modelId: entry.message.model });
+  return { thinkingLevel, model };
+}
+function sessionEntryToContextMessages(entry) {
+  if (entry.type === "message") {
+    let message = entry.message;
+    return (message.role === "user" || message.role === "assistant" || message.role === "toolResult") && message.content == null ? [{ ...message, content: [] }] : [message];
+  }
+  return entry.type === "custom_message" ? [
+    createCustomMessage(entry.customType, entry.content ?? [], entry.display, entry.details, entry.timestamp)
+  ] : entry.type === "branch_summary" && entry.summary ? [createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp)] : entry.type === "compaction" ? [createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp)] : [];
+}
+function buildContextEntries(entries, leafId, byId) {
+  let path = buildSessionPath(entries, leafId, byId), compaction = null;
+  for (let entry of path)
+    entry.type === "compaction" && (compaction = entry);
+  if (!compaction)
+    return path;
+  let compactionIdx = path.findIndex((entry) => entry.id === compaction.id);
+  if (compactionIdx < 0)
+    return path;
+  let contextEntries = [compaction], foundFirstKept = !1;
+  for (let i = 0; i < compactionIdx; i++) {
+    let entry = path[i];
+    entry.id === compaction.firstKeptEntryId && (foundFirstKept = !0), foundFirstKept && contextEntries.push(entry);
+  }
+  return contextEntries.push(...path.slice(compactionIdx + 1)), contextEntries;
+}
+function buildSessionContext(entries, leafId, byId) {
+  let path = buildSessionPath(entries, leafId, byId), { thinkingLevel, model } = getSessionContextSettings(path);
+  return { messages: buildContextEntries(entries, leafId, byId).flatMap(sessionEntryToContextMessages), thinkingLevel, model };
+}
+function getDefaultSessionDirPath(cwd, agentDir = getAgentDir()) {
+  let resolvedCwd = resolvePath(cwd), resolvedAgentDir = resolvePath(agentDir), safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+  return join(resolvedAgentDir, "sessions", safePath);
+}
+function getDefaultSessionDir(cwd, agentDir = getAgentDir()) {
+  let sessionDir = getDefaultSessionDirPath(cwd, agentDir);
+  return existsSync(sessionDir) || mkdirSync(sessionDir, { recursive: !0 }), sessionDir;
+}
+var SESSION_READ_BUFFER_SIZE = 1024 * 1024;
+function parseSessionEntryLine(line, location) {
+  let trimmed = line.replace(/\u0000/g, "").trim();
+  if (!trimmed)
+    return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    throw new Error(location ? `Malformed session line ${location}` : "Malformed session line");
+  }
+}
+function loadEntriesFromFile(filePath) {
+  let resolvedFilePath = normalizePath(filePath);
+  if (!existsSync(resolvedFilePath))
+    return [];
+  let entries = [], fd = openSync(resolvedFilePath, "r");
+  try {
+    let decoder = new StringDecoder("utf8"), buffer = Buffer.allocUnsafe(SESSION_READ_BUFFER_SIZE), pending = "", lineNumber = 0;
+    for (; ; ) {
+      let bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+      if (bytesRead === 0)
+        break;
+      pending += decoder.write(buffer.subarray(0, bytesRead));
+      let lineStart = 0, newlineIndex = pending.indexOf(`
+`, lineStart);
+      for (; newlineIndex !== -1; ) {
+        lineNumber++;
+        let entry = parseSessionEntryLine(pending.slice(lineStart, newlineIndex), `in ${resolvedFilePath}:${lineNumber}`);
+        entry && entries.push(entry), lineStart = newlineIndex + 1, newlineIndex = pending.indexOf(`
+`, lineStart);
+      }
+      pending = pending.slice(lineStart);
+    }
+    if (pending += decoder.end(), pending.trim()) {
+      lineNumber++;
+      let finalEntry = parseSessionEntryLine(pending, `in ${resolvedFilePath}:${lineNumber}`);
+      finalEntry && entries.push(finalEntry);
+    }
+  } finally {
+    closeSync(fd);
+  }
+  if (entries.length === 0)
+    return entries;
+  let header = entries[0];
+  return header.type !== "session" || typeof header.id != "string" ? [] : entries;
+}
+function readSessionHeader(filePath) {
+  try {
+    let fd = openSync(filePath, "r"), buffer = Buffer.alloc(512), bytesRead = readSync(fd, buffer, 0, 512, 0);
+    closeSync(fd);
+    let firstLine = buffer.toString("utf8", 0, bytesRead).split(`
+`)[0];
+    if (!firstLine)
+      return null;
+    let header = JSON.parse(firstLine);
+    return header.type !== "session" || typeof header.id != "string" ? null : header;
+  } catch {
+    return null;
+  }
+}
+function getSessionHeaderCwd(header) {
+  let cwd = header.cwd;
+  return typeof cwd == "string" ? cwd : void 0;
+}
+function sessionCwdMatches(cwd, resolvedCwd) {
+  return cwd !== void 0 && cwd !== "" && resolvePath(cwd) === resolvedCwd;
+}
+function findMostRecentSession(sessionDir, cwd) {
+  let resolvedSessionDir = normalizePath(sessionDir), resolvedCwd = cwd ? resolvePath(cwd) : void 0;
+  try {
+    return readdirSync(resolvedSessionDir).filter((f) => f.endsWith(".jsonl")).map((f) => join(resolvedSessionDir, f)).map((path) => ({ path, header: readSessionHeader(path) })).filter((file) => file.header !== null && (!resolvedCwd || sessionCwdMatches(getSessionHeaderCwd(file.header), resolvedCwd))).map(({ path }) => ({ path, mtime: statSync(path).mtime })).sort((a, b) => b.mtime.getTime() - a.mtime.getTime())[0]?.path || null;
+  } catch {
+    return null;
+  }
+}
+function isMessageWithContent(message) {
+  return typeof message.role == "string" && "content" in message;
+}
+function extractTextContent(message) {
+  let content = message.content;
+  return typeof content == "string" ? content : content.filter((block) => block.type === "text").map((block) => block.text).join(" ");
+}
+function getMessageActivityTime(entry) {
+  let message = entry.message;
+  if (!isMessageWithContent(message) || message.role !== "user" && message.role !== "assistant")
+    return;
+  let msgTimestamp = message.timestamp;
+  if (typeof msgTimestamp == "number")
+    return msgTimestamp;
+  let t = new Date(entry.timestamp).getTime();
+  return Number.isNaN(t) ? void 0 : t;
+}
+async function buildSessionInfo(filePath) {
+  try {
+    let stats = await stat(filePath), header = null, messageCount = 0, firstMessage = "", allMessages = [], name, lastActivityTime, rl = createInterface({
+      input: createReadStream(filePath, { encoding: "utf8" }),
+      crlfDelay: 1 / 0
+    });
+    for await (let line of rl) {
+      let entry = parseSessionEntryLine(line);
+      if (!entry)
+        continue;
+      if (!header) {
+        if (entry.type !== "session")
+          return null;
+        header = entry;
+        continue;
+      }
+      if (entry.type === "session_info" && (name = entry.name?.trim() || void 0), entry.type !== "message")
+        continue;
+      messageCount++;
+      let activityTime = getMessageActivityTime(entry);
+      typeof activityTime == "number" && (lastActivityTime = Math.max(lastActivityTime ?? 0, activityTime));
+      let message = entry.message;
+      if (!isMessageWithContent(message) || message.role !== "user" && message.role !== "assistant")
+        continue;
+      let textContent = extractTextContent(message);
+      textContent && (allMessages.push(textContent), !firstMessage && message.role === "user" && (firstMessage = textContent));
+    }
+    if (!header)
+      return null;
+    let cwd = typeof header.cwd == "string" ? header.cwd : "", parentSessionPath = header.parentSession, headerTime = typeof header.timestamp == "string" ? new Date(header.timestamp).getTime() : NaN, modified = typeof lastActivityTime == "number" && lastActivityTime > 0 ? new Date(lastActivityTime) : Number.isNaN(headerTime) ? stats.mtime : new Date(headerTime);
+    return {
+      path: filePath,
+      id: header.id,
+      cwd,
+      name,
+      parentSessionPath,
+      created: new Date(header.timestamp),
+      modified,
+      messageCount,
+      firstMessage: firstMessage || "(no messages)",
+      allMessagesText: allMessages.join(" ")
+    };
+  } catch {
+    return null;
+  }
+}
+var MAX_CONCURRENT_SESSION_INFO_LOADS = 10;
+async function buildSessionInfosWithConcurrency(files, onLoaded) {
+  let results = new Array(files.length).fill(null), inFlight = /* @__PURE__ */ new Set(), nextIndex = 0, startNext = () => {
+    let index = nextIndex++, file = files[index];
+    if (!file)
+      return;
+    let task;
+    task = buildSessionInfo(file).then((info) => {
+      results[index] = info;
+    }).catch(() => {
+      results[index] = null;
+    }).finally(() => {
+      inFlight.delete(task), onLoaded();
+    }), inFlight.add(task);
+  };
+  for (; nextIndex < files.length || inFlight.size > 0; ) {
+    for (; nextIndex < files.length && inFlight.size < MAX_CONCURRENT_SESSION_INFO_LOADS; )
+      startNext();
+    inFlight.size > 0 && await Promise.race(inFlight);
+  }
+  return results;
+}
+async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progressTotal) {
+  let sessions = [];
+  if (!existsSync(dir))
+    return sessions;
+  try {
+    let files = (await readdir(dir)).filter((f) => f.endsWith(".jsonl")).map((f) => join(dir, f)), total = progressTotal ?? files.length, loaded = 0, results = await buildSessionInfosWithConcurrency(files, () => {
+      loaded++, onProgress?.(progressOffset + loaded, total);
+    });
+    for (let info of results)
+      info && sessions.push(info);
+  } catch {
+  }
+  return sessions;
+}
+var SessionManager = class _SessionManager {
+  sessionId = "";
+  sessionFile;
+  sessionDir;
+  cwd;
+  persist;
+  flushed = !1;
+  fileEntries = [];
+  byId = /* @__PURE__ */ new Map();
+  labelsById = /* @__PURE__ */ new Map();
+  labelTimestampsById = /* @__PURE__ */ new Map();
+  leafId = null;
+  constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions) {
+    this.cwd = resolvePath(cwd), this.sessionDir = normalizePath(sessionDir), this.persist = persist, persist && this.sessionDir && !existsSync(this.sessionDir) && mkdirSync(this.sessionDir, { recursive: !0 }), sessionFile ? this.setSessionFile(sessionFile) : this.newSession(newSessionOptions);
+  }
+  /** Switch to a different session file (used for resume and branching) */
+  setSessionFile(sessionFile) {
+    if (this.sessionFile = resolvePath(sessionFile), existsSync(this.sessionFile)) {
+      if (this.fileEntries = loadEntriesFromFile(this.sessionFile), this.fileEntries.length === 0) {
+        let explicitPath = this.sessionFile;
+        if (statSync(explicitPath).size > 0)
+          throw new Error(`Session file is not a valid pi session: ${explicitPath}`);
+        this.newSession(), this.sessionFile = explicitPath, this._rewriteFile(), this.flushed = !0;
+        return;
+      }
+      let header = this.fileEntries.find((e) => e.type === "session");
+      if (!header)
+        throw new Error(`Session file is not a valid pi session: ${this.sessionFile}`);
+      this.sessionId = header.id, migrateToCurrentVersion(this.fileEntries) && this._rewriteFile(), this._buildIndex(), this.flushed = !0;
+    } else {
+      let explicitPath = this.sessionFile;
+      this.newSession(), this.sessionFile = explicitPath;
+    }
+  }
+  newSession(options) {
+    options?.id !== void 0 && assertValidSessionId(options.id), this.sessionId = options?.id ?? createSessionId();
+    let timestamp = (/* @__PURE__ */ new Date()).toISOString(), header = {
+      type: "session",
+      version: CURRENT_SESSION_VERSION,
+      id: this.sessionId,
+      timestamp,
+      cwd: this.cwd,
+      parentSession: options?.parentSession
+    };
+    if (this.fileEntries = [header], this.byId.clear(), this.labelsById.clear(), this.labelTimestampsById.clear(), this.leafId = null, this.flushed = !1, this.persist) {
+      let fileTimestamp = timestamp.replace(/[:.]/g, "-");
+      this.sessionFile = join(this.getSessionDir(), `${fileTimestamp}_${this.sessionId}.jsonl`);
+    }
+    return this.sessionFile;
+  }
+  _buildIndex() {
+    validateSessionGraph(this.fileEntries.filter((entry) => entry.type !== "session")), this.byId.clear(), this.labelsById.clear(), this.labelTimestampsById.clear(), this.leafId = null;
+    for (let entry of this.fileEntries)
+      entry.type !== "session" && (this.byId.set(entry.id, entry), this.leafId = entry.id, entry.type === "label" && (entry.label ? (this.labelsById.set(entry.targetId, entry.label), this.labelTimestampsById.set(entry.targetId, entry.timestamp)) : (this.labelsById.delete(entry.targetId), this.labelTimestampsById.delete(entry.targetId))));
+  }
+  _rewriteFile() {
+    if (!this.persist || !this.sessionFile)
+      return;
+    let fd = openSync(this.sessionFile, "w");
+    try {
+      for (let entry of this.fileEntries)
+        writeFileSync(fd, `${JSON.stringify(entry)}
+`);
+    } finally {
+      closeSync(fd);
+    }
+  }
+  isPersisted() {
+    return this.persist;
+  }
+  getCwd() {
+    return this.cwd;
+  }
+  getSessionDir() {
+    return this.sessionDir;
+  }
+  usesDefaultSessionDir() {
+    return this.sessionDir === getDefaultSessionDirPath(this.cwd);
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getSessionFile() {
+    return this.sessionFile;
+  }
+  _persist(entry) {
+    if (!this.persist || !this.sessionFile)
+      return;
+    if (!this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant")) {
+      this.flushed ? appendFileSync(this.sessionFile, `${JSON.stringify(entry)}
+`) : this.flushed = !1;
+      return;
+    }
+    if (this.flushed)
+      appendFileSync(this.sessionFile, `${JSON.stringify(entry)}
+`);
+    else {
+      let fd = openSync(this.sessionFile, "wx");
+      try {
+        for (let e of this.fileEntries)
+          writeFileSync(fd, `${JSON.stringify(e)}
+`);
+      } finally {
+        closeSync(fd);
+      }
+      this.flushed = !0;
+    }
+  }
+  _appendEntry(entry) {
+    this.fileEntries.push(entry), this.byId.set(entry.id, entry), this.leafId = entry.id, this._persist(entry);
+  }
+  /** Append a message as child of current leaf, then advance leaf. Returns entry id.
+   * Does not allow writing CompactionSummaryMessage and BranchSummaryMessage directly.
+   * Reason: we want these to be top-level entries in the session, not message session entries,
+   * so it is easier to find them.
+   * These need to be appended via appendCompaction() and appendBranchSummary() methods.
+   */
+  appendMessage(message) {
+    let entry = {
+      type: "message",
+      id: generateId(this.byId),
+      parentId: this.leafId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      message
+    };
+    return this._appendEntry(entry), entry.id;
+  }
+  /** Append a thinking level change as child of current leaf, then advance leaf. Returns entry id. */
+  appendThinkingLevelChange(thinkingLevel) {
+    let entry = {
+      type: "thinking_level_change",
+      id: generateId(this.byId),
+      parentId: this.leafId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      thinkingLevel
+    };
+    return this._appendEntry(entry), entry.id;
+  }
+  /** Append a model change as child of current leaf, then advance leaf. Returns entry id. */
+  appendModelChange(provider, modelId) {
+    let entry = {
+      type: "model_change",
+      id: generateId(this.byId),
+      parentId: this.leafId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      provider,
+      modelId
+    };
+    return this._appendEntry(entry), entry.id;
+  }
+  /** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */
+  appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook) {
+    let entry = {
+      type: "compaction",
+      id: generateId(this.byId),
+      parentId: this.leafId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      summary,
+      firstKeptEntryId,
+      tokensBefore,
+      details,
+      fromHook
+    };
+    return this._appendEntry(entry), entry.id;
+  }
+  /** Append a custom entry (for extensions) as child of current leaf, then advance leaf. Returns entry id. */
+  appendCustomEntry(customType, data) {
+    let entry = {
+      type: "custom",
+      customType,
+      data,
+      id: generateId(this.byId),
+      parentId: this.leafId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return this._appendEntry(entry), entry.id;
+  }
+  /** Append a session info entry (e.g., display name). Returns entry id. */
+  appendSessionInfo(name) {
+    let sanitizedName = name.replace(/[\r\n]+/g, " ").trim(), entry = {
+      type: "session_info",
+      id: generateId(this.byId),
+      parentId: this.leafId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      name: sanitizedName
+    };
+    return this._appendEntry(entry), entry.id;
+  }
+  /** Get the current session name from the latest session_info entry, if any. */
+  getSessionName() {
+    let entries = this.getEntries();
+    for (let i = entries.length - 1; i >= 0; i--) {
+      let entry = entries[i];
+      if (entry.type === "session_info")
+        return entry.name?.trim() || void 0;
+    }
+  }
+  /**
+   * Append a custom message entry (for extensions) that participates in LLM context.
+   * @param customType Extension identifier for filtering on reload
+   * @param content Message content (string or TextContent/ImageContent array)
+   * @param display Whether to show in TUI (true = styled display, false = hidden)
+   * @param details Optional extension-specific metadata (not sent to LLM)
+   * @returns Entry id
+   */
+  appendCustomMessageEntry(customType, content, display, details) {
+    let entry = {
+      type: "custom_message",
+      customType,
+      content,
+      display,
+      details,
+      id: generateId(this.byId),
+      parentId: this.leafId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return this._appendEntry(entry), entry.id;
+  }
+  // =========================================================================
+  // Tree Traversal
+  // =========================================================================
+  getLeafId() {
+    return this.leafId;
+  }
+  getLeafEntry() {
+    return this.leafId ? this.byId.get(this.leafId) : void 0;
+  }
+  getEntry(id) {
+    return this.byId.get(id);
+  }
+  /**
+   * Get all direct children of an entry.
+   */
+  getChildren(parentId) {
+    let children = [];
+    for (let entry of this.byId.values())
+      entry.parentId === parentId && children.push(entry);
+    return children;
+  }
+  /**
+   * Get the label for an entry, if any.
+   */
+  getLabel(id) {
+    return this.labelsById.get(id);
+  }
+  /**
+   * Set or clear a label on an entry.
+   * Labels are user-defined markers for bookmarking/navigation.
+   * Pass undefined or empty string to clear the label.
+   */
+  appendLabelChange(targetId, label) {
+    if (!this.byId.has(targetId))
+      throw new Error(`Entry ${targetId} not found`);
+    let entry = {
+      type: "label",
+      id: generateId(this.byId),
+      parentId: this.leafId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      targetId,
+      label
+    };
+    return this._appendEntry(entry), label ? (this.labelsById.set(targetId, label), this.labelTimestampsById.set(targetId, entry.timestamp)) : (this.labelsById.delete(targetId), this.labelTimestampsById.delete(targetId)), entry.id;
+  }
+  /**
+   * Walk from entry to root, returning all entries in path order.
+   * Includes all entry types (messages, compaction, model changes, etc.).
+   * Use buildSessionContext() to get the resolved messages for the LLM.
+   */
+  getBranch(fromId) {
+    let path = [], visited = /* @__PURE__ */ new Set(), startId = fromId ?? this.leafId, current = startId ? this.byId.get(startId) : void 0;
+    for (; current; ) {
+      if (visited.has(current.id))
+        throw new Error(`Session graph is corrupt: parent cycle detected at entry "${current.id}"`);
+      if (visited.add(current.id), path.push(current), current.parentId && !this.byId.has(current.parentId))
+        throw new Error(`Session graph is corrupt: entry "${current.id}" has missing parent "${current.parentId}"`);
+      current = current.parentId ? this.byId.get(current.parentId) : void 0;
+    }
+    return path.reverse(), path;
+  }
+  /**
+   * Build the active, compaction-aware entry list for context/rendering.
+   * Uses tree traversal from current leaf.
+   */
+  buildContextEntries() {
+    return buildContextEntries(this.getEntries(), this.leafId, this.byId);
+  }
+  /**
+   * Build the session context (what gets sent to the LLM).
+   * Uses tree traversal from current leaf.
+   */
+  buildSessionContext() {
+    return buildSessionContext(this.getEntries(), this.leafId, this.byId);
+  }
+  /**
+   * Get session header.
+   */
+  getHeader() {
+    let h = this.fileEntries.find((e) => e.type === "session");
+    return h || null;
+  }
+  /**
+   * Get all session entries (excludes header). Returns a shallow copy.
+   * The session is append-only: use appendXXX() to add entries, branch() to
+   * change the leaf pointer. Entries cannot be modified or deleted.
+   */
+  getEntries() {
+    return this.fileEntries.filter((e) => e.type !== "session");
+  }
+  /**
+   * Get the session as a tree structure. Returns a shallow defensive copy of all entries.
+   * A well-formed session has exactly one root (first entry with parentId === null).
+   * Orphaned entries (broken parent chain) are also returned as roots.
+   */
+  getTree() {
+    let entries = this.getEntries(), nodeMap = /* @__PURE__ */ new Map(), roots = [];
+    for (let entry of entries) {
+      let label = this.labelsById.get(entry.id), labelTimestamp = this.labelTimestampsById.get(entry.id);
+      nodeMap.set(entry.id, { entry, children: [], label, labelTimestamp });
+    }
+    for (let entry of entries) {
+      let node = nodeMap.get(entry.id);
+      if (entry.parentId === null || entry.parentId === entry.id)
+        roots.push(node);
+      else {
+        let parent = nodeMap.get(entry.parentId);
+        parent ? parent.children.push(node) : roots.push(node);
+      }
+    }
+    let stack = [...roots];
+    for (; stack.length > 0; ) {
+      let node = stack.pop();
+      node.children.sort((a, b) => new Date(a.entry.timestamp).getTime() - new Date(b.entry.timestamp).getTime()), stack.push(...node.children);
+    }
+    return roots;
+  }
+  // =========================================================================
+  // Branching
+  // =========================================================================
+  /**
+   * Start a new branch from an earlier entry.
+   * Moves the leaf pointer to the specified entry. The next appendXXX() call
+   * will create a child of that entry, forming a new branch. Existing entries
+   * are not modified or deleted.
+   */
+  branch(branchFromId) {
+    if (!this.byId.has(branchFromId))
+      throw new Error(`Entry ${branchFromId} not found`);
+    this.leafId = branchFromId;
+  }
+  /**
+   * Reset the leaf pointer to null (before any entries).
+   * The next appendXXX() call will create a new root entry (parentId = null).
+   * Use this when navigating to re-edit the first user message.
+   */
+  resetLeaf() {
+    this.leafId = null;
+  }
+  /**
+   * Start a new branch with a summary of the abandoned path.
+   * Same as branch(), but also appends a branch_summary entry that captures
+   * context from the abandoned conversation path.
+   */
+  branchWithSummary(branchFromId, summary, details, fromHook) {
+    if (branchFromId !== null && !this.byId.has(branchFromId))
+      throw new Error(`Entry ${branchFromId} not found`);
+    this.leafId = branchFromId;
+    let entry = {
+      type: "branch_summary",
+      id: generateId(this.byId),
+      parentId: branchFromId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      fromId: branchFromId ?? "root",
+      summary,
+      details,
+      fromHook
+    };
+    return this._appendEntry(entry), entry.id;
+  }
+  /**
+   * Create a new session file containing only the path from root to the specified leaf.
+   * Useful for extracting a single conversation path from a branched session.
+   * Returns the new session file path, or undefined if not persisting.
+   */
+  createBranchedSession(leafId) {
+    let previousSessionFile = this.sessionFile, path = this.getBranch(leafId);
+    if (path.length === 0)
+      throw new Error(`Entry ${leafId} not found`);
+    let pathWithoutLabels = [], pathParentId = null;
+    for (let entry of path)
+      entry.type !== "label" && (pathWithoutLabels.push({ ...entry, parentId: pathParentId }), pathParentId = entry.id);
+    let newSessionId = createSessionId(), timestamp = (/* @__PURE__ */ new Date()).toISOString(), fileTimestamp = timestamp.replace(/[:.]/g, "-"), newSessionFile = join(this.getSessionDir(), `${fileTimestamp}_${newSessionId}.jsonl`), header = {
+      type: "session",
+      version: CURRENT_SESSION_VERSION,
+      id: newSessionId,
+      timestamp,
+      cwd: this.cwd,
+      parentSession: this.persist ? previousSessionFile : void 0
+    }, pathEntryIds = new Set(pathWithoutLabels.map((e) => e.id)), labelsToWrite = [];
+    for (let [targetId, label] of this.labelsById)
+      pathEntryIds.has(targetId) && labelsToWrite.push({ targetId, label, timestamp: this.labelTimestampsById.get(targetId) });
+    if (this.persist) {
+      let parentId2 = pathWithoutLabels[pathWithoutLabels.length - 1]?.id || null, labelEntries2 = [];
+      for (let { targetId, label, timestamp: labelTimestamp } of labelsToWrite) {
+        let labelEntry = {
+          type: "label",
+          id: generateId(new Set(pathEntryIds)),
+          parentId: parentId2,
+          timestamp: labelTimestamp,
+          targetId,
+          label
+        };
+        pathEntryIds.add(labelEntry.id), labelEntries2.push(labelEntry), parentId2 = labelEntry.id;
+      }
+      return this.fileEntries = [header, ...pathWithoutLabels, ...labelEntries2], this.sessionId = newSessionId, this.sessionFile = newSessionFile, this._buildIndex(), this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant") ? (this._rewriteFile(), this.flushed = !0) : this.flushed = !1, newSessionFile;
+    }
+    let labelEntries = [], parentId = pathWithoutLabels[pathWithoutLabels.length - 1]?.id || null;
+    for (let { targetId, label, timestamp: labelTimestamp } of labelsToWrite) {
+      let labelEntry = {
+        type: "label",
+        id: generateId(/* @__PURE__ */ new Set([...pathEntryIds, ...labelEntries.map((e) => e.id)])),
+        parentId,
+        timestamp: labelTimestamp,
+        targetId,
+        label
+      };
+      labelEntries.push(labelEntry), parentId = labelEntry.id;
+    }
+    this.fileEntries = [header, ...pathWithoutLabels, ...labelEntries], this.sessionId = newSessionId, this._buildIndex();
+  }
+  /**
+   * Create a new session.
+   * @param cwd Working directory (stored in session header)
+   * @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
+   */
+  static create(cwd, sessionDir, options) {
+    let dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
+    return new _SessionManager(cwd, dir, void 0, !0, options);
+  }
+  /**
+   * Open a specific session file.
+   * @param path Path to session file
+   * @param sessionDir Optional session directory for /new or /branch. If omitted, derives from file's parent.
+   * @param cwdOverride Optional cwd override instead of the session header cwd.
+   */
+  static open(path, sessionDir, cwdOverride) {
+    let resolvedPath = resolvePath(path), header = loadEntriesFromFile(resolvedPath).find((e) => e.type === "session"), cwd = cwdOverride ?? header?.cwd ?? process.cwd(), dir = sessionDir ? normalizePath(sessionDir) : resolve(resolvedPath, "..");
+    return new _SessionManager(cwd, dir, resolvedPath, !0);
+  }
+  /**
+   * Continue the most recent session, or create new if none.
+   * @param cwd Working directory
+   * @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
+   */
+  static continueRecent(cwd, sessionDir) {
+    let dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd), filterCwd = sessionDir !== void 0 && dir !== getDefaultSessionDirPath(cwd), mostRecent = findMostRecentSession(dir, filterCwd ? cwd : void 0);
+    return mostRecent ? new _SessionManager(cwd, dir, mostRecent, !0) : new _SessionManager(cwd, dir, void 0, !0);
+  }
+  /** Create an in-memory session (no file persistence) */
+  static inMemory(cwd = process.cwd(), options) {
+    return new _SessionManager(cwd, "", void 0, !1, options);
+  }
+  /**
+   * Fork a session from another project directory into the current project.
+   * Creates a new session in the target cwd with the full history from the source session.
+   * @param sourcePath Path to the source session file
+   * @param targetCwd Target working directory (where the new session will be stored)
+   * @param sessionDir Optional session directory. If omitted, uses default for targetCwd.
+   */
+  static forkFrom(sourcePath, targetCwd, sessionDir, options) {
+    let resolvedSourcePath = resolvePath(sourcePath), resolvedTargetCwd = resolvePath(targetCwd), sourceEntries = loadEntriesFromFile(resolvedSourcePath);
+    if (sourceEntries.length === 0)
+      throw new Error(`Cannot fork: source session file is empty or invalid: ${resolvedSourcePath}`);
+    if (!sourceEntries.find((e) => e.type === "session"))
+      throw new Error(`Cannot fork: source session has no header: ${resolvedSourcePath}`);
+    let dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(resolvedTargetCwd);
+    existsSync(dir) || mkdirSync(dir, { recursive: !0 }), options?.id !== void 0 && assertValidSessionId(options.id);
+    let newSessionId = options?.id ?? createSessionId(), timestamp = (/* @__PURE__ */ new Date()).toISOString(), fileTimestamp = timestamp.replace(/[:.]/g, "-"), newSessionFile = join(dir, `${fileTimestamp}_${newSessionId}.jsonl`);
+    writeFileSync(newSessionFile, `${JSON.stringify({
+      type: "session",
+      version: CURRENT_SESSION_VERSION,
+      id: newSessionId,
+      timestamp,
+      cwd: resolvedTargetCwd,
+      parentSession: resolvedSourcePath
+    })}
+`, { flag: "wx" });
+    for (let entry of sourceEntries)
+      entry.type !== "session" && appendFileSync(newSessionFile, `${JSON.stringify(entry)}
+`);
+    return new _SessionManager(resolvedTargetCwd, dir, newSessionFile, !0);
+  }
+  /**
+   * List all sessions for a directory.
+   * @param cwd Working directory (used to compute default session directory)
+   * @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
+   * @param onProgress Optional callback for progress updates (loaded, total)
+   */
+  static async list(cwd, sessionDir, onProgress) {
+    let dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd), filterCwd = sessionDir !== void 0 && dir !== getDefaultSessionDirPath(cwd), resolvedCwd = resolvePath(cwd), sessions = (await listSessionsFromDir(dir, onProgress)).filter((session) => !filterCwd || sessionCwdMatches(session.cwd, resolvedCwd));
+    return sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime()), sessions;
+  }
+  static async listAll(sessionDirOrOnProgress, onProgress) {
+    let customSessionDir = typeof sessionDirOrOnProgress == "string" ? normalizePath(sessionDirOrOnProgress) : void 0, progress = typeof sessionDirOrOnProgress == "function" ? sessionDirOrOnProgress : onProgress;
+    if (customSessionDir) {
+      let sessions = await listSessionsFromDir(customSessionDir, progress);
+      return sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime()), sessions;
+    }
+    let sessionsDir = getSessionsDir();
+    try {
+      if (!existsSync(sessionsDir))
+        return [];
+      let dirs = (await readdir(sessionsDir, { withFileTypes: !0 })).filter((e) => e.isDirectory()).map((e) => join(sessionsDir, e.name)), totalFiles = 0, dirFiles = [];
+      for (let dir of dirs)
+        try {
+          let files = (await readdir(dir)).filter((f) => f.endsWith(".jsonl"));
+          dirFiles.push(files.map((f) => join(dir, f))), totalFiles += files.length;
+        } catch {
+          dirFiles.push([]);
+        }
+      let loaded = 0, sessions = [], allFiles = dirFiles.flat(), results = await buildSessionInfosWithConcurrency(allFiles, () => {
+        loaded++, progress?.(loaded, totalFiles);
+      });
+      for (let info of results)
+        info && sessions.push(info);
+      return sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime()), sessions;
+    } catch {
+      return [];
+    }
+  }
+};
+
+export {
+  CURRENT_SESSION_VERSION,
+  assertValidSessionId,
+  migrateSessionEntries,
+  parseSessionEntries,
+  getLatestCompactionEntry,
+  validateSessionGraph,
+  sessionEntryToContextMessages,
+  buildContextEntries,
+  buildSessionContext,
+  getDefaultSessionDir,
+  loadEntriesFromFile,
+  findMostRecentSession,
+  SessionManager
+};