@basou/cli 0.71.1 → 0.71.2

package/dist/index.js

@@ -1042,6 +1042,8 @@ import {
   CLAUDE_IMPORT_SOURCE,
   CODEX_IMPORT_SOURCE,
   classifyFilesBySourceRoot,
+  claudeTranscriptOwnRecords,
+  claudeTranscriptRecordUuid,
   claudeTranscriptToImportPayload,
   codexRolloutToImportPayload,
   displayPath as displayPath2,
@@ -1142,24 +1144,43 @@ async function doRunImportClaudeCode(options, ctx) {
   });
   const projectsRoot = ctx.claudeProjectsDir ?? join2(homedir(), ".claude", "projects");
   const files = await selectTranscriptFiles(projectsRoot, projectPaths, options);
+  const store = await loadImportStore(paths, options, CLAUDE_IMPORT_SOURCE);
+  const conversations = await indexConversations(
+    await listTranscriptFiles(projectsRoot, projectPaths),
+    ctx.transcriptCreatedAtMs ?? birthTimeMs,
+    (externalId) => earliestStart(store.byExternalId.get(externalId) ?? [])
+  );
   const projectSet = new Set(projectPaths);
   const candidates = files.map((file) => {
     const externalId = basename3(file, ".jsonl");
+    const { root, older } = conversations.place(file);
     return {
       externalId,
       sourcePath: file,
-      toPayload: async () => {
+      // An earlier import that took the copies too began the session at the
+      // conversation's first record or before it; one without them begins after
+      // the last copy.
+      holdsCopies: (prior) => older.length > 0 && root?.timestamp !== void 0 && Date.parse(prior.startedAt) <= Date.parse(root.timestamp),
+      toPayload: async (notBefore) => {
         const { records, sizeBytes } = await readJsonlRecords(file);
         const cwd = firstTranscriptCwd(records);
-        if (cwd === void 0 || !projectSet.has(cwd)) return null;
+        if (cwd === void 0 || !projectSet.has(cwd))
+          return { payload: null, leftOutCopies: false };
         const observation2 = await readSessionObservation(paths.observations, externalId);
         const observedFiles = observation2 === null ? [] : observedFilesOf(observation2);
-        return claudeTranscriptToImportPayload(records, {
-          workspaceId: manifest.workspace.id,
-          externalId,
-          sourceSizeBytes: sizeBytes,
-          ...observedFiles.length > 0 ? { observedFiles } : {}
+        const own = claudeTranscriptOwnRecords(records, {
+          copiedUuids: await conversations.uuidsOf(older),
+          ...notBefore !== void 0 ? { notBefore } : {}
         });
+        return {
+          payload: claudeTranscriptToImportPayload(own, {
+            workspaceId: manifest.workspace.id,
+            externalId,
+            sourceSizeBytes: sizeBytes,
+            ...observedFiles.length > 0 ? { observedFiles } : {}
+          }),
+          leftOutCopies: own.length < records.length
+        };
       }
     };
   });
@@ -1167,7 +1188,7 @@ async function doRunImportClaudeCode(options, ctx) {
     paths,
     manifest,
     options,
-    CLAUDE_IMPORT_SOURCE,
+    store,
     candidates,
     projectPaths,
     hasDeclaredBoundary(options, manifest)
@@ -1189,18 +1210,21 @@ async function doRunImportCodex(options, ctx) {
     sourcePath: file,
     toPayload: async () => {
       const { records, sizeBytes } = await readJsonlRecords(file);
-      return codexRolloutToImportPayload(records, {
-        workspaceId: manifest.workspace.id,
-        externalId,
-        sourceSizeBytes: sizeBytes
-      });
+      return {
+        payload: codexRolloutToImportPayload(records, {
+          workspaceId: manifest.workspace.id,
+          externalId,
+          sourceSizeBytes: sizeBytes
+        }),
+        leftOutCopies: false
+      };
     }
   }));
   await importDerivedSessions(
     paths,
     manifest,
     options,
-    CODEX_IMPORT_SOURCE,
+    await loadImportStore(paths, options, CODEX_IMPORT_SOURCE),
     candidates,
     projectPaths,
     hasDeclaredBoundary(options, manifest)
@@ -1225,14 +1249,8 @@ async function resolveImportTarget(ctx) {
   const manifest = await readManifest2(paths);
   return { repositoryRoot, paths, manifest };
 }
-async function importDerivedSessions(paths, manifest, options, sourceKind, candidates, projectPaths, boundaryDeclared) {
-  await assertSessionStoreSafe(paths);
-  if (options.dryRun !== true) await assertLockStoreSafe2(paths);
-  const {
-    byExternalId: existingByExternalId,
-    notDirectories,
-    yamlNotFiles
-  } = await loadExistingByExternalId(paths, sourceKind);
+async function importDerivedSessions(paths, manifest, options, store, candidates, projectPaths, boundaryDeclared) {
+  const { byExternalId: existingByExternalId, notDirectories, yamlNotFiles } = store;
   let notDirectoriesWarned = false;
   const seenThisRun = /* @__PURE__ */ new Set();
   const crossProjectCheck = boundaryDeclared;
@@ -1260,7 +1278,8 @@ async function importDerivedSessions(paths, manifest, options, sourceKind, candi
     skippedLegacy: 0,
     skippedDecreased: 0,
     skippedDuplicate: 0,
-    skippedUnverifiable: 0
+    skippedUnverifiable: 0,
+    droppedCopies: 0
   };
   let sanitizedPaths = 0;
   const validate = (payload) => {
@@ -1276,30 +1295,44 @@ async function importDerivedSessions(paths, manifest, options, sourceKind, candi
     }
     return parsed.data;
   };
-  for (const { externalId, sourcePath, toPayload } of candidates) {
+  for (const { externalId, sourcePath, toPayload, holdsCopies } of candidates) {
     if (seenThisRun.has(externalId)) {
       counts.skippedExisting++;
       continue;
     }
     const priors = existingByExternalId.get(externalId) ?? [];
     if (priors.length > 0 && options.force !== true) {
-      const prior = await classifyReimport(priors, sourcePath, externalId, counts);
-      if (prior === null) continue;
-      const payload2 = validate(await toPayload());
+      const decision = await classifyReimport(priors, sourcePath, externalId, counts, holdsCopies);
+      if (decision === null) continue;
+      const { prior, reason } = decision;
+      const derived = await toPayload(prior.startedAt);
+      const payload2 = validate(derived.payload);
       if (payload2 === null) {
+        if (reason === "holds_copies") {
+          console.error(
+            `Import: ${externalId} added no action of its own after the records it copied from an older transcript; its session, imported with those records, is left as it is`
+          );
+        }
         counts.skippedNoAction++;
         continue;
       }
+      if (reason === "holds_copies" && !derived.leftOutCopies) {
+        counts.skippedExisting++;
+        continue;
+      }
       const readSize = payload2.session.source.source_size_bytes;
-      if (prior.sourceSizeBytes !== void 0 && readSize !== void 0 && readSize <= prior.sourceSizeBytes) {
+      if (prior.sourceSizeBytes !== void 0 && readSize !== void 0 && (reason === "grew" ? readSize <= prior.sourceSizeBytes : readSize < prior.sourceSizeBytes)) {
         console.error(
-          `Import: ${externalId} source changed during read (now ${readSize} <= ${prior.sourceSizeBytes} bytes); re-import skipped`
+          `Import: ${externalId} source changed during read (now ${readSize} bytes, was ${prior.sourceSizeBytes}); re-import skipped`
         );
         counts.skippedDecreased++;
         continue;
       }
       const outcome = await reimportPreservingId(paths, manifest, prior.sessionId, payload2, {
-        dryRun: options.dryRun === true
+        dryRun: options.dryRun === true,
+        // What an earlier import derived from the copies predates the session's
+        // fresh start; anything later that is not reproduced still refuses.
+        ...derived.leftOutCopies ? { dropDerivedBefore: payload2.session.started_at } : {}
       });
       if (outcome.status === "skipped") {
         const detail = outcome.reason === "prior_events_unreadable" ? "prior events.jsonl has unreadable lines" : outcome.reason === "prior_chain_broken" ? "prior events.jsonl failed hash-chain verification (run 'basou verify')" : outcome.reason === "prior_yaml_invalid" ? "prior session.yaml does not load as a whole document" : "source changed in a non-append way (derived events would be dropped)";
@@ -1308,11 +1341,12 @@ async function importDerivedSessions(paths, manifest, options, sourceKind, candi
         continue;
       }
       counts.reimported++;
+      if (holdsCopies?.(prior) === true) counts.droppedCopies++;
       seenThisRun.add(externalId);
       await noteCrossProject(externalId, payload2);
       continue;
     }
-    const payload = validate(await toPayload());
+    const payload = validate((await toPayload(earliestStart(priors))).payload);
     if (payload === null) {
       counts.skippedNoAction++;
       continue;
@@ -1363,7 +1397,7 @@ async function importDerivedSessions(paths, manifest, options, sourceKind, candi
   }
   printImportResult(options, results, counts);
 }
-async function classifyReimport(priors, sourcePath, externalId, counts) {
+async function classifyReimport(priors, sourcePath, externalId, counts, holdsCopies) {
   if (priors.length > 1) {
     console.error(
       `Import: ${externalId} has ${priors.length} prior sessions; re-import skipped (use --force)`
@@ -1386,6 +1420,7 @@ async function classifyReimport(priors, sourcePath, externalId, counts) {
     return null;
   }
   if (currentSize === prior.sourceSizeBytes) {
+    if (holdsCopies?.(prior) === true) return { prior, reason: "holds_copies" };
     counts.skippedExisting++;
     return null;
   }
@@ -1396,7 +1431,15 @@ async function classifyReimport(priors, sourcePath, externalId, counts) {
     counts.skippedDecreased++;
     return null;
   }
-  return prior;
+  return { prior, reason: "grew" };
+}
+function earliestStart(priors) {
+  let earliest;
+  for (const { startedAt } of priors) {
+    if (earliest === void 0 || Date.parse(startedAt) < Date.parse(earliest))
+      earliest = startedAt;
+  }
+  return earliest;
 }
 function encodeProjectDir(projectPath) {
   return projectPath.replace(/[^a-zA-Z0-9]/g, "-");
@@ -1408,6 +1451,11 @@ function firstTranscriptCwd(records) {
   }
   return void 0;
 }
+async function loadImportStore(paths, options, sourceKind) {
+  await assertSessionStoreSafe(paths);
+  if (options.dryRun !== true) await assertLockStoreSafe2(paths);
+  return loadExistingByExternalId(paths, sourceKind);
+}
 async function loadExistingByExternalId(paths, sourceKind) {
   const byExternalId = /* @__PURE__ */ new Map();
   const add = (externalId, prior) => {
@@ -1433,7 +1481,8 @@ async function loadExistingByExternalId(paths, sourceKind) {
     }
     if (session.session.source.kind !== sourceKind) continue;
     const sourceSizeBytes = session.session.source.source_size_bytes;
-    const prior = sourceSizeBytes !== void 0 ? { sessionId, sourceSizeBytes } : { sessionId };
+    const startedAt = session.session.started_at;
+    const prior = sourceSizeBytes !== void 0 ? { sessionId, startedAt, sourceSizeBytes } : { sessionId, startedAt };
     const ext = session.session.source.external_id;
     if (typeof ext === "string" && ext.length > 0) {
       add(ext, prior);
@@ -1478,6 +1527,153 @@ async function selectTranscriptFiles(projectsRoot, projectPaths, options) {
   }
   return [...new Set(files)].sort();
 }
+async function listTranscriptFiles(projectsRoot, projectPaths) {
+  const files = [];
+  for (const projectPath of projectPaths) {
+    const transcriptDir = join2(projectsRoot, encodeProjectDir(projectPath));
+    let entries;
+    try {
+      entries = await readdir(transcriptDir);
+    } catch (error) {
+      if (findErrorCode2(error, "ENOENT")) continue;
+      throw new Error("Failed to read Claude transcript directory", { cause: error });
+    }
+    for (const name of entries) {
+      if (name.endsWith(".jsonl")) files.push(join2(transcriptDir, name));
+    }
+  }
+  return [...new Set(files)].sort();
+}
+async function indexConversations(files, createdAtMs, importedStartedAt) {
+  const uuidsByFile = /* @__PURE__ */ new Map();
+  const uuidsIn = async (file) => {
+    let held = uuidsByFile.get(file);
+    if (held === void 0) {
+      held = await readTranscriptUuids(file);
+      uuidsByFile.set(file, held);
+    }
+    return held;
+  };
+  const rootOf = /* @__PURE__ */ new Map();
+  const byRoot = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const root = await readConversationRoot(file);
+    if (root === void 0) continue;
+    rootOf.set(file, root);
+    const entry = { file, externalId: basename3(file, ".jsonl"), createdAtMs: Number.NaN };
+    const list = byRoot.get(root.uuid);
+    if (list === void 0) byRoot.set(root.uuid, [entry]);
+    else list.push(entry);
+  }
+  for (const list of byRoot.values()) {
+    if (list.length < 2) continue;
+    for (const entry of list) entry.createdAtMs = await createdAtMs(entry.file);
+    list.sort((a, b) => {
+      const knownA = Number.isFinite(a.createdAtMs) && a.createdAtMs > 0;
+      const knownB = Number.isFinite(b.createdAtMs) && b.createdAtMs > 0;
+      if (knownA && knownB && a.createdAtMs !== b.createdAtMs) return a.createdAtMs - b.createdAtMs;
+      if (knownA !== knownB) return knownA ? -1 : 1;
+      return a.externalId < b.externalId ? -1 : a.externalId > b.externalId ? 1 : 0;
+    });
+    const startedAtMs = /* @__PURE__ */ new Map();
+    for (const entry of list) {
+      const ms = Date.parse(importedStartedAt(entry.externalId) ?? "");
+      if (!Number.isNaN(ms)) startedAtMs.set(entry, ms);
+    }
+    const imported = [...startedAtMs.keys()].sort(
+      (a, b) => (startedAtMs.get(a) ?? 0) - (startedAtMs.get(b) ?? 0)
+    );
+    list.forEach((entry, index) => {
+      if (startedAtMs.has(entry)) list[index] = imported.shift() ?? entry;
+    });
+    const rootMs = Date.parse(rootOf.get(list[0]?.file ?? "")?.timestamp ?? "");
+    const forks = list.filter((entry) => (startedAtMs.get(entry) ?? Number.NaN) > rootMs);
+    if (forks.length === 0) continue;
+    const rank = new Map(list.map((entry, index) => [entry, index]));
+    const countedBy = /* @__PURE__ */ new Map();
+    for (const [index, entry] of list.entries()) {
+      if (startedAtMs.has(entry)) continue;
+      for (const fork of forks) {
+        const forkRank = rank.get(fork) ?? index;
+        if (forkRank < index) continue;
+        let counted = countedBy.get(fork);
+        if (counted === void 0) {
+          counted = await readTranscriptUuids(fork.file, importedStartedAt(fork.externalId));
+          countedBy.set(fork, counted);
+        }
+        if (counted.size === 0) continue;
+        const held = await uuidsIn(entry.file);
+        if ([...counted].some((uuid) => held.has(uuid))) {
+          rank.set(entry, Math.max(rank.get(entry) ?? index, forkRank + 0.5));
+        }
+      }
+    }
+    list.sort((a, b) => (rank.get(a) ?? 0) - (rank.get(b) ?? 0));
+  }
+  return {
+    place(file) {
+      const root = rootOf.get(file);
+      if (root === void 0) return { root: void 0, older: [] };
+      const list = byRoot.get(root.uuid) ?? [];
+      const at = list.findIndex((entry) => entry.file === file);
+      return { root, older: list.slice(0, Math.max(at, 0)).map((entry) => entry.file) };
+    },
+    async uuidsOf(older) {
+      const uuids = /* @__PURE__ */ new Set();
+      for (const file of older) {
+        for (const uuid of await uuidsIn(file)) uuids.add(uuid);
+      }
+      return uuids;
+    }
+  };
+}
+async function readTranscriptUuids(file, notBefore) {
+  const uuids = /* @__PURE__ */ new Set();
+  try {
+    const { records } = await readJsonlRecords(file);
+    const kept = notBefore === void 0 ? records : claudeTranscriptOwnRecords(records, { notBefore });
+    for (const record of kept) {
+      const uuid = claudeTranscriptRecordUuid(record);
+      if (uuid !== void 0) uuids.add(uuid);
+    }
+  } catch {
+  }
+  return uuids;
+}
+async function readConversationRoot(file) {
+  const stream = createReadStream(file, { encoding: "utf8" });
+  const rl = createInterface({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+  try {
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (!isObject(parsed)) continue;
+      const uuid = claudeTranscriptRecordUuid(parsed);
+      if (uuid === void 0) continue;
+      const timestamp = parsed.timestamp;
+      return typeof timestamp === "string" && timestamp.length > 0 ? { uuid, timestamp } : { uuid };
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+}
+async function birthTimeMs(file) {
+  try {
+    return (await stat2(file)).birthtimeMs;
+  } catch {
+    return Number.NaN;
+  }
+}
 async function pathExists(file) {
   try {
     await stat2(file);
@@ -1613,7 +1809,8 @@ function printImportResult(options, results, counts) {
     skippedLegacy,
     skippedDecreased,
     skippedDuplicate,
-    skippedUnverifiable
+    skippedUnverifiable,
+    droppedCopies
   } = counts;
   if (options.json === true) {
     console.log(
@@ -1627,6 +1824,7 @@ function printImportResult(options, results, counts) {
         imported_count: results.length,
         replaced_count: replaced,
         reimported_count: reimported,
+        dropped_copies_count: droppedCopies,
         skipped_no_action: skippedNoAction,
         skipped_already_imported: skippedExisting,
         skipped_legacy_untracked: skippedLegacy,
@@ -1649,10 +1847,11 @@ function printImportResult(options, results, counts) {
     skipParts.push(`${skippedUnverifiable} unverifiable (run 'basou verify')`);
   const skipSuffix = skipParts.length > 0 ? `; skipped ${skipParts.join(", ")}` : "";
   const eventsPart = replaced > 0 ? `${eventTotal} events, ${replaced} replaced` : `${eventTotal} events`;
+  const copiesPart = droppedCopies > 0 ? ` (${droppedCopies} without the records ${droppedCopies === 1 ? "its transcript" : "their transcripts"} copied from an older one)` : "";
   if (isDry) {
     const parts = [];
     if (results.length > 0) parts.push(`import ${results.length} session(s) (${eventsPart})`);
-    if (reimported > 0) parts.push(`re-import ${reimported} changed session(s)`);
+    if (reimported > 0) parts.push(`re-import ${reimported} changed session(s)${copiesPart}`);
     const head = parts.length > 0 ? `Dry run: would ${parts.join(", ")}` : "Dry run: no changes";
     console.log(`${head}${skipSuffix}`);
     return;
@@ -1670,7 +1869,7 @@ function printImportResult(options, results, counts) {
   }
   if (reimported > 0) {
     segments.push(
-      `${results.length > 0 ? "re-imported" : "Re-imported"} ${reimported} changed session(s)`
+      `${results.length > 0 ? "re-imported" : "Re-imported"} ${reimported} changed session(s)${copiesPart}`
     );
   }
   console.log(`${segments.join(", ")}${skipSuffix}`);
@@ -1756,6 +1955,7 @@ async function runImport(adapter, fn) {
       importedCount: readCount(json.imported_count),
       replacedCount: readCount(json.replaced_count),
       reimportedCount: readCount(json.reimported_count),
+      droppedCopiesCount: readCount(json.dropped_copies_count),
       skippedNoAction: readCount(json.skipped_no_action),
       skippedAlreadyImported: readCount(json.skipped_already_imported),
       skippedLegacyUntracked: readCount(json.skipped_legacy_untracked),
@@ -2197,9 +2397,9 @@ async function checkAndRecord(options, ctx) {
 ${parsed.errors.map((e) => `  - ${displayPath3(e)}`).join("\n")}`
     );
   }
-  const recordedAt = ctx.nowProvider?.() ?? /* @__PURE__ */ new Date();
   const previous = await previousOf(loaded);
   const measurement = await measureLoaded(loaded, ctx, parsed.input.judged_by.model, previous);
+  const recordedAt = ctx.nowProvider?.() ?? /* @__PURE__ */ new Date();
   if (measurement.digest !== parsed.input.measure_digest) {
     throw new RecordRefusal(
       `measure_digest is ${parsed.input.measure_digest}, but the board measures ${measurement.digest} now: something it measures or board.yaml changed since the judgement, or basou was rebuilt or upgraded since that measurement. Measure again and judge that; nothing was written.`
@@ -2753,7 +2953,8 @@ function printMeasurementText(m, hasRecords2) {
     const width = Math.max(...measures.map(([id]) => id.length));
     lines.push("", "Measures:");
     for (const [id, measure] of measures) {
-      const unit = measure.value === null ? "" : ` ${displayPath3(measure.unit)}`;
+      const counted = typeof measure.value === "number" || Array.isArray(measure.value);
+      const unit = counted ? ` ${displayPath3(measure.unit)}` : "";
       const listed = Array.isArray(measure.value) ? " (paths in --json)" : "";
       const lane = measure.lane === void 0 ? "" : `  [${measure.lane.join(", ")}]`;
       lines.push(`  ${id.padEnd(width)}  ${shownValue(measure.value)}${unit}${listed}${lane}`);
@@ -9996,7 +10197,10 @@ function describeImport(outcome) {
   }
   const verb = outcome.dryRun ? "would import" : "imported";
   const parts = [`${outcome.importedCount} session(s)`, `${outcome.eventTotal} events`];
-  if (outcome.reimportedCount > 0) parts.push(`${outcome.reimportedCount} re-imported`);
+  if (outcome.reimportedCount > 0) {
+    const copies = outcome.droppedCopiesCount > 0 ? ` (${outcome.droppedCopiesCount} without records copied from an older transcript)` : "";
+    parts.push(`${outcome.reimportedCount} re-imported${copies}`);
+  }
   if (outcome.replacedCount > 0) parts.push(`${outcome.replacedCount} replaced`);
   if (outcome.skippedAlreadyImported > 0)
     parts.push(`${outcome.skippedAlreadyImported} already imported`);
@@ -14323,7 +14527,8 @@ var BOARD_HTML = `<!doctype html>
               el('ul', null, m.value.map(function (p) { return el('li', { text: p }); }))
             ])]);
           }
-          return el('li', { text: m.id + ': ' + num(m.value) + (m.value === null ? '' : ' ' + m.unit) });
+          // A string (a file's name, a capture) is no amount: it takes no unit.
+          return el('li', { text: m.id + ': ' + num(m.value) + (typeof m.value === 'number' ? ' ' + m.unit : '') });
         })));
       }
       return el('div', { class: 'lane', 'data-lane': lane.id }, body);
@@ -16131,7 +16336,7 @@ function installExperimentalNotice(program2, names = EXPERIMENTAL_COMMANDS, writ
 function readBuildStamp() {
   if (false) return void 0;
   try {
-    return JSON.parse('{"version":"0.71.1","commit":"5097e32","committedAt":"2026-10-19T07:43:16+09:00"}');
+    return JSON.parse('{"version":"0.71.2","commit":"c7fc0ed","committedAt":"2026-10-19T20:00:28+09:00"}');
   } catch {
     return void 0;
   }