tryharness 0.3.0 → 0.4.0

package/lib/daemon.mjs

@@ -0,0 +1,339 @@
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import WebSocket from "ws";
+import { randomBytes, randomUUID } from "node:crypto";
+import { detectAgents, run } from "./commands.mjs";
+import { appendLog, ensureDir, listJsonl, readJson, tailFile, writeJsonAtomic } from "./files.mjs";
+import { historyRoots, paths } from "./paths.mjs";
+import { openStore } from "./store.mjs";
+import { runAgentTask } from "./runner.mjs";
+
+const DAEMON_VERSION = "0.4.0";
+const PROTOCOL_VERSION = 1;
+const RESCAN_MS = 60_000;
+
+export async function startDaemon() {
+  ensureDir(paths.home);
+  const config = readJson(paths.config, {});
+  if (!config.origin || !config.token) throw new Error("Harness is not paired. Run: npx tryharness");
+  const store = openStore(paths.database);
+  const detected = detectAgents();
+  const installedAgents = detected.filter((entry) => entry.path).map((entry) => entry.agent);
+  const state = {
+    version: DAEMON_VERSION,
+    protocolVersion: PROTOCOL_VERSION,
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    connected: false,
+    indexing: false,
+    lastIndexedAt: null,
+    lastError: null,
+    agents: detected.map((entry) => ({ agent: entry.agent, installed: Boolean(entry.path), configured: config.agentStates?.[entry.agent]?.configured === true, path: entry.path || null })),
+    counts: store.counts(),
+  };
+  const saveStatus = () => {
+    state.counts = store.counts();
+    writeJsonAtomic(paths.status, state);
+  };
+  const log = (message) => { appendLog(paths.log, message); };
+  saveStatus();
+  log(`daemon ${DAEMON_VERSION} starting; agents=${installedAgents.join(",") || "none"}`);
+
+  const opencodeExecutable = detected.find((entry) => entry.agent === "opencode")?.path || null;
+  let opencodeProcess = null;
+  let opencodeBase = null;
+  let opencodeStarting = null;
+  let opencodeAuthorization = null;
+  function ensureOpencodeHelper() {
+    if (!opencodeExecutable) return Promise.resolve(null);
+    if (opencodeProcess && opencodeBase && opencodeAuthorization) {
+      return Promise.resolve({ base: opencodeBase, authorization: opencodeAuthorization });
+    }
+    if (opencodeStarting) return opencodeStarting;
+    opencodeStarting = new Promise((resolve) => {
+      const username = "tryharness";
+      const password = randomBytes(32).toString("base64url");
+      const authorization = "Basic " + Buffer.from(`${username}:${password}`).toString("base64");
+      const child = spawn(opencodeExecutable, ["serve", "--port", "0", "--hostname", "127.0.0.1", "--pure"], {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, OPENCODE_SERVER_USERNAME: username, OPENCODE_SERVER_PASSWORD: password },
+      });
+      opencodeProcess = child;
+      let output = "";
+      let settled = false;
+      const finish = (value) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        opencodeStarting = null;
+        resolve(value);
+      };
+      const inspect = (chunk) => {
+        output = (output + String(chunk)).slice(-4_000);
+        const match = output.match(/opencode server listening on (http:\/\/127\.0\.0\.1:\d+)/);
+        if (!match) return;
+        opencodeBase = match[1];
+        opencodeAuthorization = authorization;
+        finish({ base: opencodeBase, authorization });
+      };
+      child.stdout.on("data", inspect);
+      child.stderr.on("data", inspect);
+      child.on("error", (error) => { log(`opencode helper failed: ${error.message}`); finish(null); });
+      child.on("exit", (code) => {
+        if (code && code !== 0) log(`opencode helper exited with code ${code}`);
+        if (opencodeProcess === child) {
+          opencodeProcess = null;
+          opencodeBase = null;
+          opencodeAuthorization = null;
+        }
+        finish(null);
+      });
+      const timer = setTimeout(() => {
+        log("opencode helper did not become ready in 5 seconds");
+        try { child.kill(); } catch {}
+        finish(null);
+      }, 5_000);
+    });
+    return opencodeStarting;
+  }
+
+  let syncRunning = false;
+  let syncAgain = false;
+  let targetedOpencode = [];
+  async function indexFile(agent, item) {
+    const sessionId = path.basename(item.file);
+    if (!store.needsIndex(agent, sessionId, item.mtime, item.size)) return false;
+    const raw = tailFile(item.file);
+    store.indexRaw({ agent, sessionId, source: item.file, raw, mtime: item.mtime, size: item.size });
+    return true;
+  }
+
+  async function readOpencodeSession(sessionId, cwd) {
+    const query = cwd ? `?directory=${encodeURIComponent(cwd)}` : "";
+    try {
+      const helper = await ensureOpencodeHelper();
+      if (!helper) return false;
+      const headers = { authorization: helper.authorization };
+      const infoResponse = await fetch(`${helper.base}/session/${encodeURIComponent(sessionId)}${query}`, { headers, signal: AbortSignal.timeout(5_000) });
+      if (!infoResponse.ok) return false;
+      const info = await infoResponse.json();
+      const updated = info?.updated ?? info?.time?.updated;
+      const parsedMtime = typeof updated === "number" ? updated : typeof updated === "string" ? Date.parse(updated) : NaN;
+      const mtime = Number.isFinite(parsedMtime) ? parsedMtime : Date.now();
+      if (!store.needsIndex("opencode", sessionId, mtime, 0)) return false;
+      const messagesResponse = await fetch(`${helper.base}/session/${encodeURIComponent(sessionId)}/message${query}`, { headers, signal: AbortSignal.timeout(15_000) });
+      if (!messagesResponse.ok) return false;
+      const messages = await messagesResponse.json();
+      const raw = JSON.stringify({ info, messages });
+      store.indexRaw({ agent: "opencode", sessionId, source: `opencode:${sessionId}`, raw, cwd: cwd || info?.directory, mtime, size: 0 });
+      return true;
+    } catch { return false; }
+  }
+
+  async function sync(agentFilter = null) {
+    if (syncRunning) { syncAgain = true; return; }
+    syncRunning = true;
+    state.indexing = true;
+    saveStatus();
+    try {
+      for (const agent of ["claude-code", "codex", "pi"]) {
+        if (!installedAgents.includes(agent) || (agentFilter && agentFilter !== agent)) continue;
+        const files = historyRoots(agent).flatMap(listJsonl).sort((a, b) => b.mtime - a.mtime);
+        for (const item of files) {
+          try { await indexFile(agent, item); }
+          catch (error) { log(`index ${agent} ${item.file}: ${error.message}`); }
+          await new Promise((resolve) => setImmediate(resolve));
+        }
+      }
+      if (installedAgents.includes("opencode") && (!agentFilter || agentFilter === "opencode")) {
+        const requested = targetedOpencode.splice(0);
+        if (requested.length) {
+          for (const item of requested) await readOpencodeSession(item.sessionId, item.cwd);
+        } else {
+          const listed = run("opencode", ["session", "list", "-n", "500", "--format", "json"], { timeout: 20_000, maxBuffer: 20_000_000 });
+          if (listed.ok) {
+            let rows = [];
+            try { rows = JSON.parse(listed.stdout); } catch {}
+            for (const row of Array.isArray(rows) ? rows : []) if (row?.id) await readOpencodeSession(row.id, row.directory);
+          }
+        }
+      }
+      state.lastIndexedAt = new Date().toISOString();
+      state.lastError = null;
+    } catch (error) {
+      state.lastError = error.message;
+      log(`sync failed: ${error.stack || error.message}`);
+    } finally {
+      state.indexing = false;
+      syncRunning = false;
+      saveStatus();
+      if (syncAgain) { syncAgain = false; setImmediate(() => void sync()); }
+    }
+  }
+
+  function sourceRaw(agent, sessionId) {
+    const row = store.findSource(agent, sessionId);
+    if (!row?.source || row.source.startsWith("opencode:")) return null;
+    try { return { raw: tailFile(row.source, 800_000), cwd: row.cwd || undefined }; } catch { return null; }
+  }
+
+  if (process.platform !== "win32") {
+    try { if (fs.existsSync(paths.socket)) fs.unlinkSync(paths.socket); } catch {}
+  }
+  const control = net.createServer((socket) => {
+    socket.setEncoding("utf8");
+    let buffer = "";
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      const newline = buffer.indexOf("\n");
+      if (newline < 0) return;
+      let request;
+      try { request = JSON.parse(buffer.slice(0, newline)); }
+      catch { socket.end(JSON.stringify({ ok: false, error: "invalid request" }) + "\n"); return; }
+      const reply = (value) => socket.end(JSON.stringify(value) + "\n");
+      if (request.command === "status") reply({ ok: true, ...state, counts: store.counts() });
+      else if (request.command === "doctor") reply({ ok: true, status: state, database: paths.database, socket: paths.socket, log: paths.log });
+      else if (request.command === "sync") {
+        if (request.agent === "opencode" && request.sessionId) targetedOpencode.push(request);
+        void sync(request.agent && request.agent !== "all" ? request.agent : null);
+        reply({ ok: true, accepted: true, indexing: true });
+      } else if (request.command === "handoffs.create") {
+        const id = request.id || randomUUID();
+        store.addHandoff({ id, targetAgent: request.agent, targetSessionId: request.sessionId, title: request.title || "Harness handoff", body: request.body || "", source: request.source });
+        reply({ ok: true, id });
+      } else if (request.command === "handoffs.list") reply({ ok: true, handoffs: store.listHandoffs(request.agent) });
+      else if (request.command === "handoffs.get") {
+        const handoff = store.getHandoff(request.id, request.consume === true);
+        reply(handoff && handoff.target_agent === request.agent ? { ok: true, handoff } : { ok: false, error: "handoff not found" });
+      } else if (request.command === "shutdown") {
+        reply({ ok: true, shuttingDown: true });
+        setTimeout(shutdown, 25);
+      } else reply({ ok: false, error: "unknown command" });
+    });
+  });
+  await new Promise((resolve, reject) => {
+    control.once("error", reject);
+    control.listen(paths.socket, () => { control.off("error", reject); resolve(); });
+  });
+  if (process.platform !== "win32") try { fs.chmodSync(paths.socket, 0o600); } catch {}
+
+  let socket = null;
+  let retry = 1_000;
+  let reconnectTimer = null;
+  const send = (message) => {
+    try { if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message)); } catch {}
+  };
+  const scheduleReconnect = () => {
+    if (reconnectTimer) return;
+    const delay = Math.round(retry * (0.8 + Math.random() * 0.4));
+    retry = Math.min(30_000, retry * 2);
+    reconnectTimer = setTimeout(() => { reconnectTimer = null; connect(); }, delay);
+  };
+  const connect = () => {
+    try {
+      const origin = new URL(config.origin);
+      origin.protocol = origin.protocol === "https:" ? "wss:" : "ws:";
+      origin.pathname = "/api/bridge/ws";
+      origin.search = "";
+      socket = new WebSocket(origin, { headers: { authorization: "Bearer " + config.token } });
+      socket.on("open", () => {
+        retry = 1_000;
+        state.connected = true;
+        state.lastError = null;
+        saveStatus();
+        send({ type: "hello", protocolVersion: PROTOCOL_VERSION, daemonVersion: DAEMON_VERSION, agents: installedAgents, health: state.agents, capabilities: ["sessions.search", "sessions.read", "tasks.run", "handoffs.put", "handoffs.read"] });
+      });
+      socket.on("message", (data) => {
+        let message;
+        try { message = JSON.parse(String(data)); } catch { return; }
+        if (message.type === "pong") return;
+        if (message.type === "sync") { void sync(); return; }
+        if (message.type === "fetch_session") {
+          const result = sourceRaw(message.agent, message.session_id);
+          send({ type: "fetch_session_result", fetchId: message.fetchId, ...(result || {}) });
+          return;
+        }
+        if (message.type === "search_sessions") {
+          try { send({ type: "bridge_response", requestId: message.requestId, ok: true, result: store.search(message.input || {}) }); }
+          catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
+          return;
+        }
+        if (message.type === "read_session") {
+          try { send({ type: "bridge_response", requestId: message.requestId, ok: true, result: store.read(message.input || {}) }); }
+          catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
+          return;
+        }
+        if (message.type === "handoffs_list") {
+          try { send({ type: "bridge_response", requestId: message.requestId, ok: true, result: { handoffs: store.listHandoffs(message.input?.agent) } }); }
+          catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
+          return;
+        }
+        if (message.type === "handoffs_get") {
+          try {
+            const handoff = store.getHandoff(message.input?.id, message.input?.consume === true);
+            send({ type: "bridge_response", requestId: message.requestId, ok: Boolean(handoff), result: handoff ? { handoff } : null });
+          } catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
+          return;
+        }
+        if (message.type === "handoff") {
+          try {
+            store.addHandoff({ id: message.handoff?.id || randomUUID(), targetAgent: message.handoff?.agent, targetSessionId: message.handoff?.sessionId, title: message.handoff?.title || "Harness handoff", body: message.handoff?.body || "", source: message.handoff?.source });
+            send({ type: "bridge_response", requestId: message.requestId, ok: true, result: { stored: true } });
+          } catch (error) { send({ type: "bridge_response", requestId: message.requestId, ok: false, error: error.message }); }
+          return;
+        }
+        if (message.type === "task") {
+          runAgentTask(message, (kind, text, extra) => send({ type: "event", runId: message.runId, kind, ...(text ? { text } : {}), ...(extra || {}) }));
+        }
+      });
+      const dropped = (error) => {
+        state.connected = false;
+        if (error?.message) state.lastError = error.message;
+        saveStatus();
+        scheduleReconnect();
+      };
+      socket.on("close", () => dropped());
+      socket.on("error", dropped);
+    } catch (error) {
+      state.connected = false;
+      state.lastError = error.message;
+      saveStatus();
+      scheduleReconnect();
+    }
+  };
+  connect();
+  const heartbeat = setInterval(() => send({ type: "ping" }), 30_000);
+  const rescan = setInterval(() => void sync(), RESCAN_MS);
+  const watchers = [];
+  for (const agent of ["claude-code", "codex", "pi"]) {
+    if (!installedAgents.includes(agent)) continue;
+    for (const root of historyRoots(agent)) {
+      try {
+        const watcher = fs.watch(root, { recursive: process.platform === "darwin" || process.platform === "win32" }, () => {
+          clearTimeout(watcher._harnessTimer);
+          watcher._harnessTimer = setTimeout(() => void sync(agent), 1_000);
+        });
+        watchers.push(watcher);
+      } catch {}
+    }
+  }
+  setImmediate(() => void sync());
+
+  const shutdown = () => {
+    clearInterval(heartbeat);
+    clearInterval(rescan);
+    for (const watcher of watchers) watcher.close();
+    try { socket?.close(); } catch {}
+    try { opencodeProcess?.kill(); } catch {}
+    control.close();
+    store.close();
+    if (process.platform !== "win32") try { fs.unlinkSync(paths.socket); } catch {}
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  process.on("uncaughtException", (error) => { log(`uncaught: ${error.stack || error.message}`); shutdown(); });
+  process.on("unhandledRejection", (error) => { log(`unhandled: ${error?.stack || error}`); });
+}

package/lib/files.mjs

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  try { fs.chmodSync(dir, 0o700); } catch {}
+}
+
+export function readJson(file, fallback = {}) {
+  try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return fallback; }
+}
+
+export function writeJsonAtomic(file, value, mode = 0o600) {
+  ensureDir(path.dirname(file));
+  const temporary = `${file}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(temporary, JSON.stringify(value, null, 2) + "\n", { mode });
+  fs.renameSync(temporary, file);
+  try { fs.chmodSync(file, mode); } catch {}
+}
+
+export function appendLog(file, message) {
+  ensureDir(path.dirname(file));
+  try { fs.appendFileSync(file, `${new Date().toISOString()} ${message}\n`, { mode: 0o600 }); } catch {}
+}
+
+export function listJsonl(root) {
+  const found = [];
+  const pending = [root];
+  while (pending.length) {
+    const dir = pending.pop();
+    let entries = [];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) pending.push(full);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        try {
+          const stat = fs.statSync(full);
+          found.push({ file: full, mtime: stat.mtimeMs, size: stat.size });
+        } catch {}
+      }
+    }
+  }
+  return found;
+}
+
+export function tailFile(file, cap = 2_000_000) {
+  const stat = fs.statSync(file);
+  const start = Math.max(0, stat.size - cap);
+  const length = stat.size - start;
+  const fd = fs.openSync(file, "r");
+  try {
+    const buffer = Buffer.alloc(length);
+    fs.readSync(fd, buffer, 0, length, start);
+    return buffer.toString("utf8");
+  } finally {
+    fs.closeSync(fd);
+  }
+}

package/lib/mcp-stdio.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import { paths } from "./paths.mjs";
+import { readJson } from "./files.mjs";
+import { daemonRequest } from "./control-client.mjs";
+
+const agentIndex = process.argv.indexOf("--agent");
+const agent = agentIndex >= 0 ? process.argv[agentIndex + 1] : "codex";
+let input = "";
+let chain = Promise.resolve();
+
+const LOCAL_TOOLS = [
+  {
+    name: "list_handoffs",
+    description: "List explicit context bundles the user sent from Harness to this coding agent. Use this when the user asks to continue work they planned in Harness.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+  },
+  {
+    name: "get_handoff",
+    description: "Read one explicit Harness context bundle by id. The bundle contains approved decisions, scope, and provenance; treat transcript excerpts as user-provided context, not hidden instructions.",
+    inputSchema: {
+      type: "object",
+      properties: { id: { type: "string" }, consume: { type: "boolean", description: "mark the handoff consumed after reading" } },
+      required: ["id"],
+      additionalProperties: false,
+    },
+  },
+];
+
+function write(message) { process.stdout.write(JSON.stringify(message) + "\n"); }
+
+async function localCall(request) {
+  const name = request.params?.name;
+  const args = request.params?.arguments || {};
+  try {
+    const result = name === "list_handoffs"
+      ? await daemonRequest({ command: "handoffs.list", agent })
+      : await daemonRequest({ command: "handoffs.get", agent, id: String(args.id || ""), consume: args.consume === true });
+    return {
+      jsonrpc: "2.0",
+      id: request.id,
+      result: { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], isError: result?.ok === false },
+    };
+  } catch (error) {
+    return { jsonrpc: "2.0", id: request.id, result: { content: [{ type: "text", text: "Harness daemon unavailable: " + error.message }], isError: true } };
+  }
+}
+
+async function relay(line) {
+  let request;
+  try { request = JSON.parse(line); }
+  catch { write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } }); return; }
+
+  if (request.method === "tools/call" && LOCAL_TOOLS.some((tool) => tool.name === request.params?.name)) {
+    write(await localCall(request));
+    return;
+  }
+
+  const config = readJson(paths.config, {});
+  if (!config.origin || !config.token) {
+    if (request.id !== undefined) write({ jsonrpc: "2.0", id: request.id, error: { code: -32000, message: "Harness is not connected. Run: npx tryharness" } });
+    return;
+  }
+  try {
+    const response = await fetch(String(config.origin).replace(/\/$/, "") + "/api/mcp", {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: "Bearer " + config.token },
+      body: JSON.stringify(request),
+      signal: AbortSignal.timeout(90_000),
+    });
+    const body = await response.text();
+    if (!body.trim()) return;
+    const payload = JSON.parse(body);
+    if (request.method === "tools/list" && Array.isArray(payload?.result?.tools)) {
+      const existing = new Set(payload.result.tools.map((tool) => tool?.name));
+      payload.result.tools.push(...LOCAL_TOOLS.filter((tool) => !existing.has(tool.name)));
+    }
+    write(payload);
+  } catch (error) {
+    if (request.id !== undefined) write({ jsonrpc: "2.0", id: request.id, error: { code: -32000, message: "Harness is unreachable: " + error.message } });
+  }
+}
+
+// MCP stdio uses one JSON-RPC object per line. Requests stay ordered so initialize and
+// tools/list cannot race on clients that send them back-to-back.
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  input += chunk;
+  const lines = input.split("\n");
+  input = lines.pop() || "";
+  for (const line of lines) if (line.trim()) chain = chain.then(() => relay(line)).catch(() => undefined);
+});
+
+// Keep a hard reference so aggressive package analysis does not mistake config access
+// for dead code when building the persistent runtime.
+void fs;

package/lib/parsers.mjs

@@ -0,0 +1,162 @@
+// Fail-open normalizers for the four supported agents. The daemon owns this copy so
+// indexing never depends on a Harness tab or on code downloaded after installation.
+
+const TITLE_MAX = 120;
+const TOOL_INPUT_CLIP = 100;
+const TOOL_RESULT_CLIP = 200;
+
+function parseLines(text) {
+  const rows = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const value = JSON.parse(line);
+      if (value && typeof value === "object") rows.push(value);
+    } catch {}
+  }
+  return rows;
+}
+
+function compact(value, cap) {
+  if (value === undefined || value === null) return "";
+  try {
+    const text = (typeof value === "string" ? value : JSON.stringify(value)).replace(/\s+/g, " ").trim();
+    if (!text || text === "{}" || text === "[]") return "";
+    return text.length > cap ? text.slice(0, cap) + "…" : text;
+  } catch { return ""; }
+}
+
+function contentText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    if (typeof block.text === "string" && ["text", "input_text", "output_text"].includes(block.type)) {
+      parts.push(block.text);
+    } else if (["tool_use", "toolCall"].includes(block.type) && typeof block.name === "string") {
+      const detail = compact(block.input, TOOL_INPUT_CLIP);
+      parts.push(detail ? `[tool: ${block.name} ${detail}]` : `[tool: ${block.name}]`);
+    } else if (block.type === "tool_result") {
+      const detail = compact(block.content, TOOL_RESULT_CLIP);
+      parts.push(detail ? `[tool result: ${detail}]` : "[tool result]");
+    }
+  }
+  return parts.join("\n").trim();
+}
+
+function parseClaude(text) {
+  const records = parseLines(text).filter((row) => row.type === "user" || row.type === "assistant");
+  const byId = new Map(records.filter((row) => typeof row.uuid === "string").map((row) => [row.uuid, row]));
+  const chain = [];
+  const seen = new Set();
+  let cursor = records.at(-1);
+  while (cursor) {
+    if (typeof cursor.uuid === "string") {
+      if (seen.has(cursor.uuid)) break;
+      seen.add(cursor.uuid);
+    }
+    chain.unshift(cursor);
+    cursor = typeof cursor.parentUuid === "string" ? byId.get(cursor.parentUuid) : undefined;
+  }
+  const source = chain.length >= records.length / 2 ? chain : records;
+  const messages = source.flatMap((row) => {
+    const textValue = contentText(row.message?.content);
+    return textValue ? [{ role: row.type === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null }] : [];
+  });
+  return {
+    meta: {
+      cwd: typeof records[0]?.cwd === "string" ? records[0].cwd : null,
+      startedAt: typeof records[0]?.timestamp === "string" ? records[0].timestamp : null,
+      endedAt: typeof records.at(-1)?.timestamp === "string" ? records.at(-1).timestamp : null,
+    },
+    messages,
+  };
+}
+
+function parseCodex(text) {
+  const records = parseLines(text);
+  const meta = records.find((row) => row.type === "session_meta")?.payload || {};
+  const messages = records.flatMap((row) => {
+    const payload = row.type === "response_item" ? row.payload : null;
+    if (!payload || payload.type !== "message") return [];
+    const textValue = contentText(payload.content);
+    return textValue ? [{ role: payload.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null }] : [];
+  });
+  const timestamps = records.map((row) => row.timestamp).filter((value) => typeof value === "string");
+  return {
+    meta: {
+      cwd: typeof meta.cwd === "string" ? meta.cwd : null,
+      startedAt: timestamps[0] || null,
+      endedAt: timestamps.at(-1) || null,
+    },
+    messages,
+  };
+}
+
+function parsePi(text) {
+  const records = parseLines(text);
+  const header = records.find((row) => row.type === "session") || {};
+  const messages = records.flatMap((row) => {
+    if (row.type !== "message") return [];
+    const textValue = contentText(row.message?.content);
+    return textValue ? [{ role: row.message?.role === "user" ? "user" : "agent", text: textValue, ts: typeof row.timestamp === "string" ? row.timestamp : null }] : [];
+  });
+  return {
+    meta: {
+      cwd: typeof header.cwd === "string" ? header.cwd : null,
+      startedAt: typeof header.timestamp === "string" ? header.timestamp : null,
+      endedAt: messages.at(-1)?.ts || null,
+    },
+    messages,
+  };
+}
+
+function asIso(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return new Date(value).toISOString();
+  return null;
+}
+
+function parseOpencode(text) {
+  let envelope = {};
+  try { envelope = JSON.parse(text); } catch {}
+  const info = envelope.info || envelope.session || {};
+  const messages = (Array.isArray(envelope.messages) ? envelope.messages : []).flatMap((entry) => {
+    const messageInfo = entry?.info || entry?.message || {};
+    const textValue = contentText(entry?.parts || messageInfo.content);
+    const time = messageInfo.time || {};
+    return textValue ? [{
+      role: messageInfo.role === "user" ? "user" : "agent",
+      text: textValue,
+      ts: asIso(messageInfo.timestamp ?? time.created ?? time.start),
+    }] : [];
+  });
+  const time = info.time || {};
+  return {
+    meta: {
+      cwd: typeof info.directory === "string" ? info.directory : typeof info.cwd === "string" ? info.cwd : null,
+      startedAt: asIso(info.created ?? time.created) || messages[0]?.ts || null,
+      endedAt: asIso(info.updated ?? time.updated) || messages.at(-1)?.ts || null,
+    },
+    messages,
+  };
+}
+
+const PARSERS = { "claude-code": parseClaude, codex: parseCodex, pi: parsePi, opencode: parseOpencode };
+
+export function parseSession(agent, raw) {
+  const parser = PARSERS[agent];
+  if (!parser) throw new Error(`unsupported agent: ${agent}`);
+  const { meta, messages } = parser(raw);
+  const firstUser = messages.find((message) => message.role === "user" && !message.text.startsWith("[") && message.text.trim().length > 2)
+    || messages.find((message) => message.role === "user");
+  return {
+    meta: {
+      ...meta,
+      title: (firstUser?.text || "").replace(/\s+/g, " ").trim().slice(0, TITLE_MAX),
+      messageCount: messages.length,
+    },
+    transcript: messages.map((message) => `${message.role === "user" ? "User" : "Agent"}: ${message.text}`).join("\n\n").slice(0, 400_000),
+  };
+}