mu-agent 0.1.8 → 0.1.13

package/judge/dist/import.js

@@ -1,21 +1,26 @@
 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";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join4, sep } from "node:path";
+
+// packages/kyrn-judge/src/language.ts
+function count(n, one, many = `${one}s`) {
+  return `${n} ${n === 1 ? one : many}`;
+}
 
 // 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";
+import { mkdirSync, readdirSync as readdirSync2, readFileSync, realpathSync, renameSync as renameSync2, statSync as statSync5, writeFileSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } 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";
+import { closeSync, createReadStream, fstatSync, openSync, readSync } from "node:fs";
 var MAX_LINE_BYTES = 64 * 1024 * 1024;
 function parse(bytes) {
   const text = bytes.toString("utf8").trim();
@@ -69,18 +74,18 @@ function readHead(path, visit, limit = 1024 * 1024) {
   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) {
+    let read2 = 0;
+    while (read2 < limit) {
+      const count2 = readSync(fd, chunk, 0, Math.min(chunk.length, limit - read2), null);
+      if (count2 === 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)]);
+      read2 += count2;
+      pending = Buffer.concat([pending, chunk.subarray(0, count2)]);
       let start = 0;
       for (let newline = pending.indexOf(10, start); newline !== -1; newline = pending.indexOf(10, start)) {
         const line = pending.subarray(start, newline);
@@ -95,6 +100,29 @@ function readHead(path, visit, limit = 1024 * 1024) {
     closeSync(fd);
   }
 }
+function readTail(path, limit = 256 * 1024) {
+  const fd = openSync(path, "r");
+  try {
+    const size = fstatSync(fd).size;
+    const start = Math.max(0, size - limit);
+    const buffer = Buffer.allocUnsafe(size - start);
+    const count2 = readSync(fd, buffer, 0, buffer.length, start);
+    let text = buffer.subarray(0, count2);
+    if (start > 0) {
+      const newline = text.indexOf(10);
+      text = newline === -1 ? Buffer.alloc(0) : text.subarray(newline + 1);
+    }
+    const values = [];
+    for (const line of text.toString("utf8").split("\n")) {
+      if (!line.trim()) continue;
+      const parsed = parse(Buffer.from(line));
+      if ("value" in parsed) values.push(parsed.value);
+    }
+    return values;
+  } finally {
+    closeSync(fd);
+  }
+}
 function record(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
@@ -106,16 +134,24 @@ function list(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 { createHash, randomBytes, randomUUID } from "node:crypto";
+import { closeSync as closeSync2, openSync as openSync2, readdirSync, renameSync, rmSync, 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 TOOL_NAMES = {
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  zcode: "ZCode"
+};
+var isImportTool = (value) => typeof value === "string" && Object.hasOwn(TOOL_NAMES, value);
 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 MAX_IMAGE_CHARS = 7 * 1024 * 1024;
+var MAX_IMAGES_CHARS = 48 * 1024 * 1024;
+var IMAGE_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
 var NO_RESULT = "No result was recorded for this call.";
 function emptyCounts() {
   return {
@@ -125,6 +161,8 @@ function emptyCounts() {
     assistant: 0,
     toolCalls: 0,
     toolResults: 0,
+    thinking: 0,
+    images: 0,
     context: 0,
     compactions: 0,
     missingResults: 0,
@@ -188,8 +226,7 @@ function readOrigin(file) {
   }
   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 (!isImportTool(details.tool)) return void 0;
   if (typeof details.source !== "string") return void 0;
   return { sessionId: str(header?.id) ?? "", origin: details };
 }
@@ -216,15 +253,19 @@ function findImports(store) {
   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 });
+    const read2 = readOrigin(file);
+    if (read2) found.push({ sessionFile: file, sessionId: read2.sessionId, origin: read2.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)
-  );
+  let latest;
+  for (const found of imports) {
+    if (found.origin.tool !== tool) continue;
+    if (!(sourceId !== "" && found.origin.sourceId === sourceId || found.origin.source === source)) continue;
+    if (!latest || String(found.origin.importedAt) > String(latest.origin.importedAt)) latest = found;
+  }
+  return latest;
 }
 function firstLine(text, max = 80) {
   const line = text.split(/\r?\n/).map((part) => part.replace(/\s+/g, " ").trim()).find((part) => part.length > 0) ?? "";
@@ -312,13 +353,13 @@ function toolArguments(raw) {
 }
 function unknownBlockText(block) {
   const { type, ...rest } = block;
-  let json;
+  let json2;
   try {
-    json = JSON.stringify(rest);
+    json2 = JSON.stringify(rest);
   } catch {
-    json = "";
+    json2 = "";
   }
-  return `[${typeof type === "string" ? type : "block"}] ${clip(json, 2e3).text}`.trim();
+  return `[${typeof type === "string" ? type : "block"}] ${clip(json2, 2e3).text}`.trim();
 }
 var ZERO_USAGE = {
   input: 0,
@@ -329,6 +370,29 @@ var ZERO_USAGE = {
   cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
 };
 var IMAGE = { type: "image", data: "", mimeType: "image/png" };
+function imageOf(mimeType, data) {
+  if (typeof mimeType !== "string" || typeof data !== "string" || data.length === 0) return IMAGE;
+  const type = mimeType.toLowerCase() === "image/jpg" ? "image/jpeg" : mimeType.toLowerCase();
+  return IMAGE_TYPES.has(type) ? { type: "image", data, mimeType: type } : IMAGE;
+}
+function imageFromUrl(url) {
+  if (typeof url !== "string") return IMAGE;
+  const head = /^data:([^;,]+);base64,/i.exec(url.slice(0, 200));
+  return head ? imageOf(head[1], url.slice(head[0].length)) : IMAGE;
+}
+function stableId(seed, taken) {
+  const hash = createHash("sha256").update(seed).digest("hex");
+  for (let start = 0; start + 8 <= hash.length; start += 8) {
+    const id2 = hash.slice(start, start + 8);
+    if (!taken.has(id2)) {
+      taken.add(id2);
+      return id2;
+    }
+  }
+  const id = randomUUID();
+  taken.add(id);
+  return id;
+}
 var SessionBuilder = class {
   tool;
   counts = emptyCounts();
@@ -343,23 +407,25 @@ var SessionBuilder = class {
   constructor(tool) {
     this.tool = tool;
   }
-  drop(reason, count = 1) {
-    if (count <= 0) return;
-    this.counts.dropped[reason] = (this.counts.dropped[reason] ?? 0) + count;
+  drop(reason, count2 = 1) {
+    if (count2 <= 0) return;
+    this.counts.dropped[reason] = (this.counts.dropped[reason] ?? 0) + count2;
   }
   /** 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) {
+  /** Text and images as they were; an image without its data, or larger than any model takes, says so instead. */
+  blocksOf(content) {
     if (typeof content === "string") return [{ type: "text", text: content }];
     const blocks = [];
     for (const block of content) {
-      if (block.type === "image") {
+      if (block.type === "text") blocks.push({ type: "text", text: block.text });
+      else if (block.data.length > 0 && block.data.length <= MAX_IMAGE_CHARS) blocks.push(block);
+      else {
         this.drop("images");
         blocks.push({ type: "text", text: IMAGE_MARKER });
-      } else blocks.push({ type: "text", text: block.text });
+      }
     }
     return blocks;
   }
@@ -400,7 +466,7 @@ var SessionBuilder = class {
     this.held = [];
   }
   user(content, at, key) {
-    const blocks = this.withoutImages(content).filter((block) => block.text.length > 0);
+    const blocks = this.blocksOf(content).filter((block) => block.type === "image" || block.text.length > 0);
     if (blocks.length === 0) return;
     this.counts.user++;
     this.push({
@@ -418,7 +484,15 @@ var SessionBuilder = class {
   }
   assistant(input) {
     this.settle();
-    const blocks = input.blocks.filter((block) => block.type === "toolCall" || block.text.length > 0);
+    const unread = input.blocks.filter((block) => block.type === "thinking" && !block.thinking.trim()).length;
+    this.drop("unreadable thinking", unread);
+    let blocks = input.blocks.filter(
+      (block) => block.type === "toolCall" ? true : block.type === "text" ? block.text.length > 0 : block.thinking.trim().length > 0
+    );
+    if (blocks.every((block) => block.type === "thinking")) {
+      this.drop("thinking without an answer", blocks.length);
+      blocks = [];
+    }
     if (blocks.length === 0 && !input.error) return;
     const calls = blocks.filter((block) => block.type === "toolCall");
     const message = {
@@ -435,6 +509,7 @@ var SessionBuilder = class {
     this.counts.assistant++;
     this.items.push({ kind: "message", message, at: input.at, key: input.key });
     if (input.error) return;
+    this.counts.thinking += blocks.filter((block) => block.type === "thinking").length;
     for (const call of calls) {
       this.counts.toolCalls++;
       this.calls.set(call.id, call.name);
@@ -443,18 +518,25 @@ var SessionBuilder = class {
   }
   toolResult(input) {
     const name = input.name || this.calls.get(input.id) || "unknown";
-    const blocks = this.withoutImages(input.content);
+    const blocks = this.blocksOf(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");
+      const text = blocks.map((block) => {
+        if (block.type === "text") return block.text;
+        this.drop("images");
+        return IMAGE_MARKER;
+      });
       this.context(`[Result of an earlier ${name} call]
-${blocks.map((block) => block.text).join("\n")}`, input.at);
+${text.join("\n")}`, input.at);
       return;
     }
-    const content = blocks.map((block) => ({ type: "text", text: this.clipped(block.text) }));
+    const content = blocks.map(
+      (block) => block.type === "text" ? { type: "text", text: this.clipped(block.text) } : block
+    );
     this.pending.delete(input.id);
     this.answered.add(input.id);
     this.counts.toolResults++;
@@ -487,25 +569,54 @@ ${blocks.map((block) => block.text).join("\n")}`, input.at);
     this.counts.compactions++;
     this.items.push({ kind: "compaction", summary, tokensBefore, at, keepFrom });
   }
+  /**
+   * Images take MAX_IMAGES_CHARS at most, the latest first: they are what the conversation goes on from. An earlier
+   * one past that becomes IMAGE_MARKER.
+   */
+  budgetImages() {
+    let left = MAX_IMAGES_CHARS;
+    for (let index = this.items.length - 1; index >= 0; index--) {
+      const item = this.items[index];
+      if (item.kind !== "message") continue;
+      const message = item.message;
+      if (message.role !== "user" && message.role !== "toolResult") continue;
+      if (typeof message.content === "string") continue;
+      const content = message.content;
+      if (!content.some((block) => block.type === "image")) continue;
+      const kept = [];
+      for (let at = content.length - 1; at >= 0; at--) {
+        const block = content[at];
+        if (block.type !== "image") kept.unshift(block);
+        else if (block.data.length <= left) {
+          left -= block.data.length;
+          this.counts.images++;
+          kept.unshift(block);
+        } else {
+          this.drop("images");
+          kept.unshift({ type: "text", text: IMAGE_MARKER });
+        }
+      }
+      message.content = kept;
+    }
+  }
   /** The session file's lines: header, marker, name, then the conversation as one chain. */
   finish(input) {
     this.settle();
+    this.budgetImages();
     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 seen = /* @__PURE__ */ new Map();
+    const newId = (key) => {
+      const times = seen.get(key) ?? 0;
+      seen.set(key, times + 1);
+      return stableId(`${input.sessionId}
+${key}
+${times}`, taken);
     };
     const startedAt = Date.parse(input.started);
-    const iso = (at) => new Date(at > 0 ? at : startedAt).toISOString();
-    const ids = this.items.map(() => newId());
+    const iso2 = (at) => new Date(at > 0 ? at : startedAt).toISOString();
+    const ids = this.items.map(
+      (item, index) => newId(item.kind === "compaction" ? `compaction ${index}` : item.key ?? `item ${index}`)
+    );
     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);
@@ -514,7 +625,8 @@ ${blocks.map((block) => block.text).join("\n")}`, input.at);
     this.items.forEach((item, index) => {
       if (item.kind === "compaction") lastCompaction = index;
     });
-    this.counts.entries = this.items.length + 2 + (lastCompaction >= 0 ? 1 : 0);
+    this.counts.entries = this.items.length + 2 + (lastCompaction >= 0 ? 1 : 0) + (input.model ? 1 : 0);
+    const digest = createHash("sha256").update(JSON.stringify(this.items)).digest("hex").slice(0, 32);
     const header = {
       type: "session",
       version: SESSION_VERSION,
@@ -524,17 +636,17 @@ ${blocks.map((block) => block.text).join("\n")}`, input.at);
     };
     const marker = {
       type: "custom_message",
-      id: newId(),
+      id: newId("marker"),
       parentId: null,
       timestamp: input.started,
       customType: IMPORT_MARKER,
       content: input.note,
       display: true,
-      details: { ...input.origin, counts: this.counts }
+      details: { ...input.origin, digest, counts: this.counts }
     };
     const info = {
       type: "session_info",
-      id: newId(),
+      id: newId("name"),
       parentId: marker.id,
       timestamp: input.started,
       name: input.name.replace(/[\r\n]+/g, " ").trim()
@@ -543,7 +655,7 @@ ${blocks.map((block) => block.text).join("\n")}`, input.at);
     let parentId = info.id;
     this.items.forEach((item, index) => {
       const id = ids[index];
-      const timestamp = iso(item.at);
+      const timestamp = iso2(item.at);
       if (item.kind === "message") {
         entries.push({ type: "message", id, parentId, timestamp, message: item.message });
       } else if (item.kind === "context") {
@@ -559,7 +671,7 @@ ${blocks.map((block) => block.text).join("\n")}`, input.at);
         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 firstKeptEntryId = kept !== void 0 && kept < index ? ids[kept] : index + 1 < ids.length ? ids[index + 1] : newId("after the last compaction");
         const compaction = {
           type: "compaction",
           id,
@@ -573,25 +685,48 @@ ${blocks.map((block) => block.text).join("\n")}`, input.at);
       }
       parentId = id;
       if (index === lastCompaction) {
-        const again = { ...marker, id: newId(), parentId, timestamp };
+        const again = {
+          ...marker,
+          id: newId("marker again"),
+          parentId,
+          timestamp
+        };
         entries.push(again);
         parentId = again.id;
       }
     });
+    if (input.model) {
+      const change = {
+        type: "model_change",
+        id: newId("model"),
+        parentId,
+        timestamp: input.origin.importedAt,
+        provider: input.model.provider,
+        modelId: input.model.modelId
+      };
+      entries.push(change);
+    }
     return [header, ...entries];
   }
 };
+function fileStamp(path) {
+  try {
+    const stats = statSync(path);
+    return `${stats.size}:${Math.floor(stats.mtimeMs)}`;
+  } catch {
+    return void 0;
+  }
+}
 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."
+    `Its tool calls use ${name}'s tool names, which may differ from the tools available now.`
   ].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 sessionId = input.options.sessionId ?? uuidv7(Date.parse(started));
   const name = input.name?.trim() || `${TOOL_NAMES[builder.tool]} conversation`;
   const entries = builder.finish({
     sessionId,
@@ -599,13 +734,15 @@ function complete(builder, input) {
     started,
     name,
     note: importNote(builder.tool, input.source),
+    ...input.options.model ? { model: input.options.model } : {},
     origin: {
       version: 1,
       tool: builder.tool,
       source: input.source,
       sourceId: input.sourceId,
-      importedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
-      ...input.model ? { model: input.model } : {}
+      importedAt: (input.options.now ?? /* @__PURE__ */ new Date()).toISOString(),
+      ...input.model ? { model: input.model } : {},
+      ...input.stamp ? { stamp: input.stamp } : {}
     }
   });
   return {
@@ -631,24 +768,33 @@ function writeSessionFile(file, entries) {
     closeSync2(fd);
   }
 }
+function replaceSessionFile(file, entries) {
+  const temp = `${file}.${randomBytes(4).toString("hex")}.tmp`;
+  try {
+    writeSessionFile(temp, entries);
+    renameSync(temp, file);
+  } catch (error) {
+    rmSync(temp, { force: true });
+    throw error;
+  }
+}
 
 // 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 imageBlock(block) {
+  const source = record(block.source);
+  return source?.type === "base64" ? imageOf(source.media_type, source.data) : imageOf(void 0, void 0);
+}
+var TITLES = {
+  "custom-title": "customTitle",
+  "ai-title": "aiTitle",
+  summary: "summary"
+};
 function blocksOf(message) {
   const content = message?.content;
   if (typeof content === "string") return [{ type: "text", text: content }];
@@ -663,7 +809,7 @@ function resultContent(content, counts) {
   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 === "image") blocks.push(imageBlock(block));
     else if (block.type === "tool_reference")
       blocks.push({ type: "text", text: `[tool reference: ${str(block.tool_name) ?? "unknown"}]` });
     else {
@@ -710,6 +856,8 @@ async function readClaudeCode(path, options = {}) {
   const records = [];
   const byUuid = /* @__PURE__ */ new Map();
   let sessionId;
+  const titles = /* @__PURE__ */ new Map();
+  const stamp = fileStamp(source);
   for await (const line of readJsonLines(source)) {
     counts.records++;
     if (!("value" in line)) {
@@ -719,13 +867,15 @@ async function readClaudeCode(path, options = {}) {
     const data = record(line.value);
     const type = str(data?.type);
     if (!data || !type) {
-      builder.drop("records not understood");
+      builder.drop("unrecognized records");
       continue;
     }
     sessionId ??= str(data.sessionId);
+    const title = Object.hasOwn(TITLES, type) ? str(data[TITLES[type]])?.trim() : void 0;
+    if (title) titles.set(type, title);
     const uuid = str(data.uuid);
     if (!TREE_TYPES.has(type) || !uuid) {
-      builder.drop(uuid ? "records not understood" : "Claude Code bookkeeping (titles, queue, file history)");
+      builder.drop(uuid ? "unrecognized records" : "Claude Code bookkeeping (titles, queue, file history)");
       continue;
     }
     if (byUuid.has(uuid)) {
@@ -764,6 +914,10 @@ async function readClaudeCode(path, options = {}) {
     chosen.add(current2.uuid);
     const next = current2.parent ?? current2.logicalParent;
     let found = next ? byUuid.get(next) : void 0;
+    if (!current2.parent && found) {
+      const before = (position.get(found.uuid) ?? 0) < (position.get(current2.uuid) ?? 0);
+      if (!before || chosen.has(found.uuid)) found = messageBefore(current2);
+    }
     if (next && !found) {
       if (!current2.parent) found = messageBefore(current2);
       if (!found) builder.drop("links to records that are not in the file");
@@ -802,7 +956,7 @@ async function readClaudeCode(path, options = {}) {
     if (inScope(item)) offBranch++;
     else subAgent++;
   }
-  builder.drop("sub-agent records", subAgent);
+  builder.drop("subagent 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);
@@ -865,7 +1019,8 @@ async function readClaudeCode(path, options = {}) {
       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 === "thinking") blocks.push({ type: "thinking", thinking: str(block.thinking) ?? "" });
+        else if (block.type === "redacted_thinking") builder.drop("redacted thinking");
         else if (block.type === "tool_use") {
           const callId = str(block.id) ?? part.uuid;
           if (callIds.has(callId)) {
@@ -918,7 +1073,7 @@ async function readClaudeCode(path, options = {}) {
       }
       if (block.type === "image") {
         if (meta) builder.drop("images");
-        else words.push(IMAGE);
+        else words.push(imageBlock(block));
         continue;
       }
       if (block.type !== "text") {
@@ -980,7 +1135,7 @@ async function readClaudeCode(path, options = {}) {
     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
+        (block) => block.type === "text" ? { type: "text", text: str(block.text) ?? "" } : imageBlock(block)
       );
       const typed = attachment.commandMode === "prompt" && attachment.isMeta !== true;
       if (typed) {
@@ -1027,9 +1182,10 @@ async function readClaudeCode(path, options = {}) {
     sourceId: agentId ? `agent-${agentId}` : sessionId ?? basename(source, ".jsonl"),
     cwd: cwd ?? options.cwd ?? process.cwd(),
     started: startedIso,
-    name: name ?? firstCommand,
+    name: titles.get("custom-title") ?? titles.get("ai-title") ?? titles.get("summary") ?? name ?? firstCommand,
     model,
-    now: options.now
+    stamp,
+    options
   });
 }
 
@@ -1070,7 +1226,7 @@ function outputOf(output, counts) {
     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 if (block.type === "input_image") blocks.push(imageFromUrl(block.image_url));
     else {
       counts.asText++;
       blocks.push({ type: "text", text: unknownBlockText(block) });
@@ -1090,6 +1246,7 @@ ${messages}`);
 }
 async function readCodex(path, options = {}) {
   const source = absolute(path);
+  const stamp = fileStamp(source);
   const builder = new SessionBuilder("codex");
   const { counts } = builder;
   let sourceId = "";
@@ -1122,7 +1279,7 @@ async function readCodex(path, options = {}) {
     };
     for (const block of blocks) {
       if (block.type === "input_image") {
-        words.push(IMAGE);
+        words.push(imageFromUrl(block.image_url));
         continue;
       }
       if (block.type !== "input_text" && block.type !== "text") {
@@ -1181,9 +1338,14 @@ async function readCodex(path, options = {}) {
         else builder.drop("Codex instructions");
         return;
       }
-      case "reasoning":
-        builder.drop("thinking");
+      case "reasoning": {
+        const read2 = (blocks) => list(blocks).map((block) => str(record(block)?.text)?.trim()).filter((text2) => Boolean(text2));
+        const content = read2(payload.content);
+        const text = content.length > 0 ? content : read2(payload.summary);
+        if (text.length === 0) builder.drop("unreadable thinking");
+        else answer().blocks.push({ type: "thinking", thinking: text.join("\n\n") });
         return;
+      }
       case "function_call":
       case "tool_search_call":
         answer().blocks.push({
@@ -1244,7 +1406,7 @@ ${text}`, at);
         return;
       }
       default:
-        builder.drop("records not understood");
+        builder.drop("unrecognized records");
     }
   };
   const compacted = (payload) => {
@@ -1270,7 +1432,7 @@ ${text}`, at);
     }
     const data = record(line.value);
     if (!data) {
-      builder.drop("records not understood");
+      builder.drop("unrecognized records");
       continue;
     }
     const payload = record(data.payload);
@@ -1296,7 +1458,7 @@ ${text}`, at);
           if (typeof input === "number") tokens = input;
         }
         builder.drop("Codex events and state");
-      } else builder.drop("records not understood");
+      } else builder.drop("unrecognized records");
       continue;
     }
     if (data.record_type === "state") {
@@ -1308,15 +1470,15 @@ ${text}`, at);
       continue;
     }
     const id = str(data.id);
-    const stamp = str(data.timestamp);
-    if (id && stamp) {
+    const stamp2 = str(data.timestamp);
+    if (id && stamp2) {
       if (!sourceId) sourceId = id;
-      started ??= stamp;
-      const time = Date.parse(stamp);
+      started ??= stamp2;
+      const time = Date.parse(stamp2);
       if (!Number.isNaN(time)) at = time;
       continue;
     }
-    builder.drop("records not understood");
+    builder.drop("unrecognized records");
   }
   flush();
   let startedIso = started && !Number.isNaN(Date.parse(started)) ? new Date(Date.parse(started)).toISOString() : void 0;
@@ -1335,7 +1497,365 @@ ${text}`, at);
     started: startedIso,
     name: name ?? firstCommand,
     model: lastModel ?? model,
-    now: options.now
+    stamp,
+    options
+  });
+}
+
+// packages/kyrn-judge/src/import/zcode.ts
+import { execFileSync } from "node:child_process";
+import { statSync as statSync4 } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+function zcodeDatabase(home = homedir2()) {
+  return join2(home, ".zcode", "cli", "db", "db.sqlite");
+}
+function zcodeSource(database, id) {
+  return `${database}#${id}`;
+}
+function parseZcodeSource(source) {
+  const match = /^(.+\.(?:sqlite3?|db))#([\w.:-]+)$/.exec(source);
+  return match ? { database: absolute(match[1]), id: match[2] } : void 0;
+}
+var load = createRequire(new URL("src/import/zcode.ts", new URL("../", import.meta.url)).href);
+var nodeSqlite;
+function sqliteModule() {
+  if (nodeSqlite === void 0) {
+    const emit = process.emitWarning;
+    process.emitWarning = ((warning, ...rest) => {
+      if (/sqlite/i.test(typeof warning === "string" ? warning : warning.message)) return;
+      emit.call(process, warning, ...rest);
+    });
+    try {
+      nodeSqlite = load("node:sqlite");
+    } catch {
+      nodeSqlite = null;
+    } finally {
+      process.emitWarning = emit;
+    }
+  }
+  return nodeSqlite ?? void 0;
+}
+var quote = (value) => `'${value.replaceAll("'", "''")}'`;
+function openZcode(database) {
+  statSync4(database);
+  const sqlite = sqliteModule();
+  if (sqlite) {
+    const db = new sqlite.DatabaseSync(database, { readOnly: true, timeout: 2e3 });
+    return {
+      all: (sql, ...params) => db.prepare(sql).all(...params),
+      close: () => db.close()
+    };
+  }
+  return {
+    all: (sql, ...params) => {
+      const bound = sql.replace(/\?/g, () => quote(params.shift() ?? ""));
+      const out = execFileSync("sqlite3", ["-readonly", "-json", database, bound], {
+        encoding: "utf8",
+        maxBuffer: 2 * 1024 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      return out.trim() ? JSON.parse(out) : [];
+    },
+    close: () => {
+    }
+  };
+}
+function columns(db, table) {
+  return new Set(db.all(`PRAGMA table_info(${table})`).map((row) => String(row.name)));
+}
+var json = (value) => {
+  if (typeof value !== "string") return {};
+  try {
+    return record(JSON.parse(value)) ?? {};
+  } catch {
+    return {};
+  }
+};
+var num = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var SESSION_COLUMNS = [
+  "id",
+  "parent_id",
+  "task_type",
+  "directory",
+  "title",
+  "title_source",
+  "revert",
+  "time_created",
+  "time_updated",
+  "time_archived"
+];
+function sessionsSql(db, where = "") {
+  const have = columns(db, "session");
+  const pick = SESSION_COLUMNS.map((name) => have.has(name) ? name : `NULL AS ${name}`).join(", ");
+  return `SELECT ${pick} FROM session${where}`;
+}
+var order = (db, table, tail, prefix = "") => columns(db, table).has("sequence") ? `${prefix}sequence IS NULL, ${prefix}sequence, ${prefix}time_created, ${tail}` : `${prefix}time_created, ${tail}`;
+var SIDE_THREADS = /* @__PURE__ */ new Set(["subagent_child", "selection_side_chat"]);
+var iso = (ms) => ms && ms > 0 ? new Date(ms).toISOString() : void 0;
+var titleOf = (session) => session.title_source === "default" || session.title_source === "first_input" ? "" : firstLine(str(session.title) ?? "");
+function firstPrompt(db, id) {
+  const rows = db.all(
+    `SELECT p.data AS data FROM message m JOIN part p ON p.message_id = m.id
+		 WHERE m.session_id = ? AND json_extract(m.data, '$.role') = 'user'
+		   AND coalesce(json_extract(m.data, '$.semantics.kind'), 'user_prompt') = 'user_prompt'
+		   AND json_extract(p.data, '$.type') = 'text'
+		 ORDER BY ${order(db, "message", "m.rowid", "m.")} LIMIT 1`,
+    id
+  );
+  return firstLine(str(json(rows[0]?.data).text) ?? "");
+}
+function listZcode(database, options = {}) {
+  let db;
+  try {
+    db = openZcode(database);
+  } catch {
+    return [];
+  }
+  try {
+    const sessions = db.all(sessionsSql(db));
+    const sizes = /* @__PURE__ */ new Map();
+    for (const table of ["message", "part"]) {
+      for (const row of db.all(
+        `SELECT session_id AS id, COUNT(*) AS rows, COALESCE(SUM(LENGTH(data)), 0) AS bytes FROM ${table} GROUP BY session_id`
+      )) {
+        const id = String(row.id);
+        const size = sizes.get(id) ?? { messages: 0, bytes: 0 };
+        if (table === "message") size.messages = num(row.rows) ?? 0;
+        size.bytes += num(row.bytes) ?? 0;
+        sizes.set(id, size);
+      }
+    }
+    const found = [];
+    for (const session of sessions) {
+      const id = str(session.id);
+      if (!id || session.time_archived !== null) continue;
+      const subAgent = SIDE_THREADS.has(str(session.task_type) ?? "");
+      if (subAgent && !options.subAgents) continue;
+      const size = sizes.get(id) ?? { messages: 0, bytes: 0 };
+      if (size.messages === 0) continue;
+      const updated = num(session.time_updated);
+      found.push({
+        id,
+        source: zcodeSource(database, id),
+        ...str(session.directory) ? { cwd: str(session.directory) } : {},
+        title: titleOf(session) || firstPrompt(db, id),
+        ...iso(num(session.time_created)) ? { started: iso(num(session.time_created)) } : {},
+        modified: iso(updated) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+        size: size.bytes,
+        subAgent,
+        stamp: `${updated ?? 0}:${size.messages}:${size.bytes}`
+      });
+    }
+    return found;
+  } catch {
+    return [];
+  } finally {
+    db.close();
+  }
+}
+function afterRewind(messages, revert) {
+  const target = str(revert.targetMessageID);
+  if (!target) return messages;
+  const index = (id) => typeof id === "string" ? messages.findIndex((message) => message.id === id) : -1;
+  const keptIds = list(revert.keptMessageIDs).filter((id) => typeof id === "string");
+  const kept = Array.isArray(revert.keptMessageIDs) ? messages.filter((message) => keptIds.includes(message.id)) : messages.slice(0, Math.max(0, index(target)));
+  const cut = index(revert.branchCutAfterMessageID);
+  if (cut >= 0) return [...kept, ...messages.slice(cut + 1)];
+  const created = index(revert.createdMessageID);
+  if (created >= 0) return [...kept, ...messages.slice(created)];
+  return Array.isArray(revert.keptMessageIDs) || index(target) >= 0 ? kept : messages;
+}
+var textOf = (parts) => parts.filter((part) => part.type === "text").map((part) => str(part.text) ?? "").join("\n").trim();
+var startOf = (part, fallback) => num(record(part.time)?.start) ?? num(record(record(part.state)?.time)?.start) ?? fallback;
+function toolOutput(state) {
+  const isError = state.status === "error";
+  const value = isError ? state.error : state.output;
+  const text = typeof value === "string" ? value : value === void 0 || value === null ? "" : JSON.stringify(value);
+  const content = [{ type: "text", text }];
+  for (const attachment of list(state.attachments).map(record)) {
+    if (attachment && String(attachment.mime ?? "").startsWith("image/")) content.push(imageFromUrl(attachment.url));
+  }
+  return { content, isError };
+}
+async function readZcode(sourcePath, options = {}) {
+  const where = parseZcodeSource(sourcePath);
+  if (!where) throw new Error("not a ZCode conversation");
+  const source = zcodeSource(where.database, where.id);
+  const db = openZcode(where.database);
+  let session;
+  let messages;
+  let stamp;
+  try {
+    session = db.all(sessionsSql(db, " WHERE id = ?"), where.id)[0];
+    if (!session) throw new Error("no such ZCode conversation");
+    const parts = /* @__PURE__ */ new Map();
+    const partRows = db.all(
+      `SELECT message_id, time_created, data FROM part WHERE session_id = ? ORDER BY ${order(db, "part", "id")}`,
+      where.id
+    );
+    const starts = /* @__PURE__ */ new Map();
+    let bytes = 0;
+    for (const row of partRows) {
+      const data = json(row.data);
+      bytes += String(row.data ?? "").length;
+      starts.set(data, startOf(data, num(row.time_created) ?? 0));
+      const id = String(row.message_id);
+      const own = parts.get(id) ?? [];
+      own.push(data);
+      parts.set(id, own);
+    }
+    const messageRows = db.all(
+      `SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY ${order(db, "message", "rowid")}`,
+      where.id
+    );
+    messages = messageRows.map((row) => {
+      const data = json(row.data);
+      bytes += String(row.data ?? "").length;
+      const id = String(row.id);
+      const own = parts.get(id) ?? [];
+      const sorted = own.map((part, index) => ({ part, index }));
+      sorted.sort((a, b) => (starts.get(a.part) ?? 0) - (starts.get(b.part) ?? 0) || a.index - b.index);
+      return {
+        id,
+        at: num(record(data.time)?.created) ?? num(row.time_created) ?? 0,
+        data,
+        parts: sorted.map((each) => each.part)
+      };
+    });
+    stamp = `${num(session.time_updated) ?? 0}:${messageRows.length}:${bytes}`;
+  } finally {
+    db.close();
+  }
+  const builder = new SessionBuilder("zcode");
+  const { counts } = builder;
+  counts.records = messages.length;
+  const active = afterRewind(messages, json(session.revert));
+  builder.drop("messages a rewind took back", messages.length - active.length);
+  let cwd = str(session.directory);
+  let model;
+  let name;
+  let firstCommand;
+  for (const message of active) {
+    const { data, parts, at } = message;
+    const semantics = record(data.semantics) ?? {};
+    const kind = str(semantics.kind);
+    const shown = semantics.uiVisibility !== "hidden";
+    const sent = semantics.providerVisibility !== "hidden";
+    if (kind === "timeline_event") {
+      builder.drop("ZCode timeline lines (model changes, compactions)");
+      continue;
+    }
+    if (kind === "compact_summary") {
+      const boundary = record(parts.find((part) => part.type === "compaction")?.compactBoundary) ?? {};
+      const summary = str(record(data.summary)?.body)?.trim() || textOf(parts);
+      const segment = record(boundary.preservedSegment);
+      const head = active.findIndex((each) => each.id === segment?.headMessageId);
+      const tail = active.findIndex((each) => each.id === segment?.tailMessageId);
+      const keep = head >= 0 && tail >= head ? active.slice(head, tail + 1).map((each) => each.id) : [];
+      builder.compaction(summary, num(boundary.preCompactTokenCount) ?? 0, at, keep);
+      continue;
+    }
+    if (data.role === "user") {
+      if (!sent) {
+        builder.drop("ZCode notes for the app only");
+        continue;
+      }
+      if (!shown) {
+        builder.context(textOf(parts), at, message.id);
+        continue;
+      }
+      const words = [];
+      for (const part of parts) {
+        if (part.type === "text") {
+          const text = str(part.text) ?? "";
+          if (part.synthetic === true) {
+            builder.context(text, at, message.id);
+            continue;
+          }
+          const command = commandText(text);
+          if (command !== void 0) firstCommand ??= command;
+          else if (name === void 0 && text.trim()) name = firstLine(text);
+          words.push({ type: "text", text: command ?? text });
+        } else if (part.type === "file") {
+          const mime = String(part.mime ?? "");
+          const file = str(part.filename) ?? str(record(part.source)?.path) ?? str(part.url) ?? "a file";
+          if (mime.startsWith("image/")) {
+            words.push(imageFromUrl(part.url));
+            continue;
+          }
+          words.push({ type: "text", text: `[${file}]` });
+          const preview = str(record(record(part.metadata)?.preview)?.text);
+          if (preview) builder.context(`Contents of ${file}:
+${preview}`, at, message.id);
+        } else builder.drop("ZCode bookkeeping parts");
+      }
+      builder.user(words, at, message.id);
+      continue;
+    }
+    if (data.role !== "assistant") {
+      builder.drop("unrecognized records");
+      continue;
+    }
+    const used = str(data.modelId) ?? str(data.modelID) ?? "";
+    if (used) model = used;
+    cwd ??= str(record(data.path)?.cwd);
+    const blocks = [];
+    const tools = [];
+    for (const part of parts) {
+      if (part.type === "text") blocks.push({ type: "text", text: str(part.text) ?? "" });
+      else if (part.type === "reasoning") blocks.push({ type: "thinking", thinking: str(part.text) ?? "" });
+      else if (part.type === "tool") {
+        const id = str(part.callID);
+        if (!id) continue;
+        const state = record(part.state) ?? {};
+        blocks.push({
+          type: "toolCall",
+          id,
+          name: str(part.tool) ?? "unknown",
+          arguments: toolArguments(state.input)
+        });
+        tools.push(part);
+      } else if (!["step-start", "step-finish", "snapshot", "patch", "retry", "agent"].includes(String(part.type)))
+        builder.drop("ZCode bookkeeping parts");
+    }
+    const error = record(data.error);
+    const failed = error && !blocks.some((block) => block.type !== "thinking");
+    builder.assistant({
+      blocks: failed ? [] : blocks,
+      model: used,
+      at,
+      key: message.id,
+      ...failed ? {
+        error: str(record(error.data)?.message) ?? str(error.message) ?? str(error.name) ?? "The request failed."
+      } : {},
+      ...data.finish === "length" ? { stopReason: "length" } : {}
+    });
+    for (const part of tools) {
+      const state = record(part.state) ?? {};
+      if (state.status !== "completed" && state.status !== "error") continue;
+      const output = toolOutput(state);
+      builder.toolResult({
+        id: str(part.callID) ?? "",
+        name: str(part.tool),
+        content: output.content,
+        isError: output.isError,
+        at: num(record(state.time)?.end) ?? at,
+        key: message.id
+      });
+    }
+  }
+  const started = iso(num(session.time_created)) ?? iso(messages[0]?.at) ?? (/* @__PURE__ */ new Date()).toISOString();
+  return complete(builder, {
+    source,
+    sourceId: where.id,
+    cwd: cwd ?? options.cwd ?? process.cwd(),
+    started,
+    name: titleOf(session) || name || firstCommand,
+    model,
+    stamp,
+    options
   });
 }
 
@@ -1350,6 +1870,7 @@ var CODEX_ITEMS = /* @__PURE__ */ new Set([
   "reasoning"
 ]);
 function detectTool(path) {
+  if (parseZcodeSource(path)) return "zcode";
   let tool;
   let lines = 0;
   readHead(
@@ -1372,6 +1893,27 @@ function detectTool(path) {
   );
   return tool;
 }
+var CLAUDE_TITLES = [
+  ["custom-title", "customTitle"],
+  ["ai-title", "aiTitle"],
+  ["summary", "summary"]
+];
+function claudeTitle(path, head) {
+  let tail = [];
+  try {
+    tail = readTail(path);
+  } catch {
+  }
+  const found = /* @__PURE__ */ new Map();
+  for (const value of [...head, ...tail]) {
+    const data = record(value);
+    const type = str(data?.type);
+    const field = CLAUDE_TITLES.find(([name]) => name === type)?.[1];
+    const title = field ? str(data?.[field])?.trim() : void 0;
+    if (type && title) found.set(type, firstLine(title));
+  }
+  return CLAUDE_TITLES.map(([type]) => found.get(type)).find((title) => title !== void 0);
+}
 var TREE_TYPES2 = /* @__PURE__ */ new Set(["user", "assistant", "system", "attachment"]);
 function titleParts(text) {
   if (classifyUserText(text) !== "user") return {};
@@ -1388,16 +1930,14 @@ function describeClaudeCode(path) {
   let started;
   let title;
   let command;
-  let named;
   let first;
+  const titles = [];
   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 (CLAUDE_TITLES.some(([name]) => name === type)) titles.push(data);
     if (!type || !TREE_TYPES2.has(type)) return false;
     first ??= data.isSidechain === true;
     if (first) agentId ??= str(data.agentId);
@@ -1419,7 +1959,7 @@ function describeClaudeCode(path) {
   return {
     id: first && agentId ? `agent-${agentId}` : id ?? "",
     cwd,
-    title: title ?? named ?? command ?? "",
+    title: claudeTitle(path, titles) ?? title ?? command ?? "",
     started,
     subAgent: first === true
   };
@@ -1467,11 +2007,11 @@ function describeCodex(path) {
   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 claudeProjectsDir(env = process.env, home = homedir3()) {
+  return join3(env.CLAUDE_CONFIG_DIR ? absolute(env.CLAUDE_CONFIG_DIR) : join3(home, ".claude"), "projects");
 }
-function codexSessionsDir(env = process.env, home = homedir2()) {
-  return join2(env.CODEX_HOME ? absolute(env.CODEX_HOME) : join2(home, ".codex"), "sessions");
+function codexSessionsDir(env = process.env, home = homedir3()) {
+  return join3(env.CODEX_HOME ? absolute(env.CODEX_HOME) : join3(home, ".codex"), "sessions");
 }
 function sameFolder(a, b) {
   const canonical = (dir) => {
@@ -1493,17 +2033,43 @@ function jsonlFiles(dir, depth) {
   }
   const files = [];
   for (const name of names.sort()) {
-    const path = join2(dir, name);
+    const path = join3(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));
+        if (statSync5(path).isDirectory()) files.push(...jsonlFiles(path, depth - 1));
       } catch {
       }
     }
   }
   return files;
 }
+var checksFile = (store) => join3(absolute(store.agentDir), "import-checks.json");
+function readChecks(store) {
+  try {
+    const checks = record(JSON.parse(readFileSync(checksFile(store), "utf8"))) ?? {};
+    return Object.fromEntries(
+      Object.entries(checks).filter((entry) => typeof entry[1] === "string")
+    );
+  } catch {
+    return {};
+  }
+}
+function writeChecks(store, checks) {
+  const file = checksFile(store);
+  try {
+    mkdirSync(absolute(store.agentDir), { recursive: true });
+    writeFileSync(`${file}.tmp`, `${JSON.stringify(checks, null, 1)}
+`, { mode: 384 });
+    renameSync2(`${file}.tmp`, file);
+  } catch {
+  }
+}
+function changedSince(origin, stamp, modified, checked) {
+  if (stamp !== void 0 && stamp === checked) return false;
+  if (origin.stamp !== void 0) return stamp !== void 0 && stamp !== origin.stamp;
+  return modified > origin.importedAt;
+}
 function listConversations(options = {}) {
   const claudeProjects = options.claudeProjects ?? claudeProjectsDir();
   const codexSessions = options.codexSessions ?? codexSessionsDir();
@@ -1514,22 +2080,22 @@ function listConversations(options = {}) {
   } 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(join3(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 imports = options.store ? findImports(options.store) : [];
+  const checks = options.store ? readChecks(options.store) : {};
+  const earlier = (tool, id, path) => findImport(imports, tool, id, path);
+  const mark = (found, stamp, modified) => found ? {
+    importedAs: found.sessionFile,
+    ...changedSince(found.origin, stamp, modified, checks[found.origin.source]) ? { changed: true } : {}
+  } : {};
   const conversations = [];
   for (const { tool, path } of candidates) {
     let size;
     let modified;
     try {
-      const stats = statSync4(path);
+      const stats = statSync5(path);
       size = stats.size;
       modified = stats.mtime.toISOString();
     } catch {
@@ -1543,16 +2109,75 @@ function listConversations(options = {}) {
     }
     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 } : {} });
+    const found = earlier(tool, described.id, path);
+    conversations.push({ tool, path, ...described, modified, size, ...mark(found, fileStamp(path), modified) });
+  }
+  for (const zcode of listZcode(options.zcodeDatabase ?? zcodeDatabase(), { subAgents: options.subAgents })) {
+    if (options.cwd && !(zcode.cwd && sameFolder(zcode.cwd, options.cwd))) continue;
+    const { source, stamp, ...described } = zcode;
+    const found = earlier("zcode", zcode.id, source);
+    conversations.push({ tool: "zcode", path: source, ...described, ...mark(found, stamp, zcode.modified) });
   }
   return conversations.sort((a, b) => b.modified.localeCompare(a.modified));
 }
-async function importOne(path, options, imports) {
-  const source = absolute(path);
+var NOT_A_TRANSCRIPT = "not a Claude Code, Codex or ZCode transcript";
+function read(tool, source, options) {
+  if (tool === "zcode") return readZcode(source, options);
+  return tool === "codex" ? readCodex(source, options) : readClaudeCode(source, options);
+}
+function laterEntries(file, origin) {
+  const written = origin.counts?.entries;
+  if (!written) return void 0;
+  let lines;
+  try {
+    lines = readFileSync(file, "utf8").split("\n");
+  } catch {
+    return void 0;
+  }
+  const later = [];
+  for (const line of lines.slice(written + 1)) {
+    if (!line.trim()) continue;
+    try {
+      const entry = record(JSON.parse(line));
+      if (entry) later.push(entry);
+    } catch {
+    }
+  }
+  return later;
+}
+var SETTINGS_ENTRIES = /* @__PURE__ */ new Set([
+  "session_info",
+  "model_change",
+  "thinking_level_change",
+  "custom",
+  "label"
+]);
+function updatedEntries(earlier, converted) {
+  const later = laterEntries(earlier.sessionFile, earlier.origin);
+  if (!later || later.some((entry) => !SETTINGS_ENTRIES.has(String(entry.type)))) return void 0;
+  const entries = [...converted.entries];
+  const ids = new Set(later.map((entry) => entry.id));
+  let leaf = entries.at(-1).id ?? null;
+  for (const entry of later) {
+    const parentId = typeof entry.parentId === "string" && ids.has(entry.parentId) ? entry.parentId : leaf;
+    entries.push({ ...entry, parentId });
+    leaf = String(entry.id);
+  }
+  return entries;
+}
+function sameAs(earlier, converted) {
+  const digest = record(record(converted.entries[1])?.details)?.digest;
+  if (earlier.digest !== void 0) return earlier.digest === digest;
+  const before = earlier.counts;
+  const after = converted.counts;
+  return before?.user === after.user && before.assistant === after.assistant && before.toolCalls === after.toolCalls;
+}
+async function importOne(path, options, imports, checks) {
+  const zcode = parseZcodeSource(path);
+  const source = zcode ? zcodeSource(zcode.database, zcode.id) : absolute(path);
   const failed = (error) => ({ status: "failed", source, error });
   try {
-    if (!statSync4(source).isFile()) return failed("not a file");
+    if (!statSync5(zcode ? zcode.database : source).isFile()) return failed("not a file");
   } catch {
     return failed("no such file");
   }
@@ -1565,39 +2190,61 @@ async function importOne(path, options, imports) {
   });
   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 (!tool) return failed(NOT_A_TRANSCRIPT);
+    const quick = zcode ? zcode.id : (tool === "codex" ? describeCodex(source) : describeClaudeCode(source)).id;
+    let earlier = findImport(imports, tool, quick, source);
+    if (earlier?.origin.stamp !== void 0 && earlier.origin.stamp === (zcode ? void 0 : fileStamp(source)))
+      return already(tool, earlier);
+    const readOptions = (keep) => ({
+      cwd: options.cwd,
+      now: options.now,
+      ...options.model ? { model: options.model } : {},
+      ...keep ? { sessionId: keep.sessionId } : {}
+    });
+    let converted = await read(tool, source, readOptions(earlier));
+    if (!earlier) {
+      earlier = findImport(imports, tool, converted.sourceId, source);
+      if (earlier) converted = await read(tool, source, readOptions(earlier));
+    }
+    if (earlier && sameAs(earlier.origin, converted)) {
+      const stamp = record(record(converted.entries[1])?.details)?.stamp;
+      if (typeof stamp === "string") checks[source] = stamp;
+      return already(tool, earlier);
+    }
     if (!converted.hasConversation) return failed("no messages in this transcript");
+    const written = {
+      source,
+      tool,
+      sessionFile: "",
+      sessionId: converted.sessionId,
+      name: converted.name,
+      cwd: converted.cwd,
+      counts: converted.counts
+    };
+    const update = earlier ? updatedEntries(earlier, converted) : void 0;
+    const origin = record(converted.entries[1])?.details;
+    if (earlier && update) {
+      replaceSessionFile(earlier.sessionFile, update);
+      const before = earlier.origin.counts;
+      imports.splice(imports.indexOf(earlier), 1, { ...earlier, origin });
+      return { status: "updated", ...written, sessionFile: earlier.sessionFile, before };
+    }
+    if (earlier) converted = await read(tool, source, readOptions());
     const dir = sessionDirFor(converted.cwd, options);
     mkdirSync(dir, { recursive: true });
-    const sessionFile = join2(dir, sessionFileName(converted.started, converted.sessionId));
+    const sessionFile = join3(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
-      }
+      origin: record(converted.entries[1])?.details
     });
     return {
       status: "imported",
-      source,
-      tool,
-      sessionFile,
+      ...written,
       sessionId: converted.sessionId,
-      name: converted.name,
-      cwd: converted.cwd,
-      counts: converted.counts
+      sessionFile,
+      ...earlier ? { earlier: earlier.sessionFile } : {}
     };
   } catch (error) {
     return failed(error instanceof Error ? error.message : String(error));
@@ -1605,23 +2252,27 @@ async function importOne(path, options, imports) {
 }
 async function importTranscripts(paths, options) {
   const imports = findImports(options);
+  const checks = readChecks(options);
+  const before = JSON.stringify(checks);
   const results = [];
-  for (const path of paths) results.push(await importOne(path, options, imports));
+  for (const path of paths) results.push(await importOne(path, options, imports, checks));
+  if (JSON.stringify(checks) !== before) writeChecks(options, checks);
   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: import Claude Code, Codex and ZCode conversations so you can continue them in mu.",
   "",
-  "  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",
+  "  mu import --list [--json] [--cwd <dir>]   list conversations on this machine (with --cwd, only <dir>'s)",
+  "  mu import <file>... [--json]              import these conversations; 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",
+  "  --agent-dir <dir>   mu's agent folder (default: MU_AGENT_DIR, else ~/.mu/agent)",
+  "  --sub-agents        also list subagent threads",
   "",
-  "Looks in ~/.claude/projects (CLAUDE_CONFIG_DIR) and ~/.codex/sessions (CODEX_HOME).",
-  "A conversation that was imported before is not imported again."
+  "Looks in ~/.claude/projects (CLAUDE_CONFIG_DIR), ~/.codex/sessions (CODEX_HOME) and ~/.zcode/cli/db/db.sqlite.",
+  "A ZCode conversation is named <database>#<id>, as --list shows it.",
+  "Importing a conversation again brings over what's new; one that hasn't changed is skipped."
 ].join("\n");
 function parseArgs(argv) {
   const parsed = { help: false, list: false, json: false, subAgents: false, files: [] };
@@ -1647,24 +2298,33 @@ function parseArgs(argv) {
     } 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" };
+  if (parsed.list && parsed.files.length > 0) return { error: "--list doesn't take 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"),
+    agentDirArg ?? io.env.MU_CODING_AGENT_DIR ?? io.env.KYRN_CODING_AGENT_DIR ?? join4(io.home, ".mu", "agent"),
     io.cwd
   );
   const fromEnv = io.env.MU_CODING_AGENT_SESSION_DIR;
   if (fromEnv) return { agentDir, sessionDir: absolute(fromEnv, io.cwd) };
+  const sessionDir = settingsOf(agentDir).sessionDir;
+  if (typeof sessionDir === "string" && sessionDir.trim())
+    return { agentDir, sessionDir: absolute(sessionDir, io.cwd) };
+  return { agentDir };
+}
+function settingsOf(agentDir) {
   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) };
+    return record(JSON.parse(readFileSync2(join4(agentDir, "settings.json"), "utf8"))) ?? {};
   } catch {
+    return {};
   }
-  return { agentDir };
+}
+function defaultModelOf(agentDir) {
+  const settings = settingsOf(agentDir);
+  const provider = settings.defaultProvider;
+  const modelId = settings.defaultModel;
+  return typeof provider === "string" && provider && typeof modelId === "string" && modelId ? { provider, modelId } : void 0;
 }
 function formatSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -1677,8 +2337,8 @@ function formatSize(bytes) {
   }
   return `${value < 10 ? value.toFixed(1) : Math.round(value)} ${units[unit]}`;
 }
-function formatDate(iso) {
-  const date = iso ? new Date(iso) : void 0;
+function formatDate(iso2) {
+  const date = iso2 ? new Date(iso2) : 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())}`;
@@ -1687,7 +2347,7 @@ 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.";
+  if (conversations.length === 0) return "No Claude Code, Codex or ZCode conversations found.";
   const groups = /* @__PURE__ */ new Map();
   for (const conversation of conversations) {
     const key = conversation.cwd ?? "";
@@ -1699,35 +2359,52 @@ function formatList(conversations, home) {
   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)");
+    lines.push(cwd ? tilde(cwd, home) : "(unknown folder)");
     for (const conversation of group) {
       const title = conversation.title || "(no message found)";
-      const mark = conversation.importedAs ? "  (imported)" : "";
+      const mark = !conversation.importedAs ? "" : conversation.changed ? "  (imported, changed since)" : "  (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>`);
+  const count2 = conversations.length;
+  lines.push("", `${count2} conversation${count2 === 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 === "failed") return `Couldn't 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)}`
+      `Already imported and unchanged: ${tilde(result.source, home)}`,
+      `  as 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 [
+  const skipped = Object.entries(counts.dropped).sort((a, b) => b[1] - a[1]);
+  const width = Math.max(0, ...skipped.map(([, count2]) => String(count2).length));
+  const left = skipped.map(([reason, count2]) => `    ${String(count2).padStart(width)}  ${reason}`);
+  const kept = [
+    ...counts.thinking > 0 ? [count(counts.thinking, "thinking block")] : [],
+    ...counts.images > 0 ? [count(counts.images, "image")] : [],
+    ...counts.compactions > 0 ? [count(counts.compactions, "compaction")] : []
+  ];
+  const head = result.status === "updated" ? [
+    `Brought up to date from ${TOOL_NAMES[result.tool]}: "${result.name}"`,
+    `  ${tilde(result.sessionFile, home)}`,
+    `  new since the last import: ${count(Math.max(0, counts.user - (result.before?.user ?? 0)), "message")} from you, ${count(Math.max(0, counts.assistant - (result.before?.assistant ?? 0)), "reply", "replies")}`
+  ] : [
     `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}`
+    ...result.earlier ? [
+      `  the earlier import was continued in mu, so it was left untouched: ${tilde(result.earlier, home)}`
+    ] : []
+  ];
+  return [
+    ...head,
+    `  ${count(counts.user, "message")} from you, ${count(counts.assistant, "reply", "replies")}, ${count(counts.toolCalls, "tool call")}${kept.length > 0 ? `, ${kept.join(", ")}` : ""}`,
+    ...left.length > 0 ? ["  skipped:", ...left] : [],
+    `  to continue: mu --session ${result.sessionFile}`
   ].join("\n");
 }
 async function main(argv, io) {
@@ -1754,7 +2431,7 @@ ${USAGE}`);
   }
   const results = await importTranscripts(
     parsed.files.map((file) => absolute(file, io.cwd)),
-    { ...store, cwd: io.cwd }
+    { ...store, cwd: io.cwd, model: defaultModelOf(store.agentDir) }
   );
   io.out(
     parsed.json ? JSON.stringify({ results }, null, 2) : results.map((result) => formatResult(result, io.home)).join("\n\n")
@@ -1769,7 +2446,7 @@ function processIo() {
 `),
     env: process.env,
     cwd: process.cwd(),
-    home: homedir3()
+    home: homedir4()
   };
 }