mirror-mind 0.36.1 → 0.36.3

package/ts/src/conversation/importedConversations.ts

@@ -0,0 +1,288 @@
+// The Pi conversations an earlier version imported rather than logged (CR154).
+//
+// Until v0.36.1, session maintenance copied Pi session files into the home and
+// imported each as a closed conversation (CR153 retired that). On a machine
+// with two homes, each took the other's sessions, along with sessions of Pi run
+// without Mirror and of scratch homes. This module lets a person see them and
+// remove the ones they choose. It reads no Pi file: everything it knows, the
+// home already holds.
+//
+// An import is told apart by construction: the import stamped `started_at` when
+// it copied the session and `ended_at` from the session's last message, so an
+// import starts at or after its own end, and a live conversation never does.
+// Both instants must carry a zone. A conversation with a zone-less timestamp is
+// never an import, whatever the order says: the comparison would be a guess,
+// and the guess would offer a live conversation for removal.
+//
+// Where an import came from is the directory of its session file, read from
+// the path its runtime-session row stored (Pi names a project's directory
+// `--<path with / as ->--`; the wrapping dashes are dropped). Beside it, how
+// many Pi sessions this home logged live from the same directory -- the one
+// number that tells another home's work (none logged live here) from this
+// home's own gaps. It blurs in a home made by copying another: the copied rows
+// count as its own.
+
+import { basename, dirname } from "node:path";
+import { deleteConversation } from "#conversation/conversationDeletion.ts";
+import { type Database, type WritableDatabase, withTransaction } from "#db/database.ts";
+
+/** The folder of an import with no runtime-session row left to say where it came from. */
+export const UNKNOWN_FOLDER = "(unknown)";
+
+/** How much of an id a person must give to name one conversation: what the listing prints. */
+export const MIN_ID_PREFIX = 8;
+
+export interface ImportedConversation {
+  id: string;
+  title: string | null;
+  /** When it was imported: the conversation's `started_at`. */
+  importedAt: string;
+  /** The session's last message: the conversation's `ended_at`. */
+  endedAt: string;
+  messageCount: number;
+  folder: string;
+}
+
+export interface FolderSummary {
+  folder: string;
+  imported: number;
+  messages: number;
+  /** Pi sessions this home logged live from the folder; null for the unknown folder. */
+  loggedLive: number | null;
+}
+
+export interface ImportsSummary {
+  conversations: number;
+  messages: number;
+  firstImportedAt: string | null;
+  lastImportedAt: string | null;
+  /** Most imported first, then by name; the unknown folder last. */
+  folders: FolderSummary[];
+}
+
+/** Ids, each a full id or a prefix of at least `MIN_ID_PREFIX`; or every import, of one folder or all. */
+export type ImportRemovalRequest =
+  | { readonly ids: readonly string[] }
+  | { readonly all: true; readonly folder: string | null };
+
+export type ImportRemovalPlan =
+  | { ok: true; conversations: ImportedConversation[] }
+  | { ok: false; refusal: string };
+
+export interface ImportRemovalResult {
+  conversations: ImportedConversation[];
+  messages: number;
+}
+
+/** The plan refused the request inside the removal's transaction. */
+export class ImportRemovalRefusedError extends Error {
+  constructor(refusal: string) {
+    super(refusal);
+    this.name = "ImportRemovalRefusedError";
+  }
+}
+
+/** The set the transaction found is not the set the person was shown. */
+export class ImportRemovalSetMovedError extends Error {
+  constructor() {
+    super("the imports to remove changed since they were listed");
+    this.name = "ImportRemovalSetMovedError";
+  }
+}
+
+const ZONED = /(?:Z|[+-]\d{2}:\d{2})$/;
+
+/** An import starts at or after its own last message; both instants carry a zone. */
+export function isImportShaped(startedAt: string, endedAt: string | null): boolean {
+  if (endedAt === null || !ZONED.test(startedAt) || !ZONED.test(endedAt)) return false;
+  const started = Date.parse(startedAt);
+  const ended = Date.parse(endedAt);
+  if (Number.isNaN(started) || Number.isNaN(ended)) return false;
+  return started >= ended;
+}
+
+/** The directory a Pi session file lived in, from its stored path; Pi's wrapping dashes dropped. */
+export function sessionFolder(sessionPath: string | null): string {
+  if (!sessionPath) return UNKNOWN_FOLDER;
+  const parent = dirname(sessionPath);
+  const name = basename(parent);
+  if (parent === "." || parent === sessionPath || !name) return UNKNOWN_FOLDER;
+  return name.length > 4 && name.startsWith("--") && name.endsWith("--") ? name.slice(2, -2) : name;
+}
+
+function nullableString(value: unknown): string | null {
+  return typeof value === "string" ? value : null;
+}
+
+/** Every Pi import in the home, newest import first. */
+export function listImportedPiConversations(db: Database): ImportedConversation[] {
+  // SQL narrows to the shape; `isImportShaped` decides, zones included.
+  const rows = db
+    .prepare(
+      `SELECT c.id, c.title, c.started_at, c.ended_at,
+              (SELECT COUNT(*) FROM messages m WHERE m.conversation_id = c.id) AS message_count,
+              (SELECT r.session_id FROM runtime_sessions r
+                WHERE r.conversation_id = c.id ORDER BY r.rowid LIMIT 1) AS session_path
+         FROM conversations c
+        WHERE c.interface = 'pi' AND c.ended_at IS NOT NULL
+          AND julianday(c.started_at) >= julianday(c.ended_at)
+        ORDER BY julianday(c.started_at) DESC, c.id`,
+    )
+    .all();
+  const imports: ImportedConversation[] = [];
+  for (const row of rows) {
+    const startedAt = String(row.started_at);
+    const endedAt = nullableString(row.ended_at);
+    if (endedAt === null || !isImportShaped(startedAt, endedAt)) continue;
+    imports.push({
+      id: String(row.id),
+      title: nullableString(row.title),
+      importedAt: startedAt,
+      endedAt,
+      messageCount: Number(row.message_count),
+      folder: sessionFolder(nullableString(row.session_path)),
+    });
+  }
+  return imports;
+}
+
+/** Pi sessions this home logged live, by the folder their session file lived in. */
+export function countLiveSessionsByFolder(db: Database): Map<string, number> {
+  const rows = db
+    .prepare(
+      `SELECT r.session_id, c.started_at, c.ended_at
+         FROM runtime_sessions r JOIN conversations c ON c.id = r.conversation_id
+        WHERE r.interface = 'pi' AND c.interface = 'pi'`,
+    )
+    .all();
+  const counts = new Map<string, number>();
+  for (const row of rows) {
+    if (isImportShaped(String(row.started_at), nullableString(row.ended_at))) continue;
+    const folder = sessionFolder(nullableString(row.session_id));
+    counts.set(folder, (counts.get(folder) ?? 0) + 1);
+  }
+  return counts;
+}
+
+/** Totals and one line per folder, for the listing. */
+export function summarizeImports(
+  imports: readonly ImportedConversation[],
+  loggedLive: ReadonlyMap<string, number>,
+): ImportsSummary {
+  const byFolder = new Map<string, FolderSummary>();
+  let messages = 0;
+  let first: string | null = null;
+  let last: string | null = null;
+  for (const item of imports) {
+    messages += item.messageCount;
+    if (first === null || Date.parse(item.importedAt) < Date.parse(first)) first = item.importedAt;
+    if (last === null || Date.parse(item.importedAt) > Date.parse(last)) last = item.importedAt;
+    const summary = byFolder.get(item.folder) ?? {
+      folder: item.folder,
+      imported: 0,
+      messages: 0,
+      loggedLive: item.folder === UNKNOWN_FOLDER ? null : (loggedLive.get(item.folder) ?? 0),
+    };
+    summary.imported += 1;
+    summary.messages += item.messageCount;
+    byFolder.set(item.folder, summary);
+  }
+  const folders = [...byFolder.values()].sort((a, b) => {
+    if ((a.folder === UNKNOWN_FOLDER) !== (b.folder === UNKNOWN_FOLDER)) {
+      return a.folder === UNKNOWN_FOLDER ? 1 : -1;
+    }
+    return b.imported - a.imported || a.folder.localeCompare(b.folder);
+  });
+  return {
+    conversations: imports.length,
+    messages,
+    firstImportedAt: first,
+    lastImportedAt: last,
+    folders,
+  };
+}
+
+function refuse(refusal: string): ImportRemovalPlan {
+  return { ok: false, refusal };
+}
+
+/**
+ * What a request names, decided once for the dry run and again inside the
+ * removal's transaction. Any id that does not name exactly one import refuses
+ * the whole request: nothing is removed on a partial match.
+ */
+export function planImportRemoval(db: Database, request: ImportRemovalRequest): ImportRemovalPlan {
+  const imports = listImportedPiConversations(db);
+  if ("all" in request) {
+    if (request.folder === null) return { ok: true, conversations: imports };
+    const named = imports.filter((item) => item.folder === request.folder);
+    if (named.length === 0) {
+      return refuse(
+        `no imported conversations from folder '${request.folder}' in this home: the listing names the folders that have them, exactly`,
+      );
+    }
+    return { ok: true, conversations: named };
+  }
+
+  const byId = new Map(imports.map((item) => [item.id, item]));
+  const chosen = new Map<string, ImportedConversation>();
+  // `substr` rather than LIKE: an id the person types is matched as written,
+  // never as a pattern.
+  const matching = db.prepare("SELECT id FROM conversations WHERE substr(id, 1, ?) = ?");
+  for (const given of request.ids) {
+    if (given.length < MIN_ID_PREFIX) {
+      return refuse(
+        `'${given}' is too short: give at least ${MIN_ID_PREFIX} characters of a conversation id, as the listing prints them`,
+      );
+    }
+    const matches = matching.all(given.length, given).map((row) => String(row.id));
+    if (matches.length === 0) return refuse(`no conversation '${given}' in this home`);
+    if (matches.length > 1) {
+      return refuse(`'${given}' matches ${matches.length} conversations: give more of the id`);
+    }
+    const id = matches[0] as string;
+    const imported = byId.get(id);
+    if (imported === undefined) {
+      return refuse(
+        `conversation ${id.slice(0, MIN_ID_PREFIX)} is not an imported Pi conversation; this command removes only those`,
+      );
+    }
+    chosen.set(id, imported);
+  }
+  return { ok: true, conversations: imports.filter((item) => chosen.has(item.id)) };
+}
+
+function sameIds(a: readonly string[], b: readonly string[]): boolean {
+  if (a.length !== b.length) return false;
+  const sortedA = [...a].sort();
+  const sortedB = [...b].sort();
+  return sortedA.every((id, index) => id === sortedB[index]);
+}
+
+/**
+ * Remove what the request names, in one transaction: all or nothing. The set is
+ * decided again inside the transaction and must be the one the person was
+ * shown (`expectedIds`); if it moved, nothing is removed. Each import's session
+ * row goes with it -- it bound nothing but the import -- and the conversation
+ * goes through the shared deletion.
+ */
+export function removeImportedConversations(
+  db: WritableDatabase,
+  request: ImportRemovalRequest,
+  expectedIds: readonly string[],
+): ImportRemovalResult {
+  return withTransaction(db, () => {
+    const plan = planImportRemoval(db, request);
+    if (!plan.ok) throw new ImportRemovalRefusedError(plan.refusal);
+    const ids = plan.conversations.map((item) => item.id);
+    if (!sameIds(ids, expectedIds)) throw new ImportRemovalSetMovedError();
+    const removeSessionRows = db.prepare("DELETE FROM runtime_sessions WHERE conversation_id = ?");
+    let messages = 0;
+    for (const item of plan.conversations) {
+      removeSessionRows.run(item.id);
+      deleteConversation(db, item.id);
+      messages += item.messageCount;
+    }
+    return { conversations: plan.conversations, messages };
+  });
+}

package/ts/src/conversation/logger.ts

@@ -13,6 +13,7 @@
 import { closeSync, existsSync, mkdirSync, openSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { isCommandTurn } from "#conversation/commandTurn.ts";
+import { deleteConversation } from "#conversation/conversationDeletion.ts";
 import { markCloseTailPending } from "#conversation/deferredCloseTail.ts";
 import {
   lastAssistantMessageOf,
@@ -453,25 +454,10 @@ export async function endSession(
 }
 
 /**
- * Python `ConversationService.delete_conversations` for one resolved id:
- * extracted memories survive with a nulled FK rather than cascading away.
+ * Python `discard_current_conversation`: delete and mark the session discarded.
+ * The deletion is `conversationDeletion.ts`'s, shared with CR154's removal of
+ * imported Pi conversations.
  */
-function deleteConversation(db: WritableDatabase, conversationId: string): void {
-  db.prepare("DELETE FROM messages WHERE conversation_id = ?").run(conversationId);
-  db.prepare("DELETE FROM conversation_embeddings WHERE conversation_id = ?").run(conversationId);
-  db.prepare("UPDATE memories SET conversation_id = NULL WHERE conversation_id = ?").run(
-    conversationId,
-  );
-  db.prepare("UPDATE llm_calls SET conversation_id = NULL WHERE conversation_id = ?").run(
-    conversationId,
-  );
-  db.prepare("UPDATE runtime_sessions SET conversation_id = NULL WHERE conversation_id = ?").run(
-    conversationId,
-  );
-  db.prepare("DELETE FROM conversations WHERE id = ?").run(conversationId);
-}
-
-/** Python `discard_current_conversation`: delete and mark the session discarded. */
 export function discardCurrentConversation(
   db: WritableDatabase,
   sessionId: string | null,

package/ts/src/conversation/piSkillTurns.ts

@@ -0,0 +1,267 @@
+// The Pi user turns an earlier version stored as a skill's body, and their repair
+// (CR160).
+//
+// Pi turns a prompt that opens with `/skill:<name>`, which is also what its command
+// menu sends, into the skill's whole body before its extensions see it. Until CR160
+// Pi's extension logged that prompt, so a skill invocation was stored as
+// `<skill name="…" location="…">` and the body, as if the person had said it; every
+// later reader -- the title, the embedding, extraction -- read it so.
+//
+// The repair applies the rule the core logs by (`commandTurn.ts`): a Mirror
+// question keeps its question, without the block (`mirrorForm.ts`); any other skill
+// invocation is not conversation, and neither are its arguments (a `mm-build`
+// slug), so its row goes. A conversation the repair leaves with no user turn goes
+// too, through the shared deletion, which keeps its memories unlinked (the
+// Navigator's decision, A7). A conversation titled from a block, and not titled by
+// hand, gets the title every conversation gets from its first user turn, marked
+// provisional so the title paths can improve it. Replies stay: they are what the
+// mirror said, and a reply to a skipped turn cannot be told from another. Summaries
+// and their embeddings stay: they describe a session in which a skill was invoked
+// (A6).
+//
+// Only Pi's whole wrapper, only in Pi conversations (A8): a person may type or
+// paste `<skill name=` at the start of a message anywhere. One more shape counts:
+// the wrapper the old logger cut at its size limit, whose ending only it writes.
+
+import { isCommandTurn } from "#conversation/commandTurn.ts";
+import { deleteConversation } from "#conversation/conversationDeletion.ts";
+import { generateTitle, setProvisionalTitle } from "#conversation/logger.ts";
+import { type Database, type WritableDatabase, withTransaction } from "#db/database.ts";
+
+/**
+ * Pi's expansion of `/skill:<name> args`, whole: the opening tag, Pi's line naming
+ * where the skill's references resolve, the body, the closing tag, and the
+ * arguments after a blank line when there are any (Pi 1.3.0 and 1.4.0,
+ * `_expandSkillCommand`). Pi's own extension reads the same shape back
+ * (`.pi/extensions/mirror-logger.ts`); `piSkillTurns.test.ts` holds the two alike.
+ */
+export const PI_SKILL_WRAPPER =
+  /^<skill name="([^"]+)" location="[^"]*">\nReferences are relative to [^\n]*\n\n[\s\S]*?\n<\/skill>(?:\n\n([\s\S]*))?$/;
+
+/**
+ * The same block when the old logger cut it: the extension kept the first 50,000
+ * characters and added its own marker (`truncate`, `.pi/extensions/mirror-logger.ts`),
+ * so the closing tag never arrived. Pi's opening lines, then an ending only the
+ * logger writes: no person types that. Whatever followed the block was cut with it.
+ */
+const PI_SKILL_WRAPPER_CUT =
+  /^<skill name="([^"]+)" location="[^"]*">\nReferences are relative to [^\n]*\n\n[\s\S]*\n\[… truncated\]$/;
+
+/** The one skill whose turn is conversation: its question is the turn. */
+const MIRROR_SKILL = "mm-mirror";
+
+export interface StoredSkillTurn {
+  messageId: string;
+  conversationId: string;
+  skill: string;
+  /** What followed the block, trimmed; "" when nothing did. */
+  tail: string;
+  /** The Mirror question the row keeps, or null when the row goes. */
+  question: string | null;
+}
+
+export interface ConversationToDelete {
+  id: string;
+  title: string | null;
+  messageCount: number;
+  startedAt: string;
+}
+
+export interface ConversationToRetitle {
+  id: string;
+  title: string;
+  newTitle: string;
+}
+
+export interface SkillTurnRepairPlan {
+  /** Every stored skill turn, in the order the rows were written. */
+  turns: StoredSkillTurn[];
+  /** The Mirror questions: each row keeps its question. */
+  kept: StoredSkillTurn[];
+  /** Every other skill turn: each row goes. */
+  removed: StoredSkillTurn[];
+  conversationsToDelete: ConversationToDelete[];
+  conversationsToRetitle: ConversationToRetitle[];
+}
+
+export interface SkillTurnRepairResult {
+  kept: number;
+  removed: number;
+  conversationsDeleted: number;
+  /** Messages that went with the deleted conversations, beyond the removed turns. */
+  messagesDeletedWithConversations: number;
+  conversationsRetitled: number;
+}
+
+/** The set the transaction found is not the set the person was shown. */
+export class SkillTurnRepairSetMovedError extends Error {
+  constructor() {
+    super("the stored skill turns changed since they were listed");
+    this.name = "SkillTurnRepairSetMovedError";
+  }
+}
+
+/** The skill turn a stored row holds, or null when the row is not Pi's whole wrapper. */
+export function readSkillTurn(content: string): { skill: string; tail: string } | null {
+  const match = PI_SKILL_WRAPPER.exec(content);
+  if (match) return { skill: match[1] as string, tail: (match[2] ?? "").trim() };
+  const cut = PI_SKILL_WRAPPER_CUT.exec(content);
+  if (cut) return { skill: cut[1] as string, tail: "" };
+  return null;
+}
+
+function isManualTitle(rawMetadata: unknown): boolean {
+  if (typeof rawMetadata !== "string") return false;
+  try {
+    const metadata = JSON.parse(rawMetadata) as Record<string, unknown>;
+    return metadata.title_status === "manual" || metadata.title_source === "manual";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * What the repair would change, decided once for the dry run and again inside the
+ * repair's transaction.
+ */
+export function planSkillTurnRepair(db: Database): SkillTurnRepairPlan {
+  // SQL narrows to the prefix; `readSkillTurn` decides on the whole wrapper.
+  const candidates = db
+    .prepare(
+      `SELECT m.id, m.conversation_id, m.content
+         FROM messages m JOIN conversations c ON c.id = m.conversation_id
+        WHERE c.interface = 'pi' AND m.role = 'user' AND substr(m.content, 1, 13) = '<skill name="'
+        ORDER BY m.created_at, m.rowid`,
+    )
+    .all();
+  const turns: StoredSkillTurn[] = [];
+  for (const row of candidates) {
+    const read = readSkillTurn(String(row.content));
+    if (read === null) continue;
+    const question = read.skill === MIRROR_SKILL && read.tail !== "" ? read.tail : null;
+    turns.push({
+      messageId: String(row.id),
+      conversationId: String(row.conversation_id),
+      skill: read.skill,
+      tail: read.tail,
+      question,
+    });
+  }
+  const kept = turns.filter((turn) => turn.question !== null);
+  const removed = turns.filter((turn) => turn.question === null);
+  const removedIds = new Set(removed.map((turn) => turn.messageId));
+  const keptQuestion = new Map(kept.map((turn) => [turn.messageId, turn.question as string]));
+
+  // A conversation the repair leaves with no user turn goes. Otherwise a block-born
+  // title is rebuilt from its first remaining user turn that is not a command: a
+  // command is not conversation (`commandTurn.ts`), so it names one only when
+  // nothing else remains.
+  const touched = [...new Set(turns.map((turn) => turn.conversationId))];
+  const userRows = db.prepare(
+    `SELECT id, content FROM messages WHERE conversation_id = ? AND role = 'user'
+      ORDER BY created_at, rowid`,
+  );
+  const remainingUserTurns = (conversationId: string, removing: ReadonlySet<string>): string[] =>
+    userRows
+      .all(conversationId)
+      .filter((row) => !removing.has(String(row.id)))
+      .map((row) => keptQuestion.get(String(row.id)) ?? String(row.content))
+      .filter((content) => content.trim() !== "");
+  const titleSource = (remaining: readonly string[]): string | null =>
+    remaining.find((content) => !isCommandTurn(content)) ?? remaining[0] ?? null;
+  const remainingFirstUser = new Map<string, string | null>();
+  for (const conversationId of touched) {
+    remainingFirstUser.set(
+      conversationId,
+      titleSource(remainingUserTurns(conversationId, removedIds)),
+    );
+  }
+
+  const conversationRow = db.prepare(
+    `SELECT id, title, started_at, metadata,
+            (SELECT COUNT(*) FROM messages m WHERE m.conversation_id = c.id) AS message_count
+       FROM conversations c WHERE id = ?`,
+  );
+  const conversationsToDelete: ConversationToDelete[] = [];
+  for (const conversationId of touched) {
+    if (remainingFirstUser.get(conversationId) !== null) continue;
+    const row = conversationRow.get(conversationId);
+    if (!row) continue;
+    conversationsToDelete.push({
+      id: conversationId,
+      title: typeof row.title === "string" ? row.title : null,
+      messageCount: Number(row.message_count),
+      startedAt: String(row.started_at),
+    });
+  }
+  const deleting = new Set(conversationsToDelete.map((item) => item.id));
+
+  // Titles born of a block, in any Pi conversation that stays, unless set by hand.
+  const titled = db
+    .prepare(
+      `SELECT id, title, metadata FROM conversations
+        WHERE interface = 'pi' AND lower(substr(trim(title), 1, 6)) = '<skill'
+        ORDER BY started_at, id`,
+    )
+    .all();
+  const conversationsToRetitle: ConversationToRetitle[] = [];
+  for (const row of titled) {
+    const id = String(row.id);
+    if (deleting.has(id) || isManualTitle(row.metadata)) continue;
+    const source = remainingFirstUser.has(id)
+      ? remainingFirstUser.get(id)
+      : titleSource(remainingUserTurns(id, new Set()));
+    if (!source || readSkillTurn(source) !== null) continue;
+    const newTitle = generateTitle(source).trim();
+    if (newTitle === "") continue;
+    conversationsToRetitle.push({ id, title: String(row.title), newTitle });
+  }
+
+  return { turns, kept, removed, conversationsToDelete, conversationsToRetitle };
+}
+
+/** One string that names everything a plan changes, to compare a plan with the one shown. */
+export function skillTurnRepairKey(plan: SkillTurnRepairPlan): string {
+  const sorted = (values: readonly string[]) => [...values].sort().join(",");
+  return [
+    sorted(plan.kept.map((turn) => turn.messageId)),
+    sorted(plan.removed.map((turn) => turn.messageId)),
+    sorted(plan.conversationsToDelete.map((item) => item.id)),
+    sorted(plan.conversationsToRetitle.map((item) => `${item.id}=${item.newTitle}`)),
+  ].join("|");
+}
+
+/**
+ * Repair what the plan names, in one transaction: all or nothing. The plan is
+ * decided again inside the transaction and must be the one the person was shown
+ * (`expectedKey`); if it moved, nothing changes.
+ */
+export function applySkillTurnRepair(
+  db: WritableDatabase,
+  expectedKey: string,
+): SkillTurnRepairResult {
+  return withTransaction(db, () => {
+    const plan = planSkillTurnRepair(db);
+    if (skillTurnRepairKey(plan) !== expectedKey) throw new SkillTurnRepairSetMovedError();
+    const keepQuestion = db.prepare("UPDATE messages SET content = ? WHERE id = ?");
+    for (const turn of plan.kept) keepQuestion.run(turn.question as string, turn.messageId);
+    const removeTurn = db.prepare("DELETE FROM messages WHERE id = ?");
+    for (const turn of plan.removed) removeTurn.run(turn.messageId);
+    const remainingMessages = db.prepare(
+      "SELECT COUNT(*) AS n FROM messages WHERE conversation_id = ?",
+    );
+    let messagesDeletedWithConversations = 0;
+    for (const item of plan.conversationsToDelete) {
+      messagesDeletedWithConversations += Number(remainingMessages.get(item.id)?.n ?? 0);
+      deleteConversation(db, item.id);
+    }
+    for (const item of plan.conversationsToRetitle) setProvisionalTitle(db, item.id, item.newTitle);
+    return {
+      kept: plan.kept.length,
+      removed: plan.removed.length,
+      conversationsDeleted: plan.conversationsToDelete.length,
+      messagesDeletedWithConversations,
+      conversationsRetitled: plan.conversationsToRetitle.length,
+    };
+  });
+}

package/ts/src/frontDoor/cli.ts

@@ -22,6 +22,7 @@
 import { accessSync, constants, existsSync, readFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
 import { pathToFileURL } from "node:url";
+import { createZipBackup } from "#backup/zipBackup.ts";
 import {
   AppendRejectedError,
   type AppendRejectionReason,
@@ -68,6 +69,7 @@ import {
   JOURNAL_TRANSPORT,
   WEEK_PLAN_TRANSPORT,
 } from "#providers/transport.ts";
+import { verifyBackupArchive } from "#runtime/backup.ts";
 import { exitQuietlyOnBrokenPipe } from "#runtime/brokenPipe.ts";
 import {
   configFilePath,
@@ -107,6 +109,10 @@ import { runBackupRoute, runRepairEncodingRoute } from "./dbSafetyToolsRoute.ts"
 import { defaultExploreRouteDeps, runExploreRoute } from "./exploreRoute.ts";
 import { frontDoorLogPath, logFrontDoor } from "./frontDoorLog.ts";
 import { applyIdentitySet } from "./identityWrite.ts";
+import {
+  isImportedConversationsCommand,
+  runImportedConversationsRoute,
+} from "./importedConversationsRoute.ts";
 import { applyJourneySetPath } from "./journeyWriteRoute.ts";
 import { openLiveWriteDatabase } from "./liveBackup.ts";
 import {
@@ -166,6 +172,7 @@ import { runRuntimeReadRoute, runWelcomeRoute } from "./runtimeRoute.ts";
 import { runMemorySearchRoute } from "./searchRoute.ts";
 import { resolveSeedPaths } from "./seedPaths.ts";
 import { isSessionStartWelcome, runSessionStartWelcomeRoute } from "./sessionStartWelcomeRoute.ts";
+import { isSkillTurnsCommand, runSkillTurnsRoute } from "./skillTurnsRoute.ts";
 import { runSoulRoute } from "./soulRoute.ts";
 import {
   applyTasksImport,
@@ -1759,6 +1766,37 @@ async function dispatchTs(argv: readonly string[]): Promise<number | DispatchOut
   if (argv[0] === "soul") return runSoulWrite(argv);
   if (argv[0] === "explore") return runExploreWrite(argv);
   if (isConversationsAppend(argv)) return runConversationsAppend(argv);
+  // CR154: allowlisted by name, like `append`, so the listing never answers it.
+  // The listing and the dry run read; `--apply` writes behind the pre-write
+  // backup, after its own dated, verified archive.
+  if (isImportedConversationsCommand(argv)) {
+    return runImportedConversationsRoute(argv, {
+      withReadOnlyDatabase: (read) => withMirrorReadDb(argv, read),
+      withLiveWriteDatabase: (write) => {
+        const dbPath = resolveDbPathForCli(argv.slice(1));
+        if (dbPath === null) return 2;
+        return withLiveWriteDbAt(dbPath, "conversations", (db) => write(db, dbPath));
+      },
+      backup: (dbPath) =>
+        createZipBackup({ dbPath, mirrorHome: dirname(dbPath), backupDir: null, silent: true }),
+      verifyBackup: (archive) => verifyBackupArchive(archive),
+    });
+  }
+  // CR160: the same shape -- the dry run reads; `--apply` writes behind the
+  // pre-write backup, after its own dated, verified archive.
+  if (isSkillTurnsCommand(argv)) {
+    return runSkillTurnsRoute(argv, {
+      withReadOnlyDatabase: (read) => withMirrorReadDb(argv, read),
+      withLiveWriteDatabase: (write) => {
+        const dbPath = resolveDbPathForCli(argv.slice(1));
+        if (dbPath === null) return 2;
+        return withLiveWriteDbAt(dbPath, "conversations", (db) => write(db, dbPath));
+      },
+      backup: (dbPath) =>
+        createZipBackup({ dbPath, mirrorHome: dirname(dbPath), backupDir: null, silent: true }),
+      verifyBackup: (archive) => verifyBackupArchive(archive),
+    });
+  }
   // CV22.DS7.TS1: the DB safety tools. `backup` never opens or bootstraps the
   // database; `repair-encoding --apply` rides the live-write seam.
   if (argv[0] === "backup") {