fix(pricing): add openai:gpt-5.2 canonical entry for the new default slot A

DEFAULT_SLOTS slot A moved to openai:gpt-5.2, which had no CANONICAL_PRICING entry — estimateCost silently dropped slot A from the --max-usd pre-flight and est_cost_usd audit rows (~1/3 under-count on the default panel). Rates from the OpenAI recipe chat touchpoint (verified 2026-04-20). Also refresh the --slot-a-model help text default and pin a pricing-presence assertion in the DEFAULT_SLOTS consistency test. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
fix(autopilot,eval): nightly quality probe enable path works end-to-end + wire conversation-parser probe
2026-08-15 09:22:18 +00:00 · 2026-07-22 11:18:09 -07:00 · 2026-07-21 14:24:41 -07:00
54 changed files with 881 additions and 1293 deletions
@@ -71,8 +71,8 @@ GBrain is designed to be installed and operated by an AI agent. The fastest path

 If you don't already have an AI agent platform running, start with one of these. Both are designed to read GBrain's install protocol and execute it:

- **[OpenClaw](https://github.com/openclaw/openclaw)** — deploy [AlphaClaw on Render](https://render.com/deploy?repo=https://github.com/chrysb/alphaclaw) (one click, 8GB+ RAM)
- **[Hermes](https://github.com/NousResearch/hermes-agent)** — deploy on [Railway](https://github.com/praveen-ks-2001/hermes-agent-template) (one click)
+- **[OpenClaw](https://github.com/openclawagents/openclaw)** — deploy [AlphaClaw on Render](https://render.com/deploy?repo=https://github.com/chrysb/alphaclaw) (one click, 8GB+ RAM)
+- **[Hermes](https://github.com/openclawagents/hermes)** — deploy on [Railway](https://github.com/praveen-ks-2001/hermes-agent-template) (one click)

 Then paste this into your agent:

@@ -131,9 +131,7 @@ into gbrain so other clients can scaffold it. Default behavior:
  `~/.gbrain/harvest-private-patterns.txt` plus built-in defaults
  (canonical private fork name, common email regex, Slack channel pattern). Any
  match → rollback (delete the harvested files) and exit non-zero.
- `openclaw.plugin.json` updated with the new slug, sorted. Harvest must preserve
-  the top-level OpenClaw-native plugin fields (`id`, `configSchema`, `contracts`)
-  because OpenClaw validates those before it can install the package.
+- `openclaw.plugin.json` updated with the new slug, sorted.
 - `--no-lint` bypasses the linter (after a manual editorial scrub).

 Use the `skillpack-harvest` skill (its companion editorial workflow)
@@ -233,14 +233,13 @@ keep it or `git checkout` to throw it away. Nothing is committed for you.

 **For a skill that ships with gbrain** (anything under the gbrain repo's own
 `skills/`): SkillOpt refuses to overwrite it by default and writes the winner to
-`skills/<name>/skillopt/proposed.md` instead (while keeping `best.md` as the
-optimizer's current-best pointer), so an optimization pass can never silently
-mutate a skill other people depend on. Two ways to handle that:
+`skills/<name>/skillopt/best.md` instead, so an optimization pass can never
+silently mutate a skill other people depend on. Two ways to handle that:

 ```bash
 # See the proposed improvement without touching SKILL.md (works for ANY skill):
 gbrain skillopt meeting-prep --split 1:1:1 --no-mutate
-# → writes skills/meeting-prep/skillopt/proposed.md, updates best.md, and prints the proposal path.
+# → writes skills/meeting-prep/skillopt/best.md (the proposed rewrite), prints its path. Copy what you want.

 # Actually rewrite a bundled skill (explicit opt-in + an independent held-out set):
 gbrain skillopt brain-ops --split 1:1:1 --allow-mutate-bundled \
@@ -1565,8 +1565,8 @@ GBrain is designed to be installed and operated by an AI agent. The fastest path

 If you don't already have an AI agent platform running, start with one of these. Both are designed to read GBrain's install protocol and execute it:

- **[OpenClaw](https://github.com/openclaw/openclaw)** — deploy [AlphaClaw on Render](https://render.com/deploy?repo=https://github.com/chrysb/alphaclaw) (one click, 8GB+ RAM)
- **[Hermes](https://github.com/NousResearch/hermes-agent)** — deploy on [Railway](https://github.com/praveen-ks-2001/hermes-agent-template) (one click)
+- **[OpenClaw](https://github.com/openclawagents/openclaw)** — deploy [AlphaClaw on Render](https://render.com/deploy?repo=https://github.com/chrysb/alphaclaw) (one click, 8GB+ RAM)
+- **[Hermes](https://github.com/openclawagents/hermes)** — deploy on [Railway](https://github.com/praveen-ks-2001/hermes-agent-template) (one click)

 Then paste this into your agent:

@@ -1,5 +1,4 @@
 {
-  "id": "gbrain-context-engine",
  "name": "gbrain",
  "version": "0.32.3.0",
  "description": "Personal knowledge brain with Postgres + pgvector hybrid search",
@@ -266,5 +266,4 @@ editorial pass.
  (e.g. `src/commands/<slug>.ts` if the host SKILL.md declares it
  in frontmatter)
 - gbrain's `openclaw.plugin.json` — adds the slug to `skills:`
-  array, sorted alphabetically, without removing OpenClaw-native plugin fields
-  like `id`, `configSchema`, or `contracts`
+  array, sorted alphabetically
@@ -57,8 +57,6 @@ This mode guarantees:
 - `skills/manifest.json` lists every skill directory
 - `skills/RESOLVER.md` references every skill in the manifest
 - `openclaw.plugin.json` `skills[]` round-trips with both
- `openclaw.plugin.json` keeps OpenClaw install-required native plugin fields
-  (`id`, object `configSchema`, and `contracts.contextEngines` when applicable)
 - No MECE violations (duplicate triggers across skills)

 ### Phases
@@ -74,7 +72,7 @@ This mode guarantees:
 ### Automation

 ```bash
-bun test test/skills-conformance.test.ts test/resolver.test.ts test/openclaw-plugin-manifest.test.ts
+bun test test/skills-conformance.test.ts test/resolver.test.ts
 ```

 The CI-gated check is the package.json `test` script.
@@ -54,7 +54,7 @@ export function bigintToStringReplacer(_key: string, value: unknown): unknown {
 }

 // CLI-only commands that bypass the operation layer
-export const CLI_ONLY = new Set(['init', 'reinit-pglite', 'upgrade', 'post-upgrade', 'check-update', 'integrations', 'publish', 'check-backlinks', 'lint', 'report', 'import', 'export', 'files', 'embed', 'serve', 'call', 'config', 'doctor', 'migrate', 'eval', 'bench', 'sync', 'extract', 'extract-conversation-facts', 'enrich', 'features', 'autopilot', 'graph-query', 'jobs', 'agent', 'apply-migrations', 'skillpack-check', 'skillpack', 'resolvers', 'integrity', 'repair-jsonb', 'orphans', 'maintain', 'sources', 'mounts', 'dream', 'check-resolvable', 'routing-eval', 'skillify', 'smoke-test', 'providers', 'storage', 'repos', 'code-def', 'code-refs', 'reindex', 'reindex-code', 'reindex-frontmatter', 'code-callers', 'code-callees', 'reconcile-links', 'frontmatter', 'auth', 'friction', 'claw-test', 'book-mirror', 'takes', 'think', 'salience', 'anomalies', 'calibration', 'transcripts', 'models', 'remote', 'recall', 'forget', 'edges-backfill', 'cache', 'ze-switch', 'founder', 'brainstorm', 'lsd', 'schema', 'capture', 'onboard', 'conversation-parser', 'status', 'connect', 'skillopt', 'quarantine', 'self-upgrade', 'advisor', 'watch', 'reindex-search-vector']);
+export const CLI_ONLY = new Set(['init', 'reinit-pglite', 'upgrade', 'post-upgrade', 'check-update', 'integrations', 'publish', 'check-backlinks', 'lint', 'report', 'import', 'export', 'files', 'embed', 'serve', 'call', 'config', 'doctor', 'migrate', 'eval', 'sync', 'extract', 'extract-conversation-facts', 'enrich', 'features', 'autopilot', 'graph-query', 'jobs', 'agent', 'apply-migrations', 'skillpack-check', 'skillpack', 'resolvers', 'integrity', 'repair-jsonb', 'orphans', 'sources', 'mounts', 'dream', 'check-resolvable', 'routing-eval', 'skillify', 'smoke-test', 'providers', 'storage', 'repos', 'code-def', 'code-refs', 'reindex', 'reindex-code', 'reindex-frontmatter', 'code-callers', 'code-callees', 'reconcile-links', 'frontmatter', 'auth', 'friction', 'claw-test', 'book-mirror', 'takes', 'think', 'salience', 'anomalies', 'calibration', 'transcripts', 'models', 'remote', 'recall', 'forget', 'edges-backfill', 'cache', 'ze-switch', 'founder', 'brainstorm', 'lsd', 'schema', 'capture', 'onboard', 'conversation-parser', 'status', 'connect', 'skillopt', 'quarantine', 'self-upgrade', 'advisor', 'watch', 'reindex-search-vector']);
 // CLI-only commands whose handlers print their own --help text. These are
 // excluded from the generic short-circuit so detailed per-command and
 // per-subcommand usage stays reachable.
@@ -78,8 +78,6 @@ const CLI_ONLY_SELF_HELP = new Set([
  'capture',
  // v0.42 self-upgrade ships its own usage (flags + the agent-skill story).
  'self-upgrade',
-  // maintain (#3015) prints its own usage block (modes + not-auto-applied list).
-  'maintain',
  // v0.43 (#2095): watch ships WATCH_HELP (flags + the stdin-turn protocol).
  'watch',
  // v0.37 fix wave (Lane D.4 + CDX2-12): sync's --no-embed flag was
@@ -106,9 +104,6 @@ const CLI_ONLY_SELF_HELP = new Set([
  // `gbrain connect --help` prints its own usage (flags + examples) from
  // runConnect; route around the generic one-line short-circuit.
  'connect',
-  // #1474: bench-publish ships its own detailed HELP (flags, exit codes,
-  // the export → publish → gate loop). Route around the generic stub.
-  'bench',
 ]);

 // v114 (#1941): alias -> operation lookup, kept separate from `cliOps` so
@@ -1432,29 +1427,6 @@ async function handleCliOnly(command: string, args: string[]) {
    return;
  }

-  // #1474: `gbrain bench publish` is pure file I/O (reads a captured
-  // eval-candidates NDJSON from `gbrain eval export`, writes a baseline
-  // NDJSON). No DB access; bypass connectEngine entirely so the documented
-  // export → publish → gate loop works on machines without a brain.
-  // The v0.41.1 wave shipped bench-publish.ts + docs/eval-bench.md but this
-  // dispatcher case was never added, so the command hit 'Unknown command'.
-  if (command === 'bench') {
-    if (args[0] === 'publish') {
-      const { runBenchPublish } = await import('./commands/bench-publish.ts');
-      await runBenchPublish(args.slice(1));
-      return;
-    }
-    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
-      const { runBenchPublish } = await import('./commands/bench-publish.ts');
-      await runBenchPublish(['--help']);
-      return;
-    }
-    console.error(`Unknown bench subcommand: ${args[0]}`);
-    console.error('Usage: gbrain bench publish --from <captured.ndjson> --to <baseline.ndjson> [flags]');
-    console.error('  See docs/eval-bench.md for the full loop: eval export → bench publish → eval gate');
-    process.exit(2);
-  }
-
  // v0.42.x (#2390): `gbrain eval chronicle` is deterministic — brings its own
  // in-memory PGLite, no DB/gateway. CI fixture gate runs anywhere.
  if (command === 'eval' && args[0] === 'chronicle') {
@@ -1785,11 +1757,6 @@ async function handleCliOnly(command: string, args: string[]) {
        await runOrphans(engine, args);
        break;
      }
-      case 'maintain': {
-        const { runMaintain } = await import('./commands/maintain.ts');
-        await runMaintain(engine, args);
-        break;
-      }
      // v0.32.7 CJK wave — post-upgrade markdown re-chunk sweep.
      // v0.36 Phase 3 wave — `gbrain reindex --multimodal` re-embeds content_chunks
      // into the unified Voyage multimodal-3 column.
@@ -2250,22 +2217,6 @@ async function connectEngine(opts?: { probeOnly?: boolean }): Promise<BrainEngin
      if (merged.embedding_image_ocr_model !== undefined) {
        process.env.GBRAIN_EMBEDDING_IMAGE_OCR_MODEL = merged.embedding_image_ocr_model;
      }
-      // #1475: stash the merged eval.* flags the same way. The capture gate
-      // (isEvalCaptureEnabled / isEvalScrubEnabled) runs against ctx.config,
-      // which is built from the sync file-plane loadConfig() in both the CLI
-      // op path and MCP dispatch — it never sees the DB plane directly. The
-      // gates consult this stash when the file plane is silent, so
-      // `gbrain config set eval.capture true` actually turns capture on.
-      // A pre-set env value wins over the DB plane (env-above-config, the
-      // incident escape hatch) — unlike GBRAIN_EMBEDDING_MULTIMODAL these
-      // keys have no loadConfig() env mapping, so without this guard the
-      // DB stash would silently clobber an operator's export.
-      if (process.env.GBRAIN_EVAL_CAPTURE === undefined && merged.eval?.capture !== undefined) {
-        process.env.GBRAIN_EVAL_CAPTURE = String(merged.eval.capture);
-      }
-      if (process.env.GBRAIN_EVAL_SCRUB_PII === undefined && merged.eval?.scrub_pii !== undefined) {
-        process.env.GBRAIN_EVAL_SCRUB_PII = String(merged.eval.scrub_pii);
-      }
      // Always re-configure with merged values when DB merge succeeded. The
      // trigger used to be field-name-gated (only when embedding_multimodal_model
      // was set); that coupled the gate to the field set and would silently
@@ -527,6 +527,9 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
  process.on('SIGINT',  () => { void shutdown('SIGINT'); });

  let consecutiveErrors = 0;
+  // Parser-probe fixture warning is once-per-process, not once-per-cycle
+  // (compiled-binary installs have no source tree; don't spam the log).
+  let parserProbeFixtureWarned = false;
  // v0.37.7.0 #1162 — counter for consecutive reconnect failures.
  // Reset on every successful health probe or reconnect. Threshold
  // controlled by GBRAIN_AUTOPILOT_MAX_RECONNECT_FAILS env (default 30).
@@ -1073,17 +1076,36 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
    // loop. Probe runs even when cycleOk=false (probe may surface signal
    // explaining why the cycle is failing).
    try {
-      const probeEnabled = cfg?.autopilot?.nightly_quality_probe?.enabled === true;
+      const { resolveProbeEnabled, resolveProbeMaxUsd, runNightlyQualityProbe } = await import('../core/cycle/nightly-quality-probe.ts');
+      // Dual-plane read: `gbrain config set` (what the doctor enable hint
+      // prints) writes the DB plane; ~/.gbrain/config.json is the fallback.
+      let dbEnabled: string | null = null;
+      let dbMaxUsd: string | null = null;
+      try {
+        dbEnabled = await engine.getConfig('autopilot.nightly_quality_probe.enabled');
+        dbMaxUsd = await engine.getConfig('autopilot.nightly_quality_probe.max_usd');
+      } catch { /* DB unavailable → file plane only */ }
+      const probeEnabled = resolveProbeEnabled(dbEnabled, cfg?.autopilot?.nightly_quality_probe?.enabled);
      if (probeEnabled) {
-        const { runNightlyQualityProbe } = await import('../core/cycle/nightly-quality-probe.ts');
        const { runLongMemEvalForProbe, runCrossModalBatchForProbe } = await import('../core/cycle/nightly-probe-adapters.ts');
        const { isAvailable } = await import('../core/ai/gateway.ts');
-        const maxUsd = Number(cfg?.autopilot?.nightly_quality_probe?.max_usd ?? 5);
+        const { existsSync } = await import('node:fs');
+        const { fileURLToPath } = await import('node:url');
+        const { join } = await import('node:path');
+        const maxUsd = resolveProbeMaxUsd(dbMaxUsd, cfg?.autopilot?.nightly_quality_probe?.max_usd);
+        // The committed fixture (test/fixtures/longmemeval-nightly.jsonl)
+        // lives in the gbrain PACKAGE, not the brain repo — repoPath is
+        // sync.repo_path (the user's brain), where the fixture never
+        // exists, so the probe error'd on every real install. Resolve the
+        // package root from the module location; keep repoPath as the
+        // fallback for setups that vendor the fixture into the brain repo.
+        const pkgRoot = fileURLToPath(new URL('../..', import.meta.url));
+        const fixtureAtPkgRoot = existsSync(join(pkgRoot, 'test', 'fixtures', 'longmemeval-nightly.jsonl'));
        await runNightlyQualityProbe({
          isEnabled: () => true, // already gated above; phase re-checks for defense-in-depth
          hasEmbeddingProvider: () => isAvailable('embedding'),
          resolveMaxUsd: () => maxUsd,
-          resolveRepoRoot: () => repoPath ?? gbrainHomePath('.'),
+          resolveRepoRoot: () => (fixtureAtPkgRoot ? pkgRoot : repoPath ?? gbrainHomePath('.')),
          runLongMemEval: runLongMemEvalForProbe,
          runCrossModalBatch: runCrossModalBatchForProbe,
          now: () => new Date(),
@@ -1095,6 +1117,62 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
      // informational; autopilot loop continues.
    }

+    // 4.6 — Nightly conversation-parser probe (v0.41.16.0 phase module;
+    // the scheduler wire-up was deferred at ship and is added here). Same
+    // posture as 4.5: the phase owns its gates (enabled/mode-gate, LLM
+    // key), the wiring owns invocation + the audit row, and a probe
+    // failure NEVER crashes the autopilot loop. Per D10 the probe is
+    // default-ON for search.mode=tokenmax, opt-in otherwise.
+    try {
+      const { runConversationParserNightlyProbe } = await import('../core/conversation-parser/nightly-probe.ts');
+      const { logParserProbeEvent, parserProbeRanWithin } = await import('../core/audit-parser-probe.ts');
+      const { isAvailable } = await import('../core/ai/gateway.ts');
+      const { existsSync } = await import('node:fs');
+      const { fileURLToPath } = await import('node:url');
+      const { join } = await import('node:path');
+      // Flag reads dual-plane: the DB row (`gbrain config set …`) wins,
+      // ~/.gbrain/config.json is the fallback. search.mode lives on the
+      // DB plane only (mode.ts owns it).
+      let parserDbEnabled: string | null = null;
+      let dbSearchMode: string | null = null;
+      try {
+        parserDbEnabled = await engine.getConfig('autopilot.conversation_parser_probe.enabled');
+        dbSearchMode = await engine.getConfig('search.mode');
+      } catch { /* DB unavailable → file plane only */ }
+      const parserEnabled = parserDbEnabled != null
+        ? parserDbEnabled === 'true'
+        : cfg?.autopilot?.conversation_parser_probe?.enabled === true;
+      const searchMode = dbSearchMode ?? '';
+      // Fixtures are committed in the gbrain package (test/fixtures/…),
+      // NOT the brain repo — resolve from the module location. Compiled
+      // binaries carry no source tree: skip quietly instead of writing
+      // failure rows that would flip doctor to WARN on every binary install.
+      const pkgRoot = fileURLToPath(new URL('../..', import.meta.url));
+      const fixturePath = join(pkgRoot, 'test', 'fixtures', 'conversation-formats', 'all.jsonl');
+      const adversarialPath = join(pkgRoot, 'test', 'fixtures', 'conversation-formats', 'adversarial.jsonl');
+      const shouldInvoke = parserEnabled || searchMode === 'tokenmax';
+      if (shouldInvoke && existsSync(fixturePath) && existsSync(adversarialPath)) {
+        const result = await runConversationParserNightlyProbe({
+          isEnabled: () => parserEnabled,
+          searchMode: () => searchMode,
+          hasLlmKey: () => isAvailable('chat'),
+          resolveFixturePath: () => fixturePath,
+          resolveAdversarialPath: () => adversarialPath,
+          now: () => new Date(),
+          shouldSkipForRateLimit: () => parserProbeRanWithin(24 * 60 * 60 * 1000),
+        });
+        // rate_limited is a non-run: the loop ticks every few minutes, so
+        // logging every skip would flood the audit file with no-signal rows.
+        if (result.outcome !== 'rate_limited') logParserProbeEvent(result);
+      } else if (shouldInvoke && !parserProbeFixtureWarned) {
+        parserProbeFixtureWarned = true;
+        console.error(`[parser-probe] fixtures not found under ${pkgRoot}; skipping (probe needs a source-checkout install)`);
+      }
+    } catch (e) {
+      logError('autopilot.parser_probe', e);
+      // Informational, like 4.5: do NOT bump consecutiveErrors.
+    }
+
    // Wait for next cycle
    await new Promise(r => setTimeout(r, interval * 1000));
  }
@@ -2960,6 +2960,54 @@ function _resolveSyncFreshnessHours(varName: string, fallback: number): number {
 * branch (disabled / enabled-no-events / enabled-all-pass / enabled-with-failures)
 * without spinning up the audit JSONL or a real config file.
 */
+/**
+ * Pure function form of the conversation_parser_probe_health check.
+ * Mirrors computeNightlyQualityProbeHealthCheck: skip-with-hint when the
+ * probe is off and silent, surface the last 7 days of audit events when
+ * it has run, WARN on any non-pass outcome.
+ *
+ * `effectiveEnabled` folds the D10 mode-gate in: explicitly enabled OR
+ * search.mode=tokenmax (where the probe is default-on).
+ */
+export function computeConversationParserProbeHealthCheck(
+  effectiveEnabled: boolean,
+  events: ReadonlyArray<{ outcome: string; ts: string; reason?: string }>,
+): Check {
+  const name = 'conversation_parser_probe_health';
+  if (!effectiveEnabled && events.length === 0) {
+    return {
+      name,
+      status: 'ok',
+      message:
+        'disabled (opt-in; default-on only for search.mode=tokenmax). Enable with: ' +
+        '`gbrain config set autopilot.conversation_parser_probe.enabled true`',
+    };
+  }
+  if (events.length === 0) {
+    return {
+      name,
+      status: 'ok',
+      message: 'enabled but no probe events in the last 7 days (next run by autopilot; fixtures require a source-checkout install).',
+    };
+  }
+  const bad = events.filter(e => e.outcome !== 'pass');
+  const latest = events[events.length - 1]!;
+  if (bad.length > 0) {
+    return {
+      name,
+      status: 'warn',
+      message:
+        `${bad.length}/${events.length} probe run(s) in the last 7 days did not pass; ` +
+        `latest: ${latest.outcome}${latest.reason ? ` (${latest.reason})` : ''}`,
+    };
+  }
+  return {
+    name,
+    status: 'ok',
+    message: `${events.length} probe run(s) in the last 7 days, all pass (latest ${latest.ts}).`,
+  };
+}
+
 export function computeNightlyQualityProbeHealthCheck(
  probeEnabled: boolean,
  events: ReadonlyArray<{ outcome: string; ts: string; detail?: string }>,
@@ -4843,10 +4891,17 @@ export async function buildChecks(
  try {
    const { readRecentQualityProbeEvents } = await import('../core/audit-quality-probe.ts');
    const { loadConfig } = await import('../core/config.ts');
+    const { resolveProbeEnabled } = await import('../core/cycle/nightly-quality-probe.ts');
    let probeEnabled = false;
    try {
+      // Dual-plane read, matching the autopilot gate: the DB row (what the
+      // enable hint's `gbrain config set` writes) wins; file plane fallback.
+      let dbVal: string | null = null;
+      try {
+        dbVal = engine ? await engine.getConfig('autopilot.nightly_quality_probe.enabled') : null;
+      } catch { /* DB unavailable → file plane only */ }
      const cfg = loadConfig();
-      probeEnabled = Boolean((cfg as any)?.autopilot?.nightly_quality_probe?.enabled);
+      probeEnabled = resolveProbeEnabled(dbVal, (cfg as any)?.autopilot?.nightly_quality_probe?.enabled);
    } catch { /* config unavailable → treat as disabled */ }
    const events = readRecentQualityProbeEvents(7);
    const check = computeNightlyQualityProbeHealthCheck(probeEnabled, events);
@@ -5030,19 +5085,29 @@ export async function buildChecks(

  // 3d.5 v0.41.13.0 — conversation_parser_probe_health. Mode-gated
  // per D10: ON when search.mode=tokenmax, opt-in for other modes.
-  // Surface the last 7 days of nightly-probe events; warn on FAIL /
-  // BUDGET_EXCEEDED / adversarial_false_positive.
-  //
-  // v0.41.13.0 ships the probe as opt-in (autopilot wiring deferred
-  // to T7 in the cathedral plan); this check skips with an enable
-  // hint until the probe has at least one audit event written.
-  checks.push({
-    name: 'conversation_parser_probe_health',
-    status: 'ok',
-    message:
-      'Skipped (nightly probe is opt-in; enable with ' +
-      '`gbrain config set autopilot.conversation_parser_probe.enabled true`)',
-  });
+  // Surfaces the last 7 days of nightly-probe audit events; warn on any
+  // non-pass outcome (fail / budget_exceeded / adversarial_false_positive).
+  // (Until the autopilot wire-up this was a hardcoded "Skipped" stub.)
+  try {
+    const { readRecentParserProbeEvents } = await import('../core/audit-parser-probe.ts');
+    let parserProbeEnabled = false;
+    try {
+      let dbVal: string | null = null;
+      let dbMode: string | null = null;
+      try {
+        dbVal = engine ? await engine.getConfig('autopilot.conversation_parser_probe.enabled') : null;
+        dbMode = engine ? await engine.getConfig('search.mode') : null;
+      } catch { /* DB unavailable → file plane only */ }
+      const { loadConfig } = await import('../core/config.ts');
+      const fileVal = (loadConfig() as any)?.autopilot?.conversation_parser_probe?.enabled;
+      const flagOn = dbVal != null ? dbVal === 'true' : fileVal === true;
+      parserProbeEnabled = flagOn || dbMode === 'tokenmax';
+    } catch { /* config unavailable → treat as disabled */ }
+    const parserEvents = readRecentParserProbeEvents(7);
+    checks.push(computeConversationParserProbeHealthCheck(parserProbeEnabled, parserEvents));
+  } catch {
+    // Best-effort; audit-log read failure shouldn't stop doctor.
+  }

  // 3e. home_dir_in_worktree (v0.35.8.0). Walks up from `gbrainPath()`
  // looking for a `.git` directory OR file. If found, warns: `~/.gbrain/`
@@ -581,7 +581,7 @@ async function embedPage(
  for (let j = 0; j < toEmbed.length; j++) {
    embeddingMap.set(toEmbed[j].chunk_index, embeddings[j]);
  }
-  const updated: ChunkInput[] = chunks.map(c => preserveCodeMetadata(c, {
+  const updated: ChunkInput[] = chunks.map(c => ({
    chunk_index: c.chunk_index,
    chunk_text: c.chunk_text,
    chunk_source: c.chunk_source,
@@ -605,31 +605,6 @@ async function embedPage(
  slog(`${slug}: embedded ${toEmbed.length} chunks`);
 }

-/**
- * Carry code-chunk metadata (language, symbol_name, symbol_type, line range,
- * parent scope, doc comment, qualified name) from a loaded Chunk back into a
- * ChunkInput destined for upsertChunks.
- *
- * Issue #769: every re-embed used to strip these fields, and upsertChunks
- * overwrites (does not COALESCE) the metadata columns from EXCLUDED, so
- * each pass clobbered code-def's primary index to NULL. Pulling the
- * preservation into one helper keeps the three re-embed call sites
- * (embedPage, embedAll non-stale, embedAllStale) in lock-step.
- */
-function preserveCodeMetadata(loaded: any, base: ChunkInput): ChunkInput {
-  return {
-    ...base,
-    language: loaded.language ?? undefined,
-    symbol_name: loaded.symbol_name ?? undefined,
-    symbol_type: loaded.symbol_type ?? undefined,
-    start_line: loaded.start_line ?? undefined,
-    end_line: loaded.end_line ?? undefined,
-    parent_symbol_path: loaded.parent_symbol_path ?? undefined,
-    doc_comment: loaded.doc_comment ?? undefined,
-    symbol_name_qualified: loaded.symbol_name_qualified ?? undefined,
-  };
-}
-
 async function embedAll(
  engine: BrainEngine,
  staleOnly: boolean,
@@ -742,10 +717,8 @@ async function embedAll(
      for (let j = 0; j < toEmbed.length; j++) {
        embeddingMap.set(toEmbed[j].chunk_index, embeddings[j]);
      }
-      // Preserve ALL chunks, only update embeddings for stale ones.
-      // preserveCodeMetadata threads code-chunk metadata (#769) so re-embed
-      // doesn't clobber language/symbol_name/symbol_type to NULL.
-      const updated: ChunkInput[] = chunks.map(c => preserveCodeMetadata(c, {
+      // Preserve ALL chunks, only update embeddings for stale ones
+      const updated: ChunkInput[] = chunks.map(c => ({
        chunk_index: c.chunk_index,
        chunk_text: c.chunk_text,
        chunk_source: c.chunk_source,
@@ -1039,10 +1012,7 @@ async function embedAllStale(
          for (let j = 0; j < stale.length; j++) {
            staleIdxToEmbedding.set(stale[j].chunk_index, embeddings[j]);
          }
-          // preserveCodeMetadata threads code-chunk metadata (#769) so the
-          // autopilot --stale path doesn't clobber language/symbol_name/etc
-          // to NULL on every cycle.
-          const merged: ChunkInput[] = existing.map(c => preserveCodeMetadata(c, {
+          const merged: ChunkInput[] = existing.map(c => ({
            chunk_index: c.chunk_index,
            chunk_text: c.chunk_text,
            chunk_source: c.chunk_source,
@@ -76,7 +76,7 @@ FLAGS:
                           dimensions (goal, depth, sourcing, specificity, useful).
  --cycles N               1-3. Default: 3 in TTY, 1 in non-TTY (T11). Each
                           cycle is 3 model calls; verdict aggregates over them.
-  --slot-a-model <id>      Override default 'openai:gpt-4o'.
+  --slot-a-model <id>      Override default 'openai:gpt-5.2'.
  --slot-b-model <id>      Override default 'anthropic:claude-opus-4-7'.
  --slot-c-model <id>      Override default 'google:gemini-1.5-pro'.
  --receipt-dir <path>     Default: gbrainPath('eval-receipts').
@@ -468,6 +468,14 @@ interface BatchRow {
  question_id: string;
  question: string;
  hypothesis: string;
+  /**
+   * Gold answer from the benchmark dataset, when the upstream eval emits
+   * it (eval-longmemeval does). Folded into the judge task so CORRECTNESS
+   * is verifiable — without it a judge panel that sees only
+   * {question, hypothesis} cannot validate a terse factual answer against
+   * a haystack it never saw.
+   */
+  answer?: string;
 }

 /**
@@ -581,6 +589,7 @@ function readBatchRows(path: string): BatchReadResult {
      question_id: typeof obj.question_id === 'string' ? obj.question_id : `line-${lineNo}`,
      question: obj.question,
      hypothesis: obj.hypothesis,
+      ...(typeof obj.answer === 'string' && obj.answer.length > 0 ? { answer: obj.answer } : {}),
    });
  }
  if (summarySkipped > 0) {
@@ -697,7 +706,11 @@ async function runBatchMode(parsed: ParsedArgs, opts: RunCrossModalOpts): Promis
      fn: async (row, idx) => {
        process.stderr.write(`[eval cross-modal batch] ${idx + 1}/${rows.length} ${row.question_id} starting...\n`);
        return await runEvalFn({
-          task: row.question,
+          // With a gold answer the judges can actually verify correctness;
+          // without one they see only {question, hypothesis} and cannot.
+          task: row.answer
+            ? `${row.question}\n\nExpected answer (gold label from the benchmark dataset): ${row.answer}`
+            : row.question,
          output: row.hypothesis,
          slug: row.question_id,
          dimensions,
@@ -33,6 +33,7 @@ import {
  type AliasMap,
 } from '../eval/longmemeval/extract.ts';
 import { extractCandidateEntities } from '../core/think/entity-extract.ts';
+import { splitProviderModelId } from '../core/model-id.ts';
 import { resolveEntitySlugWithSource, type ResolutionSource } from '../core/entities/resolve.ts';
 import { formatTrajectoryBlock } from '../core/trajectory-format.ts';

@@ -469,14 +470,22 @@ export async function runEvalLongMemEval(args: string[], runOpts: RunOpts = {}):
  });

  // Wrap Anthropic SDK so its `.messages.create` shape matches ThinkLLMClient.
-  // Same pattern as src/core/think/index.ts:247-249.
+  // Same pattern as src/core/think/index.ts:247-249 — EXCEPT think's default
+  // client routes through the gateway, which parses `provider:model` recipe
+  // ids. This eval's client is a raw SDK by design (hermetic, no gateway
+  // dependency), and resolveModel returns RECIPE ids (`anthropic:claude-…`);
+  // passing one through unstripped 404s every answer/extractor call, which
+  // surfaces downstream as all-upstream_error batches in the nightly probe.
+  const toSdkModel = (m: string): string => splitProviderModelId(m).model || m;
  const realClient = new Anthropic();
  const client: ThinkLLMClient = runOpts.client ?? {
-    create: (params, callOpts) => realClient.messages.create(params, callOpts),
+    create: (params, callOpts) =>
+      realClient.messages.create({ ...params, model: toSdkModel(params.model) }, callOpts),
  };
  // v0.40.2.0 — separate extractor client (defaults to same SDK).
  const extractorClient: ThinkLLMClient = runOpts.extractorClient ?? {
-    create: (params, callOpts) => realClient.messages.create(params, callOpts),
+    create: (params, callOpts) =>
+      realClient.messages.create({ ...params, model: toSdkModel(params.model) }, callOpts),
  };
  const trajectoryEnabled = !opts.noTrajectory;
  const extractorModel = trajectoryEnabled
@@ -751,6 +760,11 @@ async function runOneQuestion(
    // v0.40.1.0 (Track D / T2) — copy question_type into the row so the
    // by_type_summary can be rebuilt from the file on resume runs.
    question_type: q.question_type,
+    // Gold answer for downstream consumers that verify correctness (the
+    // cross-modal --batch judge folds it into the task; evaluate_qa.py
+    // ignores unknown fields). Without it a judge can't validate a terse
+    // factual hypothesis against a haystack it never saw.
+    ...(q.answer !== undefined ? { answer: q.answer } : {}),
    hypothesis,
    retrieved_session_ids: retrievedSessionIds,
    ...(recallHit !== undefined ? { recall_hit: recallHit } : {}),
@@ -1651,7 +1651,7 @@ async function extractTimelineFromDB(
 * make re-extraction idempotent). EVERY processed page is stamped, including
 * zero-link pages — they WERE processed.
 */
-export async function extractStaleFromDB(
+async function extractStaleFromDB(
  engine: BrainEngine,
  opts: {
    dryRun: boolean;
@@ -1,224 +0,0 @@
-/**
- * gbrain maintain — conservative self-healing maintenance.
- *
- * This command automates the safe parts of the operator runbook:
- *   - stale link/timeline extraction
- *   - stale per-source dream cycles when doctor reports cycle_freshness
- *
- * It deliberately does NOT mutate source files, apply schema-pack upgrades, or
- * invent semantic hub links. Those need review or a separate command with an
- * auditable proposal surface.
- */
-
-import { existsSync } from 'fs';
-import type { BrainEngine } from '../core/engine.ts';
-import type { BrainHealth } from '../core/types.ts';
-import { buildChecks, computeDoctorReport, type DoctorReport, type Check } from './doctor.ts';
-import { extractStaleFromDB } from './extract.ts';
-import { runCycle, type CycleReport } from '../core/cycle.ts';
-
-type ActionStatus = 'ok' | 'would_apply' | 'applied' | 'blocked' | 'skipped';
-
-export interface MaintenanceAction {
-  name: string;
-  status: ActionStatus;
-  message: string;
-  details?: Record<string, unknown>;
-}
-
-export interface MaintainOptions {
-  json: boolean;
-  safe: boolean;
-  dryRun: boolean;
-  help: boolean;
-}
-
-export interface MaintainReport {
-  mode: 'dry-run' | 'safe';
-  before: {
-    health: BrainHealth;
-    doctor: DoctorReport;
-  };
-  actions: MaintenanceAction[];
-  after: {
-    health: BrainHealth;
-    doctor: DoctorReport;
-  };
-}
-
-export function parseMaintainArgs(args: string[]): MaintainOptions {
-  const safe = args.includes('--safe');
-  return {
-    json: args.includes('--json'),
-    safe,
-    dryRun: args.includes('--dry-run') || !safe,
-    help: args.includes('--help') || args.includes('-h'),
-  };
-}
-
-export function extractCycleFreshnessSourceIds(checks: Check[]): string[] {
-  const ids = new Set<string>();
-  for (const check of checks) {
-    if (check.name !== 'cycle_freshness' || check.status === 'ok') continue;
-    const re = /Source '([^']+)' last cycled/g;
-    for (const match of check.message.matchAll(re)) {
-      const id = match[1]?.trim();
-      if (id) ids.add(id);
-    }
-  }
-  return [...ids].sort();
-}
-
-async function buildDoctorReport(engine: BrainEngine): Promise<DoctorReport> {
-  const checks = await buildChecks(engine, ['--json', '--scope=brain']);
-  return computeDoctorReport(checks);
-}
-
-async function runStaleExtraction(
-  engine: BrainEngine,
-  beforeHealth: BrainHealth,
-  dryRun: boolean,
-): Promise<MaintenanceAction> {
-  if (beforeHealth.stale_pages <= 0) {
-    return { name: 'extract_stale', status: 'ok', message: 'No stale pages.' };
-  }
-
-  if (dryRun) {
-    return {
-      name: 'extract_stale',
-      status: 'would_apply',
-      message: `Would run DB-backed stale extraction for ${beforeHealth.stale_pages} page(s).`,
-      details: { stale_pages: beforeHealth.stale_pages },
-    };
-  }
-
-  const result = await extractStaleFromDB(engine, {
-    dryRun: false,
-    jsonMode: false,
-    includeFrontmatter: false,
-    catchUp: false,
-  });
-
-  return {
-    name: 'extract_stale',
-    status: 'applied',
-    message: `Processed ${result.pagesProcessed} stale page(s); ${result.staleRemaining} remain.`,
-    details: {
-      links_created: result.linksCreated,
-      timeline_created: result.timelineCreated,
-      pages_processed: result.pagesProcessed,
-      stale_remaining: result.staleRemaining,
-    },
-  };
-}
-
-async function runCycleFreshnessMaintenance(
-  engine: BrainEngine,
-  beforeDoctor: DoctorReport,
-  dryRun: boolean,
-): Promise<MaintenanceAction[]> {
-  const sourceIds = extractCycleFreshnessSourceIds(beforeDoctor.checks);
-  if (sourceIds.length === 0) {
-    return [{ name: 'cycle_freshness', status: 'ok', message: 'All sources cycled recently.' }];
-  }
-
-  if (dryRun) {
-    return sourceIds.map((sourceId) => ({
-      name: 'cycle_freshness',
-      status: 'would_apply',
-      message: `Would run source-scoped dream cycle for ${sourceId}.`,
-      details: { source_id: sourceId },
-    }));
-  }
-
-  const sources = await engine.listAllSources();
-  const actions: MaintenanceAction[] = [];
-
-  for (const sourceId of sourceIds) {
-    const source = sources.find((s) => s.id === sourceId);
-    const localPath = source?.local_path ?? null;
-    const brainDir = localPath && existsSync(localPath) ? localPath : null;
-    const report: CycleReport = await runCycle(engine, {
-      brainDir,
-      dryRun: false,
-      pull: false,
-      sourceId,
-    });
-    actions.push({
-      name: 'cycle_freshness',
-      status: report.status === 'failed' ? 'blocked' : 'applied',
-      message: `Ran source-scoped dream cycle for ${sourceId}: ${report.status}.`,
-      details: {
-        source_id: sourceId,
-        brain_dir: brainDir,
-        cycle_status: report.status,
-        phases: report.phases.map((p) => ({ phase: p.phase, status: p.status })),
-      },
-    });
-  }
-
-  return actions;
-}
-
-export async function runMaintain(engine: BrainEngine, args: string[]): Promise<MaintainReport | void> {
-  const opts = parseMaintainArgs(args);
-  if (opts.help) {
-    console.log(`Usage: gbrain maintain [--safe] [--dry-run] [--json]
-
-Conservative self-healing maintenance.
-
-Modes:
-  --dry-run   Preview safe actions without writes. Default when --safe is absent.
-  --safe      Apply safe actions: stale extraction and source cycle freshness.
-  --json      Emit a structured before/action/after report.
-
-Not auto-applied:
-  source-file frontmatter fixes, schema-pack upgrades, atom-pack changes,
-  semantic hub-link guesses, and destructive cleanup.
-`);
-    return;
-  }
-
-  const beforeHealth = await engine.getHealth();
-  const beforeDoctor = await buildDoctorReport(engine);
-  const actions: MaintenanceAction[] = [];
-
-  actions.push(await runStaleExtraction(engine, beforeHealth, opts.dryRun));
-  actions.push(...await runCycleFreshnessMaintenance(engine, beforeDoctor, opts.dryRun));
-
-  const afterHealth = await engine.getHealth();
-  const afterDoctor = await buildDoctorReport(engine);
-  const report: MaintainReport = {
-    mode: opts.dryRun ? 'dry-run' : 'safe',
-    before: { health: beforeHealth, doctor: beforeDoctor },
-    actions,
-    after: { health: afterHealth, doctor: afterDoctor },
-  };
-
-  if (opts.json) {
-    console.log(JSON.stringify(report, null, 2));
-  } else {
-    printMaintainReport(report);
-  }
-  return report;
-}
-
-function printMaintainReport(report: MaintainReport): void {
-  console.log(`GBrain maintain (${report.mode})`);
-  console.log(
-    `Before: brain_score=${Math.round(report.before.health.brain_score)}/100 ` +
-    `stale=${report.before.health.stale_pages} islands=${report.before.health.orphan_pages} ` +
-    `doctor=${report.before.doctor.status}`,
-  );
-  for (const action of report.actions) {
-    console.log(`  ${action.status}: ${action.name} — ${action.message}`);
-  }
-  console.log(
-    `After:  brain_score=${Math.round(report.after.health.brain_score)}/100 ` +
-    `stale=${report.after.health.stale_pages} islands=${report.after.health.orphan_pages} ` +
-    `doctor=${report.after.doctor.status}`,
-  );
-  if (report.mode === 'dry-run') {
-    console.log('Run `gbrain maintain --safe` to apply safe actions.');
-  }
-}
@@ -15,11 +15,6 @@
 import type { BrainEngine } from '../core/engine.ts';
 import { createProgress, startHeartbeat } from '../core/progress.ts';
 import { getCliOptions, cliOptsToProgressOptions } from '../core/cli-options.ts';
-import {
-  shouldExcludeFromOrphanReporting,
-  loadOrphanPolicyOverrides,
-  type OrphanPolicyOverrides,
-} from '../core/orphan-policy.ts';

 // --- Types ---

@@ -37,14 +32,65 @@ export interface OrphanResult {
  excluded: number;
 }

+// --- Filter constants ---
+
+/** Slug suffixes that are always auto-generated root files */
+const AUTO_SUFFIX_PATTERNS = ['/_index', '/log'];
+
+/** Page slugs that are pseudo-pages by convention */
+const PSEUDO_SLUGS = new Set(['_atlas', '_index', '_stats', '_orphans', '_scratch', 'claude']);
+
+/** Slug segment that marks raw sources */
+const RAW_SEGMENT = '/raw/';
+
+/** Slug prefixes where no inbound links is expected */
+const DENY_PREFIXES = [
+  'output/',
+  'dashboards/',
+  'scripts/',
+  'templates/',
+  'openclaw/config/',
+];
+
+/** First slug segments where no inbound links is expected */
+const FIRST_SEGMENT_EXCLUSIONS = new Set([
+  'scratch',
+  'thoughts',
+  'catalog',
+  'entities',
+  'raw',
+  'atoms',
+  'skills',
+]);
+
 // --- Filter logic ---

 /**
 * Returns true if a slug should be excluded from orphan reporting by default.
 * These are pages where having no inbound links is expected / not a content problem.
 */
-export function shouldExclude(slug: string, overrides?: OrphanPolicyOverrides): boolean {
-  return shouldExcludeFromOrphanReporting(slug, overrides);
+export function shouldExclude(slug: string): boolean {
+  // Pseudo-pages (exact match)
+  if (PSEUDO_SLUGS.has(slug)) return true;
+
+  // Auto-generated suffix patterns
+  for (const suffix of AUTO_SUFFIX_PATTERNS) {
+    if (slug.endsWith(suffix)) return true;
+  }
+
+  // Raw source slugs
+  if (slug.includes(RAW_SEGMENT)) return true;
+
+  // Deny-prefix slugs
+  for (const prefix of DENY_PREFIXES) {
+    if (slug.startsWith(prefix)) return true;
+  }
+
+  // First-segment exclusions
+  const firstSegment = slug.split('/')[0];
+  if (FIRST_SEGMENT_EXCLUSIONS.has(firstSegment)) return true;
+
+  return false;
 }

 /**
@@ -110,7 +156,6 @@ export async function findOrphans(
  let allOrphans: { slug: string; title: string; domain: string | null }[];
  let total: number;
  let excludedAll: number;
-  const overrides = includePseudo ? undefined : await loadOrphanPolicyOverrides(engine);
  try {
    allOrphans = await engine.findOrphanPages(
      sourceIds ? { sourceIds } : sourceId ? { sourceId } : undefined,
@@ -139,7 +184,7 @@ export async function findOrphans(
    total = liveRows.length;
    excludedAll = includePseudo
      ? 0
-      : liveRows.reduce((n, r) => n + (shouldExclude(r.slug, overrides) ? 1 : 0), 0);
+      : liveRows.reduce((n, r) => n + (shouldExclude(r.slug) ? 1 : 0), 0);
  } finally {
    stopHb();
    progress.finish();
@@ -147,7 +192,7 @@ export async function findOrphans(

  const filtered = includePseudo
    ? allOrphans
-    : allOrphans.filter(row => !shouldExclude(row.slug, overrides));
+    : allOrphans.filter(row => !shouldExclude(row.slug));

  const orphans: OrphanPage[] = filtered.map(row => ({
    slug: row.slug,
@@ -0,0 +1,63 @@
+/**
+ * Nightly conversation-parser probe audit trail.
+ *
+ * One event per REAL probe run lands in
+ * `~/.gbrain/audit/parser-probe-YYYY-Www.jsonl` (ISO-week rotation via the
+ * shared audit-writer primitive; honors `GBRAIN_AUDIT_DIR`).
+ * Scheduler-cadence skips (`rate_limited`) are NOT logged — the autopilot
+ * loop ticks every few minutes, so logging every skip would flood the
+ * audit file with rows that carry no signal.
+ *
+ * Read by `gbrain doctor`'s `conversation_parser_probe_health` check and
+ * by the autopilot wiring's 24h rate-limit gate (`parserProbeRanWithin`).
+ */
+
+import { createAuditWriter } from './audit/audit-writer.ts';
+import type { NightlyProbeResult } from './conversation-parser/nightly-probe.ts';
+
+export type ParserProbeAuditEvent = NightlyProbeResult;
+
+const writer = createAuditWriter<ParserProbeAuditEvent>({
+  featureName: 'parser-probe',
+  errorLabel: 'gbrain',
+  errorMessagePrefix: 'parser-probe audit ',
+  errorTrailer: '; probe continues',
+});
+
+/** Append one parser-probe event. Best-effort; never throws. */
+export function logParserProbeEvent(event: ParserProbeAuditEvent): void {
+  writer.log(event);
+}
+
+/**
+ * Read recent parser-probe events (current + previous ISO week, filtered
+ * to the window). Missing files and corrupt rows are skipped silently.
+ */
+export function readRecentParserProbeEvents(
+  days = 7,
+  now: Date = new Date(),
+): ParserProbeAuditEvent[] {
+  return writer.readRecent(days, now);
+}
+
+/** Exposed for tests pinning the rotation edge cases. */
+export function computeParserProbeAuditFilename(now: Date = new Date()): string {
+  return writer.computeFilename(now);
+}
+
+/**
+ * 24h rate-limit gate for the autopilot wiring: true when any audited run
+ * happened within `windowMs` of `now`. Only REAL outcomes are audited (see
+ * module header), so a pass/fail today blocks re-runs until tomorrow while
+ * scheduler-cadence skips never extend the window.
+ */
+export function parserProbeRanWithin(
+  windowMs: number,
+  now: Date = new Date(),
+): boolean {
+  const cutoff = now.getTime() - windowMs;
+  return readRecentParserProbeEvents(2, now).some((ev) => {
+    const ts = Date.parse(ev.ts);
+    return Number.isFinite(ts) && ts >= cutoff;
+  });
+}
@@ -105,6 +105,16 @@ export interface GBrainConfig {
       */
      max_usd?: number;
    };
+    /**
+     * v0.41.16.0 — nightly conversation-parser probe. Per D10: default ON
+     * for `search.mode=tokenmax` brains, opt-in for conservative/balanced.
+     * ~$0.05/night with the committed fixtures × Haiku polish. Gated
+     * INSIDE the autopilot tick body, like nightly_quality_probe.
+     */
+    conversation_parser_probe?: {
+      /** Enable for non-tokenmax modes. Defaults to false. */
+      enabled?: boolean;
+    };
    /**
     * v0.42.x (#1685 GAP D) — extract_atoms backlog auto-drain. Default ON so a
     * pack-gated silent backlog never piles up unseen; daily-spend-capped so the
@@ -816,25 +826,6 @@ export async function loadConfigWithEngine(
    merged.dream = mergedDream;
  }

-  // #1475: eval.* DB-plane merge. `gbrain config set eval.capture true`
-  // writes the DB plane (both keys are in KNOWN_CONFIG_KEYS, so `set`
-  // accepts them silently), but the capture gate (isEvalCaptureEnabled)
-  // reads the merged config. Without this merge the DB value was written
-  // and never read — capture only fired via GBRAIN_CONTRIBUTOR_MODE=1.
-  // Sparse per-key merge: file/env wins per key, DB fills the gaps.
-  const dbEvalCapture = await dbBool('eval.capture');
-  const dbEvalScrub = await dbBool('eval.scrub_pii');
-  const mergedEval: NonNullable<GBrainConfig['eval']> = { ...(merged.eval ?? {}) };
-  if (mergedEval.capture === undefined && dbEvalCapture !== undefined) {
-    mergedEval.capture = dbEvalCapture;
-  }
-  if (mergedEval.scrub_pii === undefined && dbEvalScrub !== undefined) {
-    mergedEval.scrub_pii = dbEvalScrub;
-  }
-  if (Object.keys(mergedEval).length > 0) {
-    merged.eval = mergedEval;
-  }
-
  return merged;
 }

@@ -54,7 +54,6 @@ import {
 import {
  generatePerChunkSynopsis,
  SYNOPSIS_PROMPT_VERSION,
-  SYNOPSIS_DOC_MAX_CHARS,
  type GeneratePerChunkSynopsisResult,
 } from './page-summary.ts';
 import {
@@ -104,17 +103,8 @@ function getEmbeddingModelTag(): string {
 export function computeCorpusGeneration(args: {
  crMode: CRMode;
  haikuModel: string;
-  /**
-   * Resolved `SYNOPSIS_DOC_MAX_CHARS` for per_chunk_synopsis runs. When
-   * present, folded into the hash so changes to
-   * `GBRAIN_SYNOPSIS_DOC_MAX_CHARS` invalidate the prior cache cleanly.
-   * Omit for `crMode !== 'per_chunk_synopsis'` — title / none modes
-   * don't consult the cap and the field stays out of the hash for
-   * back-compat with pre-cap embeddings.
-   */
-  synopsisDocMaxChars?: number;
 }): string {
-  const h = createHash('sha256')
+  return createHash('sha256')
    .update(args.crMode)
    .update('|')
    .update(String(SYNOPSIS_PROMPT_VERSION))
@@ -123,11 +113,9 @@ export function computeCorpusGeneration(args: {
    .update('|')
    .update(String(TITLE_WRAPPER_VERSION))
    .update('|')
-    .update(getEmbeddingModelTag());
-  if (args.synopsisDocMaxChars !== undefined) {
-    h.update('|doc_cap=').update(String(args.synopsisDocMaxChars));
-  }
-  return h.digest('hex').slice(0, 16);
+    .update(getEmbeddingModelTag())
+    .digest('hex')
+    .slice(0, 16);
 }

 /**
@@ -265,11 +253,7 @@ export async function reembedPageWithContextualRetrieval(
      args.pageSlug,
      args.sourceId,
      resolution.mode,
-      computeCorpusGeneration({
-        crMode: resolution.mode,
-        haikuModel: args.haikuModel ?? DEFAULT_HAIKU_MODEL,
-        synopsisDocMaxChars: resolution.mode === 'per_chunk_synopsis' ? SYNOPSIS_DOC_MAX_CHARS : undefined,
-      }),
+      computeCorpusGeneration({ crMode: resolution.mode, haikuModel: args.haikuModel ?? DEFAULT_HAIKU_MODEL }),
    );
    return { kind: 'skipped', reason: 'no_chunks' };
  }
@@ -298,7 +282,6 @@ export async function reembedPageWithContextualRetrieval(
      const corpus_generation = computeCorpusGeneration({
        crMode: attemptMode,
        haikuModel,
-        synopsisDocMaxChars: attemptMode === 'per_chunk_synopsis' ? SYNOPSIS_DOC_MAX_CHARS : undefined,
      });

      // ── PHASE 2: single DB transaction ───────────────────────────
@@ -17,11 +17,11 @@
 * Cost: ~$0.05/night with default fixtures × Haiku polish. Bounded
 * by the active BudgetTracker the autopilot loop creates per-tick.
 *
- * **Wiring into the autopilot loop is deferred to a follow-up**
- * (filed in TODOS.md). v0.41.16.0 ships the phase as a callable
- * module so doctor + future cron drivers can invoke it; the
- * scheduler wire-up follows the same shape as
- * `src/core/cycle/nightly-quality-probe.ts` (v0.40.1.0 Track D / T6).
+ * Wired into the autopilot loop (step 4.6 in autopilot.ts), following
+ * the same shape as `src/core/cycle/nightly-quality-probe.ts`
+ * (v0.40.1.0 Track D / T6): the wiring resolves fixtures from the
+ * gbrain package root, writes real outcomes to the parser-probe audit
+ * trail (`audit-parser-probe.ts`), and never crashes the loop.
 *
 * Test seam: all dependencies are injected via NightlyProbeDeps so
 * unit tests don't touch real LLMs or real fixtures.
@@ -44,7 +44,12 @@ export const DEFAULT_DIMENSIONS: string[] = [
 * `--slot-a-model`, `--slot-b-model`, `--slot-c-model` on the CLI.
 */
 export const DEFAULT_SLOTS: SlotConfig[] = [
-  { id: 'A', model: 'openai:gpt-4o' },
+  // Every default MUST be listed in its recipe's chat touchpoint (pinned by
+  // test/cross-modal-default-slots.test.ts) — `openai:gpt-4o` sat here after
+  // the OpenAI recipe dropped it, so slot A errored "not listed for OpenAI
+  // chat" on every install and the 3-slot panel could never reach its
+  // 2-model quorum without a Google key (verdict: permanently inconclusive).
+  { id: 'A', model: 'openai:gpt-5.2' },
  { id: 'B', model: 'anthropic:claude-opus-4-7' },
  { id: 'C', model: 'google:gemini-1.5-pro' },
 ];
@@ -70,6 +70,28 @@ export async function runLongMemEvalForProbe(args: LongMemEvalProbeArgs): Promis
 * the batch input) or unparseable (cross-modal wrote garbage). Both
 * cases are paste-ready in the error message.
 */
+/**
+ * QA-shaped judge dimensions for the nightly probe. The batch judge's
+ * DEFAULT_DIMENSIONS rubric (DEPTH / SOURCING / SPECIFICITY / …) is built
+ * for rich agent responses; LongMemEval hypotheses are deliberately terse
+ * factual answers ("in widget-co") that can never score ≥7 on DEPTH or
+ * SOURCING — so with the default rubric the probe FAILs every night even
+ * when retrieval + answering are perfectly healthy. The probe owns its
+ * invocation of the eval tool and passes dimensions matching the
+ * fixture's QA shape instead.
+ *
+ * NOTE: the `--dimensions` CLI flag splits on commas, so these dimension
+ * descriptions must stay comma-free.
+ */
+export const PROBE_QA_DIMENSIONS: string[] = [
+  // No faithfulness/grounding dimension on purpose: the judge never sees
+  // the haystack, so any accurate detail beyond the terse gold label reads
+  // as "invented" and correct answers fail (verified empirically — a
+  // correct "before + dates" answer scored 4/10 on such a dimension).
+  'CORRECTNESS — Does the hypothesis state the same fact as the expected answer? A terse direct answer is ideal.',
+  'DIRECTNESS — Does it answer THIS question without hedging or padding or answering something else?',
+];
+
 export async function runCrossModalBatchForProbe(
  args: CrossModalProbeArgs,
 ): Promise<{ exitCode: number; summary: CrossModalBatchSummary }> {
@@ -81,6 +103,8 @@ export async function runCrossModalBatchForProbe(
    args.summaryPath,
    '--max-usd',
    String(args.maxUsd),
+    '--dimensions',
+    PROBE_QA_DIMENSIONS.join(','),
    '--yes',
    '--json',
  ]);
@@ -62,6 +62,42 @@ export interface NightlyProbeDeps {
  now: () => Date;
 }

+/**
+ * Dual-plane flag resolution (same precedent as `mcp.publish_skills` in
+ * serve-http.ts): the DB config row — what `gbrain config set` writes —
+ * wins when present; the file plane (~/.gbrain/config.json) is the
+ * fallback. Doctor's paste-ready enable hint says `gbrain config set
+ * autopilot.nightly_quality_probe.enabled true`, so the gate MUST read
+ * the DB plane — a file-only read turns that hint into a silent no-op.
+ */
+export function resolveProbeEnabled(
+  dbVal: string | null | undefined,
+  fileVal: unknown,
+): boolean {
+  if (dbVal != null) return dbVal === 'true';
+  return fileVal === true;
+}
+
+/**
+ * Same dual-plane rule for the per-run cost cap. Malformed or negative
+ * values on either plane fall through to the next plane / the default.
+ */
+export function resolveProbeMaxUsd(
+  dbVal: string | null | undefined,
+  fileVal: unknown,
+  fallback: number = DEFAULT_MAX_USD,
+): number {
+  if (dbVal != null) {
+    const n = Number(dbVal);
+    if (Number.isFinite(n) && n >= 0) return n;
+  }
+  if (fileVal != null) {
+    const n = Number(fileVal);
+    if (Number.isFinite(n) && n >= 0) return n;
+  }
+  return fallback;
+}
+
 /**
 * Pure function: decide whether the probe should run given the audit
 * history. Returns reason when skipping.
@@ -101,21 +137,17 @@ export async function runNightlyQualityProbe(deps: NightlyProbeDeps): Promise<Ni
    return { outcome: 'disabled', exit_code: 0, detail: 'feature flag off' };
  }

-  // 24h rate limit — skip + audit "rate_limited".
+  // 24h rate limit — skip WITHOUT an audit row. The autopilot loop invokes
+  // the probe every cycle (~5-10 min), so all but one invocation per day
+  // lands here; logging each skip floods the audit file (~hundreds of
+  // rows/day) and — because doctor treats any non-pass outcome as bad
+  // signal — flips nightly_quality_probe_health to a permanent WARN the
+  // moment the probe is enabled. A skip is a non-event: the real runs are
+  // the signal, and their rows are what gates the next 24h window.
  const now = deps.now();
  const recent = readRecentQualityProbeEvents(2, now); // 2-day window is enough for 24h check
  const decision = shouldRunNightly(now, recent);
  if (!decision.run) {
-    logQualityProbeEvent({
-      outcome: 'rate_limited',
-      exit_code: 0,
-      pass_count: 0,
-      fail_count: 0,
-      inconclusive_count: 0,
-      error_count: 0,
-      est_cost_usd: 0,
-      detail: 'already ran within 24h window',
-    });
    return { outcome: 'rate_limited', exit_code: 0, detail: 'already ran within 24h' };
  }

@@ -251,14 +251,6 @@ registerBackgroundWorkDrainer({
 export function isEvalCaptureEnabled(config: GBrainConfig | null | undefined): boolean {
  if (config?.eval?.capture === true) return true;
  if (config?.eval?.capture === false) return false;
-  // #1475: DB-plane stash. `gbrain config set eval.capture true` lands in the
-  // config table; connectEngine stamps the merged value here because
-  // ctx.config is the sync file-plane load and never sees the DB plane.
-  // Explicit per-key setting (file above, DB here) beats the broad
-  // CONTRIBUTOR_MODE flag, matching how file-plane `false` already wins.
-  // Doubles as a direct operator env knob.
-  if (process.env.GBRAIN_EVAL_CAPTURE === 'true') return true;
-  if (process.env.GBRAIN_EVAL_CAPTURE === 'false') return false;
  return process.env.GBRAIN_CONTRIBUTOR_MODE === '1';
 }

@@ -271,8 +263,5 @@ export function isEvalCaptureEnabled(config: GBrainConfig | null | undefined): b
 * have explicit `capture: true`.
 */
 export function isEvalScrubEnabled(config: GBrainConfig | null | undefined): boolean {
-  if (config?.eval?.scrub_pii === false) return false;
-  if (config?.eval?.scrub_pii === true) return true;
-  // #1475: DB-plane stash — see isEvalCaptureEnabled. Default stays true.
-  return process.env.GBRAIN_EVAL_SCRUB_PII !== 'false';
+  return config?.eval?.scrub_pii !== false;
 }
@@ -733,11 +733,6 @@ export async function importFromContent(
      : computeCorpusGeneration({
          crMode: effectiveCRMode,
          haikuModel: 'anthropic:claude-haiku-4-5-20251001',
-          // Inline import-file path never uses per_chunk_synopsis (refuses
-          // upstream); pass undefined so the doc-cap field stays out of
-          // the hash here. Per_chunk_synopsis runs through the Minion
-          // backfill handler which threads SYNOPSIS_DOC_MAX_CHARS through
-          // the service layer.
        });

  // Transaction wraps all DB writes. Every per-page tx call carries the
@@ -489,22 +489,7 @@ export async function extractPageLinks(
      // text inside `[[...]]` before any `|`), NOT the display alias
      // (ref.name = match[2]). `[[struktura|the project]]` must resolve
      // `struktura`, not "the project". The display text is for context only.
-      //
-      // The literal may be path-qualified (`[[notes/struktura]]`). The FS
-      // path (resolveSlugAll) strips the dirname before its basename lookup,
-      // but this path passed the raw literal to an index keyed by final
-      // segments only — so every slash-containing wikilink outside
-      // DIR_PATTERN silently resolved to nothing. Query by the final
-      // segment, then use the written path as a disambiguation filter
-      // (the analogue of the FS ancestor walk honoring the written path):
-      // a match must end with the literal, so `[[notes/struktura]]` can
-      // resolve to `vault/notes/struktura` but never to `wiki/struktura`.
-      const slashIdx = ref.slug.lastIndexOf('/');
-      const basename = slashIdx === -1 ? ref.slug : ref.slug.slice(slashIdx + 1);
-      let matches = await resolver.resolveBasenameMatches(basename);
-      if (slashIdx !== -1) {
-        matches = matches.filter(m => m === ref.slug || m.endsWith(`/${ref.slug}`));
-      }
+      const matches = await resolver.resolveBasenameMatches(ref.slug);
      if (matches.length === 0) continue;
      const idx = content.indexOf(ref.slug);
      const context = idx >= 0 ? excerpt(content, idx, 240) : ref.name;
@@ -75,6 +75,11 @@ export const CANONICAL_PRICING: Record<string, ModelPricing> = {
  'openai:gpt-4o':                        { input:  2.50, output: 10.00 },
  'openai:gpt-4o-mini':                   { input:  0.15, output:  0.60 },
  'openai:gpt-5':                         { input:  5.00, output: 20.00 },
+  // gpt-5.2: rates from the OpenAI recipe chat touchpoint (verified
+  // 2026-04-20). Needed here because it's the cross-modal DEFAULT_SLOTS
+  // slot-A model — without a canonical entry estimateCost silently drops
+  // slot A from the --max-usd pre-flight and est_cost_usd audit rows.
+  'openai:gpt-5.2':                       { input:  1.25, output: 10.00 },
  'openai:gpt-5.5':                       { input:  4.00, output: 16.00 },

  // ── Google ─────────────────────────────────────────────────────────────
@@ -1,116 +0,0 @@
-/**
- * Shared orphan-reporting exclusion policy.
- *
- * These are pages where "no inbound links" is expected and should not count
- * against health. Keep this in core so the CLI orphan report and engine health
- * dashboard cannot drift.
- *
- * Defaults are GBrain-wide conventions only. Brain-specific exclusions
- * (private folder names, one-off fixture slugs) belong in the brain's own
- * config, not here:
- *
- *   gbrain config set orphans.exclude_prefixes "my-private-folder/,archive/"
- *   gbrain config set orphans.exclude_slugs "some-one-off-page"
- */
-
-const AUTO_SUFFIX_PATTERNS = ['/_index', '/log'];
-
-const PSEUDO_SLUGS = new Set(['_atlas', '_index', '_stats', '_orphans', '_scratch', 'claude']);
-
-const RAW_SEGMENT = '/raw/';
-
-const DENY_PREFIXES = [
-  'output/',
-  'dashboards/',
-  'scripts/',
-  'templates/',
-  '_templates/',
-  'openclaw/config/',
-  'extracts/',
-];
-
-const FIRST_SEGMENT_EXCLUSIONS = new Set([
-  'scratch',
-  'thoughts',
-  'catalog',
-  'entities',
-  'raw',
-  'atoms',
-  'skills',
-  'dreaming',
-  'daily',
-]);
-
-const ROOT_DATE_SLUG = /^\d{4}-\d{2}-\d{2}(?:-.+)?$/;
-
-function isAgentWorkspaceConvention(slug: string): boolean {
-  if (!slug.startsWith('agents/')) return false;
-  if (slug.includes('/memory/dreaming/')) return true;
-  return /^agents\/[^/]+\/(?:agents|identity|soul|tools|user|heartbeat|dreams|dormant)$/.test(slug);
-}
-
-/** Per-brain additions to the convention defaults (from config). */
-export interface OrphanPolicyOverrides {
-  excludePrefixes?: string[];
-  excludeSlugs?: string[];
-}
-
-/** Config keys for per-brain orphan exclusions (comma-separated values). */
-export const ORPHAN_EXCLUDE_PREFIXES_KEY = 'orphans.exclude_prefixes';
-export const ORPHAN_EXCLUDE_SLUGS_KEY = 'orphans.exclude_slugs';
-
-function parseList(value: string | null): string[] {
-  if (!value) return [];
-  return value.split(',').map(s => s.trim()).filter(Boolean);
-}
-
-/**
- * Load per-brain orphan exclusions from the brain config table. Callers with
- * an engine in hand (getHealth, `gbrain orphans`) pass the result as the
- * second argument to shouldExcludeFromOrphanReporting.
- */
-export async function loadOrphanPolicyOverrides(
-  engine: { getConfig(key: string): Promise<string | null> },
-): Promise<OrphanPolicyOverrides> {
-  const [prefixes, slugs] = await Promise.all([
-    engine.getConfig(ORPHAN_EXCLUDE_PREFIXES_KEY),
-    engine.getConfig(ORPHAN_EXCLUDE_SLUGS_KEY),
-  ]);
-  return { excludePrefixes: parseList(prefixes), excludeSlugs: parseList(slugs) };
-}
-
-export function shouldExcludeFromOrphanReporting(
-  slug: string,
-  overrides?: OrphanPolicyOverrides,
-): boolean {
-  if (PSEUDO_SLUGS.has(slug)) return true;
-
-  for (const suffix of AUTO_SUFFIX_PATTERNS) {
-    if (slug.endsWith(suffix)) return true;
-  }
-
-  if (slug.includes(RAW_SEGMENT)) return true;
-  if (slug.includes('/daily/')) return true;
-
-  for (const prefix of DENY_PREFIXES) {
-    if (slug.startsWith(prefix)) return true;
-  }
-
-  const firstSegment = slug.split('/')[0];
-  if (FIRST_SEGMENT_EXCLUSIONS.has(firstSegment)) return true;
-
-  if (ROOT_DATE_SLUG.test(slug)) return true;
-
-  if (slug.startsWith('_brain-')) return true;
-
-  if (isAgentWorkspaceConvention(slug)) return true;
-
-  if (overrides) {
-    if (overrides.excludeSlugs?.includes(slug)) return true;
-    for (const prefix of overrides.excludePrefixes ?? []) {
-      if (slug.startsWith(prefix)) return true;
-    }
-  }
-
-  return false;
-}
@@ -44,33 +44,6 @@ const HAIKU_MAX_TOKENS = 200;
 /** Default model when caller doesn't override. Resolves through the gateway. */
 const DEFAULT_SYNOPSIS_MODEL = 'anthropic:claude-haiku-4-5-20251001';

-/**
- * Hard cap on `documentText` length (chars) before send.
- *
- * 2026-05-25 fix wave: small local chat models (Gemma 4 E2B, Qwen3 4B) get
- * dramatically slower on long contexts even with 131K-token windows declared.
- * A 73K-char page synopsis on Gemma 4 E2B takes 60-120s, exceeding the
- * worker's default 30s `lockDuration` and tripping `lock-lost` errors.
- *
- * Truncate to a budget that fits a small model's effective throughput while
- * preserving enough document context for the synopsis to be useful. Truncates
- * the TAIL because the head (title, frontmatter, intro) carries the
- * document-level anchor the synopsis needs.
- *
- * Override per workload via `GBRAIN_SYNOPSIS_DOC_MAX_CHARS`. Default 32768
- * (~8K tokens at 4 chars/tok) keeps small-model synopsis under ~30s.
- * Anthropic Haiku is unaffected at this cap; bump higher when running
- * frontier models if you want richer document anchoring.
- */
-export const SYNOPSIS_DOC_MAX_CHARS = (() => {
-  const env = process.env.GBRAIN_SYNOPSIS_DOC_MAX_CHARS;
-  if (env && /^\d+$/.test(env)) {
-    const n = parseInt(env, 10);
-    if (n >= 512 && n <= 1_048_576) return n;
-  }
-  return 32768;
-})();
-
 /**
 * Synopsis prompt version. Folded into corpus_generation so prompt edits
 * invalidate prior embeddings via the v0.40.3.0 query_cache.page_generations
@@ -215,19 +188,11 @@ function buildUserPrompt(
  documentText: string,
  chunkText: string,
 ): string {
-  // Tail-truncate `documentText` to `SYNOPSIS_DOC_MAX_CHARS` so small local
-  // chat models don't stall on >100KB pages. Head preserved (title block,
-  // frontmatter, intro paragraphs carry the document-level anchor).
-  let trimmedDoc = documentText;
-  if (documentText.length > SYNOPSIS_DOC_MAX_CHARS) {
-    trimmedDoc = documentText.slice(0, SYNOPSIS_DOC_MAX_CHARS) +
-      `\n\n[... ${documentText.length - SYNOPSIS_DOC_MAX_CHARS} chars truncated for synopsis budget ...]`;
-  }
  return [
    `<page_title>${pageTitle}</page_title>`,
    '',
    '<full_document>',
-    trimmedDoc,
+    documentText,
    '</full_document>',
    '',
    '<chunk>',
@@ -57,8 +57,6 @@ import { finalizeLastSeen } from './chronicle/last-seen.ts';
 import { computeAnomaliesFromBuckets } from './cycle/anomaly.ts';
 import { resolveBoostMap, resolveHardExcludes } from './search/source-boost.ts';
 import { buildSourceFactorCase, buildHardExcludeClause, buildVisibilityClause, buildRecencyComponentSql, buildBestPerPagePoolCte, buildOrFallbackWebsearchQuery } from './search/sql-ranking.ts';
-import { shouldExcludeFromOrphanReporting, loadOrphanPolicyOverrides } from './orphan-policy.ts';
-import { LINK_EXTRACTOR_VERSION_TS } from './link-extraction.ts';
 import {
  normalizeEngineColumn,
  buildVectorCastFragment,
@@ -2324,10 +2322,6 @@ export class PGLiteEngine implements BrainEngine {
    // v0.40.3.0 D24 NULL→non-NULL race fix mirrors postgres-engine.ts. Two writers
    // racing on the same chunk previously raced last-write-wins; the fix lets the
    // fresher `embedded_at` win in the text-unchanged branch.
-    //
-    // Code-chunk metadata columns follow the same chunk_text-gated CASE pattern as `embedding`
-    // (#769). Re-chunk trusts EXCLUDED outright; pure re-embed COALESCEs so a caller carrying
-    // only embedding-shaped fields doesn't clobber metadata to NULL.
    await this.db.query(
      `INSERT INTO content_chunks ${cols} VALUES ${rowParts.join(', ')}
       ON CONFLICT (page_id, chunk_index) DO UPDATE SET
@@ -2351,14 +2345,14 @@ export class PGLiteEngine implements BrainEngine {
                THEN EXCLUDED.embedded_at
           ELSE content_chunks.embedded_at
         END,
-         language = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.language ELSE COALESCE(EXCLUDED.language, content_chunks.language) END,
-         symbol_name = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.symbol_name ELSE COALESCE(EXCLUDED.symbol_name, content_chunks.symbol_name) END,
-         symbol_type = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.symbol_type ELSE COALESCE(EXCLUDED.symbol_type, content_chunks.symbol_type) END,
-         start_line = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.start_line ELSE COALESCE(EXCLUDED.start_line, content_chunks.start_line) END,
-         end_line = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.end_line ELSE COALESCE(EXCLUDED.end_line, content_chunks.end_line) END,
-         parent_symbol_path = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.parent_symbol_path ELSE COALESCE(EXCLUDED.parent_symbol_path, content_chunks.parent_symbol_path) END,
-         doc_comment = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.doc_comment ELSE COALESCE(EXCLUDED.doc_comment, content_chunks.doc_comment) END,
-         symbol_name_qualified = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.symbol_name_qualified ELSE COALESCE(EXCLUDED.symbol_name_qualified, content_chunks.symbol_name_qualified) END,
+         language = EXCLUDED.language,
+         symbol_name = EXCLUDED.symbol_name,
+         symbol_type = EXCLUDED.symbol_type,
+         start_line = EXCLUDED.start_line,
+         end_line = EXCLUDED.end_line,
+         parent_symbol_path = EXCLUDED.parent_symbol_path,
+         doc_comment = EXCLUDED.doc_comment,
+         symbol_name_qualified = EXCLUDED.symbol_name_qualified,
         modality = EXCLUDED.modality,
         embedding_image = COALESCE(EXCLUDED.embedding_image, content_chunks.embedding_image)`,
      params
@@ -5213,10 +5207,15 @@ export class PGLiteEngine implements BrainEngine {
        (SELECT count(*) FROM pages) as page_count,
        (SELECT count(*) FROM content_chunks WHERE embedded_at IS NOT NULL)::float /
          GREATEST((SELECT count(*) FROM content_chunks), 1)::float as embed_coverage,
-        0 as stale_pages,
-        -- Bug 11 — orphan = islanded (no inbound AND no outbound). The raw
-        -- list is filtered in TS using the shared orphan-reporting policy.
-        0 as orphan_pages,
+        (SELECT count(*) FROM pages p
+         WHERE p.updated_at < (SELECT MAX(te.created_at) FROM timeline_entries te WHERE te.page_id = p.id)
+        ) as stale_pages,
+        -- Bug 11 — orphan = islanded (no inbound AND no outbound).
+        -- See BrainHealth.orphan_pages docstring; docs updated to match this.
+        (SELECT count(*) FROM pages p
+         WHERE NOT EXISTS (SELECT 1 FROM links l WHERE l.to_page_id = p.id)
+           AND NOT EXISTS (SELECT 1 FROM links l WHERE l.from_page_id = p.id)
+        ) as orphan_pages,
        (SELECT count(*) FROM links l
         WHERE NOT EXISTS (SELECT 1 FROM pages p WHERE p.id = l.to_page_id)
        ) as dead_links,
@@ -5241,20 +5240,10 @@ export class PGLiteEngine implements BrainEngine {
      LIMIT 5
    `);

-    const { rows: islandedRows } = await this.db.query(`
-      SELECT p.slug
-      FROM pages p
-      WHERE NOT EXISTS (SELECT 1 FROM links l WHERE l.to_page_id = p.id)
-        AND NOT EXISTS (SELECT 1 FROM links l WHERE l.from_page_id = p.id)
-    `);
-
    const r = h as Record<string, unknown>;
    const pageCount = Number(r.page_count);
    const embedCoverage = Number(r.embed_coverage);
-    const stalePages = await this.countStalePagesForExtraction({ versionTs: LINK_EXTRACTOR_VERSION_TS });
-    const orphanOverrides = await loadOrphanPolicyOverrides(this);
-    const orphanPages = (islandedRows as { slug: string }[])
-      .filter(row => !shouldExcludeFromOrphanReporting(row.slug, orphanOverrides)).length;
+    const orphanPages = Number(r.orphan_pages);
    const deadLinks = Number(r.dead_links);
    const linkCount = Number(r.link_count);
    const pagesWithTimeline = Number(r.pages_with_timeline);
@@ -5282,7 +5271,7 @@ export class PGLiteEngine implements BrainEngine {
    return {
      page_count: pageCount,
      embed_coverage: embedCoverage,
-      stale_pages: stalePages,
+      stale_pages: Number(r.stale_pages),
      orphan_pages: orphanPages,
      missing_embeddings: Number(r.missing_embeddings),
      brain_score: brainScore,
@@ -67,8 +67,6 @@ import { resolveBoostMap, resolveHardExcludes } from './search/source-boost.ts';
 import { buildSourceFactorCase, buildHardExcludeClause, buildVisibilityClause, buildRecencyComponentSql, buildBestPerPagePoolCte, buildOrFallbackWebsearchQuery } from './search/sql-ranking.ts';
 import { DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_DIMENSIONS } from './ai/defaults.ts';
 import { DELETE_BATCH_SIZE } from './engine-constants.ts';
-import { shouldExcludeFromOrphanReporting, loadOrphanPolicyOverrides } from './orphan-policy.ts';
-import { LINK_EXTRACTOR_VERSION_TS } from './link-extraction.ts';

 function escapeSqlStringLiteral(value: string): string {
  return value.replace(/'/g, "''");
@@ -2475,13 +2473,6 @@ export class PostgresEngine implements BrainEngine {
    //   - new is fresher (embedded_at > existing.embedded_at) → take new
    //   - otherwise → keep existing (slower writer with stale embedding loses)
    // Mirrored in pglite-engine.ts; pinned by test/e2e/concurrent-embed-race.test.ts.
-    //
-    // Code-chunk metadata columns (language / symbol_name / symbol_type / line range /
-    // parent_symbol_path / doc_comment / symbol_name_qualified) follow the SAME chunk_text-gated
-    // CASE pattern as `embedding` (#769). Re-chunk (chunk_text changed) trusts EXCLUDED outright;
-    // pure re-embed (chunk_text unchanged) COALESCEs so a caller that only carries embedding
-    // doesn't clobber metadata to NULL. Without this, every embed --stale pass nuked code-def's
-    // primary index for thousands of chunks at once.
    await sql.unsafe(
      `INSERT INTO content_chunks ${cols} VALUES ${rows.join(', ')}
       ON CONFLICT (page_id, chunk_index) DO UPDATE SET
@@ -2505,14 +2496,14 @@ export class PostgresEngine implements BrainEngine {
                THEN EXCLUDED.embedded_at
           ELSE content_chunks.embedded_at
         END,
-         language = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.language ELSE COALESCE(EXCLUDED.language, content_chunks.language) END,
-         symbol_name = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.symbol_name ELSE COALESCE(EXCLUDED.symbol_name, content_chunks.symbol_name) END,
-         symbol_type = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.symbol_type ELSE COALESCE(EXCLUDED.symbol_type, content_chunks.symbol_type) END,
-         start_line = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.start_line ELSE COALESCE(EXCLUDED.start_line, content_chunks.start_line) END,
-         end_line = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.end_line ELSE COALESCE(EXCLUDED.end_line, content_chunks.end_line) END,
-         parent_symbol_path = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.parent_symbol_path ELSE COALESCE(EXCLUDED.parent_symbol_path, content_chunks.parent_symbol_path) END,
-         doc_comment = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.doc_comment ELSE COALESCE(EXCLUDED.doc_comment, content_chunks.doc_comment) END,
-         symbol_name_qualified = CASE WHEN EXCLUDED.chunk_text != content_chunks.chunk_text THEN EXCLUDED.symbol_name_qualified ELSE COALESCE(EXCLUDED.symbol_name_qualified, content_chunks.symbol_name_qualified) END,
+         language = EXCLUDED.language,
+         symbol_name = EXCLUDED.symbol_name,
+         symbol_type = EXCLUDED.symbol_type,
+         start_line = EXCLUDED.start_line,
+         end_line = EXCLUDED.end_line,
+         parent_symbol_path = EXCLUDED.parent_symbol_path,
+         doc_comment = EXCLUDED.doc_comment,
+         symbol_name_qualified = EXCLUDED.symbol_name_qualified,
         modality = EXCLUDED.modality,
         embedding_image = COALESCE(EXCLUDED.embedding_image, content_chunks.embedding_image)`,
      params as Parameters<typeof sql.unsafe>[1],
@@ -5322,9 +5313,11 @@ export class PostgresEngine implements BrainEngine {
  async getHealth(): Promise<BrainHealth> {
    const sql = this.sql;
    // Bug 11 doc-drift fix — orphan_pages means "islanded" (no inbound AND
-    // no outbound links). The raw islanded list is filtered through the same
-    // policy as `gbrain orphans` so convention pages do not count against
-    // dashboard health.
+    // no outbound links), aligning both engines with the user-facing
+    // definition. The type comment previously said "no inbound" but the
+    // SQL required both — docs now match code so users can trust the
+    // number. A hub page that links out to many but has no back-references
+    // is working as intended, not an orphan.
    const [h] = await sql`
      WITH entity_pages AS (
        SELECT id, slug FROM pages WHERE type IN ('person', 'company')
@@ -5333,8 +5326,13 @@ export class PostgresEngine implements BrainEngine {
        (SELECT count(*) FROM pages) as page_count,
        (SELECT count(*) FROM content_chunks WHERE embedded_at IS NOT NULL)::float /
          GREATEST((SELECT count(*) FROM content_chunks), 1)::float as embed_coverage,
-        0 as stale_pages,
-        0 as orphan_pages,
+        (SELECT count(*) FROM pages p
+         WHERE p.updated_at < (SELECT MAX(te.created_at) FROM timeline_entries te WHERE te.page_id = p.id)
+        ) as stale_pages,
+        (SELECT count(*) FROM pages p
+         WHERE NOT EXISTS (SELECT 1 FROM links l WHERE l.to_page_id = p.id)
+           AND NOT EXISTS (SELECT 1 FROM links l WHERE l.from_page_id = p.id)
+        ) as orphan_pages,
        (SELECT count(*) FROM links l
         WHERE NOT EXISTS (SELECT 1 FROM pages p WHERE p.id = l.to_page_id)
        ) as dead_links,
@@ -5358,18 +5356,9 @@ export class PostgresEngine implements BrainEngine {
      LIMIT 5
    `;

-    const islandedRows = await sql<{ slug: string }[]>`
-      SELECT p.slug
-      FROM pages p
-      WHERE NOT EXISTS (SELECT 1 FROM links l WHERE l.to_page_id = p.id)
-        AND NOT EXISTS (SELECT 1 FROM links l WHERE l.from_page_id = p.id)
-    `;
-
    const pageCount = Number(h.page_count);
    const embedCoverage = Number(h.embed_coverage);
-    const stalePages = await this.countStalePagesForExtraction({ versionTs: LINK_EXTRACTOR_VERSION_TS });
-    const orphanOverrides = await loadOrphanPolicyOverrides(this);
-    const orphanPages = islandedRows.filter(row => !shouldExcludeFromOrphanReporting(row.slug, orphanOverrides)).length;
+    const orphanPages = Number(h.orphan_pages);
    const deadLinks = Number(h.dead_links);
    const linkCount = Number(h.link_count);
    const pagesWithTimeline = Number(h.pages_with_timeline);
@@ -5397,7 +5386,7 @@ export class PostgresEngine implements BrainEngine {
    return {
      page_count: pageCount,
      embed_coverage: embedCoverage,
-      stale_pages: stalePages,
+      stale_pages: Number(h.stale_pages),
      orphan_pages: orphanPages,
      missing_embeddings: Number(h.missing_embeddings),
      brain_score: brainScore,
@@ -93,13 +93,7 @@ import { resolveLrSchedule } from './lr-schedule.ts';
 import { preflight, formatPreflightReport } from './preflight.ts';
 import { isRejected, loadRejectedBuffer, makeRejectedEntry, saveRejectedBuffer } from './rejected-buffer.ts';
 import { runReflect, runOneShotRewrite, describeJudges } from './reflect.ts';
-import {
-  acceptCandidate,
-  proposedPath as proposedFilePath,
-  revertAllPending,
-  skillPath,
-  writeProposed,
-} from './version-store.ts';
+import { acceptCandidate, bestPath, revertAllPending, skillPath, writeProposed } from './version-store.ts';
 import { runValidationGate, scoreSkillOnTasks } from './validate-gate.ts';
 import { ROLLOUT_SUCCESS_THRESHOLD } from './types.ts';
 import type { SkillOptOpts, EditOp, RunReceipt, BenchmarkTask } from './types.ts';
@@ -708,9 +702,9 @@ async function runOptimizationLoop(
  // to the catch's assignment values only (it can't prove the async callback ran).
  const finalOutcome = outcome as 'accepted' | 'no_improvement' | 'aborted' | 'errored';
  if (!mutateDecision.mutate && finalOutcome === 'accepted') {
-    // writeProposed() emitted both the best pointer and the stable review
-    // artifact in the accept branch. SKILL.md remains untouched.
-    proposedPath = proposedFilePath(skillsDir, skillName);
+    // best.md was written by writeProposed() in the accept branch (no-mutate
+    // path); it doubles as proposed.md for human review. SKILL.md untouched.
+    proposedPath = bestPath(skillsDir, skillName);
  } else if (mutateDecision.mutate) {
    mutatedSkillFile = finalOutcome === 'accepted';
  }
@@ -23,7 +23,6 @@
 *
 *   history.json
 *   best.md
- *   proposed.md
 *   versions/
 *     v0001_e1_s1.md
 *     v0002_e1_s2.md
@@ -53,10 +52,6 @@ export function bestPath(skillsDir: string, skillName: string): string {
  return path.join(skilloptDir(skillsDir, skillName), 'best.md');
 }

-export function proposedPath(skillsDir: string, skillName: string): string {
-  return path.join(skilloptDir(skillsDir, skillName), 'proposed.md');
-}
-
 export function skillPath(skillsDir: string, skillName: string): string {
  return path.join(skillsDir, skillName, 'SKILL.md');
 }
@@ -176,18 +171,17 @@ export function acceptCandidate(input: AcceptInput): AcceptResult {
 }

 /**
- * Write the candidate to both `best.md` and `proposed.md` WITHOUT touching
- * SKILL.md or the history ledger. `best.md` remains the optimizer's current
- * best pointer; `proposed.md` is the stable human-review artifact promised by
- * `--no-mutate`. Returns the proposal path. Each write is atomic (.tmp + rename).
+ * Write the candidate to `best.md` (which doubles as `proposed.md`) WITHOUT
+ * touching SKILL.md or the history ledger. Used by the `--no-mutate` /
+ * bundled-without-allow paths: the optimizer found a better candidate but the
+ * caller opted out of in-place mutation, so we surface it for human review.
+ * Returns the path written. Atomic (.tmp + rename).
 */
 export function writeProposed(skillsDir: string, skillName: string, candidateText: string): string {
-  const best = bestPath(skillsDir, skillName);
-  const proposed = proposedPath(skillsDir, skillName);
-  fs.mkdirSync(path.dirname(best), { recursive: true });
-  atomicWrite(best, candidateText);
-  atomicWrite(proposed, candidateText);
-  return proposed;
+  const p = bestPath(skillsDir, skillName);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  atomicWrite(p, candidateText);
+  return p;
 }

 /**
@@ -63,26 +63,25 @@ interface PluginCtx {
  [key: string]: unknown;
 }

-export function register(api: PluginApi) {
-  api.registerContextEngine(ENGINE_ID, (ctx: PluginCtx) => {
-    const hostResolver =
-      typeof ctx.resolveEntities === 'function'
-        ? ctx.resolveEntities
-        : typeof ctx.brainQuery === 'function'
-          ? ctx.brainQuery
-          : undefined;
-    return createGBrainContextEngine({
-      workspaceDir: ctx.workspaceDir,
-      resolveEntities: hostResolver,
-    });
-  });
-}
-
 const entry: PluginEntry = {
  id: 'gbrain-context-engine',
  name: 'GBrain Context Engine',
  description: 'Deterministic temporal/spatial context injection on every turn',
-  register,
+
+  register(api: PluginApi) {
+    api.registerContextEngine(ENGINE_ID, (ctx: PluginCtx) => {
+      const hostResolver =
+        typeof ctx.resolveEntities === 'function'
+          ? ctx.resolveEntities
+          : typeof ctx.brainQuery === 'function'
+            ? ctx.brainQuery
+            : undefined;
+      return createGBrainContextEngine({
+        workspaceDir: ctx.workspaceDir,
+        resolveEntities: hostResolver,
+      });
+    });
+  },
 };

 export default entry;
@@ -0,0 +1,102 @@
+/**
+ * Tests for the parser-probe audit trail + the 24h rate-limit gate.
+ *
+ * Uses GBRAIN_AUDIT_DIR override pointed at a tmpdir for hermeticity
+ * (same pattern as audit-slug-fallback.serial.test.ts). Serial because
+ * the env override is process-global.
+ */
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtempSync, rmSync, readdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  computeParserProbeAuditFilename,
+  logParserProbeEvent,
+  parserProbeRanWithin,
+  readRecentParserProbeEvents,
+  type ParserProbeAuditEvent,
+} from '../src/core/audit-parser-probe.ts';
+
+let auditDir: string;
+let savedEnv: string | undefined;
+
+beforeEach(() => {
+  auditDir = mkdtempSync(join(tmpdir(), 'parser-probe-audit-'));
+  savedEnv = process.env.GBRAIN_AUDIT_DIR;
+  process.env.GBRAIN_AUDIT_DIR = auditDir;
+});
+
+afterEach(() => {
+  if (savedEnv === undefined) delete process.env.GBRAIN_AUDIT_DIR;
+  else process.env.GBRAIN_AUDIT_DIR = savedEnv;
+  rmSync(auditDir, { recursive: true, force: true });
+});
+
+function makeEvent(overrides: Partial<ParserProbeAuditEvent> = {}): ParserProbeAuditEvent {
+  return {
+    schema_version: 1,
+    ts: new Date().toISOString(),
+    outcome: 'pass',
+    fixtures_total: 12,
+    fixtures_passed: 12,
+    recall_mean: 0.98,
+    participants_recall_mean: 0.97,
+    adversarial_false_positives: 0,
+    failed_fixture_ids: [],
+    ...overrides,
+  };
+}
+
+describe('parser-probe audit trail', () => {
+  test('log + readRecent round-trip', () => {
+    logParserProbeEvent(makeEvent({ outcome: 'fail', reason: '2 fixture(s) failed' }));
+    const events = readRecentParserProbeEvents(7);
+    expect(events.length).toBe(1);
+    expect(events[0]!.outcome).toBe('fail');
+    expect(events[0]!.reason).toBe('2 fixture(s) failed');
+    const files = readdirSync(auditDir);
+    expect(files.length).toBe(1);
+    expect(files[0]).toMatch(/^parser-probe-\d{4}-W\d{2}\.jsonl$/);
+  });
+
+  test('filename uses ISO-week rotation with the parser-probe prefix', () => {
+    // Year-boundary edge pinned by the shared writer's own tests; here we
+    // pin the prefix wiring.
+    expect(computeParserProbeAuditFilename(new Date('2026-07-06T12:00:00Z'))).toBe(
+      'parser-probe-2026-W28.jsonl',
+    );
+  });
+
+  test('readRecent filters by window', () => {
+    const old = new Date(Date.now() - 10 * 86400000).toISOString();
+    logParserProbeEvent(makeEvent({ ts: old }));
+    expect(readRecentParserProbeEvents(7).length).toBe(0);
+  });
+});
+
+describe('parserProbeRanWithin — 24h rate-limit gate', () => {
+  const DAY_MS = 24 * 60 * 60 * 1000;
+
+  test('false when no runs are audited', () => {
+    expect(parserProbeRanWithin(DAY_MS)).toBe(false);
+  });
+
+  test('true when a run landed within the window', () => {
+    logParserProbeEvent(makeEvent({ ts: new Date(Date.now() - 60_000).toISOString() }));
+    expect(parserProbeRanWithin(DAY_MS)).toBe(true);
+  });
+
+  test('false when the last run is older than the window', () => {
+    logParserProbeEvent(makeEvent({ ts: new Date(Date.now() - 25 * 3600_000).toISOString() }));
+    expect(parserProbeRanWithin(DAY_MS)).toBe(false);
+  });
+
+  test('non-pass outcomes also hold the window (mirrors quality-probe semantics)', () => {
+    logParserProbeEvent(makeEvent({
+      outcome: 'no_embedding_key',
+      ts: new Date(Date.now() - 3600_000).toISOString(),
+    }));
+    expect(parserProbeRanWithin(DAY_MS)).toBe(true);
+  });
+});
@@ -31,10 +31,15 @@ describe('autopilot wiring: nightly quality probe', () => {
    expect(SOURCE).toContain(`runCrossModalBatchForProbe`);
  });

-  test('feature flag gate present: cfg.autopilot.nightly_quality_probe.enabled', () => {
+  test('feature flag gate present: dual-plane read (DB row wins, file plane fallback)', () => {
    // Per D10: the scheduler ONLY checks the feature flag. The 24h rate-limit
    // lives inside runNightlyQualityProbe itself (no scheduler-side precheck).
-    expect(SOURCE).toContain(`nightly_quality_probe?.enabled === true`);
+    // The flag resolves through resolveProbeEnabled so `gbrain config set
+    // autopilot.nightly_quality_probe.enabled true` (the doctor hint, DB
+    // plane) and ~/.gbrain/config.json (file plane) BOTH work — a file-only
+    // read made the printed hint a silent no-op.
+    expect(SOURCE).toContain(`getConfig('autopilot.nightly_quality_probe.enabled')`);
+    expect(SOURCE).toMatch(/resolveProbeEnabled\(dbEnabled,\s*cfg\?\.autopilot\?\.nightly_quality_probe\?\.enabled\)/);
  });

  test('NO scheduler-side rate-limit check (D10 simplification)', () => {
@@ -64,12 +69,23 @@ describe('autopilot wiring: nightly quality probe', () => {
    expect(SOURCE).toContain(`now:`);
  });

+  test('resolveRepoRoot prefers the gbrain package root (committed fixture home), not the brain repoPath', () => {
+    // The DI harness in nightly-quality-probe.test.ts passes process.cwd()
+    // (= the gbrain repo in CI), which papered over the wiring passing
+    // repoPath (= sync.repo_path, the user's BRAIN repo, where the fixture
+    // never exists). Pin the package-root resolution + existence check.
+    expect(SOURCE).toMatch(/fileURLToPath\(new URL\('\.\.\/\.\.', import\.meta\.url\)\)/);
+    expect(SOURCE).toContain(`'longmemeval-nightly.jsonl'`);
+    expect(SOURCE).toMatch(/fixtureAtPkgRoot \? pkgRoot : repoPath/);
+  });
+
  test('hasEmbeddingProvider reads from gateway.isAvailable("embedding") (codex round-2 #12 — in-process, not subprocess)', () => {
    expect(SOURCE).toContain(`isAvailable('embedding')`);
    expect(SOURCE).toContain(`gateway`);
  });

-  test('max_usd default = 5 when config unset (matches plan default per D10)', () => {
-    expect(SOURCE).toMatch(/max_usd\s*\?\?\s*5/);
+  test('max_usd resolves dual-plane (default = 5 pinned by resolveProbeMaxUsd unit tests)', () => {
+    expect(SOURCE).toContain(`getConfig('autopilot.nightly_quality_probe.max_usd')`);
+    expect(SOURCE).toMatch(/resolveProbeMaxUsd\(dbMaxUsd,\s*cfg\?\.autopilot\?\.nightly_quality_probe\?\.max_usd\)/);
  });
 });
@@ -0,0 +1,77 @@
+/**
+ * Source-shape regression tests for the autopilot wiring of
+ * `runConversationParserNightlyProbe` (step 4.6).
+ *
+ * Same rationale as autopilot-nightly-probe-wiring.test.ts: the loop is
+ * hard to drive end-to-end, so these pin the structural protections —
+ * the dual-plane flag read, the D10 tokenmax mode-gate, the package-root
+ * fixture resolution, the audit-flood guard, and the try/catch posture.
+ *
+ * The probe's own gate/scoring logic is pinned by the module's unit
+ * tests; the audit trail by audit-parser-probe.serial.test.ts.
+ */
+
+import { describe, test, expect } from 'bun:test';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const AUTOPILOT_SRC = resolve('src/commands/autopilot.ts');
+const SOURCE = readFileSync(AUTOPILOT_SRC, 'utf-8');
+
+describe('autopilot wiring: conversation-parser probe', () => {
+  test('invokes the phase module and the audit trail', () => {
+    expect(SOURCE).toContain(`runConversationParserNightlyProbe`);
+    expect(SOURCE).toContain(`conversation-parser/nightly-probe`);
+    expect(SOURCE).toContain(`logParserProbeEvent`);
+    expect(SOURCE).toContain(`audit-parser-probe`);
+  });
+
+  test('flag reads dual-plane: DB row (gbrain config set) wins, file plane fallback', () => {
+    expect(SOURCE).toContain(`getConfig('autopilot.conversation_parser_probe.enabled')`);
+    expect(SOURCE).toContain(`cfg?.autopilot?.conversation_parser_probe?.enabled === true`);
+  });
+
+  test('D10 mode-gate present: tokenmax brains run the probe by default', () => {
+    expect(SOURCE).toMatch(/parserEnabled \|\| searchMode === 'tokenmax'/);
+  });
+
+  test('fixtures resolve from the gbrain package root, NOT the brain repoPath', () => {
+    // The committed fixtures live in the gbrain source tree; resolving
+    // them against sync.repo_path would point into the user's brain repo.
+    expect(SOURCE).toMatch(/fileURLToPath\(new URL\('\.\.\/\.\.', import\.meta\.url\)\)/);
+    expect(SOURCE).toContain(`'conversation-formats', 'all.jsonl'`);
+    expect(SOURCE).toContain(`'conversation-formats', 'adversarial.jsonl'`);
+  });
+
+  test('missing fixtures skip quietly (no audit row, once-per-process stderr note)', () => {
+    // Compiled-binary installs carry no source tree; writing failure rows
+    // would flip doctor to WARN on every binary install.
+    expect(SOURCE).toContain(`parserProbeFixtureWarned`);
+  });
+
+  test('rate_limited outcomes are NOT audit-logged (flood guard)', () => {
+    expect(SOURCE).toMatch(/outcome !== 'rate_limited'\) logParserProbeEvent\(result\)/);
+  });
+
+  test('rate-limit gate delegates to the audit module, not inline event reads', () => {
+    expect(SOURCE).toContain(`parserProbeRanWithin(24 * 60 * 60 * 1000)`);
+  });
+
+  test('LLM-key gate reads gateway.isAvailable("chat") in-process', () => {
+    expect(SOURCE).toContain(`isAvailable('chat')`);
+  });
+
+  test('probe call wrapped in try/catch that does NOT bump consecutiveErrors', () => {
+    expect(SOURCE).toMatch(/catch[\s\S]*?autopilot\.parser_probe[\s\S]*?do NOT bump consecutiveErrors/);
+  });
+
+  test('DI shape: the exact 7 fields of the parser probe NightlyProbeDeps', () => {
+    expect(SOURCE).toContain(`isEnabled:`);
+    expect(SOURCE).toContain(`searchMode:`);
+    expect(SOURCE).toContain(`hasLlmKey:`);
+    expect(SOURCE).toContain(`resolveFixturePath:`);
+    expect(SOURCE).toContain(`resolveAdversarialPath:`);
+    expect(SOURCE).toContain(`shouldSkipForRateLimit:`);
+    expect(SOURCE).toContain(`now:`);
+  });
+});
@@ -1,67 +0,0 @@
-// #1474: the v0.41.1 wave shipped bench-publish.ts + docs/eval-bench.md
-// advertising `gbrain bench publish`, but the cli.ts dispatcher case was never
-// added — the documented command hit 'Unknown command'. These tests spawn the
-// real CLI (no DB needed; bench publish is pure file I/O) and fail on any
-// regression of the dispatcher wiring.
-import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, writeFileSync, existsSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { spawnSync } from 'node:child_process';
-
-function runCli(args: string[]): { stdout: string; stderr: string; code: number } {
-  const result = spawnSync(process.execPath, ['run', 'src/cli.ts', 'bench', ...args], {
-    encoding: 'utf8',
-    cwd: process.cwd(),
-    env: { ...process.env },
-  });
-  return { stdout: result.stdout ?? '', stderr: result.stderr ?? '', code: result.status ?? -1 };
-}
-
-describe('gbrain bench dispatcher (#1474)', () => {
-  test('bench --help reaches bench-publish help without a DB (was: Unknown command)', () => {
-    const { stdout, stderr, code } = runCli(['--help']);
-    expect(stderr).not.toContain('Unknown command');
-    expect(code).toBe(0);
-    expect(stdout).toContain('gbrain bench publish');
-    expect(stdout).toContain('--from');
-  });
-
-  test('unknown bench subcommand exits 2 with usage', () => {
-    const { stderr, code } = runCli(['bogus']);
-    expect(code).toBe(2);
-    expect(stderr).toContain('Unknown bench subcommand');
-    expect(stderr).toContain('bench publish');
-  });
-
-  test('bench publish roundtrip: captured NDJSON in, baseline file out', () => {
-    const tmp = mkdtempSync(join(tmpdir(), 'bench-cli-'));
-    try {
-      const row = {
-        tool_name: 'query',
-        query: 'hello world',
-        retrieved_slugs: ['slug-a'],
-        retrieved_chunk_ids: [1],
-        source_ids: ['default'],
-        expand_enabled: false,
-        detail: 'medium',
-        detail_resolved: 'medium',
-        vector_enabled: true,
-        expansion_applied: false,
-        latency_ms: 100,
-        remote: false,
-        job_id: null,
-        subagent_id: null,
-      };
-      const from = join(tmp, 'captured.ndjson');
-      const to = join(tmp, 'personal.baseline.ndjson');
-      writeFileSync(from, `${JSON.stringify(row)}\n`);
-      const { code, stderr } = runCli(['publish', '--from', from, '--to', to]);
-      expect(stderr).not.toContain('Unknown command');
-      expect(code).toBe(0);
-      expect(existsSync(to)).toBe(true);
-    } finally {
-      rmSync(tmp, { recursive: true, force: true });
-    }
-  });
-});
@@ -0,0 +1,47 @@
+/**
+ * Consistency guard: every cross-modal DEFAULT_SLOTS model must be listed
+ * in its recipe's chat touchpoint. `openai:gpt-4o` drifted out of the
+ * OpenAI recipe while remaining the slot-A default — the gateway then
+ * rejected slot A ("not listed for OpenAI chat") on every install, and the
+ * 3-slot judge panel could never reach its 2-model quorum without a Google
+ * key, pinning every batch verdict at inconclusive (which the nightly
+ * quality probe surfaces as a doctor WARN).
+ */
+import { describe, expect, test } from 'bun:test';
+
+import { DEFAULT_SLOTS } from '../src/core/cross-modal-eval/runner.ts';
+import { getRecipe } from '../src/core/ai/recipes/index.ts';
+import { splitProviderModelId } from '../src/core/model-id.ts';
+import { canonicalLookup } from '../src/core/model-pricing.ts';
+
+describe('cross-modal DEFAULT_SLOTS ↔ recipe consistency', () => {
+  test('every default slot model is listed in its recipe chat touchpoint', () => {
+    for (const slot of DEFAULT_SLOTS) {
+      const { provider, model } = splitProviderModelId(slot.model);
+      expect(provider).not.toBeNull();
+      const recipe = getRecipe(provider!);
+      expect(recipe, `slot ${slot.id}: unknown recipe "${provider}"`).toBeDefined();
+      const chatModels = recipe!.touchpoints.chat?.models ?? [];
+      expect(
+        chatModels,
+        `slot ${slot.id}: "${model}" not listed for ${provider} chat — the judge slot can never run`,
+      ).toContain(model);
+    }
+  });
+
+  test('every default slot model has a canonical pricing entry', () => {
+    // Without one, estimateCost silently drops the slot from the
+    // --max-usd pre-flight and est_cost_usd audit rows (~1/3 under-count).
+    for (const slot of DEFAULT_SLOTS) {
+      expect(
+        canonicalLookup(slot.model),
+        `slot ${slot.id}: "${slot.model}" missing from CANONICAL_PRICING`,
+      ).toBeDefined();
+    }
+  });
+
+  test('slots span three distinct providers (uncorrelated blind spots)', () => {
+    const providers = new Set(DEFAULT_SLOTS.map(s => splitProviderModelId(s.model).provider));
+    expect(providers.size).toBe(3);
+  });
+});
@@ -0,0 +1,51 @@
+/**
+ * Tests for computeConversationParserProbeHealthCheck — the pure function
+ * behind doctor's conversation_parser_probe_health check, which replaced
+ * the v0.41.13.0 hardcoded "Skipped" stub when the autopilot wiring
+ * landed. Mirrors the branch coverage style of the quality-probe check.
+ */
+import { describe, expect, test } from 'bun:test';
+
+import { computeConversationParserProbeHealthCheck } from '../src/commands/doctor.ts';
+
+const ev = (outcome: string, reason?: string, ts = new Date().toISOString()) => ({
+  outcome,
+  ts,
+  ...(reason !== undefined ? { reason } : {}),
+});
+
+describe('computeConversationParserProbeHealthCheck', () => {
+  test('disabled + no events → ok with paste-ready enable hint', () => {
+    const check = computeConversationParserProbeHealthCheck(false, []);
+    expect(check.status).toBe('ok');
+    expect(check.message).toContain('gbrain config set autopilot.conversation_parser_probe.enabled true');
+  });
+
+  test('enabled + no events yet → ok, next run by autopilot', () => {
+    const check = computeConversationParserProbeHealthCheck(true, []);
+    expect(check.status).toBe('ok');
+    expect(check.message).toContain('no probe events');
+  });
+
+  test('disabled flag but events exist (tokenmax mode-gate ran it) → events win over the hint', () => {
+    const check = computeConversationParserProbeHealthCheck(false, [ev('pass')]);
+    expect(check.status).toBe('ok');
+    expect(check.message).toContain('all pass');
+  });
+
+  test('any non-pass outcome in the window → warn, latest surfaced with reason', () => {
+    const check = computeConversationParserProbeHealthCheck(true, [
+      ev('pass'),
+      ev('adversarial_false_positive', '1 adversarial fixture(s) parsed to non-empty'),
+    ]);
+    expect(check.status).toBe('warn');
+    expect(check.message).toContain('adversarial_false_positive');
+    expect(check.message).toContain('parsed to non-empty');
+  });
+
+  test('all pass → ok with run count', () => {
+    const check = computeConversationParserProbeHealthCheck(true, [ev('pass'), ev('pass')]);
+    expect(check.status).toBe('ok');
+    expect(check.message).toContain('2 probe run(s)');
+  });
+});
@@ -172,59 +172,6 @@ describe('issue #972 — DB-source (gbrain extract links --source db)', () => {
    expect(strk!.link_type).toBe('wikilink_basename');
  });

-  test('flag ON → path-qualified wikilink outside DIR_PATTERN resolves via DB path', async () => {
-    // `[[notes/struktura]]` — `notes` is not in DIR_PATTERN, so the ref
-    // reaches the generic pass with its dirname intact. Regression: the DB
-    // path queried the basename index with the raw literal (which is keyed
-    // by final segments only), so path-qualified wikilinks outside
-    // DIR_PATTERN silently produced zero edges while the FS path resolved
-    // the identical content.
-    await engine.putPage('notes/struktura', {
-      type: 'concept' as any, title: 'Struktura Notes',
-      compiled_truth: '', timeline: '',
-    });
-    await engine.putPage('concepts/knowledge-graph', {
-      type: 'concept', title: 'Knowledge Graph',
-      compiled_truth: 'Background in [[notes/struktura]].', timeline: '',
-    });
-    await engine.setConfig('link_resolution.global_basename', 'true');
-
-    await runExtract(engine, ['links', '--source', 'db']);
-
-    const outLinks = await engine.getLinks('concepts/knowledge-graph');
-    const strk = outLinks.find(l => l.to_slug === 'notes/struktura');
-    expect(strk).toBeDefined();
-    expect(strk!.link_type).toBe('wikilink_basename');
-    expect(strk!.link_source).toBe('wikilink-resolved');
-  });
-
-  test('path-qualified wikilink never attaches to a basename-only sibling', async () => {
-    // Both notes/struktura and wiki/struktura exist. The author wrote
-    // `[[notes/struktura]]` — the written path must exclude wiki/struktura
-    // (a bare `[[struktura]]` would legitimately match both).
-    await engine.putPage('notes/struktura', {
-      type: 'concept' as any, title: 'Struktura Notes',
-      compiled_truth: '', timeline: '',
-    });
-    await engine.putPage('wiki/struktura', {
-      type: 'concept' as any, title: 'Struktura Wiki',
-      compiled_truth: '', timeline: '',
-    });
-    await engine.putPage('concepts/x', {
-      type: 'concept', title: 'X',
-      compiled_truth: 'See [[notes/struktura]].', timeline: '',
-    });
-    await engine.setConfig('link_resolution.global_basename', 'true');
-
-    await runExtract(engine, ['links', '--source', 'db']);
-
-    const outLinks = await engine.getLinks('concepts/x');
-    const basenameLinks = outLinks
-      .filter(l => l.link_type === 'wikilink_basename')
-      .map(l => l.to_slug);
-    expect(basenameLinks).toEqual(['notes/struktura']);
-  });
-
  test('flag OFF → no basename edges via DB path (back-compat)', async () => {
    await engine.putPage('projects/struktura', {
      type: 'project', title: 'Struktura',
@@ -39,7 +39,6 @@ import { runSkillOpt } from '../../src/core/skillopt/orchestrator.ts';
 import {
  bestPath,
  loadHistory,
-  proposedPath,
  skillPath,
 } from '../../src/core/skillopt/version-store.ts';
 import { loadRejectedBuffer } from '../../src/core/skillopt/rejected-buffer.ts';
@@ -742,7 +741,7 @@ describe('skillopt T3 — F11 held-out gate, ablation opts, no-DB-pollution', ()
    } finally { fixture.cleanup(); }
  });

-  test('--no-mutate writes proposed.md and best.md, leaves SKILL.md untouched', async () => {
+  test('--no-mutate writes proposed.md (best.md), leaves SKILL.md untouched', async () => {
    const fixture = setupFixture(SKILL_PEOPLE_ONLY, CITATIONS_BENCHMARK);
    try {
      installStub({
@@ -754,9 +753,10 @@ describe('skillopt T3 — F11 held-out gate, ablation opts, no-DB-pollution', ()
          const result = await runOnce(fixture, { noMutate: true });
          expect(result.outcome).toBe('accepted');
          expect(result.mutatedSkillFile).toBe(false);
-          expect(result.proposedPath).toBe(proposedPath(fixture.skillsDir, SKILL));
+          expect(result.proposedPath).toBeDefined();
+          // proposed.md (best.md) exists and carries the improvement.
+          expect(fs.existsSync(result.proposedPath!)).toBe(true);
          expect(fs.readFileSync(result.proposedPath!, 'utf8')).toContain('## Citations');
-          expect(fs.readFileSync(bestPath(fixture.skillsDir, SKILL), 'utf8')).toContain('## Citations');
          // SKILL.md on disk is UNCHANGED (still People-only).
          const skill = fs.readFileSync(skillPath(fixture.skillsDir, SKILL), 'utf8');
          expect(skill).not.toContain('## Citations');
@@ -803,107 +803,3 @@ describe('embedAllStale --source threading (D7)', () => {
    expect((firstCallOpts as { sourceId?: string }).sourceId).toBe('media-corpus');
  });
 });
-
-// ────────────────────────────────────────────────────────────────
-// Code metadata preservation across re-embed (regression for #769)
-// ────────────────────────────────────────────────────────────────
-//
-// gbrain v0.30.1 and earlier silently clobbered code-chunk metadata
-// (language, symbol_name, symbol_type, start_line, end_line,
-// parent_symbol_path, doc_comment, symbol_name_qualified) on every
-// re-embed pass. The chunker populated those columns at import time,
-// but embed.ts loaded chunks via getChunks then mapped them to a
-// stripped ChunkInput carrying only 5 fields. upsertChunks then
-// OVERWROTE (not COALESCEd) the metadata columns from EXCLUDED, so
-// re-embed wiped them to NULL. End result on a real brain: 4875 code
-// pages, 47866 chunks, all with NULL language/symbol_name/symbol_type;
-// code-def returned 0 hits across every indexed repo.
-//
-// All three runEmbed paths (--stale autopilot, --all, --slugs) must
-// thread metadata through the re-upsert. Tests below assert that the
-// engine.upsertChunks call carries the same metadata it loaded.
-
-describe('runEmbed preserves code-chunk metadata across re-embed (regression for #769)', () => {
-  const fullCodeChunk = {
-    chunk_index: 0,
-    chunk_text: '[Java] foo/Bar.java:10-20 method baz',
-    chunk_source: 'compiled_truth' as const,
-    embedded_at: null,
-    token_count: 12,
-    language: 'java',
-    symbol_name: 'baz',
-    symbol_type: 'function',
-    start_line: 10,
-    end_line: 20,
-    parent_symbol_path: ['Bar'],
-    doc_comment: 'does the thing',
-    symbol_name_qualified: 'Bar.baz',
-  };
-
-  function metadataOf(chunk: any) {
-    return {
-      language: chunk.language,
-      symbol_name: chunk.symbol_name,
-      symbol_type: chunk.symbol_type,
-      start_line: chunk.start_line,
-      end_line: chunk.end_line,
-      parent_symbol_path: chunk.parent_symbol_path,
-      doc_comment: chunk.doc_comment,
-      symbol_name_qualified: chunk.symbol_name_qualified,
-    };
-  }
-
-  test('--stale (autopilot path) carries code metadata into upsertChunks', async () => {
-    const stale = [{
-      slug: 'code-page',
-      chunk_index: 0,
-      chunk_text: fullCodeChunk.chunk_text,
-      chunk_source: 'compiled_truth',
-      model: null,
-      token_count: 12,
-    }];
-    let upsertChunkArgs: any[] | null = null;
-    const engine = mockEngine({
-      countStaleChunks: async () => 1,
-      listStaleChunks: async () => stale,
-      getChunks: async () => [fullCodeChunk],
-      upsertChunks: async (_slug: string, chunks: any[]) => { upsertChunkArgs = chunks; },
-    });
-
-    await runEmbed(engine, ['--stale']);
-
-    expect(upsertChunkArgs).not.toBeNull();
-    expect(upsertChunkArgs!).toHaveLength(1);
-    expect(metadataOf(upsertChunkArgs![0])).toEqual(metadataOf(fullCodeChunk));
-  });
-
-  test('--all (full re-embed) carries code metadata into upsertChunks', async () => {
-    let upsertChunkArgs: any[] | null = null;
-    const engine = mockEngine({
-      listPages: async () => [{ slug: 'code-page' }],
-      getChunks: async () => [fullCodeChunk],
-      upsertChunks: async (_slug: string, chunks: any[]) => { upsertChunkArgs = chunks; },
-    });
-
-    await runEmbed(engine, ['--all']);
-
-    expect(upsertChunkArgs).not.toBeNull();
-    expect(upsertChunkArgs!).toHaveLength(1);
-    expect(metadataOf(upsertChunkArgs![0])).toEqual(metadataOf(fullCodeChunk));
-  });
-
-  test('--slugs (per-page embed) carries code metadata into upsertChunks', async () => {
-    let upsertChunkArgs: any[] | null = null;
-    const engine = mockEngine({
-      getPage: async () => ({ slug: 'code-page', compiled_truth: 'x', timeline: '' }),
-      getChunks: async () => [fullCodeChunk],
-      upsertChunks: async (_slug: string, chunks: any[]) => { upsertChunkArgs = chunks; },
-    });
-
-    await runEmbed(engine, ['--slugs', 'code-page']);
-
-    expect(upsertChunkArgs).not.toBeNull();
-    expect(upsertChunkArgs!).toHaveLength(1);
-    expect(metadataOf(upsertChunkArgs![0])).toEqual(metadataOf(fullCodeChunk));
-  });
-});
@@ -309,62 +309,3 @@ describe('isEvalCaptureEnabled / isEvalScrubEnabled (CONTRIBUTOR_MODE-gated)', (
    } finally { restore(); }
  });
 });
-
-describe('DB-plane stash (#1475): GBRAIN_EVAL_CAPTURE / GBRAIN_EVAL_SCRUB_PII', () => {
-  // connectEngine stamps `gbrain config set eval.capture` (DB plane) onto
-  // these env vars because ctx.config is the sync file-plane load. Without
-  // the stash check the DB value was written and never read.
-  const origCapture = process.env.GBRAIN_EVAL_CAPTURE;
-  const origScrub = process.env.GBRAIN_EVAL_SCRUB_PII;
-  const origMode = process.env.GBRAIN_CONTRIBUTOR_MODE;
-  const restore = () => {
-    if (origCapture === undefined) delete process.env.GBRAIN_EVAL_CAPTURE;
-    else process.env.GBRAIN_EVAL_CAPTURE = origCapture;
-    if (origScrub === undefined) delete process.env.GBRAIN_EVAL_SCRUB_PII;
-    else process.env.GBRAIN_EVAL_SCRUB_PII = origScrub;
-    if (origMode === undefined) delete process.env.GBRAIN_CONTRIBUTOR_MODE;
-    else process.env.GBRAIN_CONTRIBUTOR_MODE = origMode;
-  };
-
-  test('stash=true turns capture on when file plane is silent (the #1475 repro)', () => {
-    delete process.env.GBRAIN_CONTRIBUTOR_MODE;
-    process.env.GBRAIN_EVAL_CAPTURE = 'true';
-    try {
-      expect(isEvalCaptureEnabled(null)).toBe(true);
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const noEval: any = { engine: 'pglite' };
-      expect(isEvalCaptureEnabled(noEval)).toBe(true);
-    } finally { restore(); }
-  });
-
-  test('stash=false wins over CONTRIBUTOR_MODE=1 (explicit per-key beats broad flag)', () => {
-    process.env.GBRAIN_CONTRIBUTOR_MODE = '1';
-    process.env.GBRAIN_EVAL_CAPTURE = 'false';
-    try {
-      expect(isEvalCaptureEnabled(null)).toBe(false);
-    } finally { restore(); }
-  });
-
-  test('file-plane explicit value still wins over the stash', () => {
-    process.env.GBRAIN_EVAL_CAPTURE = 'true';
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const disabled: any = { engine: 'pglite', eval: { capture: false } };
-      expect(isEvalCaptureEnabled(disabled)).toBe(false);
-    } finally { restore(); }
-  });
-
-  test('scrub stash: false disables, file plane wins, default stays true', () => {
-    process.env.GBRAIN_EVAL_SCRUB_PII = 'false';
-    try {
-      expect(isEvalScrubEnabled(null)).toBe(false);
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const fileWins: any = { engine: 'pglite', eval: { scrub_pii: true } };
-      expect(isEvalScrubEnabled(fileWins)).toBe(true);
-    } finally { restore(); }
-    delete process.env.GBRAIN_EVAL_SCRUB_PII;
-    try {
-      expect(isEvalScrubEnabled(null)).toBe(true);
-    } finally { restore(); }
-  });
-});
@@ -403,77 +403,6 @@ describe('extractPageLinks', () => {
    expect(candidates).toEqual([]);
  });

-  test('path-qualified wikilink outside DIR_PATTERN queries by final segment', async () => {
-    // `[[notes/struktura]]` (dir not in DIR_PATTERN) falls to the generic
-    // pass. The resolver's basename index is keyed by final path segments,
-    // so the lookup must strip the dirname — mirroring the FS path
-    // (resolveSlugAll). Regression: the raw literal was passed through,
-    // which never matched, so these links silently dropped.
-    const seen: string[] = [];
-    const resolver: SlugResolver = {
-      resolve: async () => null,
-      resolveBasenameMatches: async (name) => {
-        seen.push(name);
-        return name === 'struktura' ? ['notes/struktura'] : [];
-      },
-    };
-    const { candidates } = await extractPageLinks(
-      'concepts/x', 'See [[notes/struktura]].',
-      {}, 'concept', resolver, { globalBasename: true },
-    );
-    expect(seen).toContain('struktura');
-    expect(seen).not.toContain('notes/struktura');
-    expect(candidates.map(c => c.targetSlug)).toEqual(['notes/struktura']);
-    expect(candidates[0].linkType).toBe('wikilink_basename');
-    expect(candidates[0].linkSource).toBe('wikilink-resolved');
-  });
-
-  test('path-qualified wikilink keeps only matches ending with the written path', async () => {
-    // The written path disambiguates: `[[notes/struktura]]` must never
-    // attach to `wiki/struktura` even though both share the basename.
-    const resolver: SlugResolver = {
-      resolve: async () => null,
-      resolveBasenameMatches: async (name) =>
-        name === 'struktura' ? ['notes/struktura', 'wiki/struktura'] : [],
-    };
-    const { candidates } = await extractPageLinks(
-      'concepts/x', 'See [[notes/struktura]].',
-      {}, 'concept', resolver, { globalBasename: true },
-    );
-    expect(candidates.map(c => c.targetSlug)).toEqual(['notes/struktura']);
-  });
-
-  test('path-qualified wikilink matches a deeper real slug by path suffix', async () => {
-    // The page lives at vault/notes/struktura; the author wrote the shorter
-    // tail `[[notes/struktura]]`. Suffix matching connects them, while the
-    // basename-only sibling `wiki/struktura` stays excluded.
-    const resolver: SlugResolver = {
-      resolve: async () => null,
-      resolveBasenameMatches: async (name) =>
-        name === 'struktura' ? ['vault/notes/struktura', 'wiki/struktura'] : [],
-    };
-    const { candidates } = await extractPageLinks(
-      'concepts/x', 'See [[notes/struktura]].',
-      {}, 'concept', resolver, { globalBasename: true },
-    );
-    expect(candidates.map(c => c.targetSlug)).toEqual(['vault/notes/struktura']);
-  });
-
-  test('path-qualified self-link is dropped like the bare form', async () => {
-    // `[[notes/struktura]]` written on notes/struktura itself must not
-    // produce a self-loop (same guard as the bare `[[own-tail]]` case).
-    const resolver: SlugResolver = {
-      resolve: async () => null,
-      resolveBasenameMatches: async (name) =>
-        name === 'struktura' ? ['notes/struktura'] : [],
-    };
-    const { candidates } = await extractPageLinks(
-      'notes/struktura', 'See [[notes/struktura]].',
-      {}, 'concept', resolver, { globalBasename: true },
-    );
-    expect(candidates).toEqual([]);
-  });
-
  test('bare wikilink resolution does not interfere with DIR_PATTERN wikilinks', async () => {
    // 2b refs (people/alice) take the verb-inferred type;
    // 2c refs (struktura) take wikilink_basename. Same call.
@@ -302,29 +302,4 @@ describe('loadConfigWithEngine (Phase 4 / F3)', () => {
      expect(merged?.engine).toBe('pglite');
    });
  });
-
-  describe('eval.* DB-plane merge (#1475)', () => {
-    test('gbrain config set eval.capture true reaches the merged config', async () => {
-      // The #1475 repro: DB plane has eval.capture=true, file plane silent.
-      // Pre-fix the merge skipped eval.* entirely and capture never fired.
-      const base: GBrainConfig = { engine: 'pglite' };
-      const engine = makeEngine({ 'eval.capture': 'true', 'eval.scrub_pii': 'false' });
-      const merged = await loadConfigWithEngine(engine, base);
-      expect(merged?.eval?.capture).toBe(true);
-      expect(merged?.eval?.scrub_pii).toBe(false);
-    });
-
-    test('file plane wins per key; DB fills only the gaps', async () => {
-      const base: GBrainConfig = { engine: 'pglite', eval: { capture: false } };
-      const engine = makeEngine({ 'eval.capture': 'true', 'eval.scrub_pii': 'false' });
-      const merged = await loadConfigWithEngine(engine, base);
-      expect(merged?.eval?.capture).toBe(false); // file wins
-      expect(merged?.eval?.scrub_pii).toBe(false); // DB fills the gap
-    });
-
-    test('no eval keys anywhere leaves cfg.eval undefined', async () => {
-      const merged = await loadConfigWithEngine(makeEngine({}), { engine: 'pglite' });
-      expect(merged?.eval).toBeUndefined();
-    });
-  });
 });
@@ -1,62 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  extractCycleFreshnessSourceIds,
-  parseMaintainArgs,
-} from '../src/commands/maintain.ts';
-import type { Check } from '../src/commands/doctor.ts';
-
-describe('maintain args', () => {
-  test('defaults to dry-run unless --safe is explicit', () => {
-    expect(parseMaintainArgs([])).toMatchObject({
-      safe: false,
-      dryRun: true,
-      json: false,
-    });
-  });
-
-  test('--safe enables mutating safe mode', () => {
-    expect(parseMaintainArgs(['--safe', '--json'])).toMatchObject({
-      safe: true,
-      dryRun: false,
-      json: true,
-    });
-  });
-
-  test('--dry-run wins over --safe', () => {
-    expect(parseMaintainArgs(['--safe', '--dry-run'])).toMatchObject({
-      safe: true,
-      dryRun: true,
-    });
-  });
-});
-
-describe('cycle freshness source extraction', () => {
-  test('extracts stale source ids from doctor messages', () => {
-    const checks: Check[] = [
-      {
-        name: 'cycle_freshness',
-        status: 'fail',
-        message: "Source 'brain-sync-remote-teffur' last cycled 40h ago. Run `gbrain dream --source <id>`.",
-      },
-      {
-        name: 'cycle_freshness',
-        status: 'fail',
-        message: "Source 'wiki' last cycled 25h ago. Source 'wiki' last cycled 25h ago.",
-      },
-    ];
-
-    expect(extractCycleFreshnessSourceIds(checks)).toEqual([
-      'brain-sync-remote-teffur',
-      'wiki',
-    ]);
-  });
-
-  test('ignores ok and unrelated checks', () => {
-    const checks: Check[] = [
-      { name: 'cycle_freshness', status: 'ok', message: "Source 'fresh' last cycled recently." },
-      { name: 'frontmatter_integrity', status: 'warn', message: "Source 'wiki' has frontmatter issues." },
-    ];
-
-    expect(extractCycleFreshnessSourceIds(checks)).toEqual([]);
-  });
-});
@@ -0,0 +1,74 @@
+// Regression test for the nightly-quality-probe config-plane split-brain.
+//
+// The doctor check prints a paste-ready enable hint — `gbrain config set
+// autopilot.nightly_quality_probe.enabled true` — which writes the DB config
+// plane. But both the autopilot gate and the doctor check used to read ONLY
+// the file plane (~/.gbrain/config.json via loadConfig), so following the
+// hint was a silent no-op: the probe never ran and doctor kept reporting
+// "disabled (opt-in)".
+//
+// resolveProbeEnabled / resolveProbeMaxUsd pin the dual-plane rule (same
+// precedent as `mcp.publish_skills` in serve-http.ts): DB row wins when
+// present, file plane is the fallback.
+import { describe, expect, test } from 'bun:test';
+
+import {
+  resolveProbeEnabled,
+  resolveProbeMaxUsd,
+} from '../src/core/cycle/nightly-quality-probe.ts';
+
+describe('resolveProbeEnabled — dual-plane flag resolution', () => {
+  test('DB plane "true" enables regardless of file plane (the doctor hint path)', () => {
+    expect(resolveProbeEnabled('true', undefined)).toBe(true);
+    expect(resolveProbeEnabled('true', false)).toBe(true);
+  });
+
+  test('explicit DB "false" wins over file-plane true (config set off sticks)', () => {
+    expect(resolveProbeEnabled('false', true)).toBe(false);
+  });
+
+  test('file plane is the fallback when no DB row exists', () => {
+    expect(resolveProbeEnabled(null, true)).toBe(true);
+    expect(resolveProbeEnabled(undefined, true)).toBe(true);
+    expect(resolveProbeEnabled(null, undefined)).toBe(false);
+    expect(resolveProbeEnabled(null, false)).toBe(false);
+  });
+
+  test('file plane stays strict boolean — string "true" in config.json does not enable', () => {
+    // Matches the pre-fix autopilot gate (`=== true`); the doctor check used
+    // Boolean(...) and could disagree with autopilot on a string value.
+    // Both call sites now share this helper, so they can no longer diverge.
+    expect(resolveProbeEnabled(null, 'true')).toBe(false);
+    expect(resolveProbeEnabled(null, 1)).toBe(false);
+  });
+
+  test('non-"true" DB strings are off (mcp.publish_skills semantics)', () => {
+    expect(resolveProbeEnabled('1', true)).toBe(false);
+    expect(resolveProbeEnabled('yes', true)).toBe(false);
+    expect(resolveProbeEnabled('', true)).toBe(false);
+  });
+});
+
+describe('resolveProbeMaxUsd — dual-plane cost cap resolution', () => {
+  test('DB plane wins when parseable', () => {
+    expect(resolveProbeMaxUsd('2.5', 10)).toBe(2.5);
+    expect(resolveProbeMaxUsd('0', 10)).toBe(0);
+  });
+
+  test('malformed or negative DB value falls through to file plane', () => {
+    expect(resolveProbeMaxUsd('banana', 3)).toBe(3);
+    expect(resolveProbeMaxUsd('-1', 3)).toBe(3);
+  });
+
+  test('file plane used when no DB row; default when both absent/invalid', () => {
+    expect(resolveProbeMaxUsd(null, 7)).toBe(7);
+    expect(resolveProbeMaxUsd(null, '4')).toBe(4);
+    expect(resolveProbeMaxUsd(null, undefined)).toBe(5);
+    expect(resolveProbeMaxUsd(null, 'banana')).toBe(5);
+    expect(resolveProbeMaxUsd(undefined, -2)).toBe(5);
+  });
+
+  test('explicit fallback override is honored', () => {
+    expect(resolveProbeMaxUsd(null, undefined, 12)).toBe(12);
+  });
+});
@@ -132,17 +132,20 @@ describe('runNightlyQualityProbe (DI stub harness)', () => {
    });
  });

-  test('enabled + recent run within 24h → outcome: rate_limited', async () => {
+  test('enabled + recent run within 24h → outcome: rate_limited, NO audit row', async () => {
    // Pre-seed a recent audit event by running the probe once first.
    await withEnv({ GBRAIN_AUDIT_DIR: auditTmp }, async () => {
      // First run succeeds.
      await runNightlyQualityProbe(makeDeps());
-      // Second run, same hour → rate_limited.
+      // Second run, same hour → rate_limited. A skip is a non-event: the
+      // autopilot loop invokes the probe every cycle (~5-10 min), so
+      // logging each skip would flood the audit file and flip doctor's
+      // any-non-pass-is-bad filter to a permanent WARN.
      const r2 = await runNightlyQualityProbe(makeDeps());
      expect(r2.outcome).toBe('rate_limited');
      const events = await readEvents();
-      expect(events.length).toBe(2);
-      expect(events[1].outcome).toBe('rate_limited');
+      expect(events.length).toBe(1);
+      expect(events[0].outcome).toBe('pass');
    });
  });

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { readFileSync } from 'fs';
-import { join } from 'path';
-
-describe('root OpenClaw plugin manifest', () => {
-  it('declares the id required by OpenClaw plugin installs', () => {
-    const manifest = JSON.parse(readFileSync(join(import.meta.dir, '..', 'openclaw.plugin.json'), 'utf8'));
-    const entrySource = readFileSync(join(import.meta.dir, '..', 'src', 'openclaw-context-engine.ts'), 'utf8');
-    const entryId = entrySource.match(/id:\s*'([^']+)'/)?.[1];
-
-    expect(manifest.id).toBe(entryId);
-    expect(manifest.configSchema).toBeDefined();
-    expect(typeof manifest.configSchema).toBe('object');
-    expect(manifest.contracts?.contextEngines).toContain('gbrain-context');
-    expect(entrySource).toContain('export function register');
-  });
-});
@@ -186,67 +186,11 @@ describe('shouldExclude — orphan filter regression (preserve curation)', () =>
    expect(shouldExclude('entities/anonymous')).toBe(true);
    expect(shouldExclude('atoms/fact-123')).toBe(true);
    expect(shouldExclude('skills/gbrain-operations')).toBe(true);
-    expect(shouldExclude('dreaming/light/2026-07-20')).toBe(true);
-    expect(shouldExclude('daily/2026-07-20')).toBe(true);
-    expect(shouldExclude('agent-openclaw/daily/2026-07-20')).toBe(true);
-  });
-
-  test('workspace convention slugs are excluded', () => {
-    expect(shouldExclude('_brain-conventions')).toBe(true);
-    expect(shouldExclude('_templates/decision')).toBe(true);
-    expect(shouldExclude('extracts/2026-06-30/takes.proposed/round-single')).toBe(true);
-    expect(shouldExclude('2026-07-20')).toBe(true);
-    expect(shouldExclude('2026-07-20-qa-sweep')).toBe(true);
-    expect(shouldExclude('agents/arya/identity')).toBe(true);
-    expect(shouldExclude('agents/arya/memory/dreaming/deep/2026-07-20')).toBe(true);
  });

  test('regular slugs are NOT excluded', () => {
    expect(shouldExclude('people/alice')).toBe(false);
    expect(shouldExclude('companies/acme')).toBe(false);
    expect(shouldExclude('writing/post-1')).toBe(false);
-    expect(shouldExclude('agents/arya/qa-reports/launch-review')).toBe(false);
-  });
-});
-
-describe('getHealth orphan_pages uses shared exclusion policy', () => {
-  test('excluded convention islands do not count against health', async () => {
-    await engine.putPage('_templates/decision', {
-      type: 'template', title: 'Decision', compiled_truth: 'template', timeline: '', frontmatter: {},
-    });
-    await engine.putPage('skills/arya/source-check', {
-      type: 'concept', title: 'Skill', compiled_truth: 'skill', timeline: '', frontmatter: {},
-    });
-    await engine.putPage('agents/arya/identity', {
-      type: 'note', title: 'Identity', compiled_truth: 'identity', timeline: '', frontmatter: {},
-    });
-    await engine.putPage('people/alice', {
-      type: 'person', title: 'Alice', compiled_truth: 'real island', timeline: '', frontmatter: {},
-    });
-
-    const health = await engine.getHealth();
-
-    expect(health.orphan_pages).toBe(1);
-  });
-
-  test('per-brain config overrides (orphans.exclude_*) also apply to health', async () => {
-    await engine.putPage('my-private-folder/secret-ref', {
-      type: 'note', title: 'Ref', compiled_truth: 'ref', timeline: '', frontmatter: {},
-    });
-    await engine.putPage('one-off-fixture-page', {
-      type: 'note', title: 'Fixture', compiled_truth: 'fixture', timeline: '', frontmatter: {},
-    });
-    await engine.putPage('people/alice', {
-      type: 'person', title: 'Alice', compiled_truth: 'real island', timeline: '', frontmatter: {},
-    });
-
-    expect((await engine.getHealth()).orphan_pages).toBe(3);
-
-    await engine.setConfig('orphans.exclude_prefixes', 'my-private-folder/');
-    await engine.setConfig('orphans.exclude_slugs', 'one-off-fixture-page');
-    expect((await engine.getHealth()).orphan_pages).toBe(1);
-
-    await engine.unsetConfig('orphans.exclude_prefixes');
-    await engine.unsetConfig('orphans.exclude_slugs');
  });
 });
@@ -66,10 +66,6 @@ describe('shouldExclude', () => {
    expect(shouldExclude('templates/meeting-note')).toBe(true);
  });

-  test('excludes deny-prefix: _templates/', () => {
-    expect(shouldExclude('_templates/meeting-note')).toBe(true);
-  });
-
  test('excludes deny-prefix: openclaw/config/', () => {
    expect(shouldExclude('openclaw/config/agent')).toBe(true);
  });
@@ -90,44 +86,10 @@ describe('shouldExclude', () => {
    expect(shouldExclude('entities/product-hunt')).toBe(true);
  });

-  test('excludes first-segment: skills, dreaming, and daily', () => {
-    expect(shouldExclude('skills/arya/source-check')).toBe(true);
-    expect(shouldExclude('dreaming/light/2026-07-20')).toBe(true);
-    expect(shouldExclude('daily/2026-07-20')).toBe(true);
-    expect(shouldExclude('agent-openclaw/daily/2026-07-20')).toBe(true);
-  });
-
-  test('excludes root date logs and agent workspace conventions', () => {
-    expect(shouldExclude('_brain-conventions')).toBe(true);
-    expect(shouldExclude('2026-07-20')).toBe(true);
-    expect(shouldExclude('2026-07-20-qa-sweep')).toBe(true);
-    expect(shouldExclude('agents/arya/identity')).toBe(true);
-    expect(shouldExclude('agents/arya/memory/dreaming/deep/2026-07-20')).toBe(true);
-  });
-
-  test('excludes generated extracts', () => {
-    expect(shouldExclude('extracts/2026-06-30/takes.proposed/round-single')).toBe(true);
-  });
-
-  test('brain-specific exclusions come from config overrides, not global defaults', () => {
-    // No baked-in defaults for these:
-    expect(shouldExclude('my-private-folder/some-secret-ref.md')).toBe(false);
-    expect(shouldExclude('one-off-fixture-page')).toBe(false);
-    // The per-brain config plane (orphans.exclude_prefixes / exclude_slugs):
-    const overrides = {
-      excludePrefixes: ['my-private-folder/'],
-      excludeSlugs: ['one-off-fixture-page'],
-    };
-    expect(shouldExclude('my-private-folder/some-secret-ref.md', overrides)).toBe(true);
-    expect(shouldExclude('one-off-fixture-page', overrides)).toBe(true);
-    expect(shouldExclude('people/jane-doe', overrides)).toBe(false);
-  });
-
  test('does NOT exclude a normal content page', () => {
    expect(shouldExclude('companies/acme')).toBe(false);
    expect(shouldExclude('people/jane-doe')).toBe(false);
    expect(shouldExclude('projects/gbrain')).toBe(false);
-    expect(shouldExclude('agents/arya/qa-reports/launch-review')).toBe(false);
  });

  test('does NOT exclude a page ending with log-like text that is not /log', () => {
@@ -218,21 +218,15 @@ describe('progress reporter', () => {
  test('only one process-level signal handler installed across many reporters', () => {
    // Baseline: one handler already installed by prior tests in this file.
    const installedBefore = __signalHandlerInstalledForTest();
-    // liveReporters is process-global: earlier test files in the same shard
-    // can leave a live entry behind (e.g. a production path that skips
-    // finish() on an error branch). Assert NET-zero leak from THIS test's
-    // lifecycles, not an absolute zero we don't control — same tolerance
-    // the handler assertion below already applies via `installedBefore`.
-    const liveBefore = __liveReporterCountForTest();
    const { stream } = sink(false);
    for (let i = 0; i < 50; i++) {
      const p = createProgress({ mode: 'json', stream, minIntervalMs: 0, minItems: 1 });
      p.start(`phase_${i}`, 1);
      p.finish();
    }
-    // After 50 reporter lifecycles, still exactly one handler and zero NEWLY leaked live entries.
+    // After 50 reporter lifecycles, still exactly one handler and zero leaked live entries.
    expect(__signalHandlerInstalledForTest()).toBe(installedBefore || true);
-    expect(__liveReporterCountForTest()).toBe(liveBefore);
+    expect(__liveReporterCountForTest()).toBe(0);
  });

  test('startHeartbeat() fires heartbeats and stop() clears', async () => {
@@ -12,11 +12,9 @@ import {
  bestPath,
  historyPath,
  loadHistory,
-  proposedPath,
  revertAllPending,
  skillPath,
  versionsDir,
-  writeProposed,
 } from '../../src/core/skillopt/version-store.ts';

 let tmpDir: string;
@@ -81,19 +79,6 @@ describe('acceptCandidate (D8 two-phase commit)', () => {
  });
 });

-describe('writeProposed', () => {
-  test('writes distinct best and proposed artifacts without mutating SKILL.md (#2635)', () => {
-    const candidate = '---\nname: test\n---\nproposed body\n';
-
-    const written = writeProposed(tmpDir, SKILL, candidate);
-
-    expect(written).toBe(proposedPath(tmpDir, SKILL));
-    expect(fs.readFileSync(bestPath(tmpDir, SKILL), 'utf8')).toBe(candidate);
-    expect(fs.readFileSync(proposedPath(tmpDir, SKILL), 'utf8')).toBe(candidate);
-    expect(fs.readFileSync(skillPath(tmpDir, SKILL), 'utf8')).toContain('baseline body');
-  });
-});
-
 describe('revertAllPending (D8 crash recovery)', () => {
  test('no-op when no pending rows', () => {
    const reverted = revertAllPending(tmpDir, SKILL);