codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/replay-frames.js

@@ -0,0 +1,387 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var replay_frames_exports = {};
+__export(replay_frames_exports, {
+  DEFAULT_FRAME_LIMIT: () => DEFAULT_FRAME_LIMIT,
+  MAX_FRAME_LIMIT: () => MAX_FRAME_LIMIT,
+  frameIntervalMs: () => frameIntervalMs,
+  frameRefusal: () => frameRefusal,
+  framesByCommit: () => framesByCommit,
+  graphDigest: () => graphDigest,
+  holdsProject: () => holdsProject,
+  listFrames: () => listFrames,
+  mergeTriggers: () => mergeTriggers,
+  noteAgentActivity: () => noteAgentActivity,
+  noteRefsChanged: () => noteRefsChanged,
+  parseWorktreeList: () => parseWorktreeList,
+  pruneFrames: () => pruneFrames,
+  requestFrame: () => requestFrame,
+  seedHeads: () => seedHeads,
+  setFramePublisher: () => setFramePublisher,
+  setHeldProject: () => setHeldProject,
+  startReplayFrames: () => startReplayFrames,
+  takeFrame: () => takeFrame,
+  turnGapMs: () => turnGapMs
+});
+module.exports = __toCommonJS(replay_frames_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"));
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_git_checkout = require("./git-checkout");
+var import_trellis_service = require("./trellis-service");
+var import_workstream_watch_service = require("./workstream-watch-service");
+var import_retention = require("./retention");
+var import_turn_gap = require("../../shared/lib/turn-gap");
+const frameIntervalMs = () => Number(process.env.CODETRELLIS_FRAME_INTERVAL_MS) || 1e4;
+const turnGapMs = () => Number(process.env.CODETRELLIS_TURN_GAP_MS) || import_turn_gap.TURN_GAP_MS;
+const DEFAULT_FRAME_LIMIT = 500;
+const MAX_FRAME_LIMIT = 2e3;
+const trimRoot = (p) => p.replace(/[\\/]+$/, "");
+let held = () => ({ path: null, scanning: null });
+function setHeldProject(fn) {
+  held = fn;
+}
+let publisher = null;
+function setFramePublisher(fn) {
+  publisher = fn;
+}
+function graphDigest(graph) {
+  const files = graph.files.map((f) => `${f.path}\0${f.contentHash}`).sort();
+  const edges = graph.edges.map((e) => `${e.source}\0${e.target}\0${[...e.specifiers].sort().join(",")}`).sort();
+  return (0, import_node_crypto.createHash)("sha256").update(files.join("\n")).update("
").update(edges.join("\n")).digest("hex");
+}
+function mergeTriggers(triggers) {
+  const reasons = [];
+  const merged = { projectPath: triggers[0].projectPath, reason: triggers[0].reason, reasons };
+  for (const t of triggers) {
+    if (!reasons.includes(t.reason)) reasons.push(t.reason);
+    if (t.ref) merged.ref = t.ref;
+    if (t.sessionId) {
+      merged.sessionId = t.sessionId;
+      merged.agentType = t.agentType ?? null;
+    }
+    if (t.workstreamRoot) merged.workstreamRoot = t.workstreamRoot;
+    if (t.commitSha) merged.commitSha = t.commitSha;
+  }
+  return merged;
+}
+function frameRefusal(projectPath, now) {
+  if (now.scanning) return "scanning";
+  if (!now.path || trimRoot(now.path) !== trimRoot(projectPath)) return "other-project";
+  return null;
+}
+function holdsProject(projectPath) {
+  return frameRefusal(projectPath, held()) === null;
+}
+function git(root, args) {
+  try {
+    return (0, import_node_child_process.execFileSync)("git", ["-C", root, ...args], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5e3,
+      maxBuffer: 4 * 1024 * 1024
+    });
+  } catch {
+    return null;
+  }
+}
+function headSha(root) {
+  const out = git(root, ["rev-parse", "HEAD"])?.trim() ?? "";
+  return /^[0-9a-f]{40,64}$/.test(out) ? out : null;
+}
+const canonical = (p) => {
+  try {
+    return import_node_fs.default.realpathSync(p);
+  } catch {
+    return trimRoot(p);
+  }
+};
+function parseWorktreeList(porcelain) {
+  const heads2 = /* @__PURE__ */ new Map();
+  for (const block of porcelain.split(/\n\s*\n/)) {
+    const root = /^worktree (.+)$/m.exec(block)?.[1];
+    const head = /^HEAD ([0-9a-f]{40,64})$/m.exec(block)?.[1];
+    if (root && head && !/^bare$/m.test(block)) heads2.set(root, head);
+  }
+  return heads2;
+}
+function checkoutHeads(project) {
+  const out = git(project, ["worktree", "list", "--porcelain"]);
+  return out ? parseWorktreeList(out) : /* @__PURE__ */ new Map();
+}
+function takeFrame(m) {
+  const refusal = frameRefusal(m.projectPath, held());
+  if (refusal) return refusal;
+  const db = (0, import_database.getDb)();
+  const project = trimRoot(m.projectPath);
+  const reasons = m.reasons ?? [m.reason];
+  const graph = (0, import_trellis_service.readLiveGraph)();
+  const digest = graphDigest(graph);
+  const last = db.exec(
+    `SELECT id, digest, same_as FROM trellis_snapshots
+     WHERE snapshot_type = 'frame' AND project_path = ? ORDER BY created_at DESC, id DESC LIMIT 1`,
+    [project]
+  )[0]?.values[0];
+  const sameAs = last && last[1] === digest ? last[2] ?? last[0] : null;
+  const commitSha = m.commitSha ?? headSha(m.projectPath);
+  const branch = (0, import_git_checkout.currentBranch)(m.projectPath);
+  const at = Date.now();
+  db.run(
+    `INSERT INTO trellis_snapshots
+       (name, snapshot_type, plan_uid, git_branch, files_json, edges_json, created_at,
+        project_path, reason, ref, session_id, agent_type, workstream_root, commit_sha, digest, same_as)
+     VALUES (?, 'frame', NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      `Frame: ${reasons.join(", ")}`,
+      branch,
+      sameAs ? "[]" : JSON.stringify(graph.files),
+      sameAs ? "[]" : JSON.stringify(graph.edges),
+      at,
+      project,
+      reasons.join(","),
+      m.ref ?? null,
+      m.sessionId ?? null,
+      m.agentType ?? null,
+      m.workstreamRoot ?? null,
+      commitSha,
+      digest,
+      sameAs
+    ]
+  );
+  const id = db.exec("SELECT last_insert_rowid()")[0]?.values[0]?.[0] || 0;
+  (0, import_persistence.markDirty)();
+  const frame = {
+    id,
+    at,
+    projectPath: project,
+    reasons,
+    ref: m.ref ?? null,
+    sessionId: m.sessionId ?? null,
+    agentType: m.agentType ?? null,
+    workstreamRoot: m.workstreamRoot ?? null,
+    commitSha,
+    branch,
+    digest,
+    sameAs,
+    fileCount: graph.files.length,
+    edgeCount: graph.edges.length
+  };
+  try {
+    publisher?.("replay-frame", frame);
+  } catch {
+  }
+  return frame;
+}
+const lastFrameAt = /* @__PURE__ */ new Map();
+const pending = /* @__PURE__ */ new Map();
+function requestFrame(trigger) {
+  if (!trigger.projectPath) return;
+  const key = trimRoot(trigger.projectPath);
+  const open = pending.get(key);
+  if (open) {
+    open.triggers.push(trigger);
+    return;
+  }
+  const wait = Math.max(0, (lastFrameAt.get(key) ?? 0) + frameIntervalMs() - Date.now());
+  const timer = setTimeout(() => flush(key), wait);
+  timer.unref?.();
+  pending.set(key, { triggers: [trigger], timer });
+}
+function flush(key) {
+  const open = pending.get(key);
+  pending.delete(key);
+  if (!open) return;
+  lastFrameAt.set(key, Date.now());
+  try {
+    const result = takeFrame(mergeTriggers(open.triggers));
+    if (result === "scanning") for (const t of open.triggers) requestFrame(t);
+  } catch (err) {
+    console.warn("[Replay] Frame not taken:", err instanceof Error ? err.message : err);
+  }
+}
+const turns = /* @__PURE__ */ new Map();
+function heldProjectOf(root) {
+  const project = held().path;
+  if (!project) return null;
+  if (!root || trimRoot(root) === trimRoot(project)) return project;
+  const target = canonical(root);
+  return [...checkoutHeads(project).keys()].some((r) => canonical(r) === target) ? project : null;
+}
+function noteAgentActivity(e) {
+  const key = e.sessionId ?? (e.workstreamRoot ? `workstream:${e.workstreamRoot}` : null);
+  if (!key) return;
+  const running = turns.get(key);
+  if (running) clearTimeout(running);
+  const timer = setTimeout(() => {
+    turns.delete(key);
+    const project = heldProjectOf(e.workstreamRoot);
+    if (project) {
+      requestFrame({
+        projectPath: project,
+        reason: "turn-end",
+        sessionId: e.sessionId,
+        agentType: e.agentType,
+        workstreamRoot: e.workstreamRoot
+      });
+    }
+  }, turnGapMs());
+  timer.unref?.();
+  turns.set(key, timer);
+}
+const heads = /* @__PURE__ */ new Map();
+function seedHeads(project) {
+  heads.clear();
+  if (!project) return;
+  for (const [root, head] of checkoutHeads(project)) heads.set(root, head);
+  (0, import_workstream_watch_service.watchRefs)(project).catch(() => {
+  });
+}
+function noteRefsChanged() {
+  const project = held().path;
+  if (!project) return;
+  const now = checkoutHeads(project);
+  for (const [root, head] of now) {
+    const before = heads.get(root);
+    if (before && before !== head) {
+      requestFrame({ projectPath: project, reason: "commit", ref: head, commitSha: head, workstreamRoot: root });
+    }
+  }
+  heads.clear();
+  for (const [root, head] of now) heads.set(root, head);
+}
+function framesByCommit(projectPath, shas) {
+  const out = /* @__PURE__ */ new Map();
+  const wanted = shas.filter((s) => /^[0-9a-f]{40,64}$/.test(s));
+  for (let i = 0; i < wanted.length; i += 200) {
+    const batch = wanted.slice(i, i + 200);
+    const rows = (0, import_database.getDb)().exec(
+      `SELECT commit_sha, agent_type, session_id, workstream_root FROM trellis_snapshots
+       WHERE snapshot_type = 'frame' AND project_path = ? AND commit_sha IN (${batch.map(() => "?").join(",")})
+       ORDER BY created_at ASC`,
+      [trimRoot(projectPath), ...batch]
+    )[0]?.values ?? [];
+    for (const r of rows) {
+      const prior = out.get(r[0]);
+      if (prior?.agentType && !r[1]) continue;
+      out.set(r[0], { agentType: r[1] ?? null, sessionId: r[2] ?? null, workstreamRoot: r[3] ?? null });
+    }
+  }
+  return out;
+}
+function listFrames(projectPath, q = {}) {
+  const where = [`t.snapshot_type = 'frame'`, "t.project_path = ?"];
+  const params = [trimRoot(projectPath)];
+  if (Number.isFinite(q.from)) {
+    where.push("t.created_at >= ?");
+    params.push(q.from);
+  }
+  if (Number.isFinite(q.to)) {
+    where.push("t.created_at <= ?");
+    params.push(q.to);
+  }
+  const limit = Math.min(Math.max(1, Math.floor(q.limit ?? DEFAULT_FRAME_LIMIT)), MAX_FRAME_LIMIT);
+  params.push(limit);
+  const rows = (0, import_database.getDb)().exec(
+    `SELECT t.id, t.created_at, t.project_path, t.reason, t.ref, t.session_id, t.agent_type, t.workstream_root,
+            t.commit_sha, t.git_branch, t.digest, t.same_as,
+            json_array_length(COALESCE(o.files_json, t.files_json)), json_array_length(COALESCE(o.edges_json, t.edges_json))
+     FROM trellis_snapshots t LEFT JOIN trellis_snapshots o ON o.id = t.same_as
+     WHERE ${where.join(" AND ")} ORDER BY t.created_at ${q.newestFirst ? "DESC" : "ASC"}, t.id ${q.newestFirst ? "DESC" : "ASC"} LIMIT ?`,
+    params
+  )[0]?.values ?? [];
+  return rows.map((r) => ({
+    id: r[0],
+    at: r[1],
+    projectPath: r[2],
+    reasons: String(r[3] ?? "").split(",").filter(Boolean),
+    ref: r[4] ?? null,
+    sessionId: r[5] ?? null,
+    agentType: r[6] ?? null,
+    workstreamRoot: r[7] ?? null,
+    commitSha: r[8] ?? null,
+    branch: r[9] ?? null,
+    digest: String(r[10] ?? ""),
+    sameAs: r[11] ?? null,
+    fileCount: Number(r[12]) || 0,
+    edgeCount: Number(r[13]) || 0
+  }));
+}
+function pruneFrames(now = Date.now()) {
+  const cutoff = (0, import_retention.retentionCutoff)(now);
+  if (cutoff === null) return 0;
+  const db = (0, import_database.getDb)();
+  const before = Number(db.exec(`SELECT COUNT(*) FROM trellis_snapshots WHERE snapshot_type = 'frame'`)[0]?.values[0]?.[0]) || 0;
+  db.run(
+    `DELETE FROM trellis_snapshots WHERE snapshot_type = 'frame' AND created_at < ?
+       AND id NOT IN (SELECT same_as FROM trellis_snapshots WHERE same_as IS NOT NULL AND created_at >= ?)`,
+    [cutoff, cutoff]
+  );
+  const after = Number(db.exec(`SELECT COUNT(*) FROM trellis_snapshots WHERE snapshot_type = 'frame'`)[0]?.values[0]?.[0]) || 0;
+  db.run("DELETE FROM awareness_signal_spans WHERE closed_at IS NOT NULL AND closed_at < ?", [cutoff]);
+  if (after !== before) (0, import_persistence.markDirty)();
+  return before - after;
+}
+let pruneTimer = null;
+function startReplayFrames() {
+  (0, import_database.getDb)().run("CREATE INDEX IF NOT EXISTS idx_trellis_frames ON trellis_snapshots(project_path, created_at)");
+  pruneFrames();
+  if (!pruneTimer) {
+    pruneTimer = setInterval(() => {
+      try {
+        pruneFrames();
+      } catch {
+      }
+    }, 60 * 60 * 1e3);
+    pruneTimer.unref?.();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_FRAME_LIMIT,
+  MAX_FRAME_LIMIT,
+  frameIntervalMs,
+  frameRefusal,
+  framesByCommit,
+  graphDigest,
+  holdsProject,
+  listFrames,
+  mergeTriggers,
+  noteAgentActivity,
+  noteRefsChanged,
+  parseWorktreeList,
+  pruneFrames,
+  requestFrame,
+  seedHeads,
+  setFramePublisher,
+  setHeldProject,
+  startReplayFrames,
+  takeFrame,
+  turnGapMs
+});

package/src/backend/services/replay-state.js

@@ -0,0 +1,201 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var replay_state_exports = {};
+__export(replay_state_exports, {
+  itemsAt: () => itemsAt,
+  stateAt: () => stateAt
+});
+module.exports = __toCommonJS(replay_state_exports);
+var import_database = require("./database");
+var import_trellis_service = require("./trellis-service");
+var import_replay_frames = require("./replay-frames");
+var import_breakpoint_service = require("./breakpoint-service");
+var import_plan_item_service = require("./plan-item-service");
+var import_stack_service = require("./stack-service");
+const trimRoot = (p) => p.replace(/[\\/]+$/, "");
+const rows = (sql, params = []) => (0, import_database.getDb)().exec(sql, params)[0]?.values ?? [];
+const parse = (s, fallback) => {
+  try {
+    return JSON.parse(String(s));
+  } catch {
+    return fallback;
+  }
+};
+function frameAt(projectPath, at) {
+  return (0, import_replay_frames.listFrames)(projectPath, { to: at, limit: 1, newestFirst: true })[0] ?? null;
+}
+const KEPT = [
+  ["title", ""],
+  ["assignee", null],
+  ["assigneeType", null],
+  ["dependencies", []],
+  ["workstream", null],
+  ["fileSpecs", []],
+  ["symbolSpecs", []],
+  ["parentUid", null]
+];
+function itemsAt(projectPath, at) {
+  const plans = rows(
+    // The plan list's order, so rows keep their places as the cursor moves.
+    "SELECT uid, title, status FROM plans WHERE (project_path = ? OR project_path = ?) AND created_at <= ? ORDER BY updated_at DESC",
+    [projectPath, trimRoot(projectPath), at]
+  );
+  if (plans.length === 0) return [];
+  const uids = plans.map((r) => r[0]);
+  const marks = uids.map(() => "?").join(",");
+  const changes = /* @__PURE__ */ new Map();
+  for (const r of rows(
+    `SELECT item_uid, created_at, before_state, after_state FROM plan_events
+     WHERE plan_uid IN (${marks}) AND event_type = 'status_changed' ORDER BY created_at, id`,
+    uids
+  )) {
+    const list = changes.get(r[0]) ?? [];
+    list.push({
+      when: r[1],
+      before: parse(r[2], {}).status ?? null,
+      after: parse(r[3], {}).status ?? null
+    });
+    changes.set(r[0], list);
+  }
+  const statusThen = (uid, now) => {
+    const list = changes.get(uid) ?? [];
+    const lastBy = [...list].reverse().find((c) => c.when <= at);
+    const firstAfter = list.find((c) => c.when > at);
+    return lastBy ? lastBy.after : firstAfter ? firstAfter.before : now;
+  };
+  const snapshot = /* @__PURE__ */ new Map();
+  for (const r of rows(
+    `SELECT v.item_uid, v.meta_snapshot FROM plan_item_versions v JOIN plan_items i ON i.uid = v.item_uid
+     WHERE i.plan_uid IN (${marks}) AND v.created_at <= ? ORDER BY v.item_uid, v.version`,
+    [...uids, at]
+  )) snapshot.set(r[0], parse(r[1], {}));
+  const out = [];
+  for (const r of plans) {
+    const planUid = r[0];
+    const items = (0, import_plan_item_service.listAllItems)(planUid).filter((i) => i.createdAt <= at).map((now) => {
+      const then = { ...now };
+      const snap = snapshot.get(now.uid);
+      if (snap) {
+        for (const [key, missing] of KEPT) then[key] = snap[key] ?? missing;
+      }
+      if (then.assignee !== now.assignee) then.assigneeSession = null;
+      if (now.kind === "action") then.status = statusThen(now.uid, now.status ?? null);
+      return then;
+    });
+    const status = r[2];
+    const finishedNow = status === "completed" || status === "archived";
+    const openThen = items.some((i) => i.kind === "action" && i.status !== "done" && i.status !== "skipped");
+    out.push({ plan: { uid: planUid, title: r[1], status: finishedNow && openThen ? "in_progress" : status }, items });
+  }
+  return out;
+}
+function tasksAt(then, stack) {
+  const rowOf = new Map(stack.plans.flatMap((p) => p.tasks.map((t) => [t.uid, t])));
+  const nowStatus = /* @__PURE__ */ new Map();
+  for (const p of then) for (const i of (0, import_plan_item_service.listAllItems)(p.plan.uid)) nowStatus.set(i.uid, i.status ?? null);
+  return then.flatMap((p) => p.items.filter((i) => i.kind === "action").map((i) => {
+    const row = rowOf.get(i.uid);
+    const status = i.status ?? null;
+    const now = nowStatus.get(i.uid) ?? null;
+    const task = {
+      uid: i.uid,
+      planUid: p.plan.uid,
+      planTitle: p.plan.title,
+      title: i.title,
+      status,
+      assignee: i.assignee ?? null,
+      workstream: row?.workstream ?? null,
+      dependencies: i.dependencies ?? []
+    };
+    if (status !== now) task.statusNow = now;
+    return task;
+  }));
+}
+function waitingAt(projectPath, at) {
+  return rows(
+    `SELECT h.ref FROM breakpoint_hits h JOIN breakpoints b ON b.id = h.breakpoint_id
+     LEFT JOIN plans p ON p.uid = COALESCE(h.plan_uid, b.plan_uid)
+     WHERE (b.project_root IN (?, ?) OR p.project_path IN (?, ?))
+       AND h.hit_at <= ? AND (h.answered_at IS NULL OR h.answered_at > ?)
+     ORDER BY h.hit_at`,
+    [projectPath, trimRoot(projectPath), projectPath, trimRoot(projectPath), at, at]
+  ).map((r) => (0, import_breakpoint_service.getHit)(r[0])).filter((h) => h !== null);
+}
+function signalsAt(projectPath, at) {
+  const roots = [projectPath, trimRoot(projectPath)];
+  const spans = rows(
+    `SELECT p.signal_id, p.kind, p.severity, p.summary, p.workstreams, p.opened_at, p.closed_at, s.subject
+     FROM awareness_signal_spans p LEFT JOIN awareness_signals s ON s.id = p.signal_id
+     WHERE p.project_root IN (?, ?) AND p.opened_at <= ? AND (p.closed_at IS NULL OR p.closed_at > ?)`,
+    [...roots, at, at]
+  ).map((r) => ({
+    id: r[0],
+    kind: r[1],
+    subject: parse(r[7], {}),
+    severity: r[2],
+    summary: r[3],
+    workstreams: parse(r[4], []),
+    openedAt: r[5],
+    closedAt: r[6] ?? null
+  }));
+  const older = rows(
+    `SELECT s.id, s.kind, s.severity, s.summary, s.workstreams, s.first_seen, s.resolved_at, s.subject FROM awareness_signals s
+     WHERE s.project_root IN (?, ?) AND s.first_seen <= ? AND (s.resolved_at IS NULL OR s.resolved_at > ?)
+       AND NOT EXISTS (SELECT 1 FROM awareness_signal_spans p WHERE p.signal_id = s.id)`,
+    [...roots, at, at]
+  ).map((r) => ({
+    id: r[0],
+    kind: r[1],
+    subject: parse(r[7], {}),
+    severity: r[2],
+    summary: r[3],
+    workstreams: parse(r[4], []),
+    openedAt: r[5],
+    closedAt: r[6] ?? null
+  }));
+  return [...spans, ...older].sort((a, b) => a.openedAt - b.openedAt);
+}
+function stateAt(projectPath, at, holdsProject) {
+  const frame = frameAt(projectPath, at);
+  const waiting = waitingAt(projectPath, at);
+  const signals = signalsAt(projectPath, at);
+  const then = itemsAt(projectPath, at);
+  const stack = (0, import_stack_service.stackThen)(
+    projectPath,
+    then.filter((p) => p.plan.status !== "completed" && p.plan.status !== "archived"),
+    // Open then, whatever became of them since.
+    signals.map((sig) => ({ ...sig, kind: sig.kind, severity: sig.severity, state: "open" })),
+    waiting,
+    at
+  );
+  return {
+    at,
+    projectPath: trimRoot(projectPath),
+    frame,
+    sinceFrame: frame && holdsProject ? (0, import_trellis_service.computeTrellisDiff)(frame.id) : null,
+    tasks: tasksAt(then, stack),
+    waiting,
+    signals,
+    stack
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  itemsAt,
+  stateAt
+});

package/src/backend/services/resolvers/base.js

@@ -0,0 +1,108 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var base_exports = {};
+__export(base_exports, {
+  buildDirectoryIndex: () => buildDirectoryIndex,
+  findContainingSystem: () => findContainingSystem,
+  pickRepresentativeFile: () => pickRepresentativeFile,
+  tryExtensions: () => tryExtensions
+});
+module.exports = __toCommonJS(base_exports);
+var import_node_path = __toESM(require("node:path"));
+function findContainingSystem(filePath, systems) {
+  let best = null;
+  for (const sys of systems) {
+    if (filePath === sys.rootPath || filePath.startsWith(sys.rootPath + "/")) {
+      if (!best || sys.rootPath.length > best.rootPath.length) best = sys;
+    }
+  }
+  return best;
+}
+function tryExtensions(basePath, knownFiles, extensions = [
+  "",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  "/index.ts",
+  "/index.tsx",
+  "/index.js",
+  "/index.jsx"
+]) {
+  for (const ext of extensions) {
+    const candidate = basePath + ext;
+    if (knownFiles.has(candidate)) return candidate;
+  }
+  return null;
+}
+const dirIndexCache = /* @__PURE__ */ new WeakMap();
+function buildDirectoryIndex(knownFiles, extensions) {
+  const key = [...extensions].sort().join(",");
+  let perSet = dirIndexCache.get(knownFiles);
+  if (!perSet) {
+    perSet = /* @__PURE__ */ new Map();
+    dirIndexCache.set(knownFiles, perSet);
+  }
+  const cached = perSet.get(key);
+  if (cached) return cached;
+  const index = /* @__PURE__ */ new Map();
+  for (const file of knownFiles) {
+    if (!extensions.some((ext) => file.endsWith(ext))) continue;
+    const dir = import_node_path.default.dirname(file);
+    const bucket = index.get(dir);
+    if (bucket) bucket.push(file);
+    else index.set(dir, [file]);
+  }
+  for (const bucket of index.values()) bucket.sort();
+  perSet.set(key, index);
+  return index;
+}
+function pickRepresentativeFile(dir, knownFiles, options) {
+  const files = buildDirectoryIndex(knownFiles, options.extensions).get(dir);
+  if (!files || files.length === 0) return null;
+  if (options.prefer) {
+    for (const ext of options.extensions) {
+      const candidate = import_node_path.default.join(dir, options.prefer + ext);
+      if (files.includes(candidate)) return candidate;
+    }
+  }
+  if (options.deprioritize) {
+    const primary = files.find((f) => !options.deprioritize(f));
+    if (primary) return primary;
+  }
+  return files[0];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildDirectoryIndex,
+  findContainingSystem,
+  pickRepresentativeFile,
+  tryExtensions
+});