archymedes-cli 2.2.0 → 2.5.0

package/dist/guide-screen-w5nb9sry.mjs

@@ -0,0 +1,273 @@
+import {
+  GUIDE_TOPICS,
+  applyViewport,
+  newViewport,
+  visibleLines,
+  wrapText
+} from "./archymedes-d3azqkay.mjs";
+import {
+  joinHorizontal,
+  padToWidth,
+  scrollIndicator,
+  scrollPercent,
+  sliceToWidth
+} from "./archymedes-5vhvv8kr.mjs";
+import"./archymedes-bmtdqqwt.mjs";
+import {
+  NO_COLOR_PALETTE,
+  exitTopTermUIApp,
+  visibleWidth
+} from "./archymedes-130jt0wr.mjs";
+import {
+  __require
+} from "./archymedes-x67v3n58.mjs";
+
+// packages/archymedes-cli/src/ui/guide-screen.tsx
+import { useInput, useState } from "@termuijs/jsx";
+import { Box, Text } from "@termuijs/widgets";
+
+// packages/archymedes-cli/src/ui/guide-browser.ts
+function initialGuideState(columns, rows, palette = NO_COLOR_PALETTE) {
+  return { topics: GUIDE_TOPICS, selected: 0, scroll: 0, query: "", searching: false, columns, rows, palette };
+}
+function visibleTopics(state) {
+  const needle = state.query.trim().toLowerCase();
+  if (!needle)
+    return [...state.topics];
+  return state.topics.filter((topic) => [topic.title, topic.summary, topic.id, ...topic.body, ...(topic.examples ?? []).flatMap((example) => [example.input, example.effect])].some((text) => text.toLowerCase().includes(needle)));
+}
+function currentTopic(state) {
+  const topics = visibleTopics(state);
+  if (topics.length === 0)
+    return;
+  return topics[Math.max(0, Math.min(state.selected, topics.length - 1))];
+}
+function sidebarWidth(columns) {
+  const width = Math.max(1, Math.floor(columns));
+  return Math.min(width, Math.max(14, Math.min(26, Math.floor(width * 0.28))));
+}
+function bodyHeight(rows) {
+  return Math.max(0, Math.floor(rows) - 2);
+}
+function keyToGuideAction(key, character, searching) {
+  const name = key.name ?? "";
+  if (key.ctrl && name === "c")
+    return { kind: "exit" };
+  const isEnter = name === "return" || name === "enter" || name === "\r" || name === `
+`;
+  const isEscape = name === "escape" || name === "\x1B";
+  if (searching) {
+    if (isEscape || isEnter)
+      return { kind: "commit" };
+    if (name === "backspace")
+      return { kind: "backspace" };
+    if (name === "up")
+      return { kind: "move", step: -1 };
+    if (name === "down")
+      return { kind: "move", step: 1 };
+    if (character && character.length === 1 && character >= " ")
+      return { kind: "type", character };
+    return { kind: "none" };
+  }
+  if (isEscape || name === "q")
+    return { kind: "exit" };
+  if (character === "/" || name === "f3")
+    return { kind: "search" };
+  if (name === "up" || name === "k")
+    return { kind: "move", step: -1 };
+  if (name === "down" || name === "j")
+    return { kind: "move", step: 1 };
+  if (name === "tab")
+    return { kind: "move", step: key.shift ? -1 : 1 };
+  if (name === "pagedown" || character === " ")
+    return { kind: "page", step: 1 };
+  if (name === "pageup")
+    return { kind: "page", step: -1 };
+  if (name === "right")
+    return { kind: "scroll", rows: 1 };
+  if (name === "left")
+    return { kind: "scroll", rows: -1 };
+  return { kind: "none" };
+}
+function applyGuideAction(state, action) {
+  const topics = visibleTopics(state);
+  switch (action.kind) {
+    case "move": {
+      if (topics.length === 0)
+        return state;
+      const next = ((state.selected + action.step) % topics.length + topics.length) % topics.length;
+      return { ...state, selected: next, scroll: 0 };
+    }
+    case "scroll":
+    case "page": {
+      const topic = currentTopic(state);
+      if (!topic)
+        return state;
+      const lines = topicLines(topic, bodyWidth(state.columns)).map((line) => line.text);
+      const viewport = { ...newViewport(lines, bodyHeight(state.rows)), top: state.scroll };
+      const moved = action.kind === "page" ? applyViewport(viewport, { kind: action.step === 1 ? "pageDown" : "pageUp" }) : applyViewport(viewport, action.rows > 0 ? { kind: "down", rows: action.rows } : { kind: "up", rows: -action.rows });
+      return { ...state, scroll: moved.top };
+    }
+    case "search":
+      return { ...state, searching: true };
+    case "commit":
+      return { ...state, searching: false };
+    case "backspace":
+      return { ...state, query: state.query.slice(0, -1), selected: 0, scroll: 0 };
+    case "type":
+      return { ...state, query: state.query + action.character, selected: 0, scroll: 0 };
+    default:
+      return state;
+  }
+}
+function bodyWidth(columns) {
+  const width = Math.max(1, Math.floor(columns));
+  return width < 40 ? width : Math.max(1, width - sidebarWidth(width) - 3);
+}
+function topicLines(topic, width) {
+  const measure = Math.max(1, Math.floor(width));
+  const wrap = (text, available = measure) => wrapText(text, Math.max(1, available)).flatMap((line) => hardWrap(line, Math.max(1, available)));
+  const rows = [
+    ...wrap(topic.title).map((line) => ({ text: line, bold: true })),
+    { text: "" }
+  ];
+  for (const paragraph of topic.body) {
+    for (const line of wrap(paragraph))
+      rows.push({ text: line });
+    rows.push({ text: "" });
+  }
+  if (topic.examples && topic.examples.length > 0) {
+    rows.push({ text: "try", bold: true });
+    for (const example of topic.examples) {
+      const commandIndent = " ".repeat(Math.min(2, Math.max(0, measure - 1)));
+      const detailIndent = " ".repeat(Math.min(4, Math.max(0, measure - 1)));
+      const [head, ...rest] = wrap(example.input, measure - visibleWidth(detailIndent));
+      rows.push({ text: `${commandIndent}${head ?? ""}`, bold: true });
+      for (const line of rest)
+        rows.push({ text: `${detailIndent}${line}`, bold: true });
+      for (const line of wrap(example.effect, measure - visibleWidth(detailIndent)))
+        rows.push({ text: `${detailIndent}${line}`, dim: true });
+    }
+  }
+  return rows;
+}
+function hardWrap(text, width) {
+  if (visibleWidth(text) <= width)
+    return [text];
+  const lines = [];
+  let line = "";
+  const segments = typeof Intl.Segmenter === "function" ? [...new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(text)].map((entry) => entry.segment) : [...text];
+  for (const segment of segments) {
+    if (line && visibleWidth(line + segment) > width) {
+      lines.push(line);
+      line = "";
+    }
+    if (visibleWidth(segment) > width) {
+      lines.push("…");
+      continue;
+    }
+    line += segment;
+  }
+  if (line)
+    lines.push(line);
+  return lines;
+}
+function composeGuideFrame(state) {
+  const columns = Math.max(1, Math.floor(state.columns));
+  const rowCount = Math.max(1, Math.floor(state.rows));
+  const compact = columns < 40;
+  const sidebar = compact ? 0 : sidebarWidth(columns);
+  const body = bodyWidth(columns);
+  const height = bodyHeight(rowCount);
+  const topics = visibleTopics(state);
+  const selectedIndex = topics.length === 0 ? -1 : Math.max(0, Math.min(state.selected, topics.length - 1));
+  const topic = selectedIndex === -1 ? undefined : topics[selectedIndex];
+  const theme = state.palette.tokens;
+  const rows = [];
+  rows.push({
+    text: padToWidth(compact ? ` archymedes guide · ${topic?.title ?? "no matches"}` : " archymedes guide", columns),
+    bold: true,
+    color: theme.primary
+  });
+  if (rowCount === 1)
+    return rows;
+  const lines = topic ? topicLines(topic, body) : [{ text: "Nothing matches that." }];
+  const indices = visibleLines({ ...newViewport(lines.map((_, index) => `${index}`), height), top: state.scroll });
+  const start = indices.length > 0 ? Number(indices[0]) : 0;
+  const window = lines.slice(start, start + height);
+  const listStart = Math.max(0, Math.min(selectedIndex - Math.floor(height / 2), Math.max(0, topics.length - height)));
+  for (let offset = 0;offset < height; offset += 1) {
+    const listed = topics[listStart + offset];
+    const chosen = listed !== undefined && listStart + offset === selectedIndex;
+    const cell = listed ? `${chosen ? "›" : " "} ${listed.title}` : "";
+    const line = window[offset];
+    rows.push({
+      text: compact ? padToWidth(line?.text ?? "", columns) : joinHorizontal(sliceToWidth(cell, sidebar), line?.text ?? "", { leftWidth: sidebar, rightWidth: body, separator: " │ " }),
+      bold: chosen || line?.bold,
+      dim: line?.dim && !chosen,
+      ...chosen ? { color: theme.accent } : line?.bold ? { color: theme.primary } : {}
+    });
+  }
+  const position = lines.length > height ? `  ${scrollIndicator(scrollPercent(start, lines.length, height))}` : "";
+  const footer = state.searching ? `search: ${state.query}▏  Enter done · Esc done` : `↑↓ topic · ←→ scroll · space page · / search · Esc back${state.query ? `   filter: ${state.query}` : ""}${position}`;
+  rows.push({ text: padToWidth(` ${footer}`, columns), dim: true, color: theme.textMuted });
+  return rows;
+}
+
+// packages/archymedes-cli/src/ui/guide-screen.tsx
+import { jsxDEV } from "@termuijs/jsx/jsx-dev-runtime";
+var Panel = Box;
+var Line = Text;
+function GuideScreen({ columns, rows, onExit, startAt, palette = NO_COLOR_PALETTE }) {
+  const [state, setState] = useState(() => {
+    const initial = initialGuideState(columns, rows, palette);
+    const index = startAt ? initial.topics.findIndex((topic) => topic.id === startAt) : -1;
+    return index >= 0 ? { ...initial, selected: index } : initial;
+  });
+  useInput((input, key) => {
+    const action = keyToGuideAction({ name: key?.key, ctrl: key?.ctrl, shift: key?.shift }, input, state.searching);
+    if (action.kind === "exit") {
+      onExit();
+      return;
+    }
+    setState((current) => applyGuideAction(current, action));
+  });
+  const frame = composeGuideFrame(state);
+  return /* @__PURE__ */ jsxDEV(Panel, {
+    flexDirection: "column",
+    width: state.columns,
+    height: state.rows,
+    children: frame.map((row, index) => /* @__PURE__ */ jsxDEV(Line, {
+      bold: row.bold,
+      dimColor: row.dim,
+      inverse: row.inverse,
+      color: row.color,
+      children: row.text
+    }, `row-${index}`, false, undefined, this))
+  }, undefined, false, undefined, this);
+}
+async function runGuideScreen(options) {
+  const { renderApp } = await import("@termuijs/jsx");
+  await new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      exitTopTermUIApp();
+      resolve();
+    };
+    renderApp(GuideScreen, {
+      columns: options.columns,
+      rows: options.rows,
+      startAt: options.startAt,
+      palette: options.palette,
+      onExit: finish,
+      fullscreen: true
+    }).catch(finish);
+  });
+}
+export {
+  runGuideScreen,
+  GuideScreen
+};

package/dist/pager-screen-aamt6xv0.mjs

@@ -0,0 +1,155 @@
+import {
+  __require
+} from "./archymedes-x67v3n58.mjs";
+
+// packages/archymedes-cli/src/ui/pager-screen.tsx
+import { useInput, useState } from "@termuijs/jsx";
+import { Box, Text } from "@termuijs/widgets";
+
+// packages/archymedes-cli/src/ui/text-pager.ts
+var ANSI = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07]*\x07/g;
+function initialPagerState(text, height) {
+  const lines = text.replace(ANSI, "").replace(/\r/g, "").split(`
+`);
+  const rows = Math.max(1, height);
+  return { lines, top: Math.max(0, lines.length - rows), height: rows, search: { query: "", typing: false } };
+}
+function keyToPagerAction(key, character, state) {
+  const name = key.name ?? "";
+  if (key.ctrl && name === "c")
+    return { kind: "exit" };
+  if (state.search.typing) {
+    if (name === "escape")
+      return { kind: "searchCancel" };
+    if (name === "return" || name === "enter")
+      return { kind: "searchCommit" };
+    if (name === "backspace")
+      return { kind: "searchBackspace" };
+    if (character && character.length === 1 && character >= " ")
+      return { kind: "searchType", character };
+    return { kind: "none" };
+  }
+  if (name === "escape" || character === "q")
+    return { kind: "exit" };
+  if (name === "up" || character === "k")
+    return { kind: "scroll", rows: -1 };
+  if (name === "down" || character === "j" || name === "return" || name === "enter")
+    return { kind: "scroll", rows: 1 };
+  if (name === "pageup" || character === "b")
+    return { kind: "scroll", rows: -(state.height - 1) };
+  if (name === "pagedown" || name === "space" || character === " ")
+    return { kind: "scroll", rows: state.height - 1 };
+  if (name === "home" || character === "g")
+    return { kind: "home" };
+  if (name === "end" || character === "G")
+    return { kind: "end" };
+  if (character === "/")
+    return { kind: "search" };
+  if (character === "n")
+    return { kind: "searchNext" };
+  return { kind: "none" };
+}
+function clampTop(state, top) {
+  return Math.max(0, Math.min(top, Math.max(0, state.lines.length - state.height)));
+}
+function findFrom(state, from) {
+  const needle = state.search.query.toLowerCase();
+  if (!needle)
+    return -1;
+  for (let offset = 0;offset < state.lines.length; offset += 1) {
+    const row = (from + offset) % state.lines.length;
+    if (state.lines[row].toLowerCase().includes(needle))
+      return row;
+  }
+  return -1;
+}
+function applyPagerAction(state, action) {
+  switch (action.kind) {
+    case "exit":
+      return { state, exit: true };
+    case "scroll":
+      return { state: { ...state, top: clampTop(state, state.top + action.rows), message: undefined } };
+    case "home":
+      return { state: { ...state, top: 0, message: undefined } };
+    case "end":
+      return { state: { ...state, top: clampTop(state, state.lines.length), message: undefined } };
+    case "search":
+      return { state: { ...state, search: { query: "", typing: true }, message: undefined } };
+    case "searchType":
+      return { state: { ...state, search: { ...state.search, query: state.search.query + action.character } } };
+    case "searchBackspace":
+      return { state: { ...state, search: { ...state.search, query: state.search.query.slice(0, -1) } } };
+    case "searchCancel":
+      return { state: { ...state, search: { query: "", typing: false } } };
+    case "searchCommit":
+    case "searchNext": {
+      const settled = { ...state, search: { ...state.search, typing: false } };
+      const row = findFrom(settled, action.kind === "searchCommit" ? state.top : state.top + 1);
+      if (row < 0)
+        return { state: { ...settled, message: state.search.query ? `no match for "${state.search.query}"` : undefined } };
+      return { state: { ...settled, top: clampTop(settled, row), message: undefined } };
+    }
+    default:
+      return { state };
+  }
+}
+function composePagerFrame(state, columns, title = "transcript") {
+  const clip = (text) => text.length <= columns ? text : text.slice(0, Math.max(0, columns - 1));
+  const last = Math.min(state.lines.length, state.top + state.height);
+  const position = `${state.lines.length === 0 ? 0 : state.top + 1}-${last} of ${state.lines.length}`;
+  const body = state.lines.slice(state.top, state.top + state.height).map((text) => ({ text: clip(text) }));
+  while (body.length < state.height)
+    body.push({ text: "" });
+  const bar = state.search.typing ? `/${state.search.query}   Enter find · Esc cancel` : state.message ?? "↑↓ scroll · PgUp/PgDn page · g/G ends · / find · Esc back";
+  return [
+    { text: clip(`${title}   ${position}`), bold: true },
+    ...body,
+    { text: clip(bar), dim: true }
+  ];
+}
+
+// packages/archymedes-cli/src/ui/pager-screen.tsx
+import { jsxDEV } from "@termuijs/jsx/jsx-dev-runtime";
+var Panel = Box;
+var Line = Text;
+var CHROME_ROWS = 2;
+function PagerScreen({ columns, rows, text, title, onExit }) {
+  const [state, setState] = useState(() => initialPagerState(text, rows - CHROME_ROWS));
+  useInput((input, key) => {
+    const action = keyToPagerAction({ name: key?.key, ctrl: key?.ctrl }, input, state);
+    const step = applyPagerAction(state, action);
+    if (step.exit) {
+      onExit();
+      return;
+    }
+    setState(step.state);
+  });
+  const frame = composePagerFrame(state, columns, title);
+  return /* @__PURE__ */ jsxDEV(Panel, {
+    flexDirection: "column",
+    width: columns,
+    height: rows,
+    children: frame.map((row, index) => /* @__PURE__ */ jsxDEV(Line, {
+      bold: row.bold,
+      dimColor: row.dim,
+      children: row.text
+    }, `row-${index}`, false, undefined, this))
+  }, undefined, false, undefined, this);
+}
+async function runPagerScreen(options) {
+  const { renderApp } = await import("@termuijs/jsx");
+  await new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      resolve();
+    };
+    renderApp(PagerScreen, { ...options, onExit: finish, fullscreen: true }).catch(finish);
+  });
+}
+export {
+  runPagerScreen,
+  PagerScreen
+};

package/dist/projection-x6x6hm9t.mjs

@@ -0,0 +1,248 @@
+import {
+  eventJournalPath,
+  readEventJournal
+} from "./archymedes-w4bjfye7.mjs";
+import {
+  __require
+} from "./archymedes-x67v3n58.mjs";
+
+// packages/core/src/cli/projection.ts
+import { promises as fs } from "node:fs";
+import path from "node:path";
+var PROJECTION_SCHEMA_VERSION = 1;
+async function loadSqlite() {
+  const original = process.emitWarning;
+  process.emitWarning = (warning, ...rest) => {
+    const text = typeof warning === "string" ? warning : warning?.message ?? "";
+    const type = typeof rest[0] === "string" ? rest[0] : rest[0]?.type;
+    if (type === "ExperimentalWarning" && /sqlite/i.test(text))
+      return;
+    return original.call(process, warning, ...rest);
+  };
+  try {
+    return await import("node:sqlite");
+  } finally {
+    process.emitWarning = original;
+  }
+}
+var SCHEMA = `
+CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT NOT NULL) STRICT;
+CREATE TABLE events (
+  session_id TEXT NOT NULL,
+  sequence   INTEGER NOT NULL,
+  timestamp  TEXT NOT NULL,
+  type       TEXT NOT NULL,
+  turn_id    TEXT,
+  hash       TEXT NOT NULL,
+  payload    TEXT NOT NULL,
+  PRIMARY KEY (session_id, sequence)
+) STRICT;
+CREATE INDEX events_by_type ON events (session_id, type, sequence);
+-- One row per approval request, updated in place when its decision arrives. Querying "still
+-- waiting" is then an index lookup rather than a join of every request against every decision.
+CREATE TABLE approvals (
+  session_id    TEXT NOT NULL,
+  action_digest TEXT NOT NULL,
+  requested_seq INTEGER NOT NULL,
+  turn_id       TEXT,
+  tool_name     TEXT NOT NULL,
+  summary       TEXT NOT NULL,
+  decided_seq   INTEGER,
+  decision      TEXT,
+  PRIMARY KEY (session_id, requested_seq)
+) STRICT;
+CREATE INDEX approvals_pending ON approvals (session_id, decided_seq);
+-- Searchable text, lowercased once at write time so a query is a scan of prepared values rather
+-- than a per-row LOWER(). FTS5 is deliberately not used: it is a compile-time option, and a
+-- projection that only works on some builds of Node is worse than one that is merely linear.
+CREATE TABLE searchable (
+  session_id TEXT NOT NULL,
+  sequence   INTEGER NOT NULL,
+  kind       TEXT NOT NULL,
+  text       TEXT NOT NULL,
+  PRIMARY KEY (session_id, sequence, kind)
+) STRICT;
+`;
+function textOf(payload) {
+  if (payload.type === "runtime") {
+    const event = payload.event;
+    if (event.type === "tool_call")
+      return [{ kind: "tool_call", text: `${event.toolName} ${JSON.stringify(event.arguments)}` }];
+    if (event.type === "tool_result")
+      return [{ kind: "tool_result", text: event.content }];
+    if (event.type === "runtime_stop")
+      return [{ kind: "summary", text: event.summary }];
+    return [];
+  }
+  if (payload.type === "approval_requested")
+    return [{ kind: "approval", text: payload.request.summary }];
+  return [];
+}
+
+class SessionProjection {
+  database;
+  root;
+  file;
+  constructor(database, root, file) {
+    this.database = database;
+    this.root = root;
+    this.file = file;
+  }
+  static async open(root, options = {}) {
+    const file = options.file ?? path.join(root, ".archymedes", "projection.db");
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const { DatabaseSync } = await loadSqlite();
+    const build = () => {
+      const database2 = new DatabaseSync(file);
+      database2.exec(SCHEMA);
+      database2.prepare("INSERT INTO meta (key, value) VALUES (?, ?)").run("schemaVersion", String(PROJECTION_SCHEMA_VERSION));
+      return database2;
+    };
+    let database;
+    try {
+      database = new DatabaseSync(file);
+      const row = database.prepare("SELECT value FROM meta WHERE key = 'schemaVersion'").get();
+      if (row?.value !== String(PROJECTION_SCHEMA_VERSION)) {
+        database.close();
+        database = undefined;
+        await fs.rm(file, { force: true });
+        database = build();
+      }
+    } catch {
+      try {
+        database?.close();
+      } catch {}
+      await fs.rm(file, { force: true });
+      database = build();
+    }
+    return new SessionProjection(database, root, file);
+  }
+  close() {
+    this.database.close();
+  }
+  async rebuild(sessionId) {
+    const events = await readEventJournal(this.root, sessionId);
+    this.database.exec("BEGIN");
+    try {
+      for (const table of ["events", "approvals", "searchable"]) {
+        this.database.prepare(`DELETE FROM ${table} WHERE session_id = ?`).run(sessionId);
+      }
+      const insertEvent = this.database.prepare("INSERT INTO events (session_id, sequence, timestamp, type, turn_id, hash, payload) VALUES (?, ?, ?, ?, ?, ?, ?)");
+      const insertApproval = this.database.prepare("INSERT INTO approvals (session_id, action_digest, requested_seq, turn_id, tool_name, summary) VALUES (?, ?, ?, ?, ?, ?)");
+      const decideApproval = this.database.prepare("UPDATE approvals SET decided_seq = ?, decision = ? WHERE session_id = ? AND action_digest = ? AND decided_seq IS NULL");
+      const insertText = this.database.prepare("INSERT INTO searchable (session_id, sequence, kind, text) VALUES (?, ?, ?, ?)");
+      for (const event of events) {
+        const payload = event.payload;
+        const turnId = "turnId" in payload ? payload.turnId : null;
+        insertEvent.run(sessionId, event.sequence, event.timestamp, payload.type, turnId, event.hash, JSON.stringify(payload));
+        if (payload.type === "approval_requested") {
+          insertApproval.run(sessionId, payload.request.actionDigest, event.sequence, turnId, payload.request.toolName, payload.request.summary);
+        }
+        if (payload.type === "approval_decided") {
+          decideApproval.run(event.sequence, payload.decision, sessionId, payload.actionDigest);
+        }
+        for (const entry of textOf(payload))
+          insertText.run(sessionId, event.sequence, entry.kind, entry.text.toLowerCase());
+      }
+      this.database.exec("COMMIT");
+      return { events: events.length };
+    } catch (error) {
+      this.database.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async rebuildAll() {
+    const directory = path.dirname(eventJournalPath(this.root, "placeholder"));
+    const files = await fs.readdir(directory).catch(() => []);
+    let events = 0;
+    let sessions = 0;
+    for (const file of files) {
+      if (!file.endsWith(".jsonl"))
+        continue;
+      const result = await this.rebuild(file.slice(0, -6));
+      events += result.events;
+      sessions += 1;
+    }
+    return { sessions, events };
+  }
+  eventsAfter(sessionId, cursor, limit = 500) {
+    const rows = this.database.prepare("SELECT session_id, sequence, timestamp, type, turn_id, hash, payload FROM events WHERE session_id = ? AND sequence > ? ORDER BY sequence LIMIT ?").all(sessionId, cursor, limit);
+    return rows.map((row) => ({
+      sessionId: row.session_id,
+      sequence: row.sequence,
+      timestamp: row.timestamp,
+      type: row.type,
+      turnId: row.turn_id ?? null,
+      hash: row.hash,
+      payload: JSON.parse(row.payload)
+    }));
+  }
+  cursor(sessionId) {
+    const row = this.database.prepare("SELECT MAX(sequence) AS last FROM events WHERE session_id = ?").get(sessionId);
+    return row?.last ?? 0;
+  }
+  pendingApprovals(sessionId) {
+    const rows = sessionId ? this.database.prepare("SELECT * FROM approvals WHERE decided_seq IS NULL AND session_id = ? ORDER BY requested_seq").all(sessionId) : this.database.prepare("SELECT * FROM approvals WHERE decided_seq IS NULL ORDER BY session_id, requested_seq").all();
+    return rows.map((row) => ({
+      sessionId: row.session_id,
+      actionDigest: row.action_digest,
+      requestedSeq: row.requested_seq,
+      turnId: row.turn_id ?? null,
+      toolName: row.tool_name,
+      summary: row.summary
+    }));
+  }
+  search(query, options = {}) {
+    const needle = query.trim().toLowerCase();
+    if (!needle)
+      return [];
+    const pattern = `%${needle.replace(/[\\%_]/g, (character) => `\\${character}`)}%`;
+    const limit = options.limit ?? 50;
+    const rows = options.sessionId ? this.database.prepare("SELECT * FROM searchable WHERE text LIKE ? ESCAPE '\\' AND session_id = ? ORDER BY sequence LIMIT ?").all(pattern, options.sessionId, limit) : this.database.prepare("SELECT * FROM searchable WHERE text LIKE ? ESCAPE '\\' ORDER BY session_id, sequence LIMIT ?").all(pattern, limit);
+    return rows.map((row) => ({ sessionId: row.session_id, sequence: row.sequence, kind: row.kind, text: row.text }));
+  }
+  sessions() {
+    const rows = this.database.prepare("SELECT session_id, COUNT(*) AS events, MIN(timestamp) AS first_at, MAX(timestamp) AS last_at, MAX(sequence) AS last_sequence FROM events GROUP BY session_id ORDER BY last_at DESC").all();
+    return rows.map((row) => ({
+      sessionId: row.session_id,
+      events: row.events,
+      firstAt: row.first_at,
+      lastAt: row.last_at,
+      lastSequence: row.last_sequence
+    }));
+  }
+  fork(sessionId, newSessionId, throughSequence) {
+    if (newSessionId === sessionId)
+      throw new Error("A fork needs a different session id");
+    this.database.exec("BEGIN");
+    try {
+      for (const table of ["events", "approvals", "searchable"]) {
+        this.database.prepare(`DELETE FROM ${table} WHERE session_id = ?`).run(newSessionId);
+      }
+      this.database.prepare("INSERT INTO events (session_id, sequence, timestamp, type, turn_id, hash, payload) SELECT ?, sequence, timestamp, type, turn_id, hash, payload FROM events WHERE session_id = ? AND sequence <= ?").run(newSessionId, sessionId, throughSequence);
+      this.database.prepare("INSERT INTO approvals (session_id, action_digest, requested_seq, turn_id, tool_name, summary, decided_seq, decision) SELECT ?, action_digest, requested_seq, turn_id, tool_name, summary, decided_seq, decision FROM approvals WHERE session_id = ? AND requested_seq <= ?").run(newSessionId, sessionId, throughSequence);
+      this.database.prepare("INSERT INTO searchable (session_id, sequence, kind, text) SELECT ?, sequence, kind, text FROM searchable WHERE session_id = ? AND sequence <= ?").run(newSessionId, sessionId, throughSequence);
+      this.database.exec("COMMIT");
+      return { events: this.cursor(newSessionId) === 0 ? 0 : this.eventsAfter(newSessionId, 0, Number.MAX_SAFE_INTEGER).length };
+    } catch (error) {
+      this.database.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  archive(sessionId) {
+    this.database.exec("BEGIN");
+    try {
+      for (const table of ["events", "approvals", "searchable"]) {
+        this.database.prepare(`DELETE FROM ${table} WHERE session_id = ?`).run(sessionId);
+      }
+      this.database.exec("COMMIT");
+    } catch (error) {
+      this.database.exec("ROLLBACK");
+      throw error;
+    }
+  }
+}
+export {
+  SessionProjection,
+  PROJECTION_SCHEMA_VERSION
+};