@agentproto/runtime 1.1.0 → 2.0.0

package/dist/resume-strategies.mjs

@@ -93,6 +93,12 @@ var init_tool_presenter = __esm({
     };
   }
 });
+
+// src/tool-call-record.ts
+var init_tool_call_record = __esm({
+  "src/tool-call-record.ts"() {
+  }
+});
 function sessionTranscriptDir(sessionId, baseDir) {
   return join(join(homedir(), ".agentproto", "sessions"), sessionId);
 }
@@ -101,6 +107,7 @@ function sessionEventsPath(sessionId, baseDir) {
 }
 var init_transcript_writer = __esm({
   "src/transcript-writer.ts"() {
+    init_tool_call_record();
   }
 });
 
@@ -108,10 +115,19 @@ var init_transcript_writer = __esm({
 var transcript_export_exports = {};
 __export(transcript_export_exports, {
   crossValidateHermesExport: () => crossValidateHermesExport,
+  discoverCodexSessions: () => discoverCodexSessions,
   discoverHermesSessions: () => discoverHermesSessions,
+  discoverMastracodeInprocessSessions: () => discoverMastracodeInprocessSessions,
+  discoverOpenCodeSessions: () => discoverOpenCodeSessions,
+  discoverPiSessions: () => discoverPiSessions,
   exportAgentSession: () => exportAgentSession,
   exportClaudeCodeSession: () => exportClaudeCodeSession,
+  exportCodexSession: () => exportCodexSession,
+  exportDaemonEventsSession: () => exportDaemonEventsSession,
   exportHermesSession: () => exportHermesSession,
+  exportMastracodeInprocessSession: () => exportMastracodeInprocessSession,
+  exportOpenCodeSession: () => exportOpenCodeSession,
+  exportPiSession: () => exportPiSession,
   renderJson: () => renderJson,
   renderMarkdown: () => renderMarkdown
 });
@@ -127,7 +143,9 @@ function renderMarkdown(session, opts = {}) {
   out.push(`# ${meta.title ?? "(untitled)"}`);
   out.push("");
   const sourceNote = meta.source ? ` \xB7 source \`${meta.source}\`` : "";
-  out.push(`> Session${sourceNote}`);
+  const originNote = meta.origin ? ` \xB7 origin \`${meta.origin}\`` : "";
+  const callerNote = meta.callerSessionId ? ` \xB7 caller \`${meta.callerSessionId}\`` : "";
+  out.push(`> Session${sourceNote}${originNote}${callerNote}`);
   out.push("");
   out.push("| | |");
   out.push("|---|---|");
@@ -338,6 +356,27 @@ function withRetryOnBusy(fn) {
     throw err;
   }
 }
+async function openReadonlySqlite(dbPath, label) {
+  let DatabaseSync;
+  try {
+    const sqlite = await import('sqlite');
+    DatabaseSync = sqlite.DatabaseSync;
+  } catch {
+    throw new Error(`${label}: 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(`${label}: database not found at ${dbPath}. Has ${label} been run at least once?`);
+    }
+    if (msg.includes("SQLITE_BUSY") || msg.includes("database is locked")) {
+      throw new Error(`${label}: database is locked (SQLITE_BUSY). It may be writing. Try again in a moment.`);
+    }
+    throw err;
+  }
+}
 async function exportHermesSession(adapterSessionId) {
   const dbPath = join(homedir(), ".hermes", "state.db");
   const db = await openHermesDb(dbPath);
@@ -620,6 +659,10 @@ Either the session never drove an agent-cli turn, or it predates this feature.`
       case "turn-end":
         flushAssistant();
         break;
+      case "notice":
+        flushAssistant();
+        messages.push({ role: "system", text: rec.text ?? "" });
+        break;
     }
   }
   flushAssistant();
@@ -628,6 +671,8 @@ Either the session never drove an agent-cli turn, or it predates this feature.`
   if (desc?.model) meta.model = desc.model;
   if (desc?.startedAt) meta.startedAt = desc.startedAt;
   if (desc?.endedAt) meta.endedAt = desc.endedAt;
+  if (desc?.origin) meta.origin = desc.origin;
+  if (desc?.callerSessionId) meta.callerSessionId = desc.callerSessionId;
   meta.messageCount = messages.length;
   meta.toolCallCount = toolCallCount;
   if (desc?.costUsd !== void 0) meta.costUsd = desc.costUsd;
@@ -640,6 +685,629 @@ Either the session never drove an agent-cli turn, or it predates this feature.`
   }
   return { meta, messages };
 }
+async function readFirstJsonLine(path) {
+  const stream = createReadStream(path, { encoding: "utf8" });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      const t = line.trim();
+      if (t) return t;
+    }
+    return void 0;
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+}
+function codexHome() {
+  return process.env.CODEX_HOME ?? join(homedir(), ".codex");
+}
+function codexSessionsDir() {
+  return join(codexHome(), "sessions");
+}
+async function walkCodexRollouts(dir) {
+  let entries;
+  try {
+    entries = await promises.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const e of entries) {
+    const p = join(dir, e.name);
+    if (e.isDirectory()) {
+      out.push(...await walkCodexRollouts(p));
+    } else if (e.isFile() && e.name.startsWith("rollout-") && e.name.endsWith(".jsonl")) {
+      out.push(p);
+    }
+  }
+  return out;
+}
+function codexBlocksText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let acc = "";
+  for (const c of content) {
+    if (c && typeof c === "object") {
+      const b = c;
+      if (typeof b.text === "string" && (b.type === "input_text" || b.type === "output_text" || b.type === "text")) {
+        acc += b.text;
+      }
+    }
+  }
+  return acc;
+}
+async function findCodexRolloutFile(conversationId) {
+  const files = await walkCodexRollouts(codexSessionsDir());
+  const byName = files.find((f) => f.endsWith(`-${conversationId}.jsonl`));
+  if (byName) return byName;
+  for (const f of files) {
+    const first = await readFirstJsonLine(f);
+    if (!first) continue;
+    let meta;
+    try {
+      meta = JSON.parse(first);
+    } catch {
+      continue;
+    }
+    const p = meta.payload;
+    if (p && (p.id === conversationId || p.session_id === conversationId)) return f;
+  }
+  return void 0;
+}
+async function exportCodexSession(conversationId) {
+  const file = await findCodexRolloutFile(conversationId);
+  if (!file) {
+    throw new Error(
+      `codex: no rollout file for conversation "${conversationId}" under ${codexSessionsDir()}.
+The session may predate persistence, or CODEX_HOME points elsewhere.`
+    );
+  }
+  const stream = createReadStream(file, { encoding: "utf8" });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  const messages = [];
+  const toolNameByCall = /* @__PURE__ */ new Map();
+  let toolCallCount = 0;
+  let startedAt;
+  let model;
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const p = entry.payload ?? {};
+    if (entry.type === "session_meta") {
+      startedAt = p.timestamp ?? entry.timestamp;
+      if (typeof p.model === "string") model = p.model;
+      continue;
+    }
+    if (entry.type === "turn_context") {
+      if (!model && typeof p.model === "string") model = p.model;
+      continue;
+    }
+    if (entry.type !== "response_item") continue;
+    switch (p.type) {
+      case "message": {
+        const text = codexBlocksText(p.content).trim();
+        if (!text) break;
+        const role = p.role === "assistant" ? "assistant" : p.role === "user" ? "user" : "system";
+        messages.push({ role, text });
+        break;
+      }
+      case "reasoning": {
+        const r = (p.summary ?? []).map((s) => s.text ?? "").join("\n").trim();
+        if (r) messages.push({ role: "assistant", reasoning: r });
+        break;
+      }
+      case "function_call":
+      case "custom_tool_call": {
+        const name = p.name ?? "tool";
+        if (typeof p.call_id === "string") toolNameByCall.set(p.call_id, name);
+        const raw = p.type === "custom_tool_call" ? p.input : p.arguments;
+        const args = typeof raw === "string" ? raw : JSON.stringify(raw ?? {});
+        messages.push({ role: "assistant", toolCalls: [{ name, args }] });
+        toolCallCount += 1;
+        break;
+      }
+      case "function_call_output":
+      case "custom_tool_call_output": {
+        const name = typeof p.call_id === "string" ? toolNameByCall.get(p.call_id) : void 0;
+        const out = codexBlocksText(p.output) || (typeof p.output === "string" ? p.output : "");
+        messages.push({ role: "tool", text: out, ...name ? { toolName: name } : {} });
+        break;
+      }
+    }
+  }
+  const meta = { source: "codex" };
+  if (startedAt) meta.startedAt = startedAt;
+  if (model) meta.model = model;
+  meta.messageCount = messages.length;
+  meta.toolCallCount = toolCallCount;
+  return { meta, messages };
+}
+async function discoverCodexSessions(cwd, since, until, expectedId) {
+  const files = await walkCodexRollouts(codexSessionsDir());
+  const sinceMs = since ? Date.parse(since) : NaN;
+  const untilMs = until ? Date.parse(until) : NaN;
+  const scored = [];
+  for (const f of files) {
+    let mtimeMs;
+    try {
+      mtimeMs = (await promises.stat(f)).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (Number.isFinite(sinceMs) && mtimeMs < sinceMs - 1e3) continue;
+    const first = await readFirstJsonLine(f);
+    if (!first) continue;
+    let meta;
+    try {
+      meta = JSON.parse(first);
+    } catch {
+      continue;
+    }
+    if (meta.type !== "session_meta") continue;
+    const p = meta.payload ?? {};
+    const id = p.id ?? p.session_id;
+    if (!id) continue;
+    if (expectedId) {
+      if (id !== expectedId) continue;
+    } else if (p.cwd !== cwd) {
+      continue;
+    }
+    const startedAt = p.timestamp;
+    if (Number.isFinite(untilMs) && startedAt) {
+      const startedMs = Date.parse(startedAt);
+      if (Number.isFinite(startedMs) && startedMs > untilMs) continue;
+    }
+    scored.push({
+      candidate: {
+        conversationId: id,
+        ...startedAt ? { startedAt } : {},
+        lastActivityAt: new Date(mtimeMs).toISOString()
+      },
+      mtimeMs
+    });
+  }
+  scored.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return scored.map((s) => s.candidate);
+}
+function openCodeDbPath() {
+  const dataHome = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+  return join(dataHome, "opencode", "opencode.db");
+}
+function openCodeModelLabel(raw) {
+  if (!raw) return void 0;
+  try {
+    const m = JSON.parse(raw);
+    const id = m.modelID ?? m.id;
+    if (!id) return void 0;
+    return m.providerID ? `${m.providerID}/${id}` : id;
+  } catch {
+    return void 0;
+  }
+}
+async function exportOpenCodeSession(conversationId) {
+  const dbPath = openCodeDbPath();
+  const db = await openReadonlySqlite(dbPath, "opencode");
+  try {
+    const session = withRetryOnBusy(
+      () => db.prepare("SELECT * FROM session WHERE id = ?").get(conversationId)
+    );
+    if (!session) {
+      throw new Error(
+        `opencode: session "${conversationId}" not found in ${dbPath}. Sessions are keyed by the ACP session id (ses_\u2026) recorded as adapterSessionId.`
+      );
+    }
+    const msgRows = withRetryOnBusy(
+      () => db.prepare("SELECT id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(conversationId)
+    );
+    const partRows = withRetryOnBusy(
+      () => db.prepare("SELECT message_id, data, time_created FROM part WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(conversationId)
+    );
+    const partsByMsg = /* @__PURE__ */ new Map();
+    for (const r of partRows) {
+      const list = partsByMsg.get(r.message_id) ?? [];
+      list.push(r);
+      partsByMsg.set(r.message_id, list);
+    }
+    const messages = [];
+    let toolCallCount = 0;
+    for (const m of msgRows) {
+      let mdata;
+      try {
+        mdata = JSON.parse(m.data);
+      } catch {
+        continue;
+      }
+      const role = mdata.role === "assistant" ? "assistant" : "user";
+      let text = "";
+      let reasoning = "";
+      const toolCalls = [];
+      const toolResults = [];
+      for (const pr of partsByMsg.get(m.id) ?? []) {
+        let part;
+        try {
+          part = JSON.parse(pr.data);
+        } catch {
+          continue;
+        }
+        switch (part.type) {
+          case "text":
+            if (part.text) text += part.text;
+            break;
+          case "reasoning":
+            if (part.text) reasoning += part.text;
+            break;
+          case "tool": {
+            const name = part.tool ?? "tool";
+            toolCalls.push({ name, args: JSON.stringify(part.state?.input ?? {}) });
+            toolCallCount += 1;
+            const output = part.state?.output;
+            if (output !== void 0 && output !== null && output !== "") {
+              toolResults.push({ name, text: typeof output === "string" ? output : JSON.stringify(output) });
+            }
+            break;
+          }
+        }
+      }
+      if (text.trim() || reasoning.trim() || toolCalls.length) {
+        const em = { role };
+        if (text.trim()) em.text = text.trim();
+        if (reasoning.trim()) em.reasoning = reasoning.trim();
+        if (toolCalls.length) em.toolCalls = toolCalls;
+        em.ts = m.time_created;
+        messages.push(em);
+      }
+      for (const tr of toolResults) {
+        messages.push({ role: "tool", text: tr.text, ...tr.name ? { toolName: tr.name } : {} });
+      }
+    }
+    const meta = { source: "opencode" };
+    if (session.title) meta.title = session.title;
+    const model = openCodeModelLabel(session.model);
+    if (model) meta.model = model;
+    if (session.time_created) meta.startedAt = new Date(session.time_created).toISOString();
+    if (session.time_updated) meta.endedAt = new Date(session.time_updated).toISOString();
+    meta.messageCount = messages.length;
+    meta.toolCallCount = toolCallCount;
+    if (session.cost != null) meta.costUsd = Number(session.cost);
+    const tk = {
+      ...session.tokens_input != null ? { input: session.tokens_input } : {},
+      ...session.tokens_output != null ? { output: session.tokens_output } : {},
+      ...session.tokens_cache_read != null ? { cacheRead: session.tokens_cache_read } : {},
+      ...session.tokens_cache_write != null ? { cacheWrite: session.tokens_cache_write } : {},
+      ...session.tokens_reasoning != null ? { reasoning: session.tokens_reasoning } : {}
+    };
+    if (Object.keys(tk).length) meta.tokens = tk;
+    return { meta, messages };
+  } finally {
+    db.close();
+  }
+}
+async function discoverOpenCodeSessions(cwd, since, expectedId) {
+  const dbPath = openCodeDbPath();
+  let db;
+  try {
+    db = await openReadonlySqlite(dbPath, "opencode");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("database not found")) return [];
+    throw err;
+  }
+  try {
+    if (expectedId) {
+      const row = withRetryOnBusy(
+        () => db.prepare("SELECT * FROM session WHERE id = ?").get(expectedId)
+      );
+      return row ? [openCodeRowToCandidate(row)] : [];
+    }
+    const rows = withRetryOnBusy(
+      () => db.prepare("SELECT * FROM session WHERE directory = ?").all(cwd)
+    );
+    const sinceMs = since ? Date.parse(since) : NaN;
+    return rows.filter((r) => {
+      if (!Number.isFinite(sinceMs)) return true;
+      const last = r.time_updated ?? r.time_created;
+      return last === void 0 || last >= sinceMs - 1e3;
+    }).map(openCodeRowToCandidate);
+  } finally {
+    db.close();
+  }
+}
+function openCodeRowToCandidate(row) {
+  return {
+    conversationId: row.id,
+    ...row.time_created ? { startedAt: new Date(row.time_created).toISOString() } : {},
+    ...row.time_updated ? { lastActivityAt: new Date(row.time_updated).toISOString() } : {},
+    ...row.title ? { preview: row.title } : {}
+  };
+}
+function mastracodeInprocessDbPath() {
+  const home = process.env.AGENTPROTO_HOME ?? join(homedir(), ".agentproto");
+  return join(home, "mastracode-inprocess", "storage.db");
+}
+function mastraThreadId(conversationId) {
+  const idx = conversationId.indexOf(":");
+  return idx > 0 ? conversationId.slice(idx + 1) : conversationId;
+}
+function mastraContentToMessage(role, content) {
+  const toolResults = [];
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return { message: void 0, toolResults, toolCalls: 0 };
+  }
+  let text = "";
+  let reasoning = "";
+  const toolCalls = [];
+  for (const raw of parsed.parts ?? []) {
+    if (!raw || typeof raw !== "object") continue;
+    const part = raw;
+    if (part.type === "text" && part.text) text += part.text;
+    else if (part.type === "reasoning" && part.reasoning) reasoning += part.reasoning;
+    else if (part.type === "tool-invocation" && part.toolInvocation) {
+      const inv = part.toolInvocation;
+      const name = inv.toolName ?? "tool";
+      toolCalls.push({ name, args: JSON.stringify(inv.args ?? {}) });
+      if (inv.result !== void 0) {
+        const r = inv.result;
+        const rtext = Array.isArray(r?.content) ? r.content.filter((c) => c?.type === "text").map((c) => c.text ?? "").join("") : typeof inv.result === "string" ? inv.result : JSON.stringify(inv.result);
+        toolResults.push({ name, text: rtext });
+      }
+    }
+  }
+  let message;
+  if (text.trim() || reasoning.trim() || toolCalls.length) {
+    message = { role };
+    if (text.trim()) message.text = text.trim();
+    if (reasoning.trim()) message.reasoning = reasoning.trim();
+    if (toolCalls.length) message.toolCalls = toolCalls;
+  }
+  return { message, toolResults, toolCalls: toolCalls.length };
+}
+async function exportMastracodeInprocessSession(conversationId) {
+  const threadId = mastraThreadId(conversationId);
+  const dbPath = mastracodeInprocessDbPath();
+  const db = await openReadonlySqlite(dbPath, "mastracode-inprocess");
+  try {
+    const thread = withRetryOnBusy(
+      () => db.prepare("SELECT * FROM mastra_threads WHERE id = ?").get(threadId)
+    );
+    if (!thread) {
+      throw new Error(
+        `mastracode-inprocess: thread "${threadId}" not found in ${dbPath}. The sessionId is "<resourceId>:<threadId>"; only the threadId is looked up.`
+      );
+    }
+    const rows = withRetryOnBusy(
+      () => db.prepare('SELECT role, content, createdAt FROM mastra_messages WHERE thread_id = ? ORDER BY "createdAt" ASC').all(threadId)
+    );
+    const messages = [];
+    let toolCallCount = 0;
+    for (const r of rows) {
+      const role = r.role === "assistant" ? "assistant" : "user";
+      const { message, toolResults, toolCalls } = mastraContentToMessage(role, r.content);
+      if (message) messages.push(message);
+      toolCallCount += toolCalls;
+      for (const tr of toolResults) {
+        messages.push({ role: "tool", text: tr.text, ...tr.name ? { toolName: tr.name } : {} });
+      }
+    }
+    const meta = { source: "mastracode-inprocess" };
+    if (thread.title) meta.title = thread.title;
+    if (thread.createdAt) meta.startedAt = thread.createdAt;
+    if (thread.updatedAt) meta.endedAt = thread.updatedAt;
+    meta.messageCount = messages.length;
+    meta.toolCallCount = toolCallCount;
+    return { meta, messages };
+  } finally {
+    db.close();
+  }
+}
+async function discoverMastracodeInprocessSessions(_cwd, since, expectedId) {
+  const dbPath = mastracodeInprocessDbPath();
+  let db;
+  try {
+    db = await openReadonlySqlite(dbPath, "mastracode-inprocess");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("database not found")) return [];
+    throw err;
+  }
+  try {
+    if (!expectedId) return [];
+    const threadId = mastraThreadId(expectedId);
+    const thread = withRetryOnBusy(
+      () => db.prepare("SELECT * FROM mastra_threads WHERE id = ?").get(threadId)
+    );
+    if (!thread) return [];
+    const sinceMs = since ? Date.parse(since) : NaN;
+    if (Number.isFinite(sinceMs) && thread.updatedAt) {
+      const upd = Date.parse(thread.updatedAt);
+      if (Number.isFinite(upd) && upd < sinceMs - 1e3) return [];
+    }
+    return [
+      {
+        // Echo back the full composite id so callers/read() round-trip it.
+        conversationId: expectedId,
+        ...thread.createdAt ? { startedAt: thread.createdAt } : {},
+        ...thread.updatedAt ? { lastActivityAt: thread.updatedAt } : {},
+        ...thread.title ? { preview: thread.title } : {}
+      }
+    ];
+  } finally {
+    db.close();
+  }
+}
+function piSessionsDir() {
+  return join(homedir(), ".pi", "agent", "sessions");
+}
+function piBlocksText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let acc = "";
+  for (const c of content) {
+    if (c && typeof c === "object") {
+      const b = c;
+      if (b.type === "text" && typeof b.text === "string") acc += b.text;
+    }
+  }
+  return acc;
+}
+async function walkPiSessionFiles(dir) {
+  let entries;
+  try {
+    entries = await promises.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const e of entries) {
+    const p = join(dir, e.name);
+    if (e.isDirectory()) out.push(...await walkPiSessionFiles(p));
+    else if (e.isFile() && e.name.endsWith(".jsonl")) out.push(p);
+  }
+  return out;
+}
+async function findPiSessionFile(conversationId) {
+  const files = await walkPiSessionFiles(piSessionsDir());
+  const byName = files.find((f) => f.endsWith(`_${conversationId}.jsonl`));
+  if (byName) return byName;
+  for (const f of files) {
+    const first = await readFirstJsonLine(f);
+    if (!first) continue;
+    try {
+      const meta = JSON.parse(first);
+      if (meta.type === "session" && meta.id === conversationId) return f;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function exportPiSession(conversationId) {
+  const file = await findPiSessionFile(conversationId);
+  if (!file) {
+    throw new Error(
+      `pi: no session file for conversation "${conversationId}" under ${piSessionsDir()}.`
+    );
+  }
+  const stream = createReadStream(file, { encoding: "utf8" });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  const messages = [];
+  let toolCallCount = 0;
+  let startedAt;
+  let model;
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (entry.type === "session") {
+      startedAt = entry.timestamp;
+      continue;
+    }
+    if (entry.type === "model_change") {
+      model = entry.provider ? `${entry.provider}/${entry.modelId ?? ""}` : entry.modelId;
+      continue;
+    }
+    if (entry.type !== "message" || !entry.message) continue;
+    const m = entry.message;
+    const content = m.content;
+    if (m.role === "toolResult") {
+      const text2 = piBlocksText(content);
+      messages.push({
+        role: "tool",
+        text: m.isError ? `[error] ${text2}` : text2,
+        ...m.toolName ? { toolName: m.toolName } : {}
+      });
+      continue;
+    }
+    const role = m.role === "assistant" ? "assistant" : "user";
+    let text = "";
+    let reasoning = "";
+    const toolCalls = [];
+    if (typeof content === "string") {
+      text = content;
+    } else if (Array.isArray(content)) {
+      for (const raw of content) {
+        if (!raw || typeof raw !== "object") continue;
+        const part = raw;
+        if (part.type === "text" && part.text) text += part.text;
+        else if (part.type === "thinking" && part.thinking) reasoning += part.thinking;
+        else if (part.type === "toolCall") {
+          toolCalls.push({ name: part.name ?? "tool", args: JSON.stringify(part.arguments ?? {}) });
+          toolCallCount += 1;
+        }
+      }
+    }
+    if (text.trim() || reasoning.trim() || toolCalls.length) {
+      const em = { role };
+      if (text.trim()) em.text = text.trim();
+      if (reasoning.trim()) em.reasoning = reasoning.trim();
+      if (toolCalls.length) em.toolCalls = toolCalls;
+      messages.push(em);
+    }
+  }
+  const meta = { source: "pi" };
+  if (startedAt) meta.startedAt = startedAt;
+  if (model) meta.model = model;
+  meta.messageCount = messages.length;
+  meta.toolCallCount = toolCallCount;
+  return { meta, messages };
+}
+async function discoverPiSessions(cwd, since, until, expectedId) {
+  const files = await walkPiSessionFiles(piSessionsDir());
+  const sinceMs = since ? Date.parse(since) : NaN;
+  const untilMs = until ? Date.parse(until) : NaN;
+  const scored = [];
+  for (const f of files) {
+    let mtimeMs;
+    try {
+      mtimeMs = (await promises.stat(f)).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (Number.isFinite(sinceMs) && mtimeMs < sinceMs - 1e3) continue;
+    const first = await readFirstJsonLine(f);
+    if (!first) continue;
+    let meta;
+    try {
+      meta = JSON.parse(first);
+    } catch {
+      continue;
+    }
+    if (meta.type !== "session" || !meta.id) continue;
+    if (expectedId) {
+      if (meta.id !== expectedId) continue;
+    } else if (meta.cwd !== cwd) {
+      continue;
+    }
+    const startedAt = meta.timestamp;
+    if (Number.isFinite(untilMs) && startedAt) {
+      const s = Date.parse(startedAt);
+      if (Number.isFinite(s) && s > untilMs) continue;
+    }
+    scored.push({
+      candidate: {
+        conversationId: meta.id,
+        ...startedAt ? { startedAt } : {},
+        lastActivityAt: new Date(mtimeMs).toISOString()
+      },
+      mtimeMs
+    });
+  }
+  scored.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return scored.map((s) => s.candidate);
+}
 async function exportAgentSession(input) {
   const { sessionId, registry, format = "markdown", maxToolChars = 1200 } = input;
   const source = input.source ?? "auto";
@@ -735,6 +1403,18 @@ var init_transcript_export = __esm({
       },
       hermes: {
         exportSession: (id) => exportHermesSession(id)
+      },
+      codex: {
+        exportSession: (id) => exportCodexSession(id)
+      },
+      opencode: {
+        exportSession: (id) => exportOpenCodeSession(id)
+      },
+      "mastracode-inprocess": {
+        exportSession: (id) => exportMastracodeInprocessSession(id)
+      },
+      pi: {
+        exportSession: (id) => exportPiSession(id)
       }
     };
   }
@@ -862,6 +1542,38 @@ async function readHermes(conversationId) {
   const { exportHermesSession: exportHermesSession2 } = await Promise.resolve().then(() => (init_transcript_export(), transcript_export_exports));
   return exportHermesSession2(conversationId);
 }
+async function discoverCodex(input) {
+  const { discoverCodexSessions: discoverCodexSessions2 } = await Promise.resolve().then(() => (init_transcript_export(), transcript_export_exports));
+  return discoverCodexSessions2(input.cwd, input.since, input.until, input.expectedId);
+}
+async function readCodex(conversationId) {
+  const { exportCodexSession: exportCodexSession2 } = await Promise.resolve().then(() => (init_transcript_export(), transcript_export_exports));
+  return exportCodexSession2(conversationId);
+}
+async function discoverOpenCode(input) {
+  const { discoverOpenCodeSessions: discoverOpenCodeSessions2 } = await Promise.resolve().then(() => (init_transcript_export(), transcript_export_exports));
+  return discoverOpenCodeSessions2(input.cwd, input.since, input.expectedId);
+}
+async function readOpenCode(conversationId) {
+  const { exportOpenCodeSession: exportOpenCodeSession2 } = await Promise.resolve().then(() => (init_transcript_export(), transcript_export_exports));
+  return exportOpenCodeSession2(conversationId);
+}
+async function discoverMastracodeInprocess(input) {
+  const { discoverMastracodeInprocessSessions: discoverMastracodeInprocessSessions2 } = await Promise.resolve().then(() => (init_transcript_export(), transcript_export_exports));
+  return discoverMastracodeInprocessSessions2(input.cwd, input.since, input.expectedId);
+}
+async function readMastracodeInprocess(conversationId) {
+  const { exportMastracodeInprocessSession: exportMastracodeInprocessSession2 } = await Promise.resolve().then(() => (init_transcript_export(), transcript_export_exports));
+  return exportMastracodeInprocessSession2(conversationId);
+}
+async function discoverPi(input) {
+  const { discoverPiSessions: discoverPiSessions2 } = await Promise.resolve().then(() => (init_transcript_export(), transcript_export_exports));
+  return discoverPiSessions2(input.cwd, input.since, input.until, input.expectedId);
+}
+async function readPi(conversationId) {
+  const { exportPiSession: exportPiSession2 } = await Promise.resolve().then(() => (init_transcript_export(), transcript_export_exports));
+  return exportPiSession2(conversationId);
+}
 var CONVERSATION_STORES;
 var init_conversation_store = __esm({
   "src/conversation-store.ts"() {
@@ -885,6 +1597,28 @@ var init_conversation_store = __esm({
         attachArgv: (conversationId) => ["hermes", "--resume", conversationId, "--tui"],
         discover: discoverHermes,
         read: readHermes
+      },
+      // codex-acp writes no resume flag we sniff, and there's no native PTY
+      // reattach argv to declare — export/read only, so no outputHint/attachArgv.
+      codex: {
+        storeAs: "codexResumeId",
+        discover: discoverCodex,
+        read: readCodex
+      },
+      opencode: {
+        storeAs: "openCodeResumeId",
+        discover: discoverOpenCode,
+        read: readOpenCode
+      },
+      "mastracode-inprocess": {
+        storeAs: "mastracodeInprocessResumeId",
+        discover: discoverMastracodeInprocess,
+        read: readMastracodeInprocess
+      },
+      pi: {
+        storeAs: "piResumeId",
+        discover: discoverPi,
+        read: readPi
       }
     };
   }
@@ -892,37 +1626,34 @@ var init_conversation_store = __esm({
 
 // src/resume-strategies.ts
 init_conversation_store();
-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", ... }
-};
+var RESUME_STRATEGIES = Object.fromEntries(
+  Object.entries(CONVERSATION_STORES).filter(([, store]) => typeof store.attachArgv === "function").map(([slug, store]) => {
+    const s = store;
+    return [
+      slug,
+      {
+        outputHint: store.outputHint,
+        storeAs: store.storeAs,
+        fsProbe: async (cwd, prevStartedAt, expectedId) => {
+          const candidates = await s.discover({
+            cwd,
+            since: prevStartedAt,
+            expectedId
+          });
+          return candidates[0]?.conversationId ?? null;
+        },
+        spawnArgs: s.attachArgv
+      }
+    ];
+  })
+);
 function hasResumeStrategy(adapterSlug) {
   if (!adapterSlug) return false;
   const s = RESUME_STRATEGIES[adapterSlug];
   return !!(s && (s.outputHint || s.fsProbe || s.spawnArgs));
 }
 function decideRestartStrategy(prev) {
-  if (prev.adapterSlug) {
+  if (prev.adapterSlug && prev.nativeTerminalResume === true) {
     const strategy = RESUME_STRATEGIES[prev.adapterSlug];
     const id = strategy?.storeAs ? prev.resumeMetadata?.[strategy.storeAs] : void 0;
     if (strategy?.spawnArgs && id) {
@@ -933,9 +1664,11 @@ function decideRestartStrategy(prev) {
     return { kind: "pty-plain" };
   }
   if (prev.adapterSlug) {
+    const canResumeAtAcpLevel = prev.resumable !== false;
     return {
       kind: "agent",
-      ...prev.adapterSessionId ? { resumeSessionId: prev.adapterSessionId } : {}
+      ...prev.adapterSessionId && canResumeAtAcpLevel ? { resumeSessionId: prev.adapterSessionId } : {},
+      ...prev.adapterSessionId && !canResumeAtAcpLevel ? { resumeFallback: true } : {}
     };
   }
   return {
@@ -943,6 +1676,7 @@ function decideRestartStrategy(prev) {
     reason: "generic command session \u2014 restart only supports pty + agent-cli"
   };
 }
+var RESUME_ID_REJECTED_RE = /not found|does not support|not supported|unsupported/i;
 async function augmentWithFsResume(prev) {
   const slug = prev.adapterSlug;
   if (!slug) return prev;
@@ -973,6 +1707,9 @@ function describeResumePath(prev) {
     }
   }
   if (prev.adapterSlug && prev.adapterSessionId) {
+    if (prev.resumable === false) {
+      return `fresh \u2014 resume not supported by ${prev.adapterSlug}`;
+    }
     return "resumed via ACP";
   }
   return "";
@@ -1005,6 +1742,6 @@ function tokenizeCommand(s) {
   return out;
 }
 
-export { RESUME_STRATEGIES, augmentWithFsResume, decideRestartStrategy, describeResumePath, hasResumeStrategy, tokenizeCommand };
+export { RESUME_ID_REJECTED_RE, RESUME_STRATEGIES, augmentWithFsResume, decideRestartStrategy, describeResumePath, hasResumeStrategy, tokenizeCommand };
 //# sourceMappingURL=resume-strategies.mjs.map
 //# sourceMappingURL=resume-strategies.mjs.map