Falsifier execution topology

dag/gunbc/doc_graph_roots.dag

@@ -5,6 +5,7 @@ import gunbc.ci_layer_roots { compile_clean_source_roots }
 import gunbc.plan { Plan, plan_path, plan_doc_path, DissolutionTrigger, HasTrigger }
 import gunbc.plan_registry { all_plans }
 import v2.lens.module_graph { module_declaration_facts_live }
+import v2.lens.doc_reachability { doc_graph_clean_holds, doc_graph_orphan_clean_holds }
 import v2.std.algebra { filter, list_flat_map }
 import v2.std.decl_index { decl_facts }
 import v2.std.decl_ref_resolution { declaration_ref_resolves }
@@ -190,6 +191,16 @@ data hand_authored_doc_binds: List<HandAuthoredDocBind> = [
     ],
     dissolution: HasTrigger { text: "v0 lands on fleet with shadow comparison and branch-protection cutover per the design sequence, the scaffold dissolve-on items complete (REST bridge, runtime state carriers, subject_key and run_id grammar), and ci_control_plane self-emits or the plan registers — then surviving policy migrates to DESIGN or a registered gunbc.plan.Plan row and this bind deletes with the doc." },
   },
+  HandAuthoredDocBind {
+    home: PlanDoc,
+    slug: "spark-standup-program-accounting",
+    primary_work: DeclarationRef { module_path: "gunbc.plans.fleet_subsumption_manual_gaps", decl_name: "fleet_subsumption_manual_gaps_plan", field: WholeDeclaration },
+    additional_works: [
+      DeclarationRef { module_path: "gunbc.dgx_spark_procurement", decl_name: "dgx_spark_arrival_standing", field: WholeDeclaration },
+      DeclarationRef { module_path: "gunbc.dgx_spark_procurement", decl_name: "dgx_spark_router_bindings", field: WholeDeclaration },
+    ],
+    dissolution: HasTrigger { text: "the Spark standup lanes are carried as registered rows rather than by this note — the manual-gap items reach zero and srv5/srv6 are enrolled with their arrival obligations modeled where that arrival lives, at which point the accounting has no facts of its own and this bind deletes with the doc." },
+  },
   HandAuthoredDocBind {
     home: PlanDoc,
     slug: "floor-prep-tax-program",
@@ -640,6 +651,14 @@ fn doc_graph_roots_all() -> List<String> {
   concat(plan_doc_graph_roots(), hand_authored_doc_graph_roots())
 }
 
+fn doc_graph_floor_orphan_clean_holds() -> Bool {
+  doc_graph_orphan_clean_holds(plan_roots: doc_graph_roots_all())
+}
+
+fn doc_graph_floor_clean_holds() -> Bool {
+  doc_graph_clean_holds(plan_roots: doc_graph_roots_all())
+}
+
 fn hand_authored_plan_slug_is_unregistered(b: HandAuthoredDocBind) -> Bool {
   match b.home {
     PlanDoc => all(all_plans, p => p.slug != b.slug)

dag/gunbc/falsifier_cold_corpus_execution.dag

@@ -0,0 +1,234 @@
+module gunbc.falsifier_cold_corpus_execution
+
+import std.types { String, Bool }
+import gunbc.floor_component_receipt {
+  floor_component_receipt_path,
+  floor_component_receipt_schema,
+  floor_component_receipt_artifact_name,
+}
+
+data falsifier_cold_corpus_execution_note: String = "NARROW CARRIER (operator ruling proud-bear-834 msg_4657b662, adhoc-8b992195-d13; receipt-backed correction msg_bc390264): whether the falsifier cold corpus EXECUTED, distinct from whether witnesses inside it produced verdicts. CorpusExecuted is emitted only when the floor-component receipt artifact is present and parses — never inferred from a job status code alone (a cold-corpus failure before upload used to read as corpus-executed, which is fabricated plausible output). A generic workflow failure must NEVER be read as evidence the falsifier found a regression; CorpusNotRun arms name infrastructure, not witness redness. The four-job split is pre-authorized in gunbc.falsifier_run_control falsifier_control_prerequisite_note."
+
+data falsifier_cold_corpus_execution_receipt_path: String = "target/falsifier-cold-corpus-execution.json"
+
+data falsifier_cold_corpus_execution_schema: String = "falsifier-cold-corpus-execution/v1"
+
+data falsifier_cold_corpus_job_id: String = "cold-corpus"
+
+type GithubJobOutcome
+  = JobOutcomeSuccess
+  | JobOutcomeFailure
+  | JobOutcomeCancelled
+  | JobOutcomeSkipped
+  | JobOutcomeUnknown { raw: String }
+
+fn github_job_outcome_from_result(result: String) -> GithubJobOutcome {
+  if result == "success" {
+    JobOutcomeSuccess
+  } else if result == "failure" {
+    JobOutcomeFailure
+  } else if result == "cancelled" {
+    JobOutcomeCancelled
+  } else if result == "skipped" {
+    JobOutcomeSkipped
+  } else {
+    JobOutcomeUnknown { raw: result }
+  }
+}
+
+type CorpusNotRunCause
+  = BuildJobFailed
+  | BuildJobCancelled
+  | BuildJobSkipped
+  | ColdCorpusJobCancelled
+  | ColdCorpusJobSkipped { blocking_job: String }
+  | ColdCorpusReceiptArtifactAbsent
+  | ColdCorpusFailedBeforeReceipt
+  | ReleaseArtifactsUnavailable
+  | EnvironmentUnavailable { detail: String }
+
+type ColdCorpusExecution
+  = CorpusExecuted { receipt_path: String }
+  | CorpusNotRun { cause: CorpusNotRunCause }
+
+fn classify_cold_corpus_execution(
+  build: GithubJobOutcome,
+  cold: GithubJobOutcome,
+  floor_receipt_present: Bool
+) -> ColdCorpusExecution {
+  match build {
+    JobOutcomeSuccess =>
+      match cold {
+        JobOutcomeCancelled => CorpusNotRun { cause: ColdCorpusJobCancelled }
+        JobOutcomeSkipped => CorpusNotRun { cause: ColdCorpusJobSkipped { blocking_job: falsifier_cold_corpus_job_id } }
+        JobOutcomeUnknown { raw: detail } => CorpusNotRun { cause: EnvironmentUnavailable { detail: detail } }
+        JobOutcomeSuccess =>
+          if floor_receipt_present {
+            CorpusExecuted { receipt_path: floor_component_receipt_path }
+          } else {
+            CorpusNotRun { cause: ColdCorpusReceiptArtifactAbsent }
+          }
+        JobOutcomeFailure =>
+          if floor_receipt_present {
+            CorpusExecuted { receipt_path: floor_component_receipt_path }
+          } else {
+            CorpusNotRun { cause: ColdCorpusFailedBeforeReceipt }
+          }
+      }
+    JobOutcomeFailure => CorpusNotRun { cause: BuildJobFailed }
+    JobOutcomeCancelled => CorpusNotRun { cause: BuildJobCancelled }
+    JobOutcomeSkipped => CorpusNotRun { cause: BuildJobSkipped }
+    JobOutcomeUnknown { raw: detail } => CorpusNotRun { cause: EnvironmentUnavailable { detail: detail } }
+  }
+}
+
+fn cold_corpus_execution_is_executed(c: ColdCorpusExecution) -> Bool {
+  match c {
+    CorpusExecuted { receipt_path: _ } => true
+    CorpusNotRun { cause: _ } => false
+  }
+}
+
+data corpus_executed_tag: String = "corpus-executed"
+
+data corpus_not_run_tag: String = "corpus-not-run"
+
+fn cold_corpus_execution_tag(c: ColdCorpusExecution) -> String {
+  match c {
+    CorpusExecuted { receipt_path: _ } => corpus_executed_tag
+    CorpusNotRun { cause: _ } => corpus_not_run_tag
+  }
+}
+
+data corpus_not_run_build_failed_tag: String = "build-job-failed"
+
+data corpus_not_run_build_cancelled_tag: String = "build-job-cancelled"
+
+data corpus_not_run_build_skipped_tag: String = "build-job-skipped"
+
+data corpus_not_run_cold_cancelled_tag: String = "cold-corpus-job-cancelled"
+
+data corpus_not_run_cold_skipped_tag: String = "cold-corpus-job-skipped"
+
+data corpus_not_run_cold_receipt_artifact_absent_tag: String = "cold-corpus-receipt-artifact-absent"
+
+data corpus_not_run_cold_failed_before_receipt_tag: String = "cold-corpus-failed-before-receipt"
+
+data corpus_not_run_release_artifacts_tag: String = "release-artifacts-unavailable"
+
+data corpus_not_run_environment_tag: String = "environment-unavailable"
+
+fn corpus_not_run_cause_tag(cause: CorpusNotRunCause) -> String {
+  match cause {
+    BuildJobFailed => corpus_not_run_build_failed_tag
+    BuildJobCancelled => corpus_not_run_build_cancelled_tag
+    BuildJobSkipped => corpus_not_run_build_skipped_tag
+    ColdCorpusJobCancelled => corpus_not_run_cold_cancelled_tag
+    ColdCorpusJobSkipped { blocking_job: _ } => corpus_not_run_cold_skipped_tag
+    ColdCorpusReceiptArtifactAbsent => corpus_not_run_cold_receipt_artifact_absent_tag
+    ColdCorpusFailedBeforeReceipt => corpus_not_run_cold_failed_before_receipt_tag
+    ReleaseArtifactsUnavailable => corpus_not_run_release_artifacts_tag
+    EnvironmentUnavailable { detail: _ } => corpus_not_run_environment_tag
+  }
+}
+
+fn cold_corpus_execution_receipt_json(c: ColdCorpusExecution) -> String {
+  match c {
+    CorpusExecuted { receipt_path: path } =>
+      concat(
+        concat("{\"schema\":\"", concat(falsifier_cold_corpus_execution_schema, "\",")),
+        concat(
+          concat("\"execution\":\"", concat(corpus_executed_tag, "\",")),
+          concat(concat("\"receipt_path\":\"", concat(path, "\"}")), "")
+        )
+      )
+    CorpusNotRun { cause: cause } =>
+      match cause {
+        EnvironmentUnavailable { detail: detail } =>
+          concat(
+            concat("{\"schema\":\"", concat(falsifier_cold_corpus_execution_schema, "\",")),
+            concat(
+              concat(concat("\"execution\":\"", concat(corpus_not_run_tag, "\",")), concat("\"cause\":\"", concat(corpus_not_run_environment_tag, "\","))),
+              concat(concat("\"detail\":\"", concat(detail, "\"}")), "")
+            )
+          )
+        ColdCorpusJobSkipped { blocking_job: job } =>
+          concat(
+            concat("{\"schema\":\"", concat(falsifier_cold_corpus_execution_schema, "\",")),
+            concat(
+              concat(concat("\"execution\":\"", concat(corpus_not_run_tag, "\",")), concat("\"cause\":\"", concat(corpus_not_run_cold_skipped_tag, "\","))),
+              concat(concat("\"blocking_job\":\"", concat(job, "\"}")), "")
+            )
+          )
+        _ =>
+          concat(
+            concat("{\"schema\":\"", concat(falsifier_cold_corpus_execution_schema, "\",")),
+            concat(
+              concat(concat("\"execution\":\"", concat(corpus_not_run_tag, "\",")), concat("\"cause\":\"", concat(corpus_not_run_cause_tag(cause: cause), "\"}"))),
+              ""
+            )
+          )
+      }
+  }
+}
+
+fn cadence_verdict_should_fail(
+  build: GithubJobOutcome,
+  selection: GithubJobOutcome,
+  cold: GithubJobOutcome,
+  floor_receipt_present: Bool
+) -> Bool {
+  match classify_cold_corpus_execution(build: build, cold: cold, floor_receipt_present: floor_receipt_present) {
+    CorpusNotRun { cause: _ } => true
+    CorpusExecuted { receipt_path: _ } =>
+      selection != JobOutcomeSuccess || cold != JobOutcomeSuccess
+  }
+}
+
+fn aggregate_shell_receipt_build_failed() -> String {
+  cold_corpus_execution_receipt_json(
+    c: classify_cold_corpus_execution(build: JobOutcomeFailure, cold: JobOutcomeSkipped, floor_receipt_present: false)
+  )
+}
+
+fn aggregate_shell_receipt_build_cancelled() -> String {
+  cold_corpus_execution_receipt_json(
+    c: classify_cold_corpus_execution(build: JobOutcomeCancelled, cold: JobOutcomeSkipped, floor_receipt_present: false)
+  )
+}
+
+fn aggregate_shell_receipt_build_skipped() -> String {
+  cold_corpus_execution_receipt_json(
+    c: classify_cold_corpus_execution(build: JobOutcomeSkipped, cold: JobOutcomeSkipped, floor_receipt_present: false)
+  )
+}
+
+fn aggregate_shell_receipt_cold_skipped() -> String {
+  cold_corpus_execution_receipt_json(
+    c: classify_cold_corpus_execution(build: JobOutcomeSuccess, cold: JobOutcomeSkipped, floor_receipt_present: false)
+  )
+}
+
+fn aggregate_shell_receipt_cold_cancelled() -> String {
+  cold_corpus_execution_receipt_json(
+    c: classify_cold_corpus_execution(build: JobOutcomeSuccess, cold: JobOutcomeCancelled, floor_receipt_present: false)
+  )
+}
+
+fn aggregate_shell_receipt_cold_receipt_artifact_absent() -> String {
+  cold_corpus_execution_receipt_json(
+    c: classify_cold_corpus_execution(build: JobOutcomeSuccess, cold: JobOutcomeSuccess, floor_receipt_present: false)
+  )
+}
+
+fn aggregate_shell_receipt_cold_failed_before_receipt() -> String {
+  cold_corpus_execution_receipt_json(
+    c: classify_cold_corpus_execution(build: JobOutcomeSuccess, cold: JobOutcomeFailure, floor_receipt_present: false)
+  )
+}
+
+fn aggregate_shell_receipt_corpus_executed() -> String {
+  cold_corpus_execution_receipt_json(
+    c: classify_cold_corpus_execution(build: JobOutcomeSuccess, cold: JobOutcomeFailure, floor_receipt_present: true)
+  )
+}