@agentproto/runtime 0.6.0 → 0.7.0

package/dist/resume-strategies.mjs

@@ -1,66 +1,892 @@
-import { promises } from 'fs';
+import { createReadStream, promises } from 'fs';
 import { homedir } from 'os';
-import { resolve, join } from 'path';
+import { join, resolve } from 'path';
+import { createInterface } from 'readline';
 
 /**
  * @agentproto/runtime v0.1.0-alpha
  * Long-running gateway: MCP server + HTTP transport + HEARTBEAT autonomy + conversation persistence over a workspace dir.
  */
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-var RESUME_STRATEGIES = {
-  "claude-code": {
-    // Printed by claude on graceful exit when session persistence
-    // is on (default). Example: `claude --resume 0e483f81-1a44-4bec-9667-b37158450296`
-    outputHint: /claude\s+--resume\s+([0-9a-f-]{8,})/i,
-    storeAs: "claudeResumeId",
-    fsProbe: probeMtimeLatestJsonl(".claude/projects"),
-    spawnArgs: (id) => ["claude", "--resume", id]
+// src/tool-presenter.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function truncate(value, max) {
+  const oneLine = value.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? `${oneLine.slice(0, max - 1)}\u2026` : oneLine;
+}
+function formatArgValue(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return `${value.length} item${value.length === 1 ? "" : "s"}`;
+  if (isRecord(value)) return JSON.stringify(value);
+  return String(value);
+}
+function pickSalientArg(args) {
+  for (const key of SALIENT_ARG_KEYS) {
+    const value = args[key];
+    if (value !== void 0 && value !== null && value !== "") {
+      return formatArgValue(value);
+    }
   }
-  // Stubs for other shipped adapters — fill in as we learn each
-  // provider's resume mechanism. Today they fall back to ACP-level
-  // resume (whatever the agent-cli runtime supports) or fresh spawn.
-  //
-  //   hermes: { storeAs: "hermesResumeId", ... }
-  //   codex: { storeAs: "codexResumeId", ... }
-  //   openclaw: { storeAs: "openClawResumeId", ... }
-  //   opencode: { storeAs: "openCodeResumeId", ... }
-};
-function probeMtimeLatestJsonl(storeRel) {
-  return async (cwd, prevStartedAt, expectedId) => {
-    const encoded = cwd.replace(/\//g, "-");
-    const dir = resolve(homedir(), storeRel, encoded);
-    if (expectedId) {
+  return null;
+}
+function subagentSummary(args) {
+  const description = typeof args.description === "string" ? args.description : typeof args.prompt === "string" ? args.prompt : "subagent";
+  return `\u21B3 subagent: ${truncate(description, MAX_CALL_LENGTH)}`;
+}
+function formatToolCall(toolName, args) {
+  const name = toolName || "tool";
+  const argsRecord = isRecord(args) ? args : {};
+  const bespoke = BESPOKE_TOOLS[name.toLowerCase()];
+  if (bespoke) return bespoke(argsRecord);
+  const salient = pickSalientArg(argsRecord);
+  if (salient !== null) {
+    if (name.toLowerCase().includes(salient.toLowerCase())) {
+      return truncate(name, MAX_CALL_LENGTH);
+    }
+    return truncate(`${name} ${salient}`, MAX_CALL_LENGTH);
+  }
+  if (Object.keys(argsRecord).length === 0) return name;
+  return truncate(`${name} ${JSON.stringify(args)}`, MAX_CALL_LENGTH);
+}
+var SALIENT_ARG_KEYS, MAX_CALL_LENGTH, BESPOKE_TOOLS;
+var init_tool_presenter = __esm({
+  "src/tool-presenter.ts"() {
+    SALIENT_ARG_KEYS = [
+      "file_path",
+      "path",
+      "filePath",
+      "file",
+      "command",
+      "pattern",
+      "query",
+      "q",
+      "url",
+      "todos",
+      "description",
+      "prompt"
+    ];
+    MAX_CALL_LENGTH = 120;
+    BESPOKE_TOOLS = {
+      schedulewakeup: (args) => {
+        const delay = args.delaySeconds ?? args.delay ?? "?";
+        const reason = typeof args.reason === "string" ? args.reason : "";
+        return reason ? `\u23F0 wake in ${delay}s \u2014 ${reason}` : `\u23F0 wake in ${delay}s`;
+      },
+      task: subagentSummary,
+      agent: subagentSummary,
+      todowrite: (args) => {
+        const todos = Array.isArray(args.todos) ? args.todos : [];
+        return `\u2611 todos (${todos.length})`;
+      },
+      exitplanmode: () => "\u{1F4CB} plan ready"
+    };
+  }
+});
+function sessionTranscriptDir(sessionId, baseDir) {
+  return join(join(homedir(), ".agentproto", "sessions"), sessionId);
+}
+function sessionEventsPath(sessionId, baseDir) {
+  return join(sessionTranscriptDir(sessionId), "events.jsonl");
+}
+var init_transcript_writer = __esm({
+  "src/transcript-writer.ts"() {
+  }
+});
+
+// src/transcript-export.ts
+var transcript_export_exports = {};
+__export(transcript_export_exports, {
+  crossValidateHermesExport: () => crossValidateHermesExport,
+  discoverHermesSessions: () => discoverHermesSessions,
+  exportAgentSession: () => exportAgentSession,
+  exportClaudeCodeSession: () => exportClaudeCodeSession,
+  exportHermesSession: () => exportHermesSession,
+  renderJson: () => renderJson,
+  renderMarkdown: () => renderMarkdown
+});
+function trunc(text, n) {
+  if (text.length <= n) return text;
+  return text.slice(0, n) + `
+\u2026 [${text.length - n} chars truncated]`;
+}
+function renderMarkdown(session, opts = {}) {
+  const { meta, messages } = session;
+  const maxToolChars = opts.maxToolChars ?? 1200;
+  const out = [];
+  out.push(`# ${meta.title ?? "(untitled)"}`);
+  out.push("");
+  const sourceNote = meta.source ? ` \xB7 source \`${meta.source}\`` : "";
+  out.push(`> Session${sourceNote}`);
+  out.push("");
+  out.push("| | |");
+  out.push("|---|---|");
+  if (meta.model) out.push(`| Model | \`${meta.model}\` |`);
+  if (meta.startedAt || meta.endedAt) {
+    out.push(`| Start \u2192 end | ${meta.startedAt ?? "?"} \u2192 ${meta.endedAt ?? "?"} |`);
+  }
+  if (meta.messageCount !== void 0 || meta.toolCallCount !== void 0) {
+    const parts = [];
+    if (meta.messageCount !== void 0) parts.push(`${meta.messageCount} messages`);
+    if (meta.toolCallCount !== void 0) parts.push(`${meta.toolCallCount} tool calls`);
+    out.push(`| Count | ${parts.join(" \xB7 ")} |`);
+  }
+  if (meta.tokens && Object.keys(meta.tokens).length) {
+    const t = meta.tokens;
+    const parts = [];
+    if (t.input !== void 0) parts.push(`in ${t.input.toLocaleString("en-US")}`);
+    if (t.output !== void 0) parts.push(`out ${t.output.toLocaleString("en-US")}`);
+    if (t.cacheRead !== void 0 || t.cacheWrite !== void 0) {
+      parts.push(
+        `cache r/w ${(t.cacheRead ?? 0).toLocaleString("en-US")}/${(t.cacheWrite ?? 0).toLocaleString("en-US")}`
+      );
+    }
+    if (t.reasoning !== void 0) parts.push(`reason. ${t.reasoning.toLocaleString("en-US")}`);
+    if (parts.length) out.push(`| Tokens | ${parts.join(" \xB7 ")} |`);
+  }
+  if (meta.costUsd !== void 0) {
+    out.push(`| Cost | $${meta.costUsd.toFixed(4)} |`);
+  }
+  out.push("");
+  out.push("---");
+  out.push("");
+  for (const m of messages) {
+    const icon = ROLE_ICON[m.role] ?? m.role;
+    const nameSuffix = m.toolName ? ` \xB7 \`${m.toolName}\`` : "";
+    out.push(`### ${icon}${nameSuffix}`);
+    if (m.reasoning?.trim()) {
+      out.push("");
+      out.push("<details><summary>\u{1F4AD} reasoning</summary>");
+      out.push("");
+      out.push(trunc(m.reasoning, 4e3));
+      out.push("");
+      out.push("</details>");
+    }
+    if (m.text?.trim()) {
+      out.push("");
+      if (m.role === "tool") {
+        out.push("```");
+        out.push(trunc(m.text, maxToolChars));
+        out.push("```");
+      } else {
+        out.push(m.text.trim());
+      }
+    }
+    if (m.toolCalls?.length) {
+      out.push("");
+      for (const tc of m.toolCalls) {
+        let parsedArgs;
+        try {
+          parsedArgs = JSON.parse(tc.args);
+        } catch {
+          parsedArgs = tc.args;
+        }
+        out.push(`> \u{1F4DE} ${formatToolCall(tc.name, parsedArgs)}`);
+      }
+    }
+    out.push("");
+  }
+  return out.join("\n");
+}
+function renderJson(session) {
+  return JSON.stringify(session, null, 2);
+}
+async function exportClaudeCodeSession(adapterSessionId, cwd) {
+  if (!cwd) {
+    throw new Error(
+      "claude-code exporter: cwd is required to locate the JSONL file.\nPass cwd explicitly or use a session id that is in the registry."
+    );
+  }
+  const encoded = cwd.replace(/\//g, "-");
+  const filePath = join(homedir(), ".claude", "projects", encoded, `${adapterSessionId}.jsonl`);
+  let stream;
+  try {
+    stream = createReadStream(filePath, { encoding: "utf8" });
+    await new Promise((resolve2, reject) => {
+      stream.once("error", reject);
+      stream.once("open", resolve2);
+    });
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(
+        `claude-code: JSONL file not found: ${filePath}
+Verify cwd="${cwd}" and adapterSessionId="${adapterSessionId}".`
+      );
+    }
+    throw err;
+  }
+  const messages = [];
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (IGNORED_CLAUDE_TYPES.has(entry.type)) continue;
+    if (entry.type !== "user" && entry.type !== "assistant") continue;
+    const msg = entry.message;
+    if (!msg) continue;
+    const role = msg.role === "assistant" ? "assistant" : "user";
+    const content = msg.content;
+    if (typeof content === "string") {
+      if (content.trim()) messages.push({ role, text: content.trim() });
+      continue;
+    }
+    if (!Array.isArray(content)) continue;
+    let textAcc = "";
+    let reasoningAcc = "";
+    const toolCalls = [];
+    const toolResults = [];
+    for (const block of content) {
+      switch (block.type) {
+        case "text": {
+          textAcc += block.text;
+          break;
+        }
+        case "thinking": {
+          reasoningAcc += block.thinking;
+          break;
+        }
+        case "tool_use": {
+          const tb = block;
+          const args = typeof tb.input === "string" ? tb.input : JSON.stringify(tb.input ?? {});
+          toolCalls.push({ name: tb.name, args });
+          break;
+        }
+        case "tool_result": {
+          const tb = block;
+          let resultText = "";
+          if (typeof tb.content === "string") {
+            resultText = tb.content;
+          } else if (Array.isArray(tb.content)) {
+            for (const c of tb.content) {
+              if (c.type === "text") resultText += c.text;
+            }
+          }
+          toolResults.push({ text: resultText });
+          break;
+        }
+      }
+    }
+    if (textAcc.trim() || toolCalls.length || reasoningAcc) {
+      const m = { role };
+      if (textAcc.trim()) m.text = textAcc.trim();
+      if (reasoningAcc) m.reasoning = reasoningAcc;
+      if (toolCalls.length) m.toolCalls = toolCalls;
+      messages.push(m);
+    }
+    for (const tr of toolResults) {
+      messages.push({ role: "tool", text: tr.text });
+    }
+  }
+  return { meta: { source: "claude-code" }, messages };
+}
+async function openHermesDb(dbPath) {
+  let DatabaseSync;
+  try {
+    const sqlite = await import('sqlite');
+    DatabaseSync = sqlite.DatabaseSync;
+  } catch {
+    throw new Error("hermes: node:sqlite unavailable. Requires Node.js \u226522.5.0.");
+  }
+  try {
+    return new DatabaseSync(dbPath, { readOnly: true });
+  } catch (err) {
+    const msg = String(err);
+    if (err.code === "ENOENT" || msg.includes("unable to open database file")) {
+      throw new Error(
+        `hermes: state.db not found at ${dbPath}. Has hermes been run at least once?`
+      );
+    }
+    if (msg.includes("SQLITE_BUSY") || msg.includes("database is locked")) {
+      throw new Error(
+        `hermes: database is locked (SQLITE_BUSY). Hermes may be writing. Try again in a moment.`
+      );
+    }
+    throw err;
+  }
+}
+function withRetryOnBusy(fn) {
+  try {
+    return fn();
+  } catch (err) {
+    const msg = String(err);
+    if (msg.includes("SQLITE_BUSY") || msg.includes("database is locked")) {
+      try {
+        return fn();
+      } catch {
+        throw new Error(
+          `hermes: database is locked. Hermes may be actively writing. Try again.`
+        );
+      }
+    }
+    throw err;
+  }
+}
+async function exportHermesSession(adapterSessionId) {
+  const dbPath = join(homedir(), ".hermes", "state.db");
+  const db = await openHermesDb(dbPath);
+  const session = withRetryOnBusy(
+    () => db.prepare("SELECT * FROM sessions WHERE id = ?").get(adapterSessionId)
+  );
+  if (!session) {
+    db.close();
+    throw new Error(
+      `hermes: session "${adapterSessionId}" not found in ${dbPath}. ACP sessions are indexed by the agentproto UUID passed as resumeSessionId.`
+    );
+  }
+  const rows = withRetryOnBusy(
+    () => db.prepare(
+      "SELECT * FROM messages WHERE session_id = ? ORDER BY id ASC"
+    ).all(adapterSessionId)
+  );
+  db.close();
+  const cost = session.actual_cost_usd != null ? session.actual_cost_usd : session.estimated_cost_usd;
+  const startedAt = session.started_at ? new Date(session.started_at * 1e3).toISOString().replace("T", " ").slice(0, 19) : void 0;
+  const endedAt = session.ended_at ? new Date(session.ended_at * 1e3).toISOString().replace("T", " ").slice(0, 19) : void 0;
+  const meta = {
+    ...session.title ? { title: session.title } : {},
+    ...session.model ? { model: session.model } : {},
+    ...startedAt ? { startedAt } : {},
+    ...endedAt ? { endedAt } : {},
+    ...session.message_count !== void 0 ? { messageCount: session.message_count } : {},
+    ...session.tool_call_count !== void 0 ? { toolCallCount: session.tool_call_count } : {},
+    ...cost != null ? { costUsd: Number(cost) } : {},
+    ...session.source ? { source: session.source } : {}
+  };
+  const tokensInput = session.input_tokens;
+  const tokensOutput = session.output_tokens;
+  const tokensCacheRead = session.cache_read_tokens;
+  const tokensCacheWrite = session.cache_write_tokens;
+  const tokensReasoning = session.reasoning_tokens;
+  if (tokensInput !== void 0 || tokensOutput !== void 0 || tokensCacheRead !== void 0 || tokensCacheWrite !== void 0 || tokensReasoning !== void 0) {
+    meta.tokens = {
+      ...tokensInput !== void 0 ? { input: tokensInput } : {},
+      ...tokensOutput !== void 0 ? { output: tokensOutput } : {},
+      ...tokensCacheRead !== void 0 ? { cacheRead: tokensCacheRead } : {},
+      ...tokensCacheWrite !== void 0 ? { cacheWrite: tokensCacheWrite } : {},
+      ...tokensReasoning !== void 0 ? { reasoning: tokensReasoning } : {}
+    };
+  }
+  const messages = rows.map((row) => {
+    const validRoles = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system"]);
+    const role = validRoles.has(row.role) ? row.role : "user";
+    const reasoning = row.reasoning ?? row.reasoning_content;
+    let toolCalls;
+    if (row.tool_calls) {
       try {
-        await promises.stat(join(dir, `${expectedId}.jsonl`));
-        return expectedId;
+        const tc = JSON.parse(row.tool_calls);
+        if (Array.isArray(tc) && tc.length) {
+          toolCalls = tc.map((c) => {
+            const entry = c;
+            const fn = entry.function != null ? entry.function : entry;
+            const name = String(fn.name ?? entry.name ?? "tool");
+            const args = typeof fn.arguments === "string" ? fn.arguments : JSON.stringify(fn.arguments ?? {});
+            return { name, args };
+          });
+        }
       } catch {
-        return null;
       }
     }
-    let entries;
+    const m = { role };
+    if (row.content?.trim()) m.text = row.content.trim();
+    if (reasoning && String(reasoning).trim()) m.reasoning = String(reasoning);
+    if (row.tool_name) m.toolName = row.tool_name;
+    if (toolCalls) m.toolCalls = toolCalls;
+    if (row.timestamp) m.ts = row.timestamp;
+    return m;
+  });
+  void crossValidateHermesExport(adapterSessionId, messages.length).catch(() => {
+  });
+  return { meta, messages };
+}
+function hermesRowToCandidate(row) {
+  const startedAtIso = row.started_at !== void 0 ? new Date(row.started_at * 1e3).toISOString() : void 0;
+  const lastActivitySec = row.ended_at ?? row.started_at;
+  const lastActivityIso = lastActivitySec !== void 0 ? new Date(lastActivitySec * 1e3).toISOString() : void 0;
+  return {
+    conversationId: row.id,
+    ...startedAtIso ? { startedAt: startedAtIso } : {},
+    ...lastActivityIso ? { lastActivityAt: lastActivityIso } : {},
+    ...row.message_count !== void 0 ? { messageCount: row.message_count } : {},
+    ...row.title ? { preview: row.title } : {},
+    ...row.source ? { lastWriter: row.source } : {}
+  };
+}
+async function discoverHermesSessions(cwd, since, expectedId) {
+  const dbPath = join(homedir(), ".hermes", "state.db");
+  let db;
+  try {
+    db = await openHermesDb(dbPath);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("state.db not found")) return [];
+    throw err;
+  }
+  try {
+    if (expectedId) {
+      const row = withRetryOnBusy(
+        () => db.prepare("SELECT * FROM sessions WHERE id = ?").get(expectedId)
+      );
+      return row ? [hermesRowToCandidate(row)] : [];
+    }
+    const rows = withRetryOnBusy(
+      () => db.prepare("SELECT * FROM sessions WHERE cwd = ?").all(cwd)
+    );
+    const sinceMs = since ? Date.parse(since) : NaN;
+    return rows.filter((row) => {
+      if (!Number.isFinite(sinceMs)) return true;
+      const lastActivitySec = row.ended_at ?? row.started_at;
+      if (lastActivitySec === void 0) return true;
+      return lastActivitySec * 1e3 >= sinceMs - 1e3;
+    }).map(hermesRowToCandidate);
+  } finally {
+    db.close();
+  }
+}
+async function defaultHermesRunner(adapterSessionId) {
+  const { spawn } = await import('child_process');
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    const errChunks = [];
+    const proc = spawn(
+      "hermes",
+      ["sessions", "export", "--session-id", adapterSessionId, "-"],
+      { stdio: ["ignore", "pipe", "pipe"] }
+    );
+    proc.stdout.on("data", (chunk) => chunks.push(chunk));
+    proc.stderr.on("data", (chunk) => errChunks.push(chunk));
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(
+          new Error(
+            `hermes exited with code ${code}: ${Buffer.concat(errChunks).toString()}`
+          )
+        );
+      } else {
+        resolve2(Buffer.concat(chunks).toString("utf8"));
+      }
+    });
+  });
+}
+async function crossValidateHermesExport(adapterSessionId, sqliteCount, _runner = defaultHermesRunner) {
+  let stdout;
+  try {
+    stdout = await _runner(adapterSessionId);
+  } catch (err) {
+    const msg = String(err);
+    if (err.code === "ENOENT" || msg.includes("ENOENT") || msg.includes("not found")) {
+      return { sqliteCount, binaryCount: -1, matched: true, binaryUnavailable: true };
+    }
+    return null;
+  }
+  const binaryCount = stdout.split("\n").filter((l) => l.trim()).filter((l) => {
+    try {
+      const obj = JSON.parse(l);
+      return typeof obj.role === "string";
+    } catch {
+      return false;
+    }
+  }).length;
+  const matched = binaryCount === sqliteCount;
+  if (!matched) {
+    console.warn(
+      `[hermes export] cross-validation mismatch for session ${adapterSessionId}: SQLite=${sqliteCount} messages, binary=${binaryCount} messages. The state.db schema may have changed \u2014 check the SQLite reader in transcript-export.ts.`
+    );
+  }
+  return { sqliteCount, binaryCount, matched };
+}
+async function exportDaemonEventsSession(sessionId, desc) {
+  const filePath = sessionEventsPath(sessionId);
+  let stream;
+  try {
+    stream = createReadStream(filePath, { encoding: "utf8" });
+    await new Promise((resolve2, reject) => {
+      stream.once("error", reject);
+      stream.once("open", resolve2);
+    });
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      throw new Error(
+        `daemon-events: no events.jsonl for session "${sessionId}" (${filePath}).
+Either the session never drove an agent-cli turn, or it predates this feature.`
+      );
+    }
+    throw err;
+  }
+  const messages = [];
+  const toolNameById = /* @__PURE__ */ new Map();
+  let toolCallCount = 0;
+  let lastUsage;
+  let asmText = "";
+  let asmReasoning = "";
+  let asmToolCalls = [];
+  let asmTs;
+  const flushAssistant = () => {
+    if (!asmText.trim() && !asmReasoning.trim() && asmToolCalls.length === 0) return;
+    const m = { role: "assistant" };
+    if (asmText.trim()) m.text = asmText.trim();
+    if (asmReasoning.trim()) m.reasoning = asmReasoning.trim();
+    if (asmToolCalls.length) m.toolCalls = asmToolCalls;
+    if (asmTs !== void 0) m.ts = asmTs;
+    messages.push(m);
+    asmText = "";
+    asmReasoning = "";
+    asmToolCalls = [];
+    asmTs = void 0;
+  };
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let rec;
     try {
-      entries = await promises.readdir(dir);
+      rec = JSON.parse(trimmed);
     } catch {
-      return null;
+      continue;
+    }
+    const ts = Date.parse(rec.ts);
+    const tsOrUndefined = Number.isNaN(ts) ? void 0 : ts;
+    switch (rec.kind) {
+      case "user-prompt":
+        flushAssistant();
+        messages.push({ role: "user", text: rec.text ?? "", ...tsOrUndefined !== void 0 ? { ts: tsOrUndefined } : {} });
+        break;
+      case "text-delta":
+        if (asmTs === void 0) asmTs = tsOrUndefined;
+        asmText += rec.text ?? "";
+        break;
+      case "thought":
+        if (asmTs === void 0) asmTs = tsOrUndefined;
+        asmReasoning += rec.text ?? "";
+        break;
+      case "tool-call": {
+        if (asmTs === void 0) asmTs = tsOrUndefined;
+        const name = rec.toolName ?? "tool";
+        if (rec.toolCallId) toolNameById.set(rec.toolCallId, name);
+        const args = typeof rec.arguments === "string" ? rec.arguments : JSON.stringify(rec.arguments ?? {});
+        asmToolCalls.push({ name, args });
+        toolCallCount += 1;
+        break;
+      }
+      case "tool-result": {
+        flushAssistant();
+        const name = rec.toolCallId ? toolNameById.get(rec.toolCallId) : void 0;
+        const text = typeof rec.result === "string" ? rec.result : JSON.stringify(rec.result ?? "");
+        messages.push({
+          role: "tool",
+          text: rec.isError ? `[error] ${text}` : text,
+          ...name ? { toolName: name } : {},
+          ...tsOrUndefined !== void 0 ? { ts: tsOrUndefined } : {}
+        });
+        break;
+      }
+      case "agent-prompt":
+        flushAssistant();
+        messages.push({ role: "system", text: "[awaiting input] agent requested a decision" });
+        break;
+      case "plan": {
+        flushAssistant();
+        const entries = rec.entries ?? [];
+        const done = entries.filter((e) => e.status === "completed").length;
+        const list = entries.map((e) => e.content).join("; ");
+        messages.push({ role: "system", text: `[plan] ${done}/${entries.length} ${list}`.trim() });
+        break;
+      }
+      case "usage_update":
+        lastUsage = { size: rec.size, used: rec.used, cost: rec.cost };
+        break;
+      case "error":
+        flushAssistant();
+        messages.push({ role: "system", text: `[error] ${rec.error?.message ?? "unknown"}` });
+        break;
+      case "turn-end":
+        flushAssistant();
+        break;
     }
-    const jsonl = entries.filter((e) => e.endsWith(".jsonl"));
-    if (jsonl.length === 0) return null;
-    const startedAtMs = Date.parse(prevStartedAt);
-    const candidates = [];
-    for (const f of jsonl) {
+  }
+  flushAssistant();
+  const meta = { source: "daemon-events" };
+  if (desc?.label) meta.title = desc.label;
+  if (desc?.model) meta.model = desc.model;
+  if (desc?.startedAt) meta.startedAt = desc.startedAt;
+  if (desc?.endedAt) meta.endedAt = desc.endedAt;
+  meta.messageCount = messages.length;
+  meta.toolCallCount = toolCallCount;
+  if (desc?.costUsd !== void 0) meta.costUsd = desc.costUsd;
+  else if (lastUsage?.cost) meta.costUsd = lastUsage.cost.amount;
+  if (desc?.tokensIn !== void 0 || desc?.tokensOut !== void 0) {
+    meta.tokens = {
+      ...desc?.tokensIn !== void 0 ? { input: desc.tokensIn } : {},
+      ...desc?.tokensOut !== void 0 ? { output: desc.tokensOut } : {}
+    };
+  }
+  return { meta, messages };
+}
+async function exportAgentSession(input) {
+  const { sessionId, registry, format = "markdown", maxToolChars = 1200 } = input;
+  const source = input.source ?? "auto";
+  let adapterSlug = input.adapter;
+  let cwd = input.cwd;
+  let adapterSessionId = sessionId;
+  const err = (msg) => ({
+    sessionId,
+    adapter: adapterSlug ?? "unknown",
+    format,
+    meta: {},
+    content: `Error: ${msg}`
+  });
+  const desc = registry.findByIdOrName(sessionId);
+  const daemonSessionId = desc?.id ?? sessionId;
+  if (desc) {
+    adapterSlug = adapterSlug ?? desc.adapterSlug;
+    cwd = cwd ?? desc.cwd;
+    if (desc.adapterSessionId) adapterSessionId = desc.adapterSessionId;
+  }
+  const tryNative = async () => {
+    if (!adapterSlug) {
+      throw new Error(
+        `session "${sessionId}" not found in registry and no adapter override supplied.
+Pass adapter explicitly or use a known session id (sess_xxx or name).`
+      );
+    }
+    const exporter = EXPORT_STRATEGIES[adapterSlug];
+    if (!exporter) {
+      const supported = Object.keys(EXPORT_STRATEGIES).join(", ");
+      throw new Error(
+        `no exporter for adapter "${adapterSlug}". Supported: ${supported}.
+Only sessions spawned via claude-code or hermes can be exported.`
+      );
+    }
+    return exporter.exportSession(adapterSessionId, cwd);
+  };
+  const tryDaemon = () => exportDaemonEventsSession(daemonSessionId, desc);
+  let session;
+  try {
+    if (source === "native") {
+      session = await tryNative();
+    } else if (source === "daemon") {
+      session = await tryDaemon();
+    } else {
       try {
-        const st = await promises.stat(join(dir, f));
-        if (!Number.isFinite(startedAtMs) || st.mtimeMs >= startedAtMs - 1e3) {
-          candidates.push({ name: f, mtime: st.mtimeMs });
+        session = await tryNative();
+      } catch (nativeErr) {
+        try {
+          session = await tryDaemon();
+        } catch (daemonErr) {
+          const nativeMsg = nativeErr instanceof Error ? nativeErr.message : String(nativeErr);
+          const daemonMsg = daemonErr instanceof Error ? daemonErr.message : String(daemonErr);
+          return err(`${nativeMsg}
+(daemon-events fallback also failed: ${daemonMsg})`);
         }
-      } catch {
       }
     }
-    if (candidates.length === 0) return null;
-    candidates.sort((a, b) => b.mtime - a.mtime);
-    return candidates[0].name.replace(/\.jsonl$/, "");
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+  const content = format === "json" ? renderJson(session) : renderMarkdown(session, { maxToolChars });
+  return {
+    sessionId,
+    adapter: adapterSlug ?? (session.meta.source === "daemon-events" ? "daemon" : "unknown"),
+    format,
+    meta: session.meta,
+    content
   };
 }
+var ROLE_ICON, IGNORED_CLAUDE_TYPES, EXPORT_STRATEGIES;
+var init_transcript_export = __esm({
+  "src/transcript-export.ts"() {
+    init_tool_presenter();
+    init_transcript_writer();
+    ROLE_ICON = {
+      user: "\u{1F9D1} User",
+      assistant: "\u{1F916} Assistant",
+      tool: "\u{1F527} Tool",
+      system: "\u2699\uFE0F System"
+    };
+    IGNORED_CLAUDE_TYPES = /* @__PURE__ */ new Set([
+      "queue-operation",
+      "attachment",
+      "file-history-snapshot",
+      "ai-title",
+      "last-prompt"
+    ]);
+    EXPORT_STRATEGIES = {
+      "claude-code": {
+        exportSession: exportClaudeCodeSession
+      },
+      hermes: {
+        exportSession: (id) => exportHermesSession(id)
+      }
+    };
+  }
+});
+function claudeCodeProjectDir(cwd) {
+  const encoded = cwd.replace(/\//g, "-");
+  return resolve(homedir(), ".claude", "projects", encoded);
+}
+function extractFirstText(content) {
+  if (typeof content === "string") {
+    const t = content.trim();
+    return t || void 0;
+  }
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block && typeof block === "object" && block.type === "text" && typeof block.text === "string") {
+        const t = block.text.trim();
+        if (t) return t;
+      }
+    }
+  }
+  return void 0;
+}
+async function scanClaudeJsonl(filePath) {
+  const stream = createReadStream(filePath, { encoding: "utf8" });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  let startedAt;
+  let lastActivityAt;
+  let messageCount = 0;
+  let preview;
+  let lastWriter;
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (typeof entry.timestamp === "string") {
+      if (!startedAt) startedAt = entry.timestamp;
+      lastActivityAt = entry.timestamp;
+    }
+    if (typeof entry.entrypoint === "string") {
+      lastWriter = entry.entrypoint;
+    }
+    if (entry.type === "user" || entry.type === "assistant") {
+      messageCount += 1;
+      if (preview === void 0 && entry.type === "user") {
+        const text = extractFirstText(entry.message?.content);
+        if (text !== void 0) {
+          preview = text.length > 120 ? text.slice(0, 120) : text;
+        }
+      }
+    }
+  }
+  return { startedAt, lastActivityAt, messageCount, preview, lastWriter };
+}
+async function buildClaudeCandidate(filePath, conversationId) {
+  const scanned = await scanClaudeJsonl(filePath);
+  return { conversationId, ...scanned };
+}
+function claudeEntrypointFor(mode) {
+  return mode === "native" ? "cli" : "sdk-ts";
+}
+async function discoverClaudeCode(input) {
+  const { cwd, since, until, attachmentMode, expectedId } = input;
+  const dir = claudeCodeProjectDir(cwd);
+  if (expectedId) {
+    const filePath = join(dir, `${expectedId}.jsonl`);
+    try {
+      await promises.stat(filePath);
+    } catch {
+      return [];
+    }
+    return [await buildClaudeCandidate(filePath, expectedId)];
+  }
+  let entries;
+  try {
+    entries = await promises.readdir(dir);
+  } catch {
+    return [];
+  }
+  const jsonlFiles = entries.filter((e) => e.endsWith(".jsonl"));
+  if (jsonlFiles.length === 0) return [];
+  const sinceMs = since ? Date.parse(since) : NaN;
+  const untilMs = until ? Date.parse(until) : NaN;
+  const wantEntrypoint = attachmentMode ? claudeEntrypointFor(attachmentMode) : void 0;
+  const scored = [];
+  for (const f of jsonlFiles) {
+    const filePath = join(dir, f);
+    let mtimeMs;
+    try {
+      mtimeMs = (await promises.stat(filePath)).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (Number.isFinite(sinceMs) && mtimeMs < sinceMs - 1e3) continue;
+    const conversationId = f.replace(/\.jsonl$/, "");
+    const candidate = await buildClaudeCandidate(filePath, conversationId);
+    if (Number.isFinite(untilMs) && candidate.startedAt !== void 0) {
+      const startedMs = Date.parse(candidate.startedAt);
+      if (Number.isFinite(startedMs) && startedMs > untilMs) continue;
+    }
+    if (wantEntrypoint !== void 0 && candidate.lastWriter !== void 0 && candidate.lastWriter !== wantEntrypoint) {
+      continue;
+    }
+    scored.push({ candidate, mtimeMs });
+  }
+  scored.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return scored.map((s) => s.candidate);
+}
+async function readClaudeCode(conversationId, cwd) {
+  const { exportClaudeCodeSession: exportClaudeCodeSession2 } = await Promise.resolve().then(() => (init_transcript_export(), transcript_export_exports));
+  return exportClaudeCodeSession2(conversationId, cwd);
+}
+var CONVERSATION_STORES = {
+  "claude-code": {
+    storeAs: "claudeResumeId",
+    // Printed by claude on graceful exit when session persistence is on
+    // (default). Example: `claude --resume 0e483f81-1a44-4bec-9667-b37158450296`
+    outputHint: /claude\s+--resume\s+([0-9a-f-]{8,})/i,
+    attachArgv: (conversationId) => ["claude", "--resume", conversationId],
+    discover: discoverClaudeCode,
+    read: readClaudeCode
+  }};
+
+// src/resume-strategies.ts
+var claudeCodeStore = CONVERSATION_STORES["claude-code"];
+var RESUME_STRATEGIES = {
+  "claude-code": {
+    outputHint: claudeCodeStore.outputHint,
+    storeAs: claudeCodeStore.storeAs,
+    fsProbe: async (cwd, prevStartedAt, expectedId) => {
+      const candidates = await claudeCodeStore.discover({
+        cwd,
+        since: prevStartedAt,
+        expectedId
+      });
+      return candidates[0]?.conversationId ?? null;
+    },
+    spawnArgs: claudeCodeStore.attachArgv
+  }
+  // Stubs for other shipped adapters — fill in as we learn each
+  // provider's resume mechanism. Today they fall back to ACP-level
+  // resume (whatever the agent-cli runtime supports) or fresh spawn.
+  //
+  //   hermes: { storeAs: "hermesResumeId", ... }
+  //   codex: { storeAs: "codexResumeId", ... }
+  //   openclaw: { storeAs: "openClawResumeId", ... }
+  //   opencode: { storeAs: "openCodeResumeId", ... }
+};
 function hasResumeStrategy(adapterSlug) {
   if (!adapterSlug) return false;
   const s = RESUME_STRATEGIES[adapterSlug];