mirror-mind 0.39.5 → 0.40.0

package/ts/src/conversation/transcriptBackfill.ts

@@ -1,23 +1,33 @@
-// Assistant-turn backfill from a Claude transcript (CV22.DS7.US10 slice E).
+// Assistant-turn backfill from a Claude transcript (CV22.DS7.US10 slice E,
+// rescoped by CR151).
 //
-// Ports `backfill_assistant_messages` from
+// Started as a port of `backfill_assistant_messages` from
 // `src/memory/cli/conversation_logger.py` together with the two helpers it
 // borrows from `src/memory/cli/transcript_export.py` (`parse_jsonl`,
-// `_assistant_text`). `hook_session_end` calls it after ending the session --
-// and, when the payload carries no session id at all, INSTEAD of ending one:
-// that session-less route is the path US5's hook port deliberately left out.
+// `_assistant_text`). `hook_session_end` calls it after ending the session.
 //
-// This is not an import: nothing is created or bound. It appends assistant
-// turns to conversations that overlap the transcript's time window and logged
-// no assistant message of their own, stamping each with `now` (Python's
-// `Message` default), not with the transcript timestamp. Python commits every
-// message as it goes and swallows nothing here; a malformed entry reached
-// mid-walk raises with the earlier appends already committed. The port keeps
-// that sequence so partial state matches, and leaves swallowing to the hook.
+// It now DIVERGES from that Python on purpose (CR151). Python chose the
+// conversations to fill by time window alone, so a session's replies were
+// copied into every open, reply-less conversation overlapping its transcript
+// -- a session killed mid-first-turn, or a concurrent one on another runtime --
+// and stamped them with `now`. Do not restore either behavior:
+//
+//   * the caller names the ONE conversation the transcript belongs to (the
+//     ending session's bound conversation); nothing else is touched, and a
+//     transcript no session owns fills nothing;
+//   * an inserted reply carries the transcript's own timestamp, normalized to
+//     the logger's microsecond ISO form, so the reply sorts between the prompts
+//     around it for every reader that orders by `created_at`.
+//
+// This is not an import: nothing is created or bound. A conversation that
+// already logged an assistant turn of its own (the Stop hook's path) is left
+// alone. Appends commit as they go; a malformed entry reached mid-walk raises
+// with the earlier appends already committed, and the hook swallows it.
 
 import { readFileSync } from "node:fs";
 import type { LoggerDeps } from "#conversation/logger.ts";
 import type { WritableDatabase } from "#db/database.ts";
+import { toMicrosecondIso } from "#util/pyGenerators.ts";
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -76,70 +86,67 @@ export function assistantText(contentBlocks: unknown): string {
   return parts.join("\n\n");
 }
 
-/** Python `str` truthiness on the timestamp: absent, null, or empty is skipped. */
+const UTC_ISO = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d+))?Z$/;
+
+/**
+ * A timestamp in the logger's microsecond ISO-`Z` form, or null when it cannot
+ * be read as an instant. Claude writes milliseconds (`.123Z`), the logger
+ * microseconds (`.123000Z`); compared as strings the two disagree (`.123Z`
+ * sorts after `.123456Z`), so every bound and every insert goes through here.
+ * A UTC string is re-padded rather than parsed, keeping microseconds intact.
+ */
+export function normalizeTimestamp(value: string): string | null {
+  const utc = UTC_ISO.exec(value);
+  if (utc) return `${utc[1]}.${(utc[2] ?? "").padEnd(6, "0").slice(0, 6)}Z`;
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : toMicrosecondIso(parsed);
+}
+
+/** An entry's normalized timestamp; absent, empty, non-string, or unreadable is null. */
 function timestampOf(entry: unknown): string | null {
   const value = getOr(entry, "timestamp", "");
-  return typeof value === "string" && value ? value : null;
+  return typeof value === "string" && value ? normalizeTimestamp(value) : null;
 }
 
 /**
- * Python `backfill_assistant_messages`. The transcript window is
- * `[min(timestamp), max(timestamp)]` over entries that carry one; a
- * conversation is in range when `started_at <= window end` and it either
- * ended at or after the window start or is still open. Within an in-range
- * conversation that has no assistant turn, every `assistant` entry whose
- * timestamp falls inside `[started_at, ended_at or window end]` is appended.
+ * Append the transcript's assistant turns to `conversationId` -- the one
+ * conversation the transcript's session is bound to, and only it (CR151).
+ * Skipped when that conversation does not exist or already logged an
+ * assistant turn. An `assistant` entry lands when its timestamp falls inside
+ * the conversation's own `[started_at, ended_at]` (open-ended while the
+ * conversation is open), and it lands stamped with that timestamp.
  */
 export function backfillAssistantMessages(
   db: WritableDatabase,
   transcriptPath: string,
-  deps: LoggerDeps,
+  conversationId: string,
+  deps: Pick<LoggerDeps, "newId">,
 ): void {
-  const entries = parseJsonl(transcriptPath);
-  if (entries.length === 0) return;
+  const conversation = db
+    .prepare("SELECT started_at, ended_at FROM conversations WHERE id = ?")
+    .get(conversationId) as { started_at: string; ended_at: string | null } | undefined;
+  if (!conversation) return;
+  const hasAssistant = db
+    .prepare("SELECT 1 FROM messages WHERE conversation_id = ? AND role = 'assistant' LIMIT 1")
+    .get(conversationId);
+  if (hasAssistant) return;
 
-  const timestamps = entries.map(timestampOf).filter((value): value is string => value !== null);
-  if (timestamps.length === 0) return;
-  // Python's min()/max() on str compare by code point; ISO timestamps are
-  // ASCII, so plain comparison is the same order.
-  let startTime = timestamps[0] as string;
-  let endTime = timestamps[0] as string;
-  for (const value of timestamps) {
-    if (value < startTime) startTime = value;
-    if (value > endTime) endTime = value;
-  }
-
-  const conversations = db
-    .prepare(
-      `SELECT id, started_at, ended_at FROM conversations
-        WHERE started_at <= ? AND (ended_at >= ? OR ended_at IS NULL)`,
-    )
-    .all(endTime, startTime) as { id: string; started_at: string; ended_at: string | null }[];
+  const start = normalizeTimestamp(conversation.started_at) ?? conversation.started_at;
+  const end =
+    conversation.ended_at === null
+      ? null
+      : (normalizeTimestamp(conversation.ended_at) ?? conversation.ended_at);
 
-  const hasAssistant = db.prepare(
-    "SELECT 1 FROM messages WHERE conversation_id = ? AND role = 'assistant' LIMIT 1",
-  );
   const insert = db.prepare(
     `INSERT INTO messages (id, conversation_id, role, content, created_at, token_count, metadata)
      VALUES (?, ?, 'assistant', ?, ?, NULL, NULL)`,
   );
-
-  for (const conversation of conversations) {
-    if (hasAssistant.get(conversation.id)) continue;
-    const conversationStart = conversation.started_at;
-    const conversationEnd = conversation.ended_at ?? endTime;
-
-    for (const entry of entries) {
-      const timestamp = timestampOf(entry);
-      if (!timestamp || !(conversationStart <= timestamp && timestamp <= conversationEnd)) continue;
-      if (getFrom(entry, "type") !== "assistant") continue;
-      const message = getOr(entry, "message", {});
-      const text = assistantText(getOr(message, "content", []));
-      if (text) {
-        // Python: Message(...) draws its id before its created_at.
-        const id = deps.newId();
-        insert.run(id, conversation.id, text, deps.nowIso());
-      }
-    }
+  for (const entry of parseJsonl(transcriptPath)) {
+    const timestamp = timestampOf(entry);
+    if (!timestamp || timestamp < start || (end !== null && timestamp > end)) continue;
+    if (getFrom(entry, "type") !== "assistant") continue;
+    const message = getOr(entry, "message", {});
+    const text = assistantText(getOr(message, "content", []));
+    if (text) insert.run(deps.newId(), conversationId, text, timestamp);
   }
 }

package/ts/src/guards/claudePlugin.ts

@@ -87,8 +87,9 @@ export const GLOBAL_BIN_DIRS = ['"$HOME/.nvm/current/bin"', "/opt/homebrew/bin",
  * `scripts/generate_hook_wrappers.sh` and into the locator below, and held
  * equal by `mirrorNodeRule.test.ts`. It classifies exactly as
  * `path.win32.isAbsolute`, on every platform: under Git Bash the Windows
- * installer writes `C:\Program Files\nodejs\node.exe`, which a POSIX-only
- * pattern would refuse on every hook (PR #47). On POSIX a drive or backslash
+ * installer writes a drive-letter path,
+ * `C:\Users\…\AppData\Local\Programs\MirrorMind\node\node.exe`, which a
+ * POSIX-only pattern would refuse on every hook (PR #47). On POSIX a drive or backslash
  * value names no file, and is refused as missing.
  */
 export const ABSOLUTE_PATH_CASE = "/*|\\\\*|[A-Za-z]:[\\\\/]*";

package/ts/src/guards/retiredSurfaces.ts

@@ -500,8 +500,10 @@ export const RETIRED: readonly RetiredSurface[] = [
     // Windows spells `C:\...` as `/C:/...` -- and read as one it made every
     // install under such a directory `unknown` (PR #42, CR140). The fix is
     // `import.meta.dirname` or `fileURLToPath`; this row keeps the idiom from
-    // coming back in code. Tests may spell the bug to pin it, so the scope is
-    // the product and its scripts.
+    // coming back in code. The tests and smokes are in scope too (issue #44):
+    // twenty fixture and CLI paths there read a URL's pathname, so the suite
+    // failed when run from a checkout under such a directory. Only the files
+    // that spell the bug to pin it are exempt.
     surfaceId: "url-pathname-as-path",
     story: "PR #42 (CR140)",
     absentPaths: [],
@@ -509,8 +511,11 @@ export const RETIRED: readonly RetiredSurface[] = [
     // off a variable (`url.pathname`). Prose writes `URL.pathname`, capital U,
     // which neither pattern matches, so a comment may still name the cause.
     forbiddenPatterns: ["\\)\\.pathname\\b", "\\b[a-z_$][\\w$]*\\.pathname\\b"],
-    residueScope: ["ts/src/", "ts/scripts/"],
-    exemptions: {},
+    residueScope: ["ts/src/", "ts/scripts/", "ts/test/", "ts/smoke/"],
+    exemptions: {
+      "ts/test/runtime/installKind.test.ts":
+        "asserts what a URL's pathname spells for a non-ASCII checkout, the bug it pins",
+    },
   },
   {
     surfaceId: "gemini-cli",

package/ts/src/journey/journeyCalls.ts

@@ -49,12 +49,19 @@ export type JourneyCallRejection =
   | "unknown_parent"
   | "unknown_journey"
   | "journey_changed"
-  | "journey_not_empty";
+  | "journey_not_empty"
+  // `deleteJourneyWithRecords` (journeyDeletion.ts):
+  | "journey_has_children"
+  | "extension_rows_held"
+  | "backup_failed";
 
 /** A call's refusal, named with the administration's codes where it had one. Nothing was written. */
 export class JourneyCallRejectedError extends Error {
   readonly reason: JourneyCallRejection;
-  /** For `journey_not_empty`: the association classes that hold records. */
+  /**
+   * For `journey_not_empty`: the association classes that hold records. For
+   * `journey_has_children`: the child Journeys. For `extension_rows_held`: the table.
+   */
   readonly populated: string[];
 
   constructor(reason: JourneyCallRejection, populated: string[] = []) {