@planu/cli 5.7.5 → 5.7.7

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

@@ -1,6 +1,6 @@
 export declare const IMPLEMENTATION_CONTRACT_SECTION = "Implementation Contract";
 /** Subsections every rendered contract must include — omitting one is a defect. */
-export declare const IMPLEMENTATION_CONTRACT_REQUIRED_SUBSECTIONS: readonly ['User Outcome', 'File-Level Work Plan', 'Acceptance-To-Verification Map', 'Verification Commands'];
+export declare const IMPLEMENTATION_CONTRACT_REQUIRED_SUBSECTIONS: readonly ['User Outcome'];
 /**
  * SPEC-1406: subsections that carry no grounded content are omitted from the rendered
  * body rather than filled with restated-criterion filler. Their absence is not an
@@ -8,10 +8,15 @@ export declare const IMPLEMENTATION_CONTRACT_REQUIRED_SUBSECTIONS: readonly ['Us
  * already-persisted specs that still carry these sections (with real, non-empty
  * content) transitionable: `evaluateImplementationContract` only requires them when
  * the rendered body chose to include the heading.
+ *
+ * SPEC-1435: extends the same omission precedent to File-Level Work Plan,
+ * Acceptance-To-Verification Map, and Verification Commands — the renderer used to
+ * fill these with a constant "no evidence was grounded" sentence that its own quality
+ * gates could not see. Now the renderer omits the subsection instead.
  */
-export declare const IMPLEMENTATION_CONTRACT_OPTIONAL_SUBSECTIONS: readonly ['Behavior Contract', 'Edge Cases And Failure Modes', 'Non-Goals And Forbidden Approaches'];
+export declare const IMPLEMENTATION_CONTRACT_OPTIONAL_SUBSECTIONS: readonly ['Behavior Contract', 'Edge Cases And Failure Modes', 'Non-Goals And Forbidden Approaches', 'File-Level Work Plan', 'Acceptance-To-Verification Map', 'Verification Commands'];
 /** Union of required + optional subsections. Kept for callers that only need the full set. */
-export declare const IMPLEMENTATION_CONTRACT_SUBSECTIONS: readonly ["User Outcome", "File-Level Work Plan", "Acceptance-To-Verification Map", "Verification Commands", "Behavior Contract", "Edge Cases And Failure Modes", "Non-Goals And Forbidden Approaches"];
+export declare const IMPLEMENTATION_CONTRACT_SUBSECTIONS: readonly ["User Outcome", "Behavior Contract", "Edge Cases And Failure Modes", "Non-Goals And Forbidden Approaches", "File-Level Work Plan", "Acceptance-To-Verification Map", "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/common.js

@@ -1,12 +1,7 @@
 import { escapeRegex } from '../../core/shared/strings.js';
 export const IMPLEMENTATION_CONTRACT_SECTION = 'Implementation Contract';
 /** Subsections every rendered contract must include — omitting one is a defect. */
-export const IMPLEMENTATION_CONTRACT_REQUIRED_SUBSECTIONS = [
-    'User Outcome',
-    'File-Level Work Plan',
-    'Acceptance-To-Verification Map',
-    'Verification Commands',
-];
+export const IMPLEMENTATION_CONTRACT_REQUIRED_SUBSECTIONS = ['User Outcome'];
 /**
  * SPEC-1406: subsections that carry no grounded content are omitted from the rendered
  * body rather than filled with restated-criterion filler. Their absence is not an
@@ -14,11 +9,19 @@ export const IMPLEMENTATION_CONTRACT_REQUIRED_SUBSECTIONS = [
  * already-persisted specs that still carry these sections (with real, non-empty
  * content) transitionable: `evaluateImplementationContract` only requires them when
  * the rendered body chose to include the heading.
+ *
+ * SPEC-1435: extends the same omission precedent to File-Level Work Plan,
+ * Acceptance-To-Verification Map, and Verification Commands — the renderer used to
+ * fill these with a constant "no evidence was grounded" sentence that its own quality
+ * gates could not see. Now the renderer omits the subsection instead.
  */
 export const IMPLEMENTATION_CONTRACT_OPTIONAL_SUBSECTIONS = [
     'Behavior Contract',
     'Edge Cases And Failure Modes',
     'Non-Goals And Forbidden Approaches',
+    'File-Level Work Plan',
+    'Acceptance-To-Verification Map',
+    'Verification Commands',
 ];
 /** Union of required + optional subsections. Kept for callers that only need the full set. */
 export const IMPLEMENTATION_CONTRACT_SUBSECTIONS = [

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

@@ -83,12 +83,10 @@ function evaluateSubsection(section, content) {
     }
     const trimmed = content.trim();
     if (trimmed.length === 0) {
-        if (!OPTIONAL_SUBSECTIONS.has(section)) {
-            issues.push({
-                code: 'contract_subsection_empty',
-                message: `Implementation Contract subsection "${section}" is empty.`,
-            });
-        }
+        issues.push({
+            code: 'contract_subsection_empty',
+            message: `Implementation Contract subsection "${section}" is empty.`,
+        });
         return issues;
     }
     for (const pattern of FILLER_PATTERNS) {

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

@@ -3,32 +3,32 @@ export function buildImplementationContractSection(input) {
     const criteria = input.criteria;
     const testFiles = input.files.test.map((file) => file.path);
     const verificationCommands = input.verificationCommands;
+    const filePlan = renderFilePlan(input.files);
     const verificationRows = renderVerificationRows(criteria, testFiles, verificationCommands);
     const failureModes = renderFailureModes(criteria);
     const nonGoals = renderNonGoals(input.outOfScope);
+    const verificationCommandLines = verificationCommands.length > 0
+        ? verificationCommands.map((command) => `- \`${command}\``)
+        : criteria.length > 0
+            ? []
+            : ['- Needs decision: provide a repository-supported verification command.'];
     const lines = [
         `## ${IMPLEMENTATION_CONTRACT_SECTION}`,
         '### User Outcome',
         criteria[0]?.text ??
             'Needs decision: define the exact observable outcome this spec must deliver.',
         '',
-        '### File-Level Work Plan',
-        ...renderFilePlan(input.files, criteria.length > 0),
-        '',
-        '### Acceptance-To-Verification Map',
-        ...verificationRows,
-        '',
-        // SPEC-1406 (DEFECT 5): a subsection with no grounded content is omitted rather than
-        // filled with a restated-criterion placeholder — prefer omission over filler.
+        // SPEC-1406 (DEFECT 5) / SPEC-1435: a subsection with no grounded content is omitted
+        // rather than filled with a restated-criterion placeholder — prefer omission over filler.
+        ...(filePlan.length > 0 ? ['### File-Level Work Plan', ...filePlan, ''] : []),
+        ...(verificationRows.length > 0
+            ? ['### Acceptance-To-Verification Map', ...verificationRows, '']
+            : []),
         ...(failureModes.length > 0 ? ['### Edge Cases And Failure Modes', ...failureModes, ''] : []),
         ...(nonGoals.length > 0 ? ['### Non-Goals And Forbidden Approaches', ...nonGoals, ''] : []),
-        '### Verification Commands',
-        ...(verificationCommands.length > 0
-            ? verificationCommands.map((command) => `- \`${command}\``)
-            : criteria.length > 0
-                ? ['- No repository-supported verification command was grounded for this candidate.']
-                : ['- Needs decision: provide a repository-supported verification command.']),
-        '',
+        ...(verificationCommandLines.length > 0
+            ? ['### Verification Commands', ...verificationCommandLines, '']
+            : []),
     ];
     return lines.join('\n');
 }
@@ -38,7 +38,7 @@ export function appendImplementationContractIfMissing(specBody, input) {
     }
     return `${specBody.trimEnd()}\n\n${buildImplementationContractSection(input)}`;
 }
-function renderFilePlan(files, hasGroundedBehavior) {
+function renderFilePlan(files) {
     const lines = [];
     for (const [label, entries] of [
         ['Create', files.create],
@@ -49,12 +49,7 @@ function renderFilePlan(files, hasGroundedBehavior) {
             lines.push(`- ${label}: \`${entry.path}\` (${entry.status})`);
         }
     }
-    if (lines.length > 0) {
-        return lines;
-    }
-    return hasGroundedBehavior
-        ? ['- No file ownership was grounded for this behavior.']
-        : ['- Needs decision: identify expected source and test files.'];
+    return lines;
 }
 /**
  * SPEC-1406 (DEFECT 1, round 2): renders the Acceptance-To-Verification Map body.
@@ -80,7 +75,7 @@ function renderVerificationRows(criteria, testFiles, commands) {
         return rows;
     }
     if (testFiles.length === 0) {
-        return ['- No repository-supported verification evidence was grounded for these criteria.'];
+        return [];
     }
     return renderSharedVerificationRow(testFiles, commands);
 }

package/dist/engine/project-health-checker.js

@@ -2,15 +2,15 @@ import { technologyValue } from './technology-registry.js';
 import { fileExists } from '../core/shared/fs.js';
 // @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
 // engine/project-health-checker.ts — SPEC-180 + SPEC-192 + SPEC-177: Project health check with convention scanning
-import { execSync } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 import { parseConventions, scanConventions } from './convention-scanner/index.js';
 import { fastFindPatterns } from './core-bridge.js';
+import { execGitCapture } from './git/exec-git.js';
 // ── helpers ──────────────────────────────────────────────────────────────────
 function execSafe(cmd, cwd) {
     try {
-        return execSync(cmd, { cwd, stdio: ['pipe', 'pipe', 'pipe'] }).toString();
+        return execGitCapture(cmd, cwd);
     }
     catch {
         return '';

package/dist/engine/readiness-checker.js

@@ -10,11 +10,39 @@ import { findScenariosWithoutTests, parseFrontmatterScenarios, } from './validat
 import { normalizeExecutableEvidence } from './validator/executable-evidence.js';
 import { evaluateImplementationContract } from './implementation-contract/index.js';
 import { extractNormalizedAcceptanceCriteria } from './spec-format/acceptance-criteria.js';
+import { isRetiredScaffoldText } from './spec-format/retired-scaffold.js';
 import { detectCrossSpecPremiseContradictions } from './contradiction-detector.js';
+import { parseCriterionGroundingRecords, parseTechnicalReferenceGroundingRecords, } from './spec-grounding/contract.js';
 // ── SPEC-784: Technical section quality constants ─────────────────────────────
 const TECHNICAL_MIN_CHARS = 500;
+const GROUNDING_FRONTMATTER_RE = /^---\n([\s\S]*?)\n---/;
 // Detects "See technical.md", "See spec.md", or "See `<file>` technical.md" patterns
 const TECHNICAL_PLACEHOLDER_REGEX = /\bSee\s+(?:`?[^`\n]+`?\s+)?(?:technical|spec)\.md/i;
+const BDD_CRITERION_RE = /\bGIVEN\b[\s\S]*\bWHEN\b[\s\S]*\bTHEN\b/i;
+function isExecutableBddLine(line) {
+    return !isRetiredScaffoldText(line) && BDD_CRITERION_RE.test(line);
+}
+function groundingParseDiagnosticFindings(huRaw) {
+    const frontmatter = GROUNDING_FRONTMATTER_RE.exec(huRaw)?.[1] ?? '';
+    const criteriaDiagnostics = parseCriterionGroundingRecords(frontmatter).diagnostics;
+    const technicalDiagnostics = parseTechnicalReferenceGroundingRecords(frontmatter).diagnostics;
+    return [...criteriaDiagnostics, ...technicalDiagnostics].map((diagnostic) => `GROUNDING_PARSE_DROPPED: "${diagnostic.identifier}" has an invalid ${diagnostic.field} ` +
+        `("${diagnostic.value}") — allowed: ${diagnostic.allowed.join(', ') || 'n/a'}`);
+}
+function checkScenariosWithoutTests(huRaw, bddScenarioCount) {
+    if (bddScenarioCount === 0) {
+        return [];
+    }
+    return findScenariosWithoutTests(huRaw).map((title) => `scenarios_missing_tests: scenario "${title}" has no tests array — add tests entries as a block list (tests: with one "- path" line per test) or an inline array (tests: ["path"]) (SPEC-732)`);
+}
+function checkZeroBddCriteria(criteriaLines) {
+    if (criteriaLines.length === 0 || criteriaLines.some(isExecutableBddLine)) {
+        return [];
+    }
+    return [
+        'NO_BDD_CRITERIA: no acceptance criterion parses as GIVEN/WHEN/THEN — restate at least one criterion in executable form',
+    ];
+}
 // ── Helpers ──────────────────────────────────────────────────────────────────
 function scoreHuCompleteness(spec) {
     const blockers = [];
@@ -73,6 +101,15 @@ function countFrontmatterScenarios(raw) {
     // Each scenario entry starts with "  - title:" (2-space indent)
     return (block.match(/^\s+-\s+title:/gm) ?? []).length;
 }
+function frontmatterScenarioScavengeWarning(bddScenarioCount, normalizedCriteria) {
+    const bodyCriteriaCount = normalizedCriteria.filter((criterion) => criterion.source === 'body').length;
+    if (bddScenarioCount === 0 || bddScenarioCount >= bodyCriteriaCount) {
+        return null;
+    }
+    return (`frontmatter_scenarios_below_body_criteria: frontmatter declares ${String(bddScenarioCount)} ` +
+        `scenarios but body renders ${String(bodyCriteriaCount)} acceptance criteria — scenarios may ` +
+        `have been scavenged from prose`);
+}
 async function readFichaContent(spec) {
     return readSpecTechnicalSection(spec);
 }
@@ -418,6 +455,7 @@ export async function checkSpecReadiness(spec, mode, projectHash) {
         ...earsBlockers,
     ];
     const allWarnings = [...hu.warnings, ...criteria.warnings, ...files.warnings, ...deps.warnings];
+    allBlockers.push(...checkZeroBddCriteria(effectiveCriteriaLines));
     if (mode === 'strict' && spec.scope !== 'trivial' && spec.difficulty >= 3) {
         for (const issue of evaluateImplementationContract(huContent, canonicalCriteriaLines)) {
             allBlockers.push(`${issue.code}: ${issue.message}`);
@@ -426,12 +464,12 @@ export async function checkSpecReadiness(spec, mode, projectHash) {
     // SPEC-732: Executable AC gate — block approved when any scenario lacks a `tests` array.
     // Only enforce when the spec uses frontmatter scenarios (BDD format).
     const bddScenarioCount = countFrontmatterScenarios(huRaw);
-    if (bddScenarioCount > 0) {
-        const scenariosWithoutTests = findScenariosWithoutTests(huRaw);
-        for (const title of scenariosWithoutTests) {
-            allBlockers.push(`scenarios_missing_tests: scenario "${title}" has no tests array — add tests entries as a block list (tests: with one "- path" line per test) or an inline array (tests: ["path"]) (SPEC-732)`);
-        }
+    allBlockers.push(...checkScenariosWithoutTests(huRaw, bddScenarioCount));
+    const scavengeWarning = frontmatterScenarioScavengeWarning(bddScenarioCount, normalizedCriteria);
+    if (scavengeWarning) {
+        allWarnings.push(scavengeWarning);
     }
+    allWarnings.push(...groundingParseDiagnosticFindings(huRaw));
     // SPEC-1214: BDD-criteria executable-evidence gate — when a spec has no frontmatter
     // scenarios, its criteria must carry a TEST: marker mapping to an executable test file,
     // or validation will later score 0 with "No executable scenarios declared".

package/dist/engine/reconcile/apply-changes.js

@@ -2,6 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { atomicWriteFile } from '../safety/atomic-write-file.js';
 import { SECTIONS_WITHOUT_LITERAL_BODY_TEXT, } from '../../types/index.js';
 import { escapeRegex } from '../../core/shared/strings.js';
+import { propagateMirrors } from './propagate-mirrors.js';
 function findSectionBounds(content, section) {
     const headingRe = new RegExp(`^(#{1,6})\\s+${escapeRegex(section)}\\s*$`, 'mi');
     const match = headingRe.exec(content);
@@ -54,6 +55,7 @@ export async function applyChangesToSpec(specPath, changes) {
     let modified = content;
     let applied = 0;
     const skipped = [];
+    const appliedSections = new Set();
     for (const change of approvedTextChanges) {
         const bounds = findSectionBounds(modified, change.section);
         if (bounds === null) {
@@ -92,10 +94,12 @@ export async function applyChangesToSpec(specPath, changes) {
                 change.newValue +
                 modified.slice(absoluteIdx + change.originalValue.length);
         applied++;
+        appliedSections.add(change.section);
     }
     if (applied === 0) {
         return { applied: 0, skipped, fileWritten: false };
     }
+    modified = propagateMirrors(modified, appliedSections);
     await atomicWriteFile(specPath, modified);
     return { applied, skipped, fileWritten: true };
 }

package/dist/engine/reconcile/propagate-mirrors.d.ts

@@ -0,0 +1,3 @@
+import type { AppliedSections } from '../../types/index.js';
+export declare function propagateMirrors(content: string, appliedSections: AppliedSections): string;
+//# sourceMappingURL=propagate-mirrors.d.ts.map

package/dist/engine/reconcile/propagate-mirrors.js

@@ -0,0 +1,311 @@
+import { escapeRegex } from '../../core/shared/strings.js';
+import { normalizeCriterionText } from '../criterion-identity.js';
+import { parseBddScenarios, renderBddScenariosYaml } from '../spec-format/bdd-parser.js';
+import { extractSectionCriteria } from '../spec-format/acceptance-criteria.js';
+import { extractListItems, findMarkdownSectionRange } from '../spec-format/markdown-sections.js';
+import { parseCriterionGroundingRecords, parseTechnicalReferenceGroundingRecords, renderGroundingFrontmatter, renderTechnicalReferenceGroundingFrontmatter, } from '../spec-grounding/contract.js';
+const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n/;
+const ACCEPTANCE_CRITERIA_HEADING = 'Acceptance Criteria';
+const FILES_HEADING = 'Files';
+const TECHNICAL_HEADING = 'Technical';
+const FILE_WORK_PLAN_HEADING = 'File-Level Work Plan';
+const ACCEPTANCE_MAP_HEADING = 'Acceptance-To-Verification Map';
+const VERIFICATION_COMMANDS_HEADING = 'Verification Commands';
+const VERIFICATION_STARTS_WITH_RE = /Verification starts with:\s*`([^`]+)`/i;
+export function propagateMirrors(content, appliedSections) {
+    let result = content;
+    if (appliedSections.has(ACCEPTANCE_CRITERIA_HEADING)) {
+        result = propagateAcceptanceCriteria(result);
+    }
+    if (appliedSections.has(FILES_HEADING)) {
+        result = propagateFiles(result);
+    }
+    if (appliedSections.has(TECHNICAL_HEADING)) {
+        result = propagateTechnicalVerificationCommand(result);
+    }
+    return result;
+}
+function propagateAcceptanceCriteria(content) {
+    const section = findMarkdownSectionRange(content, ACCEPTANCE_CRITERIA_HEADING);
+    if (!section) {
+        return content;
+    }
+    const sectionBody = content.slice(section.contentStart, section.end);
+    const criteriaTexts = extractSectionCriteria(sectionBody);
+    const scenarios = criteriaTexts.map(criterionToScenario);
+    const oldRecords = mapWithFrontmatter(content, (fm) => indexCriterionRecords(parseCriterionGroundingRecords(fm).records));
+    const oldTestPaths = mapWithFrontmatter(content, (fm) => parseTechnicalReferenceGroundingRecords(fm)
+        .records.filter((record) => record.section === 'test')
+        .map((record) => record.path));
+    const criteriaRecords = criteriaTexts.map((text) => oldRecords.get(normalizeCriterionText(text)) ?? {
+        text,
+        source: 'user_input',
+        evidence: ['reconcile_spec.changes'],
+        confidence: 'high',
+    });
+    let result = transformFrontmatter(content, (fm) => {
+        let updated = replaceFrontmatterKeyBlock(fm, 'scenarios', renderBddScenariosYaml(scenarios));
+        updated = replaceFrontmatterKeyBlock(updated, 'grounding', groundingBlockLines(criteriaRecords, technicalReferencesFromFrontmatter(fm)));
+        return updated;
+    });
+    result = withSectionBody(result, ACCEPTANCE_MAP_HEADING, (body) => syncAcceptanceMapForCriteria(body, criteriaTexts, oldTestPaths));
+    return result;
+}
+function propagateFiles(content) {
+    const section = findMarkdownSectionRange(content, FILES_HEADING);
+    if (!section) {
+        return content;
+    }
+    const sectionBody = content.slice(section.contentStart, section.end);
+    const files = parseFilesSection(sectionBody);
+    const oldTestPaths = mapWithFrontmatter(content, (fm) => parseTechnicalReferenceGroundingRecords(fm)
+        .records.filter((record) => record.section === 'test')
+        .map((record) => record.path));
+    const oldTechnicalReferences = mapWithFrontmatter(content, (fm) => indexTechnicalReferenceRecords(parseTechnicalReferenceGroundingRecords(fm).records));
+    const technicalReferences = buildTechnicalReferenceRecords(files, oldTechnicalReferences);
+    const newTestPaths = files.test;
+    let result = transformFrontmatter(content, (fm) => replaceFrontmatterKeyBlock(fm, 'grounding', groundingBlockLines(criteriaRecordsFromFrontmatter(fm), technicalReferences)));
+    result = replaceNamedSection(result, FILE_WORK_PLAN_HEADING, renderFileWorkPlan(files));
+    result = withSectionBody(result, ACCEPTANCE_MAP_HEADING, (body) => addVerifiedTestPathEntries(body, oldTestPaths, newTestPaths));
+    result = withSectionBody(result, VERIFICATION_COMMANDS_HEADING, (body) => syncVerificationCommandLines(body, oldTestPaths, newTestPaths));
+    return result;
+}
+function propagateTechnicalVerificationCommand(content) {
+    const technicalSection = findMarkdownSectionRange(content, TECHNICAL_HEADING);
+    if (!technicalSection) {
+        return content;
+    }
+    const technicalBody = content.slice(technicalSection.contentStart, technicalSection.end);
+    const newCommand = VERIFICATION_STARTS_WITH_RE.exec(technicalBody)?.[1]?.trim();
+    if (!newCommand) {
+        return content;
+    }
+    const commandsSection = findMarkdownSectionRange(content, VERIFICATION_COMMANDS_HEADING);
+    if (!commandsSection) {
+        return content;
+    }
+    const currentBody = content.slice(commandsSection.contentStart, commandsSection.end);
+    if (currentBody.includes(newCommand)) {
+        return content;
+    }
+    return replaceNamedSection(content, VERIFICATION_COMMANDS_HEADING, [`- \`${newCommand}\``]);
+}
+function criterionToScenario(text) {
+    const gwtLines = text
+        .split(/\b(GIVEN|WHEN|THEN|AND)\b/)
+        .reduce((lines, part, index, parts) => {
+        if (index % 2 === 0) {
+            return lines;
+        }
+        const keyword = part;
+        const rest = (parts[index + 1] ?? '').trim();
+        lines.push(`${keyword} ${rest}`);
+        return lines;
+    }, []);
+    const [scenario] = parseBddScenarios(gwtLines.join('\n'));
+    return scenario ?? { title: text, steps: [{ keyword: 'then', text }], done: false };
+}
+function indexCriterionRecords(records) {
+    const index = new Map();
+    for (const record of records) {
+        index.set(normalizeCriterionText(record.text), record);
+    }
+    return index;
+}
+function indexTechnicalReferenceRecords(records) {
+    const index = new Map();
+    for (const record of records) {
+        index.set(record.path, record);
+    }
+    return index;
+}
+function parseFilesSection(sectionBody) {
+    return {
+        create: parseFilesSubsection(sectionBody, 'Create'),
+        modify: parseFilesSubsection(sectionBody, 'Modify'),
+        test: parseFilesSubsection(sectionBody, 'Test'),
+    };
+}
+function parseFilesSubsection(sectionBody, heading) {
+    const range = findMarkdownSectionRange(sectionBody, heading);
+    if (!range) {
+        return [];
+    }
+    const body = sectionBody.slice(range.contentStart, range.end);
+    return extractListItems(body).map((item) => item.replace(/`/g, '').trim());
+}
+function buildTechnicalReferenceRecords(files, oldRecords) {
+    const groups = [
+        ['create', files.create],
+        ['modify', files.modify],
+        ['test', files.test],
+    ];
+    const records = [];
+    for (const [section, paths] of groups) {
+        for (const path of paths) {
+            const existing = oldRecords.get(path);
+            records.push(existing
+                ? { ...existing, section }
+                : {
+                    path,
+                    section,
+                    source: 'user_input',
+                    evidence: ['reconcile_spec.changes'],
+                    confidence: 'high',
+                });
+        }
+    }
+    return records;
+}
+function renderFileWorkPlan(files) {
+    const groups = [
+        ['Create', files.create],
+        ['Modify', files.modify],
+        ['Test', files.test],
+    ];
+    return groups.flatMap(([label, paths]) => paths.map((path) => `- ${label}: \`${path}\` (pending)`));
+}
+function isVerifiedByLine(line, path) {
+    return /^-\s*Verified by:/i.test(line.trim()) && line.includes(path);
+}
+function addVerifiedTestPathEntries(body, oldPaths, newPaths) {
+    const removed = oldPaths.filter((path) => !newPaths.includes(path));
+    const added = newPaths.filter((path) => !oldPaths.includes(path));
+    if (removed.length === 0 && added.length === 0) {
+        return body;
+    }
+    let updated = removed.length === 0
+        ? body
+        : body
+            .split('\n')
+            .filter((line) => !removed.some((path) => isVerifiedByLine(line, path)))
+            .join('\n');
+    if (added.length > 0) {
+        const bulletLines = added.map((path) => `- Verified by: \`${path}\``).join('\n');
+        updated = `${updated.trimEnd()}\n${bulletLines}\n`;
+    }
+    return updated;
+}
+function isTestRunnerCommandLine(line) {
+    return /`[^`]*\b(vitest|jest|mocha|pnpm test|npm test)\b[^`]*`/i.test(line);
+}
+function syncVerificationCommandLines(body, oldPaths, newPaths) {
+    const removed = oldPaths.filter((path) => !newPaths.includes(path));
+    const added = newPaths.filter((path) => !oldPaths.includes(path));
+    if (removed.length === 0 && added.length === 0) {
+        return body;
+    }
+    const lines = body.split('\n').map((line) => {
+        if (!oldPaths.some((path) => line.includes(path))) {
+            return line;
+        }
+        return substituteTestPathsInLine(line, removed, added);
+    });
+    const stillMissing = added.filter((path) => !lines.some((line) => line.includes(path)));
+    if (stillMissing.length === 0) {
+        return lines.join('\n');
+    }
+    const commandLineIndex = lines.findIndex(isTestRunnerCommandLine);
+    if (commandLineIndex !== -1) {
+        lines[commandLineIndex] = substituteTestPathsInLine(lines[commandLineIndex] ?? '', [], stillMissing);
+        return lines.join('\n');
+    }
+    while (lines.length > 0 && lines[lines.length - 1]?.trim() === '') {
+        lines.pop();
+    }
+    return `${[...lines, ...stillMissing.map((path) => `- \`${path}\``)].join('\n')}\n`;
+}
+function syncAcceptanceMapForCriteria(body, criteriaTexts, testPaths) {
+    const lines = body.split('\n').filter((line) => line.trim().length > 0);
+    const kept = lines.filter((line) => criteriaTexts.some((text) => line.includes(text)));
+    const covered = new Set(kept.flatMap((line) => criteriaTexts.filter((text) => line.includes(text))));
+    const newEntries = criteriaTexts
+        .filter((text) => !covered.has(text))
+        .map((text) => renderAcceptanceMapEntry(text, testPaths));
+    const resultLines = [...kept, ...newEntries];
+    if (resultLines.length === 0) {
+        return body;
+    }
+    return `${resultLines.join('\n')}\n`;
+}
+function renderAcceptanceMapEntry(criterionText, testPaths) {
+    return testPaths.length > 0
+        ? `- ${criterionText}: verified by ${testPaths.map((path) => `\`${path}\``).join(', ')}`
+        : `- ${criterionText}: verification pending — no test file listed yet`;
+}
+function substituteTestPathsInLine(line, removed, added) {
+    let updated = line;
+    for (const path of removed) {
+        updated = updated.replace(new RegExp(`\\s*${escapeRegex(path)}`), '');
+    }
+    if (added.length === 0) {
+        return updated;
+    }
+    const insertion = ` ${added.join(' ')}`;
+    if (updated.endsWith('`.')) {
+        return `${updated.slice(0, -2)}${insertion}\`.`;
+    }
+    if (updated.endsWith('`')) {
+        return `${updated.slice(0, -1)}${insertion}\``;
+    }
+    return `${updated}${insertion}`;
+}
+function replaceNamedSection(content, headingName, bodyLines) {
+    const range = findMarkdownSectionRange(content, headingName);
+    if (!range) {
+        return content;
+    }
+    const isLast = range.end >= content.length;
+    const body = bodyLines.join('\n');
+    const tail = isLast ? `${body}\n` : `${body}\n\n`;
+    return content.slice(0, range.contentStart) + tail + content.slice(range.end);
+}
+function withSectionBody(content, headingName, transform) {
+    const range = findMarkdownSectionRange(content, headingName);
+    if (!range) {
+        return content;
+    }
+    const body = content.slice(range.contentStart, range.end);
+    const updated = transform(body);
+    if (updated === body) {
+        return content;
+    }
+    return content.slice(0, range.contentStart) + updated + content.slice(range.end);
+}
+function transformFrontmatter(content, transform) {
+    const match = FRONTMATTER_RE.exec(content);
+    if (!match?.[1]) {
+        return content;
+    }
+    const updated = transform(match[1]);
+    return `---\n${updated}\n---\n${content.slice(match[0].length)}`;
+}
+function mapWithFrontmatter(content, read) {
+    const match = FRONTMATTER_RE.exec(content);
+    return read(match?.[1] ?? '');
+}
+function technicalReferencesFromFrontmatter(frontmatter) {
+    return parseTechnicalReferenceGroundingRecords(frontmatter).records;
+}
+function criteriaRecordsFromFrontmatter(frontmatter) {
+    return parseCriterionGroundingRecords(frontmatter).records;
+}
+function groundingBlockLines(criteria, technicalReferences) {
+    const criteriaLines = renderGroundingFrontmatter(criteria).slice(2);
+    const technicalReferenceLines = technicalReferences.length > 0
+        ? renderTechnicalReferenceGroundingFrontmatter(technicalReferences)
+        : [];
+    return ['grounding:', ...criteriaLines, ...technicalReferenceLines];
+}
+function replaceFrontmatterKeyBlock(frontmatter, key, blockLines) {
+    const re = new RegExp(`^${escapeRegex(key)}:.*(?:\\n[ \\t]+.*)*`, 'm');
+    const match = re.exec(frontmatter);
+    const replacement = blockLines.join('\n');
+    if (!match) {
+        return `${frontmatter.trimEnd()}\n${replacement}`;
+    }
+    return (frontmatter.slice(0, match.index) +
+        replacement +
+        frontmatter.slice(match.index + match[0].length));
+}
+//# sourceMappingURL=propagate-mirrors.js.map

package/dist/engine/self-healing/healer.js

@@ -3,6 +3,7 @@ import { applyTypescriptFix } from './strategies/typescript-fix.js';
 import { applyLintFix } from './strategies/lint-fix.js';
 import { applyTestFix } from './strategies/test-fix.js';
 import { applyCoverageFix } from './strategies/coverage-fix.js';
+import { qaCheckTimeoutMs } from '../qa-gate.js';
 const MAX_ATTEMPTS = 3;
 /**
  * Maps a failure type to the appropriate fix strategy name.
@@ -24,14 +25,14 @@ export function identifyFixStrategy(failureType) {
 /**
  * Dispatches to the appropriate strategy based on strategy name.
  */
-function runStrategy(strategyName, projectPath, details) {
+function runStrategy(strategyName, projectPath, details, timeoutMs) {
     switch (strategyName) {
         case technologyValue('technology-typescript-969545'):
-            return applyTypescriptFix(projectPath, details);
+            return applyTypescriptFix(projectPath, details, timeoutMs);
         case 'lint':
-            return applyLintFix(projectPath, details);
+            return applyLintFix(projectPath, details, timeoutMs);
         case 'tests':
-            return applyTestFix(projectPath, details);
+            return applyTestFix(projectPath, details, timeoutMs);
         case 'coverage':
             return applyCoverageFix(projectPath, details);
     }
@@ -47,8 +48,14 @@ export async function runHealingLoop(specId, projectPath, failureContext) {
     const fixedIssues = [];
     const remainingIssues = [];
     let healed = false;
+    const deadline = Date.now() + qaCheckTimeoutMs();
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-        const result = await runStrategy(strategy, projectPath, failureContext.details);
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+            remainingIssues.push(`Attempt ${attempt}: skipped — healing wall-clock budget exhausted`);
+            break;
+        }
+        const result = await runStrategy(strategy, projectPath, failureContext.details, remainingMs);
         if (result.fixed) {
             attempts.push({
                 strategy,

package/dist/engine/self-healing/strategies/lint-fix.d.ts

@@ -2,5 +2,5 @@ import type { StrategyResult } from '../../../types/index.js';
 /**
  * Runs eslint --fix on the project and reports what was fixed.
  */
-export declare function applyLintFix(projectPath: string, _details: string): Promise<StrategyResult>;
+export declare function applyLintFix(projectPath: string, _details: string, timeoutMs?: number): Promise<StrategyResult>;
 //# sourceMappingURL=lint-fix.d.ts.map