fix(ci): revive Rust CI — it had never run (60/60 startup failures) (#358)

## The finding

`.github/workflows/rust-ci.yml` **failed 60 consecutive runs, every one
at 0s**, with
zero jobs and no logs, from 2026-06-27 to 2026-07-27. That is a *startup
failure* —
GitHub rejected the file before scheduling anything. Not a flake, not a
failing test.

It was found via a **workflow-name fallback**: GitHub reports a
workflow's `name` as its
*file path* when it has never successfully parsed the file.

```
{"name": ".github/workflows/rust-ci.yml", "path": ".github/workflows/rust-ci.yml"}  <- this one
{"name": "Governance",                    "path": ".github/workflows/governance.yml"}
{"name": "Coq Build (formal/)",           "path": ".github/workflows/coq-build.yml"}
```

`rust-ci.yml` declares `name: Rust CI`. GitHub never saw it.

## Why it matters

`cargo build` and `cargo test` exist **only** in this workflow. So the
Rust
implementation — 70 source files — had **no build or test gate for a
month**, while the
board read 13/14 green. The `wasm-validate` job guarding against invalid
emitted wasm
(cf. #348) was equally dead.

## Cause

`if: hashFiles('Cargo.toml') != ''` used as a **job-level** conditional
on both local
jobs. Job-level `if:` is evaluated server-side before any checkout, so
`hashFiles()` has
no workspace to hash. The estate reusable's own header names this exact
construct as a
recurring failure mode, and solves it correctly with a `detect` job
whose output gates
the rest.

The guard was redundant anyway — this repo unconditionally has a
`Cargo.toml`.

## Ruled out first

So the next reader doesn't repeat the work:

| Hypothesis | Result |
|---|---|
| Encoding trap (CRLF / BOM / tabs) | **Falsified** — clean; only
non-ASCII is an em-dash in a comment |
| Invalid YAML | **Falsified** — parses |
| Unresolvable action SHA pins | **Falsified** — all three resolve |
| Reusable requests perms caller doesn't grant | **Falsified** — both
exactly `contents: read` |

## Also in this PR — salvage from uncommitted sweep debris

**Kept (useful):**
- `.editorconfig` — per-language indent widths (rust/zig 4, ada 3,
Justfile 4), but with
  the SPDX header **restored** and the sweep's rebrand of this file to
  `RSR-template-repo` (a template self-name leak) dropped.
- `.gitignore` — build/tooling artefact patterns, **minus** the sweep's
`.claude/` and
`.editorconfig` entries: both are tracked here, so ignoring them would
hide real
changes from `git status`. Verified no tracked file becomes newly
ignored.

**Discarded (harmful):**
- `guix.scm` clobbered to identify as `squisher-corpus`, **relicensed to
PMPL-1.0-or-later**, Owner line deleted — and carrying a `//` comment in
a Scheme file.
- Deletion of `.tool-versions` (pins `coq 8.18.0` / `ocaml 5.4.1` /
`rust stable`).
- `.gitattributes` regression dropping `*.zig` and `*.a2ml` rules.
- Commit `55dbd3b`, which replaced a valid CodeQL pin with `29b1f65c` —
**a SHA that
does not exist (HTTP 422)** — and would have taken the currently-green
CodeQL gate down.

## How to verify

The check is self-demonstrating: **if this PR's Rust CI runs at all, the
fix worked.**
Sixty prior runs produced zero jobs. Confirm the workflow now reports as
`Rust CI`
rather than its path, and that `no-default-features` and `wasm-validate`
actually execute.

## Note for follow-up (not in this PR)

The same detector found two more `name == path` entries here. Both are
benign, but worth
recording:
- `workflow-linter.yml` — **file deleted**, registration lingers.
Harmless orphan.
- `instant-sync.yml` — file exists, `disabled_manually` (deliberately
frozen). It parses
as YAML, so its cause differs; it would need diagnosis before being
re-enabled.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: hyperpolymath

.editorconfig

@@ -1,5 +1,6 @@
 # SPDX-License-Identifier: MPL-2.0
 # .editorconfig — RSR standard editor configuration
+# https://editorconfig.org
 
 root = true
 
@@ -11,3 +12,44 @@ end_of_line = lf
 trim_trailing_whitespace = true
 insert_final_newline = true
 
+# Prose formats rely on trailing double-space for hard line breaks.
+[*.md]
+trim_trailing_whitespace = false
+
+[*.adoc]
+trim_trailing_whitespace = false
+
+# Per-language indent widths.
+[*.rs]
+indent_size = 4
+
+[*.zig]
+indent_size = 4
+
+[*.{ada,adb,ads}]
+indent_size = 3
+
+[*.{ex,exs}]
+indent_size = 2
+
+[*.hs]
+indent_size = 2
+
+[*.{res,resi}]
+indent_size = 2
+
+[*.ncl]
+indent_size = 2
+
+[*.rkt]
+indent_size = 2
+
+[*.scm]
+indent_size = 2
+
+[*.nix]
+indent_size = 2
+
+[{Justfile,justfile}]
+indent_style = space
+indent_size = 4

.github/workflows/rust-ci.yml

@@ -2,6 +2,17 @@
 # Rust CI — thin wrapper calling the shared estate reusable in
 # hyperpolymath/standards. Configure once, propagate everywhere.
 # See: docs/CI-REUSABLE-WORKFLOWS.adoc in standards.
+#
+# DO NOT reintroduce a job-level `if: hashFiles('Cargo.toml') != ''` guard here.
+# Job-level `if:` is evaluated server-side before any checkout, so hashFiles()
+# has no workspace to hash. This workflow carried that guard on both local jobs
+# and, as a result, failed 60/60 runs at 0s with zero jobs and no logs — a
+# startup failure, not a test failure. GitHub reported the workflow's name as
+# `.github/workflows/rust-ci.yml` (the path-fallback used when a file has never
+# been parsed) rather than the declared `Rust CI`, which is how it was found.
+# Net effect: this repo's Rust build/test gate never ran between 2026-06-27 and
+# 2026-07-27. If a Cargo.toml presence check is ever needed, follow the estate
+# reusable and gate on a `detect` job output, not on hashFiles() at job level.
 name: Rust CI
 
 on:
@@ -24,7 +35,6 @@ jobs:
     name: Cargo build + test (ephapax-cli, --no-default-features)
     runs-on: ubuntu-latest
     timeout-minutes: 20
-    if: hashFiles('Cargo.toml') != ''
 
     # Proves ephapax can be built and tested with zero git dep on the
     # sibling `hyperpolymath/typed-wasm` repo. Enforces the estate
@@ -64,7 +74,6 @@ jobs:
     name: wasm-tools validate (emitted modules)
     runs-on: ubuntu-latest
     timeout-minutes: 20
-    if: hashFiles('Cargo.toml') != ''
 
     # Structurally validates every module ephapax emits for the fixture
     # corpus (`just validate-wasm`), catching codegen that produces an

.gitignore

@@ -97,3 +97,36 @@ dist/
 *.cmi
 *.cmo
 *.cmx
+
+# Additional build/tooling artefacts (salvaged from the 2026-07-26 sweep;
+# `.claude/` and `.editorconfig` were dropped from that set — both are TRACKED
+# in this repo and ignoring them would hide real changes from `git status`).
+*.ali
+*.chpl.tmp.*
+*.db
+*.db-journal
+*.db-shm
+*.db-wal
+*.ez
+*.jl.cov
+*.jl.mem
+*.py[cod]
+.venv/
+/.elixir_ls/
+/.stack-work/
+/Manifest.toml
+/_build/
+/bin/
+/build/
+/cover/
+/dist-newstyle/
+/dist/
+/doc/
+/exports/*.json
+/exports/*.lgt
+/obj/
+/out/
+__pycache__/
+composer/*.beam
+composer/build/
+erl_crash.dump

ephapax-linear/src/tests.rs

@@ -422,19 +422,29 @@ fn p2p_contraction_always_rejected_both_disciplines() {
 
         let mut linear = LinearChecker::new();
         let result = linear.check(&expr);
-        assert!(result.is_err(), "P2P linear[{i}]: double use must be rejected");
+        assert!(
+            result.is_err(),
+            "P2P linear[{i}]: double use must be rejected"
+        );
         let violations = result.unwrap_err();
         assert!(
-            violations.iter().any(|v| matches!(v, DisciplineViolation::Contraction { .. })),
+            violations
+                .iter()
+                .any(|v| matches!(v, DisciplineViolation::Contraction { .. })),
             "P2P linear[{i}]: must report Contraction violation"
         );
 
         let mut affine = AffineChecker::new();
         let result = affine.check(&expr);
-        assert!(result.is_err(), "P2P affine[{i}]: double use must be rejected");
+        assert!(
+            result.is_err(),
+            "P2P affine[{i}]: double use must be rejected"
+        );
         let violations = result.unwrap_err();
         assert!(
-            violations.iter().any(|v| matches!(v, DisciplineViolation::Contraction { .. })),
+            violations
+                .iter()
+                .any(|v| matches!(v, DisciplineViolation::Contraction { .. })),
             "P2P affine[{i}]: must report Contraction violation"
         );
     }
@@ -459,10 +469,15 @@ fn p2p_weakening_linear_forbidden_affine_allowed() {
         // Linear must reject
         let mut linear = LinearChecker::new();
         let result = linear.check(&expr);
-        assert!(result.is_err(), "P2P linear[{i}]: weakening must be rejected");
+        assert!(
+            result.is_err(),
+            "P2P linear[{i}]: weakening must be rejected"
+        );
         let violations = result.unwrap_err();
         assert!(
-            violations.iter().any(|v| matches!(v, DisciplineViolation::WeakeningForbidden { .. })),
+            violations
+                .iter()
+                .any(|v| matches!(v, DisciplineViolation::WeakeningForbidden { .. })),
             "P2P linear[{i}]: must report WeakeningForbidden"
         );
 
@@ -790,7 +805,10 @@ fn aspect_checker_stateless_between_instances() {
     });
 
     let mut checker1 = LinearChecker::new();
-    assert!(checker1.check(&bad_expr).is_err(), "Aspect stateless: bad expr must fail");
+    assert!(
+        checker1.check(&bad_expr).is_err(),
+        "Aspect stateless: bad expr must fail"
+    );
 
     // Second call with a DIFFERENT checker instance on a good expression
     let good_expr = e(ExprKind::LetLin {
@@ -835,10 +853,7 @@ fn aspect_violations_non_empty_on_failure() {
                 body: Box::new(unit()),
             }),
         ),
-        (
-            "drop",
-            e(ExprKind::Drop(Box::new(i32_lit(3)))),
-        ),
+        ("drop", e(ExprKind::Drop(Box::new(i32_lit(3))))),
     ];
 
     for (label, expr) in &bad_cases {
@@ -1037,14 +1052,30 @@ fn aspect_violation_error_warning_mutually_exclusive() {
     use crate::DisciplineViolation;
 
     let all_violations: Vec<DisciplineViolation> = vec![
-        DisciplineViolation::Contraction { name: "x".to_string() },
-        DisciplineViolation::NotInScope { name: "y".to_string() },
-        DisciplineViolation::WeakeningForbidden { name: "z".to_string() },
+        DisciplineViolation::Contraction {
+            name: "x".to_string(),
+        },
+        DisciplineViolation::NotInScope {
+            name: "y".to_string(),
+        },
+        DisciplineViolation::WeakeningForbidden {
+            name: "z".to_string(),
+        },
         DisciplineViolation::DropForbidden,
-        DisciplineViolation::BranchDisagreement { name: "b".to_string() },
-        DisciplineViolation::RegionLeakLinear { region: "r".to_string(), name: "s".to_string() },
-        DisciplineViolation::LetForLinearType { name: "t".to_string() },
-        DisciplineViolation::ImplicitDropWarning { region: "r".to_string(), name: "u".to_string() },
+        DisciplineViolation::BranchDisagreement {
+            name: "b".to_string(),
+        },
+        DisciplineViolation::RegionLeakLinear {
+            region: "r".to_string(),
+            name: "s".to_string(),
+        },
+        DisciplineViolation::LetForLinearType {
+            name: "t".to_string(),
+        },
+        DisciplineViolation::ImplicitDropWarning {
+            region: "r".to_string(),
+            name: "u".to_string(),
+        },
     ];
 
     for violation in &all_violations {

src/ephapax-cli/src/import_resolver.rs

@@ -151,9 +151,7 @@ fn first_module_declaration(source: &str) -> Option<String> {
             let rest = rest.trim();
             // Take everything up to a whitespace, comma, or comment marker.
             let end = rest
-                .find(|c: char| {
-                    !(c.is_ascii_alphanumeric() || c == '_' || c == '.' || c == '/')
-                })
+                .find(|c: char| !(c.is_ascii_alphanumeric() || c == '_' || c == '.' || c == '/'))
                 .unwrap_or(rest.len());
             let name = &rest[..end];
             if !name.is_empty() {
@@ -208,15 +206,14 @@ fn visit(
         message: e.to_string(),
     })?;
 
-    let surface =
-        parse_surface_module(&source, logical).map_err(|errs| ResolveError::Parse {
-            path: file_path.clone(),
-            message: errs
-                .iter()
-                .map(|e| format!("{}", e))
-                .collect::<Vec<_>>()
-                .join("; "),
-        })?;
+    let surface = parse_surface_module(&source, logical).map_err(|errs| ResolveError::Parse {
+        path: file_path.clone(),
+        message: errs
+            .iter()
+            .map(|e| format!("{}", e))
+            .collect::<Vec<_>>()
+            .join("; "),
+    })?;
 
     // Recurse into imports BEFORE inserting this module so that the
     // post-order visit places dependencies before this module.
@@ -226,7 +223,9 @@ fn visit(
         .map(|i| normalise_path(i.module.as_str()))
         .collect();
     for dep in &deps {
-        visit(dep, None, base_dir, mod_index, loaded, order, visiting, stack)?;
+        visit(
+            dep, None, base_dir, mod_index, loaded, order, visiting, stack,
+        )?;
     }
 
     loaded.insert(
@@ -253,9 +252,9 @@ fn root_module_path_from_source(root_path: &Path) -> Result<String, ResolveError
         let line = line.trim_start();
         if let Some(rest) = line.strip_prefix("module") {
             let rest = rest.trim();
-            if let Some(end) = rest.find(|c: char| {
-                !(c.is_ascii_alphanumeric() || c == '_' || c == '.' || c == '/')
-            }) {
+            if let Some(end) = rest
+                .find(|c: char| !(c.is_ascii_alphanumeric() || c == '_' || c == '.' || c == '/'))
+            {
                 return Ok(normalise_path(&rest[..end]));
             } else if !rest.is_empty() {
                 return Ok(normalise_path(rest));

src/ephapax-cli/src/main.rs

@@ -474,8 +474,16 @@ fn compile_file(
             if verbose {
                 println!("{} Type check passed", "✓".green());
             }
-            return finish_compile(module, &filename, path, output, opt_level, debug,
-                verify_ownership, verbose);
+            return finish_compile(
+                module,
+                &filename,
+                path,
+                output,
+                opt_level,
+                debug,
+                verify_ownership,
+                verbose,
+            );
         }
         Err(e) => return Err(e.to_string()),
     };
@@ -548,8 +556,16 @@ fn compile_file(
         println!("{} Type check passed", "✓".green());
     }
 
-    finish_compile(module, &filename, path, output, opt_level, debug,
-        verify_ownership, verbose)
+    finish_compile(
+        module,
+        &filename,
+        path,
+        output,
+        opt_level,
+        debug,
+        verify_ownership,
+        verbose,
+    )
 }
 
 /// Codegen + optional ownership verification + output write. Shared by
@@ -564,7 +580,6 @@ fn finish_compile(
     verify_ownership: bool,
     verbose: bool,
 ) -> Result<(), String> {
-
     // Compile to WASM (with or without debug info)
     let wasm_bytes = if debug {
         ephapax_wasm::compile_module(&module).map_err(|e| format!("Codegen error: {}", e))?
@@ -672,16 +687,11 @@ fn report_ownership_verification(wasm_bytes: &[u8], verbose: bool) -> Result<(),
     match verify_from_module(wasm_bytes) {
         Ok(()) => {
             if verbose {
-                println!(
-                    "{} typed-wasm L7+L10 verification: clean",
-                    "✓".green()
-                );
+                println!("{} typed-wasm L7+L10 verification: clean", "✓".green());
             }
             Ok(())
         }
-        Err(VerifyError::Parse(e)) => {
-            Err(format!("verifier could not parse emitted wasm: {}", e))
-        }
+        Err(VerifyError::Parse(e)) => Err(format!("verifier could not parse emitted wasm: {}", e)),
         Err(VerifyError::Ownership(errs)) => {
             eprintln!(
                 "{} typed-wasm verification failed: {} violation(s)",