@planu/cli 5.3.3 → 5.3.4

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/workers/handlers/auto-drift.js

@@ -154,14 +154,6 @@ async function buildDriftFindings(projectDir, effectiveChanged, activeSpecs, pro
                 driftedFiles,
                 cachedAt: new Date().toISOString(),
             });
-            // Wire drift:detected event so autopilot trigger-rules can react
-            emitAutopilotEvent({
-                name: 'drift:detected',
-                projectPath: projectDir,
-                projectId,
-                specId: spec.id,
-                payload: { driftScore, driftLevel: driftScore >= 0.7 ? 'high' : 'warning' },
-            });
             findings.push({
                 severity: driftScore >= 0.7 ? 'high' : 'warning',
                 file: '',
@@ -171,6 +163,28 @@ async function buildDriftFindings(projectDir, effectiveChanged, activeSpecs, pro
             });
         }
     }
+    if (driftScore >= threshold) {
+        // Wire drift:detected event so autopilot trigger-rules can react.
+        // Emitted once per project run — driftScore is project-wide, not per-spec,
+        // so emitting inside the loop would fire N identical events for N specs.
+        //
+        // MUST run after the cache-persistence loop above: emitAutopilotEvent
+        // dispatches handlers in a microtask (event-bus.ts), and the enabled
+        // rule drift-detected:resolve_drift_violations calls resolveDriftViolations,
+        // which loads the drift cache as its first action. Emitting before the
+        // cache entries are persisted lets that microtask race ahead and read an
+        // empty cache, silently resolving nothing.
+        emitAutopilotEvent({
+            name: 'drift:detected',
+            projectPath: projectDir,
+            projectId,
+            payload: {
+                driftScore,
+                driftLevel: driftScore >= 0.7 ? 'high' : 'warning',
+                specIds: activeSpecs.map((s) => s.id),
+            },
+        });
+    }
     return findings;
 }
 // ---------------------------------------------------------------------------

package/dist/tools/create-spec.js

@@ -1030,6 +1030,11 @@ async function prepareCreateSpecCandidate(initialParams, server) {
         },
     }));
     spec.generation = generatedSpec.generation;
+    // SPEC-1406 (DEFECT 4, round 2): FallbackGenerator no longer emits an unconditional
+    // warning, so qualityWarnings only needs the non-empty guard now — the redundant
+    // constant-string filter was removed from create-spec.ts, fallback-generator.ts and
+    // opus-generator.ts (dead code, reverted) so the literal doesn't have to stay
+    // byte-identical across three files.
     spec.qualityWarnings =
         generatedSpec.qualityWarnings.length > 0 ? generatedSpec.qualityWarnings : undefined;
     const baseCriteria = extractCriteria(generatedSpec.specBody).map((criterion) => criterion.text);

package/dist/tools/update-status/evidence-gate.js

@@ -68,7 +68,7 @@ import { captureValidationFreshnessLease } from '../../engine/validation/validat
 import { computeDurableValidationBindings, toValidationReceiptBindings, } from '../../engine/validation/durable-validation.js';
 import { checkReconciliationFreshness } from '../../engine/evidence-gates/reconciliation-freshness.js';
 import { extractCanonicalFileOwnership } from '../../engine/handoff-packager.js';
-import { generateDiscoverySkeleton, generateTaskPlanSkeleton, writeEvidenceSkeleton, } from '../../engine/evidence-gates/evidence-skeletons.js';
+import { generateTaskPlanSkeleton, writeEvidenceSkeleton, } from '../../engine/evidence-gates/evidence-skeletons.js';
 import { extractSection } from '../../engine/spec-format/markdown-sections.js';
 const CANONICAL_SCOPE_PATH = /(?:src|tests|scripts|website)\/[\w/.@-]+\.\w+/g;
 /** SPEC-1356: repo-relative paths mentioned in the spec's Problem/Technical prose also count
@@ -187,28 +187,21 @@ function isArtifactAbsent(artifacts, label) {
     return !artifacts.invalidArtifacts.some((entry) => entry.startsWith(label));
 }
 /**
- * SPEC-1356: self-heal missing (not malformed) discovery/task-plan handoff evidence by
- * generating a schema-valid skeleton and persisting it, instead of blocking the transition
- * on a manual authoring step. Malformed existing artifacts still fail the gate as before.
+ * SPEC-1356: self-heal missing (not malformed) task-plan handoff evidence by generating a
+ * schema-valid skeleton and persisting it, instead of blocking the transition on a manual
+ * authoring step. Malformed existing artifacts still fail the gate as before.
+ *
+ * SPEC-1406 (DEFECT 3): discovery evidence for `approved` is intentionally NOT self-healed —
+ * writing a skeleton here made the blocking discovery gate self-certify by fabricating the
+ * evidence it was supposed to require. `checkLifecycleEvidenceGate` (lifecycle-gate.ts) reports
+ * `discovery_missing` with the specific missing fields named when discovery is absent, and that
+ * is the intended, honest outcome.
  */
 async function autofillMissingEvidenceSkeletons(args) {
     if (args.spec.scope === 'trivial') {
         return args.artifacts;
     }
     let artifacts = args.artifacts;
-    if (args.transition === 'approved' &&
-        !artifacts.discovery &&
-        isArtifactAbsent(artifacts, 'Discovery evidence')) {
-        const skeleton = generateDiscoverySkeleton({ spec: args.spec, body: args.body });
-        await writeEvidenceSkeleton({
-            projectId: args.projectId,
-            specId: args.specId,
-            filename: 'discovery.json',
-            artifact: skeleton,
-        });
-        console.warn('[planu:evidence-skeleton]', { specId: args.specId, filename: 'discovery.json' });
-        artifacts = { ...artifacts, discovery: skeleton };
-    }
     if (args.transition === 'implementing' &&
         !artifacts.taskPlan &&
         isArtifactAbsent(artifacts, 'Task plan evidence')) {

package/dist/tools/update-status/transition-guard.js

@@ -7,7 +7,7 @@ import { scoreAmbiguityFromPath } from '../../engine/ambiguity-scorer.js';
 import { checkSpecReadiness } from '../../engine/readiness-checker.js';
 import { validateEnglishOnlySpecText } from '../../engine/spec-language/english-only.js';
 import { checkGroundedSpecContract } from '../../engine/spec-grounding/contract.js';
-import { checkGenericSpecOutput } from '../../engine/spec-quality/generic-output-gate.js';
+import { checkGenericSpecOutput, STRUCTURAL_INTERPOLATION_KIND, } from '../../engine/spec-quality/generic-output-gate.js';
 import { formatKeyValue } from '../output-formatter.js';
 import { getResolvedChallengeEvidence, requiredResolvedChallenges, } from '../challenge-spec/challenge-report.js';
 import { evaluateSpecDependencies } from '../../engine/dependency-evaluator.js';
@@ -319,14 +319,22 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
         };
     }
     const genericOutputGate = checkGenericSpecOutput(body);
-    if (!genericOutputGate.passed) {
+    // SPEC-1406: structural-interpolation findings warn instead of block here — the
+    // `create_spec` call site is where this new detector is blocking; ~1100 already-persisted
+    // specs must stay transitionable at update_status even if their rendered body still
+    // contains an interpolated-list pattern.
+    const blockingGenericOutputIssues = genericOutputGate.issues.filter((issue) => issue.kind !== STRUCTURAL_INTERPOLATION_KIND);
+    const structuralInterpolationWarnings = genericOutputGate.issues
+        .filter((issue) => issue.kind === STRUCTURAL_INTERPOLATION_KIND)
+        .map((issue) => `${issue.phrase}: ${issue.reason}`);
+    if (blockingGenericOutputIssues.length > 0) {
         return {
             blockResult: {
                 content: [
                     {
                         type: 'text',
                         text: `Spec quality gate blocked transition to ${newStatus}. ` +
-                            genericOutputGate.issues
+                            blockingGenericOutputIssues
                                 .slice(0, 3)
                                 .map((issue) => `${issue.phrase}: ${issue.reason}`)
                                 .join('; '),
@@ -336,11 +344,15 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
                 structuredContent: {
                     error: 'GENERIC_SPEC_OUTPUT_BLOCKED',
                     sddConstitutionRuleId: 'sdd.no-generic-output',
-                    issues: genericOutputGate.issues,
+                    issues: blockingGenericOutputIssues,
                     fixHint: 'Replace generic criteria or placeholder references with grounded, testable behavior before review or approval.',
                 },
             },
-            qualityWarnings: [],
+            // SPEC-1406 (AC3, round 2): the offending section must be named in the output on
+            // every return path, not only the success path — this blockResult already fired
+            // for a different reason, but any structural-interpolation warnings computed above
+            // are still real findings and must not be dropped.
+            qualityWarnings: structuralInterpolationWarnings,
         };
     }
     let readiness;
@@ -350,7 +362,7 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
     catch (error) {
         /* reliability-optional: READINESS_EVALUATION_FAILED — transition fails closed below */
         reportClassifiedDegradation('READINESS_EVALUATION_FAILED', error);
-        return readinessUnavailable('READINESS_EVALUATION_FAILED', error instanceof Error ? error.message : 'readiness evaluation failed');
+        return readinessUnavailable('READINESS_EVALUATION_FAILED', error instanceof Error ? error.message : 'readiness evaluation failed', structuralInterpolationWarnings);
     }
     const { score } = readiness;
     const blockers = [...readiness.issues.blockers];
@@ -377,7 +389,7 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
                         fixHint: 'Add at least 3 testable acceptance criteria before moving to review.',
                     },
                 },
-                qualityWarnings: [],
+                qualityWarnings: structuralInterpolationWarnings,
             };
         }
         const question = {
@@ -412,11 +424,11 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
                     interactiveQuestions: [question],
                 },
             },
-            qualityWarnings: [],
+            qualityWarnings: structuralInterpolationWarnings,
         };
     }
     if (readiness.ready) {
-        return { blockResult: null, qualityWarnings: [] };
+        return { blockResult: null, qualityWarnings: structuralInterpolationWarnings };
     }
     const diagnostic = score < 70
         ? `score ${String(score)}/100 is below the 70 threshold`
@@ -442,13 +454,13 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
                     fixHint: 'Complete the spec before moving from draft to review.',
                 },
             },
-            qualityWarnings: [],
+            qualityWarnings: structuralInterpolationWarnings,
         };
     }
     // Score < 70
     if (forceApprove) {
         // Caller wants to force through — proceed with warnings attached
-        return { blockResult: null, qualityWarnings: issues };
+        return { blockResult: null, qualityWarnings: [...issues, ...structuralInterpolationWarnings] };
     }
     const question = {
         header: 'Readiness gate',
@@ -486,7 +498,7 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
                 interactiveQuestions: [question],
             },
         },
-        qualityWarnings: [],
+        qualityWarnings: structuralInterpolationWarnings,
     };
 }
 function gateUnavailableResult(code, message) {
@@ -496,8 +508,8 @@ function gateUnavailableResult(code, message) {
         structuredContent: { error: code, message, retryable: true },
     };
 }
-function readinessUnavailable(code, message) {
-    return { blockResult: gateUnavailableResult(code, message), qualityWarnings: [] };
+function readinessUnavailable(code, message, qualityWarnings = []) {
+    return { blockResult: gateUnavailableResult(code, message), qualityWarnings };
 }
 /**
  * SPEC-964: Challenge gate — block 'review' if challenge_spec was never run

package/dist/types/spec-quality.d.ts

@@ -35,7 +35,12 @@ export interface SpecQualityReport {
         risk: QualityDimensionDetail;
     };
 }
-export type GenericSpecOutputIssueKind = 'generic-criterion' | 'unsupported-verification' | 'placeholder-reference' | 'generic-technical-reference';
+export type GenericSpecOutputIssueKind = 'generic-criterion' | 'unsupported-verification' | 'placeholder-reference' | 'generic-technical-reference'
+/** SPEC-1406: dedicated kind for structural-interpolation findings (checkInterpolatedSections).
+ * Kept distinct from 'generic-technical-reference' — severity routing in transition-guard.ts
+ * and sdd-rules-registry.ts filters BY KIND, so aliasing the two would silently downgrade
+ * whichever kind collides the day something else emits the shared value. */
+ | 'structural-interpolation';
 export interface GenericSpecOutputIssue {
     kind: GenericSpecOutputIssueKind;
     phrase: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "5.3.3",
+  "version": "5.3.4",
   "description": "Planu — MCP Server for Spec Driven Development with native Rust acceleration for hot paths. Cross-platform (Linux/macOS/Windows, x64/arm64, glibc/musl).",
   "type": "module",
   "main": "dist/index.js",
@@ -35,14 +35,14 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "5.3.3",
-    "@planu/core-darwin-x64": "5.3.3",
-    "@planu/core-linux-arm64-gnu": "5.3.3",
-    "@planu/core-linux-arm64-musl": "5.3.3",
-    "@planu/core-linux-x64-gnu": "5.3.3",
-    "@planu/core-linux-x64-musl": "5.3.3",
-    "@planu/core-win32-arm64-msvc": "5.3.3",
-    "@planu/core-win32-x64-msvc": "5.3.3"
+    "@planu/core-darwin-arm64": "5.3.4",
+    "@planu/core-darwin-x64": "5.3.4",
+    "@planu/core-linux-arm64-gnu": "5.3.4",
+    "@planu/core-linux-arm64-musl": "5.3.4",
+    "@planu/core-linux-x64-gnu": "5.3.4",
+    "@planu/core-linux-x64-musl": "5.3.4",
+    "@planu/core-win32-arm64-msvc": "5.3.4",
+    "@planu/core-win32-x64-msvc": "5.3.4"
   },
   "engines": {
     "node": ">=24.0.0"

package/planu-native.json

@@ -1,7 +1,7 @@
 {
   "name": "dev.planu.native",
   "displayName": "Planu Native Lightweight Surface",
-  "version": "5.3.3",
+  "version": "5.3.4",
   "packageName": "@planu/cli",
   "modes": {
     "lightweight": {

package/planu-plugin.json

@@ -2,7 +2,7 @@
   "name": "dev.planu.cli",
   "displayName": "Planu — Spec Driven Development",
   "description": "Manage software specs, estimations, and autonomous SDD workflows. Language-agnostic MCP server for Claude Code.",
-  "version": "5.3.3",
+  "version": "5.3.4",
   "icon": "assets/plugin/icon.svg",
   "command": ["npx", "@planu/cli@latest"],
   "packageName": "@planu/cli",