@planu/cli 4.7.1 → 4.7.2

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [4.7.2] - 2026-06-16
+
+### Features
+- feat(SPEC-1088): add policy-driven minimal implementation gate
+
+### Chores
+- chore(deps): update patch/minor dependencies
+
+
 ## [4.7.1] - 2026-06-12
 
 ### Chores
@@ -4085,4 +4094,4 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) · Versioning:
 - Mermaid diagram generation (architecture, sequence, state machine, ER, data flow)
 - Multi-language i18n (EN/ES/PT) for generated specs
 - Clean Architecture (hexagonal) — engine, tools, storage, types layers
-- 10,857 tests with ≥95% coverage
+- 10,857 tests with ≥95% coverage

package/dist/config/minimal-implementation-gate.json

@@ -0,0 +1,110 @@
+{
+  "version": 1,
+  "enabled": true,
+  "report": {
+    "maxFindings": 12,
+    "maxMarkdownLines": 12,
+    "maxEvidenceChars": 180
+  },
+  "tags": {
+    "delete": { "description": "Remove avoidable code or files." },
+    "stdlib": { "description": "Use a standard library capability before adding custom code." },
+    "native": { "description": "Use an existing platform or Planu-native capability." },
+    "installed-dependency": { "description": "Use an already-installed dependency instead of adding another." },
+    "yagni": { "description": "Avoid speculative code that is not required by the approved spec." },
+    "shrink": { "description": "Reduce an oversized abstraction or workflow." },
+    "dependency": { "description": "Avoid an unnecessary new package or dependency path." },
+    "file-scope": { "description": "Keep implementation inside the approved file scope." },
+    "debt-marker": { "description": "Record accepted shortcuts as structured debt evidence." }
+  },
+  "rules": [
+    {
+      "id": "minimality.delete.dead-compat",
+      "tag": "delete",
+      "severity": "warning",
+      "confidence": "medium",
+      "patterns": ["legacy compatibility", "deprecated fallback", "unused fallback"],
+      "replacementGuidance": "Remove the compatibility path unless the approved spec explicitly requires backward compatibility."
+    },
+    {
+      "id": "minimality.stdlib.custom-parser",
+      "tag": "stdlib",
+      "severity": "warning",
+      "confidence": "medium",
+      "patterns": ["custom parser", "manual parser", "hand rolled parser"],
+      "replacementGuidance": "Use an existing parser from the runtime or current dependency set before writing parsing code."
+    },
+    {
+      "id": "minimality.native.existing-planu-surface",
+      "tag": "native",
+      "severity": "warning",
+      "confidence": "high",
+      "patterns": ["new public mcp tool", "new command", "new cli command"],
+      "replacementGuidance": "Prefer existing Planu SDD surfaces unless the spec proves a new public surface is required."
+    },
+    {
+      "id": "minimality.installed-dependency.add-package",
+      "tag": "installed-dependency",
+      "severity": "warning",
+      "confidence": "medium",
+      "patterns": ["add dependency", "new dependency", "install package"],
+      "replacementGuidance": "Check package.json first and reuse an already-installed dependency when possible."
+    },
+    {
+      "id": "minimality.yagni.future-proofing",
+      "tag": "yagni",
+      "severity": "blocker",
+      "confidence": "high",
+      "patterns": ["future-proof", "just in case", "might need later", "eventually support"],
+      "replacementGuidance": "Remove speculative scope unless it is directly required by an acceptance criterion.",
+      "blockWhenRiskAtLeast": "medium"
+    },
+    {
+      "id": "minimality.shrink.over-architecture",
+      "tag": "shrink",
+      "severity": "warning",
+      "confidence": "medium",
+      "patterns": ["framework", "orchestration layer", "plugin architecture", "abstract factory"],
+      "replacementGuidance": "Shrink the design to the smallest correct module/function that satisfies the spec."
+    },
+    {
+      "id": "minimality.dependency.new-runtime",
+      "tag": "dependency",
+      "severity": "blocker",
+      "confidence": "high",
+      "patterns": ["npm install", "pnpm add", "yarn add"],
+      "replacementGuidance": "Avoid adding runtime dependencies unless the approved spec explicitly requires one.",
+      "blockWhenRiskAtLeast": "low"
+    },
+    {
+      "id": "minimality.file-scope.unapproved-area",
+      "tag": "file-scope",
+      "severity": "warning",
+      "confidence": "medium",
+      "patterns": ["touch unrelated", "broad refactor", "repo-wide refactor"],
+      "replacementGuidance": "Keep edits inside the approved technical references and tests."
+    },
+    {
+      "id": "minimality.debt-marker.comment-only",
+      "tag": "debt-marker",
+      "severity": "warning",
+      "confidence": "medium",
+      "patterns": ["todo debt", "temporary hack", "shortcut accepted"],
+      "replacementGuidance": "Record accepted shortcuts as structured debt evidence with ceiling and upgrade trigger."
+    }
+  ],
+  "safetyExclusions": [
+    "security",
+    "accessibility",
+    "data-loss",
+    "compliance",
+    "money",
+    "access-control",
+    "explicitly requested",
+    "trust boundary"
+  ],
+  "excludedPathPatterns": ["dist/**", "coverage/**", "node_modules/**", "pnpm-lock.yaml", "*.snap"],
+  "debtEvidence": {
+    "requiredFields": ["specId", "files", "ceiling", "upgradeTrigger", "reviewRationale"]
+  }
+}

package/dist/engine/handoff-artifacts/schemas.d.ts

@@ -96,6 +96,62 @@ export declare const ValidationReportV1Schema: z.ZodObject<{
             evidence: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    minimalityReport: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        blocked: z.ZodBoolean;
+        findings: z.ZodArray<z.ZodObject<{
+            ruleId: z.ZodString;
+            tag: z.ZodString;
+            severity: z.ZodEnum<{
+                blocker: "blocker";
+                warning: "warning";
+                info: "info";
+            }>;
+            confidence: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>;
+            target: z.ZodString;
+            line: z.ZodOptional<z.ZodNumber>;
+            evidence: z.ZodString;
+            replacementGuidance: z.ZodString;
+            blocksDone: z.ZodBoolean;
+            evidenceSource: z.ZodArray<z.ZodObject<{
+                source: z.ZodEnum<{
+                    spec: "spec";
+                    runtime: "runtime";
+                    policy: "policy";
+                    "project-config": "project-config";
+                }>;
+                key: z.ZodString;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        safetyExceptions: z.ZodArray<z.ZodObject<{
+            target: z.ZodString;
+            reason: z.ZodString;
+            evidence: z.ZodString;
+        }, z.core.$strip>>;
+        debtEvidence: z.ZodArray<z.ZodObject<{
+            specId: z.ZodString;
+            files: z.ZodArray<z.ZodString>;
+            ceiling: z.ZodString;
+            upgradeTrigger: z.ZodString;
+            reviewRationale: z.ZodString;
+        }, z.core.$strip>>;
+        evidence: z.ZodArray<z.ZodObject<{
+            source: z.ZodEnum<{
+                spec: "spec";
+                runtime: "runtime";
+                policy: "policy";
+                "project-config": "project-config";
+            }>;
+            key: z.ZodString;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        }, z.core.$strip>>;
+        markdown: z.ZodString;
+    }, z.core.$strip>>;
     score: z.ZodOptional<z.ZodNumber>;
     completedAt: z.ZodISODateTime;
 }, z.core.$strip>;
@@ -194,6 +250,62 @@ export declare const ARTIFACT_SCHEMAS: {
                 evidence: z.ZodArray<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        minimalityReport: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            blocked: z.ZodBoolean;
+            findings: z.ZodArray<z.ZodObject<{
+                ruleId: z.ZodString;
+                tag: z.ZodString;
+                severity: z.ZodEnum<{
+                    blocker: "blocker";
+                    warning: "warning";
+                    info: "info";
+                }>;
+                confidence: z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                }>;
+                target: z.ZodString;
+                line: z.ZodOptional<z.ZodNumber>;
+                evidence: z.ZodString;
+                replacementGuidance: z.ZodString;
+                blocksDone: z.ZodBoolean;
+                evidenceSource: z.ZodArray<z.ZodObject<{
+                    source: z.ZodEnum<{
+                        spec: "spec";
+                        runtime: "runtime";
+                        policy: "policy";
+                        "project-config": "project-config";
+                    }>;
+                    key: z.ZodString;
+                    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            safetyExceptions: z.ZodArray<z.ZodObject<{
+                target: z.ZodString;
+                reason: z.ZodString;
+                evidence: z.ZodString;
+            }, z.core.$strip>>;
+            debtEvidence: z.ZodArray<z.ZodObject<{
+                specId: z.ZodString;
+                files: z.ZodArray<z.ZodString>;
+                ceiling: z.ZodString;
+                upgradeTrigger: z.ZodString;
+                reviewRationale: z.ZodString;
+            }, z.core.$strip>>;
+            evidence: z.ZodArray<z.ZodObject<{
+                source: z.ZodEnum<{
+                    spec: "spec";
+                    runtime: "runtime";
+                    policy: "policy";
+                    "project-config": "project-config";
+                }>;
+                key: z.ZodString;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$strip>>;
+            markdown: z.ZodString;
+        }, z.core.$strip>>;
         score: z.ZodOptional<z.ZodNumber>;
         completedAt: z.ZodISODateTime;
     }, z.core.$strip>;

package/dist/engine/handoff-artifacts/schemas.js

@@ -73,6 +73,46 @@ export const ValidationReportV1Schema = z.object({
         })),
     })
         .optional(),
+    minimalityReport: z
+        .object({
+        enabled: z.boolean(),
+        blocked: z.boolean(),
+        findings: z.array(z.object({
+            ruleId: z.string(),
+            tag: z.string(),
+            severity: z.enum(['info', 'warning', 'blocker']),
+            confidence: z.enum(['low', 'medium', 'high']),
+            target: z.string(),
+            line: z.number().optional(),
+            evidence: z.string(),
+            replacementGuidance: z.string(),
+            blocksDone: z.boolean(),
+            evidenceSource: z.array(z.object({
+                source: z.enum(['policy', 'project-config', 'runtime', 'spec']),
+                key: z.string(),
+                value: z.union([z.string(), z.number(), z.boolean()]).optional(),
+            })),
+        })),
+        safetyExceptions: z.array(z.object({
+            target: z.string(),
+            reason: z.string(),
+            evidence: z.string(),
+        })),
+        debtEvidence: z.array(z.object({
+            specId: z.string(),
+            files: z.array(z.string()),
+            ceiling: z.string(),
+            upgradeTrigger: z.string(),
+            reviewRationale: z.string(),
+        })),
+        evidence: z.array(z.object({
+            source: z.enum(['policy', 'project-config', 'runtime', 'spec']),
+            key: z.string(),
+            value: z.union([z.string(), z.number(), z.boolean()]).optional(),
+        })),
+        markdown: z.string(),
+    })
+        .optional(),
     score: z.number().optional(),
     completedAt: z.iso.datetime(),
 });

package/dist/engine/minimality/analyzer.d.ts

@@ -0,0 +1,3 @@
+import type { MinimalImplementationInput, MinimalImplementationReport } from '../../types/minimal-implementation-gate.js';
+export declare function analyzeMinimalImplementation(input: MinimalImplementationInput): MinimalImplementationReport;
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/engine/minimality/analyzer.js

@@ -0,0 +1,140 @@
+import { formatMinimalImplementationReport } from './formatter.js';
+const RISK_ORDER = ['low', 'medium', 'high', 'max'];
+function riskRank(risk) {
+    const index = RISK_ORDER.indexOf(risk);
+    return index >= 0 ? index : 1;
+}
+function isExcludedPath(path, policy) {
+    return policy.excludedPathPatterns.some((pattern) => {
+        const escaped = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*/g, '.*')
+            .replace(/\*/g, '[^/]*');
+        return new RegExp(`^${escaped}$`).test(path);
+    });
+}
+function firstMatchingSafetyExclusion(text, policy) {
+    const lower = text.toLowerCase();
+    return policy.safetyExclusions.find((term) => lower.includes(term.toLowerCase())) ?? null;
+}
+function trimEvidence(value, maxChars) {
+    const compact = value.replace(/\s+/g, ' ').trim();
+    return compact.length > maxChars ? `${compact.slice(0, maxChars - 1)}...` : compact;
+}
+function lineForMatch(content, index) {
+    return content.slice(0, index).split('\n').length;
+}
+function ruleBlocksDone(rule, specRisk) {
+    if (rule.severity !== 'blocker') {
+        return false;
+    }
+    if (rule.blockWhenRiskAtLeast === undefined) {
+        return true;
+    }
+    return riskRank(specRisk) >= riskRank(rule.blockWhenRiskAtLeast);
+}
+function makeEvidence(input, rule) {
+    return [...(input.evidence ?? []), { source: 'policy', key: rule.id }];
+}
+function scanText(args) {
+    for (const pattern of args.rule.patterns) {
+        const index = args.content.toLowerCase().indexOf(pattern.toLowerCase());
+        if (index < 0) {
+            continue;
+        }
+        const evidence = trimEvidence(args.content.slice(index, index + 220), args.policy.report.maxEvidenceChars);
+        const safetyTerm = firstMatchingSafetyExclusion(args.content, args.policy);
+        if (safetyTerm !== null) {
+            return {
+                safety: {
+                    target: args.target,
+                    reason: `Matched safety exclusion: ${safetyTerm}`,
+                    evidence,
+                },
+            };
+        }
+        return {
+            finding: {
+                ruleId: args.rule.id,
+                tag: args.rule.tag,
+                severity: args.rule.severity,
+                confidence: args.rule.confidence,
+                target: args.target,
+                line: args.target.includes(':') ? undefined : lineForMatch(args.content, index),
+                evidence,
+                replacementGuidance: args.rule.replacementGuidance,
+                blocksDone: ruleBlocksDone(args.rule, args.input.specRisk),
+                evidenceSource: makeEvidence(args.input, args.rule),
+            },
+        };
+    }
+    return {};
+}
+function collectSources(input) {
+    const virtual = [];
+    if (input.specText) {
+        virtual.push({ path: 'spec.md', content: input.specText });
+    }
+    if (input.handoffText) {
+        virtual.push({ path: 'handoff', content: input.handoffText });
+    }
+    if (input.packageManifestText) {
+        virtual.push({ path: 'package.json', content: input.packageManifestText });
+    }
+    return [...virtual, ...(input.files ?? [])];
+}
+export function analyzeMinimalImplementation(input) {
+    const { policy } = input;
+    if (!policy.enabled) {
+        return {
+            enabled: false,
+            blocked: false,
+            findings: [],
+            safetyExceptions: [],
+            debtEvidence: input.acceptedDebt ?? [],
+            evidence: input.evidence ?? [],
+            markdown: '',
+        };
+    }
+    const findings = [];
+    const safetyExceptions = [];
+    for (const source of collectSources(input)) {
+        if (isExcludedPath(source.path, policy) || source.content === undefined) {
+            continue;
+        }
+        for (const rule of policy.rules) {
+            const result = scanText({
+                target: source.path,
+                content: source.content,
+                policy,
+                input,
+                rule,
+            });
+            if (result.safety) {
+                safetyExceptions.push(result.safety);
+            }
+            if (result.finding) {
+                findings.push(result.finding);
+            }
+            if (findings.length >= policy.report.maxFindings) {
+                break;
+            }
+        }
+        if (findings.length >= policy.report.maxFindings) {
+            break;
+        }
+    }
+    const report = {
+        enabled: true,
+        blocked: findings.some((finding) => finding.blocksDone),
+        findings,
+        safetyExceptions,
+        debtEvidence: input.acceptedDebt ?? [],
+        evidence: input.evidence ?? [],
+    };
+    return {
+        ...report,
+        markdown: formatMinimalImplementationReport({ ...report, markdown: '' }, policy),
+    };
+}
+//# sourceMappingURL=analyzer.js.map

package/dist/engine/minimality/formatter.d.ts

@@ -0,0 +1,3 @@
+import type { MinimalImplementationPolicy, MinimalImplementationReport } from '../../types/minimal-implementation-gate.js';
+export declare function formatMinimalImplementationReport(report: MinimalImplementationReport, policy?: MinimalImplementationPolicy): string;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/engine/minimality/formatter.js

@@ -0,0 +1,25 @@
+export function formatMinimalImplementationReport(report, policy) {
+    if (!report.enabled) {
+        return '';
+    }
+    const maxLines = policy?.report.maxMarkdownLines ?? 12;
+    const lines = ['## Minimal Implementation', ''];
+    if (report.findings.length === 0) {
+        lines.push('- No avoidable complexity findings from the current policy.');
+    }
+    else {
+        for (const finding of report.findings.slice(0, Math.max(1, maxLines - 4))) {
+            const location = finding.line !== undefined ? `${finding.target}:${String(finding.line)}` : finding.target;
+            const marker = finding.blocksDone ? 'BLOCK' : finding.severity.toUpperCase();
+            lines.push(`- [${marker}] ${finding.tag} ${location}: ${finding.replacementGuidance}`);
+        }
+    }
+    if (report.safetyExceptions.length > 0) {
+        lines.push(`- Safety exceptions preserved: ${String(report.safetyExceptions.length)} required safeguard(s).`);
+    }
+    if (report.debtEvidence.length > 0) {
+        lines.push(`- Structured debt evidence recorded: ${String(report.debtEvidence.length)} item(s).`);
+    }
+    return lines.slice(0, maxLines).join('\n');
+}
+//# sourceMappingURL=formatter.js.map

package/dist/engine/minimality/index.d.ts

@@ -0,0 +1,4 @@
+export { loadMinimalImplementationPolicy } from './policy-loader.js';
+export { analyzeMinimalImplementation } from './analyzer.js';
+export { formatMinimalImplementationReport } from './formatter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/engine/minimality/index.js

@@ -0,0 +1,4 @@
+export { loadMinimalImplementationPolicy } from './policy-loader.js';
+export { analyzeMinimalImplementation } from './analyzer.js';
+export { formatMinimalImplementationReport } from './formatter.js';
+//# sourceMappingURL=index.js.map

package/dist/engine/minimality/policy-loader.d.ts

@@ -0,0 +1,3 @@
+import type { LoadedMinimalImplementationPolicy, MinimalImplementationPolicyLoadOptions } from '../../types/minimal-implementation-gate.js';
+export declare function loadMinimalImplementationPolicy(projectPath?: string, options?: MinimalImplementationPolicyLoadOptions): Promise<LoadedMinimalImplementationPolicy>;
+//# sourceMappingURL=policy-loader.d.ts.map

package/dist/engine/minimality/policy-loader.js

@@ -0,0 +1,133 @@
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+function configPath() {
+    return join(dirname(fileURLToPath(import.meta.url)), '../../config/minimal-implementation-gate.json');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function mergeDeep(base, override) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        const current = result[key];
+        result[key] = isRecord(current) && isRecord(value) ? mergeDeep(current, value) : value;
+    }
+    return result;
+}
+function assertString(value, path) {
+    if (value === undefined) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: string is required`);
+    }
+    if (value === null) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: null is not allowed`);
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`Invalid minimal implementation policy at ${path}: expected string`);
+    }
+    if (value.length === 0) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: empty string is not allowed`);
+    }
+    if (value.trim().length === 0) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: whitespace-only string is not allowed`);
+    }
+    if (value.length > 500) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: string is too long`);
+    }
+}
+function assertStringArray(value, path) {
+    if (!Array.isArray(value)) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: expected string[]`);
+    }
+    value.forEach((item, index) => {
+        assertString(item, `${path}.${String(index)}`);
+    });
+}
+function validateRule(value, path) {
+    if (!isRecord(value)) {
+        throw new Error(`Invalid minimal implementation policy at ${path}: expected object`);
+    }
+    assertString(value.id, `${path}.id`);
+    assertString(value.tag, `${path}.tag`);
+    if (!['info', 'warning', 'blocker'].includes(String(value.severity))) {
+        throw new Error(`Invalid minimal implementation policy at ${path}.severity`);
+    }
+    if (!['low', 'medium', 'high'].includes(String(value.confidence))) {
+        throw new Error(`Invalid minimal implementation policy at ${path}.confidence`);
+    }
+    assertStringArray(value.patterns, `${path}.patterns`);
+    assertString(value.replacementGuidance, `${path}.replacementGuidance`);
+    if (value.blockWhenRiskAtLeast !== undefined &&
+        (typeof value.blockWhenRiskAtLeast !== 'string' ||
+            !['low', 'medium', 'high', 'max'].includes(value.blockWhenRiskAtLeast))) {
+        throw new Error(`Invalid minimal implementation policy at ${path}.blockWhenRiskAtLeast`);
+    }
+    return value;
+}
+function validatePolicy(value) {
+    if (!isRecord(value)) {
+        throw new Error('Invalid minimal implementation policy: expected object');
+    }
+    if (value.version !== 1) {
+        throw new Error('Invalid minimal implementation policy: version must be 1');
+    }
+    const policy = value;
+    if (typeof policy.enabled !== 'boolean') {
+        throw new Error('Invalid minimal implementation policy at enabled: expected boolean');
+    }
+    if (!isRecord(policy.report)) {
+        throw new Error('Invalid minimal implementation policy at report: expected object');
+    }
+    for (const key of ['maxFindings', 'maxMarkdownLines', 'maxEvidenceChars']) {
+        if (!Number.isFinite(policy.report[key]) || policy.report[key] < 1) {
+            throw new Error(`Invalid minimal implementation policy at report.${key}`);
+        }
+    }
+    if (!isRecord(policy.tags)) {
+        throw new Error('Invalid minimal implementation policy at tags: expected object');
+    }
+    for (const [tag, definition] of Object.entries(policy.tags)) {
+        assertString(tag, `tags.${tag}`);
+        if (!isRecord(definition)) {
+            throw new Error(`Invalid minimal implementation policy at tags.${tag}: expected object`);
+        }
+        assertString(definition.description, `tags.${tag}.description`);
+    }
+    if (!Array.isArray(policy.rules) || policy.rules.length === 0) {
+        throw new Error('Invalid minimal implementation policy at rules: expected non-empty array');
+    }
+    policy.rules.forEach((rule, index) => validateRule(rule, `rules.${String(index)}`));
+    assertStringArray(policy.safetyExclusions, 'safetyExclusions');
+    assertStringArray(policy.excludedPathPatterns, 'excludedPathPatterns');
+    if (!isRecord(policy.debtEvidence)) {
+        throw new Error('Invalid minimal implementation policy at debtEvidence: expected object');
+    }
+    assertStringArray(policy.debtEvidence.requiredFields, 'debtEvidence.requiredFields');
+    return policy;
+}
+async function readJson(path) {
+    return JSON.parse(await readFile(path, 'utf-8'));
+}
+export async function loadMinimalImplementationPolicy(projectPath, options = {}) {
+    const defaultPolicyPath = options.defaultPolicyPath ?? configPath();
+    const defaultPolicy = validatePolicy(await readJson(defaultPolicyPath));
+    const evidence = [
+        { source: 'policy', key: defaultPolicyPath },
+    ];
+    let merged = defaultPolicy;
+    if (projectPath !== undefined) {
+        const planuConfigPath = join(projectPath, 'planu.json');
+        try {
+            const config = await readJson(planuConfigPath);
+            if (isRecord(config) && isRecord(config.minimalImplementationGate)) {
+                merged = validatePolicy(mergeDeep(defaultPolicy, config.minimalImplementationGate));
+                evidence.push({ source: 'project-config', key: 'planu.json.minimalImplementationGate' });
+            }
+        }
+        catch {
+            // Missing or malformed project config does not block default policy loading.
+        }
+    }
+    return { policy: merged, evidence };
+}
+//# sourceMappingURL=policy-loader.js.map

package/dist/engine/validator/validation-report-writer.d.ts

@@ -1,5 +1,6 @@
 import type { Spec } from '../../types/index.js';
 import type { ValidationReportV1 } from '../../types/handoff-artifacts.js';
+import type { MinimalImplementationReport } from '../../types/minimal-implementation-gate.js';
 export declare function writeImplementationReviewReport(input: {
     projectId: string;
     specId: string;
@@ -8,6 +9,7 @@ export declare function writeImplementationReviewReport(input: {
     score: number | null;
     lintPassed?: boolean;
     conventionRegression?: boolean;
+    minimalityReport?: MinimalImplementationReport;
 }): Promise<{
     written: boolean;
     path?: string;

package/dist/engine/validator/validation-report-writer.js

@@ -7,6 +7,7 @@ export async function writeImplementationReviewReport(input) {
         lintPassed: input.lintPassed ?? true,
         conventionRegression: input.conventionRegression ?? false,
         specCompliance,
+        minimalityReport: input.minimalityReport,
     });
     const passed = gates.every((gate) => gate.passed);
     const reviewer = {
@@ -22,6 +23,7 @@ export async function writeImplementationReviewReport(input) {
         gates,
         reviewer,
         specCompliance: reportCompliance,
+        minimalityReport: input.minimalityReport,
         score: input.score ?? undefined,
         completedAt: new Date().toISOString(),
     };
@@ -73,8 +75,25 @@ function buildGates(args) {
             reason: args.conventionRegression ? 'Convention baseline regression detected.' : undefined,
         },
         buildSpecComplianceGate(args.specCompliance),
+        buildMinimalityGate(args.minimalityReport),
     ];
 }
+function buildMinimalityGate(report) {
+    if (report?.enabled !== true) {
+        return {
+            name: 'minimal-implementation',
+            passed: true,
+            reason: 'Minimal implementation report unavailable or disabled.',
+        };
+    }
+    return {
+        name: 'minimal-implementation',
+        passed: !report.blocked,
+        reason: report.blocked
+            ? `Blocking minimality findings: ${String(report.findings.filter((finding) => finding.blocksDone).length)}.`
+            : undefined,
+    };
+}
 function buildSpecComplianceGate(result) {
     if (result.perScenario.length === 0) {
         return {

package/dist/tools/challenge-spec.js

@@ -24,6 +24,7 @@ import { generateResilienceChallengeScenarios } from './challenge-spec/resilienc
 import { detectContradictions as detectDecisionContradictions, searchPriorDecisions, } from '../engine/prior-decisions/index.js';
 import { getDecisions } from '../storage/decision-store.js';
 import { calculateTokenBudget, injectBudgetIntoPrompt } from '../engine/token-budget/index.js';
+import { analyzeMinimalImplementation, loadMinimalImplementationPolicy, } from '../engine/minimality/index.js';
 const ALL_FOCUS_AREAS = [
     'failures',
     'concurrency',
@@ -127,6 +128,30 @@ export async function handleChallengeSpec(args, server) {
     const focusAreas = focus && focus.length > 0 ? focus : ALL_FOCUS_AREAS;
     // 5. Generate failure scenarios
     const failureScenarios = [];
+    try {
+        const { policy, evidence } = await loadMinimalImplementationPolicy(knowledge.projectPath);
+        const minimality = analyzeMinimalImplementation({
+            policy,
+            specId,
+            specRisk: spec.risk,
+            specText: specContent,
+            evidence,
+        });
+        for (const finding of minimality.findings.slice(0, 5)) {
+            failureScenarios.push({
+                scenario: `Minimal implementation concern: ${finding.tag}`,
+                probability: finding.confidence === 'high' ? 'high' : 'medium',
+                impact: finding.blocksDone ? 'high' : 'low',
+                currentHandling: `${finding.target}${finding.line ? `:${String(finding.line)}` : ''} — ${finding.evidence}`,
+                requiredHandling: finding.replacementGuidance,
+                dataConsistency: 'Scope control risk',
+                userExperience: 'Avoidable implementation complexity can increase token use and maintenance cost',
+            });
+        }
+    }
+    catch {
+        // Minimality challenge is best-effort and must not hide resilience findings.
+    }
     if (focusAreas.includes('failures')) {
         failureScenarios.push(...generateFailureScenarios(spec, specContent, knowledge));
     }

package/dist/tools/package-handoff.js

@@ -6,6 +6,7 @@ import { detectParadigms } from '../engine/paradigm-detector.js';
 import { analyzeContextPreflight, buildTokenWasteReport, formatTokenWasteReport, loadTokenWastePolicy, recommendRelevantTools, toolsFromPolicyGroups, } from '../engine/token-optimizer/index.js';
 import { appendTransitionEvent } from '../storage/transition-log.js';
 import { formatProjectGraphContext, queryProjectGraphSlice, } from '../engine/project-graph/index.js';
+import { analyzeMinimalImplementation, loadMinimalImplementationPolicy, } from '../engine/minimality/index.js';
 // ── Formatting helpers ───────────────────────────────────────────────────────
 function formatHandoff(pkg) {
     const lines = [];
@@ -196,6 +197,22 @@ async function buildGraphContextSection(args) {
         return null;
     }
 }
+async function buildMinimalImplementationReport(pkg, knowledge, spec, handoffText) {
+    try {
+        const { policy, evidence } = await loadMinimalImplementationPolicy(knowledge.projectPath);
+        return analyzeMinimalImplementation({
+            policy,
+            specId: spec.id,
+            specRisk: spec.risk,
+            handoffText,
+            files: [...pkg.filesToModify, ...pkg.filesToCreate].map((path) => ({ path, content: path })),
+            evidence,
+        });
+    }
+    catch {
+        return null;
+    }
+}
 // ── Handler ──────────────────────────────────────────────────────────────────
 export async function handlePackageHandoff(args) {
     const { projectId, specId } = args;
@@ -256,9 +273,13 @@ export async function handlePackageHandoff(args) {
         projectPath: knowledge.projectPath,
         specId,
     });
-    const handoffText = graphContext !== null
+    const baseHandoffText = graphContext !== null
         ? `${formatHandoff(pkgWithScore)}\n${graphContext.text}`
         : formatHandoff(pkgWithScore);
+    const minimalityReport = await buildMinimalImplementationReport(pkgWithScore, knowledge, spec, baseHandoffText);
+    const handoffText = minimalityReport !== null && minimalityReport.markdown.length > 0
+        ? `${baseHandoffText}\n${minimalityReport.markdown}`
+        : baseHandoffText;
     const formatted = tokenWasteReport !== null
         ? `${handoffText}\n${formatTokenWasteReport(tokenWasteReport)}`
         : handoffText;
@@ -282,6 +303,7 @@ export async function handlePackageHandoff(args) {
             blockers: pkgWithScore.blockers,
             handoffPath: pkgWithScore.handoffPath,
             contextHash: pkgWithScore.contextHash,
+            ...(minimalityReport !== null ? { minimality: minimalityReport } : {}),
             ...(tokenWasteReport !== null ? { tokenWaste: tokenWasteReport } : {}),
             ...(graphContext !== null ? { graphContext: graphContext.structured } : {}),
         },

package/dist/tools/update-status/dod-gates.js

@@ -299,6 +299,15 @@ export async function checkValidationReportGate(specId, projectId, force) {
                 fixHint: 'Fix failing gates and re-run validate before marking done.',
             });
         }
+        if (result.payload.minimalityReport?.blocked) {
+            return validationReportGateError({
+                specId,
+                error: 'minimality_findings_block_done',
+                message: 'Validation report contains blocking minimal implementation findings. Remove avoidable complexity or provide an audited forceStatusReason.',
+                gates: result.payload.gates,
+                fixHint: 'Fix blocking minimality findings and re-run validate before marking done. Use forceStatus only with an audited reason for accepted complexity.',
+            });
+        }
         if (result.payload.reviewer.verdict !== 'approved' ||
             result.payload.reviewer.agent.trim().length === 0) {
             return validationReportGateError({

package/dist/tools/validate.js

@@ -18,6 +18,7 @@ import { compareWithBaseline } from '../storage/convention-baseline.js';
 import { writeImplementationReviewReport } from '../engine/validator/validation-report-writer.js';
 import { evaluateNewCodeGate } from '../engine/ai-assurance/index.js';
 import { queryProjectGraphSlice } from '../engine/project-graph/index.js';
+import { analyzeMinimalImplementation, loadMinimalImplementationPolicy, } from '../engine/minimality/index.js';
 // Re-export for external use (SPEC-018)
 export { validateContractCompliance };
 function graphCoverageGaps(slice) {
@@ -47,6 +48,25 @@ function formatGraphCoverageText(report) {
         ? `\nGRAPH     ${String(report.gaps.length)} graph-backed coverage gap(s)`
         : '';
 }
+async function buildMinimalityReport(args) {
+    try {
+        const { policy, evidence } = await loadMinimalImplementationPolicy(args.projectPath);
+        return analyzeMinimalImplementation({
+            policy,
+            specId: args.specId,
+            specRisk: args.risk,
+            specText: [args.title ?? '', ...args.missing, ...args.extra].join('\n'),
+            files: args.qualityIssues.map((issue) => ({
+                path: issue.file,
+                content: [issue.rule, issue.message, issue.suggestion ?? ''].join('\n'),
+            })),
+            evidence,
+        });
+    }
+    catch {
+        return null;
+    }
+}
 async function validateStrictLayoutOrError(args) {
     try {
         const { validateStrictPlanuLayout } = await import('../engine/spec-migrator/index.js');
@@ -176,6 +196,15 @@ export async function handleValidate(args, server) {
     // 7. Lint check (best-effort — non-blocking)
     const lintCheck = runLintCheck(projectPath, knowledge.lintCommand ?? null);
     const assuranceGates = runAssuranceGates(projectPath);
+    const minimalityReport = await buildMinimalityReport({
+        projectPath,
+        specId,
+        risk: spec.risk,
+        title: spec.title,
+        missing: result.missing,
+        extra: result.extra,
+        qualityIssues: result.qualityIssues,
+    });
     // SPEC-1050: Generate a mandatory implementation-review artifact.
     const validationReport = await writeImplementationReviewReport({
         projectId,
@@ -185,6 +214,7 @@ export async function handleValidate(args, server) {
         score: result.score,
         lintPassed: lintCheck.passed,
         conventionRegression: regressionDetected,
+        minimalityReport: minimalityReport ?? undefined,
     });
     // 8. Build output
     const output = {
@@ -262,6 +292,7 @@ export async function handleValidate(args, server) {
         lintCheck,
         assuranceGates,
         validationReport,
+        minimalityReport,
         graphCoverage,
     };
     // SPEC-612: Scope boundary validation — warn if impl files match outOfScope items
@@ -312,6 +343,9 @@ export async function handleValidate(args, server) {
     if (!assuranceGates.newCode.passed) {
         suggestions.push(`Assurance gate failed: ${String(assuranceGates.newCode.findings.length)} new-code domain inference issue(s) found.`);
     }
+    if (minimalityReport?.blocked) {
+        suggestions.push(`${minimalityReport.findings.filter((finding) => finding.blocksDone).length} blocking minimality finding(s) detected. Remove avoidable complexity or record accepted debt before marking done.`);
+    }
     const outputWithSuggestions = compactObj({
         ...output,
         suggestions: suggestions.length > 0 ? suggestions : undefined,

package/dist/types/handoff-artifacts.d.ts

@@ -72,6 +72,7 @@ export interface ValidationReportV1 {
             evidence: string[];
         }[];
     };
+    minimalityReport?: MinimalImplementationReport;
     score?: number;
     completedAt: string;
 }
@@ -83,4 +84,5 @@ export interface ArtifactPayloadMap {
     'validation-report': ValidationReportV1;
 }
 export type ArtifactPayload<K extends ArtifactKind> = ArtifactPayloadMap[K];
+import type { MinimalImplementationReport } from './minimal-implementation-gate.js';
 //# sourceMappingURL=handoff-artifacts.d.ts.map

package/dist/types/index.d.ts

@@ -80,6 +80,7 @@ export * from './workers.js';
 export * from './orchestration-runtime.js';
 export * from './token-optimization.js';
 export * from './token-waste-autopilot.js';
+export * from './minimal-implementation-gate.js';
 export * from './llm-providers.js';
 export * from './plugins.js';
 export * from './github.js';

package/dist/types/index.js

@@ -81,6 +81,7 @@ export * from './workers.js';
 export * from './orchestration-runtime.js';
 export * from './token-optimization.js';
 export * from './token-waste-autopilot.js';
+export * from './minimal-implementation-gate.js';
 export * from './llm-providers.js';
 export * from './plugins.js';
 export * from './github.js';

package/dist/types/minimal-implementation-gate.d.ts

@@ -0,0 +1,92 @@
+export type MinimalImplementationTag = string;
+export type MinimalImplementationSeverity = 'info' | 'warning' | 'blocker';
+export type MinimalImplementationConfidence = 'low' | 'medium' | 'high';
+export type MinimalImplementationSource = 'policy' | 'project-config' | 'runtime' | 'spec';
+export interface MinimalImplementationPolicyLoadOptions {
+    defaultPolicyPath?: string;
+}
+export interface MinimalImplementationEvidence {
+    source: MinimalImplementationSource;
+    key: string;
+    value?: string | number | boolean;
+}
+export interface MinimalImplementationRule {
+    id: string;
+    tag: MinimalImplementationTag;
+    severity: MinimalImplementationSeverity;
+    confidence: MinimalImplementationConfidence;
+    patterns: string[];
+    replacementGuidance: string;
+    blockWhenRiskAtLeast?: 'low' | 'medium' | 'high' | 'max';
+}
+export interface MinimalImplementationPolicy {
+    version: 1;
+    enabled: boolean;
+    report: {
+        maxFindings: number;
+        maxMarkdownLines: number;
+        maxEvidenceChars: number;
+    };
+    tags: Record<string, {
+        description: string;
+    }>;
+    rules: MinimalImplementationRule[];
+    safetyExclusions: string[];
+    excludedPathPatterns: string[];
+    debtEvidence: {
+        requiredFields: string[];
+    };
+}
+export interface LoadedMinimalImplementationPolicy {
+    policy: MinimalImplementationPolicy;
+    evidence: MinimalImplementationEvidence[];
+}
+export interface MinimalImplementationFileSignal {
+    path: string;
+    content?: string;
+}
+export interface MinimalImplementationInput {
+    policy: MinimalImplementationPolicy;
+    specId?: string;
+    specRisk?: string;
+    specText?: string;
+    handoffText?: string;
+    files?: MinimalImplementationFileSignal[];
+    packageManifestText?: string;
+    acceptedDebt?: MinimalImplementationDebtEvidence[];
+    evidence?: MinimalImplementationEvidence[];
+}
+export interface MinimalImplementationFinding {
+    ruleId: string;
+    tag: MinimalImplementationTag;
+    severity: MinimalImplementationSeverity;
+    confidence: MinimalImplementationConfidence;
+    target: string;
+    line?: number;
+    evidence: string;
+    replacementGuidance: string;
+    blocksDone: boolean;
+    evidenceSource: MinimalImplementationEvidence[];
+}
+export interface MinimalImplementationSafetyException {
+    target: string;
+    reason: string;
+    evidence: string;
+}
+export interface MinimalImplementationDebtEvidence {
+    specId: string;
+    files: string[];
+    ceiling: string;
+    upgradeTrigger: string;
+    reviewRationale: string;
+}
+export interface MinimalImplementationReport {
+    enabled: boolean;
+    blocked: boolean;
+    findings: MinimalImplementationFinding[];
+    safetyExceptions: MinimalImplementationSafetyException[];
+    debtEvidence: MinimalImplementationDebtEvidence[];
+    evidence: MinimalImplementationEvidence[];
+    markdown: string;
+}
+//# sourceMappingURL=minimal-implementation-gate.d.ts.map

package/dist/types/minimal-implementation-gate.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=minimal-implementation-gate.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "4.7.1",
+  "version": "4.7.2",
   "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",
@@ -34,14 +34,14 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "4.7.1",
-    "@planu/core-darwin-x64": "4.7.1",
-    "@planu/core-linux-arm64-gnu": "4.7.1",
-    "@planu/core-linux-arm64-musl": "4.7.1",
-    "@planu/core-linux-x64-gnu": "4.7.1",
-    "@planu/core-linux-x64-musl": "4.7.1",
-    "@planu/core-win32-arm64-msvc": "4.7.1",
-    "@planu/core-win32-x64-msvc": "4.7.1"
+    "@planu/core-darwin-arm64": "4.7.2",
+    "@planu/core-darwin-x64": "4.7.2",
+    "@planu/core-linux-arm64-gnu": "4.7.2",
+    "@planu/core-linux-arm64-musl": "4.7.2",
+    "@planu/core-linux-x64-gnu": "4.7.2",
+    "@planu/core-linux-x64-musl": "4.7.2",
+    "@planu/core-win32-arm64-msvc": "4.7.2",
+    "@planu/core-win32-x64-msvc": "4.7.2"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -129,7 +129,7 @@
   ],
   "license": "SEE LICENSE IN LICENSE",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.104.1",
+    "@anthropic-ai/sdk": "^0.104.2",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "glob": "^13.0.6",
     "yaml": "^2.9.0",
@@ -171,7 +171,7 @@
     "@commitlint/cli": "^21.0.2",
     "@commitlint/config-conventional": "^21.0.2",
     "@eslint/js": "^10.0.1",
-    "@napi-rs/cli": "^3.7.1",
+    "@napi-rs/cli": "^3.7.2",
     "@secretlint/secretlint-rule-no-homedir": "^13.0.2",
     "@secretlint/secretlint-rule-preset-recommend": "^13.0.2",
     "@semantic-release/changelog": "^6.0.3",
@@ -182,19 +182,19 @@
     "@semantic-release/release-notes-generator": "^14.1.1",
     "@stryker-mutator/core": "^9.6.1",
     "@stryker-mutator/vitest-runner": "^9.6.1",
-    "@supabase/supabase-js": "^2.108.1",
+    "@supabase/supabase-js": "^2.108.2",
     "@types/node": "^25.9.3",
     "@vitejs/plugin-vue": "^6.0.7",
-    "@vitest/coverage-v8": "^4.1.8",
+    "@vitest/coverage-v8": "^4.1.9",
     "@vue/test-utils": "^2.4.11",
     "eslint": "^10.5.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import": "^2.32.0",
-    "happy-dom": "^20.10.3",
+    "happy-dom": "^20.10.5",
     "husky": "^9.1.7",
     "javascript-obfuscator": "^5.4.3",
-    "knip": "^6.16.1",
+    "knip": "^6.17.1",
     "lint-staged": "^17.0.7",
     "madge": "^8.0.0",
     "prettier": "^3.8.4",
@@ -203,9 +203,9 @@
     "tsc-alias": "^1.8.17",
     "type-coverage": "^2.29.7",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.61.0",
+    "typescript-eslint": "^8.61.1",
     "vite": "^8.0.16",
-    "vitest": "^4.1.8",
+    "vitest": "^4.1.9",
     "vue": "^3.5.38"
   }
 }

package/planu-native.json

@@ -1,26 +1,20 @@
 {
   "name": "dev.planu.native",
   "displayName": "Planu Native Lightweight Surface",
-  "version": "4.7.1",
+  "version": "4.7.2",
   "packageName": "@planu/cli",
   "modes": {
     "lightweight": {
       "requiresMcp": false,
       "requiresDaemon": false,
-      "hosts": [
-        "codex",
-        "claude-code"
-      ],
+      "hosts": ["codex", "claude-code"],
       "commands": [
         {
           "id": "planu.status",
           "title": "Project status",
           "description": "Show the compact Planu project snapshot without loading the MCP tool graph.",
           "invocation": "planu status",
-          "hosts": [
-            "codex",
-            "claude-code"
-          ],
+          "hosts": ["codex", "claude-code"],
           "requiresMcp": false,
           "requiresDaemon": false,
           "mapsTo": "handlePlanStatus"
@@ -30,10 +24,7 @@
           "title": "Create spec",
           "description": "Create a new spec through the CLI-backed SDD contract.",
           "invocation": "planu spec create \"<title>\"",
-          "hosts": [
-            "codex",
-            "claude-code"
-          ],
+          "hosts": ["codex", "claude-code"],
           "requiresMcp": false,
           "requiresDaemon": false,
           "mapsTo": "handleCreateSpec"
@@ -43,10 +34,7 @@
           "title": "List specs",
           "description": "List specs in the current project with optional status/type filters.",
           "invocation": "planu spec list",
-          "hosts": [
-            "codex",
-            "claude-code"
-          ],
+          "hosts": ["codex", "claude-code"],
           "requiresMcp": false,
           "requiresDaemon": false,
           "mapsTo": "handleListSpecs"
@@ -56,10 +44,7 @@
           "title": "Validate spec",
           "description": "Validate a spec against the current codebase from the native CLI surface.",
           "invocation": "planu spec validate SPEC-001",
-          "hosts": [
-            "codex",
-            "claude-code"
-          ],
+          "hosts": ["codex", "claude-code"],
           "requiresMcp": false,
           "requiresDaemon": false,
           "mapsTo": "handleValidate"
@@ -69,10 +54,7 @@
           "title": "Audit technical debt",
           "description": "Run the read-only project audit path for lightweight debt checks.",
           "invocation": "planu audit debt",
-          "hosts": [
-            "codex",
-            "claude-code"
-          ],
+          "hosts": ["codex", "claude-code"],
           "requiresMcp": false,
           "requiresDaemon": false,
           "mapsTo": "handleAudit"
@@ -82,10 +64,7 @@
           "title": "Check release readiness",
           "description": "Check local branch cleanliness and main/develop/release sync readiness.",
           "invocation": "planu release check",
-          "hosts": [
-            "codex",
-            "claude-code"
-          ],
+          "hosts": ["codex", "claude-code"],
           "requiresMcp": false,
           "requiresDaemon": false,
           "mapsTo": "releaseCommand"

package/planu-plugin.json

@@ -2,12 +2,9 @@
   "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": "4.7.1",
+  "version": "4.7.2",
   "icon": "assets/plugin/icon.svg",
-  "command": [
-    "npx",
-    "@planu/cli@latest"
-  ],
+  "command": ["npx", "@planu/cli@latest"],
   "packageName": "@planu/cli",
   "capabilities": {
     "tools": [
@@ -26,42 +23,17 @@
       "create_skill",
       "skill_search"
     ],
-    "resources": [
-      "planu://specs/list",
-      "planu://specs/{id}",
-      "planu://project/status",
-      "planu://roadmap"
-    ],
-    "prompts": [
-      "create-spec-from-idea",
-      "review-spec-readiness",
-      "generate-implementation-plan"
-    ],
-    "subagents": [
-      "sdd-orchestrator",
-      "spec-challenger",
-      "test-generator"
-    ]
+    "resources": ["planu://specs/list", "planu://specs/{id}", "planu://project/status", "planu://roadmap"],
+    "prompts": ["create-spec-from-idea", "review-spec-readiness", "generate-implementation-plan"],
+    "subagents": ["sdd-orchestrator", "spec-challenger", "test-generator"]
   },
   "compatibility": {
     "minimumHostVersion": "1.0.0",
-    "requiredFeatures": [
-      "mcp-tools",
-      "file-editing"
-    ]
+    "requiredFeatures": ["mcp-tools", "file-editing"]
   },
   "repository": "https://github.com/planu-dev/planu",
   "author": "Planu",
   "license": "MIT",
   "homepage": "https://planu.dev",
-  "keywords": [
-    "sdd",
-    "spec-driven-development",
-    "mcp",
-    "specs",
-    "planning",
-    "ai",
-    "bdd",
-    "tdd"
-  ]
+  "keywords": ["sdd", "spec-driven-development", "mcp", "specs", "planning", "ai", "bdd", "tdd"]
 }