feat(fight): enact the path-filter self-win under squabble fight --apply

`squabble fight` could plan but not enact. This lands the first appliable
self-win move so the squabbler starts paying rent, not just diagnosing.

What `--apply` does (and only this, in v0.1):
- Strips an `on.*.paths` trigger filter that strands a required check. The
  documented estate fix (boj-server "CI / Required Status Checks") for a
  path-filtered required workflow that reports "Expected" forever and leaves a
  PR `mergeable_state: blocked`.
- Classification is Missing-only: the trap manifests as a *Missing* check (the
  workflow never triggered off-path). A check that ran and *Failed* did trigger,
  so the filter is not its cause — that stays an escalation, not a strip.
- Writes the workflow file and stops. No commit, no push, no CI re-run
  (doctrine #11, stop-first; only CI can turn a check green). The `Outcome`
  stays `Red` with a new `applied` evidence section recording exactly what
  changed on disk (no overclaim).
- Fail-closed + idempotent per move: an unreadable/unwritable file or a
  nothing-to-strip no-op is recorded in the report, never silently skipped.

Why this is not a bypass: removing an inclusion filter makes the required check
run on *more* PRs, never fewer — a strict coverage increase. It cannot turn a
`Failed` run into `Passed` and cannot drop a required context, so `Gate::evaluate`
is untouched and the SPARK invariant (Green iff every required check ran and
passed) needs no re-proof. The `spark/` tree is unchanged.

Details:
- squabble-core: add `AppliedChange` + `Report.applied` (#[serde(default)],
  back-compatible with older reports).
- squabble-fight: new `apply` module (`remove_on_paths` line-based YAML strip,
  `apply_moves` fail-closed driver); classify a Missing + path-filtered required
  check as the appliable `InjectPathFilterPassThrough`; dedupe self-won
  path-filter traps out of the structural owner-assignment scan.
- squabble-cli: `squabble fight --apply` (propose remains the default), applied
  section in the human report.
- Only `InjectPathFilterPassThrough` is appliable (pure local edit, no network).
  Required-context reconcile and reusable re-pin need the GitHub ruleset API / a
  target SHA and stay propose-only; the webhook leg remains honestly absent.

New tests: apply unit + temp-file end-to-end + idempotency + fail-closed;
Missing-path-filter classification; --apply flag parsing. Whole workspace green
(default + `boj` feature), fmt + clippy clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SUURnQUnzTXYftzWFs5pfZ

Author: claude

.machine_readable/descriptiles/STATE.a2ml

@@ -6,13 +6,13 @@
 [metadata]
 project = "cicd-squabbler"
 version = "0.1.0"
-last-updated = "2026-07-03"
+last-updated = "2026-07-17"
 status = "active"  # active | paused | archived
 
 [project-context]
 name = "cicd-squabbler"
 purpose = "CI/CD gate fighter: drives a stuck branch-protection gate to a legitimately-satisfied green by satisfying its required checks — never by admin override, enforce_admins toggle, or removing/renaming a required context. Rust fight engine + SPARK-proved gate invariant. Detachable; no hypatia/estate dependency."
-completion-percentage = 92
+completion-percentage = 93
 
 [position]
 phase = "implementation"   # design | implementation | testing | maintenance | archived
@@ -32,6 +32,7 @@ milestones = [
   { name = "squabble-app loopback HTTP backend (axum, 127.0.0.1:7741): /health, /api/v1/diagnose, /api/v1/fight — the process the cicd-squabbler-mcp cartridge proxies to. The GitHub App *webhook* leg (check_run.requested_action + octocrab) remains honestly absent (no webhook route registered).", completion = 100 },
   { name = "boj-server expert client (feature `boj`, ureq; default build gains zero deps): `squabble fight --summon` maps each EscalateToExpert to its cartridge (Security→panic-attack-mcp, Proof→echidna-llm-mcp, Hypatia*→hypatia-mcp; dispatch-fix recorded as assessed+tracked, actuation external — no fixer cartridge exists). Fail-closed on unreachable experts; loud refusal when built without the feature.", completion = 100 },
   { name = "cicd-squabbler-mcp cartridge (boj-server-cartridges cartridges/domains/ci-cd/): squabble_fight + squabble_diagnose tools, mod.js proxy to SQUABBLE_BACKEND_URL, no ffi block (JS dispatch path)", completion = 100 },
+  { name = "`squabble fight --apply` — enacts the first appliable self-win: strips an on.*.paths trigger filter that strands a required check (Missing-only classification), writing the workflow file. Fail-closed + idempotent + no commit/push/re-run; Outcome stays Red with an `applied` evidence section (no overclaim). Provably gate-strengthening (more coverage, never fewer) so the SPARK invariant is untouched. Other self-wins (context reconcile, reusable re-pin) stay propose-only pending the GitHub ruleset API.", completion = 100 },
   { name = "RSR scaffolding customisation (identity, root-allow, A2ML manifests)", completion = 80 },
 ]
 
@@ -41,7 +42,8 @@ milestones = [
 
 [critical-next-actions]
 actions = [
-  "Implement `squabble fight --apply` (and the squabble-app GitHub App webhook leg: check_run.requested_action + octocrab) so self-win moves are enacted + re-run, not only planned.",
+  "Enact the remaining self-wins under --apply: required-context reconcile and reusable-workflow re-pin both need the GitHub ruleset API / a target SHA (network), so they stay propose-only until that host capability exists. (`--apply` already enacts the path-filter strip, which is a pure local file edit.)",
+  "Add the squabble-app GitHub App webhook leg (check_run.requested_action + octocrab — the \"Squabble!\" button) so a fight can be triggered from a PR, not only from the CLI; still honestly absent (no webhook route registered).",
   "Live-fire --summon against a running boj-server with the expert backends up (hypatia :7701, panic-attack, echidna) — today's verification proves the wiring + fail-closed degradation; the experts themselves are not yet deployed.",
   "Extend the SPARK invariant to cover the licence-policy gate class (v0.2; v0.1 moves are Rust-only for that class).",
   "Register the CLADE (uuid 38bec2ed-bb12-44ee-9fb4-08872370c27b) into hyperpolymath/gv-clade-index (owner action).",

README.adoc

@@ -15,13 +15,17 @@ A standalone, per-repo CI/CD fighter that drives a stuck pipeline to a
 *legitimate* green — or improves red→yellow, or fails and hands the human a
 structured report. It *wins* the gate; it never cheats past it.
 
-NOTE: Status — *v0.1 in active development (updated 2026-07-03).* The engine and
+NOTE: Status — *v0.1 in active development (updated 2026-07-17).* The engine and
 its formal invariant are real and verified (see below); live gate fetch via `gh`
 landed in #6; `squabble fight` (classify each red as self-win | escalate |
 assign-owner), the `squabble-app` loopback HTTP backend, and the boj-server
-expert summoning (`--summon`, feature `boj`) landed in #13. Still open: the
-`squabble apply` plumbing (moves are proposed, not yet executed) and the GitHub
-App *webhook* leg (pending the owner's hosting decision). See
+expert summoning (`--summon`, feature `boj`) landed in #13. `squabble fight
+--apply` now *enacts* the first appliable self-win — stripping an `on.*.paths`
+trigger filter that strands a required check — by writing the workflow file
+(propose remains the default; `--apply` never commits, pushes, or re-runs CI).
+Still open: applying the other self-wins (required-context reconcile,
+reusable-workflow re-pin — these need the GitHub ruleset API / a target SHA) and
+the GitHub App *webhook* leg (pending the owner's hosting decision). See
 `docs/CHARTER.adoc` for the design and open owner decisions.
 
 == Core principle: squabble ≠ bypass
@@ -42,7 +46,7 @@ check away, or any override are provably *not* paths to green.
 |===
 | `crates/squabble-core` | The fight engine. Pure, detachable, no hypatia/estate dependency — `diagnose → propose move → apply → verify-satisfied`. The valuable reusable part.
 | `crates/squabble-fight`| The shared host brain: a2ml ecosystem-context reader + workflow ground-truth + the fight planner. One planner for the CLI and the App, so they cannot drift.
-| `crates/squabble-cli`  | `squabble` — runs locally or as a CI step. `fetch`, `diagnose`, and `fight` (with `--summon` under the `boj` feature to put expert verdicts on the report); apply plumbing next.
+| `crates/squabble-cli`  | `squabble` — runs locally or as a CI step. `fetch`, `diagnose`, and `fight` (with `--summon` under the `boj` feature to put expert verdicts on the report, and `--apply` to enact the path-filter self-win by editing the workflow — no commit/push).
 | `crates/squabble-app`  | The loopback HTTP backend (axum, `127.0.0.1:7741`): serves the shared planner to the boj-server `cicd-squabbler-mcp` cartridge. The GitHub App *webhook* leg (trigger button + octocrab) is still to come — no webhook route is registered.
 | `spark/`               | The formal heart. `Gate_Machine` + the proved theorem `green ⇔ (non-empty ∧ all passed)`.
 |===

crates/squabble-cli/src/boj.rs

@@ -325,6 +325,7 @@ mod tests {
                 escalations: vec![escalation(ExpertGroup::Security, EscalationKind::Scan)],
                 owner_assignments: vec![],
                 expert_verdicts: vec![],
+                applied: vec![],
                 blockers: vec![],
             },
         };

crates/squabble-cli/src/fight.rs

@@ -23,10 +23,11 @@ struct FightArgs {
     gate_file: Option<String>,
     json: bool,
     summon: bool,
+    apply: bool,
 }
 
 // Shared with the top-level help in main.rs so the two cannot drift.
-pub(crate) const USAGE: &str = "usage: squabble fight <owner>/<repo> <pr> [--repo-root <path>] [--gate <file>] [--json] [--summon]";
+pub(crate) const USAGE: &str = "usage: squabble fight <owner>/<repo> <pr> [--repo-root <path>] [--gate <file>] [--json] [--summon] [--apply]";
 
 /// Entry point for `squabble fight`; `rest` is the args after the subcommand.
 pub fn run(rest: &[String]) -> ExitCode {
@@ -46,10 +47,30 @@ pub fn run(rest: &[String]) -> ExitCode {
         }
     };
 
-    // `mut` is only exercised by the boj build (summon appends evidence).
-    #[cfg_attr(not(feature = "boj"), allow(unused_mut))]
     let (context, mut outcome) = squabble_fight::plan_at_root(&gate, &args.slug, &args.repo_root);
 
+    // `--apply` enacts the appliable self-win moves (v0.1: path-filter strips)
+    // by writing the workflow files — and nothing more. It never commits or
+    // pushes, and it never re-runs the checks, so the gate stays honestly red
+    // (only CI can turn a check green); the report gains an `applied` section
+    // recording exactly what was written. Default (propose) leaves the tree
+    // untouched.
+    if args.apply {
+        if let Outcome::Red { report } = &mut outcome {
+            let result =
+                squabble_fight::apply::apply_moves(&args.repo_root, &report.moves_attempted);
+            let applied_n = result.applied.len();
+            report.applied = result.applied;
+            report.blockers.extend(result.skipped);
+            if applied_n > 0 {
+                report.blockers.push(format!(
+                    "applied {applied_n} self-win move(s) to the working tree — re-run CI to \
+                     confirm the gate; nothing was committed or pushed (that is the operator's step)"
+                ));
+            }
+        }
+    }
+
     if args.summon {
         // Without the `boj` feature there is no client compiled in. Refusing
         // loudly honours `no-silent-skip`: pretending to summon would be
@@ -102,6 +123,7 @@ fn parse_args(rest: &[String]) -> Result<FightArgs, String> {
     let mut gate_file = None;
     let mut json = false;
     let mut summon = false;
+    let mut apply = false;
 
     let mut i = 0;
     while i < rest.len() {
@@ -128,6 +150,10 @@ fn parse_args(rest: &[String]) -> Result<FightArgs, String> {
                 summon = true;
                 i += 1;
             }
+            "--apply" => {
+                apply = true;
+                i += 1;
+            }
             s if s.starts_with("--") => return Err(format!("unknown flag `{s}`\n{USAGE}")),
             s => {
                 if slug.is_none() {
@@ -153,6 +179,7 @@ fn parse_args(rest: &[String]) -> Result<FightArgs, String> {
         gate_file,
         json,
         summon,
+        apply,
     })
 }
 
@@ -184,6 +211,12 @@ fn print_human(slug: &str, context: &RepoContext, outcome: &Outcome) {
             println!("    - {}", m.describe());
         }
     }
+    if !report.applied.is_empty() {
+        println!("\n  applied to the working tree (no commit/push — operator's step):");
+        for a in &report.applied {
+            println!("    - {}: {}", a.file, a.detail);
+        }
+    }
     if !report.escalations.is_empty() {
         println!("\n  escalations (call in the big guns):");
         for e in &report.escalations {
@@ -226,6 +259,15 @@ mod tests {
         assert_eq!(args.slug, "hyperpolymath/ipv6-only");
     }
 
+    #[test]
+    fn parse_args_accepts_apply_flag_default_off() {
+        let off = parse_args(&["o/r".to_string(), "1".to_string()]).expect("parse");
+        assert!(!off.apply, "apply must default to propose-only");
+        let on = parse_args(&["o/r".to_string(), "1".to_string(), "--apply".to_string()])
+            .expect("parse");
+        assert!(on.apply);
+    }
+
     #[test]
     fn parse_args_rejects_unknown_flags() {
         assert!(parse_args(&["o/r".to_string(), "--bogus".to_string()]).is_err());

crates/squabble-core/src/outcome.rs

@@ -62,10 +62,33 @@ pub struct Report {
     /// the escalation's `evidence` string carries only the human narration.
     #[serde(default)]
     pub expert_verdicts: Vec<ExpertVerdict>,
+    /// Concrete edits the squabbler wrote to the working tree while executing
+    /// self-win moves under `--apply` (propose-mode never writes, so this is
+    /// empty then). Applying a config edit does **not** make the gate green —
+    /// only a CI re-run can — so the [`Outcome`] stays [`Outcome::Red`] and this
+    /// section is the honest record of what changed on disk (`evidence-per-step`,
+    /// `no-overclaim`).
+    #[serde(default)]
+    pub applied: Vec<AppliedChange>,
     /// Why each remaining requirement could not be satisfied legitimately.
     pub blockers: Vec<String>,
 }
 
+/// One concrete edit the squabbler made to the working tree while executing a
+/// self-win move (only under `--apply`). It records *what* was written, never a
+/// claim that the gate improved: the gate's colour is a property of the checks'
+/// runs, and nothing here re-ran them. Nothing is committed or pushed — that
+/// outward-facing step is deliberately the operator's (doctrine #11, stop-first).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AppliedChange {
+    /// The move kind this realises, e.g. `"inject-path-filter-pass-through"`.
+    pub move_kind: String,
+    /// Repo-relative path of the file edited.
+    pub file: String,
+    /// Human description of the concrete change made.
+    pub detail: String,
+}
+
 /// One expert call made while summoning, recorded verbatim. `ok` follows the
 /// fail-closed rule: it is `true` only when the expert both responded AND its
 /// body carries no error signal — transport success alone is not a verdict.
@@ -217,6 +240,11 @@ mod tests {
                 meaning: "weak-point scan".into(),
                 verdict: r#"{"findings":[]}"#.into(),
             }],
+            applied: vec![AppliedChange {
+                move_kind: "inject-path-filter-pass-through".into(),
+                file: ".github/workflows/wellknown-enforcement.yml".into(),
+                detail: "removed on.*.paths filter so the required check always runs".into(),
+            }],
             blockers: vec![],
         };
         let json = serde_json::to_string(&report).expect("serialise");
@@ -226,12 +254,13 @@ mod tests {
 
     #[test]
     fn report_deserialises_without_new_sections_for_back_compat() {
-        // Older reports had no escalations/owner_assignments/expert_verdicts;
-        // #[serde(default)] must keep them parseable.
+        // Older reports had no escalations/owner_assignments/expert_verdicts/
+        // applied; #[serde(default)] must keep them parseable.
         let legacy = r#"{"summary":"x","unsatisfied":[],"moves_attempted":[],"blockers":[]}"#;
         let report: Report = serde_json::from_str(legacy).expect("legacy parse");
         assert!(report.escalations.is_empty());
         assert!(report.owner_assignments.is_empty());
         assert!(report.expert_verdicts.is_empty());
+        assert!(report.applied.is_empty());
     }
 }