@rulemetric/local 0.18.1 → 0.19.1

package/dist/supabase/migrations/00241_canonical_experiments.sql

@@ -0,0 +1,147 @@
+-- Replace experiment identities; preserve original IDs and immutable evidence.
+-- This migration must run with experiment workers quiesced for the cutover.
+BEGIN;
+-- Old workers cannot write compatibility projections after cutover. Refuse
+-- deployment while any experimental worker holds a lease; never kill its calls.
+DO $$ BEGIN
+ IF EXISTS(SELECT 1 FROM eval_jobs WHERE task_kind IN ('process_eval','process_suggestion_eval','process_suggestion_discovery') AND status IN ('claimed','running'))
+ OR EXISTS(SELECT 1 FROM launch_jobs WHERE status IN ('claimed','running') AND (config ? 'scopedConfirmation' OR payload->'config' ? 'scopedConfirmation'))
+ OR EXISTS(SELECT 1 FROM agent_jobs WHERE task_kind IN ('harbor_ab','memory_ab','cron_instruction_evolution','cron_instruction_training','cron_eval_autorun') AND status IN ('claimed','running')) THEN
+  RAISE EXCEPTION 'Drain experiment workers before canonical experiment migration';
+ END IF;
+END $$;
+ALTER TABLE performance_studies RENAME TO experiments;
+DROP TRIGGER performance_study_immutable ON experiments;
+ALTER TABLE experiments RENAME COLUMN result TO analysis;
+ALTER TABLE experiments ALTER COLUMN eval_target_id DROP NOT NULL;
+ALTER TABLE experiments ALTER COLUMN project_path DROP NOT NULL;
+ALTER TABLE experiments DROP CONSTRAINT performance_study_version;
+ALTER TABLE experiments DROP CONSTRAINT performance_study_finalization_pair;
+ALTER TABLE experiments ADD COLUMN executor text NOT NULL DEFAULT 'fixture'
+ CHECK (executor IN ('fixture','benchmark','replay','repository','historical'));
+ALTER TABLE experiments ADD COLUMN name text NOT NULL DEFAULT 'Experiment';
+ALTER TABLE experiments ADD COLUMN status text NOT NULL DEFAULT 'ready'
+ CHECK (status IN ('ready','queued','running','completed','failed','cancelled','stopped'));
+ALTER TABLE experiments ADD COLUMN result jsonb;
+ALTER TABLE experiments ADD COLUMN parent_experiment_id uuid REFERENCES experiments(id) ON DELETE RESTRICT;
+ALTER TABLE experiments ADD COLUMN delivery_policy_id uuid;
+ALTER TABLE experiments ADD COLUMN salt text;
+ALTER TABLE experiments ADD COLUMN analysis_decision text;
+ALTER TABLE experiments ADD COLUMN legacy_evidence jsonb;
+DROP INDEX performance_studies_protocol_unique;
+CREATE UNIQUE INDEX experiments_fixture_protocol_unique ON experiments(user_id,eval_target_id,protocol_hash) WHERE executor='fixture';
+CREATE INDEX experiments_user_created ON experiments(user_id,created_at DESC,id);
+CREATE INDEX experiments_parent ON experiments(parent_experiment_id) WHERE parent_experiment_id IS NOT NULL;
+CREATE UNIQUE INDEX experiments_delivery_policy ON experiments(delivery_policy_id) WHERE delivery_policy_id IS NOT NULL;
+UPDATE experiments s SET name=coalesce(s.protocol->>'question',t.name),
+ status=CASE WHEN s.finalized_at IS NOT NULL THEN 'completed' ELSE 'ready' END,
+ legacy_evidence=jsonb_build_object('source','study','id',s.id,'decision',s.analysis->>'decision','runs',coalesce((SELECT jsonb_agg(to_jsonb(r)) FROM eval_runs r WHERE r.outputs->'study'->>'studyId'=s.id::text),'[]'::jsonb))
+ FROM eval_targets t WHERE t.id=s.eval_target_id;
+
+-- The adapter projections below are READ ONLY; new code writes experiments.
+ALTER TABLE scoped_live_confirmations RENAME TO historical_scoped_live_confirmations;
+INSERT INTO experiments(id,user_id,executor,name,project_path,protocol,protocol_hash,
+ status,analysis,analysis_decision,created_at,finalized_at,parent_experiment_id,delivery_policy_id,salt,legacy_evidence)
+ SELECT c.id,c.user_id,'repository',i.name,c.protocol->>'projectPath',c.protocol,c.protocol_hash,
+ c.status,c.decision_detail,c.decision,c.started_at,c.ended_at,c.source_study_id,c.experiment_id,c.salt,
+ jsonb_build_object('source','live','id',c.id,'decision',c.decision,'assignments',coalesce((SELECT jsonb_agg(to_jsonb(a)) FROM scoped_live_confirmation_assignments a WHERE a.confirmation_id=c.id),'[]'::jsonb))
+ FROM historical_scoped_live_confirmations c JOIN instruction_experiments x ON x.id=c.experiment_id
+ JOIN instructions i ON i.id=x.instruction_id;
+ALTER TABLE scoped_live_confirmation_assignments DROP CONSTRAINT scoped_live_confirmation_assignments_confirmation_id_fkey;
+ALTER TABLE scoped_live_confirmation_assignments ADD FOREIGN KEY(confirmation_id) REFERENCES experiments(id) ON DELETE CASCADE;
+ALTER TABLE recommendation_applications DROP CONSTRAINT recommendation_applications_scoped_confirmation_id_fkey;
+ALTER TABLE recommendation_applications ADD FOREIGN KEY(scoped_confirmation_id) REFERENCES experiments(id) ON DELETE RESTRICT;
+
+CREATE VIEW performance_studies AS SELECT id,user_id,eval_target_id,project_path,protocol,protocol_hash,
+ analysis AS result,finalized_at,created_at FROM experiments WHERE executor='fixture';
+CREATE VIEW scoped_live_confirmations AS SELECT id,user_id,delivery_policy_id AS experiment_id,
+ parent_experiment_id AS source_study_id,protocol,protocol_hash,salt,status,
+ analysis_decision AS decision,analysis AS decision_detail,created_at AS started_at,finalized_at AS ended_at
+ FROM experiments WHERE executor='repository';
+CREATE FUNCTION reject_retired_experiment_write() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN RAISE EXCEPTION 'Retired experiment write path: use the canonical experiment API'; END $$;
+CREATE TRIGGER retired_study_write INSTEAD OF INSERT OR UPDATE OR DELETE ON performance_studies
+ FOR EACH ROW EXECUTE FUNCTION reject_retired_experiment_write();
+CREATE TRIGGER retired_confirmation_write INSTEAD OF INSERT OR UPDATE OR DELETE ON scoped_live_confirmations
+ FOR EACH ROW EXECUTE FUNCTION reject_retired_experiment_write();
+
+ALTER TABLE eval_jobs ADD COLUMN experiment_id uuid REFERENCES experiments(id) ON DELETE RESTRICT;
+ALTER TABLE agent_jobs ADD COLUMN experiment_id uuid REFERENCES experiments(id) ON DELETE RESTRICT;
+CREATE INDEX eval_jobs_experiment ON eval_jobs(experiment_id) WHERE experiment_id IS NOT NULL;
+CREATE INDEX agent_jobs_experiment ON agent_jobs(experiment_id) WHERE experiment_id IS NOT NULL;
+UPDATE eval_jobs j SET experiment_id=s.id FROM experiments s
+ WHERE s.executor='fixture' AND s.user_id=j.user_id AND
+ s.id::text=coalesce(j.config->>'studyId',j.payload->'study'->>'studyId',j.payload->'study'->>'id');
+
+-- Historical records enter the common store once, without recomputing claims.
+INSERT INTO experiments(id,user_id,executor,name,project_path,protocol,protocol_hash,status,analysis,created_at,finalized_at,legacy_evidence)
+ SELECT j.id,j.user_id,CASE WHEN j.task_kind='harbor_ab' THEN 'benchmark' ELSE 'historical' END,
+ coalesce(j.payload->>'task',t.name,'Historical experiment'),coalesce(j.payload->>'projectPath',t.project_path),
+ jsonb_build_object('version',1,'execution',j.task_kind,'configuration',j.payload),encode(sha256(j.payload::text::bytea),'hex'),
+ CASE WHEN j.status='pending' THEN 'queued' WHEN j.status='claimed' THEN 'running' WHEN j.status IN ('completed','failed','running') THEN j.status ELSE 'cancelled' END,
+ j.result,j.created_at,j.completed_at,jsonb_build_object('source',CASE WHEN j.task_kind='harbor_ab' THEN 'harbor' WHEN j.task_kind='cron_eval_autorun' THEN 'eval' ELSE 'evolution' END,'id',j.id,'record',to_jsonb(j))
+ FROM agent_jobs j LEFT JOIN eval_targets t ON t.id::text=j.payload->>'evalTargetId'
+ WHERE j.task_kind IN ('harbor_ab','cron_instruction_evolution','cron_instruction_training','cron_eval_autorun');
+UPDATE agent_jobs j SET experiment_id=e.id FROM experiments e WHERE e.id=j.id;
+INSERT INTO experiments(id,user_id,executor,name,project_path,protocol,protocol_hash,status,analysis,created_at,finalized_at,legacy_evidence)
+ SELECT j.id,j.user_id,'historical',t.name,t.project_path,jsonb_build_object('version',1,'configuration',j.config),encode(sha256(j.config::text::bytea),'hex'),
+ CASE WHEN j.status='pending' THEN 'queued' WHEN j.status='claimed' THEN 'running' WHEN j.status IN ('completed','failed','running') THEN j.status ELSE 'cancelled' END,
+ j.result,j.created_at,j.completed_at,jsonb_build_object('source','eval','id',j.id,'record',to_jsonb(j))
+ FROM eval_jobs j JOIN eval_targets t ON t.id=j.eval_target_id WHERE j.experiment_id IS NULL
+ AND coalesce(j.task_kind,'process_eval') IN ('process_eval','process_suggestion_eval','process_suggestion_discovery');
+UPDATE eval_jobs j SET experiment_id=e.id FROM experiments e WHERE e.id=j.id;
+INSERT INTO experiments(id,user_id,executor,name,protocol,protocol_hash,status,analysis,created_at,finalized_at,legacy_evidence)
+ SELECT m.id,m.user_id,'historical','Memory: '||left(m.task_prompt,120),jsonb_build_object('version',1,'prompt',m.task_prompt),encode(sha256(m.task_prompt::bytea),'hex'),
+ CASE WHEN m.status='pending' THEN 'queued' ELSE m.status END,m.result,m.created_at,m.completed_at,
+ jsonb_build_object('source','memory','id',m.id,'record',to_jsonb(m)) FROM memory_experiments m;
+INSERT INTO experiments(id,user_id,executor,name,project_path,protocol,protocol_hash,status,analysis,created_at,finalized_at,legacy_evidence)
+ SELECT c.id,c.user_id,'historical',a.name||' / '||b.name,a.project_path,jsonb_build_object('version',1,'targetA',c.target_a_id,'targetB',c.target_b_id),
+ encode(sha256(c.id::text::bytea),'hex'),CASE WHEN c.status='completed' THEN 'completed' ELSE 'failed' END,c.overall,c.created_at,c.created_at,
+ jsonb_build_object('source','comparison','id',c.id,'record',to_jsonb(c))
+ FROM eval_comparisons c JOIN eval_targets a ON a.id=c.target_a_id JOIN eval_targets b ON b.id=c.target_b_id;
+INSERT INTO experiments(id,user_id,executor,name,project_path,protocol,protocol_hash,status,created_at,legacy_evidence)
+ SELECT x.id,x.user_id,'historical',i.name,x.project_path,jsonb_build_object('version',1),encode(sha256(x.id::text::bytea),'hex'),
+ CASE WHEN x.status='running' THEN 'cancelled' ELSE 'stopped' END,x.created_at,jsonb_build_object('source','live','id',x.id,'record',to_jsonb(x))
+ FROM instruction_experiments x JOIN instructions i ON i.id=x.instruction_id
+ WHERE NOT EXISTS(SELECT 1 FROM experiments e WHERE e.delivery_policy_id=x.id);
+
+CREATE TABLE experiment_observations (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(), experiment_id uuid NOT NULL REFERENCES experiments(id) ON DELETE CASCADE,
+ task_id text NOT NULL, arm text NOT NULL CHECK(arm IN ('baseline','treatment')), repetition integer NOT NULL CHECK(repetition>0),
+ metrics jsonb NOT NULL, eligibility text NOT NULL CHECK(eligibility IN ('eligible','excluded')),
+ exclusion text, evidence jsonb NOT NULL, created_at timestamptz NOT NULL DEFAULT now(),
+ CONSTRAINT experiment_observation_once UNIQUE(experiment_id,task_id,arm,repetition)
+);
+ALTER TABLE experiment_observations ENABLE ROW LEVEL SECURITY;
+CREATE POLICY experiment_observations_owner ON experiment_observations FOR SELECT USING
+ (EXISTS(SELECT 1 FROM experiments e WHERE e.id=experiment_id AND e.user_id=auth.uid()));
+CREATE FUNCTION preserve_experiment_observation() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN RAISE EXCEPTION 'Experiment observations are immutable'; END $$;
+CREATE TRIGGER experiment_observation_immutable BEFORE UPDATE ON experiment_observations
+ FOR EACH ROW EXECUTE FUNCTION preserve_experiment_observation();
+
+-- Archive-only special-purpose experiment producers. Historical reads survive.
+CREATE TRIGGER retired_memory_experiment_write BEFORE INSERT OR UPDATE ON memory_experiments
+ FOR EACH ROW EXECUTE FUNCTION reject_retired_experiment_write();
+CREATE TRIGGER retired_blind_comparison_write BEFORE INSERT OR UPDATE ON eval_comparisons
+ FOR EACH ROW EXECUTE FUNCTION reject_retired_experiment_write();
+CREATE TRIGGER retired_confirmation_archive_write BEFORE INSERT OR UPDATE ON historical_scoped_live_confirmations
+ FOR EACH ROW EXECUTE FUNCTION reject_retired_experiment_write();
+
+-- Canonical identity/protocol cannot move, even while execution status changes.
+CREATE FUNCTION preserve_experiment() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+ IF (to_jsonb(NEW)-ARRAY['status','analysis','analysis_decision','result','finalized_at']) IS DISTINCT FROM
+    (to_jsonb(OLD)-ARRAY['status','analysis','analysis_decision','result','finalized_at']) THEN
+  RAISE EXCEPTION 'Experiment identity and protocol are immutable';
+ END IF;
+ IF OLD.result IS NOT NULL AND NEW.result IS DISTINCT FROM OLD.result THEN
+  RAISE EXCEPTION 'Final experiment result is immutable';
+ END IF;
+ IF OLD.finalized_at IS NOT NULL AND (NEW.analysis IS DISTINCT FROM OLD.analysis OR NEW.analysis_decision IS DISTINCT FROM OLD.analysis_decision) THEN
+  RAISE EXCEPTION 'Final analysis is immutable';
+ END IF;
+ RETURN NEW;
+END $$;
+CREATE TRIGGER experiment_immutable BEFORE UPDATE ON experiments FOR EACH ROW EXECUTE FUNCTION preserve_experiment();
+COMMIT;

package/dist/supabase/migrations/00242_experiment_results_and_applications.sql

@@ -0,0 +1,86 @@
+BEGIN;
+-- Preserve the original decision verbatim in analysis/legacy_evidence. The
+-- historical normalization is a one-time import, not another live evaluator.
+UPDATE experiments SET result=jsonb_build_object(
+ 'version',1,'primaryMetric',CASE WHEN analysis IS NULL THEN NULL ELSE (CASE WHEN executor IN ('fixture','repository') THEN 'correctness' WHEN executor='benchmark' THEN CASE WHEN analysis->>'axis'='cost' OR analysis->>'decision'='cost_signal' OR protocol->'configuration'->>'axis'='cost' THEN 'costUsd' ELSE 'correctness' END ELSE 'recorded' END) END,
+ 'metrics',CASE WHEN analysis IS NULL THEN '[]'::jsonb ELSE jsonb_build_array(jsonb_build_object(
+  'key',(CASE WHEN executor IN ('fixture','repository') THEN 'correctness' WHEN executor='benchmark' THEN CASE WHEN analysis->>'axis'='cost' OR analysis->>'decision'='cost_signal' OR protocol->'configuration'->>'axis'='cost' THEN 'costUsd' ELSE 'correctness' END ELSE 'recorded' END),'label',CASE (CASE WHEN executor IN ('fixture','repository') THEN 'correctness' WHEN executor='benchmark' THEN CASE WHEN analysis->>'axis'='cost' OR analysis->>'decision'='cost_signal' OR protocol->'configuration'->>'axis'='cost' THEN 'costUsd' ELSE 'correctness' END ELSE 'recorded' END) WHEN 'costUsd' THEN 'Cost' WHEN 'correctness' THEN 'Correctness' ELSE 'Historical finding' END,
+  'unit',CASE (CASE WHEN executor IN ('fixture','repository') THEN 'correctness' WHEN executor='benchmark' THEN CASE WHEN analysis->>'axis'='cost' OR analysis->>'decision'='cost_signal' OR protocol->'configuration'->>'axis'='cost' THEN 'costUsd' ELSE 'correctness' END ELSE 'recorded' END) WHEN 'costUsd' THEN 'USD' WHEN 'correctness' THEN 'pass fraction' ELSE 'original measure' END,
+  'direction',CASE WHEN (CASE WHEN executor IN ('fixture','repository') THEN 'correctness' WHEN executor='benchmark' THEN CASE WHEN analysis->>'axis'='cost' OR analysis->>'decision'='cost_signal' OR protocol->'configuration'->>'axis'='cost' THEN 'costUsd' ELSE 'correctness' END ELSE 'recorded' END)='costUsd' THEN 'lower' ELSE 'higher' END,
+  'baseline',NULL,'treatment',NULL,'basis','historical','interval',NULL,
+  'finding',CASE
+   WHEN status NOT IN ('completed','stopped') THEN 'unassessed'
+   WHEN executor='benchmark' AND (analysis->>'decisionSemanticsVersion' IS DISTINCT FROM '2' OR analysis->'provenance'->>'comparable' IS DISTINCT FROM 'true') THEN 'unassessed'
+   WHEN analysis->>'decision'='cost_signal' AND analysis->'cost'->>'rewardRegressed'='true' THEN 'inconclusive'
+   WHEN analysis->>'decision'='cost_signal' AND analysis->'cost'->>'decision'='cheaper' THEN 'improved'
+   WHEN analysis->>'decision'='cost_signal' AND analysis->'cost'->>'decision'='costlier' THEN 'worsened'
+   WHEN coalesce(analysis->>'decision',analysis_decision) IN ('improvement','improved','holds','now_discriminates','promote') THEN 'improved'
+   WHEN coalesce(analysis->>'decision',analysis_decision) IN ('harmful','reward_harm') THEN 'worsened'
+   WHEN analysis->>'decision'='no_useful_effect' THEN 'no_useful_difference'
+   WHEN legacy_evidence->>'source'='memory' AND analysis->'verdict'->>'sufficient'='true'
+    AND analysis->'verdict'->>'significant'='true' AND analysis->'verdict'->>'confounded'='false'
+    THEN CASE WHEN (analysis->'verdict'->>'delta')::numeric>0 THEN 'improved' ELSE 'worsened' END
+   ELSE 'inconclusive' END,
+  'explanation',coalesce(analysis->>'explanation',analysis->>'reason','Historical decision retained; inspect original evidence.'))) END,
+ 'validity','limited','explanation','Imported historical evidence; original protocol and decision are preserved.',
+ 'observed',coalesce((analysis->>'observedCalls')::integer,0),'planned',NULL,'applicationAllowed',false)
+ WHERE status IN ('completed','failed','stopped','cancelled') AND result IS NULL;
+
+-- Executions have transport jobs; their status is not an effect verdict.
+CREATE FUNCTION sync_experiment_execution_status() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+ IF NEW.experiment_id IS NOT NULL THEN
+  UPDATE experiments SET status=CASE NEW.status WHEN 'pending' THEN 'queued' WHEN 'claimed' THEN 'running'
+   WHEN 'paused' THEN 'running' WHEN 'cancelled' THEN 'cancelled' ELSE NEW.status END
+   WHERE id=NEW.experiment_id AND user_id=NEW.user_id AND result IS NULL;
+ END IF;
+ RETURN NEW;
+END $$;
+CREATE TRIGGER eval_experiment_status AFTER INSERT OR UPDATE OF status,experiment_id ON eval_jobs
+ FOR EACH ROW EXECUTE FUNCTION sync_experiment_execution_status();
+CREATE TRIGGER agent_experiment_status AFTER INSERT OR UPDATE OF status,experiment_id ON agent_jobs
+ FOR EACH ROW EXECUTE FUNCTION sync_experiment_execution_status();
+
+-- File workflow state is an actuator implementation detail. Actual applications
+-- from every actuator have one ledger and cannot contaminate each other's gates.
+CREATE TABLE experiment_applications (
+ id uuid PRIMARY KEY, user_id uuid NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
+ experiment_id uuid REFERENCES experiments(id) ON DELETE RESTRICT,
+ action text NOT NULL CHECK(action IN ('file_change','instruction_delivery','instruction_revision')),
+ status text NOT NULL CHECK(status IN ('not_applied','applied','reverted')),
+ target text NOT NULL, applied_at timestamptz, evidence jsonb NOT NULL,
+ created_at timestamptz NOT NULL DEFAULT now()
+);
+CREATE INDEX experiment_applications_experiment ON experiment_applications(experiment_id,created_at,id);
+ALTER TABLE experiment_applications ENABLE ROW LEVEL SECURITY;
+CREATE POLICY experiment_applications_owner ON experiment_applications FOR SELECT USING(auth.uid()=user_id);
+CREATE FUNCTION record_file_application() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+ INSERT INTO experiment_applications(id,user_id,experiment_id,action,status,target,applied_at,evidence,created_at)
+ VALUES(NEW.id,NEW.user_id,coalesce(NEW.scoped_confirmation_id,NEW.source_study_id),'file_change',
+  CASE WHEN NEW.reverted_at IS NOT NULL THEN 'reverted' WHEN NEW.applied_at IS NOT NULL THEN 'applied' ELSE 'not_applied' END,
+  NEW.target_path,NEW.applied_at,to_jsonb(NEW),NEW.created_at)
+ ON CONFLICT(id) DO UPDATE SET status=EXCLUDED.status,applied_at=EXCLUDED.applied_at,evidence=EXCLUDED.evidence;
+ RETURN NEW;
+END $$;
+CREATE TRIGGER file_application_receipt AFTER INSERT OR UPDATE ON recommendation_applications
+ FOR EACH ROW EXECUTE FUNCTION record_file_application();
+INSERT INTO experiment_applications(id,user_id,experiment_id,action,status,target,applied_at,evidence,created_at)
+ SELECT a.id,a.user_id,coalesce(a.scoped_confirmation_id,a.source_study_id),'file_change',
+ CASE WHEN a.reverted_at IS NOT NULL THEN 'reverted' WHEN a.applied_at IS NOT NULL THEN 'applied' ELSE 'not_applied' END,
+ a.target_path,a.applied_at,to_jsonb(a),a.created_at FROM recommendation_applications a;
+
+-- Retire the competing automatic revision runner. Manual restoration survives.
+CREATE OR REPLACE FUNCTION public.enqueue_instruction_evolution() RETURNS integer
+ LANGUAGE sql SECURITY DEFINER SET search_path=public AS $$ SELECT 0 $$;
+CREATE FUNCTION reject_retired_experiment_job() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+ IF NEW.task_kind='memory_ab' OR (NEW.task_kind='cron_instruction_evolution' AND NEW.payload->'restoration' IS NULL) THEN
+  RAISE EXCEPTION 'Retired experiment producer: create a canonical experiment';
+ END IF;
+ RETURN NEW;
+END $$;
+CREATE TRIGGER retired_experiment_job BEFORE INSERT ON agent_jobs FOR EACH ROW EXECUTE FUNCTION reject_retired_experiment_job();
+UPDATE agent_jobs SET status='failed',error='Superseded by canonical experiments; no additional calls authorized',completed_at=now(),claimed_by=NULL,lease_expires_at=NULL
+ WHERE status='pending' AND (task_kind='memory_ab' OR (task_kind='cron_instruction_evolution' AND payload->'restoration' IS NULL));
+COMMIT;

package/dist/supabase/migrations/00243_experiment_receipt_integrity.sql

@@ -0,0 +1,61 @@
+BEGIN;
+-- Compatibility projections must preserve the owner policies on their base tables.
+ALTER VIEW performance_studies SET (security_invoker=true);
+ALTER VIEW scoped_live_confirmations SET (security_invoker=true);
+
+-- Serialize completion with receipt admission. Identical retries are safe even
+-- after finalization, but a conflicting retry never disappears behind DO NOTHING.
+CREATE FUNCTION admit_experiment_observation() RETURNS trigger LANGUAGE plpgsql AS $$
+DECLARE e experiments%ROWTYPE; prior experiment_observations%ROWTYPE;
+BEGIN
+ SELECT * INTO e FROM experiments WHERE id=NEW.experiment_id FOR UPDATE;
+ IF NOT FOUND THEN RAISE EXCEPTION 'Experiment not found'; END IF;
+ SELECT * INTO prior FROM experiment_observations WHERE experiment_id=NEW.experiment_id
+  AND task_id=NEW.task_id AND arm=NEW.arm AND repetition=NEW.repetition;
+ IF FOUND THEN
+  IF (to_jsonb(prior)-ARRAY['id','created_at']) IS DISTINCT FROM (to_jsonb(NEW)-ARRAY['id','created_at']) THEN
+   RAISE EXCEPTION 'Conflicting experiment observation';
+  END IF;
+  RETURN NULL;
+ END IF;
+ IF e.result IS NOT NULL THEN RAISE EXCEPTION 'Experiment is finalized'; END IF;
+ RETURN NEW;
+END $$;
+CREATE TRIGGER experiment_observation_admission BEFORE INSERT ON experiment_observations
+ FOR EACH ROW EXECUTE FUNCTION admit_experiment_observation();
+
+-- Trial and follow-up delivery both carry their phase in the receipt.
+CREATE FUNCTION record_experiment_delivery() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+ IF NEW.delivered_at IS NOT NULL AND OLD.delivered_at IS NULL THEN
+  INSERT INTO experiment_applications(id,user_id,experiment_id,action,status,target,applied_at,evidence)
+  VALUES(NEW.id,NEW.user_id,NEW.confirmation_id,'instruction_delivery','applied','assignment:'||NEW.id,NEW.delivered_at,
+   jsonb_build_object('phase',NEW.phase,'arm',NEW.arm,'deliveryHash',NEW.delivery_hash,'sessionId',NEW.external_session_id))
+  ON CONFLICT(id) DO NOTHING;
+ END IF;
+ RETURN NEW;
+END $$;
+CREATE TRIGGER experiment_delivery_receipt AFTER UPDATE OF delivered_at ON scoped_live_confirmation_assignments
+ FOR EACH ROW EXECUTE FUNCTION record_experiment_delivery();
+INSERT INTO experiment_applications(id,user_id,experiment_id,action,status,target,applied_at,evidence)
+ SELECT a.id,a.user_id,a.confirmation_id,'instruction_delivery','applied','assignment:'||a.id,a.delivered_at,
+ jsonb_build_object('phase',a.phase,'arm',a.arm,'deliveryHash',a.delivery_hash,'sessionId',a.external_session_id,'historical',true)
+ FROM scoped_live_confirmation_assignments a WHERE a.delivered_at IS NOT NULL;
+
+-- A recorded promotion decision can be a dry run. Only actual rewrites enter
+-- this ledger. Their complete inverse bodies remain in the immutable receipt.
+CREATE FUNCTION record_instruction_revision_application() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+ IF NEW.applied THEN
+  INSERT INTO experiment_applications(id,user_id,experiment_id,action,status,target,applied_at,evidence)
+  VALUES(NEW.id,NEW.user_id,(SELECT e.id FROM experiments e WHERE e.user_id=NEW.user_id AND e.analysis->>'promotionId'=NEW.id::text LIMIT 1),'instruction_revision','applied','instruction:'||coalesce(NEW.instruction_id,NEW.eval_target_id),coalesce((NEW.gates->>'appliedAt')::timestamptz,NEW.created_at),to_jsonb(NEW))
+  ON CONFLICT(id) DO NOTHING;
+ END IF;
+ RETURN NEW;
+END $$;
+CREATE TRIGGER instruction_revision_application AFTER INSERT OR UPDATE OF applied ON instruction_promotions
+ FOR EACH ROW EXECUTE FUNCTION record_instruction_revision_application();
+INSERT INTO experiment_applications(id,user_id,experiment_id,action,status,target,applied_at,evidence)
+ SELECT p.id,p.user_id,(SELECT e.id FROM experiments e WHERE e.user_id=p.user_id AND e.analysis->>'promotionId'=p.id::text LIMIT 1),'instruction_revision','applied','instruction:'||coalesce(p.instruction_id,p.eval_target_id),coalesce((p.gates->>'appliedAt')::timestamptz,p.created_at),to_jsonb(p)
+ FROM instruction_promotions p WHERE p.applied;
+COMMIT;

package/dist/supabase/migrations/00244_experiment_history_completion.sql

@@ -0,0 +1,32 @@
+BEGIN;
+-- Runs written before queue identities existed remain separately inspectable.
+-- Do not import receipts already represented by a study or queue experiment.
+INSERT INTO experiments(id,user_id,executor,name,eval_target_id,project_path,protocol,protocol_hash,status,analysis,result,created_at,finalized_at,legacy_evidence)
+ SELECT r.id,t.user_id,'historical',t.name||' / '||e.name,t.id,t.project_path,
+ jsonb_build_object('version',1,'configuration',r.configuration,'targetVersion',r.eval_target_version),
+ encode(sha256(r.id::text::bytea),'hex'),CASE WHEN r.status='completed' THEN 'completed' ELSE 'failed' END,
+ jsonb_build_object('grading',r.grading,'outputs',r.outputs,'timing',r.timing),
+ jsonb_build_object('version',1,'primaryMetric',NULL,'metrics','[]'::jsonb,'validity','unassessed',
+  'explanation','Historical execution receipt; no inferential comparison was recorded.',
+  'observed',1,'planned',NULL,'applicationAllowed',false),coalesce(r.created_at,now()),coalesce(r.created_at,now()),
+ jsonb_build_object('source','eval-run','id',r.id,'record',to_jsonb(r))
+ FROM eval_runs r JOIN eval_targets t ON t.id=r.eval_target_id JOIN evals e ON e.id=r.eval_id
+ WHERE NOT EXISTS(SELECT 1 FROM eval_jobs j WHERE j.id=r.job_id AND j.experiment_id IS NOT NULL)
+ AND NOT EXISTS(SELECT 1 FROM experiments x WHERE x.id::text=r.outputs->'study'->>'studyId');
+
+-- Retired producers cannot leave perpetual running entries. Their original
+-- state and results are already preserved verbatim in legacy_evidence.
+UPDATE experiments SET status='cancelled',finalized_at=coalesce(finalized_at,now()),result=jsonb_build_object(
+ 'version',1,'primaryMetric',NULL,'metrics','[]'::jsonb,'validity','unassessed',
+ 'explanation','Historical producer retired before completion. No new calls were made.',
+ 'observed',0,'planned',NULL,'applicationAllowed',false)
+ WHERE executor='historical' AND status IN ('ready','queued','running') AND result IS NULL;
+
+-- Ordinary session randomization is retired. Repository delivery policies are
+-- stopped too: their canonical experiment owns per-task enrollment and delivery.
+ALTER TABLE instruction_experiments DROP CONSTRAINT instruction_experiments_stopped_reason_check;
+ALTER TABLE instruction_experiments ADD CONSTRAINT instruction_experiments_stopped_reason_check CHECK (stopped_reason IN (
+ 'graduated','trial_neutral','trial_inconclusive','content_changed','inactive_project','invalid_template','delivery_refused','scoped_live_confirmation','canonical_experiments'));
+UPDATE instruction_experiments SET status='stopped',stopped_reason='canonical_experiments'
+ WHERE status='running';
+COMMIT;

package/dist/supabase/migrations/00245_experiment_fixture_guards.sql

@@ -0,0 +1,20 @@
+BEGIN;
+ALTER TABLE experiments ADD CONSTRAINT experiment_fixture_version CHECK(executor<>'fixture' OR (protocol ? 'version' AND protocol->>'version'='1'));
+ALTER TABLE experiments ADD CONSTRAINT experiment_fixture_finalization CHECK(executor<>'fixture' OR ((analysis IS NULL)=(finalized_at IS NULL)));
+CREATE FUNCTION admit_experiment() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+ IF NEW.executor<>'historical' AND (NEW.result IS NOT NULL OR NEW.analysis IS NOT NULL OR NEW.finalized_at IS NOT NULL) THEN
+  RAISE EXCEPTION 'Experiments must be registered before finalization';
+ END IF;
+ RETURN NEW;
+END $$;
+CREATE TRIGGER experiment_admission BEFORE INSERT ON experiments FOR EACH ROW EXECUTE FUNCTION admit_experiment();
+CREATE FUNCTION preserve_experiment_final_state() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+ IF OLD.result IS NOT NULL AND (NEW.status IS DISTINCT FROM OLD.status OR NEW.finalized_at IS DISTINCT FROM OLD.finalized_at) THEN
+  RAISE EXCEPTION 'Final experiment execution state is immutable';
+ END IF;
+ RETURN NEW;
+END $$;
+CREATE TRIGGER experiment_final_state BEFORE UPDATE ON experiments FOR EACH ROW EXECUTE FUNCTION preserve_experiment_final_state();
+COMMIT;

package/dist/supabase/migrations/00246_experiment_target_retention.sql

@@ -0,0 +1,5 @@
+BEGIN;
+-- An experiment owns its frozen inputs and remains meaningful after a mutable
+-- test target is deleted. Retain the original target ID as historical identity.
+ALTER TABLE experiments DROP CONSTRAINT performance_studies_eval_target_id_fkey;
+COMMIT;

package/dist/supabase/migrations/00247_historical_experiment_receipts.sql

@@ -0,0 +1,89 @@
+BEGIN;
+-- Materialize existing raw receipts, without recomputing historical findings or
+-- granting eligibility to old labels. Only migration imports may bypass finalization.
+ALTER TABLE experiment_observations DISABLE TRIGGER experiment_observation_admission;
+
+WITH receipts AS (
+ SELECT e.id AS experiment_id,'eval-run:'||r.id AS identity,
+   CASE WHEN r.configuration IN ('without_target','baseline','with_prior_version') THEN 'baseline' ELSE 'treatment' END AS arm,
+   to_jsonb(r) AS record, 1 AS priority
+ FROM eval_runs r JOIN eval_targets t ON t.id=r.eval_target_id
+ LEFT JOIN eval_jobs j ON j.id=r.job_id AND j.user_id=t.user_id
+ JOIN experiments e ON e.user_id=t.user_id AND e.legacy_evidence IS NOT NULL
+   AND e.id::text=coalesce(r.outputs->'study'->>'studyId',j.experiment_id::text,r.id::text)
+ UNION ALL
+ -- Snapshot receipts survive even when their original execution rows were pruned.
+ SELECT e.id,'eval-run:'||(r->>'id'),
+   CASE WHEN r->>'configuration' IN ('without_target','baseline','with_prior_version') THEN 'baseline' ELSE 'treatment' END,r,0
+ FROM experiments e CROSS JOIN LATERAL jsonb_array_elements(
+   CASE WHEN jsonb_typeof(e.legacy_evidence->'runs')='array' THEN e.legacy_evidence->'runs' ELSE '[]'::jsonb END) r
+ WHERE r->>'id' IS NOT NULL
+ UNION ALL
+ SELECT e.id,'eval-run:'||(e.legacy_evidence->'record'->>'id'),
+   CASE WHEN e.legacy_evidence->'record'->>'configuration' IN ('without_target','baseline','with_prior_version') THEN 'baseline' ELSE 'treatment' END,
+   e.legacy_evidence->'record',0
+ FROM experiments e WHERE e.legacy_evidence->>'source'='eval-run' AND e.legacy_evidence->'record'->>'id' IS NOT NULL
+ UNION ALL
+ SELECT e.id,'assignment:'||(a->>'id'),CASE WHEN a->>'arm'='treated' THEN 'treatment' ELSE 'baseline' END,a,0
+ FROM experiments e CROSS JOIN LATERAL jsonb_array_elements(
+   CASE WHEN jsonb_typeof(e.legacy_evidence->'assignments')='array' THEN e.legacy_evidence->'assignments' ELSE '[]'::jsonb END) a
+ WHERE a->>'id' IS NOT NULL
+ UNION ALL
+ SELECT e.id,'assignment:'||a.id,CASE WHEN a.arm='treated' THEN 'treatment' ELSE 'baseline' END,to_jsonb(a),1
+ FROM experiments e JOIN scoped_live_confirmation_assignments a ON a.confirmation_id=e.id AND a.user_id=e.user_id
+ WHERE e.legacy_evidence IS NOT NULL
+ UNION ALL
+ SELECT e.id,'session-assignment:'||a.id,CASE WHEN a.arm='treated' THEN 'treatment' ELSE 'baseline' END,to_jsonb(a),1
+ FROM experiments e JOIN instruction_experiment_arms a ON a.experiment_id=e.id AND a.user_id=e.user_id
+ WHERE e.legacy_evidence->>'source'='live' AND e.executor='historical'
+ UNION ALL
+ SELECT e.id,'worker-observation:'||o.ordinality,CASE WHEN o.value->>'arm'='baseline' THEN 'baseline' ELSE 'treatment' END,o.value,0
+ FROM experiments e CROSS JOIN LATERAL jsonb_array_elements(
+   CASE WHEN jsonb_typeof(e.legacy_evidence->'record'->'result'->'observations')='array'
+     THEN e.legacy_evidence->'record'->'result'->'observations' ELSE '[]'::jsonb END) WITH ORDINALITY o
+ UNION ALL
+ SELECT e.id,'memory-pair:'||p.ordinality,arm.value,p.value,0
+ FROM experiments e CROSS JOIN LATERAL jsonb_array_elements(
+   CASE WHEN jsonb_typeof(e.legacy_evidence->'record'->'result'->'pairs')='array'
+     THEN e.legacy_evidence->'record'->'result'->'pairs' ELSE '[]'::jsonb END) WITH ORDINALITY p
+ CROSS JOIN (VALUES ('baseline'),('treatment')) arm(value)
+ WHERE e.legacy_evidence->>'source'='memory'
+), deduplicated AS (
+ SELECT DISTINCT ON (experiment_id,identity,arm) * FROM receipts
+ -- Prefer the frozen snapshot if the retained execution row later changed.
+ ORDER BY experiment_id,identity,arm,priority
+)
+INSERT INTO experiment_observations(experiment_id,task_id,arm,repetition,metrics,eligibility,exclusion,evidence)
+ SELECT experiment_id,'historical:'||identity,arm,1,'{}'::jsonb,'excluded',
+   'Historical raw receipt; eligibility was not re-adjudicated during migration.',
+   jsonb_build_object('historical',true,'sourceIdentity',identity,'record',record)
+ FROM deduplicated
+ ON CONFLICT(experiment_id,task_id,arm,repetition) DO NOTHING;
+
+ALTER TABLE experiment_observations ENABLE TRIGGER experiment_observation_admission;
+-- Restoration is an inverse action tied to the original receipt, not another
+-- experimental revision. Preserve the original evidence and do not guess links.
+CREATE OR REPLACE FUNCTION record_instruction_revision_application() RETURNS trigger LANGUAGE plpgsql AS $$
+DECLARE experiment_id uuid;
+BEGIN
+ IF NEW.applied THEN
+  SELECT e.id INTO experiment_id FROM experiments e
+   WHERE e.user_id=NEW.user_id AND e.analysis->>'promotionId'=NEW.id::text LIMIT 1;
+  IF experiment_id IS NULL AND NEW.decision='revert' THEN
+   SELECT a.experiment_id INTO experiment_id FROM experiment_applications a
+    WHERE a.user_id=NEW.user_id AND a.action='instruction_revision' AND a.evidence->>'decision'='promote'
+      AND a.id::text=NEW.gates->>'restoredPromotionId';
+  END IF;
+  INSERT INTO experiment_applications(id,user_id,experiment_id,action,status,target,applied_at,evidence)
+  VALUES(NEW.id,NEW.user_id,experiment_id,'instruction_revision',CASE WHEN NEW.decision='revert' THEN 'reverted' ELSE 'applied' END,
+   'instruction:'||coalesce(NEW.instruction_id,NEW.eval_target_id),coalesce((NEW.gates->>'appliedAt')::timestamptz,NEW.created_at),to_jsonb(NEW))
+  ON CONFLICT(id) DO NOTHING;
+ END IF;
+ RETURN NEW;
+END $$;
+UPDATE experiment_applications a SET status='reverted',experiment_id=coalesce(a.experiment_id,(
+ SELECT prior.experiment_id FROM experiment_applications prior
+ WHERE prior.user_id=a.user_id AND prior.action='instruction_revision' AND prior.evidence->>'decision'='promote'
+  AND prior.id::text=a.evidence->'gates'->>'restoredPromotionId'))
+ WHERE a.action='instruction_revision' AND a.status='applied' AND a.evidence->>'decision'='revert';
+COMMIT;

package/dist/supabase/migrations/00248_bounded_study_repairs.sql

@@ -0,0 +1,5 @@
+-- A repair is another paid actor call within the same task observation.
+-- Existing protocols retain exactly one attempt. Old workers are fenced at claim.
+ALTER TABLE public.performance_study_calls ADD COLUMN attempt integer NOT NULL DEFAULT 1 CHECK (attempt BETWEEN 1 AND 2);
+ALTER TABLE public.performance_study_calls DROP CONSTRAINT performance_study_calls_study_id_task_id_arm_repetition_key;
+ALTER TABLE public.performance_study_calls ADD CONSTRAINT performance_study_calls_attempt_unique UNIQUE(study_id,task_id,arm,repetition,attempt);

package/dist/supabase/migrations/00249_archive_unsupported_study_protocols.sql

@@ -0,0 +1,17 @@
+BEGIN;
+-- Some pre-cutover deployments contain version-2 studies despite the repository's
+-- version-1 registration contract. They remain inspectable history, never a new
+-- executable fixture protocol. Preserve every original byte and finding.
+-- During a 00245 refusal on this history, apply this repair before retrying 00245.
+ALTER TABLE experiments DISABLE TRIGGER experiment_immutable;
+UPDATE experiments SET executor='historical'
+ WHERE executor='fixture' AND legacy_evidence->>'source'='study'
+   AND (NOT (protocol ? 'version') OR protocol->>'version' IS DISTINCT FROM '1');
+ALTER TABLE experiments ENABLE TRIGGER experiment_immutable;
+
+CREATE OR REPLACE VIEW performance_studies AS
+ SELECT id,user_id,eval_target_id,project_path,protocol,protocol_hash,
+   analysis AS result,finalized_at,created_at FROM experiments
+ WHERE executor='fixture' OR (executor='historical' AND legacy_evidence->>'source'='study');
+ALTER VIEW performance_studies SET (security_invoker=true);
+COMMIT;