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>

src/cli.ts

@@ -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', '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', 'facts', '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.
@@ -991,8 +991,6 @@ const THIN_CLIENT_REFUSED_COMMANDS = new Set([
   // hint pointing at the routable MCP tools; per-subcommand splits are
   // a v0.31.x follow-up TODO.
   'takes', 'sources',
-  // #1867: fence-backfill edits local .md fences + stamps the local DB.
-  'facts',
   // v0.32 thin-client routing audit (Codex round 2 findings #2, #4):
   // - `pages` purge-deleted is admin+localOnly (operations.ts:856-864)
   // - `files` list / file_url MCP ops are localOnly (operations.ts:1769-1879)
@@ -1028,7 +1026,6 @@ const THIN_CLIENT_REFUSE_HINTS: Record<string, string> = {
   migrate: "migrate runs on the host's local engine. Run on the host machine.",
   'apply-migrations': 'schema migrations run on the host. SSH and run there.',
   'repair-jsonb': 'repair-jsonb operates on the local DB only.',
-  facts: 'facts fence-backfill edits local entity-page fences. Run on the host machine.',
   integrity: 'integrity scans local files. Run on the host machine.',
   serve: 'serve starts a server. Run on the host, not the thin client.',
   dream: 'dream runs the autopilot cycle on the host. `gbrain remote ping` queues one. (Native `gbrain dream` thin-client routing planned for v0.31.2.)',
@@ -1858,13 +1855,6 @@ async function handleCliOnly(command: string, args: string[]) {
         await runEdgesBackfill(engine, args);
         break;
       }
-      case 'facts': {
-        // #1867 — re-runnable fence-backfill for row_num-NULL legacy fact
-        // rows (idempotent v0_32_2 phase B, exposed as an operator command).
-        const { runFactsCommand } = await import('./commands/facts.ts');
-        await runFactsCommand(engine, args);
-        break;
-      }
       case 'whoknows': {
         // v0.33 (Issue #?): expertise + relationship-proximity routing.
         // MCP op `find_experts` (read-scoped) backs the same code path; CLI
@@ -2345,7 +2335,6 @@ TOOLS
   check-backlinks <check|fix> [dir]  Find/fix missing back-links across brain
   lint <dir|file> [--fix]            Catch LLM artifacts, placeholder dates, bad frontmatter
   orphans [--json] [--count]         Find pages with no inbound wikilinks
-  facts fence-backfill [--dry-run]   Fence legacy fact rows (row_num NULL) onto entity pages
   salience [--days N] [--kind P]     v0.29: pages ranked by emotional + activity salience
   anomalies [--since D] [--sigma N]  v0.29: cohort-based statistical anomalies (tag, type)
   transcripts recent [--days N]      v0.29: recent raw .txt transcripts (local-only)

src/commands/autopilot.ts

@@ -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));
   }

src/commands/doctor.ts

@@ -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/`

src/commands/eval-cross-modal.ts

@@ -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,

src/commands/eval-longmemeval.ts

@@ -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 } : {}),

src/commands/facts.ts

@@ -1,48 +0,0 @@
-/**
- * gbrain facts — fact-store maintenance surface (#1867).
- *
- * `fence-backfill` re-runs the v0_32_2 fence-backfill phase on demand.
- * Remote `extract_facts` deposits that predate the fence-write backstop
- * (and any legacy DB-only insert) leave `row_num IS NULL` rows that the
- * cycle extract_facts guard refuses to reconcile past — previously the
- * only remedy was the one-shot v0_32_2 migration, which the ledger marks
- * complete and never re-runs. The phase is idempotent (only touches
- * `row_num IS NULL` rows), so exposing it as a command is safe to re-run
- * any time the backlog reappears.
- */
-import type { BrainEngine } from '../core/engine.ts';
-import { setCliExitVerdict } from '../core/cli-force-exit.ts';
-import { phaseBFenceFacts } from './migrations/v0_32_2.ts';
-
-function printHelp(): void {
-  process.stderr.write(
-    `Usage: gbrain facts fence-backfill [--dry-run]\n\n` +
-      `Fence-backfill: appends every legacy fact row (row_num IS NULL) to its\n` +
-      `entity page's \`## Facts\` fence and stamps row_num + source_markdown_slug\n` +
-      `back onto the DB row. Idempotent — re-runs only pick up rows still\n` +
-      `missing a fence assignment. Clears the backlog that makes the cycle's\n` +
-      `extract_facts phase skip fence→DB reconciliation.\n\n` +
-      `  --dry-run   report what would be fenced; no FS or DB writes\n`,
-  );
-}
-
-export async function runFactsCommand(engine: BrainEngine, args: string[]): Promise<void> {
-  const sub = args[0];
-  if (!sub || sub === '--help' || sub === '-h') {
-    printHelp();
-    return;
-  }
-  if (sub !== 'fence-backfill') {
-    process.stderr.write(`Unknown facts subcommand: ${sub}\n`);
-    printHelp();
-    setCliExitVerdict(1);
-    return;
-  }
-
-  const dryRun = args.includes('--dry-run');
-  const result = await phaseBFenceFacts(engine, { dryRun });
-  process.stderr.write(
-    `fence-backfill: ${result.status}${result.detail ? ` — ${result.detail}` : ''}\n`,
-  );
-  if (result.status === 'failed') setCliExitVerdict(1);
-}

src/commands/migrations/v0_32_2.ts

@@ -39,7 +39,6 @@ import type { BrainEngine } from '../../core/engine.ts';
 import { loadConfig, toEngineConfig } from '../../core/config.ts';
 import { createEngine } from '../../core/engine-factory.ts';
 import { upsertFactRow, parseFactsFence } from '../../core/facts-fence.ts';
-import { resolvePageFilePath } from '../../core/markdown.ts';
 
 let testEngineOverride: BrainEngine | null = null;
 export function __setTestEngineOverride(engine: BrainEngine | null): void {
@@ -149,16 +148,9 @@ function isLocalPathDirty(localPath: string): boolean {
   }
 }
 
-/**
- * Exported (not just via `__testing`) because `gbrain facts fence-backfill`
- * (#1867) re-runs this phase on demand: remote `extract_facts` deposits that
- * predate the fence-write backstop leave row_num-NULL rows the cycle guard
- * refuses to reconcile past. The phase is idempotent (only touches
- * `row_num IS NULL` rows), so re-running is always safe.
- */
-export async function phaseBFenceFacts(
+async function phaseBFenceFacts(
   engine: BrainEngine | null,
-  opts: Pick<OrchestratorOpts, 'dryRun'>,
+  opts: OrchestratorOpts,
 ): Promise<OrchestratorPhaseResult> {
   if (opts.dryRun) {
     // Dry-run: report what WOULD happen without touching FS or DB.
@@ -246,11 +238,7 @@ export async function phaseBFenceFacts(
     for (const [key, group] of groups) {
       const [sourceId, entitySlug] = key.split('\0');
       const localPath = localPathById.get(sourceId)!;
-      // resolvePageFilePath, NOT a bare join — non-default sources fence
-      // into `<local_path>/.sources/<id>/<slug>.md`, the same path the
-      // fence-write backstop and put_page write-through compute. A bare
-      // join here diverges fence and DB for non-default sources (#2044).
-      const filePath = resolvePageFilePath(localPath, entitySlug, sourceId);
+      const filePath = join(localPath, `${entitySlug}.md`);
       const tmpPath = `${filePath}.tmp`;
 
       try {
@@ -281,21 +269,6 @@ export async function phaseBFenceFacts(
         const existingFence = parseFactsFence(body);
         const existingKeySet = new Set(existingFence.facts.map(f => `${f.claim}\0${f.source ?? ''}`));
 
-        // Seed appended row_nums from MAX(fence max, DB max) — same #2044
-        // divergence guard as writeFactsToFence. When the fence at the
-        // resolved path is missing/behind but the DB already holds stamped
-        // rows for this slug (legacy wrong-path fence writes), fence-max+1
-        // collides with idx_facts_fence_key on the post-rename UPDATE,
-        // failing the page and leaving fence and DB disagreeing.
-        const dbMaxRows = await engine.executeRaw<{ max: number | string | null }>(
-          `SELECT MAX(row_num) AS max FROM facts
-            WHERE source_id = $1 AND source_markdown_slug = $2`,
-          [sourceId, entitySlug],
-        );
-        const dbMaxRowNum = Number(dbMaxRows[0]?.max ?? 0) || 0;
-        const fenceMaxRowNum = existingFence.facts.reduce((m, f) => Math.max(m, f.rowNum), 0);
-        let nextRowNum = Math.max(fenceMaxRowNum, dbMaxRowNum) + 1;
-
         const assignments: Array<{ id: string; row_num: number }> = [];
         for (const row of group) {
           const key = `${row.fact}\0${row.source ?? ''}`;
@@ -318,7 +291,6 @@ export async function phaseBFenceFacts(
                 .toISOString().slice(0, 10)
             : undefined;
           const { body: updated, rowNum } = upsertFactRow(body, {
-            rowNum:     nextRowNum++,
             claim:      row.fact,
             kind:       row.kind,
             confidence: row.confidence,
@@ -409,7 +381,7 @@ async function phaseCVerify(
     for (const g of groups) {
       const localPath = localPathById.get(g.source_id);
       if (!localPath) continue;
-      const filePath = resolvePageFilePath(localPath, g.source_markdown_slug, g.source_id);
+      const filePath = join(localPath, `${g.source_markdown_slug}.md`);
       if (!existsSync(filePath)) {
         mismatches.push(`${g.source_markdown_slug} (file missing)`);
         continue;

src/core/audit-parser-probe.ts

@@ -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;
+  });
+}

src/core/config.ts

@@ -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

src/core/conversation-parser/nightly-probe.ts

@@ -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.

src/core/cross-modal-eval/runner.ts

@@ -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' },
 ];

src/core/cycle/extract-facts.ts

@@ -176,11 +176,9 @@ export async function runExtractFacts(
   if (legacyCount > 0) {
     result.guardTriggered = true;
     result.warnings.push(
-      `extract_facts: ${legacyCount} legacy fact rows pending fence backfill ` +
-      `(row_num IS NULL — v0.31 rows or remote extract_facts deposits that ` +
-      `predate the fence backstop). Run \`gbrain facts fence-backfill\` ` +
-      `(idempotent, re-runnable) before this phase can safely reconcile ` +
-      `fence → DB.`,
+      `extract_facts: ${legacyCount} legacy v0.31 fact rows pending fence backfill. ` +
+      `Run \`gbrain apply-migrations --yes\` to complete v0_32_2 before this phase ` +
+      `can safely reconcile fence → DB.`,
     );
     return result;
   }

src/core/cycle/nightly-probe-adapters.ts

@@ -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',
   ]);

src/core/cycle/nightly-quality-probe.ts

@@ -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' };
   }
 

src/core/engine.ts

@@ -1739,14 +1739,13 @@ export interface BrainEngine {
    * single-row supersede flow because fence reconciliation is the canonical
    * source-of-truth direction, not the consolidator path.
    *
-   * Insertion runs in a single transaction. A collision on the v51
-   * partial UNIQUE index `(source_id, source_markdown_slug, row_num)`
-   * skips ONLY that row (ON CONFLICT DO NOTHING, #2044) — the rest of
-   * the batch still commits, so a redundant deposit against an
-   * already-indexed fence row is idempotent instead of a hard failure.
+   * Insertion is atomic per call: all rows commit in a single transaction
+   * or none commit (the transaction rolls back on any constraint
+   * violation, e.g. the v51 partial UNIQUE index on
+   * `(source_id, source_markdown_slug, row_num)`).
    *
-   * Returns the inserted ids in input-order (colliding rows omitted) so
-   * callers can correlate fence-row → DB-id without a separate lookup.
+   * Returns the inserted ids in input-order so callers can correlate
+   * fence-row → DB-id without a separate lookup.
    */
   insertFacts(
     rows: Array<NewFact & { row_num: number; source_markdown_slug: string }>,

src/core/facts/fence-write.ts

@@ -218,27 +218,11 @@ export async function writeFactsToFence(
       }
 
       // 2. Upsert each fact onto the fence in input order. row_num
-      //    monotonically increases, append-only, seeded from the MAX of
-      //    the fence and the DB index (#2044): when fence and DB have
-      //    diverged (e.g. legacy writes that stamped DB rows against a
-      //    fence at a path this code no longer reads), fence-max+1 can
-      //    collide with an existing DB row_num, tripping
-      //    idx_facts_fence_key and rolling back the whole batch.
-      const dbMaxRows = await engine.executeRaw<{ max: number | string | null }>(
-        `SELECT MAX(row_num) AS max FROM facts
-          WHERE source_id = $1 AND source_markdown_slug = $2`,
-        [target.sourceId, target.slug],
-      );
-      const dbMaxRowNum = Number(dbMaxRows[0]?.max ?? 0) || 0;
-      const fenceMaxRowNum = parseFactsFence(body).facts
-        .reduce((m, f) => Math.max(m, f.rowNum), 0);
-      let nextRowNum = Math.max(fenceMaxRowNum, dbMaxRowNum) + 1;
-
+      //    monotonically increases (max-existing + 1 per call, append-only).
       const assignedRowNums: number[] = [];
       for (const f of facts) {
         const validFromStr = (f.validFrom ?? new Date()).toISOString().slice(0, 10);
         const { body: updated, rowNum } = upsertFactRow(body, {
-          rowNum:      nextRowNum++,
           claim:       f.fact,
           kind:        (f.kind ?? 'fact') as 'fact' | 'event' | 'preference' | 'commitment' | 'belief',
           confidence:  f.confidence ?? 1.0,

src/core/model-pricing.ts

@@ -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 ─────────────────────────────────────────────────────────────

src/core/pglite-engine.ts

@@ -4102,13 +4102,11 @@ export class PGLiteEngine implements BrainEngine {
   ): Promise<{ inserted: number; ids: number[] }> {
     if (rows.length === 0) return { inserted: 0, ids: [] };
 
-    // Single transaction; per-row INSERTs (not multi-row VALUES) keep the
-    // embedding-vs-no-embedding branching readable; batch sizes are small
-    // (5-30 rows per page in practice) so the loop overhead is negligible
-    // vs the embedding compute cost. #2044: ON CONFLICT DO NOTHING on the
-    // v51 partial UNIQUE index makes a residual fence/DB row_num collision
-    // skip that row instead of rolling back the whole batch (parity with
-    // postgres-engine.ts).
+    // Single transaction so the v51 partial UNIQUE index can roll back the
+    // whole batch on constraint violation. Per-row INSERTs (not multi-row
+    // VALUES) keep the embedding-vs-no-embedding branching readable; batch
+    // sizes are small (5-30 rows per page in practice) so the loop overhead
+    // is negligible vs the embedding compute cost.
     const ids = await this.db.transaction(async (tx) => {
       const out: number[] = [];
       for (const input of rows) {
@@ -4151,11 +4149,7 @@ export class PGLiteEngine implements BrainEngine {
                  $14, $15,
                  $16, $17, $18, $19,
                  $20
-               )
-               ON CONFLICT (source_id, source_markdown_slug, row_num)
-                 WHERE row_num IS NOT NULL
-                 DO NOTHING
-               RETURNING id`
+               ) RETURNING id`
             : `INSERT INTO facts (
                  source_id, entity_slug, fact, kind, visibility, notability, context,
                  valid_from, valid_until, source, source_session, confidence,
@@ -4169,16 +4163,12 @@ export class PGLiteEngine implements BrainEngine {
                  $15, $16,
                  $17, $18, $19, $20,
                  $21
-               )
-               ON CONFLICT (source_id, source_markdown_slug, row_num)
-                 WHERE row_num IS NOT NULL
-                 DO NOTHING
-               RETURNING id`,
+               ) RETURNING id`,
           embedStr === null
             ? [ctx.source_id, entitySlug, input.fact, kind, visibility, notability, context, validFrom, validUntil, input.source, sourceSession, confidence, embeddedAt, input.row_num, input.source_markdown_slug, claimMetric, claimValue, claimUnit, claimPeriod, eventType]
             : [ctx.source_id, entitySlug, input.fact, kind, visibility, notability, context, validFrom, validUntil, input.source, sourceSession, confidence, embedStr, embeddedAt, input.row_num, input.source_markdown_slug, claimMetric, claimValue, claimUnit, claimPeriod, eventType],
         );
-        if (ins.rows[0]) out.push(ins.rows[0].id);
+        out.push(ins.rows[0].id);
       }
       return out;
     });

src/core/postgres-engine.ts

@@ -4302,12 +4302,10 @@ export class PostgresEngine implements BrainEngine {
     // ONCE per process so the cast matches the actual column type
     // (halfvec vs vector). The probe is cached after first call.
     const castSuffix = await this.resolveFactsEmbeddingCast();
-    // Single transaction; per-row INSERTs (not multi-row VALUES) keep the
-    // embedding-vs-no-embedding branching readable; batch sizes are small
-    // (5-30 rows per page in practice). #2044: ON CONFLICT DO NOTHING on
-    // the v51 partial UNIQUE index makes a residual fence/DB row_num
-    // collision skip that row instead of rolling back the whole batch —
-    // the fence stays system-of-record and reconciliation catches up.
+    // Single transaction so the v51 partial UNIQUE index can roll back
+    // the whole batch on constraint violation. Per-row INSERTs (not
+    // multi-row VALUES) keep the embedding-vs-no-embedding branching
+    // readable; batch sizes are small (5-30 rows per page in practice).
     // No supersede flow in this path — fence reconciliation is the
     // canonical source-of-truth direction, not the consolidator path.
     const ids = await sql.begin(async (tx) => {
@@ -4348,13 +4346,9 @@ export class PostgresEngine implements BrainEngine {
             ${input.row_num}, ${input.source_markdown_slug},
             ${claimMetric}, ${claimValue}, ${claimUnit}, ${claimPeriod},
             ${eventType}
-          )
-          ON CONFLICT (source_id, source_markdown_slug, row_num)
-            WHERE row_num IS NOT NULL
-            DO NOTHING
-          RETURNING id
+          ) RETURNING id
         `;
-        if (ins[0]) out.push(Number(ins[0].id));
+        out.push(Number(ins[0].id));
       }
       return out;
     });

test/audit-parser-probe.serial.test.ts

@@ -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);
+  });
+});

test/autopilot-nightly-probe-wiring.test.ts

@@ -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\)/);
   });
 });

test/autopilot-parser-probe-wiring.test.ts

@@ -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:`);
+  });
+});

test/cross-modal-default-slots.test.ts

@@ -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);
+  });
+});

test/doctor-parser-probe-check.test.ts

@@ -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)');
+  });
+});

test/extract-facts-phase.test.ts

@@ -304,9 +304,7 @@ describe('runExtractFacts — empty-fence guard (Codex R2-#7)', () => {
     expect(r.legacyRowsPending).toBe(1);
     expect(r.factsInserted).toBe(0);
     expect(r.factsDeleted).toBe(0);
-    // #1867: the remedy hint points at the re-runnable backfill command,
-    // not the one-shot v0_32_2 migration (which the ledger never re-runs).
-    expect(r.warnings.some(w => w.includes('gbrain facts fence-backfill'))).toBe(true);
+    expect(r.warnings.some(w => w.includes('apply-migrations'))).toBe(true);
 
     // Legacy row was NOT touched.
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

test/facts-fence-backfill-command.test.ts

@@ -1,133 +0,0 @@
-/**
- * #1867 — `gbrain facts fence-backfill` command tests.
- *
- * The command re-runs the (idempotent) v0_32_2 phase B on demand so
- * row_num-NULL backlogs — remote extract_facts deposits that predate
- * the fence-write backstop — can be cleared without re-running the
- * one-shot migration. Real PGLite + real tempdir filesystem.
- */
-
-import { describe, test, expect, beforeAll, afterAll, beforeEach } from 'bun:test';
-import { mkdtempSync, rmSync, existsSync, readFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { PGLiteEngine } from '../src/core/pglite-engine.ts';
-import { runFactsCommand } from '../src/commands/facts.ts';
-import { phaseBFenceFacts } from '../src/commands/migrations/v0_32_2.ts';
-
-let engine: PGLiteEngine;
-let brainDir: string;
-
-beforeAll(async () => {
-  engine = new PGLiteEngine();
-  await engine.connect({});
-  await engine.initSchema();
-});
-
-afterAll(async () => {
-  await engine.disconnect();
-  try {
-    if (brainDir) rmSync(brainDir, { recursive: true, force: true });
-  } catch { /* best-effort */ }
-});
-
-beforeEach(async () => {
-  brainDir = mkdtempSync(join(tmpdir(), 'facts-backfill-cmd-test-'));
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  await (engine as any).db.query('DELETE FROM facts');
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  await (engine as any).db.query(
-    `UPDATE sources SET local_path = $1 WHERE id = 'default'`,
-    [brainDir],
-  );
-});
-
-async function seedLegacyFact(fact: string): Promise<void> {
-  // The row_num-NULL shape a remote extract_facts deposit leaves behind
-  // when it lands via the legacy DB-only path.
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  await (engine as any).db.query(
-    `INSERT INTO facts (source_id, entity_slug, fact, kind, visibility, notability,
-                        valid_from, source, confidence)
-     VALUES ('default', 'people/alice', $1, 'fact', 'private', 'medium',
-             now(), 'mcp:extract_facts', 1.0)`,
-    [fact],
-  );
-}
-
-describe('gbrain facts fence-backfill', () => {
-  test('fences row_num-NULL rows and stamps the DB', async () => {
-    await seedLegacyFact('Deposited remotely');
-
-    await runFactsCommand(engine, ['fence-backfill']);
-
-    // The fence exists on disk with the claim.
-    const filePath = join(brainDir, 'people/alice.md');
-    expect(existsSync(filePath)).toBe(true);
-    expect(readFileSync(filePath, 'utf-8')).toContain('Deposited remotely');
-
-    // The backlog is cleared: no row_num-NULL rows remain.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const rows = await (engine as any).db.query(
-      'SELECT row_num, source_markdown_slug FROM facts',
-    );
-    expect(rows.rows).toHaveLength(1);
-    expect(rows.rows[0].row_num).toBe(1);
-    expect(rows.rows[0].source_markdown_slug).toBe('people/alice');
-  });
-
-  test('re-run is a no-op (idempotent)', async () => {
-    await seedLegacyFact('Deposited remotely');
-    await runFactsCommand(engine, ['fence-backfill']);
-    await runFactsCommand(engine, ['fence-backfill']);
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const rows = await (engine as any).db.query('SELECT id FROM facts');
-    expect(rows.rows).toHaveLength(1);
-    const body = readFileSync(join(brainDir, 'people/alice.md'), 'utf-8');
-    expect(body.match(/Deposited remotely/g)).toHaveLength(1);
-  });
-
-  test('--dry-run reports without writing', async () => {
-    await seedLegacyFact('Deposited remotely');
-    await runFactsCommand(engine, ['fence-backfill', '--dry-run']);
-
-    expect(existsSync(join(brainDir, 'people/alice.md'))).toBe(false);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const rows = await (engine as any).db.query(
-      'SELECT row_num FROM facts',
-    );
-    expect(rows.rows[0].row_num).toBeNull();
-  });
-
-  test('diverged page: appends past the DB row_num max instead of colliding (#2044 class)', async () => {
-    // The #2044 divergence shape the backfill must survive: the DB already
-    // holds stamped rows 1..3 for the slug (legacy wrong-path fence write),
-    // but the fence at the resolved path is missing. Fence-max+1 (= 1) would
-    // collide with the stamped rows on the post-rename UPDATE, failing the
-    // page and leaving the renamed fence disagreeing with the DB.
-    for (let n = 1; n <= 3; n++) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      await (engine as any).db.query(
-        `INSERT INTO facts (source_id, entity_slug, fact, kind, visibility, notability,
-                            valid_from, source, confidence, row_num, source_markdown_slug)
-         VALUES ('default', 'people/alice', $1, 'fact', 'private', 'medium',
-                 now(), 'mcp:extract_facts', 1.0, $2, 'people/alice')`,
-        [`stamped ${n}`, n],
-      );
-    }
-    await seedLegacyFact('Deposited remotely');
-
-    const result = await phaseBFenceFacts(engine, { dryRun: false });
-    expect(result.status).toBe('complete');
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const rows = await (engine as any).db.query(
-      `SELECT row_num FROM facts WHERE fact = 'Deposited remotely'`,
-    );
-    expect(rows.rows[0].row_num).toBe(4);
-    const body = readFileSync(join(brainDir, 'people/alice.md'), 'utf-8');
-    expect(body).toContain('| 4 | Deposited remotely |');
-  });
-});

test/fence-write.test.ts

@@ -292,49 +292,6 @@ describe('lookupSourceLocalPath', () => {
   });
 });
 
-describe('writeFactsToFence — fence/DB divergence (#2044)', () => {
-  test('seeds row_num past the DB max when the fence lags the DB', async () => {
-    // Simulate the divergence class from #2044: DB rows were stamped with
-    // row_nums against a fence written at a path this code no longer reads
-    // (e.g. the pre-"Local patch 2026-06-11" wrong-path writes). The page
-    // on disk has NO fence, but the DB already holds row_num 1..3 for the
-    // slug. Pre-fix, the next deposit re-assigned row_num=1 from fence
-    // text alone and the whole insertFacts batch failed on
-    // idx_facts_fence_key.
-    for (let n = 1; n <= 3; n++) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      await (engine as any).db.query(
-        `INSERT INTO facts (source_id, entity_slug, fact, kind, visibility, notability,
-                            valid_from, source, confidence, row_num, source_markdown_slug)
-         VALUES ('default', 'people/dana', $1, 'fact', 'private', 'medium',
-                 now(), 'mcp:extract_facts', 1.0, $2, 'people/dana')`,
-        [`old claim ${n}`, n],
-      );
-    }
-
-    const result = await writeFactsToFence(
-      engine,
-      { sourceId: 'default', localPath: brainDir, slug: 'people/dana' },
-      [baseInput({ fact: 'second deposit' })],
-    );
-
-    expect(result.fenceWriteFailed).toBeUndefined();
-    expect(result.inserted).toBe(1);
-
-    // The new row landed PAST the DB max, not at fence-max+1 (= 1).
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const rows = await (engine as any).db.query(
-      'SELECT row_num FROM facts WHERE id = $1',
-      [result.ids[0]],
-    );
-    expect(rows.rows[0].row_num).toBe(4);
-
-    // And the on-disk fence carries the same row_num — fence and DB agree.
-    const body = readFileSync(join(brainDir, 'people/dana.md'), 'utf-8');
-    expect(body).toContain('| 4 | second deposit |');
-  });
-});
-
 // Cleanup any leftover tempdirs after the whole suite.
 afterAll(() => {
   // No-op: each test cleaned up via the beforeEach; this is a safety net.

test/insert-facts-batch.test.ts

@@ -5,7 +5,7 @@
  *   - Batch insert N rows persists row_num + source_markdown_slug
  *   - Empty batch is a no-op
  *   - Returns ids in input-order
- *   - v51 partial UNIQUE collision skips only the colliding row (#2044)
+ *   - v51 partial UNIQUE index rolls back the whole batch on a collision
  *   - deleteFactsForPage scopes by (source_id, source_markdown_slug);
  *     never touches other pages or pre-v51 NULL-source_markdown_slug rows
  *   - deleteFactsForPage on an empty page returns deleted:0 (idempotent)
@@ -135,29 +135,30 @@ describe('engine.insertFacts — batch insert', () => {
     });
   });
 
-  test('v51 partial UNIQUE collision skips ONLY the colliding row (#2044)', async () => {
+  test('v51 partial UNIQUE index rolls back the whole batch on collision', async () => {
     // Seed row #1 first.
     await engine.insertFacts([fixtureFact(1, { fact: 'seeded' })], { source_id: 'default' });
 
-    // Batch-insert rows that include a colliding row_num=1. Pre-#2044 this
-    // threw and rolled back the whole batch, making a second remote
-    // extract_facts deposit to an already-fenced page a hard failure. Now
-    // ON CONFLICT DO NOTHING skips the colliding row and keeps the rest.
-    const result = await engine.insertFacts(
-      [
-        fixtureFact(2, { fact: 'second' }),
-        fixtureFact(1, { fact: 'collides' }),  // row_num=1 on same (source_id, source_markdown_slug)
-        fixtureFact(3, { fact: 'third' }),
-      ],
-      { source_id: 'default' },
-    );
-    expect(result.inserted).toBe(2);
-    expect(result.ids).toHaveLength(2);
+    // Now try to batch-insert rows that include a colliding row_num=1.
+    let threw = false;
+    try {
+      await engine.insertFacts(
+        [
+          fixtureFact(2, { fact: 'second' }),
+          fixtureFact(1, { fact: 'collides' }),  // row_num=1 on same (source_id, source_markdown_slug)
+          fixtureFact(3, { fact: 'third' }),
+        ],
+        { source_id: 'default' },
+      );
+    } catch {
+      threw = true;
+    }
+    expect(threw).toBe(true);
 
-    // The seeded row survives untouched; the colliding claim is skipped.
+    // Verify the transaction rolled back — only the seeded row should remain.
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const rows = await (engine as any).db.query('SELECT fact FROM facts ORDER BY id');
-    expect(rows.rows.map((r: { fact: string }) => r.fact)).toEqual(['seeded', 'second', 'third']);
+    expect(rows.rows.map((r: { fact: string }) => r.fact)).toEqual(['seeded']);
   });
 
   test('different source_markdown_slug values DO NOT collide on the same row_num', async () => {

test/nightly-probe-config-plane.test.ts

@@ -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);
+  });
+});

test/nightly-quality-probe.test.ts

@@ -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');
     });
   });