@agentsky/sky 2.20.2 → 2.22.0

package/vendor/trace-collect/sources/gemini-cli.mjs

@@ -0,0 +1,113 @@
+// Gemini CLI stores sessions under ~/.gemini/tmp/<project-dir>/chats/.
+// Each session is either a JSON file { sessionId, projectHash, startTime, lastUpdated, messages[] }
+// or a JSONL file whose first line is the session header and subsequent lines are individual
+// messages (or $set partial-update lines, which we skip).
+//
+// Message shape (both formats):
+//   user    – { id, timestamp, type:"user",   content: [{text}] }
+//   gemini  – { id, timestamp, type:"gemini", content: string, thoughts?, model?, tokens?,
+//               toolCalls?: [{id, name, args, result, status, ...}] }
+//   error   – { id, timestamp, type:"error",  content: string }  (harness error; kept)
+//
+// Tool results are embedded inside the gemini message's toolCalls[i].result which is an array of
+// { functionResponse: { id, name, response: { output } } }.  We emit a tool result message for each.
+
+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 "";
+}
+
+/** Parse one session file (JSON or JSONL) and return messages + metadata. */
+function parseSession(filePath) {
+  const raw = fs.readFileSync(filePath, "utf8");
+  const firstChar = raw.trimStart()[0];
+  // JSON format: single JSON object
+  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 */ }
+  }
+  // JSONL format: first line is header, rest are messages or $set updates
+  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; // partial update delta – skip
+    if (!header) { header = obj; continue; }
+    msgs.push(obj);
+  }
+  return { sessionId: header?.sessionId, projectHash: header?.projectHash, startTime: header?.startTime, lastUpdated: header?.lastUpdated, msgs };
+}
+
+/** Walk a project directory's chats/ folder and yield sessions. */
+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 === "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 } : {}) });
+        }
+        // Emit tool results from embedded toolCalls[i].result
+        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") {
+        // Keep harness errors as assistant messages (they are recorded in the session)
+        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: "gemini-cli", 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: "gemini-cli",
+  name: "Gemini CLI",
+  kind: "local",
+  roots: (home) => [path.join(home, ".gemini", "tmp")],
+  *collect(root) {
+    const resolve = projectRootResolver(path.dirname(root), path.dirname(path.dirname(root)));
+    // Each entry under root that is a directory is a project; each project has a chats/ subdir.
+    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/gemini.mjs

@@ -0,0 +1,150 @@
+// Google Gemini chat history via Google Takeout → My Activity → Gemini Apps.
+// Export the "My Activity" section in JSON format; the file lands at
+//   Takeout/My Activity/Gemini Apps/MyActivity.json
+// (or MyActivity.html if you kept the default HTML format).
+// The JSON is a flat array of activity records per Google's Data Portability schema
+// (developers.google.com/data-portability/schema-reference/my_activity).
+// Each record has header, title (the user prompt/query), titleUrl, time, subtitles[].
+// There is no conversation-id, so entries are grouped into sessions by 30-minute gaps.
+// The HTML variant encodes assistant responses as inline HTML; this adapter strips tags.
+// Evidence: developers.google.com/data-portability/schema-reference/my_activity
+//           and workalizer.com/blog/apps-tools/fixing-empty-gemini-history-exports-from-google-takeout
+
+const GEMINI_FILE = /(?:^|\/)MyActivity\.(json|html)$/i;
+const GEMINI_HEADER = /gemini|bard/i;
+// Records within this many milliseconds of each other belong to the same session
+const SESSION_GAP_MS = 30 * 60 * 1000;
+
+import { createHash } from "node:crypto";
+import { FORMAT } from "../normalize.mjs";
+
+function stripHtml(s) {
+  if (!s) return "";
+  return s.replace(/<[^>]{0,200}>/g, " ").replace(/\s+/g, " ").trim();
+}
+
+/** Parse the HTML My Activity file: extract .content-cell text blocks as activity entries. */
+function parseHtml(html) {
+  const entries = [];
+  // Each activity block is in a div with class content-cell or similar
+  const block = /<div[^>]*class="[^"]*content-cell[^"]*"[^>]*>([\s\S]*?)<\/div>/gi;
+  let m;
+  while ((m = block.exec(html)) !== null) {
+    const inner = m[1];
+    // Pull the text after any heading link as the user query
+    const text = stripHtml(inner).replace(/^(Google Gemini|Bard|Used Gemini Apps?)\s*/i, "").trim();
+    if (!text || text.length < 3) continue;
+    // Try to find a timestamp nearby
+    const tsMatch = /<span[^>]*>([\w, :]+(?:AM|PM|UTC|GMT)?)<\/span>/i.exec(inner);
+    entries.push({ title: text, time: tsMatch ? tsMatch[1] : null });
+  }
+  return entries;
+}
+
+/** Parse the JSON My Activity file. */
+function parseJson(raw) {
+  let data;
+  try { data = JSON.parse(raw); } catch { return []; }
+  // Top-level array of activity records (Google standard) or {conversations:[...]}
+  if (Array.isArray(data)) {
+    return data
+      .filter((r) => r && GEMINI_HEADER.test(r.header || ""))
+      .map((r) => ({
+        title: r.title || "",
+        time: r.time || null,
+        subtitles: Array.isArray(r.subtitles) ? r.subtitles : [],
+        details: Array.isArray(r.details) ? r.details : [],
+      }));
+  }
+  // Some guides suggest a {conversations:[{title, create_time, entries:[{role, text}]}]} shape
+  if (Array.isArray(data.conversations)) {
+    const result = [];
+    for (const conv of data.conversations) {
+      const entries = Array.isArray(conv.entries) ? conv.entries : [];
+      for (const e of entries) {
+        result.push({ title: e.text || e.content || "", time: conv.create_time || null, role: e.role || "user" });
+      }
+    }
+    return result;
+  }
+  return [];
+}
+
+/** Group activity entries into sessions by time proximity; each entry becomes a user message. */
+function buildSessions(entries, source) {
+  if (!entries.length) return [];
+  // Sort by time ascending
+  const sorted = [...entries].sort((a, b) => {
+    const ta = a.time ? Date.parse(a.time) : 0;
+    const tb = b.time ? Date.parse(b.time) : 0;
+    return ta - tb;
+  });
+  const sessions = [];
+  let current = null;
+  for (const e of sorted) {
+    const ts = e.time ? (Number.isFinite(Date.parse(e.time)) ? new Date(Date.parse(e.time)).toISOString() : null) : null;
+    const tms = ts ? Date.parse(ts) : 0;
+    // Start new session if gap > SESSION_GAP_MS or no current
+    if (!current || (tms && current._lastTs && tms - current._lastTs > SESSION_GAP_MS)) {
+      current = { entries: [], _firstTs: tms, _lastTs: tms, _source: source };
+      sessions.push(current);
+    }
+    current.entries.push({ ...e, ts });
+    if (tms) current._lastTs = tms;
+  }
+  return sessions.map((s) => buildSession(s));
+}
+
+function buildSession(s) {
+  const messages = [];
+  let firstTs = null, lastTs = null;
+  for (const e of s.entries) {
+    if (!firstTs) firstTs = e.ts;
+    lastTs = e.ts;
+    // Determine role
+    const isUser = !e.role || e.role.toLowerCase() === "user" || e.role.toLowerCase() === "human";
+    const isAssistant = e.role && (e.role.toLowerCase() === "model" || e.role.toLowerCase() === "assistant" || e.role.toLowerCase() === "ai");
+    const text = (e.title || "").replace(/^(Searched for|Chatted with Google Gemini about|Used Google Gemini)\s*/i, "").trim() || e.title || "";
+    // Subtitles can carry extra context
+    const subText = e.subtitles?.map((sub) => (typeof sub === "string" ? sub : sub?.name || "")).filter(Boolean).join("\n") || "";
+    const fullText = [text, subText].filter(Boolean).join("\n").trim();
+    if (!fullText) continue;
+    if (isAssistant) messages.push({ role: "assistant", ts: e.ts, text: fullText });
+    else messages.push({ role: "user", ts: e.ts, text: fullText });
+  }
+  const seed = (firstTs || "") + (s.entries[0]?.title || "");
+  return {
+    format: FORMAT,
+    harness: "gemini",
+    model: "",
+    session_id: `gemini-${createHash("sha256").update(`gemini:${seed}`).digest("hex").slice(0, 16)}`,
+    title: s.entries[0]?.title?.slice(0, 100) || "",
+    started_at: firstTs,
+    ended_at: lastTs,
+    cwd: "",
+    source: "gemini-export",
+    messages,
+  };
+}
+
+export default {
+  id: "gemini",
+  name: "Gemini (Google)",
+  kind: "export",
+  how: "takeout.google.com → Deselect all → My Activity → (Multiple formats → JSON) → All activity data → Gemini Apps → Create export",
+  sniff(l) {
+    const f = l.names.find((n) => GEMINI_FILE.test(n));
+    if (!f) return false;
+    // Confirm it contains Gemini/Bard content
+    const head = l.read(f).slice(0, 100_000);
+    return GEMINI_HEADER.test(head);
+  },
+  *collect(input, { listing: l }) {
+    const f = l.names.find((n) => GEMINI_FILE.test(n));
+    if (!f) return;
+    const raw = l.read(f);
+    const isHtml = f.toLowerCase().endsWith(".html");
+    const entries = isHtml ? parseHtml(raw) : parseJson(raw);
+    yield* buildSessions(entries, f);
+  },
+};

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

@@ -0,0 +1,93 @@
+// Goose (Block/Square AI) stores sessions in a SQLite database at
+// ~/.local/share/goose/sessions/sessions.db.
+//
+// Tables of interest:
+//   sessions  – id, name, working_dir, created_at, updated_at, provider_name, total_tokens,
+//               input_tokens, output_tokens, parent_session_id
+//   messages  – session_id, role, content_json (OpenAI-style content array), created_timestamp,
+//               tokens, message_id
+//
+// content_json is an array of blocks: text {type:"text", text}, tool_use, tool_result, etc.
+// created_timestamp is a Unix millisecond integer.
+
+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) {
+  try {
+    const out = execFileSync("sqlite3", ["-json", db, sql], { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+    return JSON.parse(out || "[]");
+  } catch { return []; }
+}
+
+function textFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((p) => (typeof p === "string" ? p : p?.type === "text" ? (p.text ?? "") : "")).filter(Boolean).join("\n");
+}
+
+export default {
+  id: "goose",
+  name: "Goose (Block AI)",
+  kind: "local",
+  roots: (home) => [path.join(home, ".local", "share", "goose", "sessions")],
+  *collect(root) {
+    const db = path.join(root, "sessions.db");
+    if (!fs.existsSync(db)) return;
+
+    const sessions = query(db, "SELECT id, name, working_dir, created_at, updated_at, provider_name, total_tokens, input_tokens, output_tokens, parent_session_id FROM sessions WHERE archived_at IS NULL ORDER BY created_at");
+    if (!sessions.length) return;
+
+    for (const sess of sessions) {
+      const rows = query(db, `SELECT role, content_json, created_timestamp, tokens, message_id FROM messages WHERE session_id=${JSON.stringify(sess.id)} ORDER BY created_timestamp, id`);
+      if (!rows.length) continue;
+
+      const messages = [];
+      const callNames = new Map();
+      let model = "";
+
+      for (const row of rows) {
+        const ts = row.created_timestamp ? new Date(Number(row.created_timestamp)).toISOString() : undefined;
+        let content; try { content = JSON.parse(row.content_json); } catch { content = []; }
+        if (!Array.isArray(content)) content = [{ type: "text", text: String(content) }];
+
+        if (row.role === "user") {
+          const t = textFromContent(content);
+          if (t) messages.push({ role: "user", ts, text: t });
+        } else if (row.role === "assistant") {
+          const textParts = content.filter((p) => p?.type === "text").map((p) => p.text ?? "").join("\n");
+          const tool_calls = content.filter((p) => p?.type === "tool_use").map((c) => {
+            callNames.set(c.id, c.name);
+            return { id: c.id, name: c.name, input: c.input ?? {} };
+          });
+          if (textParts || tool_calls.length) {
+            messages.push({ role: "assistant", ts, text: textParts, ...(tool_calls.length ? { tool_calls } : {}) });
+          }
+        } else if (row.role === "tool") {
+          // Goose encodes tool results as role:"tool" with content_json being an array of tool_result blocks
+          for (const p of content) {
+            if (p?.type !== "tool_result") continue;
+            const t = textFromContent(p.content);
+            messages.push({ role: "tool", ts, tool_use_id: p.tool_use_id, tool_name: callNames.get(p.tool_use_id), is_error: !!p.is_error, text: t.slice(0, 1_000_000) });
+          }
+        }
+      }
+
+      if (!messages.some((m) => m.role === "user")) continue;
+
+      const usage = {};
+      if (sess.input_tokens) usage.input_tokens = Number(sess.input_tokens);
+      if (sess.output_tokens) usage.output_tokens = Number(sess.output_tokens);
+      const parentId = sess.parent_session_id || undefined;
+
+      yield {
+        format: FORMAT, harness: "goose", session_id: sess.id, model,
+        title: sess.name || "", started_at: sess.created_at, ended_at: sess.updated_at,
+        cwd: sess.working_dir || "", ...(parentId ? { parent_session_id: parentId } : {}),
+        ...(Object.keys(usage).length ? { usage } : {}), messages,
+      };
+    }
+  },
+};

package/vendor/trace-collect/sources/grok-cli.mjs

@@ -0,0 +1,110 @@
+// Grok CLI (x.ai) stores each session under
+//   ~/.grok/sessions/<encoded-cwd>/<session-id>/
+// with two key files:
+//   summary.json   – { id, title, model, created_at, updated_at, parent_session_id, ... }
+//   updates.jsonl  – ACP session update stream; each line is a JSON event:
+//     { type: "user_message",      data: { content: [{type:"text",text}], ... } }
+//     { type: "assistant_message", data: { message: { content: [{type:"text",text}|...] }, usage? } }
+//     { type: "tool_call",         data: { id, name, input } }
+//     { type: "tool_result",       data: { tool_use_id, output, is_error } }
+//     (other structural events like turn_start/end, step_start/end are skipped)
+//
+// The sessions/ dir also holds a session_search.sqlite FTS index which we skip.
+
+import fs from "node:fs";
+import path from "node:path";
+import { FORMAT } from "../normalize.mjs";
+
+function text(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content.map((p) => (typeof p === "string" ? p : p?.type === "text" ? (p.text ?? "") : "")).filter(Boolean).join("\n");
+  return "";
+}
+
+function* sessionsFromGroup(groupDir) {
+  let entries; try { entries = fs.readdirSync(groupDir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    const sessDir = path.join(groupDir, e.name);
+    const summaryPath = path.join(sessDir, "summary.json");
+    const updatesPath = path.join(sessDir, "updates.jsonl");
+    if (!fs.existsSync(updatesPath)) continue;
+    let summary = {}; try { summary = JSON.parse(fs.readFileSync(summaryPath, "utf8")); } catch { /* no summary */ }
+
+    const messages = [];
+    const callNames = new Map();
+    let model = summary.model || "";
+    let started_at = summary.created_at || null;
+    let ended_at = summary.updated_at || null;
+
+    let raw; try { raw = fs.readFileSync(updatesPath, "utf8"); } catch { continue; }
+    for (const line of raw.split("\n")) {
+      const t = line.trim();
+      if (!t) continue;
+      let ev; try { ev = JSON.parse(t); } catch { continue; }
+      const { type, data = {}, time } = ev;
+      const ts = time ? new Date(typeof time === "number" ? time : time).toISOString() : undefined;
+      if (ts) { started_at ||= ts; ended_at = ts; }
+
+      if (type === "user_message" || type === "user/message") {
+        const t2 = text(data.content ?? data.text ?? "");
+        if (t2) messages.push({ role: "user", ts, text: t2 });
+      } else if (type === "assistant_message" || type === "assistant/message") {
+        const msg = data.message ?? data;
+        model ||= msg.model || "";
+        const t2 = text(msg.content ?? msg.text ?? "");
+        const thinking = (Array.isArray(msg.content) ? msg.content : []).filter((p) => p?.type === "reasoning" || p?.type === "thinking").map((p) => p.text ?? "").join("\n");
+        if (t2 || thinking) messages.push({ role: "assistant", ts, text: t2, ...(thinking ? { thinking } : {}) });
+      } else if (type === "tool_call" || type === "tool/call") {
+        const id = data.callId ?? data.id ?? "";
+        const name = data.name ?? "";
+        let input = data.arguments ?? data.input ?? {};
+        if (typeof input === "string") { try { input = JSON.parse(input); } catch { /* keep */ } }
+        callNames.set(id, name);
+        const last = messages[messages.length - 1];
+        const call = { id, name, input };
+        if (last?.role === "assistant" && !last.text) (last.tool_calls ||= []).push(call);
+        else messages.push({ role: "assistant", ts, text: "", tool_calls: [call] });
+      } else if (type === "tool_result" || type === "tool/result") {
+        const msg = data.message ?? data;
+        const content = Array.isArray(msg.content) ? msg.content : [];
+        // Grok wraps results in tool-result blocks inside data.message.content[]
+        const resultBlocks = content.filter((p) => p?.type === "tool-result" || p?.type === "tool_result");
+        if (resultBlocks.length) {
+          for (const p of resultBlocks) {
+            const rid = p.toolCallId ?? p.tool_use_id ?? data.callId ?? data.id ?? "";
+            const inner = Array.isArray(p.content) ? p.content.map((c) => c?.text ?? String(c ?? "")).join("") : String(p.content ?? "");
+            messages.push({ role: "tool", ts, tool_use_id: rid, tool_name: callNames.get(rid), is_error: !!(p.isError || data.is_error), text: inner.slice(0, 1_000_000) });
+          }
+        } else {
+          // Flat format: data.output or data.tool_use_id
+          const id = data.tool_use_id ?? data.callId ?? data.id ?? "";
+          const out = typeof data.output === "string" ? data.output : JSON.stringify(data.output ?? "");
+          messages.push({ role: "tool", ts, tool_use_id: id, tool_name: callNames.get(id), is_error: !!data.is_error, text: out.slice(0, 1_000_000) });
+        }
+      }
+    }
+
+    if (!messages.some((m) => m.role === "user")) continue;
+    const sessionId = summary.id || e.name;
+    const parentId = summary.parent_session_id || undefined;
+    yield { format: FORMAT, harness: "grok-cli", session_id: sessionId, model, title: summary.title || "", started_at, ended_at, cwd: summary.cwd || "", ...(parentId ? { parent_session_id: parentId } : {}), messages };
+  }
+}
+
+export default {
+  id: "grok-cli",
+  name: "Grok CLI (xAI)",
+  kind: "local",
+  roots: (home) => [path.join(home, ".grok")],
+  *collect(root) {
+    const sessionsDir = path.join(root, "sessions");
+    if (!fs.existsSync(sessionsDir)) return;
+    let groups; try { groups = fs.readdirSync(sessionsDir, { withFileTypes: true }); } catch { return; }
+    for (const g of groups) {
+      // Skip the sqlite FTS index and WAL files
+      if (!g.isDirectory()) continue;
+      yield* sessionsFromGroup(path.join(sessionsDir, g.name));
+    }
+  },
+};

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

@@ -0,0 +1,83 @@
+// xAI Grok data export: accounts.x.ai → Settings → Data → Export Data.
+// The download is a zip (or single JSON file) containing prod-grok-backend.json with
+// a top-level `conversations` array; each entry holds a `responses` array of turn objects.
+// Timestamps use MongoDB extended JSON: { "$date": { "$numberLong": "<ms-epoch>" } }.
+// Evidence: ai-chat-importer.com/blog/how-to-export-grok-conversations
+
+import { createHash } from "node:crypto";
+import { FORMAT } from "../normalize.mjs";
+
+const GROK_FILE = /(?:^|\/)prod-grok-backend\.json$/;
+
+/** Decode a MongoDB extended-JSON timestamp to an ISO string (or null). */
+function decodeMongoTs(v) {
+  if (!v) return null;
+  if (typeof v === "number") return new Date(v).toISOString();
+  if (typeof v === "string") return Number.isFinite(Number(v)) ? new Date(Number(v)).toISOString() : v;
+  // { "$date": { "$numberLong": "..." } }
+  const inner = v["$date"];
+  if (!inner) return null;
+  if (typeof inner === "string") return Number.isFinite(Number(inner)) ? new Date(Number(inner)).toISOString() : inner;
+  const long = inner["$numberLong"];
+  return long != null ? new Date(Number(long)).toISOString() : null;
+}
+
+function grokSession(conv) {
+  const messages = [];
+  for (const r of conv.responses || []) {
+    const role = (r.sender || r.role || "").toLowerCase();
+    const text = typeof r.message === "string" ? r.message : (r.content || r.text || "");
+    const ts = decodeMongoTs(r.create_time || r.created_at || r.timestamp);
+    if (!text) continue;
+    if (role === "human" || role === "user") {
+      messages.push({ role: "user", ts, text });
+    } else if (role === "assistant" || role === "ai" || role === "grok") {
+      messages.push({ role: "assistant", ts, text });
+    }
+  }
+  const started_at = decodeMongoTs(conv.create_time || conv.created_at);
+  const ended_at = decodeMongoTs(conv.update_time || conv.updated_at);
+  return {
+    format: FORMAT,
+    harness: "grok",
+    model: conv.model || "",
+    session_id: `grok-${createHash("sha256").update(`grok:${conv.id || conv.title || ""}`).digest("hex").slice(0, 16)}`,
+    title: conv.title || "",
+    started_at,
+    ended_at,
+    cwd: "",
+    source: "grok-export",
+    messages,
+  };
+}
+
+export function grokSessions(convs) {
+  return convs.map((c) => {
+    try { return grokSession(c); } catch { return null; }
+  }).filter((s) => s && s.messages.some((m) => m.role === "user") && s.messages.some((m) => m.role === "assistant"));
+}
+
+function readGrokData(l) {
+  const f = l.names.find((n) => GROK_FILE.test(n));
+  if (!f) return [];
+  const raw = l.read(f);
+  let data;
+  try { data = JSON.parse(raw); } catch { return []; }
+  // Top level can be { conversations: [...] } or just [...]
+  if (Array.isArray(data)) return data;
+  if (Array.isArray(data.conversations)) return data.conversations;
+  return [];
+}
+
+export default {
+  id: "grok",
+  name: "Grok (xAI)",
+  kind: "export",
+  how: "accounts.x.ai → Data → Download account data → Export; download the zip from the email",
+  sniff(l) {
+    return l.names.some((n) => GROK_FILE.test(n));
+  },
+  *collect(input, { listing: l }) {
+    yield* grokSessions(readGrokData(l));
+  },
+};

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

@@ -0,0 +1,4 @@
+// Hermes: read in place by the scan (lib/normalize.mjs); listed here so every agent shows up in one registry.
+import path from "node:path";
+
+export default { id: "hermes", name: "Hermes", kind: "native", roots: (home) => [path.join(home, ".hermes/sessions")] };