@planu/cli 4.11.1 → 4.11.3

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

@@ -3,12 +3,11 @@ 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));
+    if (gaps.length === 0 && isShortAmbiguous(signals)) {
+        gaps.push(buildScopeGap(signals));
     }
     return gaps.slice(0, MAX_GAPS);
 }
@@ -18,16 +17,19 @@ function buildPermissionGap(signals) {
     }
     const subject = formatSubject(signals);
     return makeGap({
-        id: 'permission-owner',
+        id: 'permission-boundary',
         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']),
+        header: 'Access',
+        question: `For ${subject}, which access boundary is intended? This changes authorization checks and audit criteria.`,
+        evidence: evidenceFrom(signals, ['capability:permission']),
         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.'],
+            ['Existing access boundary', 'Apply the access boundary already defined by the project.'],
+            [
+                'New access boundary',
+                'Define the permitted actor without assuming a role or identity model.',
+            ],
+            ['Access control out of scope', 'Keep authorization changes outside this spec.'],
         ]),
     });
 }
@@ -37,38 +39,21 @@ function buildProviderGap(signals) {
     }
     const subject = formatSubject(signals);
     return makeGap({
-        id: 'payment-provider',
+        id: 'payment-provider-boundary',
         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.',
+        question: `For ${subject}, is payment-provider selection part of this spec? This changes integration ownership and acceptance criteria.`,
+        evidence: evidenceFrom(signals, ['domain:billing']),
+        impact: 'Changes integration ownership and acceptance criteria.',
         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.',
+                'Provider selection in scope',
+                'Define selection criteria without choosing an unevidenced vendor.',
+            ],
+            [
+                'Provider selection out of scope',
+                'Limit the spec to behavior that does not choose a provider.',
             ],
-        ]),
-    });
-}
-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.'],
         ]),
     });
 }
@@ -78,81 +63,76 @@ function buildDataGap(signals) {
     }
     const subject = formatSubject(signals);
     return makeGap({
-        id: 'data-shape',
+        id: 'data-boundary',
         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.',
+        question: `For ${subject}, which data shape belongs in scope? This changes persistence, validation, and migration criteria.`,
+        evidence: evidenceFrom(signals, ['domain:data']),
+        impact: 'Changes persistence, validation, and migration criteria.',
         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.'],
+            ['Existing data shape', 'Use only data structures already present in the project.'],
+            ['New data shape', 'Define the required data change without assuming a database product.'],
+            ['Data change out of scope', 'Keep persistence changes outside this spec.'],
         ]),
     });
 }
 function buildFailureGap(signals) {
-    if (signals.integrations.length === 0 &&
-        !signals.riskTerms.includes('sync') &&
-        !signals.riskTerms.includes('api')) {
+    const integration = signals.integrations[0];
+    if (integration === undefined) {
         return null;
     }
     const subject = formatSubject(signals);
     return makeGap({
-        id: 'failure-handling',
+        id: 'failure-boundary',
         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.',
+        question: `For ${subject}, should ${integration} failure behavior be in scope? This changes error-handling and verification criteria.`,
+        evidence: evidenceFrom(signals, [`integration:${integration}`]),
+        impact: 'Changes error-handling and verification criteria.',
         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.'],
+            [
+                'Failure behavior in scope',
+                'Define the observable failure outcome without assuming a recovery strategy.',
+            ],
+            ['Failure behavior out of scope', 'Limit this spec to the successful integration boundary.'],
         ]),
     });
 }
-function buildBehaviorGap(signals) {
+function buildScopeGap(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.',
+        id: 'scope-outcome',
+        kind: 'scope',
+        header: 'Scope',
+        question: `For ${subject}, which observable outcome should define the scope? This changes the primary acceptance criterion.`,
+        evidence: evidenceFrom(signals, ['request:short-ambiguous']),
+        impact: 'Changes the primary acceptance criterion.',
         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.'],
+            ['Behavior change', 'Describe the concrete before-and-after behavior.'],
+            ['Bounded investigation', 'Limit the work to a finding and its verification evidence.'],
+            ['Maintenance outcome', 'Define the concrete cleanup or compatibility result.'],
         ]),
     });
 }
+function isShortAmbiguous(signals) {
+    return (!signals.hasScope &&
+        !signals.hasTarget &&
+        !signals.hasBilling &&
+        !signals.hasDatabase &&
+        !signals.hasPermissionRisk &&
+        signals.integrations.length === 0);
+}
 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';
+    return signals.domainObject === null ? action : `${action} ${signals.domainObject}`;
 }
 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);
 }

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

@@ -5,7 +5,6 @@ export * from './question-generator.js';
 export * from './capability.js';
 export * from './elicit-helper.js';
 export * from './answer-extractor.js';
-export * from './option-builder.js';
 export * from './user-elicitor.js';
 export * from './decision-cache.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/engine/elicitation/index.js

@@ -6,7 +6,6 @@ export * from './question-generator.js';
 export * from './capability.js';
 export * from './elicit-helper.js';
 export * from './answer-extractor.js';
-export * from './option-builder.js';
 export * from './user-elicitor.js';
 export * from './decision-cache.js';
 //# sourceMappingURL=index.js.map

package/dist/engine/elicitation/question-generator.js

@@ -46,13 +46,20 @@ function shouldInclude(config, lowerDesc, context) {
         if (context?.hasDatabase === true) {
             return true;
         }
-        return (config.conditionKeywords ?? []).some((kw) => lowerDesc.includes(kw));
+        return (config.conditionKeywords ?? []).some((keyword) => hasAffirmedKeyword(lowerDesc, keyword));
     }
     // condition === 'api' is the only remaining case
     if (context?.isApi === true) {
         return true;
     }
-    return (config.conditionKeywords ?? []).some((kw) => lowerDesc.includes(kw));
+    return (config.conditionKeywords ?? []).some((keyword) => hasAffirmedKeyword(lowerDesc, keyword));
+}
+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;
+function hasAffirmedKeyword(description, keyword) {
+    return description.split(/(?:\r?\n|[.;!?]+)/).some((segment) => {
+        const index = segment.indexOf(keyword.toLowerCase());
+        return index >= 0 && !NEGATION_RE.test(segment.slice(0, index));
+    });
 }
 /** Generate standard clarification questions for a feature spec */
 export function generateSpecQuestions(title, description, context) {
@@ -101,7 +108,7 @@ export function formatQuestionsAsPrompt(session) {
         lines.push('');
     });
     lines.push('---');
-    lines.push('*Reply with your answers (e.g., "1. Admin users 2. User sees dashboard with charts...")*');
+    lines.push('*Reply with numbered answers that reflect only confirmed requirements.*');
     return lines.join('\n');
 }
 /** Parse answers from free-form text (numbered list format) */

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

@@ -6,49 +6,98 @@ const GENERIC_QUESTION_PATTERNS = [
     /^what data is needed\??$/i,
     /^what are the requirements\??$/i,
 ];
+const REQUIRED_EVIDENCE = {
+    permission: ['capability:permission'],
+    provider: ['domain:billing'],
+    'billing-model': ['domain:billing'],
+    data: ['domain:data'],
+    failure: ['integration:'],
+    behavior: ['request:short-ambiguous'],
+    scope: ['request:short-ambiguous'],
+};
+const OPTION_CONCEPTS = [
+    [/\b(payment|billing|checkout|subscription|invoice|provider|vendor)\b/i, ['domain:billing']],
+    [/\b(database|schema|table|sql|persistence)\b/i, ['domain:data']],
+    [/\b(admin|role|auth|authorization|permission|access control)\b/i, ['capability:permission']],
+    [/\b(retry|backoff|queue|queued)\b/i, ['capability:retry']],
+    [/\b(docker|kubernetes|cloud|serverless)\b/i, ['capability:infrastructure']],
+];
+const NEUTRAL_TITLE_WORDS = new Set([
+    'access',
+    'apply',
+    'behavior',
+    'bounded',
+    'current',
+    'data',
+    'define',
+    'describe',
+    'existing',
+    'failure',
+    'in',
+    'include',
+    'keep',
+    'limit',
+    'maintenance',
+    'new',
+    'no',
+    'out',
+    'project',
+    'provider',
+    'request',
+    'scope',
+    'selection',
+    'the',
+    'use',
+]);
 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 requiredMarkers = REQUIRED_EVIDENCE[context.gap.kind] ?? [];
+    if (!requiredMarkers.some((marker) => hasEvidenceMarker(context.gap.evidence, marker))) {
+        return { passed: false, reason: 'Gap lacks affirmed evidence for this decision kind.' };
+    }
+    const groundingPhrases = context.gap.evidence
+        .filter((item) => /^(?:action|object|integration|project):/i.test(item))
+        .map((item) => item.slice(item.indexOf(':') + 1).toLowerCase())
+        .filter((item) => item.length > 1);
     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));
+    const hasRequestEvidence = groundingPhrases.some((phrase) => lowerQuestion.includes(phrase));
     if (!hasRequestEvidence) {
-        return {
-            passed: false,
-            reason: 'Question does not include evidence from the request or detected gap.',
-        };
+        return { passed: false, reason: 'Question does not include concrete request evidence.' };
     }
-    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.',
-        };
+    if (!/\bchanges?\b|\baffects?\b|\bbecause\b|\bbecomes?\b/i.test(text)) {
+        return { passed: false, reason: 'Question does not explain why the answer matters.' };
     }
-    return { passed: true };
+    const optionFailure = validateOptions(question, context);
+    return optionFailure ?? { 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));
+function validateOptions(question, context) {
+    const evidenceText = `${context.requestText} ${context.gap.evidence.join(' ')}`.toLowerCase();
+    for (const option of question.options) {
+        const optionText = `${option.label} ${option.description}`;
+        for (const [pattern, markers] of OPTION_CONCEPTS) {
+            if (pattern.test(optionText) &&
+                !markers.some((marker) => hasEvidenceMarker(context.gap.evidence, marker))) {
+                return { passed: false, reason: 'Option introduces a domain concept without evidence.' };
+            }
+        }
+        const properNames = optionText.match(/\b(?:[A-Z]{2,}|[A-Z][a-z]+(?:[A-Z][A-Za-z]+)?)\b/g) ?? [];
+        const unsupported = properNames.find((name) => {
+            const lower = name.toLowerCase();
+            return !NEUTRAL_TITLE_WORDS.has(lower) && !evidenceText.includes(lower);
+        });
+        if (unsupported !== undefined) {
+            return {
+                passed: false,
+                reason: `Option introduces unsupported named candidate: ${unsupported}.`,
+            };
+        }
+    }
+    return null;
+}
+function hasEvidenceMarker(evidence, marker) {
+    return evidence.some((item) => item.toLowerCase().startsWith(marker));
 }
-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/engine/evidence-gates/lifecycle-gate.js

@@ -1,26 +1,39 @@
+import { hasAnyAffirmedMatch } from '../text-signal-boundaries.js';
 const CONTRACT_HINTS = {
-    api: /\b(api|rest|endpoint|openapi|http route|controller)\b/i,
-    graphql: /\b(graphql|gql|schema\.graphql|resolver)\b/i,
-    event: /\b(event|webhook|queue|topic|message broker|kafka|rabbitmq|pubsub)\b/i,
-    ui: /\b(ui contract|component contract|screen contract|design contract)\b/i,
-    mcp: /\b(mcp|tool contract|model context protocol|registerTool|server tool)\b/i,
+    api: [
+        /\b(?:public|external|rest|http)[ -]?api\b/i,
+        /\bapi\s+(?:endpoint|route|request|response|contract)\b/i,
+        /\b(?:rest|http)\s+(?:endpoint|route|contract)\b/i,
+        /\bopenapi\b/i,
+    ],
+    graphql: [/\b(?:graphql|gql)\s+(?:api|schema|resolver|contract)\b/i, /\bschema\.graphql\b/i],
+    event: [
+        /\b(?:event|message)\s+(?:contract|schema|producer|consumer|handler|queue|topic)\b/i,
+        /\b(?:message\s+broker|kafka|rabbitmq|pubsub|webhook\s+(?:delivery|contract|payload))\b/i,
+    ],
+    ui: [/\b(?:ui|component|screen|design)\s+contract\b/i],
+    mcp: [
+        /\bmcp\s+(?:tool|contract|server|protocol)\b/i,
+        /\b(?:tool\s+contract|model\s+context\s+protocol|registerTool|server\s+tool)\b/i,
+    ],
 };
 function isNonTrivial(spec) {
     return spec.scope !== 'trivial';
 }
 function normalizeCriterion(value) {
-    return value
-        .replace(/^-\s*\[[ x]\]\s*/i, '')
-        .replace(/^(AC\d+)\s*[:.)-]?\s*/i, '')
+    const withoutCheckbox = value.replace(/^-\s*\[[ x]\]\s*/i, '').trim();
+    const criterionOnly = /^(AC\d+)\s*[:.)-]?\s*$/i.exec(withoutCheckbox)?.[1];
+    if (criterionOnly) {
+        return criterionOnly.toLowerCase();
+    }
+    return withoutCheckbox
+        .replace(/^AC\d+\s*[:.)-]?\s*/i, '')
         .replace(/\s+/g, ' ')
         .trim()
         .toLowerCase();
 }
 function criterionAliases(value, index) {
-    const aliases = new Set([
-        normalizeCriterion(value),
-        normalizeCriterion(`AC${String(index + 1)}`),
-    ]);
+    const aliases = new Set([normalizeCriterion(value), `ac${String(index + 1)}`]);
     const explicit = /^(AC\d+)\b/i.exec(value)?.[1];
     if (explicit) {
         aliases.add(normalizeCriterion(explicit));
@@ -33,8 +46,8 @@ function hasText(value) {
 export function inferRequiredContractEvidence(spec, criteria) {
     const text = `${spec.title} ${spec.tags.join(' ')} ${criteria.join(' ')}`;
     const required = [];
-    for (const [kind, pattern] of Object.entries(CONTRACT_HINTS)) {
-        if (pattern.test(text)) {
+    for (const [kind, patterns] of Object.entries(CONTRACT_HINTS)) {
+        if (hasAnyAffirmedMatch(text, [...patterns])) {
             required.push(kind);
         }
     }

package/dist/engine/evidence-index/index-builder.js

@@ -155,8 +155,13 @@ function record(kind, value, status, source, reason) {
     return { kind, value, status, source, ...(reason ? { reason } : {}) };
 }
 function normalizeCriterion(value) {
-    return value
-        .replace(/^-\s*\[[ x]\]\s*/i, '')
+    const withoutCheckbox = value.replace(/^-\s*\[[ x]\]\s*/i, '').trim();
+    const criterionOnly = /^(AC\d+)\s*[:.)-]?\s*$/i.exec(withoutCheckbox)?.[1];
+    if (criterionOnly) {
+        return criterionOnly.toLowerCase();
+    }
+    return withoutCheckbox
+        .replace(/^AC\d+\s*[:.)-]?\s*/i, '')
         .replace(/\s+/g, ' ')
         .trim()
         .toLowerCase();

package/dist/engine/frontmatter-sha/frozen-fields.d.ts

@@ -2,6 +2,6 @@
  * Frontmatter fields that become immutable when a spec transitions to a terminal state
  * (done or discarded). Any change to these fields after the SHA freeze is a tamper signal.
  */
-export declare const FROZEN_FIELDS: readonly ["status", "scenarios", "spec_version", "id", "type", "target"];
+export declare const FROZEN_FIELDS: readonly ['status', 'scenarios', 'spec_version', 'id', 'type', 'target'];
 export type FrozenField = (typeof FROZEN_FIELDS)[number];
 //# sourceMappingURL=frozen-fields.d.ts.map

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

@@ -8,10 +8,10 @@ export declare const RedTestsHandoffSchema: z.ZodObject<{
     testFiles: z.ZodArray<z.ZodString>;
     testFramework: z.ZodEnum<{
         jest: "jest";
-        vitest: "vitest";
+        playwright: "playwright";
         pytest: "pytest";
         rspec: "rspec";
-        playwright: "playwright";
+        vitest: "vitest";
     }>;
     expectedFailures: z.ZodArray<z.ZodString>;
     authoredBy: z.ZodString;

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

@@ -5,11 +5,11 @@ export declare const SchemaVersion: z.ZodString;
 export declare const IntakeV1Schema: z.ZodObject<{
     schema_version: z.ZodString;
     kind: z.ZodEnum<{
-        idea: "idea";
-        "quick-fix": "quick-fix";
         "bug-spec": "bug-spec";
-        "feature-spec": "feature-spec";
         epic: "epic";
+        "feature-spec": "feature-spec";
+        idea: "idea";
+        "quick-fix": "quick-fix";
     }>;
     description: z.ZodString;
     confidence: z.ZodNumber;
@@ -38,9 +38,9 @@ export declare const ReviewFeedbackV1Schema: z.ZodObject<{
     }>;
     reviewer: z.ZodObject<{
         kind: z.ZodEnum<{
+            automation: "automation";
             human: "human";
             "spec-review-agent": "spec-review-agent";
-            automation: "automation";
         }>;
         agent: z.ZodString;
         verdict: z.ZodEnum<{
@@ -73,8 +73,8 @@ export declare const ValidationReportV1Schema: z.ZodObject<{
     }, z.core.$strip>>;
     reviewer: z.ZodObject<{
         kind: z.ZodEnum<{
-            human: "human";
             automation: "automation";
+            human: "human";
             "implementation-review-agent": "implementation-review-agent";
         }>;
         agent: z.ZodString;
@@ -104,13 +104,13 @@ export declare const ValidationReportV1Schema: z.ZodObject<{
             tag: z.ZodString;
             severity: z.ZodEnum<{
                 blocker: "blocker";
-                warning: "warning";
                 info: "info";
+                warning: "warning";
             }>;
             confidence: z.ZodEnum<{
+                high: "high";
                 low: "low";
                 medium: "medium";
-                high: "high";
             }>;
             target: z.ZodString;
             line: z.ZodOptional<z.ZodNumber>;
@@ -119,10 +119,10 @@ export declare const ValidationReportV1Schema: z.ZodObject<{
             blocksDone: z.ZodBoolean;
             evidenceSource: z.ZodArray<z.ZodObject<{
                 source: z.ZodEnum<{
-                    spec: "spec";
-                    runtime: "runtime";
                     policy: "policy";
                     "project-config": "project-config";
+                    runtime: "runtime";
+                    spec: "spec";
                 }>;
                 key: z.ZodString;
                 value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
@@ -142,10 +142,10 @@ export declare const ValidationReportV1Schema: z.ZodObject<{
         }, z.core.$strip>>;
         evidence: z.ZodArray<z.ZodObject<{
             source: z.ZodEnum<{
-                spec: "spec";
-                runtime: "runtime";
                 policy: "policy";
                 "project-config": "project-config";
+                runtime: "runtime";
+                spec: "spec";
             }>;
             key: z.ZodString;
             value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
@@ -159,11 +159,11 @@ export declare const ARTIFACT_SCHEMAS: {
     readonly intake: z.ZodObject<{
         schema_version: z.ZodString;
         kind: z.ZodEnum<{
-            idea: "idea";
-            "quick-fix": "quick-fix";
             "bug-spec": "bug-spec";
-            "feature-spec": "feature-spec";
             epic: "epic";
+            "feature-spec": "feature-spec";
+            idea: "idea";
+            "quick-fix": "quick-fix";
         }>;
         description: z.ZodString;
         confidence: z.ZodNumber;
@@ -192,9 +192,9 @@ export declare const ARTIFACT_SCHEMAS: {
         }>;
         reviewer: z.ZodObject<{
             kind: z.ZodEnum<{
+                automation: "automation";
                 human: "human";
                 "spec-review-agent": "spec-review-agent";
-                automation: "automation";
             }>;
             agent: z.ZodString;
             verdict: z.ZodEnum<{
@@ -227,8 +227,8 @@ export declare const ARTIFACT_SCHEMAS: {
         }, z.core.$strip>>;
         reviewer: z.ZodObject<{
             kind: z.ZodEnum<{
-                human: "human";
                 automation: "automation";
+                human: "human";
                 "implementation-review-agent": "implementation-review-agent";
             }>;
             agent: z.ZodString;
@@ -258,13 +258,13 @@ export declare const ARTIFACT_SCHEMAS: {
                 tag: z.ZodString;
                 severity: z.ZodEnum<{
                     blocker: "blocker";
-                    warning: "warning";
                     info: "info";
+                    warning: "warning";
                 }>;
                 confidence: z.ZodEnum<{
+                    high: "high";
                     low: "low";
                     medium: "medium";
-                    high: "high";
                 }>;
                 target: z.ZodString;
                 line: z.ZodOptional<z.ZodNumber>;
@@ -273,10 +273,10 @@ export declare const ARTIFACT_SCHEMAS: {
                 blocksDone: z.ZodBoolean;
                 evidenceSource: z.ZodArray<z.ZodObject<{
                     source: z.ZodEnum<{
-                        spec: "spec";
-                        runtime: "runtime";
                         policy: "policy";
                         "project-config": "project-config";
+                        runtime: "runtime";
+                        spec: "spec";
                     }>;
                     key: z.ZodString;
                     value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
@@ -296,10 +296,10 @@ export declare const ARTIFACT_SCHEMAS: {
             }, z.core.$strip>>;
             evidence: z.ZodArray<z.ZodObject<{
                 source: z.ZodEnum<{
-                    spec: "spec";
-                    runtime: "runtime";
                     policy: "policy";
                     "project-config": "project-config";
+                    runtime: "runtime";
+                    spec: "spec";
                 }>;
                 key: z.ZodString;
                 value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;