feat(overengineering): add the delta lane — recurring audits that report only what moved (0.2.0)

docs/CATALOG.md

@@ -60,7 +60,7 @@ plugin manifests and kept in sync by CI — never hand-edit it; the category voc
 - [`codebase-health`](../plugins/codebase-health) — Repo-wide drift audit between docs, config, code, and architecture: verifies every factual claim against reality via parallel subagent fan-out, severity-rates findings, and reports read-only, delegating remediation to the implementation/verification lanes. Audit dimensions are configurable through a tracked .claude/codebase-health.md config file written by the setup skill.
 - [`discipline`](../plugins/discipline) — Discipline correctors that re-anchor a standing rule mid-session, then audit both the work in flight and the pre-existing state and choices it trusts, and correct what has drifted: do-your-research (research and no-assumptions discipline; sibling do-your-research-deep escalates to a typed full inventory of the session's claims — assumptions, asserted facts, concrete specifics, load-bearing premises — verified at a configurable depth and reported as a per-item ledger), follow-our-standards (alignment to the consuming org's engineering conventions), point-dont-copy (pointer-over-copy discipline — no copied content, internal-name coupling, or closed capability lists), reason-dont-recite (interrogate inherited content — precedent is evidence of what is, never self-justifying authority), tighten-your-output (terseness discipline — fewer words or lines with no loss of meaning or correctness), recheck-against-upstream (existing state is not evidence of its own correctness — audit config, code, and infra against current official upstream docs; sibling recheck-against-upstream-deep fans subagents doc-by-doc over a whole subsystem), pick-for-the-problem (tool, library, framework, and approach selection fitted to the problem, not reached for out of habit, availability, incumbency, or preconception), mind-your-maxims (cooperative-communication discipline per Grice plus the AI-augmented transparency maxim), script-the-deterministic-work (offload deterministic sub-work — counts, diffs, sorts, transforms, and scaffolds — to a script that runs, reserving model output for judgment over its real output; the audit runs both ways, also catching an existing script that over-reaches into judgement), use-your-skills (actually use the skills already in context — scan the listing, map the task, invoke the fitting skill instead of reinventing it, and name skills when delegating to a subagent), and reuse-or-replace (anti-fragmentation — new work reuses an established way of doing something or openly replaces it (migrate the old uses, record the decision), never silently stands up a second parallel way; divergence is allowed but owes a recorded reason proportional to blast radius), and scrutinize-dont-coast (adversarial self-scrutiny — stop coasting on your own recent output and re-examine whether it is sound, not merely confidently produced, through a fresh-context pass blind to the reasoning that made it, then remediate with the user; it stops the trajectory first and remediates collaboratively rather than autonomously). Plus further species that are not correctors (examples, not a fixed list — each skill's own description is authoritative), including setup, sweep-all, a posture-batch runbook that composes them — it fans out an audit-only subagent per in-scope corrector, then applies the corrections on the main thread in a fixed order, with batch membership and order set by each corrector's own colocated tier metadata and an optional userConfig overlay — and wait-what, a one-shot user-invoked-only communication repair: type /discipline:wait-what when the last message did not land and the model re-pitches it, backing up as far as needed, adding the missing context, in ASD-STE100 Simplified Technical English, using the project's ubiquitous language; never model-invoked and never in the batch. Firing a corrector is a re-anchor, not an accusation; the audit may return clean.
 - [`ai-slop`](../plugins/ai-slop) — Detects and removes AI-writing tells (slop) in checked-in markdown prose: em dashes, emoji formatting, AI vocabulary, negative parallelisms, chatbot phrases, filler, stacked hedging, citation artifacts, and the rest of a catalog distilled from Wikipedia's Signs of AI writing. Read-only audit by default with a deterministic detector plus a judgment rubric; an explicit fix action rewrites findings behind a semantic-diff guard. Findings conform to the detector-findings convention so the review fanout fix relay can consume them.
-- [`overengineering`](../plugins/overengineering) — Evidence-earned-keep audit of an existing enforcement surface — agent hooks and standing instructions, repository and version-control hooks, CI lanes and gate scripts, branch protections, forge apps, declared external integrations — treating every incumbent mechanism as a retirement candidate until empirical evidence earns its keep, arguing every verdict in cost of carry, capping retirement-direction verdicts on security-class artifacts at FLAG-FOR-HUMAN, and realigning to the simplest adequate solution behind an explicit per-item human gate. The audit is read-only and emits a diffable findings artifact; realignment is a separate, explicitly invoked skill.
+- [`overengineering`](../plugins/overengineering) — Evidence-earned-keep audit of an existing enforcement surface — agent hooks and standing instructions, repository and version-control hooks, CI lanes and gate scripts, branch protections, forge apps, declared external integrations — treating every incumbent mechanism as a retirement candidate until empirical evidence earns its keep, arguing every verdict in cost of carry, capping retirement-direction verdicts on security-class artifacts at FLAG-FOR-HUMAN, and realigning to the simplest adequate solution behind an explicit per-item human gate. The audit is read-only and emits a diffable findings artifact; realignment is a separate, explicitly invoked skill; and a third read-only lane re-runs the audit on whatever cadence the consumer wires and reports only what moved since the last run, above a configurable noise budget.
 - [`improvement`](../plugins/improvement) — Evidence-first, cross-dimension improvement finder — point it at a repo, feature, concept, or process surface and it produces a ranked, evidence-cited list of improvement candidates led by value-to-effort, interviews on the pick, and hands off to the planning pipeline; runnable unattended as a tech-debt-sweep routine.
 
 ## Maintenance

docs/SKILL-CHEAT-SHEET.md

@@ -194,6 +194,7 @@ owned by [docs/CATALOG-TAXONOMY.md](CATALOG-TAXONOMY.md).
 | [`/github:audit`](../plugins/github/skills/audit/SKILL.md) | `github` | Read-only audit of GitHub org and repo settings, drift, and cost signals |
 | [`/improvement:find`](../plugins/improvement/skills/find/SKILL.md) | `improvement` | Rank evidence-cited improvement candidates across dimensions; execution goes to the pipeline |
 | [`/overengineering:audit`](../plugins/overengineering/skills/audit/SKILL.md) | `overengineering` | Audit the enforcement surface for mechanisms no longer earning their carry cost |
+| [`/overengineering:delta`](../plugins/overengineering/skills/delta/SKILL.md) | `overengineering` | Re-run the enforcement-surface audit and report only what moved since the last run |
 | [`/playbooks:boris`](../plugins/playbooks/skills/boris/SKILL.md) | `playbooks` | Boris Cherny's Claude Code workflow tips across 115 sections |
 | [`/playbooks:fable-5`](../plugins/playbooks/skills/fable-5/SKILL.md) | `playbooks` | Fable 5's operating doctrine loaded as standing session instructions |
 | [`/playbooks:skill-authoring`](../plugins/playbooks/skills/skill-authoring/SKILL.md) | `playbooks` | Anthropic's internal skill-authoring playbook and patterns |

plugins/overengineering/.claude-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "overengineering",
-  "version": "0.1.1",
-  "description": "Evidence-earned-keep audit of an existing enforcement surface — agent hooks and standing instructions, repository and version-control hooks, CI lanes and gate scripts, branch protections, forge apps, declared external integrations — treating every incumbent mechanism as a retirement candidate until empirical evidence earns its keep, arguing every verdict in cost of carry, capping retirement-direction verdicts on security-class artifacts at FLAG-FOR-HUMAN, and realigning to the simplest adequate solution behind an explicit per-item human gate. The audit is read-only and emits a diffable findings artifact; realignment is a separate, explicitly invoked skill.",
+  "version": "0.2.0",
+  "description": "Evidence-earned-keep audit of an existing enforcement surface — agent hooks and standing instructions, repository and version-control hooks, CI lanes and gate scripts, branch protections, forge apps, declared external integrations — treating every incumbent mechanism as a retirement candidate until empirical evidence earns its keep, arguing every verdict in cost of carry, capping retirement-direction verdicts on security-class artifacts at FLAG-FOR-HUMAN, and realigning to the simplest adequate solution behind an explicit per-item human gate. The audit is read-only and emits a diffable findings artifact; realignment is a separate, explicitly invoked skill; and a third read-only lane re-runs the audit on whatever cadence the consumer wires and reports only what moved since the last run, above a configurable noise budget.",
   "author": {
     "name": "Melodic Software",
     "email": "info@melodicsoftware.com"
@@ -13,6 +13,7 @@
     "enforcement-surface",
     "audit",
     "realign",
+    "delta",
     "retirement",
     "yagni",
     "carry-cost",

plugins/overengineering/CHANGELOG.md

@@ -3,6 +3,97 @@
 All notable changes to the `overengineering` plugin are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning.
 
+## [0.2.0]
+
+### Added
+
+- **`delta` — the recurring lane the findings artifact was designed for (#2898).** A third,
+  read-only skill: it composes `overengineering:audit` over the same layer scope, compares the
+  resulting findings spine against the baseline the previous cycle left behind, captures a fresh one
+  for the next, and reports **only what moved** — new clutter, verdict moves, closures, status
+  changes — instead of re-serving the whole surface every cycle. The
+  artifact's stable spine was given its diffable line format for exactly this consumer, and the lane
+  reads the spine alone: prose is recomputed fresh every run, so comparing it would report model
+  noise as change.
+- **The baseline is the previous cycle's post-audit spine, stated as the lane's load-bearing
+  mechanic.** Two things have to be right and each fails silently alone. A spine must be *persisted*,
+  because the artifact is rewritten in place, per layer, as the audit walks — **after an audit has
+  run there is nothing left to diff against**, so "audit, then diff the file" is not available and a
+  memory-tier `spine-baseline.md` sibling is mandatory. And it must be captured at the **end** of a
+  cycle, from the post-audit artifact: `Status` is written by realign, a human runs realign *between*
+  cycles, and the audit carries every non-new status forward untouched, so a start-of-cycle capture
+  would already hold the new status and the status-change class could never fire. A pre-audit capture
+  survives only as an explicitly named **bootstrap** — a home with an artifact and no baseline yet —
+  which cannot observe a status change and says so, while the next cycle can. A maintainer who breaks
+  either half gets no error, just a silently useless lane, which is why the mechanic is a contract
+  clause in both the skill and `context/findings-artifact.md` rather than an implementation detail.
+- **A detached checkout is never given a branch identity.** `git rev-parse --abbrev-ref HEAD` answers
+  the literal `HEAD` when detached — the ordinary shape for the scheduled runners this lane targets —
+  which keys every ref to one home and compares equal to itself, so the branch-match guard would
+  accept another ref's spine as this ref's baseline and report cross-ref differences as deltas. The
+  lane's precompute uses `git symbolic-ref`, which fails rather than inventing a name; the run then
+  prefers a logical ref where the environment supplies one (no CI vendor's variables are named or
+  assumed) and otherwise declines to compare **and** declines to capture, saying why.
+- **A noise budget with per-class rules, not a judgment gesture.** Each delta class is disposed as
+  list, count, or omit: new findings list on retirement-direction and capped verdicts and count
+  otherwise; new `UNPROVEN` findings list only the head of the audit's own carry-cost ranking, since
+  an evidence desert produces them in bulk; verdict moves on unjudged findings list only when they
+  cross the keep/retirement boundary, touch `FLAG-FOR-HUMAN`, or enter or leave `UNPROVEN`; closures
+  list when unexpected and count when the prior status was `REALIGNED`; member moves under an
+  unchanged container count. A volume cap bounds the whole report, and **a quiet cycle is one line**
+  — the anti-nag property the lane exists to hold. Evidence-only change is declared **out of scope by
+  construction**: evidence is prose, a spine comparison cannot see it, and no threshold makes it able
+  to.
+- **`delta_noise_budget` in `reference/consumer-config.md`**, seven keys with types and defaults, in
+  the ordinary **refinement** cascade class with the classification justified in the doc: no key can
+  remove a finding from the artifact, change a verdict, suppress a judgment, or weaken the protected
+  cap, so none carries the hazard that puts `protected_categories` and `suppressions` in the
+  policy-floor class. Two delta classes are deliberately not keys at all — a verdict that moved under
+  a **carried-forward judgment** (merge rule 5) and a **status change** are always surfaced, and no
+  layer can weaken either. `queue_route` defaults to `inline`: the durable tracker route is **opt-in**
+  because `work-items:track` refuses to file on inferred intent, and an operator setting the key in
+  tracked config is the explicit, recorded authorization that gate requires — one an unattended
+  scheduled cycle has nobody present to give.
+- **Recurring wiring documented, adopted nowhere.** `skills/delta/context/recurring-wiring.md`
+  carries four consumer-agnostic shapes — a fixed-interval loop, a headless scheduled task, a CI
+  schedule, and a recurring tracker item — each with its trade, including the observation that a
+  scheduled CI lane *is itself* an enforcement-surface item this plugin's own audit will later judge
+  on carry cost. The plugin ships no schedule of its own: a cadence is the consumer's ratified
+  decision, not something a plugin adopts on install.
+
+### Changed
+
+- **`context/findings-artifact.md` gains the spine-capture obligation (#2898), additively.** A new
+  section names the end-of-cycle capture timing, the `Status` reason behind it, the one sanctioned
+  pre-audit bootstrap, and specifies the `spine-baseline.md` sibling —
+  `type: overengineering-spine-baseline`, deliberately neither `overengineering-findings` nor
+  `review-findings`, so `realign` never reads it and no fix relay can locate it. `schema` stays `1`
+  and no merge rule changed; the doc's forward reference to "a future delta lane" now names the
+  shipped one, and its obligations table records that `delta` is a third **reader** and no writer —
+  least of all of `Status`, which stays realign's alone.
+
+### Contracts
+
+- **Read-only always, and realign is never entered.** The delta lane never invokes or enters
+  `overengineering:realign` — not on a verdict that moved, not on a finding an earlier run accepted,
+  and not when the operator asks for it mid-run. Realign's per-item gate needs a human present at the
+  moment the item is shown, and a lane that can run on a schedule has nobody to give one. Verdict
+  changes **queue**: always in the report's `## Queued for the human` section, and — **opt-in** on a
+  tracked `queue_route: auto` and then presence-gated on a reachable work-item tracker, with the
+  report section as the named inline fallback — as one reused item per branch that a quiet cycle
+  never touches, that drops a row the human has already dispositioned, and that the lane never
+  closes. The opt-in is the authorization, not a verbosity preference: `work-items:track` will not
+  file on inferred intent, so an unset key means report-only.
+- **No baseline is a first-class state, not an error.** A fresh container, a removed worktree, a
+  branch switch, or an artifact whose `branch:` frontmatter names another branch all mean there is no
+  prior spine. The lane says "no baseline; this run establishes one", reports nothing as a delta, and
+  points at the composed audit's own inline summary rather than producing a second full-surface view.
+  An unrecognized `schema:` is a stop instead, per the artifact contract's closed rule.
+- **A layer-scoped cycle is never a clean bill of health.** Findings in a layer absent from this
+  run's `scope` were carried forward untouched by merge rule 4; they contribute to no delta class and
+  are named once as a coverage line with their count — never as unchanged-and-checked, and never as
+  closed.
+
 ## [0.1.1]
 
 ### Changed