mirror-mind 0.33.3 → 0.34.0

package/ts/src/frontDoor/cli.ts

@@ -43,7 +43,7 @@ import { type Database, openDatabaseReadOnly, type WritableDatabase } from "#db/
 import { ensureDatabaseReady } from "#db/readyOnOpen.ts";
 import { assertSchemaState, SchemaStateError } from "#db/schemaState.ts";
 import { allDescriptors, descriptorsByLayer } from "#descriptor/descriptorRead.ts";
-import { newIdentityKeyProblem } from "#identity/identityKey.ts";
+import { newIdentityKeyProblem, newUserNameProblem } from "#identity/identityKey.ts";
 import { identityRowExists, listIdentityByLayer } from "#identity/identityRead.ts";
 import { listJourneysForListCommand } from "#identity/journeyListing.ts";
 import { listPersonas } from "#identity/personaListing.ts";
@@ -885,10 +885,20 @@ function isInit(argv: readonly string[]): boolean {
  */
 function runInit(argv: readonly string[], env: NodeJS.ProcessEnv = process.env): number {
   const user = argv[1];
-  if (!user) {
+  // A word that starts with `-` is a flag this command does not have, not a
+  // user: `init --help` once created a home named `--help`.
+  if (!user || user.startsWith("-")) {
     console.error("Usage: init <user>");
     return 2;
   }
+  // And any other word is a key: the home's directory name and the value of
+  // MIRROR_USER in the wiring commands printed below. CR104's rule for slugs
+  // and persona ids, asked before anything is created (CR141).
+  const problem = newUserNameProblem(user);
+  if (problem !== null) {
+    console.error(`Error: ${problem}`);
+    return 2;
+  }
   try {
     const identityRoot = initUserHome(user);
     const mirrorHome = dirname(identityRoot);

package/ts/src/frontDoor/routing.ts

@@ -373,10 +373,11 @@ const TS_CONVERSATION_LOGGER_SUBCOMMANDS = new Set([
   // CV21.DS2.US8: the Stop hook's reply, deterministic like user-prompt.
   "stop",
   "discard-current",
-  // US10 slice F, group 2 (need slice E): diagnose, dry-run repair, Codex import.
+  // US10 slice F, group 2 (need slice E): diagnose and dry-run repair. (The
+  // Codex import routed here too, until CV21.DS4.TS5 retired it with the
+  // v0.32.1 Codex wrapper.)
   "diagnose-journeys",
   "repair-journeys",
-  "backfill-codex-session",
 ]);
 
 // CV22.DS7.US10 slice F. These reach Python's `end_conversation`, which runs

package/ts/src/frontDoor/runtimeRoute.ts

@@ -26,6 +26,7 @@ import {
   diagnoseRuntime,
   hookFailureFindings,
   hookNodeFindings,
+  pluginWiringFindings,
   probeModelPins,
   renderRuntimeDiagnosis,
   rootStateFindings,
@@ -301,12 +302,19 @@ export async function runRuntimeReadRoute(
   if (subcommand === "diagnose") {
     // The install's own tree, so its worktree findings are Mirror's and never
     // the cwd project's (CR138).
+    const install = io.install ?? detectThisInstall();
     const report = buildRuntimeStatus({
       mirrorHome: optionValue(args, "--mirror-home"),
       env,
       version,
-      install: io.install ?? detectThisInstall(),
+      install,
     });
+    const installRoot =
+      install.kind === "clone"
+        ? install.repository
+        : install.kind === "package"
+          ? install.root
+          : null;
     const findings = [
       ...diagnoseRuntime(report, inspectGitWorktree(report.git.repository)),
       ...rootStateFindings(homesRoot(env)),
@@ -324,6 +332,10 @@ export async function runRuntimeReadRoute(
           return false;
         }
       }),
+      // CV21.DS4.TS6: the plugin wiring. Codex's versioned cache goes stale
+      // after an npm update; Claude Code's link can dangle. Absence is not
+      // drift, so an unwired machine stays green.
+      ...pluginWiringFindings(installRoot, env),
       // No catalog provider until DS8: inconclusive, which is also the
       // oracle's answer when it cannot reach OpenRouter.
       ...(await probeModelPins(null, "")),

package/ts/src/guards/claudePlugin.ts

@@ -1,5 +1,6 @@
-// Generate the canonical Mirror Mind Claude plugin (manifest + skills), and the
-// Claude Code copies of Pi-sourced skills.
+// Generate the canonical Mirror Mind Claude plugin (manifest + skills), the
+// Codex marketplace that names it (CV21.DS4.US1), and the Claude Code copies of
+// Pi-sourced skills.
 //
 // The Node port of `src/memory/plugins/claude.py` and its wrapper
 // `scripts/build_claude_plugin.py` (CV22.DS10.TS5, slice B).
@@ -43,6 +44,12 @@ export const SKILLS_SOURCE_DIR = ".claude/skills";
 export const PLUGIN_DIR = "plugins/mirror-mind";
 export const SKILL_FILENAME = "SKILL.md";
 
+/**
+ * Where Codex reads a marketplace from, under the marketplace root, which for
+ * the shipped package is the package root (CV21.DS4.US1; DS12.TS2 static 5).
+ */
+export const MARKETPLACE_PATH = ".agents/plugins/marketplace.json";
+
 /** A file the generator owns, addressed relative to the repo root. */
 export interface GeneratedFile {
   readonly relativePath: string;
@@ -142,6 +149,35 @@ export function manifestJson(version: string): string {
   return `${JSON.stringify(buildManifest(version), null, 2)}\n`;
 }
 
+/**
+ * The Codex marketplace the package ships (CV21.DS4.US1).
+ *
+ * `codex plugin marketplace add <package root>` reads it, and
+ * `codex plugin add mirror-mind@mirror-mind` copies the plugin it names into
+ * Codex's cache, at the version the plugin manifest carries: the marketplace
+ * itself has none. One local source, the plugin directory, relative to the
+ * root. Generated beside the manifest so the plugin's name lives in one
+ * constant and `--check` guards both files.
+ */
+export function buildMarketplace(): Record<string, unknown> {
+  return {
+    name: PLUGIN_NAME,
+    owner: { name: PLUGIN_AUTHOR },
+    plugins: [
+      {
+        name: PLUGIN_NAME,
+        source: { source: "local", path: `./${PLUGIN_DIR}` },
+        description: PLUGIN_DESCRIPTION,
+      },
+    ],
+  };
+}
+
+/** The marketplace as deterministic JSON text. */
+export function marketplaceJson(): string {
+  return `${JSON.stringify(buildMarketplace(), null, 2)}\n`;
+}
+
 /**
  * The skill markdown file, matching `skill.md` case-insensitively.
  *
@@ -232,6 +268,7 @@ export function planGeneratedFiles(repoRoot: string): GeneratedFile[] {
       relativePath: join(PLUGIN_DIR, ".claude-plugin", "plugin.json"),
       content: manifestJson(version),
     },
+    { relativePath: MARKETPLACE_PATH, content: marketplaceJson() },
     ...claudeCopies.values(),
     ...[...pluginSkills].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)).map(([, file]) => file),
   ];

package/ts/src/guards/packContents.ts

@@ -28,7 +28,6 @@ export const ALLOWED_PREFIXES: readonly string[] = [
   ".claude/hooks/",
   ".gemini/hooks/",
   "plugins/mirror-mind/",
-  "scripts/codex-hooks/",
 ];
 
 export const ALLOWED_FILES: readonly string[] = [
@@ -37,7 +36,9 @@ export const ALLOWED_FILES: readonly string[] = [
   "LICENSE",
   "AGENTS.md",
   "ts/README.md",
-  "scripts/codex-mirror.sh",
+  // CV21.DS4.US1: the Codex marketplace, read from the package root. The
+  // `.agents/skills/` symlinks beside it are the checkout's and stay out.
+  ".agents/plugins/marketplace.json",
 ];
 
 /** Files that must be in every tarball: the entries and one of each runtime's wiring. */
@@ -57,8 +58,7 @@ export const REQUIRED_FILES: readonly string[] = [
   ".claude/hooks/session-start.sh",
   ".gemini/hooks/session-start.sh",
   "plugins/mirror-mind/hooks/hooks.json",
-  "scripts/codex-hooks/session-start.sh",
-  "scripts/codex-mirror.sh",
+  ".agents/plugins/marketplace.json",
 ];
 
 /** Prefixes that must have at least one file: content the program reads at runtime. */

package/ts/src/guards/retiredSurfaces.ts

@@ -460,6 +460,42 @@ export const RETIRED: readonly RetiredSurface[] = [
     // exploration's record is `docs/project/exploration/es-004-*.md`.
     exemptions: {},
   },
+  {
+    surfaceId: "codex-wrapper",
+    story: "CV21.DS4.TS5",
+    // The v0.32.1 Codex wiring: a wrapper script around the `codex` command,
+    // its two generated hooks, the `codex:*` hook family, and the JSONL
+    // backfill the wrapper drove at exit. Retired once US4 measured Codex at
+    // L4 through the shipped plugin, live: the plugin's Claude-family hooks
+    // log Codex turns as they happen, so nothing re-imports the transcript.
+    // The backfill's only caller was the wrapper's session-end hook, and the
+    // plugin's SessionEnd closes the session without reading it -- the
+    // condition DS4 set for keeping it was not met.
+    absentPaths: [
+      "scripts/codex-mirror.sh",
+      "scripts/codex-hooks/",
+      "ts/src/hooks/codex.ts",
+      "scripts/smoke_codex.sh",
+      "ts/test/fixtures/backfill/codex/",
+    ],
+    // File and route names, never vocabulary: "codex" is a living word (the
+    // plugin serves Codex; `runtimeDetection.ts` labels its payloads).
+    forbiddenPatterns: [
+      "codex-mirror\\.sh",
+      "codex-hooks",
+      "codex:session-(start|end)",
+      "backfill-codex-session",
+      "backfill_codex_session",
+      "backfillCodexSession",
+      "smoke_codex",
+    ],
+    exemptions: {
+      "docs/getting-started.md":
+        "the un-wiring guidance: a user who started codex through the retired wrapper needs its name to undo that wiring",
+      "ts/src/conversation/backfill.ts":
+        "the header names the retired importer to say where it went, beside the Pi importer that stays",
+    },
+  },
   {
     // Not a deleted surface: a retired IDIOM. A URL's pathname is not a
     // filesystem path -- it percent-encodes `Código` and `John Doe`, and on

package/ts/src/hooks/claude.ts

@@ -87,9 +87,21 @@ export async function claudeStop(stdin: string): Promise<number> {
   return 0;
 }
 
-/** `log-session-end.sh`: close the session, then take the silent backup. */
-export async function claudeSessionEnd(): Promise<number> {
-  await runFrontDoorQuietly("claude:session-end", ["conversation-logger", "session-end"]);
+/**
+ * `log-session-end.sh`: close the session, then take the silent backup.
+ *
+ * The runtime goes along as `--interface`, as Stop's does, for a session row
+ * with no label. On a runtime that bounds this hook (Codex 1 s, Grok 1.5 s)
+ * the close runs no LLM work and the next session start finishes the tail
+ * (CV21.DS4.TS2); both calls then fit inside the bound.
+ */
+export async function claudeSessionEnd(stdin: string): Promise<number> {
+  const runtime = detectHookRuntime(parseHookPayload(stdin).raw);
+  await runFrontDoorQuietly(
+    "claude:session-end",
+    ["conversation-logger", "session-end", "--interface", runtime],
+    { stdin },
+  );
   await runFrontDoorQuietly("claude:session-end", ["backup", "--silent"]);
   return 0;
 }
@@ -204,7 +216,7 @@ export async function claudeHook(name: string): Promise<number> {
     case "stop":
       return claudeStop(readStdin());
     case "session-end":
-      return claudeSessionEnd();
+      return claudeSessionEnd(readStdin());
     case "inject":
       return claudeInject(readStdin());
     default:

package/ts/src/hooks/gemini.ts

@@ -14,6 +14,7 @@
 // `GEMINI_SESSION_ID` still wins over the payload's `session_id`, because the
 // runtime sets it and the payload is the fallback.
 
+import { isCommandTurn } from "#conversation/commandTurn.ts";
 import { parseHookPayload } from "./payload.ts";
 import {
   operatingInstructionsFor,
@@ -37,7 +38,8 @@ export async function geminiLogUser(stdin: string): Promise<number> {
   const payload = parseHookPayload(stdin);
   const sessionId = sessionIdFrom(payload.sessionId);
 
-  if (payload.prompt.startsWith("/")) {
+  // The same rule as the Claude-family logger's (CV21.DS4.TS3): one home.
+  if (isCommandTurn(payload.prompt)) {
     process.stdout.write("{}\n");
     return 0;
   }

package/ts/src/hooks/main.ts

@@ -8,8 +8,10 @@
 //
 //     node ts/src/hooks/main.ts claude:inject
 //
-// Arguments after the name are the hook's own; only the Codex wrapper passes
-// any, since Codex has no hook payload to read (`codex.ts`).
+// Arguments after the name are the hook's own; every current hook reads its
+// payload from stdin and passes none. (The Codex wrapper's `codex:*` entries
+// were the exception, until CV21.DS4.TS5 retired them with the wrapper: the
+// plugin's Claude-family hooks are the Codex path now.)
 //
 // One entry rather than one file per hook because the generated wrappers then
 // differ only in the hook name and their depth, and `hooks.test.ts` asserts
@@ -34,7 +36,6 @@
 import { pathToFileURL } from "node:url";
 import { loadConfiguration, silenceExperimentalWarnings } from "#runtime/config.ts";
 import { claudeHook } from "./claude.ts";
-import { codexSessionEnd, codexSessionStart } from "./codex.ts";
 import {
   geminiLogAssistant,
   geminiLogUser,
@@ -44,7 +45,7 @@ import {
 import { readStdin } from "./payload.ts";
 import { noteHookFailure } from "./runtime.ts";
 
-async function dispatch(name: string, args: readonly string[]): Promise<number> {
+async function dispatch(name: string): Promise<number> {
   const [runtime, hook] = name.split(":");
 
   switch (runtime) {
@@ -64,17 +65,6 @@ async function dispatch(name: string, args: readonly string[]): Promise<number>
           break;
       }
       break;
-    case "codex":
-      // Called by `scripts/codex-mirror.sh` through its generated wrappers.
-      switch (hook) {
-        case "session-start":
-          return codexSessionStart();
-        case "session-end":
-          return codexSessionEnd(args[0] ?? "", args[1] ?? "");
-        default:
-          break;
-      }
-      break;
     default:
       break;
   }
@@ -94,7 +84,7 @@ export async function runAsEntry(rawArgv = process.argv.slice(2)): Promise<numbe
   loadConfiguration({ entryPath: import.meta.filename });
   const name = rawArgv[0] ?? "";
   try {
-    return await dispatch(name, rawArgv.slice(1));
+    return await dispatch(name);
   } catch (error) {
     // The last line of defense. A hook that throws must still not break the
     // turn, and must still leave a trace that it happened.

package/ts/src/identity/identityEdit.ts

@@ -34,6 +34,8 @@ export interface IdentityEditDeps {
   /** The editor argv[0], resolved the way Python resolves it. */
   editor?: string | undefined;
   visual?: string | undefined;
+  /** Decides the editor when neither variable is set. Default: this process's. */
+  platform?: NodeJS.Platform;
   nowIso: () => string;
   /** Injected so a test can watch the buffer without driving a real editor. */
   spawn?: typeof spawnSync;
@@ -42,9 +44,16 @@ export interface IdentityEditDeps {
   newId: () => string;
 }
 
-/** Python's `os.environ.get("EDITOR") or os.environ.get("VISUAL") or "nano"`. */
+/**
+ * Python's `os.environ.get("EDITOR") or os.environ.get("VISUAL") or "nano"`,
+ * with one platform default: Windows has no nano outside Git Bash, so a
+ * PowerShell user with neither variable set saw `Editor 'nano' could not be
+ * started.` Notepad ships with every Windows and blocks until it is closed,
+ * which is what the edit needs. Either variable still wins when set.
+ */
 export function resolveEditor(deps: IdentityEditDeps): string {
-  return deps.editor || deps.visual || "nano";
+  const platform = deps.platform ?? process.platform;
+  return deps.editor || deps.visual || (platform === "win32" ? "notepad" : "nano");
 }
 
 /**

package/ts/src/identity/identityKey.ts

@@ -44,11 +44,27 @@ export function identityKeyBreaksGrammar(layer: string, key: string): boolean {
  */
 export function newIdentityKeyProblem(layer: string, key: string): string | null {
   const keyName = KEY_NAMES.get(layer);
-  if (keyName === undefined || isKebabSlug(key)) return null;
+  if (keyName === undefined) return null;
+  return keyProblem(layer, keyName, key);
+}
+
+/**
+ * Why `init` cannot take `user`, or null when it can (CR141). A user name is
+ * a key of the same kind: it becomes `~/.mirror-minds/<user>` and the value of
+ * `MIRROR_USER` in every wiring command `init` prints. `init ../escaped` once
+ * created `~/escaped`, outside the directory the product owns.
+ */
+export function newUserNameProblem(user: string): string | null {
+  return keyProblem("user home", "user name", user);
+}
+
+/** The one sentence every key refusal is, or null when `key` is a kebab-case slug. */
+function keyProblem(created: string, keyName: string, key: string): string | null {
+  if (isKebabSlug(key)) return null;
   const suggestion = kebabSlug(key);
   const example = suggestion ? `, for example ${pyRepr(suggestion)}` : "";
   return (
-    `no ${layer} was created: ${pyRepr(key)} is not a ${keyName}. ` +
+    `no ${created} was created: ${pyRepr(key)} is not a ${keyName}. ` +
     `Use lowercase letters, digits, and single hyphens, up to 80 characters${example}.`
   );
 }

package/ts/src/providers/config.ts

@@ -120,6 +120,17 @@ export function resolveMaintenanceMaxExtractions(options: ModelPinOptions = {}):
   return parsePythonInt(env.MEMORY_MAINTENANCE_MAX_EXTRACTIONS, 10);
 }
 
+/**
+ * `MIRROR_STALE_ORPHAN_MINUTES` (CV21.DS4.US4): how long an open conversation
+ * may sit idle before session maintenance closes it as an orphan. On a runtime
+ * whose session outlives the TUI (Codex 0.163.0) this is the close path, so an
+ * operator may shorten it; a route sets it to 0 to prove the close now.
+ */
+export function resolveStaleOrphanMinutes(options: ModelPinOptions = {}): number {
+  const env = options.env ?? process.env;
+  return parsePythonInt(env.MIRROR_STALE_ORPHAN_MINUTES, 30);
+}
+
 /** Python `int(os.getenv("MEMORY_EXTRACTION_MAX_ATTEMPTS", "3"))` (CV9.E2.S7). */
 export function resolveExtractionMaxAttempts(options: ModelPinOptions = {}): number {
   const env = options.env ?? process.env;

package/ts/src/runtime/diagnose.ts

@@ -31,7 +31,13 @@ import { identityKeyBreaksGrammar, SLUG_KEYED_LAYERS } from "#identity/identityK
 import { pyRepr, sortByCodePoint } from "#util/pythonText.ts";
 import { configFilePath } from "./config.ts";
 import type { GitWorktreeEntry } from "./git.ts";
+import {
+  claudePluginLinkState,
+  codexPluginCacheState,
+  installedPluginVersion,
+} from "./pluginWiring.ts";
 import type { RuntimeStatusReport } from "./status.ts";
+import { CODEX_PLUGIN_ADD_COMMAND } from "./wiring.ts";
 
 export interface DriftFinding {
   code: string;
@@ -114,7 +120,7 @@ export function rootStateFindings(homesRoot: string): DriftFinding[] {
     detail: path,
     recommendation:
       "relocate into the owning mirror home " +
-      "(see REFERENCE.md \u2014 Relocating legacy root runtime state)",
+      "(see REFERENCE.md — Relocating legacy root runtime state)",
     repair_route: "manual relocation",
   }));
 }
@@ -319,6 +325,60 @@ export function ftsConsistencyFindings(report: RuntimeStatusReport): DriftFindin
   return [];
 }
 
+/** A deferred close tail waits for a session start; after this long, nobody started one. */
+const DEFERRED_CLOSE_TAIL_STALE_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * CV21.DS4.TS2: a runtime that bounds its SessionEnd hook (Codex, Grok) closes
+ * without the LLM tail and flags the conversation for the next session start to
+ * finish. A user whose last session was on such a runtime, and who starts no
+ * session for a day, has memories and titles waiting and nothing saying so:
+ * this is the one place that says so. Younger flags are the normal state
+ * between two sessions, not a finding.
+ */
+export function deferredCloseTailFindings(
+  report: Pick<RuntimeStatusReport, "db_path" | "db_exists">,
+  now: Date = new Date(),
+): DriftFinding[] {
+  if (report.db_path === null || !report.db_exists) return [];
+  let row: { n: number; oldest: string } | null;
+  try {
+    const db = openDatabaseReadOnly(report.db_path);
+    try {
+      const found = db
+        .prepare(
+          `SELECT COUNT(*) AS n, MIN(ended_at) AS oldest FROM conversations
+           WHERE ended_at IS NOT NULL
+             AND json_extract(metadata, '$.close_tail_pending') IS 1`,
+        )
+        .get();
+      row =
+        found && Number(found.n) > 0 ? { n: Number(found.n), oldest: String(found.oldest) } : null;
+    } finally {
+      db.close();
+    }
+  } catch {
+    return [];
+  }
+  if (row === null) return [];
+  const oldest = Date.parse(row.oldest);
+  if (Number.isNaN(oldest) || now.getTime() - oldest < DEFERRED_CLOSE_TAIL_STALE_MS) return [];
+  return [
+    {
+      code: "deferred_close_tails_waiting",
+      severity: "attention",
+      subject: "conversations",
+      detail:
+        `${row.n} conversation(s) closed by a runtime that defers the close tail are waiting ` +
+        `for a session start to finish it; the oldest ended ${row.oldest}`,
+      recommendation:
+        "start a session on any runtime: its maintenance extracts and finalizes them, " +
+        "five per start",
+      repair_route: "session start",
+    },
+  ];
+}
+
 export interface DiagnoseOptions {
   /** Injected only so the 24h boundary is testable; production passes none. */
   now?: Date;
@@ -340,6 +400,7 @@ export function diagnoseRuntime(
   findings.push(...frontDoorErrorFindings(report, options.now));
   findings.push(...ftsConsistencyFindings(report));
   findings.push(...identityKeyFindings(report));
+  findings.push(...deferredCloseTailFindings(report, options.now));
 
   if (report.mirror_home_error) {
     findings.push({
@@ -442,6 +503,59 @@ export function diagnoseRuntime(
   return findings;
 }
 
+/**
+ * The plugin wiring findings (CV21.DS4.TS6; the debt US1 carried). Codex
+ * copies the plugin into a versioned cache, so an npm update leaves it
+ * behind; Claude Code links it in place, so its failure mode is a dangling
+ * link. Absence is not drift: no cache and no link fire nothing, so an
+ * unwired machine stays green.
+ *
+ * The defaulting happens HERE, from the env the caller hands in — CODEX_HOME
+ * else ~/.codex, and ~/.claude — never inside the readers, so every reader
+ * test is hermetic on a maintainer's machine with real wiring
+ * (CR123/128/137/142).
+ */
+export function pluginWiringFindings(
+  installRoot: string | null,
+  env: NodeJS.ProcessEnv,
+): DriftFinding[] {
+  const findings: DriftFinding[] = [];
+  const home = env.HOME?.trim() || null;
+
+  const codexHome = env.CODEX_HOME?.trim() || (home ? join(home, ".codex") : null);
+  const installedVersion = installRoot ? installedPluginVersion(installRoot) : null;
+  if (codexHome && installedVersion) {
+    const cache = codexPluginCacheState(codexHome, installedVersion);
+    if (cache.state === "behind") {
+      findings.push({
+        code: "codex_plugin_cache_behind",
+        severity: "warning",
+        subject: cache.cachePath,
+        detail: `cached ${cache.newestCached} < installed ${installedVersion}; Codex runs the copy it cached at install`,
+        recommendation: `run \`${CODEX_PLUGIN_ADD_COMMAND}\` to bring the cached plugin level (Codex has no plugin-update verb; re-adding refreshes the cache)`,
+        repair_route: CODEX_PLUGIN_ADD_COMMAND,
+      });
+    }
+  }
+
+  if (home) {
+    const link = claudePluginLinkState(join(home, ".claude"));
+    if (link.state === "dangling") {
+      findings.push({
+        code: "claude_plugin_link_dangling",
+        severity: "warning",
+        subject: link.linkPath,
+        detail: `the link points at ${link.target ?? "an unreadable target"}, which cannot be read`,
+        recommendation:
+          'relink it — `ln -s "<pkg>/plugins/mirror-mind" ~/.claude/skills/mirror-mind` — or remove it if Claude Code is no longer wired',
+        repair_route: "relink or remove",
+      });
+    }
+  }
+
+  return findings;
+}
+
 /** The catalog read `probeModelPins` needs. DS5 replay only until DS8. */
 export interface ModelCatalogProvider {
   listAvailableModels(): Promise<Set<string>>;