@planu/cli 4.4.3 → 4.5.0

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [4.5.0] - 2026-06-10
+
+### Features
+- feat(create-spec): generate intent-grounded questions
+
+### Chores
+- chore(deps): update release tooling
+
+
 ## [4.4.3] - 2026-06-09
 
 ### Features
@@ -4042,4 +4051,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/engine/elicitation/answer-extractor.js

@@ -5,6 +5,12 @@ const BACKEND_TERMS = /\b(api|endpoint|route|handler|migration|query|rpc|action|
 const INFRA_TERMS = /\b(deploy|ci|cd|docker|pipeline|config|env)\b/;
 const BILLING_TERMS = /\b(payment|billing|invoice|subscription|checkout|pricing|pay)\b/;
 const DATABASE_TERMS = /\b(database|schema|migration|table|query|sql|rls|rpc|persist|persistence|data access)\b/;
+const ACTION_RE = /\b(add|build|create|fix|update|remove|delete|integrate|sync|import|export|approve|reject|upload|download|migrate|configure|validate)\b\s+(?:(?:a|an|the|new)\s+)?([a-z0-9][a-z0-9 -]{1,60})/i;
+const ACTOR_TERMS = /\b(admin|administrator|manager|owner|customer|user|member|team|approver)\b/gi;
+const DATA_OBJECT_TERMS = /\b(account|profile|request|invoice|subscription|payment|order|report|file|avatar|table|policy|record|settings)\b/gi;
+const PERMISSION_TERMS = /\b(approval|approve|reject|admin|permission|role|rls|policy|access|auth|login|oauth|owner|manager)\b/;
+const DESTRUCTIVE_TERMS = /\b(delete|remove|archive|discard|drop|truncate|revoke|reset)\b/;
+const RISK_TERMS = /\b(approval|approve|payment|billing|auth|login|permission|role|delete|remove|migration|sync|webhook|external|api|rls|privacy|security)\b/gi;
 const PAYMENT_PROVIDERS = [
     { name: 'Stripe', pattern: /\bstripe\b/ },
     { name: 'PayPal', pattern: /\bpaypal\b/ },
@@ -33,7 +39,34 @@ export function extractSignals(description) {
     const hasBilling = BILLING_TERMS.test(lower) || namedProvider !== null;
     const wordCount = description.trim().split(/\s+/).length;
     const hasScope = wordCount >= 10;
-    return { hasTarget, hasBilling, hasDatabase, hasUi, namedProvider, hasScope };
+    const actionMatch = ACTION_RE.exec(lower);
+    const action = actionMatch?.[1] ?? null;
+    const domainObject = cleanDomainObject(actionMatch?.[2] ?? null);
+    const actors = uniqueMatches(lower, ACTOR_TERMS);
+    const dataObjects = uniqueMatches(lower, DATA_OBJECT_TERMS);
+    const riskTerms = uniqueMatches(lower, RISK_TERMS);
+    const integrations = [
+        ...PAYMENT_PROVIDERS.filter(({ pattern }) => pattern.test(lower)).map(({ name }) => name),
+        ...extractExternalIntegrations(lower),
+    ];
+    const hasPermissionRisk = PERMISSION_TERMS.test(lower);
+    const hasDestructiveAction = DESTRUCTIVE_TERMS.test(lower);
+    return {
+        hasTarget,
+        hasBilling,
+        hasDatabase,
+        hasUi,
+        namedProvider,
+        hasScope,
+        action,
+        domainObject,
+        actors,
+        integrations,
+        dataObjects,
+        hasPermissionRisk,
+        hasDestructiveAction,
+        riskTerms,
+    };
 }
 function stripIncidentalReferences(description) {
     return description
@@ -41,4 +74,23 @@ function stripIncidentalReferences(description) {
         .replace(/\b\S+\/\S+\b/g, ' ')
         .replace(/\b[\w-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|css|scss|py|go|rs|java|rb|php)\b/g, ' ');
 }
+function cleanDomainObject(value) {
+    if (value === null) {
+        return null;
+    }
+    const cleaned = value
+        .replace(/\b(that|with|to|from|when|where|and|or|but|using|in)\b.*$/i, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return cleaned.length > 0 ? cleaned : null;
+}
+function uniqueMatches(text, pattern) {
+    const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+    const globalPattern = new RegExp(pattern.source, flags);
+    return Array.from(new Set(Array.from(text.matchAll(globalPattern)).map((match) => match[0])));
+}
+function extractExternalIntegrations(text) {
+    const matches = text.match(/\b([a-z][a-z0-9-]+)\s+(?:api|webhook|sdk|integration)\b/gi) ?? [];
+    return Array.from(new Set(matches.map((match) => match.replace(/\s+(api|webhook|sdk|integration)$/i, ''))));
+}
 //# sourceMappingURL=answer-extractor.js.map

package/dist/engine/elicitation/decision-gap-detector.d.ts

@@ -0,0 +1,3 @@
+import type { DecisionGap, ProjectKnowledge, DescriptionSignals } from '../../types/index.js';
+export declare function detectDecisionGaps(signals: DescriptionSignals, _projectContext: ProjectKnowledge | null): DecisionGap[];
+//# sourceMappingURL=decision-gap-detector.d.ts.map

package/dist/engine/elicitation/decision-gap-detector.js

@@ -0,0 +1,162 @@
+const MAX_GAPS = 3;
+export function detectDecisionGaps(signals, _projectContext) {
+    const gaps = [
+        buildPermissionGap(signals),
+        buildProviderGap(signals),
+        buildBillingModelGap(signals),
+        buildDataGap(signals),
+        buildFailureGap(signals),
+    ].filter((gap) => gap !== null);
+    if (gaps.length === 0 && !signals.hasScope) {
+        gaps.push(buildBehaviorGap(signals));
+    }
+    return gaps.slice(0, MAX_GAPS);
+}
+function buildPermissionGap(signals) {
+    if (!signals.hasPermissionRisk || signals.actors.length > 0) {
+        return null;
+    }
+    const subject = formatSubject(signals);
+    return makeGap({
+        id: 'permission-owner',
+        kind: 'permission',
+        header: 'Permission',
+        question: `For ${subject}, who is allowed to perform this action? This changes permissions, validation, and audit behavior.`,
+        evidence: evidenceFrom(signals, ['permission-sensitive wording']),
+        impact: 'Changes authorization checks and acceptance criteria.',
+        options: options([
+            ['Role-based owner (Recommended)', 'Use the existing role or owner model for this action.'],
+            ['Admin only', 'Restrict the behavior to administrators.'],
+            ['Any signed-in user', 'Allow all authenticated users and keep checks minimal.'],
+        ]),
+    });
+}
+function buildProviderGap(signals) {
+    if (!signals.hasBilling || signals.namedProvider !== null) {
+        return null;
+    }
+    const subject = formatSubject(signals);
+    return makeGap({
+        id: 'payment-provider',
+        kind: 'provider',
+        header: 'Provider',
+        question: `For ${subject}, which payment provider should own the payment flow? This changes API contracts, webhook handling, and test fixtures.`,
+        evidence: evidenceFrom(signals, ['billing/payment wording']),
+        impact: 'Changes integration code, webhook behavior, and verification fixtures.',
+        options: options([
+            ['Stripe (Recommended)', 'Use the most common provider for subscription and checkout flows.'],
+            ['PayPal', 'Use PayPal checkout and payment APIs.'],
+            [
+                'No provider yet',
+                'Keep provider integration out of scope and define internal contracts only.',
+            ],
+        ]),
+    });
+}
+function buildBillingModelGap(signals) {
+    if (!signals.hasBilling) {
+        return null;
+    }
+    const subject = formatSubject(signals);
+    return makeGap({
+        id: 'billing-model',
+        kind: 'billing-model',
+        header: 'Billing',
+        question: `For ${subject}, is the billing behavior recurring, one-time, or invoice-based? This changes states, events, and acceptance criteria.`,
+        evidence: evidenceFrom(signals, ['billing/payment wording']),
+        impact: 'Changes lifecycle states and acceptance criteria.',
+        options: options([
+            ['Recurring subscription (Recommended)', 'Model ongoing subscriptions and renewal states.'],
+            ['One-time checkout', 'Model a single payment completion flow.'],
+            ['Invoice-based', 'Model invoice creation, payment, and overdue states.'],
+        ]),
+    });
+}
+function buildDataGap(signals) {
+    if (!signals.hasDatabase || signals.dataObjects.length > 0) {
+        return null;
+    }
+    const subject = formatSubject(signals);
+    return makeGap({
+        id: 'data-shape',
+        kind: 'data',
+        header: 'Data',
+        question: `For ${subject}, what data must be stored or updated? This changes schema, validation, and migration work.`,
+        evidence: evidenceFrom(signals, ['database/data wording']),
+        impact: 'Changes schema, persistence, and validation requirements.',
+        options: options([
+            [
+                'Existing records only (Recommended)',
+                'Use existing tables or records without a new schema.',
+            ],
+            ['New table or field', 'Add persistence changes and migration coverage.'],
+            ['Read-only data', 'Do not persist new state for this behavior.'],
+        ]),
+    });
+}
+function buildFailureGap(signals) {
+    if (signals.integrations.length === 0 &&
+        !signals.riskTerms.includes('sync') &&
+        !signals.riskTerms.includes('api')) {
+        return null;
+    }
+    const subject = formatSubject(signals);
+    return makeGap({
+        id: 'failure-handling',
+        kind: 'failure',
+        header: 'Failure',
+        question: `For ${subject}, what should happen if ${formatIntegration(signals)} fails? This changes retry, error, and user-visible behavior.`,
+        evidence: evidenceFrom(signals, signals.integrations.length > 0 ? signals.integrations : ['integration/API wording']),
+        impact: 'Changes error handling, retries, and tests.',
+        options: options([
+            ['Show recoverable error (Recommended)', 'Return a clear error and preserve current state.'],
+            ['Retry automatically', 'Retry transient failures before surfacing an error.'],
+            ['Queue for later', 'Persist work for asynchronous retry.'],
+        ]),
+    });
+}
+function buildBehaviorGap(signals) {
+    const subject = formatSubject(signals);
+    return makeGap({
+        id: 'behavior-outcome',
+        kind: 'behavior',
+        header: 'Behavior',
+        question: `For ${subject}, what observable outcome should prove the work is done? This becomes the primary acceptance criterion.`,
+        evidence: evidenceFrom(signals, ['short request']),
+        impact: 'Changes the main acceptance criterion and verification command.',
+        options: options([
+            ['User-visible workflow (Recommended)', 'Define the end-to-end behavior a user can observe.'],
+            ['Backend behavior', 'Define API, persistence, job, or integration behavior.'],
+            ['Cleanup or fix', 'Define the before/after bug or cleanup result.'],
+        ]),
+    });
+}
+function makeGap(gap) {
+    return { ...gap, multiSelect: gap.multiSelect ?? false, blocking: true };
+}
+function formatSubject(signals) {
+    const action = signals.action ?? 'this request';
+    const object = signals.domainObject;
+    return object === null ? action : `${action} ${object}`;
+}
+function formatIntegration(signals) {
+    if (signals.integrations.length > 0) {
+        return signals.integrations[0] ?? 'the integration';
+    }
+    if (signals.riskTerms.includes('sync')) {
+        return 'the sync';
+    }
+    return 'the API';
+}
+function evidenceFrom(signals, extra) {
+    return [
+        ...(signals.action ? [`action:${signals.action}`] : []),
+        ...(signals.domainObject ? [`object:${signals.domainObject}`] : []),
+        ...signals.riskTerms.map((term) => `risk:${term}`),
+        ...extra,
+    ].slice(0, 6);
+}
+function options(items) {
+    return items.map(([label, description]) => ({ label, description }));
+}
+//# sourceMappingURL=decision-gap-detector.js.map

package/dist/engine/elicitation/question-grounding-gate.d.ts

@@ -0,0 +1,3 @@
+import type { InteractiveQuestion, QuestionGroundingContext, QuestionGroundingResult } from '../../types/index.js';
+export declare function validateQuestionGrounding(question: InteractiveQuestion, context: QuestionGroundingContext): QuestionGroundingResult;
+//# sourceMappingURL=question-grounding-gate.d.ts.map

package/dist/engine/elicitation/question-grounding-gate.js

@@ -0,0 +1,54 @@
+const GENERIC_QUESTION_PATTERNS = [
+    /^who (are|is) the users\??$/i,
+    /^what are the edge cases\??$/i,
+    /^what should happen\??$/i,
+    /^what is the scope\??$/i,
+    /^what data is needed\??$/i,
+    /^what are the requirements\??$/i,
+];
+export function validateQuestionGrounding(question, context) {
+    const text = question.question.trim();
+    if (GENERIC_QUESTION_PATTERNS.some((pattern) => pattern.test(text))) {
+        return { passed: false, reason: 'Question is a generic reusable prompt.' };
+    }
+    const lowerQuestion = text.toLowerCase();
+    const lowerEvidence = [context.requestText, ...context.gap.evidence].join(' ').toLowerCase();
+    const evidenceTokens = tokenSet(lowerEvidence);
+    const hasRequestEvidence = Array.from(evidenceTokens).some((token) => token.length >= 3 && lowerQuestion.includes(token));
+    if (!hasRequestEvidence) {
+        return {
+            passed: false,
+            reason: 'Question does not include evidence from the request or detected gap.',
+        };
+    }
+    if (!/\bchanges?\b|\bthis changes\b|\baffects?\b|\bbecause\b|\bbecomes?\b/i.test(text)) {
+        return {
+            passed: false,
+            reason: 'Question does not explain why the answer matters for the spec.',
+        };
+    }
+    return { passed: true };
+}
+function tokenSet(text) {
+    return new Set(text
+        .replace(/[^a-z0-9 ]/gi, ' ')
+        .split(/\s+/)
+        .filter((token) => !STOP_WORDS.has(token) && token.length > 2));
+}
+const STOP_WORDS = new Set([
+    'the',
+    'and',
+    'for',
+    'this',
+    'that',
+    'with',
+    'from',
+    'what',
+    'when',
+    'where',
+    'should',
+    'action',
+    'object',
+    'risk',
+]);
+//# sourceMappingURL=question-grounding-gate.js.map

package/dist/tools/create-spec/question-generator.d.ts

@@ -1,4 +1,4 @@
 import type { InteractiveQuestion, ProjectKnowledge } from '../../types/index.js';
-/** Generate clarification questions based on description gaps and project context. */
+/** Generate clarification questions based on request-specific missing decisions. */
 export declare function generateInteractiveQuestions(description: string, knowledge: ProjectKnowledge | null): InteractiveQuestion[];
 //# sourceMappingURL=question-generator.d.ts.map

package/dist/tools/create-spec/question-generator.js

@@ -1,101 +1,25 @@
-// tools/create-spec/question-generator.ts — SPEC-463 / SPEC-619 / SPEC-624
-// Config-driven interactive question generation with answer pre-extraction.
-import { t } from '../../i18n/index.js';
+// tools/create-spec/question-generator.ts — SPEC-1083
+// Dynamic clarification questions grounded in the user's requested work.
 import { extractSignals } from '../../engine/elicitation/answer-extractor.js';
-import { buildTargetOptions, buildPaymentProviderOptions, buildBillingModelOptions, buildScopeOptions, buildDatabaseOptions, buildUiTypeOptions, } from '../../engine/elicitation/option-builder.js';
-import dimensionsConfig from '../../config/elicitation-dimensions.json' with { type: 'json' };
-const MAX_QUESTIONS = 4;
-const DIMENSIONS = dimensionsConfig;
-/** Generate clarification questions based on description gaps and project context. */
+import { detectDecisionGaps } from '../../engine/elicitation/decision-gap-detector.js';
+import { validateQuestionGrounding } from '../../engine/elicitation/question-grounding-gate.js';
+/** Generate clarification questions based on request-specific missing decisions. */
 export function generateInteractiveQuestions(description, knowledge) {
     const signals = extractSignals(description);
-    const questions = [];
-    for (const dim of DIMENSIONS) {
-        if (questions.length >= MAX_QUESTIONS) {
-            break;
-        }
-        if (!shouldInclude(dim, signals, knowledge)) {
-            continue;
-        }
-        questions.push({
-            question: t(dim.questionKey),
-            header: t(dim.headerKey),
-            options: buildOptions(dim.optionSet, knowledge),
-            multiSelect: dim.multiSelect,
-        });
-    }
-    return questions;
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function isSuppressed(key, signals) {
-    if (key === 'hasTarget') {
-        return signals.hasTarget;
-    }
-    if (key === 'hasScope') {
-        return signals.hasScope;
-    }
-    if (key === 'namedProvider') {
-        return signals.namedProvider !== null;
-    }
-    return false;
-}
-function hasRequiredSignal(key, signals) {
-    if (key === 'hasBilling') {
-        return signals.hasBilling;
-    }
-    if (key === 'hasDatabase') {
-        return signals.hasDatabase;
-    }
-    if (key === 'hasUi') {
-        return signals.hasUi;
-    }
-    if (key === 'hasTarget') {
-        return signals.hasTarget;
-    }
-    if (key === 'hasScope') {
-        return signals.hasScope;
-    }
-    return false;
-}
-function matchesDNA(required, knowledge) {
-    if (!knowledge) {
-        return false;
-    }
-    const database = knowledge.database;
-    const stack = knowledge.stack;
-    const framework = knowledge.framework ?? '';
-    return required.some((r) => database === r || framework === r || stack.includes(r));
-}
-function shouldInclude(dim, signals, knowledge) {
-    if (dim.suppressWhen !== undefined && isSuppressed(dim.suppressWhen, signals)) {
-        return false;
-    }
-    if (dim.requiresSignal !== undefined && !hasRequiredSignal(dim.requiresSignal, signals)) {
-        return false;
-    }
-    if (dim.requiresDNA !== undefined) {
-        return matchesDNA(dim.requiresDNA, knowledge);
-    }
-    return true;
-}
-function buildOptions(optionSet, knowledge) {
-    switch (optionSet) {
-        case 'target':
-            return buildTargetOptions();
-        case 'payment_provider':
-            return buildPaymentProviderOptions(knowledge);
-        case 'billing_model':
-            return buildBillingModelOptions();
-        case 'scope':
-            return buildScopeOptions();
-        case 'database':
-            return buildDatabaseOptions();
-        case 'uiType':
-            return buildUiTypeOptions();
-        default:
-            return [];
-    }
+    const gaps = detectDecisionGaps(signals, knowledge);
+    return gaps.flatMap((gap) => {
+        const question = {
+            question: gap.question,
+            header: gap.header,
+            options: gap.options,
+            multiSelect: gap.multiSelect,
+        };
+        return validateQuestionGrounding(question, {
+            gap,
+            requestText: description,
+        }).passed
+            ? [question]
+            : [];
+    });
 }
 //# sourceMappingURL=question-generator.js.map

package/dist/types/clarification.d.ts

@@ -13,6 +13,14 @@ export interface DescriptionSignals {
     hasUi: boolean;
     namedProvider: string | null;
     hasScope: boolean;
+    action: string | null;
+    domainObject: string | null;
+    actors: string[];
+    integrations: string[];
+    dataObjects: string[];
+    hasPermissionRisk: boolean;
+    hasDestructiveAction: boolean;
+    riskTerms: string[];
 }
 /** Which host mechanism the LLM should use to relay interactive questions. */
 export type HostHint = 'claude-code' | 'cursor' | 'codex' | 'gemini' | 'universal';

package/dist/types/elicitation.d.ts

@@ -1,4 +1,5 @@
 import type { InteractiveQuestion } from './clarification.js';
+import type { InteractiveOption } from './interactive-question.js';
 /** Primitive field types supported by the MCP elicitation protocol. */
 export type ElicitationFieldType = 'text' | 'number' | 'boolean' | 'enum' | 'multi-select';
 /** Shared base for all elicitation field definitions. */
@@ -174,6 +175,26 @@ export type ElicitOrFallbackOutcome = {
  * - 'technical': inferred from codebase signals; elicitation is skipped
  */
 export type DecisionType = 'policy' | 'business' | 'technical';
+export type DecisionGapKind = 'behavior' | 'permission' | 'provider' | 'billing-model' | 'data' | 'failure' | 'scope';
+export interface DecisionGap {
+    id: string;
+    kind: DecisionGapKind;
+    header: string;
+    question: string;
+    evidence: string[];
+    impact: string;
+    options: InteractiveOption[];
+    multiSelect: boolean;
+    blocking: boolean;
+}
+export interface QuestionGroundingContext {
+    gap: DecisionGap;
+    requestText: string;
+}
+export interface QuestionGroundingResult {
+    passed: boolean;
+    reason?: string;
+}
 /**
  * Outcome when the decision was already cached in conventions.json.
  * The caller can return this value immediately without prompting the user.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "4.4.3",
+  "version": "4.5.0",
   "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.4.3",
-    "@planu/core-darwin-x64": "4.4.3",
-    "@planu/core-linux-arm64-gnu": "4.4.3",
-    "@planu/core-linux-arm64-musl": "4.4.3",
-    "@planu/core-linux-x64-gnu": "4.4.3",
-    "@planu/core-linux-x64-musl": "4.4.3",
-    "@planu/core-win32-arm64-msvc": "4.4.3",
-    "@planu/core-win32-x64-msvc": "4.4.3"
+    "@planu/core-darwin-arm64": "4.5.0",
+    "@planu/core-darwin-x64": "4.5.0",
+    "@planu/core-linux-arm64-gnu": "4.5.0",
+    "@planu/core-linux-arm64-musl": "4.5.0",
+    "@planu/core-linux-x64-gnu": "4.5.0",
+    "@planu/core-linux-x64-musl": "4.5.0",
+    "@planu/core-win32-arm64-msvc": "4.5.0",
+    "@planu/core-win32-x64-msvc": "4.5.0"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -170,7 +170,7 @@
     "@commitlint/cli": "^21.0.2",
     "@commitlint/config-conventional": "^21.0.2",
     "@eslint/js": "^10.0.1",
-    "@napi-rs/cli": "^3.7.0",
+    "@napi-rs/cli": "^3.7.1",
     "@secretlint/secretlint-rule-no-homedir": "^13.0.2",
     "@secretlint/secretlint-rule-preset-recommend": "^13.0.2",
     "@semantic-release/changelog": "^6.0.3",
@@ -198,7 +198,7 @@
     "madge": "^8.0.0",
     "prettier": "^3.8.4",
     "secretlint": "^13.0.2",
-    "semantic-release": "^25.0.3",
+    "semantic-release": "^25.0.5",
     "tsc-alias": "^1.8.17",
     "type-coverage": "^2.29.7",
     "typescript": "^6.0.3",

package/planu-native.json

@@ -1,20 +1,26 @@
 {
   "name": "dev.planu.native",
   "displayName": "Planu Native Lightweight Surface",
-  "version": "4.4.3",
+  "version": "4.5.0",
   "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"
@@ -24,7 +30,10 @@
           "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"
@@ -34,7 +43,10 @@
           "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"
@@ -44,7 +56,10 @@
           "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"
@@ -54,7 +69,10 @@
           "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"
@@ -64,7 +82,10 @@
           "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,9 +2,12 @@
   "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.4.3",
+  "version": "4.5.0",
   "icon": "assets/plugin/icon.svg",
-  "command": ["npx", "@planu/cli@latest"],
+  "command": [
+    "npx",
+    "@planu/cli@latest"
+  ],
   "packageName": "@planu/cli",
   "capabilities": {
     "tools": [
@@ -23,17 +26,42 @@
       "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"
+  ]
 }