mirror-mind 0.36.2 → 0.37.0

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/db/migrateOnOpen.ts

@@ -132,7 +132,7 @@ function appliedMigrationIds(dbPath: string, options: OpenOptions): Set<string>
  * No split any more. Until CV22.DS10.TS5 this separated the TS-authored tail
  * from Python-authored ids and declined the whole thing whenever a Python one
  * was pending -- correct while Python could still apply them. TypeScript
- * carries all seventeen and is the only engine left, so every pending known
+ * carries all of them and is the only engine left, so every pending known
  * migration is simply pending.
  */
 function pendingMigrations(applied: Set<string>): string[] {

package/ts/src/db/migrations.ts

@@ -514,6 +514,21 @@ function migrateJourneyParentColumn(db: WritableDatabase): void {
   );
 }
 
+/**
+ * 018 (CV9.DS8.US5) -- `runtime_sessions.hook_injected` goes. It was the
+ * Claude-family inject hook's once-per-session flag (CV21.DS2); US4 handed the
+ * hook to the one doorman and retired its last reader, and the four writers
+ * that still filled it were carried as one debt item, paid here with the
+ * column. Guarded on the column's presence: a fresh database's `createSchema`
+ * no longer has it, and a re-run finds nothing to drop. `DROP COLUMN` is
+ * SQLite 3.35; the engine ships 3.54.
+ */
+function migrateDropHookInjected(db: WritableDatabase): void {
+  if (!tableExists(db, "runtime_sessions")) return;
+  if (!tableColumns(db, "runtime_sessions").has("hook_injected")) return;
+  db.exec("ALTER TABLE runtime_sessions DROP COLUMN hook_injected");
+}
+
 export type MigrationApply = (db: WritableDatabase) => void;
 
 export const MIGRATIONS: readonly (readonly [string, MigrationApply])[] = [
@@ -534,6 +549,7 @@ export const MIGRATIONS: readonly (readonly [string, MigrationApply])[] = [
   ["015_create_builder_workbench", migrateCreateBuilderWorkbench],
   ["016_builder_workbench_display_codes", migrateBuilderWorkbenchDisplayCodes],
   ["017_journey_parent_column", migrateJourneyParentColumn],
+  ["018_drop_hook_injected", migrateDropHookInjected],
 ];
 
 /**

package/ts/src/db/schema.ts

@@ -84,7 +84,6 @@ CREATE TABLE IF NOT EXISTS runtime_sessions (
     mirror_active INTEGER NOT NULL DEFAULT 0,
     persona TEXT,
     journey TEXT,
-    hook_injected INTEGER NOT NULL DEFAULT 0,
     active INTEGER NOT NULL DEFAULT 1,
     started_at TEXT NOT NULL,
     updated_at TEXT NOT NULL,

package/ts/src/db/schemaInventorySnapshot.ts

@@ -1925,13 +1925,6 @@ export const SCHEMA_INVENTORY_SNAPSHOT: SchemaInventory = {
           "pk": 0,
           "type": "TEXT"
         },
-        {
-          "dflt_value": "0",
-          "name": "hook_injected",
-          "notnull": 1,
-          "pk": 0,
-          "type": "INTEGER"
-        },
         {
           "dflt_value": "1",
           "name": "active",
@@ -1979,7 +1972,7 @@ export const SCHEMA_INVENTORY_SNAPSHOT: SchemaInventory = {
         }
       ],
       "sql":
-        "CREATE TABLE runtime_sessions ( session_id TEXT PRIMARY KEY, conversation_id TEXT REFERENCES conversations(id), interface TEXT, mirror_active INTEGER NOT NULL DEFAULT 0, persona TEXT, journey TEXT, hook_injected INTEGER NOT NULL DEFAULT 0, active INTEGER NOT NULL DEFAULT 1, started_at TEXT NOT NULL, updated_at TEXT NOT NULL, closed_at TEXT, metadata TEXT)"
+        "CREATE TABLE runtime_sessions ( session_id TEXT PRIMARY KEY, conversation_id TEXT REFERENCES conversations(id), interface TEXT, mirror_active INTEGER NOT NULL DEFAULT 0, persona TEXT, journey TEXT, active INTEGER NOT NULL DEFAULT 1, started_at TEXT NOT NULL, updated_at TEXT NOT NULL, closed_at TEXT, metadata TEXT)"
     },
     "tasks": {
       "columns": [

package/ts/src/db/schemaState.ts

@@ -47,6 +47,8 @@ export const KNOWN_MIGRATION_IDS: readonly string[] = [
   "016_builder_workbench_display_codes",
   // TS-authored, no Python counterpart (CV22.DS6.US2 — first TS ⊋ Python migration).
   "017_journey_parent_column",
+  // CV9.DS8.US5: the inject hook's once-per-session flag, without a reader since US4.
+  "018_drop_hook_injected",
 ];
 
 /**

package/ts/src/db/schemaTsDivergence.ts

@@ -17,6 +17,15 @@ const TS_ONLY_COLUMNS: Record<string, ColumnInventory[]> = {
   identity: [{ name: "parent_journey", type: "TEXT", notnull: 0, dflt_value: null, pk: 0 }],
 };
 
+/**
+ * Columns the Python snapshot has that TS has dropped (CV9.DS8.US5, migration
+ * 018): `runtime_sessions.hook_injected`, the inject hook's once-per-session
+ * flag, without a reader since CV9.DS8.US4.
+ */
+const TS_REMOVED_COLUMNS: Record<string, string[]> = {
+  runtime_sessions: ["hook_injected"],
+};
+
 /** Indexes TS creates that the Python snapshot does not have. */
 const TS_ONLY_INDEXES: Record<string, { table: string; unique: number; columns: string[] }> = {
   idx_identity_parent_journey: { table: "identity", unique: 0, columns: ["parent_journey"] },
@@ -46,21 +55,33 @@ export function diffTsInventoryAgainstSnapshot(
     const actualTable = actual.tables[name];
     if (!actualTable) continue;
     const additions = TS_ONLY_COLUMNS[name] ?? [];
-    const expectedColumns = [...snapshot.tables[name].columns, ...additions];
+    const removals = TS_REMOVED_COLUMNS[name] ?? [];
+    const expectedColumns = [
+      ...snapshot.tables[name].columns.filter((column) => !removals.includes(column.name)),
+      ...additions,
+    ];
     if (!isDeepStrictEqual(actualTable.columns, expectedColumns)) {
-      problems.push(`tables[${name}].columns differ from snapshot + enumerated TS-only additions`);
+      problems.push(
+        `tables[${name}].columns differ from snapshot + enumerated TS-only additions and removals`,
+      );
     }
     if (!isDeepStrictEqual(actualTable.foreign_keys, snapshot.tables[name].foreign_keys)) {
       problems.push(`tables[${name}].foreign_keys differ from snapshot`);
     }
-    if (additions.length > 0) {
+    if (additions.length > 0 || removals.length > 0) {
       // The raw CREATE TABLE text diverges by exactly these columns; assert each
-      // added column name is present rather than reproduce SQLite's stored text.
+      // added column name is present and each removed one absent, rather than
+      // reproduce SQLite's stored text.
       for (const column of additions) {
         if (!(actualTable.sql ?? "").includes(column.name)) {
           problems.push(`tables[${name}].sql is missing TS-only column ${column.name}`);
         }
       }
+      for (const column of removals) {
+        if ((actualTable.sql ?? "").includes(column)) {
+          problems.push(`tables[${name}].sql still carries the dropped column ${column}`);
+        }
+      }
     } else if (!isDeepStrictEqual(actualTable.sql, snapshot.tables[name].sql)) {
       problems.push(`tables[${name}].sql differs from snapshot`);
     }

package/ts/src/frontDoor/cli.ts

@@ -52,6 +52,7 @@ import { setIdentity } from "#identity/setIdentity.ts";
 import { IdentityRootExistsError, initUserHome, TemplatesNotFoundError } from "#init/init.ts";
 import { JOURNEY_PATH_LAYER } from "#journey/journeyStatus.ts";
 import { JourneyNotFoundError } from "#journey/journeyWrite.ts";
+import { environmentSessionId } from "#mirror/runtimeSession.ts";
 import {
   CallOutcomeTally,
   formatCallOutcome,
@@ -116,9 +117,11 @@ import {
 import { applyJourneySetPath } from "./journeyWriteRoute.ts";
 import { openLiveWriteDatabase } from "./liveBackup.ts";
 import {
+  isMirrorDoorman,
   isMirrorWrite,
   isModeWrite,
   mirrorDeactivateMissingSession,
+  runMirrorDoormanRoute,
   runMirrorRead,
   runMirrorWriteRoute,
   runModeRead,
@@ -172,6 +175,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,
@@ -1476,7 +1480,10 @@ function runShadowWrite(argv: readonly string[]): number | Promise<number> {
   return runShadowScanWrite(argv); // "scan"
 }
 
-function withMirrorReadDb(argv: readonly string[], read: (db: Database) => number): number {
+function withMirrorReadDb<T = number>(
+  argv: readonly string[],
+  read: (db: Database) => T,
+): T | number {
   const dbPath = resolveDbPathForCli(argv.slice(1));
   if (dbPath === null) return 2;
   ensureDatabaseReadyForCli(dbPath, argv[0] ?? null);
@@ -1538,6 +1545,35 @@ function runModeWrite(argv: readonly string[]): Promise<number> {
   return withMirrorWriteDb(argv, (db) => runModeWriteRoute(db, argv));
 }
 
+/**
+ * `mirror doorman` (CV9.DS8.TS2): decide on a read-only handle, write behind
+ * the pre-write snapshot only for a turn that delivers. The memory scores a
+ * delta turn ranks go to the front-door log as numbers -- content-free -- the
+ * hybrid and the semantic the threshold reads (US5), every ranked memory's,
+ * so the threshold is read against measurement.
+ */
+function runMirrorDoorman(argv: readonly string[]): Promise<number> {
+  const reporter = outcomeReporter(argv, "reception");
+  const logPath = resolveLogPath(argv);
+  return runMirrorDoormanRoute(argv, {
+    withReadOnlyDatabase: (read) => withMirrorReadDb(argv, read),
+    withLiveWriteDatabase: (write) => withMirrorWriteDb(argv, write),
+    onReceptionOutcome: reporter.onOutcome,
+    onMemoryScores: (scores) =>
+      logFrontDoor(logPath, {
+        command: "mirror",
+        route: "ts",
+        exitCode: 0,
+        detail:
+          `doorman memory_scores=${scores.map((s) => s.score.toFixed(3)).join(",")}` +
+          ` memory_semantic=${scores.map((s) => s.semantic.toFixed(3)).join(",")}`,
+      }),
+  }).then((exitCode) => {
+    if (reporter.calls > 0) reporter.logSummary();
+    return exitCode;
+  });
+}
+
 function runSoulWrite(argv: readonly string[]): Promise<number> {
   return withMirrorWriteDb(argv, (db) => runSoulRoute(db, argv));
 }
@@ -1738,7 +1774,11 @@ async function dispatchTs(argv: readonly string[]): Promise<number | DispatchOut
       createLoadRuntime: (db, dbPath, ignoreProductionRole) =>
         createBuildLoadRuntime({ db, dbPath, ignoreProductionRole }),
       nowIso,
-      environmentSessionId: process.env.MIRROR_SESSION_ID ?? null,
+      // The session the harness named -- MIRROR_SESSION_ID, else Claude Code's or
+      // Codex's own -- the same reader the mirror route uses (CV9.DS8.US4: read
+      // MIRROR_SESSION_ID alone, a Builder switch on Claude Code stamped a guessed
+      // session and the doorman never saw it).
+      environmentSessionId: environmentSessionId(process.env),
     });
   }
   if (isInit(argv)) return runInit(argv);
@@ -1758,6 +1798,7 @@ async function dispatchTs(argv: readonly string[]): Promise<number | DispatchOut
   if (argv[0] === "descriptor" && argv[1] === "generate") return runDescriptorContentRoute(argv);
   if (isConsolidateSubcommandWrite(argv)) return runConsolidateWrite(argv);
   if (isShadowSubcommandWrite(argv)) return runShadowWrite(argv);
+  if (isMirrorDoorman(argv)) return runMirrorDoorman(argv);
   if (isMirrorWrite(argv)) return runMirrorWrite(argv);
   if (isModeWrite(argv)) return runModeWrite(argv);
   // CV22.DS7.US6: the Soul ritual; `routing.ts` allowlists its subcommands by
@@ -1781,6 +1822,21 @@ async function dispatchTs(argv: readonly string[]): Promise<number | DispatchOut
       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") {

package/ts/src/frontDoor/conversationLoggerRoute.ts

@@ -35,6 +35,24 @@ function subcommandOf(args: readonly string[]): string {
  */
 const readStdin = takeStdin;
 
+/**
+ * `--payload <json>`: a hook subcommand's payload in argv rather than on stdin
+ * (CR160). Pi's extension reaches the core through `pi.exec`, which cannot write
+ * a child's stdin, and since CR160 it sends Pi's turns to `user-prompt` and
+ * `stop`. Pi's prompt has travelled in argv since CV9, as `log-user`'s argument,
+ * so this is the exposure Pi always had, no wider (`stdinSource.ts`). The option
+ * is taken out of argv before the subcommand sees it, and a route given one
+ * never reads fd 0: a stdin pipe nobody closes cannot hang it.
+ */
+function takePayloadOption(args: readonly string[]): { payload: string | null; rest: string[] } {
+  const index = args.indexOf("--payload");
+  if (index === -1 || index + 1 >= args.length) return { payload: null, rest: [...args] };
+  return {
+    payload: args[index + 1] as string,
+    rest: [...args.slice(0, index), ...args.slice(index + 2)],
+  };
+}
+
 /**
  * Where the route's lines go. The default is the process's own streams; the
  * `session-start --welcome` composite (CV9.E2.S32) captures them instead, so
@@ -51,7 +69,7 @@ export async function runConversationLoggerRoute(
   argv: readonly string[],
   io: ConversationLoggerRouteIo = {},
 ): Promise<number> {
-  const args = argv.slice(1);
+  const { payload, rest: args } = takePayloadOption(argv.slice(1));
   const subcommand = subcommandOf(args);
   const runtime = createLoggerRuntime({
     db,
@@ -73,7 +91,7 @@ export async function runConversationLoggerRoute(
       }),
   });
   const result = await runConversationLoggerCommand(db, args, runtime, {
-    stdin: STDIN_SUBCOMMANDS.has(subcommand) ? readStdin() : undefined,
+    stdin: STDIN_SUBCOMMANDS.has(subcommand) ? (payload ?? readStdin()) : undefined,
   });
   const out = io.stdout ?? ((line: string) => process.stdout.write(`${line}\n`));
   const err = io.stderr ?? ((line: string) => process.stderr.write(`${line}\n`));

package/ts/src/frontDoor/exploreRoute.ts

@@ -61,7 +61,7 @@ import { getIdentityContent } from "#identity/identityRead.ts";
 import { getProjectPath } from "#journey/journeyStatus.ts";
 import { loadMirrorContext } from "#mirror/context.ts";
 import { persistStickyDefaults } from "#mirror/orchestration.ts";
-import { resolveRuntimeSessionId } from "#mirror/runtimeSession.ts";
+import { environmentSessionId, resolveRuntimeSessionId } from "#mirror/runtimeSession.ts";
 import { activateOperatingMode, deactivateOperatingMode } from "#mode/operatingMode.ts";
 import { newId, nowIso } from "#util/pyGenerators.ts";
 import { optionValue, stripOptionWithValue } from "./args.ts";
@@ -430,7 +430,7 @@ async function runPromote(
   // `--session-id`, which its promote parser does not even accept.
   const result = await runBuildLoad(
     db,
-    { slug, environmentSessionId: process.env.MIRROR_SESSION_ID ?? null },
+    { slug, environmentSessionId: environmentSessionId(process.env) },
     runtime.deps,
   );
   process.stderr.write(result.stderr);