@rulemetric/local 0.12.3 → 0.12.5

package/dist/supabase/migrations/00209_suggestion_pipeline_conformance.sql

@@ -0,0 +1,296 @@
+-- 00209 — the suggestion pipeline watches itself.
+--
+-- WHY. Nine gates between "proposal generated" and "proposal adopted" have now
+-- been found one, two, three at a time, over six weeks, each by a human noticing
+-- adoption had gone quiet and hand-writing a query. The mechanism that let every
+-- one of them hide is identical and is recorded in four separate memories and
+-- the 2026-08-27 census: each stage reports a single number — `nothing-eligible`,
+-- `refused: 0`, `queued 0 rows` — that reads the same whether the pool is EMPTY
+-- or FULL OF THINGS EVERY GATE REFUSES. A producer matching zero rows is
+-- indistinguishable from a quiet night.
+--
+-- This function encodes each discovered failure SIGNATURE as a named check that
+-- runs daily and lands as a notification (the 00147 pipeline_health_check
+-- pattern: one consolidated, unread-deduped notification per user). The census
+-- (scripts/dev/suggestion-gate-census.sql) is the manual deep-dive; this is the
+-- alarm that says the deep-dive is needed.
+--
+-- DETECTION ONLY, on purpose. Nothing here mutates suggestions, opens gates or
+-- writes files. Every incident in this pipeline's history that involved an
+-- unattended writer (00205's near-miss of 14 skills into ~/.claude/skills/, the
+-- armed-secrets workflows) argues that the automated half of "find and fix"
+-- must be the FINDING. Fixes go through review.
+--
+-- Every check corresponds to a real, dated incident. A check nobody can trace
+-- to a failure it would have caught is noise, and noise teaches people to
+-- ignore the alarm.
+
+-- Daily per-user counter snapshots, for the checks that detect CHRONIC
+-- conditions (a flag that only ever grows) rather than point-in-time states.
+create table if not exists public.pipeline_conformance_metrics (
+  id bigint generated always as identity primary key,
+  run_at timestamptz not null default now(),
+  user_id uuid not null references public.profiles(id) on delete cascade,
+  metric text not null,
+  value bigint not null
+);
+
+create index if not exists idx_conformance_metrics_lookup
+  on public.pipeline_conformance_metrics (user_id, metric, run_at desc);
+
+alter table public.pipeline_conformance_metrics enable row level security;
+
+-- Guarded so the file is safe to re-apply — the ledger-driven runner
+-- (scripts/deploy/apply-migrations.sh) may re-run a file after a lost ledger,
+-- and CREATE POLICY is the one statement here with no IF NOT EXISTS form.
+drop policy if exists "conformance_metrics_read_own" on public.pipeline_conformance_metrics;
+create policy "conformance_metrics_read_own" on public.pipeline_conformance_metrics
+  for select using (user_id = auth.uid());
+
+comment on table public.pipeline_conformance_metrics is
+  'Daily per-user snapshots written by suggestion_pipeline_conformance() (00209). Exists so one-way-flag defects (gate 7: is_stale set and never cleared) are detectable as monotone growth instead of waiting for a human to notice.';
+
+create or replace function public.suggestion_pipeline_conformance()
+returns table (check_id text, user_id uuid, detail text)
+language plpgsql
+security definer
+set search_path = public
+as $$
+begin
+  -- ── Snapshot metrics first, so the monotone checks below (and future ones)
+  -- have history even on days when every check is quiet. ────────────────────
+  insert into pipeline_conformance_metrics (user_id, metric, value)
+  select s.user_id, m.metric, m.value
+  from (select distinct is2.user_id from instruction_suggestions is2) s
+  cross join lateral (
+    select 'stale_open_rows' as metric,
+           (select count(*) from instruction_suggestions x
+             where x.user_id = s.user_id and x.kind = 'add'
+               and x.accepted_at is null and x.dismissed_at is null
+               and x.is_stale) as value
+    union all
+    select 'undecided_add_rows',
+           (select count(*) from instruction_suggestions x
+             where x.user_id = s.user_id and x.kind = 'add'
+               and x.accepted_at is null and x.dismissed_at is null)
+    union all
+    select 'auto_accept_candidates',
+           (select count(*) from auto_accept_candidate_suggestions v
+             where v.user_id = s.user_id)
+    union all
+    -- The 0.5–0.79 band: emitted by the scorer (recommend.ts floors at 0.5),
+    -- below the adoption default (0.8). Feed-only by construction — counted so
+    -- "open suggestions" stops being one number over two populations (census
+    -- cause 1, 2026-08-27: 393 of 477 open skills sat in this band).
+    select 'feed_only_band_rows',
+           (select count(*) from instruction_suggestions x
+             join instructions i on i.id = x.instruction_id
+             where x.user_id = s.user_id and x.kind = 'add'
+               and x.accepted_at is null and x.dismissed_at is null
+               and i.type in ('instruction', 'skill')
+               and x.score < 0.8
+               and coalesce(i.frontmatter->>'source', '') <> 'insights')
+    union all
+    -- Undecided rows quiet for >90 days that the weekly prune can NEVER
+    -- collect, by design: they carry instruction_suggestion_events, the FK is
+    -- ON DELETE CASCADE, and those events are the only record the funnel's
+    -- numerator was ever zero (00180's comment names naive pruning as the
+    -- failure mode). Counted here instead of deleted: the census's 2026-08-27
+    -- "cause 4" proposed pruning them and was wrong — visibility is the fix
+    -- that does not destroy evidence.
+    select 'dormant_open_rows',
+           (select count(*) from instruction_suggestions x
+             where x.user_id = s.user_id and x.kind = 'add'
+               and x.accepted_at is null and x.dismissed_at is null
+               and x.generated_at < now() - interval '90 days'
+               and coalesce(
+                     (select max(ev.created_at) from instruction_suggestion_events ev
+                       where ev.suggestion_id = x.id),
+                     x.generated_at
+                   ) < now() - interval '90 days')
+  ) m;
+
+  return query
+
+  -- ── CHECK 1: minted_on_forbidden_path ──────────────────────────────────────
+  -- Incident: census 2026-08-27 — 258 of 685 open proposals sat on paths the
+  -- writer is forbidden to touch (home dir, TMPDIR, worktrees, the dead
+  -- apps/cli). Fixed the same day by gating both mint sites on
+  -- assessMintablePath(). This check is that fix's regression alarm: any NEW
+  -- row on a non-canonical path means a mint site was added or the gate broke.
+  select 'minted_on_forbidden_path'::text,
+         s.user_id,
+         count(*) || ' suggestion(s) minted in the last 25h on non-canonical path(s), e.g. ' || min(s.project_path)
+  from instruction_suggestions s
+  where s.generated_at > now() - interval '25 hours'
+    and not exists (
+      select 1 from project_canonical_checkouts c where c.path = s.project_path
+    )
+  group by s.user_id
+
+  union all
+
+  -- ── CHECK 2: producer_silent_with_candidates ───────────────────────────────
+  -- Incident: gate 4 (00184→00197) — the DB producer's type clause matched zero
+  -- rows, pg_cron fired and SUCCEEDED at 05:00 for three days, enqueued
+  -- nothing, and no log line existed anywhere. Candidates older than 25h with
+  -- no job even CREATED in 25h cannot be a quiet night: the producer is hourly.
+  select 'producer_silent_with_candidates'::text,
+         v.user_id,
+         count(*) || ' candidate(s) (oldest ' ||
+           extract(day from now() - min(v.generated_at)) || 'd) but no auto-accept job created in 25h — the producer is not seeing them'
+  from auto_accept_candidate_suggestions v
+  where v.generated_at < now() - interval '25 hours'
+    and not exists (
+      select 1 from agent_jobs j
+      where j.user_id = v.user_id
+        and j.task_kind = 'cron_auto_accept_suggestions'
+        and j.created_at > now() - interval '25 hours'
+    )
+  group by v.user_id
+
+  union all
+
+  -- ── CHECK 3: endpoint_refuses_everything ───────────────────────────────────
+  -- Incident: gates 1–4 (#372, 2026-08-16..19) — the producer queued jobs, the
+  -- worker ran them, the ENDPOINT refused every candidate on a clause the
+  -- producer didn't have, and four days of `nothing-eligible` looked like four
+  -- quiet nights. Signature: jobs completing against a standing candidate set
+  -- while NOTHING moves — no acceptance, no refusal event. A healthy run
+  -- always moves one of those; a placeholder-refusal loop that repeats forever
+  -- without logging also lands here, and deserves to.
+  select 'endpoint_refuses_everything'::text,
+         v.user_id,
+         count(distinct v.suggestion_id) ||
+           ' candidate(s) standing >48h while auto-accept jobs completed — zero adoptions, zero refusal events. The producer and the endpoint disagree about eligibility.'
+  from auto_accept_candidate_suggestions v
+  where v.generated_at < now() - interval '48 hours'
+    and exists (
+      select 1 from agent_jobs j
+      where j.user_id = v.user_id
+        and j.task_kind = 'cron_auto_accept_suggestions'
+        and j.status = 'completed'
+        and j.updated_at > now() - interval '48 hours'
+    )
+    and not exists (
+      select 1 from instruction_suggestions a
+      where a.user_id = v.user_id
+        and a.accepted_at > now() - interval '48 hours'
+    )
+    and not exists (
+      select 1 from instruction_suggestion_events ev
+      join instruction_suggestions es on es.id = ev.suggestion_id
+      where es.user_id = v.user_id
+        and ev.event_type in ('redundant', 'partial_overlap', 'unresolvable_reference')
+        and ev.created_at > now() - interval '48 hours'
+    )
+  group by v.user_id
+
+  union all
+
+  -- ── CHECK 4: stale_flag_only_grows ─────────────────────────────────────────
+  -- Incident: gate 7 (2026-08-24) — is_stale was set by the mark-stale cron and
+  -- NOTHING ever cleared it; 51 adoption-grade proposals went invisible, and
+  -- one user's whole skill lane was structurally dead for weeks. A one-way flag
+  -- is invisible at any instant; over days it is a staircase. Fires when the
+  -- last 8 daily samples are all positive, never decrease, and end higher than
+  -- they started.
+  select 'stale_flag_only_grows'::text,
+         g.user_id,
+         'stale-flagged open rows grew ' || g.first_value || ' → ' || g.last_value ||
+           ' over ' || g.samples || ' daily samples with no decrease — nothing is un-flagging them'
+  from (
+    select m.user_id,
+           count(*) as samples,
+           (array_agg(m.value order by m.run_at))[1] as first_value,
+           (array_agg(m.value order by m.run_at desc))[1] as last_value,
+           bool_and(m.value > 0) as all_positive,
+           -- Non-decreasing across the window: max of pairwise drops is 0.
+           coalesce(max(m.drop), 0) = 0 as never_decreased
+    from (
+      select mm.user_id, mm.run_at, mm.value,
+             greatest(lag(mm.value) over (partition by mm.user_id order by mm.run_at) - mm.value, 0) as drop
+      from pipeline_conformance_metrics mm
+      where mm.metric = 'stale_open_rows'
+        and mm.run_at > now() - interval '8 days'
+    ) m
+    group by m.user_id
+  ) g
+  where g.samples >= 8 and g.all_positive and g.never_decreased and g.last_value > g.first_value
+
+  union all
+
+  -- ── CHECK 5: surface_budget_spent_on_unadoptable ───────────────────────────
+  -- Incident: gates 5/6 and census cause 2 — ~840 feature/hook/mcp pitches per
+  -- 30 days entered the SessionStart feed, burned their five-ask surface budget
+  -- on an audience that cannot act on them, and converted into permanent
+  -- silence-declines. Fixed 2026-08-27 by excluding non-adoptable types from
+  -- the session-start render set (feed.ts). Any surfaced event on such a row
+  -- after that is the filter regressing.
+  select 'surface_budget_spent_on_unadoptable'::text,
+         s.user_id,
+         count(distinct ev.suggestion_id) ||
+           ' non-adoptable proposal(s) (feature/hook/mcp/…) surfaced into sessions in the last 7d — they burn budget for an audience that cannot act'
+  from instruction_suggestion_events ev
+  join instruction_suggestions s on s.id = ev.suggestion_id
+  join instructions i on i.id = s.instruction_id
+  where ev.event_type in ('surfaced', 'surfaced_with_content')
+    and ev.created_at > now() - interval '7 days'
+    and s.kind = 'add'
+    and i.type not in ('instruction', 'skill')
+  group by s.user_id;
+end;
+$$;
+
+comment on function public.suggestion_pipeline_conformance() is
+  'Daily conformance sweep over the suggestion/promotion pipeline. Each check encodes the observable signature of a dated incident (gate 4 silent producer, #372 producer/endpoint drift, gate 7 one-way staleness, census causes 2 and 3). Detection only — never mutates pipeline state. Findings land as one consolidated notification per user (pattern: 00147).';
+
+-- Deliver findings the way pipeline_health_check does: one consolidated
+-- notification per user, deduped while a previous one is still unread.
+create or replace function public.run_suggestion_pipeline_conformance()
+returns integer
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  created integer := 0;
+begin
+  with findings as (
+    select * from public.suggestion_pipeline_conformance()
+  ),
+  by_user as (
+    select f.user_id as uid, count(*)::int as n,
+           string_agg('• [' || f.check_id || '] ' || f.detail, E'\n' order by f.check_id) as body
+    from findings f
+    group by f.user_id
+  ),
+  inserted as (
+    insert into notifications (user_id, type, title, body, url, metadata)
+    select b.uid,
+           'suggestion_conformance',
+           'Suggestion pipeline conformance findings',
+           b.body,
+           '/loop',
+           jsonb_build_object('findings', b.n)
+    from by_user b
+    where not exists (
+      select 1 from notifications n
+      where n.user_id = b.uid
+        and n.type = 'suggestion_conformance'
+        and n.read_at is null
+    )
+    returning 1
+  )
+  select count(*)::int into created from inserted;
+  return created;
+end;
+$$;
+
+-- 05:35 UTC — after eval_health_check (05:20) and pipeline_health_check
+-- (05:25), so the morning's findings arrive together.
+select cron.schedule(
+  'suggestion_pipeline_conformance',
+  '35 5 * * *',
+  $$select public.run_suggestion_pipeline_conformance();$$
+);

package/dist/supabase/migrations/00210_shared_eval_target_health_gates.sql

@@ -0,0 +1,237 @@
+-- 00210 — the eval-target health gates, defined once.
+--
+-- `enqueue_instruction_evolution` and `enqueue_eval_autorun` carried the three
+-- health gates (2a proportional-ungradeable, 2b anchored-on-errored, 2c
+-- mostly-failures) as byte-identical hand-synced copies — the evolution
+-- producer's own comment admits it: "All copied byte-identical from the live
+-- definition (00163's revision)". Two copies kept in step by discipline is the
+-- exact mechanism behind the canonical-checkout incident (00186: five copies,
+-- wrong in all five at once, silent) and the judge-segment incident (00193:
+-- five copies, one credit-exhaustion fallback re-pointed the evidence base).
+-- This repo has now paid for that lesson three times; the fix is the same each
+-- time — one named object, every reader reads it.
+--
+-- WHAT IS SHARED AND WHAT IS NOT. Only 2a/2b/2c are shared. The live-cases
+-- floor is NOT: evolution requires >= 3 (00183 — `exists` was the bug) while
+-- autorun requires >= 1, and collapsing that difference here would silently
+-- change enrolment. Pause flags, enrolment paths, change budgets and
+-- in-flight dedupe stay with their producers.
+--
+-- Gate bodies below are copied VERBATIM from the live prosrc (2026-08-27).
+-- Behaviour-identical by construction; the existing suites
+-- (evolution-enrolment-rule.test.ts, eval-autorun-health-gate.test.ts) are
+-- the proof.
+
+create or replace view public.healthy_eval_targets as
+select t.id as eval_target_id, t.user_id
+from eval_targets t
+where
+  -- Health 2a: recent grading wasn't MOSTLY ungradeable (proportional, 00163).
+  not exists (
+    select 1 from eval_runs r
+    where r.eval_target_id = t.id
+      and r.created_at > now() - interval '7 days'
+    group by r.eval_target_id
+    having count(*) >= 5
+       and count(*) filter (
+             where jsonb_typeof(r.grading->'expectations') = 'array'
+               and exists (
+                 select 1 from jsonb_array_elements(r.grading->'expectations') e
+                 where coalesce(e->>'errored', 'false') = 'true'
+               )
+           ) * 4 >= count(*)
+  )
+  -- Health 2b: no human anchors pointing at an ungradeable assertion (absolute).
+  and not exists (
+    select 1
+    from eval_grade_annotations a
+    join eval_runs r on r.id = a.eval_run_id
+    where a.eval_target_id = t.id
+      and jsonb_typeof(r.grading->'expectations') = 'array'
+      and coalesce(
+        r.grading->'expectations'->(a.expectation_index)->>'errored', 'false'
+      ) = 'true'
+  )
+  -- Health 2c: last week's batch wasn't mostly failures.
+  and not exists (
+    select 1 from eval_runs r
+    where r.eval_target_id = t.id
+      and r.created_at > now() - interval '7 days'
+    group by r.eval_target_id
+    having count(*) >= 5
+       and count(*) filter (where r.status = 'failed') * 4 >= count(*)
+  );
+
+grant select on public.healthy_eval_targets to authenticated, service_role;
+
+comment on view public.healthy_eval_targets is
+  'Eval targets passing the three shared health gates (2a proportional-ungradeable, 2b human anchor on an errored assertion, 2c mostly-failed batch). ONE definition (00210) read by both enqueue_instruction_evolution and enqueue_eval_autorun, which previously carried byte-identical hand-synced copies. Live-cases floors are deliberately NOT here — the two producers differ (>=3 vs >=1).';
+
+-- ── enqueue_instruction_evolution, health gates now read from the view ───────
+create or replace function public.enqueue_instruction_evolution()
+returns integer
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  queued integer;
+begin
+  with health_ok as (
+    select t.id, t.user_id
+    from eval_targets t
+    where coalesce(t.metadata->>'autoEvolvePaused', 'false') <> 'true'
+      -- Health 2a/2b/2c: ONE definition (00210), shared with eval autorun.
+      and exists (
+        select 1 from public.healthy_eval_targets h where h.eval_target_id = t.id
+      )
+      -- Live cases to measure against — at least MIN_LIVE_CASES (3).
+      -- `exists` (>= 1) was the bug: see 00183's header.
+      and (
+        select count(*) from evals ev
+        where ev.eval_target_id = t.id and ev.retired_at is null
+      ) >= 3
+      -- Change budget (cheap exclusion; the API is the authority).
+      and (
+        select count(*)
+        from instruction_promotions p
+        where p.eval_target_id = t.id
+          and p.applied
+          and p.created_at > now() - interval '7 days'
+      ) < 3
+      -- One in flight at a time.
+      and not exists (
+        select 1 from agent_jobs j
+        where j.task_kind = 'cron_instruction_evolution'
+          and j.status in ('pending', 'claimed', 'running')
+          and j.payload->>'evalTargetId' = t.id::text
+      )
+  ),
+  manual as (
+    -- The hand-picked path, unchanged and uncapped.
+    select h.id, h.user_id
+    from health_ok h
+    join eval_targets t on t.id = h.id
+    where coalesce(t.metadata->>'autoEvolveEnabled', 'false') = 'true'
+  ),
+  auto_ranked as (
+    -- The stated rule. Round-robin: never-decided first (nulls first), then
+    -- least-recently-decided, so the cap rotates through the candidate pool
+    -- instead of re-measuring the same winners nightly.
+    select h.id, h.user_id,
+           row_number() over (
+             partition by h.user_id
+             order by (
+               select max(p.created_at)
+               from instruction_promotions p
+               where p.eval_target_id = h.id
+             ) asc nulls first,
+             h.id
+           ) as rn
+    from health_ok h
+    join eval_targets t on t.id = h.id
+    where t.type = 'instruction'
+      and coalesce(t.metadata->>'autoEvolveOptOut', 'false') <> 'true'
+      -- Not already covered by the manual path.
+      and coalesce(t.metadata->>'autoEvolveEnabled', 'false') <> 'true'
+      -- ACTIVE (00145's load-bearing gate): a run in the last 30 days.
+      and exists (
+        select 1 from eval_runs r
+        where r.eval_target_id = t.id
+          and r.created_at > now() - interval '30 days'
+      )
+  ),
+  eligible as (
+    select id, user_id from manual
+    union
+    select id, user_id from auto_ranked where rn <= 3
+  ),
+  ins as (
+    insert into agent_jobs (user_id, task_kind, status, payload, dedupe_key)
+    select e.user_id,
+           'cron_instruction_evolution',
+           'pending',
+           jsonb_build_object('evalTargetId', e.id::text)
+             || case
+                  when public.eval_target_judge_segment(e.id) is not null
+                    then jsonb_build_object(
+                           'graderModel', public.eval_target_judge_segment(e.id))
+                  else '{}'::jsonb
+                end,
+           'instruction-evolution:' || e.id::text
+    from eligible e
+    returning 1
+  )
+  select count(*)::int into queued from ins;
+
+  return queued;
+end;
+$$;
+
+comment on function public.enqueue_instruction_evolution() is
+  'Daily producer for cron_instruction_evolution. Health gates 2a/2b/2c come from the healthy_eval_targets view (00210); pause, live-cases floor (>=3, 00183), change budget, round-robin enrolment and in-flight dedupe stay here. Judge segment from eval_target_judge_segment() (00193).';
+
+-- ── enqueue_eval_autorun, health gates now read from the view ────────────────
+create or replace function public.enqueue_eval_autorun()
+returns integer
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  queued integer;
+begin
+  with eligible as (
+    select t.id, t.user_id,
+      -- Canonical segment (00193). Was an inline "most recent stamped run"
+      -- subquery, which is how a credit-exhaustion fallback became the pin.
+      public.eval_target_judge_segment(t.id) as current_judge
+    from eval_targets t
+    where coalesce(t.metadata->>'autoRunEnabled', 'false') = 'true'
+      -- Gate 0 (00190): the target must be anchored to something a promotion
+      -- could land on. Without this, a batch is two LLM executions plus a
+      -- judged grade spent to rewrite a row nothing reads.
+      and (
+        t.instruction_id is not null
+        or t.project_path is not null
+        or t.name like '/%'
+      )
+      -- Gates 2a/2b/2c: ONE definition (00210), shared with evolution.
+      and exists (
+        select 1 from public.healthy_eval_targets h where h.eval_target_id = t.id
+      )
+      -- Gate 3: the target has live cases to actually run.
+      and exists (
+        select 1 from evals ev
+        where ev.eval_target_id = t.id and ev.retired_at is null
+      )
+      -- One in flight at a time, per the 00083/00086 pattern.
+      and not exists (
+        select 1 from agent_jobs j
+        where j.task_kind = 'cron_eval_autorun'
+          and j.status in ('pending', 'claimed', 'running')
+          and j.payload->>'evalTargetId' = t.id::text
+      )
+  ), ins as (
+    insert into agent_jobs (user_id, task_kind, status, payload, dedupe_key)
+    select e.user_id,
+           'cron_eval_autorun',
+           'pending',
+           jsonb_build_object('evalTargetId', e.id::text, 'maxRuns', 12)
+             || case
+                  when e.current_judge is not null
+                    then jsonb_build_object('graderModel', e.current_judge)
+                  else '{}'::jsonb
+                end,
+           'eval-autorun:' || e.id::text
+    from eligible e
+    returning 1
+  )
+  select count(*)::int into queued from ins;
+
+  return queued;
+end;
+$$;
+
+comment on function public.enqueue_eval_autorun() is
+  'Daily producer for cron_eval_autorun. Health gates 2a/2b/2c come from the healthy_eval_targets view (00210); the anchor gate (00190), live-cases exists, judge segment (00193) and in-flight dedupe stay here.';

package/dist/supabase/migrations/00211_training_candidate_view.sql

@@ -0,0 +1,119 @@
+-- 00211 — the trial-nomination candidate predicate, defined once.
+--
+-- Same treatment as 00208 gave the auto-accept producer: the eligibility
+-- predicate becomes a named view so the producer, the conformance monitor and
+-- diagnostics read ONE definition. `enqueue_instruction_training` is the
+-- second-churniest producer in the corpus (six rewrites: 00171, 00174, 00175,
+-- 00178, 00186, 00188 — including TWO separate canonical-path fixes), and
+-- every rewrite was a predicate change hand-held through pl/pgsql.
+--
+-- TWO DELIBERATE NON-CHANGES, recorded so nobody "fixes" them casually:
+--
+--   * `declined_at IS NULL` stays STRICT. This is NOT the gate-8 drift: the
+--     trialable endpoint (loop.ts) applies the same strict form, so producer
+--     and endpoint AGREE — a silence-declined proposal is excluded from
+--     trials at both sites today. Whether trials SHOULD admit silence
+--     declines (measurement settles what silence cannot) is a policy question
+--     for the owner; changing it belongs in its own migration with both sites
+--     moving together, never smuggled into an extraction.
+--
+--   * The activity window stays a PARAMETER. The function takes
+--     p_active_days (default 7); a view cannot. So the view exposes
+--     `last_session_activity_at` and the FUNCTION applies the cutoff —
+--     the predicate is centralised, the knob is preserved.
+--
+-- ONE EQUIVALENT SIMPLIFICATION: the old canonical check was
+--   exists (project_checkouts pc join project_canonical_checkouts c
+--           on c.project_id = pc.project_id
+--           where pc.path = s.project_path and c.path = s.project_path)
+-- Since every project_canonical_checkouts row IS a project_checkouts row
+-- (the view selects from that table), `c.path = s.project_path` alone implies
+-- the pc branch. Rewritten to the same single-EXISTS form 00208 uses.
+
+create or replace view public.instruction_training_candidate_suggestions as
+select s.id          as suggestion_id,
+       s.user_id,
+       s.project_path,
+       s.instruction_id,
+       s.score,
+       (
+         select max(se.started_at)
+           from project_checkouts pc
+           join sessions se on se.project_id = pc.project_id
+          where pc.path = s.project_path
+            and se.user_id = s.user_id
+       ) as last_session_activity_at
+from instruction_suggestions s
+where s.kind = 'add'
+  and s.accepted_at is null
+  and s.dismissed_at is null
+  -- STRICT on purpose — see header. The trialable endpoint agrees.
+  and s.declined_at is null
+  and s.is_stale = false
+  -- The canonical checkout, nowhere else (00186/00188 lineage; simplified
+  -- equivalent of the old double-join — see header).
+  and exists (
+    select 1 from public.project_canonical_checkouts c
+     where c.path = s.project_path
+  );
+
+grant select on public.instruction_training_candidate_suggestions to authenticated, service_role;
+
+comment on view public.instruction_training_candidate_suggestions is
+  'Trial-nomination candidate predicate, ONE definition (00211, the 00208 treatment for the training lane). The activity cutoff is applied by enqueue_instruction_training() against last_session_activity_at so p_active_days stays a parameter. declined_at IS NULL is strict BY AGREEMENT with the trialable endpoint — changing that policy must move both sites in one migration.';
+
+create or replace function public.enqueue_instruction_training(p_active_days integer default 7)
+returns integer
+language plpgsql
+security definer
+set search_path = public
+as $$
+declare
+  queued integer;
+begin
+  with eligible as (
+    select v.user_id, v.project_path
+      from public.instruction_training_candidate_suggestions v
+     where v.last_session_activity_at > now() - (p_active_days || ' days')::interval
+       and not exists (
+         select 1 from agent_jobs j
+          where j.task_kind = 'cron_instruction_training'
+            and j.status in ('pending', 'claimed', 'running')
+            and j.payload->>'projectPath' = v.project_path
+            and j.user_id = v.user_id
+       )
+     group by v.user_id, v.project_path
+
+    union
+
+    -- Running experiments always get their refresh pass, candidates or not.
+    select e.user_id, e.project_path
+      from instruction_experiments e
+     where e.status = 'running'
+       and not exists (
+         select 1 from agent_jobs j
+          where j.task_kind = 'cron_instruction_training'
+            and j.status in ('pending', 'claimed', 'running')
+            and j.payload->>'projectPath' = e.project_path
+            and j.user_id = e.user_id
+       )
+     group by e.user_id, e.project_path
+  ),
+  ins as (
+    insert into agent_jobs (user_id, task_kind, status, payload, dedupe_key)
+    select e.user_id,
+           'cron_instruction_training',
+           'pending',
+           jsonb_build_object('projectPath', e.project_path),
+           'instruction-training:' || e.user_id::text || ':' || e.project_path
+      from eligible e
+    returning 1
+  )
+  select count(*)::int into queued from ins;
+
+  return queued;
+end;
+$$;
+
+comment on function public.enqueue_instruction_training(integer) is
+  'Producer for cron_instruction_training. Candidate predicate lives in the instruction_training_candidate_suggestions view (00211); this function applies the p_active_days activity cutoff, the running-experiments refresh branch, and in-flight dedupe. History: 00171, 00174 (active gate), 00186/00188 (canonical path), 00210-era extraction.';