mu-agent 0.1.0 → 0.1.3

package/judge/dist/import.js

@@ -0,0 +1,1785 @@
+import { createRequire as __muCreateRequire } from "node:module"; const require = __muCreateRequire(import.meta.url);
+
+// packages/kyrn-judge/src/import/command.ts
+import { readFileSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3, sep } from "node:path";
+
+// packages/kyrn-judge/src/import/index.ts
+import { mkdirSync, readdirSync as readdirSync2, realpathSync, statSync as statSync4 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+
+// packages/kyrn-judge/src/import/claude-code.ts
+import { statSync as statSync2 } from "node:fs";
+import { basename } from "node:path";
+
+// packages/kyrn-judge/src/import/jsonl.ts
+import { closeSync, createReadStream, openSync, readSync } from "node:fs";
+var MAX_LINE_BYTES = 64 * 1024 * 1024;
+function parse(bytes) {
+  const text = bytes.toString("utf8").trim();
+  if (!text) return { problem: "malformed", bytes: bytes.length };
+  try {
+    return { value: JSON.parse(text), bytes: bytes.length };
+  } catch {
+    return { problem: "malformed", bytes: bytes.length };
+  }
+}
+var blank = (bytes) => bytes.toString("utf8").trim() === "";
+async function* readJsonLines(path, maxLineBytes = MAX_LINE_BYTES) {
+  let parts = [];
+  let size = 0;
+  let oversized = false;
+  for await (const chunk of createReadStream(path, { highWaterMark: 1024 * 1024 })) {
+    const buffer = chunk;
+    let start = 0;
+    for (let newline = buffer.indexOf(10, start); newline !== -1; newline = buffer.indexOf(10, start)) {
+      const piece = buffer.subarray(start, newline);
+      start = newline + 1;
+      if (oversized || size + piece.length > maxLineBytes) {
+        yield { problem: "oversized", bytes: size + piece.length };
+      } else if (size + piece.length > 0) {
+        const line = parts.length === 0 ? piece : Buffer.concat([...parts, piece]);
+        if (!blank(line)) yield parse(line);
+      }
+      parts = [];
+      size = 0;
+      oversized = false;
+    }
+    const rest = buffer.subarray(start);
+    if (rest.length === 0) continue;
+    if (oversized || size + rest.length > maxLineBytes) {
+      oversized = true;
+      parts = [];
+      size += rest.length;
+      continue;
+    }
+    parts.push(Buffer.from(rest));
+    size += rest.length;
+  }
+  if (oversized) yield { problem: "oversized", bytes: size };
+  else if (size > 0) {
+    const line = Buffer.concat(parts);
+    if (!blank(line)) yield parse(line);
+  }
+}
+function readHead(path, visit, limit = 1024 * 1024) {
+  const fd = openSync(path, "r");
+  try {
+    const chunk = Buffer.allocUnsafe(64 * 1024);
+    let pending = Buffer.alloc(0);
+    let read = 0;
+    while (read < limit) {
+      const count = readSync(fd, chunk, 0, Math.min(chunk.length, limit - read), null);
+      if (count === 0) {
+        if (!blank(pending)) {
+          const last = parse(pending);
+          if ("value" in last) visit(last.value);
+        }
+        return;
+      }
+      read += count;
+      pending = Buffer.concat([pending, chunk.subarray(0, count)]);
+      let start = 0;
+      for (let newline = pending.indexOf(10, start); newline !== -1; newline = pending.indexOf(10, start)) {
+        const line = pending.subarray(start, newline);
+        start = newline + 1;
+        if (blank(line)) continue;
+        const parsed = parse(line);
+        if ("value" in parsed && visit(parsed.value)) return;
+      }
+      pending = pending.subarray(start);
+    }
+  } finally {
+    closeSync(fd);
+  }
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function str(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function list(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+// packages/kyrn-judge/src/import/session.ts
+import { randomBytes, randomUUID } from "node:crypto";
+import { closeSync as closeSync2, openSync as openSync2, readdirSync, statSync, writeSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+var TOOL_NAMES = { "claude-code": "Claude Code", codex: "Codex" };
+var IMPORT_MARKER = "mu.import";
+var IMPORT_CONTEXT = "mu.import.context";
+var SESSION_VERSION = 3;
+var MAX_RESULT_CHARS = 1e5;
+var IMAGE_MARKER = "(image not imported)";
+var NO_RESULT = "No result was recorded for this call.";
+function emptyCounts() {
+  return {
+    records: 0,
+    entries: 0,
+    user: 0,
+    assistant: 0,
+    toolCalls: 0,
+    toolResults: 0,
+    context: 0,
+    compactions: 0,
+    missingResults: 0,
+    truncated: 0,
+    asText: 0,
+    dropped: {}
+  };
+}
+function uuidv7(ms = Date.now()) {
+  const bytes = randomBytes(16);
+  let time = Math.max(0, Math.floor(ms));
+  for (let index = 5; index >= 0; index--) {
+    bytes[index] = time % 256;
+    time = Math.floor(time / 256);
+  }
+  bytes[6] = bytes[6] & 15 | 112;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function expand(path) {
+  if (path === "~") return homedir();
+  if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+  return path;
+}
+function absolute(path, base = process.cwd()) {
+  const expanded = expand(path);
+  return isAbsolute(expanded) ? resolve(expanded) : resolve(base, expanded);
+}
+function defaultSessionDir(cwd, agentDir) {
+  const safe = `--${absolute(cwd).replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+  return join(absolute(agentDir), "sessions", safe);
+}
+function sessionDirFor(cwd, store) {
+  return store.sessionDir ? absolute(store.sessionDir) : defaultSessionDir(cwd, store.agentDir);
+}
+function sessionsRoot(store) {
+  return store.sessionDir ? absolute(store.sessionDir) : join(absolute(store.agentDir), "sessions");
+}
+function sessionFileName(started, id) {
+  return `${started.replace(/[:.]/g, "-")}_${id}.jsonl`;
+}
+function readOrigin(file) {
+  let header;
+  let marker;
+  try {
+    readHead(
+      file,
+      (value) => {
+        if (!header) {
+          header = record(value);
+          return header?.type !== "session";
+        }
+        marker = record(value);
+        return true;
+      },
+      256 * 1024
+    );
+  } catch {
+    return void 0;
+  }
+  const details = record(marker?.details);
+  if (marker?.type !== "custom_message" || marker.customType !== IMPORT_MARKER || !details) return void 0;
+  const tool = details.tool;
+  if (tool !== "claude-code" && tool !== "codex") return void 0;
+  if (typeof details.source !== "string") return void 0;
+  return { sessionId: str(header?.id) ?? "", origin: details };
+}
+function findImports(store) {
+  const files = [];
+  const scan = (dir, depth) => {
+    let names;
+    try {
+      names = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const path = join(dir, name);
+      if (name.endsWith(".jsonl")) files.push(path);
+      else if (depth > 0) {
+        try {
+          if (statSync(path).isDirectory()) scan(path, depth - 1);
+        } catch {
+        }
+      }
+    }
+  };
+  scan(sessionsRoot(store), 1);
+  const found = [];
+  for (const file of files) {
+    const read = readOrigin(file);
+    if (read) found.push({ sessionFile: file, sessionId: read.sessionId, origin: read.origin });
+  }
+  return found;
+}
+function findImport(imports, tool, sourceId, source) {
+  return imports.find(
+    (found) => found.origin.tool === tool && (sourceId !== "" && found.origin.sourceId === sourceId || found.origin.source === source)
+  );
+}
+function firstLine(text, max = 80) {
+  const line = text.split(/\r?\n/).map((part) => part.replace(/\s+/g, " ").trim()).find((part) => part.length > 0) ?? "";
+  const chars = Array.from(line);
+  return chars.length > max ? `${chars.slice(0, max - 1).join("")}\u2026` : line;
+}
+function clip(text, max = MAX_RESULT_CHARS) {
+  if (text.length <= max) return { text, cut: false };
+  const head = Math.floor(max * 0.6);
+  const tail = max - head;
+  const left = text.length - head - tail;
+  return {
+    text: `${text.slice(0, head)}
+
+[\u2026 ${left} characters not imported \u2026]
+
+${text.slice(text.length - tail)}`,
+    cut: true
+  };
+}
+function commandText(text) {
+  const name = /<command-name>([\s\S]*?)<\/command-name>/.exec(text)?.[1]?.trim();
+  if (!name) return void 0;
+  const args = /<command-args>([\s\S]*?)<\/command-args>/.exec(text)?.[1]?.trim();
+  const command = name.startsWith("/") ? name : `/${name}`;
+  return args ? `${command} ${args}` : command;
+}
+function shellText(text) {
+  const command = /<bash-input>([\s\S]*?)<\/bash-input>/.exec(text)?.[1];
+  if (command === void 0) return void 0;
+  const output = text.replace(/<bash-input>[\s\S]*?<\/bash-input>/, "").trim();
+  return { command: command.trim(), output };
+}
+var SETUP_TAGS = /* @__PURE__ */ new Set([
+  "environment_context",
+  "user_instructions",
+  "in-app-browser-context",
+  "codex_internal_context",
+  "recommended_plugins",
+  "permissions instructions",
+  "collaboration_mode",
+  "multi_agent_mode",
+  "multi_agent_role",
+  "skills_instructions",
+  "plugins_instructions",
+  "apps_instructions",
+  "app-context",
+  "image_resize_notice",
+  "model_switch",
+  "INSTRUCTIONS"
+]);
+var CONTEXT_TAGS = /* @__PURE__ */ new Set([
+  "task-notification",
+  "subagent_notification",
+  "system-reminder",
+  "local-command-stdout",
+  "local-command-stderr",
+  "local-command-caveat",
+  "bash-stdout",
+  "bash-stderr",
+  "turn_aborted",
+  "heartbeat"
+]);
+function classifyUserText(text) {
+  if (/^\s*\[Request interrupted by user/.test(text)) return "context";
+  const tag = /^\s*<([A-Za-z][\w-]*(?: [\w-]+)?)>/.exec(text)?.[1];
+  if (!tag) return "user";
+  if (SETUP_TAGS.has(tag)) return "setup";
+  if (CONTEXT_TAGS.has(tag)) return "context";
+  return "user";
+}
+function toolArguments(raw) {
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      const object2 = record(parsed);
+      return object2 ? object2 : { value: parsed };
+    } catch {
+      return { input: raw };
+    }
+  }
+  const object = record(raw);
+  if (object) return object;
+  return raw === void 0 || raw === null ? {} : { value: raw };
+}
+function unknownBlockText(block) {
+  const { type, ...rest } = block;
+  let json;
+  try {
+    json = JSON.stringify(rest);
+  } catch {
+    json = "";
+  }
+  return `[${typeof type === "string" ? type : "block"}] ${clip(json, 2e3).text}`.trim();
+}
+var ZERO_USAGE = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  totalTokens: 0,
+  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+};
+var IMAGE = { type: "image", data: "", mimeType: "image/png" };
+var SessionBuilder = class {
+  constructor(tool) {
+    this.counts = emptyCounts();
+    this.items = [];
+    /** Messages that arrived while calls were still waiting for their results. */
+    this.held = [];
+    /** Calls of the last assistant message without a result yet, by id. */
+    this.pending = /* @__PURE__ */ new Map();
+    /** Every call seen, by id: a result may name its call only by the id. */
+    this.calls = /* @__PURE__ */ new Map();
+    this.answered = /* @__PURE__ */ new Set();
+    this.tool = tool;
+  }
+  drop(reason, count = 1) {
+    if (count <= 0) return;
+    this.counts.dropped[reason] = (this.counts.dropped[reason] ?? 0) + count;
+  }
+  /** Whether anything a person said or a model answered is in it: a transcript without either is not imported. */
+  get hasConversation() {
+    return this.counts.user + this.counts.assistant > 0;
+  }
+  /** Images become a line that says so; everything else is kept as it was. */
+  withoutImages(content) {
+    if (typeof content === "string") return [{ type: "text", text: content }];
+    const blocks = [];
+    for (const block of content) {
+      if (block.type === "image") {
+        this.drop("images");
+        blocks.push({ type: "text", text: IMAGE_MARKER });
+      } else blocks.push({ type: "text", text: block.text });
+    }
+    return blocks;
+  }
+  clipped(text) {
+    const cut = clip(text);
+    if (cut.cut) this.counts.truncated++;
+    return cut.text;
+  }
+  push(item) {
+    const waits = item.kind === "context" || item.kind === "message" && item.message.role === "user";
+    if (this.pending.size > 0 && waits) this.held.push(item);
+    else this.items.push(item);
+  }
+  lastTime() {
+    return this.items.at(-1)?.at ?? 0;
+  }
+  /** Calls still without a result get one that says so, and whatever waited behind them follows. */
+  settle() {
+    for (const [id, name] of this.pending) {
+      this.counts.missingResults++;
+      this.answered.add(id);
+      const at = this.lastTime();
+      this.items.push({
+        kind: "message",
+        at,
+        message: {
+          role: "toolResult",
+          toolCallId: id,
+          toolName: name,
+          content: [{ type: "text", text: NO_RESULT }],
+          isError: true,
+          timestamp: at
+        }
+      });
+    }
+    this.pending.clear();
+    this.items.push(...this.held);
+    this.held = [];
+  }
+  user(content, at, key) {
+    const blocks = this.withoutImages(content).filter((block) => block.text.length > 0);
+    if (blocks.length === 0) return;
+    this.counts.user++;
+    this.push({
+      kind: "message",
+      at,
+      key,
+      message: { role: "user", content: typeof content === "string" ? content : blocks, timestamp: at }
+    });
+  }
+  /** Something the other tool showed its model that nobody typed: kept for the model, hidden from the transcript. */
+  context(text, at, key) {
+    if (!text.trim()) return;
+    this.counts.context++;
+    this.push({ kind: "context", text: this.clipped(text), at, key });
+  }
+  assistant(input) {
+    this.settle();
+    const blocks = input.blocks.filter((block) => block.type === "toolCall" || block.text.length > 0);
+    if (blocks.length === 0 && !input.error) return;
+    const calls = blocks.filter((block) => block.type === "toolCall");
+    const message = {
+      role: "assistant",
+      content: input.error ? [] : blocks,
+      api: this.tool,
+      provider: this.tool,
+      model: input.model || "unknown",
+      usage: ZERO_USAGE,
+      stopReason: input.error ? "error" : input.stopReason ?? (calls.length > 0 ? "toolUse" : "stop"),
+      ...input.error ? { errorMessage: input.error } : {},
+      timestamp: input.at
+    };
+    this.counts.assistant++;
+    this.items.push({ kind: "message", message, at: input.at, key: input.key });
+    if (input.error) return;
+    for (const call of calls) {
+      this.counts.toolCalls++;
+      this.calls.set(call.id, call.name);
+      this.pending.set(call.id, call.name);
+    }
+  }
+  toolResult(input) {
+    const name = input.name || this.calls.get(input.id) || "unknown";
+    const blocks = this.withoutImages(input.content);
+    if (!this.pending.has(input.id)) {
+      if (this.answered.has(input.id)) {
+        this.drop("repeated tool results");
+        return;
+      }
+      this.drop("tool results without their call, kept as context");
+      this.context(`[Result of an earlier ${name} call]
+${blocks.map((block) => block.text).join("\n")}`, input.at);
+      return;
+    }
+    const content = blocks.map((block) => ({ type: "text", text: this.clipped(block.text) }));
+    this.pending.delete(input.id);
+    this.answered.add(input.id);
+    this.counts.toolResults++;
+    this.items.push({
+      kind: "message",
+      at: input.at,
+      key: input.key,
+      message: {
+        role: "toolResult",
+        toolCallId: input.id,
+        toolName: name,
+        content: content.length > 0 ? content : [{ type: "text", text: "" }],
+        isError: input.isError,
+        timestamp: input.at
+      }
+    });
+    if (this.pending.size === 0) {
+      this.items.push(...this.held);
+      this.held = [];
+    }
+  }
+  /**
+   * The other tool compacted the conversation here: from now on its model saw the summary instead of what came
+   * before. `keepFrom` lists, in order, the items the tool kept word for word after its summary (Claude Code's
+   * preserved segment); the first of them that was imported is where pi's kept part starts.
+   */
+  compaction(summary, tokensBefore, at, keepFrom = []) {
+    if (!summary.trim()) return;
+    this.settle();
+    this.counts.compactions++;
+    this.items.push({ kind: "compaction", summary, tokensBefore, at, keepFrom });
+  }
+  /** The session file's lines: header, marker, name, then the conversation as one chain. */
+  finish(input) {
+    this.settle();
+    const taken = /* @__PURE__ */ new Set();
+    const newId = () => {
+      for (let attempt = 0; attempt < 100; attempt++) {
+        const id2 = randomUUID().slice(0, 8);
+        if (!taken.has(id2)) {
+          taken.add(id2);
+          return id2;
+        }
+      }
+      const id = randomUUID();
+      taken.add(id);
+      return id;
+    };
+    const startedAt = Date.parse(input.started);
+    const iso = (at) => new Date(at > 0 ? at : startedAt).toISOString();
+    const ids = this.items.map(() => newId());
+    const byKey = /* @__PURE__ */ new Map();
+    this.items.forEach((item, index) => {
+      if (item.kind !== "compaction" && item.key && !byKey.has(item.key)) byKey.set(item.key, index);
+    });
+    let lastCompaction = -1;
+    this.items.forEach((item, index) => {
+      if (item.kind === "compaction") lastCompaction = index;
+    });
+    this.counts.entries = this.items.length + 2 + (lastCompaction >= 0 ? 1 : 0);
+    const header = {
+      type: "session",
+      version: SESSION_VERSION,
+      id: input.sessionId,
+      timestamp: input.started,
+      cwd: input.cwd
+    };
+    const marker = {
+      type: "custom_message",
+      id: newId(),
+      parentId: null,
+      timestamp: input.started,
+      customType: IMPORT_MARKER,
+      content: input.note,
+      display: true,
+      details: { ...input.origin, counts: this.counts }
+    };
+    const info = {
+      type: "session_info",
+      id: newId(),
+      parentId: marker.id,
+      timestamp: input.started,
+      name: input.name.replace(/[\r\n]+/g, " ").trim()
+    };
+    const entries = [marker, info];
+    let parentId = info.id;
+    this.items.forEach((item, index) => {
+      const id = ids[index];
+      const timestamp = iso(item.at);
+      if (item.kind === "message") {
+        entries.push({ type: "message", id, parentId, timestamp, message: item.message });
+      } else if (item.kind === "context") {
+        const context = {
+          type: "custom_message",
+          id,
+          parentId,
+          timestamp,
+          customType: IMPORT_CONTEXT,
+          content: item.text,
+          display: false
+        };
+        entries.push(context);
+      } else {
+        const kept = item.keepFrom.map((key) => byKey.get(key)).find((at) => at !== void 0);
+        const firstKeptEntryId = kept !== void 0 && kept < index ? ids[kept] : index + 1 < ids.length ? ids[index + 1] : newId();
+        const compaction = {
+          type: "compaction",
+          id,
+          parentId,
+          timestamp,
+          summary: item.summary,
+          firstKeptEntryId,
+          tokensBefore: item.tokensBefore
+        };
+        entries.push(compaction);
+      }
+      parentId = id;
+      if (index === lastCompaction) {
+        const again = { ...marker, id: newId(), parentId, timestamp };
+        entries.push(again);
+        parentId = again.id;
+      }
+    });
+    return [header, ...entries];
+  }
+};
+function importNote(tool, source) {
+  const name = TOOL_NAMES[tool];
+  return [
+    `This conversation was imported from ${name} (${source}) and continues here.`,
+    `Its tool calls use ${name}'s tool names, which may differ from the tools available now.`,
+    "Thinking and images were not imported."
+  ].join(" ");
+}
+function complete(builder, input) {
+  const started = Number.isNaN(Date.parse(input.started)) ? (/* @__PURE__ */ new Date()).toISOString() : input.started;
+  const sessionId = uuidv7(Date.parse(started));
+  const name = input.name?.trim() || `${TOOL_NAMES[builder.tool]} conversation`;
+  const entries = builder.finish({
+    sessionId,
+    cwd: input.cwd,
+    started,
+    name,
+    note: importNote(builder.tool, input.source),
+    origin: {
+      version: 1,
+      tool: builder.tool,
+      source: input.source,
+      sourceId: input.sourceId,
+      importedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
+      ...input.model ? { model: input.model } : {}
+    }
+  });
+  return {
+    tool: builder.tool,
+    source: input.source,
+    sourceId: input.sourceId,
+    sessionId,
+    cwd: input.cwd,
+    started,
+    name,
+    model: input.model,
+    counts: builder.counts,
+    entries,
+    hasConversation: builder.hasConversation
+  };
+}
+function writeSessionFile(file, entries) {
+  const fd = openSync2(file, "wx", 384);
+  try {
+    for (const entry of entries) writeSync(fd, `${JSON.stringify(entry)}
+`);
+  } finally {
+    closeSync2(fd);
+  }
+}
+
+// packages/kyrn-judge/src/import/claude-code.ts
+var TREE_TYPES = /* @__PURE__ */ new Set(["user", "assistant", "system", "attachment"]);
+function slim(data) {
+  delete data.toolUseResult;
+  for (const block of list(record(data.message)?.content)) {
+    const outer = record(block);
+    if (outer?.type === "image") delete outer.source;
+    if (outer?.type === "tool_result") {
+      for (const inner of list(outer.content)) {
+        const image = record(inner);
+        if (image?.type === "image") delete image.source;
+      }
+    }
+  }
+  const file = record(record(record(data.attachment)?.content)?.file);
+  if (file) delete file.base64;
+}
+function blocksOf(message) {
+  const content = message?.content;
+  if (typeof content === "string") return [{ type: "text", text: content }];
+  return list(content).map(record).filter((block) => block !== void 0);
+}
+function messageOf(item) {
+  return record(item.data.message) ?? {};
+}
+function resultContent(content, counts) {
+  if (typeof content === "string") return [{ type: "text", text: content }];
+  const blocks = [];
+  for (const block of list(content).map(record)) {
+    if (!block) continue;
+    if (block.type === "text") blocks.push({ type: "text", text: str(block.text) ?? "" });
+    else if (block.type === "image") blocks.push(IMAGE);
+    else if (block.type === "tool_reference")
+      blocks.push({ type: "text", text: `[tool reference: ${str(block.tool_name) ?? "unknown"}]` });
+    else {
+      counts.asText++;
+      blocks.push({ type: "text", text: unknownBlockText(block) });
+    }
+  }
+  return blocks;
+}
+function attachmentText(attachment) {
+  const where = (...names) => names.map(str).find((name) => name !== void 0);
+  switch (attachment.type) {
+    case "file": {
+      const file = record(record(attachment.content)?.file);
+      const text = str(file?.content);
+      if (text === void 0) return void 0;
+      return `Contents of ${where(attachment.displayPath, attachment.filename, file?.filePath) ?? "a file"}:
+${text}`;
+    }
+    case "edited_text_file":
+      return `${where(attachment.displayPath, attachment.filename) ?? "A file"} was changed:
+${str(attachment.snippet) ?? ""}`;
+    case "directory":
+      return `Contents of ${where(attachment.displayPath, attachment.path) ?? "a folder"}:
+${str(attachment.content) ?? ""}`;
+    case "nested_memory": {
+      const memory = record(attachment.content);
+      return `Contents of ${where(attachment.displayPath, memory?.path) ?? "a memory file"}:
+${str(memory?.content) ?? ""}`;
+    }
+    case "plan_file_reference":
+      return `The plan in ${where(attachment.planFilePath) ?? "a plan file"}:
+${str(attachment.planContent) ?? ""}`;
+    case "hook_additional_context":
+      return list(attachment.content).map(str).filter((text) => text !== void 0).join("\n");
+    default:
+      return void 0;
+  }
+}
+async function readClaudeCode(path, options = {}) {
+  const source = absolute(path);
+  const builder = new SessionBuilder("claude-code");
+  const { counts } = builder;
+  const records = [];
+  const byUuid = /* @__PURE__ */ new Map();
+  let sessionId;
+  for await (const line of readJsonLines(source)) {
+    counts.records++;
+    if (!("value" in line)) {
+      builder.drop(line.problem === "oversized" ? "lines too long to read" : "unreadable lines");
+      continue;
+    }
+    const data = record(line.value);
+    const type = str(data?.type);
+    if (!data || !type) {
+      builder.drop("records not understood");
+      continue;
+    }
+    sessionId ??= str(data.sessionId);
+    const uuid = str(data.uuid);
+    if (!TREE_TYPES.has(type) || !uuid) {
+      builder.drop(uuid ? "records not understood" : "Claude Code bookkeeping (titles, queue, file history)");
+      continue;
+    }
+    if (byUuid.has(uuid)) {
+      builder.drop("repeated records");
+      continue;
+    }
+    slim(data);
+    const item = {
+      uuid,
+      parent: str(data.parentUuid),
+      logicalParent: str(data.logicalParentUuid),
+      type,
+      sidechain: data.isSidechain === true,
+      data
+    };
+    records.push(item);
+    byUuid.set(uuid, item);
+  }
+  const hasMain = records.some((item) => !item.sidechain);
+  const inScope = (item) => !hasMain || !item.sidechain;
+  let leaf;
+  for (let index = records.length - 1; index >= 0 && !leaf; index--) {
+    const item = records[index];
+    if (inScope(item) && (item.type === "user" || item.type === "assistant")) leaf = item;
+  }
+  const chosen = /* @__PURE__ */ new Set();
+  const position = new Map(records.map((item, index) => [item.uuid, index]));
+  const messageBefore = (item) => {
+    for (let index = (position.get(item.uuid) ?? 0) - 1; index >= 0; index--) {
+      const earlier = records[index];
+      if (inScope(earlier) && (earlier.type === "user" || earlier.type === "assistant")) return earlier;
+    }
+    return void 0;
+  };
+  for (let current2 = leaf; current2 && !chosen.has(current2.uuid); ) {
+    chosen.add(current2.uuid);
+    const next = current2.parent ?? current2.logicalParent;
+    let found = next ? byUuid.get(next) : void 0;
+    if (next && !found) {
+      if (!current2.parent) found = messageBefore(current2);
+      if (!found) builder.drop("links to records that are not in the file");
+    }
+    current2 = found;
+  }
+  const answers = /* @__PURE__ */ new Set();
+  for (const item of records) {
+    const id = str(messageOf(item).id);
+    if (chosen.has(item.uuid) && item.type === "assistant" && id) answers.add(id);
+  }
+  for (const item of records) {
+    const id = str(messageOf(item).id);
+    if (!chosen.has(item.uuid) && item.type === "assistant" && inScope(item) && id && answers.has(id))
+      chosen.add(item.uuid);
+  }
+  const calls = /* @__PURE__ */ new Set();
+  for (const item of records) {
+    if (!chosen.has(item.uuid) || item.type !== "assistant") continue;
+    for (const block of blocksOf(messageOf(item))) {
+      const id = str(block.id);
+      if (block.type === "tool_use" && id) calls.add(id);
+    }
+  }
+  for (const item of records) {
+    if (chosen.has(item.uuid) || item.type !== "user" || !inScope(item)) continue;
+    const answersCall = blocksOf(messageOf(item)).some(
+      (block) => block.type === "tool_result" && calls.has(str(block.tool_use_id) ?? "")
+    );
+    if (answersCall) chosen.add(item.uuid);
+  }
+  let subAgent = 0;
+  let offBranch = 0;
+  for (const item of records) {
+    if (chosen.has(item.uuid)) continue;
+    if (inScope(item)) offBranch++;
+    else subAgent++;
+  }
+  builder.drop("sub-agent records", subAgent);
+  builder.drop("records off the latest branch", offBranch);
+  const ordered = records.filter((item) => chosen.has(item.uuid));
+  const orderedIds = ordered.map((item) => item.uuid);
+  let at = 0;
+  let started;
+  let cwd;
+  let model;
+  let name;
+  let firstCommand;
+  let boundary;
+  const answerParts = /* @__PURE__ */ new Map();
+  const partOf = /* @__PURE__ */ new Map();
+  let current;
+  for (const item of ordered) {
+    const message = messageOf(item);
+    if (item.type === "assistant") {
+      if (item.data.isApiErrorMessage === true || message.model === "<synthetic>") {
+        current = void 0;
+        continue;
+      }
+      const id = str(message.id) ?? item.uuid;
+      const continues = current !== void 0 && current.id === id && (!current.interrupted || current.waiting.size > 0);
+      if (!current || !continues) {
+        current = { id, first: item.uuid, waiting: /* @__PURE__ */ new Set(), interrupted: false };
+        answerParts.set(item.uuid, []);
+      }
+      answerParts.get(current.first)?.push(item);
+      partOf.set(item.uuid, current.first);
+      for (const block of blocksOf(message)) {
+        const callId = str(block.id);
+        if (block.type === "tool_use" && callId) current.waiting.add(callId);
+      }
+    } else if (item.type === "user" && current) {
+      const blocks = blocksOf(message);
+      for (const block of blocks)
+        if (block.type === "tool_result") current.waiting.delete(str(block.tool_use_id) ?? "");
+      current.interrupted = true;
+      if (item.data.isMeta !== true && blocks.some((block) => block.type !== "tool_result")) current = void 0;
+    }
+  }
+  const assistantRecord = (item) => {
+    const message = messageOf(item);
+    const used = str(message.model) ?? "";
+    if (item.data.isApiErrorMessage === true) {
+      const text = blocksOf(message).map((block) => str(block.text) ?? "").join("\n").trim();
+      builder.assistant({ blocks: [], error: text || "The request failed.", model: used, at, key: item.uuid });
+      return;
+    }
+    if (used === "<synthetic>") {
+      builder.drop("Claude Code's own placeholder answers");
+      return;
+    }
+    if (partOf.get(item.uuid) !== item.uuid) return;
+    if (used) model = used;
+    const blocks = [];
+    const callIds = /* @__PURE__ */ new Set();
+    let stop;
+    for (const part of answerParts.get(item.uuid) ?? [item]) {
+      const partMessage = messageOf(part);
+      if (partMessage.stop_reason === "max_tokens") stop = "length";
+      for (const block of blocksOf(partMessage)) {
+        if (block.type === "text") blocks.push({ type: "text", text: str(block.text) ?? "" });
+        else if (block.type === "thinking" || block.type === "redacted_thinking") builder.drop("thinking");
+        else if (block.type === "tool_use") {
+          const callId = str(block.id) ?? part.uuid;
+          if (callIds.has(callId)) {
+            builder.drop("repeated tool calls");
+            continue;
+          }
+          callIds.add(callId);
+          blocks.push({
+            type: "toolCall",
+            id: callId,
+            name: str(block.name) ?? "unknown",
+            arguments: toolArguments(block.input)
+          });
+        } else if (block.type === "image") {
+          builder.drop("images");
+          blocks.push({ type: "text", text: IMAGE_MARKER });
+        } else {
+          counts.asText++;
+          blocks.push({ type: "text", text: unknownBlockText(block) });
+        }
+      }
+    }
+    builder.assistant({ blocks, model: used, at, key: item.uuid, stopReason: stop });
+  };
+  const userRecord = (item) => {
+    const blocks = blocksOf(messageOf(item));
+    if (item.data.isCompactSummary === true) {
+      const summary = blocks.map((block) => str(block.text) ?? "").join("\n");
+      builder.compaction(summary, boundary?.tokens ?? 0, boundary?.at ?? at, boundary?.keep);
+      boundary = void 0;
+      return;
+    }
+    const meta = item.data.isMeta === true;
+    const words = [];
+    const say = () => {
+      if (words.length === 0) return;
+      builder.user(words.splice(0), at, item.uuid);
+    };
+    for (const block of blocks) {
+      if (block.type === "tool_result") {
+        say();
+        builder.toolResult({
+          id: str(block.tool_use_id) ?? "",
+          content: resultContent(block.content, counts),
+          isError: block.is_error === true,
+          at,
+          key: item.uuid
+        });
+        continue;
+      }
+      if (block.type === "image") {
+        if (meta) builder.drop("images");
+        else words.push(IMAGE);
+        continue;
+      }
+      if (block.type !== "text") {
+        counts.asText++;
+        words.push({ type: "text", text: unknownBlockText(block) });
+        continue;
+      }
+      const text = str(block.text) ?? "";
+      const kind = meta ? "context" : classifyUserText(text);
+      if (kind === "setup") {
+        builder.drop("Claude Code setup");
+        continue;
+      }
+      if (kind === "context") {
+        say();
+        builder.context(text, at, item.uuid);
+        continue;
+      }
+      const shell = shellText(text);
+      if (shell) {
+        words.push({ type: "text", text: `! ${shell.command}` });
+        say();
+        builder.context(shell.output, at);
+        continue;
+      }
+      const command = commandText(text);
+      if (command !== void 0) {
+        firstCommand ??= command;
+        words.push({ type: "text", text: command });
+        continue;
+      }
+      if (name === void 0 && text.trim()) name = firstLine(text);
+      words.push({ type: "text", text });
+    }
+    say();
+  };
+  const systemRecord = (item, index) => {
+    const subtype = str(item.data.subtype);
+    if (subtype === "compact_boundary") {
+      const metadata = record(item.data.compactMetadata);
+      const head = str(record(metadata?.preservedSegment)?.headUuid);
+      const start = head ? orderedIds.indexOf(head) : -1;
+      const tokens = metadata?.preTokens;
+      boundary = {
+        tokens: typeof tokens === "number" ? tokens : 0,
+        at,
+        keep: start >= 0 && start < index ? orderedIds.slice(start, index) : []
+      };
+      return;
+    }
+    if (subtype === "local_command") {
+      builder.context(str(item.data.content) ?? "", at, item.uuid);
+      return;
+    }
+    builder.drop("Claude Code status records");
+  };
+  const attachmentRecord = (item) => {
+    const attachment = record(item.data.attachment) ?? {};
+    if (attachment.type === "queued_command") {
+      const prompt = attachment.prompt;
+      const words = typeof prompt === "string" ? [{ type: "text", text: prompt }] : list(prompt).map(record).filter((block) => block !== void 0).map(
+        (block) => block.type === "text" ? { type: "text", text: str(block.text) ?? "" } : IMAGE
+      );
+      const typed = attachment.commandMode === "prompt" && attachment.isMeta !== true;
+      if (typed) {
+        const text2 = words.map((block) => block.type === "text" ? block.text : "").join("\n");
+        if (name === void 0 && text2.trim()) name = firstLine(text2);
+        builder.user(words, at, item.uuid);
+      } else {
+        const text2 = words.map((block) => block.type === "text" ? block.text : IMAGE_MARKER).join("\n");
+        builder.context(text2, at, item.uuid);
+      }
+      return;
+    }
+    if (attachment.type === "file" && record(attachment.content)?.type === "image") {
+      builder.drop("images");
+      return;
+    }
+    const text = attachmentText(attachment);
+    if (text === void 0) builder.drop("Claude Code reminders and state");
+    else builder.context(text, at, item.uuid);
+  };
+  ordered.forEach((item, index) => {
+    const time = Date.parse(str(item.data.timestamp) ?? "");
+    if (!Number.isNaN(time)) at = time;
+    if (started === void 0 && at > 0) started = at;
+    cwd ??= str(item.data.cwd);
+    if (item.type === "assistant") assistantRecord(item);
+    else if (item.type === "user") userRecord(item);
+    else if (item.type === "system") systemRecord(item, index);
+    else attachmentRecord(item);
+  });
+  if (boundary) builder.drop("compactions without their summary");
+  cwd ??= records.map((item) => str(item.data.cwd)).find((dir) => dir !== void 0);
+  let startedIso = started === void 0 ? void 0 : new Date(started).toISOString();
+  if (!startedIso) {
+    try {
+      startedIso = statSync2(source).mtime.toISOString();
+    } catch {
+      startedIso = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  const agentId = hasMain ? void 0 : records.map((item) => str(item.data.agentId)).find((id) => id !== void 0);
+  return complete(builder, {
+    source,
+    sourceId: agentId ? `agent-${agentId}` : sessionId ?? basename(source, ".jsonl"),
+    cwd: cwd ?? options.cwd ?? process.cwd(),
+    started: startedIso,
+    name: name ?? firstCommand,
+    model,
+    now: options.now
+  });
+}
+
+// packages/kyrn-judge/src/import/codex.ts
+import { statSync as statSync3 } from "node:fs";
+import { basename as basename2 } from "node:path";
+var APP_RECORDS = /* @__PURE__ */ new Set([
+  "event_msg",
+  "world_state",
+  "token_usage_record",
+  "inter_agent_communication_metadata"
+]);
+function environmentCwd(text) {
+  return /<cwd>([\s\S]*?)<\/cwd>/.exec(text)?.[1]?.trim() || void 0;
+}
+function outputOf(output, counts) {
+  if (typeof output === "string") {
+    if (output.startsWith("{")) {
+      try {
+        const parsed = record(JSON.parse(output));
+        const text = str(parsed?.output);
+        if (parsed && text !== void 0) {
+          const exit = record(parsed.metadata)?.exit_code;
+          return { content: text, isError: typeof exit === "number" && exit !== 0 };
+        }
+      } catch {
+      }
+    }
+    return { content: output, isError: false };
+  }
+  const object = record(output);
+  if (object) {
+    const text = str(object.content);
+    return { content: text ?? unknownBlockText(object), isError: object.success === false };
+  }
+  const blocks = [];
+  for (const block of list(output).map(record)) {
+    if (!block) continue;
+    if (block.type === "input_text" || block.type === "output_text" || block.type === "text")
+      blocks.push({ type: "text", text: str(block.text) ?? "" });
+    else if (block.type === "input_image") blocks.push(IMAGE);
+    else {
+      counts.asText++;
+      blocks.push({ type: "text", text: unknownBlockText(block) });
+    }
+  }
+  return { content: blocks, isError: false };
+}
+function compactionText(summary, kept) {
+  const parts = [summary || "Codex compacted the conversation here. Its summary cannot be read outside Codex."];
+  if (kept.length > 0) {
+    const messages = clip(kept.map((text) => clip(text, 4e3).text).join("\n\n---\n\n"), 4e4).text;
+    parts.push(`The user's messages that Codex kept after compacting:
+
+${messages}`);
+  }
+  return parts.join("\n\n");
+}
+async function readCodex(path, options = {}) {
+  const source = absolute(path);
+  const builder = new SessionBuilder("codex");
+  const { counts } = builder;
+  let sourceId = "";
+  let sawMeta = false;
+  let cwd;
+  let started;
+  let model;
+  let lastModel;
+  let at = 0;
+  let tokens = 0;
+  let name;
+  let firstCommand;
+  let open;
+  const flush = () => {
+    if (!open) return;
+    const { blocks, at: when, model: used } = open;
+    open = void 0;
+    builder.assistant({ blocks, model: used, at: when });
+  };
+  const answer = () => {
+    open ??= { blocks: [], at, model: model ?? "unknown" };
+    if (model) lastModel = model;
+    return open;
+  };
+  const userMessage = (blocks) => {
+    flush();
+    const words = [];
+    const say = () => {
+      if (words.length > 0) builder.user(words.splice(0), at);
+    };
+    for (const block of blocks) {
+      if (block.type === "input_image") {
+        words.push(IMAGE);
+        continue;
+      }
+      if (block.type !== "input_text" && block.type !== "text") {
+        counts.asText++;
+        words.push({ type: "text", text: unknownBlockText(block) });
+        continue;
+      }
+      const text = str(block.text) ?? "";
+      const kind = classifyUserText(text);
+      if (kind === "setup") {
+        cwd ??= environmentCwd(text);
+        builder.drop("Codex setup");
+        continue;
+      }
+      if (kind === "context") {
+        say();
+        builder.context(text, at);
+        continue;
+      }
+      const shell = shellText(text);
+      if (shell) {
+        words.push({ type: "text", text: `! ${shell.command}` });
+        say();
+        builder.context(shell.output, at);
+        continue;
+      }
+      const command = commandText(text);
+      if (command !== void 0) {
+        firstCommand ??= command;
+        words.push({ type: "text", text: command });
+        continue;
+      }
+      if (name === void 0 && text.trim()) name = firstLine(text);
+      words.push({ type: "text", text });
+    }
+    say();
+  };
+  const item = (payload) => {
+    const callId = str(payload.call_id) ?? str(payload.id) ?? "";
+    switch (payload.type) {
+      case "message": {
+        const blocks = list(payload.content).map(record).filter((block) => block !== void 0);
+        if (payload.role === "assistant") {
+          const target = answer();
+          for (const block of blocks) {
+            if (block.type === "output_text" || block.type === "text" || block.type === "input_text")
+              target.blocks.push({ type: "text", text: str(block.text) ?? "" });
+            else if (block.type === "refusal")
+              target.blocks.push({ type: "text", text: str(block.refusal) ?? "" });
+            else {
+              counts.asText++;
+              target.blocks.push({ type: "text", text: unknownBlockText(block) });
+            }
+          }
+        } else if (payload.role === "user") userMessage(blocks);
+        else builder.drop("Codex instructions");
+        return;
+      }
+      case "reasoning":
+        builder.drop("thinking");
+        return;
+      case "function_call":
+      case "tool_search_call":
+        answer().blocks.push({
+          type: "toolCall",
+          id: callId,
+          name: str(payload.name) ?? (payload.type === "tool_search_call" ? "tool_search" : "unknown"),
+          arguments: toolArguments(payload.arguments)
+        });
+        return;
+      case "custom_tool_call":
+        answer().blocks.push({
+          type: "toolCall",
+          id: callId,
+          name: str(payload.name) ?? "unknown",
+          arguments: { input: str(payload.input) ?? "" }
+        });
+        return;
+      case "local_shell_call":
+        answer().blocks.push({
+          type: "toolCall",
+          id: callId,
+          name: "local_shell",
+          arguments: toolArguments(payload.action)
+        });
+        return;
+      case "web_search_call": {
+        const query = str(record(payload.action)?.query);
+        counts.asText++;
+        answer().blocks.push({ type: "text", text: query ? `(Searched the web: ${query})` : "(Searched the web)" });
+        return;
+      }
+      case "function_call_output":
+      case "custom_tool_call_output":
+      case "local_shell_call_output": {
+        flush();
+        const output = outputOf(payload.output, counts);
+        builder.toolResult({ id: callId, content: output.content, isError: output.isError, at });
+        return;
+      }
+      case "tool_search_output": {
+        flush();
+        const found = list(payload.tools).map((tool) => str(record(tool)?.name)).filter((toolName) => toolName !== void 0);
+        builder.toolResult({
+          id: callId,
+          content: found.length > 0 ? `Tools found: ${found.join(", ")}` : "No tools found.",
+          isError: false,
+          at
+        });
+        return;
+      }
+      case "agent_message": {
+        flush();
+        const text = list(payload.content).map((block) => str(record(block)?.text) ?? "").join("\n");
+        const from = str(payload.author) ?? "an agent";
+        const to = str(payload.recipient) ?? "an agent";
+        builder.context(`[Message from ${from} to ${to}]
+${text}`, at);
+        return;
+      }
+      default:
+        builder.drop("records not understood");
+    }
+  };
+  const compacted = (payload) => {
+    flush();
+    const summary = (str(payload.message) ?? "").trim();
+    const kept = [];
+    for (const entry of list(payload.replacement_history).map(record)) {
+      if (entry?.type !== "message" || entry.role !== "user") continue;
+      for (const block of list(entry.content)) {
+        const text = str(record(block)?.text)?.trim();
+        if (!text || classifyUserText(text) !== "user") continue;
+        if (summary && text.includes(summary.slice(0, 200))) continue;
+        kept.push(text);
+      }
+    }
+    builder.compaction(compactionText(summary, kept), tokens, at);
+  };
+  for await (const line of readJsonLines(source)) {
+    counts.records++;
+    if (!("value" in line)) {
+      builder.drop(line.problem === "oversized" ? "lines too long to read" : "unreadable lines");
+      continue;
+    }
+    const data = record(line.value);
+    if (!data) {
+      builder.drop("records not understood");
+      continue;
+    }
+    const payload = record(data.payload);
+    const type = str(data.type);
+    if (payload && type) {
+      const time = Date.parse(str(data.timestamp) ?? "");
+      if (!Number.isNaN(time)) at = time;
+      if (type === "session_meta") {
+        if (!sawMeta) {
+          sawMeta = true;
+          sourceId = str(payload.id) ?? "";
+          cwd = str(payload.cwd) ?? cwd;
+          started = str(payload.timestamp) ?? str(data.timestamp);
+        }
+      } else if (type === "turn_context") {
+        model = str(payload.model) ?? model;
+        cwd ??= str(payload.cwd);
+      } else if (type === "response_item") item(payload);
+      else if (type === "compacted") compacted(payload);
+      else if (APP_RECORDS.has(type)) {
+        if (type === "event_msg" && payload.type === "token_count") {
+          const input = record(record(payload.info)?.last_token_usage)?.input_tokens;
+          if (typeof input === "number") tokens = input;
+        }
+        builder.drop("Codex events and state");
+      } else builder.drop("records not understood");
+      continue;
+    }
+    if (data.record_type === "state") {
+      builder.drop("Codex events and state");
+      continue;
+    }
+    if (type) {
+      item(data);
+      continue;
+    }
+    const id = str(data.id);
+    const stamp = str(data.timestamp);
+    if (id && stamp) {
+      if (!sourceId) sourceId = id;
+      started ??= stamp;
+      const time = Date.parse(stamp);
+      if (!Number.isNaN(time)) at = time;
+      continue;
+    }
+    builder.drop("records not understood");
+  }
+  flush();
+  let startedIso = started && !Number.isNaN(Date.parse(started)) ? new Date(Date.parse(started)).toISOString() : void 0;
+  if (!startedIso) {
+    try {
+      startedIso = statSync3(source).mtime.toISOString();
+    } catch {
+      startedIso = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  const fromName = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i.exec(source)?.[1];
+  return complete(builder, {
+    source,
+    sourceId: sourceId || fromName || basename2(source, ".jsonl"),
+    cwd: cwd ?? options.cwd ?? process.cwd(),
+    started: startedIso,
+    name: name ?? firstCommand,
+    model: lastModel ?? model,
+    now: options.now
+  });
+}
+
+// packages/kyrn-judge/src/import/index.ts
+var CODEX_ITEMS = /* @__PURE__ */ new Set([
+  "message",
+  "function_call",
+  "function_call_output",
+  "custom_tool_call",
+  "custom_tool_call_output",
+  "local_shell_call",
+  "reasoning"
+]);
+function detectTool(path) {
+  let tool;
+  let lines = 0;
+  readHead(
+    path,
+    (value) => {
+      lines++;
+      const data = record(value);
+      if (data) {
+        if (record(data.payload) && typeof data.type === "string") tool = "codex";
+        else if (typeof data.sessionId === "string" || typeof data.uuid === "string" || typeof data.leafUuid === "string")
+          tool = "claude-code";
+        else if (data.record_type === "state") tool = "codex";
+        else if (typeof data.id === "string" && typeof data.timestamp === "string" && data.type === void 0)
+          tool = "codex";
+        else if (typeof data.type === "string" && CODEX_ITEMS.has(data.type)) tool = "codex";
+      }
+      return tool !== void 0 || lines >= 50;
+    },
+    4 * 1024 * 1024
+  );
+  return tool;
+}
+var TREE_TYPES2 = /* @__PURE__ */ new Set(["user", "assistant", "system", "attachment"]);
+function titleParts(text) {
+  if (classifyUserText(text) !== "user") return {};
+  const command = commandText(text);
+  if (command !== void 0) return { command };
+  if (/^\s*<bash-input>/.test(text)) return {};
+  const line = firstLine(text);
+  return line ? { title: line } : {};
+}
+function describeClaudeCode(path) {
+  let id;
+  let agentId;
+  let cwd;
+  let started;
+  let title;
+  let command;
+  let named;
+  let first;
+  readHead(path, (value) => {
+    const data = record(value);
+    if (!data) return false;
+    id ??= str(data.sessionId);
+    const type = str(data.type);
+    if (type === "custom-title") named ??= str(data.customTitle);
+    else if (type === "ai-title") named ??= str(data.aiTitle);
+    else if (type === "summary") named ??= str(data.summary);
+    if (!type || !TREE_TYPES2.has(type)) return false;
+    first ??= data.isSidechain === true;
+    if (first) agentId ??= str(data.agentId);
+    cwd ??= str(data.cwd);
+    started ??= str(data.timestamp);
+    const own = first || data.isSidechain !== true;
+    if (type === "user" && own && data.isMeta !== true && data.isCompactSummary !== true) {
+      const message = record(data.message);
+      const content = message?.content;
+      const texts = typeof content === "string" ? [content] : (Array.isArray(content) ? content : []).map((block) => record(block)).filter((block) => block?.type === "text").map((block) => str(block?.text) ?? "");
+      for (const text of texts) {
+        const parts = titleParts(text);
+        title ??= parts.title;
+        command ??= parts.command;
+      }
+    }
+    return title !== void 0 && cwd !== void 0 && id !== void 0;
+  });
+  return {
+    id: first && agentId ? `agent-${agentId}` : id ?? "",
+    cwd,
+    title: title ?? named ?? command ?? "",
+    started,
+    subAgent: first === true
+  };
+}
+function describeCodex(path) {
+  let id;
+  let cwd;
+  let started;
+  let title;
+  let command;
+  let subAgent = false;
+  let sawMeta = false;
+  const visit = (item) => {
+    if (item.type !== "message" || item.role !== "user" || !Array.isArray(item.content)) return;
+    for (const block of item.content) {
+      const text = str(record(block)?.text);
+      if (text === void 0) continue;
+      if (classifyUserText(text) === "setup") cwd ??= environmentCwd(text);
+      const parts = titleParts(text);
+      title ??= parts.title;
+      command ??= parts.command;
+    }
+  };
+  readHead(path, (value) => {
+    const data = record(value);
+    if (!data) return false;
+    const payload = record(data.payload);
+    const type = str(data.type);
+    if (payload && type) {
+      if (type === "session_meta" && !sawMeta) {
+        sawMeta = true;
+        id = str(payload.id) ?? id;
+        cwd = str(payload.cwd) ?? cwd;
+        started = str(payload.timestamp) ?? str(data.timestamp);
+        subAgent = record(payload.source) !== void 0 || payload.thread_source === "subagent";
+      } else if (type === "turn_context") cwd ??= str(payload.cwd);
+      else if (type === "response_item") visit(payload);
+    } else if (type) visit(data);
+    else if (str(data.id) && str(data.timestamp)) {
+      id ??= str(data.id);
+      started ??= str(data.timestamp);
+    }
+    return title !== void 0 && cwd !== void 0 && id !== void 0;
+  });
+  const fromName = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i.exec(path)?.[1];
+  return { id: id ?? fromName ?? "", cwd, title: title ?? command ?? "", started, subAgent };
+}
+function claudeProjectsDir(env = process.env, home = homedir2()) {
+  return join2(env.CLAUDE_CONFIG_DIR ? absolute(env.CLAUDE_CONFIG_DIR) : join2(home, ".claude"), "projects");
+}
+function codexSessionsDir(env = process.env, home = homedir2()) {
+  return join2(env.CODEX_HOME ? absolute(env.CODEX_HOME) : join2(home, ".codex"), "sessions");
+}
+function sameFolder(a, b) {
+  const canonical = (dir) => {
+    const path = absolute(dir);
+    try {
+      return realpathSync.native(path);
+    } catch {
+      return path;
+    }
+  };
+  return canonical(a) === canonical(b);
+}
+function jsonlFiles(dir, depth) {
+  let names;
+  try {
+    names = readdirSync2(dir);
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const name of names.sort()) {
+    const path = join2(dir, name);
+    if (name.endsWith(".jsonl")) files.push(path);
+    else if (depth > 0 && !name.startsWith(".")) {
+      try {
+        if (statSync4(path).isDirectory()) files.push(...jsonlFiles(path, depth - 1));
+      } catch {
+      }
+    }
+  }
+  return files;
+}
+function listConversations(options = {}) {
+  const claudeProjects = options.claudeProjects ?? claudeProjectsDir();
+  const codexSessions = options.codexSessions ?? codexSessionsDir();
+  const candidates = [];
+  let projects = [];
+  try {
+    projects = readdirSync2(claudeProjects).sort();
+  } catch {
+  }
+  for (const project of projects) {
+    for (const path of jsonlFiles(join2(claudeProjects, project), 0)) candidates.push({ tool: "claude-code", path });
+  }
+  for (const path of jsonlFiles(codexSessions, 4)) candidates.push({ tool: "codex", path });
+  const imported = /* @__PURE__ */ new Map();
+  if (options.store) {
+    for (const found of findImports(options.store)) {
+      imported.set(`${found.origin.tool}:id:${found.origin.sourceId}`, found.sessionFile);
+      imported.set(`${found.origin.tool}:path:${found.origin.source}`, found.sessionFile);
+    }
+  }
+  const conversations = [];
+  for (const { tool, path } of candidates) {
+    let size;
+    let modified;
+    try {
+      const stats = statSync4(path);
+      size = stats.size;
+      modified = stats.mtime.toISOString();
+    } catch {
+      continue;
+    }
+    let described;
+    try {
+      described = tool === "codex" ? describeCodex(path) : describeClaudeCode(path);
+    } catch {
+      continue;
+    }
+    if (described.subAgent && !options.subAgents) continue;
+    if (options.cwd && !(described.cwd && sameFolder(described.cwd, options.cwd))) continue;
+    const importedAs = (described.id ? imported.get(`${tool}:id:${described.id}`) : void 0) ?? imported.get(`${tool}:path:${path}`);
+    conversations.push({ tool, path, ...described, modified, size, ...importedAs ? { importedAs } : {} });
+  }
+  return conversations.sort((a, b) => b.modified.localeCompare(a.modified));
+}
+async function importOne(path, options, imports) {
+  const source = absolute(path);
+  const failed = (error) => ({ status: "failed", source, error });
+  try {
+    if (!statSync4(source).isFile()) return failed("not a file");
+  } catch {
+    return failed("no such file");
+  }
+  const already = (tool, earlier) => ({
+    status: "already-imported",
+    source,
+    tool,
+    sessionFile: earlier.sessionFile,
+    sessionId: earlier.sessionId
+  });
+  try {
+    const tool = detectTool(source);
+    if (!tool) return failed("not a Claude Code or Codex transcript");
+    const quick = (tool === "codex" ? describeCodex(source) : describeClaudeCode(source)).id;
+    const known = findImport(imports, tool, quick, source);
+    if (known) return already(tool, known);
+    const converted = tool === "codex" ? await readCodex(source, options) : await readClaudeCode(source, options);
+    const earlier = findImport(imports, tool, converted.sourceId, source);
+    if (earlier) return already(tool, earlier);
+    if (!converted.hasConversation) return failed("no messages in this transcript");
+    const dir = sessionDirFor(converted.cwd, options);
+    mkdirSync(dir, { recursive: true });
+    const sessionFile = join2(dir, sessionFileName(converted.started, converted.sessionId));
+    writeSessionFile(sessionFile, converted.entries);
+    imports.push({
+      sessionFile,
+      sessionId: converted.sessionId,
+      origin: {
+        version: 1,
+        tool,
+        source,
+        sourceId: converted.sourceId,
+        importedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        counts: converted.counts
+      }
+    });
+    return {
+      status: "imported",
+      source,
+      tool,
+      sessionFile,
+      sessionId: converted.sessionId,
+      name: converted.name,
+      cwd: converted.cwd,
+      counts: converted.counts
+    };
+  } catch (error) {
+    return failed(error instanceof Error ? error.message : String(error));
+  }
+}
+async function importTranscripts(paths, options) {
+  const imports = findImports(options);
+  const results = [];
+  for (const path of paths) results.push(await importOne(path, options, imports));
+  return results;
+}
+
+// packages/kyrn-judge/src/import/command.ts
+var USAGE = [
+  "mu import: bring Claude Code and Codex conversations into mu, to continue them here.",
+  "",
+  "  mu import --list [--json] [--cwd <dir>]   the conversations on this machine (only <dir>'s with --cwd)",
+  "  mu import <file>... [--json]              import these transcripts; each becomes a mu session",
+  "",
+  "  --agent-dir <dir>   mu's agent folder (default: MU_CODING_AGENT_DIR, else ~/.mu/agent)",
+  "  --sub-agents        also list the threads sub-agents ran",
+  "",
+  "Looks in ~/.claude/projects (CLAUDE_CONFIG_DIR) and ~/.codex/sessions (CODEX_HOME).",
+  "A conversation that was imported before is not imported again."
+].join("\n");
+function parseArgs(argv) {
+  const parsed = { help: false, list: false, json: false, subAgents: false, files: [] };
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    const value = () => {
+      const next = argv[index + 1];
+      index++;
+      return next === void 0 || next.startsWith("--") ? void 0 : next;
+    };
+    if (arg === "-h" || arg === "--help" || arg === "help") parsed.help = true;
+    else if (arg === "--list" || arg === "-l") parsed.list = true;
+    else if (arg === "--json") parsed.json = true;
+    else if (arg === "--sub-agents") parsed.subAgents = true;
+    else if (arg === "--cwd") {
+      const dir = value();
+      if (!dir) return { error: "--cwd needs a folder" };
+      parsed.cwd = dir;
+    } else if (arg === "--agent-dir") {
+      const dir = value();
+      if (!dir) return { error: "--agent-dir needs a folder" };
+      parsed.agentDir = dir;
+    } else if (arg.startsWith("--")) return { error: `unknown option ${arg}` };
+    else parsed.files.push(arg);
+  }
+  if (parsed.list && parsed.files.length > 0) return { error: "--list takes no files" };
+  return parsed;
+}
+function storeFor(agentDirArg, io) {
+  const agentDir = absolute(
+    agentDirArg ?? io.env.MU_CODING_AGENT_DIR ?? io.env.KYRN_CODING_AGENT_DIR ?? join3(io.home, ".mu", "agent"),
+    io.cwd
+  );
+  const fromEnv = io.env.MU_CODING_AGENT_SESSION_DIR;
+  if (fromEnv) return { agentDir, sessionDir: absolute(fromEnv, io.cwd) };
+  try {
+    const settings = JSON.parse(readFileSync(join3(agentDir, "settings.json"), "utf8"));
+    const sessionDir = settings !== null && typeof settings === "object" && "sessionDir" in settings ? settings.sessionDir : void 0;
+    if (typeof sessionDir === "string" && sessionDir.trim())
+      return { agentDir, sessionDir: absolute(sessionDir, io.cwd) };
+  } catch {
+  }
+  return { agentDir };
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit++;
+  }
+  return `${value < 10 ? value.toFixed(1) : Math.round(value)} ${units[unit]}`;
+}
+function formatDate(iso) {
+  const date = iso ? new Date(iso) : void 0;
+  if (!date || Number.isNaN(date.getTime())) return "????-??-?? ??:??";
+  const two = (value) => String(value).padStart(2, "0");
+  return `${date.getFullYear()}-${two(date.getMonth() + 1)}-${two(date.getDate())} ${two(date.getHours())}:${two(date.getMinutes())}`;
+}
+function tilde(path, home) {
+  return path === home ? "~" : path.startsWith(home + sep) ? `~${path.slice(home.length)}` : path;
+}
+function formatList(conversations, home) {
+  if (conversations.length === 0) return "No Claude Code or Codex conversations found.";
+  const groups = /* @__PURE__ */ new Map();
+  for (const conversation of conversations) {
+    const key = conversation.cwd ?? "";
+    const group = groups.get(key) ?? [];
+    group.push(conversation);
+    groups.set(key, group);
+  }
+  const lines = [];
+  const toolWidth = Math.max(...Object.values(TOOL_NAMES).map((name) => name.length));
+  for (const [cwd, group] of groups) {
+    if (lines.length > 0) lines.push("");
+    lines.push(cwd ? tilde(cwd, home) : "(folder unknown)");
+    for (const conversation of group) {
+      const title = conversation.title || "(no message found)";
+      const mark = conversation.importedAs ? "  (imported)" : "";
+      lines.push(
+        `  ${formatDate(conversation.modified)}  ${TOOL_NAMES[conversation.tool].padEnd(toolWidth)}  ${formatSize(conversation.size).padStart(7)}  ${title}${mark}`
+      );
+      lines.push(`${" ".repeat(20)}${tilde(conversation.path, home)}`);
+    }
+  }
+  const count = conversations.length;
+  lines.push("", `${count} conversation${count === 1 ? "" : "s"}. Import one with: mu import <file>`);
+  return lines.join("\n");
+}
+function formatResult(result, home) {
+  if (result.status === "failed") return `Could not import ${tilde(result.source, home)}: ${result.error}`;
+  if (result.status === "already-imported")
+    return [
+      `Already imported: ${tilde(result.source, home)}`,
+      `  it is the session ${tilde(result.sessionFile, home)}`
+    ].join("\n");
+  const { counts } = result;
+  const left = Object.entries(counts.dropped).sort((a, b) => b[1] - a[1]).map(([reason, count]) => `${reason} ${count}`);
+  return [
+    `Imported from ${TOOL_NAMES[result.tool]}: "${result.name}"`,
+    `  ${tilde(result.sessionFile, home)}`,
+    `  ${counts.user} messages from you, ${counts.assistant} answers, ${counts.toolCalls} tool calls${counts.compactions > 0 ? `, ${counts.compactions} compactions` : ""}`,
+    ...left.length > 0 ? [`  left out: ${left.join(", ")}`] : [],
+    `  continue it: mu --session ${result.sessionFile}`
+  ].join("\n");
+}
+async function main(argv, io) {
+  const parsed = parseArgs(argv);
+  if ("error" in parsed) {
+    io.err(`mu import: ${parsed.error}
+
+${USAGE}`);
+    return 2;
+  }
+  if (parsed.help || !parsed.list && parsed.files.length === 0) {
+    io.out(USAGE);
+    return parsed.help ? 0 : 2;
+  }
+  const store = storeFor(parsed.agentDir, io);
+  if (parsed.list) {
+    const conversations = listConversations({
+      cwd: parsed.cwd === void 0 ? void 0 : absolute(parsed.cwd, io.cwd),
+      store,
+      subAgents: parsed.subAgents
+    });
+    io.out(parsed.json ? JSON.stringify({ conversations }, null, 2) : formatList(conversations, io.home));
+    return 0;
+  }
+  const results = await importTranscripts(
+    parsed.files.map((file) => absolute(file, io.cwd)),
+    { ...store, cwd: io.cwd }
+  );
+  io.out(
+    parsed.json ? JSON.stringify({ results }, null, 2) : results.map((result) => formatResult(result, io.home)).join("\n\n")
+  );
+  return results.some((result) => result.status === "failed") ? 1 : 0;
+}
+function processIo() {
+  return {
+    out: (text) => process.stdout.write(`${text}
+`),
+    err: (text) => process.stderr.write(`${text}
+`),
+    env: process.env,
+    cwd: process.cwd(),
+    home: homedir3()
+  };
+}
+
+// packages/kyrn-judge/src/import/cli.ts
+main(process.argv.slice(2), processIo()).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (error) => {
+    process.stderr.write(`mu import: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 1;
+  }
+);