@agentsky/sky 2.20.2 → 2.22.0

package/vendor/trace-collect/sources/cursor-chat.mjs

@@ -0,0 +1,274 @@
+// Cursor chat / composer history.
+// Source: ~/Library/Application Support/Cursor/User/globalStorage/state.vscdb (SQLite)
+//         ~/Library/Application Support/Cursor/User/workspaceStorage/*/state.vscdb
+//
+// Tables used:
+//   composerHeaders – one row per composer: composerId, workspaceId, createdAt, lastUpdatedAt,
+//                     isArchived, isSubagent, value (JSON head with name/subtitle/workspace)
+//   cursorDiskKV    – key=composerData:<id> : composer metadata + fullConversationHeadersOnly
+//                   – key=bubbleId:<composerId>:<bubbleId> : individual message bubble
+//
+// Bubble types: 1=user, 2=assistant.
+// capabilityType: 15=tool call/result (toolFormerData has id/name/rawArgs/status),
+//                 30=thinking (thinking field as JSON string with {text}).
+//
+// De-duplication vs "cursor" native source: that source reads ~/.cursor/projects JSONL
+// (agent-transcript format).  composer data in state.vscdb is the chat UI and is never
+// stored under ~/.cursor/projects – no overlap.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { FORMAT } from "../normalize.mjs";
+
+const GLOBAL_DB = "Library/Application Support/Cursor/User/globalStorage/state.vscdb";
+const WORKSPACE_DB_GLOB = "Library/Application Support/Cursor/User/workspaceStorage";
+
+function dbRoots(home) {
+  const roots = [];
+  const global = path.join(home, GLOBAL_DB);
+  if (fs.existsSync(global)) roots.push(global);
+  const wsRoot = path.join(home, WORKSPACE_DB_GLOB);
+  try {
+    for (const d of fs.readdirSync(wsRoot)) {
+      const p = path.join(wsRoot, d, "state.vscdb");
+      if (fs.existsSync(p)) roots.push(p);
+    }
+  } catch { /* no workspace storage */ }
+  return roots;
+}
+
+/** workspaceStorage/<id>/workspace.json → the folder (or first folder of a .code-workspace) that id stands for. */
+function workspaceFolders(home) {
+  const out = new Map();
+  const wsRoot = path.join(home, WORKSPACE_DB_GLOB);
+  let ids = []; try { ids = fs.readdirSync(wsRoot); } catch { return out; }
+  for (const id of ids) {
+    try {
+      const j = JSON.parse(fs.readFileSync(path.join(wsRoot, id, "workspace.json"), "utf8"));
+      let uri = j.folder;
+      if (!uri && j.workspace) { const w = JSON.parse(fs.readFileSync(new URL(j.workspace), "utf8")); uri = w.folders?.[0]?.path ? new URL(w.folders[0].path, j.workspace).href : null; }
+      if (uri?.startsWith("file://")) out.set(id, decodeURIComponent(new URL(uri).pathname));
+    } catch { /* remote or deleted workspace */ }
+  }
+  return out;
+}
+const uriPath = (u) => (typeof u === "string" ? (u.startsWith("file://") ? decodeURIComponent(new URL(u).pathname) : u) : u?.fsPath || u?.path || "");
+
+/** Copy db (and WAL/SHM if present) to a temp path so sqlite3 can access it without locks.
+ *  Note: -readonly fails in WAL mode because sqlite needs to write a checkpoint; we use
+ *  a fresh copy instead and open without -readonly. */
+function tempCopy(dbPath) {
+  const suffix = createHash("md5").update(dbPath).digest("hex").slice(0, 8);
+  const tmp = path.join(os.tmpdir(), `cursor-chat-${suffix}.vscdb`);
+  try { fs.copyFileSync(dbPath, tmp); } catch { return null; }
+  // Copy WAL and SHM if present so sqlite3 can read a consistent snapshot
+  for (const ext of ["-wal", "-shm"]) {
+    try { fs.copyFileSync(dbPath + ext, tmp + ext); } catch { /* ok if absent */ }
+  }
+  return tmp;
+}
+
+function queryJson(db, sql) {
+  try {
+    const out = execFileSync("sqlite3", ["-json", db, sql], { encoding: "utf8", maxBuffer: 512 * 1024 * 1024 });
+    return JSON.parse(out || "[]");
+  } catch { return []; }
+}
+
+function parseThinking(raw) {
+  if (!raw) return "";
+  if (typeof raw === "object") return raw.text || JSON.stringify(raw);
+  try {
+    const p = JSON.parse(raw);
+    if (p && typeof p.text === "string") return p.text;
+    return raw;
+  } catch { return raw; }
+}
+
+function parseInput(rawArgs) {
+  if (!rawArgs) return {};
+  try { return JSON.parse(rawArgs); } catch { return { _raw: rawArgs }; }
+}
+
+/** Convert bubbles (ordered by fullConversationHeadersOnly) into trace/v1 messages. */
+function buildMessages(headers, bubbleMap) {
+  const messages = [];
+
+  for (const h of headers) {
+    const bub = bubbleMap.get(h.bubbleId);
+    if (!bub) continue;
+
+    const ts = h.createdAt || bub.createdAt || null;
+    const btype = bub.type ?? h.type;
+    const capType = bub.capabilityType ?? h.grouping?.capabilityType ?? null;
+
+    if (btype === 1) {
+      // User message
+      const text = bub.text || bub.richText || "";
+      const attachments = [];
+      for (const img of (bub.images || [])) {
+        attachments.push({ kind: "image", media_type: img.mediaType || "image/png", name: img.fileName || "" });
+      }
+      if (text || attachments.length) {
+        messages.push({ role: "user", ts, text, ...(attachments.length ? { attachments } : {}) });
+      }
+      continue;
+    }
+
+    if (btype === 2) {
+      if (capType === 30) {
+        // Thinking bubble
+        const thinking = parseThinking(bub.thinking);
+        if (thinking) messages.push({ role: "assistant", ts, text: "", thinking });
+        continue;
+      }
+
+      if (capType === 15) {
+        // Tool call + result bubble
+        const tfd = bub.toolFormerData;
+        if (tfd && tfd.toolCallId) {
+          const callId = tfd.toolCallId;
+          const name = tfd.name || "tool";
+          const input = parseInput(tfd.rawArgs);
+          const isError = tfd.status === "failed" || tfd.status === "error";
+
+          // Attach call to preceding assistant bubble or create new one
+          const last = messages[messages.length - 1];
+          if (last?.role === "assistant" && !last.text && !last.thinking) {
+            (last.tool_calls ||= []).push({ id: callId, name, input });
+          } else {
+            messages.push({ role: "assistant", ts, text: "", tool_calls: [{ id: callId, name, input }] });
+          }
+          // Result – the binary is protobuf; emit empty text to satisfy tool_use_id linkage
+          messages.push({ role: "tool", ts, tool_use_id: callId, tool_name: name, is_error: isError, text: "" });
+        }
+        continue;
+      }
+
+      // Normal assistant text / fallback
+      const text = bub.text || "";
+      const thinking = parseThinking(bub.thinking);
+      if (text || thinking) {
+        messages.push({ role: "assistant", ts, text, ...(thinking ? { thinking } : {}) });
+      }
+    }
+  }
+  return messages;
+}
+
+function* collectDb(dbPath, home) {
+  const tmp = tempCopy(dbPath);
+  if (!tmp) return;
+  try {
+    // Load composer metadata
+    const headers = queryJson(tmp, "SELECT composerId, workspaceId, createdAt, lastUpdatedAt, isArchived, value FROM composerHeaders WHERE isArchived=0 ORDER BY lastUpdatedAt ASC");
+    if (!headers.length) return;
+
+    const composerIds = headers.map((h) => h.composerId);
+
+    // Load all bubbleId keys for these composers in one query
+    const idList = composerIds.map((id) => `'${id.replace(/'/g, "''")}'`).join(",");
+    const bubbleRows = queryJson(tmp, `SELECT key, value FROM cursorDiskKV WHERE key LIKE 'bubbleId:%' AND substr(key, 10, instr(substr(key,10),':')-1) IN (${idList}) LIMIT 200000`);
+
+    // Build per-composer bubble maps
+    const perComposer = new Map();
+    for (const row of bubbleRows) {
+      // key = bubbleId:<composerId>:<bubbleId>
+      const rest = row.key.slice("bubbleId:".length);
+      const colon = rest.indexOf(":");
+      if (colon < 0) continue;
+      const cid = rest.slice(0, colon);
+      const bid = rest.slice(colon + 1);
+      let bub;
+      try { bub = JSON.parse(row.value); } catch { continue; }
+      let map = perComposer.get(cid);
+      if (!map) { map = new Map(); perComposer.set(cid, map); }
+      map.set(bid, bub);
+    }
+
+    // Load composerData for each (to get fullConversationHeadersOnly order)
+    const cdRows = queryJson(tmp, `SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%' AND substr(key, 14) IN (${idList})`);
+    const composerData = new Map();
+    for (const row of cdRows) {
+      const cid = row.key.slice("composerData:".length);
+      try { composerData.set(cid, JSON.parse(row.value)); } catch { }
+    }
+
+    const folders = workspaceFolders(home);
+    // Pre-edit contents Cursor keeps for every file a composer changed, referenced by contentKey.
+    const contentKeys = [...composerData.values()].flatMap((cd) => Object.values(cd?.originalFileStates ?? {}).map((f) => f?.contentKey)).filter((k) => typeof k === "string");
+    const originals = new Map();
+    for (let i = 0; i < contentKeys.length; i += 400) {
+      const list = contentKeys.slice(i, i + 400).map((k) => `'${k.replace(/'/g, "''")}'`).join(",");
+      for (const r of queryJson(tmp, `SELECT key, value FROM cursorDiskKV WHERE key IN (${list})`)) originals.set(r.key, r.value);
+    }
+    for (const h of headers) {
+      const cid = h.composerId;
+      const bubMap = perComposer.get(cid) || new Map();
+      const cd = composerData.get(cid);
+      const orderedHeaders = cd?.fullConversationHeadersOnly || [];
+      if (!orderedHeaders.length && bubMap.size === 0) continue;
+
+      let meta;
+      try { meta = JSON.parse(h.value); } catch { meta = {}; }
+
+      const messages = buildMessages(orderedHeaders, bubMap);
+      if (!messages.some((m) => m.role === "user")) continue;
+
+      const models = [...new Set(
+        [...bubMap.values()]
+          .map((b) => b.modelType)
+          .filter((m) => m && typeof m === "string")
+      )];
+
+      const started = h.createdAt ? new Date(Number(h.createdAt)).toISOString() : null;
+      const ended = h.lastUpdatedAt ? new Date(Number(h.lastUpdatedAt)).toISOString() : null;
+      const wsId = cd?.workspaceIdentifier ?? meta.workspaceIdentifier ?? {};
+      const repos = (cd?.trackedGitRepos ?? []).filter((r) => r?.repoPath);
+      const workspace = uriPath(wsId.uri) || folders.get(wsId.id || h.workspaceId) || repos[0]?.repoPath || "";
+      const touched = [
+        ...Object.entries(cd?.originalFileStates ?? {}).map(([uri, f]) => {
+          const raw = f?.contentKey ? originals.get(f.contentKey) : null;
+          let before = null; try { before = raw == null ? null : typeof JSON.parse(raw) === "string" ? JSON.parse(raw) : raw; } catch { before = raw; }
+          return { path: uriPath(uri), op: "write", ...(f?.isNewlyCreated ? { created: true } : before != null ? { original_text: before } : {}) };
+        }),
+        ...(cd?.newlyCreatedFiles ?? []).map((f) => ({ path: uriPath(f?.uri), op: "write", created: true })),
+        ...(cd?.context?.fileSelections ?? []).map((f) => ({ path: uriPath(f?.uri ?? f), op: "read" })),
+      ].filter((f) => f.path);
+      const modelName = cd?.modelConfig?.modelName;
+
+      yield {
+        format: FORMAT,
+        harness: "cursor-chat",
+        session_id: `cursor-chat-${createHash("sha256").update(`cursor-chat:${cid}`).digest("hex").slice(0, 16)}`,
+        model: (modelName && modelName !== "default" ? modelName : "") || models[0] || "",
+        ...(models.length > 1 ? { models } : {}),
+        title: meta.name || meta.subtitle || "",
+        started_at: started,
+        ended_at: ended,
+        cwd: workspace,
+        ...(repos.length ? { git: { root: repos[0].repoPath, branch: repos[0].branches?.at(-1)?.branchName || "" }, tracked_git_repos: repos.map((r) => ({ path: r.repoPath, branches: (r.branches ?? []).map((b) => b.branchName) })) } : {}),
+        ...(touched.length ? { touched_files: touched } : {}),
+        ...(cd?.contextTokensUsed != null ? { context_usage: { tokens_used: cd.contextTokensUsed, token_limit: cd.contextTokenLimit, breakdown: cd.promptTokenBreakdown?.categories } } : {}),
+        source: dbPath,
+        messages,
+      };
+    }
+  } finally {
+    try { fs.unlinkSync(tmp); } catch { }
+  }
+}
+
+export default {
+  id: "cursor-chat",
+  name: "Cursor Chat / Composer",
+  kind: "local",
+  roots: (home) => dbRoots(home),
+
+  *collect(root, ctx = {}) {
+    yield* collectDb(root, ctx.home || root.slice(0, root.indexOf("/Library/")) || os.homedir());
+  },
+};

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

@@ -0,0 +1,4 @@
+// Cursor agent transcripts: 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: "cursor", name: "Cursor agent transcripts", kind: "native", roots: (home) => [path.join(home, ".cursor/projects")] };

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

@@ -0,0 +1,172 @@
+// DeepSeek chat export: Settings → Data → Export → conversations.json.
+// Uses a mapping-node tree (like ChatGPT) but messages carry a `fragments` array
+// instead of a `content.parts` array. Fragment types include REQUEST (user input),
+// RESPONSE (assistant reply), THINK (chain-of-thought reasoning → thinking field),
+// and SEARCH (web search → tool_call + tool result pair).
+// Evidence: task description (format confirmed from real DeepSeek exports) and
+//           greasyfork.org/en/scripts/523474 (multi-segment thinking chain note)
+
+import { createHash } from "node:crypto";
+import { FORMAT } from "../normalize.mjs";
+
+const CONV_FILE = /(?:^|\/)conversations\.json$/;
+
+/** Follow current_node (if present) or the latest-updated leaf back to root. */
+function mainBranch(mapping, currentNode) {
+  const ids = Object.keys(mapping);
+  // Prefer explicit current_node; fall back to latest created_at leaf
+  let startId = currentNode;
+  if (!startId || !mapping[startId]) {
+    const leaves = ids.filter((id) => !mapping[id].children?.length);
+    if (!leaves.length) startId = ids[ids.length - 1];
+    else startId = leaves.reduce((a, b) => {
+      const ta = mapping[a].message?.created_at || 0;
+      const tb = mapping[b].message?.created_at || 0;
+      return tb > ta ? b : a;
+    }, leaves[0]);
+  }
+  const chain = [];
+  let id = startId;
+  const seen = new Set();
+  while (id && !seen.has(id)) {
+    seen.add(id);
+    const node = mapping[id];
+    if (!node) break;
+    if (node.message) chain.unshift(node);
+    id = node.parent;
+  }
+  return chain;
+}
+
+function deepseekSession(conv) {
+  const mapping = conv.mapping || {};
+  const branch = mainBranch(mapping, conv.current_node);
+  const messages = [];
+  let callCounter = 0;
+
+  for (const node of branch) {
+    const m = node.message;
+    if (!m) continue;
+    const role = (m.role || "").toLowerCase();
+    const fragments = Array.isArray(m.fragments) ? m.fragments : [];
+    const ts = m.created_at ? (typeof m.created_at === "number" ? new Date(m.created_at * 1000).toISOString() : m.created_at) : undefined;
+
+    if (role === "user") {
+      const parts = fragments
+        .filter((f) => f.type === "REQUEST" || !f.type)
+        .map((f) => f.content || f.text || "")
+        .filter(Boolean);
+      const text = parts.join("\n") || (m.content || m.text || "");
+      if (text) messages.push({ role: "user", ts, text });
+      continue;
+    }
+
+    if (role === "assistant") {
+      let text = "";
+      let thinking = "";
+      const toolCalls = [];
+      const pendingResults = [];
+
+      for (const f of fragments) {
+        const ftype = (f.type || "").toUpperCase();
+        const fcontent = f.content || f.text || "";
+
+        if (ftype === "RESPONSE") {
+          text += (text ? "\n" : "") + fcontent;
+        } else if (ftype === "THINK") {
+          thinking += (thinking ? "\n" : "") + fcontent;
+        } else if (ftype === "SEARCH") {
+          // SEARCH → tool_call (web_search) + tool result
+          callCounter++;
+          const callId = `ds-search-${node.id || callCounter}`;
+          let input, resultText;
+          try {
+            // f may have { query, results } or just { content }
+            if (f.query || f.results !== undefined) {
+              input = { query: f.query || "" };
+              resultText = typeof f.results === "string" ? f.results : JSON.stringify(f.results ?? "");
+            } else {
+              // Try to parse content as JSON
+              const parsed = typeof fcontent === "string" ? JSON.parse(fcontent) : fcontent;
+              input = { query: parsed.query || fcontent };
+              resultText = typeof parsed.results === "string" ? parsed.results : JSON.stringify(parsed.results ?? parsed);
+            }
+          } catch {
+            input = { query: fcontent };
+            resultText = fcontent;
+          }
+          toolCalls.push({ id: callId, name: "web_search", input });
+          pendingResults.push({ role: "tool", ts, tool_use_id: callId, tool_name: "web_search", is_error: false, text: resultText.slice(0, 1_000_000) });
+        } else if (!ftype) {
+          // Untyped fragment: treat as response text
+          text += (text ? "\n" : "") + fcontent;
+        }
+      }
+
+      // Fallback: use message-level content if no fragments produced text
+      if (!text && !thinking && !toolCalls.length) {
+        const fallback = m.content || m.text || "";
+        if (fallback) text = typeof fallback === "string" ? fallback : JSON.stringify(fallback);
+      }
+
+      if (text || thinking || toolCalls.length) {
+        messages.push({
+          role: "assistant", ts, text,
+          ...(thinking ? { thinking } : {}),
+          ...(toolCalls.length ? { tool_calls: toolCalls } : {}),
+        });
+      }
+      for (const r of pendingResults) messages.push(r);
+      continue;
+    }
+  }
+
+  const models = [...new Set(
+    branch.map((n) => n.message?.model || n.message?.model_slug).filter(Boolean)
+  )];
+
+  return {
+    format: FORMAT,
+    harness: "deepseek",
+    model: conv.model || models[0] || "",
+    ...(models.length > 1 ? { models } : {}),
+    session_id: `deepseek-${createHash("sha256").update(`deepseek:${conv.id || conv.title || ""}`).digest("hex").slice(0, 16)}`,
+    title: conv.title || "",
+    started_at: conv.create_time ? (typeof conv.create_time === "number" ? new Date(conv.create_time * 1000).toISOString() : conv.create_time) : null,
+    ended_at: conv.update_time ? (typeof conv.update_time === "number" ? new Date(conv.update_time * 1000).toISOString() : conv.update_time) : null,
+    cwd: "",
+    source: "deepseek-export",
+    messages,
+  };
+}
+
+export function deepseekSessions(convs) {
+  return convs.map((c) => {
+    try { return deepseekSession(c); } catch { return null; }
+  }).filter((s) => s && s.messages.some((m) => m.role === "user") && s.messages.some((m) => m.role === "assistant"));
+}
+
+function readConversations(l) {
+  const f = l.names.find((n) => CONV_FILE.test(n));
+  if (!f) return [];
+  let data;
+  try { data = JSON.parse(l.read(f)); } catch { return []; }
+  return Array.isArray(data) ? data : [];
+}
+
+export default {
+  id: "deepseek",
+  name: "DeepSeek",
+  kind: "export",
+  how: "chat.deepseek.com → Settings → Data → Export → download conversations.json",
+  sniff(l) {
+    const f = l.names.find((n) => CONV_FILE.test(n));
+    if (!f) return false;
+    const head = l.read(f).slice(0, 200_000);
+    // "fragments" is unique to DeepSeek; "chat_messages" = claude-ai; "current_node" without "fragments" = chatgpt
+    return head.includes('"fragments"') && !head.includes('"chat_messages"');
+  },
+  *collect(input, { listing: l }) {
+    yield* deepseekSessions(readConversations(l));
+  },
+};

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

@@ -0,0 +1,145 @@
+// DSH (DeepSeek Harness) stores each session as a zstd-compressed JSONL file:
+//   ~/.dsh/sessions/<encoded-cwd>/<session-id>/session.jsonl.zstd
+//
+// Each line in the decompressed JSONL is one event:
+//   { type:"session",          id, createdAt, cwd, delegationDepth, parentSession? }
+//   { type:"user/message",     seq, time, data:{content:[{type:"text",text}], role, id} }
+//   { type:"assistant/message",seq, time, data:{turn,step,message:{role,content,id},usage?} }
+//       content blocks: {type:"text",text} | {type:"reasoning",text}
+//   { type:"tool/call",        seq, time, data:{callId,name,arguments} }
+//   { type:"tool/result",      seq, time, data:{message:{content:[{type:"tool-result",
+//       toolCallId,content:[{type:"text",text}],isError}]}} }
+//   (other event types are structural markers and are skipped)
+//
+// Uses Node's built-in zstd (22.15+), or the `zstd` CLI on older Nodes.
+// Performance: large sessions have 100k+ lines but only a small fraction are relevant.
+// We fast-path by reading the type value directly from the raw line before JSON.parse.
+
+import fs from "node:fs";
+import zlib from "node:zlib";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { FORMAT } from "../normalize.mjs";
+
+// Max decompressed size per session; 300 MB covers even the largest known sessions.
+const MAX_BUF = 300 * 1024 * 1024;
+// Only these event types carry data we need; everything else (hook/invoked, reasoning-chunks, etc.) is skipped.
+const KEEP = new Set(["session", "user/message", "assistant/message", "tool/call", "tool/result"]);
+// All DSH JSONL lines start with this prefix; type value starts at character index 9.
+const TYPE_PREFIX = '{"type":"';
+
+// DSH appends a zstd frame per write. Node's zstdDecompressSync stops after the first frame, so prefer the zstd CLI
+// and, without it, decompress frame by frame (split at the frame magic; a false split just merges with the next piece).
+const MAGIC = Buffer.from([0x28, 0xb5, 0x2f, 0xfd]);
+let hasCli = null;
+function decompress(zstdFile) {
+  if (hasCli !== false) {
+    try { return execFileSync("zstd", ["-d", "-c", zstdFile], { stdio: ["ignore", "pipe", "ignore"], maxBuffer: MAX_BUF }); }
+    catch (e) { if (e.code !== "ENOENT") return null; hasCli = false; }
+  }
+  if (!zlib.zstdDecompressSync) return null;
+  const buf = fs.readFileSync(zstdFile), out = [];
+  let start = 0, pending = null;
+  for (let i = buf.indexOf(MAGIC, 1); start < buf.length; i = buf.indexOf(MAGIC, i + 1)) {
+    const end = i < 0 ? buf.length : i;
+    const piece = pending ? Buffer.concat([pending, buf.subarray(start, end)]) : buf.subarray(start, end);
+    try { out.push(zlib.zstdDecompressSync(piece)); pending = null; } catch { pending = piece; }
+    start = end;
+    if (i < 0) break;
+  }
+  return out.length ? Buffer.concat(out) : null;
+}
+
+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* sessionsFromGroupDir(groupDir) {
+  let sessIds; try { sessIds = fs.readdirSync(groupDir, { withFileTypes: true }); } catch { return; }
+  for (const e of sessIds) {
+    if (!e.isDirectory()) continue;
+    const zstdPath = path.join(groupDir, e.name, "session.jsonl.zstd");
+    if (!fs.existsSync(zstdPath)) continue;
+    const buf = decompress(zstdPath);
+    if (!buf) continue;
+
+    const messages = [];
+    const callNames = new Map();
+    let sessionId = e.name, cwd = "", createdAt = null, parentSession = null, model = "";
+
+    for (const line of buf.toString("utf8").split("\n")) {
+      // Fast-path: extract the type value at a fixed offset before paying for JSON.parse.
+      // All DSH lines start with {"type":"<value>", so the value begins at index 9.
+      if (line.length < 10 || !line.startsWith(TYPE_PREFIX)) continue;
+      const q = line.indexOf('"', 9);
+      if (q < 0) continue;
+      const type = line.slice(9, q);
+      if (!KEEP.has(type)) continue;
+      let ev; try { ev = JSON.parse(line); } catch { continue; }
+      const { data = {}, time } = ev;
+      const ts = time ? new Date(typeof time === "number" ? time : time).toISOString() : undefined;
+
+      if (type === "session") {
+        sessionId = ev.id || sessionId;
+        cwd = ev.cwd || "";
+        createdAt = ev.createdAt ? new Date(ev.createdAt).toISOString() : null;
+        parentSession = ev.parentSession || null;
+        continue;
+      }
+      if (type === "user/message") {
+        const t2 = text(data.content);
+        if (t2) messages.push({ role: "user", ts, text: t2 });
+      } else if (type === "assistant/message") {
+        const msg = data.message ?? {};
+        model ||= msg.model || "";
+        const content = Array.isArray(msg.content) ? msg.content : [];
+        const t2 = content.filter((p) => p?.type === "text").map((p) => p.text ?? "").join("\n");
+        const thinking = content.filter((p) => p?.type === "reasoning").map((p) => p.text ?? "").join("\n");
+        if (t2 || thinking) messages.push({ role: "assistant", ts, text: t2, ...(thinking ? { thinking } : {}) });
+        // Record usage
+        if (data.usage) { /* usage is per-turn; aggregate if needed */ }
+      } else if (type === "tool/call") {
+        const id = data.callId ?? "";
+        const name = data.name ?? "";
+        let input = data.arguments ?? {};
+        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") {
+        const msg = data.message ?? {};
+        const content = Array.isArray(msg.content) ? msg.content : [];
+        for (const p of content) {
+          if (p?.type !== "tool-result") continue;
+          const id = p.toolCallId ?? "";
+          const out = text(p.content);
+          messages.push({ role: "tool", ts, tool_use_id: id, tool_name: callNames.get(id), is_error: !!p.isError, text: out.slice(0, 1_000_000) });
+        }
+      }
+    }
+
+    if (!messages.some((m) => m.role === "user")) continue;
+    yield {
+      format: FORMAT, harness: "dsh", session_id: sessionId, model, title: "", started_at: createdAt, ended_at: null, cwd,
+      ...(parentSession ? { parent_session_id: parentSession } : {}), messages,
+    };
+  }
+}
+
+export default {
+  id: "dsh",
+  name: "DeepSeek Harness (DSH)",
+  kind: "local",
+  roots: (home) => [path.join(home, ".dsh", "sessions")],
+  *collect(root) {
+    let groups; try { groups = fs.readdirSync(root, { withFileTypes: true }); } catch { return; }
+    for (const g of groups) {
+      if (!g.isDirectory()) continue;
+      yield* sessionsFromGroupDir(path.join(root, g.name));
+    }
+  },
+};