fix(remediation): pass LINK_EXTRACTOR_VERSION_TS to the extraction-lag gate

countExtractionLag omitted versionTs, so its predicate diverged from the
counter it claims to share with doctor's links_extraction_lag check and
the extract --stale walk: pages stamped before an extractor version bump
(links_extracted_at < LINK_EXTRACTOR_VERSION_TS) lagged for doctor and
extract but never tripped the sync.repo/extract.all gate. Pass the stamp;
pin the version-bump arm with a backdated-page test (fails without it).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/commands/autopilot.ts

@@ -686,6 +686,7 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
       try {
         const { MinionQueue } = await import('../core/minions/queue.ts');
         const { computeRecommendations, embeddingProviderConfigured, HOSTED_EMBED_KEY_CONFIG } = await import('../core/brain-score-recommendations.ts');
+        const { countExtractionLag } = await import('../core/remediation/context.ts');
         const queue = new MinionQueue(engine);
         const slotMs = Math.floor(Date.now() / (baseInterval * 1000)) * baseInterval * 1000;
         const slot = new Date(slotMs).toISOString();
@@ -877,6 +878,9 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
             return !!(process.env[envVar] || (cfgField ? embedKeyCfg[cfgField] : undefined));
           }),
           hasChatApiKey: !!(process.env.ANTHROPIC_API_KEY || await engine.getConfig('anthropic_api_key')),
+          // Real extraction-lag gate for sync.repo/extract.all — same counter
+          // loadRecommendationContext uses (replaces the health.stale_pages proxy).
+          extractionLagPages: await countExtractionLag(engine),
         };
         // v0.41.18.0 (A5 + A19 + A22, T15): consult onboard recommendations
         // ALONGSIDE doctor's brain-score recommendations. Onboard's 4 new

src/commands/models.ts

@@ -50,10 +50,6 @@ const PER_TASK_KEYS: Array<{ key: string; tier: ModelTier; description: string }
   { key: 'models.eval.contradictions_judge', tier: 'utility',  description: 'Contradiction probe judge (v0.34 temporal-aware)' },
   { key: 'models.expansion',                tier: 'utility',   description: 'Query expansion for hybrid search' },
   { key: 'models.chat',                     tier: 'reasoning', description: 'Default `gateway.chat()` model' },
-  { key: 'models.propose_takes',            tier: 'reasoning', description: 'propose_takes claim extractor' },
-  { key: 'models.grade_takes',              tier: 'reasoning', description: 'grade_takes verdict judge' },
-  { key: 'models.calibration_profile',      tier: 'reasoning', description: 'Calibration profile generator' },
-  { key: 'models.brainstorm',               tier: 'reasoning', description: '`gbrain brainstorm` orchestrator' },
 ];
 
 interface ModelEntry {

src/core/brain-score-recommendations.ts

@@ -146,6 +146,16 @@ export interface RecommendationContext {
   chatModel?: string;
   /** Whether the chat provider has a usable API key. */
   hasChatApiKey?: boolean;
+  /**
+   * Count of pages needing link/timeline extraction — the SAME staleness the
+   * `gbrain extract --stale` walk and doctor's `links_extraction_lag` check use
+   * (`engine.countStalePagesForExtraction`). Gates the sync→extract pipeline
+   * (sync.repo / extract.all). Replaces the old `health.stale_pages` gate, which
+   * counted "pages whose updated_at predates their newest timeline entry" — a
+   * proxy that broke when the updated_at-on-timeline-insert trigger was dropped
+   * (migration v10) and never reflected real extraction work.
+   */
+  extractionLagPages?: number;
 }
 
 /** Triage result for one check. */
@@ -192,20 +202,28 @@ export function computeRecommendations(
   const source = ctx.sourceId ?? 'default';
 
   // ---------------------------------------------------------------------
-  // sync.repo — fires when sync hasn't run recently OR pages are stale
+  // sync.repo + extract.all — the materialization pipeline, gated on the REAL
+  // extraction lag (pages whose link/timeline edges are stale), NOT on the
+  // legacy `health.stale_pages` proxy. `extractionLagPages` comes from the same
+  // counter the `extract --stale` walk + doctor's `links_extraction_lag` use, so
+  // the recommendation can only fire when running extract will actually reduce
+  // it (and clear the rec). See RecommendationContext.extractionLagPages.
+  // sync.repo is the prerequisite: re-sync so pages are current before extract
+  // materializes their edges.
   // ---------------------------------------------------------------------
-  if (ctx.repoPath && health.stale_pages > 0) {
+  const extractionLag = ctx.extractionLagPages ?? 0;
+  if (ctx.repoPath && extractionLag > 0) {
     const params = { repoPath: ctx.repoPath, sourceId: ctx.sourceId, noEmbed: true };
     out.push({
       id: 'sync.repo',
       job: 'sync',
       params,
       idempotency_key: idemKey(source, 'sync', params),
-      severity: health.stale_pages > 50 ? 'high' : 'medium',
-      est_seconds: Math.min(600, 30 + health.stale_pages * 0.5),
+      severity: extractionLag > 50 ? 'high' : 'medium',
+      est_seconds: Math.min(600, 30 + extractionLag * 0.5),
       est_usd_cost: 0,  // sync is fs+DB only
       depends_on: [],
-      rationale: `${health.stale_pages} stale page${health.stale_pages === 1 ? '' : 's'} on disk`,
+      rationale: `Sync before extracting ${extractionLag} page${extractionLag === 1 ? '' : 's'} with stale link/timeline edges`,
       status: 'remediable',
     });
   }
@@ -237,7 +255,7 @@ export function computeRecommendations(
       est_seconds: Math.min(3600, 5 + health.missing_embeddings * 0.05),
       est_usd_cost,
       // sync should run first so embed sees fresh pages.
-      depends_on: ctx.repoPath && health.stale_pages > 0 ? ['sync.repo'] : [],
+      depends_on: ctx.repoPath && extractionLag > 0 ? ['sync.repo'] : [],
       rationale: `${health.missing_embeddings} chunk${health.missing_embeddings === 1 ? '' : 's'} invisible to vector search`,
       status: 'remediable',
     });
@@ -267,7 +285,7 @@ export function computeRecommendations(
   // Triggered when sync.repo fires (because sync was set to noEmbed:true,
   // and noExtract:true after T5 lands → extract job is the materializer).
   // ---------------------------------------------------------------------
-  if (ctx.repoPath && health.stale_pages > 0) {
+  if (ctx.repoPath && extractionLag > 0) {
     const params = { mode: 'all', dir: ctx.repoPath };
     out.push({
       id: 'extract.all',
@@ -278,7 +296,7 @@ export function computeRecommendations(
       est_seconds: Math.min(600, 30 + health.page_count * 0.01),
       est_usd_cost: 0,
       depends_on: ['sync.repo'],
-      rationale: 'Materialize link + timeline edges from fresh pages',
+      rationale: `Materialize link + timeline edges for ${extractionLag} page${extractionLag === 1 ? '' : 's'} with stale extraction`,
       status: 'remediable',
     });
   }

src/core/brainstorm/judges.ts

@@ -61,10 +61,7 @@ export const MAX_OUTPUT_TOKENS_CEIL = 32_000;
  * (with a readable error) instead of the provider's opaque HTTP 400.
  */
 export const ANTHROPIC_OUTPUT_CAPS: Record<string, number> = {
-  'claude-fable-5': 64_000,
-  'claude-opus-4-8': 32_000,
   'claude-opus-4-7': 32_000,
-  'claude-sonnet-5': 64_000,
   'claude-sonnet-4-6': 64_000,
   'claude-haiku-4-5': 64_000,
   'claude-haiku-4-5-20251001': 64_000,

src/core/brainstorm/orchestrator.ts

@@ -32,7 +32,6 @@
  */
 
 import type { BrainEngine } from '../engine.ts';
-import { resolveModel } from '../model-config.ts';
 import { chat as defaultChat, embedQuery, type ChatResult, type ChatOpts } from '../ai/gateway.ts';
 import { hybridSearch, hybridSearchCached } from '../search/hybrid.ts';
 import { fetchFar, type CloseRef, type FarPage } from './domain-bank.ts';
@@ -539,14 +538,7 @@ async function _runBrainstormInner(
   const embedFn = opts.embedQueryFn ?? embedQuery;
 
   // ---- Phase 0: cost preview + TTY grace ----
-  // Tier-resolved (mirrors the cycle phases): honors models.brainstorm >
-  // models.default > models.tier.reasoning; the fallback keeps stock
-  // behavior identical (reasoning tier default IS claude-sonnet-4-6).
-  const modelStr = opts.modelOverride ?? await resolveModel(engine, {
-    configKey: 'models.brainstorm',
-    tier: 'reasoning',
-    fallback: 'anthropic:claude-sonnet-4-6',
-  });
+  const modelStr = opts.modelOverride ?? 'anthropic:claude-sonnet-4-6';
   const { aborted, estimate } = await previewCostAndWait({
     profile,
     model: modelStr,

src/core/cycle/calibration-profile.ts

@@ -26,8 +26,8 @@
  */
 
 import { BaseCyclePhase, type ScopedReadOpts, type BasePhaseOpts } from './base-phase.ts';
-import { chat as gatewayChat, getChatModel } from '../ai/gateway.ts';
-import { resolveModel } from '../model-config.ts';
+import { chat as gatewayChat } from '../ai/gateway.ts';
+import { TIER_DEFAULTS } from '../model-config.ts';
 import { gateVoice, type VoiceGateGenerator, type VoiceGateJudge } from '../calibration/voice-gate.ts';
 import { patternStatementTemplate, type PatternStatementSlots } from '../calibration/templates.ts';
 // v0.41 T10 — domain widening. The aggregator module resolves the active
@@ -229,16 +229,7 @@ class CalibrationProfilePhase extends BaseCyclePhase {
   ): Promise<{ summary: string; details: Record<string, unknown>; status?: PhaseStatus }> {
     const holder = opts.holder ?? 'garry';
     const promptVersion = opts.promptVersion ?? CALIBRATION_PROFILE_PROMPT_VERSION;
-    // Resolved once (see propose-takes.ts for the chain): models.calibration_profile
-    // > models.default > env > the gateway's chat model (itself resolved
-    // through models.chat + the reasoning tier). Provider-prefixed per #2451
-    // — a bare id would make gateway.chat() throw "missing a provider
-    // prefix". Drives the generator's chat call, the budget label, and the
-    // persisted model_id, so the three can never disagree.
-    const modelId = opts.model ?? await resolveModel(engine, {
-      configKey: 'models.calibration_profile',
-      fallback: getChatModel(),
-    });
+    const modelId = opts.model ?? TIER_DEFAULTS.reasoning;
     const gradeCompletion = opts.gradeCompletion ?? 1.0;
     const patternsGenerator = opts.patternsGenerator ?? defaultPatternsGenerator;
     const biasTagsGenerator = opts.biasTagsGenerator ?? defaultBiasTagsGenerator;
@@ -274,7 +265,6 @@ class CalibrationProfilePhase extends BaseCyclePhase {
         scorecard,
         holder,
         attempt,
-        modelHint: modelId,
         ...(feedback !== undefined ? { feedback } : {}),
       });
       return lines.join('\n');

src/core/cycle/grade-takes.ts

@@ -36,9 +36,7 @@
 
 import { createHash } from 'node:crypto';
 import { BaseCyclePhase, type ScopedReadOpts, type BasePhaseOpts } from './base-phase.ts';
-import { chat as gatewayChat, getChatModel } from '../ai/gateway.ts';
-import { resolveModel } from '../model-config.ts';
-import { splitProviderModelId } from '../model-id.ts';
+import { chat as gatewayChat } from '../ai/gateway.ts';
 import { GBrainError } from '../types.ts';
 import type { OperationContext } from '../operations.ts';
 import type { BrainEngine, Take, TakeResolution } from '../engine.ts';
@@ -397,24 +395,7 @@ class GradeTakesPhase extends BaseCyclePhase {
     const autoResolve = opts.autoResolve ?? false; // D17 default OFF
     const autoResolveThreshold = opts.autoResolveThreshold ?? 0.95; // D12 conservative
     const resolvedByLabel = opts.resolvedByLabel ?? 'gbrain:grade_takes';
-    // Resolve the judge model ONCE (see propose-takes.ts for the chain —
-    // same label-vs-actual split fixed here: the judge call rode the
-    // gateway's chat_model while the grade cache key, evidence signature,
-    // and budget label recorded a hardcoded 4.6).
-    // NOTE: changing the resolved judge model invalidates the grade cache
-    // (judge_model_id is part of its key) — a one-time, budget-capped
-    // re-grade wave that is CORRECT, since the actual judge did change.
-    const judgeModelFull = opts.model ?? await resolveModel(engine, {
-      configKey: 'models.grade_takes',
-      fallback: getChatModel(),
-    });
-    // Bare tail for cache keys / evidence signatures / stored ids — the
-    // grade cache has always been keyed on bare ids; the gateway default
-    // resolves provider-prefixed, and normalizing preserves cache continuity
-    // on stock installs (no spurious re-judge wave from a prefix change). A
-    // genuinely different configured judge still invalidates, which is
-    // correct. The FULL string drives the actual judge call.
-    const judgeModelId = splitProviderModelId(judgeModelFull).model || judgeModelFull;
+    const judgeModelId = opts.model ?? 'claude-sonnet-4-6';
 
     const useEnsemble = opts.useEnsemble ?? false;
     const ensembleThreshold = opts.ensembleThreshold ?? 0.85;
@@ -487,7 +468,7 @@ class GradeTakesPhase extends BaseCyclePhase {
       // Call the single-model judge. Errors on a single take log warning + continue.
       let verdict: JudgeVerdict;
       try {
-        verdict = await judge({ take, evidence, modelHint: judgeModelFull });
+        verdict = await judge({ take, evidence, modelHint: opts.model });
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         result.warnings.push(`judge failed on take ${take.id}: ${msg}`);

src/core/cycle/propose-takes.ts

@@ -5,16 +5,11 @@
  * a tuned LLM extractor, writes the extracted gradeable claims to the
  * `take_proposals` queue. User accepts/rejects via `gbrain takes propose`.
  *
- * Idempotency contract (D17 schema spec; per-claim rows since migration v125):
- *   Every scan of a (source_id, page_slug, content_hash, prompt_version)
- *   tuple leaves at least one row — one per extracted claim, or a single
- *   status='empty' sentinel when extraction yields nothing — so an unchanged
- *   page never re-spends LLM tokens. Pre-v125 only proposal rows were
- *   written: a zero-claim page never entered the cache and was re-extracted
- *   on EVERY cycle (observed live: ~60 such pages × every cycle ≈ 1,400
- *   wasted extractor calls / ~$15 per day — ~90% of total autopilot spend).
- *   Bumping PROPOSE_TAKES_PROMPT_VERSION cleanly invalidates the cache so a
- *   tuned prompt re-runs proposals on every page.
+ * Idempotency contract (D17 schema spec):
+ *   The unique index on (source_id, page_slug, content_hash, prompt_version)
+ *   means an unchanged page never re-spends LLM tokens. Bumping
+ *   PROPOSE_TAKES_PROMPT_VERSION cleanly invalidates the cache so a tuned
+ *   prompt re-runs proposals on every page.
  *
  * F2 fence dedup:
  *   The phase reads the page's existing `<!-- gbrain:takes:begin -->` fence
@@ -45,7 +40,6 @@
 import { randomUUID, createHash } from 'node:crypto';
 import { BaseCyclePhase, type ScopedReadOpts, type BasePhaseOpts } from './base-phase.ts';
 import { chat as gatewayChat, getChatModel } from '../ai/gateway.ts';
-import { resolveModel } from '../model-config.ts';
 import { writeReceipt } from '../extract/receipt-writer.ts';
 import { upsertExtractRollup } from '../extract/rollup-writer.ts';
 import { GBrainError } from '../types.ts';
@@ -313,18 +307,6 @@ class ProposeTakesPhase extends BaseCyclePhase {
     const promptVersion = opts.promptVersion ?? PROPOSE_TAKES_PROMPT_VERSION;
     const pageLimit = opts.pageLimit ?? 100;
     const skipPagesWithFence = opts.skipPagesWithFence ?? false;
-    // Resolve the extractor model ONCE: models.propose_takes >
-    // models.default > GBRAIN_MODEL env > the gateway's chat model (which
-    // reconfigureGatewayWithEngine already resolved through models.chat +
-    // the reasoning tier). One resolved provider-prefixed string drives the
-    // actual chat call, the budget estimate, AND the stored model_id — so
-    // the recorded model can never disagree with the model that ran (#2451
-    // convention: stored ids are provider-prefixed, nested prefixes like
-    // openrouter:anthropic/... stay intact).
-    const extractorModelId = opts.model ?? await resolveModel(engine, {
-      configKey: 'models.propose_takes',
-      fallback: getChatModel(),
-    });
     const proposalRunId = `propose-${new Date().toISOString().slice(0, 19).replace(/[-:T]/g, '')}-${randomUUID().slice(0, 8)}`;
 
     const result: ProposeTakesResult = {
@@ -348,6 +330,8 @@ class ProposeTakesPhase extends BaseCyclePhase {
       opts.reporter.start('propose_takes.pages' as never, pages.length);
     }
 
+    const modelId = opts.model ?? getChatModel();
+
     for (const page of pages) {
       result.pages_scanned += 1;
       this.tick(opts);
@@ -377,7 +361,7 @@ class ProposeTakesPhase extends BaseCyclePhase {
 
       // Budget pre-check before the LLM call. Estimate: ~1500 input tokens + 500 output.
       const budget = this.checkBudget({
-        modelId: extractorModelId,
+        modelId,
         estimatedInputTokens: 1500,
         maxOutputTokens: 500,
       });
@@ -396,7 +380,7 @@ class ProposeTakesPhase extends BaseCyclePhase {
           pagePath: page.slug,
           pageBody: body,
           existingTakes,
-          modelHint: extractorModelId,
+          modelHint: opts.model,
         });
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -404,42 +388,16 @@ class ProposeTakesPhase extends BaseCyclePhase {
         continue;
       }
 
-      // Zero-claim scans MUST still enter the idempotency cache. Pre-v125
-      // only proposal rows were written, so a page whose extraction yielded
-      // no gradeable claims never got a row for its (page, content_hash) —
-      // the cache check above missed on every subsequent cycle and the LLM
-      // call was re-spent on the same unchanged page, forever. The sentinel
-      // row (status='empty', empty claim_text) is invisible to the review
-      // queue (pending_idx is partial on status='pending'); it exists only
-      // so the cache check hits.
-      if (proposals.length === 0) {
-        await engine.executeRaw(
-          `INSERT INTO take_proposals
-             (source_id, page_slug, content_hash, prompt_version, proposal_run_id,
-              status, claim_text, kind, holder, weight, domain, dedup_against_fence_rows, model_id)
-           VALUES ($1, $2, $3, $4, $5, 'empty', '', 'none', 'brain', 0, NULL, NULL, $6)
-           ON CONFLICT (source_id, page_slug, content_hash, prompt_version, md5(claim_text)) DO NOTHING`,
-          [sourceId, page.slug, ch, promptVersion, proposalRunId, extractorModelId],
-        );
-        continue;
-      }
-
-      // Write proposals to take_proposals, one row per claim. The v125
-      // idempotency index includes md5(claim_text), so a same-page
-      // multi-claim run keeps EVERY claim — the pre-v125 four-column unique
-      // index made claims 2..N conflict with claim 1 and ON CONFLICT DO
-      // NOTHING silently dropped them (the review queue only ever saw the
-      // first claim of each page version). RETURNING id keeps
-      // proposals_inserted honest: it counts rows that actually landed,
-      // not insert attempts.
+      // Write proposals to take_proposals. Each row is a separate INSERT
+      // because the composite idempotency key is on the per-page tuple — a
+      // bulk UPSERT would collapse a same-page-multi-claim run into one row.
       for (const p of proposals) {
-        const landed = await engine.executeRaw<{ id: number }>(
+        await engine.executeRaw(
           `INSERT INTO take_proposals
              (source_id, page_slug, content_hash, prompt_version, proposal_run_id,
               claim_text, kind, holder, weight, domain, dedup_against_fence_rows, model_id)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
-           ON CONFLICT (source_id, page_slug, content_hash, prompt_version, md5(claim_text)) DO NOTHING
-           RETURNING id`,
+           ON CONFLICT (source_id, page_slug, content_hash, prompt_version) DO NOTHING`,
           [
             sourceId,
             page.slug,
@@ -452,10 +410,10 @@ class ProposeTakesPhase extends BaseCyclePhase {
             p.weight,
             p.domain ?? null,
             JSON.stringify(existingTakes),
-            extractorModelId,
+            modelId,
           ],
         );
-        if (landed.length > 0) result.proposals_inserted += 1;
+        result.proposals_inserted += 1;
       }
     }
 

src/core/cycle/synthesize.ts

@@ -58,11 +58,8 @@ const SUMMARY_SLUG_RE = /^[a-z0-9][a-z0-9\-]*(\/[a-z0-9][a-z0-9\-]*)*$/;
  * resolver returns for known Anthropic aliases.
  */
 const MODEL_CONTEXT_TOKENS: Record<string, number> = {
-  'claude-fable-5': 1_000_000,
-  'claude-opus-4-8': 1_000_000,
   'claude-opus-4-7': 1_000_000,
   'claude-opus-4-6': 1_000_000,
-  'claude-sonnet-5': 1_000_000,
   'claude-sonnet-4-6': 200_000,
   'claude-sonnet-4-5': 200_000,
   'claude-haiku-4-5-20251001': 200_000,

src/core/migrate.ts

@@ -5671,41 +5671,6 @@ export const MIGRATIONS: Migration[] = [
 `);
     },
   },
-  {
-    version: 125,
-    name: 'take_proposals_empty_scan_sentinels_and_per_claim_rows',
-    // v0.42.x — kill the propose_takes rescan loop + stop dropping claims.
-    //
-    // Two defects, one schema touch:
-    //   1. Zero-claim scans never entered the idempotency cache (only
-    //      proposal rows were written), so pages whose extraction yielded
-    //      nothing were re-extracted on EVERY cycle. Observed live: ~60
-    //      such pages per run ≈ 1,400 wasted extractor calls / ~$15 per
-    //      day — ~90% of total autopilot LLM spend. Fix: the phase now
-    //      writes a status='empty' sentinel row per zero-claim scan; the
-    //      status CHECK gains the 'empty' value. Sentinels are excluded
-    //      from the partial pending index, so the review queue never sees
-    //      them.
-    //   2. The 4-column unique index collapsed a same-page multi-claim run
-    //      to its FIRST claim: rows 2..N conflicted and ON CONFLICT DO
-    //      NOTHING silently dropped them (verified live: exactly one row
-    //      per (page, hash) across 3 days of runs). Fix: the idempotency
-    //      index gains md5(claim_text) — per-claim rows, while the
-    //      4-column prefix still serves the per-scan cache lookup.
-    //
-    // Existing data is index-safe by construction: the old index guaranteed
-    // at most one row per 4-tuple, so the widened index has no duplicates
-    // to trip on. The DROP+ADD CONSTRAINT pair is idempotent as a unit.
-    idempotent: true,
-    sql: `
-      ALTER TABLE take_proposals DROP CONSTRAINT IF EXISTS take_proposals_status_check;
-      ALTER TABLE take_proposals ADD CONSTRAINT take_proposals_status_check
-        CHECK (status IN ('pending','accepted','rejected','superseded','empty'));
-      DROP INDEX IF EXISTS take_proposals_idempotency_idx;
-      CREATE UNIQUE INDEX IF NOT EXISTS take_proposals_idempotency_idx
-        ON take_proposals (source_id, page_slug, content_hash, prompt_version, md5(claim_text));
-    `,
-  },
 ];
 
 export const LATEST_VERSION = MIGRATIONS.length > 0

src/core/pglite-schema.ts

@@ -762,7 +762,7 @@ CREATE TABLE IF NOT EXISTS take_proposals (
   proposed_at                 TIMESTAMPTZ  NOT NULL DEFAULT now(),
   proposal_run_id             TEXT         NOT NULL,
   status                      TEXT         NOT NULL DEFAULT 'pending'
-                                           CHECK (status IN ('pending','accepted','rejected','superseded','empty')),
+                                           CHECK (status IN ('pending','accepted','rejected','superseded')),
   claim_text                  TEXT         NOT NULL,
   kind                        TEXT         NOT NULL,
   holder                      TEXT         NOT NULL,
@@ -777,7 +777,7 @@ CREATE TABLE IF NOT EXISTS take_proposals (
   predicted_brier_bucket_n    INTEGER
 );
 CREATE UNIQUE INDEX IF NOT EXISTS take_proposals_idempotency_idx
-  ON take_proposals (source_id, page_slug, content_hash, prompt_version, md5(claim_text));
+  ON take_proposals (source_id, page_slug, content_hash, prompt_version);
 CREATE INDEX IF NOT EXISTS take_proposals_pending_idx
   ON take_proposals (source_id, status, proposed_at DESC)
   WHERE status = 'pending';

src/core/remediation/context.ts

@@ -8,6 +8,7 @@
 
 import type { BrainEngine } from '../engine.ts';
 import type { RecommendationContext } from '../brain-score-recommendations.ts';
+import { LINK_EXTRACTOR_VERSION_TS } from '../link-extraction.ts';
 
 // Re-export so consumers can `import { RecommendationContext } from '../remediation'`
 // — the canonical RecommendationContext type still lives in
@@ -68,5 +69,29 @@ export async function loadRecommendationContext(
     embeddingDimensions,
     embeddingProviderConfigured: embeddingConfigured,
     hasChatApiKey: !!(process.env.ANTHROPIC_API_KEY || fileCfg?.anthropic_api_key),
+    extractionLagPages: await countExtractionLag(engine),
   };
 }
+
+/**
+ * Real extraction-lag count — the SAME staleness `gbrain extract --stale`
+ * processes (engine.countStalePagesForExtraction with
+ * versionTs=LINK_EXTRACTOR_VERSION_TS, matching doctor's links_extraction_lag
+ * check — without versionTs, pages stamped before an extractor version bump
+ * would lag for doctor/extract but never trip this gate). Drives the
+ * sync→extract recommendation pipeline; replaces the legacy
+ * `health.stale_pages` proxy that no longer reflected real extraction work
+ * after the v10 trigger drop.
+ *
+ * Shared by loadRecommendationContext AND the D7 per-step recheck in
+ * runRemediation — the recheck MUST refresh this gate alongside getHealth,
+ * or a completed extract step keeps re-firing off the frozen initial count.
+ */
+export async function countExtractionLag(engine: BrainEngine): Promise<number> {
+  try {
+    return await engine.countStalePagesForExtraction({ versionTs: LINK_EXTRACTOR_VERSION_TS });
+  } catch {
+    /* counter unavailable (very old brain / mid-migration) — treat as 0 */
+    return 0;
+  }
+}

src/core/remediation/run.ts

@@ -16,7 +16,7 @@ import {
   computeRecommendations,
 } from '../brain-score-recommendations.ts';
 import type { RemediationStep } from '../remediation-step.ts';
-import { loadRecommendationContext } from './context.ts';
+import { countExtractionLag, loadRecommendationContext } from './context.ts';
 import { computeRemediationPlan } from './plan.ts';
 import type {
   RemediationHooks,
@@ -65,7 +65,7 @@ export async function runRemediation(
     clearRemediationCheckpoint,
   } = await import('../remediation-checkpoint.ts');
 
-  const ctx = await loadRecommendationContext(engine);
+  let ctx = await loadRecommendationContext(engine);
 
   // Pre-flight ceiling check via the shared plan computation.
   const initialPlan = await computeRemediationPlan(engine, { targetScore });
@@ -305,6 +305,11 @@ export async function runRemediation(
       // steps with bumped retry suffix (D1).
       if (recs.length === 0 || stepCount >= maxJobs) break;
       const freshHealth = await engine.getHealth();
+      // Refresh the extraction-lag gate alongside health: ctx was loaded once
+      // before the loop, and a completed sync/extract step is exactly what
+      // drives the count down. Reusing the frozen initial count would re-fire
+      // sync.repo/extract.all every recheck until maxJobs.
+      ctx = { ...ctx, extractionLagPages: await countExtractionLag(engine) };
       recs = computeRecommendations(freshHealth, ctx).filter((r) => r.status === 'remediable');
     }
   };

src/core/schema-embedded.ts

@@ -1274,14 +1274,8 @@ CREATE INDEX IF NOT EXISTS calibration_profiles_published_idx
   WHERE published = true;
 
 -- take_proposals: propose_takes phase queue. Idempotency cache via the
--- composite unique index (source_id, page_slug, content_hash, prompt_version,
--- md5(claim_text)) — the 4-column prefix is the per-scan cache key (mirrors
--- v0.23 dream_verdicts); md5(claim_text) makes rows per-claim so multi-claim
--- pages keep every claim (v125). status='empty' rows are zero-claim scan
--- sentinels: they hold the cache slot for a page version whose extraction
--- yielded nothing — the phase never re-spends the LLM call on that page
--- version. Excluded from the partial pending index. proposal_run_id supports
--- --rollback by run.
+-- composite unique index (source_id, page_slug, content_hash, prompt_version)
+-- mirrors v0.23 dream_verdicts. proposal_run_id supports --rollback by run.
 CREATE TABLE IF NOT EXISTS take_proposals (
   id                          BIGSERIAL PRIMARY KEY,
   source_id                   TEXT         NOT NULL REFERENCES sources(id) ON DELETE CASCADE,
@@ -1292,7 +1286,7 @@ CREATE TABLE IF NOT EXISTS take_proposals (
   proposed_at                 TIMESTAMPTZ  NOT NULL DEFAULT now(),
   proposal_run_id             TEXT         NOT NULL,
   status                      TEXT         NOT NULL DEFAULT 'pending'
-                                           CHECK (status IN ('pending','accepted','rejected','superseded','empty')),
+                                           CHECK (status IN ('pending','accepted','rejected','superseded')),
   claim_text                  TEXT         NOT NULL,
   kind                        TEXT         NOT NULL,
   holder                      TEXT         NOT NULL,
@@ -1307,7 +1301,7 @@ CREATE TABLE IF NOT EXISTS take_proposals (
   predicted_brier_bucket_n    INTEGER
 );
 CREATE UNIQUE INDEX IF NOT EXISTS take_proposals_idempotency_idx
-  ON take_proposals (source_id, page_slug, content_hash, prompt_version, md5(claim_text));
+  ON take_proposals (source_id, page_slug, content_hash, prompt_version);
 CREATE INDEX IF NOT EXISTS take_proposals_pending_idx
   ON take_proposals (source_id, status, proposed_at DESC)
   WHERE status = 'pending';

src/core/types.ts

@@ -1423,6 +1423,15 @@ export interface BrainStats {
 export interface BrainHealth {
   page_count: number;
   embed_coverage: number;
+  /**
+   * LEGACY proxy: count of pages whose `updated_at` predates their newest
+   * timeline entry. This bumped meaningfully only while a trigger updated
+   * `pages.updated_at` on timeline insert; that trigger was dropped in
+   * migration v10, so the metric no longer reflects real "needs work" state.
+   * NO LONGER gates remediations — the sync→extract pipeline now gates on
+   * `RecommendationContext.extractionLagPages` (the real extraction-lag from
+   * `countStalePagesForExtraction`). Retained for the CLI health line + back-compat.
+   */
   stale_pages: number;
   /**
    * Islanded pages — zero inbound AND zero outbound links. A hub page

src/schema.sql

@@ -1270,14 +1270,8 @@ CREATE INDEX IF NOT EXISTS calibration_profiles_published_idx
   WHERE published = true;
 
 -- take_proposals: propose_takes phase queue. Idempotency cache via the
--- composite unique index (source_id, page_slug, content_hash, prompt_version,
--- md5(claim_text)) — the 4-column prefix is the per-scan cache key (mirrors
--- v0.23 dream_verdicts); md5(claim_text) makes rows per-claim so multi-claim
--- pages keep every claim (v125). status='empty' rows are zero-claim scan
--- sentinels: they hold the cache slot for a page version whose extraction
--- yielded nothing — the phase never re-spends the LLM call on that page
--- version. Excluded from the partial pending index. proposal_run_id supports
--- --rollback by run.
+-- composite unique index (source_id, page_slug, content_hash, prompt_version)
+-- mirrors v0.23 dream_verdicts. proposal_run_id supports --rollback by run.
 CREATE TABLE IF NOT EXISTS take_proposals (
   id                          BIGSERIAL PRIMARY KEY,
   source_id                   TEXT         NOT NULL REFERENCES sources(id) ON DELETE CASCADE,
@@ -1288,7 +1282,7 @@ CREATE TABLE IF NOT EXISTS take_proposals (
   proposed_at                 TIMESTAMPTZ  NOT NULL DEFAULT now(),
   proposal_run_id             TEXT         NOT NULL,
   status                      TEXT         NOT NULL DEFAULT 'pending'
-                                           CHECK (status IN ('pending','accepted','rejected','superseded','empty')),
+                                           CHECK (status IN ('pending','accepted','rejected','superseded')),
   claim_text                  TEXT         NOT NULL,
   kind                        TEXT         NOT NULL,
   holder                      TEXT         NOT NULL,
@@ -1303,7 +1297,7 @@ CREATE TABLE IF NOT EXISTS take_proposals (
   predicted_brier_bucket_n    INTEGER
 );
 CREATE UNIQUE INDEX IF NOT EXISTS take_proposals_idempotency_idx
-  ON take_proposals (source_id, page_slug, content_hash, prompt_version, md5(claim_text));
+  ON take_proposals (source_id, page_slug, content_hash, prompt_version);
 CREATE INDEX IF NOT EXISTS take_proposals_pending_idx
   ON take_proposals (source_id, status, proposed_at DESC)
   WHERE status = 'pending';

test/brain-score-recommendations.test.ts

@@ -119,13 +119,12 @@ describe('computeRecommendations', () => {
     expect(recs.find((r) => r.id === 'embed.stale')).toBeUndefined();
   });
 
-  test('stale pages + dead links produce sync + backlinks + extract', () => {
+  test('extraction lag + dead links produce sync + backlinks + extract', () => {
     const health = makeHealth({
-      stale_pages: 25,
       dead_links: 8,
       brain_score: 70,
     });
-    const recs = computeRecommendations(health, { repoPath: '/brain', embeddingProviderConfigured: true });
+    const recs = computeRecommendations(health, { repoPath: '/brain', embeddingProviderConfigured: true, extractionLagPages: 25 });
     const ids = recs.map((r) => r.id);
     expect(ids).toContain('sync.repo');
     expect(ids).toContain('backlinks.fix');
@@ -133,18 +132,17 @@ describe('computeRecommendations', () => {
   });
 
   test('extract.all depends on sync.repo (D14: stable ids)', () => {
-    const health = makeHealth({ stale_pages: 10 });
-    const recs = computeRecommendations(health, { repoPath: '/brain', embeddingProviderConfigured: true });
+    const health = makeHealth();
+    const recs = computeRecommendations(health, { repoPath: '/brain', embeddingProviderConfigured: true, extractionLagPages: 10 });
     const extract = recs.find((r) => r.id === 'extract.all');
     expect(extract?.depends_on).toContain('sync.repo');
   });
 
-  test('embed.stale depends on sync.repo when sync also needed', () => {
+  test('embed.stale depends on sync.repo when extraction also needed', () => {
     const health = makeHealth({
-      stale_pages: 10,
       missing_embeddings: 100,
     });
-    const recs = computeRecommendations(health, { repoPath: '/brain', embeddingProviderConfigured: true });
+    const recs = computeRecommendations(health, { repoPath: '/brain', embeddingProviderConfigured: true, extractionLagPages: 10 });
     const embed = recs.find((r) => r.id === 'embed.stale');
     expect(embed?.depends_on).toContain('sync.repo');
   });
@@ -159,9 +157,9 @@ describe('computeRecommendations', () => {
   test('severity ordering: critical before high before medium', () => {
     const health = makeHealth({
       missing_embeddings: 100,  // critical
-      stale_pages: 80,          // high
     });
-    const recs = computeRecommendations(health, { repoPath: '/brain', embeddingProviderConfigured: true });
+    // extractionLagPages > 50 → sync.repo fires at 'high' severity.
+    const recs = computeRecommendations(health, { repoPath: '/brain', embeddingProviderConfigured: true, extractionLagPages: 80 });
     const critIdx = recs.findIndex((r) => r.severity === 'critical');
     const highIdx = recs.findIndex((r) => r.severity === 'high');
     expect(critIdx).toBeLessThan(highIdx);
@@ -170,11 +168,10 @@ describe('computeRecommendations', () => {
   // D6 #5 — THE critical regression test for the agent contract.
   test('D6 #5: determinism — same input twice produces identical output', () => {
     const health = makeHealth({
-      stale_pages: 10,
       missing_embeddings: 50,
       dead_links: 3,
     });
-    const ctx = { repoPath: '/brain', embeddingProviderConfigured: true, sourceId: 'default' };
+    const ctx = { repoPath: '/brain', embeddingProviderConfigured: true, sourceId: 'default', extractionLagPages: 10 };
     const run1 = computeRecommendations(health, ctx);
     const run2 = computeRecommendations(health, ctx);
     expect(JSON.stringify(run1)).toBe(JSON.stringify(run2));

test/calibration-profile.test.ts

@@ -38,7 +38,6 @@ function buildMockEngine(opts: { scorecard: TakesScorecard }): {
 } {
   const captured: CapturedSql[] = [];
   const engine = {
-    async getConfig() { return null; },
     kind: 'pglite',
     async getScorecard() {
       return opts.scorecard;

test/grade-takes-ensemble.test.ts

@@ -47,7 +47,6 @@ function buildMockEngine(opts: { takes: Take[] }): {
   const captured: CapturedSql[] = [];
   const resolves: CapturedResolve[] = [];
   const engine = {
-    async getConfig() { return null; },
     kind: 'pglite',
     async listTakes() {
       return opts.takes;

test/grade-takes.test.ts

@@ -46,14 +46,12 @@ interface CapturedResolve {
 function buildMockEngine(opts: {
   takes: Take[];
   cachedGrades?: Set<string>; // composite-key strings already in take_grade_cache
-  config?: Record<string, string>; // engine.getConfig plane (models.grade_takes etc.)
 }): { engine: BrainEngine; captured: CapturedSql[]; resolves: CapturedResolve[] } {
   const captured: CapturedSql[] = [];
   const resolves: CapturedResolve[] = [];
   const cached = opts.cachedGrades ?? new Set<string>();
 
   const engine = {
-    async getConfig(key: string) { return opts.config?.[key] ?? null; },
     kind: 'pglite',
     async listTakes() {
       return opts.takes;
@@ -226,28 +224,6 @@ describe('runPhaseGradeTakes — phase integration', () => {
     expect(resolves).toHaveLength(0); // no canonical mutation
   });
 
-  test('models.grade_takes config drives the judge call; cache key stays bare-tailed', async () => {
-    // Pre-fix the judge call rode the gateway's chat_model while the cache
-    // key / budget label recorded a hardcoded 'claude-sonnet-4-6'. The phase
-    // now resolves models.grade_takes; the judge gets the FULL string and
-    // the cache row keys on the bare tail (continuity with historical rows).
-    const takes = [buildTake({ id: 1, sinceDate: '2023-01-01' })];
-    const { engine, captured } = buildMockEngine({
-      takes,
-      config: { 'models.grade_takes': 'anthropic:claude-sonnet-5' },
-    });
-    const hints: Array<string | undefined> = [];
-    const judge: JudgeFn = async ({ modelHint }) => {
-      hints.push(modelHint);
-      return { verdict: 'correct', confidence: 0.9, reasoning: 'held' };
-    };
-    const result = await runPhaseGradeTakes(buildCtx(engine), { judge });
-    expect(result.status).toBe('ok');
-    expect(hints).toEqual(['anthropic:claude-sonnet-5']); // actual call gets the FULL string
-    const inserts = captured.filter(c => c.sql.includes('INSERT INTO take_grade_cache'));
-    expect(inserts[0]!.params[2]).toBe('claude-sonnet-5'); // judge_model_id is the bare tail
-  });
-
   test('D17: auto-resolve OFF by default — even high-confidence verdict does NOT mutate takes', async () => {
     const takes = [buildTake({ id: 1, sinceDate: '2023-01-01' })];
     const { engine, resolves } = buildMockEngine({ takes });

test/propose-takes-rescan.test.ts

@@ -1,160 +0,0 @@
-/**
- * propose_takes rescan-loop + dropped-claims regression tests (migration v125).
- *
- * Two live-observed defects, both fixed by the v125 schema + phase change:
- *
- *   1. RESCAN LOOP — a page whose extraction yielded zero claims never
- *      entered the idempotency cache (only proposal rows were written), so
- *      every cycle re-spent the extractor call on the same unchanged page.
- *      Live impact: ~60 such pages × every cycle ≈ 1,400 wasted LLM calls
- *      (~$15) per day — ~90% of total autopilot spend. Fix: status='empty'
- *      sentinel row per zero-claim scan.
- *
- *   2. DROPPED CLAIMS — the 4-column unique index collapsed a same-page
- *      multi-claim run to its first claim (rows 2..N conflicted, ON CONFLICT
- *      DO NOTHING dropped them silently; verified live: exactly 1 row per
- *      (page, hash) over 3 days). Fix: idempotency index gains
- *      md5(claim_text).
- *
- * Hermetic: PGLite engine + injected extractor; no gateway, no LLM.
- */
-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
-import { PGLiteEngine } from '../src/core/pglite-engine.ts';
-import { runPhaseProposeTakes, type ProposeTakesExtractor, type ProposedTake } from '../src/core/cycle/propose-takes.ts';
-import type { OperationContext } from '../src/core/operations.ts';
-
-let engine: PGLiteEngine;
-
-function ctx(): OperationContext {
-  return {
-    engine,
-    remote: false,
-    config: {} as OperationContext['config'],
-    logger: { info() {}, warn() {}, error() {}, debug() {} } as unknown as OperationContext['logger'],
-  } as unknown as OperationContext;
-}
-
-/** Extractor stub that counts invocations per page slug. */
-function countingExtractor(
-  claimsBySlug: Record<string, ProposedTake[]>,
-): { extractor: ProposeTakesExtractor; calls: string[] } {
-  const calls: string[] = [];
-  const extractor: ProposeTakesExtractor = async ({ pagePath }) => {
-    calls.push(pagePath);
-    return claimsBySlug[pagePath] ?? [];
-  };
-  return { extractor, calls };
-}
-
-beforeAll(async () => {
-  engine = new PGLiteEngine();
-  await engine.connect({});
-  await engine.initSchema();
-  await engine.putPage('notes/zero-claims', {
-    type: 'note',
-    title: 'pure narrative',
-    compiled_truth: 'A quiet walk in the park. Nothing opinionated happened at all today.',
-  });
-  await engine.putPage('notes/three-claims', {
-    type: 'note',
-    title: 'opinionated',
-    compiled_truth: 'I bet acme-example wins the market. widget-co will struggle. fund-a is overexposed.',
-  });
-});
-
-afterAll(async () => {
-  await engine.disconnect();
-});
-
-describe('rescan loop — zero-claim scans enter the cache', () => {
-  test('second run cache-hits: extractor is NOT called again on unchanged pages', async () => {
-    const claims = {
-      'notes/three-claims': [
-        { claim_text: 'acme-example wins the market', kind: 'bet' as const, holder: 'brain', weight: 0.7 },
-        { claim_text: 'widget-co will struggle', kind: 'take' as const, holder: 'brain', weight: 0.6 },
-        { claim_text: 'fund-a is overexposed', kind: 'take' as const, holder: 'brain', weight: 0.55 },
-      ],
-    };
-
-    const first = countingExtractor(claims);
-    const r1 = await runPhaseProposeTakes(ctx(), { extractor: first.extractor });
-    expect(r1.status).toBe('ok');
-    // Both pages extracted on the first pass.
-    expect(first.calls).toContain('notes/zero-claims');
-    expect(first.calls).toContain('notes/three-claims');
-
-    const second = countingExtractor(claims);
-    const r2 = await runPhaseProposeTakes(ctx(), { extractor: second.extractor });
-    expect(r2.status).toBe('ok');
-    // THE regression: pre-fix the zero-claim page missed the cache every
-    // run and was re-extracted here. (Run 1's receipt page legitimately
-    // appears once — it's a new page — and its zero-claim scan now caches
-    // too; pre-fix, receipts re-scanned forever as well.)
-    expect(second.calls).not.toContain('notes/zero-claims');
-    expect(second.calls).not.toContain('notes/three-claims');
-
-    // Run 2 inserted nothing, so no new receipt page exists: run 3 must be
-    // fully quiescent — zero extractor calls, zero cache misses.
-    const third = countingExtractor(claims);
-    const r3 = await runPhaseProposeTakes(ctx(), { extractor: third.extractor });
-    expect(r3.status).toBe('ok');
-    expect(third.calls).toEqual([]);
-    expect((r3.details as Record<string, unknown>).cache_misses).toBe(0);
-  });
-
-  test('zero-claim scan wrote an "empty" sentinel invisible to the pending queue', async () => {
-    const sentinel = await engine.executeRaw<{ status: string; claim_text: string }>(
-      `SELECT status, claim_text FROM take_proposals WHERE page_slug = 'notes/zero-claims'`,
-      [],
-    );
-    expect(sentinel.length).toBe(1);
-    expect(sentinel[0].status).toBe('empty');
-    expect(sentinel[0].claim_text).toBe('');
-    const pending = await engine.executeRaw<{ n: number }>(
-      `SELECT COUNT(*)::int AS n FROM take_proposals WHERE page_slug = 'notes/zero-claims' AND status = 'pending'`,
-      [],
-    );
-    expect(Number(pending[0].n)).toBe(0);
-  });
-});
-
-describe('dropped claims — per-claim rows survive the idempotency index', () => {
-  test('a 3-claim page stores 3 rows and reports an honest inserted count', async () => {
-    const rows = await engine.executeRaw<{ claim_text: string }>(
-      `SELECT claim_text FROM take_proposals WHERE page_slug = 'notes/three-claims' AND status = 'pending' ORDER BY id`,
-      [],
-    );
-    // Pre-fix the 4-column unique index kept only the FIRST claim.
-    expect(rows.length).toBe(3);
-    expect(rows.map(r => r.claim_text)).toEqual([
-      'acme-example wins the market',
-      'widget-co will struggle',
-      'fund-a is overexposed',
-    ]);
-  });
-
-  test('content change re-extracts and stores the new version separately', async () => {
-    await engine.putPage('notes/zero-claims', {
-      type: 'note',
-      title: 'pure narrative',
-      compiled_truth: 'Updated: I now believe acme-example is undervalued and will re-rate within a year.',
-    });
-    const claims = {
-      'notes/zero-claims': [
-        { claim_text: 'acme-example is undervalued', kind: 'take' as const, holder: 'brain', weight: 0.6 },
-      ],
-    };
-    const run = countingExtractor(claims);
-    const r = await runPhaseProposeTakes(ctx(), { extractor: run.extractor });
-    expect(r.status).toBe('ok');
-    // Changed page re-extracts; the unchanged 3-claim page stays cached.
-    expect(run.calls).toEqual(['notes/zero-claims']);
-    expect((r.details as Record<string, unknown>).proposals_inserted).toBe(1);
-    const all = await engine.executeRaw<{ status: string }>(
-      `SELECT status FROM take_proposals WHERE page_slug = 'notes/zero-claims' ORDER BY id`,
-      [],
-    );
-    // Old hash's sentinel + new hash's pending claim coexist.
-    expect(all.map(r2 => r2.status).sort()).toEqual(['empty', 'pending']);
-  });
-});

test/propose-takes.test.ts

@@ -41,16 +41,12 @@ interface CapturedSql {
 function buildMockEngine(opts: {
   pages: Page[];
   existingProposals?: Set<string>; // composite-key strings already in take_proposals
-  config?: Record<string, string>; // engine.getConfig plane (models.tier.* etc.)
 }): { engine: BrainEngine; captured: CapturedSql[] } {
   const captured: CapturedSql[] = [];
   const existing = opts.existingProposals ?? new Set<string>();
 
   const engine = {
     kind: 'pglite',
-    async getConfig(key: string) {
-      return opts.config?.[key] ?? null;
-    },
     async listPages() {
       return opts.pages;
     },
@@ -63,12 +59,7 @@ function buildMockEngine(opts: {
         if (existing.has(key)) return [{ id: 1 } as unknown as T];
         return [];
       }
-      // INSERT ... RETURNING id — emulate a successful insert so the
-      // honest proposals_inserted counter (counts RETURNING rows, not
-      // attempts) sees the row land. Conflicted inserts would return [].
-      if (sql.includes('INSERT INTO take_proposals') && sql.includes('RETURNING id')) {
-        return [{ id: 1 } as unknown as T];
-      }
+      // INSERT — return nothing
       return [];
     },
   } as unknown as BrainEngine;
@@ -276,29 +267,6 @@ describe('runPhaseProposeTakes — phase integration', () => {
     expect(inserts[0]!.params[9]).toBe('market'); // domain
   });
 
-  test('extractor model resolves through models.propose_takes config', async () => {
-    // Pre-fix the phase's only model knob was the gateway chat model — there
-    // was no per-phase config key. The phase now resolves once via
-    // resolveModel(models.propose_takes > models.default > env > gateway
-    // chat model); the extractor hint and the stored model_id must both
-    // reflect the configured override (full provider-prefixed string, #2451).
-    const pages = [buildPage({ slug: 'wiki/concepts/tier-routing', body: 'Tier-routed models will win.' })];
-    const { engine, captured } = buildMockEngine({
-      pages,
-      config: { 'models.propose_takes': 'anthropic:claude-sonnet-5' },
-    });
-    const seen: Array<string | undefined> = [];
-    const extractor: ProposeTakesExtractor = async ({ modelHint }) => {
-      seen.push(modelHint);
-      return [{ claim_text: 'tier-routed models win', kind: 'bet', holder: 'brain', weight: 0.7 }];
-    };
-    const result = await runPhaseProposeTakes(buildCtx(engine), { extractor });
-    expect(result.status).toBe('ok');
-    expect(seen).toEqual(['anthropic:claude-sonnet-5']); // chat call gets the FULL string
-    const inserts = captured.filter(c => c.sql.includes('INSERT INTO take_proposals'));
-    expect(inserts[0]!.params[11]).toBe('anthropic:claude-sonnet-5'); // stored model_id matches the call
-  });
-
   test('cache hit: page already in take_proposals is skipped', async () => {
     const body = 'A page that was already processed.';
     const pages = [buildPage({ slug: 'wiki/old-page', body })];

test/remediation-context-extraction-lag.test.ts

@@ -0,0 +1,62 @@
+// test/remediation-context-extraction-lag.test.ts
+//
+// Pins the v-next fix: the sync→extract remediation pipeline gates on REAL
+// extraction lag, not the legacy `health.stale_pages` proxy (which counted
+// "updated_at predates newest timeline entry" — meaningless after the v10
+// trigger drop). loadRecommendationContext now populates `extractionLagPages`
+// from `engine.countStalePagesForExtraction` — the SAME counter the
+// `gbrain extract --stale` walk and doctor's `links_extraction_lag` use — so a
+// recommendation can only fire when running extract will actually reduce it.
+
+import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
+import { PGLiteEngine } from '../src/core/pglite-engine.ts';
+import { loadRecommendationContext } from '../src/core/remediation/context.ts';
+
+let engine: PGLiteEngine;
+
+beforeAll(async () => {
+  engine = new PGLiteEngine();
+  await engine.connect({});
+  await engine.initSchema();
+});
+
+afterAll(async () => {
+  await engine.disconnect();
+});
+
+describe('loadRecommendationContext — extractionLagPages wiring', () => {
+  it('is 0 on an empty brain (nothing to extract)', async () => {
+    const ctx = await loadRecommendationContext(engine);
+    expect(ctx.extractionLagPages).toBe(0);
+  });
+
+  it('reflects the real extraction-lag count once a page needs extraction', async () => {
+    // A freshly-imported page has links_extracted_at = NULL, which the canonical
+    // countStalePagesForExtraction predicate counts as stale-for-extraction.
+    await engine.putPage('p0', {
+      title: 'p0',
+      type: 'note' as never,
+      compiled_truth: 'body that is long enough to pass any minimum-length guards in the codebase',
+      timeline: '',
+      frontmatter: {},
+      source_path: 'p0.md',
+    });
+    const ctx = await loadRecommendationContext(engine);
+    expect(ctx.extractionLagPages).toBeGreaterThan(0);
+  });
+
+  it('counts pages stamped before LINK_EXTRACTOR_VERSION_TS (version-bump arm)', async () => {
+    // Backdate p0 so BOTH the NULL arm and the updated_at arm are quiet:
+    // updated_at < links_extracted_at, but links_extracted_at predates the
+    // extractor version stamp. doctor's links_extraction_lag and
+    // `extract --stale` both count this page; the remediation gate must too.
+    await engine.executeRaw(
+      `UPDATE pages SET updated_at = '2020-01-01T00:00:00Z'::timestamptz,
+                        links_extracted_at = '2020-01-02T00:00:00Z'::timestamptz
+        WHERE slug = 'p0'`,
+      [],
+    );
+    const ctx = await loadRecommendationContext(engine);
+    expect(ctx.extractionLagPages).toBeGreaterThan(0);
+  });
+});

test/remediation-run-d7-refresh.serial.test.ts

@@ -0,0 +1,81 @@
+// test/remediation-run-d7-refresh.serial.test.ts
+//
+// Pins the D7-recheck half of the extraction-lag gate fix: runRemediation
+// loads RecommendationContext ONCE before the step loop, and the per-step
+// recheck (D7) must REFRESH ctx.extractionLagPages alongside getHealth.
+// Without the refresh, a completed sync/extract step keeps re-firing off
+// the frozen initial count — the plan never converges and the loop burns
+// steps until maxJobs.
+//
+// SERIAL (R2): uses top-level mock.module for the minion queue +
+// wait-for-completion so no real worker is needed — mocks leak across
+// files in a shard process, so this file must run in its own process.
+
+import { describe, expect, mock, test } from 'bun:test';
+
+// The fake brain: sync.repo clears the extraction lag when it "runs"
+// (today's sync materializes link/timeline edges; extract.all is the
+// explicit re-materializer). The frozen-ctx bug makes runRemediation
+// ignore that and resubmit sync.repo on every D7 recheck.
+let extractionLag = 25;
+const submittedJobs: string[] = [];
+
+mock.module('../src/core/minions/queue.ts', () => ({
+  MinionQueue: class {
+    constructor(_engine: unknown) {}
+    async add(job: string): Promise<{ id: number }> {
+      submittedJobs.push(job);
+      if (job === 'sync' || job === 'extract') extractionLag = 0;
+      return { id: submittedJobs.length };
+    }
+  },
+}));
+
+mock.module('../src/core/minions/wait-for-completion.ts', () => ({
+  waitForCompletion: async () => ({ status: 'completed' }),
+}));
+
+const health = () => ({
+  page_count: 100,
+  embed_coverage: 1.0,
+  stale_pages: 0, // legacy proxy stays 0 — the real counter drives the gate
+  orphan_pages: 0,
+  missing_embeddings: 0,
+  brain_score: 70,
+  dead_links: 0,
+  link_coverage: 1.0,
+  timeline_coverage: 1.0,
+  most_connected: [],
+  embed_coverage_score: 35,
+  link_density_score: 25,
+  timeline_coverage_score: 15,
+  no_orphans_score: 15,
+  no_dead_links_score: 10,
+});
+
+const fakeEngine = {
+  kind: 'pglite' as const,
+  getHealth: async () => health(),
+  getConfig: async (key: string) =>
+    key === 'sync.repo_path' ? '/tmp/brain-example' : null,
+  countStalePagesForExtraction: async () => extractionLag,
+};
+
+describe('runRemediation D7 recheck — extraction-lag gate refresh', () => {
+  test('a completed materializer step clears the gate; the pipeline is not resubmitted', async () => {
+    const { runRemediation } = await import('../src/core/remediation/run.ts');
+    const result = await runRemediation(
+      // Only the methods the orchestrator touches are needed.
+      fakeEngine as never,
+      { targetScore: 0, maxJobs: 6 },
+    );
+    // Frozen-ctx bug: extractionLagPages stays 25 forever, so every D7
+    // recheck re-introduces the sync/extract pipeline and the loop burns
+    // all 6 maxJobs. With the refresh, the plan converges after the first
+    // completed step: no step id is ever submitted twice.
+    const ids = result.submitted.map((s) => s.id);
+    expect(new Set(ids).size).toBe(ids.length);
+    expect(submittedJobs.length).toBeLessThan(3);
+    expect(extractionLag).toBe(0);
+  });
+});