feat(optimize): add --subtract, the subtraction axis, behind a deterministic floor

Every command so far asked an addition question — what to add, what to move,
what it costs. Nothing asked what is no longer earning its always-loaded rent.
This adds that axis as a fourth lensCheck on the existing hybrid motor rather
than a new scanner or a 22nd command: the measured payoff (~18% of one file)
justifies a mode, not machinery.

It is the only lens that proposes REMOVING config, so it carries a guarantee
the others don't need: a load-bearing block is never a candidate. Precision is
asymmetric — a missed dead line costs a few tokens per turn, a deleted one
costs a wrong remote or a broken script — so the floor is decided in code
(lib/floor-exclusion.mjs) before the opus judge sees anything, never in prose.

Granularity is the leaf block, with two structural exceptions: a paragraph
ending in ':' merges with the list it introduces, and an ordered list is a
contract whose steps inherit floor from any sibling. Unordered lists
deliberately do not inherit — a load-bearing bullet and a disposable one
routinely share a list, and container-reasoning is the error the hand-built
ground truth exists to catch.

Verified against that ground truth (built before any classifier existed), with
the comparison machine-checked rather than read by eye: zero load-bearing
blocks proposed, 11/18 deletable groups surfaced, ~756 tok ~ 18% of a ~4300
token file — inside the pre-registered band. The first run found five floor
violations the synthesized fixture missed; each got a structural rule and a
fixture shape so it cannot regress.

Three real bugs the dogfood run exposed, all now covered:
- JS \b is ASCII-only, so /\bunngå\b/ never matches — every Norwegian keyword
  ending in æ/ø/å was silently dead.
- A bare word/word is not a path; "pros/cons" vetoed the largest deletable
  block until PATH_RE was tightened to rooted paths and globs.
- "Mid-sentence" must key on a preceding lowercase letter; the loose version
  read **bold labels:** and quoted openers as entities, costing 4 of 11 groups.

BP-SUB-001 is grounded entirely in the Anthropic steering blog already cited by
BP-MECH-001..004 and asserts nothing from the talk that motivated the feature —
no "80%", no ablation figure.

Suite 1365 -> 1382/0. Frozen v5.0.0 snapshots untouched; plain optimize output
byte-identical on identical input (--subtract adds keys only when passed).
knowledge-refresh-cli's reference date moved to 2026-08-01: its premise that
every seed entry was verified 2026-06-20 expired when BP-SUB-001 got a genuine
verification date, and backdating the entry to fit the test would have been a
lie about when its source was checked.

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

scanners/optimize-lens-cli.mjs

@@ -31,6 +31,7 @@ import { resetCounter } from './lib/output.mjs';
 import { parseFrontmatter } from './lib/yaml-parser.mjs';
 import { loadRegister, getEntry } from './lib/best-practices-register.mjs';
 import { prefilterClaudeMd, LENS_DETECTORS } from './lib/lens-prefilter.mjs';
+import { subtractionCandidates, SUBTRACT_DETECTORS } from './lib/subtraction-prefilter.mjs';
 import { scan as optScan } from './optimization-lens-scanner.mjs';
 
 // Files under `.claude/plugins/` are shipped by an installed plugin — vendored
@@ -53,9 +54,11 @@ async function main() {
   let targetPath = '.';
   let outputFile = null;
   let includeGlobal = false;
+  let subtract = false;
 
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '--global') includeGlobal = true;
+    else if (args[i] === '--subtract') subtract = true;
     else if (args[i] === '--output-file' && args[i + 1]) outputFile = args[++i];
     else if (!args[i].startsWith('-')) targetPath = args[i];
   }
@@ -95,6 +98,11 @@ async function main() {
   // ── Recall half: prose-judgment candidates from the pre-filter ──
   const claudeMdFiles = (discovery.files || []).filter((f) => f.type === 'claude-md');
   const candidates = [];
+  // Opt-in only: the subtraction axis asks a different question and must not
+  // fire on a plain `/config-audit optimize` run (brief §7 q3).
+  const subtractCands = [];
+  const subtractEntry = subtract && register ? confirmedEntry(register, 'BP-SUB-001') : null;
+
   for (const file of claudeMdFiles) {
     let content;
     try {
@@ -105,6 +113,28 @@ async function main() {
     const parsed = parseFrontmatter(content);
     const body = parsed.body || content;
     const bodyStartLine = parsed.bodyStartLine || 1;
+
+    if (subtractEntry) {
+      for (const cand of subtractionCandidates(body)) {
+        subtractCands.push({
+          file: file.absPath,
+          line: bodyStartLine - 1 + cand.startLine,
+          endLine: bodyStartLine - 1 + cand.endLine,
+          lineCount: cand.lineCount,
+          lensCheck: cand.lensCheck,
+          mechanism: cand.mechanism,
+          signalText: cand.text,
+          register: {
+            id: subtractEntry.id,
+            claim: subtractEntry.claim,
+            recommendation: subtractEntry.recommendation || null,
+            severity: subtractEntry.severity || 'low',
+            source: subtractEntry.source,
+          },
+        });
+      }
+    }
+
     for (const cand of prefilterClaudeMd(body)) {
       const entry = register ? confirmedEntry(register, cand.registerId) : null;
       if (!entry) continue; // never surface an unverifiable recommendation
@@ -161,6 +191,29 @@ async function main() {
     },
   };
 
+  // Additive ONLY under --subtract: a plain run's payload must stay byte-identical.
+  if (subtract) {
+    payload.subtract = {
+      enabled: true,
+      candidates: subtractCands,
+      register: subtractEntry
+        ? [
+            {
+              id: subtractEntry.id,
+              lensCheck: subtractEntry.lensCheck,
+              claim: subtractEntry.claim,
+              recommendation: subtractEntry.recommendation || null,
+              mechanism: subtractEntry.mechanism || null,
+              severity: subtractEntry.severity || 'low',
+              source: subtractEntry.source,
+            },
+          ]
+        : [],
+      detectors: SUBTRACT_DETECTORS.map((d) => ({ ...d })),
+    };
+    payload.counts.subtractCandidates = subtractCands.length;
+  }
+
   const json = JSON.stringify(payload, null, 2);
   if (outputFile) {
     await writeFile(outputFile, json, 'utf-8');