@juli-os/ledger 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1216 @@
+// src/platform/ledger/store.ts
+import { DatabaseSync } from "node:sqlite";
+
+// src/platform/shared/json.ts
+var safeParse = (raw) => {
+  if (raw === null || raw === void 0 || raw === "") return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+var asRecord = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+
+// src/platform/shared/clock.ts
+var systemClock = {
+  now: () => /* @__PURE__ */ new Date()
+};
+var hex = (n2) => Array.from({ length: n2 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+var randomIds = {
+  newId: (prefix) => `${prefix}_${hex(12)}`
+};
+var rfc3339 = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+
+// src/contracts/entities.ts
+var TERMINAL_WORKFLOW_STATUSES = [
+  "completed",
+  "failed",
+  "cancelled",
+  "rejected"
+];
+var AGENT_STEP_KINDS = ["agent", "verify"];
+
+// src/contracts/statuses.ts
+var WORKFLOW_STATUSES = [
+  { key: "queued", label: "\u6392\u961F\u4E2D", group: "\u8FDB\u884C\u4E2D", terminal: false },
+  { key: "running", label: "\u8FDB\u884C\u4E2D", group: "\u8FDB\u884C\u4E2D", terminal: false },
+  { key: "completed", label: "\u5DF2\u5B8C\u6210", group: "\u7EC8\u6001", terminal: true },
+  { key: "failed", label: "\u5931\u8D25", group: "\u7EC8\u6001", terminal: true },
+  { key: "cancelled", label: "\u5DF2\u53D6\u6D88", group: "\u7EC8\u6001", terminal: true },
+  { key: "rejected", label: "\u5DF2\u62D2\u7EDD", group: "\u7EC8\u6001", terminal: true }
+];
+var STEP_STATUSES = [
+  { key: "pending", label: "\u5F85\u6392", group: "\u8FDB\u884C\u4E2D", terminal: false },
+  { key: "running", label: "\u8FDB\u884C\u4E2D", group: "\u8FDB\u884C\u4E2D", terminal: false },
+  { key: "waiting_human", label: "\u7B49\u4F60\u51B3\u5B9A", group: "\u7B49\u51B3\u5B9A", terminal: false },
+  { key: "completed", label: "\u5DF2\u5B8C\u6210", group: "\u7EC8\u6001", terminal: true },
+  { key: "failed", label: "\u5931\u8D25", group: "\u7EC8\u6001", terminal: true },
+  { key: "cancelled", label: "\u5DF2\u53D6\u6D88", group: "\u7EC8\u6001", terminal: true },
+  { key: "skipped", label: "\u5DF2\u8DF3\u8FC7", group: "\u7EC8\u6001", terminal: true }
+];
+var ACTIVE_STEP_STATUSES = STEP_STATUSES.filter((s) => !s.terminal).map((s) => s.key);
+var ACTIVE_WORKFLOW_STATUSES = WORKFLOW_STATUSES.filter((s) => !s.terminal).map((s) => s.key);
+var SETTLED_STEP_STATUSES = STEP_STATUSES.filter((s) => s.key === "completed" || s.key === "cancelled").map((s) => s.key);
+var SETTLED_WORKFLOW_STATUSES = WORKFLOW_STATUSES.filter((s) => s.key === "completed" || s.key === "cancelled").map((s) => s.key);
+var TERMINAL_STEP_STATUSES = STEP_STATUSES.filter((s) => s.terminal).map((s) => s.key);
+var DEDUP_WINDOW_STATUSES = ["queued", "running", "waiting_human"];
+var PRUNE_WORKFLOW_STATUSES = ["completed", "cancelled", "rejected"];
+var sqlInList = (keys) => keys.map((k) => `'${k}'`).join(",");
+
+// src/platform/ledger/casefile.ts
+var emptyCaseFile = (now) => ({
+  original: {},
+  extract: null,
+  executions: [],
+  draft: null,
+  decisions: [],
+  references: [],
+  artifacts: [],
+  updatedAt: rfc3339(now)
+});
+var pick = (vals, guard) => {
+  const out = [];
+  for (const v of vals) {
+    if (typeof v === "object" && v !== null && guard(v)) out.push(v);
+  }
+  return out;
+};
+var parseCaseFile = (raw, now) => {
+  const base = emptyCaseFile(now);
+  const v = safeParse(raw);
+  if (!v || typeof v !== "object" || Array.isArray(v)) return base;
+  const r = v;
+  const str2 = (k) => {
+    const x = r[k];
+    return typeof x === "string" ? x : "";
+  };
+  const arr = (k) => {
+    const x = r[k];
+    return Array.isArray(x) ? x : [];
+  };
+  return {
+    original: Object.fromEntries(
+      Object.entries(asRecord(r.original)).filter(([, x]) => typeof x === "string")
+    ),
+    extract: r.extract ?? null,
+    executions: arr("executions"),
+    draft: r.draft ?? null,
+    decisions: pick(arr("decisions"), (d) => "action" in d),
+    references: arr("references").filter((x) => typeof x === "string"),
+    artifacts: pick(arr("artifacts"), (a) => "id" in a),
+    updatedAt: str2("updated_at") || base.updatedAt
+  };
+};
+var serializeCaseFile = (cf) => JSON.stringify(cf);
+
+// src/platform/ledger/store.ts
+var MIGRATIONS = `
+CREATE TABLE IF NOT EXISTS workflows (
+  id TEXT PRIMARY KEY,
+  parent_id TEXT,
+  kind TEXT NOT NULL DEFAULT 'adhoc',
+  title TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'running',
+  session TEXT,
+  project TEXT,
+  path TEXT,
+  meta TEXT,
+  case_file TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS workflow_steps (
+  id TEXT PRIMARY KEY,
+  workflow_id TEXT NOT NULL,
+  seq INTEGER NOT NULL,
+  kind TEXT NOT NULL,
+  title TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'pending',
+  input TEXT,
+  output TEXT,
+  summary TEXT,
+  updated_at TEXT NOT NULL,
+  started_at TEXT,
+  completed_at TEXT,
+  UNIQUE(workflow_id, seq)
+);
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entity_type TEXT NOT NULL,
+  entity_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  payload TEXT,
+  ts TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS runs (
+  id TEXT PRIMARY KEY,
+  workflow_id TEXT NOT NULL,
+  session TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'running',
+  created_at TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS prompts (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL,
+  content TEXT NOT NULL DEFAULT '',
+  source TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'submitted',
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_steps_wf ON workflow_steps(workflow_id, seq);
+CREATE TABLE IF NOT EXISTS relays (
+  id TEXT PRIMARY KEY,
+  workflow_id TEXT NOT NULL,
+  step_id TEXT NOT NULL,
+  session TEXT NOT NULL,
+  text TEXT NOT NULL,
+  marker TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  delivered_at TEXT,
+  attempts INTEGER NOT NULL DEFAULT 0,
+  last_error TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_events_entity ON events(entity_type, entity_id);
+CREATE INDEX IF NOT EXISTS idx_runs_session ON runs(session, status);
+`;
+var str = (v) => typeof v === "string" ? v : v === null || v === void 0 ? "" : String(v);
+var num = (v) => typeof v === "number" ? v : Number(v ?? 0);
+var dedupPattern = (key) => {
+  const jsonValue = JSON.stringify(key).slice(1, -1);
+  return `%"dedup_key":"${jsonValue.replace(/[%_\\]/g, (c) => `\\${c}`)}"%`;
+};
+var SEND_STEP_LIKE_CUTOFF = "2026-09-19";
+var rowToWorkflow = (r) => ({
+  id: str(r["id"]),
+  parentId: r["parent_id"] === null ? null : str(r["parent_id"]),
+  kind: str(r["kind"]),
+  title: str(r["title"]),
+  status: str(r["status"]),
+  session: str(r["session"]),
+  project: str(r["project"]),
+  path: str(r["path"]),
+  threadId: r["thread_id"] === null || r["thread_id"] === void 0 ? null : str(r["thread_id"]),
+  meta: asRecord(safeParse(str(r["meta"]))),
+  createdAt: str(r["created_at"]),
+  updatedAt: str(r["updated_at"])
+});
+var rowToStep = (r) => ({
+  id: str(r["id"]),
+  workflowId: str(r["workflow_id"]),
+  seq: num(r["seq"]),
+  kind: str(r["kind"]),
+  title: str(r["title"]),
+  status: str(r["status"]),
+  input: asRecord(safeParse(str(r["input"]))),
+  output: asRecord(safeParse(str(r["output"]))),
+  summary: str(r["summary"]),
+  updatedAt: str(r["updated_at"]),
+  startedAt: str(r["started_at"] ?? ""),
+  completedAt: r["completed_at"] === null || r["completed_at"] === void 0 ? null : str(r["completed_at"])
+});
+var rowToEvent = (r) => ({
+  id: num(r["id"]),
+  entityType: str(r["entity_type"]),
+  entityId: str(r["entity_id"]),
+  type: str(r["type"]),
+  payload: asRecord(safeParse(str(r["payload"]))),
+  ts: str(r["ts"])
+});
+var pruneImpl = (db, retentionDays, nowIso) => {
+  if (retentionDays <= 0) return { events: 0, workflows: 0 };
+  const cutoff = new Date(new Date(nowIso).getTime() - retentionDays * 864e5).toISOString();
+  const ev = db.prepare("DELETE FROM events WHERE ts < ?").run(cutoff);
+  const wfRows = db.prepare(
+    `SELECT id FROM workflows WHERE status IN (${sqlInList(PRUNE_WORKFLOW_STATUSES)}) AND updated_at < ?`
+  ).all(cutoff);
+  let wfCount = 0;
+  for (const r of wfRows) {
+    db.prepare("DELETE FROM workflow_steps WHERE workflow_id=?").run(r.id);
+    db.prepare("DELETE FROM workflows WHERE id=?").run(r.id);
+    wfCount++;
+  }
+  return { events: Number(ev.changes), workflows: wfCount };
+};
+var STEP_COLS = `id, workflow_id, seq, kind, title, status, COALESCE(input,'') AS input,
+  COALESCE(output,'') AS output, COALESCE(summary,'') AS summary, updated_at,
+  started_at, completed_at`;
+var createLedgerStore = (dbPath, deps = {}) => {
+  const clock = deps.clock ?? systemClock;
+  const ids = deps.ids ?? randomIds;
+  const db = new DatabaseSync(dbPath);
+  db.exec(MIGRATIONS);
+  const wfCols = db.prepare("PRAGMA table_info(workflows)").all().map((c) => c.name);
+  if (!wfCols.includes("owner")) {
+    db.exec("ALTER TABLE workflows ADD COLUMN owner TEXT");
+  }
+  if (!wfCols.includes("thread_id")) {
+    db.exec("ALTER TABLE workflows ADD COLUMN thread_id TEXT");
+  }
+  db.exec("CREATE INDEX IF NOT EXISTS idx_workflows_thread ON workflows(thread_id)");
+  const stepCols = db.prepare("PRAGMA table_info(workflow_steps)").all().map((c) => c.name);
+  if (!stepCols.includes("started_at")) db.exec("ALTER TABLE workflow_steps ADD COLUMN started_at TEXT");
+  if (!stepCols.includes("completed_at")) db.exec("ALTER TABLE workflow_steps ADD COLUMN completed_at TEXT");
+  const now = () => rfc3339(clock.now());
+  const mergeStepJson = (id, col, patch) => {
+    const row = db.prepare(`SELECT COALESCE(${col},'{}') AS v FROM workflow_steps WHERE id=?`).get(id);
+    const cur = asRecord(safeParse(str(row?.["v"])));
+    const merged = { ...cur, ...patch };
+    db.prepare(`UPDATE workflow_steps SET ${col}=?, updated_at=? WHERE id=?`).run(JSON.stringify(merged), now(), id);
+  };
+  const getWorkflowById = (id) => {
+    const r = db.prepare("SELECT * FROM workflows WHERE id=?").get(id);
+    return r ? rowToWorkflow(r) : null;
+  };
+  const getStepById = (id) => {
+    const r = db.prepare(`SELECT ${STEP_COLS} FROM workflow_steps WHERE id=?`).get(id);
+    return r ? rowToStep(r) : null;
+  };
+  const activeRunOf = (session) => {
+    const r = db.prepare(
+      `SELECT r.id AS id, r.workflow_id AS workflow_id, r.session AS session,
+              r.status AS status, r.created_at AS created_at FROM runs r
+       JOIN workflows w ON w.id = r.workflow_id
+       WHERE r.session=? AND r.status IN ('running','idle') AND w.status='running'
+       ORDER BY r.created_at DESC LIMIT 1`
+    ).get(session);
+    if (!r) return null;
+    return {
+      id: str(r["id"]),
+      workflowId: str(r["workflow_id"]),
+      session: str(r["session"]),
+      status: "running",
+      createdAt: str(r["created_at"])
+    };
+  };
+  return {
+    db,
+    createWorkflow(w) {
+      const id = ids.newId("wf");
+      const ts = now();
+      db.prepare(
+        `INSERT INTO workflows (id, parent_id, kind, title, status, owner, meta, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(id, w.parentId ?? null, w.kind, w.title, w.status ?? "running", w.owner ?? null, JSON.stringify(w.meta ?? {}), ts, ts);
+      return getWorkflowById(id);
+    },
+    getWorkflow(id) {
+      const r = db.prepare("SELECT * FROM workflows WHERE id=?").get(id);
+      return r ? rowToWorkflow(r) : null;
+    },
+    listWorkflows(limit = 100, status) {
+      if (status !== void 0 && status !== "") {
+        return db.prepare("SELECT * FROM workflows WHERE status=? ORDER BY created_at DESC, rowid DESC LIMIT ?").all(status, limit).map(rowToWorkflow);
+      }
+      return db.prepare("SELECT * FROM workflows ORDER BY created_at DESC, rowid DESC LIMIT ?").all(limit).map(rowToWorkflow);
+    },
+    setWorkflowSession(id, session) {
+      db.prepare("UPDATE workflows SET session=?, updated_at=? WHERE id=?").run(session, now(), id);
+    },
+    setWorkflowStatus(id, status) {
+      db.prepare("UPDATE workflows SET status=?, updated_at=? WHERE id=?").run(status, now(), id);
+      if (TERMINAL_WORKFLOW_STATUSES.includes(status)) {
+        const runStatus = status === "failed" ? "failed" : "completed";
+        db.prepare(`UPDATE runs SET status=? WHERE workflow_id=? AND status IN ('running','idle')`).run(runStatus, id);
+      }
+    },
+    updateWorkflowMeta(id, patch) {
+      const row = db.prepare(`SELECT COALESCE(meta,'{}') AS v FROM workflows WHERE id=?`).get(id);
+      const cur = asRecord(safeParse(str(row?.["v"])));
+      const merged = { ...cur };
+      for (const [k, v] of Object.entries(patch)) {
+        if (v === null) delete merged[k];
+        else merged[k] = v;
+      }
+      db.prepare("UPDATE workflows SET meta=?, updated_at=? WHERE id=?").run(JSON.stringify(merged), now(), id);
+      return merged;
+    },
+    setWorkflowRouting(id, session, project) {
+      db.prepare("UPDATE workflows SET session=?, project=?, updated_at=? WHERE id=?").run(session || null, project || null, now(), id);
+    },
+    assignThread(workflowId, threadId) {
+      if (threadId === "") return;
+      db.prepare("UPDATE workflows SET thread_id=?, updated_at=? WHERE id=?").run(threadId, now(), workflowId);
+    },
+    latestByMessageId(messageId, excludeWorkflowId) {
+      if (messageId === "") return null;
+      const r = db.prepare(
+        `SELECT * FROM workflows WHERE json_extract(meta,'$.message_id')=?
+           AND (? IS NULL OR id != ?)
+         ORDER BY created_at DESC, rowid DESC LIMIT 1`
+      ).get(messageId, excludeWorkflowId ?? null, excludeWorkflowId ?? "");
+      return r ? rowToWorkflow(r) : null;
+    },
+    recentBySender(from, sinceIso, excludeWorkflowId, limit = 200) {
+      return db.prepare(
+        `SELECT * FROM workflows WHERE status != 'rejected'
+           AND lower(COALESCE(json_extract(meta,'$.from'),'')) = lower(?)
+           AND created_at >= ?
+           AND (? IS NULL OR id != ?)
+         ORDER BY created_at DESC, rowid DESC LIMIT ?`
+      ).all(from, sinceIso, excludeWorkflowId ?? null, excludeWorkflowId ?? "", limit).map(rowToWorkflow);
+    },
+    loadCaseFile(id) {
+      const row = db.prepare("SELECT COALESCE(case_file,'') AS v FROM workflows WHERE id=?").get(id);
+      return parseCaseFile(str(row?.["v"]) || null, clock.now());
+    },
+    saveCaseFile(id, cf) {
+      db.prepare("UPDATE workflows SET case_file=?, updated_at=? WHERE id=?").run(serializeCaseFile(cf), now(), id);
+    },
+    createStep(s) {
+      const id = ids.newId("st");
+      db.prepare(
+        `INSERT INTO workflow_steps (id, workflow_id, seq, kind, title, status, input, updated_at)
+         VALUES (?, ?, ?, ?, ?, 'pending', ?, ?)`
+      ).run(id, s.workflowId, s.seq, s.kind, s.title, JSON.stringify(s.input ?? {}), now());
+      return getStepById(id);
+    },
+    insertStepsAt(workflowId, afterSeq, steps) {
+      if (steps.length === 0) return;
+      const insert = db.prepare(
+        `INSERT INTO workflow_steps (id, workflow_id, seq, kind, title, status, input, updated_at)
+         VALUES (?, ?, ?, ?, ?, 'pending', ?, ?)`
+      );
+      const shift = db.prepare(
+        "UPDATE workflow_steps SET seq = seq + ? WHERE workflow_id = ? AND seq >= ?"
+      );
+      db.exec("BEGIN");
+      try {
+        shift.run(steps.length, workflowId, afterSeq + 1);
+        steps.forEach((st, i) => {
+          insert.run(
+            ids.newId("st"),
+            workflowId,
+            afterSeq + 1 + i,
+            st.kind,
+            st.title,
+            JSON.stringify(st.input ?? {}),
+            now()
+          );
+        });
+        db.exec("COMMIT");
+      } catch (e) {
+        db.exec("ROLLBACK");
+        throw e;
+      }
+    },
+    getStep(id) {
+      const r = db.prepare(`SELECT ${STEP_COLS} FROM workflow_steps WHERE id=?`).get(id);
+      return r ? rowToStep(r) : null;
+    },
+    stepsForWorkflow(id) {
+      return db.prepare(`SELECT ${STEP_COLS} FROM workflow_steps WHERE workflow_id=? ORDER BY seq`).all(id).map(rowToStep);
+    },
+    currentStep(id) {
+      const r = db.prepare(
+        `SELECT ${STEP_COLS} FROM workflow_steps
+         WHERE workflow_id=? AND status IN (${sqlInList(ACTIVE_STEP_STATUSES)}) ORDER BY seq LIMIT 1`
+      ).get(id);
+      return r ? rowToStep(r) : null;
+    },
+    setStepStatus(id, status) {
+      db.prepare(`UPDATE workflow_steps SET status=?, updated_at=?,
+        started_at=COALESCE(started_at, CASE WHEN ? NOT IN ('pending') THEN ? END),
+        completed_at=CASE WHEN ? IN (${sqlInList(TERMINAL_STEP_STATUSES)})
+          THEN COALESCE(completed_at, ?) ELSE completed_at END
+        WHERE id=?`).run(status, now(), status, now(), status, now(), id);
+    },
+    setStepInput(id, patch) {
+      mergeStepJson(id, "input", patch);
+    },
+    insertRelay(r) {
+      const id = ids.newId("relay");
+      db.prepare(`INSERT INTO relays (id, workflow_id, step_id, session, text, marker, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, r.workflowId, r.stepId, r.session, r.text, r.marker, now());
+      return id;
+    },
+    pendingRelays() {
+      return db.prepare(`SELECT id, workflow_id, step_id, session, text, marker, created_at, attempts,
+          COALESCE(last_error,'') AS last_error FROM relays WHERE delivered_at IS NULL ORDER BY created_at`).all().map((r) => ({
+        id: str(r["id"]),
+        workflowId: str(r["workflow_id"]),
+        stepId: str(r["step_id"]),
+        session: str(r["session"]),
+        text: str(r["text"]),
+        marker: str(r["marker"]),
+        createdAt: str(r["created_at"]),
+        attempts: num(r["attempts"]),
+        lastError: str(r["last_error"])
+      }));
+    },
+    markRelayDelivered(id) {
+      db.prepare("UPDATE relays SET delivered_at=? WHERE id=?").run(now(), id);
+    },
+    markRelayAttempt(id, error) {
+      db.prepare("UPDATE relays SET attempts=attempts+1, last_error=? WHERE id=?").run(error.slice(0, 300), id);
+    },
+    setStepOutput(id, patch) {
+      mergeStepJson(id, "output", patch);
+    },
+    appendStepOutputItem(id, key, entry, cap) {
+      const row = db.prepare(`SELECT COALESCE(output,'{}') AS v FROM workflow_steps WHERE id=?`).get(id);
+      const cur = asRecord(safeParse(str(row?.["v"])));
+      const arr = Array.isArray(cur[key]) ? [...cur[key], entry] : [entry];
+      const next = cap > 0 && arr.length > cap ? arr.slice(arr.length - cap) : arr;
+      db.prepare("UPDATE workflow_steps SET output=?, updated_at=? WHERE id=?").run(JSON.stringify({ ...cur, [key]: next }), now(), id);
+    },
+    claimRunningStep(id) {
+      const res = db.prepare(
+        `UPDATE workflow_steps SET status='completed', updated_at=?,
+           completed_at=COALESCE(completed_at, ?) WHERE id=? AND status='running'`
+      ).run(now(), now(), id);
+      return Number(res.changes) === 1;
+    },
+    listSteps(status, limit = 100) {
+      return db.prepare(
+        `SELECT ${STEP_COLS} FROM workflow_steps WHERE status=? ORDER BY updated_at DESC LIMIT ?`
+      ).all(status, limit).map(rowToStep);
+    },
+    runningAgentStepForSession(session) {
+      const r = db.prepare(
+        `SELECT st.id AS id, st.workflow_id AS workflow_id, st.seq AS seq, st.kind AS kind,
+                COALESCE(st.title,'') AS title, st.status AS status,
+                COALESCE(st.input,'') AS input, COALESCE(st.output,'') AS output,
+                COALESCE(st.summary,'') AS summary, st.updated_at AS updated_at
+         FROM workflow_steps st
+         JOIN workflows w ON w.id = st.workflow_id
+         JOIN runs r ON r.workflow_id = st.workflow_id
+         WHERE st.status='running' AND st.kind IN (${sqlInList(AGENT_STEP_KINDS)}) AND r.session=? AND w.status='running'
+         ORDER BY st.updated_at DESC LIMIT 1`
+      ).get(session);
+      if (r) return rowToStep(r);
+      const r2 = db.prepare(
+        `SELECT st.id AS id, st.workflow_id AS workflow_id, st.seq AS seq, st.kind AS kind,
+                COALESCE(st.title,'') AS title, st.status AS status,
+                COALESCE(st.input,'') AS input, COALESCE(st.output,'') AS output,
+                COALESCE(st.summary,'') AS summary, st.updated_at AS updated_at
+         FROM workflow_steps st
+         JOIN workflows w ON w.id = st.workflow_id
+         WHERE st.status='running' AND st.kind IN (${sqlInList(AGENT_STEP_KINDS)}) AND w.status='running'
+           AND (w.session=? OR COALESCE(json_extract(w.meta,'$.assigned_session'),'')=?)
+         ORDER BY st.updated_at DESC LIMIT 1`
+      ).get(session, session);
+      return r2 ? rowToStep(r2) : null;
+    },
+    sessionHasOpenWork(session, excludeWorkflowId) {
+      const anchor = "(session=?1 OR COALESCE(json_extract(meta,'$.assigned_session'),'')=?1 OR id IN (SELECT workflow_id FROM runs WHERE session=?1))";
+      const sql = excludeWorkflowId !== void 0 && excludeWorkflowId !== "" ? `SELECT COUNT(*) AS n FROM workflows WHERE status IN ('queued','running') AND ${anchor} AND id != ?2` : `SELECT COUNT(*) AS n FROM workflows WHERE status IN ('queued','running') AND ${anchor}`;
+      const row = excludeWorkflowId !== void 0 && excludeWorkflowId !== "" ? db.prepare(sql).get(session, excludeWorkflowId) : db.prepare(sql).get(session);
+      return Number(row["n"]) > 0;
+    },
+    appendEvent(entityType, entityId, type, payload = {}) {
+      const ts = now();
+      const res = db.prepare(
+        "INSERT INTO events (entity_type, entity_id, type, payload, ts) VALUES (?, ?, ?, ?, ?)"
+      ).run(entityType, entityId, type, JSON.stringify(payload), ts);
+      return {
+        id: Number(res.lastInsertRowid),
+        entityType,
+        entityId,
+        type,
+        payload,
+        ts
+      };
+    },
+    listEvents(limit = 200, types) {
+      if (types !== void 0 && types.length > 0) {
+        const ph = types.map(() => "?").join(",");
+        return db.prepare(`SELECT * FROM events WHERE type IN (${ph}) ORDER BY id DESC LIMIT ?`).all(...types, limit).map(rowToEvent);
+      }
+      return db.prepare("SELECT * FROM events ORDER BY id DESC LIMIT ?").all(limit).map(rowToEvent);
+    },
+    eventsSince(afterId, limit = 200) {
+      return db.prepare("SELECT * FROM events WHERE id>? ORDER BY id ASC LIMIT ?").all(afterId, limit).map(rowToEvent);
+    },
+    entityEvents(entityType, entityId, type, limit = 500) {
+      return db.prepare(
+        "SELECT * FROM events WHERE entity_type=? AND entity_id=? AND type=? ORDER BY id ASC LIMIT ?"
+      ).all(entityType, entityId, type, limit).map(rowToEvent);
+    },
+    lastEventAt(entityType, entityId) {
+      const r = db.prepare(
+        "SELECT MAX(ts) AS m FROM events WHERE entity_type=? AND entity_id=?"
+      ).get(entityType, entityId);
+      const m = r?.["m"];
+      return m === null || m === void 0 ? "" : String(m);
+    },
+    createRun(workflowId, session) {
+      const id = ids.newId("run");
+      db.prepare(`INSERT INTO runs (id, workflow_id, session, status, created_at)
+        VALUES (?, ?, ?, 'running', ?)`).run(id, workflowId, session, now());
+      return {
+        id,
+        workflowId,
+        session,
+        status: "running",
+        createdAt: now()
+      };
+    },
+    activeRunForSession: (session) => activeRunOf(session),
+    /** 活跃去重：同 dedup_key 且工作流仍在途 → 跳过重复建流。
+     * ⚠ ESCAPE '\' 必须与转义成对：message-id 几乎必含 `_`，漏写 ESCAPE 时
+     * `\_` 成了"字面反斜杠+任意字符"，模式永不匹配——去重整体失效（09-07 事故）。 */
+    hasActiveDedup(key) {
+      const r = db.prepare(
+        `SELECT 1 FROM workflows WHERE status IN (${sqlInList(DEDUP_WINDOW_STATUSES)})
+         AND meta LIKE ? ESCAPE '\\' LIMIT 1`
+      ).get(dedupPattern(key));
+      return r !== void 0;
+    },
+    /** 已摄取去重（轮询层）：同 dedup_key 存在任何非 rejected 工作流 → 这封
+     * 邮件已被处理过（含 failed），轮询不再重复拉取。重试走步骤 retry，不走再摄取。 */
+    hasSeenDedup(key) {
+      const r = db.prepare(
+        `SELECT 1 FROM workflows WHERE status != 'rejected'
+         AND meta LIKE ? ESCAPE '\\' LIMIT 1`
+      ).get(dedupPattern(key));
+      return r !== void 0;
+    },
+    /** 自回环守卫查询（2026-09-20 断点十三）：message_id 是否命中本引擎已
+     * 发送记录——completed send 步的 output.message_id（email_sent 事件同源
+     * 落账）。进件层据此丢弃投递副本回灌（引擎给轮询邮箱自己发信的 echo）。
+     * LIKE 预筛 + 精确比对：JSON 编码取实际存储字节，%/_/\ 照 dedupPattern
+     * 成对转义（message-id 几乎必含 `_`）。 */
+    recordSentMessageId(messageId, meta) {
+      if (messageId === "") return;
+      db.prepare(
+        `INSERT INTO events (entity_type, entity_id, type, payload, ts) VALUES ('email', ?, 'email_sent', ?, ?)`
+      ).run(messageId, JSON.stringify(meta ?? {}), now());
+    },
+    sentMessageIdExists(messageId) {
+      if (messageId === "") return false;
+      const registered = db.prepare(
+        `SELECT 1 FROM events WHERE type = 'email_sent' AND entity_type = 'email' AND entity_id = ? LIMIT 1`
+      ).get(messageId);
+      if (registered !== void 0) return true;
+      const jsonValue = JSON.stringify(messageId).slice(1, -1);
+      const pattern = `%"message_id":"${jsonValue.replace(/[%_\\]/g, (c) => `\\${c}`)}"%`;
+      const rows = db.prepare(
+        `SELECT output FROM workflow_steps WHERE kind = 'send' AND status = 'completed'
+         AND updated_at < ? AND output LIKE ? ESCAPE '\\'`
+      ).all(SEND_STEP_LIKE_CUTOFF, pattern);
+      return rows.some((r) => {
+        const out = safeParse(str(r["output"]));
+        return out !== null && typeof out === "object" && !Array.isArray(out) && out["message_id"] === messageId;
+      });
+    },
+    createPrompt(runId, content, source) {
+      const id = ids.newId("pr");
+      db.prepare(`INSERT INTO prompts (id, run_id, content, source, status, created_at)
+        VALUES (?, ?, ?, ?, 'submitted', ?)`).run(id, runId, content, source, now());
+      return { id, runId, content, status: "submitted", createdAt: now() };
+    },
+    prune(retentionDays) {
+      return pruneImpl(db, retentionDays, now());
+    },
+    taskViews(limit = 500) {
+      const all = db.prepare("SELECT * FROM workflows ORDER BY created_at DESC, rowid DESC LIMIT ?").all(limit).map(rowToWorkflow);
+      const byId = new Map(all.map((w) => [w.id, w]));
+      const parentOf = (w) => {
+        const rel = w.meta["related_workflow"];
+        if (typeof rel === "string" && rel !== "") return rel;
+        return w.parentId ?? "";
+      };
+      const isTaskCard = (w) => w.meta["mode"] === "nodes";
+      const rootCache = /* @__PURE__ */ new Map();
+      const rootOf = (w) => {
+        const cached = rootCache.get(w.id);
+        if (cached !== void 0) return cached;
+        const path = [];
+        let cur = w;
+        while (cur !== void 0 && !path.some((p) => p.id === cur.id)) {
+          path.push(cur);
+          const pid = parentOf(cur);
+          if (pid === "") break;
+          cur = byId.get(pid);
+        }
+        let best = "";
+        for (let i = path.length - 1; i >= 0; i--) {
+          const p = path[i];
+          if (best === "" && isTaskCard(p)) best = p.id;
+          rootCache.set(p.id, best);
+        }
+        return rootCache.get(w.id) ?? "";
+      };
+      const members = /* @__PURE__ */ new Map();
+      const map = {};
+      for (const w of all) {
+        const root = rootOf(w);
+        if (root === "") continue;
+        map[w.id] = root;
+        const arr = members.get(root);
+        if (arr === void 0) members.set(root, [w.id]);
+        else arr.push(w.id);
+      }
+      const views = [...members.entries()].map(([taskId, ids2]) => {
+        const card = byId.get(taskId);
+        return { taskId, title: card.title, status: card.status, workflowIds: ids2 };
+      }).sort((a, b) => {
+        const ca = byId.get(a.taskId)?.createdAt ?? "";
+        const cb = byId.get(b.taskId)?.createdAt ?? "";
+        return cb.localeCompare(ca);
+      });
+      return { views, map };
+    },
+    latestPromptForSession(session, statuses) {
+      const run = activeRunOf(session);
+      if (!run) return null;
+      const placeholders = statuses.map(() => "?").join(",");
+      const r = db.prepare(
+        `SELECT id, run_id, content, status, created_at FROM prompts
+         WHERE run_id=? AND status IN (${placeholders}) ORDER BY created_at DESC LIMIT 1`
+      ).get(run.id, ...statuses);
+      if (!r) return null;
+      return {
+        id: str(r["id"]),
+        runId: str(r["run_id"]),
+        content: str(r["content"]),
+        status: str(r["status"]),
+        createdAt: str(r["created_at"])
+      };
+    }
+  };
+};
+
+// src/platform/ledger/usage.ts
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { readdirSync, openSync, readSync, fstatSync, closeSync } from "node:fs";
+import { join } from "node:path";
+
+// src/platform/ledger/pricing.ts
+var PRICING_SOURCE = "https://docs.bigmodel.cn/cn/guide/start/pricing";
+var PRICING_RETRIEVED_AT = "2026-10-06";
+var K32 = 32e3;
+var K200 = 200;
+var flat = (input, cache, output, note = "\u7EDF\u4E00\u4EF7") => ({ when: {}, input, cache, output, note });
+var BIGMODEL_PRICES = [
+  { id: "glm-5.3", label: "GLM-5.3", tiers: [flat(8, 2, 28)] },
+  { id: "glm-5.3-flash", label: "GLM-5.3-Flash", tiers: [flat(0.8, 0.23, 2.8)] },
+  { id: "glm-5.3-flashx", label: "GLM-5.3-FlashX", tiers: [flat(2, 0.57, 7)] },
+  { id: "glm-5.2", label: "GLM-5.2", tiers: [flat(8, 2, 28)] },
+  {
+    id: "glm-5.1",
+    label: "GLM-5.1",
+    tiers: [
+      { when: { inputLt: K32 }, input: 6, cache: 1.3, output: 24, note: "\u5165<32K" },
+      { when: { inputGte: K32 }, input: 8, cache: 2, output: 28, note: "\u5165\u226532K" }
+    ]
+  },
+  {
+    id: "glm-5-turbo",
+    label: "GLM-5-Turbo",
+    tiers: [
+      { when: { inputLt: K32 }, input: 5, cache: 1.2, output: 22, note: "\u5165<32K" },
+      { when: { inputGte: K32 }, input: 7, cache: 1.8, output: 26, note: "\u5165\u226532K" }
+    ]
+  },
+  {
+    id: "glm-5",
+    label: "GLM-5",
+    tiers: [
+      { when: { inputLt: K32 }, input: 4, cache: 1, output: 18, note: "\u5165<32K" },
+      { when: { inputGte: K32 }, input: 6, cache: 1.5, output: 22, note: "\u5165\u226532K" }
+    ]
+  },
+  {
+    id: "glm-4.7",
+    label: "GLM-4.7",
+    tiers: [
+      { when: { inputLt: K32, outputLt: K200 }, input: 2, cache: 0.4, output: 8, note: "\u5165<32K\xB7\u51FA<0.2K" },
+      { when: { inputLt: K32, outputGte: K200 }, input: 3, cache: 0.6, output: 14, note: "\u5165<32K\xB7\u51FA\u22650.2K" },
+      { when: { inputGte: K32 }, input: 4, cache: 0.8, output: 16, note: "\u516532K\u2013200K" }
+    ]
+  },
+  {
+    id: "glm-4.5-air",
+    label: "GLM-4.5-Air",
+    tiers: [
+      { when: { inputLt: K32, outputLt: K200 }, input: 0.8, cache: 0.16, output: 2, note: "\u5165<32K\xB7\u51FA<0.2K" },
+      { when: { inputLt: K32, outputGte: K200 }, input: 0.8, cache: 0.16, output: 6, note: "\u5165<32K\xB7\u51FA\u22650.2K" },
+      { when: { inputGte: K32 }, input: 1.2, cache: 0.24, output: 8, note: "\u516532K\u2013128K" }
+    ]
+  },
+  { id: "glm-4.7-flashx", label: "GLM-4.7-FlashX", tiers: [flat(0.5, 0.1, 3)] },
+  { id: "glm-4.7-flash", label: "GLM-4.7-Flash\uFF08\u514D\u8D39\uFF09", tiers: [flat(0, 0, 0, "\u514D\u8D39")] },
+  { id: "glm-4-plus", label: "GLM-4-Plus", tiers: [flat(5, 2.5, 5)] },
+  { id: "glm-4-air-250414", label: "GLM-4-Air-250414", tiers: [flat(0.5, 0.25, 0.5)] },
+  { id: "glm-4-air", label: "GLM-4-Air\uFF08\u540C 250414 \u7248\u4EF7\uFF09", tiers: [flat(0.5, 0.25, 0.5)] },
+  { id: "glm-4-airx", label: "GLM-4-AirX", tiers: [flat(10, null, 10)] },
+  { id: "glm-4-long", label: "GLM-4-Long", tiers: [flat(1, 0.5, 1)] },
+  { id: "glm-4-assistant", label: "GLM-4-Assistant", tiers: [flat(5, null, 5)] },
+  { id: "glm-z1-air", label: "GLM-Z1-Air", tiers: [flat(0.5, null, 0.5)] },
+  { id: "glm-z1-airx", label: "GLM-Z1-AirX", tiers: [flat(5, null, 5)] },
+  { id: "glm-z1-flashx", label: "GLM-Z1-FlashX", tiers: [flat(0.1, null, 0.1)] },
+  { id: "glm-4-flashx-250414", label: "GLM-4-FlashX-250414", tiers: [flat(0.1, 0.05, 0.1)] },
+  { id: "glm-4-flashx", label: "GLM-4-FlashX\uFF08\u540C 250414 \u7248\u4EF7\uFF09", tiers: [flat(0.1, 0.05, 0.1)] },
+  { id: "glm-4-flash-250414", label: "GLM-4-Flash-250414\uFF08\u514D\u8D39\uFF09", tiers: [flat(0, null, 0, "\u514D\u8D39\xB7\u7F13\u5B58\u4E0D\u652F\u6301")] },
+  { id: "glm-4-flash", label: "GLM-4-Flash\uFF08\u514D\u8D39\uFF09", tiers: [flat(0, null, 0, "\u514D\u8D39\xB7\u7F13\u5B58\u4E0D\u652F\u6301")] },
+  { id: "glm-z1-flash", label: "GLM-Z1-Flash\uFF08\u514D\u8D39\uFF09", tiers: [flat(0, null, 0, "\u514D\u8D39\xB7\u7F13\u5B58\u4E0D\u652F\u6301")] },
+  { id: "glm-ocr", label: "GLM-OCR", tiers: [flat(0.2, null, 0.2)] },
+  {
+    id: "glm-5v-turbo",
+    label: "GLM-5V-Turbo",
+    tiers: [
+      { when: { inputLt: K32 }, input: 5, cache: 1.2, output: 22, note: "\u5165<32K" },
+      { when: { inputGte: K32 }, input: 7, cache: 1.8, output: 26, note: "\u5165\u226532K" }
+    ]
+  },
+  {
+    id: "glm-4.6v",
+    label: "GLM-4.6V",
+    tiers: [
+      { when: { inputLt: K32 }, input: 1, cache: 0.2, output: 3, note: "\u5165<32K" },
+      { when: { inputGte: K32 }, input: 2, cache: 0.4, output: 6, note: "\u516532K\u2013128K\uFF08\u8D85\u4E0A\u754C\u5E76\u5165\u9AD8\u6863\uFF09" }
+    ]
+  },
+  {
+    id: "glm-4.6v-flashx",
+    label: "GLM-4.6V-FlashX",
+    tiers: [
+      { when: { inputLt: K32 }, input: 0.15, cache: 0.03, output: 1.5, note: "\u5165<32K" },
+      { when: { inputGte: K32 }, input: 0.3, cache: 0.03, output: 3, note: "\u516532K\u2013128K\uFF08\u8D85\u4E0A\u754C\u5E76\u5165\u9AD8\u6863\uFF09" }
+    ]
+  },
+  { id: "glm-4.6v-flash", label: "GLM-4.6V-Flash\uFF08\u514D\u8D39\uFF09", tiers: [flat(0, 0, 0, "\u514D\u8D39")] },
+  {
+    id: "glm-4.5v",
+    label: "GLM-4.5V",
+    tiers: [
+      { when: { inputLt: K32 }, input: 2, cache: 0.4, output: 6, note: "\u5165<32K" },
+      { when: { inputGte: K32 }, input: 4, cache: 0.8, output: 12, note: "\u516532K\u201364K\uFF08\u8D85\u4E0A\u754C\u5E76\u5165\u9AD8\u6863\uFF09" }
+    ]
+  },
+  { id: "glm-4v-plus-0111", label: "GLM-4V-Plus-0111", tiers: [flat(4, 2, 4)] },
+  { id: "glm-4v-plus", label: "GLM-4V-Plus\uFF08\u540C 0111 \u7248\u4EF7\uFF09", tiers: [flat(4, 2, 4)] },
+  { id: "glm-4v-flash", label: "GLM-4V-Flash\uFF08\u514D\u8D39\uFF09", tiers: [flat(0, null, 0, "\u514D\u8D39\xB7\u7F13\u5B58\u4E0D\u652F\u6301")] },
+  { id: "glm-4.1v-thinking-flashx", label: "GLM-4.1V-Thinking-FlashX", tiers: [flat(2, null, 2)] },
+  { id: "glm-4.1v-thinking-flash", label: "GLM-4.1V-Thinking-Flash\uFF08\u514D\u8D39\uFF09", tiers: [flat(0, null, 0, "\u514D\u8D39\xB7\u7F13\u5B58\u4E0D\u652F\u6301")] },
+  { id: "embedding-3", label: "Embedding-3", tiers: [flat(0.5, null, 0.5, "\u5355\u503C\u4EF7\u76EE\xB7input \u8BA1")] },
+  { id: "embedding-2", label: "Embedding-2", tiers: [flat(0.5, null, 0.5, "\u5355\u503C\u4EF7\u76EE\xB7input \u8BA1")] },
+  { id: "rerank", label: "Rerank", tiers: [flat(0.8, null, 0.8, "\u5355\u503C\u4EF7\u76EE")] },
+  { id: "codegeex-4", label: "CodeGeeX-4", tiers: [flat(0.1, null, 0.1, "\u5355\u503C\u4EF7\u76EE")] }
+];
+var findPrice = (model) => {
+  const m = model.trim().toLowerCase();
+  if (m === "") return null;
+  let hit = null;
+  for (const p of BIGMODEL_PRICES) {
+    if (m === p.id || m.startsWith(p.id + "-") && (hit === null || p.id.length > hit.id.length)) hit = p;
+  }
+  return hit;
+};
+var round4 = (x) => Math.round(x * 1e4) / 1e4;
+var tierOf = (price, r) => {
+  const input = r.inputTokens;
+  const output = r.outputTokens;
+  for (const t of price.tiers) {
+    const w = t.when;
+    if (w.inputLt !== void 0 && !(input < w.inputLt)) continue;
+    if (w.inputGte !== void 0 && !(input >= w.inputGte)) continue;
+    if (w.outputLt !== void 0 && !(output < w.outputLt)) continue;
+    if (w.outputGte !== void 0 && !(output >= w.outputGte)) continue;
+    return t;
+  }
+  return price.tiers[price.tiers.length - 1];
+};
+var priceUsage = (rows) => {
+  const accs = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (r.inputTokens === 0 && r.outputTokens === 0) continue;
+    const key = r.model === "" ? "\uFF08\u672A\u8BB0\u5F55\u6A21\u578B\uFF09" : r.model;
+    let a = accs.get(key);
+    if (a === void 0) {
+      const p = findPrice(key);
+      a = {
+        model: key,
+        label: p?.label ?? key,
+        free: false,
+        priced: p !== null,
+        calls: 0,
+        inputTokens: 0,
+        cachedTokens: 0,
+        outputTokens: 0,
+        tiersHit: /* @__PURE__ */ new Set(),
+        cost: { cache: 0, input: 0, output: 0 }
+      };
+      accs.set(key, a);
+    }
+    a.calls++;
+    a.inputTokens += r.inputTokens;
+    a.cachedTokens += r.cachedTokens;
+    a.outputTokens += r.outputTokens;
+    if (!a.priced) continue;
+    const t = tierOf(findPrice(key), r);
+    a.tiersHit.add(t.note);
+    if (t.input === 0 && t.output === 0) {
+      a.free = true;
+      continue;
+    }
+    const cached = Math.min(Math.max(r.cachedTokens, 0), r.inputTokens);
+    const cachePrice = t.cache ?? t.input;
+    a.cost.cache += cached / 1e6 * cachePrice;
+    a.cost.input += (r.inputTokens - cached) / 1e6 * t.input;
+    a.cost.output += r.outputTokens / 1e6 * t.output;
+  }
+  const byModel = [...accs.values()].map((a) => ({
+    model: a.model,
+    label: a.label,
+    free: a.free,
+    priced: a.priced,
+    calls: a.calls,
+    inputTokens: a.inputTokens,
+    cachedTokens: a.cachedTokens,
+    inputTokensChargeable: a.inputTokens - Math.min(a.cachedTokens, a.inputTokens),
+    outputTokens: a.outputTokens,
+    tiersHit: [...a.tiersHit],
+    costCny: {
+      cache: round4(a.cost.cache),
+      input: round4(a.cost.input),
+      output: round4(a.cost.output),
+      total: round4(a.cost.cache + a.cost.input + a.cost.output)
+    }
+  })).sort((x, y) => y.costCny.total - x.costCny.total);
+  const total = byModel.reduce(
+    (s, m) => ({ cache: s.cache + m.costCny.cache, input: s.input + m.costCny.input, output: s.output + m.costCny.output }),
+    { cache: 0, input: 0, output: 0 }
+  );
+  return {
+    currency: "CNY",
+    unit: "per_1m_tokens",
+    pricingSource: PRICING_SOURCE,
+    pricingRetrievedAt: PRICING_RETRIEVED_AT,
+    byModel,
+    totalCny: { cache: round4(total.cache), input: round4(total.input), output: round4(total.output), total: round4(total.cache + total.input + total.output) },
+    unpricedModels: byModel.filter((m) => !m.priced).map((m) => m.model)
+  };
+};
+
+// src/platform/ledger/usage.ts
+var MIGRATIONS2 = `
+CREATE TABLE IF NOT EXISTS prompt_usage (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  source TEXT NOT NULL DEFAULT '',
+  note TEXT NOT NULL DEFAULT '',
+  model TEXT NOT NULL DEFAULT '',
+  input_tokens INTEGER NOT NULL DEFAULT 0,
+  -- cached_tokens\uFF1Az.ai \u53E3\u5F84\u7F13\u5B58\u547D\u4E2D\uFF08input \u5B50\u96C6\uFF0Cwf_66a9b632154d\uFF09
+  --\uFF08\u5341\u4E09\u8DD1 R1 \u987A\u624B\u4FEE\uFF1A\u539F JS \u98CE\u683C // \u6CE8\u91CA\u5199\u5728 SQL \u4E32\u5185\uFF0CSQLite \u4E0D\u8BA4\uFF0C
+  -- db.exec(MIGRATIONS) \u76F4\u63A5\u629B near "/": syntax error\uFF0C\u5168\u4ED3 store \u7EA7\u6D4B\u8BD5\u5C3D\u7EA2\uFF09
+  cached_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  duration_ms INTEGER NOT NULL DEFAULT 0,
+  error TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_usage_time ON prompt_usage(created_at);
+CREATE TABLE IF NOT EXISTS claude_sessions (
+  claude_session_id TEXT PRIMARY KEY,
+  tmux_session TEXT NOT NULL DEFAULT '',
+  transcript_path TEXT NOT NULL DEFAULT '',
+  cwd TEXT NOT NULL DEFAULT ''
+);
+CREATE TABLE IF NOT EXISTS claude_ingest_offset (
+  claude_session_id TEXT PRIMARY KEY,
+  byte_offset INTEGER NOT NULL DEFAULT 0,
+  last_ingested_at TEXT NOT NULL DEFAULT ''
+);
+CREATE TABLE IF NOT EXISTS usage_meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL DEFAULT ''
+);
+`;
+var n = (v) => typeof v === "number" ? v : Number(v ?? 0);
+var windowUsageRows = (db, tmuxSession, windows) => {
+  if (windows.length === 0) return [];
+  const conds = windows.map(() => "(created_at >= ? AND created_at <= ?)").join(" OR ");
+  const params = [tmuxSession];
+  for (const [a, b] of windows) params.push(a, b);
+  return db.prepare(
+    `SELECT model, input_tokens AS i, output_tokens AS o, cached_tokens AS k
+     FROM prompt_usage WHERE source='claude_code' AND tmux_session=? AND (${conds})`
+  ).all(...params).map((r) => ({
+    model: String(r["model"]),
+    inputTokens: n(r["i"]),
+    outputTokens: n(r["o"]),
+    cachedTokens: n(r["k"])
+  }));
+};
+var REPLAY_COOLDOWN_MS = 24 * 36e5;
+var createUsageStore = (dbPath, now = () => /* @__PURE__ */ new Date()) => {
+  const db = new DatabaseSync2(dbPath);
+  db.exec(MIGRATIONS2);
+  try {
+    db.exec("ALTER TABLE prompt_usage ADD COLUMN cached_tokens INTEGER NOT NULL DEFAULT 0");
+  } catch {
+  }
+  try {
+    db.exec(`ALTER TABLE prompt_usage ADD COLUMN tmux_session TEXT NOT NULL DEFAULT ''`);
+  } catch {
+  }
+  try {
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_usage_session ON prompt_usage(tmux_session, id)`);
+  } catch {
+  }
+  return {
+    record(r) {
+      db.prepare(`INSERT INTO prompt_usage (source, note, model, input_tokens, output_tokens, cached_tokens, duration_ms, error, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
+        r.source,
+        r.note ?? "",
+        r.model ?? "",
+        r.inputTokens ?? 0,
+        r.outputTokens ?? 0,
+        r.cachedTokens ?? 0,
+        r.durationMs ?? 0,
+        r.error ?? "",
+        now().toISOString()
+      );
+    },
+    stats(sinceHours = 24) {
+      const since = new Date(now().getTime() - sinceHours * 36e5).toISOString();
+      const total = db.prepare(
+        `SELECT COUNT(*) AS c, COALESCE(SUM(input_tokens),0) AS i, COALESCE(SUM(output_tokens),0) AS o
+         FROM prompt_usage WHERE created_at >= ?`
+      ).get(since);
+      const byModel = db.prepare(
+        `SELECT model, COUNT(*) AS c, COALESCE(SUM(input_tokens),0) AS i, COALESCE(SUM(output_tokens),0) AS o
+         FROM prompt_usage WHERE created_at >= ? AND model != '' GROUP BY model ORDER BY i DESC`
+      ).all(since).map((r) => ({
+        model: String(r["model"]),
+        calls: n(r["c"]),
+        inputTokens: n(r["i"]),
+        outputTokens: n(r["o"])
+      }));
+      return {
+        totalCalls: n(total?.["c"]),
+        totalInputTokens: n(total?.["i"]),
+        totalOutputTokens: n(total?.["o"]),
+        byModel
+      };
+    },
+    timeline(hours = 24) {
+      const since = new Date(now().getTime() - hours * 36e5).toISOString();
+      return db.prepare(
+        `SELECT substr(created_at,1,13) AS hour, COUNT(*) AS c, COALESCE(SUM(input_tokens),0) AS i, COALESCE(SUM(output_tokens),0) AS o
+         FROM prompt_usage WHERE created_at >= ? GROUP BY hour ORDER BY hour`
+      ).all(since).map((r) => ({
+        hour: String(r["hour"]),
+        calls: n(r["c"]),
+        inputTokens: n(r["i"]),
+        outputTokens: n(r["o"])
+      }));
+    },
+    latestInputTokens(tmuxSession) {
+      const r = db.prepare(
+        `SELECT input_tokens AS i FROM prompt_usage
+         WHERE source='claude_code' AND tmux_session=? ORDER BY id DESC LIMIT 1`
+      ).get(tmuxSession);
+      return r === void 0 ? 0 : n(r["i"]);
+    },
+    lastClaudeCodeAt(tmuxSession) {
+      const r = db.prepare(
+        `SELECT created_at AS t FROM prompt_usage
+         WHERE source='claude_code' AND tmux_session=? ORDER BY id DESC LIMIT 1`
+      ).get(tmuxSession);
+      return r === void 0 ? "" : String(r["t"] ?? "");
+    },
+    perSessionWindows(tmuxSession, windows) {
+      if (windows.length === 0) return { count: 0, inputTokens: 0, outputTokens: 0 };
+      const conds = windows.map(() => "(created_at >= ? AND created_at <= ?)").join(" OR ");
+      const params = [tmuxSession];
+      for (const [a, b] of windows) params.push(a, b);
+      const r = db.prepare(
+        `SELECT COUNT(*) AS c, COALESCE(SUM(input_tokens),0) AS i, COALESCE(SUM(output_tokens),0) AS o
+         FROM prompt_usage WHERE source='claude_code' AND tmux_session=? AND (${conds})`
+      ).get(...params);
+      return { count: n(r["c"]), inputTokens: n(r["i"]), outputTokens: n(r["o"]) };
+    },
+    perSessionWindowsRows(tmuxSession, windows) {
+      return windowUsageRows(db, tmuxSession, windows);
+    },
+    sessionWindowsPriced(sessions, windows) {
+      if (sessions.length === 0 || windows.length === 0) return priceUsage([]);
+      return priceUsage(sessions.flatMap((s) => windowUsageRows(db, s, windows)));
+    },
+    byLocalDay(days = 7) {
+      const since = new Date(now().getTime() - days * 864e5).toISOString();
+      return db.prepare(
+        `SELECT strftime('%Y-%m-%d', created_at, 'localtime') AS day,
+                COUNT(*) AS c, COALESCE(SUM(input_tokens),0) AS i, COALESCE(SUM(output_tokens),0) AS o,
+                COALESCE(SUM(cached_tokens),0) AS k
+         FROM prompt_usage
+         WHERE created_at >= ?
+         GROUP BY day ORDER BY day`
+      ).all(since).map((r) => ({
+        day: String(r["day"]),
+        inputTokens: n(r["i"]),
+        outputTokens: n(r["o"]),
+        cachedTokens: n(r["k"]),
+        calls: n(r["c"])
+      }));
+    },
+    needsClaudeReplay() {
+      const mark = db.prepare(`SELECT value FROM usage_meta WHERE key='last_claude_replay_at'`).get();
+      const lastAt = mark === void 0 ? "" : String(mark["value"] ?? "");
+      const lastMs = lastAt === "" ? NaN : Date.parse(lastAt);
+      if (Number.isFinite(lastMs) && now().getTime() - lastMs < REPLAY_COOLDOWN_MS) return false;
+      const r = db.prepare(
+        `SELECT COUNT(*) AS total, SUM(CASE WHEN tmux_session != '' THEN 1 ELSE 0 END) AS filled FROM prompt_usage WHERE source='claude_code'`
+      ).get();
+      const total = n(r["total"]);
+      const filled = n(r["filled"]);
+      const mapped = n(db.prepare("SELECT COUNT(*) AS c FROM claude_sessions").get()["c"]);
+      return mapped > 0 && total > 0 && filled * 2 < total;
+    },
+    resetClaudeIngest() {
+      db.exec("DELETE FROM prompt_usage WHERE source='claude_code'");
+      db.exec("DELETE FROM claude_ingest_offset");
+      db.prepare(`INSERT INTO usage_meta (key, value) VALUES ('last_claude_replay_at', ?)
+        ON CONFLICT(key) DO UPDATE SET value=excluded.value`).run(now().toISOString());
+    },
+    recent(limit = 100) {
+      return db.prepare("SELECT * FROM prompt_usage ORDER BY id DESC LIMIT ?").all(limit).map((r) => ({
+        id: n(r["id"]),
+        source: String(r["source"]),
+        note: String(r["note"]),
+        model: String(r["model"]),
+        inputTokens: n(r["input_tokens"]),
+        outputTokens: n(r["output_tokens"]),
+        cachedTokens: n(r["cached_tokens"]),
+        durationMs: n(r["duration_ms"]),
+        error: String(r["error"]),
+        createdAt: String(r["created_at"])
+      }));
+    },
+    recordClaudeSession(claudeSessionId, tmuxSession, transcriptPath, cwd) {
+      if (claudeSessionId === "" || transcriptPath === "") return;
+      db.prepare(`INSERT INTO claude_sessions (claude_session_id, tmux_session, transcript_path, cwd)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(claude_session_id) DO UPDATE SET
+          tmux_session=excluded.tmux_session,
+          transcript_path=excluded.transcript_path,
+          cwd=excluded.cwd
+        WHERE tmux_session = '' `).run(claudeSessionId, tmuxSession, transcriptPath, cwd);
+    },
+    recordClaudeSessionPrecise(claudeSessionId, tmuxSession) {
+      if (claudeSessionId === "" || tmuxSession === "") return;
+      db.prepare(`UPDATE claude_sessions SET tmux_session=? WHERE claude_session_id=?`).run(tmuxSession, claudeSessionId);
+      db.prepare(`INSERT INTO claude_sessions (claude_session_id, tmux_session, transcript_path, cwd)
+        VALUES (?, ?, '', '') ON CONFLICT(claude_session_id) DO NOTHING`).run(claudeSessionId, tmuxSession);
+    },
+    ingestProjectTranscripts(claudeProjectsDir) {
+      const mapped = new Set(
+        db.prepare("SELECT claude_session_id FROM claude_sessions").all().map((r) => String(r["claude_session_id"]))
+      );
+      let count = 0;
+      try {
+        const projects = readdirSync(claudeProjectsDir);
+        for (const proj of projects) {
+          const dir = join(claudeProjectsDir, proj);
+          let files = [];
+          try {
+            files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+          } catch {
+            continue;
+          }
+          for (const f of files) {
+            const stem = f.replace(/\.jsonl$/, "");
+            count += ingestFile(db, stem, join(dir, f));
+          }
+        }
+      } catch {
+        return count;
+      }
+      return count;
+    }
+  };
+};
+var tmuxOf = (db, claudeId) => {
+  const r = db.prepare("SELECT tmux_session FROM claude_sessions WHERE claude_session_id=?").get(claudeId);
+  return r?.["tmux_session"] ?? "";
+};
+var ingestFile = (db, claudeId, transcriptPath) => {
+  let fd;
+  try {
+    fd = openSync(transcriptPath, "r");
+  } catch {
+    return 0;
+  }
+  try {
+    let offset = 0;
+    const prev = db.prepare("SELECT byte_offset FROM claude_ingest_offset WHERE claude_session_id=?").get(claudeId);
+    offset = Number(prev?.["byte_offset"] ?? 0);
+    const size = fstatSync(fd).size;
+    if (offset > size) {
+      offset = 0;
+    }
+    const length = Math.max(0, size - offset);
+    if (length === 0) return 0;
+    const buf = Buffer.alloc(length);
+    readSync(fd, buf, 0, length, offset);
+    const text = buf.toString("utf8");
+    const lastNL = text.lastIndexOf("\n");
+    if (lastNL < 0) return 0;
+    const complete = text.slice(0, lastNL + 1);
+    let count = 0;
+    for (const line of complete.split("\n")) {
+      if (line === "") continue;
+      const rec = parseAssistantLine(line);
+      if (!rec) continue;
+      const sess = tmuxOf(db, claudeId);
+      db.prepare(`INSERT INTO prompt_usage (source, note, model, input_tokens, output_tokens, cached_tokens, duration_ms, error, created_at, tmux_session)
+        VALUES ('claude_code', ?, ?, ?, ?, ?, 0, '', ?, ?)`).run(
+        `turn=${String(rec.callContext).slice(0, 40)}`,
+        rec.model,
+        rec.inputTokens,
+        rec.outputTokens,
+        rec.cacheRead,
+        rec.timestamp,
+        sess
+      );
+      count++;
+    }
+    const newOffset = offset + Buffer.byteLength(complete, "utf8");
+    db.prepare(`INSERT INTO claude_ingest_offset (claude_session_id, byte_offset, last_ingested_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(claude_session_id) DO UPDATE SET byte_offset=excluded.byte_offset, last_ingested_at=excluded.last_ingested_at`).run(claudeId, newOffset, (/* @__PURE__ */ new Date()).toISOString());
+    return count;
+  } finally {
+    closeSync(fd);
+  }
+};
+var parseAssistantLine = (line) => {
+  try {
+    const v = JSON.parse(line);
+    if (v.type !== "assistant") return null;
+    const u = v.message?.usage;
+    if (!u || !u.input_tokens && !u.output_tokens) return null;
+    const cacheRead = u.cache_read_input_tokens ?? 0;
+    const cacheCreate = u.cache_creation_input_tokens ?? 0;
+    const input = (u.input_tokens ?? 0) + cacheRead + cacheCreate;
+    const output = u.output_tokens ?? 0;
+    return {
+      model: v.message?.model ?? "",
+      inputTokens: input,
+      outputTokens: output,
+      cacheRead,
+      timestamp: typeof v.timestamp === "string" ? v.timestamp : (/* @__PURE__ */ new Date()).toISOString(),
+      callContext: v.uuid ?? ""
+    };
+  } catch {
+    return null;
+  }
+};
+export {
+  asRecord,
+  createLedgerStore,
+  createUsageStore,
+  emptyCaseFile,
+  parseCaseFile,
+  priceUsage,
+  randomIds,
+  rfc3339,
+  safeParse,
+  serializeCaseFile,
+  systemClock
+};