panoma 0.9.0 → 0.10.0

package/dist/handoff-command-NGSYPGWW.js

@@ -0,0 +1,3876 @@
+import {
+  detectCliAgents,
+  providersByAuth
+} from "./chunk-6RVG2VUY.js";
+import {
+  sinceMs
+} from "./chunk-WAI2SCFY.js";
+import {
+  catalogFetch,
+  unreachable
+} from "./chunk-HHHT2MTQ.js";
+import {
+  HandoffFault,
+  asHandoffFault,
+  handoffFaultText,
+  say
+} from "./chunk-3QYJKRW6.js";
+import "./chunk-DITTKJ7U.js";
+import {
+  HANDOFF_CLAUDE_RECORD_VERSION,
+  HANDOFF_PROVENANCE_PREFIX,
+  REDACTED,
+  estimateTokens,
+  expandTilde,
+  panomaPath,
+  redactSecrets,
+  resolveExecutable
+} from "./chunk-3T3WTSPS.js";
+import "./chunk-MLKGABMK.js";
+
+// src/handoff-command.ts
+import { execFile } from "child_process";
+import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { promisify } from "util";
+import pc from "picocolors";
+
+// ../../packages/handoff/dist/index.js
+import { randomBytes, randomUUID } from "crypto";
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { posix, win32 } from "path";
+import { readFile } from "fs/promises";
+import { createHash as createHash2 } from "crypto";
+import { readFileSync } from "fs";
+import { realpath } from "fs/promises";
+import { resolve } from "path";
+import { readdir, readFile as readFile3, stat as stat2 } from "fs/promises";
+import { readFile as readFile2, stat } from "fs/promises";
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile4, stat as stat3 } from "fs/promises";
+import { stat as stat4 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile5, stat as stat5 } from "fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir, rename, rm, writeFile } from "fs/promises";
+import { appendFile } from "fs/promises";
+import { open, readdir as readdir3, stat as stat6 } from "fs/promises";
+import { stat as stat7 } from "fs/promises";
+var AGENT_IDS = [
+  "claude-cli",
+  "codex-cli",
+  "opencode",
+  "gemini-cli",
+  "cursor-agent",
+  "copilot-cli",
+  "aider",
+  "amp-cli",
+  "goose"
+];
+var NATIVE_AGENTS = ["claude-cli", "codex-cli", "opencode", "gemini-cli"];
+var APP_OF = {
+  "claude-cli": { id: "claude-app", name: "Claude (app)", bundle: "Claude" },
+  "codex-cli": { id: "codex-app", name: "Codex (app)", bundle: "ChatGPT" }
+};
+var APP_WORDS = {
+  "claude-app": "claude-cli",
+  "codex-app": "codex-cli"
+};
+function agentOfApp(appId) {
+  return APP_WORDS[appId.trim().toLowerCase()];
+}
+var AGENT_WORDS = {
+  claude: "claude-cli",
+  codex: "codex-cli",
+  opencode: "opencode",
+  gemini: "gemini-cli",
+  cursor: "cursor-agent",
+  copilot: "copilot-cli",
+  aider: "aider",
+  amp: "amp-cli",
+  goose: "goose"
+};
+var AGENT_NAMES = {
+  "claude-cli": "Claude Code",
+  "codex-cli": "Codex CLI",
+  opencode: "OpenCode",
+  "gemini-cli": "Gemini CLI",
+  "cursor-agent": "Cursor Agent",
+  "copilot-cli": "GitHub Copilot",
+  aider: "Aider",
+  "amp-cli": "Amp",
+  goose: "Goose"
+};
+function agentFromWord(word) {
+  const lower = word.trim().toLowerCase();
+  if (AGENT_IDS.includes(lower)) return lower;
+  return AGENT_WORDS[lower];
+}
+function isAgentId(value) {
+  return AGENT_IDS.includes(value);
+}
+var NOTHING_DROPPED = Object.freeze({
+  thinking: 0,
+  images: 0,
+  subagents: 0,
+  offloaded: 0,
+  secrets: 0,
+  other: 0
+});
+var KEEP_TURNS_DEFAULT = 12;
+var DISCOVERY_LIMIT_DEFAULT = 40;
+var DISCOVERY_WHOLE_FILE_BYTES = 2 * 1024 * 1024;
+var DISCOVERY_WINDOW_BYTES = 64 * 1024;
+var LARGE_CONVERSATION_BYTES = 16 * 1024 * 1024;
+var MAX_CONVERSATION_BYTES = 64 * 1024 * 1024;
+var SAFE_ID = /^[A-Za-z0-9_-]{1,80}$/;
+function isSafeId(value) {
+  return SAFE_ID.test(value);
+}
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var OPENCODE_SESSION = /^ses_[A-Za-z0-9]{20,40}$/;
+function isSessionIdOf(agent, value) {
+  if (!isSafeId(value)) return false;
+  switch (agent) {
+    case "opencode":
+      return OPENCODE_SESSION.test(value);
+    case "claude-cli":
+    case "codex-cli":
+    case "gemini-cli":
+      return UUID.test(value);
+    default:
+      return true;
+  }
+}
+function shortHandle(agent, sessionId) {
+  const body = agent === "opencode" && sessionId.startsWith("ses_") ? sessionId.slice(4) : sessionId;
+  return body.slice(0, 8);
+}
+function conversationId(agent, sessionId) {
+  return `${agent}:${sessionId}`;
+}
+function splitConversationId(id) {
+  const cut3 = id.indexOf(":");
+  if (cut3 <= 0 || cut3 === id.length - 1) return void 0;
+  return { agent: id.slice(0, cut3), sessionId: id.slice(cut3 + 1) };
+}
+var cryptoRandom = {
+  uuid: () => randomUUID(),
+  hex: (bytes) => randomBytes(bytes).toString("hex")
+};
+var BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function opencodeId(prefix, at, counter, random) {
+  const ordered = (BigInt(at.getTime()) * 4096n + BigInt(counter % 4096)).toString(16).padStart(12, "0");
+  const tail = Array.from(Buffer.from(random.hex(14), "hex"), (byte) => BASE62[byte % 62]).join("");
+  return `${prefix}_${ordered.slice(-12)}${tail}`;
+}
+var NEVER = ["thinking and reasoning (never travels)", "images", "subagent runs"];
+var FIDELITY = {
+  "claude-cli": {
+    agent: "claude-cli",
+    native: true,
+    carries: ["every message", "tool calls and their results, balanced", "the source's own summary", "the title"],
+    leaves: [...NEVER],
+    testedWith: "Claude Code 2.1.258 (11-Sep-2026)",
+    resumeShape: "claude --resume <id> finds the file from any folder"
+  },
+  "codex-cli": {
+    agent: "codex-cli",
+    native: true,
+    carries: ["every message", "tool calls and results as text notes", "the source's own summary", "the title as the preview"],
+    leaves: [...NEVER, "structured tool calls (Codex's own importer drops them too)"],
+    testedWith: "Codex CLI 0.153.0 (11-Sep-2026)",
+    resumeShape: "codex resume <id> from the project folder; the picker is scoped to it"
+  },
+  opencode: {
+    agent: "opencode",
+    native: true,
+    carries: ["every message", "tool calls and results as text notes", "the source's own summary as a compaction", "the title"],
+    leaves: [...NEVER, "the source's model: the next turn needs -m provider/model"],
+    testedWith: "OpenCode 1.2.6 import (11-Sep-2026)",
+    resumeShape: "opencode import <file>, then opencode -s <id>"
+  },
+  "gemini-cli": {
+    agent: "gemini-cli",
+    native: true,
+    carries: ["every message", "tool calls and results as text notes", "the source's own summary", "the title"],
+    leaves: [...NEVER, "structured tool calls"],
+    /*
+      No `testedWith`: the writer follows the CLI's source and was never run against a live
+      store (open-questions.md keeps the row). The field is data — a version and a date — or
+      absent; the screen words the absence in the viewer's language (`handoff.neverRunLive`)
+      instead of painting an English sentence from here, and the terminal and the channel never
+      printed this field. Changed 12-Sep-2026.
+     */
+    resumeShape: "gemini --resume <id> from the project folder"
+  },
+  "cursor-agent": documentOnly("cursor-agent"),
+  "copilot-cli": documentOnly("copilot-cli"),
+  aider: documentOnly("aider"),
+  "amp-cli": documentOnly("amp-cli"),
+  goose: documentOnly("goose")
+};
+function documentOnly(agent) {
+  return {
+    agent,
+    native: false,
+    carries: ["a document with the digest and the last turns, to paste as the first message"],
+    leaves: [...NEVER, "the agent's own resume: it does not know this conversation"],
+    resumeShape: `${AGENT_NAMES[agent]} cannot resume a written conversation; it gets a document`
+  };
+}
+function fidelityOf(target) {
+  return FIDELITY[target];
+}
+function isNativeTarget(target) {
+  return NATIVE_AGENTS.includes(target);
+}
+var RESUME_ARGV = {
+  "claude-cli": { command: "claude", args: (id) => ["--resume", id] },
+  "codex-cli": { command: "codex", args: (id) => ["resume", id] },
+  opencode: { command: "opencode", args: (id) => ["-s", id] },
+  "gemini-cli": { command: "gemini", args: (id) => ["--resume", id] }
+};
+var FORK_ARGV = {
+  "claude-cli": (id) => ["--resume", id, "--fork-session"],
+  "codex-cli": (id) => ["fork", id]
+};
+var SIGN_OUT = {
+  "claude-cli": "claude auth logout",
+  "codex-cli": "codex logout",
+  opencode: "opencode auth logout",
+  "gemini-cli": "/auth inside gemini"
+};
+var SIGN_IN = {
+  "claude-cli": "claude auth login",
+  "codex-cli": "codex login",
+  opencode: "opencode auth login",
+  "gemini-cli": "/auth inside gemini"
+};
+function quoteForShell(value, platform = process.platform) {
+  if (platform === "win32") return `'${value.replace(/'/g, "''")}'`;
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function resumeOf(agent, sessionId, cwd, platform = process.platform) {
+  const entry = RESUME_ARGV[agent];
+  if (!entry || !isSessionIdOf(agent, sessionId)) return void 0;
+  const args = entry.args(sessionId);
+  return { command: entry.command, args, line: line(entry.command, args, cwd, platform) };
+}
+function forkOf(agent, sessionId, cwd, platform = process.platform) {
+  const entry = RESUME_ARGV[agent];
+  const fork = FORK_ARGV[agent];
+  if (!entry || !fork || !isSessionIdOf(agent, sessionId)) return void 0;
+  const args = fork(sessionId);
+  return { command: entry.command, args, line: line(entry.command, args, cwd, platform) };
+}
+function line(command, args, cwd, platform) {
+  const call = [command, ...args].join(" ");
+  if (platform === "win32") return `Set-Location -LiteralPath ${quoteForShell(cwd, platform)}; ${call}`;
+  return `cd ${quoteForShell(cwd, platform)} && ${call}`;
+}
+var APP_URL = {
+  "claude-cli": (id) => `claude://resume?session=${id}`,
+  "codex-cli": (id) => `codex://threads/${id}`
+};
+function resumeInApp(agent, sessionId, cwd, platform = process.platform) {
+  const app = APP_OF[agent];
+  const url = APP_URL[agent];
+  if (!app || !url || platform !== "darwin" || !isSessionIdOf(agent, sessionId)) return void 0;
+  const link = url(sessionId);
+  return {
+    app,
+    url: link,
+    line: `open ${quoteForShell(link, platform)}`,
+    sentence: agent === "claude-cli" ? `Open Claude, the Code tab, the folder ${cwd}, and pick the conversation ${sessionId}` : `Open the Codex app, the folder ${cwd}, and pick the thread ${sessionId}`
+  };
+}
+var TEST_GUARD_DETAIL = "tests must pass home and env";
+function resolveStoreOptions(options = {}) {
+  if (process.env.NODE_ENV === "test" && (options.home === void 0 || options.env === void 0)) {
+    throw new HandoffFault("store-missing", TEST_GUARD_DETAIL);
+  }
+  const platform = options.platform ?? process.platform;
+  return {
+    home: options.home ?? homedir(),
+    env: options.env ?? process.env,
+    platform,
+    path: platform === "win32" ? win32 : posix
+  };
+}
+function envValue(env, name) {
+  const value = env[name]?.trim();
+  return value ? value : void 0;
+}
+function exists(path) {
+  try {
+    return existsSync(path);
+  } catch {
+    return false;
+  }
+}
+function nativePath() {
+  return process.platform === "win32" ? win32 : posix;
+}
+function isAbsoluteOn(path, platform) {
+  return platform === "win32" ? win32.isAbsolute(path) : posix.isAbsolute(path);
+}
+var MAX_SLUG = 200;
+function claudeStore(options = {}) {
+  const resolved = resolveStoreOptions(options);
+  const { path } = resolved;
+  const root = envValue(resolved.env, "CLAUDE_CONFIG_DIR") ?? path.join(resolved.home, ".claude");
+  return { root, projects: path.join(root, "projects"), resolved };
+}
+function claudeStoreAt(root, options = {}) {
+  const resolved = resolveStoreOptions(options);
+  return { root, projects: resolved.path.join(root, "projects"), resolved };
+}
+function claudeStoreExists(store) {
+  return exists(store.projects);
+}
+function claudeSlug(cwd) {
+  const slug = cwd.replace(/[^A-Za-z0-9]/g, "-");
+  if (slug.length <= MAX_SLUG) return slug;
+  const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 8);
+  return `${slug.slice(0, MAX_SLUG - hash.length - 1)}-${hash}`;
+}
+function claudeFolderHolds(name, cwd, platform = process.platform) {
+  const fold = (s) => platform === "win32" ? s.toLowerCase() : s;
+  const own = fold(claudeSlug(cwd.replace(/[\\/]+$/, "")));
+  const child = `${own}-`.slice(0, MAX_SLUG - 9);
+  if (fold(name) === own) return "own";
+  return fold(name).startsWith(child) ? "maybe" : false;
+}
+function claudeProjectDir(store, cwd) {
+  return store.resolved.path.join(store.projects, claudeSlug(cwd));
+}
+function claudeSidecarDir(transcriptPath, path = nativePath()) {
+  const dir = path.dirname(transcriptPath);
+  const id = path.basename(transcriptPath, ".jsonl");
+  return path.join(dir, id);
+}
+var CODEX_DEFAULT_MODEL = "gpt-5-codex";
+var CODEX_DEFAULT_REASONING_EFFORT = "medium";
+var CODEX_DEFAULT_APPROVAL_POLICY = "on-request";
+var CODEX_DEFAULT_SANDBOX_MODE = "workspace-write";
+function build(root, resolved) {
+  const { path } = resolved;
+  return {
+    root,
+    sessions: path.join(root, "sessions"),
+    index: path.join(root, "session_index.jsonl"),
+    config: path.join(root, "config.toml"),
+    resolved
+  };
+}
+function codexStore(options = {}) {
+  const resolved = resolveStoreOptions(options);
+  const root = envValue(resolved.env, "CODEX_HOME") ?? resolved.path.join(resolved.home, ".codex");
+  return build(root, resolved);
+}
+function codexStoreAt(root, options = {}) {
+  return build(root, resolveStoreOptions(options));
+}
+function codexStoreExists(store) {
+  return exists(store.sessions);
+}
+function localFields(at) {
+  const two = (n) => String(n).padStart(2, "0");
+  return [String(at.getFullYear()).padStart(4, "0"), two(at.getMonth() + 1), two(at.getDate()), two(at.getHours()), two(at.getMinutes()), two(at.getSeconds())];
+}
+function codexFileStamp(at) {
+  const [year, month, day, hour, minute, second] = localFields(at);
+  return `${year}-${month}-${day}T${hour}-${minute}-${second}`;
+}
+function codexRolloutPath(store, at, sessionId) {
+  const { path } = store.resolved;
+  const [year, month, day] = localFields(at);
+  return path.join(store.sessions, year, month, day, `rollout-${codexFileStamp(at)}-${sessionId}.jsonl`);
+}
+async function codexModelSettings(store) {
+  const settings = {
+    model: CODEX_DEFAULT_MODEL,
+    reasoningEffort: CODEX_DEFAULT_REASONING_EFFORT,
+    approvalPolicy: CODEX_DEFAULT_APPROVAL_POLICY,
+    sandboxMode: CODEX_DEFAULT_SANDBOX_MODE
+  };
+  let text;
+  try {
+    text = await readFile(store.config, "utf8");
+  } catch {
+    return settings;
+  }
+  const firstTable = /^[ \t]*\[/m.exec(text);
+  const top = firstTable ? text.slice(0, firstTable.index) : text;
+  const line2 = (key) => new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*"([^"\\n]+)"`, "m").exec(top)?.[1]?.trim();
+  const model = line2("model");
+  const effort = line2("model_reasoning_effort");
+  const approval = line2("approval_policy");
+  const sandbox = line2("sandbox_mode");
+  if (model) settings.model = model;
+  if (effort) settings.reasoningEffort = effort;
+  if (approval) settings.approvalPolicy = approval;
+  if (sandbox) settings.sandboxMode = sandbox;
+  return settings;
+}
+function codexIdFromName(name) {
+  const match = /^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-([0-9a-f-]{36})(?:_[0-9a-f-]{36})?\.jsonl$/i.exec(
+    name
+  );
+  return match?.[1];
+}
+function build2(root, resolved) {
+  const { path } = resolved;
+  return { root, db: path.join(root, "opencode.db"), storage: path.join(root, "storage"), resolved };
+}
+function opencodeStore(options = {}) {
+  const resolved = resolveStoreOptions(options);
+  const { path, env, home, platform } = resolved;
+  const xdg = envValue(env, "XDG_DATA_HOME");
+  const data = xdg ?? (platform === "win32" ? envValue(env, "LOCALAPPDATA") ?? path.join(home, "AppData", "Local") : path.join(home, ".local", "share"));
+  return build2(path.join(data, "opencode"), resolved);
+}
+function opencodeStoreAt(root, options = {}) {
+  return build2(root, resolveStoreOptions(options));
+}
+function opencodeStoreExists(store) {
+  return exists(store.db) || exists(store.resolved.path.join(store.storage, "session"));
+}
+function opencodeEnvelopePath(store, sessionId) {
+  return store.resolved.path.join(store.root, `panoma-import-${sessionId}.json`);
+}
+var ENVELOPE_NAME = /^panoma-import-(ses_[A-Za-z0-9]+)\.json$/;
+function opencodeEnvelopeId(name) {
+  return ENVELOPE_NAME.exec(name)?.[1];
+}
+async function realFolder(folder) {
+  if (!folder) return folder;
+  const absolute = resolve(folder);
+  return realpath(absolute).catch(() => absolute);
+}
+function flat(path, platform) {
+  const folded = path.replace(/\\/g, "/").replace(/\/+$/, "");
+  return platform === "win32" ? folded.toLowerCase() : folded;
+}
+function insideFolder(cwd, folder, platform = process.platform) {
+  if (!cwd) return false;
+  const a = flat(cwd, platform);
+  const b = flat(folder, platform);
+  return a === b || a.startsWith(`${b}/`);
+}
+function sameFolder(a, b, platform = process.platform) {
+  if (!a || !b) return false;
+  return flat(a, platform) === flat(b, platform);
+}
+function build3(root, resolved) {
+  const { path } = resolved;
+  return { root, tmp: path.join(root, "tmp"), registry: path.join(root, "projects.json"), resolved };
+}
+function geminiStore(options = {}) {
+  const resolved = resolveStoreOptions(options);
+  return build3(resolved.path.join(resolved.home, ".gemini"), resolved);
+}
+function geminiStoreAt(root, options = {}) {
+  return build3(root, resolveStoreOptions(options));
+}
+function geminiStoreExists(store) {
+  return exists(store.tmp);
+}
+function sha256Hex(text) {
+  return createHash2("sha256").update(text).digest("hex");
+}
+function readGeminiRegistry(store) {
+  let raw;
+  try {
+    raw = readFileSync(store.registry, "utf8");
+  } catch {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null) return void 0;
+  const record2 = parsed;
+  const projects = typeof record2["projects"] === "object" && record2["projects"] !== null ? record2["projects"] : record2;
+  const map = /* @__PURE__ */ new Map();
+  for (const [folder, slug] of Object.entries(projects)) {
+    if (typeof slug === "string" && slug.length > 0) map.set(folder.replace(/[\\/]+$/, ""), slug);
+  }
+  return map;
+}
+function geminiProjectId(store, cwd) {
+  const registry = readGeminiRegistry(store);
+  if (registry) {
+    for (const [folder, slug] of registry) {
+      if (sameFolder(folder, cwd, store.resolved.platform)) return slug;
+    }
+  }
+  return sha256Hex(cwd);
+}
+function geminiProjectFolders(store, candidates) {
+  const folders = /* @__PURE__ */ new Map();
+  const registry = readGeminiRegistry(store);
+  if (registry) for (const [folder, slug] of registry) folders.set(slug, folder);
+  for (const cwd of candidates) folders.set(sha256Hex(cwd), cwd);
+  return folders;
+}
+function geminiChatsDir(store, projectId) {
+  return store.resolved.path.join(store.tmp, projectId, "chats");
+}
+function geminiChatPath(store, projectId, at, sessionId) {
+  const stamp = at.toISOString().slice(0, 16).replace(/:/g, "-");
+  return store.resolved.path.join(geminiChatsDir(store, projectId), `session-${stamp}-${sessionId.slice(0, 8)}.jsonl`);
+}
+var NOTE_INPUT_CHARS = 8e3;
+var NOTE_OUTPUT_CHARS = 16e3;
+function noteOfCall(part) {
+  return `[tool call: ${part.name}]
+${renderInput(part.input)}`;
+}
+function noteOfResult(part) {
+  const head = part.isError ? "[tool result: error]" : "[tool result]";
+  return `${head}
+${cut(part.output, NOTE_OUTPUT_CHARS)}`;
+}
+function textOfPart(part) {
+  switch (part.kind) {
+    case "text":
+    case "summary":
+      return part.text;
+    case "tool_call":
+      return noteOfCall(part);
+    case "tool_result":
+      return noteOfResult(part);
+  }
+}
+function renderInput(input) {
+  if (typeof input === "object" && input !== null && !Array.isArray(input)) {
+    const lines = [];
+    for (const [key, value] of Object.entries(input)) {
+      const text = typeof value === "string" ? value : stringify(value);
+      lines.push(`${key}: ${cut(text, NOTE_INPUT_CHARS)}`);
+    }
+    return lines.join("\n");
+  }
+  if (typeof input === "string") return cut(input, NOTE_INPUT_CHARS);
+  return cut(stringify(input), NOTE_INPUT_CHARS);
+}
+function stringify(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function cut(text, max) {
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
+}
+function provenanceLine(source, sessionId, tier, at) {
+  const date = at.toISOString().slice(0, 10);
+  return `${HANDOFF_PROVENANCE_PREFIX}${AGENT_NAMES[source]} conversation ${sessionId} by panoma on ${date} \xB7 tier ${tier}`;
+}
+function stripProvenance(text) {
+  if (!text.startsWith(HANDOFF_PROVENANCE_PREFIX)) return text;
+  const cut3 = text.indexOf("\n");
+  if (cut3 === -1) return "";
+  return text.slice(cut3 + 1).replace(/^\n+/, "");
+}
+function normalizeTurns(turns) {
+  const out = [];
+  for (const turn of turns) {
+    const parts = turn.parts.map(textOfPart).filter((text) => text.length > 0);
+    const last = out[out.length - 1];
+    if (last && last.role === turn.role) last.parts.push(...parts);
+    else out.push({ role: turn.role, parts });
+  }
+  return out.filter((turn) => turn.parts.length > 0);
+}
+function hashTurns(turns) {
+  return createHash3("sha256").update(JSON.stringify(normalizeTurns(turns))).digest("hex");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function emptyDropped() {
+  return { thinking: 0, images: 0, subagents: 0, offloaded: 0, secrets: 0, other: 0 };
+}
+function isoFromEpochSeconds(value) {
+  const seconds = readNumber(value);
+  if (seconds === void 0 || seconds <= 0) return void 0;
+  const ms = seconds > 1e12 ? seconds : seconds * 1e3;
+  return new Date(ms).toISOString();
+}
+function isoFromEpochMs(value) {
+  const ms = readNumber(value);
+  return ms === void 0 || ms <= 0 ? void 0 : new Date(ms).toISOString();
+}
+var TurnBuilder = class {
+  turns = [];
+  push(role, part, at) {
+    const last = this.turns[this.turns.length - 1];
+    if (last && last.role === role && !last.parts.some((p) => p.kind === "summary") && part.kind !== "summary") {
+      last.parts.push(part);
+      return;
+    }
+    const turn = { role, parts: [part] };
+    if (at) turn.at = at;
+    this.turns.push(turn);
+  }
+  /** A new turn even when the role repeats: two user prompts in a row stay two turns. */
+  open(role, parts, at) {
+    if (parts.length === 0) return;
+    const turn = { role, parts };
+    if (at) turn.at = at;
+    this.turns.push(turn);
+  }
+  /** Everything read so far is behind a compaction: the turns start again. */
+  reset() {
+    this.turns.length = 0;
+  }
+};
+async function readTranscript(path) {
+  let size2;
+  try {
+    size2 = (await stat(path)).size;
+  } catch (error) {
+    throw asHandoffFault(error, "conversation-not-found");
+  }
+  if (size2 > MAX_CONVERSATION_BYTES) throw new HandoffFault("too-large", String(size2));
+  try {
+    return await readFile2(path, "utf8");
+  } catch (error) {
+    throw asHandoffFault(error, "unreadable-transcript");
+  }
+}
+function parseLines(text) {
+  const out = [];
+  for (const line2 of text.split("\n")) {
+    const trimmed = line2.trim();
+    if (trimmed.length < 2) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return out;
+}
+function finishConversation(head, turns, compactions, dropped) {
+  const first = turns[0]?.parts[0];
+  if (first && (first.kind === "text" || first.kind === "summary")) {
+    first.text = stripProvenance(first.text);
+    if (first.text.length === 0) {
+      turns[0].parts.shift();
+      if (turns[0].parts.length === 0) turns.shift();
+    }
+  }
+  const ref = {
+    id: conversationId(head.agent, head.sessionId),
+    agent: head.agent,
+    sessionId: head.sessionId,
+    handle: shortHandle(head.agent, head.sessionId),
+    path: head.path,
+    cwd: head.cwd,
+    updatedAt: head.updatedAt,
+    turnCount: turns.length,
+    bytes: head.bytes,
+    compacted: head.compacted || compactions.length > 0
+  };
+  if (head.gitBranch) ref.gitBranch = head.gitBranch;
+  if (head.title) ref.title = head.title;
+  if (head.model) ref.model = head.model;
+  if (head.startedAt) ref.startedAt = head.startedAt;
+  if (head.limit) ref.limit = head.limit;
+  if (head.surface) ref.surface = head.surface;
+  return { ...ref, version: 1, hash: hashTurns(turns), turns, compactions, dropped };
+}
+function titleFromText(text, max = 80) {
+  const line2 = text.split(/\r?\n/).map((l) => l.trim()).find((l) => l.length > 0);
+  if (!line2) return void 0;
+  return line2.length > max ? `${line2.slice(0, max - 1).trimEnd()}\u2026` : line2;
+}
+var APP_ENTRYPOINTS = ["claude-desktop", "claude-desktop-3p"];
+function surfaceOfEntrypoint(entrypoint) {
+  return entrypoint !== void 0 && APP_ENTRYPOINTS.includes(entrypoint) ? "app" : "cli";
+}
+var OFFLOADED_MAX_BYTES = DISCOVERY_WINDOW_BYTES;
+var SAVED_TO = /Full output saved to: (.+?)(?:\r?\n|$)/;
+var SYNTHETIC_MODEL = "<synthetic>";
+var INJECTED_BLOCKS = [
+  /<system-reminder>[\s\S]*?<\/system-reminder>/g,
+  /<task-notification>[\s\S]*?<\/task-notification>/g,
+  /<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g,
+  /<local-command-stdout>[\s\S]*?<\/local-command-stdout>/g,
+  /<local-command-stderr>[\s\S]*?<\/local-command-stderr>/g,
+  /<command-name>[\s\S]*?<\/command-name>/g,
+  /<command-message>[\s\S]*?<\/command-message>/g,
+  /<command-args>[\s\S]*?<\/command-args>/g
+];
+var INJECTED_LINES = [/^\[Request interrupted[^\n]*$/gm, /^Caveat: The messages below[^\n]*$/gm];
+function stripClaudeInjections(text) {
+  let out = text;
+  for (const block of INJECTED_BLOCKS) out = out.replace(block, " ");
+  for (const line2 of INJECTED_LINES) out = out.replace(line2, " ");
+  return out === text ? text : out.trim();
+}
+async function readClaudeConversation(path, options = {}) {
+  resolveStoreOptions(options);
+  const text = await readTranscript(path);
+  const local = nativePath();
+  const info = await stat2(path);
+  return parseClaudeTranscript(text, {
+    path,
+    sessionId: local.basename(path, ".jsonl"),
+    bytes: info.size,
+    mtime: info.mtime.toISOString(),
+    sidecar: claudeSidecarDir(path, local)
+  });
+}
+async function parseClaudeTranscript(text, input) {
+  const local = nativePath();
+  const { sidecar, sessionId } = input;
+  const builder = new TurnBuilder();
+  const compactions = [];
+  const dropped = emptyDropped();
+  const head = {
+    agent: "claude-cli",
+    sessionId,
+    path: input.path,
+    cwd: "",
+    updatedAt: input.mtime,
+    bytes: input.bytes,
+    compacted: false,
+    surface: "cli"
+  };
+  let entrypoint;
+  let customTitle;
+  let aiTitle;
+  let firstUserText;
+  let pending;
+  let limit;
+  let lastAt;
+  for (const record2 of parseLines(text)) {
+    if (!isRecord(record2)) continue;
+    const type = record2["type"];
+    const at = readString(record2["timestamp"]);
+    if (entrypoint === void 0) {
+      entrypoint = readString(record2["entrypoint"]);
+      if (entrypoint !== void 0) head.surface = surfaceOfEntrypoint(entrypoint);
+    }
+    if (type === "custom-title") {
+      customTitle = readString(record2["customTitle"]) ?? customTitle;
+      continue;
+    }
+    if (type === "ai-title") {
+      aiTitle = readString(record2["aiTitle"]) ?? aiTitle;
+      continue;
+    }
+    if (type === "system") {
+      if (record2["subtype"] !== "compact_boundary") continue;
+      builder.reset();
+      compactions.length = 0;
+      head.compacted = true;
+      firstUserText = void 0;
+      const meta = record2["compactMetadata"];
+      pending = { at, tokensBefore: isRecord(meta) ? readNumber(meta["preTokens"]) : void 0 };
+      continue;
+    }
+    if (type !== "user" && type !== "assistant") continue;
+    if (at) {
+      head.startedAt ??= at;
+      lastAt = at;
+    }
+    const cwd = readString(record2["cwd"]);
+    if (cwd && !head.cwd) head.cwd = cwd;
+    const branch = readString(record2["gitBranch"]);
+    if (branch) head.gitBranch = branch;
+    if (record2["isSidechain"] === true) {
+      dropped.other += 1;
+      continue;
+    }
+    const message = record2["message"];
+    if (!isRecord(message)) continue;
+    if (type === "user") {
+      if (record2["isMeta"] === true) {
+        dropped.other += 1;
+        continue;
+      }
+      if (record2["isCompactSummary"] === true) {
+        const summary = contentText(message["content"]);
+        builder.open("user", [{ kind: "summary", text: summary }], at);
+        const compaction = { text: summary };
+        const when = pending?.at ?? at;
+        if (when) compaction.at = when;
+        if (pending?.tokensBefore !== void 0) compaction.tokensBefore = pending.tokensBefore;
+        compactions.push(compaction);
+        pending = void 0;
+        continue;
+      }
+      const parts = await userParts(message["content"], sidecar, dropped, local);
+      if (firstUserText === void 0) {
+        const first = parts.find((p) => p.kind === "text");
+        if (first && first.kind === "text") firstUserText = first.text;
+      }
+      for (const part of parts) builder.push("user", part, at);
+      continue;
+    }
+    if (record2["isApiErrorMessage"] === true) {
+      limit = limitOf(record2, at) ?? limit;
+      dropped.other += 1;
+      continue;
+    }
+    limit = void 0;
+    const model = readString(message["model"]);
+    if (model && model !== SYNTHETIC_MODEL && !head.model) head.model = model;
+    for (const part of assistantParts(message["content"], dropped)) builder.push("assistant", part, at);
+  }
+  if (lastAt) head.updatedAt = lastAt;
+  head.title = customTitle ?? aiTitle ?? (firstUserText ? titleFromText(firstUserText) : void 0);
+  if (limit) head.limit = limit;
+  if (sidecar) dropped.subagents += await countSubagents(local.join(sidecar, "subagents"), local);
+  return finishConversation(head, builder.turns, compactions, dropped);
+}
+function limitOf(record2, at) {
+  const quota = record2["quotaLimits"];
+  const status = readNumber(record2["apiErrorStatus"]);
+  if (status !== 429 && !isRecord(quota)) return void 0;
+  const hit = { at: at ?? "" };
+  if (isRecord(quota)) {
+    const resetsAt = isoFromEpochSeconds(quota["resetsAt"]);
+    if (resetsAt) hit.resetsAt = resetsAt;
+    const kind = readString(quota["rateLimitType"]);
+    if (kind) hit.kind = kind;
+  }
+  return hit;
+}
+async function userParts(content, sidecar, dropped, path) {
+  const parts = [];
+  const own = (text) => {
+    const words = stripClaudeInjections(text);
+    if (words) parts.push({ kind: "text", text: words });
+    else dropped.other += 1;
+  };
+  if (typeof content === "string") {
+    if (content.length > 0) own(content);
+    return parts;
+  }
+  if (!Array.isArray(content)) return [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    const kind = block["type"];
+    if (kind === "text") {
+      const text = readString(block["text"]);
+      if (text) own(text);
+    } else if (kind === "tool_result") {
+      const callId = readString(block["tool_use_id"]);
+      if (!callId) continue;
+      let output = contentText(block["content"], dropped);
+      output = await inlineOffloaded(output, sidecar, dropped, path);
+      const part = { kind: "tool_result", callId, output };
+      if (block["is_error"] === true) part.isError = true;
+      parts.push(part);
+    } else if (kind === "image") {
+      dropped.images += 1;
+    } else {
+      dropped.other += 1;
+    }
+  }
+  return parts;
+}
+function assistantParts(content, dropped) {
+  if (typeof content === "string") return content.length > 0 ? [{ kind: "text", text: content }] : [];
+  if (!Array.isArray(content)) return [];
+  const parts = [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    const kind = block["type"];
+    if (kind === "text") {
+      const text = readString(block["text"]);
+      if (text) parts.push({ kind: "text", text });
+    } else if (kind === "tool_use") {
+      const id = readString(block["id"]);
+      const name = readString(block["name"]);
+      if (id && name) parts.push({ kind: "tool_call", id, name, input: block["input"] ?? {} });
+    } else if (kind === "thinking" || kind === "redacted_thinking") {
+      dropped.thinking += 1;
+    } else if (kind === "image") {
+      dropped.images += 1;
+    } else {
+      dropped.other += 1;
+    }
+  }
+  return parts;
+}
+function contentText(content, dropped) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const texts = [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (block["type"] === "text") {
+      const text = readString(block["text"]);
+      if (text) texts.push(text);
+    } else if (block["type"] === "image" && dropped) {
+      dropped.images += 1;
+    }
+  }
+  return texts.join("\n");
+}
+async function inlineOffloaded(output, sidecar, dropped, path) {
+  if (!output.startsWith("<persisted-output>")) return output;
+  const saved = SAVED_TO.exec(output)?.[1]?.trim();
+  const resultsDir = sidecar ? path.join(sidecar, "tool-results") : void 0;
+  if (!saved || !resultsDir || path.dirname(saved) !== resultsDir || !saved.endsWith(".txt") || path.basename(saved).includes("..")) {
+    dropped.offloaded += 1;
+    return output;
+  }
+  try {
+    const info = await stat2(saved);
+    if (!info.isFile() || info.size > OFFLOADED_MAX_BYTES) {
+      dropped.offloaded += 1;
+      return output;
+    }
+    return await readFile3(saved, "utf8");
+  } catch {
+    dropped.offloaded += 1;
+    return output;
+  }
+}
+async function countSubagents(dir, path, depth = 0) {
+  if (depth > 4) return 0;
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  let count = 0;
+  for (const entry of entries) {
+    if (entry.isDirectory()) count += await countSubagents(path.join(dir, entry.name), path, depth + 1);
+    else if (entry.isFile() && /^agent-.*\.jsonl$/i.test(entry.name)) count += 1;
+  }
+  return count;
+}
+var CODEX_APP_ORIGINATOR = "Codex Desktop";
+var INJECTED_PREFIXES = [
+  "<environment_context>",
+  "<app-context>",
+  "<user_instructions>",
+  "<permissions instructions>",
+  "<turn_aborted>",
+  "<user_shell>",
+  "# AGENTS.md instructions",
+  "<recommended_plugins>",
+  "<subagent_notification>",
+  "<skill>",
+  "<in-app-browser-context",
+  // A dump from a voice session, which the history reader in @panoma/core strips as a block.
+  "<realtime_delegation>"
+];
+var REQUEST_MARKER = /^##[ \t]+My request(?:[ \t]+for[ \t]+Codex)?:[ \t]*$/m;
+function isCodexInjection(text) {
+  const head = text.trimStart();
+  return INJECTED_PREFIXES.some((prefix) => head.startsWith(prefix));
+}
+function codexUserText(text) {
+  const marker = REQUEST_MARKER.exec(text);
+  if (marker !== null) {
+    const words = text.slice(marker.index + marker[0].length).trim();
+    return words.length > 0 ? words : void 0;
+  }
+  return isCodexInjection(text) ? void 0 : text;
+}
+async function readCodexConversation(path, options = {}) {
+  const store = codexStore(options);
+  const text = await readTranscript(path);
+  const info = await stat3(path);
+  const names = await readSessionIndex(store.index);
+  return parseCodexRollout(text, { path, bytes: info.size, mtime: info.mtime.toISOString(), names });
+}
+function parseCodexRollout(text, input) {
+  const local = nativePath();
+  const { path } = input;
+  const builder = new TurnBuilder();
+  const compactions = [];
+  const dropped = emptyDropped();
+  const head = {
+    agent: "codex-cli",
+    sessionId: codexIdFromName(local.basename(path)) ?? local.basename(path, ".jsonl"),
+    path,
+    cwd: "",
+    updatedAt: input.mtime,
+    bytes: input.bytes,
+    compacted: false,
+    surface: "cli"
+  };
+  let metaSeen = false;
+  let firstUserText;
+  let limit;
+  let lastAt;
+  for (const record2 of parseLines(text)) {
+    if (!isRecord(record2)) continue;
+    const payload = record2["payload"];
+    if (!isRecord(payload)) continue;
+    const type = record2["type"];
+    const at = readString(record2["timestamp"]);
+    if (at) lastAt = at;
+    if (type === "session_meta") {
+      if (metaSeen) continue;
+      metaSeen = true;
+      const id = readString(payload["id"]) ?? readString(payload["session_id"]);
+      if (id) head.sessionId = id;
+      head.cwd = readString(payload["cwd"]) ?? head.cwd;
+      head.startedAt = readString(payload["timestamp"]) ?? at;
+      if (payload["originator"] === CODEX_APP_ORIGINATOR) head.surface = "app";
+      const git = payload["git"];
+      const branch = isRecord(git) ? readString(git["branch"]) : void 0;
+      if (branch) head.gitBranch = branch;
+      continue;
+    }
+    if (type === "turn_context") {
+      const cwd = readString(payload["cwd"]);
+      if (cwd) head.cwd = cwd;
+      const model = readString(payload["model"]);
+      if (model && !head.model) head.model = model;
+      continue;
+    }
+    if (type === "compacted") {
+      builder.reset();
+      compactions.length = 0;
+      head.compacted = true;
+      const summary = readString(payload["message"]);
+      if (summary) {
+        builder.open("user", [{ kind: "summary", text: summary }], at);
+        const compaction = { text: summary };
+        if (at) compaction.at = at;
+        compactions.push(compaction);
+      }
+      const history = payload["replacement_history"];
+      if (Array.isArray(history)) {
+        for (const item of history) {
+          if (isRecord(item)) replayItem(item, builder, dropped, at, (t) => {
+            firstUserText ??= t;
+          });
+        }
+      }
+      continue;
+    }
+    if (type === "event_msg") {
+      if (payload["type"] === "token_count") limit = limitOf2(payload, at);
+      continue;
+    }
+    if (type !== "response_item") continue;
+    replayItem(payload, builder, dropped, at, (t) => {
+      firstUserText ??= t;
+    });
+  }
+  if (lastAt) head.updatedAt = lastAt;
+  head.title = input.names?.get(head.sessionId) ?? (firstUserText ? titleFromText(firstUserText) : void 0);
+  if (limit) head.limit = limit;
+  return finishConversation(head, builder.turns, compactions, dropped);
+}
+function replayItem(item, builder, dropped, at, onUserText) {
+  const kind = item["type"];
+  if (kind === "message") {
+    const role = item["role"];
+    if (role !== "user" && role !== "assistant") {
+      dropped.other += 1;
+      return;
+    }
+    const texts = contentTexts(item["content"], dropped);
+    for (const raw of texts) {
+      const text = role === "user" ? codexUserText(raw) : raw;
+      if (text === void 0) {
+        dropped.other += 1;
+        continue;
+      }
+      if (role === "user") onUserText(text);
+      builder.push(role, { kind: "text", text }, at);
+    }
+    return;
+  }
+  if (kind === "function_call" || kind === "custom_tool_call" || kind === "local_shell_call") {
+    const id = readString(item["call_id"]) ?? readString(item["id"]);
+    if (!id) return;
+    const name = readString(item["name"]) ?? (kind === "local_shell_call" ? "shell" : "tool");
+    const raw = kind === "function_call" ? parseArguments(item["arguments"]) : kind === "custom_tool_call" ? item["input"] : item["action"];
+    builder.push("assistant", { kind: "tool_call", id, name, input: toolInput(raw) }, at);
+    return;
+  }
+  if (kind === "function_call_output" || kind === "custom_tool_call_output") {
+    const callId = readString(item["call_id"]);
+    if (!callId) return;
+    const raw = item["output"];
+    const output = typeof raw === "string" ? raw : contentTexts(raw, dropped).join("\n");
+    builder.push("user", { kind: "tool_result", callId, output }, at);
+    return;
+  }
+  if (kind === "reasoning") {
+    dropped.thinking += 1;
+    return;
+  }
+  dropped.other += 1;
+}
+function parseArguments(value) {
+  if (typeof value !== "string") return value ?? {};
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function toolInput(value) {
+  if (isRecord(value)) return value;
+  return { input: value ?? "" };
+}
+function contentTexts(content, dropped) {
+  if (typeof content === "string") return content.length > 0 ? [content] : [];
+  if (!Array.isArray(content)) return [];
+  const texts = [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    const type = block["type"];
+    if (type === "input_text" || type === "output_text" || type === "text") {
+      const text = readString(block["text"]);
+      if (text) texts.push(text);
+    } else if (type === "input_image" || type === "image") {
+      dropped.images += 1;
+    } else if (type === "encrypted_content") {
+      dropped.thinking += 1;
+    } else {
+      dropped.other += 1;
+    }
+  }
+  return texts;
+}
+function limitOf2(payload, at) {
+  const limits = payload["rate_limits"];
+  if (!isRecord(limits)) return void 0;
+  const reached = readString(limits["rate_limit_reached_type"]);
+  const windows = [["primary", limits["primary"]], ["secondary", limits["secondary"]]];
+  let full;
+  for (const [name, window] of windows) {
+    if (!isRecord(window)) continue;
+    const used = readNumber(window["used_percent"]);
+    if (used !== void 0 && used >= 100) {
+      full = { name };
+      const resetsAt2 = isoFromEpochSeconds(window["resets_at"]);
+      if (resetsAt2) full.resetsAt = resetsAt2;
+      break;
+    }
+  }
+  if (!reached && !full) return void 0;
+  const hit = { at: at ?? "", kind: reached ?? full.name };
+  const resetsAt = full?.resetsAt ?? soonestReset(windows);
+  if (resetsAt) hit.resetsAt = resetsAt;
+  return hit;
+}
+function soonestReset(windows) {
+  let best;
+  for (const [, window] of windows) {
+    if (!isRecord(window)) continue;
+    const iso = isoFromEpochSeconds(window["resets_at"]);
+    if (iso && (!best || iso < best)) best = iso;
+  }
+  return best;
+}
+async function readSessionIndex(indexPath) {
+  const names = /* @__PURE__ */ new Map();
+  let text;
+  try {
+    text = await readFile4(indexPath, "utf8");
+  } catch {
+    return names;
+  }
+  for (const record2 of parseLines(text)) {
+    if (!isRecord(record2)) continue;
+    const id = readString(record2["id"]);
+    const name = readString(record2["thread_name"]);
+    if (id && name) names.set(id, name);
+  }
+  return names;
+}
+async function readGeminiConversation(path, options = {}, deps = {}) {
+  const store = geminiStore(options);
+  const text = await readTranscript(path);
+  const local = nativePath();
+  const info = await stat4(path);
+  const projectId = local.basename(local.dirname(local.dirname(path)));
+  const cwd = geminiProjectFolders(store, deps.cwds ?? []).get(projectId);
+  const input = {
+    path,
+    bytes: info.size,
+    mtime: info.mtime.toISOString(),
+    legacy: path.toLowerCase().endsWith(".json")
+  };
+  if (cwd) input.cwd = cwd;
+  return parseGeminiChat(text, input);
+}
+function parseGeminiChat(text, input) {
+  const local = nativePath();
+  const { path } = input;
+  const records = input.legacy ? legacyRecords(text) : parseLines(text);
+  const builder = new TurnBuilder();
+  const dropped = emptyDropped();
+  const head = {
+    agent: "gemini-cli",
+    sessionId: "",
+    path,
+    cwd: input.cwd ?? "",
+    updatedAt: input.mtime,
+    bytes: input.bytes,
+    compacted: false
+  };
+  let summary;
+  let firstUserText;
+  const messages = /* @__PURE__ */ new Map();
+  for (const record2 of records) {
+    if (!isRecord(record2)) continue;
+    const set = record2["$set"];
+    if (isRecord(set)) {
+      const title2 = readString(set["summary"]);
+      if (title2) summary = title2;
+      const replaced = set["messages"];
+      if (Array.isArray(replaced)) {
+        messages.clear();
+        replaced.forEach((m, i) => {
+          if (isRecord(m)) messages.set(readString(m["id"]) ?? `#${i}`, m);
+        });
+      }
+      continue;
+    }
+    const rewind = readString(record2["$rewindTo"]);
+    if (rewind) {
+      let cut3 = false;
+      for (const id2 of [...messages.keys()]) {
+        if (id2 === rewind) cut3 = true;
+        if (cut3) messages.delete(id2);
+      }
+      continue;
+    }
+    const messageId = record2["id"];
+    if (typeof messageId === "string") {
+      messages.set(messageId, record2);
+      continue;
+    }
+    const id = readString(record2["sessionId"]);
+    if (id) head.sessionId = id;
+    const started = readString(record2["startTime"]);
+    if (started) head.startedAt = started;
+    const updated = readString(record2["lastUpdated"]);
+    if (updated) head.updatedAt = updated;
+    const title = readString(record2["summary"]);
+    if (title) summary = title;
+  }
+  if (!head.sessionId) head.sessionId = local.basename(path).replace(/\.jsonl?$/i, "");
+  for (const message of messages.values()) {
+    const at = readString(message["timestamp"]);
+    if (at) head.updatedAt = at;
+    const type = message["type"];
+    if (type === "user") {
+      const texts = contentTexts2(message["content"], dropped);
+      for (const t of texts) {
+        firstUserText ??= t;
+        builder.push("user", { kind: "text", text: t }, at);
+      }
+      continue;
+    }
+    if (type !== "gemini") {
+      dropped.other += 1;
+      continue;
+    }
+    const model = readString(message["model"]);
+    if (model && !head.model) head.model = model;
+    if (Array.isArray(message["thoughts"]) && message["thoughts"].length > 0) dropped.thinking += 1;
+    for (const t of contentTexts2(message["content"], dropped)) {
+      builder.push("assistant", { kind: "text", text: t }, at);
+    }
+    for (const call of Array.isArray(message["toolCalls"]) ? message["toolCalls"] : []) {
+      if (!isRecord(call)) continue;
+      const id = readString(call["id"]);
+      const name = readString(call["name"]);
+      if (!id || !name) continue;
+      builder.push("assistant", { kind: "tool_call", id, name, input: call["args"] ?? {} }, at);
+      const output = responseText(call["result"]);
+      if (output !== void 0) {
+        const result = { kind: "tool_result", callId: id, output };
+        if (call["status"] === "error") result.isError = true;
+        builder.push("user", result, at);
+      }
+    }
+  }
+  head.title = summary ?? (firstUserText ? titleFromText(firstUserText) : void 0);
+  return finishConversation(head, builder.turns, [], dropped);
+}
+function legacyRecords(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return [];
+  }
+  if (!isRecord(parsed)) return [];
+  const { messages, ...meta } = parsed;
+  return [meta, ...Array.isArray(messages) ? messages : []];
+}
+function contentTexts2(content, dropped) {
+  if (typeof content === "string") return content.length > 0 ? [content] : [];
+  if (!Array.isArray(content)) return [];
+  const texts = [];
+  for (const part of content) {
+    if (!isRecord(part)) continue;
+    const text = readString(part["text"]);
+    if (text) texts.push(text);
+    else if (part["inlineData"] !== void 0 || part["fileData"] !== void 0) dropped.images += 1;
+    else if (part["functionCall"] === void 0 && part["functionResponse"] === void 0) dropped.other += 1;
+  }
+  return texts;
+}
+function responseText(result) {
+  if (result === void 0 || result === null) return void 0;
+  if (typeof result === "string") return result;
+  if (!Array.isArray(result)) return JSON.stringify(result);
+  const texts = [];
+  for (const part of result) {
+    if (!isRecord(part)) continue;
+    const response = isRecord(part["functionResponse"]) ? part["functionResponse"]["response"] : void 0;
+    if (isRecord(response)) {
+      const output = response["output"] ?? response["error"];
+      texts.push(typeof output === "string" ? output : JSON.stringify(response));
+    } else if (typeof part["text"] === "string") {
+      texts.push(part["text"]);
+    }
+  }
+  return texts.join("\n");
+}
+async function readOpencodeConversation(source, options = {}, deps = {}) {
+  resolveStoreOptions(options);
+  const local = nativePath();
+  const name = local.basename(source.path);
+  if (opencodeEnvelopeId(name)) return readEnvelope(source.path, source.sessionId);
+  const isDb = name.toLowerCase().endsWith(".db");
+  const root = isDb ? local.dirname(source.path) : source.path;
+  if (isDb) {
+    const fromDb = await readFromDatabase(source.path, source.sessionId, deps);
+    if (fromDb) return fromDb;
+  }
+  return readFromStorage(local.join(root, "storage"), source.sessionId, source.path);
+}
+async function openSqlite(deps = {}) {
+  if (deps.sqlite) return deps.sqlite;
+  try {
+    const specifier = ["node", "sqlite"].join(":");
+    const mod = await import(
+      /* webpackIgnore: true */
+      /* @vite-ignore */
+      specifier
+    );
+    return {
+      open(path) {
+        const db = new mod.DatabaseSync(path, { readOnly: true });
+        return {
+          all: (sql, ...params) => db.prepare(sql).all(...params),
+          close: () => db.close()
+        };
+      }
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function readFromDatabase(dbPath, sessionId, deps) {
+  const sqlite = await openSqlite(deps);
+  if (!sqlite) return void 0;
+  let db;
+  try {
+    db = sqlite.open(dbPath);
+  } catch {
+    return void 0;
+  }
+  try {
+    const sessions = db.all(
+      "SELECT id, directory, title, time_created, time_updated FROM session WHERE id = ?",
+      sessionId
+    );
+    const row = sessions[0];
+    if (!row) throw new HandoffFault("conversation-not-found", sessionId);
+    const session = {
+      id: sessionId,
+      directory: readString(row["directory"]) ?? "",
+      created: readNumber(row["time_created"]),
+      updated: readNumber(row["time_updated"])
+    };
+    const title = readString(row["title"]);
+    if (title) session.title = title;
+    const messages = db.all("SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created, id", sessionId).map(rowOf).filter((r) => r !== void 0);
+    const parts = /* @__PURE__ */ new Map();
+    for (const raw of db.all(
+      "SELECT id, message_id, time_created, data FROM part WHERE session_id = ? ORDER BY time_created, id",
+      sessionId
+    )) {
+      const part = rowOf(raw);
+      const messageId = readString(raw["message_id"]);
+      if (!part || !messageId) continue;
+      const list2 = parts.get(messageId) ?? [];
+      list2.push(part);
+      parts.set(messageId, list2);
+    }
+    const bytes = readNumber(
+      db.all("SELECT COALESCE(SUM(LENGTH(data)), 0) AS bytes FROM message WHERE session_id = ?", sessionId)[0]?.["bytes"]
+    ) ?? 0;
+    const partBytes = readNumber(
+      db.all("SELECT COALESCE(SUM(LENGTH(data)), 0) AS bytes FROM part WHERE session_id = ?", sessionId)[0]?.["bytes"]
+    ) ?? 0;
+    return assemble(session, messages, parts, dbPath, bytes + partBytes);
+  } finally {
+    db.close();
+  }
+}
+function rowOf(raw) {
+  const id = readString(raw["id"]);
+  const created = readNumber(raw["time_created"]) ?? 0;
+  const data = raw["data"];
+  let parsed = data;
+  if (typeof data === "string") {
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      return void 0;
+    }
+  }
+  if (!id || !isRecord(parsed)) return void 0;
+  return { id, created, data: parsed };
+}
+async function readFromStorage(storage, sessionId, shownPath) {
+  const local = nativePath();
+  const sessionFile = await findSessionFile(local.join(storage, "session"), sessionId);
+  if (!sessionFile) throw new HandoffFault("conversation-not-found", sessionId);
+  const info = await readJson(sessionFile);
+  if (!isRecord(info)) throw new HandoffFault("unreadable-transcript", sessionFile);
+  const time = isRecord(info["time"]) ? info["time"] : {};
+  const session = {
+    id: sessionId,
+    directory: readString(info["directory"]) ?? "",
+    created: readNumber(time["created"]),
+    updated: readNumber(time["updated"])
+  };
+  const title = readString(info["title"]);
+  if (title) session.title = title;
+  let bytes = 0;
+  const messages = [];
+  const parts = /* @__PURE__ */ new Map();
+  const messageDir = local.join(storage, "message", sessionId);
+  for (const file of await listJson(messageDir)) {
+    const data = await readJson(local.join(messageDir, file));
+    bytes += (await stat5(local.join(messageDir, file)).catch(() => ({ size: 0 }))).size;
+    if (!isRecord(data)) continue;
+    const id = readString(data["id"]) ?? local.basename(file, ".json");
+    const created = isRecord(data["time"]) ? readNumber(data["time"]["created"]) ?? 0 : 0;
+    messages.push({ id, created, data });
+    const partDir = local.join(storage, "part", id);
+    const list2 = [];
+    for (const partFile of await listJson(partDir)) {
+      const part = await readJson(local.join(partDir, partFile));
+      bytes += (await stat5(local.join(partDir, partFile)).catch(() => ({ size: 0 }))).size;
+      if (!isRecord(part)) continue;
+      const partId = readString(part["id"]) ?? local.basename(partFile, ".json");
+      const time2 = isRecord(part["time"]) ? readNumber(part["time"]["start"]) ?? 0 : 0;
+      list2.push({ id: partId, created: time2, data: part });
+    }
+    parts.set(id, sortRows(list2));
+  }
+  return assemble(session, sortRows(messages), parts, shownPath, bytes);
+}
+function sortRows(rows) {
+  return rows.sort((a, b) => a.created - b.created || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+async function findSessionFile(sessionRoot, sessionId) {
+  const local = nativePath();
+  let projects;
+  try {
+    projects = await readdir2(sessionRoot);
+  } catch {
+    return void 0;
+  }
+  for (const project of projects) {
+    const candidate = local.join(sessionRoot, project, `${sessionId}.json`);
+    try {
+      if ((await stat5(candidate)).isFile()) return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function listJson(dir) {
+  try {
+    return (await readdir2(dir)).filter((name) => name.endsWith(".json")).sort();
+  } catch {
+    return [];
+  }
+}
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile5(path, "utf8"));
+  } catch (error) {
+    throw asHandoffFault(error, "unreadable-transcript");
+  }
+}
+async function readEnvelope(path, sessionId) {
+  const envelope = await readJson(path);
+  if (!isRecord(envelope) || !isRecord(envelope["info"]) || !Array.isArray(envelope["messages"])) {
+    throw new HandoffFault("unreadable-transcript", path);
+  }
+  const info = envelope["info"];
+  const time = isRecord(info["time"]) ? info["time"] : {};
+  const session = {
+    id: readString(info["id"]) ?? sessionId,
+    directory: readString(info["directory"]) ?? "",
+    created: readNumber(time["created"]),
+    updated: readNumber(time["updated"])
+  };
+  const title = readString(info["title"]);
+  if (title) session.title = title;
+  const messages = [];
+  const parts = /* @__PURE__ */ new Map();
+  for (const entry of envelope["messages"]) {
+    if (!isRecord(entry) || !isRecord(entry["info"])) continue;
+    const data = entry["info"];
+    const id = readString(data["id"]);
+    if (!id) continue;
+    const created = isRecord(data["time"]) ? readNumber(data["time"]["created"]) ?? 0 : 0;
+    messages.push({ id, created, data });
+    const list2 = [];
+    for (const part of Array.isArray(entry["parts"]) ? entry["parts"] : []) {
+      if (!isRecord(part)) continue;
+      list2.push({ id: readString(part["id"]) ?? "", created: 0, data: part });
+    }
+    parts.set(id, list2);
+  }
+  const bytes = (await stat5(path)).size;
+  return assemble(session, messages, parts, path, bytes);
+}
+function assemble(session, messages, partsByMessage, path, bytes) {
+  const builder = new TurnBuilder();
+  const compactions = [];
+  const dropped = emptyDropped();
+  const head = {
+    agent: "opencode",
+    sessionId: session.id,
+    path,
+    cwd: session.directory,
+    updatedAt: isoFromEpochMs(session.updated) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    bytes,
+    compacted: false
+  };
+  const startedAt = isoFromEpochMs(session.created);
+  if (startedAt) head.startedAt = startedAt;
+  if (session.title) head.title = session.title;
+  let limit;
+  let pendingSummary = false;
+  for (const message of messages) {
+    const data = message.data;
+    const role = data["role"];
+    const at = isoFromEpochMs(isRecord(data["time"]) ? data["time"]["created"] : message.created);
+    const parts = partsByMessage.get(message.id) ?? [];
+    if (role !== "user" && role !== "assistant") {
+      dropped.other += 1;
+      continue;
+    }
+    if (role === "user") {
+      if (parts.some((p) => p.data["type"] === "compaction")) {
+        builder.reset();
+        compactions.length = 0;
+        head.compacted = true;
+        pendingSummary = true;
+        continue;
+      }
+      for (const part of parts) userPart(part.data, builder, dropped, at);
+      continue;
+    }
+    const provider = readString(data["providerID"]);
+    const model = readString(data["modelID"]);
+    if (model) head.model = provider ? `${provider}/${model}` : model;
+    const error = data["error"];
+    if (isRecord(error)) {
+      limit = limitOf3(error, at) ?? limit;
+      if (parts.every((p) => p.data["type"] !== "text")) {
+        dropped.other += 1;
+        continue;
+      }
+    } else {
+      limit = void 0;
+    }
+    if (pendingSummary && data["summary"] === true) {
+      pendingSummary = false;
+      const text = parts.filter((p) => p.data["type"] === "text").map((p) => readString(p.data["text"]) ?? "").filter((t) => t.length > 0).join("\n");
+      builder.open("user", [{ kind: "summary", text }], at);
+      const compaction = { text };
+      if (at) compaction.at = at;
+      compactions.push(compaction);
+      continue;
+    }
+    for (const part of parts) assistantPart(part.data, builder, dropped, at);
+  }
+  if (limit) head.limit = limit;
+  return finishConversation(head, builder.turns, compactions, dropped);
+}
+function userPart(data, builder, dropped, at) {
+  const type = data["type"];
+  if (type === "text") {
+    const text = readString(data["text"]);
+    if (text) builder.push("user", { kind: "text", text }, at);
+  } else if (type === "file") {
+    const mime = readString(data["mime"]) ?? "";
+    if (mime.startsWith("image/")) dropped.images += 1;
+    else dropped.other += 1;
+  } else {
+    dropped.other += 1;
+  }
+}
+function assistantPart(data, builder, dropped, at) {
+  const type = data["type"];
+  if (type === "text") {
+    const text = readString(data["text"]);
+    if (text) builder.push("assistant", { kind: "text", text }, at);
+    return;
+  }
+  if (type === "tool") {
+    const id = readString(data["callID"]) ?? readString(data["id"]);
+    const name = readString(data["tool"]) ?? "tool";
+    if (!id) return;
+    const state = isRecord(data["state"]) ? data["state"] : {};
+    builder.push("assistant", { kind: "tool_call", id, name, input: state["input"] ?? {} }, at);
+    const status = readString(state["status"]);
+    if (status === "completed" || status === "error") {
+      const output = readString(state["output"]) ?? readString(state["error"]) ?? "";
+      const result = { kind: "tool_result", callId: id, output };
+      builder.push("user", status === "error" ? { ...result, isError: true } : result, at);
+    }
+    return;
+  }
+  if (type === "reasoning") {
+    dropped.thinking += 1;
+    return;
+  }
+  if (type === "subtask") {
+    dropped.subagents += 1;
+    return;
+  }
+  if (type === "file") {
+    const mime = readString(data["mime"]) ?? "";
+    if (mime.startsWith("image/")) dropped.images += 1;
+    else dropped.other += 1;
+    return;
+  }
+}
+function limitOf3(error, at) {
+  const data = isRecord(error["data"]) ? error["data"] : {};
+  const status = readNumber(data["statusCode"]);
+  if (status !== 429 && status !== 402) return void 0;
+  return { at: at ?? "", kind: status === 429 ? "rate-limit" : "credits" };
+}
+async function readConversation(source, options = {}, deps = {}) {
+  switch (source.agent) {
+    case "claude-cli":
+      return readClaudeConversation(source.path, options);
+    case "codex-cli":
+      return readCodexConversation(source.path, options);
+    case "opencode": {
+      if (!source.sessionId) throw new HandoffFault("invalid-id", "an OpenCode session id is needed");
+      const opencodeDeps = deps.sqlite ? { sqlite: deps.sqlite } : {};
+      return readOpencodeConversation({ path: source.path, sessionId: source.sessionId }, options, opencodeDeps);
+    }
+    case "gemini-cli":
+      return readGeminiConversation(source.path, options, deps.cwds ? { cwds: deps.cwds } : {});
+    default:
+      throw new HandoffFault("unsupported-target", source.agent);
+  }
+}
+var TITLE_CHARS = 80;
+var GOAL_CHARS = 600;
+var LINE_CHARS = 200;
+var EXCHANGE_CHARS = 600;
+var MAX_DECISIONS = 8;
+var MAX_FILES = 40;
+var MAX_COMMANDS = 30;
+var MAX_OPEN_ITEMS = 8;
+var DECISION_STARTS = /^(?:[-*•]\s*)?(?:\*\*)?(?:decision|decided|we will|we'll|i'll|i will|let's go with|going with|chose|choosing|settled on|the plan is)\b/i;
+var OPEN_ITEM_LINE = /^(?:[-*•]\s*\[ \]\s*|(?:[-*•]|\d+[.)])\s*(?:todo|next|then|remaining|pending|still|left to|to do)\b|todo\b|next(?: step)?s?\b|pending\b|remaining\b|still to\b|left to\b)/i;
+var OPEN_ITEM_HEADING = /^#{0,6}\s*(?:\*\*)?(?:next steps?|open items?|remaining|pending|todos?|what's left|left to do)(?:\*\*)?\s*:?\s*$/i;
+var WRITE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit", "apply_patch", "edit", "write", "multiedit"]);
+var PATH_KEYS = ["file_path", "path", "notebook_path", "filePath"];
+var PATCH_FILE = /^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm;
+var SHELL_TOOLS = /* @__PURE__ */ new Set(["Bash", "bash", "exec", "shell", "exec_command", "run_shell_command", "shell_command"]);
+var COMMAND_MARKER = /^\s*<command-(?:name|message)>[\s\S]*$/;
+function digestConversation(conversation) {
+  const turns = conversation.turns;
+  const firstUser = firstText(turns, "user", (text) => !COMMAND_MARKER.test(text)) ?? firstText(turns, "user");
+  const title = conversation.title ?? (firstUser ? cutLine(firstLine(firstUser), TITLE_CHARS) : "Untitled conversation");
+  const goal = firstUser ? cut2(firstUser, GOAL_CHARS) : "";
+  const summary = conversation.compactions[conversation.compactions.length - 1]?.text;
+  const decisions = [];
+  const files = /* @__PURE__ */ new Set();
+  const commands = [];
+  let toolCalls = 0;
+  for (const turn of turns) {
+    for (const part of turn.parts) {
+      if (part.kind === "text" && turn.role === "assistant") {
+        for (const line2 of part.text.split(/\r?\n/)) {
+          const clean = line2.trim();
+          if (decisions.length < MAX_DECISIONS && DECISION_STARTS.test(clean)) decisions.push(cutLine(clean, LINE_CHARS));
+        }
+      }
+      if (part.kind !== "tool_call") continue;
+      toolCalls += 1;
+      for (const file of filesOf(part)) if (files.size < MAX_FILES) files.add(file);
+      const command = commandOf(part);
+      if (command && commands.length < MAX_COMMANDS) commands.push(cutLine(command, LINE_CHARS));
+    }
+  }
+  const lastUser = lastText(turns, "user");
+  const lastAssistant = lastText(turns, "assistant");
+  const lastExchange = {};
+  if (lastUser) lastExchange.user = cut2(lastUser, EXCHANGE_CHARS);
+  if (lastAssistant) lastExchange.assistant = cut2(lastAssistant, EXCHANGE_CHARS);
+  const digest = {
+    by: "panoma",
+    title,
+    goal,
+    decisions,
+    filesTouched: [...files],
+    commandsRun: commands,
+    openItems: lastAssistant ? openItemsOf(lastAssistant) : [],
+    lastExchange,
+    stats: { turns: turns.length, toolCalls, estimatedTokens: estimateTokens(textOfTurns(turns)) }
+  };
+  if (summary) digest.summary = summary;
+  return digest;
+}
+function textOfTurns(turns) {
+  return turns.map((turn) => turn.parts.map(textOfPart).join("\n")).join("\n");
+}
+function firstText(turns, role, keep = () => true) {
+  for (const turn of turns) {
+    if (turn.role !== role) continue;
+    const part = turn.parts.find((p) => p.kind === "text" && p.text.trim().length > 0 && keep(p.text.trim()));
+    if (part && part.kind === "text") return part.text.trim();
+  }
+  return void 0;
+}
+function lastText(turns, role) {
+  for (let i = turns.length - 1; i >= 0; i -= 1) {
+    const turn = turns[i];
+    if (turn.role !== role) continue;
+    const texts = turn.parts.filter((p) => p.kind === "text" && p.text.trim().length > 0);
+    if (texts.length > 0) return texts.map((p) => p.text.trim()).join("\n\n");
+  }
+  return void 0;
+}
+function filesOf(part) {
+  const found = [];
+  const input = part.input;
+  if (WRITE_TOOLS.has(part.name)) {
+    if (typeof input === "object" && input !== null) {
+      for (const key of PATH_KEYS) {
+        const value = input[key];
+        if (typeof value === "string" && value.length > 0) found.push(value);
+      }
+      const patch = input["patch"] ?? input["input"];
+      if (typeof patch === "string") for (const m of patch.matchAll(PATCH_FILE)) found.push(m[1].trim());
+    } else if (typeof input === "string") {
+      for (const m of input.matchAll(PATCH_FILE)) found.push(m[1].trim());
+    }
+  }
+  const command = commandOf(part);
+  if (command) found.push(...movedFiles(command));
+  return found;
+}
+function movedFiles(command) {
+  const found = [];
+  for (const segment of command.split(/\s*(?:&&|\|\||;|\|)\s*/)) {
+    const words = shellWords(segment);
+    const verb = words[0];
+    if (verb !== "mv" && verb !== "cp" && verb !== "touch") continue;
+    for (const word of words.slice(1)) {
+      if (word.startsWith("-") || word.length === 0 || /^\\+$/.test(word)) continue;
+      found.push(word);
+    }
+  }
+  return found;
+}
+function shellWords(segment) {
+  const words = [];
+  let current = "";
+  let quote;
+  let has = false;
+  for (const char of segment) {
+    if (quote) {
+      if (char === quote) quote = void 0;
+      else current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      has = true;
+    } else if (/\s/.test(char)) {
+      if (has) words.push(current);
+      current = "";
+      has = false;
+    } else {
+      current += char;
+      has = true;
+    }
+  }
+  if (has) words.push(current);
+  return words;
+}
+function commandOf(part) {
+  if (!SHELL_TOOLS.has(part.name)) return void 0;
+  const input = part.input;
+  if (typeof input === "string") return commandInScript(input);
+  if (typeof input !== "object" || input === null) return void 0;
+  const record2 = input;
+  const direct = record2["command"] ?? record2["cmd"];
+  if (typeof direct === "string") return oneLine(direct);
+  if (Array.isArray(direct)) return oneLine(direct.map(String).join(" "));
+  return void 0;
+}
+function commandInScript(script) {
+  const match = /"cmd"\s*:\s*"((?:[^"\\]|\\.)*)"/.exec(script);
+  if (!match) return void 0;
+  try {
+    return oneLine(JSON.parse(`"${match[1]}"`));
+  } catch {
+    return void 0;
+  }
+}
+function openItemsOf(text) {
+  const items = [];
+  let underHeading = false;
+  for (const raw of text.split(/\r?\n/)) {
+    const line2 = raw.trim();
+    if (line2.length === 0) {
+      underHeading = false;
+      continue;
+    }
+    if (OPEN_ITEM_HEADING.test(line2)) {
+      underHeading = true;
+      continue;
+    }
+    const listed = /^(?:[-*•]|\d+[.)])\s+/.test(line2);
+    if (underHeading && listed || OPEN_ITEM_LINE.test(line2)) {
+      items.push(cutLine(line2.replace(/^(?:[-*•]|\d+[.)])\s+/, ""), LINE_CHARS));
+      if (items.length >= MAX_OPEN_ITEMS) break;
+    } else if (!listed) {
+      underHeading = false;
+    }
+  }
+  return items;
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function firstLine(text) {
+  return text.split(/\r?\n/).map((l) => l.trim()).find((l) => l.length > 0) ?? "";
+}
+function cutLine(text, max) {
+  const line2 = oneLine(text);
+  return line2.length > max ? `${line2.slice(0, max - 1).trimEnd()}\u2026` : line2;
+}
+function cut2(text, max) {
+  const clean = text.trim();
+  return clean.length > max ? `${clean.slice(0, max - 1).trimEnd()}\u2026` : clean;
+}
+function digestMarkdown(digest) {
+  const lines = [`# ${digest.title}`, ""];
+  if (digest.goal) lines.push("## Goal", "", digest.goal, "");
+  if (digest.summary) lines.push("## Summary", "", digest.summary.trim(), "");
+  if (digest.decisions.length > 0) lines.push("## Decisions", "", ...digest.decisions.map((d) => `- ${d}`), "");
+  if (digest.filesTouched.length > 0) lines.push("## Files touched", "", ...digest.filesTouched.map((f) => `- \`${f}\``), "");
+  if (digest.commandsRun.length > 0) lines.push("## Commands run", "", ...digest.commandsRun.map((c) => `- \`${c}\``), "");
+  if (digest.openItems.length > 0) lines.push("## Open items", "", ...digest.openItems.map((o) => `- ${o}`), "");
+  if (digest.lastExchange.user || digest.lastExchange.assistant) {
+    lines.push("## Last exchange", "");
+    if (digest.lastExchange.user) lines.push(`**User:** ${digest.lastExchange.user}`, "");
+    if (digest.lastExchange.assistant) lines.push(`**Assistant:** ${digest.lastExchange.assistant}`, "");
+  }
+  const { turns, toolCalls, estimatedTokens } = digest.stats;
+  lines.push(`_Digest by ${digest.by} \xB7 tool calls: ${toolCalls} \xB7 tokens (estimated): ${estimatedTokens} \xB7 turns: ${turns}_`);
+  return `${lines.join("\n")}
+`;
+}
+function compactConversation(conversation, digest, options = {}) {
+  const keep = Math.max(1, Math.floor(options.keepTurns ?? KEEP_TURNS_DEFAULT));
+  const source = conversation.turns;
+  let start = Math.max(0, source.length - keep);
+  while (start < source.length && source[start].parts.every((part) => part.kind === "summary")) start += 1;
+  const first = source[start];
+  if (start > 0 && first && first.role === "user" && first.parts.some((part) => part.kind === "tool_result")) {
+    start -= 1;
+  }
+  const kept = source.slice(start).map((turn) => ({ ...turn, parts: [...turn.parts] }));
+  const summary = { role: "user", parts: [{ kind: "summary", text: digestMarkdown(digest) }] };
+  const at = kept[0]?.at ?? conversation.startedAt;
+  if (at) summary.at = at;
+  const turns = [summary, ...kept];
+  return {
+    ...conversation,
+    turns,
+    turnCount: turns.length,
+    compacted: true,
+    hash: hashTurns(turns),
+    compactions: [...conversation.compactions],
+    dropped: { ...conversation.dropped }
+  };
+}
+var Redactor = class {
+  count = 0;
+  text(value) {
+    const out = redactSecrets(value);
+    if (out !== value) this.count += marks(out) - marks(value);
+    return out;
+  }
+};
+function marks(text) {
+  return text.split(REDACTED).length - 1;
+}
+function withProvenance(turns, request) {
+  const { conversation, tier, now } = request;
+  const line2 = provenanceLine(conversation.agent, conversation.sessionId, tier, now);
+  const copy = turns.map((turn) => ({ ...turn, parts: turn.parts.map((part2) => ({ ...part2 })) }));
+  const first = copy[0];
+  const part = first?.parts[0];
+  if (first && first.role === "user" && part && (part.kind === "text" || part.kind === "summary")) {
+    part.text = `${line2}
+
+${part.text}`;
+    return copy;
+  }
+  return [{ role: "user", parts: [{ kind: "text", text: line2 }] }, ...copy];
+}
+function balanceTurns(turns, dropped) {
+  const out = [];
+  const open2 = /* @__PURE__ */ new Set();
+  for (const turn of turns) {
+    const parts = [];
+    for (const part of turn.parts) {
+      if (part.kind === "tool_result") {
+        if (!open2.has(part.callId)) {
+          dropped.other += 1;
+          continue;
+        }
+        open2.delete(part.callId);
+      }
+      if (part.kind === "tool_call") open2.add(part.id);
+      parts.push(part);
+    }
+    if (turn.role === "user" && open2.size > 0) {
+      const missing = [...open2].map((callId) => ({ kind: "tool_result", callId, output: "(result not carried)" }));
+      open2.clear();
+      parts.unshift(...missing);
+    }
+    if (parts.length > 0) out.push({ ...turn, parts });
+  }
+  if (open2.size > 0) {
+    out.push({
+      role: "user",
+      parts: [...open2].map((callId) => ({ kind: "tool_result", callId, output: "(result not carried)" }))
+    });
+  }
+  return out;
+}
+async function writeAtomic(path, content, dir, id, mode = 384) {
+  const temp = nativePath().join(dir, `.panoma-${id}.tmp`);
+  try {
+    await mkdir(dir, { recursive: true });
+    await writeFile(temp, content, { encoding: "utf8", mode });
+    await rename(temp, path);
+  } catch (error) {
+    await rm(temp, { force: true }).catch(() => void 0);
+    throw asHandoffFault(error, "write-failed");
+  }
+  return Buffer.byteLength(content, "utf8");
+}
+function resultOf(agent, request, sessionId, path, turns, bytes, redactor, steps = []) {
+  const { conversation, tier, now, cwd, platform } = request;
+  const surface = request.surface ?? "cli";
+  return {
+    agent,
+    surface,
+    sessionId,
+    path,
+    resume: resumeOf(agent, sessionId, cwd, platform),
+    resumeInApp: resumeInApp(agent, sessionId, cwd, platform),
+    steps,
+    fidelity: fidelityOf(agent),
+    provenance: {
+      sourceAgent: conversation.agent,
+      sourceSessionId: conversation.sessionId,
+      sourceHash: conversation.hash,
+      tier,
+      at: now.toISOString(),
+      by: "panoma"
+    },
+    turns,
+    bytes,
+    dropped: { ...conversation.dropped, secrets: conversation.dropped.secrets + redactor.count }
+  };
+}
+function clock(now) {
+  let ms = now.getTime();
+  return () => new Date(ms++);
+}
+function briefMarkdown(conversation, digest, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const redactor = options.redactor ?? new Redactor();
+  const keep = Math.max(0, Math.floor(options.keepTurns ?? KEEP_TURNS_DEFAULT));
+  const recent = keep > 0 ? conversation.turns.slice(-keep) : [];
+  const lines = [
+    provenanceLine(conversation.agent, conversation.sessionId, "brief", now),
+    "",
+    redactor.text(digestMarkdown(digest)).trimEnd(),
+    ""
+  ];
+  if (recent.length > 0) {
+    lines.push(`## Last turns (${AGENT_NAMES[conversation.agent]})`, "");
+    for (const turn of recent) lines.push(...renderTurn(turn, redactor), "");
+  }
+  lines.push(
+    "---",
+    "",
+    "This document was written by panoma from a conversation kept by another agent. Continue the work from here; the original transcript was not modified."
+  );
+  return `${lines.join("\n")}
+`;
+}
+function renderTurn(turn, redactor) {
+  const who = turn.role === "user" ? "User" : "Assistant";
+  const body = turn.parts.map((part) => part.kind === "text" || part.kind === "summary" ? part.text : `\`\`\`
+${textOfPart(part)}
+\`\`\``).join("\n\n");
+  return [`### ${who}`, "", redactor.text(body).trimEnd()];
+}
+async function writeBrief(path, markdown) {
+  try {
+    await mkdir2(nativePath().dirname(path), { recursive: true });
+    await writeFile2(path, markdown, { encoding: "utf8", mode: 384 });
+  } catch (error) {
+    throw asHandoffFault(error, "write-failed");
+  }
+  return Buffer.byteLength(markdown, "utf8");
+}
+var CLAUDE_RECORD_VERSION = HANDOFF_CLAUDE_RECORD_VERSION;
+async function writeClaudeConversation(request) {
+  const { conversation, cwd, gitBranch, random, now, platform, title } = request;
+  const store = claudeStoreAt(request.root, { home: request.root, env: {}, platform });
+  const sessionId = random.uuid();
+  const dir = claudeProjectDir(store, cwd);
+  const path = store.resolved.path.join(dir, `${sessionId}.jsonl`);
+  const redactor = new Redactor();
+  const dropped = { ...conversation.dropped };
+  const turns = balanceTurns(withProvenance(conversation.turns, request), dropped);
+  const tick = clock(now);
+  const records = [];
+  let parent = null;
+  const envelope = (at) => {
+    const base = {
+      parentUuid: parent,
+      isSidechain: false,
+      userType: "external",
+      cwd,
+      sessionId,
+      version: CLAUDE_RECORD_VERSION,
+      timestamp: at ?? tick().toISOString()
+    };
+    if (gitBranch) base["gitBranch"] = gitBranch;
+    return base;
+  };
+  const push = (record2) => {
+    const uuid = random.uuid();
+    records.push({ ...record2, uuid });
+    parent = uuid;
+  };
+  const shownTitle = title ?? conversation.title;
+  if (shownTitle) {
+    records.push({ type: "custom-title", customTitle: redactor.text(shownTitle), sessionId });
+  }
+  for (const turn of turns) {
+    if (turn.role === "user") {
+      const rest = [];
+      for (const part of turn.parts) {
+        if (part.kind !== "summary") {
+          rest.push(part);
+          continue;
+        }
+        const boundaryAt = turn.at ?? tick().toISOString();
+        const boundaryUuid = random.uuid();
+        records.push({
+          parentUuid: null,
+          logicalParentUuid: parent,
+          isSidechain: false,
+          type: "system",
+          subtype: "compact_boundary",
+          content: "Conversation compacted",
+          isMeta: false,
+          level: "info",
+          compactMetadata: { trigger: "manual", preTokens: 0, postTokens: 0 },
+          uuid: boundaryUuid,
+          timestamp: boundaryAt,
+          sessionId,
+          cwd,
+          version: CLAUDE_RECORD_VERSION
+        });
+        parent = boundaryUuid;
+        push({
+          ...envelope(turn.at),
+          type: "user",
+          message: { role: "user", content: redactor.text(part.text) },
+          isCompactSummary: true,
+          isVisibleInTranscriptOnly: true
+        });
+      }
+      if (rest.length === 0) continue;
+      push({ ...envelope(turn.at), type: "user", message: { role: "user", content: userContent(rest, redactor) } });
+      continue;
+    }
+    const messageId = `msg_${random.hex(12)}`;
+    const blocks = assistantBlocks(turn.parts, redactor);
+    if (blocks.length === 0) continue;
+    blocks.forEach((block, index) => {
+      push({
+        ...envelope(turn.at),
+        type: "assistant",
+        message: {
+          id: messageId,
+          type: "message",
+          role: "assistant",
+          content: [block],
+          stop_reason: index === blocks.length - 1 ? block["type"] === "tool_use" ? "tool_use" : "end_turn" : null,
+          stop_sequence: null
+        },
+        apiBlockIndex: index
+      });
+    });
+  }
+  const content = `${records.map((record2) => JSON.stringify(record2)).join("\n")}
+`;
+  const bytes = await writeAtomic(path, content, dir, sessionId);
+  const result = resultOf("claude-cli", request, sessionId, path, turns.length, bytes, redactor);
+  result.dropped = { ...dropped, secrets: dropped.secrets + redactor.count };
+  return result;
+}
+function userContent(parts, redactor) {
+  if (parts.length === 1 && parts[0].kind === "text") return redactor.text(parts[0].text);
+  const blocks = [];
+  for (const part of parts) {
+    if (part.kind === "text") blocks.push({ type: "text", text: redactor.text(part.text) });
+    else if (part.kind === "tool_result") {
+      const block = {
+        tool_use_id: part.callId,
+        type: "tool_result",
+        content: redactor.text(part.output)
+      };
+      if (part.isError) block["is_error"] = true;
+      blocks.push(block);
+    }
+  }
+  return blocks;
+}
+function assistantBlocks(parts, redactor) {
+  const blocks = [];
+  for (const part of parts) {
+    if (part.kind === "text" || part.kind === "summary") {
+      blocks.push({ type: "text", text: redactor.text(part.text) });
+    } else if (part.kind === "tool_call") {
+      blocks.push({ type: "tool_use", id: part.id, name: part.name, input: toolUseInput(redactInput(part.input, redactor)) });
+    } else {
+      blocks.push({ type: "text", text: redactor.text(`[tool result]
+${part.output}`) });
+    }
+  }
+  return blocks;
+}
+function toolUseInput(input) {
+  if (typeof input === "object" && input !== null && !Array.isArray(input)) return input;
+  return { input: input ?? "" };
+}
+function redactInput(input, redactor) {
+  if (typeof input === "string") return redactor.text(input);
+  if (Array.isArray(input)) return input.map((item) => redactInput(item, redactor));
+  if (typeof input === "object" && input !== null) {
+    const out = {};
+    for (const [key, value] of Object.entries(input)) out[key] = redactInput(value, redactor);
+    return out;
+  }
+  return input;
+}
+var CODEX_ORIGINATOR = "panoma";
+var CODEX_CLI_VERSION = "0.0.0-panoma";
+async function writeCodexConversation(request) {
+  const { conversation, cwd, gitBranch, random, now, platform, title } = request;
+  const store = codexStoreAt(request.root, { home: request.root, env: {}, platform });
+  const sessionId = random.uuid();
+  const path = codexRolloutPath(store, now, sessionId);
+  const dir = store.resolved.path.dirname(path);
+  const redactor = new Redactor();
+  const turns = withProvenance(conversation.turns, request);
+  const tick = clock(now);
+  const lines = [];
+  const meta = {
+    session_id: sessionId,
+    id: sessionId,
+    timestamp: now.toISOString(),
+    cwd,
+    originator: CODEX_ORIGINATOR,
+    cli_version: CODEX_CLI_VERSION,
+    source: "cli"
+  };
+  if (gitBranch) meta["git"] = { branch: gitBranch };
+  lines.push({ timestamp: now.toISOString(), type: "session_meta", payload: meta });
+  for (const turn of turns) {
+    const at = turn.at ?? tick().toISOString();
+    const texts = turn.parts.map((part) => redactor.text(textOfPart(part))).filter((t) => t.length > 0);
+    if (texts.length === 0) continue;
+    const message = turn.role === "user" ? { type: "message", role: "user", content: texts.map((text) => ({ type: "input_text", text })) } : { type: "message", role: "assistant", content: texts.map((text) => ({ type: "output_text", text })) };
+    lines.push({ timestamp: at, type: "response_item", payload: message });
+    lines.push({
+      timestamp: at,
+      type: "event_msg",
+      payload: { type: turn.role === "user" ? "user_message" : "agent_message", message: texts.join("\n\n") }
+    });
+  }
+  lines.push(threadSettingsApplied(sessionId, cwd, await codexModelSettings(store), tick().toISOString()));
+  const content = `${lines.map((line2) => JSON.stringify(line2)).join("\n")}
+`;
+  const bytes = await writeAtomic(path, content, dir, sessionId);
+  const shownTitle = title ?? conversation.title;
+  if (shownTitle) {
+    const entry = { id: sessionId, thread_name: redactor.text(shownTitle), updated_at: now.toISOString() };
+    try {
+      await appendFile(store.index, `${JSON.stringify(entry)}
+`, "utf8");
+    } catch {
+    }
+  }
+  return resultOf("codex-cli", request, sessionId, path, countWritten(turns), bytes, redactor);
+}
+function threadSettingsApplied(sessionId, cwd, settings, at) {
+  const { model, reasoningEffort, approvalPolicy, sandboxMode } = settings;
+  return {
+    timestamp: at,
+    type: "event_msg",
+    payload: {
+      type: "thread_settings_applied",
+      thread_id: sessionId,
+      thread_settings: {
+        model,
+        model_provider_id: "openai",
+        approval_policy: approvalPolicy,
+        approvals_reviewer: "user",
+        permission_profile: permissionProfile(sandboxMode, cwd),
+        cwd,
+        reasoning_effort: reasoningEffort,
+        collaboration_mode: { mode: "default", settings: { model, reasoning_effort: reasoningEffort, developer_instructions: null } }
+      }
+    }
+  };
+}
+function permissionProfile(sandboxMode, cwd) {
+  if (sandboxMode === "danger-full-access") return { type: "disabled" };
+  const entries = [{ path: { type: "special", value: { kind: "root" } }, access: "read" }];
+  if (sandboxMode !== "read-only") entries.push({ path: { type: "path", path: cwd }, access: "write" });
+  entries.push(
+    { path: { type: "special", value: { kind: "slash_tmp" } }, access: "write" },
+    { path: { type: "special", value: { kind: "tmpdir" } }, access: "write" }
+  );
+  return { type: "managed", file_system: { type: "restricted", entries } };
+}
+function countWritten(turns) {
+  return turns.filter((turn) => turn.parts.some((part) => textOfPart(part).length > 0)).length;
+}
+var OPENCODE_PROVIDER = "panoma";
+var OPENCODE_MODEL = "handoff";
+var OPENCODE_VERSION = "0.0.0-panoma";
+async function writeOpencodeConversation(request) {
+  const { conversation, cwd, random, now, platform, title } = request;
+  const store = opencodeStoreAt(request.root, { home: request.root, env: {}, platform });
+  const redactor = new Redactor();
+  const turns = withProvenance(conversation.turns, request);
+  const tick = clock(now);
+  let counter = 0;
+  const nextId = (prefix, at) => opencodeId(prefix, at, counter++, random);
+  const sessionId = nextId("ses", now);
+  const path = opencodeEnvelopePath(store, sessionId);
+  const shownTitle = redactor.text(title ?? conversation.title ?? "Handed off by panoma");
+  const messages = [];
+  let lastUser;
+  let written = 0;
+  const userMessage = (at, parts, id) => {
+    lastUser = id;
+    messages.push({
+      info: {
+        id,
+        sessionID: sessionId,
+        role: "user",
+        time: { created: at.getTime() },
+        agent: "build",
+        model: { providerID: OPENCODE_PROVIDER, modelID: OPENCODE_MODEL }
+      },
+      parts
+    });
+  };
+  const assistantMessage = (at, parts, id, summary) => {
+    const info = {
+      id,
+      sessionID: sessionId,
+      role: "assistant",
+      time: { created: at.getTime(), completed: at.getTime() },
+      parentID: lastUser ?? id,
+      modelID: OPENCODE_MODEL,
+      providerID: OPENCODE_PROVIDER,
+      mode: summary ? "compaction" : "build",
+      agent: summary ? "compaction" : "build",
+      path: { cwd, root: cwd },
+      cost: 0,
+      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+      finish: "stop"
+    };
+    if (summary) info["summary"] = true;
+    messages.push({ info, parts });
+  };
+  const textPart = (messageId, at, text) => ({
+    id: nextId("prt", at),
+    sessionID: sessionId,
+    messageID: messageId,
+    type: "text",
+    text,
+    time: { start: at.getTime(), end: at.getTime() }
+  });
+  for (const turn of turns) {
+    const at = turn.at ? new Date(turn.at) : tick();
+    const when = Number.isNaN(at.getTime()) ? tick() : at;
+    const summary = turn.parts.find((part) => part.kind === "summary");
+    if (summary) {
+      const compactionId = nextId("msg", when);
+      userMessage(when, [{
+        id: nextId("prt", when),
+        sessionID: sessionId,
+        messageID: compactionId,
+        type: "compaction",
+        auto: false
+      }], compactionId);
+      const summaryId = nextId("msg", when);
+      assistantMessage(when, [textPart(summaryId, when, redactor.text(summary.text))], summaryId, true);
+      written += 1;
+    }
+    const texts = turn.parts.filter((part) => part.kind !== "summary").map((part) => redactor.text(textOfPart(part))).filter((text) => text.length > 0);
+    if (texts.length === 0) continue;
+    const id = nextId("msg", when);
+    const parts = texts.map((text) => textPart(id, when, text));
+    if (turn.role === "user") userMessage(when, parts, id);
+    else assistantMessage(when, parts, id, false);
+    written += 1;
+  }
+  const envelope = {
+    info: {
+      id: sessionId,
+      slug: `handoff-${sessionId.slice(-6).toLowerCase()}`,
+      projectID: "global",
+      directory: cwd,
+      title: shownTitle,
+      version: OPENCODE_VERSION,
+      time: { created: now.getTime(), updated: tick().getTime() }
+    },
+    messages
+  };
+  const content = `${JSON.stringify(envelope, null, 2)}
+`;
+  const bytes = await writeAtomic(path, content, store.root, sessionId, 384);
+  const steps = [`opencode import ${quoteForShell(path, platform)}`];
+  return resultOf("opencode", request, sessionId, path, written, bytes, redactor, steps);
+}
+async function writeGeminiConversation(request) {
+  const { conversation, cwd, random, now, platform, title } = request;
+  const store = geminiStoreAt(request.root, { home: request.root, env: {}, platform });
+  const sessionId = random.uuid();
+  const projectId = geminiProjectId(store, cwd);
+  const path = geminiChatPath(store, projectId, now, sessionId);
+  const dir = store.resolved.path.dirname(path);
+  const redactor = new Redactor();
+  const turns = withProvenance(conversation.turns, request);
+  const tick = clock(now);
+  const lines = [];
+  let written = 0;
+  let last = now.toISOString();
+  for (const turn of turns) {
+    const at = turn.at ?? tick().toISOString();
+    const texts = turn.parts.map((part) => redactor.text(textOfPart(part))).filter((t) => t.length > 0);
+    if (texts.length === 0) continue;
+    lines.push({
+      id: random.uuid(),
+      timestamp: at,
+      type: turn.role === "user" ? "user" : "gemini",
+      content: texts.map((text) => ({ text }))
+    });
+    written += 1;
+    last = at;
+  }
+  lines.unshift({
+    sessionId,
+    projectHash: projectId,
+    startTime: turns[0]?.at ?? now.toISOString(),
+    lastUpdated: last,
+    kind: "main"
+  });
+  const shownTitle = title ?? conversation.title;
+  if (shownTitle) lines.push({ $set: { summary: redactor.text(shownTitle) } });
+  const content = `${lines.map((line2) => JSON.stringify(line2)).join("\n")}
+`;
+  const bytes = await writeAtomic(path, content, dir, sessionId);
+  return resultOf("gemini-cli", request, sessionId, path, written, bytes, redactor);
+}
+async function scopeOf(cwd, platform) {
+  if (!cwd) return void 0;
+  const given = cwd.replace(/[\\/]+$/, "") || cwd;
+  const real = await realFolder(given);
+  return { folders: [.../* @__PURE__ */ new Set([given, real])], platform };
+}
+function inScope(scope, cwd) {
+  return scope.folders.some((folder) => insideFolder(cwd, folder, scope.platform));
+}
+async function discoverConversations(options = {}) {
+  const resolved = resolveStoreOptions(options);
+  const limit = Math.max(1, Math.floor(options.limit ?? DISCOVERY_LIMIT_DEFAULT));
+  const agents = options.agents ?? NATIVE_AGENTS;
+  const scope = await scopeOf(options.cwd, resolved.platform);
+  const conversations = [];
+  const stores2 = [];
+  for (const agent of agents) {
+    const listed = await listStore(agent, options, limit, scope);
+    if (!listed) continue;
+    stores2.push(listed.report);
+    conversations.push(...listed.refs);
+  }
+  const filtered = scope ? conversations.filter((ref) => inScope(scope, ref.cwd)) : conversations;
+  filtered.sort((a, b) => a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : a.id.localeCompare(b.id));
+  return { conversations: filtered, stores: stores2 };
+}
+async function listStore(agent, options, limit, scope) {
+  switch (agent) {
+    case "claude-cli":
+      return listClaude(options, limit, scope);
+    case "codex-cli":
+      return listCodex(options, limit, scope);
+    case "opencode":
+      return listOpencode(options, limit, scope);
+    case "gemini-cli":
+      return listGemini(options, limit, scope);
+    default:
+      return void 0;
+  }
+}
+function newest(candidates, limit) {
+  return candidates.sort((a, b) => b.mtimeMs - a.mtimeMs || a.path.localeCompare(b.path)).slice(0, limit);
+}
+async function withinScope(candidates, scope, placed) {
+  const kept = [];
+  for (const candidate of candidates) {
+    let place;
+    try {
+      place = placed(await readHead(candidate));
+    } catch {
+      place = void 0;
+    }
+    if (place === null) continue;
+    if (place === void 0 || inScope(scope, place)) kept.push(candidate);
+  }
+  return kept;
+}
+async function readHead(candidate) {
+  const handle = await open(candidate.path, "r");
+  try {
+    const size2 = Math.min(candidate.bytes, DISCOVERY_WINDOW_BYTES);
+    const buffer = Buffer.alloc(size2);
+    const { bytesRead } = await handle.read(buffer, 0, size2, 0);
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+function firstRecord(head) {
+  const cut3 = head.indexOf("\n");
+  try {
+    const parsed = JSON.parse(cut3 === -1 ? head : head.slice(0, cut3));
+    return isRecord(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function statFiles(dir, keep) {
+  const local = nativePath();
+  let entries;
+  try {
+    entries = await readdir3(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const found = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !keep(entry.name)) continue;
+    const path = local.join(dir, entry.name);
+    const info = await stat6(path).catch(() => void 0);
+    if (info) found.push({ path, mtimeMs: info.mtimeMs, bytes: info.size });
+  }
+  return found;
+}
+async function subdirs(dir) {
+  const local = nativePath();
+  try {
+    const entries = await readdir3(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => local.join(dir, e.name));
+  } catch {
+    return [];
+  }
+}
+async function readWindows(candidate) {
+  const handle = await open(candidate.path, "r");
+  try {
+    if (candidate.bytes <= DISCOVERY_WHOLE_FILE_BYTES) {
+      const buffer = Buffer.alloc(candidate.bytes);
+      const { bytesRead } = await handle.read(buffer, 0, candidate.bytes, 0);
+      const text = buffer.subarray(0, bytesRead).toString("utf8");
+      return { whole: true, head: text, tail: text };
+    }
+    const size2 = DISCOVERY_WINDOW_BYTES;
+    const headBuffer = Buffer.alloc(size2);
+    const tailBuffer = Buffer.alloc(size2);
+    const headRead = await handle.read(headBuffer, 0, size2, 0);
+    const tailRead = await handle.read(tailBuffer, 0, size2, candidate.bytes - size2);
+    const head = headBuffer.subarray(0, headRead.bytesRead).toString("utf8");
+    const tailRaw = tailBuffer.subarray(0, tailRead.bytesRead).toString("utf8");
+    const cut3 = tailRaw.indexOf("\n");
+    return { whole: false, head, tail: cut3 === -1 ? "" : tailRaw.slice(cut3 + 1) };
+  } finally {
+    await handle.close();
+  }
+}
+function refOf(conversation, turnCount) {
+  const { version: _version, hash: _hash, turns: _turns, compactions: _compactions, dropped: _dropped, ...ref } = conversation;
+  return { ...ref, turnCount };
+}
+function mergeWindows(head, tail, tailHasTitleRecord) {
+  const ref = refOf(head, null);
+  ref.updatedAt = tail.updatedAt > head.updatedAt ? tail.updatedAt : head.updatedAt;
+  ref.compacted = head.compacted || tail.compacted;
+  if (tail.limit) ref.limit = tail.limit;
+  else delete ref.limit;
+  if (tailHasTitleRecord && tail.title) ref.title = tail.title;
+  return ref;
+}
+async function listClaude(options, limit, scope) {
+  const store = claudeStore(options);
+  const found = claudeStoreExists(store);
+  const candidates = [];
+  const local = nativePath();
+  const holds = (project) => {
+    if (!scope) return "own";
+    const answers = scope.folders.map((folder) => claudeFolderHolds(local.basename(project), folder, scope.platform));
+    return answers.includes("own") ? "own" : answers.includes("maybe") ? "maybe" : false;
+  };
+  const maybe = [];
+  let count = 0;
+  if (found) {
+    for (const project of await subdirs(store.projects)) {
+      const files = await statFiles(project, (name) => name.toLowerCase().endsWith(".jsonl"));
+      count += files.length;
+      const answer = holds(project);
+      if (answer === "own") candidates.push(...files);
+      else if (answer === "maybe") maybe.push(...files);
+    }
+    if (scope && maybe.length > 0) candidates.push(...await withinScope(maybe, scope, claudePlace));
+  }
+  const report = { agent: "claude-cli", path: store.projects, found, conversations: count };
+  const refs = [];
+  for (const candidate of newest(candidates, limit)) {
+    try {
+      const windows = await readWindows(candidate);
+      const input = {
+        path: candidate.path,
+        sessionId: local.basename(candidate.path, ".jsonl"),
+        bytes: candidate.bytes,
+        mtime: new Date(candidate.mtimeMs).toISOString()
+      };
+      if (windows.whole) {
+        const conversation = await parseClaudeTranscript(windows.head, input);
+        refs.push(refOf(conversation, conversation.turnCount));
+      } else {
+        const head = await parseClaudeTranscript(windows.head, input);
+        const tail = await parseClaudeTranscript(windows.tail, input);
+        const titled = windows.tail.includes('"custom-title"') || windows.tail.includes('"ai-title"');
+        refs.push(mergeWindows(head, tail, titled));
+      }
+    } catch {
+    }
+  }
+  return { report, refs };
+}
+function claudePlace(head) {
+  for (const line2 of head.split("\n")) {
+    if (!line2.includes('"cwd"')) continue;
+    let record2;
+    try {
+      record2 = JSON.parse(line2);
+    } catch {
+      continue;
+    }
+    if (!isRecord(record2) || record2["type"] !== "user" && record2["type"] !== "assistant") continue;
+    const cwd = readString(record2["cwd"]);
+    if (cwd) return cwd;
+  }
+  return void 0;
+}
+async function listCodex(options, limit, scope) {
+  const store = codexStore(options);
+  const found = codexStoreExists(store);
+  const candidates = [];
+  if (found) {
+    for (const year of await subdirs(store.sessions)) {
+      for (const month of await subdirs(year)) {
+        for (const day of await subdirs(month)) {
+          candidates.push(...await statFiles(day, (name) => codexIdFromName(name) !== void 0));
+        }
+      }
+    }
+  }
+  const perThread = /* @__PURE__ */ new Map();
+  const local = nativePath();
+  for (const candidate of candidates) {
+    const id = codexIdFromName(local.basename(candidate.path)) ?? candidate.path;
+    const seen = perThread.get(id);
+    if (!seen || seen.mtimeMs < candidate.mtimeMs) perThread.set(id, candidate);
+  }
+  const threads = [...perThread.values()];
+  const report = { agent: "codex-cli", path: store.sessions, found, conversations: threads.length };
+  const refs = [];
+  const chosen = newest(scope ? await withinScope(threads, scope, codexPlace) : threads, limit);
+  const names = chosen.length > 0 ? await readSessionIndex(store.index) : /* @__PURE__ */ new Map();
+  for (const candidate of chosen) {
+    try {
+      const windows = await readWindows(candidate);
+      const input = { path: candidate.path, bytes: candidate.bytes, mtime: new Date(candidate.mtimeMs).toISOString(), names };
+      if (windows.whole) {
+        const conversation = parseCodexRollout(windows.head, input);
+        if (isSubagentRollout(windows.head)) continue;
+        refs.push(refOf(conversation, conversation.turnCount));
+      } else {
+        if (isSubagentRollout(windows.head)) continue;
+        const head = parseCodexRollout(windows.head, input);
+        const tail = parseCodexRollout(windows.tail, input);
+        const ref = mergeWindows(head, tail, false);
+        ref.compacted = ref.compacted || windows.tail.includes('"type":"compacted"');
+        refs.push(ref);
+      }
+    } catch {
+    }
+  }
+  return { report, refs };
+}
+function isSubagentRollout(head) {
+  const payload = firstRecord(head)?.["payload"];
+  if (!isRecord(payload)) return false;
+  const source = payload["source"];
+  return isRecord(source) && source["subagent"] !== void 0;
+}
+function codexPlace(head) {
+  if (isSubagentRollout(head)) return null;
+  const record2 = firstRecord(head);
+  if (!record2 || record2["type"] !== "session_meta" || !isRecord(record2["payload"])) return void 0;
+  return readString(record2["payload"]["cwd"]);
+}
+function geminiProjectOf(candidate) {
+  const local = nativePath();
+  return local.basename(local.dirname(local.dirname(candidate.path)));
+}
+async function listGemini(options, limit, scope) {
+  const store = geminiStore(options);
+  const found = geminiStoreExists(store);
+  const candidates = [];
+  if (found) {
+    for (const project of await subdirs(store.tmp)) {
+      const chats = nativePath().join(project, "chats");
+      candidates.push(...await statFiles(chats, (name) => /^session-.*\.jsonl?$/i.test(name)));
+    }
+  }
+  const report = { agent: "gemini-cli", path: store.tmp, found, conversations: candidates.length };
+  const refs = [];
+  const folders = candidates.length > 0 ? geminiProjectFolders(store, [...options.cwds ?? [], ...scope?.folders ?? []]) : /* @__PURE__ */ new Map();
+  const chosen = newest(
+    scope ? candidates.filter((candidate) => {
+      const cwd = folders.get(geminiProjectOf(candidate));
+      return cwd !== void 0 && inScope(scope, cwd);
+    }) : candidates,
+    limit
+  );
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of chosen) {
+    try {
+      const windows = await readWindows(candidate);
+      const projectId = geminiProjectOf(candidate);
+      const legacy = candidate.path.toLowerCase().endsWith(".json");
+      const cwd = folders.get(projectId);
+      const input = { path: candidate.path, bytes: candidate.bytes, mtime: new Date(candidate.mtimeMs).toISOString(), legacy, ...cwd ? { cwd } : {} };
+      let ref;
+      if (windows.whole) {
+        const conversation = parseGeminiChat(windows.head, input);
+        ref = refOf(conversation, conversation.turnCount);
+      } else if (legacy) {
+        continue;
+      } else {
+        ref = mergeWindows(parseGeminiChat(windows.head, input), parseGeminiChat(windows.tail, input), windows.tail.includes('"$set"'));
+      }
+      if (seen.has(ref.sessionId)) continue;
+      seen.add(ref.sessionId);
+      refs.push(ref);
+    } catch {
+    }
+  }
+  return { report, refs };
+}
+async function listOpencode(options, limit, scope) {
+  const store = opencodeStore(options);
+  const found = opencodeStoreExists(store);
+  const report = { agent: "opencode", path: store.db, found, conversations: 0 };
+  if (!found) return { report, refs: [] };
+  const sqlite = await openSqlite(options.sqlite ? { sqlite: options.sqlite } : {});
+  let db;
+  if (sqlite) {
+    try {
+      db = sqlite.open(store.db);
+    } catch {
+      db = void 0;
+    }
+  }
+  if (db) {
+    try {
+      return listOpencodeRows(db, store.db, report, limit, scope);
+    } finally {
+      db.close();
+    }
+  }
+  return listOpencodeStorage(store.storage, store.db, report, limit, scope);
+}
+function listOpencodeRows(db, dbPath, report, limit, scope) {
+  const rows = db.all(
+    "SELECT id, directory, title, time_created, time_updated FROM session WHERE parent_id IS NULL ORDER BY time_updated DESC"
+  );
+  report.conversations = rows.length;
+  const refs = [];
+  const chosen = scope ? rows.filter((row) => inScope(scope, readString(row["directory"]) ?? "")) : rows;
+  for (const row of chosen.slice(0, limit)) {
+    const id = readString(row["id"]);
+    if (!id) continue;
+    const bytes = (readNumber(db.all("SELECT COALESCE(SUM(LENGTH(data)), 0) AS b FROM message WHERE session_id = ?", id)[0]?.["b"]) ?? 0) + (readNumber(db.all("SELECT COALESCE(SUM(LENGTH(data)), 0) AS b FROM part WHERE session_id = ?", id)[0]?.["b"]) ?? 0);
+    const compacted = db.all(`SELECT 1 AS one FROM part WHERE session_id = ? AND data LIKE '%"type":"compaction"%' LIMIT 1`, id).length > 0;
+    const last = db.all("SELECT data, time_created FROM message WHERE session_id = ? ORDER BY time_created DESC, id DESC LIMIT 1", id)[0];
+    const ref = opencodeRef(dbPath, id, row, null, bytes, compacted);
+    const limitHit = last ? opencodeLimit(last) : void 0;
+    if (limitHit) ref.limit = limitHit;
+    refs.push(ref);
+  }
+  return { report, refs };
+}
+function opencodeRef(path, id, row, turnCount, bytes, compacted) {
+  const ref = {
+    id: conversationId("opencode", id),
+    agent: "opencode",
+    sessionId: id,
+    handle: shortHandle("opencode", id),
+    path,
+    cwd: readString(row["directory"]) ?? "",
+    updatedAt: isoFromEpochMs(row["time_updated"]) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    turnCount,
+    bytes,
+    compacted
+  };
+  const title = readString(row["title"]);
+  if (title) ref.title = title;
+  const startedAt = isoFromEpochMs(row["time_created"]);
+  if (startedAt) ref.startedAt = startedAt;
+  return ref;
+}
+function opencodeLimit(last) {
+  let data = last["data"];
+  if (typeof data === "string") {
+    try {
+      data = JSON.parse(data);
+    } catch {
+      return void 0;
+    }
+  }
+  if (!isRecord(data) || data["role"] !== "assistant" || !isRecord(data["error"])) return void 0;
+  const inner = isRecord(data["error"]["data"]) ? data["error"]["data"] : {};
+  const status = readNumber(inner["statusCode"]);
+  if (status !== 429 && status !== 402) return void 0;
+  const time = isRecord(data["time"]) ? data["time"] : {};
+  return { at: isoFromEpochMs(time["created"]) ?? isoFromEpochMs(last["time_created"]) ?? "", kind: status === 429 ? "rate-limit" : "credits" };
+}
+function opencodeStoragePlace(head) {
+  let info;
+  try {
+    info = JSON.parse(head);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(info)) return void 0;
+  if (readString(info["parentID"])) return null;
+  return readString(info["directory"]);
+}
+async function listOpencodeStorage(storage, shownPath, report, limit, scope) {
+  const local = nativePath();
+  const candidates = [];
+  for (const project of await subdirs(local.join(storage, "session"))) {
+    candidates.push(...await statFiles(project, (name) => name.startsWith("ses_") && name.endsWith(".json")));
+  }
+  report.conversations = candidates.length;
+  const refs = [];
+  const chosen = newest(scope ? await withinScope(candidates, scope, opencodeStoragePlace) : candidates, limit);
+  for (const candidate of chosen) {
+    try {
+      const windows = await readWindows(candidate);
+      if (!windows.whole) continue;
+      const info = JSON.parse(windows.head);
+      if (!isRecord(info)) continue;
+      if (readString(info["parentID"])) continue;
+      const id = readString(info["id"]) ?? local.basename(candidate.path, ".json");
+      const time = isRecord(info["time"]) ? info["time"] : {};
+      const messages = await statFiles(local.join(storage, "message", id), (name) => name.endsWith(".json"));
+      const row = { directory: info["directory"], title: info["title"], time_created: time["created"], time_updated: time["updated"] };
+      refs.push(opencodeRef(shownPath, id, row, null, messages.reduce((n, m) => n + m.bytes, 0), false));
+    } catch {
+    }
+  }
+  return { report, refs };
+}
+var MIN_PREFIX = 4;
+function resolveConversation(handleOrPrefix, discovery) {
+  const wanted = handleOrPrefix.trim();
+  const split = splitConversationId(wanted);
+  if (split && isAgentId(split.agent)) {
+    const exact = discovery.conversations.find((ref) => ref.id === wanted);
+    if (exact) return exact;
+    throw new HandoffFault("conversation-not-found", wanted);
+  }
+  if (!isSafeId(wanted)) throw new HandoffFault("invalid-id", wanted);
+  if (wanted.length < MIN_PREFIX) throw new HandoffFault("invalid-id", `at least ${MIN_PREFIX} characters`);
+  const bySession = discovery.conversations.filter((ref) => ref.sessionId === wanted);
+  if (bySession.length === 1) return bySession[0];
+  const lower = wanted.toLowerCase();
+  const matches = discovery.conversations.filter((ref) => {
+    const handle = shortHandle(ref.agent, ref.sessionId).toLowerCase();
+    const body = (ref.agent === "opencode" && ref.sessionId.startsWith("ses_") ? ref.sessionId.slice(4) : ref.sessionId).toLowerCase();
+    return handle.startsWith(lower) || body.startsWith(lower) || ref.sessionId.toLowerCase().startsWith(lower);
+  });
+  if (matches.length === 1) return matches[0];
+  if (matches.length === 0) throw new HandoffFault("conversation-not-found", wanted);
+  throw new HandoffFault("ambiguous-id", matches.map((ref) => `${ref.agent}:${ref.handle}`).join(", "));
+}
+var SAME_HOUR_MS = 60 * 60 * 1e3;
+function newestOfFolder(refs) {
+  const [newest2] = refs;
+  if (!newest2) return { newest: void 0, rival: void 0 };
+  const since = Date.parse(newest2.updatedAt);
+  const rival = refs.slice(1).find((ref) => ref.agent !== newest2.agent && since - Date.parse(ref.updatedAt) < SAME_HOUR_MS);
+  return { newest: newest2, rival };
+}
+function toBundle(conversation, digest, now = /* @__PURE__ */ new Date()) {
+  return { format: "panoma-conversation", version: 1, exportedAt: now.toISOString(), conversation, digest };
+}
+function isBundlePath(value) {
+  return value.includes("/") || value.includes("\\") || value.toLowerCase().endsWith(".json");
+}
+function fromBundle(value) {
+  const record2 = asRecord(value, "not an object");
+  if (record2["format"] !== "panoma-conversation") throw invalid("format");
+  if (record2["version"] !== 1) throw invalid("version");
+  const exportedAt = record2["exportedAt"];
+  if (typeof exportedAt !== "string") throw invalid("exportedAt");
+  const conversation = conversationOf(record2["conversation"]);
+  const digest = digestOf(record2["digest"]);
+  return { format: "panoma-conversation", version: 1, exportedAt, conversation, digest };
+}
+function invalid(detail) {
+  return new HandoffFault("bundle-invalid", detail);
+}
+function asRecord(value, detail) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw invalid(detail);
+  return value;
+}
+function str(record2, key, where) {
+  const value = record2[key];
+  if (typeof value !== "string") throw invalid(`${where}.${key}`);
+  return value;
+}
+function optionalStr(record2, key, where) {
+  const value = record2[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw invalid(`${where}.${key}`);
+  return value;
+}
+function strings(value, where) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw invalid(where);
+  return value;
+}
+function conversationOf(value) {
+  const c = asRecord(value, "conversation");
+  const agent = str(c, "agent", "conversation");
+  if (!isAgentId(agent)) throw invalid("conversation.agent");
+  const turnsRaw = c["turns"];
+  if (!Array.isArray(turnsRaw)) throw invalid("conversation.turns");
+  const turns = turnsRaw.map((turn, index) => turnOf(turn, `conversation.turns[${index}]`));
+  const turnCount = c["turnCount"];
+  if (turnCount !== null && typeof turnCount !== "number") throw invalid("conversation.turnCount");
+  const bytes = c["bytes"];
+  if (typeof bytes !== "number") throw invalid("conversation.bytes");
+  const compactionsRaw = c["compactions"];
+  if (!Array.isArray(compactionsRaw)) throw invalid("conversation.compactions");
+  const compactions = compactionsRaw.map((item, index) => {
+    const r = asRecord(item, `conversation.compactions[${index}]`);
+    const out = { text: str(r, "text", `conversation.compactions[${index}]`) };
+    const at = optionalStr(r, "at", `conversation.compactions[${index}]`);
+    if (at) out.at = at;
+    if (typeof r["tokensBefore"] === "number") out.tokensBefore = r["tokensBefore"];
+    return out;
+  });
+  const conversation = {
+    version: 1,
+    id: str(c, "id", "conversation"),
+    agent,
+    sessionId: str(c, "sessionId", "conversation"),
+    handle: str(c, "handle", "conversation"),
+    path: str(c, "path", "conversation"),
+    cwd: str(c, "cwd", "conversation"),
+    updatedAt: str(c, "updatedAt", "conversation"),
+    turnCount,
+    bytes,
+    compacted: c["compacted"] === true,
+    hash: typeof c["hash"] === "string" ? c["hash"] : hashTurns(turns),
+    turns,
+    compactions,
+    dropped: droppedOf(c["dropped"])
+  };
+  for (const key of ["gitBranch", "title", "model", "startedAt"]) {
+    const v = optionalStr(c, key, "conversation");
+    if (v) conversation[key] = v;
+  }
+  const limit = c["limit"];
+  if (limit !== void 0 && limit !== null) {
+    const l = asRecord(limit, "conversation.limit");
+    conversation.limit = { at: str(l, "at", "conversation.limit") };
+    const resetsAt = optionalStr(l, "resetsAt", "conversation.limit");
+    if (resetsAt) conversation.limit.resetsAt = resetsAt;
+    const kind = optionalStr(l, "kind", "conversation.limit");
+    if (kind) conversation.limit.kind = kind;
+  }
+  return conversation;
+}
+function turnOf(value, where) {
+  const t = asRecord(value, where);
+  const role = t["role"];
+  if (role !== "user" && role !== "assistant") throw invalid(`${where}.role`);
+  const partsRaw = t["parts"];
+  if (!Array.isArray(partsRaw)) throw invalid(`${where}.parts`);
+  const turn = { role, parts: partsRaw.map((part, index) => partOf(part, `${where}.parts[${index}]`)) };
+  const at = optionalStr(t, "at", where);
+  if (at) turn.at = at;
+  return turn;
+}
+function partOf(value, where) {
+  const p = asRecord(value, where);
+  switch (p["kind"]) {
+    case "text":
+    case "summary":
+      return { kind: p["kind"], text: str(p, "text", where) };
+    case "tool_call":
+      return { kind: "tool_call", id: str(p, "id", where), name: str(p, "name", where), input: p["input"] };
+    case "tool_result": {
+      const part = { kind: "tool_result", callId: str(p, "callId", where), output: str(p, "output", where) };
+      if (p["isError"] === true) part.isError = true;
+      return part;
+    }
+    default:
+      throw invalid(`${where}.kind`);
+  }
+}
+function droppedOf(value) {
+  const d = asRecord(value, "conversation.dropped");
+  const out = { thinking: 0, images: 0, subagents: 0, offloaded: 0, secrets: 0, other: 0 };
+  for (const key of Object.keys(out)) {
+    const n = d[key];
+    if (n !== void 0 && typeof n !== "number") throw invalid(`conversation.dropped.${key}`);
+    out[key] = typeof n === "number" ? n : 0;
+  }
+  return out;
+}
+function digestOf(value) {
+  const d = asRecord(value, "digest");
+  const by = d["by"];
+  if (by !== "panoma" && by !== "model") throw invalid("digest.by");
+  const exchange = asRecord(d["lastExchange"] ?? {}, "digest.lastExchange");
+  const stats = asRecord(d["stats"] ?? {}, "digest.stats");
+  const digest = {
+    by,
+    title: str(d, "title", "digest"),
+    goal: str(d, "goal", "digest"),
+    decisions: strings(d["decisions"], "digest.decisions"),
+    filesTouched: strings(d["filesTouched"], "digest.filesTouched"),
+    commandsRun: strings(d["commandsRun"], "digest.commandsRun"),
+    openItems: strings(d["openItems"], "digest.openItems"),
+    lastExchange: {},
+    stats: {
+      turns: typeof stats["turns"] === "number" ? stats["turns"] : 0,
+      toolCalls: typeof stats["toolCalls"] === "number" ? stats["toolCalls"] : 0,
+      estimatedTokens: typeof stats["estimatedTokens"] === "number" ? stats["estimatedTokens"] : 0
+    }
+  };
+  const summary = optionalStr(d, "summary", "digest");
+  if (summary) digest.summary = summary;
+  const user = optionalStr(exchange, "user", "digest.lastExchange");
+  if (user) digest.lastExchange.user = user;
+  const assistant = optionalStr(exchange, "assistant", "digest.lastExchange");
+  if (assistant) digest.lastExchange.assistant = assistant;
+  return digest;
+}
+async function handoff(input) {
+  const plan = await prepare(input);
+  if (plan.kind === "document") return writeDocument(input, plan.digest, plan.now, plan.keepTurns);
+  switch (plan.target) {
+    case "claude-cli":
+      return writeClaudeConversation(plan.request);
+    case "codex-cli":
+      return writeCodexConversation(plan.request);
+    case "opencode":
+      return writeOpencodeConversation(plan.request);
+    case "gemini-cli":
+      return writeGeminiConversation(plan.request);
+    default:
+      throw new HandoffFault("unsupported-target", plan.target);
+  }
+}
+async function prepare(input) {
+  const options = input.options ?? {};
+  const resolved = resolveStoreOptions(options);
+  const { conversation, target, tier } = input;
+  if (!isAgentId(target)) throw new HandoffFault("unsupported-target", String(target));
+  if (conversation.bytes > MAX_CONVERSATION_BYTES) throw new HandoffFault("too-large", String(conversation.bytes));
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const random = input.random ?? cryptoRandom;
+  const keepTurns = Math.max(1, Math.floor(input.keepTurns ?? KEEP_TURNS_DEFAULT));
+  const digest = input.digest ?? digestConversation(conversation);
+  if (!isNativeTarget(target) || tier === "brief") {
+    return { kind: "document", digest, now, keepTurns };
+  }
+  if (target === conversation.agent && tier === "full" && !input.targetHome) throw new HandoffFault("same-store", target);
+  const root = await resolveRoot(target, input.targetHome, options, conversation, tier);
+  const cwd = input.cwd ?? conversation.cwd;
+  if (!cwd) throw new HandoffFault("cwd-missing");
+  const folder = await stat7(cwd).catch(() => void 0);
+  if (!folder?.isDirectory()) throw new HandoffFault("cwd-missing", cwd);
+  const tiered = tier === "compact" ? compactConversation(conversation, digest, { keepTurns }) : conversation;
+  if (!carriesAnything(tiered)) throw new HandoffFault("nothing-to-carry");
+  const request = {
+    conversation: tiered,
+    tier,
+    root,
+    cwd,
+    title: digest.title,
+    now,
+    random,
+    platform: resolved.platform,
+    surface: input.surface ?? "cli"
+  };
+  const branch = input.gitBranch ?? conversation.gitBranch;
+  if (branch) request.gitBranch = branch;
+  return { kind: "native", target, request };
+}
+function carriesAnything(conversation) {
+  return conversation.turns.some(
+    (turn) => turn.parts.some((part) => part.kind === "tool_call" ? true : part.kind === "tool_result" ? part.output.length > 0 : part.text.trim().length > 0)
+  );
+}
+async function resolveRoot(target, targetHome, options, conversation, tier) {
+  const resolved = resolveStoreOptions(options);
+  if (targetHome !== void 0) {
+    if (!isAbsoluteOn(targetHome, resolved.platform)) throw new HandoffFault("target-store-missing", "must be absolute");
+    const store = storeAt(target, targetHome, options);
+    if (!store.exists) throw new HandoffFault("target-store-missing", targetHome);
+    if (target === conversation.agent && tier === "full") {
+      const own = defaultRoot(target, options);
+      const [a, b] = await Promise.all([realFolder(targetHome), realFolder(own)]);
+      if (sameFolder(a, b, resolved.platform)) throw new HandoffFault("same-store", targetHome);
+    }
+    return targetHome;
+  }
+  const root = defaultRoot(target, options);
+  if (!exists(root)) throw new HandoffFault("target-store-missing", root);
+  return root;
+}
+function defaultRoot(target, options) {
+  switch (target) {
+    case "claude-cli":
+      return claudeStore(options).root;
+    case "codex-cli":
+      return codexStore(options).root;
+    case "opencode":
+      return opencodeStore(options).root;
+    case "gemini-cli":
+      return geminiStore(options).root;
+    default:
+      throw new HandoffFault("unsupported-target", target);
+  }
+}
+function storeAt(target, root, options) {
+  switch (target) {
+    case "claude-cli":
+      return { exists: claudeStoreExists(claudeStoreAt(root, options)) };
+    case "codex-cli":
+      return { exists: codexStoreExists(codexStoreAt(root, options)) };
+    case "opencode":
+      return { exists: opencodeStoreExists(opencodeStoreAt(root, options)) };
+    case "gemini-cli":
+      return { exists: geminiStoreExists(geminiStoreAt(root, options)) };
+    default:
+      throw new HandoffFault("unsupported-target", target);
+  }
+}
+async function writeDocument(input, digest, now, keepTurns) {
+  const { conversation, target } = input;
+  const redactor = new Redactor();
+  const markdown = briefMarkdown(conversation, digest, { keepTurns, now, redactor });
+  const stem = `${conversation.agent}-${conversation.handle}-${now.toISOString().slice(0, 10)}`;
+  const path = input.out ?? panomaPath("handoff", `${stem}.md`);
+  const bytes = await writeBrief(path, markdown);
+  return {
+    agent: target,
+    surface: input.surface ?? "cli",
+    sessionId: stem,
+    path,
+    resume: void 0,
+    resumeInApp: void 0,
+    steps: [],
+    fidelity: fidelityOf(target),
+    provenance: {
+      sourceAgent: conversation.agent,
+      sourceSessionId: conversation.sessionId,
+      sourceHash: conversation.hash,
+      tier: "brief",
+      at: now.toISOString(),
+      by: "panoma"
+    },
+    turns: Math.min(keepTurns, conversation.turns.length),
+    bytes,
+    dropped: { ...conversation.dropped, secrets: conversation.dropped.secrets + redactor.count }
+  };
+}
+
+// src/handoff-command.ts
+var run = promisify(execFile);
+var TARGET_WORDS = [...Object.keys(AGENT_WORDS), ...Object.keys(APP_WORDS), "bundle"];
+function labelOf(ref) {
+  return (ref.surface === "app" ? APP_OF[ref.agent]?.name : void 0) ?? AGENT_NAMES[ref.agent];
+}
+async function handoffCommand(parsed, deps = {}) {
+  const [, source, extra] = parsed.positionals;
+  if (extra !== void 0) {
+    process.stderr.write(
+      pc.red(`${say("handoff.extraArgument", { extra })}
+`) + pc.dim(`${say("handoff.usage")}
+${say("handoff.usageHint")}
+`)
+    );
+    return 1;
+  }
+  const cwd = await realFolder(deps.cwd ?? process.cwd());
+  const store = deps.store ?? {};
+  const tier = parsed.tier ?? "full";
+  const digestBy = parsed.digest ?? "panoma";
+  const out = parsed.out ? resolve2(expandTilde(parsed.out)) : void 0;
+  let target;
+  let surface = "cli";
+  if (parsed.to !== void 0) {
+    const word = parsed.to.trim().toLowerCase();
+    const app = agentOfApp(word);
+    if (word === "bundle") target = "bundle";
+    else if (app !== void 0) {
+      target = app;
+      surface = "app";
+    } else target = agentFromWord(word);
+    if (target === void 0) {
+      const guess = nearestWord(word);
+      process.stderr.write(
+        pc.red(`${say("handoff.unknownTarget", { target: parsed.to })}${guess ? `  ${say("error.didYouMean", { guess })}` : ""}
+`) + pc.dim(`${say("handoff.targets", { list: TARGET_WORDS.join(" \xB7 ") })}
+`)
+      );
+      return 1;
+    }
+  }
+  if (source === void 0 && target === void 0 && tier !== "brief") {
+    return list(parsed, cwd, store);
+  }
+  const loaded = await load(source, target === void 0 || target === "bundle" ? "<agent>" : wordOf(target, surface), parsed, cwd, store);
+  if (typeof loaded === "number") return loaded;
+  const { conversation, taken } = loaded;
+  let digest = loaded.digest;
+  if (digestBy === "model" && !parsed.dryRun) {
+    const written = await modelDigest(parsed, conversation);
+    if (typeof written === "number") return written;
+    digest = written;
+  } else {
+    if (digestBy === "model" && !parsed.json) process.stderr.write(pc.dim(`${say("handoff.dryRunDigest")}
+`));
+    digest ??= digestConversation(conversation);
+  }
+  const now = deps.now ?? /* @__PURE__ */ new Date();
+  if (target === "bundle") {
+    if (parsed.dryRun) return preview(parsed, conversation, digest, "bundle", "full", out);
+    const covered = coverBundle(conversation, digest);
+    const bundle = toBundle(covered.conversation, covered.digest, now);
+    const json = `${JSON.stringify(bundle, null, 2)}
+`;
+    if (out) {
+      await writeFile3(out, json, { encoding: "utf8", mode: 384 });
+      if (parsed.json) process.stdout.write(`${JSON.stringify({ ok: true, bundle: out, dropped: covered.conversation.dropped }, null, 2)}
+`);
+      else process.stderr.write(pc.green(`\u2713 ${say("handoff.bundleWritten", { path: out })}
+`));
+      return 0;
+    }
+    process.stdout.write(json);
+    return 0;
+  }
+  const documentOnly2 = target !== void 0 && !isNativeTarget(target);
+  if (tier === "brief" || documentOnly2) {
+    if (documentOnly2 && !parsed.json) {
+      process.stderr.write(pc.dim(`${say("handoff.documentOnly", { agent: AGENT_NAMES[target] })}
+`));
+    }
+    if (parsed.dryRun) return preview(parsed, conversation, digest, target, "brief");
+    const options = { keepTurns: parsed.keep, now };
+    if (out === void 0) {
+      const markdown = briefMarkdown(conversation, digest, options);
+      if (parsed.json) process.stdout.write(`${JSON.stringify({ ok: true, tier: "brief", document: markdown }, null, 2)}
+`);
+      else process.stdout.write(markdown.endsWith("\n") ? markdown : `${markdown}
+`);
+      return 0;
+    }
+    return write({ parsed, deps, conversation, digest, target: target ?? conversation.agent, surface, named: target !== void 0, tier: "brief", out, taken, cwd, store, now });
+  }
+  if (target === void 0) {
+    if (!parsed.json) process.stderr.write(pc.dim(`${say("handoff.hint", { handle: conversation.handle })}
+`));
+    return preview(parsed, conversation, digest, void 0, tier);
+  }
+  if (target === conversation.agent && parsed.targetHome === void 0 && tier === "full") {
+    if (parsed.dryRun && !parsed.json) process.stderr.write(pc.dim(`${say("handoff.dryRunSameAgent")}
+`));
+    return sameAgent(parsed, conversation, cwd, store.platform);
+  }
+  if (parsed.dryRun) return preview(parsed, conversation, digest, target, tier);
+  return write({ parsed, deps, conversation, digest, target, surface, named: true, tier, out, taken, cwd, store, now });
+}
+async function list(parsed, cwd, store) {
+  const projects = await catalogProjects(parsed.api);
+  const roots = projects === void 0 ? [] : projects.map((project) => project.root);
+  const discovery = await discover(store, { cwds: [cwd, ...roots] });
+  if (typeof discovery === "number") return discovery;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify({ conversations: discovery.conversations, stores: discovery.stores, catalog: projects !== void 0 }, null, 2)}
+`);
+    return 0;
+  }
+  if (discovery.conversations.length === 0) {
+    process.stdout.write(["", `  ${pc.yellow(say("handoff.emptyAll"))}`, ...storeLines(discovery.stores), "", `  ${pc.dim(say("handoff.storesHint"))}`, ""].join("\n"));
+    return 0;
+  }
+  const lines = [""];
+  const here = await inFolder(discovery.conversations, cwd, store.platform);
+  const rest = discovery.conversations.filter((ref) => !here.includes(ref));
+  if (here.length > 0) {
+    lines.push(`  ${pc.bold(say("handoff.inFolder"))}`, ...rowLines(here, now), "");
+  }
+  if (projects === void 0) {
+    if (rest.length > 0) lines.push(`  ${pc.bold(say("handoff.elsewhere"))}`, ...rowLines(rest, now), "");
+    lines.push(`  ${pc.dim(say("handoff.catalogDown"))}`, "");
+  } else {
+    for (const group of groupByProject(rest, projects, store.platform)) {
+      lines.push(`  ${pc.bold(group.slug ?? say("handoff.notInCatalog"))}`, ...rowLines(group.conversations, now), "");
+    }
+  }
+  process.stdout.write(lines.join("\n"));
+  return 0;
+}
+async function catalogProjects(api) {
+  try {
+    const reply = await catalogFetch(new URL("/api/catalog", api));
+    if (!reply.ok) return void 0;
+    const body = await reply.json();
+    return (body.projects ?? []).filter((project) => typeof project.root === "string" && typeof project.slug === "string");
+  } catch {
+    return void 0;
+  }
+}
+function groupByProject(conversations, projects, platform) {
+  const deepestFirst = [...projects].sort((a, b) => b.root.length - a.root.length);
+  const groups = /* @__PURE__ */ new Map();
+  for (const ref of conversations) {
+    const owner = deepestFirst.find((project) => insideFolder(ref.cwd, project.root, platform));
+    const key = owner?.slug;
+    const bucket = groups.get(key);
+    if (bucket) bucket.push(ref);
+    else groups.set(key, [ref]);
+  }
+  const named = [...groups.entries()].filter(([slug]) => slug !== void 0).sort(([a], [b]) => a.localeCompare(b));
+  const orphans = groups.get(void 0);
+  return [
+    ...named.map(([slug, refs]) => ({ slug, conversations: refs })),
+    ...orphans ? [{ slug: void 0, conversations: orphans }] : []
+  ];
+}
+function rowLines(refs, now) {
+  const lines = [];
+  for (const ref of refs) {
+    const when = sinceMs(ref.updatedAt, now) || ref.updatedAt.slice(0, 10);
+    const facts = ref.turnCount === null ? say("handoff.rowSize", { when, size: size(ref.bytes) }) : say("handoff.rowTurns", { when, n: ref.turnCount });
+    const tags = [ref.compacted ? say("handoff.rowSummary") : "", limitWord(ref, now)].filter(Boolean);
+    lines.push(
+      `    ${pc.cyan(ref.handle.padEnd(10))}${pc.dim(labelOf(ref).padEnd(16))}${ref.title ?? pc.dim(ref.cwd)}`,
+      `              ${pc.dim([facts, ...tags].join(" \xB7 "))}`
+    );
+    if (ref.limit) {
+      const target = ref.agent === "codex-cli" ? "claude" : "codex";
+      lines.push(`              ${say("handoff.readyLine", { handle: ref.handle, target })}`);
+    }
+  }
+  return lines;
+}
+function limitWord(ref, now) {
+  if (!ref.limit) return "";
+  if (!ref.limit.resetsAt) return say("handoff.rowLimit");
+  const reset = Date.parse(ref.limit.resetsAt);
+  if (!Number.isFinite(reset)) return say("handoff.rowLimit");
+  if (reset > Date.parse(now)) {
+    const minutes = Math.max(1, Math.round((reset - Date.parse(now)) / 6e4));
+    const when = minutes < 60 ? say("handoff.inMinutes", { n: minutes }) : say("handoff.inHours", { n: Math.round(minutes / 60) });
+    return say("handoff.rowLimitBack", { when });
+  }
+  return say("handoff.rowLimitLifted", { when: sinceMs(ref.limit.resetsAt, now) });
+}
+function storeLines(stores) {
+  return stores.map(
+    (report) => `    ${pc.dim(
+      report.found ? say("handoff.storeFound", { agent: AGENT_NAMES[report.agent], path: report.path, n: report.conversations }) : say("handoff.storeMissing", { agent: AGENT_NAMES[report.agent], path: report.path })
+    )}`
+  );
+}
+async function load(source, targetWord, parsed, cwd, store) {
+  if (source !== void 0 && isBundlePath(source)) {
+    try {
+      const text = await readFile6(resolve2(expandTilde(source)), "utf8");
+      const bundle = fromBundle(JSON.parse(text));
+      return { conversation: bundle.conversation, digest: bundle.digest };
+    } catch (error) {
+      process.stderr.write(pc.red(`${handoffFaultText(error instanceof SyntaxError ? "bundle-invalid: not JSON" : error)}
+`));
+      return 1;
+    }
+  }
+  if (source === void 0) {
+    const discovery2 = await discover(store, { cwds: [cwd] });
+    if (typeof discovery2 === "number") return discovery2;
+    const { newest: first, rival } = newestOfFolder(await inFolder(discovery2.conversations, cwd, store.platform));
+    if (!first) {
+      process.stderr.write(pc.red(`${say("handoff.noneHere", { cwd })}
+`) + pc.dim(`${say("handoff.noneHereHint")}
+`));
+      return 1;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (rival) {
+      process.stderr.write(
+        `${pc.yellow(say("handoff.twoRecent"))}
+` + [first, rival].map((ref2) => `  ${say("handoff.candidate", { handle: ref2.handle, target: targetWord, agent: labelOf(ref2), when: sinceMs(ref2.updatedAt, now) })}`).join("\n") + "\n"
+      );
+      return 1;
+    }
+    const conversation2 = await read(first, store);
+    if (typeof conversation2 === "number") return conversation2;
+    const taken = say("handoff.tookNewest", { agent: labelOf(first), handle: first.handle, when: sinceMs(first.updatedAt, now) });
+    if (!parsed.json) process.stderr.write(pc.dim(`${taken}
+`));
+    return { conversation: conversation2, taken };
+  }
+  const discovery = await discover(store, { cwds: [cwd] });
+  if (typeof discovery === "number") return discovery;
+  let ref;
+  try {
+    ref = resolveConversation(source, discovery);
+  } catch (error) {
+    process.stderr.write(pc.red(`${handoffFaultText(error)}
+`));
+    return 1;
+  }
+  const conversation = await read(ref, store);
+  if (typeof conversation === "number") return conversation;
+  return { conversation };
+}
+async function discover(store, extra) {
+  try {
+    return await discoverConversations({ ...store, ...extra });
+  } catch (error) {
+    process.stderr.write(pc.red(`${handoffFaultText(error)}
+`));
+    return 1;
+  }
+}
+async function read(ref, store) {
+  try {
+    return await readConversation(ref, store, { cwds: [ref.cwd] });
+  } catch (error) {
+    process.stderr.write(pc.red(`${handoffFaultText(error)}
+`));
+    return 1;
+  }
+}
+async function modelDigest(parsed, conversation) {
+  let reply;
+  try {
+    reply = await catalogFetch(new URL("/api/handoff/digest", parsed.api), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ id: conversation.id })
+    });
+  } catch {
+    unreachable(parsed.api);
+    process.stderr.write(pc.dim(`${say("handoff.needsCatalog")}
+`));
+    return 1;
+  }
+  if (!reply.ok) {
+    process.stderr.write(pc.red(`${say("handoff.digestRejected", { status: reply.status, detail: await refusalOf(reply) })}
+`));
+    return 1;
+  }
+  const body = await reply.json().catch(() => void 0);
+  const digest = body?.digest ?? (body?.by === "model" ? body : void 0);
+  if (!digest || typeof digest.title !== "string") {
+    process.stderr.write(pc.red(`${say("handoff.digestUnreadable")}
+`));
+    return 1;
+  }
+  return digest;
+}
+function preview(parsed, conversation, digest, target, tier, out) {
+  const fidelity = target !== void 0 && target !== "bundle" ? fidelityOf(target) : void 0;
+  const sizeFacts = { turns: conversation.turns.length, tokens: digest.stats.estimatedTokens, bytes: conversation.bytes };
+  if (parsed.json) {
+    process.stdout.write(
+      `${JSON.stringify({ dryRun: true, conversation: refOf2(conversation), digest, tier, target: target ?? null, fidelity: fidelity ?? null, size: sizeFacts, dropped: conversation.dropped, ...target === "bundle" ? { bundle: out ?? null } : {} }, null, 2)}
+`
+    );
+    return 0;
+  }
+  const lines = ["", `  ${pc.bold(say("handoff.preview"))}`, ...digestLines(conversation, digest, tier)];
+  if (fidelity) {
+    lines.push("", `  ${pc.bold(say("handoff.travels", { agent: AGENT_NAMES[fidelity.agent] }))}`);
+    for (const item of fidelity.carries) lines.push(`    ${pc.green("+")} ${item}`);
+    lines.push(`  ${pc.bold(say("handoff.stays"))}`);
+    for (const item of fidelity.leaves) lines.push(`    ${pc.dim("\u2212")} ${pc.dim(item)}`);
+  }
+  if (target === "bundle") lines.push("", `  ${pc.dim(out ? say("handoff.bundleWouldWrite", { path: out }) : say("handoff.bundleWouldPrint"))}`);
+  lines.push("", `  ${sizeLine(sizeFacts)}`, `  ${pc.dim(leftBehind(conversation.dropped))}`, "");
+  process.stdout.write(lines.join("\n"));
+  return 0;
+}
+function digestLines(conversation, digest, tier) {
+  const lines = [
+    `  ${say("handoff.source", { agent: labelOf(conversation), handle: pc.cyan(conversation.handle), title: digest.title })}`,
+    `  ${pc.dim(say("handoff.digestBy", { by: digest.by, tier }))}`,
+    "",
+    `  ${say("handoff.goal", { goal: oneLine2(digest.goal, 160) })}`
+  ];
+  if (digest.summary) lines.push(`  ${pc.dim(say("handoff.sourceSummary"))}`);
+  lines.push(
+    `  ${pc.dim(
+      say("handoff.counts", {
+        decisions: digest.decisions.length,
+        files: digest.filesTouched.length,
+        commands: digest.commandsRun.length,
+        open: digest.openItems.length
+      })
+    )}`
+  );
+  return lines;
+}
+function sizeLine(facts) {
+  return say("handoff.sizeLine", { n: facts.turns, k: Math.max(1, Math.round(facts.tokens / 1e3)), size: size(facts.bytes) });
+}
+function leftBehind(dropped) {
+  const parts = [];
+  for (const key of ["thinking", "images", "subagents", "offloaded", "secrets", "other"]) {
+    const n = dropped[key];
+    if (n > 0) parts.push(say(`handoff.left.${key}`, { n }));
+  }
+  return parts.length === 0 ? "" : say("handoff.leftBehind", { list: parts.join(", ") });
+}
+var Cover = class {
+  count = 0;
+  text(value) {
+    const out = redactSecrets(value);
+    if (out !== value) this.count += marks2(out) - marks2(value);
+    return out;
+  }
+  /** Strings inside a tool input pass through; the structure stays as it was. */
+  input(value) {
+    if (typeof value === "string") return this.text(value);
+    if (Array.isArray(value)) return value.map((item) => this.input(item));
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [key, item] of Object.entries(value)) out[key] = this.input(item);
+      return out;
+    }
+    return value;
+  }
+  part(part) {
+    switch (part.kind) {
+      case "text":
+      case "summary":
+        return { ...part, text: this.text(part.text) };
+      case "tool_call":
+        return { ...part, input: this.input(part.input) };
+      case "tool_result":
+        return { ...part, output: this.text(part.output) };
+    }
+  }
+  turn(turn) {
+    return { ...turn, parts: turn.parts.map((part) => this.part(part)) };
+  }
+  digest(digest) {
+    const list2 = (items) => items.map((item) => this.text(item));
+    const exchange = {};
+    if (digest.lastExchange.user !== void 0) exchange.user = this.text(digest.lastExchange.user);
+    if (digest.lastExchange.assistant !== void 0) exchange.assistant = this.text(digest.lastExchange.assistant);
+    return {
+      ...digest,
+      title: this.text(digest.title),
+      goal: this.text(digest.goal),
+      ...digest.summary !== void 0 ? { summary: this.text(digest.summary) } : {},
+      decisions: list2(digest.decisions),
+      filesTouched: list2(digest.filesTouched),
+      commandsRun: list2(digest.commandsRun),
+      openItems: list2(digest.openItems),
+      lastExchange: exchange
+    };
+  }
+};
+function marks2(text) {
+  return text.split(REDACTED).length - 1;
+}
+function coverBundle(conversation, digest) {
+  const cover = new Cover();
+  const turns = conversation.turns.map((turn) => cover.turn(turn));
+  const compactions = conversation.compactions.map((compaction) => ({ ...compaction, text: cover.text(compaction.text) }));
+  const covered = {
+    ...conversation,
+    ...conversation.title !== void 0 ? { title: cover.text(conversation.title) } : {},
+    turns,
+    compactions,
+    dropped: { ...conversation.dropped }
+  };
+  const coveredDigest = cover.digest(digest);
+  covered.dropped.secrets += cover.count;
+  return { conversation: covered, digest: coveredDigest };
+}
+var INSIDE = {
+  "claude-cli": { binary: "claude", out: "/logout", in: "/login" }
+};
+async function sameAgent(parsed, conversation, cwd, platform) {
+  const agent = conversation.agent;
+  const resume = resumeOf(agent, conversation.sessionId, conversation.cwd, platform);
+  const fork = forkOf(agent, conversation.sessionId, conversation.cwd, platform);
+  const app = resumeInApp(agent, conversation.sessionId, conversation.cwd, platform);
+  const signOut = SIGN_OUT[agent] ?? "";
+  const signIn = SIGN_IN[agent] ?? "";
+  const bundle = `panoma handoff ${conversation.handle} --to bundle --out <file>`;
+  if (parsed.json) {
+    process.stdout.write(
+      `${JSON.stringify({ ok: true, sameAgent: true, agent, signOut, signIn, resume: resume ?? null, resumeInApp: app ?? null, fork: fork ?? null, bundle }, null, 2)}
+`
+    );
+    return 0;
+  }
+  const lines = ["", `  ${say("handoff.sameAgent")}`, ""];
+  let n = 0;
+  const step = (text) => {
+    n += 1;
+    lines.push(`  ${n}. ${text}`);
+  };
+  for (const line2 of accountLines(agent)) step(line2);
+  if (resume) {
+    step(say("handoff.sameAgentResume", { line: pc.cyan(await lineFor(resume, conversation.cwd, cwd, platform)) }));
+    if (app) {
+      const name = app.app.name;
+      lines.push(`     ${say("handoff.sameAgentAppDoor", { app: name, line: pc.cyan(app.line) })}`);
+      lines.push(`     ${pc.dim(say(agent === "claude-cli" ? "handoff.sameAgentAppClaude" : "handoff.sameAgentAppCodex", { app: name }))}`);
+    }
+  }
+  if (fork) step(say("handoff.sameAgentFork", { line: pc.cyan(await lineFor(fork, conversation.cwd, cwd, platform)) }));
+  step(say("handoff.sameAgentBundle", { handle: conversation.handle }));
+  lines.push("", `  ${pc.dim(say("handoff.sameAgentHome", { handle: conversation.handle, target: wordOf(agent) }))}`, "");
+  process.stdout.write(lines.join("\n"));
+  return 0;
+}
+function accountLines(agent) {
+  const inside = INSIDE[agent];
+  const withSlash = (command, slash) => inside ? say("handoff.sameAgentOrInside", { command: pc.cyan(command), slash: pc.cyan(slash), binary: inside.binary }) : pc.cyan(command);
+  return [
+    say("handoff.sameAgentSignOut", { agent: AGENT_NAMES[agent], command: withSlash(SIGN_OUT[agent] ?? "", inside?.out ?? "") }),
+    say("handoff.sameAgentSignIn", { command: withSlash(SIGN_IN[agent] ?? "", inside?.in ?? "") })
+  ];
+}
+function doorLines(app, name, line2, agent) {
+  const lines = [];
+  if (app) {
+    lines.push(`  ${pc.bold(say("handoff.openInApp", { app: name }))}`, `    ${pc.cyan(app.line)}`, `    ${pc.dim(say("handoff.appFallback", { sentence: app.sentence }))}`);
+    if (agent === "claude-cli") lines.push(`    ${pc.dim(say("handoff.claudeTrust"))}`);
+    if (line2) lines.push("", `  ${pc.bold(say("handoff.orTerminal"))}`, `    ${pc.cyan(line2)}`);
+  } else {
+    lines.push(`  ${say("handoff.appMacOnly", { app: name })}`);
+    if (line2) lines.push(`    ${pc.cyan(line2)}`);
+  }
+  return lines;
+}
+async function write({ parsed, deps, conversation, digest, target, surface, named, tier, out, taken, cwd, store, now }) {
+  let result;
+  try {
+    result = await handoff({
+      conversation,
+      target,
+      surface,
+      tier,
+      digest,
+      cwd: conversation.cwd,
+      targetHome: parsed.targetHome === void 0 ? void 0 : resolve2(expandTilde(parsed.targetHome)),
+      keepTurns: parsed.keep,
+      out,
+      now,
+      random: deps.random,
+      options: store
+    });
+  } catch (error) {
+    process.stderr.write(pc.red(`${handoffFaultText(error)}
+`));
+    return 1;
+  }
+  const steps = [];
+  let importFault;
+  if (target === "opencode" && result.steps.length > 0) {
+    const command = await opencodeCommand(deps);
+    if (command === void 0) {
+      steps.push(...result.steps.map((step) => ({ step, ran: false })));
+    } else {
+      try {
+        const exec = deps.exec ?? runImport;
+        await exec(command, ["import", result.path], conversation.cwd);
+        steps.push(...result.steps.map((step) => ({ step, ran: true })));
+      } catch (error) {
+        importFault = handoffFaultText(`import-command-failed: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+        steps.push(...result.steps.map((step) => ({ step, ran: false })));
+      }
+    }
+  } else {
+    steps.push(...result.steps.map((step) => ({ step, ran: false })));
+  }
+  const recorded = named ? await record(parsed, conversation, result, target, surface, tier) : "";
+  const resume = result.resume ? await lineFor(result.resume, conversation.cwd, cwd, store.platform) : void 0;
+  const account = target === conversation.agent && parsed.targetHome === void 0 && tier !== "brief";
+  if (parsed.json) {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: importFault === void 0,
+          result,
+          resume: resume ?? null,
+          account: account ? { signOut: SIGN_OUT[target] ?? "", signIn: SIGN_IN[target] ?? "" } : null,
+          steps,
+          recorded: recorded ?? null,
+          importFault: importFault ?? null,
+          taken: taken ?? null
+        },
+        null,
+        2
+      )}
+`
+    );
+    return importFault === void 0 ? 0 : 1;
+  }
+  const lines = [""];
+  if (tier === "brief" || !isNativeTarget(target)) {
+    lines.push(`  ${pc.green("\u2713")} ${say("handoff.documentWritten", { path: pc.dim(result.path) })}`);
+  } else {
+    lines.push(`  ${pc.green("\u2713")} ${say("handoff.written", { agent: labelOf({ agent: target, surface }), path: pc.dim(result.path) })}`);
+  }
+  lines.push(`    ${pc.dim(say("handoff.digestBy", { by: digest.by, tier }))}`);
+  lines.push(`    ${pc.dim(sizeLine({ turns: result.turns, tokens: digest.stats.estimatedTokens, bytes: result.bytes }))}`);
+  if (account) {
+    lines.push("");
+    accountLines(target).forEach((line2, index) => lines.push(`  ${index + 1}. ${line2}`));
+  }
+  if (surface === "app" && tier !== "brief" && isNativeTarget(target)) {
+    lines.push("", ...doorLines(result.resumeInApp, labelOf({ agent: target, surface }), resume, target));
+  } else if (resume) lines.push("", `  ${pc.bold(say("handoff.resume"))}`, `    ${pc.cyan(resume)}`);
+  if (steps.length > 0) {
+    lines.push("", `  ${pc.bold(say("handoff.then"))}`);
+    for (const { step, ran } of steps) {
+      lines.push(`    ${ran ? pc.green("\u2713") : pc.yellow("\u2192")} ${ran ? say("handoff.stepRan", { step }) : say("handoff.stepPending", { step })}`);
+    }
+  }
+  if (importFault) lines.push(`    ${pc.red(importFault)}`);
+  if (target === "claude-cli" && surface === "cli" && tier !== "brief") lines.push(`    ${pc.dim(say("handoff.claudeContinue"))}`);
+  const left = leftBehind(result.dropped);
+  if (left) lines.push("", `  ${pc.dim(left)}`);
+  if (recorded === void 0) lines.push(`  ${pc.dim(say("handoff.notRecorded"))}`);
+  else if (recorded) lines.push(`  ${pc.dim(say("handoff.recorded", { id: recorded }))}`);
+  lines.push("");
+  process.stdout.write(lines.join("\n"));
+  return importFault === void 0 ? 0 : 1;
+}
+async function opencodeCommand(deps) {
+  const detect = deps.detect ?? (async () => (await detectCliAgents(providersByAuth("cli"))).map((agent) => ({ id: agent.provider.id, installed: agent.installed, command: agent.command })));
+  const found = (await detect()).find((agent) => agent.id === "opencode" && agent.installed && agent.command);
+  return found?.command;
+}
+async function runImport(file, args, cwd) {
+  const launch = resolveExecutable(file, args);
+  await run(launch.file, launch.args, { cwd, timeout: 6e4 });
+}
+async function record(parsed, conversation, result, target, surface, tier) {
+  try {
+    const reply = await catalogFetch(new URL("/api/handoff/record", parsed.api), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        id: conversation.id,
+        target,
+        surface,
+        tier,
+        targetSessionId: result.sessionId,
+        targetPath: result.path,
+        sourceHash: conversation.hash,
+        turns: result.turns,
+        bytes: result.bytes,
+        dropped: result.dropped
+      })
+    });
+    if (!reply.ok) return void 0;
+    const body = await reply.json().catch(() => void 0);
+    return body?.receipt?.id ?? body?.id ?? "";
+  } catch {
+    return void 0;
+  }
+}
+async function lineFor(resume, conversationCwd, cwd, platform) {
+  return sameFolder(await realFolder(conversationCwd), cwd, platform) ? [resume.command, ...resume.args].join(" ") : resume.line;
+}
+async function inFolder(refs, cwd, platform) {
+  const kept = [];
+  for (const ref of refs) {
+    if (ref.cwd && insideFolder(await realFolder(ref.cwd), cwd, platform)) kept.push(ref);
+  }
+  return kept;
+}
+function wordOf(agent, surface = "cli") {
+  if (surface === "app" && APP_OF[agent]) return APP_OF[agent].id;
+  return Object.entries(AGENT_WORDS).find(([, id]) => id === agent)?.[0] ?? agent;
+}
+function nearestWord(word) {
+  let best;
+  for (const candidate of TARGET_WORDS) {
+    const distance = editDistance(word, candidate);
+    if (distance <= 2 && (!best || distance < best.distance)) best = { word: candidate, distance };
+  }
+  return best?.word;
+}
+function editDistance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    }
+    previous = current;
+  }
+  return previous[b.length];
+}
+function refOf2(conversation) {
+  const ref = {
+    id: conversation.id,
+    agent: conversation.agent,
+    sessionId: conversation.sessionId,
+    handle: conversation.handle,
+    path: conversation.path,
+    cwd: conversation.cwd,
+    updatedAt: conversation.updatedAt,
+    turnCount: conversation.turnCount,
+    bytes: conversation.bytes,
+    compacted: conversation.compacted
+  };
+  for (const key of ["gitBranch", "title", "model", "startedAt"]) {
+    if (conversation[key] !== void 0) ref[key] = conversation[key];
+  }
+  if (conversation.surface !== void 0) ref.surface = conversation.surface;
+  if (conversation.limit) ref.limit = conversation.limit;
+  return ref;
+}
+function oneLine2(text, max) {
+  const flat2 = text.replace(/\s+/g, " ").trim();
+  return flat2.length > max ? `${flat2.slice(0, max - 1)}\u2026` : flat2;
+}
+async function refusalOf(response) {
+  const text = await response.text().catch(() => "");
+  try {
+    const body = JSON.parse(text);
+    const error = typeof body.error === "string" ? body.error : "";
+    const hint = typeof body.hint === "string" ? ` ${body.hint}` : "";
+    if (error) return `${error}${hint}`;
+  } catch {
+  }
+  return text.split("\n")[0]?.trim() ?? "";
+}
+function size(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  if (bytes < 10 * 1024 ** 2) return `${(bytes / 1024 ** 2).toFixed(1)} MB`;
+  if (bytes < 1024 ** 3) return `${(bytes / 1024 ** 2).toFixed(0)} MB`;
+  return `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+}
+export {
+  coverBundle,
+  groupByProject,
+  handoffCommand,
+  labelOf,
+  leftBehind,
+  nearestWord,
+  rowLines
+};