@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.3

package/src/routing.js

@@ -0,0 +1,49 @@
+import { getAdapter, AGENT_IDS } from "./adapters/index.js";
+const PREFERENCE = ["claude", "codex", "agy"];
+const NEARLY_FULL = 0.9;
+const LIMITED_FOR_MS = 60 * 6e4;
+const SIGNED_OUT_FOR_MS = 15 * 6e4;
+function exhausted(agent, quota, now = Date.now()) {
+  const q = quota[agent];
+  if (!q) return void 0;
+  if (q.status === "signed_out") return now - q.at < SIGNED_OUT_FOR_MS ? "isn't signed in" : void 0;
+  const windows = Object.entries(q.windows);
+  const live = windows.filter(([, w]) => !w.resetsAt || w.resetsAt > now);
+  if (q.status === "limited" || q.status === "rejected") {
+    const resets = windows.map(([, w]) => w.resetsAt).filter((t) => !!t);
+    if (resets.length ? Math.max(...resets) > now : now - q.at < LIMITED_FOR_MS) return "hit its usage limit";
+  }
+  for (const [name, w] of live) {
+    if ((w.utilization ?? 0) >= NEARLY_FULL) return `is at ${Math.round((w.utilization ?? 0) * 100)}% of its ${name.replace(/_/g, "-")} limit`;
+  }
+  return void 0;
+}
+function resolveAuto(roles, quota, installed, rank = { order: [], why: {} }) {
+  const notes = [];
+  const out = {};
+  const order = [.../* @__PURE__ */ new Set([...rank.order, ...PREFERENCE, ...AGENT_IDS])];
+  const candidates = order.filter((a) => installed.has(a));
+  const roomy = candidates.filter((a) => !exhausted(a, quota));
+  const skipped = candidates.filter((a) => exhausted(a, quota));
+  for (const [role, list] of Object.entries(roles)) {
+    const chosen = list.filter((a) => AGENT_IDS.includes(a));
+    for (const value of list) {
+      if (value !== "auto") continue;
+      const pick = roomy.find((a) => !chosen.includes(a)) ?? candidates.find((a) => !chosen.includes(a));
+      if (!pick) continue;
+      chosen.push(pick);
+      const reasons = [];
+      const pickedFull = exhausted(pick, quota);
+      if (pickedFull) reasons.push(`every agent is out of room; ${getAdapter(pick).displayName} ${pickedFull}`);
+      else if (skipped.length) reasons.push(`${getAdapter(skipped[0]).displayName} ${exhausted(skipped[0], quota)}`);
+      if (rank.why[pick] && rank.order[0] === pick) reasons.push(rank.why[pick]);
+      notes.push(`Auto picked ${getAdapter(pick).displayName} for ${role}${reasons.length ? ` (${reasons.join("; ")})` : ""}`);
+    }
+    out[role] = [...new Set(chosen)];
+  }
+  return { roles: out, notes };
+}
+export {
+  exhausted,
+  resolveAuto
+};

package/src/run-analysis.js

@@ -0,0 +1,111 @@
+const finite = (value) => typeof value === "number" && Number.isFinite(value);
+function interval(start, end) {
+  return finite(start) && finite(end) && end >= start ? [start, end] : void 0;
+}
+function stepInterval(step, now) {
+  return interval(step.startedAt, step.status === "running" ? now : step.endedAt);
+}
+function unionMs(intervals) {
+  const sorted = [...intervals].sort((a, b) => a[0] - b[0]);
+  let total = 0;
+  let start;
+  let end = 0;
+  for (const [a, b] of sorted) {
+    if (start === void 0) {
+      start = a;
+      end = b;
+    } else if (a > end) {
+      total += end - start;
+      start = a;
+      end = b;
+    } else end = Math.max(end, b);
+  }
+  return total + (start === void 0 ? 0 : end - start);
+}
+function analyzeWorkflow(team, input = {}) {
+  const now = input.now ?? Date.now();
+  const tasks = /* @__PURE__ */ new Map();
+  const warnings = [];
+  for (const task of team.tasks) {
+    if (tasks.has(task.id)) warnings.push(`Duplicate task ID: ${task.id}`);
+    else tasks.set(task.id, task);
+  }
+  const edges = [];
+  const indegree = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const task of tasks.values()) {
+    const dependencies = [...new Set(task.dependsOn)];
+    indegree.set(task.id, dependencies.filter((id) => tasks.has(id)).length);
+    for (const dependency of dependencies) {
+      if (!tasks.has(dependency)) {
+        warnings.push(`${task.id} depends on missing task ${dependency}`);
+        continue;
+      }
+      edges.push({ from: dependency, to: task.id, kind: task.dependencyTypes?.[dependency] ?? "completion" });
+      children.set(dependency, [...children.get(dependency) ?? [], task.id]);
+    }
+  }
+  const queue = [...tasks.keys()].filter((id) => indegree.get(id) === 0).sort();
+  const order = [];
+  const layer = /* @__PURE__ */ new Map();
+  while (queue.length) {
+    const id = queue.shift();
+    order.push(id);
+    layer.set(id, Math.max(0, ...tasks.get(id).dependsOn.filter((dep) => layer.has(dep)).map((dep) => layer.get(dep) + 1)));
+    for (const child of children.get(id) ?? []) {
+      indegree.set(child, indegree.get(child) - 1);
+      if (indegree.get(child) === 0) {
+        queue.push(child);
+        queue.sort();
+      }
+    }
+  }
+  if (order.length < tasks.size) warnings.push("Dependencies contain a cycle. Edit the plan before dispatch.");
+  const durations = /* @__PURE__ */ new Map();
+  for (const task of tasks.values()) {
+    const steps = input.steps?.filter((step) => step.taskId === task.id);
+    if (steps?.length) {
+      const intervals = steps.map((step) => stepInterval(step, now));
+      if (intervals.every((value) => value !== void 0)) durations.set(task.id, intervals.reduce((sum, value) => sum + value[1] - value[0], 0));
+    } else {
+      const observed = interval(task.startedAt, task.status === "running" ? now : task.finishedAt);
+      if (observed) durations.set(task.id, observed[1] - observed[0]);
+      if ((task.attempts ?? 0) > 1) warnings.push(`${task.id}: task timestamps describe the latest attempt; earlier attempts are not included.`);
+    }
+  }
+  const scores = /* @__PURE__ */ new Map();
+  const chains = /* @__PURE__ */ new Map();
+  for (const id of order) {
+    const predecessors = tasks.get(id).dependsOn.filter((dep) => scores.has(dep)).sort((a, b) => scores.get(b) - scores.get(a) || chains.get(b).length - chains.get(a).length || a.localeCompare(b));
+    const previous = predecessors[0];
+    scores.set(id, (previous ? scores.get(previous) : 0) + (durations.get(id) ?? 0));
+    chains.set(id, [...previous ? chains.get(previous) : [], id]);
+  }
+  const last = [...order].sort((a, b) => scores.get(b) - scores.get(a) || chains.get(b).length - chains.get(a).length || a.localeCompare(b))[0];
+  const criticalPath = last ? chains.get(last) : [];
+  const cycleLayer = Math.max(-1, ...layer.values()) + 1;
+  const nodes = [...tasks.values()].map((task) => ({ id: task.id, title: task.title, owner: task.owner, status: task.status ?? "pending", layer: layer.get(task.id) ?? cycleLayer, ...durations.has(task.id) ? { durationMs: durations.get(task.id) } : {}, critical: criticalPath.includes(task.id) }));
+  const layers = [];
+  for (const node of nodes) (layers[node.layer] ??= []).push(node.id);
+  return { nodes, edges, layers, criticalPath, measuredCriticalPathMs: last ? scores.get(last) : 0, timedTasks: durations.size, completeTiming: durations.size === tasks.size && order.length === tasks.size && [...tasks.values()].every((task) => ["completed", "submitted"].includes(task.status ?? "") && !task.evidenceStale), warnings };
+}
+function analyzeRunTiming(run, steps, now = Date.now()) {
+  const end = run.status === "running" ? now : run.endedAt ?? now;
+  const elapsedMs = Math.max(0, end - run.createdAt);
+  const unique = [...new Map(steps.map((step) => [step.id, step])).values()];
+  const records = unique.flatMap((step) => {
+    const observed = stepInterval(step, end);
+    return observed ? [{ step, observed }] : [];
+  });
+  const total = (predicate) => records.filter(({ step }) => predicate(step)).reduce((sum, { observed }) => sum + observed[1] - observed[0], 0);
+  const occupiedMs = unionMs(records.map(({ observed }) => [Math.max(run.createdAt, observed[0]), Math.min(end, observed[1])]).filter(([start, finish]) => finish >= start));
+  const waits = (run.team?.waits ?? []).flatMap((wait) => {
+    const observed = interval(wait.createdAt, wait.resolvedAt ?? end);
+    return observed ? [[Math.max(run.createdAt, observed[0]), Math.min(end, observed[1])]] : [];
+  }).filter(([start, finish]) => finish >= start);
+  return { elapsedMs, occupiedMs, unattributedMs: Math.max(0, elapsedMs - occupiedMs), workerMs: total((step) => step.kind === "agent" && !step.coordination && step.role !== "coordinator"), coordinationMs: total((step) => step.kind === "agent" && (step.coordination === true || step.role === "coordinator")), checksMs: total((step) => step.kind !== "agent"), waitingMs: unionMs(waits), timedSteps: records.length, untimedSteps: unique.length - records.length, overlaps: total(() => true) > occupiedMs };
+}
+export {
+  analyzeRunTiming,
+  analyzeWorkflow
+};

package/src/run-cold-store.js

@@ -0,0 +1,231 @@
+import { createHash, randomBytes } from "node:crypto";
+import { constants, closeSync, fstatSync, lstatSync, openSync, readFileSync } from "node:fs";
+import { lstat, mkdir, open, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { RUNS_DIR } from "./store.js";
+import { runSearchText } from "./run-history.js";
+const COLD_LIMITS = { indexBytes: 128 * 1024, detailBytes: 16 * 1024 * 1024, cacheBytes: 32 * 1024 * 1024, cacheEntries: 8 };
+const identity = (info) => ({ size: String(info.size), mtimeNs: String(info.mtimeNs), ctimeNs: String(info.ctimeNs), dev: String(info.dev), ino: String(info.ino) });
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+const sha = (text) => createHash("sha256").update(text).digest("hex");
+const validId = (id) => /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,199}$/.test(id);
+const shorten = (text, size) => text && text.length > size ? `${text.slice(0, size)}\u2026` : text;
+function coldEligible(run) {
+  return run.archived && run.status === "done" && !run.awaiting && !run.team?.awaitingRequestId && !run.pauseRequested && !run.notes.some((note) => note.status === "queued") && !run.followUps.some((turn) => turn.status === "pending") && Object.keys(run.watches).length === 0 && !run.steps.some((step) => step.status === "running" || step.remote?.ambiguous || step.remote && ["accepted", "running", "unknown"].includes(step.remote.state));
+}
+function coldSummary(run) {
+  const { steps: _steps, team: _team, teamRerun: _rerun, verification: _verification, mergeValidation: _mergeValidation, conventions: _conventions, lessons: _lessons, memoryManifest: _memoryManifest, findings: _findings, proofs: _proofs, humanReview: _humanReview, humanRework: _humanRework, patternSummary: _patternSummary, ...metadata } = run;
+  return structuredClone({
+    ...metadata,
+    humanRework: run.humanRework?.map((item) => ({ ...item, note: "" })),
+    cold: true,
+    detailAvailable: true,
+    task: shorten(run.task, 8192),
+    summary: shorten(run.summary, 8192),
+    error: shorten(run.error, 4096),
+    notes: [],
+    followUps: run.followUps.map((turn) => ({ ...turn, message: "", result: void 0, side: turn.side ? { ...turn.side, title: shorten(turn.side.title, 500) } : void 0 })),
+    verification: run.verification ? { version: run.verification.version, state: run.verification.state, profile: run.verification.profile, startedAt: run.verification.startedAt, endedAt: run.verification.endedAt, head: run.verification.head, branch: run.verification.branch, checks: [], skipped: [] } : void 0,
+    source: run.source ? { ...run.source, body: "", ci: run.source.ci ? { ...run.source.ci, logs: "" } : void 0 } : void 0,
+    externalSource: run.externalSource ? { ...run.externalSource, body: "" } : void 0,
+    artifacts: run.artifacts.map((artifact) => ({ ...artifact, stat: artifact.stat?.trim().split("\n").at(-1) })),
+    review: run.review ? { ...run.review, summary: "", markdown: "", findings: run.review.findings.map((finding) => ({ severity: finding.severity, raisedBy: finding.raisedBy, file: "", problem: "", fix: "" })) } : void 0,
+    integrity: run.integrity ? Object.fromEntries(Object.entries(run.integrity).map(([branch, issues]) => [branch, issues.map((issue) => ({ ...issue, detail: "" }))])) : void 0
+  });
+}
+class RunColdStore {
+  constructor(directory = RUNS_DIR) {
+    this.directory = directory;
+  }
+  indexes = /* @__PURE__ */ new Map();
+  cache = /* @__PURE__ */ new Map();
+  bytes = 0;
+  source(id) {
+    return join(this.directory, `${id}.jsonl`);
+  }
+  path(id, kind) {
+    if (!validId(id)) throw new Error("Invalid cold run ID");
+    return join(this.directory, `${id}.cold-${kind}.json`);
+  }
+  async regular(path) {
+    const info = await lstat(path, { bigint: true });
+    if (!info.isFile() || info.isSymbolicLink()) throw new Error("Cold run projections require regular files");
+    return identity(info);
+  }
+  regularSync(path) {
+    const info = lstatSync(path, { bigint: true });
+    if (!info.isFile() || info.isSymbolicLink()) throw new Error("Cold run projections require regular files");
+    return identity(info);
+  }
+  has(id) {
+    return this.indexes.has(id);
+  }
+  ids() {
+    return this.indexes.keys();
+  }
+  index(id) {
+    const item = this.indexes.get(id);
+    return item ? structuredClone(item.summary) : void 0;
+  }
+  search(id) {
+    return this.indexes.get(id)?.search;
+  }
+  summaries() {
+    return [...this.indexes.values()].map((item) => structuredClone(item.summary));
+  }
+  valid(id) {
+    const item = this.indexes.get(id);
+    if (!item) return false;
+    try {
+      return same(item.source, this.regularSync(this.source(id))) && same(item.detail, this.regularSync(this.path(id, "detail")));
+    } catch {
+      return false;
+    }
+  }
+  drop(id) {
+    this.indexes.delete(id);
+    const entry = this.cache.get(id);
+    if (entry) this.bytes -= entry.bytes;
+    this.cache.delete(id);
+  }
+  inspect() {
+    return { records: this.indexes.size, cached: this.cache.size, bytes: this.bytes, limits: { ...COLD_LIMITS } };
+  }
+  async load(id) {
+    if (!validId(id)) return void 0;
+    try {
+      const before = await this.regular(this.source(id)), file = this.path(id, "index"), info = await this.regular(file);
+      if (Number(info.size) > COLD_LIMITS.indexBytes) return void 0;
+      const handle = await open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+      let text;
+      try {
+        if ((await handle.stat()).size > COLD_LIMITS.indexBytes) return void 0;
+        text = await handle.readFile("utf8");
+      } finally {
+        await handle.close();
+      }
+      const envelope = JSON.parse(text), item = envelope.index;
+      if (envelope.checksum !== sha(JSON.stringify(item)) || item?.version !== 1 || !Number.isSafeInteger(item.seq) || item.seq < 0 || !item.summary?.cold || !item.summary.detailAvailable || item.summary.id !== id || !item.summary.archived || item.summary.status !== "done" || !/^[a-f0-9]{64}$/.test(item.digest) || !same(item.source, before) || !same(before, await this.regular(this.source(id))) || !same(item.detail, await this.regular(this.path(id, "detail"))) || Number(item.detail.size) > COLD_LIMITS.detailBytes) return void 0;
+      this.indexes.set(id, item);
+      if (typeof item.search !== "string") {
+        const full = await this.getAsync(id);
+        if (!full) {
+          this.drop(id);
+          return void 0;
+        }
+        item.search = runSearchText(full);
+        this.cache.delete(id);
+        this.bytes = [...this.cache.values()].reduce((n, entry) => n + entry.bytes, 0);
+      }
+      return { summary: structuredClone(item.summary), seq: item.seq, search: item.search };
+    } catch {
+      this.drop(id);
+      return void 0;
+    }
+  }
+  async save(run, seq) {
+    if (!coldEligible(run) || !validId(run.id)) return false;
+    const serialized = JSON.stringify(run);
+    if (Buffer.byteLength(serialized) > COLD_LIMITS.detailBytes) return false;
+    const summary = coldSummary(run);
+    if (Buffer.byteLength(JSON.stringify(summary)) > COLD_LIMITS.indexBytes - 2048) return false;
+    const source = await this.regular(this.source(run.id)), detailPath = this.path(run.id, "detail");
+    await mkdir(this.directory, { recursive: true });
+    const atomic = async (path, text2) => {
+      const temp = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+      try {
+        const file = await open(temp, "wx", 384);
+        try {
+          await file.writeFile(text2);
+        } finally {
+          await file.close();
+        }
+        await rename(temp, path);
+      } finally {
+        await rm(temp, { force: true });
+      }
+    };
+    await atomic(detailPath, serialized);
+    if (!same(source, await this.regular(this.source(run.id)))) return false;
+    const index = { version: 1, source, detail: await this.regular(detailPath), digest: sha(serialized), seq, summary, search: runSearchText(run) };
+    const text = JSON.stringify({ index, checksum: sha(JSON.stringify(index)) });
+    if (Buffer.byteLength(text) > COLD_LIMITS.indexBytes) return false;
+    await atomic(this.path(run.id, "index"), text);
+    if (!same(source, await this.regular(this.source(run.id)))) return false;
+    this.drop(run.id);
+    this.indexes.set(run.id, index);
+    return true;
+  }
+  async getAsync(id) {
+    const index = this.indexes.get(id);
+    if (!index) return void 0;
+    const valid = async () => same(index.source, await this.regular(this.source(id))) && same(index.detail, await this.regular(this.path(id, "detail")));
+    if (!await valid()) return void 0;
+    const cached = this.cache.get(id);
+    if (cached) {
+      this.cache.delete(id);
+      this.cache.set(id, cached);
+      return structuredClone(cached.run);
+    }
+    const handle = await open(this.path(id, "detail"), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    let text;
+    try {
+      const info = await handle.stat();
+      if (!info.isFile() || info.size > COLD_LIMITS.detailBytes) throw new Error("Cold run detail exceeds its bound");
+      text = await handle.readFile("utf8");
+    } finally {
+      await handle.close();
+    }
+    if (Buffer.byteLength(text) > COLD_LIMITS.detailBytes || sha(text) !== index.digest || !await valid() || this.indexes.get(id) !== index) return void 0;
+    const run = JSON.parse(text);
+    if (run.id !== id || !coldEligible(run)) return void 0;
+    this.remember(id, run, Buffer.byteLength(text));
+    return structuredClone(run);
+  }
+  remember(id, run, bytes) {
+    const old = this.cache.get(id);
+    if (old) {
+      this.bytes -= old.bytes;
+      this.cache.delete(id);
+    }
+    while (this.cache.size >= COLD_LIMITS.cacheEntries || this.bytes + bytes > COLD_LIMITS.cacheBytes) {
+      const key = this.cache.keys().next().value;
+      if (!key) break;
+      this.bytes -= this.cache.get(key).bytes;
+      this.cache.delete(key);
+    }
+    this.cache.set(id, { run, bytes });
+    this.bytes += bytes;
+  }
+  /** Sync compatibility for manager.get; detail reads are bounded and cached, never whole logs. */
+  get(id) {
+    const index = this.indexes.get(id);
+    if (!index || !this.valid(id)) return void 0;
+    const cached = this.cache.get(id);
+    if (cached) {
+      this.cache.delete(id);
+      this.cache.set(id, cached);
+      return structuredClone(cached.run);
+    }
+    const handle = openSync(this.path(id, "detail"), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    let text;
+    try {
+      const info = fstatSync(handle);
+      if (!info.isFile() || info.size > COLD_LIMITS.detailBytes) throw new Error("Cold run detail exceeds its bound");
+      text = readFileSync(handle, "utf8");
+    } finally {
+      closeSync(handle);
+    }
+    if (sha(text) !== index.digest || !this.valid(id)) return void 0;
+    const run = JSON.parse(text);
+    if (run.id !== id || !coldEligible(run)) return void 0;
+    this.remember(id, run, Buffer.byteLength(text));
+    return structuredClone(run);
+  }
+}
+export {
+  COLD_LIMITS,
+  RunColdStore,
+  coldEligible,
+  coldSummary
+};

package/src/run-environment.js

@@ -0,0 +1,15 @@
+import { isDeepStrictEqual } from "node:util";
+function inheritRunEnvironment(requested, parent) {
+  const result = { ...requested };
+  if (!parent?.permissions) return result;
+  for (const key of ["agentContainer", "remoteWorker", "container"]) {
+    const inherited = parent.loop[key];
+    if (inherited === void 0) continue;
+    if (requested[key] !== void 0 && !isDeepStrictEqual(requested[key], inherited)) throw new Error(`Child runs must preserve the parent's ${key} execution boundary. Start an independent run to choose another environment.`);
+    result[key] = structuredClone(inherited);
+  }
+  return result;
+}
+export {
+  inheritRunEnvironment
+};

package/src/run-history.js

@@ -0,0 +1,91 @@
+function encodeRunCursor(run) {
+  return Buffer.from(JSON.stringify({ at: run.createdAt, id: run.id })).toString("base64url");
+}
+function decodeRunCursor(value) {
+  if (!value || value.length > 1e3 || !/^[\w-]+$/.test(value)) throw new Error("Invalid history cursor");
+  let cursor;
+  try {
+    cursor = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+  } catch {
+    throw new Error("Invalid history cursor");
+  }
+  if (!cursor || !Number.isSafeInteger(cursor.at) || cursor.at < 0 || typeof cursor.id !== "string" || !cursor.id || cursor.id.length > 256) throw new Error("Invalid history cursor");
+  return cursor;
+}
+function compareRuns(a, b) {
+  return b.createdAt - a.createdAt || b.id.localeCompare(a.id);
+}
+function afterRunCursor(run, cursor) {
+  return compareRuns(run, { createdAt: cursor.at, id: cursor.id }) > 0;
+}
+function runSearchText(run) {
+  return [run.task, run.id, run.repo, run.pattern, run.branchPrefix, run.source ? `#${run.source.number} ${run.source.title}` : "", run.externalSource?.title ?? "", run.trigger?.name ?? "", run.group?.label ?? ""].join("\n").toLowerCase();
+}
+class RunIndex {
+  records = /* @__PURE__ */ new Map();
+  ordered;
+  positions = /* @__PURE__ */ new Map();
+  repositories = /* @__PURE__ */ new Map();
+  revision = 0;
+  set(summary, search = runSearchText(summary)) {
+    const previous = this.records.get(summary.id)?.summary;
+    if (previous) this.removePaths(previous);
+    this.records.set(summary.id, { summary, search });
+    for (const path of /* @__PURE__ */ new Set([summary.repo, ...summary.worktrees.map((tree) => tree.path)])) {
+      let ids = this.repositories.get(path);
+      if (!ids) this.repositories.set(path, ids = /* @__PURE__ */ new Set());
+      ids.add(summary.id);
+    }
+    const position = this.positions.get(summary.id);
+    if (this.ordered && previous?.createdAt === summary.createdAt && position !== void 0) this.ordered[position] = summary;
+    else this.ordered = void 0;
+    this.revision++;
+  }
+  delete(id) {
+    const previous = this.records.get(id)?.summary;
+    if (!previous) return;
+    this.removePaths(previous);
+    this.records.delete(id);
+    this.ordered = void 0;
+    this.revision++;
+  }
+  removePaths(run) {
+    for (const path of [run.repo, ...run.worktrees.map((tree) => tree.path)]) {
+      const ids = this.repositories.get(path);
+      ids?.delete(run.id);
+      if (!ids?.size) this.repositories.delete(path);
+    }
+  }
+  values() {
+    if (!this.ordered) {
+      this.ordered = [...this.records.values()].map((entry) => entry.summary).sort(compareRuns);
+      this.positions = new Map(this.ordered.map((run, index) => [run.id, index]));
+    }
+    return this.ordered;
+  }
+  related(repo) {
+    return [...this.repositories.get(repo) ?? []].map((id) => this.records.get(id).summary);
+  }
+  matches(id, words) {
+    const text = this.records.get(id)?.search ?? "";
+    return words.every((word) => text.includes(word));
+  }
+}
+function historyOffset(runs, cursor, before) {
+  let low = 0, high = runs.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2), run = runs[middle];
+    if ((!cursor || afterRunCursor(run, cursor)) && (before === void 0 || run.createdAt < before)) high = middle;
+    else low = middle + 1;
+  }
+  return low;
+}
+export {
+  RunIndex,
+  afterRunCursor,
+  compareRuns,
+  decodeRunCursor,
+  encodeRunCursor,
+  historyOffset,
+  runSearchText
+};

package/src/run-log.js

@@ -0,0 +1,160 @@
+function replayEvents(events) {
+  let lastRun = -1;
+  const lastStep = /* @__PURE__ */ new Map();
+  events.forEach((e, i) => {
+    if (e.type === "run") lastRun = i;
+    else if (e.type === "step") lastStep.set(e.step.id, i);
+  });
+  return events.filter((e, i) => e.type === "run" ? i === lastRun : e.type === "step" ? lastStep.get(e.step.id) === i : true);
+}
+const MAX_PATCHES = 100;
+const MIN_STRING_KEPT = 64;
+class RunLogWriter {
+  constructor(fullAtEnd = true) {
+    this.fullAtEnd = fullAtEnd;
+  }
+  last = /* @__PURE__ */ new Map();
+  /** A line for this run didn't make it to disk: its next snapshot is written whole. */
+  forget(runId) {
+    this.last.delete(runId);
+  }
+  encode(event, opts = {}) {
+    if (event.type !== "run") return event;
+    const json = fieldsOf(event.run);
+    const prev = this.last.get(event.runId);
+    const ended = this.fullAtEnd && prev?.run.status === "running" && event.run.status !== "running";
+    if (!prev || opts.full || ended || prev.patches >= MAX_PATCHES || prev.bytes >= prev.full) {
+      this.last.set(event.runId, { seq: event.seq, run: event.run, json, patches: 0, bytes: 0, full: sizeOf(json) });
+      return event;
+    }
+    const patch = { seq: event.seq, ts: event.ts, runId: event.runId, type: "run-patch", base: prev.seq };
+    for (const [key, value] of json) {
+      const before = prev.json.get(key);
+      if (before === value) continue;
+      const tail = before === void 0 ? void 0 : tailOf(prev.run[key], event.run[key], value);
+      if (tail) (patch.tail ??= {})[key] = tail;
+      else (patch.set ??= {})[key] = event.run[key];
+    }
+    for (const key of prev.json.keys()) if (!json.has(key)) (patch.unset ??= []).push(key);
+    this.last.set(event.runId, { ...prev, seq: event.seq, run: event.run, json, patches: prev.patches + 1, bytes: prev.bytes + JSON.stringify(patch).length });
+    return patch;
+  }
+}
+function fieldsOf(run) {
+  const json = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(run)) {
+    const text = JSON.stringify(value);
+    if (text !== void 0) json.set(key, text);
+  }
+  return json;
+}
+const sizeOf = (json) => [...json].reduce((n, [k, v]) => n + k.length + v.length + 4, 2);
+function tailOf(before, after, afterJson) {
+  let kept = 0;
+  if (typeof before === "string" && typeof after === "string") {
+    const n = Math.min(before.length, after.length);
+    while (kept < n && before.charCodeAt(kept) === after.charCodeAt(kept)) kept++;
+    if (kept < MIN_STRING_KEPT) return void 0;
+    return [kept, after.slice(kept)];
+  }
+  if (Array.isArray(before) && Array.isArray(after)) {
+    const n = Math.min(before.length, after.length);
+    while (kept < n && JSON.stringify(before[kept]) === JSON.stringify(after[kept])) kept++;
+    if (!kept) return void 0;
+    const rest = after.slice(kept);
+    return JSON.stringify(rest).length < afterJson.length * 0.8 ? [kept, rest] : void 0;
+  }
+  return void 0;
+}
+class RunLogReader {
+  current;
+  currentSeq = -1;
+  decode(value) {
+    const line = value;
+    if (line?.type === "run") {
+      this.current = line.run;
+      this.currentSeq = line.seq;
+      return line;
+    } else if (line?.type === "run-patch") {
+      if (!this.current || this.current.id !== line.runId || line.base !== this.currentSeq) {
+        this.current = void 0;
+        return void 0;
+      }
+      const next = { ...this.current };
+      for (const [key, value2] of Object.entries(line.set ?? {})) next[key] = value2;
+      for (const [key, [at, rest]] of Object.entries(line.tail ?? {})) {
+        const before = next[key];
+        if (typeof before === "string" && typeof rest === "string" && before.length >= at) next[key] = before.slice(0, at) + rest;
+        else if (Array.isArray(before) && Array.isArray(rest) && before.length >= at) next[key] = [...before.slice(0, at), ...rest];
+      }
+      for (const key of line.unset ?? []) delete next[key];
+      this.current = next;
+      this.currentSeq = line.seq;
+      return { seq: line.seq, ts: line.ts, runId: line.runId, type: "run", run: this.current };
+    } else if (line) {
+      return line;
+    }
+  }
+}
+class StrictRunLogReader {
+  constructor(runId) {
+    this.runId = runId;
+  }
+  reader = new RunLogReader();
+  current;
+  currentSeq;
+  decode(value) {
+    try {
+      if (!record(value) || typeof value.type !== "string" || value.runId !== void 0 && value.runId !== this.runId) throw new Error("Invalid or mismatched run log record");
+      if (value.type === "run") {
+        if (!record(value.run) || value.run.id !== this.runId || value.seq !== void 0 && !sequence(value.seq)) throw new Error("Invalid or mismatched run snapshot");
+      } else if (value.type === "run-patch") {
+        if (Object.keys(value).some((key) => !["seq", "ts", "runId", "type", "base", "set", "tail", "unset"].includes(key)) || value.runId !== this.runId || !sequence(value.seq) || !sequence(value.base) || value.seq <= value.base || !this.current || value.base !== this.currentSeq) throw new Error("Invalid or missing run patch base");
+        if (value.set !== void 0 && !record(value.set) || value.tail !== void 0 && !record(value.tail) || value.unset !== void 0 && (!Array.isArray(value.unset) || value.unset.some((key) => typeof key !== "string"))) throw new Error("Invalid run patch fields");
+        const set = value.set, tail = value.tail, unset = value.unset;
+        const keys = [...Object.keys(set ?? {}), ...Object.keys(tail ?? {}), ...unset ?? []];
+        if (new Set(keys).size !== keys.length || keys.some((key) => !key || ["id", "__proto__", "constructor", "prototype"].includes(key))) throw new Error("Invalid or overlapping run patch fields");
+        for (const [key, change] of Object.entries(tail ?? {})) {
+          if (!Array.isArray(change) || change.length !== 2 || !sequence(change[0])) throw new Error("Invalid run patch tail");
+          const [at, rest] = change, before = this.current[key];
+          if (!(typeof before === "string" && typeof rest === "string" && at <= before.length || Array.isArray(before) && Array.isArray(rest) && at <= before.length)) throw new Error("Invalid run patch tail");
+        }
+      }
+      const event = this.reader.decode(value);
+      if (event?.type === "run") {
+        this.current = event.run;
+        this.currentSeq = sequence(value.seq) ? value.seq : void 0;
+      }
+      return event;
+    } catch (error) {
+      this.reader = new RunLogReader();
+      this.current = void 0;
+      this.currentSeq = void 0;
+      throw error;
+    }
+  }
+}
+const record = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const sequence = (value) => Number.isSafeInteger(value) && value >= 0;
+function decodeRunLog(lines) {
+  const out = [], reader = new RunLogReader();
+  for (const line of lines) {
+    const event = reader.decode(line);
+    if (event) out.push(event);
+  }
+  return out;
+}
+function compactRunLog(events) {
+  const writer = new RunLogWriter(false);
+  let lastRun = -1;
+  events.forEach((e, i) => e.type === "run" && (lastRun = i));
+  return events.map((e, i) => writer.encode(e, { full: i === lastRun }));
+}
+export {
+  RunLogReader,
+  RunLogWriter,
+  StrictRunLogReader,
+  compactRunLog,
+  decodeRunLog,
+  replayEvents
+};