mirror-mind 0.34.0 → 0.36.0

package/ts/src/extensions/extensionPlugin.ts

@@ -0,0 +1,325 @@
+// CV21.DS5.US2 — the per-home extensions plugin.
+//
+// A Mirror home's installed extensions reach Claude Code, Codex, Antigravity, and
+// Grok Build as one generated plugin per home, in the canonical plugin's format:
+//
+//   <home>/runtime/plugin/
+//     .agents/plugins/marketplace.json     the Codex marketplace, named for the home
+//     mirror-ext-<user>/
+//       .claude-plugin/plugin.json         name, version, description — no hooks, no server
+//       plugin.json                        the root marker Grok and agy read (DS10.US1)
+//       skills/<dir>/SKILL.md              each installed extension's `claude` skill
+//
+// DS5.TS1 measured the three shapes DS12.TS5 left open and chose this one: a plugin is
+// listed and found on all four runtimes, needs no manifest rewritten (it carries the
+// `claude` skill the manifests already declare), and installs beside another home's.
+// Its price is that Codex, agy, and Grok copy a plugin, so a changed extension is live
+// only after a reinstall — which is why the version matters: Codex keys its cache by
+// it and `runtime diagnose` compares it.
+//
+// The generator is a pure function from the home's `claude` catalog — the same reader
+// `expose-claude` projects from, so the plugin carries what `expose-claude` exposes —
+// to a sorted file map. The version is `0.1.<generation>`, advanced by one when the
+// tree differs from the one on disk and held when it does not: an identical
+// regeneration must not tell every runtime it is stale. The writer replaces the tree
+// atomically (write `plugin.next`, rename over `plugin`), so Claude Code, which reads
+// the directory in place through a link, never sees a half tree. The tree holds only
+// regular files the generator wrote.
+
+import {
+  type Dirent,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { pythonJsonDumpsIndentedOrdered } from "#util/pyGenerators.ts";
+import { discoverExtensions, extensionsRootForHome, runtimeSkillsRootForHome } from "./catalog.ts";
+import { filesystemSkillDirName } from "./catalogWrites.ts";
+
+export const EXTENSION_PLUGIN_SEGMENTS: readonly string[] = ["runtime", "plugin"];
+const MARKETPLACE_RELATIVE = ".agents/plugins/marketplace.json";
+const VERSION_PREFIX = "0.1.";
+
+/** The plugin's name, which is also its Codex marketplace's: one per home. */
+export function extensionPluginName(user: string): string {
+  return `mirror-ext-${user}`;
+}
+
+/** The marketplace root: what `codex plugin marketplace add` takes. */
+export function extensionPluginRoot(mirrorHome: string): string {
+  return join(mirrorHome, ...EXTENSION_PLUGIN_SEGMENTS);
+}
+
+/** The plugin directory: what Claude Code links, and agy and Grok install. */
+export function extensionPluginDirectory(mirrorHome: string): string {
+  return join(extensionPluginRoot(mirrorHome), extensionPluginName(basename(mirrorHome)));
+}
+
+/** Relative path → file content, sorted by path. */
+export type PluginFileMap = Readonly<Record<string, string>>;
+
+export interface PluginEntry {
+  /** The `claude` block's `command_name`, e.g. `ext:review-copy`. */
+  readonly commandName: string;
+  /** The installed skill file's bytes, copied verbatim: frontmatter is the author's. */
+  readonly content: string;
+}
+
+export interface PluginPlan {
+  readonly name: string;
+  readonly version: string;
+  readonly generation: number;
+  readonly skills: number;
+  /** True when the tree differs from `previous` (or there was none). */
+  readonly changed: boolean;
+  readonly files: PluginFileMap;
+}
+
+export interface PreviousPlugin {
+  readonly generation: number;
+  readonly files: PluginFileMap;
+}
+
+function render(user: string, entries: readonly PluginEntry[], generation: number): PluginFileMap {
+  const name = extensionPluginName(user);
+  const version = `${VERSION_PREFIX}${generation}`;
+  const sorted = [...entries].sort((a, b) =>
+    a.commandName < b.commandName ? -1 : a.commandName > b.commandName ? 1 : 0,
+  );
+  const skills = sorted.length;
+  const manifest = {
+    name,
+    version,
+    description: `Extensions of the Mirror home ${user}: ${skills} skill${skills === 1 ? "" : "s"}`,
+  };
+  const marketplace = {
+    name,
+    owner: { name: "Mirror Mind" },
+    plugins: [
+      {
+        name,
+        source: { source: "local", path: `./${name}` },
+        description: manifest.description,
+      },
+    ],
+  };
+  const files: Record<string, string> = {
+    [MARKETPLACE_RELATIVE]: `${pythonJsonDumpsIndentedOrdered(marketplace)}\n`,
+    [`${name}/.claude-plugin/plugin.json`]: `${pythonJsonDumpsIndentedOrdered(manifest)}\n`,
+    [`${name}/plugin.json`]: `${pythonJsonDumpsIndentedOrdered(manifest)}\n`,
+  };
+  for (const entry of sorted) {
+    files[`${name}/skills/${filesystemSkillDirName(entry.commandName)}/SKILL.md`] = entry.content;
+  }
+  return Object.fromEntries(Object.entries(files).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+}
+
+function sameFiles(a: PluginFileMap, b: PluginFileMap): boolean {
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every((key) => key in b && a[key] === b[key]);
+}
+
+/**
+ * The plan: the tree at the previous generation, compared to the previous tree;
+ * when it differs, the tree at the next generation. The version appears in both
+ * manifests, so a changed tree is re-rendered after the bump.
+ */
+export function planExtensionPlugin(input: {
+  user: string;
+  entries: readonly PluginEntry[];
+  previous: PreviousPlugin | null;
+}): PluginPlan {
+  const name = extensionPluginName(input.user);
+  const skills = input.entries.length;
+  if (input.previous === null) {
+    const files = render(input.user, input.entries, 1);
+    return { name, version: `${VERSION_PREFIX}1`, generation: 1, skills, changed: true, files };
+  }
+  const held = render(input.user, input.entries, input.previous.generation);
+  if (sameFiles(held, input.previous.files)) {
+    return {
+      name,
+      version: `${VERSION_PREFIX}${input.previous.generation}`,
+      generation: input.previous.generation,
+      skills,
+      changed: false,
+      files: held,
+    };
+  }
+  const generation = input.previous.generation + 1;
+  return {
+    name,
+    version: `${VERSION_PREFIX}${generation}`,
+    generation,
+    skills,
+    changed: true,
+    files: render(input.user, input.entries, generation),
+  };
+}
+
+/** The tree on disk as a file map with its generation, or null when there is none. */
+export function readExtensionPlugin(mirrorHome: string): PreviousPlugin | null {
+  const root = extensionPluginRoot(mirrorHome);
+  const manifestPath = join(extensionPluginDirectory(mirrorHome), ".claude-plugin", "plugin.json");
+  if (!existsSync(manifestPath)) return null;
+  let generation: number;
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(manifestPath, "utf8"));
+    const version =
+      typeof parsed === "object" && parsed !== null
+        ? (parsed as Record<string, unknown>).version
+        : undefined;
+    const match = typeof version === "string" ? /^0\.1\.(\d+)$/.exec(version) : null;
+    if (match === null) return null;
+    generation = Number(match[1]);
+  } catch {
+    return null;
+  }
+  const files: Record<string, string> = {};
+  for (const path of walk(root)) {
+    files[path.slice(root.length + 1)] = readFileSync(path, "utf8");
+  }
+  return {
+    generation,
+    files: Object.fromEntries(
+      Object.entries(files).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),
+    ),
+  };
+}
+
+function walk(root: string): string[] {
+  const found: string[] = [];
+  let entries: Dirent[];
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return found;
+  }
+  for (const entry of entries) {
+    const path = join(root, entry.name);
+    if (entry.isDirectory()) found.push(...walk(path));
+    else if (entry.isFile()) found.push(path);
+  }
+  return found.sort();
+}
+
+/**
+ * Replace the tree atomically: the map is written to `plugin.next`, then renamed over
+ * `plugin`. The path a runtime links or installed from is unchanged; a removed skill's
+ * directory is gone because the whole tree is new. Mode 0700, like the rest of the home.
+ */
+export function writeExtensionPlugin(mirrorHome: string, files: PluginFileMap): void {
+  const root = extensionPluginRoot(mirrorHome);
+  const next = `${root}.next`;
+  const old = `${root}.old`;
+  rmSync(next, { recursive: true, force: true });
+  mkdirSync(next, { recursive: true, mode: 0o700 });
+  for (const [relative, content] of Object.entries(files)) {
+    const path = join(next, relative);
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    writeFileSync(path, content, { encoding: "utf8", mode: 0o600 });
+  }
+  rmSync(old, { recursive: true, force: true });
+  if (existsSync(root)) renameSync(root, old);
+  renameSync(next, root);
+  rmSync(old, { recursive: true, force: true });
+}
+
+export interface ExtensionPluginReport {
+  readonly name: string;
+  readonly directory: string;
+  readonly marketplaceRoot: string;
+  readonly version: string;
+  readonly skills: number;
+  readonly changed: boolean;
+  /** Installed extensions that declare no `claude` block, and so are not carried. */
+  readonly notCarried: readonly string[];
+}
+
+/** The home's `claude` catalog entries that still have a skill file, as plugin entries. */
+export function claudeCatalogEntries(mirrorHome: string): PluginEntry[] | null {
+  const catalogPath = join(runtimeSkillsRootForHome(mirrorHome, "claude"), "extensions.json");
+  if (!existsSync(catalogPath)) return null;
+  let items: unknown[];
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(catalogPath, "utf8"));
+    const list =
+      typeof parsed === "object" && parsed !== null
+        ? (parsed as Record<string, unknown>).extensions
+        : undefined;
+    items = Array.isArray(list) ? list : [];
+  } catch {
+    items = [];
+  }
+  const entries: PluginEntry[] = [];
+  for (const item of items) {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) continue;
+    const record = item as Record<string, unknown>;
+    const commandName = record.command_name;
+    const skillPath = record.installed_skill_path;
+    if (typeof commandName !== "string" || typeof skillPath !== "string") continue;
+    if (!existsSync(skillPath)) continue;
+    entries.push({ commandName, content: readFileSync(skillPath, "utf8") });
+  }
+  return entries;
+}
+
+/**
+ * Regenerate the home's plugin from its `claude` catalog. A home with no catalog has
+ * never installed an extension that declares `claude`, and gets no plugin.
+ */
+export function regenerateExtensionPlugin(mirrorHome: string): ExtensionPluginReport | null {
+  const entries = claudeCatalogEntries(mirrorHome);
+  if (entries === null) return null;
+  const carried = new Set(readCatalogIds(mirrorHome) ?? []);
+  const notCarried = discoverExtensions(extensionsRootForHome(mirrorHome))
+    .manifests.map((manifest) => manifest.id)
+    .filter((id) => !carried.has(id))
+    .sort();
+  const plan = planExtensionPlugin({
+    user: basename(mirrorHome),
+    entries,
+    previous: readExtensionPlugin(mirrorHome),
+  });
+  if (plan.changed || readExtensionPlugin(mirrorHome) === null)
+    writeExtensionPlugin(mirrorHome, plan.files);
+  return {
+    name: plan.name,
+    directory: extensionPluginDirectory(mirrorHome),
+    marketplaceRoot: extensionPluginRoot(mirrorHome),
+    version: plan.version,
+    skills: plan.skills,
+    changed: plan.changed,
+    notCarried,
+  };
+}
+
+/** The extension ids the home's `claude` catalog names, or null without a catalog. */
+function readCatalogIds(mirrorHome: string): string[] | null {
+  const catalogPath = join(runtimeSkillsRootForHome(mirrorHome, "claude"), "extensions.json");
+  if (!existsSync(catalogPath)) return null;
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(catalogPath, "utf8"));
+    const list =
+      typeof parsed === "object" && parsed !== null
+        ? (parsed as Record<string, unknown>).extensions
+        : undefined;
+    if (!Array.isArray(list)) return [];
+    return list
+      .map((item) =>
+        typeof item === "object" && item !== null && !Array.isArray(item)
+          ? (item as Record<string, unknown>).id
+          : undefined,
+      )
+      .filter((id): id is string => typeof id === "string");
+  } catch {
+    return [];
+  }
+}

package/ts/src/extensions/manifest.ts

@@ -31,7 +31,13 @@ import { tablePrefixFor } from "./migrations.ts";
 
 const ALLOWED_KINDS = new Set(["prompt-skill", "command-skill"]);
 const RUNTIME_NAME_RE = /^[a-z][a-z0-9_-]*$/;
-const SKILL_ID_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/**
+ * What an extension id may look like. `install` is the authority on ids, so
+ * this is THE grammar; the settings reader (CR145) builds a path from an id
+ * only after it passes here. Two older copies of the rule still live in
+ * `contextRuntime.ts` and `dispatch.ts` -- CR147 reconciles them.
+ */
+export const SKILL_ID_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const REQUIRED_FIELDS = ["id", "name", "category", "kind", "summary", "runtimes"] as const;
 const PATH_LIKE_SUFFIXES = new Set([".js", ".mjs", ".cjs", ".py"]);
 

package/ts/src/extensions/settings.ts

@@ -0,0 +1,147 @@
+// An extension's installation settings: `<mirror-home>/extensions/<id>.env` (CR145).
+//
+// The `mirror-cli-v1` and `mirror-context-v1` contracts hand a spawned
+// extension the environment the `mirror` process had, and nothing else. That
+// left an extension's own installation settings -- which host, which TLS mode,
+// which certificate on this machine -- with nowhere to live but the login
+// shell, where two of them (`PGSSLMODE`, `NODE_EXTRA_CA_CERTS`) broke every
+// other Postgres client and Node process on the machine. Node reads
+// `NODE_EXTRA_CA_CERTS` before any extension code runs, so only the spawner can
+// set it, and the spawner is Mirror.
+//
+// The file sits BESIDE the installed directory, not inside it, for two reasons
+// measured on the maintainer's machine: `extensions install` rewrites the
+// directory, and in a development home the directory is a symlink into the
+// extension's own git repository, where a `.env` would be one `git add .` away
+// from a push.
+//
+// Precedence is the ecosystem's and Mirror's own (`runtime/config.ts`): a
+// variable already in the environment wins, the file fills the gaps, and the
+// five `MIRROR_*` names the dispatcher owns can never come from the file. The
+// merged environment reaches the one spawned process; `process.env` is read,
+// never written.
+
+import { readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { parseEnv } from "node:util";
+import { extensionsRootForHome } from "./catalog.ts";
+import { SKILL_ID_RE } from "./manifest.ts";
+
+/**
+ * The names the dispatcher sets last for a subcommand, and that a provider
+ * receives on stdin rather than in its environment. Dropped from the file at
+ * the merge, at both spawn points, so the file can steer neither.
+ */
+export const RESERVED_SETTINGS_NAMES: readonly string[] = [
+  "MIRROR_HOME",
+  "MIRROR_DATABASE_PATH",
+  "MIRROR_EXTENSION_ID",
+  "MIRROR_EXTENSION_ROOT",
+  "MIRROR_TABLE_PREFIX",
+];
+
+export type ExtensionSettings =
+  | { kind: "absent"; path: string }
+  | {
+      kind: "read";
+      path: string;
+      /** Sorted by name, as `parseEnv` yields them; a duplicate key's last value. */
+      variables: Record<string, string>;
+      /** The mode, when group or others can read the file; null when only the owner can. */
+      exposedMode: string | null;
+    }
+  | { kind: "unreadable"; path: string; reason: string };
+
+export function extensionSettingsPath(mirrorHome: string, extensionId: string): string {
+  return join(extensionsRootForHome(mirrorHome), `${extensionId}.env`);
+}
+
+/**
+ * Read the settings file, as a result and never a throw.
+ *
+ * An id outside the manifest's grammar is `unreadable` before any path is
+ * built: the context runtime takes ids from `_ext_bindings` rows, and a path
+ * must not be steerable by database content. "Unreadable" is the fail-closed
+ * answer at both call sites -- the dispatcher refuses, the provider reports.
+ *
+ * A UTF-8 BOM is stripped before parsing: `parseEnv` would otherwise keep it
+ * in the first key's name, and the editor that wrote it never shows it.
+ */
+export function readExtensionSettings(mirrorHome: string, extensionId: string): ExtensionSettings {
+  if (!SKILL_ID_RE.test(extensionId)) {
+    return {
+      kind: "unreadable",
+      path: join(extensionsRootForHome(mirrorHome), "<id>.env"),
+      reason: `'${extensionId}' is not a valid extension id`,
+    };
+  }
+  const path = extensionSettingsPath(mirrorHome, extensionId);
+  let text: string;
+  let mode: number;
+  try {
+    const stat = statSync(path, { throwIfNoEntry: false });
+    if (stat === undefined) return { kind: "absent", path };
+    mode = stat.mode;
+    text = readFileSync(path, "utf8");
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    return { kind: "unreadable", path, reason: code ?? (error as Error).message };
+  }
+  const variables: Record<string, string> = {};
+  for (const [key, value] of Object.entries(parseEnv(text.replace(/^\uFEFF/, "")))) {
+    if (value !== undefined) variables[key] = value;
+  }
+  return { kind: "read", path, variables, exposedMode: exposedModeOf(mode) };
+}
+
+/**
+ * The file's mode as `0644` when group or others can read it, else null.
+ * Mode bits mean nothing on Windows, where every file would read as exposed.
+ */
+function exposedModeOf(mode: number): string | null {
+  if (process.platform === "win32") return null;
+  const permissions = mode & 0o777;
+  return (permissions & 0o044) === 0 ? null : `0${permissions.toString(8)}`;
+}
+
+/**
+ * The file UNDER the environment: `{ ...file, ...environment }`, with the
+ * reserved names removed from the file first. A key present in the
+ * environment -- even as an empty string -- is already set and wins, the rule
+ * `loadEnvFileWithoutOverride` applies to the home's own files.
+ */
+export function settingsUnderEnvironment(
+  environment: NodeJS.ProcessEnv,
+  settings: ExtensionSettings,
+): NodeJS.ProcessEnv {
+  if (settings.kind !== "read") return { ...environment };
+  const fromFile: Record<string, string> = {};
+  for (const [key, value] of Object.entries(settings.variables)) {
+    if (RESERVED_SETTINGS_NAMES.includes(key)) continue;
+    fromFile[key] = value;
+  }
+  return { ...fromFile, ...environment };
+}
+
+/**
+ * The `ext <id>` listing's last line. Keys only, never a value: a key's name
+ * says a setting exists, which is what a person checking the file needs; its
+ * value is what must not end up in a transcript.
+ */
+export function describeExtensionSettings(settings: ExtensionSettings): string {
+  switch (settings.kind) {
+    case "absent":
+      return `settings: ${settings.path} (not present — create it to pass settings to this extension)`;
+    case "unreadable":
+      return `settings: ${settings.path} (unreadable: ${settings.reason})`;
+    case "read": {
+      const keys = Object.keys(settings.variables);
+      const state = keys.length === 0 ? "no variables" : keys.join(", ");
+      const exposure =
+        settings.exposedMode === null
+          ? ""
+          : `; mode ${settings.exposedMode}, readable by other users`;
+      return `settings: ${settings.path} (${state}${exposure})`;
+    }
+  }
+}

package/ts/src/frontDoor/cli.ts

@@ -19,7 +19,7 @@
 // so neither a `bin` shim nor a skill line needs `--env-file` or
 // `NODE_OPTIONS=--no-warnings`. Importing this module does neither.
 
-import { existsSync, readFileSync } from "node:fs";
+import { accessSync, constants, existsSync, readFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
 import { pathToFileURL } from "node:url";
 import {
@@ -68,6 +68,7 @@ import {
   JOURNAL_TRANSPORT,
   WEEK_PLAN_TRANSPORT,
 } from "#providers/transport.ts";
+import { exitQuietlyOnBrokenPipe } from "#runtime/brokenPipe.ts";
 import {
   configFilePath,
   loadConfiguration,
@@ -769,6 +770,17 @@ async function runExtensionCatalog(argv: readonly string[]): Promise<DispatchOut
     deps: { nowIso: () => pythonUtcIsoformat() },
     withReadOnlyDatabase: (run) => withMirrorReadDb(argv, run),
     withWritableDatabase: (run) => withMirrorWriteDb(argv, run),
+    // CV21.DS5.US2: the extensions-plugin readers take their homes and the
+    // PATH from the process environment here, and from nowhere else.
+    environment: process.env,
+    isExecutable: (path) => {
+      try {
+        accessSync(path, constants.X_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    },
   });
 }
 
@@ -1871,6 +1883,9 @@ export async function main(rawArgv = process.argv.slice(2)): Promise<number> {
  */
 export async function runAsEntry(rawArgv = process.argv.slice(2)): Promise<number> {
   silenceExperimentalWarnings();
+  // Before anything that could write (CR148): `mirror … | head -1` ends
+  // quietly, exit 0, instead of an unhandled EPIPE and a stack trace.
+  exitQuietlyOnBrokenPipe(process.exit);
   loadConfiguration({ entryPath: import.meta.filename });
   return main(rawArgv);
 }

package/ts/src/frontDoor/extensionCatalogRoute.ts

@@ -62,6 +62,8 @@ export interface ExtensionRouteDeps {
     run: (db: WritableDatabase) => Promise<number> | number,
   ) => Promise<number>;
   environment?: NodeJS.ProcessEnv;
+  /** Whether a PATH candidate is executable, for the extensions-plugin block (CV21.DS5.US2). */
+  isExecutable?: (path: string) => boolean;
 }
 
 /** The `extensions` verbs that need a writable handle; the rest read. */
@@ -140,7 +142,11 @@ function firstPositional(args: readonly string[]): string | null {
 }
 
 function readContextFor(route: ExtensionRouteDeps): CatalogContext {
-  return { mirrorHome: route.mirrorHome };
+  return {
+    mirrorHome: route.mirrorHome,
+    ...(route.environment ? { env: route.environment } : {}),
+    ...(route.isExecutable ? { isExecutable: route.isExecutable } : {}),
+  };
 }
 
 function dispatchOptions(route: ExtensionRouteDeps) {
@@ -151,7 +157,7 @@ function dispatchOptions(route: ExtensionRouteDeps) {
 }
 
 function writeContextFor(route: ExtensionRouteDeps, db: WritableDatabase): ExtWriteContext {
-  return { mirrorHome: route.mirrorHome, db, deps: route.deps };
+  return { ...readContextFor(route), db, deps: route.deps };
 }
 
 export async function runExtensionCatalogRoute(

package/ts/src/frontDoor/runtimeRoute.ts

@@ -24,6 +24,7 @@ import {
 import { channelFor, channelForReport, renderChannel, setChannel } from "#runtime/channel.ts";
 import {
   diagnoseRuntime,
+  extensionPluginFindings,
   hookFailureFindings,
   hookNodeFindings,
   pluginWiringFindings,
@@ -336,6 +337,16 @@ export async function runRuntimeReadRoute(
       // after an npm update; Claude Code's link can dangle. Absence is not
       // drift, so an unwired machine stays green.
       ...pluginWiringFindings(installRoot, env),
+      // CV21.DS5.US2: the home's extensions plugin, as each runtime on the
+      // PATH holds it. A stale copy is any version other than the home's.
+      ...extensionPluginFindings(report.mirror_home, env, (path) => {
+        try {
+          accessSync(path, constants.X_OK);
+          return true;
+        } catch {
+          return false;
+        }
+      }),
       // No catalog provider until DS8: inconclusive, which is also the
       // oracle's answer when it cannot reach OpenRouter.
       ...(await probeModelPins(null, "")),

package/ts/src/frontDoor/stdinSource.ts

@@ -10,8 +10,8 @@
 // A one-shot handoff rather than an argument because the hooks run the front
 // door in-process (`runFrontDoor`), through the same `main(argv)` every other
 // caller uses, and a payload does not belong in argv: argv is what `ps`
-// shows, and what the Gemini hooks already put a prompt into is the exception
-// this seam avoids repeating.
+// shows, and what the Gemini CLI hooks (retired by CV21.DS8.US1) put a prompt
+// into is the exception this seam avoids repeating.
 
 import { readFileSync } from "node:fs";