tryharness 0.7.22 → 0.7.25

package/lib/learn.mjs

@@ -0,0 +1,182 @@
+import fs from "node:fs";
+import path from "node:path";
+
+// The context engine's personal ranking model: a logistic regression over a few signals the frozen models and the
+// relay's own records give for each candidate file (meaning, words, names, what the swarm edited lately and last).
+// It learns from finished runs: the files a run went on to edit are the right answers for its brief. A new model is
+// trained on older runs and kept only if it beats the current one on the newest runs, which it never saw.
+
+export const FEATURES = [
+  "dense",
+  "denseRank",
+  "lexical",
+  "lexicalRank",
+  "named",
+  "prior",
+  "priorRead",
+  "lastEdit",
+  "lastRun",
+  "recent",
+  "test",
+  "doc",
+  "depth",
+];
+const HALF_LIFE_DAYS = 7;
+
+/**
+ * What the swarm did to each file before a moment: decayed edit and read counts from earlier runs' trails, when each
+ * file was last edited, and what the latest earlier run edited (work often picks up where the last session left off).
+ */
+export function swarmPrior(history, at) {
+  const edits = new Map();
+  const reads = new Map();
+  const lastEdit = new Map();
+  let latest = null;
+  for (const run of history) {
+    if (!(run.at < at)) continue;
+    const weight = 0.5 ** ((at - run.at) / 86_400_000 / HALF_LIFE_DAYS);
+    for (const file of run.edited) {
+      edits.set(file, (edits.get(file) ?? 0) + weight);
+      lastEdit.set(file, Math.max(lastEdit.get(file) ?? 0, run.at));
+    }
+    for (const file of run.read)
+      reads.set(file, (reads.get(file) ?? 0) + weight);
+    if (run.edited.length && (!latest || run.at > latest.at)) latest = run;
+  }
+  return { edits, reads, lastEdit, lastRun: new Set(latest?.edited ?? []), at };
+}
+
+/** One feature row per candidate. candidates: searchFiles output; extras: { prior, recent: Map(path→commits) }. */
+export function featureRows(candidates, { prior, recent = new Map() }) {
+  const byDense = [...candidates].sort((a, b) => b.dense - a.dense);
+  const byWords = [...candidates].sort((a, b) => b.lexical - a.lexical);
+  const denseRank = new Map(byDense.map((row, i) => [row.path, i]));
+  const wordsRank = new Map(byWords.map((row, i) => [row.path, i]));
+  const topWords = byWords[0]?.lexical || 1;
+  return candidates.map((row) => ({
+    path: row.path,
+    x: {
+      dense: row.dense,
+      denseRank: Math.log1p(denseRank.get(row.path)),
+      lexical: row.lexical > 0 ? row.lexical / topWords : 0,
+      lexicalRank:
+        row.lexical > 0
+          ? Math.log1p(wordsRank.get(row.path))
+          : Math.log1p(candidates.length),
+      named: row.named,
+      prior: Math.log1p(prior.edits.get(row.path) ?? 0),
+      priorRead: Math.log1p(prior.reads.get(row.path) ?? 0),
+      // Hours since any run last edited it, as a closeness from 1 (just now) toward 0 (weeks ago, or never).
+      lastEdit: prior.lastEdit.has(row.path)
+        ? 1 / (1 + (prior.at - prior.lastEdit.get(row.path)) / 3_600_000 / 24)
+        : 0,
+      lastRun: prior.lastRun.has(row.path) ? 1 : 0,
+      recent: Math.log1p(recent.get(row.path) ?? 0),
+      test: /(?:^|\/)(?:tests?|__tests__)\/|\.(?:test|spec)\.[^.]+$/.test(
+        row.path
+      )
+        ? 1
+        : 0,
+      doc: /\.(?:md|mdx|txt)$/i.test(row.path) ? 1 : 0,
+      depth: row.path.split("/").length,
+    },
+  }));
+}
+
+/** The hand-set scorer used before any learning: meaning, words and names, with the swarm's recent edits as a tiebreak. */
+export function baselineScore(x) {
+  return x.dense + 0.25 * x.lexical + 0.2 * x.named + 0.02 * x.prior;
+}
+
+/** What a pack is for: code. Notes and status docs (edited by nearly every session) are neither right answers nor misses. */
+export const codeFiles = (files) =>
+  files.filter((file) => !/\.(?:md|mdx|txt)$/i.test(file));
+
+/** Trains a logistic regression on rows { x, y }; positives weighted up to balance the classes. */
+export function train(rows, { epochs = 300, rate = 0.05, l2 = 1e-3 } = {}) {
+  const n = rows.length;
+  const mean = Object.fromEntries(
+    FEATURES.map((name) => [
+      name,
+      rows.reduce((sum, row) => sum + row.x[name], 0) / n,
+    ])
+  );
+  const std = Object.fromEntries(
+    FEATURES.map((name) => [
+      name,
+      Math.sqrt(
+        rows.reduce((sum, row) => sum + (row.x[name] - mean[name]) ** 2, 0) / n
+      ) || 1,
+    ])
+  );
+  const positives = rows.filter((row) => row.y).length;
+  const weightPos = positives ? Math.min(50, (n - positives) / positives) : 1;
+  const xs = rows.map((row) =>
+    FEATURES.map((name) => (row.x[name] - mean[name]) / std[name])
+  );
+  const w = new Float64Array(FEATURES.length);
+  let b = 0;
+  const m = new Float64Array(FEATURES.length + 1),
+    v = new Float64Array(FEATURES.length + 1);
+  for (let epoch = 1; epoch <= epochs; epoch += 1) {
+    const grad = new Float64Array(FEATURES.length + 1);
+    let total = 0;
+    for (let i = 0; i < n; i += 1) {
+      let z = b;
+      for (let j = 0; j < w.length; j += 1) z += w[j] * xs[i][j];
+      const p = 1 / (1 + Math.exp(-z));
+      const weight = rows[i].y ? weightPos : 1;
+      const error = (p - rows[i].y) * weight;
+      total += weight;
+      for (let j = 0; j < w.length; j += 1) grad[j] += error * xs[i][j];
+      grad[w.length] += error;
+    }
+    for (let j = 0; j <= w.length; j += 1) {
+      const g = grad[j] / total + (j < w.length ? l2 * w[j] : 0);
+      m[j] = 0.9 * m[j] + 0.1 * g;
+      v[j] = 0.999 * v[j] + 0.001 * g * g;
+      const step =
+        (rate * (m[j] / (1 - 0.9 ** epoch))) /
+        (Math.sqrt(v[j] / (1 - 0.999 ** epoch)) + 1e-8);
+      if (j < w.length) w[j] -= step;
+      else b -= step;
+    }
+  }
+  return {
+    features: FEATURES,
+    weights: Array.from(w),
+    bias: b,
+    mean,
+    std,
+    rows: n,
+    positives,
+  };
+}
+
+export function modelScore(model, x) {
+  let z = model.bias;
+  model.features.forEach((name, j) => {
+    z += model.weights[j] * ((x[name] - model.mean[name]) / model.std[name]);
+  });
+  return z;
+}
+
+/** Recall at k of the right files among ranked paths, for one request. */
+export function recallAt(ranked, wanted, k) {
+  if (!wanted.length) return null;
+  const top = new Set(ranked.slice(0, k));
+  return wanted.filter((file) => top.has(file)).length / wanted.length;
+}
+
+export const loadModel = (file) => {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+};
+export function saveModel(file, model) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(`${file}.tmp`, JSON.stringify(model, null, 2));
+  fs.renameSync(`${file}.tmp`, file);
+}

package/lib/live.mjs

@@ -21,10 +21,18 @@ const PLAIN_ID = /^[A-Za-z0-9._:-]{1,128}$/;
 export function processTable() {
   const table = new Map();
   if (process.platform === "win32") return table;
-  const ps = spawnSync(PS, ["-axo", "pid=,ppid=,tty=,comm="], { encoding: "utf8", maxBuffer: 16 << 20 });
+  const ps = spawnSync(PS, ["-axo", "pid=,ppid=,tty=,comm="], {
+    encoding: "utf8",
+    maxBuffer: 16 << 20,
+  });
   for (const line of (ps.stdout || "").split("\n")) {
     const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
-    if (match) table.set(Number(match[1]), { ppid: Number(match[2]), tty: /^ttys?\d+$/.test(match[3]) ? `/dev/${match[3]}` : null, comm: match[4] });
+    if (match)
+      table.set(Number(match[1]), {
+        ppid: Number(match[2]),
+        tty: /^ttys?\d+$/.test(match[3]) ? `/dev/${match[3]}` : null,
+        comm: match[4],
+      });
   }
   return table;
 }
@@ -40,16 +48,40 @@ function underTmux(table, pid) {
   return false;
 }
 
-const run = (command, args) => spawnSync(command, args, { encoding: "utf8", timeout: 3_000 });
+const run = (command, args) =>
+  spawnSync(command, args, { encoding: "utf8", timeout: 3_000 });
 
 /** The tmux pane showing a terminal, and the terminal (app and tty) a tmux client shows it in. */
 export function tmuxPlace(table, tty) {
-  const panes = run("tmux", ["list-panes", "-a", "-F", "#{pane_tty}\t#{session_name}\t#{session_name}:#{window_index}.#{pane_index}"]);
-  const pane = (panes.stdout || "").split("\n").map((line) => line.split("\t")).find(([paneTty]) => paneTty === tty);
+  const panes = run("tmux", [
+    "list-panes",
+    "-a",
+    "-F",
+    "#{pane_tty}\t#{session_name}\t#{session_name}:#{window_index}.#{pane_index}",
+  ]);
+  const pane = (panes.stdout || "")
+    .split("\n")
+    .map((line) => line.split("\t"))
+    .find(([paneTty]) => paneTty === tty);
   if (!pane) return null;
-  const clients = run("tmux", ["list-clients", "-t", pane[1], "-F", "#{client_tty}\t#{client_pid}"]);
-  const [clientTty, clientPid] = (clients.stdout || "").split("\n").filter(Boolean).map((line) => line.split("\t"))[0] ?? [];
-  return { target: pane[2], client: clientPid ? { tty: clientTty || null, host: hostApp(table, Number(clientPid)) } : null };
+  const clients = run("tmux", [
+    "list-clients",
+    "-t",
+    pane[1],
+    "-F",
+    "#{client_tty}\t#{client_pid}",
+  ]);
+  const [clientTty, clientPid] =
+    (clients.stdout || "")
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => line.split("\t"))[0] ?? [];
+  return {
+    target: pane[2],
+    client: clientPid
+      ? { tty: clientTty || null, host: hostApp(table, Number(clientPid)) }
+      : null,
+  };
 }
 
 /** The app a process runs in: the outermost app bundle on its way up to launchd, or null (tmux, ssh, a service). */
@@ -67,7 +99,11 @@ export function hostApp(table, pid) {
 export function workingDirectories(pids) {
   const found = new Map();
   if (!pids.length) return found;
-  const lsof = spawnSync("lsof", ["-a", "-d", "cwd", "-Fpn", "-p", pids.join(",")], { encoding: "utf8" });
+  const lsof = spawnSync(
+    "lsof",
+    ["-a", "-d", "cwd", "-Fpn", "-p", pids.join(",")],
+    { encoding: "utf8" }
+  );
   let pid = null;
   for (const line of (lsof.stdout || "").split("\n")) {
     if (line.startsWith("p")) pid = Number(line.slice(1));
@@ -80,13 +116,29 @@ export function workingDirectories(pids) {
 export function sessionOfProcess(agent, pid, recent = []) {
   if (!Number.isInteger(pid) || pid <= 1) return null;
   if (agent === "claude-code") {
-    const record = readJson(path.join(historyRoots("claude-code")[0], "..", "sessions", `${pid}.json`), null);
-    return record && PLAIN_ID.test(String(record.sessionId || "")) ? record.sessionId : null;
+    const record = readJson(
+      path.join(
+        historyRoots("claude-code")[0],
+        "..",
+        "sessions",
+        `${pid}.json`
+      ),
+      null
+    );
+    return record && PLAIN_ID.test(String(record.sessionId || ""))
+      ? record.sessionId
+      : null;
   }
   if (agent !== "codex") return null;
   const cwd = workingDirectories([pid]).get(pid);
-  const session = cwd ? recent.find((row) => row.agent === "codex" && row.cwd === cwd) : null;
-  return String(session?.session_id || "").match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i)?.[0] ?? null;
+  const session = cwd
+    ? recent.find((row) => row.agent === "codex" && row.cwd === cwd)
+    : null;
+  return (
+    String(session?.session_id || "").match(
+      /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
+    )?.[0] ?? null
+  );
 }
 
 /**
@@ -94,46 +146,123 @@ export function sessionOfProcess(agent, pid, recent = []) {
  * index (Codex keeps no per-process record, so its session is the newest indexed one in the process's folder);
  * `reported` holds the sessions that named their own process ({ agent, sessionId, folder, pid, comm, at }).
  */
-export function liveSessions({ exclude = new Set(), recent = [], table = processTable(), reported = [] } = {}) {
+export function liveSessions({
+  exclude = new Set(),
+  recent = [],
+  table = processTable(),
+  reported = [],
+} = {}) {
   const sessions = [];
   const records = path.join(historyRoots("claude-code")[0], "..", "sessions");
   let files = [];
-  try { files = fs.readdirSync(records).filter((name) => name.endsWith(".json")); } catch {}
+  try {
+    files = fs.readdirSync(records).filter((name) => name.endsWith(".json"));
+  } catch {}
   for (const name of files) {
     const record = readJson(path.join(records, name), null);
-    if (!record?.pid || !table.has(record.pid) || exclude.has(record.pid) || !PLAIN_ID.test(String(record.sessionId || ""))) continue;
+    if (
+      !record?.pid ||
+      !table.has(record.pid) ||
+      exclude.has(record.pid) ||
+      !PLAIN_ID.test(String(record.sessionId || ""))
+    )
+      continue;
     if (record.kind && record.kind !== "interactive") continue;
-    sessions.push({ agent: "claude-code", sessionId: record.sessionId, folder: record.cwd || null, pid: record.pid, entrypoint: record.entrypoint || null,
-      busy: record.status === "busy" ? true : record.status === "idle" ? false : null, at: Number(record.statusUpdatedAt || record.startedAt || 0) });
+    sessions.push({
+      agent: "claude-code",
+      sessionId: record.sessionId,
+      folder: record.cwd || null,
+      pid: record.pid,
+      entrypoint: record.entrypoint || null,
+      busy:
+        record.status === "busy"
+          ? true
+          : record.status === "idle"
+            ? false
+            : null,
+      at: Number(record.statusUpdatedAt || record.startedAt || 0),
+    });
   }
   // A Codex process outside any terminal and app is Codex's own background server (its terminals share it), not a session.
-  const codex = [...table].filter(([pid, row]) => path.basename(row.comm) === "codex" && !exclude.has(pid) && (row.tty || hostApp(table, pid))).map(([pid]) => pid);
+  const codex = [...table]
+    .filter(
+      ([pid, row]) =>
+        path.basename(row.comm) === "codex" &&
+        !exclude.has(pid) &&
+        (row.tty || hostApp(table, pid))
+    )
+    .map(([pid]) => pid);
   const cwds = workingDirectories(codex);
   for (const pid of codex) {
-    const session = recent.find((row) => row.agent === "codex" && row.cwd && row.cwd === cwds.get(pid));
-    const id = String(session?.session_id || "").replace(/\.jsonl$/, "").match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i)?.[0];
-    if (id && !sessions.some((row) => row.sessionId === id)) sessions.push({ agent: "codex", sessionId: id, folder: session.cwd, pid, busy: null, at: Date.parse(session.started_at) || 0 });
+    const session = recent.find(
+      (row) => row.agent === "codex" && row.cwd && row.cwd === cwds.get(pid)
+    );
+    const id = String(session?.session_id || "")
+      .replace(/\.jsonl$/, "")
+      .match(
+        /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
+      )?.[0];
+    if (id && !sessions.some((row) => row.sessionId === id))
+      sessions.push({
+        agent: "codex",
+        sessionId: id,
+        folder: session.cwd,
+        pid,
+        busy: null,
+        at: Date.parse(session.started_at) || 0,
+      });
   }
   // Codex in T3 Code runs on that shared server too, so no process says which T3 thread it works in: T3's own record does.
   const t3 = t3App();
-  if (t3) for (const row of t3Working("codex")) {
-    if (!sessions.some((session) => session.sessionId === row.sessionId)) sessions.push({ agent: "codex", sessionId: row.sessionId, folder: row.folder, pid: null, busy: true, at: row.at, host: { name: t3.name, app: t3.app }, t3Thread: row.thread });
-  }
+  if (t3)
+    for (const row of t3Working("codex")) {
+      if (!sessions.some((session) => session.sessionId === row.sessionId))
+        sessions.push({
+          agent: "codex",
+          sessionId: row.sessionId,
+          folder: row.folder,
+          pid: null,
+          busy: true,
+          at: row.at,
+          host: { name: t3.name, app: t3.app },
+          t3Thread: row.thread,
+        });
+    }
   // A session that said which process it runs in when it started (pi's extension, OpenCode's plugin, any agent's hook):
   // running while that process is, under the same name, so a reused process id is not taken for it.
   for (const row of reported) {
     const now = table.get(row.pid);
-    if (!now || exclude.has(row.pid) || path.basename(now.comm) !== path.basename(String(row.comm || "")) || sessions.some((session) => session.sessionId === row.sessionId)) continue;
-    sessions.push({ agent: row.agent, sessionId: row.sessionId, folder: row.folder || null, pid: row.pid, busy: null, at: row.at || 0 });
-  }
-  return sessions.sort((a, b) => b.at - a.at).map((session) => {
-    const tty = table.get(session.pid)?.tty ?? null;
-    // Inside tmux the app is the terminal a tmux client shows the pane in.
-    const tmux = underTmux(table, session.pid) && tty ? tmuxPlace(table, tty) : null;
-    const host = session.host ?? tmux?.client?.host ?? hostApp(table, session.pid);
-    const t3 = host && /^T3 Code\b/.test(host.name) ? t3Link(session.t3Thread ?? t3Thread(session.sessionId)) : null;
-    return { ...session, tty, tmux: tmux?.target ?? null, host, t3 };
-  });
+    if (
+      !now ||
+      exclude.has(row.pid) ||
+      path.basename(now.comm) !== path.basename(String(row.comm || "")) ||
+      sessions.some((session) => session.sessionId === row.sessionId)
+    )
+      continue;
+    sessions.push({
+      agent: row.agent,
+      sessionId: row.sessionId,
+      folder: row.folder || null,
+      pid: row.pid,
+      busy: null,
+      at: row.at || 0,
+    });
+  }
+  return sessions
+    .sort((a, b) => b.at - a.at)
+    .map((session) => {
+      const tty = table.get(session.pid)?.tty ?? null;
+      // Inside tmux the app is the terminal a tmux client shows the pane in.
+      const tmux =
+        underTmux(table, session.pid) && tty ? tmuxPlace(table, tty) : null;
+      const host =
+        session.host ?? tmux?.client?.host ?? hostApp(table, session.pid);
+      const t3 =
+        host && /^T3 Code\b/.test(host.name)
+          ? t3Link(session.t3Thread ?? t3Thread(session.sessionId))
+          : null;
+      return { ...session, tty, tmux: tmux?.target ?? null, host, t3 };
+    });
 }
 
 /**
@@ -143,36 +272,76 @@ export function liveSessions({ exclude = new Set(), recent = [], table = process
  */
 export function focusTerminal(session, place = null, table = processTable()) {
   let tty = session.tty;
-  const tmux = tty && (session.tmux || place?.tmux) ? tmuxPlace(table, tty) : null;
+  const tmux =
+    tty && (session.tmux || place?.tmux) ? tmuxPlace(table, tty) : null;
   if (tmux) {
     run("tmux", ["select-window", "-t", tmux.target]);
     run("tmux", ["select-pane", "-t", tmux.target]);
     tty = tmux.client?.tty ?? null;
   }
-  if (place?.wezterm || (session.host && /^WezTerm$/i.test(session.host.name))) {
+  if (
+    place?.wezterm ||
+    (session.host && /^WezTerm$/i.test(session.host.name))
+  ) {
     let pane = place?.wezterm ?? null;
-    if (!pane) try { pane = JSON.parse(run("wezterm", ["cli", "list", "--format", "json"]).stdout || "[]").find((entry) => entry.tty_name === session.tty)?.pane_id ?? null; } catch {}
-    if (pane != null) run("wezterm", ["cli", "activate-pane", "--pane-id", String(pane)]);
+    if (!pane)
+      try {
+        pane =
+          JSON.parse(
+            run("wezterm", ["cli", "list", "--format", "json"]).stdout || "[]"
+          ).find((entry) => entry.tty_name === session.tty)?.pane_id ?? null;
+      } catch {}
+    if (pane != null)
+      run("wezterm", ["cli", "activate-pane", "--pane-id", String(pane)]);
   }
   if (place?.kitty || (session.host && /^kitty$/i.test(session.host.name))) {
     const to = place?.kitty?.socket ? ["--to", place.kitty.socket] : [];
-    run("kitty", ["@", ...to, "focus-window", "--match", place?.kitty ? `id:${place.kitty.id}` : `pid:${session.pid}`]);
+    run("kitty", [
+      "@",
+      ...to,
+      "focus-window",
+      "--match",
+      place?.kitty ? `id:${place.kitty.id}` : `pid:${session.pid}`,
+    ]);
   }
   return session.host ? { app: session.host.app, tty } : {};
 }
 
 const FEED_BYTES = 768 << 10;
-const promptText = (content) => typeof content === "string" ? content
-  : Array.isArray(content) ? content.filter((block) => ["text", "input_text"].includes(block?.type) && typeof block.text === "string").map((block) => block.text).join("\n") : "";
+const promptText = (content) =>
+  typeof content === "string"
+    ? content
+    : Array.isArray(content)
+      ? content
+          .filter(
+            (block) =>
+              ["text", "input_text"].includes(block?.type) &&
+              typeof block.text === "string"
+          )
+          .map((block) => block.text)
+          .join("\n")
+      : "";
 // What the agent itself was handed (instructions, environment, hook output), not words the person typed.
-const machinery = (text) => !text.trim() || /^\s*<[a-z_-]+[\s>]/i.test(text) || text.startsWith("Caveat:");
+const machinery = (text) =>
+  !text.trim() ||
+  /^\s*<[a-z_-]+[\s>]/i.test(text) ||
+  text.startsWith("Caveat:");
 
 /** A session's own file: the index's source, else Claude Code's projects folder for its working folder. */
 export function sessionFile(agent, sessionId, folder, recent = []) {
-  const row = recent.find((entry) => entry.agent === agent && String(entry.session_id).includes(sessionId) && entry.source);
+  const row = recent.find(
+    (entry) =>
+      entry.agent === agent &&
+      String(entry.session_id).includes(sessionId) &&
+      entry.source
+  );
   if (row && fs.existsSync(row.source)) return row.source;
   if (agent === "claude-code" && folder && PLAIN_ID.test(sessionId)) {
-    const file = path.join(historyRoots("claude-code")[0], folder.replace(/[^a-zA-Z0-9]/g, "-"), `${sessionId}.jsonl`);
+    const file = path.join(
+      historyRoots("claude-code")[0],
+      folder.replace(/[^a-zA-Z0-9]/g, "-"),
+      `${sessionId}.jsonl`
+    );
     if (fs.existsSync(file)) return file;
   }
   return null;
@@ -181,15 +350,37 @@ export function sessionFile(agent, sessionId, folder, recent = []) {
 /** OpenCode's session as the person reads it: OpenCode keeps sessions in its own database, so `opencode export` reads it. */
 export function opencodeFeed(command, sessionId, limit = 80) {
   if (!PLAIN_ID.test(String(sessionId))) return [];
-  const exported = spawnSync(command, ["export", String(sessionId)], { encoding: "utf8", timeout: 20_000, maxBuffer: 64 << 20, stdio: ["ignore", "pipe", "ignore"] });
+  const exported = spawnSync(command, ["export", String(sessionId)], {
+    encoding: "utf8",
+    timeout: 20_000,
+    maxBuffer: 64 << 20,
+    stdio: ["ignore", "pipe", "ignore"],
+  });
   let session;
-  try { session = JSON.parse(exported.stdout); } catch { return []; }
+  try {
+    session = JSON.parse(exported.stdout);
+  } catch {
+    return [];
+  }
   const items = [];
-  for (const message of Array.isArray(session?.messages) ? session.messages : []) {
-    const at = message.info?.time?.created ? new Date(message.info.time.created).toISOString() : null;
+  for (const message of Array.isArray(session?.messages)
+    ? session.messages
+    : []) {
+    const at = message.info?.time?.created
+      ? new Date(message.info.time.created).toISOString()
+      : null;
     for (const part of Array.isArray(message.parts) ? message.parts : []) {
-      if (message.info?.role === "user") { if (part.type === "text" && !part.synthetic && !machinery(String(part.text || ""))) items.push({ kind: "you", text: String(part.text).trim(), at }); }
-      else items.push(...stepsOf({ type: part.type, part }).map((step) => ({ ...step, at })));
+      if (message.info?.role === "user") {
+        if (
+          part.type === "text" &&
+          !part.synthetic &&
+          !machinery(String(part.text || ""))
+        )
+          items.push({ kind: "you", text: String(part.text).trim(), at });
+      } else
+        items.push(
+          ...stepsOf({ type: part.type, part }).map((step) => ({ ...step, at }))
+        );
     }
   }
   return items.slice(-limit);
@@ -209,26 +400,60 @@ export function sessionFeed(agent, file, limit = 80) {
     fs.closeSync(handle);
     text = buffer.toString("utf8");
     if (size > buffer.length) text = text.slice(text.indexOf("\n") + 1);
-  } catch { return []; }
+  } catch {
+    return [];
+  }
   const items = [];
   for (const line of text.split("\n")) {
     if (!line.startsWith("{")) continue;
     let row;
-    try { row = JSON.parse(line); } catch { continue; }
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
     const at = row.timestamp || null;
     if (agent === "claude-code") {
       if (row.type === "user" && !row.isMeta) {
         const said = promptText(row.message?.content);
-        if (!machinery(said)) items.push({ kind: "you", text: said.trim(), at });
-      } else if (row.type === "assistant") items.push(...stepsOf(row).map((step) => ({ ...step, at })));
+        if (!machinery(said))
+          items.push({ kind: "you", text: said.trim(), at });
+      } else if (row.type === "assistant")
+        items.push(...stepsOf(row).map((step) => ({ ...step, at })));
     } else if (agent === "codex" && row.type === "response_item") {
       const item = row.payload || {};
-      if (item.type === "message" && item.role === "user") { const said = promptText(item.content); if (!machinery(said)) items.push({ kind: "you", text: said.trim(), at }); }
-      else if (item.type === "message" && item.role === "assistant") { const said = (item.content || []).map((block) => block?.text || "").join("\n").trim(); if (said) items.push({ kind: "say", text: said, at }); }
-      else if (item.type === "function_call" || item.type === "custom_tool_call") items.push({ kind: "do", text: `${item.name}: ${String(item.arguments ?? item.input ?? "").replace(/\s+/g, " ").slice(0, 200)}`, at });
+      if (item.type === "message" && item.role === "user") {
+        const said = promptText(item.content);
+        if (!machinery(said))
+          items.push({ kind: "you", text: said.trim(), at });
+      } else if (item.type === "message" && item.role === "assistant") {
+        const said = (item.content || [])
+          .map((block) => block?.text || "")
+          .join("\n")
+          .trim();
+        if (said) items.push({ kind: "say", text: said, at });
+      } else if (
+        item.type === "function_call" ||
+        item.type === "custom_tool_call"
+      )
+        items.push({
+          kind: "do",
+          text: `${item.name}: ${String(item.arguments ?? item.input ?? "")
+            .replace(/\s+/g, " ")
+            .slice(0, 200)}`,
+          at,
+        });
     } else if (agent === "pi" && row.type === "message" && row.message) {
-      if (row.message.role === "user") { const said = promptText(row.message.content); if (!machinery(said)) items.push({ kind: "you", text: said.trim(), at }); }
-      else if (row.message.role === "assistant") items.push(...stepsOf({ type: "message_end", message: row.message }).map((step) => ({ ...step, at })));
+      if (row.message.role === "user") {
+        const said = promptText(row.message.content);
+        if (!machinery(said))
+          items.push({ kind: "you", text: said.trim(), at });
+      } else if (row.message.role === "assistant")
+        items.push(
+          ...stepsOf({ type: "message_end", message: row.message }).map(
+            (step) => ({ ...step, at })
+          )
+        );
     }
   }
   return items.slice(-limit);