relaybrain 0.0.0-stage → 0.2.0

package/backend/lib/falkor/client.js

@@ -0,0 +1,165 @@
+const { FalkorDB } = require("falkordb");
+
+function sanitizeGraphId(projectId) {
+  return String(projectId || "default").replace(/[^A-Za-z0-9_]/g, "_");
+}
+
+function withTimeout(promise, ms, label) {
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(Object.assign(new Error(`${label} timed out after ${ms}ms`), { timeout: true })), ms);
+    }),
+  ]).finally(() => clearTimeout(timer));
+}
+
+class FalkorClient {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.db = null;
+    this.connecting = null;
+    this.queues = new Map();
+    this.breaker = { state: "closed", until: 0, failures: 0, lastError: null, lastOkAt: 0 };
+  }
+
+  graphName(projectId) {
+    return `${this.cfg.prefix}${sanitizeGraphId(projectId)}`;
+  }
+
+  available() {
+    if (this.breaker.state !== "open") return true;
+    if (Date.now() >= this.breaker.until) {
+      this.breaker.state = "probing";
+      return true;
+    }
+    return false;
+  }
+
+  async connection() {
+    if (this.closed) throw Object.assign(new Error("falkor client closed"), { breaker: true });
+    if (this.db) return this.db;
+    if (this.connecting) return this.connecting;
+    this.connecting = (async () => {
+      const db = await withTimeout(
+        FalkorDB.connect({
+          url: this.cfg.url,
+          disableOfflineQueue: true,
+          socket: {
+            connectTimeout: 5000,
+            reconnectStrategy: (retries) => Math.min(500 * (retries + 1), 5000),
+          },
+        }),
+        7000,
+        "falkor connect"
+      );
+      // An EventEmitter "error" with no listener throws and would take relay serve down.
+      db.on("error", (err) => {
+        this.breaker.lastError = String(err?.message || err);
+      });
+      this.db = db;
+      return db;
+    })().finally(() => {
+      this.connecting = null;
+    });
+    return this.connecting;
+  }
+
+  ok() {
+    this.breaker.state = "closed";
+    this.breaker.failures = 0;
+    this.breaker.lastError = null;
+    this.breaker.lastOkAt = Date.now();
+  }
+
+  fail(err) {
+    const b = this.breaker;
+    const message = String(err?.message || err);
+    // Cypher errors are our bugs (or a graph that doesn't exist yet), not an outage:
+    // only transport failures trip the breaker or count as the connection's last error.
+    const transport = /ECONN|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|closed|offline|socket|connect/i.test(message);
+    if (!transport && !err?.timeout) {
+      b.lastQueryError = message;
+      return;
+    }
+    b.lastError = message;
+    b.failures += 1;
+    if (b.state === "probing" || transport || b.failures >= 3) {
+      b.state = "open";
+      b.until = Date.now() + this.cfg.breakerCooldownMs;
+    }
+  }
+
+  async run(kind, projectId, query, params) {
+    if (!this.available()) {
+      const err = new Error("falkor unavailable (breaker open)");
+      err.breaker = true;
+      throw err;
+    }
+    try {
+      const db = await this.connection();
+      const graph = db.selectGraph(this.graphName(projectId));
+      const timeoutMs = kind === "read" ? this.cfg.readTimeoutMs : this.cfg.writeTimeoutMs;
+      const opts = { params: params || {}, TIMEOUT: timeoutMs };
+      const call = kind === "read" ? graph.roQuery(query, opts) : graph.query(query, opts);
+      const result = await withTimeout(call, timeoutMs + 500, `falkor ${kind}`);
+      this.ok();
+      return result.data || [];
+    } catch (err) {
+      if (!err.breaker) this.fail(err);
+      throw err;
+    }
+  }
+
+  // FalkorDB serializes writes per graph; chaining keeps our own batches from piling up.
+  write(projectId, query, params) {
+    const key = this.graphName(projectId);
+    const prev = this.queues.get(key) || Promise.resolve();
+    const next = prev.catch(() => undefined).then(() => this.run("write", projectId, query, params));
+    this.queues.set(
+      key,
+      next.catch(() => undefined)
+    );
+    return next;
+  }
+
+  read(projectId, query, params) {
+    return this.run("read", projectId, query, params);
+  }
+
+  async graph(projectId) {
+    const db = await this.connection();
+    return db.selectGraph(this.graphName(projectId));
+  }
+
+  async deleteGraph(projectId) {
+    const g = await this.graph(projectId);
+    try {
+      await g.delete();
+    } catch (err) {
+      if (!/empty key|not exist|Invalid graph operation on empty key/i.test(String(err.message))) throw err;
+    }
+  }
+
+  status() {
+    return {
+      state: this.breaker.state,
+      failures: this.breaker.failures,
+      lastError: this.breaker.lastError,
+      lastQueryError: this.breaker.lastQueryError || null,
+      lastOkAt: this.breaker.lastOkAt || null,
+      reopensAt: this.breaker.state === "open" ? this.breaker.until : null,
+      connected: Boolean(this.db),
+    };
+  }
+
+  async close() {
+    // A closed client stays closed: late timers must not reopen a socket that keeps the process alive.
+    this.closed = true;
+    const db = this.db;
+    this.db = null;
+    if (db) await db.close().catch(() => undefined);
+  }
+}
+
+module.exports = { FalkorClient, sanitizeGraphId, withTimeout };

package/backend/lib/falkor/config.js

@@ -0,0 +1,73 @@
+const fs = require("fs");
+const path = require("path");
+
+function flag(value) {
+  return value === "1" || value === "true" || value === "yes";
+}
+
+// ~/.relay/falkor.json, written by `relay graph enable`. Resolved per call so tests and
+// isolated runs that point USERPROFILE/HOME elsewhere get their own file.
+function configPath() {
+  return path.join(require("os").homedir(), ".relay", "falkor.json");
+}
+
+function loadFileConfig() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath(), "utf8"));
+    return raw && typeof raw === "object" ? raw : null;
+  } catch {
+    return null;
+  }
+}
+
+function saveFileConfig(cfg) {
+  const file = configPath();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  // The URL can carry a password: keep the file private where the OS supports modes.
+  fs.writeFileSync(file, `${JSON.stringify(cfg, null, 2)}\n`, { mode: 0o600 });
+  return file;
+}
+
+function clearFileConfig() {
+  try {
+    fs.unlinkSync(configPath());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function validUrl(url) {
+  return /^(falkors?|rediss?):\/\/[^\s]+$/i.test(String(url || "").trim());
+}
+
+/**
+ * Env wins over the saved file, so a one-off `RELAY_FALKOR_URL=…` still works.
+ * Only the real process env reads the file; tests pass their own env object.
+ */
+function ipv4Localhost(url) {
+  return String(url || "").replace(/\/\/localhost(?=[:/]|$)/i, "//127.0.0.1");
+}
+
+function readConfig(env = process.env, file = env === process.env ? loadFileConfig() : null) {
+  const envUrl = String(env.RELAY_FALKOR_URL || "").trim();
+  const rawUrl = envUrl || String(file?.url || "").trim();
+  const url = ipv4Localhost(rawUrl);
+  const disabled = flag(String(env.RELAY_FALKOR_DISABLED || "").toLowerCase()) || file?.disabled === true;
+  const storeText = env.RELAY_FALKOR_TEXT != null ? env.RELAY_FALKOR_TEXT !== "0" : file?.storeText !== false;
+  const rawDays = env.RELAY_FALKOR_TEXT_DAYS != null ? Number(env.RELAY_FALKOR_TEXT_DAYS) : file?.textDays != null ? Number(file.textDays) : 90;
+  const textRetentionDays = Number.isFinite(rawDays) && rawDays >= 0 ? rawDays : 90;
+  return {
+    url,
+    source: envUrl ? "env" : url ? "file" : null,
+    enabled: Boolean(url) && !disabled,
+    storeText,
+    textRetentionDays,
+    prefix: env.RELAY_FALKOR_GRAPH_PREFIX || file?.prefix || "relay_",
+    writeTimeoutMs: Number(env.RELAY_FALKOR_WRITE_TIMEOUT_MS) || 5000,
+    readTimeoutMs: Number(env.RELAY_FALKOR_READ_TIMEOUT_MS) || 2000,
+    breakerCooldownMs: 30_000,
+  };
+}
+
+module.exports = { readConfig, loadFileConfig, saveFileConfig, clearFileConfig, configPath, validUrl };

package/backend/lib/falkor/coord.js

@@ -0,0 +1,299 @@
+// Coordination events → graph, plus graph context handed to agents at the moment of conflict.
+// Everything on the claim path is synchronous Map/array work; writes happen on timers.
+const { bus } = require("./bus");
+const keys = require("./keys");
+const intents = require("./intents");
+const { each } = require("./write");
+const { loadRegistry } = require("../store");
+const { normalizeCompare } = require("../transcripts/util");
+
+const HELD_FLUSH_MS = 10_000;
+const CONTENTION_FLUSH_MS = 2_000;
+const LABEL_FALLBACK_MAX_AGE_MS = 30 * 60 * 1000;
+const MAX_ROWS = 5000;
+
+let api = null;
+const held = new Map();
+const contentions = new Map();
+let registryCache = { at: 0, projects: [] };
+
+/** Lookup only: unlike server.js projectForPath, never registers a new workspace. */
+function projectIdFor(workspaceId) {
+  if (!workspaceId) return null;
+  if (Date.now() - registryCache.at > 5000) {
+    try {
+      registryCache = { at: Date.now(), projects: loadRegistry().projects || [] };
+    } catch {
+      registryCache = { at: Date.now(), projects: [] };
+    }
+  }
+  const target = normalizeCompare(workspaceId);
+  const hit = registryCache.projects.find((p) => p.id === workspaceId || normalizeCompare(p.path) === target);
+  return hit?.id || null;
+}
+
+function ago(ts) {
+  const mins = Math.max(0, Math.round((Date.now() - ts) / 60000));
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins} min ago`;
+  if (mins < 48 * 60) return `${Math.round(mins / 60)} h ago`;
+  return `${Math.round(mins / 1440)} days ago`;
+}
+
+/** What the holder is doing, from the in-process intent cache. Never touches the database. */
+function holderIntent(holderAgentId) {
+  const h = keys.parseLockAgentId(holderAgentId);
+  if (!h.label) return null;
+  const sk = h.sessionKnown ? keys.sessionKey(h.label, h.session) : null;
+  const exact = sk ? intents.forSession(sk) : null;
+  if (exact?.intent) return { text: exact.intent, at: exact.intentAt, confidence: "high", sessionKey: sk, label: h.label };
+  const latest = intents.latestForLabel(h.label);
+  if (latest?.intent && Date.now() - (latest.intentAt || 0) < LABEL_FALLBACK_MAX_AGE_MS) {
+    return { text: latest.intent, at: latest.intentAt, confidence: "low", sessionKey: latest.sessionKey, label: h.label };
+  }
+  return null;
+}
+
+function enrichDeny(result) {
+  if (!result || result.allowed || !result.holder || result.holderIntent) return result;
+  const intent = holderIntent(result.holder);
+  if (!intent) return result;
+  result.holderIntent = { text: intent.text, at: intent.at, confidence: intent.confidence };
+  const who = intent.confidence === "high" ? "They're" : "That agent was last";
+  result.reason = `${result.reason || "File is locked."} ${who} working on: "${intent.text}" (${intent.at ? ago(intent.at) : "recently"}).`;
+  return result;
+}
+
+function sideOf(agentId) {
+  const p = keys.parseLockAgentId(agentId);
+  const sk = p.sessionKnown ? keys.sessionKey(p.label, p.session) : null;
+  return { agentId: agentId || null, label: p.label || null, session: p.sessionKnown ? p.session : null, sessionKey: sk };
+}
+
+function recordContention(projectId, { kind, file, wanter, holder, reason, ts = Date.now(), holderIntentText = null }) {
+  const fk = keys.fileKey(file);
+  if (!projectId || !fk) return;
+  const key = keys.contentionKey({ kind, fileKey: fk, wanter: wanter || "", holder: holder || "", ts });
+  const existing = contentions.get(key);
+  if (existing) {
+    existing.attempts += 1;
+    existing.lastTs = Math.max(existing.lastTs, ts);
+    return;
+  }
+  if (contentions.size >= MAX_ROWS) {
+    api.projectStats(projectId).bufferDrops += 1;
+    return;
+  }
+  const w = sideOf(wanter);
+  const h = sideOf(holder);
+  contentions.set(key, {
+    projectId,
+    key,
+    kind,
+    fileKey: fk,
+    path: keys.displayPath(file),
+    ts,
+    lastTs: ts,
+    attempts: 1,
+    reason: reason ? String(reason).slice(0, 500) : null,
+    wanter: w.agentId,
+    wanterLabel: w.label,
+    wanterSession: w.session,
+    wanterSessionKey: w.sessionKey,
+    holder: h.agentId,
+    holderLabel: h.label,
+    holderSession: h.session,
+    holderSessionKey: h.sessionKey,
+    holderIntent: holderIntentText,
+  });
+}
+
+function recordHeld(projectId, agentId, file, ts = Date.now()) {
+  const side = sideOf(agentId);
+  const fk = keys.fileKey(file);
+  if (!projectId || !side.sessionKey || !fk) return;
+  const key = `${projectId}|${side.sessionKey}|${fk}`;
+  const row = held.get(key);
+  if (row) {
+    row.count += 1;
+    row.lastAt = ts;
+    return;
+  }
+  if (held.size >= MAX_ROWS) return;
+  held.set(key, { projectId, sessionKey: side.sessionKey, label: side.label, sessionId: side.session, fileKey: fk, path: keys.displayPath(file), count: 1, firstAt: ts, lastAt: ts });
+}
+
+function observeClaim(args, result) {
+  if (!args || !result) return;
+  if (Array.isArray(args.files) && args.files.length) return; // the per-file recursion reports each file
+  if (args.mode === "read" || result.reading) return;
+  const projectId = projectIdFor(args.workspaceId);
+  if (result.allowed) {
+    recordHeld(projectId, args.agentId, args.file);
+    return;
+  }
+  if (!result.holder) return;
+  enrichDeny(result);
+  // bumpCollision() in server.js emits a second "collision" event after claim() returns,
+  // with the already-enriched reason string, so holderIntentText must fall back to holderIntent(holder).
+  const intentText = result.holderIntent?.text || holderIntent(result.holder)?.text || null;
+  recordContention(projectId, {
+    kind: "claim_blocked",
+    file: args.file,
+    wanter: args.agentId,
+    holder: result.holder,
+    reason: result.reason,
+    holderIntentText: intentText,
+  });
+}
+
+function wrapClaim(lockTable) {
+  if (!lockTable || lockTable.__relayFalkorWrapped) return;
+  const original = lockTable.claim;
+  lockTable.claim = function claimWithGraph(args) {
+    const result = original.call(this, args);
+    try {
+      observeClaim(args, result);
+    } catch {
+      /* the graph must never change a lock decision */
+    }
+    return result;
+  };
+  lockTable.__relayFalkorWrapped = true;
+}
+
+const SESSION_STUB = (side) => `
+FOREACH (_ IN CASE WHEN r.${side}SessionKey IS NULL THEN [] ELSE [1] END |
+  MERGE (s:Session {key: r.${side}SessionKey})
+    ON CREATE SET s.label = r.${side}Label, s.sessionId = r.${side}Session, s.turnCount = 0, s.editCount = 0,
+                  s.startedAt = r.ts, s.lastAt = r.ts, s.stub = true
+  MERGE (c)-[:${side === "wanter" ? "WANTED_BY" : "HELD_BY"}]->(s))`;
+
+const CONTENTION = `
+UNWIND $rows AS r
+MERGE (c:Contention {key: r.key})
+  ON CREATE SET c.kind = r.kind, c.ts = r.ts, c.attempts = 0, c.reason = r.reason,
+                c.wanter = r.wanter, c.holder = r.holder, c.wanterLabel = r.wanterLabel,
+                c.holderLabel = r.holderLabel, c.holderIntent = r.holderIntent
+SET c.attempts = c.attempts + r.attempts,
+    c.lastTs = CASE WHEN c.lastTs IS NULL OR r.lastTs > c.lastTs THEN r.lastTs ELSE c.lastTs END
+MERGE (f:File {key: r.fileKey})
+  ON CREATE SET f.path = r.path, f.editCount = 0
+MERGE (c)-[:ON]->(f)
+${SESSION_STUB("wanter")}
+${SESSION_STUB("holder")}
+RETURN count(c) AS n`;
+
+const HELD = `
+UNWIND $rows AS r
+MERGE (s:Session {key: r.sessionKey})
+  ON CREATE SET s.label = r.label, s.sessionId = r.sessionId, s.turnCount = 0, s.editCount = 0,
+                s.startedAt = r.firstAt, s.lastAt = r.lastAt, s.stub = true
+MERGE (f:File {key: r.fileKey})
+  ON CREATE SET f.path = r.path, f.editCount = 0
+MERGE (s)-[h:HELD]->(f)
+  ON CREATE SET h.count = 0, h.firstAt = r.firstAt, h.lastAt = r.lastAt
+SET h.count = h.count + r.count,
+    h.lastAt = CASE WHEN r.lastAt > h.lastAt THEN r.lastAt ELSE h.lastAt END
+RETURN count(h) AS n`;
+
+function byProject(map) {
+  const out = new Map();
+  for (const row of map.values()) {
+    if (!out.has(row.projectId)) out.set(row.projectId, []);
+    out.get(row.projectId).push(row);
+  }
+  return out;
+}
+
+async function flush(map, query, label) {
+  if (!map.size || !api.client.available()) return;
+  const groups = byProject(map);
+  map.clear();
+  for (const [projectId, rows] of groups) {
+    try {
+      await api.ensureProject(projectId);
+      await each(api.client, projectId, query, rows);
+      if (label === "contention") {
+        const attempts = rows.reduce((n, r) => n + r.attempts, 0);
+        console.log(`[relay-falkor] ${projectId}: +${rows.length} contention(s), ${attempts} blocked attempt(s)`);
+        api.notify?.(projectId, { contentions: rows.length });
+      }
+    } catch (err) {
+      api.projectStats(projectId).lastError = String(err.message || err);
+      // Only retry when the batch provably never reached the server; a re-sent batch would double the counters.
+      if (!err.breaker) continue;
+      for (const r of rows) if (map.size < MAX_ROWS) map.set(r.key || `${r.projectId}|${r.sessionKey}|${r.fileKey}`, r);
+    }
+  }
+}
+
+function every(ms, fn) {
+  const t = setInterval(() => fn().catch(() => undefined), ms);
+  if (t.unref) t.unref();
+  return t;
+}
+
+const WARM_INTENTS = `
+MATCH (s:Session) WHERE s.intent IS NOT NULL
+OPTIONAL MATCH (a:Agent)-[:RAN]->(s)
+RETURN s.key AS sessionKey, s.label AS label, s.intent AS intent, s.intentAt AS intentAt, a.key AS agentKey
+ORDER BY s.intentAt DESC LIMIT 1000`;
+
+/** The intent cache is in-process; after a restart it is refilled from the graph, not from the next ingest. */
+async function warmIntents() {
+  let projects = [];
+  try {
+    projects = loadRegistry().projects || [];
+  } catch {
+    return 0;
+  }
+  let n = 0;
+  for (const p of projects) {
+    try {
+      const rows = await api.client.read(p.id, WARM_INTENTS);
+      for (const r of rows.reverse()) {
+        intents.remember(r);
+        n += 1;
+      }
+    } catch {
+      /* project has no graph yet */
+    }
+  }
+  return n;
+}
+
+function start(falkor) {
+  api = { ...falkor, client: falkor.state.client, state: falkor.state };
+  wrapClaim(falkor.state.deps.lockTable);
+  const warm = setTimeout(() => {
+    warmIntents()
+      .then((n) => n && console.log(`[relay-falkor] warmed ${n} session intent(s) from the graph`))
+      .catch(() => undefined);
+  }, 500);
+  if (warm.unref) warm.unref();
+  bus.on("collision", ({ projectId, kind, detail = {}, ts }) => {
+    if (kind === "claim_blocked") return; // already captured, with intent, by the claim wrapper
+    recordContention(projectId, {
+      kind,
+      file: detail.file,
+      wanter: detail.agentId || detail.agent || null,
+      holder: detail.holder || null,
+      reason: detail.reason || null,
+      ts: ts || Date.now(),
+      holderIntentText: detail.holder ? holderIntent(detail.holder)?.text || null : null,
+    });
+  });
+  every(CONTENTION_FLUSH_MS, () => flush(contentions, CONTENTION, "contention"));
+  every(HELD_FLUSH_MS, () => flush(held, HELD, "held"));
+}
+
+function flushAll() {
+  return Promise.all([flush(contentions, CONTENTION, "contention"), flush(held, HELD, "held")]);
+}
+
+function configure(falkor) {
+  api = { ...falkor, client: falkor.state.client, state: falkor.state };
+}
+
+module.exports = { start, configure, wrapClaim, enrichDeny, holderIntent, observeClaim, recordContention, recordHeld, flushAll, projectIdFor, warmIntents };

package/backend/lib/falkor/cursor.js

@@ -0,0 +1,58 @@
+// Per-project ingest cursor. Purely an optimization: MERGE + batch tokens keep the
+// graph correct even if this file is lost; losing it only costs one full re-send.
+const fs = require("fs");
+const path = require("path");
+const { projectDir } = require("../store");
+const { INGEST_VERSION } = require("./schema");
+
+const MAX_SEEN = 6000;
+
+function cursorPath(projectId) {
+  return path.join(projectDir(projectId), "graph-cursor.json");
+}
+
+function blank() {
+  return { ingestVersion: INGEST_VERSION, seen: [], centralEventId: {}, updatedAt: 0 };
+}
+
+function load(projectId) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(cursorPath(projectId), "utf8"));
+    if (raw.ingestVersion !== INGEST_VERSION) return blank();
+    return { ...blank(), ...raw, seen: Array.isArray(raw.seen) ? raw.seen : [] };
+  } catch {
+    return blank();
+  }
+}
+
+function save(projectId, cursor) {
+  const file = cursorPath(projectId);
+  const tmp = `${file}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify({ ...cursor, updatedAt: Date.now() }));
+  fs.renameSync(tmp, file);
+}
+
+function seenSet(cursor) {
+  return new Set(cursor.seen);
+}
+
+function commit(projectId, cursor, ids) {
+  const set = new Set(cursor.seen);
+  for (const id of ids) {
+    set.delete(id);
+    set.add(id);
+  }
+  cursor.seen = [...set].slice(-MAX_SEEN);
+  save(projectId, cursor);
+  return cursor;
+}
+
+function reset(projectId) {
+  try {
+    fs.unlinkSync(cursorPath(projectId));
+  } catch {
+    /* already gone */
+  }
+}
+
+module.exports = { load, save, commit, reset, seenSet, cursorPath };

package/backend/lib/falkor/fixtures.js

@@ -0,0 +1,85 @@
+// Synthetic events shaped like real unifyEvent output (no user data).
+const path = require("path");
+
+// A native absolute workspace, so path handling is exercised the way it runs on each OS.
+const WS = process.platform === "win32" ? "C:\\Users\\dev\\demo" : "/home/dev/demo";
+const wsPath = (...parts) => path.join(WS, ...parts);
+// Agents sometimes report Windows paths with forward slashes; on POSIX this is the same path.
+const slashed = (p) => p.split(path.sep).join("/");
+const CLAUDE_SID = "52b29a54-d8fb-4091-ab60-463ac73c9d6c";
+const CURSOR_SID = "3e62675d-9b0f-4d99-b17d-c1d875fe98dc";
+
+let n = 0;
+function ev(fields) {
+  n += 1;
+  return {
+    id: `ev${String(n).padStart(4, "0")}`,
+    ownerLogin: "alice",
+    role: "assistant",
+    kind: "message",
+    text: "",
+    file: null,
+    path: null,
+    diff: "",
+    ...fields,
+  };
+}
+
+function demoHistory() {
+  n = 0;
+  return [
+    ev({ agent: "Claude Code", sessionId: CLAUDE_SID, ts: 1000, role: "user", text: "switch the login flow to JWT tokens" }),
+    ev({ agent: "Cursor", sessionId: CURSOR_SID, ts: 1500.685, role: "user", text: "make the navbar sticky" }),
+    ev({ agent: "Claude Code", sessionId: CLAUDE_SID, ts: 2000, role: "assistant", kind: "thinking", text: "hmm, issuer first" }),
+    ev({ agent: "Claude Code", sessionId: CLAUDE_SID, ts: 2100, role: "assistant", text: "I'll update the token issuer first." }),
+    ev({
+      agent: "Claude Code",
+      sessionId: CLAUDE_SID,
+      ts: 3000,
+      role: "tool",
+      kind: "code_edit",
+      text: "Edit auth.ts",
+      file: "auth.ts",
+      path: slashed(wsPath("src", "Auth.ts")),
+      diff: "--- a/auth.ts\n+++ b/auth.ts\n@@ -1,2 +1,3 @@\n-old\n+new\n+newer\n",
+    }),
+    ev({
+      agent: "Cursor",
+      sessionId: CURSOR_SID,
+      ts: 3500.685,
+      role: "tool",
+      kind: "code_edit",
+      text: "Write navbar.css",
+      file: "navbar.css",
+      path: wsPath("styles", "navbar.css"),
+      diff: "+.nav{position:sticky}\n",
+    }),
+    ev({ agent: "Claude Code", sessionId: CLAUDE_SID, ts: 4000, role: "user", text: "also add refresh tokens, api_key=supersecretvalue123" }),
+    ev({
+      agent: "Claude Code",
+      sessionId: CLAUDE_SID,
+      ts: 5000,
+      role: "tool",
+      kind: "code_edit",
+      text: "Edit auth.ts",
+      file: "auth.ts",
+      path: wsPath("src", "auth.ts"),
+      diff: "+refresh\n",
+    }),
+    ev({
+      agent: "Claude Code",
+      sessionId: CLAUDE_SID,
+      ts: 5100,
+      role: "tool",
+      kind: "code_edit",
+      text: "Write notes.md",
+      file: "notes.md",
+      path: path.join(path.dirname(WS), "other-repo", "notes.md"),
+      diff: "+x\n",
+    }),
+    ev({ agent: "Antigravity", sessionId: "session", ts: 6000, role: "user", text: "what files do you see" }),
+    ev({ agent: "Codex", sessionId: "codex-1", ts: 7000, role: "tool", kind: "code_edit", text: "apply_patch", file: null, path: null, diff: "" }),
+  ];
+}
+
+module.exports = { demoHistory, WS, wsPath, CLAUDE_SID, CURSOR_SID };