@planu/cli 5.7.6 → 5.7.7

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [5.7.7] - 2026-09-02
+
+### Bug Fixes
+- fix(hooks): route src/config template assets through reference classification in selector
+- fix(tools): drop phantom multi_teammate_review from review-panel hook and scan hook templates
+- fix(tools): delete dead deprecated-tool stubs dropped by the purged registry
+- fix(tools): extend schema constraint audit to nested items and combinators
+- fix(tools): declare regex and max constraints in tool input schema descriptions
+- fix(storage): spec store returns absent for deleted canonical spec so validate fails closed with spec_not_found
+- fix(spec-grounding): surface structured diagnostics for dropped grounding records
+- fix(spec-format): accept plus bullet markers in checkbox and plain-list criterion parsers
+
+
 ## [5.7.6] - 2026-09-01
 
 ### Features

package/dist/.planu-build.json

@@ -1 +1 @@
-{"schemaVersion":1,"commit":"1eaa28a4fbc0df47b8b62c888bbb34446c05810e"}
+{"schemaVersion":1,"commit":"239ab5e0b6df0ae6aae7e6a1a7ec9d699e1a66b8"}

package/dist/config/hook-templates/planu-review-panel-trigger.sh

@@ -4,7 +4,7 @@
 #
 # Wired as a PreToolUse hook for the Bash tool.
 # When Claude Code is about to run a git diff or review command and the diff is
-# large (>500 LOC), this hook prints a suggestion to use multi_teammate_review.
+# large (>500 LOC), this hook suggests the panel review skill.
 # It NEVER blocks execution — exit 0 always.
 
 set -uo pipefail
@@ -26,8 +26,7 @@ if [[ "$LOC" -gt "$THRESHOLD" ]]; then
   echo ""
   echo "💡 Planu tip: This diff is ${LOC} LOC (threshold: ${THRESHOLD})."
   echo "   Consider running the 5-specialist panel review for thorough analysis:"
-  echo "   → multi_teammate_review({ projectPath: \"$(pwd)\", diff: \"<paste diff here>\" })"
-  echo "   Or use the /planu-multi-teammate-review skill."
+  echo "   → use the /planu-multi-teammate-review skill."
   echo ""
 fi
 

package/dist/config/skill-templates/planu-multi-teammate-review.md

@@ -25,18 +25,14 @@ Use this skill when you want a thorough, multi-perspective code review:
 
 **Trigger phrases**: "panel review", "thorough review", "5-agent review", "deep review", "run the specialist panel"
 
-## How to invoke the tool
+## How this skill runs the review
 
-```
-multi_teammate_review({
-  projectPath: "/absolute/path/to/project",
-  diff: "<unified diff text>",          // preferred: paste the output of git diff
-  prNumber: 42,                          // optional: for context in the report header
-  branch: "feat/my-feature",            // optional: for context
-  commitRange: "main..HEAD",             // optional: for context
-  spec: "<linked spec content>"          // optional: helps the arbitrator detect spec drift
-})
-```
+This skill runs the panel directly — it is not an MCP tool call. Gather the review inputs below, then run the panel yourself following the specialist roles described in this skill:
+
+- `projectPath` — absolute path to the project
+- `diff` — unified diff text (preferred: paste the output of `git diff`)
+- `prNumber`, `branch`, or `commitRange` — optional context for the report header
+- `spec` — optional linked spec content, enables spec-drift detection in the Maintainability specialist's report
 
 At least one of `diff`, `prNumber`, `branch`, or `commitRange` must be provided.
 

package/dist/engine/evidence-gates/evidence-skeletons.js

@@ -32,7 +32,9 @@ function outOfScopeFromBody(specBody) {
 }
 /** Build a strict-schema discovery.json skeleton grounded in the spec's own grounding metadata. */
 export function generateDiscoverySkeleton(args) {
-    const records = args.body ? parseCriterionGroundingRecords(specFrontmatter(args.body)) : [];
+    const records = args.body
+        ? parseCriterionGroundingRecords(specFrontmatter(args.body)).records
+        : [];
     const rules = records.length > 0 ? [...new Set(records.map((record) => record.text))] : [DEFAULT_RULE];
     const examples = records.length > 0
         ? records.map((record) => ({

package/dist/engine/readiness-checker.js

@@ -12,14 +12,29 @@ import { evaluateImplementationContract } from './implementation-contract/index.
 import { extractNormalizedAcceptanceCriteria } from './spec-format/acceptance-criteria.js';
 import { isRetiredScaffoldText } from './spec-format/retired-scaffold.js';
 import { detectCrossSpecPremiseContradictions } from './contradiction-detector.js';
+import { parseCriterionGroundingRecords, parseTechnicalReferenceGroundingRecords, } from './spec-grounding/contract.js';
 // ── SPEC-784: Technical section quality constants ─────────────────────────────
 const TECHNICAL_MIN_CHARS = 500;
+const GROUNDING_FRONTMATTER_RE = /^---\n([\s\S]*?)\n---/;
 // Detects "See technical.md", "See spec.md", or "See `<file>` technical.md" patterns
 const TECHNICAL_PLACEHOLDER_REGEX = /\bSee\s+(?:`?[^`\n]+`?\s+)?(?:technical|spec)\.md/i;
 const BDD_CRITERION_RE = /\bGIVEN\b[\s\S]*\bWHEN\b[\s\S]*\bTHEN\b/i;
 function isExecutableBddLine(line) {
     return !isRetiredScaffoldText(line) && BDD_CRITERION_RE.test(line);
 }
+function groundingParseDiagnosticFindings(huRaw) {
+    const frontmatter = GROUNDING_FRONTMATTER_RE.exec(huRaw)?.[1] ?? '';
+    const criteriaDiagnostics = parseCriterionGroundingRecords(frontmatter).diagnostics;
+    const technicalDiagnostics = parseTechnicalReferenceGroundingRecords(frontmatter).diagnostics;
+    return [...criteriaDiagnostics, ...technicalDiagnostics].map((diagnostic) => `GROUNDING_PARSE_DROPPED: "${diagnostic.identifier}" has an invalid ${diagnostic.field} ` +
+        `("${diagnostic.value}") — allowed: ${diagnostic.allowed.join(', ') || 'n/a'}`);
+}
+function checkScenariosWithoutTests(huRaw, bddScenarioCount) {
+    if (bddScenarioCount === 0) {
+        return [];
+    }
+    return findScenariosWithoutTests(huRaw).map((title) => `scenarios_missing_tests: scenario "${title}" has no tests array — add tests entries as a block list (tests: with one "- path" line per test) or an inline array (tests: ["path"]) (SPEC-732)`);
+}
 function checkZeroBddCriteria(criteriaLines) {
     if (criteriaLines.length === 0 || criteriaLines.some(isExecutableBddLine)) {
         return [];
@@ -449,16 +464,12 @@ export async function checkSpecReadiness(spec, mode, projectHash) {
     // SPEC-732: Executable AC gate — block approved when any scenario lacks a `tests` array.
     // Only enforce when the spec uses frontmatter scenarios (BDD format).
     const bddScenarioCount = countFrontmatterScenarios(huRaw);
-    if (bddScenarioCount > 0) {
-        const scenariosWithoutTests = findScenariosWithoutTests(huRaw);
-        for (const title of scenariosWithoutTests) {
-            allBlockers.push(`scenarios_missing_tests: scenario "${title}" has no tests array — add tests entries as a block list (tests: with one "- path" line per test) or an inline array (tests: ["path"]) (SPEC-732)`);
-        }
-    }
+    allBlockers.push(...checkScenariosWithoutTests(huRaw, bddScenarioCount));
     const scavengeWarning = frontmatterScenarioScavengeWarning(bddScenarioCount, normalizedCriteria);
     if (scavengeWarning) {
         allWarnings.push(scavengeWarning);
     }
+    allWarnings.push(...groundingParseDiagnosticFindings(huRaw));
     // SPEC-1214: BDD-criteria executable-evidence gate — when a spec has no frontmatter
     // scenarios, its criteria must carry a TEST: marker mapping to an executable test file,
     // or validation will later score 0 with "No executable scenarios declared".

package/dist/engine/reconcile/propagate-mirrors.js

@@ -33,9 +33,9 @@ function propagateAcceptanceCriteria(content) {
     const sectionBody = content.slice(section.contentStart, section.end);
     const criteriaTexts = extractSectionCriteria(sectionBody);
     const scenarios = criteriaTexts.map(criterionToScenario);
-    const oldRecords = mapWithFrontmatter(content, (fm) => indexCriterionRecords(parseCriterionGroundingRecords(fm)));
+    const oldRecords = mapWithFrontmatter(content, (fm) => indexCriterionRecords(parseCriterionGroundingRecords(fm).records));
     const oldTestPaths = mapWithFrontmatter(content, (fm) => parseTechnicalReferenceGroundingRecords(fm)
-        .filter((record) => record.section === 'test')
+        .records.filter((record) => record.section === 'test')
         .map((record) => record.path));
     const criteriaRecords = criteriaTexts.map((text) => oldRecords.get(normalizeCriterionText(text)) ?? {
         text,
@@ -59,9 +59,9 @@ function propagateFiles(content) {
     const sectionBody = content.slice(section.contentStart, section.end);
     const files = parseFilesSection(sectionBody);
     const oldTestPaths = mapWithFrontmatter(content, (fm) => parseTechnicalReferenceGroundingRecords(fm)
-        .filter((record) => record.section === 'test')
+        .records.filter((record) => record.section === 'test')
         .map((record) => record.path));
-    const oldTechnicalReferences = mapWithFrontmatter(content, (fm) => indexTechnicalReferenceRecords(parseTechnicalReferenceGroundingRecords(fm)));
+    const oldTechnicalReferences = mapWithFrontmatter(content, (fm) => indexTechnicalReferenceRecords(parseTechnicalReferenceGroundingRecords(fm).records));
     const technicalReferences = buildTechnicalReferenceRecords(files, oldTechnicalReferences);
     const newTestPaths = files.test;
     let result = transformFrontmatter(content, (fm) => replaceFrontmatterKeyBlock(fm, 'grounding', groundingBlockLines(criteriaRecordsFromFrontmatter(fm), technicalReferences)));
@@ -285,10 +285,10 @@ function mapWithFrontmatter(content, read) {
     return read(match?.[1] ?? '');
 }
 function technicalReferencesFromFrontmatter(frontmatter) {
-    return parseTechnicalReferenceGroundingRecords(frontmatter);
+    return parseTechnicalReferenceGroundingRecords(frontmatter).records;
 }
 function criteriaRecordsFromFrontmatter(frontmatter) {
-    return parseCriterionGroundingRecords(frontmatter);
+    return parseCriterionGroundingRecords(frontmatter).records;
 }
 function groundingBlockLines(criteria, technicalReferences) {
     const criteriaLines = renderGroundingFrontmatter(criteria).slice(2);

package/dist/engine/spec-format/lean-spec-generator.js

@@ -154,7 +154,7 @@ export function extractCriteria(description) {
 /** Extract checkbox-style criteria: `- [ ] text` or `- [x] text`. */
 function extractCheckboxCriteria(description) {
     const criteria = [];
-    const checkboxRegex = /^[-*]\s*\[([ xX])\]\s*(.+)$/gm;
+    const checkboxRegex = /^[-*+]\s*\[([ xX])\]\s*(.+)$/gm;
     let match = checkboxRegex.exec(description);
     while (match) {
         criteria.push({
@@ -205,7 +205,7 @@ function extractPlainListCriteria(description) {
     }
     const criteria = [];
     // Plain list: `- text` or `* text`, not followed by `[`
-    const plainListRegex = /^[-*]\s+(?!\[)(.+)$/gm;
+    const plainListRegex = /^[-*+]\s+(?!\[)(.+)$/gm;
     let match = plainListRegex.exec(acceptanceSection);
     while (match) {
         const text = match[1]?.trim() ?? '';

package/dist/engine/spec-grounding/contract.d.ts

@@ -1,5 +1,5 @@
 import type { Spec } from '../../types/index.js';
-import type { CriterionGroundingRecord, GroundingGateResult, TechnicalReferenceGroundingRecord } from '../../types/spec-grounding.js';
+import type { CriterionGroundingRecord, GroundingGateResult, GroundingParseResult, TechnicalReferenceGroundingRecord } from '../../types/spec-grounding.js';
 export { normalizeCriterionText } from '../criterion-identity.js';
 export declare function isGenericCriterion(text: string): boolean;
 export declare function filterGroundedCriteria(criteria: string[]): string[];
@@ -19,8 +19,8 @@ export declare function getAdvisoryCriteria(records: CriterionGroundingRecord[])
 export declare function renderGroundingFrontmatter(records: CriterionGroundingRecord[]): string[];
 export declare function renderTechnicalReferenceGroundingFrontmatter(records: TechnicalReferenceGroundingRecord[]): string[];
 export declare function checkGroundedSpecContract(spec: Spec, content: string): GroundingGateResult;
-export declare function parseCriterionGroundingRecords(frontmatter: string): CriterionGroundingRecord[];
-export declare function parseTechnicalReferenceGroundingRecords(frontmatter: string): TechnicalReferenceGroundingRecord[];
+export declare function parseCriterionGroundingRecords(frontmatter: string): GroundingParseResult<CriterionGroundingRecord>;
+export declare function parseTechnicalReferenceGroundingRecords(frontmatter: string): GroundingParseResult<TechnicalReferenceGroundingRecord>;
 export declare function parseApprovedFileLevelWorkPlanPaths(content: string): string[];
 export declare function parseGroundedTechnicalPaths(content: string): string[];
 //# sourceMappingURL=contract.d.ts.map

package/dist/engine/spec-grounding/contract.js

@@ -1,17 +1,6 @@
 import YAML from 'yaml';
 import { createCriterionIdentity, normalizeCriterionText } from '../criterion-identity.js';
-const GROUNDING_SOURCES = [
-    'user_input',
-    'project_evidence',
-    'documented_assumption',
-    'ungrounded_advisory',
-];
-const GROUNDING_CONFIDENCES = ['low', 'medium', 'high'];
-const TECHNICAL_REFERENCE_SECTIONS = [
-    'create',
-    'modify',
-    'test',
-];
+import { isRecord, toCriterionGroundingRecord, toTechnicalReferenceGroundingRecord, } from './grounding-entry-parser.js';
 export { normalizeCriterionText } from '../criterion-identity.js';
 const GENERIC_CRITERION_PATTERNS = [
     /\bimplementation complete\b/i,
@@ -115,7 +104,7 @@ export function renderTechnicalReferenceGroundingFrontmatter(records) {
 export function checkGroundedSpecContract(spec, content) {
     const frontmatter = FRONTMATTER_RE.exec(content)?.[1] ?? '';
     const required = /^grounding_required:\s*true\s*$/m.test(frontmatter);
-    const records = parseCriterionGroundingRecords(frontmatter);
+    const records = parseCriterionGroundingRecords(frontmatter).records;
     if (!required) {
         return { passed: true, required: false, issues: [], records };
     }
@@ -131,7 +120,7 @@ export function checkGroundedSpecContract(spec, content) {
             issues.push(`Criterion has no grounding evidence: ${record.text}`);
         }
     }
-    const technicalRecords = parseTechnicalReferenceGroundingRecords(frontmatter);
+    const technicalRecords = parseTechnicalReferenceGroundingRecords(frontmatter).records;
     for (const record of technicalRecords) {
         if (record.source === 'ungrounded_advisory' || record.source === 'documented_assumption') {
             issues.push(`Technical reference is advisory-only and cannot be contract: ${record.path}`);
@@ -150,23 +139,28 @@ export function checkGroundedSpecContract(spec, content) {
 export function parseCriterionGroundingRecords(frontmatter) {
     const outcome = parseFrontmatterYaml(frontmatter);
     if (!outcome.parsed) {
-        return parseCriterionGroundingRecordsLegacy(frontmatter);
+        return { records: parseCriterionGroundingRecordsLegacy(frontmatter), diagnostics: [] };
     }
     const grounding = readGroundingSection(outcome.document);
     const entries = Array.isArray(grounding?.criteria) ? grounding.criteria : [];
     const records = [];
-    for (const entry of entries) {
-        const record = toCriterionGroundingRecord(entry);
-        if (record) {
-            records.push(record);
+    const diagnostics = [];
+    for (const [index, entry] of entries.entries()) {
+        const entryOutcome = toCriterionGroundingRecord(entry, index);
+        if (entryOutcome.record) {
+            records.push(entryOutcome.record);
         }
+        diagnostics.push(...entryOutcome.diagnostics);
     }
-    return records;
+    return { records, diagnostics };
 }
 export function parseTechnicalReferenceGroundingRecords(frontmatter) {
     const outcome = parseFrontmatterYaml(frontmatter);
     if (!outcome.parsed) {
-        return parseTechnicalReferenceGroundingRecordsLegacy(frontmatter);
+        return {
+            records: parseTechnicalReferenceGroundingRecordsLegacy(frontmatter),
+            diagnostics: [],
+        };
     }
     const grounding = readGroundingSection(outcome.document);
     const entries = grounding
@@ -177,13 +171,15 @@ export function parseTechnicalReferenceGroundingRecords(frontmatter) {
             ? outcome.document.technicalReferences
             : [];
     const records = [];
-    for (const entry of entries) {
-        const record = toTechnicalReferenceGroundingRecord(entry);
-        if (record) {
-            records.push(record);
+    const diagnostics = [];
+    for (const [index, entry] of entries.entries()) {
+        const entryOutcome = toTechnicalReferenceGroundingRecord(entry, index);
+        if (entryOutcome.record) {
+            records.push(entryOutcome.record);
         }
+        diagnostics.push(...entryOutcome.diagnostics);
     }
-    return records;
+    return { records, diagnostics };
 }
 function parseFrontmatterYaml(frontmatter) {
     let value;
@@ -199,55 +195,6 @@ function readGroundingSection(document) {
     const grounding = document?.grounding;
     return isRecord(grounding) ? grounding : undefined;
 }
-function toCriterionGroundingRecord(entry) {
-    if (!isRecord(entry)) {
-        return null;
-    }
-    const text = typeof entry.text === 'string' && entry.text.length > 0 ? entry.text : null;
-    const source = toGroundingSource(entry.source);
-    const confidence = toGroundingConfidence(entry.confidence);
-    if (!text || !source || !confidence) {
-        return null;
-    }
-    return { text, source, evidence: toStringArray(entry.evidence), confidence };
-}
-function toTechnicalReferenceGroundingRecord(entry) {
-    if (!isRecord(entry)) {
-        return null;
-    }
-    const path = typeof entry.path === 'string' && entry.path.length > 0 ? entry.path : null;
-    const section = toTechnicalReferenceSection(entry.section);
-    const source = toGroundingSource(entry.source);
-    const confidence = toGroundingConfidence(entry.confidence);
-    if (!path || !section || !source || !confidence) {
-        return null;
-    }
-    return { path, section, source, evidence: toStringArray(entry.evidence), confidence };
-}
-function toGroundingSource(value) {
-    return typeof value === 'string' && GROUNDING_SOURCES.includes(value)
-        ? value
-        : null;
-}
-function toGroundingConfidence(value) {
-    return typeof value === 'string' && GROUNDING_CONFIDENCES.includes(value)
-        ? value
-        : null;
-}
-function toTechnicalReferenceSection(value) {
-    return typeof value === 'string' &&
-        TECHNICAL_REFERENCE_SECTIONS.includes(value)
-        ? value
-        : null;
-}
-function toStringArray(value) {
-    return Array.isArray(value)
-        ? value.filter((item) => typeof item === 'string')
-        : [];
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
 function parseCriterionGroundingRecordsLegacy(frontmatter) {
     const records = [];
     const chunks = frontmatter.split(/\n\s{4}- text:\s*/).slice(1);
@@ -311,7 +258,7 @@ export function parseGroundedTechnicalPaths(content) {
     const frontmatter = FRONTMATTER_RE.exec(content)?.[1] ?? '';
     return [
         ...new Set([
-            ...parseTechnicalReferenceGroundingRecords(frontmatter).map((record) => record.path),
+            ...parseTechnicalReferenceGroundingRecords(frontmatter).records.map((record) => record.path),
             ...parseApprovedFileLevelWorkPlanPaths(content),
         ]),
     ];

package/dist/engine/spec-grounding/grounding-entry-parser.d.ts

@@ -0,0 +1,5 @@
+import type { CriterionGroundingRecord, GroundingEntryOutcome, TechnicalReferenceGroundingRecord } from '../../types/spec-grounding.js';
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function toCriterionGroundingRecord(entry: unknown, index: number): GroundingEntryOutcome<CriterionGroundingRecord>;
+export declare function toTechnicalReferenceGroundingRecord(entry: unknown, index: number): GroundingEntryOutcome<TechnicalReferenceGroundingRecord>;
+//# sourceMappingURL=grounding-entry-parser.d.ts.map

package/dist/engine/spec-grounding/grounding-entry-parser.js

@@ -0,0 +1,185 @@
+const GROUNDING_SOURCES = [
+    'user_input',
+    'project_evidence',
+    'documented_assumption',
+    'ungrounded_advisory',
+];
+const GROUNDING_CONFIDENCES = ['low', 'medium', 'high'];
+const TECHNICAL_REFERENCE_SECTIONS = [
+    'create',
+    'modify',
+    'test',
+];
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stringifyDiagnosticValue(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (value === null) {
+        return 'null';
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return value.toString();
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return 'unstringifiable value';
+    }
+}
+function nonObjectEntryDiagnostic(entry, index) {
+    return {
+        identifier: `entry[${String(index)}]`,
+        field: 'entry',
+        value: stringifyDiagnosticValue(entry),
+        allowed: [],
+    };
+}
+function toGroundingSource(value) {
+    return typeof value === 'string' && GROUNDING_SOURCES.includes(value)
+        ? value
+        : null;
+}
+function toGroundingConfidence(value) {
+    return typeof value === 'string' && GROUNDING_CONFIDENCES.includes(value)
+        ? value
+        : null;
+}
+function toTechnicalReferenceSection(value) {
+    return typeof value === 'string' &&
+        TECHNICAL_REFERENCE_SECTIONS.includes(value)
+        ? value
+        : null;
+}
+function toStringArrayWithDiagnostics(value, identifier) {
+    if (!Array.isArray(value)) {
+        return { evidence: [], diagnostics: [] };
+    }
+    const evidence = [];
+    const diagnostics = [];
+    for (const item of value) {
+        if (typeof item === 'string') {
+            evidence.push(item);
+        }
+        else {
+            diagnostics.push({
+                identifier,
+                field: 'evidence',
+                value: stringifyDiagnosticValue(item),
+                allowed: ['string'],
+            });
+        }
+    }
+    return { evidence, diagnostics };
+}
+export function toCriterionGroundingRecord(entry, index) {
+    if (!isRecord(entry)) {
+        return { record: null, diagnostics: [nonObjectEntryDiagnostic(entry, index)] };
+    }
+    const text = typeof entry.text === 'string' && entry.text.length > 0 ? entry.text : null;
+    const identifier = text ?? `entry[${String(index)}]`;
+    const source = toGroundingSource(entry.source);
+    if (!source) {
+        return {
+            record: null,
+            diagnostics: [
+                {
+                    identifier,
+                    field: 'source',
+                    value: stringifyDiagnosticValue(entry.source),
+                    allowed: GROUNDING_SOURCES,
+                },
+            ],
+        };
+    }
+    const confidence = toGroundingConfidence(entry.confidence);
+    if (!confidence) {
+        return {
+            record: null,
+            diagnostics: [
+                {
+                    identifier,
+                    field: 'confidence',
+                    value: stringifyDiagnosticValue(entry.confidence),
+                    allowed: GROUNDING_CONFIDENCES,
+                },
+            ],
+        };
+    }
+    if (!text) {
+        return {
+            record: null,
+            diagnostics: [
+                { identifier, field: 'text', value: stringifyDiagnosticValue(entry.text), allowed: [] },
+            ],
+        };
+    }
+    const { evidence, diagnostics } = toStringArrayWithDiagnostics(entry.evidence, identifier);
+    return { record: { text, source, evidence, confidence }, diagnostics };
+}
+export function toTechnicalReferenceGroundingRecord(entry, index) {
+    if (!isRecord(entry)) {
+        return { record: null, diagnostics: [nonObjectEntryDiagnostic(entry, index)] };
+    }
+    const path = typeof entry.path === 'string' && entry.path.length > 0 ? entry.path : null;
+    const identifier = path ?? `entry[${String(index)}]`;
+    const section = toTechnicalReferenceSection(entry.section);
+    if (!section) {
+        return {
+            record: null,
+            diagnostics: [
+                {
+                    identifier,
+                    field: 'section',
+                    value: stringifyDiagnosticValue(entry.section),
+                    allowed: TECHNICAL_REFERENCE_SECTIONS,
+                },
+            ],
+        };
+    }
+    const source = toGroundingSource(entry.source);
+    if (!source) {
+        return {
+            record: null,
+            diagnostics: [
+                {
+                    identifier,
+                    field: 'source',
+                    value: stringifyDiagnosticValue(entry.source),
+                    allowed: GROUNDING_SOURCES,
+                },
+            ],
+        };
+    }
+    const confidence = toGroundingConfidence(entry.confidence);
+    if (!confidence) {
+        return {
+            record: null,
+            diagnostics: [
+                {
+                    identifier,
+                    field: 'confidence',
+                    value: stringifyDiagnosticValue(entry.confidence),
+                    allowed: GROUNDING_CONFIDENCES,
+                },
+            ],
+        };
+    }
+    if (!path) {
+        return {
+            record: null,
+            diagnostics: [
+                { identifier, field: 'path', value: stringifyDiagnosticValue(entry.path), allowed: [] },
+            ],
+        };
+    }
+    const { evidence, diagnostics } = toStringArrayWithDiagnostics(entry.evidence, identifier);
+    return { record: { path, section, source, evidence, confidence }, diagnostics };
+}
+//# sourceMappingURL=grounding-entry-parser.js.map

package/dist/storage/spec-store.js

@@ -256,6 +256,9 @@ async function refreshSpecFromDisk(projectId, spec, canonicalRoot) {
         specMdPath = await resolveVerifiedSpecPath(spec.id, spec.specPath, canonicalRoot);
     }
     catch (error) {
+        if (error instanceof PortablePathError && error.code === 'NOT_FOUND') {
+            return null;
+        }
         reportClassifiedDegradation('SPEC_CONTENT_DIGEST_CHECK_SKIPPED', error);
         return spec;
     }
@@ -264,6 +267,9 @@ async function refreshSpecFromDisk(projectId, spec, canonicalRoot) {
         content = await readFile(specMdPath, 'utf-8');
     }
     catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return null;
+        }
         reportClassifiedDegradation('SPEC_CONTENT_DIGEST_CHECK_SKIPPED', error);
         return spec;
     }
@@ -290,7 +296,8 @@ export async function listSpecs(projectId, canonicalRoot) {
     if (canonicalRoot === undefined) {
         return specs;
     }
-    return Promise.all(specs.map((spec) => refreshSpecFromDisk(projectId, spec, canonicalRoot)));
+    const refreshed = await Promise.all(specs.map((spec) => refreshSpecFromDisk(projectId, spec, canonicalRoot)));
+    return refreshed.filter((spec) => spec !== null);
 }
 /**
  * Run a read-modify side effect against a fresh spec snapshot while holding the

package/dist/tools/bump-spec-version.js

@@ -19,14 +19,14 @@ const BumpSpecVersionSchema = {
         .min(1)
         .max(4096)
         .optional()
-        .describe('Absolute path to the project root. Takes precedence over projectId.'),
+        .describe('Absolute path to the project root. Takes precedence over projectId. Max 4096 characters.'),
     projectId: z
         .string()
         .min(1)
         .max(500)
         .optional()
-        .describe('Project ID (hash). Required if projectPath is not provided.'),
-    specId: SpecIdSchema.describe('Spec ID to bump, e.g. SPEC-042.'),
+        .describe('Project ID (hash). Required if projectPath is not provided. Max 500 characters.'),
+    specId: SpecIdSchema.describe('Spec ID to bump, e.g. SPEC-042. Must match pattern ^SPEC-\\d+$, max 50 characters.'),
     kind: z
         .enum(['patch', 'minor', 'major'])
         .describe('Bump kind: patch (typo/format), minor (new criterion/scope expansion), major (breaking change).'),
@@ -34,13 +34,13 @@ const BumpSpecVersionSchema = {
         .string()
         .min(5)
         .max(500)
-        .describe('Free-text reason for the bump (min 5 chars). Recorded in history.'),
+        .describe('Free-text reason for the bump. Min 5, max 500 characters. Recorded in history.'),
     by: z
         .string()
         .min(1)
         .max(200)
         .optional()
-        .describe('Actor identifier (session id, plugin id, username). Defaults to a session token.'),
+        .describe('Actor identifier (session id, plugin id, username). Defaults to a session token. Max 200 characters.'),
 };
 // ---------------------------------------------------------------------------
 // Handler

package/dist/tools/init-project/skills-multi-teammate-review-writer.js

@@ -31,7 +31,7 @@ triggers:
 
 # /planu-multi-teammate-review
 
-Invoke \`multi_teammate_review\` for a 5-specialist panel code review.
+Runs a 5-specialist panel code review directly — not an MCP tool call.
 `;
     }
 }

package/dist/tools/multi-teammate-review.js

@@ -1,11 +1,5 @@
-// tools/multi-teammate-review.ts — MCP tool registration for multi-teammate review (SPEC-593)
-// NOTE (SPEC-658): registerMultiTeammateReviewTool now registers a deprecation stub.
-// The underlying handleMultiTeammateReview logic is kept for direct import by skills/tests.
 import { z } from 'zod';
-// safeTracked removed — registration replaced by deprecation stub (SPEC-658)
 import { toolResult, formatError } from './response-helpers.js';
-import { makeDeprecationStub } from './tool-registry/deprecated-stubs.js';
-import { registerFromEntries } from './tool-entry.js';
 import { runReviewPanel } from '../engine/multi-teammate-review/panel-orchestrator.js';
 import { buildModelHeader } from '../engine/model-router/subtask-model-assigner.js';
 // ---------------------------------------------------------------------------
@@ -117,14 +111,7 @@ export async function handleMultiTeammateReview(args) {
     ];
     return toolResult(outputLines.join('\n'));
 }
-// ---------------------------------------------------------------------------
-// Tool registration (SPEC-658: replaced with deprecation stub)
-// ---------------------------------------------------------------------------
 export function registerMultiTeammateReviewTool(s) {
-    // multi_teammate_review has been migrated to .claude/skills/review-and-merge.md
-    // The tool stays registered so callers receive a helpful message, not "unknown tool".
-    registerFromEntries(s, [
-        makeDeprecationStub('multi_teammate_review', '.claude/skills/review-and-merge.md', 'review-and-merge'),
-    ]);
+    void s;
 }
 //# sourceMappingURL=multi-teammate-review.js.map