feat(trekplan): Regression and On failure step rules, and trial 2's minor fixes

The minor points (B8-B12, C13, C14, C16, C17) of the second voyage-lekerepo
trial (2026-10-08), each verified against the code and started with a test
that failed first.

- K10: optional step field `Regression:` - one command the criteria runner
  allows, unpiped; plan-validator refuses one that can never run
  (PLAN_STEP_REGRESSION_NOT_RUNNABLE). Any plan_version, no bump.
- K11: `On failure:` opens with revert | retry | skip | escalate, or the
  validator warns (PLAN_STEP_ON_FAILURE_UNKNOWN); onFailureAction in
  plan-schema.
- B8 (operator decision 2026-10-08): minors open after the last critic round
  are listed numbered in the Phase 10 summary; the ones the operator picks are
  fixed and get one more round (--extra-round when the 3 are spent).
- B11: plan-review dedup merges two reviewers' findings on the same file:line
  with the same content (trial pair: Jaccard 0.44, overlap 0.83); the Jaccard
  threshold for every other pair is unchanged.
- B12: /trekbrief Step 4c says the reviewer runs in the background and is
  waited for, not "foreground, blocking".
- C13: the Phase 4 size count includes .mjs, .cjs, .mts, .cts.
- C14: --evidence shows the first output line on PASS rows.
- C16: findings-schema checks path:line citations in finding prose (error) and
  in the prose around the block (warning) against the file.
- C17: git-historian gets the brief, never proposes changing a frozen file,
  and names the remote from `git remote -v`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

lib/validators/plan-validator.mjs

@@ -22,6 +22,14 @@
 //     criteria runner's allowlist, and each `End-to-end:` command also stands
 //     under `## Verification`, where Phase 7 runs it.
 // Strict mode reports these as errors; --soft downgrades them to warnings.
+//
+// Every plan version (the fields are new; a plan without them is unchanged):
+//   - K10: the optional step field `Regression:` holds ONE command the
+//     criteria runner's allowlist runs (first backticked span, no pipe, no
+//     `&&`); the executor runs it green before the step's checkpoint. One that
+//     can never run is an error (a warning under --soft).
+//   - K11: `On failure:` opens with revert | retry | skip | escalate, the words
+//     /trekexecute reads; any other opening is a warning.
 
 import { readFileSync, existsSync, realpathSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
@@ -29,6 +37,7 @@ import {
   sliceSteps, validatePlanHeadings, extractPlanVersion, extractPlanCeremony,
   parseStepFields, findSection, splitSections, findModuleCycle, parseMermaid, fencedBlocks,
   versionAtLeast, PLAN_VERSION_CURRENT, PLAN_VERSIONS_SUPPORTED, CEREMONY_VALUES,
+  ON_FAILURE_ACTIONS, onFailureAction,
 } from '../parsers/plan-schema.mjs';
 import { validateAllManifests } from '../parsers/manifest-yaml.mjs';
 import { parseDocument } from '../util/frontmatter.mjs';
@@ -125,6 +134,36 @@ function checkRunnable(text, sections, opts) {
   return out;
 }
 
+/**
+ * K10 and K11. `Verify:` is both the step's one test command and its proof of
+ * red, so a step whose red test is a shell script could not also run the frozen
+ * suite before its checkpoint; the plan wrote "run npm test before the
+ * checkpoint" in prose that nothing enforced (voyage-lekerepo trial 2,
+ * 2026-10-08). `Regression:` is that command, checked like `Verify:`.
+ */
+function checkRecovery(sections, opts) {
+  const errors = [];
+  const warnings = [];
+  for (const s of sections) {
+    const f = parseStepFields(s.body);
+    if (f.has('Regression')) {
+      const r = runnableCheck(firstCommand(f.get('Regression').text), opts);
+      if (!r.runnable) {
+        errors.push(issue('PLAN_STEP_REGRESSION_NOT_RUNNABLE',
+          `Step ${s.n}: \`Regression:\` is not one runnable command (${r.reason})`,
+          'Backtick ONE command the criteria runner allows, unpiped and without `&&` (`npm test`); ' +
+            `the executor runs it green before the checkpoint. ${WAY_IN}`));
+      }
+    }
+    if (f.has('On failure') && onFailureAction(f.get('On failure').text) === null) {
+      warnings.push(issue('PLAN_STEP_ON_FAILURE_UNKNOWN',
+        `Step ${s.n}: \`On failure:\` does not open with a recovery word the executor reads`,
+        `Open with one of ${ON_FAILURE_ACTIONS.join(' | ')}, then the specifics (\`retry once, then escalate\`).`));
+    }
+  }
+  return { errors, warnings };
+}
+
 /** Table body rows (skips the header and the |---| separator). */
 function tableRows(text) {
   const rows = text.split('\n').filter(l => l.trim().startsWith('|'));
@@ -230,6 +269,11 @@ export function validatePlanContent(rawText, opts = {}) {
     warnings.push(issue('PLAN_VERSION_MISMATCH', `plan_version=${planVersion}, current target is ${PLAN_VERSION_CURRENT}`));
   }
 
+  const recovery = checkRecovery(sections, { cwd: opts.cwd });
+  if (strict) errors.push(...recovery.errors);
+  else warnings.push(...recovery.errors);
+  warnings.push(...recovery.warnings);
+
   const ceremony = extractPlanCeremony(text);
   if (versionAtLeast(planVersion, '1.8')) {
     const v18 = [...checkSteps(sections), ...checkRunnable(text, sections, { cwd: opts.cwd })];