mirror-mind 0.36.3 → 0.38.0

package/ts/src/providers/config.ts

@@ -18,7 +18,14 @@ const ARG_SECRET_PATTERN =
 // Model pins (AI-06, CV9.E2.S12): a deprecated pinned model would fail every
 // extraction/embedding call, and those paths fail soft -- so the pins must be
 // env-overridable to repoint a deployed instance without a release.
-export const DEFAULT_EXTRACTION_MODEL = "google/gemini-2.5-flash-lite";
+//
+// The extraction pin moved from `google/gemini-2.5-flash-lite` to Claude Haiku 5.5
+// on 2026-10-28 (CV9.DS9.US3), on DS9's measurement: the Navigator's own blind
+// rankings on his conversations, the suite at reasoning off, and Flash Lite's
+// upstream rate limits. A pin change is a migration: the pin, its entry in
+// MODEL_DEFAULT_REASONING, and MODEL_PRICES (cost.ts) move in one commit, behind
+// a green `eval --all` (the development guide's model upgrade playbook).
+export const DEFAULT_EXTRACTION_MODEL = "anthropic/claude-haiku-5.5";
 export const DEFAULT_EMBEDDING_MODEL = "openai/text-embedding-3-small";
 
 export interface ModelPinOptions {
@@ -51,6 +58,103 @@ export function resolveEmbeddingModel(options: ModelPinOptions = {}): string {
   return env.MEMORY_EMBEDDING_MODEL ?? DEFAULT_EMBEDDING_MODEL;
 }
 
+/**
+ * The reasoning efforts OpenRouter's catalogue lists across its models (checked
+ * 2026-10-26, CV9.DS9.TS1). `none` turns reasoning off. Whether a given model
+ * honours a given effort is the operator's choice; this list is the vocabulary.
+ */
+export const REASONING_EFFORTS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+] as const;
+
+export type ReasoningEffort = (typeof REASONING_EFFORTS)[number];
+
+/** What `MEMORY_EXTRACTION_REASONING` says: an effort to send, or a value that is not one. */
+export interface ExtractionReasoning {
+  /** The effort to send as `reasoning.effort`, or null to send no reasoning field. */
+  effort: ReasoningEffort | null;
+  /** The value as written when it is not an effort; null otherwise. */
+  invalid: string | null;
+}
+
+/**
+ * Read `MEMORY_EXTRACTION_REASONING` (CV9.DS9.TS1): the reasoning effort every
+ * extraction-family call sends. Absent or blank sends nothing, which is the request
+ * as it was before the setting existed.
+ *
+ * Unlike the numeric resolvers below, this never throws. They fail loudly, but they
+ * are read inside the session-end hooks, where a throw becomes an extraction attempt
+ * and three attempts quarantine a conversation for good (CR178). So a value that is
+ * not an effort sends nothing too, and comes back as `invalid` for `runtime status`
+ * and `runtime diagnose` to show.
+ */
+export function readExtractionReasoning(options: ModelPinOptions = {}): ExtractionReasoning {
+  const env = options.env ?? process.env;
+  const raw = env.MEMORY_EXTRACTION_REASONING ?? "";
+  const value = raw.trim().toLowerCase();
+  if (value === "") return { effort: null, invalid: null };
+  const effort = REASONING_EFFORTS.find((candidate) => candidate === value);
+  return effort ? { effort, invalid: null } : { effort: null, invalid: raw.trim() };
+}
+
+/**
+ * The reasoning effort a model sends when `MEMORY_EXTRACTION_REASONING` is unset
+ * (CV9.DS9.US3). A property of the model, because what DS9 measured is: Haiku
+ * reasons by default and spent the title call's 40-token budget, so it was
+ * measured and chosen at `none`; Flash Lite was measured with no reasoning field,
+ * and a model absent from this table gets none, which is the request as it was
+ * before the setting existed. So the playbook's rollback, `MEMORY_EXTRACTION_MODEL`
+ * set to the old pin, reproduces exactly the request the old pin was measured with,
+ * and naming the default pin explicitly sends the same request as leaving it unset.
+ */
+export const MODEL_DEFAULT_REASONING: Readonly<Record<string, ReasoningEffort>> = {
+  "anthropic/claude-haiku-5.5": "none",
+};
+
+/** Where the effective effort came from: the setting, the model's default, or nowhere. */
+export type ReasoningSource = "setting" | "model_default";
+
+/** The effective pair every extraction-family call sends: the model and its effort. */
+export interface EffectiveExtractionReasoning {
+  /** The model the call names: `MEMORY_EXTRACTION_MODEL` or the default pin. */
+  model: string;
+  /** The effort to send as `reasoning.effort`, or null to send no reasoning field. */
+  effort: ReasoningEffort | null;
+  /** What decided `effort`; null when no field is sent. */
+  source: ReasoningSource | null;
+  /** `MEMORY_EXTRACTION_REASONING` as written when it is not an effort; null otherwise. */
+  invalid: string | null;
+}
+
+/**
+ * Resolve the model and the reasoning effort an extraction-family call sends
+ * (CV9.DS9.US3): the model first, then the effort: the setting when it names an
+ * effort, else the model's entry in `MODEL_DEFAULT_REASONING`, else no field. An
+ * invalid setting reads as unset, so the default pin still sends its model default;
+ * `invalid` carries the value for `runtime status` and `runtime diagnose`. The
+ * transport, the eval harness, and `runtime status` all read this one resolver.
+ */
+export function resolveExtractionReasoning(
+  options: ModelPinOptions = {},
+): EffectiveExtractionReasoning {
+  const model = resolveExtractionModel(options);
+  const setting = readExtractionReasoning(options);
+  if (setting.effort !== null) {
+    return { model, effort: setting.effort, source: "setting", invalid: null };
+  }
+  const modelDefault = MODEL_DEFAULT_REASONING[model];
+  if (modelDefault !== undefined) {
+    return { model, effort: modelDefault, source: "model_default", invalid: setting.invalid };
+  }
+  return { model, effort: null, source: null, invalid: setting.invalid };
+}
+
 // Observability (AI-09, CV9.E2.S13): mirrors Python's MEMORY_LOG_LLM_CALLS
 // resolution exactly -- off | metadata | full, default metadata (never a
 // silent full -- bodies are opt-in only). Legacy "1" maps to "full" for

package/ts/src/providers/cost.ts

@@ -29,7 +29,11 @@ export interface ModelPrice {
 
 /** Estimated OpenRouter list prices (USD / 1K tokens). Verify on every pin change. */
 export const MODEL_PRICES: Readonly<Record<string, ModelPrice>> = {
-  // Extraction pin -- google/gemini-2.5-flash-lite: ~$0.10/M in, ~$0.40/M out.
+  // Extraction pin since CV9.DS9.US3 -- anthropic/claude-haiku-5.5: $0.10/M in,
+  // $0.50/M out, read from OpenRouter's catalogue on 2026-10-28.
+  "anthropic/claude-haiku-5.5": { promptPer1k: 0.0001, completionPer1k: 0.0005 },
+  // The pin before it, kept so a rolled-back install (`MEMORY_EXTRACTION_MODEL`)
+  // keeps pricing its calls -- google/gemini-2.5-flash-lite: ~$0.10/M in, ~$0.40/M out.
   "google/gemini-2.5-flash-lite": { promptPer1k: 0.0001, completionPer1k: 0.0004 },
   // Embedding pin -- openai/text-embedding-3-small: ~$0.02/M, no completion side.
   "openai/text-embedding-3-small": { promptPer1k: 0.00002, completionPer1k: 0.0 },

package/ts/src/providers/llm.ts

@@ -4,6 +4,7 @@ import {
   type LlmTimeoutRole,
   type ProviderConfig,
   resolveExtractionModel,
+  resolveExtractionReasoning,
   resolveLlmMaxRetries,
   resolveLlmTimeoutMs,
   resolveProviderConfig,
@@ -76,6 +77,33 @@ const LLM_TIMEOUT_TIER: Readonly<Record<LlmRole, LlmTimeoutRole>> = {
   descriptor: "extraction",
 };
 
+/**
+ * Which roles carry `MEMORY_EXTRACTION_REASONING` (CV9.DS9.TS1): every role that
+ * runs on the extraction pin. `consult` picks its own model on every call, so a
+ * setting meant for the extraction pin must not reach it.
+ *
+ * A full `Record<LlmRole, boolean>` for the reason `LLM_TIMEOUT_TIER` is one: a
+ * role added to `LLM_ROLES` cannot compile without declaring it. A check against
+ * `"consult"` would let the next role that names its own model inherit the
+ * setting silently.
+ */
+export const CARRIES_EXTRACTION_REASONING: Readonly<Record<LlmRole, boolean>> = {
+  extraction: true,
+  task_extraction: true,
+  summary: true,
+  curation: true,
+  consult: false,
+  reception: true,
+  consolidation: true,
+  shadow_scan: true,
+  conversation_title: true,
+  conversation_tags: true,
+  conversation_summary: true,
+  journal_classification: true,
+  week_plan: true,
+  descriptor: true,
+};
+
 /**
  * The roles a message in Python's envelope can carry.
  *
@@ -273,6 +301,16 @@ export class LiveLlmProvider implements LlmProvider {
   async complete(request: LlmRequest): Promise<LlmResponse> {
     const client = this.resolveClient();
     const model = request.model ?? resolveExtractionModel({ env: this.env });
+    // CV9.DS9.TS1: the one added field; US3: the setting, else the model's own
+    // default (Haiku sends `none`; a model outside the table sends nothing). An
+    // invalid value reads as unset, so it fails nothing (a failed call would
+    // become an extraction attempt, CR178); `runtime status` and `diagnose`
+    // report it.
+    const { effort } = resolveExtractionReasoning({ env: this.env });
+    const reasoning =
+      effort !== null && CARRIES_EXTRACTION_REASONING[request.role]
+        ? { reasoning: { effort } }
+        : {};
     const startedAt = Date.now();
     const body = await client.postJson(
       "/chat/completions",
@@ -286,6 +324,8 @@ export class LiveLlmProvider implements LlmProvider {
           : [{ role: "user", content: request.prompt }],
         temperature: request.temperature ?? DEFAULT_TEMPERATURE,
         max_tokens: request.maxTokens ?? DEFAULT_MAX_TOKENS,
+        // Unset, this adds nothing: the body is the one it was before the setting.
+        ...reasoning,
       },
       {
         timeoutMs: resolveLlmTimeoutMs(LLM_TIMEOUT_TIER[request.role], { env: this.env }),

package/ts/src/providers/transport.ts

@@ -321,6 +321,20 @@ export const MIRROR_QUERY_TRANSPORT: ProviderTransportSpec = {
   liveReason: "DS8.US3 mirror load --query live",
 };
 
+/**
+ * The mirror-query spec as the environment narrows it: with
+ * `MEMORY_RECEPTION=0` the classifier never runs, so the chat fixture stops
+ * being required and the embedding fixture alone is a complete replay. The
+ * router decided this way for `load --query` since CV22.DS8.US3; the doorman's
+ * route (CV9.DS8.TS2) resolves its providers from the same answer, so the
+ * route and the resolution cannot disagree about what "complete" means.
+ */
+export function mirrorQueryTransportFor(env: { MEMORY_RECEPTION?: string }): ProviderTransportSpec {
+  return env.MEMORY_RECEPTION === "0"
+    ? { ...MIRROR_QUERY_TRANSPORT, replay: { embedding: MIRROR_QUERY_TRANSPORT.replay?.embedding } }
+    : MIRROR_QUERY_TRANSPORT;
+}
+
 /**
  * `consolidate scan` and `shadow scan` -- the two cultivation leaves that send
  * a PROMPT. Everything around the call landed in CV22.DS8.US3; the flip

package/ts/src/runtime/diagnose.ts

@@ -34,11 +34,13 @@ import {
   readExtensionPlugin,
 } from "#extensions/extensionPlugin.ts";
 import { identityKeyBreaksGrammar, SLUG_KEYED_LAYERS } from "#identity/identityKey.ts";
+import { REASONING_EFFORTS, resolveExtractionReasoning } from "#providers/config.ts";
 import { pyRepr, sortByCodePoint } from "#util/pythonText.ts";
 import { configFilePath } from "./config.ts";
 import { extensionPluginStates } from "./extensionPluginWiring.ts";
 import type { GitWorktreeEntry } from "./git.ts";
 import {
+  agyPluginCopyState,
   codexPluginCacheState,
   grokPluginCopyState,
   installedPluginVersion,
@@ -46,7 +48,11 @@ import {
 } from "./pluginWiring.ts";
 
 import type { RuntimeStatusReport } from "./status.ts";
-import { CODEX_PLUGIN_ADD_COMMAND, grokPluginReinstallCommand } from "./wiring.ts";
+import {
+  agyPluginInstallCommand,
+  CODEX_PLUGIN_ADD_COMMAND,
+  grokPluginReinstallCommand,
+} from "./wiring.ts";
 
 export interface DriftFinding {
   code: string;
@@ -514,18 +520,19 @@ export function diagnoseRuntime(
 
 /**
  * The plugin wiring findings (CV21.DS4.TS6; the debt US1 carried; Grok in
- * CV21.DS10.US1). Codex and Grok copy the plugin, so an npm update leaves
- * the copy behind; Claude Code links it in place, so its failure mode is a
- * dangling link, and Grok's rules link fails the same way. Grok adds one
+ * CV21.DS10.US1; agy in CV21.DS11.TS4). Codex, agy, and Grok copy the plugin,
+ * so an npm update leaves the copy behind; Claude Code links it in place, so
+ * its failure mode is a dangling link, and Grok's rules link fails the same
+ * way. Grok adds one
  * failure of its own: a respelt install path keys a SECOND copy, and Grok
  * loads one of the two without saying which. Absence is not drift: no
  * cache, no registry, 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, GROK_HOME else ~/.grok, and ~/.claude — never inside the
- * readers, so every reader test is hermetic on a maintainer's machine with
- * real wiring (CR123/128/137/142).
+ * else ~/.codex, GROK_HOME else ~/.grok, ~/.claude, and ~/.gemini — 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,
@@ -550,6 +557,25 @@ export function pluginWiringFindings(
     }
   }
 
+  // agy stages a copy under ~/.gemini/config/plugins/mirror-mind/ (agy 1.4.7,
+  // DS11.TS4's route), read the way the extensions plugin's copy is read: the
+  // `.gemini` home from HOME, with no Mirror variable to override it.
+  const geminiHome = home ? join(home, ".gemini") : null;
+  if (geminiHome && installedVersion && installRoot) {
+    const copy = agyPluginCopyState(geminiHome, installedVersion, "mirror-mind");
+    if (copy.state === "behind") {
+      const install = agyPluginInstallCommand(installRoot);
+      findings.push({
+        code: "agy_plugin_copy_behind",
+        severity: "warning",
+        subject: copy.copyPath,
+        detail: `copied ${copy.copiedVersion} < installed ${installedVersion}; agy runs the copy it staged at install`,
+        recommendation: `run \`${install}\` to bring the copy level (an update leaves agy's copy as it was, and installing again replaces it)`,
+        repair_route: install,
+      });
+    }
+  }
+
   if (home) {
     const link = pluginLinkState(join(home, ".claude", "skills", "mirror-mind"));
     if (link.state === "dangling") {
@@ -746,6 +772,37 @@ export function staleRevertGateFindings(env: NodeJS.ProcessEnv): DriftFinding[]
   ];
 }
 
+/**
+ * A `MEMORY_EXTRACTION_REASONING` that is not a reasoning effort (CV9.DS9.TS1).
+ *
+ * The transport reads it as unset rather than fail the call -- a failed call is
+ * an extraction attempt, and three quarantine a conversation for good (CR178) --
+ * so the setting is silently not in force: the calls send the model's own default
+ * effort (CV9.DS9.US3), or no reasoning field for a model without one. Diagnose
+ * says which, with the values that would be in force.
+ */
+export function extractionReasoningFindings(env: NodeJS.ProcessEnv): DriftFinding[] {
+  const { model, effort, invalid } = resolveExtractionReasoning({ env });
+  if (invalid === null) return [];
+  const sent = effort === null ? "no reasoning setting" : `${model}'s own default, ${effort}`;
+  return [
+    {
+      code: "extraction_reasoning_invalid",
+      severity: "attention",
+      subject: "MEMORY_EXTRACTION_REASONING",
+      detail: `"${invalid}" is not a reasoning effort, so extraction calls send ${sent}`,
+      recommendation:
+        `set it to ${formatEffortList()}, or unset it, where it is set: ` +
+        "the environment, the clone's .env, or ~/.config/mirror/env",
+      repair_route: "edit the setting",
+    },
+  ];
+}
+
+function formatEffortList(): string {
+  return `${REASONING_EFFORTS.slice(0, -1).join(", ")}, or ${REASONING_EFFORTS.at(-1)}`;
+}
+
 /**
  * Where a hook wrapper looks for Node after `MIRROR_NODE` and `PATH`, in order.
  * The generated wrappers carry the same list (`for candidate in ...`), and

package/ts/src/runtime/pluginWiring.ts

@@ -1,4 +1,5 @@
-// The plugin wiring readers (CV21.DS4.TS6; Grok in CV21.DS10.US1).
+// The plugin wiring readers (CV21.DS4.TS6; Grok in CV21.DS10.US1; agy's
+// reader in CV21.DS5.US2, read for the canonical plugin since CV21.DS11.TS4).
 //
 // Three runtimes hold the plugin outside the install tree. Codex copies it
 // into a versioned cache (`$CODEX_HOME/plugins/cache/mirror-mind/mirror-mind/
@@ -226,9 +227,10 @@ export interface AgyCopyState {
  * Read agy's staged copy of a plugin below a `.gemini` home, read-only:
  * `agy plugin install <dir>` stages the tree under `config/plugins/<name>/`
  * (CV21.DS7.US1), and the copy's own `.claude-plugin/plugin.json` carries
- * its version. Written for the extensions plugin (CV21.DS5.US2); the
- * canonical plugin has no agy finding yet, and this reader serves it when
- * one is added.
+ * its version. Written for the extensions plugin (CV21.DS5.US2); since
+ * CV21.DS11.TS4 it reads the canonical plugin's copy too, which agy 1.4.7
+ * stages the same way (`mirror-mind/.claude-plugin/plugin.json`, measured in
+ * a scratch HOME on 2026-10-24).
  */
 export function agyPluginCopyState(
   geminiHome: string,

package/ts/src/runtime/status.ts

@@ -25,7 +25,7 @@ import { readExtensionPlugin } from "#extensions/extensionPlugin.ts";
 import { loadExtensionManifest } from "#extensions/manifest.ts";
 import { inspectMigrationFiles } from "#extensions/migrations.ts";
 import { type DbPathEnv, dbNameForEnv, resolveMirrorHome } from "#frontDoor/dbPath.ts";
-import { DEFAULT_EMBEDDING_MODEL, DEFAULT_EXTRACTION_MODEL } from "#providers/config.ts";
+import { DEFAULT_EMBEDDING_MODEL, resolveExtractionReasoning } from "#providers/config.ts";
 import { sortByCodePoint } from "#util/pythonText.ts";
 import { channelForReport } from "./channel.ts";
 import type { MarkerValue } from "./git.ts";
@@ -119,7 +119,8 @@ function errorMessage(error: unknown): string {
  *
  * One rule, `assertSchemaState`'s, so the codebase keeps ONE definition of a
  * healthy ledger: every id in `KNOWN_MIGRATION_IDS` is required, and an id
- * outside it is unknown. A current database renders `current (17/17)`.
+ * outside it is unknown. A current database renders `current (18/18)` (CV9.DS8.US5's
+ * 018 is the eighteenth; the history below is TS5's).
  *
  * Until CV22.DS10.TS5 this grader kept a second rule for one migration.
  * `017_journey_parent_column` is the first one TypeScript authored, and the
@@ -131,7 +132,7 @@ function errorMessage(error: unknown): string {
  * the forgiveness hid a pending migration behind "ready" on exactly the
  * databases `runtime migrate` exists to bring forward. TS5 finding F19 (a
  * removal the comment here promised for plateau 3 and nobody performed) made
- * the denominator honest: seventeen, everywhere.
+ * the denominator honest: every known migration, everywhere.
  */
 export function inspectCoreMigrations(
   dbPath: string | null,
@@ -528,6 +529,24 @@ function intEnv(raw: string | undefined, fallback: number): number {
   return Number.isNaN(parsed) ? fallback : parsed;
 }
 
+/**
+ * The models line's reasoning clause (CV9.DS9.TS1, US3): the effort the calls
+ * send, marked `(model default)` when it is the model's rather than the setting's;
+ * empty when no field is sent, so a rolled-back pin's line stays byte for byte
+ * what the frozen status scenarios before US3 recorded; and an invalid setting
+ * shown, never thrown, beside the model default it falls back to.
+ */
+function reasoningClause(env: NodeJS.ProcessEnv): string {
+  const { effort, source, invalid } = resolveExtractionReasoning({ env });
+  if (effort !== null && source === "setting") return `reasoning=${effort}, `;
+  if (effort !== null) {
+    const note = invalid === null ? "model default" : `model default, invalid setting: ${invalid}`;
+    return `reasoning=${effort} (${note}), `;
+  }
+  if (invalid !== null) return `reasoning=invalid (${invalid}), `;
+  return "";
+}
+
 /** Port of `render_runtime_status`. */
 export function renderRuntimeStatus(
   report: RuntimeStatusReport,
@@ -569,7 +588,8 @@ export function renderRuntimeStatus(
       `embedding=${formatG(embedding)}, extraction=${formatG(extraction)}; retries=${retries}`,
   );
   lines.push(
-    `Models: extraction=${env.MEMORY_EXTRACTION_MODEL ?? DEFAULT_EXTRACTION_MODEL}, ` +
+    `Models: extraction=${resolveExtractionReasoning({ env }).model}, ` +
+      reasoningClause(env) +
       `embedding=${env.MEMORY_EMBEDDING_MODEL ?? DEFAULT_EMBEDDING_MODEL}`,
   );
   lines.push("");

package/ts/src/runtime/update.ts

@@ -30,6 +30,7 @@ import { join } from "node:path";
 import { verifyBackupArchive } from "#runtime/backup.ts";
 import type { InstallKind } from "#runtime/installKind.ts";
 import {
+  agyPluginCopyState,
   codexPluginCacheState,
   grokPluginCopyState,
   installedPluginVersion,
@@ -43,7 +44,11 @@ import {
   type UpdateResult,
   type UpdateStage,
 } from "#runtime/updatePipeline.ts";
-import { CODEX_PLUGIN_ADD_COMMAND, grokPluginReinstallCommand } from "#runtime/wiring.ts";
+import {
+  agyPluginInstallCommand,
+  CODEX_PLUGIN_ADD_COMMAND,
+  grokPluginReinstallCommand,
+} from "#runtime/wiring.ts";
 import { commandOnPath } from "#util/paths.ts";
 import { PROGRAM } from "#util/program.ts";
 import { shellWord } from "#util/shellWord.ts";
@@ -456,6 +461,17 @@ export function postUpdateHints(
       );
     }
   }
+  // CV21.DS11.TS4: agy stages a copy too, and an update leaves it as it was;
+  // installing again from the path init printed brings it level.
+  const geminiHome = home ? join(home, ".gemini") : null;
+  if (installRoot && geminiHome && landed) {
+    const copy = agyPluginCopyState(geminiHome, landed, "mirror-mind");
+    if (copy.state === "behind") {
+      hints.push(
+        `Antigravity's copy of the plugin is behind the update (${copy.copiedVersion} < ${landed}): run \`${agyPluginInstallCommand(installRoot)}\` to bring it level.`,
+      );
+    }
+  }
 
   return hints;
 }

package/ts/src/runtime/wiring.ts

@@ -83,6 +83,19 @@ function grokPluginInstallCommand(root: string): string {
   return `grok plugin install "${pluginDirectory(root)}" --trust`;
 }
 
+/**
+ * The one agy install command (CV21.DS7.US1), which is also its level-up
+ * (CV21.DS11.TS4). agy stages a copy of the plugin under
+ * `~/.gemini/config/plugins/mirror-mind/` (agy 1.4.7), an update leaves that
+ * copy as it was, and installing again replaces it (by name, from any path). A
+ * function of the root, so the line `init` prints, the recommendation
+ * `diagnose` prints, and the hint `update` prints cannot disagree (the CR071
+ * lesson at the string level).
+ */
+export function agyPluginInstallCommand(root: string): string {
+  return `agy plugin install "${pluginDirectory(root)}"`;
+}
+
 export interface RuntimeWiring {
   /** The runtime, as a person names it. */
   readonly title: string;
@@ -121,7 +134,7 @@ export const RUNTIME_WIRING: Readonly<Record<RuntimeName, RuntimeWiring>> = {
       // the Claude surfaces and overwrites the layer's hooks file). Per-turn
       // injection and logging land with DS7's TS2/TS3; this line promises
       // the install, nothing more.
-      (root) => [`agy plugin install "${root}/plugins/mirror-mind"`],
+      (root) => [agyPluginInstallCommand(root)],
     ],
   },
   grok: {

package/ts/src/search/memorySearch.ts

@@ -54,9 +54,22 @@ export interface FreshSearchOptions extends FreshSearchFilters {
    * tool: search never learns it exists.
    */
   recordEmbeddingLedger?: boolean | ((info: EmbeddingAttemptInfo) => void);
+  /**
+   * The query's embedding, already generated (CV9.DS8.TS2). The doorman embeds
+   * a turn's prompt once and hands the vector to this search and to the
+   * attachment search, so a Mirror Mode turn costs one embedding call, counted
+   * once (DS8 decision 1). When given, no provider is called and nothing is
+   * recorded here: the caller that embedded owns the ledger row.
+   */
+  queryEmbedding?: readonly number[];
   frozenNowMs?: number;
   now?: string;
-  provider: EmbeddingProvider;
+  /**
+   * Absent only with `queryEmbedding` given, or on a turn with no provider at
+   * all (the doorman without a key, CV9.DS8.TS2): the search then degrades to
+   * FTS as it does when the provider fails, with `no_provider` as the kind.
+   */
+  provider?: EmbeddingProvider;
   /** Test-injectable override for generateEmbeddingSafely's retry backoff
    * (real timers by default) -- avoids paying real backoff wait time in tests
    * that exercise the transient-retry path. */
@@ -111,26 +124,33 @@ export async function searchMemoriesWithStatus(
   options: FreshSearchOptions,
 ): Promise<FreshSearchOutcome> {
   const limit = options.limit ?? 5;
-  let queryEmbedding: readonly number[] = [];
+  let queryEmbedding: readonly number[] = options.queryEmbedding ?? [];
   let degraded = false;
   let degradedKind: string | undefined;
-  try {
-    // generateEmbeddingSafely (CR043) retries a transient empty response up to
-    // its default budget before giving up -- matching Python's search, which
-    // calls the same generate_embedding used everywhere else, not a bespoke
-    // single-shot attempt. Any exhausted/permanent/provider-exception failure
-    // still maps to degraded=true here, preserving CR037's contract exactly.
-    queryEmbedding = await generateEmbeddingSafely(options.provider, options.query, {
-      onAttempt: resolveLedgerSink(db, options.recordEmbeddingLedger),
-      sleep: options.embeddingRetrySleep,
-    });
-  } catch (error) {
+  if (options.queryEmbedding !== undefined) {
+    // The caller embedded: nothing to generate, nothing to record.
+  } else if (!options.provider) {
     degraded = true;
-    // Keep the CLASS of failure (AI-18 taxonomy) so an operator can tell an
-    // expired key from a timeout from a rate limit. Without this the front
-    // door only ever says "offline or no API key", which is a guess -- and
-    // the taxonomy the live transport builds would die here unseen.
-    degradedKind = classifyDegradedCause(error);
+    degradedKind = "no_provider";
+  } else {
+    try {
+      // generateEmbeddingSafely (CR043) retries a transient empty response up to
+      // its default budget before giving up -- matching Python's search, which
+      // calls the same generate_embedding used everywhere else, not a bespoke
+      // single-shot attempt. Any exhausted/permanent/provider-exception failure
+      // still maps to degraded=true here, preserving CR037's contract exactly.
+      queryEmbedding = await generateEmbeddingSafely(options.provider, options.query, {
+        onAttempt: resolveLedgerSink(db, options.recordEmbeddingLedger),
+        sleep: options.embeddingRetrySleep,
+      });
+    } catch (error) {
+      degraded = true;
+      // Keep the CLASS of failure (AI-18 taxonomy) so an operator can tell an
+      // expired key from a timeout from a rate limit. Without this the front
+      // door only ever says "offline or no API key", which is a guess -- and
+      // the taxonomy the live transport builds would die here unseen.
+      degradedKind = classifyDegradedCause(error);
+    }
   }
 
   const memories = listSearchMemoryRows(db, options);

package/ts/src/search/ranker.ts

@@ -33,12 +33,22 @@ export interface RankableMemory {
 
 export interface RankedMemory {
   id: string;
+  /** The hybrid score the order is by. */
   score: number;
+  /**
+   * The semantic component alone: the cosine of the query and the memory, 0 on
+   * a degraded search. Reported, not ranked by (CV9.DS8.US5): the doorman's
+   * memory threshold reads it, because half of `score` is recency,
+   * reinforcement, relevance, and lexical, and a fresh, reinforced memory
+   * floors near 0.35 with no semantic match at all.
+   */
+  semantic: number;
 }
 
 interface Candidate {
   id: string;
   score: number;
+  semantic: number;
   embedding: Float32Array;
 }
 
@@ -131,7 +141,7 @@ export function rankMemories(
       lexical: memory.lexical_score ?? 0,
       weights: config.weights,
     });
-    return { id: memory.id, score, embedding };
+    return { id: memory.id, score, semantic, embedding };
   });
 
   candidates.sort((a, b) => b.score - a.score);
@@ -150,5 +160,9 @@ export function rankMemories(
     if (selected.length >= config.limit) break;
   }
 
-  return selected.map((candidate) => ({ id: candidate.id, score: candidate.score }));
+  return selected.map((candidate) => ({
+    id: candidate.id,
+    score: candidate.score,
+    semantic: candidate.semantic,
+  }));
 }