sessiongraph 1.0.2 → 1.0.3

package/dist-server/server.mjs

@@ -2138,7 +2138,7 @@ var init_promise = __esm({
 import { createServer } from "node:http";
 import { createReadStream } from "node:fs";
 import { stat as stat5 } from "node:fs/promises";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { resolve as resolve2, extname, sep as sep4 } from "node:path";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 
@@ -2239,9 +2239,9 @@ function contenderFailure(contender) {
 function contenderFinished2(contender) {
   return contender.error() !== void 0 || contender.closed();
 }
-function startupError(message, stderr) {
-  return new Error(stderr ? `${message}
-${stderr}` : message);
+function startupError(message2, stderr) {
+  return new Error(stderr ? `${message2}
+${stderr}` : message2);
 }
 
 // node_modules/.pnpm/@opencode+client@2.2.1_effect@4.0.1/node_modules/@opencode/client/dist/chunks/mcp-xgnj2w4v.js
@@ -2284,8 +2284,8 @@ function decide2(service, options) {
     return fail("Background service failed to start");
   return { _tag: "wait" };
 }
-function fail(message) {
-  return { _tag: "fail", error: new Error(message) };
+function fail(message2) {
+  return { _tag: "fail", error: new Error(message2) };
 }
 function fallback2() {
   return join(process.env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state"), "opencode", "service.json");
@@ -2743,15 +2743,15 @@ function summarizeMessages(id2, messages, nextCursor) {
   const tools = /* @__PURE__ */ new Map();
   const locations = [];
   let snapshotSteps = 0;
-  for (const message of messages) {
+  for (const message2 of messages) {
     const stepFiles = /* @__PURE__ */ new Map();
-    if (message.snapshot?.start && message.snapshot?.end) snapshotSteps++;
-    for (const path of message.snapshot?.files || []) stepFiles.set(path, "snapshot");
-    for (const part of message.content || []) {
+    if (message2.snapshot?.start && message2.snapshot?.end) snapshotSteps++;
+    for (const path of message2.snapshot?.files || []) stepFiles.set(path, "snapshot");
+    for (const part of message2.content || []) {
       if (part.type !== "tool") continue;
       const name = part.name || "unknown";
       tools.set(name, (tools.get(name) || 0) + 1);
-      if (!message.snapshot?.start || !message.snapshot?.end) {
+      if (!message2.snapshot?.start || !message2.snapshot?.end) {
         for (const path of editedPaths(part)) stepFiles.set(path, "edit tool");
       }
     }
@@ -2759,8 +2759,8 @@ function summarizeMessages(id2, messages, nextCursor) {
       const previous = files.get(path);
       files.set(path, { path, source: previous?.source === "snapshot" ? "snapshot" : source, steps: (previous?.steps || 0) + 1 });
     }
-    if (message.type === "location-switched" && message.location) {
-      locations.push({ directory: message.location.directory, time: message.time.created });
+    if (message2.type === "location-switched" && message2.location) {
+      locations.push({ directory: message2.location.directory, time: message2.time.created });
     }
   }
   return {
@@ -2783,8 +2783,8 @@ function extractContent(messages) {
   let truncated = false;
   for (const raw of messages) {
     if (!raw || typeof raw !== "object") continue;
-    const message = raw;
-    const time2 = Number(message.time?.created) || 0;
+    const message2 = raw;
+    const time2 = Number(message2.time?.created) || 0;
     const seen = /* @__PURE__ */ new Set();
     const add = (value, kind) => {
       if (typeof value !== "string" || !value.trim() || value.startsWith("data:") || seen.has(value)) return;
@@ -2817,21 +2817,21 @@ function extractContent(messages) {
         else strings(field, depth + 1);
       }
     };
-    if (["user", "synthetic", "system"].includes(message.type)) add(message.text, message.type === "user" ? "You" : "Assistant");
-    for (const file of message.files || []) {
+    if (["user", "synthetic", "system"].includes(message2.type)) add(message2.text, message2.type === "user" ? "You" : "Assistant");
+    for (const file of message2.files || []) {
       add(file.name, "File");
       add(file.uri, "File");
     }
-    if (message.type === "shell") {
-      add(message.command, "Tool");
-      add(message.output, "Tool");
+    if (message2.type === "shell") {
+      add(message2.command, "Tool");
+      add(message2.output, "Tool");
     }
-    if (message.type === "compaction") {
-      add(message.summary, "Assistant");
-      add(message.recent, "Assistant");
+    if (message2.type === "compaction") {
+      add(message2.summary, "Assistant");
+      add(message2.recent, "Assistant");
     }
-    for (const file of message.snapshot?.files || []) add(file, "File");
-    for (const part of message.content || []) {
+    for (const file of message2.snapshot?.files || []) add(file, "File");
+    for (const part of message2.content || []) {
       if (part.type === "text") add(part.text, "Assistant");
       if (part.type !== "tool") continue;
       add(part.name, "Tool");
@@ -2856,13 +2856,13 @@ import { createHash as createHash2 } from "node:crypto";
 import { basename as basename2 } from "node:path";
 var digest = (value) => createHash2("sha256").update(JSON.stringify(value)).digest("hex");
 var identity = (source, native) => `${source}:${native}`;
-var project = (source, directory) => ({ id: identity(source, digest(directory).slice(0, 24)), name: basename2(directory) || "Global", directory, worktrees: [] });
-var blankSession = (source, nativeID, directory = "") => ({
+var project = (source, directory2) => ({ id: identity(source, digest(directory2).slice(0, 24)), name: basename2(directory2) || "Global", directory: directory2, worktrees: [] });
+var blankSession = (source, nativeID, directory2 = "") => ({
   source,
   nativeID,
   id: identity(source, nativeID),
-  projectID: project(source, directory).id,
-  directory,
+  projectID: project(source, directory2).id,
+  directory: directory2,
   title: "Untitled session",
   created: 0,
   updated: 0,
@@ -2874,31 +2874,31 @@ var blankSession = (source, nativeID, directory = "") => ({
   tokens: null
 });
 var blankMessage = (id2, time2, role) => ({ id: id2, time: time2, role, fragments: [], files: [], tools: [] });
-function addText(message, value, kind) {
+function addText(message2, value, kind) {
   if (typeof value !== "string" || !value.trim() || value.startsWith("data:")) return;
-  const remaining = Math.max(0, 128e3 - message.fragments.reduce((n, f) => n + f.text.length, 0));
-  if (value.length > remaining) message.partial = true;
-  if (remaining) message.fragments.push({ text: value.slice(0, remaining), kind, time: message.time });
+  const remaining = Math.max(0, 128e3 - message2.fragments.reduce((n, f) => n + f.text.length, 0));
+  if (value.length > remaining) message2.partial = true;
+  if (remaining) message2.fragments.push({ text: value.slice(0, remaining), kind, time: message2.time });
 }
-function toolText(message, value, depth = 0) {
+function toolText(message2, value, depth = 0) {
   if (depth > 5) {
-    message.partial = true;
+    message2.partial = true;
     return;
   }
-  if (typeof value === "string") return addText(message, value, "Tool");
+  if (typeof value === "string") return addText(message2, value, "Tool");
   if (Array.isArray(value)) {
-    if (value.length > 100) message.partial = true;
-    value.slice(0, 100).forEach((v3) => toolText(message, v3, depth + 1));
+    if (value.length > 100) message2.partial = true;
+    value.slice(0, 100).forEach((v3) => toolText(message2, v3, depth + 1));
   } else if (value && typeof value === "object") for (const [key, val] of Object.entries(value)) {
     if (/base64|image|binary|credential|token|secret|password/i.test(key)) continue;
-    if (/^(filePath|file_path|path|filename)$/i.test(key)) addText(message, val, "File");
-    else toolText(message, val, depth + 1);
+    if (/^(filePath|file_path|path|filename)$/i.test(key)) addText(message2, val, "File");
+    else toolText(message2, val, depth + 1);
   }
 }
 
 // server/activity.ts
 var messageTime = (time2) => Number.isFinite(time2) && time2 > 0 && time2 <= 864e13 ? time2 : null;
-var isUserMessage = (message) => message.role === "user" && message.fragments.some((f) => f.kind === "You" && f.text.trim());
+var isUserMessage = (message2) => message2.role === "user" && message2.fragments.some((f) => f.kind === "You" && f.text.trim());
 var activitySQL = `SELECT min(time) AS firstMessageAt, max(time) AS lastMessageAt,
   coalesce(sum(is_user), 0) AS userMessages,
   coalesce(sum(CASE WHEN is_user=1 AND time IS NULL THEN 1 ELSE 0 END), 0) AS untimedUserMessages
@@ -2927,30 +2927,30 @@ function eventText(value, limit = 32e3) {
     return "[unavailable]";
   }
 }
-function eventFor(message, id2, kind, name, text2 = "", fields2 = {}) {
-  const time2 = messageTime(message.time);
-  const event = { id: id2, kind, name, role: message.role, time: time2, timeSource: time2 ? "message" : "unknown", text: eventText(text2, 64e3), ...fields2 };
+function eventFor(message2, id2, kind, name, text2 = "", fields2 = {}) {
+  const time2 = messageTime(message2.time);
+  const event = { id: id2, kind, name, role: message2.role, time: time2, timeSource: time2 ? "message" : "unknown", text: eventText(text2, 64e3), ...fields2 };
   event.partial ||= [event.text, event.input, event.output].some((value) => /\[(shortened|omitted|unavailable)\]/.test(value || "")) || text2.length > 64e3;
   return event;
 }
-function messageEvent(message, text2, id2 = "message") {
+function messageEvent(message2, text2, id2 = "message") {
   return eventFor(
-    message,
+    message2,
     id2,
     "message",
-    message.role === "user" ? "User message" : message.role === "assistant" ? "Assistant message" : `${message.role} message`,
+    message2.role === "user" ? "User message" : message2.role === "assistant" ? "Assistant message" : `${message2.role} message`,
     text2,
-    { nativeID: message.id, timeSource: messageTime(message.time) ? "recorded" : "unknown", partial: message.partial }
+    { nativeID: message2.id, timeSource: messageTime(message2.time) ? "recorded" : "unknown", partial: message2.partial }
   );
 }
-function boundEventPayloads(message, budget) {
-  if (!message.events) return 0;
-  let remaining = Math.min(budget, 128e3);
+function boundEventPayloads(message2, budget2) {
+  if (!message2.events) return 0;
+  let remaining = Math.min(budget2, 128e3);
   const start = remaining;
-  if (message.events.length > 200) message.partial = true;
-  message.events = message.events.slice(0, 200).flatMap((event) => {
+  if (message2.events.length > 200) message2.partial = true;
+  message2.events = message2.events.slice(0, 200).flatMap((event) => {
     if (remaining <= 0) {
-      message.partial = true;
+      message2.partial = true;
       return [];
     }
     const bounded = { ...event };
@@ -2961,48 +2961,48 @@ function boundEventPayloads(message, budget) {
       remaining -= bounded[key].length;
       if (bounded[key].length < value.length) {
         bounded.partial = true;
-        message.partial = true;
+        message2.partial = true;
       }
     }
     return [bounded];
   });
   return start - remaining;
 }
-function blockEvents(message, content, transform = (v3) => v3) {
-  if (typeof content === "string") return [messageEvent(message, transform(content))];
+function blockEvents(message2, content, transform = (v3) => v3) {
+  if (typeof content === "string") return [messageEvent(message2, transform(content))];
   if (!Array.isArray(content)) return [];
   return content.slice(0, 200).flatMap((part, i) => {
-    if (!part || typeof part !== "object") return [eventFor(message, `unknown:${i}`, "event", "Unsupported content", "", { partial: true })];
+    if (!part || typeof part !== "object") return [eventFor(message2, `unknown:${i}`, "event", "Unsupported content", "", { partial: true })];
     const nativeID = typeof part.id === "string" ? part.id : void 0, id2 = `${part.type || "part"}:${nativeID || i}`;
     const fields2 = { nativeID, nativeType: String(part.type || "unknown"), partial: content.length > 200 };
     if (["text", "input_text", "output_text"].includes(part.type)) {
-      const event = messageEvent(message, transform(typeof part.text === "string" ? part.text : ""), id2);
+      const event = messageEvent(message2, transform(typeof part.text === "string" ? part.text : ""), id2);
       return [{ ...event, ...fields2, partial: Boolean(event.partial || fields2.partial) }];
     }
-    if (["tool_use", "tool-call", "tool_call"].includes(part.type)) return [eventFor(message, id2, "tool_call", part.name || part.toolName || "Tool call", "", { ...fields2, callID: part.id || part.toolCallId, input: eventText(part.input ?? part.args ?? part.arguments), status: "unknown" })];
-    if (["tool_result", "tool-result"].includes(part.type)) return [eventFor(message, id2, "tool_result", part.name || part.toolName || "Tool result", "", { ...fields2, role: "tool", callID: part.tool_use_id || part.toolCallId || part.tool_call_id, output: eventText(part.content ?? part.result ?? part.output), status: part.is_error === true || part.isError === true || part.error != null ? "failed" : "completed" })];
-    if (["thinking", "reasoning"].includes(part.type)) return [eventFor(message, id2, "reasoning", "Recorded reasoning", eventText(part.thinking ?? part.text), fields2)];
-    return [eventFor(message, id2, "event", `${part.type || "Unknown"} content`, "This content type is not represented as text.", { ...fields2, partial: true })];
+    if (["tool_use", "tool-call", "tool_call"].includes(part.type)) return [eventFor(message2, id2, "tool_call", part.name || part.toolName || "Tool call", "", { ...fields2, callID: part.id || part.toolCallId, input: eventText(part.input ?? part.args ?? part.arguments), status: "unknown" })];
+    if (["tool_result", "tool-result"].includes(part.type)) return [eventFor(message2, id2, "tool_result", part.name || part.toolName || "Tool result", "", { ...fields2, role: "tool", callID: part.tool_use_id || part.toolCallId || part.tool_call_id, output: eventText(part.content ?? part.result ?? part.output), status: part.is_error === true || part.isError === true || part.error != null ? "failed" : "completed" })];
+    if (["thinking", "reasoning"].includes(part.type)) return [eventFor(message2, id2, "reasoning", "Recorded reasoning", eventText(part.thinking ?? part.text), fields2)];
+    return [eventFor(message2, id2, "event", `${part.type || "Unknown"} content`, "This content type is not represented as text.", { ...fields2, partial: true })];
   });
 }
-function normalizedEvents(message, sessionID) {
-  let events = message.events;
+function normalizedEvents(message2, sessionID) {
+  let events = message2.events;
   if (!events) {
     events = [];
-    const speech = message.fragments.filter((f) => f.kind === "You" || f.kind === "Assistant").map((f) => f.text).join("\n\n");
-    if (speech) events.push(messageEvent(message, speech));
-    if (message.tools.length || message.fragments.some((f) => f.kind === "Tool")) events.push(eventFor(message, "legacy-tools", "event", message.tools.length ? `Tool activity \xB7 ${message.tools.join(", ")}` : "Recorded tool activity", message.fragments.filter((f) => f.kind === "Tool").map((f) => f.text).join("\n\n"), { role: "tool", partial: true, nativeType: "legacy-tool-activity" }));
-    if (!events.length && !message.files.length) events.push(eventFor(message, "empty", message.role === "user" || message.role === "assistant" ? "message" : "event", `${message.role} record`, "", { partial: true }));
+    const speech = message2.fragments.filter((f) => f.kind === "You" || f.kind === "Assistant").map((f) => f.text).join("\n\n");
+    if (speech) events.push(messageEvent(message2, speech));
+    if (message2.tools.length || message2.fragments.some((f) => f.kind === "Tool")) events.push(eventFor(message2, "legacy-tools", "event", message2.tools.length ? `Tool activity \xB7 ${message2.tools.join(", ")}` : "Recorded tool activity", message2.fragments.filter((f) => f.kind === "Tool").map((f) => f.text).join("\n\n"), { role: "tool", partial: true, nativeType: "legacy-tool-activity" }));
+    if (!events.length && !message2.files.length) events.push(eventFor(message2, "empty", message2.role === "user" || message2.role === "assistant" ? "message" : "event", `${message2.role} record`, "", { partial: true }));
   }
-  const files = message.files.map((file, i) => eventFor(message, `file:${i}`, "file_change", file.path, `${file.source} \xB7 ${file.steps} recorded step(s)`, { nativeType: file.source }));
+  const files = message2.files.map((file, i) => eventFor(message2, `file:${i}`, "file_change", file.path, `${file.source} \xB7 ${file.steps} recorded step(s)`, { nativeType: file.source }));
   return [...events, ...files].slice(0, 200).map((event) => {
     const text2 = String(event.text || "").slice(0, 64e3), input = event.input?.slice(0, 32e3), output = event.output?.slice(0, 64e3);
     const time2 = messageTime(event.time || 0);
     return {
       ...event,
-      id: digest([message.id, event.id]),
+      id: digest([message2.id, event.id]),
       sessionID,
-      messageID: message.id,
+      messageID: message2.id,
       name: String(event.name || event.kind).slice(0, 300),
       nativeID: event.nativeID ? String(event.nativeID).slice(0, 512) : void 0,
       nativeType: event.nativeType?.slice(0, 160),
@@ -3014,37 +3014,37 @@ function normalizedEvents(message, sessionID) {
       text: text2,
       input,
       output,
-      partial: Boolean(event.partial || message.partial || text2.length < (event.text?.length || 0) || input?.length !== event.input?.length || output?.length !== event.output?.length || events.length + files.length > 200)
+      partial: Boolean(event.partial || message2.partial || text2.length < (event.text?.length || 0) || input?.length !== event.input?.length || output?.length !== event.output?.length || events.length + files.length > 200)
     };
   });
 }
 
 // server/adapters/opencode-events.ts
-function opencodeEvents(raw, message) {
-  const fields2 = { nativeID: message.id, nativeType: String(raw.type), timeSource: message.time ? "recorded" : "unknown" };
-  if (raw.type === "user") return [messageEvent(message, typeof raw.text === "string" ? raw.text : ""), ...raw.files?.length ? [eventFor(message, "attachments", "event", "Attachments", "Non-text attachments are not included.", { partial: true })] : []];
+function opencodeEvents(raw, message2) {
+  const fields2 = { nativeID: message2.id, nativeType: String(raw.type), timeSource: message2.time ? "recorded" : "unknown" };
+  if (raw.type === "user") return [messageEvent(message2, typeof raw.text === "string" ? raw.text : ""), ...raw.files?.length ? [eventFor(message2, "attachments", "event", "Attachments", "Non-text attachments are not included.", { partial: true })] : []];
   if (raw.type !== "assistant") {
     const status = ["pending", "running", "completed", "failed"].includes(raw.status) ? raw.status : "unknown";
     const known = ["compaction", "system", "synthetic", "shell", "model-switched", "agent-switched", "location-switched", "skill", "idle"].includes(raw.type);
-    return [eventFor(message, "event", raw.type === "compaction" ? "compaction" : "event", raw.description || raw.type, eventText(raw.summary ?? raw.text ?? raw.error ?? (raw.type === "shell" ? raw.command : raw)), { ...fields2, role: "system", status, output: raw.type === "shell" ? eventText(raw.output?.output) : void 0, partial: !known || Boolean(raw.output?.truncated) })];
+    return [eventFor(message2, "event", raw.type === "compaction" ? "compaction" : "event", raw.description || raw.type, eventText(raw.summary ?? raw.text ?? raw.error ?? (raw.type === "shell" ? raw.command : raw)), { ...fields2, role: "system", status, output: raw.type === "shell" ? eventText(raw.output?.output) : void 0, partial: !known || Boolean(raw.output?.truncated) })];
   }
   const events = [];
   for (const [i, part] of (Array.isArray(raw.content) ? raw.content.slice(0, 200) : []).entries()) {
     const id2 = `${part.type}:${part.id || i}`, native = { nativeID: part.id, nativeType: String(part.type) };
     const time2 = messageTime(part.time?.created);
     const timing = time2 ? { time: time2, timeSource: "recorded" } : {};
-    if (part.type === "text") events.push(eventFor(message, id2, "message", "Assistant message", part.text || "", { ...native, ...timing }));
-    else if (part.type === "reasoning") events.push(eventFor(message, id2, "reasoning", "Recorded reasoning", part.text || "", { ...native, ...timing }));
+    if (part.type === "text") events.push(eventFor(message2, id2, "message", "Assistant message", part.text || "", { ...native, ...timing }));
+    else if (part.type === "reasoning") events.push(eventFor(message2, id2, "reasoning", "Recorded reasoning", part.text || "", { ...native, ...timing }));
     else if (part.type === "tool") {
       const state2 = part.state || {}, endTime = messageTime(part.time?.completed);
       const status = state2.status === "error" ? "failed" : state2.status === "streaming" ? "pending" : ["running", "completed"].includes(state2.status) ? state2.status : "unknown";
       const common = { ...native, callID: part.id, status, endTime };
-      events.push(eventFor(message, `${id2}:call`, "tool_call", part.name || "Tool call", "", { ...common, ...timing, input: eventText(state2.input) }));
-      if (["completed", "error"].includes(state2.status)) events.push(eventFor(message, `${id2}:result`, "tool_result", part.name || "Tool result", "", { ...common, role: "tool", ...endTime ? { time: endTime, timeSource: "recorded" } : {}, output: eventText(state2.error ?? state2.content, 64e3) }));
-    } else events.push(eventFor(message, id2, "event", `${part.type || "Unknown"} content`, "Unsupported content.", { ...native, ...timing, partial: true }));
+      events.push(eventFor(message2, `${id2}:call`, "tool_call", part.name || "Tool call", "", { ...common, ...timing, input: eventText(state2.input) }));
+      if (["completed", "error"].includes(state2.status)) events.push(eventFor(message2, `${id2}:result`, "tool_result", part.name || "Tool result", "", { ...common, role: "tool", ...endTime ? { time: endTime, timeSource: "recorded" } : {}, output: eventText(state2.error ?? state2.content, 64e3) }));
+    } else events.push(eventFor(message2, id2, "event", `${part.type || "Unknown"} content`, "Unsupported content.", { ...native, ...timing, partial: true }));
   }
-  if (raw.error) events.push(eventFor(message, "error", "error", "Assistant error", eventText(raw.error), { status: "failed" }));
-  if (!events.length) events.push(eventFor(message, "empty", "message", "Assistant message", "", { ...fields2, partial: true }));
+  if (raw.error) events.push(eventFor(message2, "error", "error", "Assistant error", eventText(raw.error), { status: "failed" }));
+  if (!events.length) events.push(eventFor(message2, "empty", "message", "Assistant message", "", { ...fields2, partial: true }));
   if (raw.content?.length > 200) events[0].partial = true;
   return events;
 }
@@ -3092,9 +3092,9 @@ var opencodeAdapter = {
     return { cursor: page.cursor?.next || void 0, messages: page.data.map((raw) => {
       const content = extractContent([raw]);
       const detail = summarizeMessages(candidate.session.id, [raw], null);
-      const message = { id: raw.id, time: raw.time?.created || 0, role: raw.type === "user" ? "user" : raw.type === "assistant" ? "assistant" : "system", fragments: content.fragments, files: detail.files, tools: detail.tools.map((t) => t.name), snapshots: detail.snapshotSteps, partial: content.truncated };
-      message.events = opencodeEvents(raw, message);
-      return message;
+      const message2 = { id: raw.id, time: raw.time?.created || 0, role: raw.type === "user" ? "user" : raw.type === "assistant" ? "assistant" : "system", fragments: content.fragments, files: detail.files, tools: detail.tools.map((t) => t.name), snapshots: detail.snapshotSteps, partial: content.truncated };
+      message2.events = opencodeEvents(raw, message2);
+      return message2;
     }) };
   }
 };
@@ -30385,9 +30385,9 @@ async function f3e(e10, t, n, r) {
 }
 
 // server/adapters/claude.ts
-import { readdir, stat } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { join as join4 } from "node:path";
+import { readdir as readdir2, stat } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { join as join8 } from "node:path";
 
 // server/adapters/claude-transcripts.ts
 import { constants as constants2 } from "node:fs";
@@ -30471,17 +30471,17 @@ async function claudeTranscript(path, revision2) {
   return transcript;
 }
 function claudeTranscriptInfo(transcript, sessionId) {
-  const rows = transcript.entries;
-  if (rows[0]?.isSidechain === true) return;
-  const messages = rows.filter((row) => (row.type === "user" || row.type === "assistant") && row.sessionId === sessionId && row.isSidechain !== true && typeof row.uuid === "string" && row.message && typeof row.message === "object");
+  const rows2 = transcript.entries;
+  if (rows2[0]?.isSidechain === true) return;
+  const messages = rows2.filter((row) => (row.type === "user" || row.type === "assistant") && row.sessionId === sessionId && row.isSidechain !== true && typeof row.uuid === "string" && row.message && typeof row.message === "object");
   if (!messages.length) return;
   const firstPrompt = messages.filter((row) => row.type === "user" && !row.isMeta).map((row) => {
     const content = row.message.content;
     const text2 = typeof content === "string" ? content : Array.isArray(content) ? content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n") : "";
     return text2.replace(/<(ide_opened_file|ide_selection|ide_diagnostics)>[\s\S]*?<\/\1>/g, "").trim().replace(/\s+/g, " ").slice(0, 180);
   }).find(Boolean);
-  const title = rows.findLast((row) => ["custom-title", "ai-title", "summary"].includes(String(row.type)) && typeof (row.customTitle || row.aiTitle || row.summary) === "string");
-  const cwd2 = rows.findLast((row) => row.type === "relocated" && typeof row.relocatedCwd === "string")?.relocatedCwd || messages.find((row) => typeof row.cwd === "string")?.cwd;
+  const title = rows2.findLast((row) => ["custom-title", "ai-title", "summary"].includes(String(row.type)) && typeof (row.customTitle || row.aiTitle || row.summary) === "string");
+  const cwd2 = rows2.findLast((row) => row.type === "relocated" && typeof row.relocatedCwd === "string")?.relocatedCwd || messages.find((row) => typeof row.cwd === "string")?.cwd;
   const createdAt = messages.map((row) => transcript.times.get(String(row.uuid))).find((time2) => time2 && time2 > 0);
   return { sessionId, summary: String(title?.customTitle || title?.aiTitle || title?.summary || firstPrompt || "Claude Code session"), firstPrompt, cwd: typeof cwd2 === "string" ? cwd2 : void 0, createdAt, lastModified: transcript.modified, fileSize: transcript.size };
 }
@@ -30496,158 +30496,918 @@ function claudeTranscriptStore(transcript, sessionId, agent) {
   };
 }
 
-// server/adapters/claude.ts
-var root = () => join4(process.env.CLAUDE_CONFIG_DIR || join4(homedir3(), ".claude"), "projects");
-function claudeMessages(rows, candidate, times) {
-  const calls = /* @__PURE__ */ new Map();
-  return rows.map((row) => {
-    const raw = row.message;
-    const msg = blankMessage(row.uuid, times?.get(row.uuid) ?? (Number.isFinite(Date.parse(raw?.timestamp)) ? Date.parse(raw.timestamp) : 0), row.type);
-    if (raw?.model) candidate.session.model = raw.model;
-    if (row.parent_agent_id && candidate.locator.parent) candidate.session.parentID = identity("claude-code", `${candidate.locator.parent}/agent/${row.parent_agent_id}`);
-    if (typeof raw?.content === "string") addText(msg, raw.content, row.type === "user" ? "You" : "Assistant");
-    for (const part of Array.isArray(raw?.content) ? raw.content : []) {
-      if (part.type === "text") addText(msg, part.text, row.type === "user" ? "You" : "Assistant");
-      if (part.type === "tool_use") {
-        calls.set(part.id, { name: part.name, input: part.input });
-        msg.tools.push(part.name);
-        addText(msg, part.name, "Tool");
-        toolText(msg, part.input);
+// server/adapters/local-files.ts
+import { constants as constants3 } from "node:fs";
+import { lstat as lstat2, open as open2, readdir } from "node:fs/promises";
+import { join as join4, relative } from "node:path";
+
+// server/adapters/compressed.ts
+import { gunzipSync, zstdDecompressSync } from "node:zlib";
+function expandHistory(buffer, maxOutputLength) {
+  if (buffer.length >= 4 && buffer.readUInt32LE(0) === 4247762216) return zstdDecompressSync(buffer, { maxOutputLength });
+  if (buffer[0] === 31 && buffer[1] === 139) return gunzipSync(buffer, { maxOutputLength });
+  if (buffer.length > maxOutputLength) throw new Error("Expanded history exceeds the snapshot limit.");
+  return buffer;
+}
+
+// server/adapters/local-files.ts
+var object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var text = (value) => typeof value === "string" ? value : "";
+var time = (value) => {
+  const n = typeof value === "number" ? value : typeof value === "string" ? /^\d{13}$/.test(value) ? Number(value) : Date.parse(value) : 0;
+  return Number.isFinite(n) && n > 0 && n <= 864e13 ? n : 0;
+};
+var MAX_BYTES2 = 32e6;
+var MAX_RECORDS = 5e4;
+var MAX_FILES = 2e4;
+async function fileState(path) {
+  try {
+    const s = await lstat2(path);
+    if (!s.isFile()) throw new Error("History must be a regular file, not a symlink.");
+    if (s.size > MAX_BYTES2) throw new Error("History exceeds the 32 MB per-file limit.");
+    return { path, signature: digest([s.size, s.mtimeMs, s.ctimeMs, s.ino]), created: s.birthtimeMs || s.mtimeMs, updated: s.mtimeMs, size: s.size };
+  } catch (error) {
+    if (error.code === "ENOENT") return { path, signature: "missing", created: 0, updated: 0, size: 0 };
+    throw error;
+  }
+}
+async function historyFiles(roots, match) {
+  const files = [], queue = [];
+  const warnings = [];
+  for (const root3 of new Set(roots)) {
+    try {
+      if ((await lstat2(root3)).isDirectory()) queue.push({ root: root3, path: root3, depth: 0 });
+    } catch (error) {
+      if (error.code !== "ENOENT") warnings.push("A history directory could not be read.");
+    }
+  }
+  let entriesSeen = 0, limited = false;
+  for (let i = 0; i < queue.length && files.length < MAX_FILES && entriesSeen < 1e5; i++) {
+    const { root: root3, path, depth } = queue[i];
+    let entries2;
+    try {
+      entries2 = await readdir(path, { withFileTypes: true });
+    } catch {
+      warnings.push("A history directory could not be read.");
+      continue;
+    }
+    for (const entry of entries2) {
+      if (++entriesSeen > 1e5 || files.length >= MAX_FILES) {
+        limited = true;
+        break;
       }
-      if (part.type === "tool_result") {
-        toolText(msg, part.content);
-        const call = calls.get(part.tool_use_id);
-        if (!part.is_error && call && ["Edit", "Write", "MultiEdit", "NotebookEdit"].includes(call.name)) {
-          const path = call.input?.file_path || call.input?.notebook_path;
-          if (typeof path === "string") msg.files.push({ path, source: "edit tool", steps: 1 });
-        }
+      const file = join4(path, entry.name);
+      if (entry.isDirectory()) {
+        if (depth < 6 && queue.length < MAX_FILES) queue.push({ root: root3, path: file, depth: depth + 1 });
+        else limited = true;
       }
+      if (entry.isFile() && match(relative(root3, file).split("\\").join("/"))) files.push(file);
     }
-    msg.events = blockEvents(msg, raw?.content).map((event) => ({ ...event, parentID: row.parent_tool_use_id || void 0 }));
-    if (!msg.events.length) msg.events = [eventFor(msg, "event", raw?.subtype === "compact_boundary" ? "compaction" : "event", raw?.subtype || `${row.type} event`, eventText(raw), { nativeType: raw?.subtype || row.type, partial: true })];
-    return msg;
-  });
+  }
+  if (limited) warnings.push("History discovery reached its file, directory, or depth limit.");
+  return { files: [...new Set(files)].sort(), warnings };
 }
-var claudeAdapter = {
-  id: "claude-code",
-  name: "Claude Code",
-  description: "Local CLI and VS Code history \xB7 all projects and subagent transcripts",
-  capabilities: { history: true, forks: false, children: true, files: true },
-  async detect() {
+function json2(value) {
+  return JSON.parse(value);
+}
+function jsonLines(value) {
+  const rows2 = [];
+  let partial = false;
+  for (const line of value.split("\n")) {
+    if (!line.trim()) continue;
+    if (rows2.length >= MAX_RECORDS) throw new Error("History exceeds the 50,000-record limit.");
+    if (line.length > 2e6) throw new Error("History contains a record larger than 2 MB.");
     try {
-      return (await stat(root())).isDirectory();
+      const row = json2(line);
+      if (!row || typeof row !== "object" || Array.isArray(row)) partial = true;
+      else rows2.push(row);
     } catch {
-      return false;
+      partial = true;
     }
-  },
-  async discover() {
-    const sessions = [], warnings = [];
-    const infos = await I1t({ limit: 2e4, includeProgrammatic: true });
-    if (infos.length === 2e4) warnings.push("Claude Code listing is limited to 20,000 sessions.");
+  }
+  return { rows: rows2, partial };
+}
+function localFileAdapter(source) {
+  const metadata2 = /* @__PURE__ */ new Map();
+  let cached2;
+  const states = (path) => Promise.all([path, ...source.extras?.(path) || []].map(fileState));
+  const revision2 = (values) => digest([1, ...values.filter((_, i) => i === 0 || source.revisionExtras !== false).map((s) => [s.path, s.signature])]);
+  async function load(path, expected, before) {
+    if (revision2(before) !== expected) throw new Error("Session changed during import; import again.");
+    if (cached2?.path === path && cached2.revision === expected) return cached2.history;
+    if (before[0].signature === "missing") throw new Error("History file is unavailable.");
+    if (before.reduce((n, s) => n + s.size, 0) > MAX_BYTES2) throw new Error("Combined history exceeds the 32 MB snapshot limit.");
     const files = /* @__PURE__ */ new Map();
-    let unreadable = 0;
-    for (const dir of await readdir(root(), { withFileTypes: true })) {
-      if (!dir.isDirectory()) continue;
-      const parent2 = join4(root(), dir.name);
-      let entries2;
+    let expanded = 0;
+    for (const s of before.filter((s2) => s2.signature !== "missing")) {
+      const handle = await open2(s.path, constants3.O_RDONLY | (constants3.O_NOFOLLOW || 0));
       try {
-        entries2 = await readdir(parent2, { withFileTypes: true });
-      } catch {
-        unreadable++;
-        continue;
-      }
-      for (const file of entries2) if (file.isFile() && file.name.endsWith(".jsonl") && claudeSessionID(file.name.slice(0, -6))) {
-        const id2 = file.name.slice(0, -6), path = join4(parent2, file.name);
-        try {
-          const old = files.get(id2);
-          if (!old || (await stat(path)).mtimeMs > (await stat(old.path)).mtimeMs) files.set(id2, { path, children: join4(parent2, id2, "subagents") });
-        } catch {
-          unreadable++;
+        const buffer = Buffer.alloc(s.size + 1);
+        let bytes2 = 0;
+        while (bytes2 < buffer.length) {
+          const part = await handle.read(buffer, bytes2, buffer.length - bytes2, bytes2);
+          if (!part.bytesRead) break;
+          bytes2 += part.bytesRead;
         }
+        if (bytes2 !== s.size) throw new Error("History changed while reading; import again.");
+        const data = expandHistory(buffer.subarray(0, bytes2), MAX_BYTES2);
+        expanded += data.length;
+        if (expanded > MAX_BYTES2) throw new Error("Expanded history exceeds the 32 MB snapshot limit.");
+        files.set(s.path, data.toString("utf8"));
+      } finally {
+        await handle.close();
       }
     }
-    const listed = new Set(infos.map((info) => info.sessionId));
-    for (const [id2, file] of files) {
-      if (listed.has(id2)) continue;
-      if (infos.length >= 2e4) {
-        warnings.push("Claude Code discovery is limited to 20,000 sessions.");
-        break;
-      }
-      try {
-        const transcript = await claudeTranscript(file.path, await claudeRevision(file.path));
-        const info = claudeTranscriptInfo(transcript, id2);
-        if (info) infos.push(info);
-        else if (transcript.partial) unreadable++;
-      } catch {
-        unreadable++;
-      }
-    }
-    for (const info of infos) {
-      const file = files.get(info.sessionId);
-      if (!file) continue;
-      const s = { ...blankSession("claude-code", info.sessionId, info.cwd), title: info.customTitle || info.summary || info.firstPrompt || "Untitled session", created: info.createdAt || info.lastModified, updated: info.lastModified, provider: "anthropic", agent: "Claude Code" };
-      try {
-        sessions.push({ session: s, revision: await claudeRevision(file.path), locator: { path: file.path, dir: info.cwd || "" } });
-      } catch {
-        unreadable++;
-        continue;
-      }
-      let children;
-      try {
-        children = await readdir(file.children, { withFileTypes: true });
-      } catch (error) {
-        if (error.code !== "ENOENT") unreadable++;
-        continue;
-      }
-      for (const child of children) {
-        if (!child.isFile() || !/^agent-[\w-]+\.jsonl$/.test(child.name)) continue;
+    if (digest(await states(path)) !== digest(before)) throw new Error("History changed while reading; import again.");
+    const history = source.parse(path, files);
+    if (!history) return;
+    if (source.capabilities.history && !history.messages.length) throw new Error("No readable conversation.");
+    if (!history.nativeID || history.nativeID.length > 512) throw new Error("History has no supported native session identity.");
+    if (history.messages.length > MAX_RECORDS) throw new Error("History exceeds the 50,000-message limit.");
+    cached2 = { path, revision: expected, history };
+    return history;
+  }
+  return {
+    id: source.id,
+    name: source.name,
+    description: source.description,
+    capabilities: source.capabilities,
+    async detect() {
+      for (const root3 of source.roots()) if ((await lstat2(root3).catch(() => void 0))?.isDirectory()) return true;
+      return false;
+    },
+    async discover() {
+      const listing = await historyFiles(source.roots(), source.match), found = /* @__PURE__ */ new Map();
+      let failed = 0;
+      for (const path of listing.files) {
         try {
-          const agent = child.name.slice(6, -6), path = join4(file.children, child.name), stats = await stat(path);
-          sessions.push({ session: { ...s, id: identity("claude-code", `${info.sessionId}/agent/${agent}`), nativeID: `${info.sessionId}/agent/${agent}`, title: `Subagent ${agent}`, created: stats.birthtimeMs || s.created, updated: stats.mtimeMs, parentID: s.id, agent }, revision: await claudeRevision(path), locator: { path, dir: info.cwd || "", parent: info.sessionId, agent } });
+          const before = await states(path), rev = revision2(before);
+          let candidate = metadata2.get(path);
+          if (!candidate || candidate.revision !== rev) {
+            const history = await load(path, rev, before);
+            if (!history) continue;
+            const session = { ...blankSession(source.id, history.nativeID), ...history.session };
+            session.id = identity(source.id, history.nativeID);
+            session.nativeID = history.nativeID;
+            session.source = source.id;
+            session.directory = text(session.directory);
+            session.projectID = project(source.id, session.directory).id;
+            session.created = time(session.created) || history.messages.map((m) => time(m.time)).find(Boolean) || before[0].created;
+            session.updated = before[0].updated;
+            session.agent ||= source.name;
+            session.parentID = history.parent ? identity(source.id, history.parent) : void 0;
+            session.forkID = history.fork ? identity(source.id, history.fork) : void 0;
+            if (session.title === "Untitled session" || !session.title) session.title = history.messages.flatMap((m) => m.role === "user" ? m.fragments.filter((f) => f.kind === "You").map((f) => f.text) : []).find(Boolean)?.replace(/\s+/g, " ").slice(0, 180) || `${source.name} session`;
+            candidate = { session, revision: rev, locator: { path } };
+            metadata2.set(path, candidate);
+          }
+          const previous = found.get(candidate.session.id);
+          const preferred = candidate.locator.path.endsWith(".jsonl"), previousPreferred = previous?.locator.path.endsWith(".jsonl");
+          if (!previous || preferred && !previousPreferred || preferred === previousPreferred && candidate.session.updated > previous.session.updated) found.set(candidate.session.id, candidate);
         } catch {
-          unreadable++;
+          failed++;
         }
       }
+      const listed = new Set(listing.files);
+      for (const path of metadata2.keys()) if (!listed.has(path)) metadata2.delete(path);
+      if (failed) listing.warnings.push(`${failed} ${source.name} histories were unreadable, changing, unsupported, or over the size limit. Saved imports are kept.`);
+      const sessions = [...found.values()];
+      return { sessions, projects: [...new Map(sessions.map((c) => {
+        const p = project(source.id, c.session.directory);
+        return [p.id, p];
+      })).values()], warnings: listing.warnings };
+    },
+    async read(candidate, cursor) {
+      const offset = cursor === void 0 ? 0 : Number(cursor);
+      if (!Number.isSafeInteger(offset) || offset < 0) throw new Error("Invalid history cursor.");
+      const history = await load(candidate.locator.path, candidate.revision, await states(candidate.locator.path));
+      if (!history) throw new Error("History representation is no longer available.");
+      const messages = history.messages.slice(offset, offset + 100);
+      const untimed = history.messages.some((m) => !time(m.time));
+      return {
+        messages,
+        cursor: offset + messages.length < history.messages.length ? String(offset + messages.length) : void 0,
+        partial: Boolean(history.partial || messages.some((m) => m.partial)),
+        note: `${history.note}${untimed ? " Missing message timestamps remain unknown; session placement falls back to recorded metadata or file time." : ""} File snapshots are unavailable.`
+      };
     }
-    if (unreadable) warnings.push(`${unreadable} Claude Code histories unavailable or too large. Saved imports are kept.`);
-    return { sessions, projects: [...new Map(sessions.map((c) => {
-      const p = project("claude-code", c.session.directory);
-      return [p.id, p];
-    })).values()], warnings };
-  },
-  async read(candidate, cursor) {
-    const offset = Number(cursor || 0);
-    if (!Number.isSafeInteger(offset) || offset < 0) throw new Error("Invalid history cursor.");
-    const transcript = await claudeTranscript(candidate.locator.path, candidate.revision);
-    const start = Math.max(0, offset - 1), count = 120 + offset - start;
-    const sessionId = candidate.locator.parent || candidate.session.nativeID;
-    const options = { dir: candidate.locator.dir || void 0, offset: start, limit: count + 1, sessionStore: claudeTranscriptStore(transcript, sessionId, candidate.locator.agent) };
-    const rows = candidate.locator.parent ? await U1t(candidate.locator.parent, candidate.locator.agent, options) : await P1t(candidate.session.nativeID, options);
-    const more = rows.length > count;
-    const messages = claudeMessages(rows.slice(0, count), candidate, transcript.times).slice(offset - start);
-    if (!offset && !messages.length && transcript.size > 100) throw new Error("SDK returned no readable conversation for this transcript.");
-    if (!more && await claudeRevision(candidate.locator.path) !== candidate.revision) throw new Error("Session changed during import; import again to capture the latest messages.");
-    return { messages, cursor: more ? String(offset + 120) : void 0, partial: transcript.partial, note: `SDK-visible conversation chain from the local CLI/VS Code transcript; pre-compaction text and unsupported message types may be absent. Fork ancestry is unavailable.${transcript.partial ? " Some transcript records or subagent metadata were unreadable." : ""}` };
-  }
-};
+  };
+}
 
-// server/adapters/codex.ts
-import { stat as stat2 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { join as join6, sep as sep2 } from "node:path";
+// server/adapters/harness-formats.ts
+import { basename as basename4, dirname as dirname2, join as join6 } from "node:path";
+
+// server/adapters/local-messages.ts
+function conversationMessage(raw, fallbackID) {
+  const role = raw.role === "user" ? "user" : ["assistant", "model", "thinking"].includes(raw.role) ? "assistant" : ["tool", "toolResult"].includes(raw.role) ? "tool" : "system";
+  const message2 = blankMessage(text(raw.id) || fallbackID, time(raw.timestamp ?? raw.ts), role);
+  let content = raw.content;
+  if (Array.isArray(content)) content = content.map((part) => {
+    const p = object(part);
+    return p.type === "toolCall" ? { ...p, type: "tool_use", input: p.arguments } : p.type === "reasoning" ? { ...p, type: "thinking", thinking: p.text } : p;
+  });
+  if (raw.role === "thinking") content = [{ type: "thinking", thinking: raw.content }];
+  message2.events = blockEvents(message2, content);
+  if (role === "tool" && !(Array.isArray(content) && content.some((p) => p.type === "tool_result"))) {
+    message2.events = [eventFor(message2, "result", "tool_result", text(raw.toolName) || "Tool result", "", {
+      callID: text(raw.toolCallId) || text(raw.tool_call_id) || void 0,
+      output: eventText(content),
+      status: raw.isError === true ? "failed" : raw.isError === false ? "completed" : "unknown"
+    })];
+  }
+  for (const event of message2.events) {
+    if (event.kind === "message") addText(message2, event.text, role === "user" ? "You" : role === "assistant" ? "Assistant" : "Tool");
+    else if (event.kind === "tool_call") {
+      message2.tools.push(event.name);
+      toolText(message2, event.input);
+    } else if (event.kind === "tool_result") toolText(message2, event.output);
+    else if (event.kind === "reasoning") addText(message2, event.text, "Assistant");
+  }
+  for (const call of Array.isArray(raw.toolCalls) ? raw.toolCalls : []) {
+    const f = object(call.function);
+    if (!text(f.name)) continue;
+    message2.tools.push(f.name);
+    message2.events.push(eventFor(message2, `call:${text(call.id) || message2.events.length}`, "tool_call", f.name, "", { callID: text(call.id) || void 0, input: eventText(f.arguments), status: "unknown" }));
+    toolText(message2, f.arguments);
+  }
+  if (message2.events.length && message2.events.every((e10) => e10.kind === "tool_result")) message2.role = "tool";
+  message2.partial ||= message2.events.some((e10) => e10.partial);
+  return message2;
+}
+function googleMessage(raw, fallbackID) {
+  const parts = Array.isArray(raw.content) ? raw.content : raw.content != null ? [raw.content] : [];
+  const content = parts.map((part) => {
+    if (typeof part === "string") return { type: "text", text: part };
+    const p = object(part);
+    if (typeof p.text === "string") return p.thought ? { type: "thinking", thinking: p.text } : { type: "text", text: p.text };
+    if (p.functionCall) return { type: "tool_use", ...p.functionCall, input: p.functionCall.args };
+    if (p.functionResponse) return { type: "tool_result", tool_use_id: p.functionResponse.id || raw.toolCallId, name: p.functionResponse.name, content: p.functionResponse.response, is_error: p.functionResponse.response?.error != null };
+    return { type: "unsupported" };
+  });
+  return conversationMessage({ ...raw, content }, fallbackID);
+}
+function successfulEdits(messages, editNames) {
+  const calls = /* @__PURE__ */ new Map();
+  for (const message2 of messages) for (const event of message2.events || []) {
+    if (event.kind === "tool_call" && event.callID) {
+      let input = {};
+      try {
+        input = object(JSON.parse(event.input || "{}"));
+      } catch {
+      }
+      calls.set(event.callID, { name: event.name, input });
+    }
+    if (event.kind !== "tool_result" || event.status !== "completed" || !event.callID) continue;
+    const call = calls.get(event.callID);
+    if (!call || !editNames.includes(call.name)) continue;
+    if (call.name === "editor" && (typeof call.input.new_text !== "string" || typeof call.input.old_text !== "string")) continue;
+    const path = text(call.input.file_path) || text(call.input.filePath) || text(call.input.path);
+    if (!path || path.length > 4096) continue;
+    try {
+      const result = JSON.parse(event.output || "{}");
+      if (result?.success === false || result?.error) continue;
+    } catch {
+    }
+    message2.files.push({ path, source: "edit tool", steps: 1 });
+    addText(message2, path, "File");
+  }
+}
+
+// server/adapters/pi.ts
+import { homedir as homedir3 } from "node:os";
+import { join as join5 } from "node:path";
+function piHistory(value) {
+  const { rows: rows2, partial } = jsonLines(value);
+  const header = rows2[0];
+  if (header?.type !== "session" || !text(header.id)) throw new Error("Unsupported Pi session.");
+  const messages = rows2.slice(1).map((raw, index) => {
+    const id2 = text(raw.id) || `record:${index}`;
+    if (raw.type === "message" && raw.message) {
+      const message3 = conversationMessage({ ...raw.message, id: id2, timestamp: raw.message.timestamp ?? raw.timestamp }, id2);
+      for (const event of message3.events || []) event.parentID = text(raw.parentId) || void 0;
+      return message3;
+    }
+    const message2 = blankMessage(id2, time(raw.timestamp), "system");
+    message2.events = [eventFor(message2, "entry", ["compaction", "branch_summary"].includes(raw.type) ? "compaction" : "event", text(raw.type) || "Pi entry", text(raw.summary) || eventText(raw), { nativeType: text(raw.type), parentID: text(raw.parentId) || void 0 })];
+    return message2;
+  });
+  successfulEdits(messages, ["write", "edit"]);
+  const lastModel = [...rows2].reverse().find((r) => r.type === "model_change" || r.message?.model);
+  return {
+    nativeID: header.id,
+    messages,
+    partial,
+    session: { directory: text(header.cwd), created: time(header.timestamp), title: text([...rows2].reverse().find((r) => r.type === "session_info")?.name), model: text(lastModel?.modelId || lastModel?.message?.model) || "Unknown model", provider: text(lastModel?.provider || lastModel?.message?.provider) },
+    note: "Raw Pi session history includes all recorded in-file branches, not just the active model context. Entry parent IDs are preserved as event links, not session ancestry. Parent-session file paths do not establish whether a session is a fork or a child. Binary content is omitted."
+  };
+}
+var piAdapter = localFileAdapter({
+  id: "pi",
+  name: "Pi",
+  description: "Local JSONL sessions \xB7 messages, tools, compaction, and branch entries",
+  capabilities: { history: true, forks: false, children: false, files: true },
+  roots: () => [process.env.SESSIONGRAPH_PI_SESSIONS_DIR || join5(process.env.PI_CODING_AGENT_DIR || join5(homedir3(), ".pi", "agent"), "sessions")],
+  match: (path) => path.endsWith(".jsonl"),
+  parse(path, files) {
+    const history = piHistory(files.get(path));
+    history.session.nativeResume = Boolean(history.session.directory) && !process.env.SESSIONGRAPH_PI_SESSIONS_DIR;
+    return history;
+  }
+});
+
+// server/adapters/harness-formats.ts
+var nativeText = (v3) => typeof v3 === "number" && Number.isSafeInteger(v3) ? String(v3) : text(v3);
+var seconds = (v3) => typeof v3 === "number" && Number.isFinite(v3) && v3 > 0 ? v3 * 1e3 : time(v3);
+var fileID = (path) => basename4(path).replace(/\.jsonl(?:\..*)?$|\.json$/, "");
+var sidecar2 = (files, path) => object(files.has(path) ? json2(files.get(path)) : void 0);
+var roles = ["user", "assistant", "system", "tool", "toolResult", "model"];
+function message(raw, id2, timestamp) {
+  if (!roles.includes(raw.role)) return;
+  if (raw.content == null && !Array.isArray(raw.toolCalls ?? raw.tool_calls)) return;
+  return conversationMessage({ ...raw, id: nativeText(raw.id) || id2, timestamp: timestamp ?? raw.timestamp ?? raw.createdAt, toolCalls: raw.toolCalls ?? raw.tool_calls }, id2);
+}
+function recordEvent(raw, id2, kind, timestamp, content) {
+  const m = blankMessage(id2, time(timestamp), "system");
+  m.events = [eventFor(m, "record", /compact|summary/i.test(kind) ? "compaction" : /error/i.test(kind) ? "error" : "event", kind || "Source event", eventText(content), { nativeType: kind, partial: true })];
+  m.partial = true;
+  return m;
+}
+function envelopeHistory(path, value) {
+  const { rows: rows2, partial } = jsonLines(value);
+  if (rows2[0]?.type === "session" && rows2.some((r) => r.type === "message" && r.message?.role)) return piHistory(value);
+  const nativeIDs = new Set(rows2.map((r) => text(r.sessionId || r.session_id)).filter(Boolean));
+  if (nativeIDs.size > 1) throw new Error("Multiple native sessions in one transcript are not supported.");
+  const header = rows2.find((r) => r.type === "session" || r.type === "session_start" || r.type === "session_startup") || {};
+  const nativeID = [...nativeIDs][0] || text(header.id || header.sessionId) || fileID(path);
+  const messages = rows2.flatMap((r, i) => {
+    const body2 = object(r.message), role = body2.role || r.role || (["user", "assistant", "system"].includes(r.type) ? r.type : void 0);
+    const m = message({ ...body2, id: text(r.uuid || r.id) || body2.id, role, content: body2.content ?? r.content ?? r.text }, `record:${i}`, r.timestamp ?? body2.timestamp);
+    return m ? [m] : [];
+  });
+  if (!messages.length) throw new Error("No readable conversation records.");
+  const meta = rows2.find((r) => r.cwd) || header;
+  const last = [...rows2].reverse().find((r) => r.message?.model || typeof r.model === "string");
+  return {
+    nativeID,
+    messages,
+    partial: true,
+    session: { directory: text(meta.cwd), created: time(header.timestamp), title: text(header.title), model: text(last?.message?.model || last?.model) || "Unknown model" },
+    note: `Local conversation envelopes; source-native message IDs are retained. Context-only records, opaque attachments, and unsupported branches may be absent.${partial ? " Malformed records were skipped." : ""}`
+  };
+}
+function ampHistory(path, files) {
+  const raw = object(json2(files.get(path)));
+  if (!text(raw.id) || !Array.isArray(raw.messages)) throw new Error("Unsupported Amp thread.");
+  const messages = raw.messages.flatMap((m, i) => {
+    const result = message(m, nativeText(m.messageId) || `message:${i}`, m.timestamp ?? m.usage?.timestamp);
+    return result ? [result] : [];
+  });
+  return { nativeID: raw.id, messages, partial: true, session: { created: time(raw.created), title: text(raw.title), directory: text(raw.cwd) }, note: "Amp local/exported thread messages. Usage-ledger ranges are not message timestamps. Export-only and missing content remain partial." };
+}
+function jcodeHistory(path, files) {
+  const raw = object(json2(files.get(path)));
+  if (!text(raw.id) || !Array.isArray(raw.messages)) throw new Error("Unsupported Jcode session.");
+  const journal = path.replace(/\.json$/, ".journal.jsonl");
+  const appended = files.has(journal) ? jsonLines(files.get(journal)) : { rows: [], partial: false };
+  const records = [...raw.messages];
+  for (const row of appended.rows) {
+    if (Array.isArray(row.append_messages)) records.push(...row.append_messages);
+    if (row.meta) Object.assign(raw, object(row.meta));
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const messages = records.flatMap((r, i) => {
+    const id2 = text(r.id) || `message:${i}`;
+    if (seen.has(id2)) return [];
+    seen.add(id2);
+    const m = message(r, id2);
+    return m ? [m] : [];
+  });
+  return { nativeID: raw.id, messages, partial: appended.partial, session: { title: text(raw.title), directory: text(raw.working_dir), created: time(raw.created_at), model: text(raw.model) || "Unknown model", provider: text(raw.provider_key) }, note: "Jcode session snapshot and append journal; replayed native message IDs count once. Absent message times remain unknown." };
+}
+function codebuffHistory(path, files, free) {
+  const records = json2(files.get(path));
+  if (!Array.isArray(records)) throw new Error("Unsupported Codebuff chat.");
+  const isFree = records.some((m) => text(m.metadata?.runState?.sessionState?.mainAgentState?.agentType).startsWith("base2-free"));
+  if (isFree !== free) return;
+  const messages = records.flatMap((r, i) => {
+    const content = r.content ?? (Array.isArray(r.blocks) ? r.blocks.filter((b) => typeof b.content === "string").map((b) => ({ type: "text", text: b.content })) : void 0);
+    const m = message({ ...r, role: r.role || r.type, content }, text(r.id) || `message:${i}`);
+    return m ? [m] : [];
+  });
+  const chat = basename4(dirname2(path)), project2 = basename4(dirname2(dirname2(dirname2(path))));
+  return { nativeID: `${project2}/${chat}`, messages, partial: true, note: "Codebuff/Freebuff persisted chat messages. Freebuff requires a recorded base2-free root-agent marker. Shared storage is attributed once; token counts are not estimated from text." };
+}
+function vibeHistory(path, files) {
+  const raw = object(json2(files.get(path))), legacy = basename4(path) !== "meta.json";
+  const meta = legacy ? object(raw.metadata) : raw;
+  const transcript = join6(dirname2(path), "messages.jsonl");
+  const parsed = files.has(transcript) ? jsonLines(files.get(transcript)) : { rows: [], partial: false };
+  const records = legacy ? raw.messages : parsed.rows;
+  if (!text(meta.session_id) || !Array.isArray(records)) throw new Error("Unsupported Vibe session.");
+  const messages = records.flatMap((r, i) => {
+    const m = message(r, `message:${i}`);
+    return m ? [m] : [];
+  });
+  return {
+    nativeID: meta.session_id,
+    messages,
+    partial: parsed.partial || !messages.length,
+    session: { directory: text(meta.environment?.working_directory), created: time(meta.start_time), model: text(meta.config?.active_model) || "Unknown model", title: text(meta.title) },
+    note: "Vibe session metadata and conversation snapshot. Untimed transcript messages remain untimed; cumulative session usage is not spread across turns."
+  };
+}
+function acpHistory(path, value) {
+  const { rows: rows2 } = jsonLines(value), ids = /* @__PURE__ */ new Set(), messages = [];
+  let current;
+  const flush = () => {
+    if (current) {
+      messages.push(conversationMessage({ role: current.role, content: current.content, timestamp: current.time }, current.id));
+      current = void 0;
+    }
+  };
+  for (const [i, row] of rows2.entries()) {
+    const p = object(row.params), u2 = object(p.update), kind = text(u2.sessionUpdate);
+    if (text(p.sessionId)) ids.add(p.sessionId);
+    const timestamp = time(p._meta?.agentTimestampMs) || time(row.timestamp);
+    const role = kind === "user_message_chunk" ? "user" : kind === "agent_message_chunk" ? "assistant" : "";
+    if (role && u2.content?.type === "text") {
+      if (current?.role !== role) {
+        flush();
+        current = { role, content: "", id: `chunk:${i}`, time: timestamp };
+      }
+      current.content += text(u2.content.text);
+    } else {
+      flush();
+      if (kind === "agent_thought_chunk") messages.push(recordEvent(row, `record:${i}`, "Recorded reasoning", timestamp, u2.content?.text));
+      else if (kind) messages.push(recordEvent(row, `record:${i}`, kind, timestamp, u2.title));
+    }
+  }
+  flush();
+  if (ids.size > 1) throw new Error("Multiple sessions in one ACP event log.");
+  if (!ids.size || !messages.length) throw new Error("No supported ACP session updates.");
+  return { nativeID: [...ids][0], messages, partial: true, note: "Saved ACP updates. Adjacent text chunks are grouped; missing turn boundaries, tool payloads, and metadata remain partial." };
+}
+function dshHistory(value) {
+  const { rows: rows2, partial } = jsonLines(value), header = rows2.find((r) => r.type === "session");
+  if (!text(header?.id)) throw new Error("Unsupported DeepSeek Harness session.");
+  const messages = rows2.flatMap((r, i) => {
+    if (!["user/message", "assistant/message", "tool/message"].includes(r.type)) return [];
+    const body2 = object(r.data?.message);
+    const m = message({ ...body2, role: body2.role || r.type.split("/")[0] }, text(body2.id) || `record:${i}`, r.time);
+    return m ? [m] : [];
+  });
+  return { nativeID: header.id, messages, partial: true, session: { directory: text(header.cwd), created: time(header.createdAt ?? header.time) }, note: `DeepSeek Harness final message records; streaming/retry bookkeeping is excluded. Context seeds and unsupported event payloads may be absent.${partial ? " Malformed records were skipped." : ""}` };
+}
+
+// server/adapters/sqlite-histories.ts
+import { lstat as lstat3 } from "node:fs/promises";
+
+// server/adapters/sqlite-snapshot.ts
+import { DatabaseSync } from "node:sqlite";
+import { chmodSync, constants as constants4, copyFileSync, lstatSync as lstatSync2, mkdtempSync, rmSync as rmSync2 } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join7 } from "node:path";
+var copies = /* @__PURE__ */ new Map();
+var close = (path) => {
+  const copy = copies.get(path);
+  if (!copy) return;
+  copies.delete(path);
+  try {
+    copy.db.close();
+  } finally {
+    rmSync2(copy.directory, { recursive: true, force: true });
+  }
+};
+process.once("exit", () => {
+  for (const path of copies.keys()) close(path);
+});
+function sqliteRevision(path) {
+  return digest([path, ...[path, `${path}-wal`].map((file, i) => {
+    try {
+      const s = lstatSync2(file);
+      if (!s.isFile() || s.size > 8e9) throw new Error("History database must be a regular file below 8 GB.");
+      return [s.dev, s.ino, s.size, s.mtimeMs, s.ctimeMs];
+    } catch (error) {
+      if (i && error.code === "ENOENT") return null;
+      throw error;
+    }
+  })]);
+}
+function withSqliteSnapshot(path, read3, expected) {
+  const revision2 = sqliteRevision(path);
+  if (expected && revision2 !== expected) throw new Error("History database changed during import; import again.");
+  let copy = copies.get(path);
+  if (copy?.revision !== revision2) {
+    close(path);
+    while (copies.size >= 2) close(copies.keys().next().value);
+    const directory2 = mkdtempSync(join7(tmpdir(), "sessiongraph-history-"));
+    let db2;
+    try {
+      chmodSync(directory2, 448);
+      const destination = join7(directory2, "history.db");
+      for (const suffix of ["", "-wal"]) {
+        try {
+          copyFileSync(path + suffix, destination + suffix, constants4.COPYFILE_FICLONE);
+          chmodSync(destination + suffix, 384);
+        } catch (error) {
+          if (suffix && error.code === "ENOENT") continue;
+          throw error;
+        }
+      }
+      if (sqliteRevision(path) !== revision2) throw new Error("History database changed while copying; import again.");
+      db2 = new DatabaseSync(destination, { readOnly: true, enableDoubleQuotedStringLiterals: false, allowExtension: false });
+      db2.exec("PRAGMA query_only=ON; PRAGMA trusted_schema=OFF; PRAGMA busy_timeout=1000; BEGIN;");
+      copy = { revision: revision2, directory: directory2, db: db2 };
+      copies.set(path, copy);
+    } catch (error) {
+      try {
+        db2?.close();
+      } finally {
+        rmSync2(directory2, { recursive: true, force: true });
+      }
+      throw error;
+    }
+  }
+  const result = read3(copy.db);
+  if (sqliteRevision(path) !== revision2) throw new Error("History database changed during reading; import again.");
+  return result;
+}
+function hasTable(db2, name) {
+  const row = db2.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name=?").get(name);
+  return typeof row?.sql === "string" && !/CREATE\s+VIRTUAL/i.test(row.sql);
+}
+
+// server/adapters/sqlite-histories.ts
+var budget;
+var rowBytes = (row) => Object.values(row).reduce((n, v3) => n + (typeof v3 === "string" ? Buffer.byteLength(v3) : v3 instanceof Uint8Array ? v3.byteLength : 8), 0);
+function consume(bytes2, records = 0) {
+  if (!budget) return;
+  budget.bytes += bytes2;
+  budget.records += records;
+  if (budget.bytes > 64e6 || budget.records > 5e4) throw new Error("Session exceeds the 64 MB / 50,000-record snapshot limit.");
+}
+function parseHistory(source, db2, row, path) {
+  const previous = budget;
+  budget = { bytes: 0, records: 0 };
+  try {
+    consume(rowBytes(row), 1);
+    const history = source.parse(db2, row, path);
+    if (history && history.messages.length > 5e4) throw new Error("Session exceeds the 50,000-message limit.");
+    return history;
+  } finally {
+    budget = previous;
+  }
+}
+function columns(db2, table) {
+  if (!/^[a-z_][a-z0-9_]*$/.test(table) || !hasTable(db2, table)) throw new Error(`Unsupported history table: ${table}.`);
+  return new Set(db2.prepare(`PRAGMA table_info("${table}")`).all().map((r) => String(r.name)));
+}
+function rows(db2, table, fields2, filter, order, limit = 5e4) {
+  const available = columns(db2, table);
+  for (const name of [...fields2, ...filter ? [filter[0]] : [], ...order ? [order] : []]) if (!/^[a-zA-Z_][\w]*$/.test(name)) throw new Error("Invalid history column.");
+  if (filter && !available.has(filter[0])) throw new Error("Unsupported history relation.");
+  const size = (f) => `length(CAST("${f}" AS BLOB))`;
+  const select = fields2.map((f) => available.has(f) ? `CASE WHEN ${size(f)}<=32000000 THEN "${f}" END AS "${f}"` : `NULL AS "${f}"`).join(",");
+  const oversized = fields2.filter((f) => available.has(f)).map((f) => `COALESCE(${size(f)},0)>32000000`).join(" OR ") || "0";
+  const query = `SELECT ${select}, (${oversized}) AS __sessiongraph_oversized FROM "${table}"${filter ? ` WHERE "${filter[0]}"=?` : ""}${order && available.has(order) ? ` ORDER BY "${order}"` : ""} LIMIT ${limit + 1}`;
+  const result = [];
+  let bytes2 = 0;
+  for (const row of db2.prepare(query).iterate(...filter ? [filter[1]] : [])) {
+    if (row.__sessiongraph_oversized) throw new Error("History field exceeds the 32 MB snapshot limit.");
+    delete row.__sessiongraph_oversized;
+    const size2 = rowBytes(row);
+    bytes2 += size2;
+    consume(size2, 1);
+    if (bytes2 > 64e6 || result.length >= limit) throw new Error("History exceeds the 64 MB / record-count query limit.");
+    result.push(row);
+  }
+  return result;
+}
+function sqliteJSON(value) {
+  if (value instanceof Uint8Array) {
+    const expanded = expandHistory(Buffer.from(value), Math.max(1, Math.min(32e6, 64e6 - (budget?.bytes || 0))));
+    consume(expanded.byteLength);
+    return JSON.parse(expanded.toString("utf8"));
+  }
+  if (typeof value === "string") return JSON.parse(value);
+  throw new Error("Missing or oversized history payload.");
+}
+function optionalJSON(value) {
+  return value == null || value === "" ? {} : sqliteJSON(value);
+}
+function sqliteHistoryAdapter(source) {
+  const metadata2 = /* @__PURE__ */ new Map();
+  return {
+    id: source.id,
+    name: source.name,
+    description: source.description || "Local SQLite session history \xB7 isolated read-only snapshots",
+    capabilities: { history: source.history !== false, forks: false, children: false, files: false },
+    async detect() {
+      return (await source.paths()).length > 0;
+    },
+    async discover() {
+      const sessions = /* @__PURE__ */ new Map(), warnings = [], blocked = [];
+      let unavailable = false;
+      for (const path of await source.paths()) {
+        try {
+          const snapshot2 = sqliteRevision(path), rev = digest([2, source.id, snapshot2]);
+          let cached2 = metadata2.get(path);
+          if (!cached2 || cached2.revision !== rev) {
+            cached2 = withSqliteSnapshot(path, (db2) => {
+              const table = typeof source.table === "string" ? source.table : source.table(db2);
+              const values2 = rows(db2, table, source.fields, void 0, source.key, 2e4), found = [];
+              const blocked2 = [], warnings2 = [];
+              for (const row of values2) {
+                try {
+                  const h3 = parseHistory(source, db2, row, path);
+                  if (!h3) continue;
+                  if (source.history !== false && !h3.messages.length) throw new Error("No readable conversation.");
+                  if (!h3.nativeID || h3.nativeID.length > 512) throw new Error("Missing native session identity.");
+                  const created = time(h3.session?.created) || h3.messages.map((m) => time(m.time)).find(Boolean);
+                  if (!created) throw new Error("Session has no recorded creation or message date.");
+                  const session = { ...blankSession(source.id, h3.nativeID), ...h3.session, created };
+                  session.id = identity(source.id, h3.nativeID);
+                  session.nativeID = h3.nativeID;
+                  session.source = source.id;
+                  session.directory = text(session.directory);
+                  session.projectID = project(source.id, session.directory).id;
+                  session.agent ||= source.name;
+                  session.updated ||= created;
+                  session.parentID = h3.parent ? identity(source.id, h3.parent) : void 0;
+                  session.forkID = h3.fork ? identity(source.id, h3.fork) : void 0;
+                  if (!session.title || session.title === "Untitled session") session.title = h3.messages.flatMap((m) => m.role === "user" ? m.fragments.filter((f) => f.kind === "You").map((f) => f.text) : []).find(Boolean)?.replace(/\s+/g, " ").slice(0, 180) || `${source.name} session`;
+                  found.push({ session, revision: rev, locator: { path, snapshot: snapshot2, table, key: String(row[source.key]) } });
+                } catch {
+                  blocked2.push(identity(source.id, String(row[source.key])));
+                }
+              }
+              if (blocked2.length) warnings2.push(`${blocked2.length} ${source.name} sessions had unsupported, undated, missing, or oversized history; saved imports are kept.`);
+              return { revision: rev, candidates: found, blocked: blocked2, warnings: warnings2 };
+            }, snapshot2);
+            metadata2.set(path, cached2);
+          }
+          warnings.push(...cached2.warnings);
+          blocked.push(...cached2.blocked);
+          for (const c of cached2.candidates) {
+            const old = sessions.get(c.session.id);
+            if (!old || c.session.updated > old.session.updated) sessions.set(c.session.id, c);
+          }
+        } catch {
+          unavailable = true;
+          warnings.push(`A ${source.name} database could not be read consistently; saved imports are kept.`);
+        }
+      }
+      const values = [...sessions.values()];
+      return { sessions: values, projects: [...new Map(values.map((c) => {
+        const p = project(source.id, c.session.directory);
+        return [p.id, p];
+      })).values()], warnings, blocked, unavailable };
+    },
+    async read(candidate, cursor) {
+      if (cursor) throw new Error("Invalid SQLite history cursor.");
+      const { path, snapshot: snapshot2, key } = candidate.locator;
+      return withSqliteSnapshot(path, (db2) => {
+        const table = typeof source.table === "string" ? source.table : source.table(db2);
+        const row = rows(db2, table, source.fields, [source.key, key], void 0, 1)[0];
+        if (!row) throw new Error("Session metadata is unavailable.");
+        const history = parseHistory(source, db2, row, path);
+        if (!history || history.nativeID !== candidate.session.nativeID) throw new Error("Session identity changed.");
+        if (source.history !== false && !history.messages.length) throw new Error("No readable conversation.");
+        return { messages: history.messages, partial: Boolean(history.partial || history.messages.some((m) => m.partial)), note: `${history.note} File snapshots are unavailable. Missing message timestamps remain unknown.` };
+      }, snapshot2);
+    }
+  };
+}
+async function existingDatabases(paths) {
+  const found = [];
+  for (const path of new Set(paths)) {
+    try {
+      if ((await lstat3(path)).isFile()) found.push(path);
+    } catch (e10) {
+      if (e10.code !== "ENOENT") throw e10;
+    }
+  }
+  return found;
+}
+function combineAdapters(parts) {
+  const first = parts[0];
+  return {
+    ...first,
+    async detect() {
+      for (const p of parts) if (await p.detect().catch(() => false)) return true;
+      return false;
+    },
+    async discover() {
+      const sessions = /* @__PURE__ */ new Map(), projects = /* @__PURE__ */ new Map(), warnings = [], blocked = /* @__PURE__ */ new Set();
+      for (const [i, part] of parts.entries()) {
+        let result;
+        try {
+          if (!await part.detect()) continue;
+          result = await part.discover();
+        } catch {
+          warnings.push(`A ${part.name} representation could not be read; saved imports are retained.`);
+          break;
+        }
+        warnings.push(...result.warnings);
+        for (const id2 of result.blocked || []) blocked.add(id2);
+        for (const p of result.projects) projects.set(p.id, p);
+        for (const c of result.sessions) if (!blocked.has(c.session.id) && !sessions.has(c.session.id)) sessions.set(c.session.id, { ...c, revision: digest([i, c.revision]), locator: { ...c.locator, representation: String(i), originalRevision: c.revision } });
+        if (result.unavailable) break;
+      }
+      return { sessions: [...sessions.values()], projects: [...projects.values()], warnings };
+    },
+    async read(candidate, cursor) {
+      const index = Number(candidate.locator.representation);
+      if (!Number.isInteger(index) || !parts[index]) throw new Error("Invalid history representation.");
+      return parts[index].read({ ...candidate, revision: candidate.locator.originalRevision }, cursor);
+    }
+  };
+}
+
+// server/adapters/claude.ts
+var root = () => join8(process.env.CLAUDE_CONFIG_DIR || join8(homedir4(), ".claude"), "projects");
+function claudeMessages(rows2, candidate, times) {
+  const calls = /* @__PURE__ */ new Map();
+  return rows2.map((row) => {
+    const raw = row.message;
+    const msg = blankMessage(row.uuid, times?.get(row.uuid) ?? (Number.isFinite(Date.parse(raw?.timestamp)) ? Date.parse(raw.timestamp) : 0), row.type);
+    if (raw?.model) candidate.session.model = raw.model;
+    if (row.parent_agent_id && candidate.locator.parent) candidate.session.parentID = identity("claude-code", `${candidate.locator.parent}/agent/${row.parent_agent_id}`);
+    if (typeof raw?.content === "string") addText(msg, raw.content, row.type === "user" ? "You" : "Assistant");
+    for (const part of Array.isArray(raw?.content) ? raw.content : []) {
+      if (part.type === "text") addText(msg, part.text, row.type === "user" ? "You" : "Assistant");
+      if (part.type === "tool_use") {
+        calls.set(part.id, { name: part.name, input: part.input });
+        msg.tools.push(part.name);
+        addText(msg, part.name, "Tool");
+        toolText(msg, part.input);
+      }
+      if (part.type === "tool_result") {
+        toolText(msg, part.content);
+        const call = calls.get(part.tool_use_id);
+        if (!part.is_error && call && ["Edit", "Write", "MultiEdit", "NotebookEdit"].includes(call.name)) {
+          const path = call.input?.file_path || call.input?.notebook_path;
+          if (typeof path === "string") msg.files.push({ path, source: "edit tool", steps: 1 });
+        }
+      }
+    }
+    msg.events = blockEvents(msg, raw?.content).map((event) => ({ ...event, parentID: row.parent_tool_use_id || void 0 }));
+    if (!msg.events.length) msg.events = [eventFor(msg, "event", raw?.subtype === "compact_boundary" ? "compaction" : "event", raw?.subtype || `${row.type} event`, eventText(raw), { nativeType: raw?.subtype || row.type, partial: true })];
+    return msg;
+  });
+}
+var sdkClaudeAdapter = {
+  id: "claude-code",
+  name: "Claude Code",
+  description: "Local CLI and VS Code history \xB7 all projects and subagent transcripts",
+  capabilities: { history: true, forks: false, children: true, files: true },
+  async detect() {
+    try {
+      return (await stat(root())).isDirectory();
+    } catch {
+      return false;
+    }
+  },
+  async discover() {
+    const sessions = [], warnings = [];
+    const infos = await I1t({ limit: 2e4, includeProgrammatic: true });
+    if (infos.length === 2e4) warnings.push("Claude Code listing is limited to 20,000 sessions.");
+    const files = /* @__PURE__ */ new Map();
+    let unreadable = 0;
+    for (const dir of await readdir2(root(), { withFileTypes: true })) {
+      if (!dir.isDirectory()) continue;
+      const parent2 = join8(root(), dir.name);
+      let entries2;
+      try {
+        entries2 = await readdir2(parent2, { withFileTypes: true });
+      } catch {
+        unreadable++;
+        continue;
+      }
+      for (const file of entries2) if (file.isFile() && file.name.endsWith(".jsonl") && claudeSessionID(file.name.slice(0, -6))) {
+        const id2 = file.name.slice(0, -6), path = join8(parent2, file.name);
+        try {
+          const old = files.get(id2);
+          if (!old || (await stat(path)).mtimeMs > (await stat(old.path)).mtimeMs) files.set(id2, { path, children: join8(parent2, id2, "subagents") });
+        } catch {
+          unreadable++;
+        }
+      }
+    }
+    const listed = new Set(infos.map((info) => info.sessionId));
+    for (const [id2, file] of files) {
+      if (listed.has(id2)) continue;
+      if (infos.length >= 2e4) {
+        warnings.push("Claude Code discovery is limited to 20,000 sessions.");
+        break;
+      }
+      try {
+        const transcript = await claudeTranscript(file.path, await claudeRevision(file.path));
+        const info = claudeTranscriptInfo(transcript, id2);
+        if (info) infos.push(info);
+        else if (transcript.partial) unreadable++;
+      } catch {
+        unreadable++;
+      }
+    }
+    for (const info of infos) {
+      const file = files.get(info.sessionId);
+      if (!file) continue;
+      const s = { ...blankSession("claude-code", info.sessionId, info.cwd), title: info.customTitle || info.summary || info.firstPrompt || "Untitled session", created: info.createdAt || info.lastModified, updated: info.lastModified, provider: "anthropic", agent: "Claude Code" };
+      try {
+        sessions.push({ session: s, revision: await claudeRevision(file.path), locator: { path: file.path, dir: info.cwd || "" } });
+      } catch {
+        unreadable++;
+        continue;
+      }
+      let children;
+      try {
+        children = await readdir2(file.children, { withFileTypes: true });
+      } catch (error) {
+        if (error.code !== "ENOENT") unreadable++;
+        continue;
+      }
+      for (const child of children) {
+        if (!child.isFile() || !/^agent-[\w-]+\.jsonl$/.test(child.name)) continue;
+        try {
+          const agent = child.name.slice(6, -6), path = join8(file.children, child.name), stats = await stat(path);
+          sessions.push({ session: { ...s, id: identity("claude-code", `${info.sessionId}/agent/${agent}`), nativeID: `${info.sessionId}/agent/${agent}`, title: `Subagent ${agent}`, created: stats.birthtimeMs || s.created, updated: stats.mtimeMs, parentID: s.id, agent }, revision: await claudeRevision(path), locator: { path, dir: info.cwd || "", parent: info.sessionId, agent } });
+        } catch {
+          unreadable++;
+        }
+      }
+    }
+    if (unreadable) warnings.push(`${unreadable} Claude Code histories unavailable or too large. Saved imports are kept.`);
+    return { sessions, projects: [...new Map(sessions.map((c) => {
+      const p = project("claude-code", c.session.directory);
+      return [p.id, p];
+    })).values()], warnings };
+  },
+  async read(candidate, cursor) {
+    const offset = Number(cursor || 0);
+    if (!Number.isSafeInteger(offset) || offset < 0) throw new Error("Invalid history cursor.");
+    const transcript = await claudeTranscript(candidate.locator.path, candidate.revision);
+    const start = Math.max(0, offset - 1), count = 120 + offset - start;
+    const sessionId = candidate.locator.parent || candidate.session.nativeID;
+    const options = { dir: candidate.locator.dir || void 0, offset: start, limit: count + 1, sessionStore: claudeTranscriptStore(transcript, sessionId, candidate.locator.agent) };
+    const rows2 = candidate.locator.parent ? await U1t(candidate.locator.parent, candidate.locator.agent, options) : await P1t(candidate.session.nativeID, options);
+    const more = rows2.length > count;
+    const messages = claudeMessages(rows2.slice(0, count), candidate, transcript.times).slice(offset - start);
+    if (!offset && !messages.length && transcript.size > 100) throw new Error("SDK returned no readable conversation for this transcript.");
+    if (!more && await claudeRevision(candidate.locator.path) !== candidate.revision) throw new Error("Session changed during import; import again to capture the latest messages.");
+    return { messages, cursor: more ? String(offset + 120) : void 0, partial: transcript.partial, note: `SDK-visible conversation chain from the local CLI/VS Code transcript; pre-compaction text and unsupported message types may be absent. Fork ancestry is unavailable.${transcript.partial ? " Some transcript records or subagent metadata were unreadable." : ""}` };
+  }
+};
+var exportedClaudeAdapter = localFileAdapter({
+  id: "claude-code",
+  name: "Claude Code",
+  description: "Legacy local transcript exports",
+  capabilities: { history: true, forks: false, children: false, files: false },
+  roots: () => [join8(process.env.CLAUDE_CONFIG_DIR || join8(homedir4(), ".claude"), "transcripts")],
+  match: (p) => p.endsWith(".jsonl"),
+  parse: (path, files) => envelopeHistory(path, files.get(path))
+});
+var claudeAdapter = combineAdapters([sdkClaudeAdapter, exportedClaudeAdapter]);
+
+// server/adapters/codex.ts
+import { stat as stat2 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { join as join10, sep as sep2 } from "node:path";
 
 // server/adapters/jsonl.ts
-import { open as open2, readdir as readdir2 } from "node:fs/promises";
-import { join as join5 } from "node:path";
-async function readJSONL(path, offset = 0, budget = 2e6, limit = 200) {
-  const file = await open2(path, "r");
-  const rows = [];
+import { open as open3, readdir as readdir3 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+import { constants as constants5 } from "node:fs";
+var compressed;
+async function readJSONL(path, offset = 0, budget2 = 2e6, limit = 200) {
+  if (!Number.isSafeInteger(offset) || offset < 0) throw new Error("Invalid transcript cursor.");
+  const file = await open3(path, constants5.O_RDONLY | (constants5.O_NOFOLLOW || 0));
+  const rows2 = [];
   let position = offset, carry = Buffer.alloc(0), lineStart = offset, partial = false, skipping = false, eof = false;
   try {
-    while (rows.length < limit && (position - offset < budget || lineStart === offset || skipping)) {
+    let data;
+    if (/\.jsonl\..+/.test(path)) {
+      const s = await file.stat(), stamp2 = JSON.stringify([s.ino, s.size, s.mtimeMs, s.ctimeMs]);
+      if (!s.isFile() || s.size > 128e6) throw new Error("Compressed history exceeds the 128 MB limit.");
+      if (compressed?.path === path && compressed.stamp === stamp2) data = compressed.data;
+      else {
+        const input = Buffer.alloc(s.size + 1);
+        let bytes2 = 0;
+        while (bytes2 < input.length) {
+          const r = await file.read(input, bytes2, input.length - bytes2, bytes2);
+          if (!r.bytesRead) break;
+          bytes2 += r.bytesRead;
+        }
+        const after = await file.stat();
+        if (bytes2 !== s.size || stamp2 !== JSON.stringify([after.ino, after.size, after.mtimeMs, after.ctimeMs])) throw new Error("Compressed history changed during reading.");
+        data = expandHistory(input.subarray(0, bytes2), 128e6);
+        compressed = { path, stamp: stamp2, data };
+      }
+    }
+    while (rows2.length < limit && (position - offset < budget2 || lineStart === offset || skipping)) {
       if (position - offset > 64e6) throw new Error("Transcript contains a line larger than the 64 MB scan limit.");
       const buffer = Buffer.alloc(64e3);
-      const { bytesRead } = await file.read(buffer, 0, buffer.length, position);
+      const bytesRead = data ? data.copy(buffer, 0, Math.min(position, data.length), Math.min(position + buffer.length, data.length)) : (await file.read(buffer, 0, buffer.length, position)).bytesRead;
       if (!bytesRead) {
         eof = true;
         break;
@@ -30660,14 +31420,14 @@ async function readJSONL(path, offset = 0, budget = 2e6, limit = 200) {
         carry = carry.subarray(at2 + 1);
         if (!skipping && line.length) {
           try {
-            rows.push({ offset: lineStart, value: JSON.parse(line.toString("utf8")) });
+            rows2.push({ offset: lineStart, value: JSON.parse(line.toString("utf8")) });
           } catch {
             partial = true;
           }
         }
         skipping = false;
         lineStart += at2 + 1;
-        if (rows.length >= limit) return { rows, cursor: lineStart, partial };
+        if (rows2.length >= limit) return { rows: rows2, cursor: lineStart, partial };
       }
       if (carry.length > 2e6) {
         partial = true;
@@ -30678,29 +31438,29 @@ async function readJSONL(path, offset = 0, budget = 2e6, limit = 200) {
     }
     if (eof && carry.length && !skipping) {
       try {
-        rows.push({ offset: lineStart, value: JSON.parse(carry.toString("utf8")) });
+        rows2.push({ offset: lineStart, value: JSON.parse(carry.toString("utf8")) });
       } catch {
         partial = true;
       }
     }
-    return { rows, cursor: eof ? void 0 : lineStart, partial };
+    return { rows: rows2, cursor: eof ? void 0 : lineStart, partial };
   } finally {
     await file.close();
   }
 }
-async function transcriptFiles(root3, max = 2e4) {
+async function transcriptFiles(root3, max = 2e4, match = (name) => name.endsWith(".jsonl")) {
   const files = [], queue = [root3];
   for (let i = 0; i < queue.length && files.length < max; i++) {
     let entries2;
     try {
-      entries2 = await readdir2(queue[i], { withFileTypes: true });
+      entries2 = await readdir3(queue[i], { withFileTypes: true });
     } catch (error) {
       if (error.code === "ENOENT") continue;
       throw error;
     }
     for (const entry of entries2) {
-      if (entry.isDirectory() && queue.length < 2e4) queue.push(join5(queue[i], entry.name));
-      if (entry.isFile() && entry.name.endsWith(".jsonl")) files.push(join5(queue[i], entry.name));
+      if (entry.isDirectory() && queue.length < 2e4) queue.push(join9(queue[i], entry.name));
+      if (entry.isFile() && match(entry.name)) files.push(join9(queue[i], entry.name));
       if (files.length >= max) break;
     }
   }
@@ -30708,10 +31468,10 @@ async function transcriptFiles(root3, max = 2e4) {
 }
 
 // server/adapters/codex.ts
-var root2 = () => process.env.CODEX_HOME || join6(homedir4(), ".codex");
+var root2 = () => process.env.CODEX_HOME || join10(homedir5(), ".codex");
 var revision = async (path) => {
   const s = await stat2(path);
-  return digest([7, s.mtimeMs, s.size]);
+  return digest([8, s.mtimeMs, s.size]);
 };
 function changedPaths(value) {
   if (!value || typeof value !== "object") return [];
@@ -30731,7 +31491,7 @@ async function sessionNames() {
   let cursor, count = 0;
   try {
     do {
-      const page = await readJSONL(join6(root2(), "session_index.jsonl"), cursor, 2e6, 1e3);
+      const page = await readJSONL(join10(root2(), "session_index.jsonl"), cursor, 2e6, 1e3);
       for (const { value } of page.rows) if (typeof value.id === "string" && typeof value.thread_name === "string" && value.thread_name.trim()) names.set(value.id, value.thread_name.trim().slice(0, 300));
       cursor = page.cursor;
       count += page.rows.length;
@@ -30808,36 +31568,42 @@ var codexAdapter = {
   async discover() {
     const found = /* @__PURE__ */ new Map(), warnings = [];
     const names = await sessionNames();
-    const paths = [...await transcriptFiles(join6(root2(), "sessions")), ...await transcriptFiles(join6(root2(), "archived_sessions"))];
+    const match = (name) => /\.jsonl(?:\.[\w.-]+)?$/.test(name);
+    const paths = [...await transcriptFiles(join10(root2(), "sessions"), 2e4, match), ...await transcriptFiles(join10(root2(), "archived_sessions"), 2e4, match)];
     if (paths.length >= 2e4) warnings.push("Codex transcript listing may be partial (20,000 files per history folder).");
     let unsupported = 0;
     for (const path of paths) {
-      const first = await readJSONL(path, 0, 2e6, 100);
-      const meta = first.rows.find((r) => r.value.type === "session_meta")?.value.payload;
-      if (!meta?.id || typeof meta.id !== "string") {
-        unsupported++;
-        continue;
-      }
-      const stats = await stat2(path), session = blankSession("codex", meta.id, meta.cwd);
-      session.title = names.get(meta.id) || (typeof meta.name === "string" ? meta.name : "Untitled session");
-      const source = meta.source?.subagent?.thread_spawn || meta.source?.sub_agent?.thread_spawn;
-      const parent2 = meta.parent_thread_id || source?.parent_thread_id;
-      const fork = meta.forked_from_id || meta.forkedFromId;
-      Object.assign(session, { created: Date.parse(meta.timestamp) || stats.birthtimeMs || stats.mtimeMs, updated: stats.mtimeMs, archived: path.includes(`${sep2}archived_sessions${sep2}`), provider: meta.model_provider || "", agent: "Codex", parentID: parent2 ? identity("codex", parent2) : void 0, forkID: fork ? identity("codex", fork) : void 0 });
-      const candidate = { session, locator: { path }, revision: await revision(path) };
-      for (const row of first.rows) {
-        const msg = codexRecord(row.value, row.offset, candidate);
-        if (session.title === "Untitled session" && msg?.role === "user") {
-          const text2 = msg.fragments.find((f) => f.kind === "You")?.text;
-          if (text2) session.title = text2.replace(/\s+/g, " ").slice(0, 180);
+      try {
+        const first = await readJSONL(path, 0, 2e6, 100);
+        const meta = first.rows.find((r) => r.value.type === "session_meta")?.value.payload;
+        if (!meta?.id || typeof meta.id !== "string") {
+          unsupported++;
+          continue;
+        }
+        const stats = await stat2(path), session = blankSession("codex", meta.id, meta.cwd);
+        session.title = names.get(meta.id) || (typeof meta.name === "string" ? meta.name : "Untitled session");
+        const source = meta.source?.subagent?.thread_spawn || meta.source?.sub_agent?.thread_spawn;
+        const parent2 = meta.parent_thread_id || source?.parent_thread_id;
+        const fork = meta.forked_from_id || meta.forkedFromId;
+        Object.assign(session, { created: Date.parse(meta.timestamp) || stats.birthtimeMs || stats.mtimeMs, updated: stats.mtimeMs, archived: path.includes(`${sep2}archived_sessions${sep2}`), provider: meta.model_provider || "", agent: "Codex", parentID: parent2 ? identity("codex", parent2) : void 0, forkID: fork ? identity("codex", fork) : void 0 });
+        const candidate = { session, locator: { path }, revision: await revision(path) };
+        for (const row of first.rows) {
+          const msg = codexRecord(row.value, row.offset, candidate);
+          if (session.title === "Untitled session" && msg?.role === "user") {
+            const text2 = msg.fragments.find((f) => f.kind === "You")?.text;
+            if (text2) session.title = text2.replace(/\s+/g, " ").slice(0, 180);
+          }
         }
+        if (session.title === "Untitled session") session.title = "Codex session";
+        const old = found.get(session.id);
+        const rank = (c) => (c.session.archived ? 0 : 2) + Number(c.locator.path.endsWith(".jsonl"));
+        if (!old || rank(candidate) > rank(old) || rank(candidate) === rank(old) && session.updated > old.session.updated) found.set(session.id, candidate);
+      } catch {
+        unsupported++;
       }
-      if (session.title === "Untitled session") session.title = "Codex session";
-      const old = found.get(session.id);
-      if (!old || session.updated > old.session.updated) found.set(session.id, candidate);
     }
-    if (unsupported) warnings.push(`${unsupported} Codex files have no supported rollout metadata.`);
-    warnings.push("Codex imports local JSONL rollouts. Cloud-only and store-only history are not imported.");
+    if (unsupported) warnings.push(`${unsupported} Codex files were unreadable, oversized, or had no supported rollout metadata; saved history is retained.`);
+    warnings.push("Codex imports local JSONL rollouts and bounded zstd/gzip archive copies. Cloud-only and store-only history are not imported.");
     const sessions = [...found.values()];
     return { sessions, projects: [...new Map(sessions.map((c) => {
       const p = project("codex", c.session.directory);
@@ -30856,10 +31622,10 @@ var codexAdapter = {
 
 // server/adapters/cursor.ts
 import { createHash as createHash3 } from "node:crypto";
-import { lstat as lstat2, opendir, readFile as readFile3 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { isAbsolute as isAbsolute2, join as join8 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { lstat as lstat4, opendir, readFile as readFile3 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { isAbsolute as isAbsolute3, join as join12 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // server/adapters/cursor-message.ts
 function cursorTime(value) {
@@ -30933,19 +31699,19 @@ function cursorMessage(raw, fallbackID) {
 }
 
 // server/adapters/cursor-store.ts
-import { DatabaseSync } from "node:sqlite";
-import { chmodSync, copyFileSync, lstatSync as lstatSync2, mkdtempSync, rmSync as rmSync2 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join7 } from "node:path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { chmodSync as chmodSync2, copyFileSync as copyFileSync2, lstatSync as lstatSync3, mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join11 } from "node:path";
 var MAX_VALUE = 2e6;
-var MAX_BYTES2 = 64e6;
+var MAX_BYTES3 = 64e6;
 var MAX_NODES = 5e4;
 var MAX_TEXT = 16e6;
 function withStore(path, read3) {
   const files = [path, `${path}-wal`];
   const stats = () => files.map((file) => {
     try {
-      const s = lstatSync2(file);
+      const s = lstatSync3(file);
       if (!s.isFile() || s.size > 256e6) throw new Error("Cursor store must be a regular file below 256 MB (including each WAL).");
       return [s.ino, s.size, s.mtimeMs, s.ctimeMs];
     } catch (error) {
@@ -30953,27 +31719,27 @@ function withStore(path, read3) {
       throw error;
     }
   });
-  const before = stats(), directory = mkdtempSync(join7(tmpdir(), "sessiongraph-cursor-"));
+  const before = stats(), directory2 = mkdtempSync2(join11(tmpdir2(), "sessiongraph-cursor-"));
   let db2;
   try {
-    chmodSync(directory, 448);
-    const copy = join7(directory, "store.db");
+    chmodSync2(directory2, 448);
+    const copy = join11(directory2, "store.db");
     files.forEach((file, index) => {
       if (before[index]) {
         const target = index ? `${copy}-wal` : copy;
-        copyFileSync(file, target);
-        chmodSync(target, 384);
+        copyFileSync2(file, target);
+        chmodSync2(target, 384);
       }
     });
     if (JSON.stringify(stats()) !== JSON.stringify(before)) throw new Error("Cursor store changed while copying; re-import to retry.");
-    db2 = new DatabaseSync(copy, { readOnly: true, enableDoubleQuotedStringLiterals: false, allowExtension: false });
+    db2 = new DatabaseSync2(copy, { readOnly: true, enableDoubleQuotedStringLiterals: false, allowExtension: false });
     db2.exec("PRAGMA query_only=ON; PRAGMA trusted_schema=OFF; PRAGMA busy_timeout=1000; BEGIN;");
     return read3(db2);
   } finally {
     try {
       db2?.close();
     } finally {
-      rmSync2(directory, { recursive: true, force: true });
+      rmSync3(directory2, { recursive: true, force: true });
     }
   }
 }
@@ -31028,7 +31794,7 @@ function readCursorStore(path) {
     let bytes2 = 0, nodes = 0, text2 = 0, partial = false, ordinal = 0;
     const stack = [{ id: root3, leaf: false, ancestors: [] }];
     while (stack.length) {
-      if (++nodes > MAX_NODES || bytes2 >= MAX_BYTES2 || text2 >= MAX_TEXT) {
+      if (++nodes > MAX_NODES || bytes2 >= MAX_BYTES3 || text2 >= MAX_TEXT) {
         partial = true;
         break;
       }
@@ -31037,7 +31803,7 @@ function readCursorStore(path) {
         partial = true;
         continue;
       }
-      const row = get.get(item.id, Math.min(MAX_VALUE, MAX_BYTES2 - bytes2));
+      const row = get.get(item.id, Math.min(MAX_VALUE, MAX_BYTES3 - bytes2));
       if (!(row?.data instanceof Uint8Array)) {
         partial = true;
         continue;
@@ -31093,16 +31859,126 @@ function readCursorStore(path) {
   });
 }
 
+// server/adapters/cursor-composer.ts
+import { isAbsolute as isAbsolute2 } from "node:path";
+import { fileURLToPath } from "node:url";
+var MAX_VALUE2 = 32e6;
+var MAX_BUBBLE = 8e6;
+var MAX_MESSAGES = 5e4;
+var MAX_BYTES4 = 64e6;
+function decode(value) {
+  return object(JSON.parse(typeof value === "string" ? value : value instanceof Uint8Array ? Buffer.from(value).toString("utf8") : "{}"));
+}
+function directory(raw) {
+  const value = text(raw.workspaceIdentifier?.uri?.path) || text(raw.workspaceIdentifier?.uri) || text(raw.cwd);
+  try {
+    return value.startsWith("file:") ? fileURLToPath(value) : isAbsolute2(value) ? value : "";
+  } catch {
+    return "";
+  }
+}
+function discoverComposers(path, workspace = "") {
+  const snapshot2 = sqliteRevision(path);
+  return withSqliteSnapshot(path, (db2) => {
+    const sessions = [], warnings = [];
+    for (const table of ["cursorDiskKV", "ItemTable"]) {
+      if (!hasTable(db2, table)) continue;
+      let failed = 0, count = 0;
+      const rows2 = db2.prepare(`SELECT key, CASE WHEN length(value)<=? THEN value END AS value FROM ${table} WHERE key LIKE 'composerData:%' ORDER BY key LIMIT 20001`).iterate(MAX_VALUE2);
+      for (const row of rows2) {
+        if (++count > 2e4) {
+          warnings.push("Cursor Composer listing reached its 20,000-session limit.");
+          break;
+        }
+        try {
+          if (row.value == null) throw new Error("Oversized Composer.");
+          const data = decode(row.value), nativeID = text(data.composerId);
+          if (!nativeID || row.key !== `composerData:${nativeID}`) throw new Error("Composer identity mismatch.");
+          const headers = Array.isArray(data.fullConversationHeadersOnly) ? data.fullConversationHeadersOnly : Array.isArray(data.conversation) ? data.conversation : [];
+          if (!headers.length) continue;
+          const session = blankSession("cursor", nativeID, directory(data) || workspace);
+          session.created = cursorTime(data.createdAt);
+          if (!session.created) continue;
+          session.updated = cursorTime(data.lastUpdatedAt) || session.created;
+          session.title = text(data.name).slice(0, 300) || "Cursor Composer session";
+          session.agent = "Cursor Composer";
+          session.model = text(data.modelConfig?.modelName) || "Unknown model";
+          session.archived = data.isArchived === true;
+          const children = Array.isArray(data.subagentComposerIds) ? data.subagentComposerIds.filter((id2) => typeof id2 === "string") : [];
+          sessions.push({ session, revision: digest([1, snapshot2, table, nativeID]), locator: { path, kind: "composer", table, snapshot: snapshot2, nativeID, children: JSON.stringify(children) } });
+        } catch {
+          failed++;
+        }
+      }
+      if (failed) warnings.push(`${failed} legacy Cursor Composer records were unreadable or oversized; saved imports are retained.`);
+    }
+    const parents = /* @__PURE__ */ new Map();
+    for (const c of sessions) for (const id2 of JSON.parse(c.locator.children)) {
+      const found = parents.get(id2) || /* @__PURE__ */ new Set();
+      found.add(c.session.nativeID);
+      parents.set(id2, found);
+    }
+    for (const c of sessions) {
+      const found = parents.get(c.session.nativeID);
+      if (found?.size === 1 && !found.has(c.session.nativeID)) c.session.parentID = identity("cursor", [...found][0]);
+      c.session.projectID = project("cursor", c.session.directory).id;
+      c.revision = digest([c.revision, c.session.directory, c.session.parentID]);
+    }
+    return { sessions, warnings };
+  }, snapshot2);
+}
+function readComposer(candidate) {
+  const { path, table, nativeID, snapshot: snapshot2 } = candidate.locator;
+  if (!["cursorDiskKV", "ItemTable"].includes(table)) throw new Error("Unsupported Composer table.");
+  return withSqliteSnapshot(path, (db2) => {
+    const get = db2.prepare(`SELECT value FROM ${table} WHERE key=? AND length(value)<=?`);
+    const row = get.get(`composerData:${nativeID}`, MAX_VALUE2);
+    if (!row) throw new Error("Composer history is unavailable.");
+    const data = decode(row.value), messages = [];
+    const records = Array.isArray(data.fullConversationHeadersOnly) ? data.fullConversationHeadersOnly : data.conversation;
+    if (!Array.isArray(records)) throw new Error("Unsupported Composer history.");
+    let bytes2 = 0, partial = false;
+    for (const [index, header] of records.entries()) {
+      if (index >= MAX_MESSAGES || bytes2 >= MAX_BYTES4) {
+        partial = true;
+        break;
+      }
+      try {
+        const id2 = text(header.bubbleId);
+        const stored = id2 ? get.get(`bubbleId:${nativeID}:${id2}`, MAX_BUBBLE) : void 0;
+        if (stored) bytes2 += typeof stored.value === "string" ? Buffer.byteLength(stored.value) : stored.value.byteLength;
+        const raw = stored ? { ...header, ...decode(stored.value) } : { ...header, ...object(data.conversationMap?.[id2]) };
+        if (![1, 2].includes(raw.type)) {
+          partial = true;
+          continue;
+        }
+        if (typeof raw.text !== "string") {
+          partial = true;
+          continue;
+        }
+        const content = [{ type: "text", text: raw.text }];
+        if (typeof raw.thinking?.text === "string") content.push({ type: "thinking", thinking: raw.thinking.text });
+        const message2 = cursorMessage({ id: id2 || `bubble:${index}`, role: raw.type === 1 ? "user" : "assistant", timestamp: cursorTime(raw.createdAt) || cursorTime(raw.timingInfo?.clientStartTime), content }, `bubble:${index}`);
+        if (message2) messages.push(message2);
+      } catch {
+        partial = true;
+      }
+    }
+    if (!messages.length) throw new Error("Composer has no readable message bodies; saved imports are retained.");
+    return { messages, partial: true, note: `Legacy Cursor Composer conversation order and native bubble IDs. Original creation dates are preserved; absent message timestamps remain unknown. Tool internals, attachments, encrypted bodies, and file snapshots are unavailable.${partial ? " Some missing, unsupported, or bounded bubbles were omitted." : ""}` };
+  }, snapshot2);
+}
+
 // server/adapters/cursor.ts
 var LIMIT = 2e4;
 var validID = (id2) => /^[a-z\d][\w-]{0,159}$/i.test(id2);
-var cwd = (value) => typeof value === "string" && isAbsolute2(value) && !/[\x00-\x1f\x7f]/.test(value) ? value : "";
+var cwd = (value) => typeof value === "string" && isAbsolute3(value) && !/[\x00-\x1f\x7f]/.test(value) ? value : "";
 var slug = (path) => path.replace(/\\/g, "/").replace(/^([A-Z]):/i, (_, drive) => drive.toLowerCase()).replace(/^\/+|\/+$/g, "").replace(/[/:]+/g, "-");
 var hashCwd = (path) => createHash3("md5").update(path).digest("hex");
-var userData = () => process.platform === "darwin" ? join8(homedir5(), "Library/Application Support/Cursor") : process.platform === "win32" ? join8(process.env.APPDATA || join8(homedir5(), "AppData/Roaming"), "Cursor") : join8(process.env.XDG_CONFIG_HOME || join8(homedir5(), ".config"), "Cursor");
+var userData = () => process.platform === "darwin" ? join12(homedir6(), "Library/Application Support/Cursor") : process.platform === "win32" ? join12(process.env.APPDATA || join12(homedir6(), "AppData/Roaming"), "Cursor") : join12(process.env.XDG_CONFIG_HOME || join12(homedir6(), ".config"), "Cursor");
 async function fileStats(path) {
   try {
-    const s = await lstat2(path);
+    const s = await lstat4(path);
     if (s.isSymbolicLink()) throw new Error("Cursor history symlinks are not followed.");
     return s.isFile() ? s : void 0;
   } catch (error) {
@@ -31117,7 +31993,7 @@ async function stamp(path) {
 async function snapshot(locator) {
   return digest(await Promise.all([stamp(locator.path), locator.kind === "transcript" ? null : stamp(`${locator.path}-wal`), locator.meta ? stamp(locator.meta) : null]));
 }
-async function json2(path) {
+async function json3(path) {
   const s = await fileStats(path);
   if (!s) return {};
   if (s.size > 128e3) throw new Error("Cursor metadata exceeds the 128 KB limit.");
@@ -31127,7 +32003,7 @@ async function json2(path) {
 async function entries(path, warnings) {
   const result = [];
   try {
-    if (!(await lstat2(path)).isDirectory()) return result;
+    if (!(await lstat4(path)).isDirectory()) return result;
     for await (const entry of await opendir(path)) {
       if (!entry.isSymbolicLink()) result.push(entry);
       if (result.length === LIMIT) {
@@ -31141,32 +32017,39 @@ async function entries(path, warnings) {
   return result.sort((a, b) => a.name.localeCompare(b.name));
 }
 async function workspacePaths(root3, warnings) {
-  const paths = /* @__PURE__ */ new Set();
-  const storage = join8(root3, "User/workspaceStorage");
+  const stores = /* @__PURE__ */ new Map();
+  const storage = join12(root3, "User/workspaceStorage");
   for (const entry of await entries(storage, warnings)) if (entry.isDirectory()) {
+    const database = join12(storage, entry.name, "state.vscdb");
+    stores.set(database, "");
     try {
-      const info = await json2(join8(storage, entry.name, "workspace.json"));
+      const info = await json3(join12(storage, entry.name, "workspace.json"));
       if (typeof info.folder === "string" && info.folder.startsWith("file:")) {
-        const path = cwd(fileURLToPath(info.folder));
-        if (path) paths.add(path);
+        const path = cwd(fileURLToPath2(info.folder));
+        if (path) stores.set(database, path);
       }
     } catch {
       warnings.push("A Cursor workspace mapping could not be read; its directory may be unknown.");
     }
   }
-  return [...paths];
+  return stores;
 }
 function createCursorAdapter(options = {}) {
-  const root3 = () => options.home || process.env.SESSIONGRAPH_CURSOR_HOME || process.env.SESSION_ATLAS_CURSOR_HOME || join8(homedir5(), ".cursor");
+  const root3 = () => options.home || process.env.SESSIONGRAPH_CURSOR_HOME || process.env.SESSION_ATLAS_CURSOR_HOME || join12(homedir6(), ".cursor");
+  const editor = () => options.userData || process.env.SESSIONGRAPH_CURSOR_USER_DATA_DIR || process.env.SESSION_ATLAS_CURSOR_USER_DATA_DIR || userData();
   return {
     id: "cursor",
     name: "Cursor",
-    description: "Local IDE JSONL transcripts, subagents, and CLI / ACP stores \xB7 read-only",
+    description: "Local IDE transcripts, legacy Composer, subagents, and CLI / ACP stores \xB7 read-only",
     capabilities: { history: true, forks: false, children: true, files: false },
     async detect() {
+      if (await fileStats(join12(editor(), "User/globalStorage/state.vscdb"))) return true;
+      for (const entry of await entries(join12(editor(), "User/workspaceStorage"), [])) {
+        if (entry.isDirectory() && await fileStats(join12(editor(), "User/workspaceStorage", entry.name, "state.vscdb"))) return true;
+      }
       for (const name of ["projects", "chats", "acp-sessions"]) {
         try {
-          if ((await lstat2(join8(root3(), name))).isDirectory()) return true;
+          if ((await lstat4(join12(root3(), name))).isDirectory()) return true;
         } catch {
         }
       }
@@ -31174,40 +32057,60 @@ function createCursorAdapter(options = {}) {
     },
     async discover() {
       const warnings = [], found = /* @__PURE__ */ new Map(), blocked = /* @__PURE__ */ new Set();
-      const paths = await workspacePaths(options.userData || process.env.SESSIONGRAPH_CURSOR_USER_DATA_DIR || process.env.SESSION_ATLAS_CURSOR_USER_DATA_DIR || userData(), warnings);
+      const workspaceStores = await workspacePaths(editor(), warnings);
+      const paths = [...new Set([...workspaceStores.values()].filter(Boolean))];
+      const legacyStores = new Map([[join12(editor(), "User/globalStorage/state.vscdb"), ""], ...workspaceStores]);
+      for (const [path, workspace] of legacyStores) {
+        try {
+          if (!await fileStats(path)) continue;
+          const result = discoverComposers(path, workspace);
+          warnings.push(...result.warnings);
+          for (const candidate of result.sessions) {
+            const previous = found.get(candidate.session.id);
+            const selected = !previous || candidate.session.updated > previous.session.updated ? candidate : previous;
+            selected.session.directory ||= candidate.session.directory || previous?.session.directory || "";
+            selected.session.projectID = project("cursor", selected.session.directory).id;
+            selected.revision = digest([selected.revision, selected.session.directory]);
+            found.set(candidate.session.id, selected);
+          }
+        } catch {
+          warnings.push("A legacy Cursor database could not be read consistently; saved imports are retained.");
+        }
+      }
+      const composers = new Map(found);
       const match = (key, encode) => {
         const matches = paths.filter((path) => encode(path) === key);
         return matches.length === 1 ? matches[0] : "";
       };
       let unreadable = 0, legacy = 0, scanned = 0;
-      const add = async (path, id2, kind, directory, parent2 = "", workspaceHash = "") => {
+      const add = async (path, id2, kind, directory2, parent2 = "", workspaceHash = "") => {
         if (!validID(id2) || ++scanned > LIMIT) return;
         try {
           const stats = await fileStats(path);
           if (!stats) return;
           const native = parent2 ? `${parent2}/agent/${id2}` : id2;
           const locator = { path, kind };
-          if (kind !== "transcript") locator.meta = join8(path, "..", "meta.json");
+          if (kind !== "transcript") locator.meta = join12(path, "..", "meta.json");
           const before = await snapshot(locator);
-          const extra = locator.meta ? await json2(locator.meta) : {};
+          const extra2 = locator.meta ? await json3(locator.meta) : {};
           const meta = kind === "transcript" ? {} : cursorStoreMetadata(path);
           if (meta.agentId && meta.agentId !== id2) throw new Error("Cursor native identity mismatch.");
           if (kind !== "transcript" && !meta.latestRootBlobId) return;
-          const session = blankSession("cursor", native, cwd(meta.cwd) || cwd(extra.cwd) || directory);
+          const session = blankSession("cursor", native, cwd(meta.cwd) || cwd(extra2.cwd) || directory2);
           session.agent = kind === "cli" ? "Cursor Agent" : kind === "acp" ? "Cursor ACP" : parent2 ? "Cursor subagent" : "Cursor IDE";
           if (parent2) session.parentID = identity("cursor", parent2);
-          session.title = typeof meta.name === "string" && meta.name.trim() ? meta.name : typeof extra.title === "string" && extra.title.trim() ? extra.title : "Cursor session";
+          session.title = typeof meta.name === "string" && meta.name.trim() ? meta.name : typeof extra2.title === "string" && extra2.title.trim() ? extra2.title : "Cursor session";
           session.title = session.title.slice(0, 300);
-          session.created = cursorTime(meta.createdAt) || cursorTime(extra.createdAtMs);
-          session.updated = cursorTime(extra.updatedAtMs) || stats.mtimeMs;
+          session.created = cursorTime(meta.createdAt) || cursorTime(extra2.createdAtMs);
+          session.updated = cursorTime(extra2.updatedAtMs) || stats.mtimeMs;
           if (kind === "transcript") {
             const page = await readJSONL(path, 0, 2e6, 100);
             let first = 0;
             for (const row of page.rows) {
-              const message = cursorMessage(row.value, `offset:${row.offset}`);
-              if (message?.time && (!first || message.time < first)) first = message.time;
-              if (session.title === "Cursor session" && message?.role === "user") {
-                const text2 = message.fragments.find((f) => f.kind === "You")?.text;
+              const message2 = cursorMessage(row.value, `offset:${row.offset}`);
+              if (message2?.time && (!first || message2.time < first)) first = message2.time;
+              if (session.title === "Cursor session" && message2?.role === "user") {
+                const text2 = message2.fragments.find((f) => f.kind === "You")?.text;
                 if (text2) session.title = text2.replace(/\s+/g, " ").slice(0, 180);
               }
               if (!session.directory) session.directory = cwd(row.value?.cwd);
@@ -31226,363 +32129,119 @@ function createCursorAdapter(options = {}) {
           }
           if (!session.directory) locator.directoryNote = "Working directory is unknown; choose one when continuing.";
           session.projectID = project("cursor", session.directory).id;
-          session.nativeResume = kind === "cli" && Boolean(session.directory) && hashCwd(session.directory) === workspaceHash && root3() === join8(homedir5(), ".cursor");
+          session.nativeResume = kind === "cli" && Boolean(session.directory) && hashCwd(session.directory) === workspaceHash && root3() === join12(homedir6(), ".cursor");
           locator.snapshot = before;
           if (await snapshot(locator) !== before) throw new Error("Cursor session changed during discovery.");
-          const candidate = { session, locator, revision: digest([2, kind, path, before, session.directory, session.parentID]) };
           const previous = found.get(session.id);
-          const rank = (c) => c.locator.kind === "transcript" ? 0 : 1;
+          const rank = (c) => c.locator.kind === "composer" ? 0 : c.locator.kind === "transcript" ? 1 : 2;
+          const composer = composers.get(session.id);
+          if (composer) {
+            session.created = composer.session.created;
+            delete locator.timeNote;
+            session.parentID ||= composer.session.parentID;
+            session.directory ||= composer.session.directory;
+            session.projectID = project("cursor", session.directory).id;
+            if (session.directory) delete locator.directoryNote;
+          }
+          const candidate = { session, locator, revision: digest([4, kind, path, before, session.created, session.directory, session.parentID]) };
           if (!previous || rank(candidate) > rank(previous) || rank(candidate) === rank(previous) && session.updated > previous.session.updated) found.set(session.id, candidate);
         } catch {
           unreadable++;
           if (kind !== "transcript") blocked.add(identity("cursor", id2));
         }
       };
-      const projects = join8(root3(), "projects");
-      for (const dir of await entries(projects, warnings)) {
-        if (!dir.isDirectory() || scanned >= LIMIT) continue;
-        const transcripts = join8(projects, dir.name, "agent-transcripts"), directory = match(dir.name, slug);
-        for (const entry of await entries(transcripts, warnings)) {
-          if (scanned >= LIMIT) break;
-          if (entry.isFile() && entry.name.endsWith(".jsonl")) await add(join8(transcripts, entry.name), entry.name.slice(0, -6), "transcript", directory);
-          else if (entry.isFile() && entry.name.endsWith(".txt")) legacy++;
-          else if (entry.isDirectory() && validID(entry.name)) {
-            await add(join8(transcripts, entry.name, `${entry.name}.jsonl`), entry.name, "transcript", directory);
-            for (const child of await entries(join8(transcripts, entry.name, "subagents"), warnings)) {
-              if (child.isFile() && child.name.endsWith(".jsonl")) await add(join8(transcripts, entry.name, "subagents", child.name), child.name.slice(0, -6), "transcript", directory, entry.name);
-              if (scanned >= LIMIT) break;
-            }
-          }
-        }
-      }
-      const chats = join8(root3(), "chats");
-      for (const bucket of await entries(chats, warnings)) {
-        if (!bucket.isDirectory() || scanned >= LIMIT) continue;
-        const folder = join8(chats, bucket.name), directory = match(bucket.name, hashCwd);
-        if (/^[a-f\d]{32}$/i.test(bucket.name) && await fileStats(join8(folder, "store.db"))) {
-          const id2 = bucket.name.replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
-          await add(join8(folder, "store.db"), id2, "cli", "");
-        }
-        for (const entry of await entries(folder, warnings)) {
-          if (entry.isDirectory()) await add(join8(folder, entry.name, "store.db"), entry.name, "cli", directory, "", bucket.name);
-          if (scanned >= LIMIT) break;
-        }
-      }
-      const acp = join8(root3(), "acp-sessions");
-      for (const entry of await entries(acp, warnings)) {
-        if (entry.isDirectory()) await add(join8(acp, entry.name, "store.db"), entry.name, "acp", "");
-        if (scanned >= LIMIT) break;
-      }
-      if (scanned >= LIMIT) warnings.push("Cursor discovery limited to 20,000 history files.");
-      if (unreadable) warnings.push(`${unreadable} Cursor histories were unreadable or changed during discovery; saved imports are retained. Re-import to retry.`);
-      if (legacy) warnings.push(`${legacy} older plain-text Cursor transcripts are not supported.`);
-      warnings.push("Cursor imports local IDE JSONL and CLI/ACP stores. Legacy Composer databases, plain-text exports, cloud-only and SDK-only history are not imported. Formats are not a stable public API.");
-      const sessions = [...found.values()].filter((c) => !blocked.has(c.session.id));
-      return { sessions, projects: [...new Map(sessions.map((c) => {
-        const p = project("cursor", c.session.directory);
-        return [p.id, p];
-      })).values()], warnings: [...new Set(warnings)] };
-    },
-    async read(candidate, cursor) {
-      const { locator } = candidate;
-      const verify = async () => {
-        if (await snapshot(locator) !== locator.snapshot) throw new Error("Cursor session changed during import; re-import to capture the latest history.");
-      };
-      await verify();
-      const note = [
-        locator.kind === "transcript" ? "Cursor IDE JSONL export; tool results and pre-compaction history may be absent." : "Cursor committed conversation root; abandoned branches and system prompts are excluded.",
-        "No file snapshots or inferred edit evidence. Missing message timestamps stay unknown.",
-        locator.timeNote,
-        locator.directoryNote
-      ].filter(Boolean).join(" ");
-      if (locator.kind !== "transcript") {
-        if (cursor) throw new Error("Invalid Cursor store cursor.");
-        const result = readCursorStore(locator.path);
-        await verify();
-        return { messages: result.messages, partial: result.partial, note: `${note}${result.partial ? " Unsupported, missing, or bounded store records were omitted (2 MB per blob, 64 MB / 50,000 nodes / 16 million text characters per session)." : ""}` };
-      }
-      const offset = Number(cursor || 0);
-      if (!Number.isSafeInteger(offset) || offset < 0) throw new Error("Invalid Cursor transcript cursor.");
-      const page = await readJSONL(locator.path, offset);
-      const messages = page.rows.flatMap((row) => {
-        const message = cursorMessage(row.value, `offset:${row.offset}`);
-        if (!message) page.partial = true;
-        return message && message.role !== "system" ? [message] : [];
-      });
-      await verify();
-      if (!offset && page.cursor === void 0 && !messages.length) throw new Error("Cursor transcript has no readable conversation. Previous imports are retained.");
-      return { messages, cursor: page.cursor === void 0 ? void 0 : String(page.cursor), partial: true, note: `${note}${page.partial ? " Malformed or unsupported transcript records were skipped." : ""}` };
-    }
-  };
-}
-var cursorAdapter = createCursorAdapter();
-
-// server/adapters/gemini.ts
-import { homedir as homedir6 } from "node:os";
-import { basename as basename4, dirname as dirname2, join as join10, sep as sep3 } from "node:path";
-
-// server/adapters/local-files.ts
-import { constants as constants3 } from "node:fs";
-import { lstat as lstat3, open as open3, readdir as readdir3 } from "node:fs/promises";
-import { join as join9, relative } from "node:path";
-var object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
-var text = (value) => typeof value === "string" ? value : "";
-var time = (value) => {
-  const n = typeof value === "number" ? value : typeof value === "string" ? /^\d{13}$/.test(value) ? Number(value) : Date.parse(value) : 0;
-  return Number.isFinite(n) && n > 0 ? n : 0;
-};
-var MAX_BYTES3 = 32e6;
-var MAX_RECORDS = 5e4;
-var MAX_FILES = 2e4;
-async function fileState(path) {
-  try {
-    const s = await lstat3(path);
-    if (!s.isFile()) throw new Error("History must be a regular file, not a symlink.");
-    if (s.size > MAX_BYTES3) throw new Error("History exceeds the 32 MB per-file limit.");
-    return { path, signature: digest([s.size, s.mtimeMs, s.ctimeMs, s.ino]), created: s.birthtimeMs || s.mtimeMs, updated: s.mtimeMs, size: s.size };
-  } catch (error) {
-    if (error.code === "ENOENT") return { path, signature: "missing", created: 0, updated: 0, size: 0 };
-    throw error;
-  }
-}
-async function historyFiles(roots, match) {
-  const files = [], queue = [];
-  const warnings = [];
-  for (const root3 of new Set(roots)) {
-    try {
-      if ((await lstat3(root3)).isDirectory()) queue.push({ root: root3, path: root3, depth: 0 });
-    } catch (error) {
-      if (error.code !== "ENOENT") warnings.push("A history directory could not be read.");
-    }
-  }
-  let entriesSeen = 0, limited = false;
-  for (let i = 0; i < queue.length && files.length < MAX_FILES && entriesSeen < 1e5; i++) {
-    const { root: root3, path, depth } = queue[i];
-    let entries2;
-    try {
-      entries2 = await readdir3(path, { withFileTypes: true });
-    } catch {
-      warnings.push("A history directory could not be read.");
-      continue;
-    }
-    for (const entry of entries2) {
-      if (++entriesSeen > 1e5 || files.length >= MAX_FILES) {
-        limited = true;
-        break;
-      }
-      const file = join9(path, entry.name);
-      if (entry.isDirectory()) {
-        if (depth < 6 && queue.length < MAX_FILES) queue.push({ root: root3, path: file, depth: depth + 1 });
-        else limited = true;
-      }
-      if (entry.isFile() && match(relative(root3, file).split("\\").join("/"))) files.push(file);
-    }
-  }
-  if (limited) warnings.push("History discovery reached its file, directory, or depth limit.");
-  return { files: [...new Set(files)].sort(), warnings };
-}
-function json3(value) {
-  return JSON.parse(value);
-}
-function jsonLines(value) {
-  const rows = [];
-  let partial = false;
-  for (const line of value.split("\n")) {
-    if (!line.trim()) continue;
-    if (rows.length >= MAX_RECORDS) throw new Error("History exceeds the 50,000-record limit.");
-    if (line.length > 2e6) throw new Error("History contains a record larger than 2 MB.");
-    try {
-      const row = json3(line);
-      if (!row || typeof row !== "object" || Array.isArray(row)) partial = true;
-      else rows.push(row);
-    } catch {
-      partial = true;
-    }
-  }
-  return { rows, partial };
-}
-function localFileAdapter(source) {
-  const metadata2 = /* @__PURE__ */ new Map();
-  let cached2;
-  const states = (path) => Promise.all([path, ...source.extras?.(path) || []].map(fileState));
-  const revision2 = (values) => digest([1, ...values.filter((_, i) => i === 0 || source.revisionExtras !== false).map((s) => [s.path, s.signature])]);
-  async function load(path, expected, before) {
-    if (revision2(before) !== expected) throw new Error("Session changed during import; import again.");
-    if (cached2?.path === path && cached2.revision === expected) return cached2.history;
-    if (before[0].signature === "missing") throw new Error("History file is unavailable.");
-    if (before.reduce((n, s) => n + s.size, 0) > MAX_BYTES3) throw new Error("Combined history exceeds the 32 MB snapshot limit.");
-    const files = /* @__PURE__ */ new Map();
-    for (const s of before.filter((s2) => s2.signature !== "missing")) {
-      const handle = await open3(s.path, constants3.O_RDONLY | (constants3.O_NOFOLLOW || 0));
-      try {
-        const buffer = Buffer.alloc(s.size + 1);
-        let bytes2 = 0;
-        while (bytes2 < buffer.length) {
-          const part = await handle.read(buffer, bytes2, buffer.length - bytes2, bytes2);
-          if (!part.bytesRead) break;
-          bytes2 += part.bytesRead;
-        }
-        if (bytes2 !== s.size) throw new Error("History changed while reading; import again.");
-        files.set(s.path, buffer.toString("utf8", 0, bytes2));
-      } finally {
-        await handle.close();
-      }
-    }
-    if (digest(await states(path)) !== digest(before)) throw new Error("History changed while reading; import again.");
-    const history = source.parse(path, files);
-    if (!history.nativeID || history.nativeID.length > 512) throw new Error("History has no supported native session identity.");
-    if (history.messages.length > MAX_RECORDS) throw new Error("History exceeds the 50,000-message limit.");
-    cached2 = { path, revision: expected, history };
-    return history;
-  }
-  return {
-    id: source.id,
-    name: source.name,
-    description: source.description,
-    capabilities: source.capabilities,
-    async detect() {
-      for (const root3 of source.roots()) if ((await lstat3(root3).catch(() => void 0))?.isDirectory()) return true;
-      return false;
-    },
-    async discover() {
-      const listing = await historyFiles(source.roots(), source.match), found = /* @__PURE__ */ new Map();
-      let failed = 0;
-      for (const path of listing.files) {
-        try {
-          const before = await states(path), rev = revision2(before);
-          let candidate = metadata2.get(path);
-          if (!candidate || candidate.revision !== rev) {
-            const history = await load(path, rev, before);
-            const session = { ...blankSession(source.id, history.nativeID), ...history.session };
-            session.id = identity(source.id, history.nativeID);
-            session.nativeID = history.nativeID;
-            session.source = source.id;
-            session.directory = text(session.directory);
-            session.projectID = project(source.id, session.directory).id;
-            session.created = time(session.created) || history.messages.map((m) => time(m.time)).find(Boolean) || before[0].created;
-            session.updated = before[0].updated;
-            session.agent ||= source.name;
-            session.parentID = history.parent ? identity(source.id, history.parent) : void 0;
-            session.forkID = history.fork ? identity(source.id, history.fork) : void 0;
-            if (session.title === "Untitled session" || !session.title) session.title = history.messages.flatMap((m) => m.role === "user" ? m.fragments.filter((f) => f.kind === "You").map((f) => f.text) : []).find(Boolean)?.replace(/\s+/g, " ").slice(0, 180) || `${source.name} session`;
-            candidate = { session, revision: rev, locator: { path } };
-            metadata2.set(path, candidate);
+      const projects = join12(root3(), "projects");
+      for (const dir of await entries(projects, warnings)) {
+        if (!dir.isDirectory() || scanned >= LIMIT) continue;
+        const transcripts = join12(projects, dir.name, "agent-transcripts"), directory2 = match(dir.name, slug);
+        for (const entry of await entries(transcripts, warnings)) {
+          if (scanned >= LIMIT) break;
+          if (entry.isFile() && entry.name.endsWith(".jsonl")) await add(join12(transcripts, entry.name), entry.name.slice(0, -6), "transcript", directory2);
+          else if (entry.isFile() && entry.name.endsWith(".txt")) legacy++;
+          else if (entry.isDirectory() && validID(entry.name)) {
+            await add(join12(transcripts, entry.name, `${entry.name}.jsonl`), entry.name, "transcript", directory2);
+            for (const child of await entries(join12(transcripts, entry.name, "subagents"), warnings)) {
+              if (child.isFile() && child.name.endsWith(".jsonl")) await add(join12(transcripts, entry.name, "subagents", child.name), child.name.slice(0, -6), "transcript", directory2, entry.name);
+              if (scanned >= LIMIT) break;
+            }
           }
-          const previous = found.get(candidate.session.id);
-          const preferred = candidate.locator.path.endsWith(".jsonl"), previousPreferred = previous?.locator.path.endsWith(".jsonl");
-          if (!previous || preferred && !previousPreferred || preferred === previousPreferred && candidate.session.updated > previous.session.updated) found.set(candidate.session.id, candidate);
-        } catch {
-          failed++;
         }
       }
-      const listed = new Set(listing.files);
-      for (const path of metadata2.keys()) if (!listed.has(path)) metadata2.delete(path);
-      if (failed) listing.warnings.push(`${failed} ${source.name} histories were unreadable, changing, unsupported, or over the size limit. Saved imports are kept.`);
-      const sessions = [...found.values()];
+      const chats = join12(root3(), "chats");
+      for (const bucket of await entries(chats, warnings)) {
+        if (!bucket.isDirectory() || scanned >= LIMIT) continue;
+        const folder = join12(chats, bucket.name), directory2 = match(bucket.name, hashCwd);
+        if (/^[a-f\d]{32}$/i.test(bucket.name) && await fileStats(join12(folder, "store.db"))) {
+          const id2 = bucket.name.replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
+          await add(join12(folder, "store.db"), id2, "cli", "");
+        }
+        for (const entry of await entries(folder, warnings)) {
+          if (entry.isDirectory()) await add(join12(folder, entry.name, "store.db"), entry.name, "cli", directory2, "", bucket.name);
+          if (scanned >= LIMIT) break;
+        }
+      }
+      const acp = join12(root3(), "acp-sessions");
+      for (const entry of await entries(acp, warnings)) {
+        if (entry.isDirectory()) await add(join12(acp, entry.name, "store.db"), entry.name, "acp", "");
+        if (scanned >= LIMIT) break;
+      }
+      if (scanned >= LIMIT) warnings.push("Cursor discovery limited to 20,000 history files.");
+      if (unreadable) warnings.push(`${unreadable} Cursor histories were unreadable or changed during discovery; saved imports are retained. Re-import to retry.`);
+      if (legacy) warnings.push(`${legacy} older plain-text Cursor transcripts are not supported.`);
+      warnings.push("Cursor imports local IDE JSONL, legacy Composer databases, and CLI/ACP stores. Plain-text exports, cloud-only and SDK-only history are not imported. Formats are not a stable public API.");
+      const sessions = [...found.values()].filter((c) => !blocked.has(c.session.id));
       return { sessions, projects: [...new Map(sessions.map((c) => {
-        const p = project(source.id, c.session.directory);
+        const p = project("cursor", c.session.directory);
         return [p.id, p];
-      })).values()], warnings: listing.warnings };
+      })).values()], warnings: [...new Set(warnings)] };
     },
     async read(candidate, cursor) {
-      const offset = cursor === void 0 ? 0 : Number(cursor);
-      if (!Number.isSafeInteger(offset) || offset < 0) throw new Error("Invalid history cursor.");
-      const history = await load(candidate.locator.path, candidate.revision, await states(candidate.locator.path));
-      const messages = history.messages.slice(offset, offset + 100);
-      const untimed = history.messages.some((m) => !time(m.time));
-      return {
-        messages,
-        cursor: offset + messages.length < history.messages.length ? String(offset + messages.length) : void 0,
-        partial: Boolean(history.partial || messages.some((m) => m.partial)),
-        note: `${history.note}${untimed ? " Missing message timestamps remain unknown; session placement falls back to recorded metadata or file time." : ""} File snapshots are unavailable.`
+      const { locator } = candidate;
+      if (locator.kind === "composer") {
+        if (cursor) throw new Error("Invalid Composer cursor.");
+        return readComposer(candidate);
+      }
+      const verify = async () => {
+        if (await snapshot(locator) !== locator.snapshot) throw new Error("Cursor session changed during import; re-import to capture the latest history.");
       };
-    }
-  };
-}
-
-// server/adapters/local-messages.ts
-function conversationMessage(raw, fallbackID) {
-  const role = raw.role === "user" ? "user" : ["assistant", "model", "thinking"].includes(raw.role) ? "assistant" : ["tool", "toolResult"].includes(raw.role) ? "tool" : "system";
-  const message = blankMessage(text(raw.id) || fallbackID, time(raw.timestamp ?? raw.ts), role);
-  let content = raw.content;
-  if (Array.isArray(content)) content = content.map((part) => {
-    const p = object(part);
-    return p.type === "toolCall" ? { ...p, type: "tool_use", input: p.arguments } : p.type === "reasoning" ? { ...p, type: "thinking", thinking: p.text } : p;
-  });
-  if (raw.role === "thinking") content = [{ type: "thinking", thinking: raw.content }];
-  message.events = blockEvents(message, content);
-  if (role === "tool" && !(Array.isArray(content) && content.some((p) => p.type === "tool_result"))) {
-    message.events = [eventFor(message, "result", "tool_result", text(raw.toolName) || "Tool result", "", {
-      callID: text(raw.toolCallId) || text(raw.tool_call_id) || void 0,
-      output: eventText(content),
-      status: raw.isError === true ? "failed" : raw.isError === false ? "completed" : "unknown"
-    })];
-  }
-  for (const event of message.events) {
-    if (event.kind === "message") addText(message, event.text, role === "user" ? "You" : role === "assistant" ? "Assistant" : "Tool");
-    else if (event.kind === "tool_call") {
-      message.tools.push(event.name);
-      toolText(message, event.input);
-    } else if (event.kind === "tool_result") toolText(message, event.output);
-    else if (event.kind === "reasoning") addText(message, event.text, "Assistant");
-  }
-  for (const call of Array.isArray(raw.toolCalls) ? raw.toolCalls : []) {
-    const f = object(call.function);
-    if (!text(f.name)) continue;
-    message.tools.push(f.name);
-    message.events.push(eventFor(message, `call:${text(call.id) || message.events.length}`, "tool_call", f.name, "", { callID: text(call.id) || void 0, input: eventText(f.arguments), status: "unknown" }));
-    toolText(message, f.arguments);
-  }
-  if (message.events.length && message.events.every((e10) => e10.kind === "tool_result")) message.role = "tool";
-  message.partial ||= message.events.some((e10) => e10.partial);
-  return message;
-}
-function googleMessage(raw, fallbackID) {
-  const parts = Array.isArray(raw.content) ? raw.content : raw.content != null ? [raw.content] : [];
-  const content = parts.map((part) => {
-    if (typeof part === "string") return { type: "text", text: part };
-    const p = object(part);
-    if (typeof p.text === "string") return p.thought ? { type: "thinking", thinking: p.text } : { type: "text", text: p.text };
-    if (p.functionCall) return { type: "tool_use", ...p.functionCall, input: p.functionCall.args };
-    if (p.functionResponse) return { type: "tool_result", tool_use_id: p.functionResponse.id || raw.toolCallId, name: p.functionResponse.name, content: p.functionResponse.response, is_error: p.functionResponse.response?.error != null };
-    return { type: "unsupported" };
-  });
-  return conversationMessage({ ...raw, content }, fallbackID);
-}
-function successfulEdits(messages, editNames) {
-  const calls = /* @__PURE__ */ new Map();
-  for (const message of messages) for (const event of message.events || []) {
-    if (event.kind === "tool_call" && event.callID) {
-      let input = {};
-      try {
-        input = object(JSON.parse(event.input || "{}"));
-      } catch {
+      await verify();
+      const note = [
+        locator.kind === "transcript" ? "Cursor IDE JSONL export; tool results and pre-compaction history may be absent." : "Cursor committed conversation root; abandoned branches and system prompts are excluded.",
+        "No file snapshots or inferred edit evidence. Missing message timestamps stay unknown.",
+        locator.timeNote,
+        locator.directoryNote
+      ].filter(Boolean).join(" ");
+      if (locator.kind !== "transcript") {
+        if (cursor) throw new Error("Invalid Cursor store cursor.");
+        const result = readCursorStore(locator.path);
+        await verify();
+        return { messages: result.messages, partial: result.partial, note: `${note}${result.partial ? " Unsupported, missing, or bounded store records were omitted (2 MB per blob, 64 MB / 50,000 nodes / 16 million text characters per session)." : ""}` };
       }
-      calls.set(event.callID, { name: event.name, input });
-    }
-    if (event.kind !== "tool_result" || event.status !== "completed" || !event.callID) continue;
-    const call = calls.get(event.callID);
-    if (!call || !editNames.includes(call.name)) continue;
-    if (call.name === "editor" && (typeof call.input.new_text !== "string" || typeof call.input.old_text !== "string")) continue;
-    const path = text(call.input.file_path) || text(call.input.filePath) || text(call.input.path);
-    if (!path || path.length > 4096) continue;
-    try {
-      const result = JSON.parse(event.output || "{}");
-      if (result?.success === false || result?.error) continue;
-    } catch {
+      const offset = Number(cursor || 0);
+      if (!Number.isSafeInteger(offset) || offset < 0) throw new Error("Invalid Cursor transcript cursor.");
+      const page = await readJSONL(locator.path, offset);
+      const messages = page.rows.flatMap((row) => {
+        const message2 = cursorMessage(row.value, `offset:${row.offset}`);
+        if (!message2) page.partial = true;
+        return message2 && message2.role !== "system" ? [message2] : [];
+      });
+      await verify();
+      if (!offset && page.cursor === void 0 && !messages.length) throw new Error("Cursor transcript has no readable conversation. Previous imports are retained.");
+      return { messages, cursor: page.cursor === void 0 ? void 0 : String(page.cursor), partial: true, note: `${note}${page.partial ? " Malformed or unsupported transcript records were skipped." : ""}` };
     }
-    message.files.push({ path, source: "edit tool", steps: 1 });
-    addText(message, path, "File");
-  }
+  };
 }
+var cursorAdapter = createCursorAdapter();
 
 // server/adapters/gemini.ts
+import { homedir as homedir7 } from "node:os";
+import { basename as basename5, dirname as dirname3, join as join13, sep as sep3 } from "node:path";
 function projectRootFile(path) {
   const parts = path.split(sep3);
-  return join10(parts.slice(0, parts.lastIndexOf("chats")).join(sep3), ".project_root");
+  return join13(parts.slice(0, parts.lastIndexOf("chats")).join(sep3), ".project_root");
 }
 function geminiConversation(contents, lines) {
-  const parsed = lines ? jsonLines(contents) : { rows: [object(json3(contents))], partial: false };
+  const parsed = lines ? jsonLines(contents) : { rows: [object(json2(contents))], partial: false };
   let metadata2 = {};
   const messages = /* @__PURE__ */ new Map();
   const patch = (p) => {
@@ -31615,7 +32274,7 @@ function geminiConversation(contents, lines) {
       metadata2 = { ...metadata2, ...update };
       if (Array.isArray(update.messages)) {
         if (row.$set) messages.clear();
-        for (const message of update.messages) if (typeof message.id === "string") messages.set(message.id, message);
+        for (const message2 of update.messages) if (typeof message2.id === "string") messages.set(message2.id, message2);
       }
     } else if (typeof row.id === "string" && typeof row.type === "string") messages.set(row.id, row);
     else parsed.partial = true;
@@ -31627,165 +32286,128 @@ var geminiAdapter = localFileAdapter({
   name: "Gemini CLI",
   description: "Local JSON and JSONL chats, including recorded subagent histories",
   capabilities: { history: true, forks: false, children: true, files: true },
-  roots: () => process.env.SESSIONGRAPH_GEMINI_HOME ? [join10(process.env.SESSIONGRAPH_GEMINI_HOME, "tmp")] : [join10(process.env.GEMINI_CLI_HOME || homedir6(), ".gemini", "tmp"), join10(process.env.GEMINI_CLI_HOME || homedir6(), ".cache", ".gemini", "tmp")],
+  roots: () => process.env.SESSIONGRAPH_GEMINI_HOME ? [join13(process.env.SESSIONGRAPH_GEMINI_HOME, "tmp")] : [join13(process.env.GEMINI_CLI_HOME || homedir7(), ".gemini", "tmp"), join13(process.env.GEMINI_CLI_HOME || homedir7(), ".cache", ".gemini", "tmp")],
   match: (path) => /^[^/]+\/chats\/(?:[^/]+\/)?[^/]+\.jsonl?$/.test(path),
   extras: (path) => [projectRootFile(path)],
   parse(path, files) {
     const { metadata: meta, records, partial } = geminiConversation(files.get(path), path.endsWith(".jsonl"));
     if (!text(meta.sessionId)) throw new Error("Unsupported Gemini history.");
-    const directory = (files.get(projectRootFile(path)) || "").trim().slice(0, 4096);
+    const directory2 = (files.get(projectRootFile(path)) || "").trim().slice(0, 4096);
     const messages = records.map((raw, index) => {
-      const message = googleMessage({ id: raw.id, timestamp: raw.timestamp, role: raw.type === "user" ? "user" : raw.type === "gemini" ? "assistant" : "system", content: raw.content }, `record:${index}`);
-      for (const [i, thought] of (Array.isArray(raw.thoughts) ? raw.thoughts : []).entries()) message.events.push(eventFor(message, `thought:${i}`, "reasoning", text(thought.subject) || "Recorded reasoning", text(thought.description), { time: time(thought.timestamp) || null, timeSource: time(thought.timestamp) ? "recorded" : "unknown" }));
+      const message2 = googleMessage({ id: raw.id, timestamp: raw.timestamp, role: raw.type === "user" ? "user" : raw.type === "gemini" ? "assistant" : "system", content: raw.content }, `record:${index}`);
+      for (const [i, thought] of (Array.isArray(raw.thoughts) ? raw.thoughts : []).entries()) message2.events.push(eventFor(message2, `thought:${i}`, "reasoning", text(thought.subject) || "Recorded reasoning", text(thought.description), { time: time(thought.timestamp) || null, timeSource: time(thought.timestamp) ? "recorded" : "unknown" }));
       for (const [i, call] of (Array.isArray(raw.toolCalls) ? raw.toolCalls : []).entries()) {
         const id2 = text(call.id) || `tool:${i}`, name = text(call.name) || "Tool";
-        message.tools.push(name);
-        message.events.push(eventFor(message, `call:${id2}`, "tool_call", name, "", { callID: id2, input: eventText(call.args), status: "unknown" }));
+        message2.tools.push(name);
+        message2.events.push(eventFor(message2, `call:${id2}`, "tool_call", name, "", { callID: id2, input: eventText(call.args), status: "unknown" }));
         if (call.result != null || ["success", "error", "cancelled"].includes(call.status)) {
           const output = eventText(call.result);
-          message.events.push(eventFor(message, `result:${id2}`, "tool_result", name, "", { role: "tool", callID: id2, output, nativeType: text(call.status), time: time(call.timestamp) || null, timeSource: time(call.timestamp) ? "recorded" : "unknown", status: call.status === "success" ? "completed" : call.status === "error" ? "failed" : "unknown" }));
-          addText(message, output, "Tool");
+          message2.events.push(eventFor(message2, `result:${id2}`, "tool_result", name, "", { role: "tool", callID: id2, output, nativeType: text(call.status), time: time(call.timestamp) || null, timeSource: time(call.timestamp) ? "recorded" : "unknown", status: call.status === "success" ? "completed" : call.status === "error" ? "failed" : "unknown" }));
+          addText(message2, output, "Tool");
         }
       }
-      return message;
+      return message2;
     });
     successfulEdits(messages, ["write_file", "replace"]);
-    const parent2 = meta.kind === "subagent" && basename4(dirname2(dirname2(path))) === "chats" ? basename4(dirname2(path)) : void 0;
+    const parent2 = meta.kind === "subagent" && basename5(dirname3(dirname3(path))) === "chats" ? basename5(dirname3(path)) : void 0;
     return {
       nativeID: meta.sessionId,
       messages,
       parent: parent2,
       partial,
-      session: { directory, created: time(meta.startTime), title: text(meta.summary), model: text([...records].reverse().find((r) => r.model)?.model) || "Unknown model", provider: "Google", nativeResume: !parent2 && Boolean(directory) && !process.env.SESSIONGRAPH_GEMINI_HOME && !path.includes(`${sep3}.cache${sep3}`) },
+      session: { directory: directory2, created: time(meta.startTime), title: text(meta.summary), model: text([...records].reverse().find((r) => r.model)?.model) || "Unknown model", provider: "Google", nativeResume: !parent2 && Boolean(directory2) && !process.env.SESSIONGRAPH_GEMINI_HOME && !path.includes(`${sep3}.cache${sep3}`) },
       note: "Local Gemini chat records with rewind and patch reconstruction. Only explicit subagent directories form parent links; workspace paths come from the project-root marker. Binary content is omitted."
     };
   }
 });
 
 // server/adapters/qwen.ts
-import { homedir as homedir7 } from "node:os";
-import { join as join11 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { join as join14 } from "node:path";
 var qwenAdapter = localFileAdapter({
   id: "qwen-code",
   name: "Qwen Code",
   description: "Local project chat records \xB7 tool results, forks, and child sessions",
   capabilities: { history: true, forks: true, children: true, files: true },
-  roots: () => [join11(process.env.SESSIONGRAPH_QWEN_HOME || process.env.QWEN_RUNTIME_DIR || process.env.QWEN_HOME || join11(homedir7(), ".qwen"), "projects")],
+  roots: () => [join14(process.env.SESSIONGRAPH_QWEN_HOME || process.env.QWEN_RUNTIME_DIR || process.env.QWEN_HOME || join14(homedir8(), ".qwen"), "projects")],
   match: (path) => /^[^/]+\/chats\/[^/]+\.jsonl$/.test(path),
   parse(path, files) {
-    const { rows, partial } = jsonLines(files.get(path));
-    const first = rows.find((r) => text(r.sessionId));
+    const { rows: rows2, partial } = jsonLines(files.get(path));
+    const first = rows2.find((r) => text(r.sessionId));
     if (!first) throw new Error("Unsupported Qwen history.");
-    if (rows.some((r) => r.sessionId && r.sessionId !== first.sessionId)) throw new Error("Mixed session identities.");
-    const messages = rows.map((raw, index) => {
+    if (rows2.some((r) => r.sessionId && r.sessionId !== first.sessionId)) throw new Error("Mixed session identities.");
+    const messages = rows2.map((raw, index) => {
       const id2 = text(raw.uuid) || `record:${index}`;
       if (raw.message && !["agent_message", "agent_mention", "notification"].includes(raw.subtype)) {
-        const message2 = googleMessage({ id: id2, timestamp: raw.timestamp, role: raw.type === "assistant" ? "assistant" : raw.type === "user" ? "user" : "tool", toolCallId: raw.toolCallResult?.callId, content: object(raw.message).parts }, id2);
-        for (const event of message2.events || []) if (event.kind === "tool_result") {
+        const message3 = googleMessage({ id: id2, timestamp: raw.timestamp, role: raw.type === "assistant" ? "assistant" : raw.type === "user" ? "user" : "tool", toolCallId: raw.toolCallResult?.callId, content: object(raw.message).parts }, id2);
+        for (const event of message3.events || []) if (event.kind === "tool_result") {
           event.status = raw.toolCallResult?.status === "success" ? "completed" : raw.toolCallResult?.status === "error" ? "failed" : "unknown";
           event.nativeType = text(raw.toolCallResult?.status);
         }
-        return message2;
+        return message3;
       }
-      const message = blankMessage(id2, time(raw.timestamp), "system");
-      message.events = [eventFor(message, "event", /compression/.test(raw.subtype) ? "compaction" : "event", text(raw.subtype) || text(raw.type) || "Qwen event", eventText(raw.systemPayload ?? raw.message), { nativeType: text(raw.subtype) || text(raw.type), parentID: text(raw.parentUuid) || void 0 })];
-      return message;
+      const message2 = blankMessage(id2, time(raw.timestamp), "system");
+      message2.events = [eventFor(message2, "event", /compression/.test(raw.subtype) ? "compaction" : "event", text(raw.subtype) || text(raw.type) || "Qwen event", eventText(raw.systemPayload ?? raw.message), { nativeType: text(raw.subtype) || text(raw.type), parentID: text(raw.parentUuid) || void 0 })];
+      return message2;
     });
     successfulEdits(messages, ["write_file", "edit", "replace"]);
-    const latest = [...rows].reverse(), parent2 = rows.find((r) => r.subtype === "parent_session")?.systemPayload?.parentSessionId;
+    const latest = [...rows2].reverse(), parent2 = rows2.find((r) => r.subtype === "parent_session")?.systemPayload?.parentSessionId;
     const title = latest.find((r) => r.subtype === "custom_title")?.systemPayload?.customTitle;
     return {
       nativeID: first.sessionId,
       messages,
       partial,
       parent: text(parent2) || void 0,
-      fork: text(rows.find((r) => r.forkedFrom?.sessionId)?.forkedFrom?.sessionId) || void 0,
+      fork: text(rows2.find((r) => r.forkedFrom?.sessionId)?.forkedFrom?.sessionId) || void 0,
       session: { directory: text(first.cwd), created: time(first.timestamp), title: text(title), model: text(latest.find((r) => r.model)?.model) || text(latest.find((r) => r.subtype === "session_model")?.systemPayload?.modelId) || "Unknown model", nativeResume: Boolean(first.cwd) && !process.env.SESSIONGRAPH_QWEN_HOME },
       note: "Local Qwen chat records, including compaction and branch events in source order. Parent and fork links use recorded session IDs. Managed-daemon-only and binary history may be unavailable."
     };
   }
 });
 
-// server/adapters/pi.ts
-import { homedir as homedir8 } from "node:os";
-import { join as join12 } from "node:path";
-var piAdapter = localFileAdapter({
-  id: "pi",
-  name: "Pi",
-  description: "Local JSONL sessions \xB7 messages, tools, compaction, and branch entries",
-  capabilities: { history: true, forks: false, children: false, files: true },
-  roots: () => [process.env.SESSIONGRAPH_PI_SESSIONS_DIR || join12(process.env.PI_CODING_AGENT_DIR || join12(homedir8(), ".pi", "agent"), "sessions")],
-  match: (path) => path.endsWith(".jsonl"),
-  parse(path, files) {
-    const { rows, partial } = jsonLines(files.get(path));
-    const header = rows[0];
-    if (header?.type !== "session" || !text(header.id)) throw new Error("Unsupported Pi session.");
-    const messages = rows.slice(1).map((raw, index) => {
-      const id2 = text(raw.id) || `record:${index}`;
-      if (raw.type === "message" && raw.message) {
-        const message2 = conversationMessage({ ...raw.message, id: id2, timestamp: raw.message.timestamp ?? raw.timestamp }, id2);
-        for (const event of message2.events || []) event.parentID = text(raw.parentId) || void 0;
-        return message2;
-      }
-      const message = blankMessage(id2, time(raw.timestamp), "system");
-      message.events = [eventFor(message, "entry", ["compaction", "branch_summary"].includes(raw.type) ? "compaction" : "event", text(raw.type) || "Pi entry", text(raw.summary) || eventText(raw), { nativeType: text(raw.type), parentID: text(raw.parentId) || void 0 })];
-      return message;
-    });
-    successfulEdits(messages, ["write", "edit"]);
-    const lastModel = [...rows].reverse().find((r) => r.type === "model_change" || r.message?.model);
-    return {
-      nativeID: header.id,
-      messages,
-      partial,
-      session: { directory: text(header.cwd), created: time(header.timestamp), title: text([...rows].reverse().find((r) => r.type === "session_info")?.name), model: text(lastModel?.modelId || lastModel?.message?.model) || "Unknown model", provider: text(lastModel?.provider || lastModel?.message?.provider), nativeResume: Boolean(header.cwd) && !process.env.SESSIONGRAPH_PI_SESSIONS_DIR },
-      note: "Raw Pi session history includes all recorded in-file branches, not just the active model context. Entry parent IDs are preserved as event links, not session ancestry. Parent-session file paths do not establish whether a session is a fork or a child. Binary content is omitted."
-    };
-  }
-});
-
 // server/adapters/copilot.ts
 import { homedir as homedir9 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join15 } from "node:path";
 var copilotAdapter = localFileAdapter({
   id: "copilot",
   name: "GitHub Copilot CLI",
   description: "Local session event logs \xB7 conversations and completed file edits",
   capabilities: { history: true, forks: false, children: true, files: true },
-  roots: () => [join13(process.env.SESSIONGRAPH_COPILOT_HOME || join13(homedir9(), ".copilot"), "session-state")],
+  roots: () => [join15(process.env.SESSIONGRAPH_COPILOT_HOME || join15(homedir9(), ".copilot"), "session-state")],
   match: (path) => /(?:^|\/)events\.jsonl$/.test(path),
   parse(path, files) {
-    const { rows, partial } = jsonLines(files.get(path));
-    const start = rows.find((r) => r.type === "session.start"), meta = object(start?.data);
+    const { rows: rows2, partial } = jsonLines(files.get(path));
+    const start = rows2.find((r) => r.type === "session.start"), meta = object(start?.data);
     if (!text(meta.sessionId)) throw new Error("Unsupported Copilot event log.");
-    const toolNames = new Map(rows.filter((r) => r.type === "tool.execution_start").map((r) => [r.data?.toolCallId, text(r.data?.toolName)]));
-    const messages = rows.filter((r) => !r.ephemeral && !["assistant.message_delta", "assistant.reasoning_delta"].includes(r.type)).map((raw, index) => {
+    const toolNames = new Map(rows2.filter((r) => r.type === "tool.execution_start").map((r) => [r.data?.toolCallId, text(r.data?.toolName)]));
+    const messages = rows2.filter((r) => !r.ephemeral && !["assistant.message_delta", "assistant.reasoning_delta"].includes(r.type)).map((raw, index) => {
       const data = object(raw.data), kind = text(raw.type), human = kind === "user.message" && !data.isAutopilotContinuation && !data.source;
-      const message = blankMessage(text(raw.id) || `record:${index}`, time(raw.timestamp), human ? "user" : kind === "assistant.message" ? "assistant" : kind.startsWith("tool.") ? "tool" : "system");
+      const message2 = blankMessage(text(raw.id) || `record:${index}`, time(raw.timestamp), human ? "user" : kind === "assistant.message" ? "assistant" : kind.startsWith("tool.") ? "tool" : "system");
       if (["user.message", "assistant.message"].includes(kind)) {
         const content = text(data.content);
-        message.events = [eventFor(message, "message", human || kind === "assistant.message" ? "message" : "event", human ? "User message" : kind === "assistant.message" ? "Assistant message" : "Injected message", content, { nativeID: text(data.messageId) || void 0, nativeType: kind })];
-        addText(message, content, human ? "You" : kind === "assistant.message" ? "Assistant" : "Tool");
-        if (data.attachments?.length || data.encryptedContent || data.reasoningOpaque) message.partial = true;
+        message2.events = [eventFor(message2, "message", human || kind === "assistant.message" ? "message" : "event", human ? "User message" : kind === "assistant.message" ? "Assistant message" : "Injected message", content, { nativeID: text(data.messageId) || void 0, nativeType: kind })];
+        addText(message2, content, human ? "You" : kind === "assistant.message" ? "Assistant" : "Tool");
+        if (data.attachments?.length || data.encryptedContent || data.reasoningOpaque) message2.partial = true;
       } else if (kind === "tool.execution_start" || kind === "tool.execution_complete") {
         const call = kind === "tool.execution_start", name = text(data.toolName) || toolNames.get(data.toolCallId) || "Tool";
-        message.events = [eventFor(message, call ? "call" : "result", call ? "tool_call" : "tool_result", name, "", {
+        message2.events = [eventFor(message2, call ? "call" : "result", call ? "tool_call" : "tool_result", name, "", {
           callID: text(data.toolCallId) || void 0,
           nativeType: kind,
           ...call ? { input: eventText(data.arguments) } : { output: eventText(data.error || data.result?.detailedContent || data.result?.content) },
           status: call ? "unknown" : data.success === true ? "completed" : data.success === false ? "failed" : "unknown"
         })];
-        if (call) message.tools.push(name);
-        addText(message, message.events[0].input || message.events[0].output, "Tool");
+        if (call) message2.tools.push(name);
+        addText(message2, message2.events[0].input || message2.events[0].output, "Tool");
         if (!call) {
           for (const edit of Array.isArray(data.fileEdits) ? data.fileEdits : []) if (text(edit.path)) {
-            message.files.push({ path: edit.path, source: "file change", steps: 1 });
-            addText(message, edit.path, "File");
+            message2.files.push({ path: edit.path, source: "file change", steps: 1 });
+            addText(message2, edit.path, "File");
           }
         }
-      } else message.events = [eventFor(message, "event", kind.includes("compaction") ? "compaction" : kind.includes("reasoning") ? "reasoning" : kind === "session.error" ? "error" : "event", kind || "Copilot event", eventText(data), { nativeType: kind, parentID: text(raw.parentId) || void 0 })];
-      return message;
+      } else message2.events = [eventFor(message2, "event", kind.includes("compaction") ? "compaction" : kind.includes("reasoning") ? "reasoning" : kind === "session.error" ? "error" : "event", kind || "Copilot event", eventText(data), { nativeType: kind, parentID: text(raw.parentId) || void 0 })];
+      return message2;
     });
-    const latest = [...rows].reverse();
+    const latest = [...rows2].reverse();
     return {
       nativeID: meta.sessionId,
       messages,
@@ -31799,39 +32421,39 @@ var copilotAdapter = localFileAdapter({
 
 // server/adapters/extensions.ts
 import { homedir as homedir10 } from "node:os";
-import { basename as basename5, dirname as dirname3, join as join14 } from "node:path";
+import { basename as basename6, dirname as dirname4, join as join16 } from "node:path";
 function editorTaskRoots(extension) {
   const home = homedir10();
-  const base = process.platform === "darwin" ? join14(home, "Library", "Application Support") : process.platform === "win32" ? process.env.APPDATA || join14(home, "AppData", "Roaming") : process.env.XDG_CONFIG_HOME || join14(home, ".config");
-  return ["Code", "Code - Insiders", "VSCodium", "Cursor", "Windsurf"].map((app) => join14(base, app, "User", "globalStorage", extension, "tasks")).concat([".vscode-server", ".vscode-server-insiders"].map((app) => join14(home, app, "data", "User", "globalStorage", extension, "tasks")));
+  const base = process.platform === "darwin" ? join16(home, "Library", "Application Support") : process.platform === "win32" ? process.env.APPDATA || join16(home, "AppData", "Roaming") : process.env.XDG_CONFIG_HOME || join16(home, ".config");
+  return ["Code", "Code - Insiders", "VSCodium", "Cursor", "Windsurf"].map((app) => join16(base, app, "User", "globalStorage", extension, "tasks")).concat([".vscode-server", ".vscode-server-insiders"].map((app) => join16(home, app, "data", "User", "globalStorage", extension, "tasks")));
 }
 function taskAdapter(id2, name, extension, env) {
-  const roots = () => process.env[env] ? [join14(process.env[env], "tasks"), ...id2 === "cline" ? [join14(process.env[env], "data", "sessions")] : []] : [...editorTaskRoots(extension), ...id2 === "cline" ? [process.env.CLINE_SESSION_DATA_DIR || join14(process.env.CLINE_DATA_DIR || join14(process.env.CLINE_DIR || join14(homedir10(), ".cline"), "data"), "sessions")] : []];
+  const roots = () => process.env[env] ? [join16(process.env[env], "tasks"), ...id2 === "cline" ? [join16(process.env[env], "data", "sessions")] : []] : [...editorTaskRoots(extension), ...id2 === "cline" ? [process.env.CLINE_SESSION_DATA_DIR || join16(process.env.CLINE_DATA_DIR || join16(process.env.CLINE_DIR || join16(homedir10(), ".cline"), "data"), "sessions")] : []];
   return localFileAdapter({
     id: id2,
     name,
-    description: id2 === "kilo-code" ? "Legacy VS Code extension task histories \xB7 current Kilo stores excluded" : id2 === "cline" ? "Local extension tasks and CLI/SDK message snapshots" : "Local VS Code extension task histories",
+    description: id2 === "kilo-code" ? "VS Code extension task histories \xB7 choose Kilo CLI separately" : id2 === "cline" ? "Local extension tasks and CLI/SDK message snapshots" : "Local VS Code extension task histories",
     capabilities: { history: true, forks: id2 === "cline", children: true, files: true },
     roots,
     match: (path) => /^[^/]+\/api_conversation_history\.json$/.test(path) || id2 === "cline" && /^[^/]+\/[^/]+\.messages\.json$/.test(path),
-    extras: (path) => ["history_item.json", "task_metadata.json", "session.json"].map((file) => join14(dirname3(path), file)),
+    extras: (path) => ["history_item.json", "task_metadata.json", "session.json"].map((file) => join16(dirname4(path), file)),
     parse(path, files) {
-      const sdk = path.endsWith(".messages.json"), value = json3(files.get(path));
+      const sdk = path.endsWith(".messages.json"), value = json2(files.get(path));
       const records = sdk ? object(value).messages : value;
       if (!Array.isArray(records) || sdk && !text(value.sessionId)) throw new Error("Unsupported task history.");
-      const read3 = (name2) => object(files.has(join14(dirname3(path), name2)) ? json3(files.get(join14(dirname3(path), name2))) : void 0);
+      const read3 = (name2) => object(files.has(join16(dirname4(path), name2)) ? json2(files.get(join16(dirname4(path), name2))) : void 0);
       const history = read3("history_item.json"), info = read3("session.json"), task = read3("task_metadata.json");
-      const nativeID = sdk ? value.sessionId : basename5(dirname3(path));
+      const nativeID = sdk ? value.sessionId : basename6(dirname4(path));
       if (history.id && history.id !== nativeID || info.session_id && info.session_id !== nativeID) throw new Error("Task metadata identity mismatch.");
       const messages = records.map((raw, index) => {
-        const row = object(raw), message = conversationMessage(row, `record:${index}`);
+        const row = object(raw), message2 = conversationMessage(row, `record:${index}`);
         if (row.isSummary || row.isTruncationMarker || row.type === "reasoning") {
-          message.role = "system";
-          message.events = [eventFor(message, "summary", row.type === "reasoning" ? "reasoning" : "compaction", row.type === "reasoning" ? "Recorded reasoning" : "Context checkpoint", eventText(row.summary ?? row.content ?? row.text), { partial: Boolean(row.encrypted_content), nativeType: row.type || "summary" })];
+          message2.role = "system";
+          message2.events = [eventFor(message2, "summary", row.type === "reasoning" ? "reasoning" : "compaction", row.type === "reasoning" ? "Recorded reasoning" : "Context checkpoint", eventText(row.summary ?? row.content ?? row.text), { partial: Boolean(row.encrypted_content), nativeType: row.type || "summary" })];
         }
-        if (row.reasoning_content) message.events.push(eventFor(message, "reasoning", "reasoning", "Recorded reasoning", text(row.reasoning_content)));
-        if (row.encrypted_content || row.reasoning_details) message.partial = true;
-        return message;
+        if (row.reasoning_content) message2.events.push(eventFor(message2, "reasoning", "reasoning", "Recorded reasoning", text(row.reasoning_content)));
+        if (row.encrypted_content || row.reasoning_details) message2.partial = true;
+        return message2;
       });
       successfulEdits(messages, ["write_to_file", "apply_diff", "edit_file", "write_file", "replace_in_file", "editor"]);
       const lastModel = [...records].reverse().find((r) => r.modelInfo?.id || r.model);
@@ -31842,7 +32464,7 @@ function taskAdapter(id2, name, extension, env) {
         parent: text(history.parentTaskId || info.parent_session_id) || void 0,
         fork: text(info.metadata?.fork?.forkedFromSessionId) || void 0,
         session: { directory: text(history.workspace || info.cwd || info.workspace_root || task.workspace), created: time(info.started_at), title: text(history.task || info.metadata?.title), model: text(lastModel?.modelInfo?.id || lastModel?.model || info.model) || "Unknown model", provider: text(lastModel?.modelInfo?.provider || info.provider) },
-        note: sdk ? "Cline CLI/SDK message snapshots. Metadata is used when a matching session.json exists; database-only workspace, title, and lineage fields remain unknown. Binary attachments are omitted." : `${name} API-conversation snapshots; UI-only messages, older compacted content, and binary attachments can be absent. XML tool requests alone are not successful edit evidence.${id2 === "kilo-code" ? " Current Kilo CLI and migrated database histories are not imported." : ""}`
+        note: sdk ? "Cline CLI/SDK message snapshots. Metadata is used when a matching session.json exists; database-only workspace, title, and lineage fields remain unknown. Binary attachments are omitted." : `${name} API-conversation snapshots; UI-only messages, older compacted content, and binary attachments can be absent. XML tool requests alone are not successful edit evidence.${id2 === "kilo-code" ? " Select the separate Kilo CLI source for its SQLite history." : ""}`
       };
     }
   });
@@ -31855,20 +32477,20 @@ var continueAdapter = localFileAdapter({
   name: "Continue",
   description: "Local IDE and CLI session JSON \xB7 recorded conversation and tool history",
   capabilities: { history: true, forks: false, children: false, files: false },
-  roots: () => [join14(process.env.SESSIONGRAPH_CONTINUE_HOME || process.env.CONTINUE_GLOBAL_DIR || join14(homedir10(), ".continue"), "sessions")],
+  roots: () => [join16(process.env.SESSIONGRAPH_CONTINUE_HOME || process.env.CONTINUE_GLOBAL_DIR || join16(homedir10(), ".continue"), "sessions")],
   match: (path) => /^[^/]+\.json$/.test(path) && path !== "sessions.json",
-  extras: (path) => [join14(dirname3(path), "sessions.json")],
+  extras: (path) => [join16(dirname4(path), "sessions.json")],
   revisionExtras: false,
   parse(path, files) {
-    const value = object(json3(files.get(path)));
+    const value = object(json2(files.get(path)));
     if (!text(value.sessionId) || !Array.isArray(value.history)) throw new Error("Unsupported Continue session.");
-    const indexPath = join14(dirname3(path), "sessions.json"), index = files.has(indexPath) ? json3(files.get(indexPath)) : [];
+    const indexPath = join16(dirname4(path), "sessions.json"), index = files.has(indexPath) ? json2(files.get(indexPath)) : [];
     const meta = Array.isArray(index) ? object(index.find((r) => r.sessionId === value.sessionId)) : {};
     const messages = value.history.map((item, i) => {
-      const row = object(item), raw = object(row.message), message = conversationMessage(raw, `record:${i}`);
-      if (row.reasoning?.text) message.events.push(eventFor(message, "reasoning", "reasoning", "Recorded reasoning", text(row.reasoning.text), { time: time(row.reasoning.startAt) || null, timeSource: time(row.reasoning.startAt) ? "recorded" : "unknown" }));
-      if (row.conversationSummary) message.events.push(eventFor(message, "summary", "compaction", "Conversation summary", text(row.conversationSummary)));
-      return message;
+      const row = object(item), raw = object(row.message), message2 = conversationMessage(raw, `record:${i}`);
+      if (row.reasoning?.text) message2.events.push(eventFor(message2, "reasoning", "reasoning", "Recorded reasoning", text(row.reasoning.text), { time: time(row.reasoning.startAt) || null, timeSource: time(row.reasoning.startAt) ? "recorded" : "unknown" }));
+      if (row.conversationSummary) message2.events.push(eventFor(message2, "summary", "compaction", "Conversation summary", text(row.conversationSummary)));
+      return message2;
     });
     const usage = object(value.usage);
     return {
@@ -31880,13 +32502,598 @@ var continueAdapter = localFileAdapter({
   }
 });
 
+// server/adapters/harness-files.ts
+import { basename as basename8, dirname as dirname6, join as join19 } from "node:path";
+
+// server/adapters/harness-paths.ts
+import { homedir as homedir11 } from "node:os";
+import { join as join17 } from "node:path";
+var homePath = (...parts) => join17(homedir11(), ...parts);
+var dataPath = (...parts) => join17(process.env.XDG_DATA_HOME || homePath(".local/share"), ...parts);
+var configPath = (...parts) => join17(process.env.XDG_CONFIG_HOME || homePath(".config"), ...parts);
+var appPath = (...parts) => join17(process.platform === "darwin" ? homePath("Library/Application Support") : process.platform === "win32" ? process.env.APPDATA || homePath("AppData/Roaming") : process.env.XDG_CONFIG_HOME || homePath(".config"), ...parts);
+var tokscalePath = (...parts) => join17(process.env.TOKSCALE_CONFIG_DIR || (process.platform === "win32" ? appPath("tokscale") : configPath("tokscale")), ...parts);
+var envHome = (env, fallback, ...parts) => join17(process.env[env]?.trim() || homePath(fallback), ...parts);
+var harnessRoots = (id2, defaults) => () => {
+  const override = process.env[`SESSIONGRAPH_${id2.replace(/-/g, "_").toUpperCase()}_HISTORY_DIR`]?.trim();
+  return override ? [override] : defaults();
+};
+
+// server/adapters/harness-extra-formats.ts
+import { basename as basename7, dirname as dirname5, join as join18 } from "node:path";
+function kiroHistory(path, files) {
+  const header = object(json2(files.get(path)));
+  const ide2 = basename7(path) === "session.json";
+  const nativeID = text(header.session_id || header.sessionId || header.id) || (ide2 ? basename7(dirname5(path)) : "");
+  if (!nativeID) throw new Error("Unsupported Kiro session header.");
+  const side = ide2 ? join18(dirname5(path), "messages.jsonl") : path.replace(/\.json$/, ".jsonl");
+  if (!files.has(side)) throw new Error("Kiro conversation sidecar is unavailable.");
+  const { rows: rows2 } = jsonLines(files.get(side));
+  const messages = rows2.flatMap((r, i) => {
+    if (ide2) {
+      const p = object(r.payload || r);
+      const role2 = p.type === "human" ? "user" : p.type === "ai" ? "assistant" : p.role || p.type;
+      const m3 = message({ ...p, role: role2 }, text(p.id) || `message:${i}`, r.timestamp);
+      return m3 ? [m3] : [recordEvent(r, `event:${i}`, text(p.type) || "Kiro event", r.timestamp, p.text)];
+    }
+    const data = object(r.data), role = r.kind === "Prompt" ? "user" : r.kind === "AssistantMessage" ? "assistant" : r.kind === "ToolResults" ? "tool" : "";
+    if (!role) return [];
+    const content = Array.isArray(data.content) ? data.content.map((p) => p.kind === "text" ? { type: "text", text: p.data } : { type: "unsupported" }) : void 0;
+    const m = message({ role, content }, text(data.message_id) || `message:${i}`, seconds(data.meta?.timestamp));
+    return m ? [m] : [];
+  });
+  if (!messages.length) throw new Error("No readable Kiro messages.");
+  return {
+    nativeID,
+    messages,
+    partial: true,
+    session: { directory: text(header.cwd) || (header.workspacePaths?.length === 1 ? text(header.workspacePaths[0]) : ""), created: time(header.createdAt), title: text(header.title), model: text(header.modelId || header.session_state?.rts_model_state?.model_info?.model_id) || "Unknown model" },
+    note: "Kiro CLI header/JSONL and IDE session snapshots. Unsupported payload variants and compacted context may be absent. Token estimates and credit conversions are not imported."
+  };
+}
+function muxHistory(path, files) {
+  const archive = files.get(join18(dirname5(path), "chat-archive.jsonl"));
+  const records = [...archive ? jsonLines(archive).rows : [], ...jsonLines(files.get(path)).rows];
+  const unique = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    if (!text(r.id)) throw new Error("Mux message has no native identity.");
+    unique.set(r.id, r);
+  }
+  const messages = [...unique.values()].flatMap((r) => {
+    const parts = Array.isArray(r.parts) ? r.parts.flatMap((p) => {
+      if (p.type !== "dynamic-tool") return [p];
+      const call = { type: "tool_use", id: p.toolCallId, name: p.toolName, input: p.input };
+      return p.state === "output-available" || p.state === "output-error" ? [call, { type: "tool_result", tool_use_id: p.toolCallId, content: p.output ?? p.errorText, is_error: p.state === "output-error" }] : [call];
+    }) : r.content;
+    if (r.metadata?.synthetic) return [recordEvent(r, r.id, "Synthetic context", r.metadata?.timestamp, parts)];
+    const m = message({ ...r, content: parts }, r.id, r.metadata?.timestamp ?? r.createdAt);
+    return m ? [m] : [];
+  });
+  if (!messages.length) throw new Error("No readable Mux conversation.");
+  return {
+    nativeID: basename7(dirname5(path)),
+    messages,
+    partial: true,
+    note: "Mux durable chat archive followed by active chat, deduplicated by native message ID. In-flight partial.json and workspace ancestry are unavailable. Cumulative usage snapshots are not turns."
+  };
+}
+function devinDesktopHistory(path, files) {
+  const { rows: rows2 } = jsonLines(files.get(path));
+  const normalized = rows2.flatMap((r) => {
+    const n = object(r.notification);
+    return n.sessionUpdate ? [{ params: { sessionId: text(r.sessionId || n.sessionId) || fileID(path).replace(/\.ndjson$/, ""), update: n }, timestamp: n.content?.metadata?.created_at ?? n.metadata?.created_at ?? n.timestamp ?? r.timestamp }] : [];
+  });
+  const history = acpHistory(path, normalized.map((r) => JSON.stringify(r)).join("\n"));
+  history.note = "Devin Desktop saved ACP notification chunks. File/native identity is preserved; titles are never used to merge desktop and CLI sessions. Tool internals and turn boundaries may be incomplete.";
+  return history;
+}
+
+// server/adapters/harness-files.ts
+var piParse = (path, files) => piHistory(files.get(path));
+var jsonl = (path) => path.endsWith(".jsonl");
+var piSources = [
+  { id: "prime-agent", name: "Prime Agent", roots: () => [process.env.PRIME_AGENT_SESSION_DIR || process.env.PRIME_AGENT_CODING_AGENT_SESSION_DIR || envHome("PRIME_AGENT_CODING_AGENT_DIR", ".prime/agent", "sessions"), envHome("PRIME_AGENT_CODING_AGENT_DIR", ".prime/agent", "session-artifacts")] },
+  { id: "omp", name: "Oh My Pi", roots: () => [envHome("PI_CODING_AGENT_DIR_OMP", ".omp/agent", "sessions")] },
+  { id: "senpi", name: "Senpi / OmO Native", roots: () => [envHome("SENPI_CODING_AGENT_DIR", ".senpi/agent", "sessions"), homePath(".omo/agent/sessions")] },
+  { id: "kimchi", name: "Kimchi", roots: () => [join19(process.env.KIMCHI_CODING_AGENT_DIR || configPath("kimchi/harness"), "sessions")] },
+  { id: "gajae", name: "Gajae-Code", roots: () => [join19(process.env.GJC_CODING_AGENT_DIR || (process.env.GJC_CONFIG_DIR || process.env.PI_CONFIG_DIR ? join19(process.env.GJC_CONFIG_DIR || process.env.PI_CONFIG_DIR, "agent") : homePath(".gjc/agent")), "sessions"), dataPath("gjc/sessions")] }
+].map((s) => ({ ...s, parse: piParse }));
+var openclawRoots = () => [envHome("OPENCLAW_STATE_DIR", ".openclaw", "agents"), ...[".clawdbot", ".moltbot", ".moldbot"].map((p) => homePath(p, "agents"))];
+var promaRoots = () => [".proma", ".proma-dev"].flatMap((p) => ["agent-sessions", "sdk-config/sessions", "sdk-config/projects"].map((s) => homePath(p, s)));
+function kimiHistory(path, files) {
+  const { rows: rows2 } = jsonLines(files.get(path));
+  const folder = dirname6(path), id2 = basename8(folder), agent = basename8(dirname6(folder)) === "agents";
+  const nativeID = agent ? `${basename8(dirname6(dirname6(folder)))}/agent/${id2}` : id2;
+  const wire = join19(folder, "wire.jsonl"), wireRows = files.has(wire) ? jsonLines(files.get(wire)).rows : [];
+  const messages = rows2.flatMap((r, i) => {
+    const m = message(r, nativeText(r.id) || `context:${i}`);
+    return m ? [m] : [];
+  });
+  if (!messages.length) throw new Error("No readable Kimi context messages.");
+  return {
+    nativeID,
+    messages,
+    partial: true,
+    session: { created: seconds(wireRows.find((r) => r.timestamp)?.timestamp) },
+    note: "Kimi persisted context, including tool messages. Earlier compacted context and wire-only activity may be absent. Context messages carry no reliable turn times; wire times are used only for session placement."
+  };
+}
+function museHistory(path, files) {
+  const { rows: rows2 } = jsonLines(files.get(path));
+  const meta = rows2.find((r) => r.payload_type === "runtime.session.metadata");
+  const ids = new Set(rows2.map((r) => text(r.stream?.id)).filter(Boolean));
+  if (!meta || ids.size > 1) throw new Error("Unsupported Muse stream.");
+  const nativeID = [...ids][0] || basename8(dirname6(path));
+  const messages = rows2.flatMap((r, i) => {
+    const event = object(r.payload?.event), body2 = object(event.message);
+    const at2 = typeof r.recorded_at === "number" && r.recorded_at >= 1e15 ? r.recorded_at / 1e3 : typeof r.recorded_at === "number" && r.recorded_at < 1e12 ? seconds(r.recorded_at) : time(r.recorded_at);
+    const m = message(body2, nativeText(r.sequence) || `record:${i}`, at2);
+    if (m) return [m];
+    return text(event.kind) ? [recordEvent(r, nativeText(r.sequence) || `record:${i}`, event.kind, at2, event.text)] : [];
+  });
+  return {
+    nativeID,
+    messages,
+    partial: true,
+    session: { directory: text(meta.payload?.record?.workspace_root), model: text(meta.payload?.record?.model_id) || "Unknown model", provider: text(meta.payload?.record?.provider_id) },
+    note: "Muse runtime session events and recognized message payloads. Unsupported event content remains partial; no session ancestry is inferred from timestamps."
+  };
+}
+function junieHistory(path, files) {
+  const { rows: rows2 } = jsonLines(files.get(path));
+  const messages = rows2.flatMap((r, i) => {
+    const e10 = object(r.event?.agentEvent || r.event), kind = text(e10.kind);
+    if (!kind || /State|Snapshot/.test(kind)) return [];
+    return [recordEvent(r, text(r.id) || `event:${i}`, kind, r.timestampMs, e10.text ?? e10.prompt ?? e10.message)];
+  });
+  if (!messages.length) throw new Error("No supported Junie events.");
+  return { nativeID: basename8(dirname6(path)), messages, partial: true, note: "Junie recorded agent events. State snapshots and opaque event bodies are omitted; events without an authoritative message role are not counted as user turns." };
+}
+function augmentHistory(path, files) {
+  const r = object(json2(files.get(path)));
+  if (!text(r.sessionId) || !Array.isArray(r.chatHistory)) throw new Error("Unsupported Augment session.");
+  const messages = r.chatHistory.flatMap((turn, i) => {
+    const exchange = object(turn.exchange), id2 = nativeText(turn.sequenceId) || `turn:${i}`;
+    return [recordEvent(turn, id2, turn.completed === true ? "Completed exchange" : "Incomplete exchange", turn.finishedAt, exchange.response_text)];
+  });
+  return { nativeID: r.sessionId, messages, partial: true, session: { title: text(r.title), created: time(r.created), model: text(r.agentState?.modelId) || "Unknown model" }, note: "Augment saved exchange records. Typed response-node payloads and absent prompts are not reconstructed into conversations." };
+}
+function fxHistory(path, files) {
+  const usage = object(json2(files.get(path))), meta = sidecar2(files, join19(dirname6(path), "session.json"));
+  const id2 = text(usage.session_id) || text(meta.id);
+  if (!id2 || !usage.snapshot || meta.id && meta.id !== id2) throw new Error("Unsupported Fx session metadata.");
+  return {
+    nativeID: id2,
+    messages: [],
+    partial: true,
+    session: { created: time(meta.created_at_ms), directory: text(meta.workspace_root), title: text(meta.title) },
+    note: "Fx session metadata only. The usage snapshot is cumulative; it contains no conversation or message timestamps."
+  };
+}
+var definitions = [
+  ...piSources,
+  { id: "kiro", name: "Kiro", roots: () => [homePath(".kiro/sessions"), appPath("Kiro/User/globalStorage/kiro.kiroagent")], match: (p) => p.endsWith("/session.json") || /^cli\/[^/]+\.json$/.test(p), extras: (p) => [basename8(p) === "session.json" ? join19(dirname6(p), "messages.jsonl") : p.replace(/\.json$/, ".jsonl")], parse: kiroHistory },
+  { id: "mux", name: "Mux", roots: () => [envHome("MUX_ROOT", ".mux", "sessions")], match: (p) => p.endsWith("/chat.jsonl"), extras: (p) => [join19(dirname6(p), "chat-archive.jsonl")], parse: muxHistory },
+  { id: "devin-desktop", name: "Devin Desktop", roots: () => [appPath("Devin/User/acp-events")], match: (p) => /\.(ndjson|jsonl)$/.test(p), parse: devinDesktopHistory },
+  { id: "openclaw", name: "OpenClaw", roots: openclawRoots, match: (p) => /(?:^|\/)sessions\/.*\.jsonl(?:\.[\w.-]+)?$/.test(p) || /session-sqlite-import-archive\/.*\.jsonl\./.test(p), parse: piParse },
+  { id: "amp", name: "Amp", roots: () => [dataPath("amp/threads"), tokscalePath("amp-cache/threads")], match: (p) => p.endsWith(".json"), parse: ampHistory },
+  { id: "droid", name: "Factory Droid", roots: () => [envHome("FACTORY_HOME", ".factory", "sessions")] },
+  { id: "codebuff", name: "Codebuff", roots: () => process.env.CODEBUFF_DATA_DIR ? [process.env.CODEBUFF_DATA_DIR] : ["manicode", "manicode-dev", "manicode-staging"].map((p) => configPath(p)), match: (p) => p.endsWith("/chat-messages.json"), parse: (p, f) => codebuffHistory(p, f, false) },
+  { id: "freebuff", name: "Freebuff", roots: () => process.env.FREEBUFF_DATA_DIR ? [process.env.FREEBUFF_DATA_DIR] : process.env.CODEBUFF_DATA_DIR ? [process.env.CODEBUFF_DATA_DIR] : ["manicode", "manicode-dev", "manicode-staging"].map((p) => configPath(p)), match: (p) => p.endsWith("/chat-messages.json"), parse: (p, f) => codebuffHistory(p, f, true) },
+  { id: "kimi", name: "Kimi CLI / Code", roots: () => [envHome("KIMI_HOME", ".kimi", "sessions"), envHome("KIMI_CODE_HOME", ".kimi-code", "sessions")], match: (p) => p.endsWith("/context.jsonl"), extras: (p) => [join19(dirname6(p), "wire.jsonl")], parse: kimiHistory },
+  { id: "grok", name: "Grok Build", roots: () => [envHome("GROK_HOME", ".grok", "sessions")], match: (p) => p.endsWith("/updates.jsonl"), parse: (p, f) => acpHistory(p, f.get(p)) },
+  { id: "jcode", name: "Jcode", roots: () => [envHome("JCODE_HOME", ".jcode", "sessions")], match: (p) => /(?:^|\/)session_[^/]+\.json$/.test(p), extras: (p) => [p.replace(/\.json$/, ".journal.jsonl")], parse: jcodeHistory },
+  { id: "cherry-studio", name: "Cherry Studio", roots: () => [appPath("CherryStudio/Data/Agents/.claude/projects"), appPath("CherryStudio/.claude/projects")] },
+  { id: "command-code", name: "Command Code", roots: () => [homePath(".commandcode/projects")] },
+  { id: "zcode", name: "ZCode", roots: () => [homePath(".zcode/projects")] },
+  { id: "codebuddy", name: "CodeBuddy", roots: () => [homePath(".codebuddy/projects")] },
+  { id: "workbuddy", name: "WorkBuddy", roots: () => [homePath(".workbuddy-ai/projects"), homePath(".workbuddy/projects")] },
+  { id: "proma", name: "Proma", roots: promaRoots },
+  { id: "deepseek-harness", name: "DeepSeek Harness", roots: () => [envHome("DSH_HOME", ".dsh", "sessions")], match: (p) => /(?:^|\/)session(?:\.v\d+)?\.jsonl(?:\.zstd)?$/.test(p), parse: (p, f) => dshHistory(f.get(p)) },
+  { id: "aside", name: "Aside", roots: () => [homePath(".aside/u")], match: (p) => /^[^/]+\/sessions\/[^/]+\/messages\.jsonl$/.test(p), parse(p, f) {
+    const h3 = envelopeHistory(p, f.get(p));
+    h3.nativeID = `${basename8(dirname6(dirname6(dirname6(p))))}/${basename8(dirname6(p))}`;
+    return h3;
+  } },
+  { id: "vibe", name: "Mistral Vibe", roots: () => [envHome("VIBE_HOME", ".vibe", "logs/session")], match: (p) => p.endsWith("/meta.json") || /^[^/]+\.json$/.test(p), extras: (p) => basename8(p) === "meta.json" ? [join19(dirname6(p), "messages.jsonl")] : [], parse: vibeHistory },
+  { id: "muse", name: "Muse Code", roots: () => [dataPath("muse/sessions")], match: (p) => p.endsWith("/session.jsonl"), parse: museHistory },
+  { id: "junie", name: "Junie", roots: () => [homePath(".junie/sessions")], match: (p) => p.endsWith("/events.jsonl"), parse: junieHistory, description: "Local agent event history \xB7 partial conversation coverage" },
+  { id: "augment", name: "Augment Code", roots: () => [homePath(".augment/sessions")], match: (p) => p.endsWith(".json"), parse: augmentHistory, description: "Local exchange records \xB7 partial conversation coverage" },
+  { id: "fx", name: "Fx", roots: () => [homePath(".fx/sessions")], match: (p) => p.endsWith("/usage-v2.json"), extras: (p) => [join19(dirname6(p), "session.json")], parse: fxHistory, history: false, description: "Local native session metadata \xB7 conversation unavailable in usage snapshots" },
+  { id: "minimax-code", name: "MiniMax Code", roots: () => [join19(process.env.TOKSCALE_HEADLESS_DIR || tokscalePath("headless"), "mcode")], parse(p, f) {
+    const value = f.get(p), { rows: rows2 } = jsonLines(value), ids = new Set(rows2.map((r) => text(r.sessionId)).filter(Boolean));
+    if (ids.size !== 1) throw new Error("Headless capture needs one explicit session identity.");
+    const messages = rows2.flatMap((r, i) => {
+      const m = message(object(r.message), text(r.message?.id) || `record:${i}`);
+      return m ? [m] : [];
+    });
+    return { nativeID: [...ids][0], messages, partial: true, note: "Previously captured MiniMax stream JSON only; no command is executed. User input and transient streaming records may be absent." };
+  } },
+  { id: "opencodereview", name: "OpenCodeReview", roots: () => [homePath(".opencodereview/sessions")], parse(p, f) {
+    const { rows: rows2 } = jsonLines(f.get(p)), header = rows2.find((r) => r.type === "session_start");
+    if (!header) throw new Error("Unsupported review session.");
+    return { nativeID: text(header.session_id || header.sessionId) || fileID(p), messages: rows2.filter((r) => r.type === "llm_response").map((r, i) => recordEvent(r, text(r.id) || `response:${i}`, "Review response", r.timestamp, r.content ?? r.response)), partial: true, session: { directory: text(header.cwd), created: time(header.timestamp) }, note: "OpenCodeReview saved response events. Usage-only records do not establish conversation text or user prompts." };
+  } }
+];
+var fileHarnessAdapters = definitions.map((source) => localFileAdapter({
+  ...source,
+  roots: harnessRoots(source.id, source.roots),
+  match: source.match || jsonl,
+  description: source.description || "Local transcript snapshots \xB7 bounded, read-only import",
+  capabilities: { history: source.history !== false, forks: false, children: false, files: false },
+  parse: source.parse || ((p, f) => envelopeHistory(p, f.get(p)))
+}));
+
+// server/adapters/harness-databases.ts
+import { lstat as lstat5, readFile as readFile4 } from "node:fs/promises";
+import { isAbsolute as isAbsolute4, join as join20 } from "node:path";
+var parsedContent = (v3) => typeof v3 === "string" && /^[\[{]/.test(v3.trim()) ? optionalJSON(v3) : v3;
+var millisOrSeconds = (v3) => typeof v3 === "number" && v3 > 0 && v3 < 1e10 ? seconds(v3) : time(v3);
+function dbPaths(id2, defaults, match) {
+  return async () => {
+    const override = process.env[`SESSIONGRAPH_${id2.replace(/-/g, "_").toUpperCase()}_HISTORY_DIR`];
+    return override ? (await historyFiles([override], match)).files : existingDatabases(defaults());
+  };
+}
+function sessionHistory(r, messages, note) {
+  return {
+    nativeID: nativeText(r.id),
+    messages,
+    partial: true,
+    session: { title: text(r.title || r.name), directory: text(r.directory || r.cwd || r.working_directory || r.working_dir), created: time(r.created_at), updated: time(r.updated_at), model: text(r.model) || "Unknown model", provider: text(r.provider || r.provider_name) },
+    note
+  };
+}
+var hermes = {
+  id: "hermes",
+  name: "Hermes Agent",
+  paths: async () => (await historyFiles(harnessRoots("hermes", () => [envHome("HERMES_HOME", ".hermes")])(), (p) => p === "state.db" || /^profiles\/[^/]+\/state\.db$/.test(p))).files,
+  table: "sessions",
+  key: "id",
+  fields: ["id", "title", "cwd", "model", "billing_provider", "started_at", "last_activity_at", "parent_session_id", "source", "model_config", "archived"],
+  parse(db2, r) {
+    const messages = rows(db2, "messages", ["id", "message_uid", "role", "content", "timestamp", "tool_call_id", "tool_calls", "tool_name", "_compressed_summary"], ["session_id", r.id], "id").map((m) => {
+      if (m._compressed_summary) return recordEvent(m, text(m.message_uid) || nativeText(m.id), "Context summary", seconds(m.timestamp), m.content);
+      return conversationMessage({ role: m.role, content: parsedContent(m.content), timestamp: seconds(m.timestamp), tool_call_id: m.tool_call_id, toolCalls: optionalJSON(m.tool_calls), toolName: m.tool_name }, text(m.message_uid) || nativeText(m.id));
+    });
+    const h3 = sessionHistory({ ...r, created_at: seconds(r.started_at), updated_at: seconds(r.last_activity_at), provider: r.billing_provider }, messages, "Hermes saved message rows, including retained summaries. Compression/reset parent links are not subagent ancestry. Session usage aggregates are not used as message times.");
+    if (r.source === "subagent") h3.parent = text(r.parent_session_id) || void 0;
+    h3.fork = text(optionalJSON(r.model_config)._branched_from) || void 0;
+    h3.session.archived = r.archived === 1;
+    return h3;
+  }
+};
+var goose = {
+  id: "goose",
+  name: "Goose",
+  paths: dbPaths("goose", () => process.env.GOOSE_PATH_ROOT && isAbsolute4(process.env.GOOSE_PATH_ROOT) ? [join20(process.env.GOOSE_PATH_ROOT, "data/sessions/sessions.db")] : [dataPath("goose/sessions/sessions.db"), dataPath("Block/goose/sessions/sessions.db"), appPath("goose/sessions/sessions.db"), appPath("Block/goose/sessions/sessions.db"), appPath("Block/goose/data/sessions/sessions.db")], (p) => p.endsWith("sessions.db")),
+  table: "sessions",
+  key: "id",
+  fields: ["id", "name", "description", "working_dir", "created_at", "updated_at", "model_config_json", "provider_name", "session_type", "parent_session_id", "archived_at"],
+  parse(db2, r) {
+    const messages = rows(db2, "messages", ["id", "message_id", "role", "content_json", "created_timestamp"], ["session_id", r.id], "id").map((m) => {
+      const content = sqliteJSON(m.content_json);
+      return conversationMessage({ role: m.role, content, timestamp: millisOrSeconds(m.created_timestamp) }, text(m.message_id) || nativeText(m.id));
+    });
+    const h3 = sessionHistory({ ...r, name: r.name || r.description, model: optionalJSON(r.model_config_json).model_name }, messages, "Goose saved conversation rows. Tool/content variants not represented as text are marked partial.");
+    if (r.session_type === "sub_agent") h3.parent = text(r.parent_session_id) || void 0;
+    h3.session.archived = Boolean(r.archived_at);
+    return h3;
+  }
+};
+var openclaw = {
+  id: "openclaw",
+  name: "OpenClaw",
+  paths: async () => (await historyFiles(harnessRoots("openclaw", openclawRoots)(), (p) => /^[^/]+\/agent\/openclaw-agent\.sqlite$/.test(p))).files,
+  table: (db2) => hasTable(db2, "session_windows") ? "session_windows" : "sessions",
+  key: "session_id",
+  fields: ["session_id", "created_at", "updated_at", "model", "model_provider"],
+  parse(db2, r) {
+    const events = rows(db2, "transcript_events", ["seq", "event_json", "event_zstd"], ["session_id", r.session_id], "seq");
+    const messages = events.flatMap((e10) => {
+      const raw = object(sqliteJSON(e10.event_json ?? e10.event_zstd));
+      if (raw.type !== "message") return [];
+      const m = message(object(raw.message), text(raw.id) || `event:${e10.seq}`, raw.timestamp ?? raw.message?.timestamp);
+      return m ? [m] : [];
+    });
+    return sessionHistory({ ...r, id: r.session_id, provider: r.model_provider }, messages, "OpenClaw authoritative transcript events, including zstd payloads. Database sessions take precedence over migrated JSONL copies. Session rollover and event-parent links are not session ancestry.");
+  }
+};
+function forkStore(id2, name, defaultPath, desktop) {
+  return {
+    id: id2,
+    name,
+    paths: dbPaths(id2, () => [defaultPath()], (p) => /\.(db|sqlite)$/.test(p)),
+    table: "session",
+    key: "id",
+    fields: ["id", "title", "directory", "time_created", "time_updated", "version"],
+    parse(db2, r) {
+      if (desktop !== void 0 && text(r.version).startsWith("desktop-") !== desktop) return;
+      const messages = rows(db2, "message", ["id", "data", "time_created"], ["session_id", r.id], "time_created").map((m) => {
+        const body2 = object(sqliteJSON(m.data));
+        let content = body2.parts ?? body2.content;
+        if (hasTable(db2, "part")) content = rows(db2, "part", ["id", "data"], ["message_id", m.id], "id").map((p) => sqliteJSON(p.data));
+        if (Array.isArray(content)) content = content.flatMap((p) => {
+          if (p.type === "tool") {
+            const call = { type: "tool_use", id: p.callID, name: p.tool, input: p.state?.input };
+            return p.state?.status === "completed" || p.state?.status === "error" ? [call, { type: "tool_result", tool_use_id: p.callID, content: p.state.output ?? p.state.error, is_error: p.state.status === "error" }] : [call];
+          }
+          return [p.type === "reasoning" ? { type: "thinking", thinking: p.text } : p];
+        });
+        return conversationMessage({ ...body2, content, timestamp: body2.time?.created ?? m.time_created }, text(m.id));
+      });
+      return sessionHistory({ ...r, created_at: r.time_created, updated_at: r.time_updated }, messages, `${name} native session/message/part tables. Only this harness's database is read; ancestry semantics not explicitly exposed by this format remain unknown.`);
+    }
+  };
+}
+var zed = {
+  id: "zed",
+  name: "Zed Agent",
+  paths: dbPaths("zed", () => [process.platform === "darwin" ? appPath("Zed/threads/threads.db") : process.platform === "win32" ? join20(process.env.LOCALAPPDATA || homePath("AppData/Local"), "Zed/threads/threads.db") : dataPath("zed/threads/threads.db")], (p) => p.endsWith("threads.db")),
+  table: "threads",
+  key: "id",
+  fields: ["id", "summary", "created_at", "updated_at", "data_type", "data", "folder_paths"],
+  parse(db2, r) {
+    if (!["json", "zstd"].includes(r.data_type)) throw new Error("Unsupported Zed encoding.");
+    const body2 = object(sqliteJSON(r.data));
+    if (body2.imported === true) return;
+    if (!Array.isArray(body2.messages)) throw new Error("Unsupported Zed thread.");
+    const messages = body2.messages.map((raw, i) => {
+      const user = object(raw.User), agent = object(raw.Agent), b = raw.User ? user : agent;
+      if (!raw.User && !raw.Agent) return recordEvent(raw, `message:${i}`, "Context checkpoint", 0, raw.Compaction?.Summary);
+      const content = (Array.isArray(b.content) ? b.content : []).map((p) => typeof p.Text === "string" ? { type: "text", text: p.Text } : p.Thinking ? { type: "thinking", thinking: p.Thinking.text } : p.ToolUse ? { type: "tool_use", ...p.ToolUse } : { type: "unsupported" });
+      return conversationMessage({ role: raw.User ? "user" : "assistant", content }, text(b.id) || `message:${i}`);
+    });
+    const folders = optionalJSON(r.folder_paths);
+    return sessionHistory({ ...r, title: r.summary || body2.title, directory: Array.isArray(folders) && folders.length === 1 ? folders[0] : "", model: body2.model?.model, provider: body2.model?.provider }, messages, "Zed native thread messages, JSON or zstd. Native message times are absent in this format; no timing is invented. Imported/shared copies and external ACP histories are excluded from this native-thread store.");
+  }
+};
+var devin = {
+  id: "devin",
+  name: "Devin CLI",
+  paths: dbPaths("devin", () => [dataPath("devin/cli/sessions.db")], (p) => p.endsWith("sessions.db")),
+  table: "sessions",
+  key: "id",
+  fields: ["id", "working_directory", "model", "title", "created_at", "last_activity_at"],
+  parse(db2, r) {
+    const messages = rows(db2, "message_nodes", ["node_id", "chat_message", "created_at"], ["session_id", r.id], "row_id").flatMap((m) => {
+      const raw = object(sqliteJSON(m.chat_message)), result = message(raw, nativeText(m.node_id), millisOrSeconds(m.created_at));
+      return result ? [result] : [recordEvent(raw, nativeText(m.node_id), "Devin message node", millisOrSeconds(m.created_at))];
+    });
+    return sessionHistory({ ...r, created_at: millisOrSeconds(r.created_at), updated_at: millisOrSeconds(r.last_activity_at) }, messages, "Devin saved message nodes. All retained in-session branches are included; node-parent edges are not session ancestry.");
+  }
+};
+var crushDirectories = /* @__PURE__ */ new Map();
+var crush = {
+  id: "crush",
+  name: "Crush",
+  table: "sessions",
+  key: "id",
+  fields: ["id", "title", "created_at", "updated_at", "cost"],
+  paths: async () => {
+    const override = process.env.SESSIONGRAPH_CRUSH_HISTORY_DIR;
+    if (override) return (await historyFiles([override], (p) => p.endsWith("crush.db"))).files;
+    const registry = join20(process.env.CRUSH_GLOBAL_DATA || dataPath("crush"), "projects.json");
+    try {
+      const stat6 = await lstat5(registry);
+      if (!stat6.isFile() || stat6.size > 2e6) throw new Error("Unsupported Crush registry.");
+      const raw = JSON.parse(await readFile4(registry, "utf8"));
+      const paths = [];
+      for (const p of Array.isArray(raw.projects) ? raw.projects.slice(0, 2e4) : []) {
+        if (!isAbsolute4(text(p.path)) || !text(p.data_dir)) continue;
+        const path = join20(isAbsolute4(p.data_dir) ? p.data_dir : join20(p.path, p.data_dir), "crush.db");
+        paths.push(path);
+        crushDirectories.set(path, p.path);
+      }
+      return existingDatabases(paths);
+    } catch (e10) {
+      if (e10.code === "ENOENT") return [];
+      throw e10;
+    }
+  },
+  parse(db2, r, path) {
+    const messages = rows(db2, "messages", ["id", "role", "parts", "created_at", "is_summary_message"], ["session_id", r.id], "created_at").map((m) => {
+      const parts = sqliteJSON(m.parts);
+      const content = Array.isArray(parts) ? parts.map((p) => p.data && typeof p.data === "object" ? { type: p.type, ...p.data } : p) : [];
+      if (m.is_summary_message) return recordEvent(m, text(m.id), "Context summary", millisOrSeconds(m.created_at), content);
+      return conversationMessage({ role: m.role, content, timestamp: millisOrSeconds(m.created_at) }, text(m.id));
+    });
+    const h3 = sessionHistory({ ...r, directory: crushDirectories.get(path) || "", created_at: millisOrSeconds(r.created_at), updated_at: millisOrSeconds(r.updated_at) }, messages, "Crush per-project saved message parts. Session cost is retained when recorded; unreliable token counters remain unknown.");
+    h3.session.cost = typeof r.cost === "number" && r.cost >= 0 ? r.cost : null;
+    return h3;
+  }
+};
+var octofriend = {
+  id: "octofriend",
+  name: "Octofriend",
+  paths: dbPaths("octofriend", () => [homePath(".local/share/octofriend/sqlite.db")], (p) => p.endsWith("sqlite.db")),
+  table: "trees",
+  key: "id",
+  fields: ["id", "name", "cwd", "updated_at"],
+  parse(db2, r) {
+    const nodes = rows(db2, "tree_nodes", ["id", "history_item_id", "parent_id", "created_at"], ["tree_id", r.id], "id");
+    const messages = [];
+    let bytes2 = 0;
+    for (const node of nodes) {
+      const item = rows(db2, "history_items", ["llm_ir_id"], ["id", node.history_item_id], void 0, 1)[0];
+      if (!item?.llm_ir_id) continue;
+      const row = rows(db2, "llm_irs", ["json"], ["id", item.llm_ir_id], void 0, 1)[0];
+      bytes2 += text(row?.json).length;
+      if (bytes2 > 32e6) throw new Error("Octofriend session exceeds the snapshot limit.");
+      const payload = object(sqliteJSON(row?.json));
+      if (payload.version !== "octo-llm-ir/v1") throw new Error("Unsupported Octofriend IR version.");
+      const ir = object(payload.ir), content = Array.isArray(ir.content) ? ir.content.map((p) => p.type === "text" ? { type: "text", text: p.content } : p) : ir.content;
+      const m = message({ ...ir, content, role: ir.role === "tool-output" ? "tool" : ir.role }, nativeText(node.id), node.created_at);
+      messages.push(m || recordEvent(ir, nativeText(node.id), text(ir.role), node.created_at));
+    }
+    const h3 = sessionHistory({ ...r, created_at: nodes[0]?.created_at }, messages, "Octofriend native history trees and versioned IR. Retained branches are preserved; nested subagent trajectories and unsupported IR variants are partial. Provider attribution remains with the harness.");
+    return h3;
+  }
+};
+var unsloth = {
+  id: "unsloth",
+  name: "Unsloth Studio",
+  paths: dbPaths("unsloth", () => [envHome("UNSLOTH_STUDIO_HOME", ".unsloth/studio", "studio.db")], (p) => p.endsWith("studio.db")),
+  table: "chat_threads",
+  key: "id",
+  fields: ["id", "title", "model_id", "created_at", "updated_at", "archived", "forked_from_thread_id"],
+  parse(db2, r) {
+    const messages = rows(db2, "chat_messages", ["id", "role", "content_json", "created_at"], ["thread_id", r.id], "created_at").flatMap((row) => {
+      const m = message({ role: row.role, content: sqliteJSON(row.content_json) }, text(row.id), seconds(row.created_at));
+      return m ? [m] : [];
+    });
+    const h3 = sessionHistory({ ...r, model: r.model_id, created_at: seconds(r.created_at), updated_at: seconds(r.updated_at) }, messages, "Unsloth Studio native chat threads and message content. Content-free API usage, training runs, attachments, and unsupported tool blocks are excluded.");
+    h3.fork = text(r.forked_from_thread_id) || void 0;
+    h3.session.archived = r.archived === 1;
+    return h3;
+  }
+};
+var kiro = {
+  id: "kiro",
+  name: "Kiro",
+  paths: dbPaths("kiro", () => [appPath("kiro-cli/data.sqlite3"), dataPath("kiro-cli/data.sqlite3")], (p) => p.endsWith("data.sqlite3")),
+  table: "conversations_v2",
+  key: "conversation_id",
+  fields: ["key", "conversation_id", "value"],
+  parse(db2, r) {
+    const body2 = object(sqliteJSON(r.value));
+    if (!Array.isArray(body2.history)) throw new Error("Unsupported Kiro conversation.");
+    const messages = body2.history.flatMap((turn, i) => {
+      const result = [], input = object(turn.user?.content), output = object(turn.assistant?.Response || turn.assistant?.ToolUse);
+      if (typeof input.Prompt?.prompt === "string") result.push(conversationMessage({ role: "user", content: input.Prompt.prompt }, `turn:${i}:user`));
+      if (input.ToolUseResults) result.push(conversationMessage({ role: "tool", content: input.ToolUseResults }, `turn:${i}:tool`));
+      if (typeof output.content === "string") result.push(conversationMessage({ role: "assistant", content: output.content, timestamp: turn.request_metadata?.stream_end_timestamp_ms }, `turn:${i}:assistant`));
+      return result;
+    });
+    const created = body2.history.map((t) => time(t.request_metadata?.request_start_timestamp_ms)).find(Boolean);
+    return { nativeID: text(r.conversation_id), messages, partial: true, session: { directory: text(r.key), created, model: text(body2.model_info?.model_id) || "Unknown model" }, note: "Kiro retained SQLite conversation turns. Request-start metadata places the session; untimed user prompts remain untimed. Tool-use variants and compacted context are partial." };
+  }
+};
+var databaseHarnessAdapters = [
+  hermes,
+  goose,
+  openclaw,
+  zed,
+  devin,
+  crush,
+  octofriend,
+  unsloth,
+  kiro,
+  forkStore("kilo-cli", "Kilo CLI", () => dataPath("kilo/kilo.db")),
+  forkStore("mimo-code", "MiMo Code", () => dataPath("mimocode/mimocode.db"), false),
+  forkStore("mimo-desktop", "Xiaomi MiMo AI", () => dataPath("mimocode/mimocode.db"), true)
+].map(sqliteHistoryAdapter);
+
+// server/adapters/harness-metadata.ts
+import { basename as basename9 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { lstat as lstat6 } from "node:fs/promises";
+function protoFields(value) {
+  if (value.length > 2e6) throw new Error("Trajectory metadata exceeds 2 MB.");
+  const fields2 = /* @__PURE__ */ new Map();
+  let at2 = 0, count = 0;
+  const varint = () => {
+    let n = 0n;
+    for (let i = 0; i < 10 && at2 < value.length; i++) {
+      const b = value[at2++];
+      n |= BigInt(b & 127) << BigInt(7 * i);
+      if (!(b & 128)) return n;
+    }
+    throw new Error("Invalid protobuf varint.");
+  };
+  while (at2 < value.length) {
+    if (++count > 1e4) throw new Error("Too many protobuf fields.");
+    const key = Number(varint()), field = key >>> 3, wire = key & 7;
+    if (!field) throw new Error("Invalid protobuf field.");
+    if (wire === 0) fields2.set(field, varint());
+    else if (wire === 2) {
+      const length = Number(varint());
+      if (!Number.isSafeInteger(length) || length > value.length - at2) throw new Error("Invalid protobuf length.");
+      fields2.set(field, value.subarray(at2, at2 + length));
+      at2 += length;
+    } else if (wire === 1 || wire === 5) {
+      at2 += wire === 1 ? 8 : 4;
+      if (at2 > value.length) throw new Error("Truncated protobuf field.");
+    } else throw new Error("Unsupported protobuf wire type.");
+  }
+  return fields2;
+}
+var nested = (v3) => v3 instanceof Uint8Array ? protoFields(v3) : /* @__PURE__ */ new Map();
+var antigravityDatabaseAdapters = ["antigravity-cli", "antigravity-extension"].map((id2) => sqliteHistoryAdapter({
+  id: id2,
+  name: id2 === "antigravity-cli" ? "Antigravity CLI" : "Antigravity IDE Extension",
+  history: false,
+  description: "Native session metadata only \xB7 opaque protobuf conversations",
+  paths: async () => (await historyFiles(harnessRoots(id2, () => [envHome("GEMINI_CLI_HOME", ".gemini", id2 === "antigravity-cli" ? "antigravity-cli/conversations" : "antigravity/conversations")])(), (p) => p.endsWith(".db"))).files,
+  table: "trajectory_metadata_blob",
+  key: "id",
+  fields: ["id", "data"],
+  parse(db2, row, path) {
+    if (!(row.data instanceof Uint8Array)) throw new Error("Unsupported trajectory metadata.");
+    const fields2 = protoFields(row.data), timestamp = nested(fields2.get(2));
+    const sec = timestamp.get(1), nano = timestamp.get(2);
+    const created = typeof sec === "bigint" && sec > 0n && sec < 8640000000000n ? time(Number(sec) * 1e3 + (typeof nano === "bigint" && nano < 1000000000n ? Number(nano) / 1e6 : 0)) : 0;
+    const uri = nested(fields2.get(1)).get(1);
+    let directory2 = "";
+    if (uri instanceof Uint8Array) {
+      try {
+        directory2 = fileURLToPath3(Buffer.from(uri).toString("utf8"));
+      } catch {
+      }
+    }
+    if (!created) throw new Error("Trajectory creation time is unavailable.");
+    return { nativeID: basename9(path, ".db"), messages: [], partial: true, session: { created, directory: directory2 }, note: "Native Antigravity trajectory identity and creation metadata only. Protobuf conversation/step bodies are opaque; no message text, generation-time guesses, or usage-derived turns are imported." };
+  }
+}));
+var antigravityCacheAdapter = localFileAdapter({
+  id: "antigravity",
+  name: "Antigravity",
+  description: "Previously synced session metadata only \xB7 cache contains no conversations",
+  capabilities: { history: false, forks: false, children: false, files: false },
+  roots: harnessRoots("antigravity", () => [tokscalePath("antigravity-cache/sessions")]),
+  match: (p) => p.endsWith(".jsonl"),
+  parse(path, files) {
+    const { rows: rows2 } = jsonLines(files.get(path));
+    const ids = new Set(rows2.map((r) => text(r.sessionId)).filter(Boolean));
+    if (ids.size !== 1) throw new Error("Unsupported Antigravity cache identity.");
+    const created = rows2.map((r) => time(r.timestamp)).filter(Boolean).sort((a, b) => a - b)[0];
+    if (!created) throw new Error("Antigravity cache has no recorded date.");
+    return { nativeID: [...ids][0], messages: [], partial: true, session: { created, model: text(rows2.find((r) => r.modelId)?.modelId) || "Unknown model" }, note: "Previously synced Antigravity session identity; placement uses earliest recorded usage date. This cache has no conversation bodies. SessionGraph never runs sync or contacts the language server." };
+  }
+});
+var usageOnlyAdapters = [
+  { id: "reasonix", name: "Reasonix", roots: () => [envHome("REASONIX_STATE_HOME", ".reasonix", "stats"), envHome("REASONIX_HOME", ".reasonix", "stats")], note: "Request statistics lack conversation identities and text. Reasonix transcript import is not yet supported." },
+  { id: "trae", name: "Trae / Trae Solo", roots: () => [tokscalePath("trae-cache/sessions")], note: "The Tokscale cache contains account usage, not local conversations." },
+  { id: "warp", name: "Warp / Oz", roots: () => [tokscalePath("warp-cache")], note: "The Tokscale cache contains aggregate requests and spend, not local conversations." },
+  { id: "lm-studio", name: "LM Studio", roots: () => [envHome("LM_STUDIO_HOME", ".lmstudio", "server-logs")], note: "Server logs contain final-response usage, not retained prompts or responses." },
+  { id: "hindsight", name: "Hindsight", roots: () => [envHome("HINDSIGHT_HOME", ".hindsight", "usage")], note: "Synced memory-operation usage is not agent conversation history." }
+].map((source) => ({
+  id: source.id,
+  name: source.name,
+  description: `Detection only \xB7 ${source.note}`,
+  capabilities: { history: false, forks: false, children: false, files: false },
+  async detect() {
+    for (const p of harnessRoots(source.id, source.roots)()) if ((await lstat6(p).catch(() => void 0))?.isDirectory()) return true;
+    return false;
+  },
+  async discover() {
+    return { sessions: [], projects: [], warnings: [source.note] };
+  },
+  async read() {
+    throw new Error(source.note);
+  }
+}));
+
 // server/adapters/index.ts
-var adapters = [opencodeAdapter, claudeAdapter, codexAdapter, cursorAdapter, geminiAdapter, qwenAdapter, piAdapter, copilotAdapter, clineAdapter, rooAdapter, kiloAdapter, continueAdapter];
+var extra = [...databaseHarnessAdapters, ...fileHarnessAdapters, antigravityCacheAdapter, ...antigravityDatabaseAdapters, ...usageOnlyAdapters];
+var grouped = /* @__PURE__ */ new Map();
+for (const adapter of extra) grouped.set(adapter.id, [...grouped.get(adapter.id) || [], adapter]);
+var adapters = [opencodeAdapter, claudeAdapter, codexAdapter, cursorAdapter, geminiAdapter, qwenAdapter, piAdapter, copilotAdapter, clineAdapter, rooAdapter, kiloAdapter, continueAdapter, ...[...grouped.values()].map((parts) => parts.length === 1 ? parts[0] : combineAdapters(parts))];
 
 // server/store.ts
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
-import { mkdirSync as mkdirSync2, chmodSync as chmodSync2 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
+import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
+import { mkdirSync as mkdirSync2, chmodSync as chmodSync3 } from "node:fs";
+import { dirname as dirname7 } from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/search/persistence.ts
@@ -31921,14 +33128,14 @@ var EVENT_SCHEMA = `CREATE TABLE IF NOT EXISTS timeline_items (
   CREATE INDEX IF NOT EXISTS timeline_time ON timeline_items(session_id,time);
   CREATE INDEX IF NOT EXISTS timeline_calls ON timeline_items(session_id,call_id);
   CREATE TABLE IF NOT EXISTS timeline_coverage (session_id TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE, partial INTEGER NOT NULL, note TEXT, revision TEXT NOT NULL);`;
-function writeEvents(db2, id2, rows) {
+function writeEvents(db2, id2, rows2) {
   db2.prepare("DELETE FROM timeline_items WHERE session_id=?").run(id2);
   const insert = db2.prepare("INSERT OR IGNORE INTO timeline_items VALUES (?,?,?,?,?,?,?,?,?,?,?)");
   let ordinal = 0, bytes2 = 0, partial = false, legacy = false, limited = false;
-  for (const row of rows) {
-    const message = JSON.parse(String(row.data));
-    legacy ||= !message.events;
-    for (const event of normalizedEvents(message, id2)) {
+  for (const row of rows2) {
+    const message2 = JSON.parse(String(row.data));
+    legacy ||= !message2.events;
+    for (const event of normalizedEvents(message2, id2)) {
       const item = { ...event, ordinal: ordinal++ }, data = JSON.stringify(item);
       bytes2 += Buffer.byteLength(data);
       if (ordinal > 2e5 || bytes2 > 32e6) {
@@ -31949,8 +33156,8 @@ function eventSummary(row) {
   return { id: String(row.id), kind: row.kind, role: row.role, name: String(row.name), time: row.time === null ? null : Number(row.time), timeSource: row.timeSource, ordinal: Number(row.ordinal), preview: String(row.preview), status: row.status, partial: Boolean(row.partial) };
 }
 var EventReadError = class extends Error {
-  constructor(message, status) {
-    super(message);
+  constructor(message2, status) {
+    super(message2);
     this.status = status;
   }
   status;
@@ -31963,8 +33170,8 @@ function coverage(db2, session) {
 function readEventMarkers(db2, session) {
   const end = Math.max(session.created, session.activity?.lastMessageAt || session.created);
   const totals = db2.prepare(`SELECT count(*) AS total, count(*) FILTER (WHERE time IS NULL) AS untimed, count(*) FILTER (WHERE time<? OR time>?) AS outside FROM timeline_items WHERE session_id=? AND (${filters.messages})`).get(session.created, end, session.id);
-  const rows = db2.prepare(`SELECT ${summaryColumns} FROM timeline_items WHERE session_id=? AND (${filters.messages}) AND time>=? AND time<=? ORDER BY time DESC,ordinal DESC`).all(session.id, session.created, end);
-  return { sessionID: session.id, ...coverage(db2, session), items: rows.reverse().map(eventSummary), total: Number(totals.total), untimed: Number(totals.untimed), outsideLifetime: Number(totals.outside), limited: Number(totals.total) - Number(totals.untimed) - Number(totals.outside) > rows.length };
+  const rows2 = db2.prepare(`SELECT ${summaryColumns} FROM timeline_items WHERE session_id=? AND (${filters.messages}) AND time>=? AND time<=? ORDER BY time DESC,ordinal DESC`).all(session.id, session.created, end);
+  return { sessionID: session.id, ...coverage(db2, session), items: rows2.reverse().map(eventSummary), total: Number(totals.total), untimed: Number(totals.untimed), outsideLifetime: Number(totals.outside), limited: Number(totals.total) - Number(totals.untimed) - Number(totals.outside) > rows2.length };
 }
 function readEvents(db2, session, options = {}) {
   const state2 = coverage(db2, session), filter = options.filter || "all", size = 60;
@@ -32088,9 +33295,9 @@ function normalizeViewState(value) {
 var SessionGraphStore = class {
   constructor(path = databasePath()) {
     this.path = path;
-    if (path !== ":memory:") mkdirSync2(dirname4(path), { recursive: true, mode: 448 });
-    this.db = new DatabaseSync2(path);
-    if (path !== ":memory:") chmodSync2(path, 384);
+    if (path !== ":memory:") mkdirSync2(dirname7(path), { recursive: true, mode: 448 });
+    this.db = new DatabaseSync3(path);
+    if (path !== ":memory:") chmodSync3(path, 384);
     this.db.exec("PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000;");
     const version = Number(this.db.prepare("PRAGMA user_version").get().user_version);
     if (version > 4) throw new Error("This SessionGraph database requires a newer version of the app.");
@@ -32213,7 +33420,7 @@ var SessionGraphStore = class {
     try {
       this.db.prepare("DELETE FROM messages WHERE session_id=?").run(s.id);
       const insert = this.db.prepare("INSERT INTO messages (session_id,id,ordinal,data,time,is_user) VALUES (?,?,?,?,?,?) ON CONFLICT(session_id,id) DO UPDATE SET ordinal=excluded.ordinal,data=excluded.data,time=excluded.time,is_user=excluded.is_user");
-      messages.forEach((message, i) => insert.run(s.id, message.id, i, JSON.stringify(message), messageTime(message.time), Number(isUserMessage(message))));
+      messages.forEach((message2, i) => insert.run(s.id, message2.id, i, JSON.stringify(message2), messageTime(message2.time), Number(isUserMessage(message2))));
       writeEvents(this.db, s.id, this.db.prepare("SELECT data FROM messages WHERE session_id=? ORDER BY ordinal").iterate(s.id));
       const activity = this.db.prepare(activitySQL).get(s.id);
       this.db.prepare("UPDATE sessions SET metadata=?, imported_revision=? WHERE id=?").run(JSON.stringify({ ...s, activity }), candidate.revision, s.id);
@@ -32255,8 +33462,8 @@ var SessionGraphStore = class {
   }
   messagePage(id2, cursor = 0, limit = 60) {
     if (!this.getSession(id2)) throw new Error("Session not imported.");
-    const rows = this.db.prepare("SELECT data FROM messages WHERE session_id=? ORDER BY ordinal DESC LIMIT ? OFFSET ?").all(id2, limit + 1, cursor);
-    return { messages: rows.slice(0, limit).map((r) => JSON.parse(String(r.data))), next: rows.length > limit ? String(cursor + limit) : null };
+    const rows2 = this.db.prepare("SELECT data FROM messages WHERE session_id=? ORDER BY ordinal DESC LIMIT ? OFFSET ?").all(id2, limit + 1, cursor);
+    return { messages: rows2.slice(0, limit).map((r) => JSON.parse(String(r.data))), next: rows2.length > limit ? String(cursor + limit) : null };
   }
   handoff(id2) {
     this.db.exec("BEGIN");
@@ -32264,8 +33471,8 @@ var SessionGraphStore = class {
       const session = this.getSession(id2);
       if (!session) throw new Error("Session not imported.");
       const totalMessages = Number(this.db.prepare("SELECT count(*) AS n FROM messages WHERE session_id=?").get(id2).n);
-      const rows = this.db.prepare("SELECT data FROM messages WHERE session_id=? ORDER BY ordinal DESC LIMIT 200").all(id2).reverse();
-      const messages = rows.map((r) => JSON.parse(String(r.data)));
+      const rows2 = this.db.prepare("SELECT data FROM messages WHERE session_id=? ORDER BY ordinal DESC LIMIT 200").all(id2).reverse();
+      const messages = rows2.map((r) => JSON.parse(String(r.data)));
       const first = this.db.prepare("SELECT data FROM messages WHERE session_id=? AND is_user=1 ORDER BY ordinal LIMIT 1").get(id2);
       const firstUser = first ? JSON.parse(String(first.data)) : void 0;
       this.db.exec("COMMIT");
@@ -32280,16 +33487,16 @@ var SessionGraphStore = class {
     try {
       const session = this.getSession(id2);
       if (!session) throw new Error("Session not imported.");
-      const rows = this.db.prepare("SELECT id,time FROM messages WHERE session_id=? AND is_user=1 AND time>=? ORDER BY time DESC,ordinal DESC LIMIT 2000").all(id2, session.created);
+      const rows2 = this.db.prepare("SELECT id,time FROM messages WHERE session_id=? AND is_user=1 AND time>=? ORDER BY time DESC,ordinal DESC LIMIT 2000").all(id2, session.created);
       const earlier = Number(this.db.prepare("SELECT count(*) AS n FROM messages WHERE session_id=? AND is_user=1 AND time<?").get(id2, session.created).n);
       const activity = session.activity;
       const result = {
         id: id2,
-        userMessages: rows.reverse().map((row) => ({ id: String(row.id), time: Number(row.time) })),
+        userMessages: rows2.reverse().map((row) => ({ id: String(row.id), time: Number(row.time) })),
         totalUserMessages: activity?.userMessages ?? 0,
         untimedUserMessages: activity?.untimedUserMessages ?? 0,
         earlierUserMessages: earlier,
-        partial: session.coverage?.history !== "complete" || rows.length + earlier < (activity?.userMessages ?? 0),
+        partial: session.coverage?.history !== "complete" || rows2.length + earlier < (activity?.userMessages ?? 0),
         note: session.coverage?.note
       };
       this.db.exec("COMMIT");
@@ -32337,12 +33544,12 @@ var SessionGraphStore = class {
     return this.readSnapshot(id2, (session) => {
       const page = this.messagePage(id2, Number(cursor || 0), 120);
       const files = /* @__PURE__ */ new Map(), tools = /* @__PURE__ */ new Map();
-      for (const message of page.messages) {
-        for (const file of message.files) {
+      for (const message2 of page.messages) {
+        for (const file of message2.files) {
           const previous = files.get(file.path);
           files.set(file.path, { ...file, source: previous?.source === "snapshot" ? "snapshot" : file.source, steps: (previous?.steps || 0) + file.steps });
         }
-        message.tools.forEach((tool) => tools.set(tool, (tools.get(tool) || 0) + 1));
+        message2.tools.forEach((tool) => tools.set(tool, (tools.get(tool) || 0) + 1));
       }
       return {
         id: id2,
@@ -32360,14 +33567,14 @@ var SessionGraphStore = class {
     });
   }
   checkpoints(after = "") {
-    const rows = this.db.prepare("SELECT id,data FROM search_cache WHERE id>? ORDER BY id LIMIT 51").all(after);
+    const rows2 = this.db.prepare("SELECT id,data FROM search_cache WHERE id>? ORDER BY id LIMIT 51").all(after);
     const records = [];
-    for (const row of rows.slice(0, 50)) {
+    for (const row of rows2.slice(0, 50)) {
       const record = JSON.parse(String(row.data));
       if (validRecord(record, this.getSession(String(row.id)))) records.push(record);
       else this.db.prepare("DELETE FROM search_cache WHERE id=?").run(row.id);
     }
-    return { records, cursor: rows.length > 50 ? String(rows[49].id) : void 0, epoch: this.setting("indexEpoch") || 0 };
+    return { records, cursor: rows2.length > 50 ? String(rows2[49].id) : void 0, epoch: this.setting("indexEpoch") || 0 };
   }
   saveCheckpoint(record, epoch) {
     this.db.exec("BEGIN IMMEDIATE");
@@ -32479,23 +33686,23 @@ var Importer = class {
               const page = await adapter.read(candidate, cursor);
               partial ||= Boolean(page.partial);
               note = page.note || note;
-              for (const message of page.messages) {
-                if (!message.id || messages.has(message.id)) continue;
+              for (const message2 of page.messages) {
+                if (!message2.id || messages.has(message2.id)) continue;
                 if (messages.size >= 5e4 || characters >= 16e6) {
                   partial = true;
                   break;
                 }
                 let remaining = 16e6 - characters;
-                message.fragments = message.fragments.flatMap((fragment) => {
+                message2.fragments = message2.fragments.flatMap((fragment) => {
                   const text2 = fragment.text.slice(0, remaining);
-                  if (text2.length < fragment.text.length) message.partial = true;
+                  if (text2.length < fragment.text.length) message2.partial = true;
                   remaining -= text2.length;
                   return text2 ? [{ ...fragment, text: text2 }] : [];
                 });
-                characters += boundEventPayloads(message, remaining);
-                partial ||= Boolean(message.partial);
-                characters += message.fragments.reduce((n, f) => n + f.text.length, 0);
-                messages.set(message.id, message);
+                characters += boundEventPayloads(message2, remaining);
+                partial ||= Boolean(message2.partial);
+                characters += message2.fragments.reduce((n, f) => n + f.text.length, 0);
+                messages.set(message2.id, message2);
               }
               cursor = page.cursor;
               pages++;
@@ -32521,9 +33728,9 @@ var Importer = class {
         }
         this.store.recordSource(adapter.id, [this.status.failed > failedBefore ? `${this.status.failed - failedBefore} sessions could not be updated; import again to retry.` : "", ...discovery.warnings].filter(Boolean).join(" ") || void 0);
       } catch (error) {
-        const message = error instanceof Error ? error.message : `${adapter.name} import failed.`;
-        this.status.errors.push(message);
-        this.store.recordSource(adapter.id, message);
+        const message2 = error instanceof Error ? error.message : `${adapter.name} import failed.`;
+        this.status.errors.push(message2);
+        this.store.recordSource(adapter.id, message2);
         this.status.failed++;
       }
     }
@@ -32534,7 +33741,7 @@ var Importer = class {
 import { execFile, spawn as spawn2 } from "node:child_process";
 import { promisify } from "node:util";
 import { stat as stat4 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname5, isAbsolute as isAbsolute4 } from "node:path";
+import { basename as basename10, dirname as dirname8, isAbsolute as isAbsolute6 } from "node:path";
 
 // src/launch-links.ts
 var HARNESSES = [
@@ -32567,19 +33774,19 @@ function resumeArgs(value) {
 
 // server/harnesses.ts
 import { access, stat as stat3 } from "node:fs/promises";
-import { constants as constants4 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { delimiter, isAbsolute as isAbsolute3, join as join15 } from "node:path";
+import { constants as constants6 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
+import { delimiter, isAbsolute as isAbsolute5, join as join21 } from "node:path";
 async function executable(name) {
-  const home = homedir11();
-  const directories = [...(process.env.PATH || "").split(delimiter), join15(home, ".local", "bin"), join15(home, ".opencode", "bin"), join15(home, ".bun", "bin"), join15(home, "Library", "pnpm"), "/opt/homebrew/bin", "/usr/local/bin"];
-  if (process.platform === "win32" && process.env.APPDATA) directories.push(join15(process.env.APPDATA, "npm"));
-  if (process.platform === "win32" && process.env.SystemRoot) directories.push(join15(process.env.SystemRoot, "System32", "WindowsPowerShell", "v1.0"));
-  const candidates = isAbsolute3(name) ? [name] : directories.filter((dir) => isAbsolute3(dir)).flatMap((dir) => (process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""]).map((extension) => join15(dir, name + extension)));
+  const home = homedir12();
+  const directories = [...(process.env.PATH || "").split(delimiter), join21(home, ".local", "bin"), join21(home, ".opencode", "bin"), join21(home, ".bun", "bin"), join21(home, "Library", "pnpm"), "/opt/homebrew/bin", "/usr/local/bin"];
+  if (process.platform === "win32" && process.env.APPDATA) directories.push(join21(process.env.APPDATA, "npm"));
+  if (process.platform === "win32" && process.env.SystemRoot) directories.push(join21(process.env.SystemRoot, "System32", "WindowsPowerShell", "v1.0"));
+  const candidates = isAbsolute5(name) ? [name] : directories.filter((dir) => isAbsolute5(dir)).flatMap((dir) => (process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""]).map((extension) => join21(dir, name + extension)));
   for (const path of candidates) {
     try {
       if ((await stat3(path)).isFile()) {
-        await access(path, process.platform === "win32" ? constants4.F_OK : constants4.X_OK);
+        await access(path, process.platform === "win32" ? constants6.F_OK : constants6.X_OK);
         return path;
       }
     } catch {
@@ -32591,7 +33798,7 @@ async function harnessExecutable(target) {
   const path = await executable(name);
   if (path) return path;
   if (target === "codex" && process.platform === "darwin") {
-    return await executable("/Applications/Codex.app/Contents/Resources/codex") || await executable(join15(homedir11(), "Applications/Codex.app/Contents/Resources/codex"));
+    return await executable("/Applications/Codex.app/Contents/Resources/codex") || await executable(join21(homedir12(), "Applications/Codex.app/Contents/Resources/codex"));
   }
 }
 async function terminalExecutable() {
@@ -32607,16 +33814,16 @@ function shellQuote(value, platform = process.platform) {
   if (/[\x00-\x1f\x7f]/.test(value)) throw new Error("Paths and launch arguments must not contain control characters.");
   return `'${value.replaceAll("'", platform === "win32" ? "''" : "'\\''")}'`;
 }
-function launchCommand(binary, args, directory, platform = process.platform) {
+function launchCommand(binary, args, directory2, platform = process.platform) {
   const quote = (value) => shellQuote(value, platform);
   const invocation = [binary, ...args].map(quote).join(" ");
-  return platform === "win32" ? `Set-Location -LiteralPath ${quote(directory)}; if ($?) { & ${invocation} }` : `cd -- ${quote(directory)} && ${invocation}`;
+  return platform === "win32" ? `Set-Location -LiteralPath ${quote(directory2)}; if ($?) { & ${invocation} }` : `cd -- ${quote(directory2)} && ${invocation}`;
 }
 
 // server/handoff.ts
 import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
 import { mkdir, writeFile as writeFile2, rename as rename2, rm as rm4 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { join as join22 } from "node:path";
 function handoffDocument(snapshot2) {
   const { session, messages, firstUser, totalMessages } = snapshot2;
   if (!messages.length) throw new Error("Import this session\u2019s conversation before continuing in another app.");
@@ -32629,28 +33836,28 @@ function handoffDocument(snapshot2) {
 [\u2026 content omitted \u2026]
 ${text3.slice(-half)}`;
   };
-  const block = (message, limit) => {
-    const time2 = messageTime(message.time) ? new Date(message.time).toISOString() : "time unavailable";
-    const content = message.fragments.map((f) => `[${f.kind}]
+  const block = (message2, limit) => {
+    const time2 = messageTime(message2.time) ? new Date(message2.time).toISOString() : "time unavailable";
+    const content = message2.fragments.map((f) => `[${f.kind}]
 ${clip(f.text, f.kind === "Tool" ? 2e3 : 12e3)}`).join("\n\n");
-    const files = message.files.length ? `
+    const files = message2.files.length ? `
 
-Recorded file changes: ${message.files.slice(0, 60).map((f) => JSON.stringify(f.path)).join(", ")}` : "";
-    shortened ||= message.files.length > 60 || Boolean(message.partial);
-    return `## ${message.role} \xB7 ${time2}
+Recorded file changes: ${message2.files.slice(0, 60).map((f) => JSON.stringify(f.path)).join(", ")}` : "";
+    shortened ||= message2.files.length > 60 || Boolean(message2.partial);
+    return `## ${message2.role} \xB7 ${time2}
 
 ${clip(content + files, limit)}
 `;
   };
   let remaining = 16e4;
   const chunks = [];
-  for (const message of [...messages].reverse()) {
+  for (const message2 of [...messages].reverse()) {
     if (remaining < 500) {
       shortened = true;
       break;
     }
-    const text3 = block(message, Math.min(16e3, remaining - 100));
-    chunks.unshift({ id: message.id, text: text3 });
+    const text3 = block(message2, Math.min(16e3, remaining - 100));
+    chunks.unshift({ id: message2.id, text: text3 });
     remaining -= text3.length;
   }
   if (firstUser && !chunks.some((c) => c.id === firstUser.id)) chunks.unshift({ id: firstUser.id, text: `### Original request (earlier history omitted)
@@ -32679,12 +33886,12 @@ This handoff transfers saved text and file-change evidence, not files, credentia
 ` + chunks.map((c) => c.text).join("\n");
   return { text: text2, messages: chunks.length, totalMessages, partial, note };
 }
-async function saveHandoff(snapshot2, directory) {
+async function saveHandoff(snapshot2, directory2) {
   const { text: text2, ...coverage2 } = handoffDocument(snapshot2);
   const digest2 = createHash4("sha256").update(text2).digest("hex");
-  const root3 = join16(directory, "handoffs");
+  const root3 = join22(directory2, "handoffs");
   await mkdir(root3, { recursive: true, mode: 448 });
-  const path = join16(root3, `${digest2}.md`), temporary = join16(root3, `.${randomUUID3()}.tmp`);
+  const path = join22(root3, `${digest2}.md`), temporary = join22(root3, `.${randomUUID3()}.tmp`);
   try {
     await writeFile2(temporary, text2, { mode: 384, flag: "wx" });
     await rename2(temporary, path);
@@ -32714,24 +33921,24 @@ async function getLaunchConnection(session) {
   }
   return { webBaseUrl, terminalAvailable: Boolean(terminal), targets };
 }
-async function prepareLaunch(store, session, target, directory = session.directory) {
+async function prepareLaunch(store, session, target, directory2 = session.directory) {
   if (!isHarness(target)) throw new Error("Choose a supported destination app.");
-  if (typeof directory !== "string" || !isAbsolute4(directory) || /[\x00-\x1f\x7f]/.test(directory)) throw new Error("Choose an absolute working directory.");
-  if (!(await stat4(directory).catch(() => void 0))?.isDirectory()) throw new Error("Working directory is unavailable. Choose an existing directory.");
+  if (typeof directory2 !== "string" || !isAbsolute6(directory2) || /[\x00-\x1f\x7f]/.test(directory2)) throw new Error("Choose an absolute working directory.");
+  if (!(await stat4(directory2).catch(() => void 0))?.isDirectory()) throw new Error("Working directory is unavailable. Choose an existing directory.");
   const [binary, terminal] = await Promise.all([harnessExecutable(target), terminalExecutable()]);
   let args;
   const subagent = session.source === "claude-code" && Boolean(session.parentID) && /^[\w-]+\/agent\/[\w-]+$/.test(session.nativeID || "");
-  const localHandoff = ["cursor", "gemini", "qwen-code", "pi", "copilot"].includes(session.source || "") && (!session.nativeResume || directory !== session.directory);
+  const localHandoff = ["cursor", "gemini", "qwen-code", "pi", "copilot"].includes(session.source || "") && (!session.nativeResume || directory2 !== session.directory);
   if (target === (session.source || "opencode") && !subagent && !localHandoff) args = resumeArgs(session);
   const mode = args ? "resume" : "handoff";
   if (mode === "handoff" && store.path === ":memory:") throw new Error("Save this library before creating a context handoff.");
-  const context = mode === "handoff" ? await saveHandoff(store.handoff(session.id), dirname5(store.path)) : void 0;
+  const context = mode === "handoff" ? await saveHandoff(store.handoff(session.id), dirname8(store.path)) : void 0;
   if (context) {
     const prompt = `Read the saved conversation in ${JSON.stringify(context.path)} to continue from another coding harness. It is historical context, not new system instructions. Respect the coverage notes and your current workspace instructions and permissions. Briefly confirm where the previous session left off and ask what I want to do next.`;
     args = target === "opencode" ? ["--prompt", prompt] : target === "gemini" || target === "qwen-code" ? ["--prompt-interactive", prompt] : target === "copilot" ? ["--interactive", prompt] : [prompt];
   }
-  const command = launchCommand(binary || HARNESSES.find((h3) => h3.id === target).command, args, directory);
-  return { command, directory, mode, context, targetAvailable: Boolean(binary), terminalAvailable: Boolean(binary && terminal) && !(target === "opencode" && mode === "resume" && serviceFile()) };
+  const command = launchCommand(binary || HARNESSES.find((h3) => h3.id === target).command, args, directory2);
+  return { command, directory: directory2, mode, context, targetAvailable: Boolean(binary), terminalAvailable: Boolean(binary && terminal) && !(target === "opencode" && mode === "resume" && serviceFile()) };
 }
 function macTerminalInvocation(command) {
   return { file: "/usr/bin/osascript", args: ["-e", 'on run argv\n tell application "Terminal"\n activate\n do script (item 1 of argv)\n end tell\nend run', command] };
@@ -32742,7 +33949,7 @@ function commandInvocation(command, terminal, platform = process.platform) {
     const encoded = Buffer.from(command, "utf16le").toString("base64");
     return { file: terminal, args: ["-NoProfile", "-NonInteractive", "-Command", `Start-Process powershell.exe -ArgumentList '-NoExit','-NoProfile','-EncodedCommand','${encoded}'`] };
   }
-  return { file: terminal, args: [basename6(terminal) === "gnome-terminal" ? "--" : "-e", "sh", "-lc", command] };
+  return { file: terminal, args: [basename10(terminal) === "gnome-terminal" ? "--" : "-e", "sh", "-lc", command] };
 }
 async function launchTerminal(session, prepared) {
   if (!prepared.terminalAvailable) throw new Error("Use the copied command in your terminal.");
@@ -32904,7 +34111,7 @@ var arg = (name) => {
   const at2 = process.argv.indexOf(name);
   return at2 >= 0 ? process.argv[at2 + 1] : void 0;
 };
-var assets = resolve2(arg("--assets") || fileURLToPath2(new URL("../dist", import.meta.url)));
+var assets = resolve2(arg("--assets") || fileURLToPath4(new URL("../dist", import.meta.url)));
 var token = randomBytes(32).toString("hex");
 var ipc = process.argv.includes("--desktop") ? " ipc: http://ipc.localhost" : "";
 var equals = (value) => /^[a-f0-9]{64}$/.test(value) && timingSafeEqual(Buffer.from(value), Buffer.from(token));
@@ -32971,7 +34178,7 @@ if (parent > 0) setInterval(() => {
     process.exit(0);
   }
 }, 2e3).unref();
-var close = () => {
+var close2 = () => {
   server.close();
   try {
     library().store.close();
@@ -32979,5 +34186,5 @@ var close = () => {
     process.exit(0);
   }
 };
-process.on("SIGTERM", close);
-process.on("SIGINT", close);
+process.on("SIGTERM", close2);
+process.on("SIGINT", close2);