@planu/cli 4.11.1 → 4.11.3

package/dist/engine/human-summary.js

@@ -1,5 +1,5 @@
 // engine/human-summary.ts — Plain-language one/two-sentence summaries for tool responses.
-// Rules: no IDs/hashes, no jargon, max 2 sentences, always end with a next-step suggestion.
+// Rules: no IDs/hashes, no jargon, max 2 sentences, and no invented next step for terminal states.
 /** create_spec — plan was created successfully */
 export function buildCreateSpecSummary(title, devHours) {
     const hours = devHours > 0 ? `Estimated ${String(devHours)}h` : 'Estimation ready';
@@ -8,7 +8,7 @@ export function buildCreateSpecSummary(title, devHours) {
 /** update_status — status transition completed */
 export function buildUpdateStatusSummary(title, newStatus) {
     if (newStatus === 'done') {
-        return `Done! "${title}" is complete and recorded. Run estimate or start a new plan when you're ready.`;
+        return `Done! "${title}" is complete and recorded.`;
     }
     if (newStatus === 'approved') {
         return `"${title}" is approved and ready to build. Start implementing whenever you like.`;
@@ -20,7 +20,7 @@ export function buildUpdateStatusSummary(title, newStatus) {
         return `"${title}" is now under review. Approve it or request changes to move forward.`;
     }
     if (newStatus === 'discarded') {
-        return `"${title}" has been discarded. Create a new plan whenever you want to restart.`;
+        return `"${title}" has been discarded.`;
     }
     return `"${title}" moved to ${newStatus}. Check the next step suggestion above to continue.`;
 }

package/dist/engine/implementation-contract/common.d.ts

@@ -1,5 +1,5 @@
 export declare const IMPLEMENTATION_CONTRACT_SECTION = "Implementation Contract";
-export declare const IMPLEMENTATION_CONTRACT_SUBSECTIONS: readonly ["User Outcome", "Behavior Contract", "File-Level Work Plan", "Acceptance-To-Verification Map", "Edge Cases And Failure Modes", "Non-Goals And Forbidden Approaches", "Verification Commands"];
+export declare const IMPLEMENTATION_CONTRACT_SUBSECTIONS: readonly ['User Outcome', 'Behavior Contract', 'File-Level Work Plan', 'Acceptance-To-Verification Map', 'Edge Cases And Failure Modes', 'Non-Goals And Forbidden Approaches', 'Verification Commands'];
 export declare function hasImplementationContract(specBody: string): boolean;
 export declare function extractTopLevelSection(body: string, sectionName: string): string;
 //# sourceMappingURL=common.d.ts.map

package/dist/engine/implementation-contract/renderer.js

@@ -1,43 +1,33 @@
 import { hasImplementationContract, IMPLEMENTATION_CONTRACT_SECTION } from './common.js';
 export function buildImplementationContractSection(input) {
-    const criteria = input.criteria.length > 0 ? input.criteria : fallbackCriteria();
+    const criteria = input.criteria;
     const testFiles = input.files.test.map((file) => file.path);
-    const verificationCommands = input.verificationCommands.length > 0
-        ? input.verificationCommands
-        : ['pnpm typecheck', 'pnpm lint', 'pnpm test'];
+    const verificationCommands = input.verificationCommands;
     const lines = [
         `## ${IMPLEMENTATION_CONTRACT_SECTION}`,
         '### User Outcome',
         firstConcreteSentence(input.description) ??
-            'Needs decision: define the exact user-visible outcome this spec must deliver.',
+            'Needs decision: define the exact observable outcome this spec must deliver.',
         '',
         '### Behavior Contract',
         ...renderBehaviorContract(criteria),
-        '- Inputs: use the user request and existing project conventions as the source of truth.',
-        '- Outputs: update canonical `spec.md` behavior without creating sidecar implementation docs.',
-        '- State changes: persist only the files and metadata required by the spec workflow.',
-        '- Errors: missing implementation detail must surface as `Needs decision:` instead of generic filler.',
         '',
         '### File-Level Work Plan',
         ...renderFilePlan(input.files),
         '',
-        '### Minimal Change Guidance',
-        ...renderMinimalChangeGuidance(),
-        '',
         '### Acceptance-To-Verification Map',
         ...criteria.map((criterion, index) => renderVerificationRow(criterion.text, index + 1, testFiles, verificationCommands)),
         '',
         '### Edge Cases And Failure Modes',
-        '- Generated specs with too little context must use `Needs decision:` placeholders.',
-        '- Existing specs without this section must remain readable and must not be rewritten by readiness checks.',
-        '- A heading with filler text must not count as a usable implementation contract.',
-        '- Manual verification must include exact observable steps when no automated proof is practical.',
+        '- Needs decision: identify criterion-specific failure modes from user input or project evidence.',
         '',
         '### Non-Goals And Forbidden Approaches',
         ...renderNonGoals(input.outOfScope),
         '',
         '### Verification Commands',
-        ...verificationCommands.map((command) => `- \`${command}\``),
+        ...(verificationCommands.length > 0
+            ? verificationCommands.map((command) => `- \`${command}\``)
+            : ['- Needs decision: provide a repository-supported verification command.']),
         '',
     ];
     return lines.join('\n');
@@ -48,21 +38,6 @@ export function appendImplementationContractIfMissing(specBody, input) {
     }
     return `${specBody.trimEnd()}\n\n${buildImplementationContractSection(input)}`;
 }
-function renderMinimalChangeGuidance() {
-    return [
-        '- Before implementing, check whether the work is unnecessary, already exists in this codebase, is covered by stdlib, is covered by the native platform, or is covered by an already-installed dependency.',
-        '- Add new code only after those checks, and keep the diff to the minimum that satisfies the accepted criteria.',
-        '- Do not use minimality to remove security, trust-boundary validation, data-loss handling, accessibility, explicit requirements, or required validation.',
-    ];
-}
-function fallbackCriteria() {
-    return [
-        {
-            text: 'Needs decision: define at least one acceptance criterion with executable verification.',
-            done: false,
-        },
-    ];
-}
 function firstConcreteSentence(description) {
     const body = description
         .replace(/^---[\s\S]*?---/, '')
@@ -89,20 +64,23 @@ function renderFilePlan(files) {
     return lines.length > 0 ? lines : ['- Needs decision: identify expected source and test files.'];
 }
 function renderBehaviorContract(criteria) {
-    return criteria.map((criterion, index) => `- Expected behavior AC${String(index + 1)}: ${criterion.text}`);
+    return criteria.length > 0
+        ? criteria.map((criterion, index) => `- Expected behavior AC${String(index + 1)}: ${criterion.text}`)
+        : ['- Needs decision: define at least one evidence-grounded acceptance criterion.'];
 }
 function renderVerificationRow(criterion, index, testFiles, commands) {
     const test = testFiles[0];
     if (test) {
-        return `- AC${String(index)}: ${criterion} -> unit test \`${test}\` plus \`${commands[0] ?? 'pnpm test'}\`.`;
+        const command = commands[0];
+        return command
+            ? `- AC${String(index)}: ${criterion} -> unit test \`${test}\` plus \`${command}\`.`
+            : `- AC${String(index)}: ${criterion} -> unit test \`${test}\`.`;
     }
     return `- AC${String(index)}: ${criterion} -> Needs decision: choose unit test, integration test, CLI/tool result, snapshot/golden fixture, or exact manual verification.`;
 }
 function renderNonGoals(outOfScope) {
-    const base = [
-        '- Do not create durable sidecar implementation docs outside canonical `spec.md`.',
-        '- Do not treat headings or filler text as implementation-ready detail.',
-    ];
-    return outOfScope.length > 0 ? [...base, ...outOfScope.map((item) => `- ${item}`)] : base;
+    return outOfScope.length > 0
+        ? outOfScope.map((item) => `- ${item}`)
+        : ['- Needs decision: provide explicit non-goals or confirm that none were supplied.'];
 }
 //# sourceMappingURL=renderer.js.map

package/dist/engine/keyword-matcher/stopwords.d.ts

@@ -3,13 +3,13 @@
  * "validate input") but rarely represent a domain concept worth searching for.
  * Keep lowercase; callers normalize before lookup.
  */
-export declare const ACTION_VERBS: readonly ["commit", "write", "read", "delete", "create", "update", "export", "import", "store", "send", "push", "pull", "sync", "check", "validate", "verify", "fetch", "load", "save", "remove", "add", "get", "set", "put", "post", "patch", "run", "execute", "parse", "render", "build", "compile"];
+export declare const ACTION_VERBS: readonly ['commit', 'write', 'read', 'delete', 'create', 'update', 'export', 'import', 'store', 'send', 'push', 'pull', 'sync', 'check', 'validate', 'verify', 'fetch', 'load', 'save', 'remove', 'add', 'get', 'set', 'put', 'post', 'patch', 'run', 'execute', 'parse', 'render', 'build', 'compile'];
 /**
  * Generic English connectors and filler nouns that do not narrow a match.
  * Kept deliberately small — domain stopwords should go through
  * `KeywordMatchOptions.customStopwords`.
  */
-export declare const COMMON_STOPWORDS: readonly ["the", "and", "for", "that", "this", "with", "from", "into", "onto", "version", "control", "system", "data", "value", "field", "record", "user", "item", "thing", "stuff", "something", "anything"];
+export declare const COMMON_STOPWORDS: readonly ['the', 'and', 'for', 'that', 'this', 'with', 'from', 'into', 'onto', 'version', 'control', 'system', 'data', 'value', 'field', 'record', 'user', 'item', 'thing', 'stuff', 'something', 'anything'];
 /**
  * True if `word` is a known action verb (case-insensitive).
  */

package/dist/engine/lifecycle-hints.d.ts

@@ -3,7 +3,7 @@ import type { SpecStatus, NextAction, LifecycleMap } from '../types/index.js';
  * Returns the guided next action for a given status transition.
  * The hint targets the *newStatus* reached, guiding what to do from there.
  */
-export declare function buildNextAction(newStatus: SpecStatus): NextAction;
+export declare function buildNextAction(newStatus: SpecStatus): NextAction | null;
 /**
  * Returns the lifecycle map for the given current status.
  * Shows where the spec is, what's next, and what remains.

package/dist/engine/lifecycle-hints.js

@@ -2,53 +2,37 @@
 const LIFECYCLE_STAGES = ['draft', 'review', 'approved', 'implementing', 'done'];
 /** Maps each forward transition to a guided next action */
 const NEXT_ACTION_MAP = {
+    draft: {
+        step: 'Challenge the spec',
+        prompt: 'Run challenge_spec and resolve the discovered findings before review',
+        suggestedCommand: 'challenge_spec(specId)',
+        whenToDoIt: 'Before requesting review',
+    },
     review: {
         step: 'Get approval',
         prompt: "Share this plan with your team or just tell me 'approved' to move forward",
-        suggestedCommand: 'update_status(approved)',
+        suggestedCommand: 'update_status(status="approved")',
         whenToDoIt: "When you're happy with the plan",
     },
     approved: {
-        step: 'Create your git branch',
-        prompt: 'Run: git checkout -b feat/<spec-slug>',
-        suggestedCommand: 'manage_git(branch)',
+        step: 'Start implementation',
+        prompt: 'Move the approved spec to implementing before writing production code',
+        suggestedCommand: 'update_status(status="implementing")',
         whenToDoIt: 'Before writing any code',
     },
     implementing: {
-        step: 'Start coding',
-        prompt: 'Implement the spec following the technical plan',
-        suggestedCommand: 'validate(specId)',
-        whenToDoIt: 'While developing',
-    },
-    done: {
-        step: 'Validate your implementation',
-        prompt: 'Run validate to check that your code matches the spec',
+        step: 'Validate the implementation',
+        prompt: 'Check the implementation against every acceptance criterion',
         suggestedCommand: 'validate(specId)',
         whenToDoIt: 'After all tests pass',
     },
-    discarded: {
-        step: 'Archive or delete spec',
-        prompt: 'This spec has been discarded. You can delete it or keep it for reference.',
-        suggestedCommand: 'delete_spec(specId)',
-        whenToDoIt: 'When cleanup is needed',
-    },
 };
 /**
  * Returns the guided next action for a given status transition.
  * The hint targets the *newStatus* reached, guiding what to do from there.
  */
 export function buildNextAction(newStatus) {
-    const hint = NEXT_ACTION_MAP[newStatus];
-    if (hint !== undefined) {
-        return hint;
-    }
-    // Fallback for any unrecognised status
-    return {
-        step: 'Continue',
-        prompt: `Spec is now ${newStatus}. Check Planu for next steps.`,
-        suggestedCommand: 'list_specs()',
-        whenToDoIt: 'When ready',
-    };
+    return NEXT_ACTION_MAP[newStatus] ?? null;
 }
 /**
  * Returns the lifecycle map for the given current status.

package/dist/engine/provider-adapters/adapters/claude.d.ts

@@ -5,7 +5,7 @@ import type { ProviderRenderInput, ProviderRenderOutput, SpecRenderer } from '..
  */
 export declare const CLAUDE_TOOL_CALLOUT_MAP: Readonly<Record<string, readonly string[]>>;
 export declare class ClaudeRenderer implements SpecRenderer {
-    readonly kind: "claude";
+    readonly kind: 'claude';
     render(input: ProviderRenderInput): Promise<ProviderRenderOutput>;
 }
 //# sourceMappingURL=claude.d.ts.map

package/dist/engine/provider-adapters/adapters/gemini.d.ts

@@ -5,7 +5,7 @@ import type { ProviderRenderInput, ProviderRenderOutput, SpecRenderer } from '..
  */
 export declare const GEMINI_API_VERSION = "v1beta";
 export declare class GeminiRenderer implements SpecRenderer {
-    readonly kind: "gemini";
+    readonly kind: 'gemini';
     render(input: ProviderRenderInput): Promise<ProviderRenderOutput>;
 }
 //# sourceMappingURL=gemini.d.ts.map

package/dist/engine/provider-adapters/adapters/gpt4.d.ts

@@ -1,6 +1,6 @@
 import type { ProviderRenderInput, ProviderRenderOutput, SpecRenderer } from '../../../types/provider-adapter.js';
 export declare class GPT4Renderer implements SpecRenderer {
-    readonly kind: "gpt4";
+    readonly kind: 'gpt4';
     render(input: ProviderRenderInput): Promise<ProviderRenderOutput>;
 }
 //# sourceMappingURL=gpt4.d.ts.map

package/dist/engine/provider-adapters/adapters/markdown.d.ts

@@ -1,6 +1,6 @@
 import type { ProviderRenderInput, ProviderRenderOutput, SpecRenderer } from '../../../types/provider-adapter.js';
 export declare class GenericMarkdownRenderer implements SpecRenderer {
-    readonly kind: "markdown";
+    readonly kind: 'markdown';
     render(input: ProviderRenderInput): Promise<ProviderRenderOutput>;
 }
 //# sourceMappingURL=markdown.d.ts.map

package/dist/engine/safety/atomic-write-file.d.ts

@@ -6,7 +6,7 @@ import type { AtomicWriteOptions } from '../../types/safety.js';
 export declare class SpecFrozenError extends Error {
     readonly specId: string;
     readonly fixHint: string;
-    readonly code: "SPEC_FROZEN";
+    readonly code: 'SPEC_FROZEN';
     constructor(specId: string, fixHint: string);
 }
 /**

package/dist/engine/safety/cross-process-lock.d.ts

@@ -3,7 +3,7 @@ declare const HEARTBEAT_INTERVAL_MS = 30000;
 export { HEARTBEAT_INTERVAL_MS };
 /** Thrown by withSpecLock when the lock is held by another live session. */
 export declare class LockBusyError extends Error {
-    readonly code: "LOCK_BUSY";
+    readonly code: 'LOCK_BUSY';
     readonly holder: CrossProcessLockMetadata;
     constructor(holder: CrossProcessLockMetadata);
 }

package/dist/engine/safety/path-sanitizer.d.ts

@@ -1,6 +1,6 @@
 import type { SafePath } from '../../types/safety.js';
 export declare class PathViolationError extends Error {
-    readonly code: "PATH_VIOLATION";
+    readonly code: 'PATH_VIOLATION';
     readonly input: string;
     constructor(message: string, input: string);
 }

package/dist/engine/security-analyzer/profile-detector.js

@@ -1,28 +1,58 @@
 // engine/security-analyzer/profile-detector.ts — Feature profile and auth detection
 // SPEC-029
+import { hasAnyAffirmedMatch } from '../text-signal-boundaries.js';
 // === Feature profile detection ===
-const PROFILE_KEYWORDS = [
-    { keywords: ['api', 'endpoint', 'route', 'rest', 'graphql'], profile: 'public-api' },
+const PROFILE_SIGNALS = [
     {
-        keywords: ['auth', 'login', 'signup', 'register', 'password', 'jwt', 'oauth', 'session'],
+        patterns: [
+            /(?<!compiler\s)\bapi\b(?!\s+(?:compatibility|surface|package|type))/i,
+            /\b(?:public|external|rest|http)[ -]?api\b/i,
+            /\bapi\s+(?:endpoint|route|request|response|server)\b/i,
+            /\b(?:http|rest)\s+(?:endpoint|route)\b/i,
+            /\bgraphql\s+(?:api|endpoint|resolver|schema)\b/i,
+        ],
+        profile: 'public-api',
+    },
+    {
+        patterns: [
+            /\b(?:auth(?:entication)?|login|sign[ -]?up|register\s+user|password|jwt|oauth2?|session\s+auth)\b/i,
+        ],
         profile: 'auth',
     },
     {
-        keywords: ['database', 'query', 'sql', 'db', 'schema', 'orm', 'repository'],
+        patterns: [
+            /\b(?:database|db-access|postgres(?:ql)?|mysql|sqlite|mongodb|dynamodb)\b/i,
+            /\b(?:sql|nosql)\s+(?:query|statement|table|database)\b/i,
+            /\b(?:database|persistence)\s+(?:query|schema|table|migration|transaction)\b/i,
+            /\b(?:orm|prisma|drizzle|typeorm|sequelize)\b/i,
+        ],
         profile: 'db-access',
     },
-    { keywords: ['upload', 'file', 'attachment', 'media', 'image'], profile: 'file-upload' },
-    { keywords: ['html', 'render', 'template', 'ui', 'frontend', 'view'], profile: 'html-render' },
     {
-        keywords: ['pii', 'personal', 'email', 'phone', 'ssn', 'gdpr', 'privacy'],
+        patterns: [
+            /\bfile[ -]?upload\b/i,
+            /\b(?:upload|attach)(?:ed|ment|ing|s)?\s+(?:file|image|media)\b/i,
+        ],
+        profile: 'file-upload',
+    },
+    {
+        patterns: [
+            /\b(?:html\s+render|render(?:ed|ing)?\s+html|ui\s+(?:component|view|rendering)|frontend\s+view|template\s+render)\b/i,
+        ],
+        profile: 'html-render',
+    },
+    {
+        patterns: [
+            /\b(?:pii|personal\s+(?:data|information)|user\s+email|email\s+address|phone\s+number|ssn|gdpr|privacy)\b/i,
+        ],
         profile: 'pii-data',
     },
 ];
 export function detectSecurityProfiles(title, description, tags) {
-    const lower = `${title} ${description} ${tags.join(' ')}`.toLowerCase();
+    const text = `${title}\n${description}\n${tags.join(' ')}`;
     const profiles = [];
-    for (const { keywords, profile } of PROFILE_KEYWORDS) {
-        if (keywords.some((kw) => lower.includes(kw))) {
+    for (const { patterns, profile } of PROFILE_SIGNALS) {
+        if (hasAnyAffirmedMatch(text, patterns)) {
             profiles.push(profile);
         }
     }
@@ -33,20 +63,22 @@ export function detectSecurityProfiles(title, description, tags) {
 }
 // === Auth mechanism detection ===
 export function detectAuthMechanism(description, tags) {
-    const lower = `${description} ${tags.join(' ')}`.toLowerCase();
-    if (lower.includes('jwt') || lower.includes('json web token')) {
+    const text = `${description}\n${tags.join(' ')}`;
+    if (hasAnyAffirmedMatch(text, [/\b(?:jwt|json\s+web\s+token)\b/i])) {
         return 'jwt';
     }
-    if (lower.includes('oauth') || lower.includes('oauth2')) {
+    if (hasAnyAffirmedMatch(text, [/\boauth2?\b/i])) {
         return 'oauth2';
     }
-    if (lower.includes('api key') || lower.includes('apikey') || lower.includes('api_key')) {
+    if (hasAnyAffirmedMatch(text, [/\bapi[ _-]?key\b/i])) {
         return 'api-key';
     }
-    if (lower.includes('session') || lower.includes('cookie')) {
+    if (hasAnyAffirmedMatch(text, [
+        /\b(?:session[ -]?based\s+authentication|session\s+auth|session\s+cookie)\b/i,
+    ])) {
         return 'session';
     }
-    if (lower.includes('basic auth') || lower.includes('basic authentication')) {
+    if (hasAnyAffirmedMatch(text, [/\bbasic\s+auth(?:entication)?\b/i])) {
         return 'basic';
     }
     return 'none';

package/dist/engine/spec-format/copula-blacklist.d.ts

@@ -1,7 +1,7 @@
 /** Spanish copulative verbs that indicate non-testable, state-describing criteria. */
-export declare const COPULA_VERBS_ES: readonly ["es", "son", "está", "están", "tiene", "tienen"];
+export declare const COPULA_VERBS_ES: readonly ['es', 'son', 'está', 'están', 'tiene', 'tienen'];
 /** English copulative verbs that indicate non-testable, state-describing criteria. */
-export declare const COPULA_VERBS_EN: readonly ["is", "are", "has", "have", "exists", "contains"];
+export declare const COPULA_VERBS_EN: readonly ['is', 'are', 'has', 'have', 'exists', 'contains'];
 export interface CopulaCheckResult {
     hit: boolean;
     verb?: string;

package/dist/engine/spec-format/lean-spec-generator.d.ts

@@ -2,7 +2,7 @@ import type { LeanCriterion, LeanSpecInput } from '../../types/index.js';
 export type { LeanCriterion, LeanHistoryEntry, LeanSpecInput } from '../../types/index.js';
 /** Generate lean spec.md content: YAML frontmatter + user description only. */
 export declare function generateLeanSpecContent(input: LeanSpecInput): string;
-/** Extract acceptance criteria from description. Looks for checkbox patterns or generates a default.
- * Priority: checkboxes > GIVEN/WHEN/THEN > plain list items > fallback. */
+/** Extract acceptance criteria explicitly present in the description.
+ * Priority: checkboxes > GIVEN/WHEN/THEN > plain list items. */
 export declare function extractCriteria(description: string): LeanCriterion[];
 //# sourceMappingURL=lean-spec-generator.d.ts.map

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

@@ -128,8 +128,8 @@ function buildBddLines(description, extraCriteria, criteriaOverride, scenarioTes
     }
     return renderBddScenariosYaml(scenarios);
 }
-/** Extract acceptance criteria from description. Looks for checkbox patterns or generates a default.
- * Priority: checkboxes > GIVEN/WHEN/THEN > plain list items > fallback. */
+/** Extract acceptance criteria explicitly present in the description.
+ * Priority: checkboxes > GIVEN/WHEN/THEN > plain list items. */
 export function extractCriteria(description) {
     const checkboxCriteria = extractCheckboxCriteria(description);
     if (checkboxCriteria.length > 0) {
@@ -143,12 +143,7 @@ export function extractCriteria(description) {
     if (plainListCriteria.length > 0) {
         return plainListCriteria;
     }
-    return [
-        {
-            text: 'Define acceptance criteria — autopilot could not infer testable behavior from the description',
-            done: false,
-        },
-    ];
+    return [];
 }
 /** Extract checkbox-style criteria: `- [ ] text` or `- [x] text`. */
 function extractCheckboxCriteria(description) {
@@ -198,16 +193,20 @@ function extractGivenWhenThenCriteria(description) {
 /** Extract plain list items: `- text` or `* text` (no checkboxes).
  * Only used when no checkboxes or GIVEN/WHEN/THEN are found. */
 function extractPlainListCriteria(description) {
+    const acceptanceSection = /(?:^|\n)#{1,6}[ \t]+Acceptance Criteria[ \t]*\r?\n([\s\S]*?)(?=\r?\n#{1,6}[ \t]+|$)/i.exec(description)?.[1] ?? '';
+    if (acceptanceSection.length === 0) {
+        return [];
+    }
     const criteria = [];
     // Plain list: `- text` or `* text`, not followed by `[`
     const plainListRegex = /^[-*]\s+(?!\[)(.+)$/gm;
-    let match = plainListRegex.exec(description);
+    let match = plainListRegex.exec(acceptanceSection);
     while (match) {
         const text = match[1]?.trim() ?? '';
         if (text) {
             criteria.push({ text, done: false });
         }
-        match = plainListRegex.exec(description);
+        match = plainListRegex.exec(acceptanceSection);
     }
     return criteria;
 }

package/dist/engine/spec-format/metadata-value-policy.d.ts

@@ -4,102 +4,102 @@
  */
 export declare const SPEC_METADATA_VALUE_POLICY: {
     readonly id: {
-        readonly classification: "required";
+        readonly classification: 'required';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly title: {
-        readonly classification: "required";
+        readonly classification: 'required';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly status: {
-        readonly classification: "required";
+        readonly classification: 'required';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly type: {
-        readonly classification: "required";
+        readonly classification: 'required';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly target: {
-        readonly classification: "required";
+        readonly classification: 'required';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly scope: {
-        readonly classification: "required";
+        readonly classification: 'required';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly difficulty: {
-        readonly classification: "required";
+        readonly classification: 'required';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly risk: {
-        readonly classification: "required";
+        readonly classification: 'required';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly branch: {
-        readonly classification: "required";
+        readonly classification: 'required';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly created: {
-        readonly classification: "required";
+        readonly classification: 'required';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly spec_format_version: {
-        readonly classification: "required";
+        readonly classification: 'required';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly spec_version: {
-        readonly classification: "required";
+        readonly classification: 'required';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly tags: {
-        readonly classification: "conditional";
+        readonly classification: 'conditional';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly generation: {
-        readonly classification: "conditional";
+        readonly classification: 'conditional';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly qualityWarnings: {
-        readonly classification: "conditional";
+        readonly classification: 'conditional';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly grounding_required: {
-        readonly classification: "conditional";
+        readonly classification: 'conditional';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly grounding: {
-        readonly classification: "conditional";
+        readonly classification: 'conditional';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly criteria: {
-        readonly classification: "conditional";
+        readonly classification: 'conditional';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly scenarios: {
-        readonly classification: "conditional";
+        readonly classification: 'conditional';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };
     readonly history: {
-        readonly classification: "conditional";
+        readonly classification: 'conditional';
         readonly consumers: readonly [string, ...string[]];
         readonly purpose: string;
     };