From df2ce2a7abc0361ecabb4d1a8334ac60d50084bb Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 6 Jun 2026 04:00:23 +0000 Subject: [PATCH 1/3] WIP: codex --- .../workflow/manual_corpus_eval_expected.dag | 117 ++++++++++++++++-- 1 file changed, 107 insertions(+), 10 deletions(-) diff --git a/src/v4/test/claim/workflow/manual_corpus_eval_expected.dag b/src/v4/test/claim/workflow/manual_corpus_eval_expected.dag index a40733dec07..3ae0010624f 100644 --- a/src/v4/test/claim/workflow/manual_corpus_eval_expected.dag +++ b/src/v4/test/claim/workflow/manual_corpus_eval_expected.dag @@ -1,5 +1,5 @@ // src/v4/test/claim/workflow/manual_corpus_eval_expected.dag -// Scope: T-38 tracked-expectation pins for the manual corpus roster (verdict arm + primary reason). +// Scope: T-38 asymmetric tracked-expectation pins for the manual corpus roster (verdict arm + primary reason). // Status: drift gate authority — host transport mirrors `manual_corpus_eval_expected_pins` + // `manual_corpus_eval_host_run_specs` (single authority; no parallel bash claim-list). // HostRejected CDV rows: transport observes `corpus_eval_cdv_host_rejection_stderr_marker` @@ -68,8 +68,16 @@ type CorpusEvalExpectedObservation | HostRejected +// PinnedRed is a provisional known-bad row. MustPass is the ratcheted, locked state: once a +// row improves, its pin changes to MustPass and the gate only accepts an ExecutedPass result. +type CorpusEvalPinStatus + = PinnedRed + | MustPass + + type CorpusEvalExpectedPin { claim_id: Symbol + status: CorpusEvalPinStatus observation: CorpusEvalExpectedObservation primary_reason: Symbol dissolution_target: Symbol @@ -116,30 +124,35 @@ data manual_corpus_eval_host_run_specs: List = [ data manual_corpus_eval_expected_pins: List = [ CorpusEvalExpectedPin { claim_id: claim_eval_mvp2_test_claim_route, + status: PinnedRed, observation: ExecutedFail, primary_reason: eval_rejected_invalid_node, dissolution_target: dissolution_target_transform_eval }, CorpusEvalExpectedPin { claim_id: claim_parallelism_data_dependency_run_test_claim_receipt, + status: PinnedRed, observation: HostRejected, primary_reason: interpreter_classified_dependency_view_non_exhaustive, dissolution_target: dissolution_target_cdv_eager_moth_810 }, CorpusEvalExpectedPin { claim_id: claim_lens_effect_depends_on_runtime_verdict, + status: PinnedRed, observation: HostRejected, primary_reason: interpreter_classified_dependency_view_non_exhaustive, dissolution_target: dissolution_target_cdv_eager_moth_810 }, CorpusEvalExpectedPin { claim_id: claim_rust_language_model_emit_mechanical_reverification, + status: PinnedRed, observation: ExecutedFail, primary_reason: eval_rejected_invalid_node, dissolution_target: dissolution_target_transform_eval }, CorpusEvalExpectedPin { claim_id: claim_rust_language_model_emit_subsumption_reverifies, + status: PinnedRed, observation: ExecutedFail, primary_reason: eval_rejected_type_node, dissolution_target: dissolution_target_subsumption_tree_eval @@ -165,6 +178,7 @@ fn corpus_eval_tracked_expectation_pins_well_formed() -> Bool { corpus_eval_expected_pins_match_host_run_specs() && corpus_eval_expected_pins_match_roster_frontier() && corpus_eval_all_host_specs_have_pins() + && corpus_eval_all_pin_statuses_well_formed() } @@ -211,6 +225,46 @@ fn corpus_eval_all_host_specs_have_pins() -> Bool { } +fn corpus_eval_observation_is_pass( + observation: CorpusEvalExpectedObservation, + reason: Symbol +) -> Bool { + match observation { + ExecutedPass => reason == corpus_eval_verdict_pass_reason + ExecutedFail => false + ExecutedDeferred => false + HostRejected => false + } +} + + +fn corpus_eval_pin_status_well_formed(pin: CorpusEvalExpectedPin) -> Bool { + match pin.status { + MustPass => + corpus_eval_observation_is_pass( + observation: pin.observation, + reason: pin.primary_reason + ) + PinnedRed => + !corpus_eval_observation_is_pass( + observation: pin.observation, + reason: pin.primary_reason + ) + } +} + + +fn corpus_eval_all_pin_statuses_well_formed() -> Bool { + fold_list( + xs: manual_corpus_eval_expected_pins, + empty: true, + cons: fn(acc, pin) { + acc && corpus_eval_pin_status_well_formed(pin: pin) + } + ) +} + + fn corpus_eval_observation_arm_matches( actual: CorpusEvalExpectedObservation, expected: CorpusEvalExpectedObservation @@ -244,7 +298,13 @@ fn corpus_eval_observation_arm_matches( } -fn corpus_eval_observation_matches_pin( +type CorpusEvalPinEvaluation + = CorpusEvalPinMatched + | CorpusEvalPinRatchetForward { dissolution_target: Symbol } + | CorpusEvalPinRegression + + +fn corpus_eval_observation_exactly_matches_pin( actual: CorpusEvalExpectedObservation, actual_reason: Symbol, pin: CorpusEvalExpectedPin @@ -254,39 +314,76 @@ fn corpus_eval_observation_matches_pin( } +fn corpus_eval_evaluate_pin( + actual: CorpusEvalExpectedObservation, + actual_reason: Symbol, + pin: CorpusEvalExpectedPin +) -> CorpusEvalPinEvaluation { + match pin.status { + MustPass => + if corpus_eval_observation_is_pass(observation: actual, reason: actual_reason) { + CorpusEvalPinMatched + } else { + CorpusEvalPinRegression + } + PinnedRed => + if corpus_eval_observation_exactly_matches_pin( + actual: actual, + actual_reason: actual_reason, + pin: pin + ) { + CorpusEvalPinMatched + } else if corpus_eval_observation_is_pass(observation: actual, reason: actual_reason) { + CorpusEvalPinRatchetForward { dissolution_target: pin.dissolution_target } + } else { + CorpusEvalPinRegression + } + } +} + + +fn corpus_eval_pin_evaluation_allows_ci(evaluation: CorpusEvalPinEvaluation) -> Bool { + match evaluation { + CorpusEvalPinMatched => true + CorpusEvalPinRatchetForward { dissolution_target: _ } => true + CorpusEvalPinRegression => false + } +} + + fn corpus_eval_executed_row_runtime_gate( run: TestClaimRun, pin: CorpusEvalExpectedPin ) -> Bool { match run.verdict { Pass => - corpus_eval_observation_matches_pin( + corpus_eval_pin_evaluation_allows_ci(evaluation: corpus_eval_evaluate_pin( actual: ExecutedPass, actual_reason: corpus_eval_verdict_pass_reason, pin: pin - ) + )) Fail { actual: Rejected { diagnostics: ds }, falsification: _ } => - corpus_eval_observation_matches_pin( + corpus_eval_pin_evaluation_allows_ci(evaluation: corpus_eval_evaluate_pin( actual: ExecutedFail, actual_reason: ds.head.reason, pin: pin - ) + )) Deferred { diagnostic: d, actual: _ } => - corpus_eval_observation_matches_pin( + corpus_eval_pin_evaluation_allows_ci(evaluation: corpus_eval_evaluate_pin( actual: ExecutedDeferred, actual_reason: d.reason, pin: pin - ) + )) } } fn corpus_eval_host_rejected_transport_gate(pin: CorpusEvalExpectedPin) -> Bool { - corpus_eval_observation_matches_pin( + corpus_eval_pin_evaluation_allows_ci(evaluation: corpus_eval_evaluate_pin( actual: HostRejected, actual_reason: interpreter_classified_dependency_view_non_exhaustive, pin: pin - ) + )) } From daf6cdbf02f8a1f927144fbc4c62cd3dd7e8b237 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 6 Jun 2026 04:10:37 +0000 Subject: [PATCH 2/3] feat(v4): make corpus eval ratchet asymmetric --- scripts/v4-testclaim-corpus-eval.sh | 102 ++++++++++--- .../workflow/manual_corpus_eval_expected.dag | 140 +++++++++++++++++- .../v4_workflow_ci_runner_dag_smoke_test.rs | 87 +++++++++++ 3 files changed, 306 insertions(+), 23 deletions(-) diff --git a/scripts/v4-testclaim-corpus-eval.sh b/scripts/v4-testclaim-corpus-eval.sh index f5c038cbabc..06ae54ea028 100755 --- a/scripts/v4-testclaim-corpus-eval.sh +++ b/scripts/v4-testclaim-corpus-eval.sh @@ -30,6 +30,32 @@ claim_run() { "$bin" run --source-root src/v4 --entry "$entry" --function "$1" --claim-run } +claim_run_required() { + local gate_fn="$1" ratchet_fn="$2" label="$3" target="$4" + set +e + local out + out="$(claim_run "$gate_fn" 2>&1)" + local ex=$? + set -e + printf '%s\n' "$out" + if [[ "$ex" -eq 0 ]]; then + return 0 + fi + + set +e + local ratchet_out + ratchet_out="$(claim_run "$ratchet_fn" 2>&1)" + local ratchet_ex=$? + set -e + if [[ "$ratchet_ex" -eq 0 ]]; then + printf '%s\n' "$ratchet_out" + echo "::error title=corpus eval ratchet required::row ${label} greened (dissolution_target ${target} achieved); flip its pin PinnedRed->MustPass in src/v4/test/claim/workflow/manual_corpus_eval_expected.dag in this PR to lock the win." >&2 + exit 1 + fi + + return "$ex" +} + dag_string_data() { local name="$1" grep -E "^data ${name}: String = \"" "$root/$entry" \ @@ -37,17 +63,40 @@ dag_string_data() { | head -1 } -transport_run() { +transport_claim_run() { local row_entry="$1" row_fn="$2" set +e local out - out="$("$bin" run --source-root src/v4 --entry "$row_entry" --function "$row_fn" 2>&1)" + out="$("$bin" run --source-root src/v4 --entry "$row_entry" --function "$row_fn" --claim-run 2>&1)" local ex=$? set -e printf '%s' "$out" return "$ex" } +host_rejected_or_transport_pass_required() { + local label="$1" target="$2" row_entry="$3" row_fn="$4" host_gate_fn="$5" pass_gate_fn="$6" pass_ratchet_fn="$7" + set +e + local out + out="$(transport_claim_run "$row_entry" "$row_fn" 2>&1)" + local ex=$? + set -e + printf '%s\n' "$out" + + if [[ "$ex" -eq 0 ]]; then + claim_run_required "$pass_gate_fn" "$pass_ratchet_fn" "$label" "$target" + return 0 + fi + + if grep -Fq "$cdv_host_rejection_marker" <<< "$out"; then + claim_run "$host_gate_fn" + return 0 + fi + + echo "::error title=corpus eval regression::${label} row no longer matched its HostRejected pin and did not produce a passing TestClaimRun." >&2 + return "$ex" +} + cdv_host_rejection_marker="$(dag_string_data corpus_eval_cdv_host_rejection_stderr_marker)" if [[ -z "$cdv_host_rejection_marker" ]]; then echo "error: missing corpus_eval_cdv_host_rejection_stderr_marker in $entry" >&2 @@ -58,28 +107,41 @@ fi claim_run witness_corpus_eval_tracked_expectation_closed # Executed rows: runtime drift gate projects from TestClaimRun via modeled witnesses. -claim_run witness_corpus_eval_row_eval_mvp2_runtime_gate -claim_run witness_corpus_eval_row_mechanical_reverification_runtime_gate -claim_run witness_corpus_eval_row_subsumption_reverifies_runtime_gate +claim_run_required \ + witness_corpus_eval_row_eval_mvp2_runtime_gate \ + witness_corpus_eval_row_eval_mvp2_ratchet_forward \ + claim_eval_mvp2_test_claim_route \ + dissolution_target_transform_eval +claim_run_required \ + witness_corpus_eval_row_mechanical_reverification_runtime_gate \ + witness_corpus_eval_row_mechanical_reverification_ratchet_forward \ + claim_rust_language_model_emit_mechanical_reverification \ + dissolution_target_transform_eval +claim_run_required \ + witness_corpus_eval_row_subsumption_reverifies_runtime_gate \ + witness_corpus_eval_row_subsumption_reverifies_ratchet_forward \ + claim_rust_language_model_emit_subsumption_reverifies \ + dissolution_target_subsumption_tree_eval -# HostRejected rows: transport observes pinned stderr marker; modeled witness gates pin alignment. -out="$(transport_run \ +# HostRejected rows: if the row now produces a passing TestClaimRun, the modeled pass gate forces +# a PinnedRed->MustPass source edit instead of letting the improvement pass silently. +host_rejected_or_transport_pass_required \ + claim_parallelism_data_dependency_run_test_claim_receipt \ + dissolution_target_cdv_eager_moth_810 \ "src/v4/test/claim/lens_parallelism/data_dependency.dag" \ - "run_parallelism_data_dependency_receipt")" || true -if ! grep -Fq "$cdv_host_rejection_marker" <<< "$out"; then - echo "::error title=corpus eval transport::parallelism row expected CDV host rejection (marker from .dag)" >&2 - exit 1 -fi -claim_run witness_corpus_eval_row_parallelism_host_rejected_gate + "run_parallelism_data_dependency_receipt" \ + witness_corpus_eval_row_parallelism_host_rejected_gate \ + witness_corpus_eval_row_parallelism_transport_pass_gate \ + witness_corpus_eval_row_parallelism_transport_pass_ratchet_forward -out="$(transport_run \ +host_rejected_or_transport_pass_required \ + claim_lens_effect_depends_on_runtime_verdict \ + dissolution_target_cdv_eager_moth_810 \ "src/v4/test/claim/lens_effect/effect_depends_on.dag" \ - "run_lens_effect_depends_on_runtime_verdict")" || true -if ! grep -Fq "$cdv_host_rejection_marker" <<< "$out"; then - echo "::error title=corpus eval transport::effect row expected CDV host rejection (marker from .dag)" >&2 - exit 1 -fi -claim_run witness_corpus_eval_row_effect_host_rejected_gate + "run_lens_effect_depends_on_runtime_verdict" \ + witness_corpus_eval_row_effect_host_rejected_gate \ + witness_corpus_eval_row_effect_transport_pass_gate \ + witness_corpus_eval_row_effect_transport_pass_ratchet_forward echo "::notice title=corpus eval tracked-expectation gate::all pinned rows matched (0 drift)" exit 0 diff --git a/src/v4/test/claim/workflow/manual_corpus_eval_expected.dag b/src/v4/test/claim/workflow/manual_corpus_eval_expected.dag index 3ae0010624f..2aa59f3f54b 100644 --- a/src/v4/test/claim/workflow/manual_corpus_eval_expected.dag +++ b/src/v4/test/claim/workflow/manual_corpus_eval_expected.dag @@ -245,11 +245,13 @@ fn corpus_eval_pin_status_well_formed(pin: CorpusEvalExpectedPin) -> Bool { observation: pin.observation, reason: pin.primary_reason ) - PinnedRed => - !corpus_eval_observation_is_pass( + PinnedRed => match corpus_eval_observation_is_pass( observation: pin.observation, reason: pin.primary_reason - ) + ) { + true => false + false => true + } } } @@ -345,12 +347,60 @@ fn corpus_eval_evaluate_pin( fn corpus_eval_pin_evaluation_allows_ci(evaluation: CorpusEvalPinEvaluation) -> Bool { match evaluation { CorpusEvalPinMatched => true + CorpusEvalPinRatchetForward { dissolution_target: _ } => false + CorpusEvalPinRegression => false + } +} + + +fn corpus_eval_pin_evaluation_is_ratchet_forward(evaluation: CorpusEvalPinEvaluation) -> Bool { + match evaluation { CorpusEvalPinRatchetForward { dissolution_target: _ } => true + CorpusEvalPinMatched => false CorpusEvalPinRegression => false } } +fn corpus_eval_observation_ratchet_forward_for_claim( + actual: CorpusEvalExpectedObservation, + actual_reason: Symbol, + claim_id: Symbol +) -> Bool { + match corpus_eval_expected_pin_lookup(claim_id: claim_id) { + CorpusEvalPinLookupFound { pin: pin } => + corpus_eval_pin_evaluation_is_ratchet_forward(evaluation: corpus_eval_evaluate_pin( + actual: actual, + actual_reason: actual_reason, + pin: pin + )) + CorpusEvalPinLookupMissing => false + } +} + + +fn corpus_eval_transport_pass_gate_for_claim(claim_id: Symbol) -> Bool { + match corpus_eval_expected_pin_lookup(claim_id: claim_id) { + CorpusEvalPinLookupFound { pin: pin } => + corpus_eval_pin_evaluation_allows_ci(evaluation: corpus_eval_evaluate_pin( + actual: ExecutedPass, + actual_reason: corpus_eval_verdict_pass_reason, + pin: pin + )) + CorpusEvalPinLookupMissing => false + } +} + + +fn corpus_eval_transport_pass_ratchet_forward_for_claim(claim_id: Symbol) -> Bool { + corpus_eval_observation_ratchet_forward_for_claim( + actual: ExecutedPass, + actual_reason: corpus_eval_verdict_pass_reason, + claim_id: claim_id + ) +} + + fn corpus_eval_executed_row_runtime_gate( run: TestClaimRun, pin: CorpusEvalExpectedPin @@ -378,6 +428,33 @@ fn corpus_eval_executed_row_runtime_gate( } +fn corpus_eval_executed_row_ratchet_forward( + run: TestClaimRun, + pin: CorpusEvalExpectedPin +) -> Bool { + match run.verdict { + Pass => + corpus_eval_pin_evaluation_is_ratchet_forward(evaluation: corpus_eval_evaluate_pin( + actual: ExecutedPass, + actual_reason: corpus_eval_verdict_pass_reason, + pin: pin + )) + Fail { actual: Rejected { diagnostics: ds }, falsification: _ } => + corpus_eval_pin_evaluation_is_ratchet_forward(evaluation: corpus_eval_evaluate_pin( + actual: ExecutedFail, + actual_reason: ds.head.reason, + pin: pin + )) + Deferred { diagnostic: d, actual: _ } => + corpus_eval_pin_evaluation_is_ratchet_forward(evaluation: corpus_eval_evaluate_pin( + actual: ExecutedDeferred, + actual_reason: d.reason, + pin: pin + )) + } +} + + fn corpus_eval_host_rejected_transport_gate(pin: CorpusEvalExpectedPin) -> Bool { corpus_eval_pin_evaluation_allows_ci(evaluation: corpus_eval_evaluate_pin( actual: HostRejected, @@ -399,6 +476,18 @@ fn corpus_eval_executed_row_runtime_gate_for_claim( } +fn corpus_eval_executed_row_ratchet_forward_for_claim( + run: TestClaimRun, + claim_id: Symbol +) -> Bool { + match corpus_eval_expected_pin_lookup(claim_id: claim_id) { + CorpusEvalPinLookupFound { pin: pin } => + corpus_eval_executed_row_ratchet_forward(run: run, pin: pin) + CorpusEvalPinLookupMissing => false + } +} + + fn corpus_eval_host_rejected_transport_gate_for_claim(claim_id: Symbol) -> Bool { match corpus_eval_expected_pin_lookup(claim_id: claim_id) { CorpusEvalPinLookupFound { pin: pin } => @@ -447,3 +536,48 @@ fn witness_corpus_eval_row_effect_host_rejected_gate() -> Bool { claim_id: claim_lens_effect_depends_on_runtime_verdict ) } + +fn witness_corpus_eval_row_eval_mvp2_ratchet_forward() -> Bool { + corpus_eval_executed_row_ratchet_forward_for_claim( + run: run_eval_mvp2_test_claim_route, + claim_id: claim_eval_mvp2_test_claim_route + ) +} + +fn witness_corpus_eval_row_mechanical_reverification_ratchet_forward() -> Bool { + corpus_eval_executed_row_ratchet_forward_for_claim( + run: run_rust_language_model_emit_mechanical_reverification_claim, + claim_id: claim_rust_language_model_emit_mechanical_reverification + ) +} + +fn witness_corpus_eval_row_subsumption_reverifies_ratchet_forward() -> Bool { + corpus_eval_executed_row_ratchet_forward_for_claim( + run: run_rust_language_model_emit_subsumption_reverifies, + claim_id: claim_rust_language_model_emit_subsumption_reverifies + ) +} + +fn witness_corpus_eval_row_parallelism_transport_pass_gate() -> Bool { + corpus_eval_transport_pass_gate_for_claim( + claim_id: claim_parallelism_data_dependency_run_test_claim_receipt + ) +} + +fn witness_corpus_eval_row_parallelism_transport_pass_ratchet_forward() -> Bool { + corpus_eval_transport_pass_ratchet_forward_for_claim( + claim_id: claim_parallelism_data_dependency_run_test_claim_receipt + ) +} + +fn witness_corpus_eval_row_effect_transport_pass_gate() -> Bool { + corpus_eval_transport_pass_gate_for_claim( + claim_id: claim_lens_effect_depends_on_runtime_verdict + ) +} + +fn witness_corpus_eval_row_effect_transport_pass_ratchet_forward() -> Bool { + corpus_eval_transport_pass_ratchet_forward_for_claim( + claim_id: claim_lens_effect_depends_on_runtime_verdict + ) +} diff --git a/tools/ci_workflow_ratchet/tests/v4_workflow_ci_runner_dag_smoke_test.rs b/tools/ci_workflow_ratchet/tests/v4_workflow_ci_runner_dag_smoke_test.rs index 4442c4e2379..a521a79abc7 100644 --- a/tools/ci_workflow_ratchet/tests/v4_workflow_ci_runner_dag_smoke_test.rs +++ b/tools/ci_workflow_ratchet/tests/v4_workflow_ci_runner_dag_smoke_test.rs @@ -94,6 +94,9 @@ const SHARED_CLOSURE_WORKSHEET_PATH: &str = "docs/planning/v4-ci-rust-dag-shared-closure-worksheet-2026-06-01.md"; const M1_RUST_EMIT_PROBE_SCRIPT: &str = include_str!("../../../.github/ci-floor/v4-m1-rust-emit-probe.sh"); +const TESTCLAIM_CORPUS_EVAL_SCRIPT: &str = + include_str!("../../../scripts/v4-testclaim-corpus-eval.sh"); +const TESTCLAIM_CORPUS_EVAL_SCRIPT_PATH: &str = "scripts/v4-testclaim-corpus-eval.sh"; const T15_SELF_HOST_STEP_NAME: &str = "T-15 self-host fixed-point harness (stage1==stage2)"; const CLAIM_DAG: &str = include_str!("../../../src/v4/test/claim/workflow/affected_set_ci_runner.dag"); @@ -104,6 +107,10 @@ const WAVE3_ROSTER_PATH: &str = "src/v4/test/claim/workflow/wave3_shadow_roster. const TESTCLAIM_CORPUS_RUNNER_DAG: &str = include_str!("../../../src/v4/test/claim/workflow/testclaim_corpus_runner.dag"); const TESTCLAIM_CORPUS_RUNNER_PATH: &str = "src/v4/test/claim/workflow/testclaim_corpus_runner.dag"; +const MANUAL_CORPUS_EVAL_EXPECTED_DAG: &str = + include_str!("../../../src/v4/test/claim/workflow/manual_corpus_eval_expected.dag"); +const MANUAL_CORPUS_EVAL_EXPECTED_PATH: &str = + "src/v4/test/claim/workflow/manual_corpus_eval_expected.dag"; const MANUAL_CORPUS_ROSTER_DAG: &str = include_str!("../../../src/v4/test/claim/manual/manual_corpus_roster.dag"); const MANUAL_CORPUS_ROSTER_PATH: &str = "src/v4/test/claim/manual/manual_corpus_roster.dag"; @@ -1148,6 +1155,86 @@ fn v4_workflow_ci_testclaim_corpus_eval_modeled_and_bound_to_ci_yml() { ); } +#[test] +fn v4_workflow_ci_testclaim_corpus_eval_ratchet_is_asymmetric_and_modeled() { + let _module = parse_module( + MANUAL_CORPUS_EVAL_EXPECTED_DAG, + MANUAL_CORPUS_EVAL_EXPECTED_PATH, + ); + assert!( + MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("type CorpusEvalPinStatus") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("= PinnedRed") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("| MustPass"), + "{MANUAL_CORPUS_EVAL_EXPECTED_PATH}: corpus eval pins must model provisional-red vs ratcheted must-pass state" + ); + assert!( + MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("type CorpusEvalPinEvaluation") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG + .contains("| CorpusEvalPinRatchetForward { dissolution_target: Symbol }") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("| CorpusEvalPinRegression"), + "{MANUAL_CORPUS_EVAL_EXPECTED_PATH}: gate must classify ratchet-forward separately from regression" + ); + assert!( + MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("fn corpus_eval_pin_status_well_formed") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("MustPass =>") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("corpus_eval_verdict_pass_reason") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG + .contains("PinnedRed => match corpus_eval_observation_is_pass") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("true => false") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("false => true"), + "{MANUAL_CORPUS_EVAL_EXPECTED_PATH}: MustPass pins must be locked to ExecutedPass/pass-reason and PinnedRed pins must stay non-pass" + ); + assert_eq!( + MANUAL_CORPUS_EVAL_EXPECTED_DAG + .matches("status: PinnedRed") + .count(), + 5, + "{MANUAL_CORPUS_EVAL_EXPECTED_PATH}: current 0/5 corpus baseline must keep all five rows provisional-red" + ); + assert!( + !MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("status: MustPass"), + "{MANUAL_CORPUS_EVAL_EXPECTED_PATH}: no row is green yet; first green must land as an explicit pin-table ratchet" + ); + assert!( + MANUAL_CORPUS_EVAL_EXPECTED_DAG + .contains("CorpusEvalPinRatchetForward { dissolution_target: pin.dissolution_target }") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG + .contains("CorpusEvalPinRatchetForward { dissolution_target: _ } => false") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("CorpusEvalPinRegression => false"), + "{MANUAL_CORPUS_EVAL_EXPECTED_PATH}: a PinnedRed pass must flow through modeled ratchet-forward state and fail until the pin is locked; regression also fails hard" + ); + assert!( + MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("fn corpus_eval_executed_row_ratchet_forward(") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("Fail { actual: Rejected") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG.contains("Deferred { diagnostic: d"), + "{MANUAL_CORPUS_EVAL_EXPECTED_PATH}: executed-row ratchet prompts must inspect the actual TestClaimRun, not assume every gate failure is a pass" + ); + assert!( + MANUAL_CORPUS_EVAL_EXPECTED_DAG + .contains("fn witness_corpus_eval_row_parallelism_transport_pass_ratchet_forward") + && MANUAL_CORPUS_EVAL_EXPECTED_DAG + .contains("fn witness_corpus_eval_row_effect_transport_pass_ratchet_forward"), + "{MANUAL_CORPUS_EVAL_EXPECTED_PATH}: CDV HostRejected rows need modeled transport-pass ratchet witnesses for the first green" + ); + assert!( + CI_YML.contains("bash scripts/v4-testclaim-corpus-eval.sh"), + "{CI_YML_PATH}: corpus eval transport must stay in the existing script; no ci.yml/carrier cascade for this ratchet" + ); + for needle in [ + "claim_run_required()", + "host_rejected_or_transport_pass_required()", + "flip its pin PinnedRed->MustPass", + "witness_corpus_eval_row_parallelism_transport_pass_ratchet_forward", + "witness_corpus_eval_row_effect_transport_pass_ratchet_forward", + "--claim-run", + ] { + assert!( + TESTCLAIM_CORPUS_EVAL_SCRIPT.contains(needle), + "{TESTCLAIM_CORPUS_EVAL_SCRIPT_PATH}: thin transport must surface modeled ratchet outcome `{needle}`" + ); + } +} + #[test] fn v4_workflow_ci_bootstrap_gate_skip_policy_is_modeled() { let module = parse_module(CI_DAG, CI_DAG_PATH); From 9abe14aea161ce9e1428acbcbfe673ed9b8ea654 Mon Sep 17 00:00:00 2001 From: Brian Searls Date: Sat, 6 Jun 2026 04:34:52 +0000 Subject: [PATCH 3/3] WIP: codex --- scripts/v4-testclaim-corpus-eval.sh | 14 +++++++------- .../tests/v4_workflow_ci_runner_dag_smoke_test.rs | 7 +++++++ 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/scripts/v4-testclaim-corpus-eval.sh b/scripts/v4-testclaim-corpus-eval.sh index 06ae54ea028..bf7b687bab9 100755 --- a/scripts/v4-testclaim-corpus-eval.sh +++ b/scripts/v4-testclaim-corpus-eval.sh @@ -63,11 +63,11 @@ dag_string_data() { | head -1 } -transport_claim_run() { +transport_run() { local row_entry="$1" row_fn="$2" set +e local out - out="$("$bin" run --source-root src/v4 --entry "$row_entry" --function "$row_fn" --claim-run 2>&1)" + out="$("$bin" run --source-root src/v4 --entry "$row_entry" --function "$row_fn" 2>&1)" local ex=$? set -e printf '%s' "$out" @@ -78,18 +78,18 @@ host_rejected_or_transport_pass_required() { local label="$1" target="$2" row_entry="$3" row_fn="$4" host_gate_fn="$5" pass_gate_fn="$6" pass_ratchet_fn="$7" set +e local out - out="$(transport_claim_run "$row_entry" "$row_fn" 2>&1)" + out="$(transport_run "$row_entry" "$row_fn" 2>&1)" local ex=$? set -e printf '%s\n' "$out" - if [[ "$ex" -eq 0 ]]; then - claim_run_required "$pass_gate_fn" "$pass_ratchet_fn" "$label" "$target" + if grep -Fq "$cdv_host_rejection_marker" <<< "$out"; then + claim_run "$host_gate_fn" return 0 fi - if grep -Fq "$cdv_host_rejection_marker" <<< "$out"; then - claim_run "$host_gate_fn" + if grep -Fq "TestClaimRun { verdict: Pass" <<< "$out"; then + claim_run_required "$pass_gate_fn" "$pass_ratchet_fn" "$label" "$target" return 0 fi diff --git a/tools/ci_workflow_ratchet/tests/v4_workflow_ci_runner_dag_smoke_test.rs b/tools/ci_workflow_ratchet/tests/v4_workflow_ci_runner_dag_smoke_test.rs index a521a79abc7..595cf96cb12 100644 --- a/tools/ci_workflow_ratchet/tests/v4_workflow_ci_runner_dag_smoke_test.rs +++ b/tools/ci_workflow_ratchet/tests/v4_workflow_ci_runner_dag_smoke_test.rs @@ -1224,6 +1224,7 @@ fn v4_workflow_ci_testclaim_corpus_eval_ratchet_is_asymmetric_and_modeled() { "claim_run_required()", "host_rejected_or_transport_pass_required()", "flip its pin PinnedRed->MustPass", + "TestClaimRun { verdict: Pass", "witness_corpus_eval_row_parallelism_transport_pass_ratchet_forward", "witness_corpus_eval_row_effect_transport_pass_ratchet_forward", "--claim-run", @@ -1233,6 +1234,12 @@ fn v4_workflow_ci_testclaim_corpus_eval_ratchet_is_asymmetric_and_modeled() { "{TESTCLAIM_CORPUS_EVAL_SCRIPT_PATH}: thin transport must surface modeled ratchet outcome `{needle}`" ); } + assert!( + TESTCLAIM_CORPUS_EVAL_SCRIPT.contains( + "out=\"$(\"$bin\" run --source-root src/v4 --entry \"$row_entry\" --function \"$row_fn\" 2>&1)\"" + ), + "{TESTCLAIM_CORPUS_EVAL_SCRIPT_PATH}: TestClaimRun row transport must not use --claim-run; row functions return TestClaimRun, not Bool" + ); } #[test]