human-to-code 0.1.23 → 0.1.24

package/dist/agents/direct/integration-validation.js

@@ -1,225 +1,289 @@
 /**
- * Opt-in post-generation checks for relationships that a compiler cannot
- * validate. The first contract covers static-web entry documents: generated
- * HTML must reference conventional generated CSS/browser-JavaScript companions
- * in the same directory. Consistent groups issue no request; a detected gap
- * permits one bounded whole-file reconciliation and otherwise fails closed.
+ * Optional, bounded, cross-language integration auditing. ProjectMemory owns
+ * relationship discovery; this module is language-agnostic orchestration over
+ * generated paths, compact contracts, a strict JSON audit, target-scoped
+ * repairs, and one verification audit. No application/framework scenario is
+ * embedded here.
  */
 import { posix } from "node:path";
 import { ContextSecurityError, scanSecrets } from "../../context/context.js";
 import { validateGeneratedUnit } from "./candidate-validation.js";
+import { compactFileContract } from "./project-contracts.js";
 const DEFAULT_CONTEXT_CHAR_BUDGET = 48_000;
-const HTML_EXTENSIONS = new Set([".html", ".htm"]);
-const BROWSER_SCRIPT_EXTENSIONS = new Set([".js", ".mjs"]);
-const RAW_OR_INERT_HTML_ELEMENTS = new Set([
-    "iframe", "noembed", "noframes", "script", "style", "template", "textarea", "title", "xmp",
-]);
-const CONVENTIONAL_BROWSER_SCRIPT = /^(?:app|client|frontend|index|main|page|script|ui)(?:[.-].*)?\.(?:js|mjs)$/iu;
-const BROWSER_PURPOSE = /\b(?:browser|button|calculator|click|document|dom|event|form|html|page|screen|ui|window)\b/iu;
+const MAX_COMPONENT_FILES = 24;
+const MAX_NEIGHBORHOOD_FILES = 17;
+const MAX_CONTRACT_CHARS = 2_000;
+const MAX_PURPOSE_CHARS = 400;
+const MAX_AUDIT_ISSUES = 64;
+const MAX_ISSUE_MESSAGE_CHARS = 600;
 function targetPath(unit) {
     return unit.kind === "file" ? unit.outputPath : unit.sourcePath;
 }
-function extension(path) {
-    return posix.extname(path).toLowerCase();
+function oneLine(value, limit) {
+    const clean = value
+        .replace(/[\u0000-\u0008\u000b-\u001f\u007f]/gu, " ")
+        .replace(/\s+/gu, " ")
+        .trim();
+    return clean.length <= limit ? clean : `${clean.slice(0, Math.max(0, limit - 1))}…`;
 }
-function isWholeHtml(unit) {
-    return unit.kind === "file" && HTML_EXTENSIONS.has(extension(targetPath(unit)));
+function ownKeys(value, expected) {
+    const actual = Object.keys(value).sort();
+    return actual.length === expected.length && actual.every((key, index) => key === [...expected].sort()[index]);
 }
-function isStylesheetCompanion(unit) {
-    if (unit.kind !== "file" || extension(targetPath(unit)) !== ".css")
-        return false;
-    return !/(?:^|[.-])(?:module|spec|test)(?:[.-]|\.css$)/iu.test(posix.basename(targetPath(unit)));
+function object(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isBrowserScriptCompanion(unit) {
-    if (unit.kind !== "file" || !BROWSER_SCRIPT_EXTENSIONS.has(extension(targetPath(unit))))
-        return false;
-    const name = posix.basename(targetPath(unit));
-    if (/(?:^|[.-])(?:config|server|spec|test)(?:[.-]|\.(?:js|mjs)$)/iu.test(name))
-        return false;
-    return CONVENTIONAL_BROWSER_SCRIPT.test(name) || BROWSER_PURPOSE.test(unit.prompt);
-}
-function webIntegrationGroups(units) {
-    const files = units.filter((unit) => unit.kind === "file");
-    return files.filter(isWholeHtml).flatMap((html) => {
-        const directory = posix.dirname(targetPath(html));
-        const related = files.filter((unit) => unit !== html
-            && posix.dirname(targetPath(unit)) === directory
-            && (isStylesheetCompanion(unit) || isBrowserScriptCompanion(unit)));
-        return related.length > 0 ? [{ html, related }] : [];
-    });
-}
-/** Maximum integration requests disclosed before an opt-in run. */
-export function potentialIntegrationRequests(units) {
-    return webIntegrationGroups(units).length;
-}
-function requiredReference(from, to) {
-    return posix.relative(posix.dirname(from), to) || posix.basename(to);
-}
-function attribute(tag, name) {
-    const pattern = new RegExp(`(?:^|\\s)${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'=<>\u0060]+))`, "iu");
-    const match = pattern.exec(tag);
-    return match?.[1] ?? match?.[2] ?? match?.[3];
-}
-function resolveLocalReference(from, reference) {
-    const trimmed = reference.trim();
-    if (trimmed.length === 0 || trimmed.startsWith("#") || trimmed.startsWith("//"))
-        return undefined;
-    if (/^[a-z][a-z0-9+.-]*:/iu.test(trimmed))
-        return undefined;
-    const withoutSuffix = trimmed.split(/[?#]/u, 1)[0] ?? "";
-    let decoded;
+/** Strictly validate the model's audit JSON against the exact generated group. */
+export function parseIntegrationAuditOutput(output, allowedPaths) {
+    let parsed;
     try {
-        decoded = decodeURIComponent(withoutSuffix);
+        parsed = JSON.parse(output);
     }
     catch {
-        decoded = withoutSuffix;
+        throw new Error("Integration auditor returned invalid JSON.");
     }
-    const resolved = decoded.startsWith("/")
-        ? posix.normalize(decoded.slice(1))
-        : posix.normalize(posix.join(posix.dirname(from), decoded));
-    if (resolved === ".." || resolved.startsWith("../"))
-        return undefined;
-    return resolved.replace(/^\.\//u, "");
-}
-function tagEnd(html, start) {
-    let quote;
-    for (let index = start + 1; index < html.length; index += 1) {
-        const char = html[index];
-        if (quote !== undefined) {
-            if (char === quote)
-                quote = undefined;
+    if (!object(parsed) || !ownKeys(parsed, ["issues", "status"])) {
+        throw new Error("Integration audit must contain exactly status and issues.");
+    }
+    if (parsed.status !== "consistent" && parsed.status !== "issues") {
+        throw new Error("Integration audit status must be consistent or issues.");
+    }
+    if (!Array.isArray(parsed.issues) || parsed.issues.length > MAX_AUDIT_ISSUES) {
+        throw new Error(`Integration audit issues must be an array with at most ${MAX_AUDIT_ISSUES} entries.`);
+    }
+    const issues = parsed.issues.map((value, index) => {
+        if (!object(value) || !ownKeys(value, ["code", "message", "relatedPaths", "targetPath"])) {
+            throw new Error(`Integration audit issue ${index} has unknown or missing fields.`);
+        }
+        if (typeof value.targetPath !== "string" || !allowedPaths.has(value.targetPath)) {
+            throw new Error(`Integration audit issue ${index} names an unknown targetPath.`);
+        }
+        if (!Array.isArray(value.relatedPaths) || value.relatedPaths.length === 0 || value.relatedPaths.length > 16) {
+            throw new Error(`Integration audit issue ${index} must name 1-16 relatedPaths.`);
+        }
+        const relatedPaths = value.relatedPaths.map((path) => {
+            if (typeof path !== "string" || path === value.targetPath || !allowedPaths.has(path)) {
+                throw new Error(`Integration audit issue ${index} names an unknown related path.`);
+            }
+            return path;
+        });
+        if (new Set(relatedPaths).size !== relatedPaths.length) {
+            throw new Error(`Integration audit issue ${index} repeats a related path.`);
         }
-        else if (char === "\"" || char === "'") {
-            quote = char;
+        if (typeof value.code !== "string" || !/^[A-Z][A-Z0-9_]{1,63}$/u.test(value.code)) {
+            throw new Error(`Integration audit issue ${index} has an invalid code.`);
         }
-        else if (char === ">") {
-            return index;
+        if (typeof value.message !== "string") {
+            throw new Error(`Integration audit issue ${index} has an invalid message.`);
         }
+        const message = oneLine(value.message, MAX_ISSUE_MESSAGE_CHARS);
+        if (message.length === 0)
+            throw new Error(`Integration audit issue ${index} has an empty message.`);
+        return { targetPath: value.targetPath, relatedPaths, code: value.code, message };
+    });
+    if (parsed.status === "consistent" && issues.length !== 0 || parsed.status === "issues" && issues.length === 0) {
+        throw new Error("Integration audit status contradicts its issues array.");
     }
-    return html.length - 1;
+    return { status: parsed.status, issues };
 }
-/**
- * Extract active start tags without accepting examples inside HTML comments,
- * template contents, or JavaScript/CSS raw-text bodies as real references.
- */
-function htmlStartTags(html) {
-    const tags = [];
-    let offset = 0;
-    while (offset < html.length) {
-        const start = html.indexOf("<", offset);
-        if (start === -1)
-            break;
-        if (html.startsWith("<!--", start)) {
-            const end = html.indexOf("-->", start + 4);
-            offset = end === -1 ? html.length : end + 3;
-            continue;
+function relationshipGroups(generated, projectMemory) {
+    const wholeFiles = generated.filter((item) => item.unit.kind === "file");
+    const byPath = new Map(wholeFiles.map((item) => [targetPath(item.unit), item.unit]));
+    const adjacency = new Map([...byPath.keys()].map((path) => [path, new Set()]));
+    const relationships = new Map();
+    for (const { unit } of wholeFiles) {
+        const fromPath = targetPath(unit);
+        const evidenced = projectMemory?.relationsFor?.(unit) ?? [];
+        for (const relationship of evidenced) {
+            if (!byPath.has(relationship.path) || relationship.path === fromPath)
+                continue;
+            adjacency.get(fromPath).add(relationship.path);
+            adjacency.get(relationship.path).add(fromPath);
+            const entry = {
+                fromPath,
+                toPath: relationship.path,
+                role: oneLine(relationship.role, 240),
+                reference: oneLine(relationship.reference, 240),
+            };
+            relationships.set(`${entry.fromPath}\0${entry.toPath}`, entry);
         }
-        const end = tagEnd(html, start);
-        const source = html.slice(start, end + 1);
-        const match = /^<\s*([a-z][a-z0-9:-]*)\b/iu.exec(source);
-        if (!match) {
-            offset = end + 1;
+    }
+    const components = [];
+    const visited = new Set();
+    for (const start of [...byPath.keys()].sort()) {
+        if (visited.has(start) || adjacency.get(start).size === 0)
             continue;
+        const queue = [start];
+        const component = [];
+        visited.add(start);
+        while (queue.length > 0) {
+            const path = queue.shift();
+            component.push(path);
+            for (const next of adjacency.get(path) ?? []) {
+                if (visited.has(next))
+                    continue;
+                visited.add(next);
+                queue.push(next);
+            }
         }
-        const name = match[1].toLowerCase();
-        tags.push({ name, source });
-        if (RAW_OR_INERT_HTML_ELEMENTS.has(name) && !/\/\s*>$/u.test(source)) {
-            const closing = new RegExp(`<\\/\\s*${name}\\s*>`, "giu");
-            closing.lastIndex = end + 1;
-            const close = closing.exec(html);
-            offset = close === null ? html.length : close.index + close[0].length;
+        components.push(component.sort());
+    }
+    const pathGroups = [];
+    for (const component of components) {
+        if (component.length <= MAX_COMPONENT_FILES) {
+            pathGroups.push(component);
+            continue;
         }
-        else {
-            offset = end + 1;
+        const seen = new Set();
+        for (const focus of component) {
+            const neighborhood = [focus, ...[...(adjacency.get(focus) ?? [])].sort()]
+                .slice(0, MAX_NEIGHBORHOOD_FILES)
+                .sort();
+            const key = neighborhood.join("\0");
+            if (neighborhood.length < 2 || seen.has(key))
+                continue;
+            seen.add(key);
+            pathGroups.push(neighborhood);
         }
     }
-    return tags;
+    return pathGroups.map((paths) => {
+        const pathSet = new Set(paths);
+        const groupRelationships = [...relationships.values()]
+            .filter((entry) => pathSet.has(entry.fromPath) && pathSet.has(entry.toPath))
+            .sort((left, right) => left.fromPath.localeCompare(right.fromPath) || left.toPath.localeCompare(right.toPath));
+        return { units: paths.map((path) => byPath.get(path)), relationships: groupRelationships };
+    });
 }
-function hasStylesheetReference(htmlPath, tags, stylesheetPath) {
-    for (const tag of tags) {
-        if (tag.name !== "link")
-            continue;
-        const rel = attribute(tag.source, "rel")?.toLowerCase().split(/\s+/u) ?? [];
-        const href = attribute(tag.source, "href");
-        if (rel.includes("stylesheet") && href !== undefined && resolveLocalReference(htmlPath, href) === stylesheetPath)
-            return true;
-    }
-    return false;
+/** Conservative pre-run ceiling: two audits and one repair per whole-file unit. */
+export function potentialIntegrationRequests(units) {
+    const files = units.filter((unit) => unit.kind === "file").length;
+    return files < 2 ? { auditUpTo: 0, repairUpTo: 0 } : { auditUpTo: files * 2, repairUpTo: files };
 }
-function hasScriptReference(htmlPath, tags, scriptPath) {
-    for (const tag of tags) {
-        if (tag.name !== "script")
+function groupProjectMemory(group, projectMemory, budget) {
+    if (!projectMemory || budget < 160)
+        return undefined;
+    const perUnit = Math.max(160, Math.floor(budget / Math.max(1, group.units.length)));
+    const rendered = [];
+    let remaining = budget;
+    for (const unit of group.units) {
+        if (remaining < 160)
+            break;
+        const block = projectMemory.renderFor(unit, Math.min(perUnit, remaining));
+        if (block.length === 0 || rendered.includes(block))
             continue;
-        const source = attribute(tag.source, "src");
-        if (source !== undefined && resolveLocalReference(htmlPath, source) === scriptPath)
-            return true;
+        rendered.push(block);
+        remaining -= block.length;
     }
-    return false;
+    return rendered.length > 0 ? rendered.join("\n\n") : undefined;
 }
-/** Check one complete HTML candidate against its known generated companions. */
-export function findHtmlIntegrationIssues(htmlPath, html, relatedUnits) {
-    const issues = [];
-    const tags = htmlStartTags(html);
-    for (const unit of relatedUnits) {
-        const relatedPath = targetPath(unit);
-        const reference = requiredReference(htmlPath, relatedPath);
-        if (isStylesheetCompanion(unit) && !hasStylesheetReference(htmlPath, tags, relatedPath)) {
-            issues.push({
-                code: "MISSING_STYLESHEET_REFERENCE",
-                message: `${htmlPath} does not load its generated stylesheet companion ${relatedPath}.`,
-                relatedPath,
-                requiredReference: reference,
-            });
-        }
-        else if (isBrowserScriptCompanion(unit) && !hasScriptReference(htmlPath, tags, relatedPath)) {
-            issues.push({
-                code: "MISSING_BROWSER_SCRIPT_REFERENCE",
-                message: `${htmlPath} does not load its generated browser-script companion ${relatedPath}.`,
-                relatedPath,
-                requiredReference: reference,
-            });
-        }
+function buildAuditRequest(group, byUnit, contextCharBudget, projectMemory) {
+    const baseFiles = group.units.map((unit) => {
+        const item = byUnit.get(unit);
+        const path = targetPath(unit);
+        const contract = compactFileContract(path, item.code).slice(0, MAX_CONTRACT_CHARS);
+        return {
+            path,
+            language: unit.language ?? (posix.extname(path).replace(/^\./u, "") || "unknown"),
+            instruction: oneLine(unit.prompt, MAX_PURPOSE_CHARS),
+            contract,
+            code: item.code,
+        };
+    });
+    const fixedChars = baseFiles.reduce((total, file) => total + file.path.length + file.language.length + file.instruction.length + file.contract.length + 120, 0)
+        + group.relationships.reduce((total, relation) => total + relation.fromPath.length + relation.toPath.length + relation.role.length + relation.reference.length + 40, 0);
+    if (fixedChars > contextCharBudget)
+        return undefined;
+    let remaining = contextCharBudget - fixedChars;
+    const projectBlock = groupProjectMemory(group, projectMemory, Math.floor(remaining / 3));
+    remaining -= projectBlock?.length ?? 0;
+    const files = [];
+    for (const file of baseFiles) {
+        const content = file.code.length <= remaining ? file.code : undefined;
+        files.push({
+            path: file.path,
+            language: file.language,
+            instruction: file.instruction,
+            contract: file.contract,
+            ...(content !== undefined ? { content } : {}),
+        });
+        if (content !== undefined)
+            remaining -= content.length;
     }
-    return issues;
-}
-function describeIssues(issues) {
-    return issues.map((issue) => `${issue.code} (${issue.requiredReference})`).join(", ");
+    return {
+        unit: group.units[0],
+        units: [...group.units],
+        files,
+        relationships: [...group.relationships],
+        ...(projectBlock ? { projectMemory: projectBlock } : {}),
+    };
 }
-function buildIntegrationRequest(group, currentCode, issues, byUnit, contextCharBudget, projectMemory) {
-    const issueChars = issues.reduce((total, issue) => total + issue.message.length + issue.relatedPath.length + issue.requiredReference.length + 48, 0);
-    let budget = contextCharBudget - currentCode.length - issueChars;
-    if (budget < 0)
+function buildRepairRequest(unit, issues, byUnit, contextCharBudget, projectMemory) {
+    const item = byUnit.get(unit);
+    const issueChars = issues.reduce((total, issue) => total + issue.code.length + issue.message.length + issue.relatedPaths.join("").length + 48, 0);
+    let remaining = contextCharBudget - item.code.length - issueChars;
+    if (remaining < 0)
         return undefined;
-    const renderedProjectMemory = projectMemory?.renderFor(group.html, Math.floor(budget / 2));
-    budget -= renderedProjectMemory?.length ?? 0;
+    const projectBlock = projectMemory?.renderFor(unit, Math.floor(remaining / 3));
+    remaining -= projectBlock?.length ?? 0;
+    const relatedPaths = [...new Set(issues.flatMap((issue) => issue.relatedPaths))].sort();
     const relatedFiles = [];
-    for (const unit of group.related) {
-        const item = byUnit.get(unit);
-        if (!item || item.error !== undefined || item.code.length > budget)
+    for (const path of relatedPaths) {
+        const related = [...byUnit.values()].find((entry) => targetPath(entry.unit) === path);
+        if (!related || related.code.length > remaining)
             continue;
-        relatedFiles.push({ path: targetPath(unit), content: item.code });
-        budget -= item.code.length;
+        relatedFiles.push({ path, content: related.code });
+        remaining -= related.code.length;
     }
     return {
-        unit: group.html,
-        targetPath: targetPath(group.html),
-        instruction: group.html.prompt,
-        currentCode,
+        unit,
+        targetPath: targetPath(unit),
+        instruction: unit.prompt,
+        currentCode: item.code,
         issues,
         relatedFiles,
-        ...(renderedProjectMemory ? { projectMemory: renderedProjectMemory } : {}),
+        ...(projectBlock ? { projectMemory: projectBlock } : {}),
     };
 }
-/** Run opt-in integration checks and bounded repair over generated candidates. */
+function auditOutbound(request) {
+    return [
+        request.projectMemory ?? "",
+        ...request.files.flatMap((file) => [file.path, file.language, file.instruction, file.contract, file.content ?? ""]),
+        ...request.relationships.flatMap((relationship) => [
+            relationship.fromPath,
+            relationship.toPath,
+            relationship.role,
+            relationship.reference,
+        ]),
+    ].join("\n");
+}
+function repairOutbound(request) {
+    return [
+        request.targetPath,
+        request.instruction,
+        request.currentCode,
+        request.projectMemory ?? "",
+        ...request.issues.flatMap((issue) => [
+            issue.targetPath,
+            ...issue.relatedPaths,
+            issue.code,
+            issue.message,
+        ]),
+        ...request.relatedFiles.flatMap((file) => [file.path, file.content]),
+    ].join("\n");
+}
+/** Audit, repair, and verify generated relationship groups without writing. */
 export async function reconcileGeneratedIntegrations(generated, options = {}) {
     const results = generated.map((item) => ({ ...item }));
     const byUnit = new Map(results.map((item) => [item.unit, item]));
-    const groups = webIntegrationGroups(results.map((item) => item.unit));
-    const maxAttempts = Math.max(0, options.maxIntegrationAttemptsPerUnit ?? 1);
+    const groups = relationshipGroups(results, options.projectMemory);
+    const maxAuditPasses = Math.max(1, Math.min(2, options.maxAuditPassesPerGroup ?? 2));
+    const maxRepairs = Math.max(0, options.maxRepairAttemptsPerUnit ?? 1);
     const contextCharBudget = Math.max(0, options.contextCharBudget ?? DEFAULT_CONTEXT_CHAR_BUDGET);
-    let integrationRequests = 0;
+    const repairedUnits = new Set();
+    let auditRequests = 0;
+    let repairRequests = 0;
     const rejectGroup = (group, reason) => {
-        for (const unit of [group.html, ...group.related]) {
+        for (const unit of group.units) {
             const item = byUnit.get(unit);
             if (!item || item.error !== undefined)
                 continue;
@@ -229,56 +293,90 @@ export async function reconcileGeneratedIntegrations(generated, options = {}) {
         }
     };
     for (const group of groups) {
-        const groupItems = [group.html, ...group.related].map((unit) => byUnit.get(unit));
-        const unavailable = groupItems.filter((item) => item.error !== undefined || item.code.trim().length === 0);
+        const unavailable = group.units.map((unit) => byUnit.get(unit))
+            .filter((item) => item.error !== undefined || item.code.trim().length === 0);
         if (unavailable.length > 0) {
             rejectGroup(group, `cross-file integration group is incomplete because ${unavailable.map((item) => item.unit.sourcePath).join(", ")} did not produce an applicable candidate`);
             continue;
         }
-        const htmlItem = byUnit.get(group.html);
-        let issues = findHtmlIntegrationIssues(targetPath(group.html), htmlItem.code, group.related);
-        options.onProgress?.({ kind: "integration-check", unit: group.html, issues: issues.length });
-        if (issues.length === 0)
+        if (!options.audit)
             continue;
-        if (!options.integrate || maxAttempts === 0) {
-            rejectGroup(group, `cross-file integration validation failed: ${describeIssues(issues)}`);
+        const runAudit = async (pass) => {
+            const request = buildAuditRequest(group, byUnit, contextCharBudget, options.projectMemory);
+            if (!request || scanSecrets(auditOutbound(request)).length > 0)
+                return undefined;
+            options.onProgress?.({ kind: "integration-audit", unit: request.unit, pass, files: request.files.length });
+            auditRequests += 1;
+            try {
+                return parseIntegrationAuditOutput(await options.audit(request), new Set(group.units.map(targetPath)));
+            }
+            catch (error) {
+                if (error instanceof ContextSecurityError)
+                    throw error;
+                return undefined;
+            }
+        };
+        const initial = await runAudit(1);
+        if (!initial) {
+            rejectGroup(group, "cross-file integration audit failed or exceeded its safe bounded context");
+            continue;
+        }
+        if (initial.status === "consistent")
+            continue;
+        if (!options.repair || maxRepairs === 0) {
+            rejectGroup(group, `cross-file integration audit reported ${initial.issues.length} unresolved issue(s)`);
             continue;
         }
-        let reconciled = false;
-        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-            const request = buildIntegrationRequest(group, htmlItem.code, issues, byUnit, contextCharBudget, options.projectMemory);
-            if (!request)
+        let repaired = true;
+        const byTarget = new Map();
+        for (const issue of initial.issues)
+            byTarget.set(issue.targetPath, [...(byTarget.get(issue.targetPath) ?? []), issue]);
+        for (const [path, issues] of byTarget) {
+            const unit = group.units.find((candidate) => targetPath(candidate) === path);
+            if (repairedUnits.has(unit)) {
+                repaired = false;
                 break;
-            const outbound = [request.currentCode, request.projectMemory ?? "", ...request.relatedFiles.map((file) => file.content)].join("\n");
-            if (scanSecrets(outbound).length > 0)
+            }
+            const request = buildRepairRequest(unit, issues, byUnit, contextCharBudget, options.projectMemory);
+            if (!request || scanSecrets(repairOutbound(request)).length > 0) {
+                repaired = false;
                 break;
-            options.onProgress?.({ kind: "integrate", unit: group.html, attempt, issues: issues.length });
-            integrationRequests += 1;
+            }
+            options.onProgress?.({ kind: "integration-repair", unit, attempt: 1, issues: issues.length });
+            repairRequests += 1;
+            repairedUnits.add(unit);
             try {
-                const integratedCode = await options.integrate(request);
-                if (integratedCode.trim().length === 0 || integratedCode === htmlItem.code)
-                    continue;
-                await validateGeneratedUnit(group.html, integratedCode);
-                const remaining = findHtmlIntegrationIssues(targetPath(group.html), integratedCode, group.related);
-                if (remaining.length > 0) {
-                    issues = remaining;
-                    continue;
+                const code = await options.repair(request);
+                if (code.trim().length === 0 || code === byUnit.get(unit).code) {
+                    repaired = false;
+                    break;
                 }
-                htmlItem.code = integratedCode;
-                options.projectMemory?.remember(group.html, integratedCode);
-                reconciled = true;
-                break;
+                await validateGeneratedUnit(unit, code);
+                byUnit.get(unit).code = code;
+                options.projectMemory?.remember(unit, code);
             }
             catch (error) {
                 if (error instanceof ContextSecurityError)
                     throw error;
-                // The request budget is consumed. A known-broken connected group is
-                // rejected below instead of being written partially.
+                repaired = false;
+                break;
             }
         }
-        if (!reconciled)
-            rejectGroup(group, `cross-file integration validation failed after bounded reconciliation: ${describeIssues(issues)}`);
+        if (!repaired) {
+            rejectGroup(group, "cross-file integration repair failed within its bounded target budget");
+            continue;
+        }
+        if (maxAuditPasses < 2)
+            continue;
+        const verified = await runAudit(2);
+        if (!verified || verified.status !== "consistent") {
+            rejectGroup(group, "cross-file integration remained inconsistent after bounded repair and verification");
+        }
     }
-    return { results, integrationRequests, checkedTargets: groups.length };
+    return { results, auditRequests, repairRequests, checkedGroups: groups.length };
+}
+/** Helper for tests and alternative ProjectMemory implementations. */
+export function generatedRelationshipsFor(unit, projectMemory) {
+    return projectMemory.relationsFor?.(unit) ?? [];
 }
 //# sourceMappingURL=integration-validation.js.map