@planu/cli 5.3.3 → 5.3.5

package/dist/engine/planu-core.win32-x64-msvc.node.sbom.json

@@ -4,14 +4,14 @@
   "version": 1,
   "metadata": {
     "component": {
-      "bom-ref": "pkg:cargo/planu-core@5.3.3",
+      "bom-ref": "pkg:cargo/planu-core@5.3.5",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.3",
+      "version": "5.3.5",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "5da0cd500b980f5a7295886298ea9176905bc38190fee2a7eae3359ec59513e9"
+          "content": "266c514673274fe29f5d625cf33524e203371741f320e6933c0231824506e433"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.3",
+      "ref": "pkg:cargo/planu-core@5.3.5",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

package/dist/engine/reconcile/apply-changes.d.ts

@@ -1,16 +1,4 @@
 import { type ReconcileChange, type ApplyChangesResult } from '../../types/index.js';
 export type { ApplyChangesResult, SkippedChange } from '../../types/index.js';
-/**
- * Apply approved text changes to the spec.md body.
- *
- * For each non-metadata approved change:
- * 1. Locate the named section's body via heading anchor.
- * 2. Require exactly one occurrence of `originalValue` inside that section.
- * 3. Replace it in-place at the resolved absolute offset.
- *
- * Skips (with reason) when the section heading is absent, the value is missing
- * inside the section, or the value appears multiple times (ambiguous match).
- * Writes only when at least one substitution succeeded.
- */
 export declare function applyChangesToSpec(specPath: string, changes: ReconcileChange[]): Promise<ApplyChangesResult>;
 //# sourceMappingURL=apply-changes.d.ts.map

package/dist/engine/reconcile/apply-changes.js

@@ -1,19 +1,9 @@
-// engine/reconcile/apply-changes.ts — SPEC-1011 Bug D: Apply approved text changes to spec.md
-// Replacement is section-anchored to prevent silent cross-section mutations:
-// the originalValue is searched only inside the named section's body (between its
-// heading and the next heading at the same or shallower level), and the change is
-// applied only when the match is unique within those bounds.
 import { readFile } from 'node:fs/promises';
 import { atomicWriteFile } from '../safety/atomic-write-file.js';
-import { RECONCILE_METADATA_SECTIONS, } from '../../types/index.js';
+import { SECTIONS_WITHOUT_LITERAL_BODY_TEXT, } from '../../types/index.js';
 function escapeRegex(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-/**
- * Find the body bounds of a markdown section by heading name.
- * Returns the [start, end) offsets of the section body (after the heading line,
- * up to the next heading at the same or shallower level — or EOF).
- */
 function findSectionBounds(content, section) {
     const headingRe = new RegExp(`^(#{1,6})\\s+${escapeRegex(section)}\\s*$`, 'mi');
     const match = headingRe.exec(content);
@@ -22,16 +12,12 @@ function findSectionBounds(content, section) {
     }
     const headingLevel = match[1]?.length ?? 0;
     const start = match.index + match[0].length;
-    // Find next heading at same-or-shallower level
-    const nextRe = new RegExp(`^#{1,${String(headingLevel)}}\\s+\\S`, 'gm');
-    nextRe.lastIndex = start;
-    const next = nextRe.exec(content);
+    const nextHeadingAtSameOrShallowerLevelRe = new RegExp(`^#{1,${String(headingLevel)}}\\s+\\S`, 'gm');
+    nextHeadingAtSameOrShallowerLevelRe.lastIndex = start;
+    const next = nextHeadingAtSameOrShallowerLevelRe.exec(content);
     return { start, end: next ? next.index : content.length };
 }
-/**
- * Count non-overlapping occurrences of `needle` in `haystack`.
- */
-function countOccurrences(haystack, needle) {
+function countNonOverlappingOccurrences(haystack, needle) {
     if (needle.length === 0) {
         return 0;
     }
@@ -45,20 +31,8 @@ function countOccurrences(haystack, needle) {
     }
     return count;
 }
-/**
- * Apply approved text changes to the spec.md body.
- *
- * For each non-metadata approved change:
- * 1. Locate the named section's body via heading anchor.
- * 2. Require exactly one occurrence of `originalValue` inside that section.
- * 3. Replace it in-place at the resolved absolute offset.
- *
- * Skips (with reason) when the section heading is absent, the value is missing
- * inside the section, or the value appears multiple times (ambiguous match).
- * Writes only when at least one substitution succeeded.
- */
 export async function applyChangesToSpec(specPath, changes) {
-    const approvedTextChanges = changes.filter((c) => c.approved && !RECONCILE_METADATA_SECTIONS.has(c.section));
+    const approvedTextChanges = changes.filter((c) => c.approved && !SECTIONS_WITHOUT_LITERAL_BODY_TEXT.has(c.section));
     if (approvedTextChanges.length === 0) {
         return { applied: 0, skipped: [], fileWritten: false };
     }
@@ -74,6 +48,7 @@ export async function applyChangesToSpec(specPath, changes) {
                 section: c.section,
                 originalValue: c.originalValue,
                 reason: `Cannot read spec.md: ${reason}`,
+                reasonCategory: 'skipped',
             })),
             fileWritten: false,
         };
@@ -88,16 +63,18 @@ export async function applyChangesToSpec(specPath, changes) {
                 section: change.section,
                 originalValue: change.originalValue,
                 reason: `Section heading "${change.section}" not found in spec.md`,
+                reasonCategory: 'skipped',
             });
             continue;
         }
         const sectionBody = modified.slice(bounds.start, bounds.end);
-        const occurrences = countOccurrences(sectionBody, change.originalValue);
+        const occurrences = countNonOverlappingOccurrences(sectionBody, change.originalValue);
         if (occurrences === 0) {
             skipped.push({
                 section: change.section,
                 originalValue: change.originalValue,
                 reason: `originalValue not found in section "${change.section}"`,
+                reasonCategory: 'skipped',
             });
             continue;
         }
@@ -106,6 +83,7 @@ export async function applyChangesToSpec(specPath, changes) {
                 section: change.section,
                 originalValue: change.originalValue,
                 reason: `originalValue is ambiguous (${String(occurrences)} matches in section "${change.section}")`,
+                reasonCategory: 'ambiguous',
             });
             continue;
         }

package/dist/engine/reconcile/verify-write.js

@@ -1,7 +1,7 @@
 // engine/reconcile/verify-write.ts — SPEC-1011 Bug D: Post-write integrity verification
 // After reconcile_spec writes changes, re-reads the file to assert each newValue is present.
 import { readFile } from 'node:fs/promises';
-import { RECONCILE_METADATA_SECTIONS, } from '../../types/index.js';
+import { SECTIONS_WITHOUT_LITERAL_BODY_TEXT, } from '../../types/index.js';
 /**
  * Re-reads the file at `filePath` and checks that each approved change's `newValue`
  * is present somewhere in the file content.
@@ -30,8 +30,7 @@ export async function verifyWriteSucceeded(filePath, changes) {
     }
     const missingChanges = [];
     for (const change of approvedChanges) {
-        // Skip metadata-only sections that do not produce text in spec.md
-        if (RECONCILE_METADATA_SECTIONS.has(change.section)) {
+        if (SECTIONS_WITHOUT_LITERAL_BODY_TEXT.has(change.section)) {
             continue;
         }
         if (!content.includes(change.newValue)) {

package/dist/engine/rules-reconciler.js

@@ -67,7 +67,23 @@ function buildCoverageMap(rulesFiles, allRules) {
  *
  * A file is "stale" when it has NO categories in common with CLAUDE.md categories.
  */
-function detectStaleRules(rulesFiles, allRules, claudeCategories) {
+function manifestOwnedRuleFiles(projectPath) {
+    const raw = readFileSafe(join(projectPath, '.claude', 'rules', '.planu-rules-manifest.json'));
+    if (!raw) {
+        return new Set();
+    }
+    try {
+        const manifest = JSON.parse(raw);
+        return new Set((manifest.rules ?? [])
+            .map((rule) => rule.path)
+            .filter((path) => typeof path === 'string')
+            .map((path) => basename(path)));
+    }
+    catch {
+        return new Set();
+    }
+}
+function detectStaleRules(rulesFiles, allRules, claudeCategories, manifestOwned) {
     // Build per-file category sets
     const fileCategories = new Map();
     for (const r of allRules) {
@@ -80,6 +96,9 @@ function detectStaleRules(rulesFiles, allRules, claudeCategories) {
     }
     const stale = [];
     for (const filePath of rulesFiles) {
+        if (manifestOwned.has(basename(filePath))) {
+            continue;
+        }
         const cats = fileCategories.get(filePath);
         if (!cats || cats.size === 0) {
             // No parseable conventions found — candidate for stale
@@ -162,7 +181,7 @@ export function reconcileRules(projectPath) {
             }
         }
         // 5. Detect stale rules files
-        const staleRules = detectStaleRules(rulesFiles, allRules, claudeCategories);
+        const staleRules = detectStaleRules(rulesFiles, allRules, claudeCategories, manifestOwnedRuleFiles(projectPath));
         // 6. Auto-patch: generate new rules files for uncovered categories
         const updatedRules = [];
         for (const category of newRulesNeeded) {

package/dist/engine/spec-format/acceptance-criteria.js

@@ -5,7 +5,7 @@ import { stripFencedBlocks } from './text-fences.js';
 import { createCriterionIdentity, normalizeCriterionText } from '../criterion-identity.js';
 const BDD_STEP = /^(GIVEN|WHEN|THEN|AND|DADO|CUANDO|ENTONCES|Y)\b/i;
 const BDD_START = /^(GIVEN|DADO)\b/i;
-const TECHNICAL_MARKER = /^(FILES|FUNCTIONS|TEST|OWNER):/i;
+const TECHNICAL_MARKER = /^(FILES|FUNCTIONS|TEST|OWNER|NOTE):/i;
 const EXPLICIT_CRITERION_HEADING = /^#{3,6}\s+((?:AC|AB)\s*-?\s*\d+)\b/i;
 function extractBddBlocks(section) {
     const lines = section.split('\n').map((line) => line.trim());
@@ -38,6 +38,12 @@ function extractBddBlocks(section) {
             current.push(withoutListMarker);
             continue;
         }
+        // Wrapped continuation of the step above: keep it, or the criterion identity
+        // truncates at the physical Markdown wrap boundary (SPEC-1253). A line that
+        // carried its own list marker is a sibling item, never a wrap.
+        if (current.length > 0 && withoutListMarker === line) {
+            current.push(withoutListMarker);
+        }
     }
     if (current.length > 0) {
         bddBlocks.push(current.join(' '));

package/dist/engine/spec-format/unified-spec-builder.js

@@ -2,6 +2,7 @@
 // Closes the SPEC-630 residue: every new spec is born unified, never written as a
 // two-file spec.md + technical.md pair only to be merged on the next list_specs run.
 import { stripFrontmatter } from '../frontmatter-parser.js';
+import { extractAcceptanceCriteriaTexts } from './acceptance-criteria.js';
 const REQUIRED_SECTIONS = [
     'Problem',
     'Goal',
@@ -254,18 +255,41 @@ function firstSentence(text) {
         .find((part) => part.length > 0 && !part.startsWith('#'));
     return sentence ?? null;
 }
-function extractExecutableCriteria(source, criteria) {
-    const explicit = /\bGIVEN\b[\s\S]*?(?=(?:\n##|\bFILES:|\bFUNCTIONS:|\bTEST:|$))/i
-        .exec(source)?.[0]
-        ?.trim()
-        .replace(/[.\s]+$/, '.');
-    if (explicit) {
-        return `- ${explicit}`;
-    }
+function fallbackCriteriaBullets(criteria) {
     return criteria
         .map((criterion) => `- GIVEN the requested change is implemented WHEN the behavior is exercised THEN ${criterion.text}`)
         .join('\n');
 }
+// Same BDD step vocabulary `acceptance-criteria.ts` recognizes (English + Spanish).
+// A criterion already starting with one of these is a genuine BDD fragment
+// (a full GIVEN/WHEN/THEN block, or an AND continuation of one) — leave it as-is.
+const BDD_STEP_START = /^(GIVEN|WHEN|THEN|AND|DADO|CUANDO|ENTONCES|Y)\b/i;
+/**
+ * Render one real criterion as an executable bullet. Criteria already
+ * written in BDD form pass through untouched; plain-text criteria (e.g.
+ * checkbox items) are wrapped in the same GIVEN/WHEN/THEN scaffold
+ * `fallbackCriteriaBullets` uses, so every bullet stays BDD-executable
+ * without ever discarding a real criterion.
+ */
+function toExecutableBullet(text) {
+    const cleaned = text.trim().replace(/[.\s]+$/, '.');
+    if (BDD_STEP_START.test(cleaned)) {
+        return `- ${cleaned}`;
+    }
+    return `- GIVEN the requested change is implemented WHEN the behavior is exercised THEN ${cleaned}`;
+}
+/**
+ * Criteria resolve through the canonical parser in `acceptance-criteria.ts`
+ * so the renderer and `readiness-checker.ts` can never disagree about how
+ * many criteria a spec has.
+ */
+function extractExecutableCriteria(source, criteria) {
+    const parsed = extractAcceptanceCriteriaTexts(source);
+    if (parsed.length === 0) {
+        return fallbackCriteriaBullets(criteria);
+    }
+    return parsed.map(toExecutableBullet).join('\n');
+}
 function renderOwnedFiles(files) {
     const sections = [];
     for (const [title, entries] of [

package/dist/engine/spec-generator/fallback-generator.js

@@ -22,9 +22,11 @@ export class FallbackGenerator {
                 method: 'deterministic',
                 generatedAt: new Date().toISOString(),
             },
-            qualityWarnings: [
-                'Fallback generator used. Source description was preserved; missing decisions require explicit user input.',
-            ],
+            // SPEC-1406 (DEFECT 4, round 2): this generator is the only one wired into
+            // production (create-spec.ts:1430), so this warning fired unconditionally on
+            // every spec ever created — a warning with 100% incidence and no gate consumer
+            // carries no signal. Only qualityWarnings from actual quality issues remain.
+            qualityWarnings: [],
             fallbackReason: 'No external model generator is configured for create_spec.',
         });
     }

package/dist/engine/spec-quality/generic-output-gate.d.ts

@@ -1,3 +1,9 @@
-import type { GenericSpecOutputGateResult } from '../../types/index.js';
+import type { GenericSpecOutputGateResult, GenericSpecOutputIssueKind } from '../../types/index.js';
+/**
+ * SPEC-1406 (DEFECT 2 fix): the constant kind reused to mark structural-interpolation
+ * findings so callers can tell them apart from the other generic-output issue kinds and
+ * decide, per call site, whether that finding blocks or only warns.
+ */
+export declare const STRUCTURAL_INTERPOLATION_KIND: GenericSpecOutputIssueKind;
 export declare function checkGenericSpecOutput(content: string): GenericSpecOutputGateResult;
 //# sourceMappingURL=generic-output-gate.d.ts.map

package/dist/engine/spec-quality/generic-output-gate.js

@@ -1,6 +1,45 @@
-const CRITERIA_SECTION_RE = /^criteria:\n([\s\S]*?)(?=^[a-zA-Z_][\w-]*:|\n---|\s*$)/m;
+/** Bounds the search for criteria to the frontmatter block only (between the two `---`
+ * delimiters), so criterion-shaped lines never leak in from the rendered body below it. */
+const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---/;
+/**
+ * SPEC-1406 (DEFECT 1, round 4 — detector was inert on real specs): matches a criterion's
+ * `- text: "..."` line regardless of nesting depth, so it covers BOTH shapes this generator
+ * renders (`lean-spec-generator.ts`): the top-level checkbox `criteria:` list AND the BDD
+ * `grounding: criteria:` list nested under `grounding:` (see
+ * `contract.ts:renderGroundingFrontmatter`, `    - text: "..."`). The previous version only
+ * looked inside a slice bounded by a single-line lookahead that matched line-end (`\s*$`
+ * under `/m`) after the FIRST criterion, so multi-criterion checkbox specs (e.g. SPEC-001,
+ * 6 criteria) only ever contributed their first entry — and it never ran at all against
+ * `scenarios:`-shaped (BDD) specs, which have no top-level `criteria:` key, so criteria was
+ * always `[]` there and `isInterpolatedTemplate`'s `criteria.length === 0` guard made every
+ * BDD spec's filler unflaggable by construction. Scanning the whole frontmatter block with
+ * this regex (plus SCENARIO_TITLE_RE below) fixes both defects in one pass — no truncating
+ * section boundary is needed once matching isn't anchored to a single top-level key.
+ */
 const CRITERION_TEXT_RE = /^\s+- text:\s*"?(.+?)"?\s*$/gm;
+/** Matches a BDD scenario's `- title: "..."` line (`bdd-parser.ts:renderBddScenariosYaml`) —
+ * the criterion-equivalent for `scenarios:`-format specs, which have no `- text:` entries. */
+const SCENARIO_TITLE_RE = /^\s+- title:\s*"?(.+?)"?\s*$/gm;
 const FILE_LINE_RE = /^-\s+(.+?)\s+\((pending|done)\)\s*$/gm;
+const H3_HEADING_RE = /^###[ \t]+(.+?)[ \t]*$/gm;
+const BULLET_LINE_RE = /^[-*][ \t]+(.+)$/;
+/** A bullet that, once a leading `Label:`, wrapping backticks, and a trailing `(status)`
+ * marker are stripped, is just a file path: contains a `/` and ends in a short extension.
+ * File/artifact lists (`Files`, `Modify`, `Create`, `Test`, `File-Level Work Plan`, or any
+ * future heading with this shape) are legitimately parallel — the interpolation detector
+ * must not run on them. Detected structurally so no heading name needs hardcoding. */
+const BULLET_LABEL_PREFIX_RE = /^[\w-]+:\s*/;
+const STATUS_SUFFIX_RE = /\s*\([\w .-]+\)$/;
+const PATH_TOKEN_RE = /^[\w./-]+\/[\w.-]+\.[a-zA-Z0-9]{1,10}$/;
+/** Minimum normalized length before a variable substring can count as "restating" a
+ * criterion — guards against trivial short-string collisions. */
+const CRITERION_RESTATEMENT_MIN_LENGTH = 8;
+/**
+ * SPEC-1406 (DEFECT 2 fix): the constant kind reused to mark structural-interpolation
+ * findings so callers can tell them apart from the other generic-output issue kinds and
+ * decide, per call site, whether that finding blocks or only warns.
+ */
+export const STRUCTURAL_INTERPOLATION_KIND = 'structural-interpolation';
 const GENERIC_CRITERION_RULES = [
     {
         pattern: /\bimplementation (is )?complete\b/i,
@@ -50,24 +89,176 @@ const PLACEHOLDER_REFERENCE_RULES = [
     },
 ];
 export function checkGenericSpecOutput(content) {
+    const criteria = frontmatterCriteria(content);
     const issues = [
-        ...checkCriteria(frontmatterCriteria(content)),
+        ...checkCriteria(criteria),
         ...checkTechnicalReferences(content),
+        ...checkInterpolatedSections(content, criteria),
     ];
     return { passed: issues.length === 0, issues };
 }
+/**
+ * SPEC-1406 (DEFECT 2, round 2 — detector rebuilt around CRITERION RESTATEMENT): the
+ * previous prefix/suffix-length rule flagged `### File-Level Work Plan` (whose bullets
+ * legitimately share a `- Modify: \`...\` (pending)` frame around a file path) and missed
+ * the actual filler this spec exists to kill (`- AC1 failure: ...`, `- Expected behavior
+ * AC1: ...`), because the framing on those templates is interrupted by a digit
+ * (`AC1` vs `AC2`) that a plain character-by-character prefix scan treats as a mismatch.
+ * The real discriminator isn't frame length — it's whether the varying middle of each
+ * bullet is itself a restatement of a declared acceptance criterion. Digit runs are
+ * treated as mutually equal while locating the shared frame, then the extracted middle
+ * is compared against every criterion.
+ */
+function checkInterpolatedSections(content, criteria) {
+    const issues = [];
+    const headingMatches = [...content.matchAll(H3_HEADING_RE)];
+    for (let i = 0; i < headingMatches.length; i += 1) {
+        const heading = headingMatches[i];
+        if (!heading?.[1]) {
+            continue;
+        }
+        const start = heading.index + heading[0].length;
+        const end = headingMatches[i + 1]?.index ?? content.length;
+        const bullets = content
+            .slice(start, end)
+            .split('\n')
+            .map((line) => BULLET_LINE_RE.exec(line.trim())?.[1])
+            .filter((line) => Boolean(line));
+        if (isFileListSection(bullets)) {
+            continue;
+        }
+        if (isInterpolatedTemplate(bullets, criteria)) {
+            issues.push({
+                kind: STRUCTURAL_INTERPOLATION_KIND,
+                phrase: heading[1],
+                reason: `subsection "${heading[1]}" restates each criterion into the same template with no new information`,
+            });
+        }
+    }
+    return issues;
+}
+/**
+ * SPEC-1406 (DEFECT 1, round 3 — file-list false positive): a section whose bullets are
+ * mostly file paths (`### Modify`, `### Files`, `### Create`, `### Test`, `### File-Level
+ * Work Plan`, ...) is an allowlisted shape, not prose — parallel paths under a shared
+ * directory/extension carry no information loss, even when a path also happens to appear
+ * inside a criterion's `FILES:` marker. Detected structurally (allowlist, not a heading
+ * name denylist) so an unanticipated heading defaults to safe.
+ */
+function isFileListSection(bullets) {
+    if (bullets.length === 0) {
+        return false;
+    }
+    const pathLikeCount = bullets.filter(isPathLikeBullet).length;
+    return pathLikeCount > bullets.length / 2;
+}
+function isPathLikeBullet(bullet) {
+    const stripped = bullet
+        .trim()
+        .replace(BULLET_LABEL_PREFIX_RE, '')
+        .replace(STATUS_SUFFIX_RE, '')
+        .trim()
+        .replace(/^`|`$/g, '');
+    return PATH_TOKEN_RE.test(stripped);
+}
+function isInterpolatedTemplate(bullets, criteria) {
+    if (bullets.length < 2 || criteria.length === 0) {
+        return false;
+    }
+    const first = bullets[0] ?? '';
+    const prefix = commonPrefixLength(bullets);
+    const suffix = commonSuffixLength(bullets, prefix);
+    if (prefix + suffix >= first.length) {
+        // Digit-tolerant framing consumed the entire bullet: the bullets are identical
+        // except for an index digit (e.g. `AC1` vs `AC2`) with no other variable content.
+        // The digit itself isn't the restated criterion — the digit-stripped body is.
+        return bullets.every((bullet) => restatesCriterion(stripDigits(bullet), criteria));
+    }
+    return bullets.every((bullet) => {
+        const variable = bullet.slice(prefix, bullet.length - suffix);
+        return restatesCriterion(variable, criteria);
+    });
+}
+function stripDigits(value) {
+    return value.replace(/\d+/g, '');
+}
+function restatesCriterion(variable, criteria) {
+    const normalizedVariable = normalizeForRestatementMatch(variable);
+    if (normalizedVariable.length < CRITERION_RESTATEMENT_MIN_LENGTH) {
+        return false;
+    }
+    return criteria.some((criterion) => {
+        const normalizedCriterion = normalizeForRestatementMatch(criterion);
+        if (normalizedCriterion.length < CRITERION_RESTATEMENT_MIN_LENGTH) {
+            return false;
+        }
+        return (normalizedVariable.includes(normalizedCriterion) ||
+            normalizedCriterion.includes(normalizedVariable));
+    });
+}
+function normalizeForRestatementMatch(value) {
+    return value
+        .replace(/[`*_"]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+/** Digit runs are treated as mutually equal so a fixed template interrupted only by an
+ * `AC1`/`AC2`-style index still resolves to its true shared frame. */
+function charsMatch(a, b) {
+    if (a === undefined || b === undefined) {
+        return false;
+    }
+    return a === b || (isDigit(a) && isDigit(b));
+}
+function isDigit(ch) {
+    return ch >= '0' && ch <= '9';
+}
+function commonPrefixLength(values) {
+    const first = values[0] ?? '';
+    let length = first.length;
+    for (const value of values.slice(1)) {
+        let i = 0;
+        while (i < length && i < value.length && charsMatch(value[i], first[i])) {
+            i += 1;
+        }
+        length = Math.min(length, i);
+    }
+    return length;
+}
+function commonSuffixLength(values, limit) {
+    const first = values[0] ?? '';
+    let length = first.length - limit;
+    for (const value of values.slice(1)) {
+        let i = 0;
+        while (i < length &&
+            i < value.length - limit &&
+            charsMatch(value[value.length - 1 - i], first[first.length - 1 - i])) {
+            i += 1;
+        }
+        length = Math.min(length, i);
+    }
+    return Math.max(length, 0);
+}
 function frontmatterCriteria(content) {
-    const criteriaSection = CRITERIA_SECTION_RE.exec(content)?.[1] ?? '';
-    const criteria = [];
-    let match = CRITERION_TEXT_RE.exec(criteriaSection);
+    const frontmatter = FRONTMATTER_RE.exec(content)?.[1] ?? '';
+    return [
+        ...collectMatches(frontmatter, CRITERION_TEXT_RE),
+        ...collectMatches(frontmatter, SCENARIO_TITLE_RE),
+    ];
+}
+function collectMatches(text, pattern) {
+    const re = new RegExp(pattern.source, pattern.flags);
+    const values = [];
+    let match = re.exec(text);
     while (match) {
         const phrase = match[1]?.replace(/\\"/g, '"').trim() ?? '';
         if (phrase.length > 0) {
-            criteria.push(phrase);
+            values.push(phrase);
         }
-        match = CRITERION_TEXT_RE.exec(criteriaSection);
+        match = re.exec(text);
     }
-    return criteria;
+    return values;
 }
 function checkCriteria(criteria) {
     const issues = [];

package/dist/engine/spec-quality-scorer.js

@@ -1,6 +1,7 @@
 // engine/spec-quality-scorer.ts — Spec quality scoring logic (SPEC-314)
 import { readFile } from 'node:fs/promises';
 import { readSpecTechnicalSection } from './spec-format/read-technical-section.js';
+import { extractAcceptanceCriteriaTexts } from './spec-format/acceptance-criteria.js';
 import { stripFrontmatter } from './frontmatter-parser.js';
 // ── Constants ────────────────────────────────────────────────────────────────
 const MAX_DIMENSION_SCORE = 25;
@@ -67,11 +68,14 @@ async function readSpecContent(spec) {
 async function readTechnicalContent(spec) {
     return readSpecTechnicalSection(spec);
 }
+// Delegates to the canonical parser (SPEC-1410) instead of matching checkbox
+// lines only, which returned [] for every GIVEN/WHEN/THEN spec. Deliberately
+// does NOT reuse `readiness-checker.extractCriteriaLines`: that helper returns
+// every non-empty line in the section (including WHEN/THEN/FILES: lines),
+// which would inflate the denominator that scoreTestability/scoreAmbiguity
+// divide by.
 function extractCriteriaLines(content) {
-    return content
-        .split('\n')
-        .filter((line) => /^- \[[ x]\]/.test(line.trim()))
-        .map((line) => line.trim());
+    return extractAcceptanceCriteriaTexts(content);
 }
 // ── Dimension scorers ────────────────────────────────────────────────────────
 function scoreCompleteness(spec, content) {
@@ -107,7 +111,7 @@ function scoreCompleteness(spec, content) {
     }
     else {
         issues.push('No acceptance criteria found');
-        recommendations.push('Add acceptance criteria in checkbox format (- [ ] ...)');
+        recommendations.push('Add acceptance criteria in GIVEN/WHEN/THEN format');
     }
     // Scope set to non-default (5 pts) — cast to handle partial specs at runtime
     const scope = spec.scope;

package/dist/engine/universal-rules/catalog.js

@@ -10,6 +10,9 @@ import { planuApprovalGatesRule } from './rules/planu-approval-gates.js';
 import { planuReleasePolicyRule } from './rules/planu-release-policy.js';
 import { planuSddModelRoutingRule } from './rules/planu-sdd-model-routing.js';
 import { planuMinimalChangeRule } from './rules/planu-minimal-change.js';
+import { planuDebateReviewRule } from './rules/planu-debate-review.js';
+import { planuRevertProofTestsRule } from './rules/planu-revert-proof-tests.js';
+import { planuCleanCodeNoCommentsRule } from './rules/planu-clean-code-no-comments.js';
 /**
  * The full catalog of universal Planu rules.
  * Order matters: rules are installed in catalog order.
@@ -25,5 +28,8 @@ export const UNIVERSAL_RULES = [
     planuModesRule,
     agentTeamsRule,
     planuDogfoodBugsRule,
+    planuDebateReviewRule,
+    planuRevertProofTestsRule,
+    planuCleanCodeNoCommentsRule,
 ];
 //# sourceMappingURL=catalog.js.map

package/dist/engine/universal-rules/rules/agent-teams.js

@@ -1,5 +1,3 @@
-// engine/universal-rules/rules/agent-teams.ts — SPEC-779
-// Universal rule: Agent Teams (migrated from rules-generator.ts)
 function buildBody() {
     return `# Agent Teams (MANDATORY when 3+ specs in parallel)
 

package/dist/engine/universal-rules/rules/planu-approval-gates.js

@@ -1,4 +1,3 @@
-// engine/universal-rules/rules/planu-approval-gates.ts — Universal rule: approval and done gates
 function buildBody() {
     return `# Planu Approval and Done Gates
 

package/dist/engine/universal-rules/rules/planu-bdd-criteria.js

@@ -1,4 +1,3 @@
-// engine/universal-rules/rules/planu-bdd-criteria.ts — Universal rule: BDD acceptance criteria
 function buildBody() {
     return `# Planu BDD Acceptance Criteria
 

package/dist/engine/universal-rules/rules/planu-clean-code-no-comments.d.ts

@@ -0,0 +1,3 @@
+import type { UniversalRule } from '../../../types/universal-rules/index.js';
+export declare const planuCleanCodeNoCommentsRule: UniversalRule;
+//# sourceMappingURL=planu-clean-code-no-comments.d.ts.map

package/dist/engine/universal-rules/rules/planu-clean-code-no-comments.js

@@ -0,0 +1,30 @@
+function buildBody() {
+    return `# Planu Clean Code — No Comments
+
+Auto-generated by \`init_project\`. Do not edit manually.
+
+Code must be self-documenting. A comment is allowed only when the behavior cannot be expressed through naming or structure — for example a non-obvious language semantic. Everything else is a naming problem.
+
+This rule assumes \`planu-dogfood-bugs\` already prohibits deferred-work markers such as TODO/FIXME and does not restate that prohibition.
+
+## The Rule
+
+Prohibited: narrative comments that restate the code, \`(SPEC-NNNN: ...)\` rationale blocks whose history belongs in the spec and in git blame, step-by-step or section-divider comments inside a function, and JSDoc that only repeats the signature.
+
+Replacement action: Extract a helper whose name is the comment, promote a magic value to a named constant, or introduce a named type when a shape needs explaining.
+
+## Enforcement
+
+Implementation agents add narrative comments by default. Stripping them before accepting subagent output is part of reviewing that output, not an optional cleanup pass.
+`;
+}
+export const planuCleanCodeNoCommentsRule = {
+    id: 'planu-clean-code-no-comments',
+    name: 'Planu Clean Code — No Comments',
+    description: 'Prohibits narrative comments and rationale blocks, requiring named helpers or constants instead.',
+    category: 'quality',
+    applicableHosts: ['all'],
+    defaultEnabled: true,
+    buildContent: (_host) => buildBody(),
+};
+//# sourceMappingURL=planu-clean-code-no-comments.js.map