@agentsky/sky 2.20.2 → 2.21.0

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

@@ -0,0 +1,119 @@
+// Source registry. Every agent is one self-contained module in this folder; nothing else needs to know about it.
+//
+// A module default-exports:
+//   {
+//     id:   "gemini-cli",            // written as trace.harness; also the folder name under ~/.trace-market/sources/
+//     name: "Gemini CLI",
+//     kind: "native" | "local" | "export",
+//       native: the scan reads its files in place (Claude Code, Codex, Cursor agent transcripts, Hermes) — roots only
+//       local:  found on this computer in its own format; collect() converts it to trace/v1 files
+//       export: a file the person downloads from a cloud service (claude.ai, ChatGPT, Muse…); import converts it
+//     roots(home) -> string[]        // native/local: where it lives on this computer (missing paths are fine)
+//     sniff(listing) -> boolean      // export: listing = { names: string[], read(name) -> string } over the zip or folder
+//     *collect(input, ctx) -> trace/v1 sessions   // local: input is one existing root; export: the zip, folder or file
+//   }
+//
+// A session is { format: "trace/v1", harness, session_id, model, title, started_at, ended_at, cwd, messages[] } where a
+// message is user {text, attachments?} | assistant {text, thinking?, tool_calls?: [{id, name, input}]} | tool
+// {tool_use_id, tool_name, is_error, text}. Keep everything the source recorded; scrubbing happens later, on upload.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+let cache = null;
+
+export async function loadSources() {
+  if (cache) return cache;
+  const files = fs.readdirSync(HERE).filter((f) => f.endsWith(".mjs") && !f.startsWith("_") && f !== "index.mjs").sort();
+  cache = [];
+  for (const f of files) {
+    const m = (await import(pathToFileURL(path.join(HERE, f)).href)).default;
+    if (m?.id && m.kind) cache.push(m);
+  }
+  return cache;
+}
+
+/** Zip or folder as { names, read } so an export adapter can sniff without unpacking everything. */
+export function listing(input) {
+  const st = fs.statSync(input);
+  if (st.isDirectory()) {
+    const names = [];
+    const walk = (d, rel) => { for (const e of fs.readdirSync(d, { withFileTypes: true })) { const r = rel ? `${rel}/${e.name}` : e.name; if (e.isDirectory()) walk(path.join(d, e.name), r); else names.push(r); } };
+    walk(input, "");
+    return { names, read: (n) => fs.readFileSync(path.join(input, n), "utf8") };
+  }
+  if (/\.zip$/i.test(input)) {
+    const names = execFileSync("unzip", ["-Z1", input], { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 }).split("\n").filter((n) => n && !n.endsWith("/"));
+    return { names, read: (n) => execFileSync("unzip", ["-p", input, n], { encoding: "utf8", maxBuffer: 2 * 1024 ** 3 }) };
+  }
+  return { names: [path.basename(input)], read: () => fs.readFileSync(input, "utf8") };
+}
+
+/** Write sessions as <dir>/<id>/<session_id>.json; unchanged sessions are not rewritten. */
+export function writeSessions(sessions, dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  let written = 0, total = 0;
+  for (const s of sessions) {
+    if (!s?.messages?.some((m) => m.role === "user")) continue;
+    total++;
+    const name = String(s.session_id || "").replace(/[^\w.-]+/g, "_").slice(0, 120) || `session-${total}`;
+    const p = path.join(dir, `${name}.json`);
+    const body = JSON.stringify({ format: "trace/v1", ...s });
+    if (fs.existsSync(p) && fs.readFileSync(p, "utf8") === body) continue;
+    fs.writeFileSync(p, body, { mode: 0o600 });
+    written++;
+  }
+  return { total, written };
+}
+
+function fingerprint(root) {
+  // Cheap change detector: newest mtime and file count under the root, two levels deep is enough for every source we know.
+  let newest = 0, count = 0;
+  const visit = (p, depth) => { let st; try { st = fs.statSync(p); } catch { return; } newest = Math.max(newest, st.mtimeMs); count++; if (st.isDirectory() && depth < 4) { let ents = []; try { ents = fs.readdirSync(p); } catch {} for (const e of ents) visit(path.join(p, e), depth + 1); } };
+  visit(root, 0);
+  return `${count}:${Math.round(newest)}`;
+}
+
+/** Run every local adapter whose data exists; convert into <sourcesDir>/<id>/. Skips roots unchanged since last time. */
+export async function collectLocal(sourcesDir, { home = os.homedir(), only = null, force = false, log = () => {} } = {}) {
+  const statePath = path.join(sourcesDir, ".collect-state.json");
+  let state = {}; try { state = JSON.parse(fs.readFileSync(statePath, "utf8")); } catch {}
+  const report = [];
+  for (const src of await loadSources()) {
+    if (src.kind !== "local" || (only && !only.includes(src.id))) continue;
+    const roots = (src.roots?.(home) ?? []).filter((r) => fs.existsSync(r));
+    for (const root of roots) {
+      const fp = fingerprint(root), key = `${src.id}:${root}`;
+      if (!force && state[key] === fp) { report.push({ id: src.id, root, skipped: "unchanged" }); continue; }
+      try {
+        const res = writeSessions(src.collect(root, { home }), path.join(sourcesDir, src.id));
+        state[key] = fp;
+        report.push({ id: src.id, root, ...res });
+      } catch (e) {
+        report.push({ id: src.id, root, error: e.message });
+        log(`${src.name}: ${e.message}`);
+      }
+    }
+  }
+  fs.mkdirSync(sourcesDir, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(statePath, JSON.stringify(state), { mode: 0o600 });
+  return report;
+}
+
+/** Recognise a downloaded export and convert it into <sourcesDir>/<id>/. `as` forces an adapter. */
+export async function importExport(input, sourcesDir, { as = null } = {}) {
+  const sources = (await loadSources()).filter((s) => s.kind === "export");
+  const l = listing(input);
+  const src = as ? sources.find((s) => s.id === as) : sources.find((s) => { try { return s.sniff(l); } catch { return false; } });
+  if (!src) return { error: `not a supported export. Supported: ${sources.map((s) => s.id).join(", ")}` };
+  return { id: src.id, name: src.name, ...writeSessions(src.collect(input, { listing: l }), path.join(sourcesDir, src.id)) };
+}
+
+/** One row per known agent: is it on this computer, and where. */
+export async function describeSources(home = os.homedir()) {
+  return (await loadSources()).map((s) => ({ id: s.id, name: s.name, kind: s.kind, found: (s.roots?.(home) ?? []).filter((r) => fs.existsSync(r)) }));
+}

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

@@ -0,0 +1,134 @@
+// Jan (Menlo Research) local AI client.
+// Threads are stored at ~/jan/threads/<thread-id>/
+//   thread.json   — metadata: id, title, created_at, updated_at, assistants[{model:{id,...}}], usage?
+//   messages.jsonl — one message per line:
+//     { id, thread_id, role:"user"|"assistant"|"tool", content:[{type:"text",text:{value,annotations}}],
+//       created_at (Unix seconds), status, name?, tool_call_id?, tool_calls?[{id,type,function:{name,arguments}}] }
+//
+// Jan reference: https://github.com/janhq/jan – packages/core/src/types/message/messageEntity.ts
+
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { FORMAT } from "../normalize.mjs";
+
+const THREADS_REL = "jan/threads";
+
+function readJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function parseJsonl(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    try { out.push(JSON.parse(t)); } catch { /* skip partial */ }
+  }
+  return out;
+}
+
+/** Extract text from a Jan content array or string. */
+function contentText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((p) => {
+      if (typeof p === "string") return p;
+      if (p?.type === "text") {
+        const t = p.text;
+        if (typeof t === "string") return t;
+        if (t && typeof t === "object") return t.value || "";
+        return "";
+      }
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+export default {
+  id: "jan",
+  name: "Jan (Menlo Research)",
+  kind: "local",
+  roots: (home) => [path.join(home, THREADS_REL)],
+
+  *collect(root) {
+    let threadDirs;
+    try { threadDirs = fs.readdirSync(root); } catch { return; }
+
+    for (const td of threadDirs) {
+      const threadDir = path.join(root, td);
+      try { if (!fs.statSync(threadDir).isDirectory()) continue; } catch { continue; }
+
+      const meta = readJson(path.join(threadDir, "thread.json"));
+      const msgsPath = path.join(threadDir, "messages.jsonl");
+      let raw;
+      try { raw = fs.readFileSync(msgsPath, "utf8"); } catch { continue; }
+      const rows = parseJsonl(raw);
+      if (!rows.length) continue;
+
+      const messages = [];
+      const callNames = new Map();
+
+      for (const row of rows) {
+        const role = row.role;
+        const ts = row.created_at ? new Date(Number(row.created_at) * 1000).toISOString() : undefined;
+        const text = contentText(row.content);
+
+        if (role === "user") {
+          if (text) messages.push({ role: "user", ts, text });
+        } else if (role === "assistant") {
+          const tool_calls = (row.tool_calls || []).map((tc) => {
+            const id = tc.id || `call-${messages.length}`;
+            const name = tc.function?.name || tc.name || "tool";
+            let input = tc.function?.arguments ?? tc.input ?? {};
+            if (typeof input === "string") { try { input = JSON.parse(input); } catch { /* keep */ } }
+            callNames.set(id, name);
+            return { id, name, input };
+          });
+          if (text || tool_calls.length) {
+            messages.push({ role: "assistant", ts, text, ...(tool_calls.length ? { tool_calls } : {}) });
+          }
+        } else if (role === "tool") {
+          const callId = row.tool_call_id || "";
+          messages.push({
+            role: "tool", ts,
+            tool_use_id: callId,
+            tool_name: callNames.get(callId) || row.name || "",
+            is_error: false,
+            text: text.slice(0, 1_000_000),
+          });
+        }
+      }
+
+      if (!messages.some((m) => m.role === "user")) continue;
+
+      const threadId = meta?.id || td;
+      const model = meta?.assistants?.[0]?.model?.id || meta?.assistants?.[0]?.model?.name || "";
+      const started = meta?.created_at ? new Date(Number(meta.created_at) * 1000).toISOString() : null;
+      const ended = meta?.updated_at ? new Date(Number(meta.updated_at) * 1000).toISOString() : null;
+      const usage = meta?.usage
+        ? {
+            ...(meta.usage.prompt_tokens != null ? { input_tokens: meta.usage.prompt_tokens } : {}),
+            ...(meta.usage.completion_tokens != null ? { output_tokens: meta.usage.completion_tokens } : {}),
+          }
+        : undefined;
+
+      const sid = createHash("sha256").update(`jan:${threadId}`).digest("hex").slice(0, 16);
+
+      yield {
+        format: FORMAT,
+        harness: "jan",
+        session_id: sid,
+        model,
+        title: meta?.title || "",
+        started_at: started,
+        ended_at: ended,
+        cwd: "",
+        ...(usage && Object.keys(usage).length ? { usage } : {}),
+        messages,
+      };
+    }
+  },
+};

package/vendor/trace-collect/sources/kilo-code.mjs

@@ -0,0 +1,14 @@
+// Kilo Code (VS Code extension: kilocode.kilo-code)
+// Tasks: <vscode-globalStorage>/kilocode.kilo-code/tasks/<id>/api_conversation_history.json
+// Same format as Cline. See _cline-family.mjs.
+
+import path from "node:path";
+import { clineRoots, collectClineRoot } from "./_cline-family.mjs";
+
+export default {
+  id: "kilo-code",
+  name: "Kilo Code (VS Code extension)",
+  kind: "local",
+  roots: (home) => clineRoots(home, "kilocode.kilo-code"),
+  *collect(root) { yield* collectClineRoot(root, "kilo-code"); },
+};

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

@@ -0,0 +1,77 @@
+// Kiro stores agent chat sessions as .chat files under
+//   ~/Library/Application Support/Kiro/User/globalStorage/kiro.kiroagent/<workspace-hash>/
+//
+// Each .chat file is a JSON object:
+//   { executionId, actionId, context, validations,
+//     chat: [ {role:"human"|"bot"|"tool", content: string} ],
+//     metadata: { modelId, modelProvider, workflow, workflowId, startTime, endTime } }
+//
+// The "chat" value is a plain JS array (but may deserialize as an object with numeric
+// keys in some versions); messages use roles "human" (user), "bot" (assistant), "tool".
+// Tool messages are context injections (workspace layout, etc.) not tool results — they
+// have no structured id. Tool call structure is embedded as XML in bot content strings
+// rather than as separate structured objects, so we cannot extract call/result pairs;
+// we keep the full text of every bot turn.
+
+import fs from "node:fs";
+import path from "node:path";
+import { FORMAT } from "../normalize.mjs";
+import { folderByHash } from "./_project-root.mjs";
+
+const KIRO_GLOBAL = ["Library", "Application Support", "Kiro", "User", "globalStorage", "kiro.kiroagent"];
+
+export default {
+  id: "kiro",
+  name: "Kiro (AWS)",
+  kind: "local",
+  roots: (home) => [path.join(home, ...KIRO_GLOBAL)],
+  *collect(root, ctx = {}) {
+    // Each direct child directory is sha256(workspace folder) cut to 32 hex; .chat files are inside. Kiro also keeps
+    // workspace-sessions/<base64url(folder)>, which names the folders to try first.
+    let entries; try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return; }
+    let known = []; try { known = fs.readdirSync(path.join(root, "workspace-sessions")).map((n) => Buffer.from(n.replace(/_/g, "="), "base64url").toString("utf8")).filter((p) => p.startsWith("/")); } catch {}
+    const folderOf = folderByHash(ctx.home || path.resolve(root, "../../../../../.."), known);
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      const wsDir = path.join(root, e.name);
+      let chatFiles; try { chatFiles = fs.readdirSync(wsDir); } catch { continue; }
+      for (const cf of chatFiles) {
+        if (!cf.endsWith(".chat")) continue;
+        const filePath = path.join(wsDir, cf);
+        let obj; try { obj = JSON.parse(fs.readFileSync(filePath, "utf8")); } catch { continue; }
+        if (!obj) continue;
+
+        // Normalise the chat field to an array
+        const rawChat = obj.chat;
+        const chat = Array.isArray(rawChat) ? rawChat : (rawChat && typeof rawChat === "object" ? Object.values(rawChat) : []);
+        if (!chat.length) continue;
+
+        const meta = obj.metadata || {};
+        // One execution writes a .chat per step (each its own model call), so the step file names the session.
+        const sessionId = obj.executionId ? `${obj.executionId}:${cf.replace(/\.chat$/, "")}` : cf.replace(/\.chat$/, "");
+        const started_at = meta.startTime ? new Date(meta.startTime).toISOString() : null;
+        const ended_at = meta.endTime ? new Date(meta.endTime).toISOString() : null;
+
+        const messages = [];
+        for (const m of chat) {
+          const role = m.role;
+          const t = typeof m.content === "string" ? m.content : "";
+          if (role === "human") {
+            if (t) messages.push({ role: "user", text: t });
+          } else if (role === "bot") {
+            if (t) messages.push({ role: "assistant", text: t });
+          }
+          else if (role === "tool" && t) {
+            // Workspace context Kiro injected (file tree, open files…): kept as an attachment of the turn it precedes.
+            const last = messages.at(-1);
+            const doc = { kind: "document", media_type: "text/plain", name: "kiro context", text: t };
+            if (last?.role === "user") (last.attachments ||= []).push(doc); else messages.push({ role: "user", text: "", attachments: [doc] });
+          }
+        }
+
+        if (!messages.some((m) => m.role === "user")) continue;
+        yield { format: FORMAT, harness: "kiro", session_id: sessionId, ...(obj.executionId ? { execution_id: obj.executionId } : {}), model: meta.modelId || "", ...(meta.modelProvider ? { model_provider: meta.modelProvider } : {}), title: "", started_at, ended_at, cwd: folderOf(e.name), messages };
+      }
+    }
+  },
+};

package/vendor/trace-collect/sources/lm-studio.mjs

@@ -0,0 +1,84 @@
+// LM Studio (LM Studio, Inc.) local conversation history.
+// Conversations are stored as JSON files in:
+//   ~/.lmstudio/conversations/*.json         (newer LM Studio ≥ 0.3)
+//   ~/.cache/lm-studio/conversations/*.json  (older cache path)
+//
+// Each file is a single conversation object:
+//   { id, title, createdAt (ms), lastInteraction? (ms), model?,
+//     messages: [{ id, role:"user"|"assistant", content, timestamp (ms),
+//                  modelIdentifier?, tokens?: {prompt, completion} }] }
+//
+// Reference: LM Studio desktop changelog and community-documented export formats.
+
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { FORMAT } from "../normalize.mjs";
+
+const ROOTS = [
+  ".lmstudio/conversations",
+  ".cache/lm-studio/conversations",
+];
+
+function readJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function msgText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((p) => (typeof p === "string" ? p : p?.text || ""))
+      .filter(Boolean)
+      .join("\n");
+  }
+  return "";
+}
+
+export default {
+  id: "lm-studio",
+  name: "LM Studio",
+  kind: "local",
+  roots: (home) => ROOTS.map((r) => path.join(home, r)),
+
+  *collect(root) {
+    let entries;
+    try { entries = fs.readdirSync(root); } catch { return; }
+
+    for (const f of entries) {
+      if (!f.endsWith(".json")) continue;
+      const filePath = path.join(root, f);
+      const data = readJson(filePath);
+      if (!data || !Array.isArray(data.messages)) continue;
+
+      const messages = [];
+      for (const msg of data.messages) {
+        const role = msg.role;
+        if (role !== "user" && role !== "assistant") continue;
+        const text = msgText(msg.content);
+        const ts = msg.timestamp ? new Date(Number(msg.timestamp)).toISOString() : undefined;
+        if (text) messages.push({ role, ts, text });
+      }
+
+      if (!messages.some((m) => m.role === "user")) continue;
+
+      const convId = data.id || f.slice(0, -5);
+      const sid = createHash("sha256").update(`lm-studio:${convId}`).digest("hex").slice(0, 16);
+      const started = data.createdAt ? new Date(Number(data.createdAt)).toISOString() : null;
+      const ended = data.lastInteraction ? new Date(Number(data.lastInteraction)).toISOString() : null;
+      const model = data.model || data.messages.find((m) => m.modelIdentifier)?.modelIdentifier || "";
+
+      yield {
+        format: FORMAT,
+        harness: "lm-studio",
+        session_id: sid,
+        model,
+        title: data.title || "",
+        started_at: started,
+        ended_at: ended,
+        cwd: "",
+        messages,
+      };
+    }
+  },
+};

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

@@ -0,0 +1,11 @@
+// Muse (Meta AI): "Download your agent data" export. Parsing lives in ../muse.mjs.
+import { readMuseTranscript, museSessions } from "../muse.mjs";
+
+export default {
+  id: "muse",
+  name: "Muse (Meta AI)",
+  kind: "export",
+  how: "Muse → Settings → Download your agent data",
+  sniff: (l) => l.names.some((n) => /(^|\/)Conversation with Muse.*\.txt$/i.test(n)),
+  *collect(input) { yield* museSessions(readMuseTranscript(input)); },
+};

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

@@ -0,0 +1,109 @@
+// OpenCode stores sessions in a SQLite database at
+//   ~/.local/share/opencode/opencode.db
+// with three tables:
+//   session – id, directory, title, time_created (ms), parent_id
+//   message – id, session_id, time_created (ms), data (JSON blob):
+//               { role, time, modelID, providerID, tokens?, ... }
+//   part    – id, message_id, session_id, time_created (ms), data (JSON blob):
+//               { type:"text"|"tool"|"reasoning"|"step-start"|"step-finish"|"patch", ... }
+//       text      – { type:"text", text }
+//       tool      – { type:"tool", callID, tool (name), state:{ status, input, output } }
+//       reasoning – { type:"reasoning", text }
+//
+// Messages are sorted by time_created; parts are sorted the same way.
+
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { FORMAT } from "../normalize.mjs";
+
+function query(db, sql, params = []) {
+  // sqlite3 -json doesn't support bound params; we inline them safely since all values are strings.
+  let q = sql;
+  for (const p of params) q = q.replace("?", JSON.stringify(String(p)));
+  try {
+    const out = execFileSync("sqlite3", ["-json", db, q], { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+    return JSON.parse(out || "[]");
+  } catch { return []; }
+}
+
+function parseData(raw) { try { return JSON.parse(raw || "{}"); } catch { return {}; } }
+
+export default {
+  id: "opencode",
+  name: "OpenCode",
+  kind: "local",
+  roots: (home) => [path.join(home, ".local", "share", "opencode")],
+  *collect(root) {
+    const db = path.join(root, "opencode.db");
+    if (!fs.existsSync(db)) return;
+
+    const sessions = query(db, "SELECT id, directory, title, time_created, time_updated, parent_id FROM session WHERE time_archived IS NULL ORDER BY time_created");
+    if (!sessions.length) return;
+
+    for (const sess of sessions) {
+      const msgs = query(db, "SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created, id", [sess.id]);
+      if (!msgs.length) continue;
+
+      const partRows = query(db, "SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created, id", [sess.id]);
+      const partsByMsg = new Map();
+      for (const pr of partRows) {
+        const list = partsByMsg.get(pr.message_id) || [];
+        list.push(parseData(pr.data));
+        partsByMsg.set(pr.message_id, list);
+      }
+
+      const messages = [];
+      let model = "", started_at = null, ended_at = null;
+
+      for (const row of msgs) {
+        const data = parseData(row.data);
+        const ts = row.time_created ? new Date(Number(row.time_created)).toISOString() : undefined;
+        if (ts) { started_at ||= ts; ended_at = ts; }
+        const parts = partsByMsg.get(row.id) || [];
+
+        if (data.role === "user") {
+          const t = parts.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
+          if (t) messages.push({ role: "user", ts, text: t });
+        } else if (data.role === "assistant") {
+          model ||= data.modelID ? `${data.providerID || ""}/${data.modelID}`.replace(/^\//, "") : "";
+          const textBlocks = parts.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
+          const thinking = parts.filter((p) => p.type === "reasoning" && p.text).map((p) => p.text).join("\n");
+          const toolParts = parts.filter((p) => p.type === "tool");
+          const tool_calls = toolParts.map((p) => ({ id: p.callID, name: typeof p.tool === "string" ? p.tool : (p.tool?.name ?? "tool"), input: p.state?.input ?? {} }));
+          if (textBlocks || tool_calls.length || thinking) {
+            messages.push({ role: "assistant", ts, text: textBlocks, ...(thinking ? { thinking } : {}), ...(tool_calls.length ? { tool_calls } : {}) });
+          }
+          for (const p of toolParts) {
+            const out = p.state?.output;
+            if (out == null) continue;
+            messages.push({ role: "tool", ts, tool_use_id: p.callID, tool_name: typeof p.tool === "string" ? p.tool : (p.tool?.name ?? "tool"), is_error: p.state?.status === "error", text: String(out).slice(0, 1_000_000) });
+          }
+        }
+      }
+
+      if (!messages.some((m) => m.role === "user")) continue;
+
+      const usage = data_to_usage(msgs.map((r) => parseData(r.data)));
+      yield {
+        format: FORMAT, harness: "opencode", session_id: sess.id, model, title: sess.title || "",
+        started_at, ended_at, cwd: sess.directory || "",
+        ...(sess.parent_id ? { parent_session_id: sess.parent_id } : {}),
+        ...(Object.keys(usage).length ? { usage } : {}), messages,
+      };
+    }
+  },
+};
+
+function data_to_usage(msgDataList) {
+  let input = 0, output = 0;
+  for (const d of msgDataList) {
+    const tk = d.tokens;
+    if (typeof tk === "object" && tk) {
+      input += Number(tk.input || 0);
+      output += Number(tk.output || 0);
+    }
+  }
+  if (!input && !output) return {};
+  return { input_tokens: input, output_tokens: output };
+}

package/vendor/trace-collect/sources/qwen-code.mjs

@@ -0,0 +1,95 @@
+// Qwen Code CLI stores sessions under ~/.qwen/tmp/<project-dir>/chats/ in the same JSON/JSONL
+// format as Gemini CLI (they share the same session-file schema).
+// See gemini-cli.mjs for the format details.
+
+import fs from "node:fs";
+import path from "node:path";
+import { FORMAT } from "../normalize.mjs";
+import { projectRootResolver } from "./_project-root.mjs";
+
+function text(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content.map((p) => p?.text ?? "").filter(Boolean).join("\n");
+  return "";
+}
+
+function parseSession(filePath) {
+  const raw = fs.readFileSync(filePath, "utf8");
+  const firstChar = raw.trimStart()[0];
+  if (firstChar === "{") {
+    try {
+      const obj = JSON.parse(raw);
+      return { sessionId: obj.sessionId, projectHash: obj.projectHash, startTime: obj.startTime, lastUpdated: obj.lastUpdated, msgs: obj.messages || [] };
+    } catch { /* fall through */ }
+  }
+  const lines = raw.trim().split("\n");
+  let header = null;
+  const msgs = [];
+  for (const line of lines) {
+    const t = line.trim();
+    if (!t) continue;
+    let obj; try { obj = JSON.parse(t); } catch { continue; }
+    if (obj.$set) continue;
+    if (!header) { header = obj; continue; }
+    msgs.push(obj);
+  }
+  return { sessionId: header?.sessionId, projectHash: header?.projectHash, startTime: header?.startTime, lastUpdated: header?.lastUpdated, msgs };
+}
+
+function* sessionsFromChatsDir(chatsDir, cwdOf = () => "") {
+  let entries; try { entries = fs.readdirSync(chatsDir); } catch { return; }
+  for (const name of entries) {
+    if (!/\.(json|jsonl)$/.test(name)) continue;
+    const filePath = path.join(chatsDir, name);
+    let parsed; try { parsed = parseSession(filePath); } catch { continue; }
+    const { sessionId, startTime, lastUpdated, msgs } = parsed;
+    if (!sessionId) continue;
+    const messages = [];
+    let model = "";
+    for (const m of msgs) {
+      const ts = m.timestamp;
+      if (m.type === "user") {
+        const t = text(m.content);
+        if (t) messages.push({ role: "user", ts, text: t });
+      } else if (m.type === "gemini" || m.type === "qwen" || m.type === "assistant") {
+        model ||= m.model || "";
+        const t = text(m.content);
+        const calls = (m.toolCalls || []).map((tc) => ({ id: String(tc.id), name: tc.name, input: tc.args ?? {} }));
+        const thinking = m.thoughts && typeof m.thoughts === "string" && m.thoughts.trim() ? m.thoughts.trim() : undefined;
+        if (t || calls.length || thinking) {
+          messages.push({ role: "assistant", ts, text: t, ...(thinking ? { thinking } : {}), ...(calls.length ? { tool_calls: calls } : {}) });
+        }
+        for (const tc of m.toolCalls || []) {
+          const results = Array.isArray(tc.result) ? tc.result : [];
+          for (const r of results) {
+            const fr = r?.functionResponse;
+            if (!fr) continue;
+            const out = fr.response?.output ?? JSON.stringify(fr.response ?? "");
+            messages.push({ role: "tool", ts, tool_use_id: String(fr.id ?? tc.id), tool_name: fr.name ?? tc.name, is_error: tc.status === "error", text: String(out).slice(0, 1_000_000) });
+          }
+        }
+      } else if (m.type === "error") {
+        const t = text(m.content);
+        if (t) messages.push({ role: "assistant", ts, text: t });
+      }
+    }
+    if (!messages.some((m) => m.role === "user")) continue;
+    yield { format: FORMAT, harness: "qwen-code", session_id: sessionId, model, title: "", started_at: startTime, ended_at: lastUpdated, cwd: cwdOf(path.basename(path.dirname(chatsDir)), parsed.projectHash, messages), messages };
+  }
+}
+
+export default {
+  id: "qwen-code",
+  name: "Qwen Code CLI",
+  kind: "local",
+  roots: (home) => [path.join(home, ".qwen", "tmp")],
+  *collect(root) {
+    const resolve = projectRootResolver(path.dirname(root), path.dirname(path.dirname(root)));
+    let entries; try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      const chatsDir = path.join(root, e.name, "chats");
+      if (fs.existsSync(chatsDir)) yield* sessionsFromChatsDir(chatsDir, resolve);
+    }
+  },
+};

package/vendor/trace-collect/sources/roo-code.mjs

@@ -0,0 +1,14 @@
+// Roo Code (VS Code extension: rooveterinaryinc.roo-cline)
+// Tasks: <vscode-globalStorage>/rooveterinaryinc.roo-cline/tasks/<id>/api_conversation_history.json
+// Same format as Cline. See _cline-family.mjs.
+
+import path from "node:path";
+import { clineRoots, collectClineRoot } from "./_cline-family.mjs";
+
+export default {
+  id: "roo-code",
+  name: "Roo Code (VS Code extension)",
+  kind: "local",
+  roots: (home) => clineRoots(home, "rooveterinaryinc.roo-cline"),
+  *collect(root) { yield* collectClineRoot(root, "roo-code"); },
+};