@agentsky/sky 2.20.2 → 2.21.0

package/vendor/trace-collect/sinks/agentsky.mjs

@@ -0,0 +1,156 @@
+// AgentSky workspace trace library (docs/asteroids/architecture/trace-library.md in SkillBoss-AI/guild).
+// Uses the `sky` CLI's login and its trace-sync routing, so a session lands in the same workspace `sky trace sync`
+// would pick. Claude Code and Codex are skipped while `sky trace sync` is on: it already uploads them.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+
+const SKY = () => process.env.SKY_CONFIG_DIR ?? path.join(os.homedir(), ".config", "sky");
+const readJson = (p, d) => { try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return d; } };
+const skyConfig = () => readJson(path.join(SKY(), "config.json"), {});
+const syncConfig = () => readJson(path.join(SKY(), "trace-sync.json"), { enabled: false, rules: [] });
+const token = () => process.env.SKY_API_TOKEN ?? skyConfig().token;
+const apiBase = () => (process.env.SKY_API_URL ?? skyConfig().apiBase ?? "https://api.agentsky.dev/v1").replace(/\/$/, "");
+
+// Same limits the device side of `sky trace sync` applies.
+const MESSAGE_MAX = 8 * 1024, TOOL_MAX = 2 * 1024, MESSAGES_MAX = 20_000, BODY_MAX = 7 * 1024 * 1024, CHECK_BATCH = 200, CONCURRENCY = 4;
+const SKY_HARNESS = { "claude-code": "claude_code", codex: "codex" };
+
+function up(dir, fn) { for (let d = dir; d && d !== path.dirname(d); d = path.dirname(d)) { const r = fn(d); if (r !== undefined) return r; } }
+function remoteOf(cwd) {
+  return up(cwd, (d) => {
+    if (!fs.existsSync(path.join(d, ".git"))) return undefined;
+    let cfg = path.join(d, ".git", "config");
+    try { if (!fs.statSync(path.join(d, ".git")).isDirectory()) { const g = fs.readFileSync(path.join(d, ".git"), "utf8").match(/^gitdir:\s*(.+)$/m)?.[1]?.trim(); const gd = path.resolve(d, g); const common = fs.existsSync(path.join(gd, "commondir")) ? fs.readFileSync(path.join(gd, "commondir"), "utf8").trim() : "."; cfg = path.join(path.resolve(gd, common), "config"); } } catch { return null; }
+    try { return fs.readFileSync(cfg, "utf8").match(/\[remote "origin"\][^[]*?url\s*=\s*(\S+)/)?.[1] ?? null; } catch { return null; }
+  }) ?? "";
+}
+/** .agentsky.json at the repo, then the first rule matching the folder or git remote, then the fallback. */
+export function route(cwd, config) {
+  if (cwd) {
+    const pinned = up(cwd, (d) => { const f = path.join(d, ".agentsky.json"); if (fs.existsSync(f)) { const w = readJson(f, {}).workspace; if (w) return w; } if (fs.existsSync(path.join(d, ".git"))) return null; });
+    if (pinned) return pinned;
+    const hay = `${cwd}\n${remoteOf(cwd)}`.toLowerCase();
+    const rule = (config.rules ?? []).find((r) => hay.includes(String(r.match).toLowerCase()));
+    if (rule) return rule.workspace;
+  }
+  return config.fallback ?? null;
+}
+
+const gitCache = new Map();
+/** Branch, commit and origin of the repository a session ran in, read from git (the session's own record wins). */
+function gitOf(t) {
+  const cwd = t.cwd;
+  if (!cwd || !fs.existsSync(cwd)) return t.git ?? {};
+  if (!gitCache.has(cwd)) {
+    const run = (...a) => { const r = spawnSync("git", ["-C", cwd, ...a], { encoding: "utf8", timeout: 4000 }); return r.status === 0 ? r.stdout.trim() : ""; };
+    gitCache.set(cwd, { branch: run("rev-parse", "--abbrev-ref", "HEAD"), commit: run("rev-parse", "HEAD"), remote: run("remote", "get-url", "origin").replace(/\/\/[^@/]+@/, "//") });
+  }
+  const g = gitCache.get(cwd);
+  return { branch: t.git?.branch || g.branch, commit: t.git?.commit || g.commit, remote: t.git?.remote || g.remote };
+}
+
+const cap = (s, n) => { const b = Buffer.from(s, "utf8"); return b.length <= n ? [s, false] : [b.subarray(0, n).toString("utf8").replace(/�+$/, ""), true]; };
+const home = (p) => (p && (p === os.homedir() || p.startsWith(os.homedir() + path.sep)) ? `~${p.slice(os.homedir().length)}` : p);
+
+/** trace/v1 → the library's upload body. Tool calls and results are tool rows, reasoning and attachments ride as text. */
+export function toLibrary(t, device) {
+  const rows = [];
+  let partial = false;
+  const push = (role, text, at) => {
+    const s = String(text ?? "").replace(/\u0000/g, "").trim();
+    if (!s) return;
+    if (rows.length >= MESSAGES_MAX) { partial = true; return; }
+    const [c, cut] = cap(s, role === "tool" ? TOOL_MAX : MESSAGE_MAX);
+    if (cut) partial = true;
+    rows.push({ role, text: c, ...(at ? { at: new Date(at).toISOString() } : {}) });
+  };
+  for (const m of t.messages) {
+    const at = m.ts && Number.isFinite(Date.parse(m.ts)) ? m.ts : undefined;
+    if (m.role === "user") {
+      push("user", m.text, at);
+      for (const a of m.attachments ?? []) push("user", `[attachment ${a.name || a.kind}]${a.data && /^text\//.test(a.media_type || "") ? `\n${Buffer.from(a.data, "base64").toString("utf8")}` : ""}`, at);
+    } else if (m.role === "assistant") {
+      if (m.thinking) push("assistant", `[reasoning]\n${m.thinking}`, at);
+      push("assistant", m.text, at);
+      for (const c of m.tool_calls ?? []) push("tool", `${c.name} ${typeof c.input === "string" ? c.input : JSON.stringify(c.input ?? {})}`, at);
+    } else if (m.role === "tool") push("tool", m.text, at);
+  }
+  const hash = createHash("sha256");
+  hash.update(`${t.cwd ?? ""}\u0002${t.model ?? ""}\u0002`);
+  for (const r of rows) hash.update(`${r.role}\u0000${r.text}\u0001`);
+  const s = t.stats;
+  const g = gitOf(t);
+  const body = {
+    sha256: hash.digest("hex"), ...(t.title ? { title: t.title.slice(0, 300) } : {}),
+    ...(t.cwd ? { cwd: home(t.cwd).slice(0, 1024), project: path.basename(t.cwd).slice(0, 200) } : {}),
+    ...(g.branch && g.branch !== "HEAD" ? { git_branch: g.branch.slice(0, 300) } : {}),
+    ...(g.commit ? { git_commit: g.commit.slice(0, 80) } : {}),
+    ...(g.remote ? { git_remote: g.remote.slice(0, 1024) } : {}),
+    ...(t.model_provider ? { model_provider: String(t.model_provider).slice(0, 100) } : {}),
+    ...(t.effort ? { effort: String(t.effort).slice(0, 100) } : {}),
+    client: (t.client || t.harness).slice(0, 200),
+    ...(t.model ? { model: t.model.slice(0, 200) } : {}),
+    ...(s.models?.length ? { models: s.models.slice(0, 50) } : {}),
+    ...(s.harness_version ? { harness_version: String(s.harness_version).slice(0, 80) } : {}),
+    ...(s.usage && Object.keys(s.usage).length ? { usage: s.usage } : {}),
+    device: device.slice(0, 200), ...(t.started_at ? { started_at: new Date(t.started_at).toISOString() } : {}),
+    ...(t.ended_at ? { ended_at: new Date(t.ended_at).toISOString() } : {}),
+    user_turns: s.user_turns, tool_calls: s.tool_calls, partial, messages: rows,
+  };
+  while (Buffer.byteLength(JSON.stringify(body)) > BODY_MAX && body.messages.length > 1) { body.messages = body.messages.slice(0, Math.floor(body.messages.length * 0.8)); body.partial = true; }
+  return body;
+}
+
+async function call(method, p, workspace, body) {
+  for (let attempt = 0; ; attempt++) {
+    const res = await fetch(`${apiBase()}${p}`, { method, headers: { authorization: `Bearer ${token()}`, "x-universe": workspace, "user-agent": "trace-collect", ...(body ? { "content-type": "application/json" } : {}) }, body: body ? JSON.stringify(body) : undefined }).catch((e) => ({ ok: false, status: 0, statusText: e.message, json: async () => ({}) }));
+    if (res.ok) return res.json();
+    if ((res.status === 429 || res.status >= 500 || res.status === 0) && attempt < 3) { await new Promise((r) => setTimeout(r, 1000 * 2 ** attempt)); continue; }
+    const e = await res.json().catch(() => ({}));
+    throw Object.assign(new Error(`${res.status} ${e.error?.code ?? res.statusText}`), { status: res.status });
+  }
+}
+
+export default {
+  id: "agentsky",
+  name: "AgentSky workspace trace library",
+  /** The library has no parent link, so subagent and helper sessions are uploaded as traces of their own. */
+  children: true,
+  ready: () => (token() ? { ok: true } : { ok: false, why: "not logged in to AgentSky — run `sky auth login`" }),
+  /** `sky trace sync` owns Claude Code and Codex on a device where it is on. */
+  skipHarness: (opts) => (opts.all || !syncConfig().enabled ? [] : Object.keys(SKY_HARNESS)),
+  async push(list, { scrub, dry = false, workspace = null, log = () => {} }) {
+    const config = syncConfig(), device = config.device ?? os.hostname();
+    const out = { uploaded: 0, unchanged: 0, owned: 0, local: 0, failed: 0, by_workspace: {}, errors: [] };
+    const ready = new Map();
+    for (const { trace } of list) {
+      const t = scrub(trace);
+      const ws = workspace ?? route(trace.cwd, config);
+      if (!ws) { out.local++; continue; }
+      const harness = SKY_HARNESS[trace.harness] ?? trace.harness.replace(/[^a-z0-9_-]/g, "_").slice(0, 40);
+      const id = String(trace.native_session_id || trace.session_id).slice(0, 200);
+      ready.set(ws, [...(ready.get(ws) ?? []), { harness, id, body: toLibrary({ ...t, cwd: trace.cwd, stats: trace.stats }, device) }]);
+    }
+    for (const [ws, items] of ready) for (let i = 0; i < items.length; i += CHECK_BATCH) {
+      const batch = items.slice(i, i + CHECK_BATCH);
+      let st;
+      try { st = (await call("POST", "/trace-library/check", ws, { sessions: batch.map((b) => ({ harness: b.harness, session_id: b.id, sha256: b.body.sha256 })) })).sessions; }
+      catch (e) { out.failed += batch.length; out.errors.push(`${ws}: check ${e.message}`); if ([401, 403, 503].includes(e.status)) break; continue; }
+      const send = batch.filter((b, k) => { const s = st[k]?.status; if (s === "unchanged") { out.unchanged++; return false; } if (s === "owned") { out.owned++; return false; } return true; });
+      if (dry) { out.uploaded += send.length; out.by_workspace[ws] = (out.by_workspace[ws] ?? 0) + send.length; continue; }
+      let next = 0;
+      await Promise.all(Array.from({ length: Math.min(CONCURRENCY, send.length) }, async () => {
+        while (next < send.length) {
+          const b = send[next++];
+          try { await call("PUT", `/trace-library/${b.harness}/${encodeURIComponent(b.id)}`, ws, b.body); out.uploaded++; out.by_workspace[ws] = (out.by_workspace[ws] ?? 0) + 1; log(`${b.harness}/${b.id} → ${ws}`); }
+          catch (e) { out.failed++; out.errors.push(`${b.harness}/${b.id} → ${ws}: ${e.message}`); }
+        }
+      }));
+    }
+    return out;
+  },
+};

package/vendor/trace-collect/sources/_cline-family.mjs

@@ -0,0 +1,182 @@
+// Shared helper for the Cline extension family: Cline, Roo Code, Kilo Code.
+// All three store task history in the same directory layout and JSON formats.
+//
+// Layout (under a VS Code-family app's User/globalStorage/):
+//   <extensionId>/tasks/<taskId>/
+//     api_conversation_history.json  – Anthropic Messages format: {role, content}[]
+//     ui_messages.json               – UI-facing messages (may add context; optional)
+//     task_metadata.json             – {id, ts, model, cwd, tokensIn, tokensOut, …}
+//
+// api_conversation_history.json is the authoritative transcript.
+// task_metadata.json provides timestamps, model and token usage.
+// ui_messages.json provides the original human ask as the title seed.
+//
+// Extensions:
+//   Cline:    saoudrizwan.claude-dev
+//   Roo Code: rooveterinaryinc.roo-cline
+//   Kilo Code: kilocode.kilo-code
+
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { FORMAT } from "../normalize.mjs";
+
+// VS Code-family app data dirs on macOS (and Linux equivalents)
+const VSCODE_APPS_MAC = [
+  "Library/Application Support/Code/User/globalStorage",
+  "Library/Application Support/Code - Insiders/User/globalStorage",
+  "Library/Application Support/Cursor/User/globalStorage",
+  "Library/Application Support/Windsurf/User/globalStorage",
+  "Library/Application Support/VSCodium/User/globalStorage",
+];
+const VSCODE_APPS_LINUX = [
+  ".config/Code/User/globalStorage",
+  ".config/Code - Insiders/User/globalStorage",
+  ".config/Cursor/User/globalStorage",
+  ".config/Windsurf/User/globalStorage",
+  ".config/VSCodium/User/globalStorage",
+];
+
+export function clineRoots(home, extensionId) {
+  const apps = [...VSCODE_APPS_MAC, ...VSCODE_APPS_LINUX];
+  const roots = [];
+  for (const app of apps) {
+    const p = path.join(home, app, extensionId);
+    if (fs.existsSync(p)) roots.push(p);
+  }
+  return roots;
+}
+
+function readJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function blockText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return content == null ? "" : JSON.stringify(content);
+  return content.map((p) => {
+    if (typeof p === "string") return p;
+    if (p?.type === "text") return p.text || "";
+    if (p?.type === "image") return `[image: ${p?.source?.media_type || ""}]`;
+    if (p?.type === "tool_use") return ""; // handled below
+    if (p?.type === "tool_result") return ""; // handled below
+    return "";
+  }).filter(Boolean).join("\n");
+}
+
+/** Convert an Anthropic Messages array into trace/v1 messages. */
+function convertMessages(apiMsgs) {
+  const messages = [];
+  const callNames = new Map();
+  for (const m of apiMsgs) {
+    if (!m || typeof m !== "object") continue;
+    const role = m.role;
+    const content = Array.isArray(m.content) ? m.content : [{ type: "text", text: String(m.content ?? "") }];
+
+    if (role === "user") {
+      // May contain text or tool_result blocks
+      const results = content.filter((p) => p?.type === "tool_result");
+      if (results.length) {
+        for (const p of results) {
+          const out = typeof p.content === "string" ? p.content : blockText(p.content);
+          messages.push({ role: "tool", tool_use_id: p.tool_use_id || "", tool_name: callNames.get(p.tool_use_id) || "", is_error: !!p.is_error, text: out.slice(0, 1_000_000) });
+        }
+        // Check if there's also text content (rare but possible)
+        const texts = content.filter((p) => p?.type === "text" && p.text);
+        if (texts.length) {
+          const t = texts.map((p) => p.text).join("\n");
+          if (t.trim()) messages.push({ role: "user", text: t });
+        }
+        continue;
+      }
+      const text = blockText(content);
+      const attachments = content.filter((p) => p?.type === "image" && p.source).map((p) => ({
+        kind: "image",
+        media_type: p.source?.media_type || "",
+        name: "",
+      }));
+      if (text || attachments.length) {
+        messages.push({ role: "user", text: text || "", ...(attachments.length ? { attachments } : {}) });
+      }
+    } else if (role === "assistant") {
+      const tool_calls = [];
+      const thinkingParts = [];
+      let t = "";
+      for (const p of content) {
+        if (p?.type === "text") t += (t ? "\n" : "") + (p.text || "");
+        else if (p?.type === "thinking" && p.thinking) thinkingParts.push(p.thinking);
+        else if (p?.type === "tool_use") {
+          const callId = p.id || `call-${tool_calls.length}`;
+          callNames.set(callId, p.name || "tool");
+          tool_calls.push({ id: callId, name: p.name || "tool", input: p.input ?? {} });
+        }
+      }
+      const thinking = thinkingParts.join("\n");
+      if (t || tool_calls.length || thinking) {
+        messages.push({ role: "assistant", text: t, ...(thinking ? { thinking } : {}), ...(tool_calls.length ? { tool_calls } : {}) });
+      }
+    }
+  }
+  return messages;
+}
+
+/** Read one task directory and yield a session. */
+export function* collectTaskDir(taskDir, harness) {
+  const histPath = path.join(taskDir, "api_conversation_history.json");
+  if (!fs.existsSync(histPath)) return;
+
+  const history = readJson(histPath);
+  if (!Array.isArray(history)) return;
+
+  const meta = readJson(path.join(taskDir, "task_metadata.json")) || {};
+  const taskId = meta.id || path.basename(taskDir);
+
+  const messages = convertMessages(history);
+  if (!messages.some((m) => m.role === "user")) return;
+
+  // Timestamps: prefer task_metadata, fall back to file mtime
+  let started = meta.ts ? new Date(meta.ts).toISOString() : null;
+  if (!started) {
+    try { started = new Date(fs.statSync(histPath).birthtimeMs).toISOString(); } catch { }
+  }
+  let ended = meta.updatedAt ? new Date(meta.updatedAt).toISOString() : null;
+  if (!ended) {
+    try { ended = new Date(fs.statSync(histPath).mtimeMs).toISOString(); } catch { }
+  }
+
+  const model = meta.model || meta.apiModelId || "";
+  const cwd = meta.cwd || meta.dirContext || "";
+  const usage = {};
+  if (meta.tokensIn != null) usage.input_tokens = Number(meta.tokensIn);
+  if (meta.tokensOut != null) usage.output_tokens = Number(meta.tokensOut);
+  if (meta.cacheReads != null) usage.cache_read_tokens = Number(meta.cacheReads);
+  if (meta.cacheWrites != null) usage.cache_write_tokens = Number(meta.cacheWrites);
+
+  yield {
+    format: FORMAT,
+    harness,
+    session_id: createHash("sha256").update(`${harness}:${taskId}`).digest("hex").slice(0, 16),
+    model,
+    title: meta.task || "",
+    started_at: started,
+    ended_at: ended,
+    cwd,
+    ...(Object.keys(usage).length ? { usage } : {}),
+    source: taskDir,
+    messages,
+  };
+}
+
+/** Collect all tasks under a root dir (the extension's data dir). */
+export function* collectClineRoot(root, harness) {
+  const tasksDir = path.join(root, "tasks");
+  let taskIds;
+  try { taskIds = fs.readdirSync(tasksDir); } catch { return; }
+  for (const id of taskIds) {
+    const dir = path.join(tasksDir, id);
+    try {
+      if (!fs.statSync(dir).isDirectory()) continue;
+    } catch { continue; }
+    try { yield* collectTaskDir(dir, harness); } catch { /* skip bad task */ }
+  }
+}

package/vendor/trace-collect/sources/_project-root.mjs

@@ -0,0 +1,40 @@
+// Gemini CLI and Qwen Code name a project's folder under <config>/tmp by sha256(project root) (older) or by a short
+// name with a .project_root file and a projects.json map (newer). Turn either back into the real folder, so the
+// session's workspace, instruction files and touched files can be read. Never return the hash itself.
+
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+
+const sha = (s) => createHash("sha256").update(s).digest("hex");
+const dirs = (d) => { try { return fs.readdirSync(d, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => path.join(d, e.name)); } catch { return []; } };
+
+/** sha256(folder) → folder over the places a project plausibly lives; `extra` adds known folders. Matches a hash prefix too. */
+export function folderByHash(home, extra = []) {
+  const candidates = new Set([home, ...extra]);
+  for (const a of dirs(home)) { candidates.add(a); for (const b of dirs(a)) candidates.add(b); }
+  for (const w of [path.join(home, ".agents", "worktrees"), path.join(home, ".claude", "worktrees")]) for (const d of dirs(w)) candidates.add(d);
+  for (const repo of dirs(home)) for (const d of dirs(path.join(repo, ".claude", "worktrees"))) candidates.add(d);
+  const full = [...candidates].map((c) => [sha(c), c]);
+  return (h) => (h && /^[a-f0-9]{16,64}$/.test(h) ? full.find(([x]) => x.startsWith(h))?.[1] ?? "" : "");
+}
+
+export function projectRootResolver(configDir, home) {
+  let byName = {};
+  try { const p = JSON.parse(fs.readFileSync(path.join(configDir, "projects.json"), "utf8")).projects ?? {}; byName = Object.fromEntries(Object.entries(p).map(([root, name]) => [name, root])); } catch {}
+  let byHash = null;
+  const lookup = (h) => (byHash ??= folderByHash(home, Object.values(byName)))(h);
+  return (projectDir, projectHash, messages = []) => {
+    try { const r = fs.readFileSync(path.join(configDir, "tmp", projectDir, ".project_root"), "utf8").trim(); if (r) return r; } catch {}
+    if (byName[projectDir]) return byName[projectDir];
+    const h = /^[a-f0-9]{64}$/.test(projectHash || "") ? projectHash : /^[a-f0-9]{64}$/.test(projectDir) ? projectDir : "";
+    const found = lookup(h);
+    if (found) return found;
+    // Last resort: the deepest folder every absolute file path in the session shares.
+    const abs = messages.flatMap((m) => m.tool_calls ?? []).flatMap((c) => Object.values(c.input ?? {})).filter((v) => typeof v === "string" && v.startsWith("/") && v.length < 500);
+    if (!abs.length) return "";
+    let prefix = path.dirname(abs[0]);
+    for (const p of abs) while (prefix !== "/" && !p.startsWith(prefix + "/")) prefix = path.dirname(prefix);
+    return prefix === "/" || prefix === home ? "" : prefix;
+  };
+}

package/vendor/trace-collect/sources/amp.mjs

@@ -0,0 +1,18 @@
+// Amp (Sourcegraph) keeps threads in the cloud; the only local file is a device-id.json.
+// There are no local transcripts to collect, so this adapter registers the source in the
+// registry but collect() always yields nothing.
+
+import path from "node:path";
+import { FORMAT } from "../normalize.mjs";
+
+export default {
+  id: "amp",
+  name: "Amp (Sourcegraph)",
+  kind: "local",
+  roots: (home) => [path.join(home, ".local", "share", "amp")],
+  // eslint-disable-next-line require-yield
+  *collect(_root) { /* Amp stores threads in the cloud; nothing to collect locally */ },
+};
+
+// Re-export FORMAT to keep the import live (satisfies linters).
+export { FORMAT };

package/vendor/trace-collect/sources/chatgpt.mjs

@@ -0,0 +1,203 @@
+// ChatGPT data export (Settings → Data Controls → Export data). Produces a zip whose
+// conversations.json is an array; each has a `mapping` node-graph with parent/children
+// and a `current_node` id pointing to the last active message. Newer exports also split
+// large histories across conversations-0.json, conversations-1.json, etc.
+// Evidence: community.openai.com/t/decoding-exported-data-by-parsing-conversations-json-and-or-chat-html/403144
+//           and scrapbox.io/oquno/ChatGPT%E3%81%8B%E3%82%89%E3%82%A8%E3%82%AF%E3%82%B9%E3%83%9D%E3%83%BC%E3%83%88%E3%81%97%E3%81%9Fconversations.json
+
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { FORMAT } from "../normalize.mjs";
+
+const CONV_FILE = /(?:^|\/)conversations(?:-\d+)?\.json$/;
+const IMAGE_EXT = /\.(png|jpe?g|gif|webp|heic|svg)$/i;
+
+/** Follow current_node back to root to reconstruct the main branch in order. */
+function mainBranch(mapping, currentNode) {
+  const byId = mapping;
+  const chain = [];
+  let id = currentNode;
+  const seen = new Set();
+  while (id && !seen.has(id)) {
+    seen.add(id);
+    const node = byId[id];
+    if (!node) break;
+    if (node.message?.content) chain.unshift(node);
+    id = node.parent;
+  }
+  return chain;
+}
+
+/** Read text from ChatGPT content object; handles text, code, tether, thoughts, etc. */
+function contentText(content) {
+  if (!content) return "";
+  const { content_type, parts, text } = content;
+  if (typeof text === "string" && text) return text;
+  if (!Array.isArray(parts)) return "";
+  const pieces = [];
+  for (const p of parts) {
+    if (typeof p === "string") pieces.push(p);
+    else if (p && typeof p === "object") {
+      // image_asset_pointer → skip text; handled separately as attachment
+      if (p.content_type === "image_asset_pointer" || p.asset_pointer) continue;
+      if (typeof p.text === "string") pieces.push(p.text);
+    }
+  }
+  return pieces.filter(Boolean).join("\n");
+}
+
+/** Collect image_asset_pointer parts as attachments (name only; bytes are not in the export). */
+function imageAttachments(content) {
+  if (!content || !Array.isArray(content.parts)) return [];
+  return content.parts
+    .filter((p) => p && typeof p === "object" && (p.content_type === "image_asset_pointer" || p.asset_pointer))
+    .map((p) => ({
+      kind: "image",
+      media_type: "image/*",
+      name: p.asset_pointer ? String(p.asset_pointer).split("/").pop() : (p.filename || "image"),
+    }));
+}
+
+/** Read all conversations arrays from the listing (handles split files too). */
+function readAllConversations(input, l) {
+  const files = l.names.filter((n) => CONV_FILE.test(n)).sort();
+  const convs = [];
+  for (const f of files) {
+    try {
+      const arr = JSON.parse(l.read(f));
+      if (Array.isArray(arr)) convs.push(...arr);
+    } catch { /* skip bad file */ }
+  }
+  return convs;
+}
+
+/** Convert one ChatGPT conversation to trace/v1 format. */
+function chatgptSession(conv) {
+  const mapping = conv.mapping || {};
+  const branch = mainBranch(mapping, conv.current_node);
+  const messages = [];
+  const toolCallIds = new Map(); // message_id → generated call id for matching results
+
+  for (const node of branch) {
+    const m = node.message;
+    if (!m) continue;
+    const role = m.author?.role;
+    const content = m.content || {};
+    const ts = m.create_time ? new Date(m.create_time * 1000).toISOString() : undefined;
+    const modelSlug = m.metadata?.model_slug || "";
+
+    if (role === "system") {
+      // Only emit user-authored system prompts
+      if (m.metadata?.is_user_system_message) {
+        const t = contentText(content);
+        if (t) messages.push({ role: "user", ts, text: t });
+      }
+      continue;
+    }
+
+    if (role === "user") {
+      const t = contentText(content);
+      const attachments = imageAttachments(content);
+      if (t || attachments.length) {
+        messages.push({ role: "user", ts, text: t, ...(attachments.length ? { attachments } : {}) });
+      }
+      continue;
+    }
+
+    if (role === "assistant") {
+      const ct = content.content_type;
+      // Thinking / reasoning blocks
+      if (ct === "thoughts" || ct === "reasoning") {
+        const thinking = contentText(content);
+        if (thinking) {
+          const last = messages[messages.length - 1];
+          if (last?.role === "assistant") last.thinking = (last.thinking ? last.thinking + "\n" : "") + thinking;
+          else messages.push({ role: "assistant", ts, text: "", thinking, ...(modelSlug ? { model: modelSlug } : {}) });
+        }
+        continue;
+      }
+
+      // Tool call: assistant message whose recipient is a specific tool
+      const recipient = m.recipient;
+      if (recipient && recipient !== "all") {
+        const callId = `chatgpt-call-${m.id || node.id}`;
+        toolCallIds.set(node.id, callId);
+        const inputText = contentText(content);
+        let input;
+        try { input = inputText ? JSON.parse(inputText) : {}; } catch { input = inputText ? { query: inputText } : {}; }
+        const last = messages[messages.length - 1];
+        const call = { id: callId, name: recipient, input };
+        if (last?.role === "assistant" && !last.text) (last.tool_calls ||= []).push(call);
+        else messages.push({ role: "assistant", ts, text: "", tool_calls: [call], ...(modelSlug ? { model: modelSlug } : {}) });
+        continue;
+      }
+
+      const t = contentText(content);
+      const thinkingInMeta = m.metadata?.reasoning_recap || "";
+      const attachments = imageAttachments(content);
+      if (t || attachments.length || thinkingInMeta) {
+        messages.push({
+          role: "assistant", ts, text: t,
+          ...(attachments.length ? { attachments } : {}),
+          ...(thinkingInMeta ? { thinking: thinkingInMeta } : {}),
+          ...(modelSlug ? { model: modelSlug } : {}),
+        });
+      }
+      continue;
+    }
+
+    if (role === "tool") {
+      // Find the closest ancestor call id
+      const parentNode = mapping[node.parent];
+      const callId = toolCallIds.get(node.parent) || (parentNode ? `chatgpt-call-${parentNode.id || node.parent}` : `chatgpt-call-${node.id}`);
+      const toolName = m.author?.name || "tool";
+      const t = contentText(content);
+      messages.push({ role: "tool", ts, tool_use_id: callId, tool_name: toolName, is_error: content.content_type === "system_error", text: (t || "").slice(0, 1_000_000) });
+    }
+  }
+
+  const models = [...new Set(
+    branch.map((n) => n.message?.metadata?.model_slug).filter(Boolean)
+  )];
+
+  return {
+    format: FORMAT,
+    harness: "chatgpt",
+    model: conv.default_model_slug || models[0] || "",
+    ...(models.length > 1 ? { models } : {}),
+    session_id: `chatgpt-${createHash("sha256").update(`chatgpt:${conv.id || conv.title || ""}`).digest("hex").slice(0, 16)}`,
+    title: conv.title || "",
+    started_at: conv.create_time ? new Date(conv.create_time * 1000).toISOString() : null,
+    ended_at: conv.update_time ? new Date(conv.update_time * 1000).toISOString() : null,
+    cwd: "",
+    source: "chatgpt-export",
+    ...(conv.gizmo_id ? { gizmo_id: conv.gizmo_id } : {}),
+    ...(conv.project_id ? { project_id: conv.project_id } : {}),
+    messages,
+  };
+}
+
+export function chatgptSessions(convs) {
+  return convs.map((c) => {
+    try { return chatgptSession(c); } catch { return null; }
+  }).filter((s) => s && s.messages.some((m) => m.role === "user") && s.messages.some((m) => m.role === "assistant"));
+}
+
+export default {
+  id: "chatgpt",
+  name: "ChatGPT (OpenAI)",
+  kind: "export",
+  how: "chat.openai.com → Settings → Data Controls → Export data; download the zip from the email",
+  sniff(l) {
+    const convFile = l.names.find((n) => CONV_FILE.test(n));
+    if (!convFile) return false;
+    const head = l.read(convFile).slice(0, 200_000);
+    // "current_node" is ChatGPT-specific; "chat_messages" = claude-ai; "fragments" = deepseek
+    return head.includes('"current_node"') && head.includes('"mapping"') && !head.includes('"chat_messages"') && !head.includes('"fragments"');
+  },
+  *collect(input, { listing: l }) {
+    yield* chatgptSessions(readAllConversations(input, l));
+  },
+};