@planu/cli 4.14.1 → 5.1.1

package/dist/engine/handoff-packager.js

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { stripFrontmatter } from './frontmatter-parser.js';
 import { hashProjectPath, projectDataDir } from '../storage/base-store.js';
 import { extractAcceptanceCriteriaTexts } from './spec-format/acceptance-criteria.js';
+import { extractListItems, findMarkdownSectionRange } from './spec-format/markdown-sections.js';
 // ── Parsing helpers ──────────────────────────────────────────────────────────
 function extractObjective(huContent, spec) {
     if (!huContent) {
@@ -71,16 +72,369 @@ function extractFilesFromFicha(fichaContent) {
     }
     return { toModify, toCreate };
 }
+function sectionContentAtLevel(content, heading, level) {
+    let offset = 0;
+    while (offset < content.length) {
+        const range = findMarkdownSectionRange(content.slice(offset), heading);
+        if (range === null) {
+            return null;
+        }
+        if (range.level === level) {
+            return content.slice(offset + range.contentStart, offset + range.end);
+        }
+        const nextOffset = offset + range.end;
+        if (nextOffset <= offset) {
+            return null;
+        }
+        offset = nextOffset;
+    }
+    return null;
+}
+function ownershipItems(content) {
+    const visibleLines = [];
+    const fenced = [];
+    let fence = null;
+    for (const line of content.split('\n')) {
+        const marker = /^[ \t]{0,3}(`{3,}|~{3,})/.exec(line)?.[1];
+        if (marker) {
+            const type = marker[0];
+            if (fence === null) {
+                fence = { marker: type, length: marker.length };
+            }
+            else if (fence.marker === type && marker.length >= fence.length) {
+                fence = null;
+            }
+            continue;
+        }
+        if (fence !== null) {
+            const trimmed = line.trim();
+            if (trimmed.length > 0) {
+                fenced.push(extractListItems(line)[0] ?? trimmed);
+            }
+            continue;
+        }
+        visibleLines.push(line);
+    }
+    return { items: extractListItems(visibleLines.join('\n')), fenced };
+}
+/** Normalize one repository-relative ownership path without retaining unsafe input in diagnostics. */
+export function normalizeOwnedPath(value) {
+    const trimmed = value.trim();
+    if (/^none\.?$/i.test(trimmed)) {
+        return { status: 'none' };
+    }
+    const backticked = /^`([^`]+)`/.exec(trimmed)?.[1];
+    const candidate = (backticked ?? trimmed.split(/\s+(?:—|–|-)\s+|\s+\(/, 1)[0] ?? '').trim();
+    if (candidate.length === 0) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_EMPTY' };
+    }
+    if (candidate.startsWith('```') || candidate.startsWith('~~~')) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_FENCED' };
+    }
+    if (candidate.includes('\0')) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_NUL' };
+    }
+    if (/^[\\/]{2}/.test(candidate)) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_UNC' };
+    }
+    const normalizedSeparators = candidate.replaceAll('\\', '/');
+    if (normalizedSeparators.startsWith('/')) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_ABSOLUTE' };
+    }
+    if (normalizedSeparators.startsWith('~/')) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_HOME_RELATIVE' };
+    }
+    if (/^[A-Za-z]:\//.test(normalizedSeparators)) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_DRIVE_ABSOLUTE' };
+    }
+    if (/^[A-Za-z][A-Za-z\d+.-]*:/.test(normalizedSeparators)) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_URI' };
+    }
+    if (normalizedSeparators.split('/').includes('..')) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_TRAVERSAL' };
+    }
+    const path = normalizedSeparators.replace(/\/+/g, '/').replace(/^(?:\.\/)+/, '');
+    return path.length > 0
+        ? { status: 'valid', path }
+        : { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_EMPTY' };
+}
+/** Normalize a raw traceability changed-file value without interpreting Markdown or prose. */
+export function normalizeChangedFilePath(value) {
+    const trimmed = value.trim();
+    if (trimmed.includes('`') ||
+        /^(?:#{1,6}|[-*+]|\d+[.)]|>)\s/u.test(trimmed) ||
+        /^\[[ xX]\]\s/u.test(trimmed)) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_MARKDOWN' };
+    }
+    if (/\s/u.test(trimmed)) {
+        return { status: 'invalid', code: 'INVALID_FILE_OWNERSHIP_DESCRIPTION' };
+    }
+    return normalizeOwnedPath(trimmed);
+}
+export function extractCanonicalFileOwnership(content) {
+    const filesSection = sectionContentAtLevel(content, 'Files', 2);
+    if (filesSection === null) {
+        return { present: false, toModify: [], toCreate: [], toTest: [], blockers: [] };
+    }
+    const blockers = [];
+    const addBlocker = (blocker) => {
+        if (!blockers.includes(blocker)) {
+            blockers.push(blocker);
+        }
+    };
+    const parseSection = (heading) => {
+        const subsection = sectionContentAtLevel(filesSection, heading, 3);
+        if (subsection === null) {
+            return [];
+        }
+        const { items, fenced } = ownershipItems(subsection);
+        for (const _value of fenced) {
+            addBlocker('INVALID_FILE_OWNERSHIP_FENCED');
+        }
+        const paths = [];
+        for (const value of items) {
+            const normalized = normalizeOwnedPath(value);
+            if (normalized.status === 'invalid') {
+                addBlocker(normalized.code);
+            }
+            else if (normalized.status === 'valid' && !paths.includes(normalized.path)) {
+                paths.push(normalized.path);
+            }
+        }
+        return paths;
+    };
+    const toCreate = parseSection('Create');
+    const toModify = parseSection('Modify');
+    const toTest = parseSection('Test');
+    const conflicts = [...new Set([...toCreate, ...toModify, ...toTest])].filter((path) => [toCreate, toModify, toTest].filter((paths) => paths.includes(path)).length > 1);
+    for (const path of conflicts) {
+        addBlocker(`CONFLICTING_FILE_OWNERSHIP: ${path}`);
+    }
+    return {
+        present: true,
+        toCreate: toCreate.filter((path) => !conflicts.includes(path)),
+        toModify: toModify.filter((path) => !conflicts.includes(path)),
+        toTest: toTest.filter((path) => !conflicts.includes(path)),
+        blockers,
+    };
+}
+const SAFE_OWNERSHIP_ANNOTATION = /^[\p{L}\p{N} .,_:-]+$/u;
+function isSafeOwnershipResidual(value) {
+    let remaining = value.trim();
+    while (remaining.length > 0) {
+        remaining = remaining.trimStart();
+        if (remaining.length === 0) {
+            return true;
+        }
+        const connector = /^(?:and|or)\b/iu.exec(remaining)?.[0];
+        if (connector) {
+            remaining = remaining.slice(connector.length);
+            continue;
+        }
+        if (',;&'.includes(remaining[0] ?? '')) {
+            remaining = remaining.slice(1);
+            continue;
+        }
+        if (remaining.startsWith('(')) {
+            const end = remaining.indexOf(')');
+            if (end < 2 || !SAFE_OWNERSHIP_ANNOTATION.test(remaining.slice(1, end))) {
+                return false;
+            }
+            remaining = remaining.slice(end + 1);
+            continue;
+        }
+        if (remaining.startsWith('—') || remaining.startsWith('-')) {
+            const description = remaining.slice(1).trim();
+            return description.length > 0 && SAFE_OWNERSHIP_ANNOTATION.test(description);
+        }
+        return false;
+    }
+    return true;
+}
+function ownershipBlocker(path, classifications) {
+    return `handoff_ownership_invalid path=${path} classifications=${classifications.join(',')}`;
+}
+function stripInertOwnershipMarkup(content) {
+    let fence = null;
+    let script = false;
+    return content
+        .split('\n')
+        .map((line) => {
+        const trimmed = line.trim();
+        const marker = /^[ \t]{0,3}(`{3,}|~{3,})/u.exec(line)?.[1];
+        if (marker) {
+            const type = marker[0];
+            if (fence === null) {
+                fence = { marker: type, length: marker.length };
+            }
+            else if (fence.marker === type && marker.length >= fence.length) {
+                fence = null;
+            }
+            return '';
+        }
+        if (fence !== null) {
+            return '';
+        }
+        if (/<script\b/iu.test(trimmed)) {
+            script = !/<\/script>/iu.test(trimmed);
+            return '';
+        }
+        if (script) {
+            if (/<\/script>/iu.test(trimmed)) {
+                script = false;
+            }
+            return '';
+        }
+        return /<\/?[A-Za-z][^>]*>/u.test(trimmed) ? '' : line;
+    })
+        .join('\n');
+}
+function normalizeStrictOwnedPath(rawValue) {
+    const normalized = normalizeOwnedPath(rawValue);
+    if (normalized.status !== 'valid') {
+        return null;
+    }
+    return /^[A-Za-z0-9._/-]+$/u.test(normalized.path) ? normalized.path : null;
+}
+function collectStrictOwnershipEntry(rawValue, classification, state) {
+    const rawPath = rawValue.trim();
+    const backtickedValues = [...rawPath.matchAll(/`([^`\n]+)`/gu)].map((match) => match[1] ?? '');
+    const backtickedPaths = backtickedValues.map(normalizeStrictOwnedPath);
+    const residual = rawPath.replaceAll(/`[^`\n]+`/gu, '').trim();
+    const residualIsSafe = isSafeOwnershipResidual(residual);
+    if (backtickedPaths.some((path) => path === null) ||
+        (backtickedValues.length > 0 && !residualIsSafe)) {
+        state.blockers.push(ownershipBlocker('<redacted>', [classification, 'InvalidPath']));
+        return;
+    }
+    const directPath = normalizeStrictOwnedPath(rawPath);
+    const paths = backtickedPaths.length > 0
+        ? backtickedPaths
+        : directPath === null
+            ? []
+            : [directPath];
+    if (paths.length === 0) {
+        const diagnosticPath = /^`[^`]+`$/u.test(rawPath) ? '<redacted>' : rawPath || '<empty>';
+        state.blockers.push(ownershipBlocker(diagnosticPath, [classification, 'InvalidPath']));
+        return;
+    }
+    for (const path of paths) {
+        collectStrictOwnershipPath(path, classification, state);
+    }
+}
+function collectStrictOwnershipPath(path, classification, state) {
+    const own = classification === 'Create' ? state.create : state.modify;
+    const other = classification === 'Create' ? state.modify : state.create;
+    if (own.has(path)) {
+        state.blockers.push(ownershipBlocker(path, [classification, classification]));
+        return;
+    }
+    if (other.has(path)) {
+        state.blockers.push(ownershipBlocker(path, ['Create', 'Modify']));
+        own.delete(path);
+        other.delete(path);
+        return;
+    }
+    own.add(path);
+}
+function extractStrictCanonicalOwnership(content) {
+    const filesSection = sectionContentAtLevel(content, 'Files', 2);
+    if (filesSection === null) {
+        return { present: false, toModify: [], toCreate: [], blockers: [] };
+    }
+    const state = { create: new Set(), modify: new Set(), blockers: [] };
+    const parseSection = (classification) => {
+        const subsection = sectionContentAtLevel(filesSection, classification, 3);
+        if (subsection === null) {
+            state.blockers.push(ownershipBlocker('<missing>', [classification, 'MissingSection']));
+            return;
+        }
+        const items = subsection
+            .split('\n')
+            .map((line) => /^\s*[-*]\s+(.+)$/u.exec(line)?.[1]?.trim())
+            .filter((item) => Boolean(item));
+        if (items.length === 0) {
+            state.blockers.push(ownershipBlocker('<empty>', [classification, 'Malformed']));
+            return;
+        }
+        let explicitNone = false;
+        for (const item of items) {
+            if (/^none\.?$/iu.test(item.trim())) {
+                if (explicitNone) {
+                    state.blockers.push(ownershipBlocker('<none>', [classification, classification]));
+                }
+                explicitNone = true;
+                continue;
+            }
+            collectStrictOwnershipEntry(item, classification, state);
+        }
+        const own = classification === 'Create' ? state.create : state.modify;
+        if (explicitNone && own.size > 0) {
+            state.blockers.push(ownershipBlocker('<none>', [classification, classification]));
+        }
+    };
+    parseSection('Create');
+    parseSection('Modify');
+    return {
+        present: true,
+        toCreate: [...state.create].sort(),
+        toModify: [...state.modify].sort(),
+        blockers: [...new Set(state.blockers)].sort(),
+    };
+}
+function extractFileLevelWorkPlanOwnership(content) {
+    const state = { create: new Set(), modify: new Set(), blockers: [] };
+    const section = sectionContentAtLevel(content, 'File-Level Work Plan', 3);
+    if (section === null) {
+        return { present: false, toModify: [], toCreate: [], blockers: [] };
+    }
+    for (const item of extractListItems(section)) {
+        const match = /^(Create|Modify)\s*:\s*(.+?)(?:\s+\([^)]*\))?\s*$/iu.exec(item);
+        if (!match?.[1] || !match[2]) {
+            continue;
+        }
+        const classification = match[1].toLowerCase() === 'create' ? 'Create' : 'Modify';
+        collectStrictOwnershipEntry(match[2], classification, state);
+    }
+    return {
+        present: state.create.size + state.modify.size + state.blockers.length > 0,
+        toCreate: [...state.create].sort(),
+        toModify: [...state.modify].sort(),
+        blockers: [...new Set(state.blockers)].sort(),
+    };
+}
+function validateOwnershipAgreement(canonical, workPlan) {
+    if (!canonical.present || !workPlan.present) {
+        return [];
+    }
+    const classification = (ownership, path) => ownership.toCreate.includes(path)
+        ? 'Create'
+        : ownership.toModify.includes(path)
+            ? 'Modify'
+            : 'Absent';
+    const paths = new Set([
+        ...canonical.toCreate,
+        ...canonical.toModify,
+        ...workPlan.toCreate,
+        ...workPlan.toModify,
+    ]);
+    return [...paths].sort().flatMap((path) => {
+        const canonicalClass = classification(canonical, path);
+        const workPlanClass = classification(workPlan, path);
+        return canonicalClass === workPlanClass
+            ? []
+            : [ownershipBlocker(path, [`Canonical:${canonicalClass}`, `WorkPlan:${workPlanClass}`])];
+    });
+}
 function extractBacktickedFiles(content) {
     const files = new Set();
-    const matches = content.matchAll(/`([^`\n]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|yml|yaml|sh|css|scss|html))`/g);
-    for (const match of matches) {
-        const filePath = match[1]?.trim();
-        if (filePath && !filePath.includes(' ')) {
-            files.add(filePath);
+    for (const match of content.matchAll(/`([^`\n]+)`/gu)) {
+        const path = match[1] ? normalizeStrictOwnedPath(match[1]) : null;
+        if (path) {
+            files.add(path);
         }
     }
-    return [...files];
+    return [...files].sort();
 }
 function extractLinesByKeywords(content, keywords) {
     return content
@@ -95,11 +449,27 @@ function extractOperationalSections(content, spec) {
         risks: extractLinesByKeywords(content, /\b(risk|edge|failure|security|drift|migration|breaking|compatibility|rollback)\b/i),
         ownership: extractLinesByKeywords(content, /\b(owner|ownership|wave|agent|reviewer|arbiter|files?|responsible)\b/i),
         currentState: `Spec ${spec.id} is ${spec.status}; implementation must follow the approved spec artifact, not chat history.`,
-        nextAction: spec.status === 'approved'
-            ? 'Move to implementing with this handoff, then implement only the listed scope.'
-            : 'Review the current spec status and move through the required SDD gates before implementation.',
+        nextAction: lifecycleNextAction(spec.status),
     };
 }
+function lifecycleNextAction(status) {
+    switch (status) {
+        case 'draft':
+            return 'Complete the specification, discovery, challenge, and readiness evidence before review.';
+        case 'review':
+            return 'Resolve reviewer feedback and obtain independent spec approval before implementation.';
+        case 'approved':
+            return 'Move to implementing with this handoff, then implement only the listed scope.';
+        case 'implementing':
+            return 'Finish the remaining criteria, persist traceability, obtain independent implementation review, and run validation.';
+        case 'done':
+            return 'No implementation remains; preserve the validated done contract.';
+        case 'discarded':
+            return 'Do not implement this discarded specification.';
+        default:
+            return `Unsupported lifecycle status "${status}"; repair the canonical status before implementation.`;
+    }
+}
 function extractOutOfScope(huContent, spec) {
     if (!huContent) {
         return [
@@ -167,10 +537,35 @@ export async function packageHandoff(spec, knowledge) {
     }
     const objective = extractObjective(huContent, spec);
     const criteria = extractAcceptanceCriteriaTexts(rawSpecContent);
-    const parsedFiles = extractFilesFromFicha(fichaContent);
-    const discoveredFiles = extractBacktickedFiles(`${huContent}\n${fichaContent}`);
-    const toModify = parsedFiles.toModify.length > 0 ? parsedFiles.toModify : discoveredFiles;
-    const toCreate = parsedFiles.toCreate;
+    const ownershipContent = stripInertOwnershipMarkup(rawSpecContent);
+    const canonicalFiles = extractCanonicalFileOwnership(rawSpecContent);
+    const canonicalOwnership = extractStrictCanonicalOwnership(ownershipContent);
+    const workPlanOwnership = extractFileLevelWorkPlanOwnership(ownershipContent);
+    const testOwnedPaths = new Set(canonicalFiles.toTest);
+    const explicitOwnership = canonicalOwnership.present
+        ? {
+            ...canonicalOwnership,
+            toCreate: canonicalOwnership.toCreate.filter((path) => !testOwnedPaths.has(path)),
+            toModify: canonicalOwnership.toModify.filter((path) => !testOwnedPaths.has(path)),
+        }
+        : workPlanOwnership.present
+            ? workPlanOwnership
+            : null;
+    const legacyFiles = extractFilesFromFicha(ownershipContent);
+    const hasLegacyOwnership = legacyFiles.toModify.length + legacyFiles.toCreate.length > 0;
+    const toModify = explicitOwnership
+        ? explicitOwnership.toModify
+        : hasLegacyOwnership
+            ? legacyFiles.toModify
+            : extractBacktickedFiles(ownershipContent);
+    const toCreate = explicitOwnership
+        ? explicitOwnership.toCreate
+        : hasLegacyOwnership
+            ? legacyFiles.toCreate
+            : [];
+    if (!explicitOwnership && toModify.length + toCreate.length > 0) {
+        warnings.push('LEGACY_FILE_OWNERSHIP_FALLBACK');
+    }
     const outOfScope = extractOutOfScope(huContent, spec);
     const constraints = buildConstraints(knowledge);
     const operational = extractOperationalSections(`${huContent}\n${fichaContent}`, spec);
@@ -183,6 +578,13 @@ export async function packageHandoff(spec, knowledge) {
         ...(operational.testPlan.length === 0 ? ['Missing test plan'] : []),
         ...(operational.risks.length === 0 ? ['Missing risk analysis'] : []),
         ...(operational.ownership.length === 0 ? ['Missing ownership'] : []),
+        ...canonicalFiles.blockers,
+        ...canonicalOwnership.blockers,
+        ...workPlanOwnership.blockers,
+        ...validateOwnershipAgreement(canonicalOwnership, workPlanOwnership),
+        ...(!['draft', 'review', 'approved', 'implementing', 'done', 'discarded'].includes(spec.status)
+            ? [`UNSUPPORTED_LIFECYCLE_STATUS: ${spec.status}`]
+            : []),
     ];
     const pkg = {
         specId: spec.id,

package/dist/engine/hooks/effort-configurator.js

@@ -4,7 +4,7 @@
 // ---------------------------------------------------------------------------
 export const DEFAULT_EFFORT_RULES = [
     {
-        pattern: 'list_specs|usage_stats|license_status',
+        pattern: 'list_specs|usage_stats',
         effort: 'low',
         reason: 'read-only queries',
     },

package/dist/engine/impact-detector/test-break-predictor.js

@@ -19,9 +19,9 @@ const BREAK_PATTERNS = [
         remediation: 'Run scripts/sync-website-counts.sh --apply and commit website/',
     },
     {
-        pattern: /license-plans\.json/,
-        kind: 'license-plans-sync',
-        remediation: 'Add new tool name to src/config/license-plans.json',
+        pattern: /generate-host-tool-registry/,
+        kind: 'tool-registry-sync',
+        remediation: 'Run scripts/generate-host-tool-registry.mjs',
     },
 ];
 async function collectTestFiles(dir, results, budget, depth) {

package/dist/engine/impact-detector/tool-registration.js

@@ -21,7 +21,7 @@ export function detectsNewToolRegistration(specBody, technicalMd) {
 export function buildToolRegistrationCriteria() {
     return [
         {
-            text: 'license-plans.json must include the new tool name',
+            text: 'The generated host registry must match the canonical tool registry',
             source: 'impact-detector',
             autoResolvable: false,
         },

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

@@ -7,19 +7,20 @@ export function buildImplementationContractSection(input) {
         `## ${IMPLEMENTATION_CONTRACT_SECTION}`,
         '### User Outcome',
         firstConcreteSentence(input.description) ??
+            criteria[0]?.text ??
             'Needs decision: define the exact observable outcome this spec must deliver.',
         '',
         '### Behavior Contract',
         ...renderBehaviorContract(criteria),
         '',
         '### File-Level Work Plan',
-        ...renderFilePlan(input.files),
+        ...renderFilePlan(input.files, criteria.length > 0),
         '',
         '### Acceptance-To-Verification Map',
         ...criteria.map((criterion, index) => renderVerificationRow(criterion.text, index + 1, testFiles, verificationCommands)),
         '',
         '### Edge Cases And Failure Modes',
-        '- Needs decision: identify criterion-specific failure modes from user input or project evidence.',
+        ...renderFailureModes(criteria),
         '',
         '### Non-Goals And Forbidden Approaches',
         ...renderNonGoals(input.outOfScope),
@@ -27,7 +28,9 @@ export function buildImplementationContractSection(input) {
         '### Verification Commands',
         ...(verificationCommands.length > 0
             ? verificationCommands.map((command) => `- \`${command}\``)
-            : ['- Needs decision: provide a repository-supported verification command.']),
+            : criteria.length > 0
+                ? ['- No repository-supported verification command was grounded for this candidate.']
+                : ['- Needs decision: provide a repository-supported verification command.']),
         '',
     ];
     return lines.join('\n');
@@ -48,9 +51,9 @@ function firstConcreteSentence(description) {
     if (!body) {
         return null;
     }
-    return body.replace(/\s+/g, ' ').slice(0, 240);
+    return body.replace(/\s+/g, ' ');
 }
-function renderFilePlan(files) {
+function renderFilePlan(files, hasGroundedBehavior) {
     const lines = [];
     for (const [label, entries] of [
         ['Create', files.create],
@@ -61,7 +64,12 @@ function renderFilePlan(files) {
             lines.push(`- ${label}: \`${entry.path}\` (${entry.status})`);
         }
     }
-    return lines.length > 0 ? lines : ['- Needs decision: identify expected source and test files.'];
+    if (lines.length > 0) {
+        return lines;
+    }
+    return hasGroundedBehavior
+        ? ['- No file ownership was grounded for this behavior.']
+        : ['- Needs decision: identify expected source and test files.'];
 }
 function renderBehaviorContract(criteria) {
     return criteria.length > 0
@@ -76,11 +84,18 @@ function renderVerificationRow(criterion, index, testFiles, commands) {
             ? `- 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.`;
+    return `- AC${String(index)}: ${criterion} -> verify the exact observable result declared by this criterion.`;
 }
 function renderNonGoals(outOfScope) {
     return outOfScope.length > 0
         ? outOfScope.map((item) => `- ${item}`)
-        : ['- Needs decision: provide explicit non-goals or confirm that none were supplied.'];
+        : ['- No explicit non-goals were supplied.'];
+}
+function renderFailureModes(criteria) {
+    return criteria.length > 0
+        ? criteria.map((criterion, index) => `- AC${String(index + 1)} failure: reject partial behavior that violates "${criterion.text}" and preserve the last valid observable state.`)
+        : [
+            '- Needs decision: identify criterion-specific failure modes from user input or project evidence.',
+        ];
 }
 //# sourceMappingURL=renderer.js.map

package/dist/engine/lifecycle-reconciliation-io.d.ts

@@ -0,0 +1,11 @@
+import type { ReconciliationReceiptV1 } from '../types/handoff-artifacts.js';
+export declare function reconciliationDigest(value: string | Buffer): string;
+export declare function safeReceiptPath(projectId: string, specId: string, requestId: string): Promise<string>;
+export declare function readReconciliationReceipt(path: string): Promise<ReconciliationReceiptV1 | null>;
+export declare function writeReconciliationReceipt(path: string, receipt: ReconciliationReceiptV1): Promise<void>;
+export declare function collectSupersededReconciliationArtifacts(projectId: string, specId: string): Promise<{
+    artifactId: string;
+    sha256?: string;
+}[]>;
+export declare function readCommittedReconciliationReceipts(projectId: string, specId: string): Promise<ReconciliationReceiptV1[]>;
+//# sourceMappingURL=lifecycle-reconciliation-io.d.ts.map