@planu/cli 5.3.31 → 5.3.33

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [5.3.33] - 2026-08-21
+
+### Bug Fixes
+- fix(spec-1587): scope creation-time placeholder scan to standalone line content
+- fix(spec-1586): harden scoreAmbiguity against tautological substring-pairs and unanchored markers
+
+### Chores
+- chore(planu): sync autopilot state for SPEC-1586/1587
+
+
+## [5.3.32] - 2026-08-21
+
+### Bug Fixes
+- fix(spec-1585): harden scope-boundary contradiction checker against topical false positives
+
+
 ## [5.3.31] - 2026-08-21
 
 ### Bug Fixes

package/dist/engine/scope-boundaries/contradiction-checker.js

@@ -37,12 +37,35 @@ const STOP_WORDS = new Set([
     'all',
     'can',
     'may',
+    'rather',
+    'than',
+    'which',
+    'would',
+    'such',
+    'same',
+    'each',
+    'also',
+    'over',
+    'onto',
 ]);
 function keywords(phrase) {
     return normalize(phrase)
         .split(' ')
         .filter((w) => w.length > 3 && !STOP_WORDS.has(w));
 }
+/**
+ * Shared negation detector: "not/without ..." or "no <non-idiom> ..." immediately before a verb.
+ * Excludes adverbial idioms ("no doubt/longer/way/matter") that do NOT negate the verb.
+ */
+function endsWithNegation(before) {
+    if (/\b(?:not|without|never)(?:\s+\w+){0,6}\s*$/.test(before)) {
+        return true;
+    }
+    if (!/\bno(?:\s+\w+){0,6}\s*$/.test(before)) {
+        return false;
+    }
+    return !/\bno\s+(?:doubt)\b(?:\s+\w+){0,5}\s*$/.test(before);
+}
 /** Return true only for explicit language that preserves an existing boundary. */
 function preservesBoundary(text) {
     const normalized = normalize(text);
@@ -53,8 +76,19 @@ function preservesBoundary(text) {
         /\bkeeps?\b.{0,80}\bunchanged\b/,
         /\bpreserves?\b.{0,80}\b(?:behavior|contract|boundary|semantics|state)\b/,
         /\bwithout (?:any )?(?:changing|modifying|altering|adding|introducing)\b/,
-        /\b(?:does|do|must|will|should) not (?:change|modify|alter|add|introduce|implement|enable)\b/,
+        /\b(?:does|do|must|will|should) not (?:change|modify|alter|add|introduce|implement|enable|upgrade)\b/,
         /\bno changes? to\b/,
+        /\bno\b(?!\s+(?:doubt)\b)(?:\s+\w+){0,6}\s+changes?\b/,
+        /\bunchanged\b/,
+        /\bstill contains\b.{0,60}\bunchanged\b/,
+        /\bis preserved\b/,
+        /\b(?:remains?|stays?) (?:preserved|intact|in place)\b/,
+        /\brefuses? to\b/,
+        /\bmust still be rejected\b/,
+        /\bnever (?:rebound|rebind|launders?|laundered)\b/,
+        /\bstays? (?:rejected|blocked)\b/,
+        /\bdoes not emit\b/,
+        /\bstill emits?\b.{0,60}\binvalid\b/,
     ].some((pattern) => pattern.test(normalized));
 }
 const CLAUSE_KEYWORD_OR_PUNCTUATION = /\b(?:but|while|although|however)\b|[,;]/i;
@@ -66,7 +100,7 @@ function splitClauses(text) {
         .map((clause) => clause.trim())
         .filter(Boolean);
 }
-const AFFIRMATIVE_ACTION_VERBS = /\b(?:build(?:s|ing)?|chang(?:e|es|ing)|modif(?:y|ies|ying)|alter(?:s|ing)?|add(?:s|ing)?|introduc(?:e|es|ing)|implement(?:s|ing)?|enabl(?:e|es|ing)|expos(?:e|es|ing|ed)|mutat(?:e|es|ing)|rewrit(?:e|es|ing|ten))\b/;
+const AFFIRMATIVE_ACTION_VERBS = /\b(?:build(?:s|ing)?|chang(?:e|es|ing)|modif(?:y|ies|ying)|alter(?:s|ing)?|add(?:s|ing)?|introduc(?:e|es|ing)|implement(?:s|ing)?|enabl(?:e|es|ing)|expos(?:e|es|ing|ed)|mutat(?:e|es|ing)|rewrit(?:e|es|ing|ten)|remov(?:e|es|ing|ed)|forc(?:e|es|ing))\b/;
 function assertsForbiddenAction(text) {
     return AFFIRMATIVE_ACTION_VERBS.test(normalize(text));
 }
@@ -78,9 +112,9 @@ function hasAffirmativeDrift(text, outOfScopeItem) {
             new RegExp(`^${AFFIRMATIVE_ACTION_VERBS.source}`).test(segment) &&
             clauseMatchesScope(actionSegments[index - 1] ?? '', outOfScopeItem);
         for (const match of segment.matchAll(action)) {
-            const before = segment.slice(Math.max(0, match.index - 24), match.index);
+            const before = segment.slice(Math.max(0, match.index - 80), match.index);
             const after = segment.slice(match.index + match[0].length);
-            if (/\b(?:not|without|no)\s*$/.test(before)) {
+            if (endsWithNegation(before)) {
                 continue;
             }
             if (/^\s+remains? unchanged\b/.test(after)) {
@@ -102,7 +136,8 @@ function isDirectPhraseMatch(normCriterion, normScope) {
 function clauseMatchesScope(clause, outOfScopeItem) {
     const normalizedClause = normalize(clause);
     const normalizedScope = normalize(outOfScopeItem);
-    if (normalizedClause.includes(normalizedScope) || normalizedScope.includes(normalizedClause)) {
+    if (containsKeyword(normalizedClause, normalizedScope) ||
+        containsKeyword(normalizedScope, normalizedClause)) {
         return true;
     }
     const scopeKeywords = keywords(outOfScopeItem);
@@ -116,6 +151,33 @@ function clauseMentionsScope(clause, outOfScopeItem) {
     const mentionCandidates = scopeKeywords.length > 0 ? scopeKeywords : [normalize(outOfScopeItem)];
     return mentionCandidates.some((keyword) => containsKeyword(normalizedClause, keyword));
 }
+/**
+ * Bind the affirmative verb to the excluded object — an action verb only
+ * counts when a scope keyword sits within ACTION_SCOPE_WINDOW tokens of it.
+ */
+const ACTION_SCOPE_WINDOW = 4;
+function assertsActionNearScope(clause, outOfScopeItem) {
+    const tokens = normalize(clause).split(' ');
+    const scopeKeywords = keywords(outOfScopeItem);
+    const mentionCandidates = scopeKeywords.length > 0 ? scopeKeywords : [normalize(outOfScopeItem)];
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i] ?? '';
+        if (!AFFIRMATIVE_ACTION_VERBS.test(token)) {
+            continue;
+        }
+        const before = tokens.slice(Math.max(0, i - 6), i).join(' ');
+        if (endsWithNegation(before)) {
+            continue;
+        }
+        const lo = Math.max(0, i - ACTION_SCOPE_WINDOW);
+        const hi = Math.min(tokens.length, i + ACTION_SCOPE_WINDOW + 1);
+        const window = tokens.slice(lo, hi).join(' ');
+        if (mentionCandidates.some((keyword) => containsKeyword(window, keyword))) {
+            return true;
+        }
+    }
+    return false;
+}
 /**
  * Determine whether a criterion text contradicts an out-of-scope item.
  * Uses substring match first, then keyword overlap as fuzzy fallback.
@@ -139,7 +201,10 @@ function contradicts(criterionText, outOfScopeItem) {
     }
     const scopeAssertsForbiddenAction = assertsForbiddenAction(outOfScopeItem);
     return clauses.some((clause) => clauseMatchesScope(clause, outOfScopeItem) &&
-        (!scopeAssertsForbiddenAction || assertsForbiddenAction(clause)));
+        (!scopeAssertsForbiddenAction ||
+            (hasConditionalException
+                ? assertsForbiddenAction(clause)
+                : assertsActionNearScope(clause, outOfScopeItem))));
 }
 /**
  * Check acceptance criteria against the spec's outOfScope declarations.

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

@@ -144,6 +144,16 @@ function extractSection(body, sectionName) {
     const end = next ? next.index : body.length;
     return body.slice(start, end).trimEnd();
 }
+const CONTRACT_PLACEHOLDER_MARKERS = ['Needs decision', 'TBD', 'TODO'];
+function stripLeadingListMarker(line) {
+    return line.replace(/^[ \t]*(?:[-*+]|\d+[.)])[ \t]+/, '');
+}
+function hasUnresolvedContractPlaceholderLine(scannable) {
+    return scannable.split('\n').some((line) => {
+        const stripped = stripLeadingListMarker(line).trim();
+        return (CONTRACT_PLACEHOLDER_MARKERS.some((marker) => marker.toLowerCase() === stripped.toLowerCase()) || /^(?:needs decision|tbd|todo)\s*:/i.test(stripped));
+    });
+}
 /** Pure pre-persistence validation for the complete unified spec candidate. */
 // eslint-disable-next-line max-lines-per-function -- validation order mirrors the public issue contract
 export function validateUnifiedSpecCandidate(candidate, options = {}) {
@@ -188,7 +198,7 @@ export function validateUnifiedSpecCandidate(candidate, options = {}) {
             message: `Required section heading is embedded in quoted, fenced, or nested content: ${section}`,
         });
     }
-    if (/\b(?:Needs decision|TBD|TODO)\b/i.test(scannable)) {
+    if (hasUnresolvedContractPlaceholderLine(scannable)) {
         issues.push({
             code: 'UNRESOLVED_CONTRACT_PLACEHOLDER',
             message: 'Unified candidate contains an unresolved contract placeholder.',

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

@@ -26,12 +26,12 @@ const VAGUE_WORDS = [
     'intuitive',
 ];
 const CONTRADICTION_PAIRS = [
-    ['always', 'never'],
-    ['mandatory', 'optional'],
-    ['required', 'not required'],
-    ['must', 'must not'],
-    ['synchronous', 'asynchronous'],
-    ['blocking', 'non-blocking'],
+    ['always', 'never', 'genuine'],
+    ['mandatory', 'optional', 'genuine'],
+    ['required', 'not required', 'substring'],
+    ['must', 'must not', 'substring'],
+    ['synchronous', 'asynchronous', 'substring'],
+    ['blocking', 'non-blocking', 'substring'],
 ];
 // ── Internal helpers ─────────────────────────────────────────────────────────
 function gradeFromTotal(total) {
@@ -234,6 +234,30 @@ function scoreTestability(criteriaLines) {
         bddCoverage,
     };
 }
+function wordBoundaryPattern(term) {
+    return new RegExp(`\\b${term}\\b`);
+}
+function hasWordBoundaryMatch(text, term) {
+    return wordBoundaryPattern(term).test(text);
+}
+function substringPairContradicts(line, shorter, longer) {
+    if (!hasWordBoundaryMatch(line, longer)) {
+        return false;
+    }
+    const withoutLonger = line.replace(new RegExp(`\\b${longer}\\b`, 'g'), ' ');
+    return hasWordBoundaryMatch(withoutLonger, shorter);
+}
+function genuinePairContradicts(line, termA, termB) {
+    return hasWordBoundaryMatch(line, termA) && hasWordBoundaryMatch(line, termB);
+}
+function pairContradictsInCriteria(criteriaLines, termA, termB, kind) {
+    return criteriaLines.some((rawLine) => {
+        const line = rawLine.toLowerCase();
+        return kind === 'substring'
+            ? substringPairContradicts(line, termA, termB)
+            : genuinePairContradicts(line, termA, termB);
+    });
+}
 function scoreAmbiguity(content, criteriaLines) {
     const issues = [];
     const recommendations = [];
@@ -247,10 +271,10 @@ function scoreAmbiguity(content, criteriaLines) {
         };
     }
     const lower = content.toLowerCase();
-    // Check for contradiction pairs (-3 pts each, max -9)
+    // Check for contradiction pairs, scoped per criterion (-3 pts each, max -9)
     let contradictions = 0;
-    for (const [termA, termB] of CONTRADICTION_PAIRS) {
-        if (lower.includes(termA) && lower.includes(termB)) {
+    for (const [termA, termB, kind] of CONTRADICTION_PAIRS) {
+        if (pairContradictsInCriteria(criteriaLines, termA, termB, kind)) {
             contradictions++;
             if (contradictions <= 3) {
                 issues.push(`Potential contradiction: "${termA}" and "${termB}" both appear in spec`);
@@ -265,7 +289,7 @@ function scoreAmbiguity(content, criteriaLines) {
     const undefinedTerms = ['tbd', 'todo', 'fixme', 'placeholder', 'to be defined', 'to be decided'];
     let undefinedCount = 0;
     for (const term of undefinedTerms) {
-        if (lower.includes(term)) {
+        if (hasWordBoundaryMatch(lower, term)) {
             undefinedCount++;
             issues.push(`Undefined placeholder found: "${term}"`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "5.3.31",
+  "version": "5.3.33",
   "description": "Planu — MCP Server for Spec Driven Development. Cross-platform (Linux/macOS/Windows, x64/arm64).",
   "type": "module",
   "main": "dist/index.js",

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.31",
+  "version": "5.3.33",
   "icon": "assets/plugin/icon.svg",
   "command": ["npx", "@planu/cli@latest"],
   "packageName": "@planu/cli",