Skip to content

feat: plan kernel spike, engine-neutral conformance suite, and the plan laws in Agda (ADR-0003, proposed) - #76

Open
hyperpolymath wants to merge 16 commits into
mainfrom
claude/focused-noether-wjagpv
Open

hyperpolymath wants to merge 16 commits into
mainfrom
claude/focused-noether-wjagpv

Conversation

@hyperpolymath

@hyperpolymath hyperpolymath commented Nov 17, 2026 •

Copy link
Copy Markdown
Owner

Summary

Scaffoldia's first executable engine code, the test suite any future engine is judged by, and the CI check that runs it. It does not select an engine (ADR-0002's gate stands) and does not tie anything to rsr-template-repo's mint scripts.

The idea, proposed as ADR-0003: split an untrusted planner (any language; composes a plan) from a small trusted kernel (checks a plan is safe, applies it, refuses anything it cannot show safe). A minimal engine is the kernel plus published plans; the composer is a planner on top of the same kernel. That is the "one system at two sizes" the owner asked for on 2026-11-17.

Partly addresses #70 (does not close it).

One owner step is needed before this can merge. The required check E2E — smoke no longer exists (see "CI gate" below). In the branch ruleset for hyperpolymath/scaffoldia, replace the required status check E2E — smoke with Conformance L0. Until then this pull request, and every other one, waits on a check that no longer reports.

Changes

  • docs/decisions/0003-plan-kernel-tiers-and-conformance.adoc — proposed ADR. Records the owner decisions of 2026-11-17 (the hybrid automation router is the kernel's long-run home, consumed as a pinned module; deed for declarations and I-JSON/JCS for plans; Scaffoldia's first retrofit is itself; no separate control-plane repo; toolchains derived from the deed; the CI gate is conformance levels) and four open questions the proofs and spike raised.
  • verification/conformance/ — specification of plan format v0.1, the command-line protocol and a closed list of refusal codes; run.sh (engine-neutral runner); 47 L0 kernel cases with a generator; three deliberately wrong kernels and selftest.sh, which fails if the suite passes any of them; check-l0.sh, the one command list behind both just conformance and CI.
  • verification/conformance/backlog/cases-from-mint-defects.jsonl — 72 engine-neutral cases derived from real mint defects (rsr-template-repo #200, #201, #203, #205, #211, #269, #280, #309). Data only; most need a planner and are not runnable yet.
  • src/kernel/ — Rust workspace. plan-kernel is the pure core (no dependencies, #[forbid(unsafe_code)], no I/O, nothing Scaffoldia-specific so it can move to the router). scaffoldia-kernel is the thin binary (check, instantiate, apply).
  • verification/proofs/agda/PlanLaws/ — nine Agda modules stating and proving the plan-composition laws; scripts/check-plan-laws.sh and six negative controls.
  • docs/status/PROOF-STATUS.adoc, docs/status/ROADMAP.adoc, build/just/ recipes (just conformance, just kernel-check, just proof-check-plan-laws).

One law in the first draft of the ADR was wrong and is corrected here: a join of two individually safe plans is not always a safe plan (one pack writes README.adoc, another readme.adoc). The proof gives the exact condition, and the consequence for the kernel is that plan-level safety must be re-checked after composing.

CI gate (owner decision, 2026-11-17). E2E — smoke ran tests/e2e.sh, the unmodified template harness. It needs idris2 and zig, which the job never installed, so it failed on main and on every pull request; and it builds the inherited Idris/Zig scaffold that the README and ADR-0002 say not to rely on. The owner chose to retire "E2E" as a concept until Scaffoldia can mint something end to end, and to name the required check after the highest conformance level the engine passes.

  • .github/workflows/e2e.yml (file name kept): one job, Conformance L0, which runs verification/conformance/check-l0.sh. The checkout uses: line is unchanged and no action was added. The paths: filter on pull_request is removed, because a required check skipped by a path filter never reports. A block of commented-out template examples was deleted.
  • tests/e2e.sh: kept, with a header saying it is not run by CI and is not a merge gate. Whether the Idris2/Zig seam stays is the open P0 item in the roadmap.
  • Justfile: just test now runs the conformance suite (it ran idris2 and zig and failed for anyone without them); test-all no longer includes the old harness.
  • docs/status/ROADMAP.adoc, docs/status/TEST-NEEDS.adoc, docs/architecture/TOPOLOGY.adoc, verification/conformance/README.adoc: corrected so nothing presents the old harness as a gate.

RSR Quality Checklist

Required

  • Tests pass for what this PR adds (see Testing). The repo's own just validate fails identically before and after this PR.
  • Code is formatted (cargo fmt --check clean)
  • Linter is clean (cargo clippy --all-targets -- -D warnings, shellcheck)
  • No banned language patterns. Note: this template line still says "no npm/bun", which is out of date; Bun is the estate's first-choice runtime.
  • No unsafe blocks
  • No banned functions; no postulate in the Agda cone
  • SPDX headers on new files; no existing header or licence file touched
  • No secrets

As Applicable

  • docs/decisions/ and docs/status/ROADMAP.adoc updated
  • The three .a2ml lines in this template do not apply: A2ML is retired and this PR adds no fact to any .a2ml file (0 touched).

Testing

On GitHub, at the branch head 0aa489a:

  • Conformance L0 passed (run 44140030544, 34 seconds). This is the first run of the new check on a hosted runner.
  • lint-workflows fails, as it does on main (see below). Every other check that ran passed.

Run in the cloud container on the branch head:

  • bash verification/conformance/check-l0.sh (what just conformance and the CI job run) → L0: 47 ok, 0 FAIL, 0 SKIP, then selftest: PASS (3 controls, each failed by the suite at L0).
  • The CI job's run: body, extracted from the workflow with yq and run in a clean clone: exit 0, same summary. With the kernel deliberately broken in that clone (path checks ignored): exit 1, L0: 38 ok, 9 FAIL.
  • cargo test in src/kernel → 22 passed (19 core, 3 binary), 0 failed.
  • just proof-check-plan-laws → RESULT: PASS under --safe --without-K --cubical-compatible, Agda 2.7.0.1, no library, no postulate. just proof-check-plan-laws-controls → 6 of 6 controls refused, each for its expected reason.
  • tests/workflows/check-workflow-uses-lock_test.sh and tests/workflows/validate_workflows_test.sh: exit 0 before and after the workflow change.

What is not established:

  • Creusot (with Pearlite contracts) and Verus were not run. Neither could be installed in this environment. src/kernel/plan-kernel/PROOF-PLAN.adoc lists eight properties and marks every one not run. No contract annotations were added.
  • The Agda theorems are ungraded. They check locally, but a grade needs a receipt for a commit on main from CI; the Agda check is not in CI yet (the runner's packaged Agda is older than the version used). Rocq and Lean recheck legs are not done.
  • scripts/check-workflow-uses-lock.sh exits 1 before and after this PR for an unrelated, pre-existing reason (static-analysis-gate.yml uses an action missing from actions.lock). lint-workflows and other required contexts listed in P0: reconcile merged PR #68/#69 follow-ups before claiming readiness #70 are not fixed here.
  • Several just recipes still call idris2 or zig (lint, fmt-check, build, release, test-smoke), so just quality still fails without those tools. That waits on the P0 decision about the seam.
  • The kernel is Unix-only, and a concurrent writer can still race between its check and its write.
  • No planner exists. L1–L3 have no runnable cases.

Screenshots

None.

🤖 Generated with Claude Code

https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD

…formance suite

Refines ADR-0002 without selecting an engine.

- Separates an untrusted planner from a small trusted kernel that checks and
  applies a plan, so the ADR-0002 safety invariants are stated once.
- Two tiers on one plan format: a minimal engine (kernel plus published
  plans) and a composer (planner on top of the same kernel).
- Composition is a partial join that refuses conflicts; lists the laws to
  prove. Nothing is claimed proved.
- Records that hybrid-automation-router's resource-graph/plan meta-model is
  the same model (its 115 tests pass at 0176b7d, run 2026-11-17) and leaves
  the kernel's home and the graph carrier as owner decisions.
- verification/conformance/README.adoc specifies plan format v0.1, the
  command-line protocol, refusal codes, case layout and levels. Its Evidence
  section is empty: no runner, case or engine exists yet.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
Add verification/proofs/agda/PlanLaws/, a self-contained Agda development
(no agda-stdlib, no .agda-lib) of the algebra of plan composition and
application that ADR-0003 "Composition is a join, not an overwrite" lists.

Model: paths and contents abstract with decidable equality; a desired
state is a file with content or absent; a plan is a list read through
lookup (first entry wins), compared by pointwise equality of lookup (≈,
no function extensionality); the join returns a conflict naming a path or
the union; apply overrides a total file system at the paths a plan
mentions. Preconditions are kept out of the algebra and brought back in
PlanLaws.Kernel as a refinement.

Proved: conflict-sound, conflict-complete, join-lub, join-defined-sym,
join-comm, join-assoc with join-assoc-defined (either side defined iff
pairwise compatible), join-idem, join-cong; apply-idem, apply-join,
apply-comm and its converse commute-compatible (apply-comm-iff),
apply-faithful; safe-join (per-path safety) and plan-safe-join with the
counterexample plan-safety-not-preserved (plan-level clash safety is NOT
preserved by join); the total semilattice on outcomes (⊔ᴼ-comm, ⊔ᴼ-assoc,
⊔ᴼ-idem, ⊔ᴼ-unit, ⊔ᴼ-cong); kapply-refines, kapply-refuses,
unique-functional, kapply-idem.

Verified with the upstream Agda 2.7.0.1 release binary:
  cd verification/proofs/agda &&
  agda --safe --without-K --cubical-compatible PlanLaws/All.agda
checks every module with exit 0 and no warning. Import cone: the nine
PlanLaws modules plus Agda.Primitive.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
…ntrols

scripts/check-plan-laws.sh checks verification/proofs/agda/PlanLaws with
the PROOF-POLICY §2.1 invocation on a fresh copy (no stale .agdai), and
fails if agda is absent or not the pinned 2.7.0.1; if any file's first
line is not the canonical OPTIONS pragma or it has any other pragma; on a
hole or trust primitive; on an Agda error or warning; on a postulate in
the first-party import cone (scripts/scan-postulates.sh, copied unchanged
from hyperpolymath/mathesis 770e565, itself adopted from the januskey
reference gate PROOF-POLICY §8.4 names); if the prover-supplied
postulates of the cone differ from the recorded trusted base (the four of
Agda.Primitive, by name and BUILTIN binding); and if any PlanLaws file is
outside the import cone of PlanLaws/All.agda.

--controls runs the negative controls in tests/reject/PlanLaws/Controls
(a false last-writer-wins lemma, a postulated plan-safety law, a
TERMINATING loop, a hole, a --with-K OPTIONS line) plus a generated
orphan module with a postulate; each must be refused for the reason its
EXPECT-REFUSED line names.

New just recipes proof-check-plan-laws and proof-check-plan-laws-controls
run both, and proof-check-all runs them first. *.agdai is ignored.

Verified: `just proof-check-plan-laws` -> RESULT: PASS;
`just proof-check-plan-laws-controls` -> RESULT: PASS (6 of 6 control(s)
refused, each for its expected reason). Meta-checked by hand on a copy:
a valid file placed among the controls makes --controls fail
("ACCEPTED by the gate"), and importing Agda.Builtin.String into the root
makes the gate fail on the trusted base (Char, String). shellcheck clean.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
Add a "Theory claims" section to docs/status/PROOF-STATUS.adoc: one row per
theorem with its statement as proved, file:line, the PROOF-POLICY §5 token
(`proven` for the Agda leg), the PWG and both recheck legs, plus the
invocation, checker, library cone (none), trusted base, equality notions
and model scope that every row shares.

Grade: `ungraded` for every row. PROOF-POLICY §8.2 grants PWG-3 only with
a receipt recording version, library pin, flags and cone, and §8.4 derives
grades from receipts. The check ran on a local commit that is not on main,
so no receipt is recorded; a draft receipt for 35583f1 passes the canon
reader (bun 1-formats/deed/tools/deed_lint.js --proof-receipt-json, standards
58362c24) and derives PWG-3 for all 19 claims, so the missing piece is a
receipt for the commit as it lands on main. Rocq and Lean legs: open.

Also: replace "Overall: 0% proven" with a census (§8.4 forbids
percentages); record the §6 deviation (Agda 2.7.0.1 from the upstream
release archive, digests given, no Guix in the session, no CI lane yet);
note the Creusot/Pearlite and Verus obligation for a future Rust kernel;
add the remaining legs and the receipt to "Proofs Remaining"; list the new
recipes; show PlanLaws/ in verification/proofs/README.adoc.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
Law 2 said:

  . a join of safe plans is safe;

It now says:

  . every path of a join of safe plans is safe, but the join is a safe plan
    only when no path of one plan clashes with a path of the other
    (case-fold collision or directory prefix), so the kernel checks
    plan-level safety again on the composed plan;

Why: plan format v0.1 ("Safe paths") defines a safe plan by per-path
conditions and by two plan-level conditions (no case-fold collision, no
proper directory prefix). Per-path safety is preserved by join
(PlanLaws/Safety.agda safe-join-ok). Plan-level safety is not:
plan-safety-not-preserved proves that two one-entry plans at clashing safe
paths are each plan-safe, are compatible, and join to a plan that is not
plan-safe, and PlanLaws/Example.agda instantiates it with README.adoc and
readme.adoc. plan-safe-join proves the exact condition: for plan-safe p
and q with a defined join, the join is plan-safe iff no path of p clashes
with a path of q. Checked with `just proof-check-plan-laws` (Agda 2.7.0.1,
--safe --without-K --cubical-compatible): RESULT: PASS.

Laws 1, 3 and 4 hold as worded and are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
verification/conformance/run.sh implements the runner the conformance
README describes: --kernel "<cmd>" [--planner "<cmd>"] [--level L0..L3]
[--cases DIR]. For each case at or below the level it copies the inputs
and before/ into a fresh sandbox and runs the case's kind (check,
instantiate, apply, apply-twice, plan).

Assertions: exit 0 / 10 / other (= crash = fail); for a refusal, the
stdout object's `refused` equals the expected code, the output is JCS,
the target is byte-identical (files, links, directories, exec bits) and
no receipt or instantiated plan is written; for success, the tree equals
expected/ exactly, the receipt is JCS with the plan digest and the plan's
paths, and apply-twice leaves the tree identical with only
unchanged/already-absent. Every case also asserts nothing was written in
the sandbox outside the target (sibling "outside" directory, inputs,
engine cwd), so path escapes are caught even when they land elsewhere.

One line per case (ok/FAIL/SKIP + id + reason), totals per level; exit 1
on any FAIL or any SKIP at or below the level, 2 when it cannot run
(including when no case is found). Planner cases without --planner are
SKIP. Commands are split with `read -a` (no eval, no globbing).

Verified: shellcheck 0.9.0 reports nothing on run.sh.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
cases/kernel/L0/<id>/ holds case.json (JCS, naming principle and
source), plan.json, blobs/sha256/<hex>, answers.json, before/ and
expected/ as each kind needs. gen-cases.sh (Bash + jq + coreutils)
derives every blob hash, plan serialisation and case.json, and
`gen-cases.sh --check` regenerates into a temporary directory and diffs
against the committed fixtures (generate-and-diff).

Coverage: ok cases mint-minimal, apply-twice-idempotent,
already-realised, update-expected-content, delete-already-absent,
mode-755, check-open-plan, instantiate-two-holes, child-identity (the
publisher's name appears nowhere in the child). Refusals: MALFORMED x4
(not JSON, not JCS, missing field, unknown member), PLAN_VERSION,
SOURCE_UNPINNED x2, PATH_UNSAFE x9 (.., absolute, backslash, empty
segment, .git, .GIT, control char, non-NFC, and via check),
PATH_DUPLICATE x2, PATH_COLLISION x2, BLOB_MISSING, BLOB_MISMATCH,
OPEN_PLAN, HOLE_UNFILLED, HOLE_UNKNOWN, RESIDUE, PRECONDITION x6
(including all-or-nothing on the last op and an ancestor that is a
file), TARGET_SYMLINK x2 (ancestor, leaf), TARGET_INVALID x2.

cases/.gitattributes sets `-text` so git never rewrites fixture bytes.

Verified: `gen-cases.sh --check` reports the committed cases match;
`ijson-jcs check` passes every .json except the two deliberately
non-canonical plan.json fixtures (malformed-not-json, malformed-not-jcs);
shellcheck reports nothing on gen-cases.sh.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
controls/ holds deliberately wrong kernels; selftest.sh runs the suite
against each and fails if any of them passes (or if the runner cannot
run on one), listing the cases that caught each control.

- naive-kernel.sh: writes every operation with no check at all.
- no-atomicity-kernel.sh: checks the plan carefully (JCS, version,
  shape, pins, holes, paths with an ASCII-only stand-in for NFC, order,
  collisions, blobs) but checks the target op by op and writes as it
  goes. Its only intended defect is the missing check-then-write phase.
- refuse-all-kernel.sh: refuses everything, so "never writes" cannot
  pass for "safe".

Verified: `selftest.sh` exits 0 at L0 with this output summary:
naive-kernel.sh caught by 39 of 45 cases; no-atomicity-kernel.sh caught
by 2 of 45 (all-or-nothing, target-symlink: both leave the first write
behind); refuse-all-kernel.sh caught by 41 of 45. shellcheck reports
nothing on selftest.sh and controls/*.sh.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
src/kernel/ is a Cargo workspace (the root allowlist has no Cargo.toml,
and src/ is the allowed source tree):

- plan-kernel (library): the pure decision core. No dependency beyond
  std, #![forbid(unsafe_code)], no I/O. JSON value + RFC 8785 canonical
  serialiser (number-free; plan v0.1 has no numbers), closed-world plan
  well-formedness and pins, safe paths, order/uniqueness/case-fold and
  prefix collisions, blob integrity, the refuse-or-exact-effects
  decision over lstat observations, instantiate (single-pass
  substitution, residue), receipt, and an in-memory target model.
  SHA-256 and NFC are injected via the Prims trait. Neutral names only:
  it is the candidate for HAR's planned har-il (see its README).
- scaffoldia-kernel (binary): the I/O edge. check / instantiate /
  apply per the conformance README; exit 0 / 10 (refusal JCS on stdout)
  / 1 (I/O) / 2 (usage). Never follows links: lstat observation, all ops
  decided before the first write, directories created one component at
  a time with re-checks, writes via O_CREAT|O_EXCL temp file + rename.
  Dependencies: serde_json 1.0.154, sha2 0.10.9, unicode-normalization
  0.1.26 (pinned by the committed Cargo.lock).

PROOF-PLAN.adoc names Creusot (Pearlite contracts) and Verus, the
functions and properties (containment, uniqueness, pins, all-or-nothing,
precondition soundness, idempotence, no residue, canonical form); every
row is `not run`: the Verus release download got HTTP 403 through the
session proxy, and the Creusot driver is not on crates.io.

Verified: `cargo test` 22 passed (19 core incl. fixed-seed property
tests for apply∘apply = apply, all-or-nothing and permutation-then-sort,
3 edge); `cargo clippy --all-targets -- -D warnings` clean; `cargo fmt
--check` clean; `verification/conformance/run.sh --level L0 --kernel
src/kernel/target/release/scaffoldia-kernel` gives 45 ok, 0 FAIL,
0 SKIP. Toolchain: rustc/cargo 1.97.0.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
The example under 'Plan format v0.1' presents a JCS-serialised plan
(line breaks aside) but listed the write op's members as expect, mode,
op, path, blob, source. JCS sorts members by UTF-16 code units, so blob
comes first. Reordered; no other change.

Verified: the reordered member order equals the order jq -cS and the
kernel's canonical serialiser emit for the same op (see
cases/kernel/L0/mint-minimal/plan.json).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
Adds to "Case layout": expect.results, expect.tree_excludes and target
(additive fields the L0 cases use), that a missing before/ or expected/
is an empty tree, how trees are compared (accepted: files, links, exec
bits; refused: also directories), and the sandbox rule that any write
outside the target fails the case. Marked as pending ratification; the
reading choices behind them are listed with the work order's spec
questions, not silently made normative.

Verified: run.sh's validate_case accepts exactly these fields' values
(jq schema in run.sh) and all 45 committed case.json files pass it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
build/just/conformance.just, imported from the Justfile in the same
style as the other build/just/*.just files:

- kernel-build: cargo build --release --locked of src/kernel/.
- kernel-check: cargo test, clippy -D warnings and fmt --check.
- conformance: kernel-build, then gen-cases.sh --check (fixtures match
  their generator), run.sh --level L0 against the release binary, and
  selftest.sh --level L0 (every negative control must fail).

Verified: `just conformance` exits 0 (45 ok, 0 FAIL, 0 SKIP; selftest
PASS, 3 controls); `just kernel-check` exits 0. `just validate` fails
exactly as on the base commit (validate-rsr: licensing/ exhibits
missing; validate-ai-install: 2 issues); outputs compared with diff.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
…case

- residue-from-answer (RESIDUE): an answer whose value is itself a
  token ({"OWNER":"{{REPO}}"}). Substitution is one pass and residue is
  checked on the result, so an answer cannot smuggle template text in.
- instantiate-literal-answer (ok): an answer containing & | \1 $HOME
  backticks "{{ y }}" and / renders byte for byte. Source: the existing
  control in rsr-template-repo tests/e2e/use_template_mint_test.sh,
  listed as SC-T-002 in the T6 engine-neutral mint-defect list.

The other T6 L0 rows describe reference-mint content, answer validation
or source resolution and need a planner or a plan-format change; they
are listed in the work-order report, not forced into kernel cases.

Verified: gen-cases.sh --check matches (47 cases); run.sh --level L0
against the Rust kernel: 47 ok, 0 FAIL, 0 SKIP; selftest PASS, and the
naive and no-atomicity controls are both caught by residue-from-answer
(each substitutes repeatedly, so {{REPO}} inside an answer is expanded
again instead of being refused). shellcheck clean (one intentional
SC2016 suppressed with a reason).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
Evidence section of verification/conformance/README.adoc: the command
(`just conformance`), the commit it ran at (35752ee on wo/KERNEL) and
the observed totals: 47 ok, 0 FAIL, 0 SKIP at L0; selftest PASS with
naive (40/47), no-atomicity (3/47: all-or-nothing, target-symlink,
residue-from-answer) and refuse-all (43/47) controls failed by the
suite. States what is not claimed: no L1-L3 or planner cases, local not
CI, verifiers not run.

docs/status/ROADMAP.adoc: one ticked M0 line saying exactly that; the
existing "prove ... in CI" item stays open.

Verified: the quoted lines are copied from the run's output (exit 0,
from a clean src/kernel/target/).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
…ses as backlog

Owner decisions of 2026-11-17, given through the question selector:
- the plan kernel's long-run home is the hybrid automation router, consumed
  here as a pinned module; the spike crate stands in until then;
- deed for declarations, I-JSON/JCS for plans;
- Scaffoldia's first retrofit is itself (118 .a2ml files, no chora deed);
- no separate control-plane repository (standards#636);
- toolchains derived from the deed's declared languages (standards#698).

Open questions raised by the Agda laws and the kernel spike are listed, not
settled.

verification/conformance/backlog/cases-from-mint-defects.jsonl carries 72
engine-neutral cases derived from rsr-template-repo mint defects (issues
#200, #201, #203, #205, #211, #269, #280, #309) and from ADR-0002's
negatives. They are data: nothing runs them yet. Two were already taken
into the L0 suite.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
@hyperpolymath
hyperpolymath marked this pull request as ready for review November 17, 2026 13:53

Copy link
Copy Markdown
Owner Author

A note on the one red check, so it is not read as caused by this branch.

E2E — smoke fails here the same way it fails on main: the job cannot find idris2 on PATH. That is the defect tracked in #70. This pull request adds no Idris code and does not touch that workflow, so it neither causes nor fixes the failure. Nothing was skipped or disabled to work around it.

What this branch adds is not yet run by CI at all: the L0 conformance suite, the kernel's cargo test, and the Agda plan-law check ran locally only (results are in the PR description and in verification/conformance/README.adoc). Wiring them into a workflow needs new uses: lines and a regenerated actions.lock, which is an owner step.

Automated review did not run on this PR: CodeRabbit skipped it (271 files, most of them case fixtures) and Codex reported its usage limit.


Generated by Claude Code

@hyperpolymath
hyperpolymath enabled auto-merge (squash) November 17, 2026 14:47
Repository owner deleted a comment from chatgpt-codex-connector Bot Nov 17, 2026
Repository owner deleted a comment from chatgpt-codex-connector Bot Nov 17, 2026
Repository owner deleted a comment from coderabbitai Bot Nov 17, 2026
The E2E job ran the inherited Idris2/Zig harness, which needs idris2 and zig
that no runner step provides, so it failed on main and on every pull request,
and it tested an inherited scaffold that the README and ADR-0002 call unproven.

Owner decision 2026-11-17: retire E2E until Scaffoldia can mint end to end; the
required check is the highest conformance level passed, `Conformance L0` today.
e2e.yml (name kept: actions.lock key) now has one job, `Conformance L0`, which
runs verification/conformance/check-l0.sh. `just conformance` calls the same
script, so the command list lives in one place. The pull_request paths filter
is dropped so the required check always reports. No `uses:` line changed.

tests/e2e.sh is kept, marked as not run by CI. `just test` now runs the
conformance suite; `just test-all` no longer lists e2e. Docs that presented
E2E as a gate are corrected; ROADMAP records the owner step (ruleset context
`E2E — smoke` to `Conformance L0`). Not yet run on GitHub.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD
@coderabbitai

coderabbitai Bot commented Nov 17, 2026

Copy link
Copy Markdown
Contributor

Important

Review skipped

Too many files!

This PR contains 276 files, which is 176 over the limit of 100.

To get a review, reduce the PR to 100 files or fewer by splitting it into smaller PRs or changing its base branch.

Upgrade to a paid plan to raise the limit.

This review couldn't start because sufficient usage credits or metered capacity aren't available. Add credits or update usage-based reviews in the billing tab, then retry.

Run configuration

  • Source mode: Auto
  • Repository: Unavailable
  • Branch: Unavailable
  • File: No configuration file from this repository applied
  • Commit: Unavailable
  • Layers: Organization UI
  • Review profile: ASSERTIVE
  • Plan: Advanced
  • Run ID: 868352f6-4e6b-4d8a-9f07-4f038b660166
Commits

Reviewing files that changed from the base of the PR and between 8c833fb and 0aa489a.

Files ignored due to path filters: 1

  • src/kernel/Cargo.lock is excluded by !**/*.lock
Files selected for processing: 276

  • .github/workflows/e2e.yml
  • .gitignore
  • Justfile
  • build/just/conformance.just
  • build/just/proofs.just
  • docs/architecture/TOPOLOGY.adoc
  • docs/decisions/0003-plan-kernel-tiers-and-conformance.adoc
  • docs/status/PROOF-STATUS.adoc
  • docs/status/ROADMAP.adoc
  • docs/status/TEST-NEEDS.adoc
  • scripts/check-plan-laws.sh
  • scripts/scan-postulates.sh
  • src/kernel/Cargo.toml
  • src/kernel/plan-kernel/Cargo.toml
  • src/kernel/plan-kernel/PROOF-PLAN.adoc
  • src/kernel/plan-kernel/README.adoc
  • src/kernel/plan-kernel/src/apply.rs
  • src/kernel/plan-kernel/src/check.rs
  • src/kernel/plan-kernel/src/instantiate.rs
  • src/kernel/plan-kernel/src/json.rs
  • src/kernel/plan-kernel/src/lib.rs
  • src/kernel/plan-kernel/src/model.rs
  • src/kernel/plan-kernel/src/path.rs
  • src/kernel/plan-kernel/src/plan.rs
  • src/kernel/plan-kernel/src/refusal.rs
  • src/kernel/scaffoldia-kernel/Cargo.toml
  • src/kernel/scaffoldia-kernel/src/main.rs
  • tests/e2e.sh
  • tests/reject/PlanLaws/Controls/Hole.agda
  • tests/reject/PlanLaws/Controls/LastWriterWins.agda
  • tests/reject/PlanLaws/Controls/PostulatedSafety.agda
  • tests/reject/PlanLaws/Controls/Terminating.agda
  • tests/reject/PlanLaws/Controls/WithK.agda
  • verification/conformance/README.adoc
  • verification/conformance/backlog/cases-from-mint-defects.jsonl
  • verification/conformance/cases/.gitattributes
  • verification/conformance/cases/kernel/L0/all-or-nothing/before/c.txt
  • verification/conformance/cases/kernel/L0/all-or-nothing/blobs/sha256/480c2336b410f1ad5f8bf1b28944490255804b65350c527787e74ebdd511e3a4
  • verification/conformance/cases/kernel/L0/all-or-nothing/blobs/sha256/5eef8098ed6ec0a16249fc7c12422027fc9fd75b16130cc9382cf09102014796
  • verification/conformance/cases/kernel/L0/all-or-nothing/blobs/sha256/b640e840b19d378660b32fb51ae18d67dccb4a8596a29e7bd72c1b2ae5928f41
  • verification/conformance/cases/kernel/L0/all-or-nothing/case.json
  • verification/conformance/cases/kernel/L0/all-or-nothing/plan.json
  • verification/conformance/cases/kernel/L0/already-realised/before/README.adoc
  • verification/conformance/cases/kernel/L0/already-realised/blobs/sha256/1e25202bfd2f9f6a007fa6c4e19eecbddd9deab440910b457db37d3ed80c5232
  • verification/conformance/cases/kernel/L0/already-realised/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/already-realised/case.json
  • verification/conformance/cases/kernel/L0/already-realised/expected/README.adoc
  • verification/conformance/cases/kernel/L0/already-realised/expected/docs/index.adoc
  • verification/conformance/cases/kernel/L0/already-realised/plan.json
  • verification/conformance/cases/kernel/L0/apply-twice-idempotent/before/keep.txt
  • verification/conformance/cases/kernel/L0/apply-twice-idempotent/before/old.txt
  • verification/conformance/cases/kernel/L0/apply-twice-idempotent/blobs/sha256/1e25202bfd2f9f6a007fa6c4e19eecbddd9deab440910b457db37d3ed80c5232
  • verification/conformance/cases/kernel/L0/apply-twice-idempotent/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/apply-twice-idempotent/blobs/sha256/b4d644d4279594903f1a9911956432d9473041f2984fc6014c14d7402c7d126c
  • verification/conformance/cases/kernel/L0/apply-twice-idempotent/case.json
  • verification/conformance/cases/kernel/L0/apply-twice-idempotent/expected/README.adoc
  • verification/conformance/cases/kernel/L0/apply-twice-idempotent/expected/docs/index.adoc
  • verification/conformance/cases/kernel/L0/apply-twice-idempotent/expected/keep.txt
  • verification/conformance/cases/kernel/L0/apply-twice-idempotent/expected/scripts/run.sh
  • verification/conformance/cases/kernel/L0/apply-twice-idempotent/plan.json
  • verification/conformance/cases/kernel/L0/blob-mismatch/before/keep.txt
  • verification/conformance/cases/kernel/L0/blob-mismatch/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/blob-mismatch/case.json
  • verification/conformance/cases/kernel/L0/blob-mismatch/plan.json
  • verification/conformance/cases/kernel/L0/blob-missing/before/keep.txt
  • verification/conformance/cases/kernel/L0/blob-missing/case.json
  • verification/conformance/cases/kernel/L0/blob-missing/plan.json
  • verification/conformance/cases/kernel/L0/check-open-plan/blobs/sha256/e15d9b36ca091636883b329845f392cd857947239440d90ece452f9683392224
  • verification/conformance/cases/kernel/L0/check-open-plan/case.json
  • verification/conformance/cases/kernel/L0/check-open-plan/plan.json
  • verification/conformance/cases/kernel/L0/check-path-unsafe/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/check-path-unsafe/case.json
  • verification/conformance/cases/kernel/L0/check-path-unsafe/plan.json
  • verification/conformance/cases/kernel/L0/child-identity/answers.json
  • verification/conformance/cases/kernel/L0/child-identity/blobs/sha256/58b98a1e7d6412c4eb648f3ff7ad7d74a032e483ad4d2ddebc6578179b8b83ce
  • verification/conformance/cases/kernel/L0/child-identity/blobs/sha256/7bbe8b37e8b5e60e92d8bc5f148fdfe2d39b38a01c2da24b1e37e0eb072cfe40
  • verification/conformance/cases/kernel/L0/child-identity/blobs/sha256/ee02f065782fbe594b6a57d2476228ee492dde41d9642864bf4322db59ff25f1
  • verification/conformance/cases/kernel/L0/child-identity/case.json
  • verification/conformance/cases/kernel/L0/child-identity/expected/README.adoc
  • verification/conformance/cases/kernel/L0/child-identity/expected/docs/ci-note.txt
  • verification/conformance/cases/kernel/L0/child-identity/expected/identity.txt
  • verification/conformance/cases/kernel/L0/child-identity/plan.json
  • verification/conformance/cases/kernel/L0/delete-already-absent/before/keep.txt
  • verification/conformance/cases/kernel/L0/delete-already-absent/case.json
  • verification/conformance/cases/kernel/L0/delete-already-absent/expected/keep.txt
  • verification/conformance/cases/kernel/L0/delete-already-absent/plan.json
  • verification/conformance/cases/kernel/L0/hole-unfilled/answers.json
  • verification/conformance/cases/kernel/L0/hole-unfilled/blobs/sha256/e358d074e66094ccdefcf175658232ae944b02a8917ba374dd85b910cb34bfd9
  • verification/conformance/cases/kernel/L0/hole-unfilled/case.json
  • verification/conformance/cases/kernel/L0/hole-unfilled/plan.json
  • verification/conformance/cases/kernel/L0/hole-unknown/answers.json
  • verification/conformance/cases/kernel/L0/hole-unknown/blobs/sha256/e15d9b36ca091636883b329845f392cd857947239440d90ece452f9683392224
  • verification/conformance/cases/kernel/L0/hole-unknown/case.json
  • verification/conformance/cases/kernel/L0/hole-unknown/plan.json
  • verification/conformance/cases/kernel/L0/instantiate-literal-answer/answers.json
  • verification/conformance/cases/kernel/L0/instantiate-literal-answer/blobs/sha256/e15d9b36ca091636883b329845f392cd857947239440d90ece452f9683392224
  • verification/conformance/cases/kernel/L0/instantiate-literal-answer/case.json
  • verification/conformance/cases/kernel/L0/instantiate-literal-answer/expected/README.adoc
  • verification/conformance/cases/kernel/L0/instantiate-literal-answer/plan.json
  • verification/conformance/cases/kernel/L0/instantiate-two-holes/answers.json
  • verification/conformance/cases/kernel/L0/instantiate-two-holes/blobs/sha256/12ad2faebb473f861430c969e33d43664fa53a1c1602f7b6421e8839910ad336
  • verification/conformance/cases/kernel/L0/instantiate-two-holes/blobs/sha256/1bd8561499d0a3e2518f5e80a676e0370e76cdab67351bef4da77c977b9497f3
  • verification/conformance/cases/kernel/L0/instantiate-two-holes/case.json
  • verification/conformance/cases/kernel/L0/instantiate-two-holes/expected/NOTICE.adoc
  • verification/conformance/cases/kernel/L0/instantiate-two-holes/expected/README.adoc
  • verification/conformance/cases/kernel/L0/instantiate-two-holes/plan.json
  • verification/conformance/cases/kernel/L0/malformed-missing-field/before/keep.txt
  • verification/conformance/cases/kernel/L0/malformed-missing-field/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/malformed-missing-field/case.json
  • verification/conformance/cases/kernel/L0/malformed-missing-field/plan.json
  • verification/conformance/cases/kernel/L0/malformed-not-jcs/before/keep.txt
  • verification/conformance/cases/kernel/L0/malformed-not-jcs/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/malformed-not-jcs/case.json
  • verification/conformance/cases/kernel/L0/malformed-not-jcs/plan.json
  • verification/conformance/cases/kernel/L0/malformed-not-json/before/keep.txt
  • verification/conformance/cases/kernel/L0/malformed-not-json/case.json
  • verification/conformance/cases/kernel/L0/malformed-not-json/plan.json
  • verification/conformance/cases/kernel/L0/malformed-unknown-field/before/README.adoc
  • verification/conformance/cases/kernel/L0/malformed-unknown-field/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/malformed-unknown-field/case.json
  • verification/conformance/cases/kernel/L0/malformed-unknown-field/plan.json
  • verification/conformance/cases/kernel/L0/mint-minimal/blobs/sha256/1e25202bfd2f9f6a007fa6c4e19eecbddd9deab440910b457db37d3ed80c5232
  • verification/conformance/cases/kernel/L0/mint-minimal/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/mint-minimal/case.json
  • verification/conformance/cases/kernel/L0/mint-minimal/expected/README.adoc
  • verification/conformance/cases/kernel/L0/mint-minimal/expected/docs/index.adoc
  • verification/conformance/cases/kernel/L0/mint-minimal/plan.json
  • verification/conformance/cases/kernel/L0/mode-755/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/mode-755/blobs/sha256/b4d644d4279594903f1a9911956432d9473041f2984fc6014c14d7402c7d126c
  • verification/conformance/cases/kernel/L0/mode-755/case.json
  • verification/conformance/cases/kernel/L0/mode-755/expected/README.adoc
  • verification/conformance/cases/kernel/L0/mode-755/expected/bin/tool.sh
  • verification/conformance/cases/kernel/L0/mode-755/plan.json
  • verification/conformance/cases/kernel/L0/open-plan/before/keep.txt
  • verification/conformance/cases/kernel/L0/open-plan/blobs/sha256/e15d9b36ca091636883b329845f392cd857947239440d90ece452f9683392224
  • verification/conformance/cases/kernel/L0/open-plan/case.json
  • verification/conformance/cases/kernel/L0/open-plan/plan.json
  • verification/conformance/cases/kernel/L0/path-collision-case-fold/before/keep.txt
  • verification/conformance/cases/kernel/L0/path-collision-case-fold/blobs/sha256/1e25202bfd2f9f6a007fa6c4e19eecbddd9deab440910b457db37d3ed80c5232
  • verification/conformance/cases/kernel/L0/path-collision-case-fold/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/path-collision-case-fold/case.json
  • verification/conformance/cases/kernel/L0/path-collision-case-fold/plan.json
  • verification/conformance/cases/kernel/L0/path-collision-prefix/before/keep.txt
  • verification/conformance/cases/kernel/L0/path-collision-prefix/blobs/sha256/1e25202bfd2f9f6a007fa6c4e19eecbddd9deab440910b457db37d3ed80c5232
  • verification/conformance/cases/kernel/L0/path-collision-prefix/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/path-collision-prefix/case.json
  • verification/conformance/cases/kernel/L0/path-collision-prefix/plan.json
  • verification/conformance/cases/kernel/L0/path-duplicate/before/keep.txt
  • verification/conformance/cases/kernel/L0/path-duplicate/blobs/sha256/1e25202bfd2f9f6a007fa6c4e19eecbddd9deab440910b457db37d3ed80c5232
  • verification/conformance/cases/kernel/L0/path-duplicate/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/path-duplicate/case.json
  • verification/conformance/cases/kernel/L0/path-duplicate/plan.json
  • verification/conformance/cases/kernel/L0/path-unsafe-absolute/before/keep.txt
  • verification/conformance/cases/kernel/L0/path-unsafe-absolute/blobs/sha256/60f97c7b5bf55c5f186c5d1c79c8e3b6929c83bf2766434df9f1e1b9069db73a
  • verification/conformance/cases/kernel/L0/path-unsafe-absolute/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/path-unsafe-absolute/case.json
  • verification/conformance/cases/kernel/L0/path-unsafe-absolute/plan.json
  • verification/conformance/cases/kernel/L0/path-unsafe-backslash/before/keep.txt
  • verification/conformance/cases/kernel/L0/path-unsafe-backslash/blobs/sha256/60f97c7b5bf55c5f186c5d1c79c8e3b6929c83bf2766434df9f1e1b9069db73a
  • verification/conformance/cases/kernel/L0/path-unsafe-backslash/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/path-unsafe-backslash/case.json
  • verification/conformance/cases/kernel/L0/path-unsafe-backslash/plan.json
  • verification/conformance/cases/kernel/L0/path-unsafe-control-char/before/keep.txt
  • verification/conformance/cases/kernel/L0/path-unsafe-control-char/blobs/sha256/60f97c7b5bf55c5f186c5d1c79c8e3b6929c83bf2766434df9f1e1b9069db73a
  • verification/conformance/cases/kernel/L0/path-unsafe-control-char/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/path-unsafe-control-char/case.json
  • verification/conformance/cases/kernel/L0/path-unsafe-control-char/plan.json
  • verification/conformance/cases/kernel/L0/path-unsafe-dot-git-case/before/keep.txt
  • verification/conformance/cases/kernel/L0/path-unsafe-dot-git-case/blobs/sha256/60f97c7b5bf55c5f186c5d1c79c8e3b6929c83bf2766434df9f1e1b9069db73a
  • verification/conformance/cases/kernel/L0/path-unsafe-dot-git-case/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/path-unsafe-dot-git-case/case.json
  • verification/conformance/cases/kernel/L0/path-unsafe-dot-git-case/plan.json
  • verification/conformance/cases/kernel/L0/path-unsafe-dot-git/before/keep.txt
  • verification/conformance/cases/kernel/L0/path-unsafe-dot-git/blobs/sha256/60f97c7b5bf55c5f186c5d1c79c8e3b6929c83bf2766434df9f1e1b9069db73a
  • verification/conformance/cases/kernel/L0/path-unsafe-dot-git/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/path-unsafe-dot-git/case.json
  • verification/conformance/cases/kernel/L0/path-unsafe-dot-git/plan.json
  • verification/conformance/cases/kernel/L0/path-unsafe-dotdot/before/keep.txt
  • verification/conformance/cases/kernel/L0/path-unsafe-dotdot/blobs/sha256/60f97c7b5bf55c5f186c5d1c79c8e3b6929c83bf2766434df9f1e1b9069db73a
  • verification/conformance/cases/kernel/L0/path-unsafe-dotdot/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/path-unsafe-dotdot/case.json
  • verification/conformance/cases/kernel/L0/path-unsafe-dotdot/plan.json
  • verification/conformance/cases/kernel/L0/path-unsafe-empty-segment/before/keep.txt
  • verification/conformance/cases/kernel/L0/path-unsafe-empty-segment/blobs/sha256/60f97c7b5bf55c5f186c5d1c79c8e3b6929c83bf2766434df9f1e1b9069db73a
  • verification/conformance/cases/kernel/L0/path-unsafe-empty-segment/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/path-unsafe-empty-segment/case.json
  • verification/conformance/cases/kernel/L0/path-unsafe-empty-segment/plan.json
  • verification/conformance/cases/kernel/L0/path-unsafe-non-nfc/before/keep.txt
  • verification/conformance/cases/kernel/L0/path-unsafe-non-nfc/blobs/sha256/60f97c7b5bf55c5f186c5d1c79c8e3b6929c83bf2766434df9f1e1b9069db73a
  • verification/conformance/cases/kernel/L0/path-unsafe-non-nfc/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/path-unsafe-non-nfc/case.json
  • verification/conformance/cases/kernel/L0/path-unsafe-non-nfc/plan.json
  • verification/conformance/cases/kernel/L0/path-unsorted/before/keep.txt
  • verification/conformance/cases/kernel/L0/path-unsorted/blobs/sha256/1e25202bfd2f9f6a007fa6c4e19eecbddd9deab440910b457db37d3ed80c5232
  • verification/conformance/cases/kernel/L0/path-unsorted/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/path-unsorted/case.json
  • verification/conformance/cases/kernel/L0/path-unsorted/plan.json
  • verification/conformance/cases/kernel/L0/plan-version/before/keep.txt
  • verification/conformance/cases/kernel/L0/plan-version/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/plan-version/case.json
  • verification/conformance/cases/kernel/L0/plan-version/plan.json
  • verification/conformance/cases/kernel/L0/precondition-ancestor-file/before/docs
  • verification/conformance/cases/kernel/L0/precondition-ancestor-file/blobs/sha256/1e25202bfd2f9f6a007fa6c4e19eecbddd9deab440910b457db37d3ed80c5232
  • verification/conformance/cases/kernel/L0/precondition-ancestor-file/case.json
  • verification/conformance/cases/kernel/L0/precondition-ancestor-file/plan.json
  • verification/conformance/cases/kernel/L0/precondition-delete-wrong-sha/before/old.txt
  • verification/conformance/cases/kernel/L0/precondition-delete-wrong-sha/case.json
  • verification/conformance/cases/kernel/L0/precondition-delete-wrong-sha/plan.json
  • verification/conformance/cases/kernel/L0/precondition-expect-absent/before/README.adoc
  • verification/conformance/cases/kernel/L0/precondition-expect-absent/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/precondition-expect-absent/case.json
  • verification/conformance/cases/kernel/L0/precondition-expect-absent/plan.json
  • verification/conformance/cases/kernel/L0/precondition-expect-sha-absent/before/keep.txt
  • verification/conformance/cases/kernel/L0/precondition-expect-sha-absent/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/precondition-expect-sha-absent/case.json
  • verification/conformance/cases/kernel/L0/precondition-expect-sha-absent/plan.json
  • verification/conformance/cases/kernel/L0/precondition-expect-sha/before/README.adoc
  • verification/conformance/cases/kernel/L0/precondition-expect-sha/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/precondition-expect-sha/case.json
  • verification/conformance/cases/kernel/L0/precondition-expect-sha/plan.json
  • verification/conformance/cases/kernel/L0/residue-from-answer/answers.json
  • verification/conformance/cases/kernel/L0/residue-from-answer/blobs/sha256/e358d074e66094ccdefcf175658232ae944b02a8917ba374dd85b910cb34bfd9
  • verification/conformance/cases/kernel/L0/residue-from-answer/case.json
  • verification/conformance/cases/kernel/L0/residue-from-answer/plan.json
  • verification/conformance/cases/kernel/L0/residue/answers.json
  • verification/conformance/cases/kernel/L0/residue/blobs/sha256/738d156564c61171c21f6e23bc096973fdd03843e2d66ab19512b2a4383dc673
  • verification/conformance/cases/kernel/L0/residue/blobs/sha256/e15d9b36ca091636883b329845f392cd857947239440d90ece452f9683392224
  • verification/conformance/cases/kernel/L0/residue/case.json
  • verification/conformance/cases/kernel/L0/residue/plan.json
  • verification/conformance/cases/kernel/L0/target-invalid-absent/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/target-invalid-absent/case.json
  • verification/conformance/cases/kernel/L0/target-invalid-absent/plan.json
  • verification/conformance/cases/kernel/L0/target-invalid-file/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/target-invalid-file/case.json
  • verification/conformance/cases/kernel/L0/target-invalid-file/plan.json
  • verification/conformance/cases/kernel/L0/target-symlink-leaf/before/README.adoc
  • verification/conformance/cases/kernel/L0/target-symlink-leaf/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/target-symlink-leaf/case.json
  • verification/conformance/cases/kernel/L0/target-symlink-leaf/plan.json
  • verification/conformance/cases/kernel/L0/target-symlink/before/docs
  • verification/conformance/cases/kernel/L0/target-symlink/blobs/sha256/1e25202bfd2f9f6a007fa6c4e19eecbddd9deab440910b457db37d3ed80c5232
  • verification/conformance/cases/kernel/L0/target-symlink/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/target-symlink/case.json
  • verification/conformance/cases/kernel/L0/target-symlink/plan.json
  • verification/conformance/cases/kernel/L0/unpinned-short-rev/before/keep.txt
  • verification/conformance/cases/kernel/L0/unpinned-short-rev/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/unpinned-short-rev/case.json
  • verification/conformance/cases/kernel/L0/unpinned-short-rev/plan.json
  • verification/conformance/cases/kernel/L0/unpinned-undeclared-input/before/keep.txt
  • verification/conformance/cases/kernel/L0/unpinned-undeclared-input/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/unpinned-undeclared-input/case.json
  • verification/conformance/cases/kernel/L0/unpinned-undeclared-input/plan.json
  • verification/conformance/cases/kernel/L0/update-expected-content/before/README.adoc
  • verification/conformance/cases/kernel/L0/update-expected-content/before/keep.txt
  • verification/conformance/cases/kernel/L0/update-expected-content/blobs/sha256/95469b9aca6b78d8fdd258b0e331da56a1098dc671724bed3be90738ed6198ec
  • verification/conformance/cases/kernel/L0/update-expected-content/case.json
  • verification/conformance/cases/kernel/L0/update-expected-content/expected/README.adoc
  • verification/conformance/cases/kernel/L0/update-expected-content/expected/keep.txt
  • verification/conformance/cases/kernel/L0/update-expected-content/plan.json
  • verification/conformance/check-l0.sh
  • verification/conformance/controls/naive-kernel.sh
  • verification/conformance/controls/no-atomicity-kernel.sh
  • verification/conformance/controls/refuse-all-kernel.sh
  • verification/conformance/gen-cases.sh
  • verification/conformance/run.sh
  • verification/conformance/selftest.sh
  • verification/proofs/README.adoc
  • verification/proofs/agda/PlanLaws/All.agda
  • verification/proofs/agda/PlanLaws/Apply.agda
  • verification/proofs/agda/PlanLaws/Example.agda
  • verification/proofs/agda/PlanLaws/Join.agda
  • verification/proofs/agda/PlanLaws/Kernel.agda
  • verification/proofs/agda/PlanLaws/Plan.agda
  • verification/proofs/agda/PlanLaws/Prelude.agda
  • verification/proofs/agda/PlanLaws/Safety.agda
  • verification/proofs/agda/PlanLaws/Semilattice.agda

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

  • Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

Share

@sonarqubecloud

Copy link
Copy Markdown

Copy link
Copy Markdown
Owner Author

Two notes on the checks after 0aa489a, which replaces the E2E — smoke job with Conformance L0 (owner decision, 2026-11-17). This supersedes my earlier note about E2E — smoke.

lint-workflows is red, and it is not this pull request's. The failing step is bash scripts/check-workflow-uses-lock.sh ., and its only failure is:

FAIL: .github/workflows/static-analysis-gate.yml: actions/upload-artifact@v7.0.2 is missing from actions.lock workflow entries

The latest run on main (8c833fb, run 43728835137) fails on the same step with the same line. .github/workflows/e2e.yml is not named in any failure, and this pull request changes no uses: line. The fix is to regenerate the lock, which is an owner step because the lock is machine-generated and is not edited by hand:

gh actions-lock --no-migrate-local-actions

E2E — smoke will no longer report. If it is still a required status check, this pull request waits on it indefinitely. The owner step: in the branch ruleset for this repository, replace the required status check E2E — smoke with Conformance L0.

Conformance L0 itself: its commands pass locally from a clean clone (47 of 47 cases; three deliberately wrong kernels each caught), and fail when the kernel's path checks are disabled. Its first run on GitHub is what will confirm the runner has what it needs.


Generated by Claude Code

hyperpolymath added a commit to metadatastician/standards that referenced this pull request Nov 17, 2026
…tep (#1665)

## Summary

Follows #1661. The owner's decisions of 2026-11-17 (round three and
four) asked for a live retire-check before any kyX work, then for the
two files it reports deletable to be deleted and the check wired into
CI. This pull request does those three things.

Why a tool first: the measurement in
`docs/triage/2026-11-17/a2ml-measure.adoc` found that 0 of 278 `.a2ml`
files across the measured repos met the three deletion conditions in
`.claude/CLAUDE.md`, and that kyX alone would unblock none. So the list
of what blocks each file has to be recomputed from the tree, not kept by
hand.

## Changes

**The retire-check** (`scripts/a2ml-retire-check.sh`)

- For every tracked `.a2ml` file it recomputes the family, the mapping
spec, the target deeds, the three deletion conditions (facts, lint,
readers) and a closed list of blockers. A file with no blocker is
`deletable-now`.
- Rulings that cannot be read from the tree live in one data file,
`.machine_readable/a2ml-retire-rulings.jsonl` (12 rows), so a ruling
moves files between classes without a code change.
- `--check` is the gate. It fails when a file is deletable and still
present (it prints the `git rm` and the ledger line), when a file fits
no class, when the committed counts
(`.machine_readable/a2ml-retire-counts.json`) differ from the tree, and,
with `--base REV`, when an A2ML path joined since REV. The total can
only fall.
- Documented in `docs/wikis/maintainers/index.adoc`
(`[[a2ml-retire-check]]`), with the deletion recipe.

**The first two deletions** (authorised by the owner through the
selector on 2026-11-17; one commit each)

- `1-formats/sub-specs/cartridges/0.2-AI-MANIFEST.a2ml` and
`docs/wikis/0.2-AI-MANIFEST.a2ml`. Both are directory manifests, dropped
under the ruling "directory manifests are derived, not stored". No tool
read either file.
- Each commit removes the file's line from
`.machine_readable/a2ml-legacy-allow.txt`, adds a row to
`9-archive/A2ML-REMOVED.adoc` (size, sha256, blob id, what it held) and
regenerates the counts. `docs/wikis/README.adoc` no longer tells the
reader to keep the removed file in step.

**The CI step**

- `.github/workflows/self-test.yml`: a `run:` step, "A2ML retire-check",
after "A2ML stays archived", with the pull request's base as `--base`.
No `uses:` line changes, so `actions.lock` is untouched.

**Departures met on the way**

- `Justfile`: `just llm-context <role>` fell back to `cat
0-AI-MANIFEST.a2ml`, a file that no longer exists. It now names
`0-AI-MANIFEST.deed`.
- `0-AI-MANIFEST.deed`: the education-layer route named
`docs/wikis/0.2-AI-MANIFEST.deed`, which has never existed. Removed.
- `.machine_readable/departures.jsonl`: one new row (20 in all) for
`standards_chora.deed`'s `:evidence-source` pointer at `STATE.a2ml`. It
cannot be fixed until the STATE journal is removed (work order W14).

## State after this pull request

165 tracked `.a2ml` files in `standards` (167 before). By class: 80
governed by a ruling that drops them once its condition is met, 78 with
no mapping spec, 3 covered but still read, 4 waiting on kyX, 0 deletable
now, 0 unclassified.

## Testing

Run in the cloud container on the branch head:

- `bash scripts/a2ml-retire-check.sh --check --base origin/main` → `OK
(165 file(s); none deletable now, none unclassified; counts current; no
A2ML path joined since origin/main)`. Before the second deletion the
same command exited 1 and named the remaining file.
- `scripts/tests/a2ml-retire-check-test.sh` → 47 passed, 0 failed
(fixtures for each class and blocker, negative controls, mutants of the
gate).
- `scripts/tests/check-a2ml-archived-test.sh` → 26 passed; `bash
scripts/check-a2ml-archived.sh .` → OK.
- `scripts/tests/departures-test.sh` → 120 passed; `bash
scripts/departures.sh check` → 20 of 20 rows present. `ijson-jcs check`
on the ledger → canonical.
- `bun 1-formats/deed/tools/deed_lint.js 0-AI-MANIFEST.deed` → OK. `just
llm-context nosuchrole` prints the deed.
- `actionlint .github/workflows/self-test.yml` → clean.
- The whole light shard (`SHELL_TEST_SHARD=light bash
scripts/run-shell-test-suite.sh`), run before the last two small
commits: 151 of 155 files passed. The four that failed need tools this
container lacks (`gh-actions-lock-contract-test`, `js-runtimes-test`,
`prune-stale-test`, `science-ci-security-test`); they fail the same way
on `main` here. After the last two commits I re-ran only the suites they
touch (listed above).

Not established:

- The new CI step has not yet run on GitHub. It needs bun, jq and full
history, which the job already sets up.
- The tool does not see readers in other repositories, except those
named in the rulings file, and does not see glob readers.
- For families other than CLADE, STATE and the scorecards, facts are not
compared field by field; such a file is reported `facts-unchecked` and
is never classed deletable.

## Beyond this repository

The same tool takes `--root DIR --repo NAME`, so it can measure any
estate repo. In Scaffoldia it reports 71 deletable directory manifests;
removing them is planned as Scaffoldia's first kernel-checked retrofit
(work order S10), after hyperpolymath/scaffoldia#76 merges.

---
_Generated by [Claude
Code](https://claude.ai/code/session_01J4QvDfhy8tVtwc5dx1A3nD)_

---------

Signed-off-by: Jonathan D.A. Jewell <6759885+hyperpolymath@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants