@planu/cli 4.11.1 → 4.11.3

package/dist/engine/spec-generator/fallback-generator.js

@@ -1,15 +1,19 @@
+import { extractCriteria } from '../spec-format/lean-spec-generator.js';
 export class FallbackGenerator {
     generate(request) {
-        const sourceDescription = normalizeSourceDescription(request.description, request.title);
-        const contextLine = buildContextLine(request);
+        const sourceDescription = normalizeSourceDescription(request.description);
+        const hasCriteria = extractCriteria(sourceDescription).length > 0;
         const technicalSection = '';
         const specBody = [
             '## Problem',
             sourceDescription,
-            '',
-            '## Solution',
-            'Use the preserved source description above as the authoritative requirements body.',
-            contextLine,
+            ...(hasCriteria
+                ? []
+                : [
+                    '',
+                    '## Missing Decisions',
+                    'Needs decision: provide at least one explicit, verifiable acceptance criterion.',
+                ]),
         ].join('\n');
         return Promise.resolve({
             specBody,
@@ -19,28 +23,17 @@ export class FallbackGenerator {
                 generatedAt: new Date().toISOString(),
             },
             qualityWarnings: [
-                'Fallback generator used. Source description was preserved; technical ownership must come from explicit source paths or local project analysis.',
+                'Fallback generator used. Source description was preserved; missing decisions require explicit user input.',
             ],
             fallbackReason: 'No external model generator is configured for create_spec.',
         });
     }
 }
-function normalizeSourceDescription(description, title) {
+function normalizeSourceDescription(description) {
     const compact = description.replace(/\r\n/g, '\n').trim();
     if (compact.length > 0) {
         return compact;
     }
-    return `The project needs ${title} defined with enough implementation detail to proceed safely.`;
-}
-function buildContextLine(request) {
-    const parts = [
-        request.projectContext?.language,
-        request.projectContext?.framework,
-        request.projectContext?.architecture,
-    ].filter((part) => part !== undefined && part.trim().length > 0);
-    if (parts.length === 0) {
-        return 'Use the existing project architecture and conventions.';
-    }
-    return `Use the existing ${parts.join(' / ')} project conventions.`;
+    return 'Needs decision: provide the source requirement description.';
 }
 //# sourceMappingURL=fallback-generator.js.map

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

@@ -6,6 +6,11 @@ export declare function filterGroundedCriteria(criteria: string[]): string[];
 export declare function buildCriterionGroundingRecords(args: {
     criteria: string[];
     userInput: string;
+    criterionEvidence?: {
+        criterion: string;
+        evidence: string[];
+    }[];
+    /** @deprecated Global evidence cannot ground a criterion. Use criterionEvidence. */
     projectEvidence?: string[];
     generatedEvidence?: string[];
 }): CriterionGroundingRecord[];

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

@@ -23,8 +23,11 @@ export function filterGroundedCriteria(criteria) {
 }
 export function buildCriterionGroundingRecords(args) {
     const userInput = normalizeCriterionText(args.userInput);
-    const projectEvidence = args.projectEvidence ?? [];
     const generatedEvidence = args.generatedEvidence ?? [];
+    const criterionEvidence = new Map((args.criterionEvidence ?? []).map((record) => [
+        normalizeCriterionText(record.criterion),
+        record.evidence.filter((item) => item.trim().length > 0),
+    ]));
     return args.criteria.map((criterion) => {
         const normalized = normalizeCriterionText(criterion);
         if (isGenericCriterion(criterion)) {
@@ -43,12 +46,13 @@ export function buildCriterionGroundingRecords(args) {
                 confidence: 'high',
             };
         }
-        if (projectEvidence.length > 0) {
+        const directProjectEvidence = criterionEvidence.get(normalized) ?? [];
+        if (directProjectEvidence.length > 0) {
             return {
                 text: criterion,
                 source: 'project_evidence',
-                evidence: projectEvidence.slice(0, 8),
-                confidence: 'medium',
+                evidence: directProjectEvidence.slice(0, 8),
+                confidence: 'high',
             };
         }
         return {
@@ -108,7 +112,7 @@ export function checkGroundedSpecContract(spec, content) {
         issues.push(`Spec ${spec.id} requires grounding metadata but has no grounded criteria records.`);
     }
     for (const record of records) {
-        if (record.source === 'ungrounded_advisory') {
+        if (record.source === 'ungrounded_advisory' || record.source === 'documented_assumption') {
             issues.push(`Criterion is advisory-only and cannot be approved as contract: ${record.text}`);
         }
         if (record.evidence.length === 0 && record.source !== 'ungrounded_advisory') {
@@ -117,7 +121,7 @@ export function checkGroundedSpecContract(spec, content) {
     }
     const technicalRecords = parseTechnicalReferenceGroundingRecords(frontmatter);
     for (const record of technicalRecords) {
-        if (record.source === 'ungrounded_advisory') {
+        if (record.source === 'ungrounded_advisory' || record.source === 'documented_assumption') {
             issues.push(`Technical reference is advisory-only and cannot be contract: ${record.path}`);
         }
         if (record.evidence.length === 0 && record.source !== 'ungrounded_advisory') {

package/dist/engine/spec-migrator/lean-migration.js

@@ -113,9 +113,6 @@ function extractOldCriteria(content) {
         }
         match = re.exec(content);
     }
-    if (criteria.length === 0) {
-        criteria.push({ text: 'Implementation complete and tested', done: false });
-    }
     return criteria;
 }
 /** Check if a criterion is generic boilerplate (not specific to the feature). */
@@ -415,10 +412,14 @@ export async function migrateSpecToLean(specDir, projectPath) {
         const criteria = extractOldCriteria(specContent);
         const estimation = buildEstimationFromOld(metadata, oldTechContent);
         const spec = buildSpecFromMetadata(metadata, id, title, status, estimation, specPath, techPath);
-        // Generate lean spec.md with extracted criteria
-        const leanSpecLines = generateLeanSpecContent({ spec, description, estimation });
-        // Inject real criteria (replace the default one)
-        const leanSpecWithCriteria = replaceCriteria(leanSpecLines, criteria);
+        // Generate lean spec.md with extracted legacy criteria. Do not synthesize defaults:
+        // migrations preserve source-backed acceptance criteria only.
+        const leanSpecLines = generateLeanSpecContent({
+            spec,
+            description,
+            estimation,
+            criteriaOverride: criteria,
+        });
         // Generate the legacy technical body, then fold it into unified spec.md.
         const leanTech = generateLeanTechnicalContent({
             specId: id,
@@ -434,7 +435,7 @@ export async function migrateSpecToLean(specDir, projectPath) {
             return `backup failed: ${backupErr instanceof Error ? backupErr.message : String(backupErr)}`;
         }
         // Write one unified spec.md.
-        await atomicWriteFile(specPath, buildUnifiedSpecContent(leanSpecWithCriteria, leanTech));
+        await atomicWriteFile(specPath, buildUnifiedSpecContent(leanSpecLines, leanTech));
         // Delete obsolete files
         for (const file of OBSOLETE_FILES) {
             const filePath = join(specDir, file);
@@ -457,14 +458,6 @@ export async function migrateSpecToLean(specDir, projectPath) {
         return err instanceof Error ? err.message : String(err);
     }
 }
-/** Replace criteria in lean spec content with extracted old criteria. */
-function replaceCriteria(content, criteria) {
-    // Find the criteria section in YAML and replace it
-    const criteriaLines = criteria.map((c) => `  - text: "${c.text.replace(/"/g, '\\"')}"\n    done: ${String(c.done)}`);
-    const newCriteria = `criteria:\n${criteriaLines.join('\n')}`;
-    // Replace the existing criteria block
-    return content.replace(/criteria:\n(?: {2}- text:.*\n {4}done:.*\n?)+/, `${newCriteria}\n`);
-}
 /** Migrate all specs in a project to lean format. */
 export async function migrateAllSpecsToLean(projectPath) {
     const result = { migratedCount: 0, skippedCount: 0, errors: [] };

package/dist/engine/text-signal-boundaries.js

@@ -1,5 +1,4 @@
 // engine/text-signal-boundaries.ts — Boundary-aware keyword matching for advisory signals.
-const NEGATION_WINDOW_WORDS = 5;
 const NEGATION_TERMS = new Set([
     'no',
     'not',
@@ -15,25 +14,57 @@ const NEGATION_TERMS = new Set([
     'never',
 ]);
 const OUT_OF_SCOPE_RE = /\b(?:out\s+of\s+scope|not\s+in\s+scope|no\s+scope|do\s+not|don't)\b/i;
+const NON_AFFIRMING_CONTEXT_RE = /\b(?:false[ -]?positive|incorrect(?:ly)?|wrong(?:ly)?|irrelevant|unrelated|noise|repeated\s+failure)\b/i;
+const EXCLUDED_SECTION_RE = /^(?:out\s+of\s+scope|non[ -]?goals?|examples?|anticipated\s+test\s+breaks?)\b/i;
+function stripExcludedMarkdownSections(text) {
+    const lines = text.split('\n');
+    const kept = [];
+    let excludedLevel;
+    for (const line of lines) {
+        const heading = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
+        if (heading) {
+            const marker = heading[1];
+            const title = heading[2];
+            if (marker === undefined || title === undefined) {
+                continue;
+            }
+            const level = marker.length;
+            if (excludedLevel !== undefined && level <= excludedLevel) {
+                excludedLevel = undefined;
+            }
+            if (EXCLUDED_SECTION_RE.test(title)) {
+                excludedLevel = level;
+                continue;
+            }
+        }
+        if (excludedLevel === undefined) {
+            kept.push(line);
+        }
+    }
+    return kept.join('\n');
+}
 /** Remove fenced code and quoted examples before keyword-driven inference. */
 export function stripNonContractText(text) {
-    return text
+    return stripExcludedMarkdownSections(text)
         .replace(/```[\s\S]*?```/g, ' ')
         .replace(/`[^`\n]+`/g, ' ')
         .replace(/"[^"\n]+"/g, ' ')
         .replace(/'[^'\n]+'/g, ' ');
 }
-function wordTokensBefore(text, index) {
-    return text
-        .slice(Math.max(0, index - 160), index)
-        .toLowerCase()
-        .split(/[^a-z0-9]+/i)
-        .filter(Boolean);
+function clauseBefore(text, index) {
+    const before = text.slice(Math.max(0, index - 320), index);
+    const boundary = Math.max(before.lastIndexOf('\n'), before.lastIndexOf('.'), before.lastIndexOf(';'));
+    return before.slice(boundary + 1);
 }
 function isNegatedAt(text, index) {
-    const before = wordTokensBefore(text, index);
-    const recent = before.slice(-NEGATION_WINDOW_WORDS);
-    return recent.some((word) => NEGATION_TERMS.has(word));
+    const before = clauseBefore(text, index)
+        .replace(/\bnot\s+only\b/gi, '')
+        .toLowerCase();
+    const tokens = before.split(/[^a-z0-9]+/i).filter(Boolean);
+    return tokens.some((word) => NEGATION_TERMS.has(word));
+}
+function isNonAffirmingAt(text, index) {
+    return NON_AFFIRMING_CONTEXT_RE.test(clauseBefore(text, index));
 }
 function isOutOfScopeLine(line, indexInLine) {
     return OUT_OF_SCOPE_RE.test(line.slice(0, Math.max(indexInLine, 0) + 80));
@@ -49,7 +80,9 @@ export function hasAffirmedMatch(text, pattern) {
         const lineStart = cleaned.lastIndexOf('\n', index) + 1;
         const lineEnd = cleaned.indexOf('\n', index);
         const line = cleaned.slice(lineStart, lineEnd === -1 ? cleaned.length : lineEnd);
-        if (!isNegatedAt(cleaned, index) && !isOutOfScopeLine(line, index - lineStart)) {
+        if (!isNegatedAt(cleaned, index) &&
+            !isNonAffirmingAt(cleaned, index) &&
+            !isOutOfScopeLine(line, index - lineStart)) {
             return true;
         }
         match = re.exec(cleaned);

package/dist/engine/universal-rules/rules/planu-modes.js

@@ -21,7 +21,6 @@ Never suggest bypassPermissions — it disables all safety checks.
 
 ## How to apply
 
-- After \`update_status\` returns \`suggestedClaudeMode\`, relay it to the user: "I recommend switching to \`/mode <mode>\`"
 - NEVER switch modes automatically — always tell the user and let them decide
 - Critical bash actions (git push, npm publish, rm -rf) require approval regardless of mode
 `;
@@ -43,7 +42,6 @@ Auto-generated by \`init_project\`.
 
 ## How to apply
 
-- After \`update_status\` completes, suggest the appropriate mode to the user
 - NEVER switch modes automatically — always inform the user first
 `;
 }

package/dist/engine/web-fetcher/stack-advisor.d.ts

@@ -1,4 +1,4 @@
-import type { StackRecommendation, SuggestStackResult } from '../../types/index.js';
+import type { StackAdviceGrounding, StackRecommendation, SuggestStackResult } from '../../types/index.js';
 export declare function verifyFrameworkVersion(framework: string): Promise<string | null>;
 export declare function recommendStack(projectType: string, requirements: string[], constraints: string[]): StackRecommendation;
 export declare function recommendAlternativeStack(projectType: string, _requirements: string[]): StackRecommendation;
@@ -11,5 +11,5 @@ export declare function buildMcpCompatibility(stack: StackRecommendation): {
     compatible: boolean;
     notes: string;
 }[];
-export declare function buildSuggestStackResult(projectType: string, requirements: string[], constraints: string[]): Promise<SuggestStackResult>;
+export declare function buildSuggestStackResult(projectType: string, requirements: string[], constraints: string[]): Promise<SuggestStackResult & StackAdviceGrounding>;
 //# sourceMappingURL=stack-advisor.d.ts.map

package/dist/engine/web-fetcher/stack-advisor.js

@@ -96,20 +96,24 @@ function getBaseRecommendations() {
         },
     };
 }
-function applyRequirementOverrides(rec, reqStr, constStr) {
+function applyRequirementOverrides(rec, requirements, constraints) {
     let result = rec;
-    if (reqStr.includes('python') || reqStr.includes('ml') || reqStr.includes('ai')) {
+    if (hasAffirmedTerm(requirements, /\bpython\b/i) ||
+        hasAffirmedTerm(requirements, /\bml\b/i) ||
+        hasAffirmedTerm(requirements, /\bai\b/i)) {
+        const requestsApi = hasAffirmedTerm(requirements, /\bapi\b/i);
         result = {
             ...result,
             language: 'python',
-            framework: reqStr.includes('api') ? 'fastapi' : 'django',
-            version: reqStr.includes('api') ? '0.100+' : '5+',
-            ecosystem: reqStr.includes('api')
+            framework: requestsApi ? 'fastapi' : 'django',
+            version: requestsApi ? '0.100+' : '5+',
+            ecosystem: requestsApi
                 ? ['fastapi', 'pydantic', 'sqlalchemy', 'alembic']
                 : ['django', 'django-rest-framework', 'celery', 'pytest'],
         };
     }
-    if (reqStr.includes('go') || reqStr.includes('golang') || reqStr.includes('performance')) {
+    if (hasAffirmedTerm(requirements, /\bgo(?:lang)?\b/i) ||
+        hasAffirmedTerm(requirements, /\bperformance\b/i)) {
         result = {
             ...result,
             language: 'go',
@@ -118,7 +122,7 @@ function applyRequirementOverrides(rec, reqStr, constStr) {
             ecosystem: ['gin', 'gorm', 'wire', 'testify'],
         };
     }
-    if (reqStr.includes('supabase')) {
+    if (hasAffirmedTerm(requirements, /\bsupabase\b/i)) {
         result = {
             ...result,
             database: 'supabase',
@@ -126,22 +130,21 @@ function applyRequirementOverrides(rec, reqStr, constStr) {
             auth: 'supabase-auth',
         };
     }
-    if (reqStr.includes('firebase')) {
+    if (hasAffirmedTerm(requirements, /\bfirebase\b/i)) {
         result = { ...result, database: 'firebase', auth: 'firebase-auth' };
     }
-    if (constStr.includes('no-vendor-lock') || constStr.includes('self-host')) {
+    if (constraints.some((constraint) => constraint.toLowerCase().includes('no-vendor-lock')) ||
+        hasAffirmedTerm(constraints, /\bself[- ]host(?:ed|ing)?\b/i)) {
         result = { ...result, deployment: 'docker + railway', database: 'postgresql' };
     }
     return result;
 }
 export function recommendStack(projectType, requirements, constraints) {
-    const reqStr = requirements.join(' ').toLowerCase();
-    const constStr = constraints.join(' ').toLowerCase();
     const recommendations = getBaseRecommendations();
     const base = 
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- 'web' key always exists in getBaseRecommendations()
     recommendations[projectType] ?? recommendations.web;
-    return applyRequirementOverrides(base, reqStr, constStr);
+    return applyRequirementOverrides(base, requirements, constraints);
 }
 export function recommendAlternativeStack(projectType, _requirements) {
     const alternatives = {
@@ -208,23 +211,23 @@ export function buildWhyNotOthers(_projectType, chosenFramework) {
     const allAlternatives = [
         {
             name: 'Ruby on Rails',
-            reason: 'Great for prototyping but TypeScript ecosystem is larger and has better type safety.',
+            reason: 'Optional candidate; compare it against the confirmed requirements before selection.',
         },
         {
             name: 'PHP/Laravel',
-            reason: 'Solid framework but less modern tooling and TypeScript interop.',
+            reason: 'Optional candidate; compare it against the confirmed requirements before selection.',
         },
         {
             name: 'Java/Spring',
-            reason: 'Enterprise-grade but heavier setup and verbose for smaller projects.',
+            reason: 'Optional candidate; compare it against the confirmed requirements before selection.',
         },
         {
             name: 'C#/.NET',
-            reason: 'Excellent for enterprise but tighter coupling to Microsoft ecosystem.',
+            reason: 'Optional candidate; compare it against the confirmed requirements before selection.',
         },
         {
             name: 'Elixir/Phoenix',
-            reason: 'Great for real-time but smaller ecosystem and talent pool.',
+            reason: 'Optional candidate; compare it against the confirmed requirements before selection.',
         },
     ];
     return allAlternatives
@@ -307,6 +310,8 @@ export async function buildSuggestStackResult(projectType, requirements, constra
         // Offline: keep static versions, mark confidence as low
         confidence = 'low';
     }
+    const detectedEvidence = collectDetectedEvidence(requirements, constraints);
+    const confirmedChoices = collectConfirmedChoices(requirements);
     return {
         primary,
         alternative,
@@ -314,6 +319,62 @@ export async function buildSuggestStackResult(projectType, requirements, constra
         mcpCompatibility: buildMcpCompatibility(primary),
         lastChecked: new Date().toISOString(),
         confidence,
+        selectionStatus: confirmedChoices.length > 0 ? 'partially-confirmed' : 'unconfirmed',
+        detectedEvidence,
+        confirmedChoices,
+        candidateNotice: 'Recommendations are optional candidates. No candidate is selected or persisted without user confirmation.',
     };
 }
+const NEGATION_RE = /\b(?:no|not|never|without|exclude|excluding|forbid|forbidden|avoid|must not|should not|do not|does not|don't|doesn't|out[- ]of[- ]scope)\b/i;
+const NEGATIVE_SUFFIX_RE = /\b(?:forbidden|excluded|not allowed|out[- ]of[- ]scope)\b/i;
+function hasAffirmedTerm(values, pattern) {
+    return values.some((value) => {
+        const withoutQuotedText = value
+            .replace(/```[\s\S]*?```/g, ' ')
+            .replace(/`[^`]+`/g, ' ')
+            .replace(/"[^"]+"|'[^']+'/g, ' ');
+        return withoutQuotedText.split(/(?:\r?\n|[.,;!?]+)/).some((segment) => {
+            const match = new RegExp(pattern.source, pattern.flags.replace('g', '')).exec(segment);
+            if (!match) {
+                return false;
+            }
+            const prefix = segment.slice(0, match.index);
+            const suffix = segment.slice(match.index + match[0].length);
+            return !NEGATION_RE.test(prefix) && !NEGATIVE_SUFFIX_RE.test(suffix);
+        });
+    });
+}
+function collectDetectedEvidence(requirements, constraints) {
+    const definitions = [
+        ['language:python', /\bpython\b/i],
+        ['language:go', /\bgo(?:lang)?\b/i],
+        ['database:supabase', /\bsupabase\b/i],
+        ['database:firebase', /\bfirebase\b/i],
+        ['capability:api', /\bapi\b/i],
+        ['capability:ml', /\b(?:ml|ai)\b/i],
+    ];
+    const evidence = definitions
+        .filter(([, pattern]) => hasAffirmedTerm(requirements, pattern))
+        .map(([name]) => `requirement:${name}`);
+    if (constraints.some((constraint) => constraint.toLowerCase().includes('no-vendor-lock'))) {
+        evidence.push('constraint:no-vendor-lock');
+    }
+    if (hasAffirmedTerm(constraints, /\bself[- ]host(?:ed|ing)?\b/i)) {
+        evidence.push('constraint:self-host');
+    }
+    return evidence;
+}
+function collectConfirmedChoices(requirements) {
+    const confirmationText = requirements.join(' ');
+    const choices = [
+        ['language', 'python', /\b(?:must use|use|selected|confirmed|requires?)\s+python\b/i],
+        ['language', 'go', /\b(?:must use|use|selected|confirmed|requires?)\s+go(?:lang)?\b/i],
+        ['database', 'supabase', /\b(?:must use|use|selected|confirmed|requires?)\s+supabase\b/i],
+        ['database', 'firebase', /\b(?:must use|use|selected|confirmed|requires?)\s+firebase\b/i],
+    ];
+    return choices
+        .filter(([, , pattern]) => pattern.test(confirmationText))
+        .filter(([, value]) => hasAffirmedTerm(requirements, new RegExp(`\\b${value}\\b`, 'i')))
+        .map(([field, value]) => ({ field, value, source: 'user_confirmation' }));
+}
 //# sourceMappingURL=stack-advisor.js.map

package/dist/engine/well-known/manifest-schema.d.ts

@@ -6,87 +6,87 @@ export type { KnownCapability };
  * RFC 8615 .well-known URI pattern — follows OpenID Connect / OAuth conventions.
  */
 export declare const MANIFEST_SCHEMA_V1: {
-    readonly $schema: "http://json-schema.org/draft-07/schema#";
-    readonly $id: "https://planu.dev/schemas/well-known-manifest-v1.json";
-    readonly title: "Planu .well-known Manifest v1";
-    readonly description: "Spec registry discovery manifest published at .well-known/planu.json";
-    readonly type: "object";
-    readonly required: readonly ["version", "name", "specCount", "specs", "capabilities", "generatedAt"];
+    readonly $schema: 'http://json-schema.org/draft-07/schema#';
+    readonly $id: 'https://planu.dev/schemas/well-known-manifest-v1.json';
+    readonly title: 'Planu .well-known Manifest v1';
+    readonly description: 'Spec registry discovery manifest published at .well-known/planu.json';
+    readonly type: 'object';
+    readonly required: readonly ['version', 'name', 'specCount', 'specs', 'capabilities', 'generatedAt'];
     readonly additionalProperties: false;
     readonly properties: {
         readonly version: {
-            readonly type: "number";
+            readonly type: 'number';
             readonly const: 1;
-            readonly description: "Manifest schema version. Always 1 for this format.";
+            readonly description: 'Manifest schema version. Always 1 for this format.';
         };
         readonly name: {
-            readonly type: "string";
+            readonly type: 'string';
             readonly minLength: 1;
             readonly maxLength: 200;
-            readonly description: "Project display name.";
+            readonly description: 'Project display name.';
         };
         readonly specCount: {
-            readonly type: "integer";
+            readonly type: 'integer';
             readonly minimum: 0;
-            readonly description: "Total number of specs included in this manifest.";
+            readonly description: 'Total number of specs included in this manifest.';
         };
         readonly specs: {
-            readonly type: "array";
-            readonly description: "Array of spec summaries.";
+            readonly type: 'array';
+            readonly description: 'Array of spec summaries.';
             readonly items: {
-                readonly type: "object";
-                readonly required: readonly ["id", "title", "status", "type", "description", "tags", "created"];
+                readonly type: 'object';
+                readonly required: readonly ['id', 'title', 'status', 'type', 'description', 'tags', 'created'];
                 readonly additionalProperties: false;
                 readonly properties: {
                     readonly id: {
-                        readonly type: "string";
-                        readonly pattern: "^SPEC-\\d+$";
+                        readonly type: 'string';
+                        readonly pattern: '^SPEC-\\d+$';
                     };
                     readonly title: {
-                        readonly type: "string";
+                        readonly type: 'string';
                         readonly maxLength: 300;
                     };
                     readonly status: {
-                        readonly type: "string";
+                        readonly type: 'string';
                         readonly maxLength: 50;
                     };
                     readonly type: {
-                        readonly type: "string";
+                        readonly type: 'string';
                         readonly maxLength: 50;
                     };
                     readonly description: {
-                        readonly type: "string";
+                        readonly type: 'string';
                         readonly maxLength: 200;
                     };
                     readonly tags: {
-                        readonly type: "array";
+                        readonly type: 'array';
                         readonly items: {
-                            readonly type: "string";
+                            readonly type: 'string';
                             readonly maxLength: 100;
                         };
                     };
                     readonly created: {
-                        readonly type: "string";
-                        readonly format: "date";
+                        readonly type: 'string';
+                        readonly format: 'date';
                     };
                 };
             };
         };
         readonly capabilities: {
-            readonly type: "array";
-            readonly description: "Planu capabilities exported by this project.";
+            readonly type: 'array';
+            readonly description: 'Planu capabilities exported by this project.';
             readonly items: {
-                readonly type: "string";
+                readonly type: 'string';
                 readonly maxLength: 100;
             };
         };
         readonly generatedAt: {
-            readonly type: "string";
-            readonly format: "date-time";
-            readonly description: "ISO 8601 timestamp when this manifest was generated.";
+            readonly type: 'string';
+            readonly format: 'date-time';
+            readonly description: 'ISO 8601 timestamp when this manifest was generated.';
         };
     };
 };
 /** Known capabilities that a project can declare in its manifest. */
-export declare const KNOWN_CAPABILITIES: readonly ["spec-registry", "federation", "living-spec", "ai-analysis", "estimation", "changelog"];
+export declare const KNOWN_CAPABILITIES: readonly ['spec-registry', 'federation', 'living-spec', 'ai-analysis', 'estimation', 'changelog'];
 //# sourceMappingURL=manifest-schema.d.ts.map

package/dist/engine/workers/schema.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 export declare const WorkerTriggerSchema: z.ZodObject<{
     type: z.ZodEnum<{
         event: "event";
-        schedule: "schedule";
         "file-change": "file-change";
+        schedule: "schedule";
     }>;
     patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
     events: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -15,8 +15,8 @@ export declare const WorkerDefinitionSchema: z.ZodObject<{
     trigger: z.ZodObject<{
         type: z.ZodEnum<{
             event: "event";
-            schedule: "schedule";
             "file-change": "file-change";
+            schedule: "schedule";
         }>;
         patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
         events: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -38,8 +38,8 @@ export declare const WorkerRegistrySchema: z.ZodObject<{
         trigger: z.ZodObject<{
             type: z.ZodEnum<{
                 event: "event";
-                schedule: "schedule";
                 "file-change": "file-change";
+                schedule: "schedule";
             }>;
             patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
             events: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/hosts/claude-code/ux/mcp-resources.d.ts

@@ -2,10 +2,10 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { McpResourceMeta } from '../../../types/claude-code-ux.js';
 /** Planu-namespaced resource URIs exposed by SPEC-588. */
 export declare const PLANU_UX_RESOURCE_URIS: {
-    readonly specList: "planu://ux/specs";
-    readonly progress: "planu://ux/progress";
-    readonly constitution: "planu://ux/constitution";
-    readonly recentActivity: "planu://ux/recent-activity";
+    readonly specList: 'planu://ux/specs';
+    readonly progress: 'planu://ux/progress';
+    readonly constitution: 'planu://ux/constitution';
+    readonly recentActivity: 'planu://ux/recent-activity';
 };
 export declare const specListResourceMeta: McpResourceMeta;
 export declare const progressResourceMeta: McpResourceMeta;

package/dist/hosts/codex/rest-shim.d.ts

@@ -1,3 +1,3 @@
-export declare const REST_SHIM_STATUS: "disabled";
+export declare const REST_SHIM_STATUS: 'disabled';
 export declare const REST_SHIM_REASON = "Codex supports MCP-over-stdio natively. REST shim is not needed.";
 //# sourceMappingURL=rest-shim.d.ts.map