mirror-mind 0.0.1 → 0.33.0

package/ts/src/conversation/journeyInference.ts

@@ -0,0 +1,165 @@
+// Journey inference for conversations (CV22.DS7.US10 slice E).
+//
+// Ports `_journey_aliases`, `_first_user_message`, `_activation_text`, and
+// `_infer_journey_for_conversation` from
+// `src/memory/cli/conversation_logger.py`.
+//
+// This is the deterministic half of `diagnose-journeys`/`repair-journeys`: it
+// decides which journeyless conversation has a high-confidence match. The
+// decision matters because `--apply` writes it, so a false positive silently
+// reassigns a user's conversation to the wrong journey.
+//
+// Pure: no storage, no clock, no provider. The caller supplies the alias table
+// and the conversation's title and first user message.
+
+import type { WritableDatabase } from "#db/database.ts";
+
+/** slug -> alias strings, longest first (Python sorts by length descending). */
+export type JourneyAliases = Record<string, string[]>;
+
+export interface JourneyInference {
+  journey: string | null;
+  reason: string | null;
+}
+
+/**
+ * Python's `_journey_aliases`: the slug, the slug with hyphens as spaces, and
+ * the first Markdown heading in the journey's identity content.
+ *
+ * Python builds the value set with `{slug.lower(), slug.replace("-", " ").lower()}`,
+ * so a slug without hyphens contributes one alias, not two.
+ */
+export function journeyAliases(db: WritableDatabase): JourneyAliases {
+  const rows = db
+    .prepare("SELECT key, content FROM identity WHERE layer = 'journey' ORDER BY key")
+    .all() as Record<string, unknown>[];
+
+  const aliases: JourneyAliases = {};
+  for (const row of rows) {
+    const slug = String(row.key);
+    const content = typeof row.content === "string" ? row.content : "";
+    const values = new Set([slug.toLowerCase(), slug.replaceAll("-", " ").toLowerCase()]);
+    for (const line of content.split("\n")) {
+      const heading = line.trim();
+      if (heading.startsWith("#")) {
+        // Python breaks at the FIRST heading line, whether or not it yielded a
+        // title, so a bare `#` stops the scan instead of falling through.
+        const title = heading.replace(/^#+/, "").trim();
+        if (title) values.add(title.toLowerCase());
+        break;
+      }
+    }
+    aliases[slug] = sortByLengthDescending([...values]);
+  }
+  return aliases;
+}
+
+/**
+ * Python's `sorted(values, key=len, reverse=True)`, with equal lengths broken
+ * lexicographically.
+ *
+ * Python sorts a SET and its sort is stable, so aliases of equal length come
+ * out in set-iteration order -- which string hash randomization varies between
+ * processes. Observed directly while building the golden: `beta-two` alternates
+ * between `["beta two", "beta-two"]` and the reverse across runs.
+ *
+ * The ordering is behaviorally inert for inference: only the matched alias's
+ * LENGTH feeds the cross-slug tie-break, and equal-length entries tie by
+ * definition. Breaking those ties lexicographically therefore preserves
+ * behavior while making the alias table reproducible, which is what lets the
+ * golden serve as a determinism gate. The generator normalizes the oracle's
+ * output the same way and asserts the two agree on membership and lengths.
+ */
+function sortByLengthDescending(values: string[]): string[] {
+  return [...values].sort(
+    (left, right) => right.length - left.length || (left < right ? -1 : left > right ? 1 : 0),
+  );
+}
+
+/** Python's `_first_user_message`. */
+export function firstUserMessage(db: WritableDatabase, conversationId: string): string {
+  const row = db
+    .prepare(
+      `SELECT content FROM messages
+        WHERE conversation_id = ? AND role = 'user'
+        ORDER BY created_at ASC LIMIT 1`,
+    )
+    .get(conversationId) as Record<string, unknown> | undefined;
+  return row && typeof row.content === "string" ? row.content : "";
+}
+
+/**
+ * Python's `_activation_text`: the title, the text after a closing `</skill>`
+ * tag when present, and the first line -- joined with newlines and lowercased.
+ */
+export function activationText(title: string | null, firstUser: string): string {
+  const parts: string[] = [title ?? ""];
+  const stripped = firstUser.trim();
+  if (stripped.includes("</skill>")) {
+    parts.push(stripped.slice(stripped.lastIndexOf("</skill>") + "</skill>".length));
+  }
+  const firstLine = stripped ? (stripped.split("\n")[0] as string) : "";
+  parts.push(firstLine);
+  return parts.join("\n").toLowerCase();
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Python's `_infer_journey_for_conversation`.
+ *
+ * Two routes: an explicit `/mm-build <slug>` command, or an alias match that is
+ * either standalone on its own line or wrapped in an activation phrase. A tie
+ * between the two longest matching aliases returns no journey -- ambiguity is
+ * resolved by refusing, never by picking, because the caller may write it.
+ */
+export function inferJourneyForConversation(
+  title: string | null,
+  firstUser: string,
+  aliases: JourneyAliases,
+): JourneyInference {
+  const text = activationText(title, firstUser);
+  if (!text.trim()) return { journey: null, reason: null };
+
+  const buildMatch = /(?:\/mm-build|\$mm-build|\/mm:build)\s+([a-z0-9][a-z0-9_-]*)/.exec(text);
+  if (buildMatch) {
+    const slug = buildMatch[1] as string;
+    if (slug in aliases) return { journey: slug, reason: "explicit build command" };
+  }
+
+  const candidates: { slug: string; alias: string; reason: string }[] = [];
+  for (const [slug, values] of Object.entries(aliases)) {
+    for (const alias of values) {
+      const escaped = escapeRegExp(alias);
+      // Python's `$` without MULTILINE means end of string, or immediately
+      // before a trailing newline -- NOT the end of every line. A JavaScript
+      // `m` flag would match an alias sitting mid-text and silently widen the
+      // rule that decides what `--apply` rewrites, so the trailing-newline case
+      // is spelled out with a lookahead instead.
+      if (new RegExp(`(?:^|\\n)\\s*${escaped}\\s*(?=\\n?$)`).test(text)) {
+        candidates.push({ slug, alias, reason: "standalone journey slug/name" });
+        break;
+      }
+      const activation =
+        `(?:vamos|quero|preciso|let'?s)\\s+` +
+        `(?:retomar\\s+)?(?:trabalhar|ativar|continuar|retomar|work)` +
+        `(?:\\s+\\w+){0,5}\\s+(?:journey|jornada|travessia|projeto|project)?\\s*` +
+        `(?:no|na|em|on|with)?\\s*${escaped}\\b` +
+        `(?=$|\\s*[.,;:!?)]|\\s+(?:em|in|journey|jornada|travessia|modo)\\b)`;
+      if (new RegExp(activation).test(text)) {
+        candidates.push({ slug, alias, reason: "activation phrase" });
+        break;
+      }
+    }
+  }
+
+  if (candidates.length === 0) return { journey: null, reason: null };
+  candidates.sort((left, right) => right.alias.length - left.alias.length);
+  const best = candidates[0] as { slug: string; alias: string; reason: string };
+  if (candidates.length > 1 && best.alias.length === (candidates[1]?.alias.length ?? -1)) {
+    return { journey: null, reason: null };
+  }
+  return { journey: best.slug, reason: best.reason };
+}

package/ts/src/conversation/journeyRepair.ts

@@ -0,0 +1,114 @@
+// Journey association diagnosis and repair (CV22.DS7.US10 slice E).
+//
+// Ports `diagnose_journey_associations` and
+// `_print_journey_association_findings` from
+// `src/memory/cli/conversation_logger.py`.
+//
+// `diagnose-journeys` is read-only. `repair-journeys --apply` is the one
+// genuinely MUTATING repair in this story: it rewrites the `journey` column of
+// conversations the user never explicitly assigned. Python gates it behind a
+// database backup and refuses to proceed if the backup fails, which is a safety
+// property, not an implementation detail -- it is ported as a hard refusal.
+
+import {
+  firstUserMessage,
+  inferJourneyForConversation,
+  journeyAliases,
+} from "#conversation/journeyInference.ts";
+import type { WritableDatabase } from "#db/database.ts";
+
+export interface JourneyFinding {
+  conversation_id: string;
+  journey: string;
+  reason: string;
+  title: string;
+  started_at: string;
+  message_count: number;
+}
+
+export interface DiagnoseOptions {
+  limit?: number | null;
+  apply?: boolean;
+  /**
+   * Create a database backup and return its path, or null on failure. Required
+   * whenever `apply` is set; a null return refuses the repair.
+   */
+  backup?: () => string | null;
+}
+
+/**
+ * Find, and optionally repair, journeyless conversations with a high-confidence
+ * match.
+ *
+ * The findings list is identical in both modes: `apply` changes whether they are
+ * written, never which conversations qualify. That is what makes the dry run a
+ * trustworthy preview of the mutation.
+ */
+export function diagnoseJourneyAssociations(
+  db: WritableDatabase,
+  options: DiagnoseOptions = {},
+): JourneyFinding[] {
+  const aliases = journeyAliases(db);
+  const limit = options.limit ?? null;
+  const baseSql =
+    "SELECT id, title, started_at FROM conversations WHERE journey IS NULL ORDER BY started_at DESC";
+  const rows = (
+    limit === null ? db.prepare(baseSql).all() : db.prepare(`${baseSql} LIMIT ?`).all(limit)
+  ) as Record<string, unknown>[];
+
+  const findings: JourneyFinding[] = [];
+  for (const row of rows) {
+    const conversationId = String(row.id);
+    const title = typeof row.title === "string" ? row.title : null;
+    const { journey, reason } = inferJourneyForConversation(
+      title,
+      firstUserMessage(db, conversationId),
+      aliases,
+    );
+    if (!journey) continue;
+
+    const countRow = db
+      .prepare("SELECT COUNT(*) AS count FROM messages WHERE conversation_id = ?")
+      .get(conversationId) as Record<string, unknown>;
+    findings.push({
+      conversation_id: conversationId,
+      journey,
+      reason: reason ?? "high-confidence match",
+      title: title ?? "",
+      started_at: String(row.started_at),
+      message_count: Number(countRow.count ?? 0),
+    });
+  }
+
+  if (options.apply && findings.length > 0) {
+    if (!options.backup) {
+      throw new Error("Database backup failed; refusing to repair conversations.");
+    }
+    const backupPath = options.backup();
+    if (backupPath === null) {
+      throw new Error("Database backup failed; refusing to repair conversations.");
+    }
+    for (const finding of findings) {
+      db.prepare("UPDATE conversations SET journey = ? WHERE id = ?").run(
+        finding.journey,
+        finding.conversation_id,
+      );
+    }
+  }
+
+  return findings;
+}
+
+/** Python's `_print_journey_association_findings`. */
+export function renderJourneyFindings(findings: JourneyFinding[], applied: boolean): string {
+  const label = applied ? "Repaired" : "Repair candidates";
+  const lines = [`${label}: ${findings.length}`];
+  for (const finding of findings) {
+    lines.push(
+      `- ${finding.conversation_id} -> ${finding.journey} ` +
+        `(${finding.reason}; ${finding.message_count} messages; ` +
+        `${finding.started_at}; ${finding.title})`,
+    );
+  }
+  return `${lines.join("\n")}\n`;
+}

package/ts/src/conversation/lifecycleFaces.ts

@@ -0,0 +1,197 @@
+/**
+ * The ES-001 metadata-lifecycle READ faces — CV22.DS7.US11 plateau 5b.
+ *
+ * `conversations --metadata-lifecycle-dry-run <conversation-id>` and
+ * `--metadata-lifecycle-preview-at-message <message-id>`: two pure reads over
+ * the engine DS7.US10 already ported. CR068 found the whole ES-001 flag family
+ * unowned — US1 called it "own slice", no slice claimed it.
+ *
+ * **Scope boundary, Navigator decision 2026-09-09 (option B).** The sibling
+ * faces `--metadata-lifecycle-apply` and `--metadata-lifecycle-demo` are NOT
+ * ported here and are refused BY NAME in `routing.ts`. Both need
+ * `apply_metadata_lifecycle`: ~80 lines of unported decision logic with a write
+ * path, which `closeTail.ts` already refuses for the same reason, and `demo`
+ * calls `apply`. The US11 plan recorded all four as "wiring over the ported
+ * engine", which was true of the reads and false of the writes. DS7.TS4 owns
+ * them; the two historical metadata-backfill flags were retired outright by
+ * CV22.DS10.TS4.
+ */
+
+import {
+  type ConversationLike,
+  dryRunMetadataLifecycle,
+  type MessageLike,
+  type MetadataLifecycleReport,
+  titleNeedsImprovement,
+} from "#conversation/metadataLifecycle.ts";
+import type { Database } from "#db/database.ts";
+
+/** Python raises `ValueError`; the CLI renders its text. */
+export class LifecycleFaceError extends Error {}
+
+/**
+ * Every column the ENGINE reads, not just the ones the title decision reads.
+ *
+ * The first version of this face selected `id, title, metadata`, and the
+ * summary and tags decisions silently answered as if the conversation had
+ * neither: a conversation with a stored summary reported `summary: defer` where
+ * Python reports `keep`, and the title decision moved with it, because
+ * refinement evidence is drawn from the summary. Measured at CV22.DS7.TS4
+ * plateau 6 against the real CLI; the US11 corpus could not see it because no
+ * seeded conversation had a summary or tags to lose.
+ */
+interface ConversationRow {
+  id: string;
+  title: string | null;
+  summary: string | null;
+  tags: string | null;
+  metadata: string | null;
+}
+
+/**
+ * Python `_get_conversation_for_title_operation`: exact id, then an id-prefix
+ * lookup, then a ValueError naming the value the caller passed.
+ */
+export function resolveConversation(db: Database, conversationId: string): ConversationRow {
+  if (typeof conversationId !== "string" || conversationId.trim() === "") {
+    throw new LifecycleFaceError("conversationId is required");
+  }
+  const exact = db
+    .prepare("SELECT id, title, summary, tags, metadata FROM conversations WHERE id = ?")
+    .get(conversationId) as unknown as ConversationRow | undefined;
+  if (exact) return exact;
+  const prefixed = db
+    .prepare(
+      "SELECT id, title, summary, tags, metadata FROM conversations WHERE id LIKE ? " +
+        "ORDER BY started_at LIMIT 1",
+    )
+    .get(`${conversationId}%`) as unknown as ConversationRow | undefined;
+  if (prefixed) return prefixed;
+  throw new LifecycleFaceError(`Conversation '${conversationId}' not found`);
+}
+
+/**
+ * The engine's `MessageLike` declares only what the policy READS (role,
+ * content). The boundary walk needs the id as well, so it is declared here
+ * rather than widening the engine's interface for a caller's convenience.
+ */
+interface MessageRow extends MessageLike {
+  id: string;
+}
+
+function loadMessages(db: Database, conversationId: string): MessageRow[] {
+  return db
+    .prepare(
+      "SELECT id, role, content, created_at FROM messages WHERE conversation_id = ? ORDER BY created_at",
+    )
+    .all(conversationId) as unknown as MessageRow[];
+}
+
+/** Python `_metadata_dict`: a non-object or malformed metadata becomes `{}`. */
+export function metadataDict(conversation: ConversationRow): Record<string, unknown> {
+  if (!conversation.metadata) return {};
+  try {
+    const parsed: unknown = JSON.parse(conversation.metadata);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return parsed as Record<string, unknown>;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * `titleNeedsImprovement` reads `metadata` — `title_status: "provisional"` is
+ * what makes a title repairable — so the WHOLE row crosses, not just id and
+ * title. An earlier draft passed `{ id, title }` behind an `as ConversationLike`
+ * cast, which compiled fine and silently turned every `repair` into `keep`.
+ * The cast is gone: the row already satisfies the interface structurally.
+ */
+function asConversationLike(row: ConversationRow): ConversationLike {
+  return {
+    id: row.id,
+    title: row.title,
+    summary: row.summary,
+    tags: row.tags,
+    metadata: row.metadata,
+  };
+}
+
+/** `conversations --metadata-lifecycle-dry-run <conversation-id>`. */
+export function runLifecycleDryRun(db: Database, conversationId: string): MetadataLifecycleReport {
+  const conversation = resolveConversation(db, conversationId);
+  const messages = loadMessages(db, conversation.id);
+  return dryRunMetadataLifecycle(
+    asConversationLike(conversation),
+    messages,
+    metadataDict(conversation),
+    {
+      titleNeedsImprovement,
+    },
+  );
+}
+
+export interface PreviewAtMessageReport {
+  conversation_id: string;
+  message_id: string;
+  mode: "debug_preview_at_message";
+  mutated: false;
+  included_message_count: number;
+  excluded_message_count: number;
+  dry_run: MetadataLifecycleReport;
+}
+
+/**
+ * `conversations --metadata-lifecycle-preview-at-message <message-id>`.
+ *
+ * Python resolves the boundary message by exact id OR id prefix, taking the
+ * MOST RECENT match (`ORDER BY created_at DESC LIMIT 1`) — the opposite
+ * direction from the conversation lookup beside it, reproduced as written.
+ */
+export function runLifecyclePreviewAtMessage(
+  db: Database,
+  messageId: string,
+): PreviewAtMessageReport {
+  if (typeof messageId !== "string" || messageId.trim() === "") {
+    throw new LifecycleFaceError("messageId is required");
+  }
+  const boundary = db
+    .prepare(
+      "SELECT id, conversation_id FROM messages WHERE id = ? OR id LIKE ? ORDER BY created_at DESC LIMIT 1",
+    )
+    .get(messageId, `${messageId}%`) as unknown as
+    | { id: string; conversation_id: string }
+    | undefined;
+  if (!boundary) throw new LifecycleFaceError(`Message '${messageId}' not found`);
+
+  const conversation = resolveConversation(db, boundary.conversation_id);
+  const allMessages = loadMessages(db, conversation.id);
+
+  const selected: MessageRow[] = [];
+  let foundBoundary = false;
+  for (const message of allMessages) {
+    selected.push(message);
+    if (message.id === boundary.id) {
+      foundBoundary = true;
+      break;
+    }
+  }
+  if (!foundBoundary) {
+    throw new LifecycleFaceError(`Message '${messageId}' not found in conversation`);
+  }
+
+  const dryRun = dryRunMetadataLifecycle(
+    asConversationLike(conversation),
+    selected,
+    metadataDict(conversation),
+    { titleNeedsImprovement },
+  );
+  return {
+    conversation_id: conversation.id,
+    message_id: boundary.id,
+    mode: "debug_preview_at_message",
+    mutated: false,
+    included_message_count: selected.length,
+    excluded_message_count: Math.max(0, allMessages.length - selected.length),
+    dry_run: dryRun,
+  };
+}