@kaelio/ktx 0.11.0 → 0.12.0

package/dist/context/ingest/final-gate-repair.d.ts

@@ -1,16 +1,8 @@
 import type { AgentRunnerPort } from '../../context/llm/runtime-port.js';
-import type { TouchedSlSource } from '../../context/tools/touched-sl-sources.js';
+import type { ConstrainedRepairResult, RepairVerification } from './constrained-repair.js';
 import type { IngestTraceWriter } from './ingest-trace.js';
 type FinalGateRepairKind = 'patch_semantic_gate' | 'final_artifact_gate';
-export type FinalGateRepairResult = {
-    status: 'repaired';
-    attempts: number;
-    changedPaths: string[];
-} | {
-    status: 'failed';
-    attempts: number;
-    reason: string;
-};
+export type FinalGateRepairResult = ConstrainedRepairResult;
 export interface RepairFinalGateFailureInput {
     agentRunner: AgentRunnerPort;
     workdir: string;
@@ -18,13 +10,19 @@ export interface RepairFinalGateFailureInput {
     allowedPaths: string[];
     trace: IngestTraceWriter;
     repairKind: FinalGateRepairKind;
+    /**
+     * Re-runs the failed gate against the current worktree. The repair counts
+     * as successful only when this passes — editing files is not the success
+     * signal.
+     */
+    verify(changedPaths: string[]): Promise<RepairVerification>;
     maxAttempts?: number;
     stepBudget?: number;
     abortSignal?: AbortSignal;
 }
 export declare function finalGateRepairPaths(input: {
     changedWikiPageKeys: string[];
-    touchedSlSources: TouchedSlSource[];
+    touchedSlSourcePaths: string[];
 }): string[];
 export declare function repairFinalGateFailure(input: RepairFinalGateFailureInput): Promise<FinalGateRepairResult>;
 export {};

package/dist/context/ingest/final-gate-repair.js

@@ -1,43 +1,8 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
 import { z } from 'zod';
-import { traceTimed } from './ingest-trace.js';
-const readRepairFileSchema = z.object({
-    path: z.string().min(1),
-});
-const writeRepairFileSchema = z.object({
-    path: z.string().min(1),
-    content: z.string(),
-});
-function normalizeRepoPath(path) {
-    const normalized = path.replace(/\\/g, '/').replace(/^\/+/, '');
-    const parts = normalized.split('/').filter((part) => part.length > 0);
-    if (parts.length === 0 || parts.some((part) => part === '.' || part === '..')) {
-        throw new Error(`gate repair path must be a repository-relative path: ${path}`);
-    }
-    return parts.join('/');
-}
-function assertAllowedPath(path, allowedPaths) {
-    const normalized = normalizeRepoPath(path);
-    if (!allowedPaths.has(normalized)) {
-        throw new Error(`gate repair path not allowed: ${normalized}`);
-    }
-    return normalized;
-}
-async function readOptionalFile(path) {
-    try {
-        return { exists: true, content: await readFile(path, 'utf-8') };
-    }
-    catch (error) {
-        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
-            return { exists: false, content: '' };
-        }
-        throw error;
-    }
-}
+import { runConstrainedRepairLoop } from './constrained-repair.js';
 function buildGateRepairSystemPrompt() {
     return `<role>
-You repair one KTX isolated-diff artifact gate failure inside the integration worktree.
+You repair one ktx isolated-diff artifact gate failure inside the integration worktree.
 </role>
 
 <rules>
@@ -51,6 +16,9 @@ You repair one KTX isolated-diff artifact gate failure inside the integration wo
 </rules>`;
 }
 function buildGateRepairUserPrompt(input) {
+    const previousFailureBlock = input.previousFailure
+        ? `\nPrevious attempt did not pass the gate:\n${input.previousFailure}\n`
+        : '';
     return `Repair isolated-diff artifact gates.
 
 Repair kind: ${input.repairKind}
@@ -61,119 +29,63 @@ ${input.allowedPaths.map((path) => `- ${path}`).join('\n')}
 
 Gate error:
 ${input.gateError}
-
+${previousFailureBlock}
 Use read_gate_error first. Then inspect only the allowed files, write the
 minimal repaired content, and stop.`;
 }
-function buildToolSet(input) {
+function buildReadGateErrorTool(gateError) {
     return {
         read_gate_error: {
             name: 'read_gate_error',
             description: 'Read the artifact gate failure that must be repaired.',
             inputSchema: z.object({}),
             execute: async () => ({
-                markdown: input.gateError,
-                structured: { gateError: input.gateError },
+                markdown: gateError,
+                structured: { gateError },
             }),
         },
-        read_repair_file: {
-            name: 'read_repair_file',
-            description: 'Read one allowed file from the integration worktree.',
-            inputSchema: readRepairFileSchema,
-            execute: async ({ path }) => {
-                const normalized = assertAllowedPath(path, input.allowedPaths);
-                const file = await readOptionalFile(join(input.workdir, normalized));
-                return {
-                    markdown: file.exists ? file.content : `(missing file: ${normalized})`,
-                    structured: { path: normalized, exists: file.exists },
-                };
-            },
-        },
-        write_repair_file: {
-            name: 'write_repair_file',
-            description: 'Replace one allowed integration worktree file with repaired text content.',
-            inputSchema: writeRepairFileSchema,
-            execute: async ({ path, content }) => {
-                const normalized = assertAllowedPath(path, input.allowedPaths);
-                const fullPath = join(input.workdir, normalized);
-                await mkdir(dirname(fullPath), { recursive: true });
-                await writeFile(fullPath, content, 'utf-8');
-                input.editedPaths.add(normalized);
-                return {
-                    markdown: `Wrote ${normalized}`,
-                    structured: { path: normalized, bytes: Buffer.byteLength(content) },
-                };
-            },
-        },
     };
 }
 export function finalGateRepairPaths(input) {
     return [
         ...new Set([
-            ...input.touchedSlSources.map((source) => `semantic-layer/${source.connectionId}/${source.sourceName}.yaml`),
+            ...input.touchedSlSourcePaths,
             ...input.changedWikiPageKeys.map((pageKey) => `wiki/global/${pageKey}.md`),
         ]),
     ].sort();
 }
 export async function repairFinalGateFailure(input) {
-    const allowedPaths = new Set(input.allowedPaths.map(normalizeRepoPath));
-    const maxAttempts = input.maxAttempts ?? 1;
-    const stepBudget = input.stepBudget ?? 16;
-    let lastFailure = 'gate repair did not run';
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const editedPaths = new Set();
-        const sortedAllowedPaths = [...allowedPaths].sort();
-        const traceData = {
+    return runConstrainedRepairLoop({
+        agentRunner: input.agentRunner,
+        workdir: input.workdir,
+        allowedPaths: input.allowedPaths,
+        trace: input.trace,
+        tracePhase: 'gate_repair',
+        traceEventName: 'gate_repair',
+        traceData: {
+            repairKind: input.repairKind,
+            gateError: input.gateError,
+        },
+        systemPrompt: buildGateRepairSystemPrompt(),
+        buildUserPrompt: ({ attempt, maxAttempts, previousFailure }) => buildGateRepairUserPrompt({
+            gateError: input.gateError,
+            allowedPaths: [...input.allowedPaths].sort(),
             repairKind: input.repairKind,
             attempt,
             maxAttempts,
-            allowedPaths: sortedAllowedPaths,
-            gateError: input.gateError,
-        };
-        const result = await traceTimed(input.trace, 'gate_repair', 'gate_repair', traceData, async () => input.agentRunner.runLoop({
-            modelRole: 'repair',
-            systemPrompt: buildGateRepairSystemPrompt(),
-            userPrompt: buildGateRepairUserPrompt({
-                gateError: input.gateError,
-                allowedPaths: sortedAllowedPaths,
-                repairKind: input.repairKind,
-                attempt,
-                maxAttempts,
-            }),
-            toolSet: buildToolSet({
-                workdir: input.workdir,
-                gateError: input.gateError,
-                allowedPaths,
-                editedPaths,
-            }),
-            stepBudget,
-            telemetryTags: {
-                operationName: 'ingest-isolated-diff-gate-repair',
-                source: input.trace.context.sourceKey,
-                jobId: input.trace.context.jobId,
-                repairKind: input.repairKind,
-            },
-            abortSignal: input.abortSignal,
-        }));
-        if (result.stopReason === 'error') {
-            lastFailure = result.error?.message ?? 'gate repair agent loop errored';
-            await input.trace.event('error', 'gate_repair', 'gate_repair_failed', traceData, result.error);
-            continue;
-        }
-        const changedPaths = [...editedPaths].sort();
-        if (changedPaths.length === 0) {
-            lastFailure = 'gate repair completed without editing an allowed path';
-            await input.trace.event('error', 'gate_repair', 'gate_repair_failed', {
-                ...traceData,
-                reason: lastFailure,
-            });
-            continue;
-        }
-        await input.trace.event('debug', 'gate_repair', 'gate_repair_repaired', {
-            ...traceData,
-            changedPaths,
-        });
-        return { status: 'repaired', attempts: attempt, changedPaths };
-    }
-    return { status: 'failed', attempts: maxAttempts, reason: lastFailure };
+            previousFailure,
+        }),
+        buildExtraTools: () => buildReadGateErrorTool(input.gateError),
+        verify: input.verify,
+        noChangeFailureReason: 'gate repair completed without editing an allowed path',
+        telemetryTags: {
+            operationName: 'ingest-isolated-diff-gate-repair',
+            source: input.trace.context.sourceKey,
+            jobId: input.trace.context.jobId,
+            repairKind: input.repairKind,
+        },
+        maxAttempts: input.maxAttempts,
+        stepBudget: input.stepBudget ?? 16,
+        abortSignal: input.abortSignal,
+    });
 }

package/dist/context/ingest/finalization-scope.d.ts

@@ -17,6 +17,6 @@ interface CompareFinalizationDeclarationsInput {
     derivedChangedWikiPageKeys: string[];
 }
 export declare function deriveFinalizationWikiPageKeys(paths: string[]): string[];
-export declare function deriveFinalizationTouchedSources(input: DeriveTouchedSourcesInput): Promise<DeriveTouchedSourcesResult>;
+export declare function deriveFinalizationTouchedSources(input: DeriveTouchedSourcesInput): DeriveTouchedSourcesResult;
 export declare function compareFinalizationDeclarations(input: CompareFinalizationDeclarationsInput): IngestReportFinalizationMismatch[];
 export {};

package/dist/context/ingest/finalization-scope.js

@@ -1,3 +1,4 @@
+import { isSlYamlPath } from '../../context/sl/source-files.js';
 function uniqueSorted(values) {
     return [...new Set(values.filter((value) => value.length > 0))].sort();
 }
@@ -28,32 +29,31 @@ export function deriveFinalizationWikiPageKeys(paths) {
         .filter((path) => !path.slice('wiki/global/'.length, -'.md'.length).includes('/'))
         .map((path) => path.slice('wiki/global/'.length, -'.md'.length)));
 }
-export async function deriveFinalizationTouchedSources(input) {
+// Source identity is the in-file `name:`; filenames are derived labels (see
+// source-files.ts), so a changed path — manifest shard or standalone file —
+// cannot be mapped to a source by parsing its filename. Instead, every changed
+// semantic-layer file is attributed through the before/after diff of its
+// connection's composed sources. A changed file whose connection diff is empty
+// cannot be attributed to any source and is surfaced as unresolved.
+export function deriveFinalizationTouchedSources(input) {
     const touched = new Map();
     const unresolvedPaths = [];
+    const pathsByConnection = new Map();
     for (const path of input.changedPaths) {
-        if (!path.startsWith('semantic-layer/') || !(path.endsWith('.yaml') || path.endsWith('.yml'))) {
+        if (!path.startsWith('semantic-layer/') || !isSlYamlPath(path)) {
             continue;
         }
-        const parts = path.split('/');
-        const connectionId = parts[1] ?? '';
+        const connectionId = path.split('/')[1] ?? '';
         if (!connectionId) {
             unresolvedPaths.push(path);
             continue;
         }
-        if (parts[2] !== '_schema') {
-            const fileName = parts.at(-1) ?? '';
-            const sourceName = fileName.replace(/\.ya?ml$/, '');
-            if (!sourceName) {
-                unresolvedPaths.push(path);
-                continue;
-            }
-            touched.set(`${connectionId}:${sourceName}`, { connectionId, sourceName });
-            continue;
-        }
+        pathsByConnection.set(connectionId, [...(pathsByConnection.get(connectionId) ?? []), path]);
+    }
+    for (const [connectionId, paths] of pathsByConnection) {
         const changedNames = changedSourceNames(input.beforeSourcesByConnection.get(connectionId) ?? [], input.afterSourcesByConnection.get(connectionId) ?? []);
         if (changedNames.length === 0) {
-            unresolvedPaths.push(path);
+            unresolvedPaths.push(...paths);
             continue;
         }
         for (const sourceName of changedNames) {

package/dist/context/ingest/ingest-bundle.runner.d.ts

@@ -55,6 +55,7 @@ export declare class IngestBundleRunner {
     private provenanceValidationTraceData;
     private wikiPageKeysFromPaths;
     private touchedSlSourcesFromPaths;
+    private touchedSlSourcePaths;
     private touchedSlSourcesFromActions;
     private wikiPageKeysFromActions;
     private uniqueWikiPageKeys;

package/dist/context/ingest/ingest-bundle.runner.js

@@ -4,6 +4,7 @@ import pLimit from 'p-limit';
 import { z } from 'zod';
 import { noopLogger } from '../../context/core/config.js';
 import { createRuntimeToolDescriptorFromAiTool } from '../../context/llm/runtime-tools.js';
+import { isSlYamlPath, slSourceFilePath, slSourceNameForFile, sourceNameFromPath } from '../../context/sl/source-files.js';
 import { createTouchedSlSources } from '../../context/tools/touched-sl-sources.js';
 import { findDanglingWikiRefsForActions } from '../wiki/wiki-ref-validation.js';
 import { actionTargetConnectionId } from './action-identity.js';
@@ -351,7 +352,7 @@ export class IngestBundleRunner {
                     const files = await this.deps.semanticLayerService.listFilesForConnection(connectionId);
                     const names = files
                         .filter((f) => !f.startsWith('_schema/'))
-                        .map((f) => f.replace(/\.yaml$/, ''))
+                        .map((f) => sourceNameFromPath(f))
                         .sort((left, right) => left.localeCompare(right));
                     const body = names.length > 0 ? names.join('\n') : '(no sources yet)';
                     return `## ${connectionId}\n${body}`;
@@ -584,14 +585,48 @@ export class IngestBundleRunner {
                 .map((path) => path.slice('wiki/global/'.length, -'.md'.length))),
         ].sort();
     }
-    touchedSlSourcesFromPaths(paths) {
-        return paths
-            .filter((path) => path.startsWith('semantic-layer/') && path.endsWith('.yaml') && !path.includes('/_schema/'))
-            .map((path) => {
-            const [, connectionId, fileName] = path.split('/');
-            return { connectionId: connectionId ?? '', sourceName: (fileName ?? '').replace(/\.yaml$/, '') };
-        })
-            .filter((source) => source.connectionId.length > 0 && source.sourceName.length > 0);
+    async touchedSlSourcesFromPaths(worktree, paths, deletedFileSha) {
+        const sources = [];
+        for (const path of paths) {
+            if (!path.startsWith('semantic-layer/') || !isSlYamlPath(path) || path.includes('/_schema/')) {
+                continue;
+            }
+            const [, connectionId] = path.split('/');
+            if (!connectionId) {
+                continue;
+            }
+            // Source identity is the in-file `name:`, never the filename — an uppercase
+            // warehouse source like `WIDGET_SALES` lives in a hash-derived
+            // `widget_sales-<hash>.yaml`, so parsing the basename yields a phantom name.
+            // Read the live file; when it was deleted this run, recover its declared
+            // name from the pre-change commit the way `revertSourceToPreHead` resolves a
+            // gone file from history. The filename is a last resort only when the content
+            // is unrecoverable from both.
+            let content;
+            try {
+                content = await readFile(join(worktree.workdir, path), 'utf-8');
+            }
+            catch {
+                content = await worktree.git.getFileAtCommit(path, deletedFileSha).catch(() => null);
+            }
+            const sourceName = content === null ? sourceNameFromPath(path) : slSourceNameForFile(path, content);
+            if (sourceName.length > 0) {
+                sources.push({ connectionId, sourceName });
+            }
+        }
+        return sources;
+    }
+    // Inverse direction for commits and repair allowlists: resolve each touched
+    // source to its real on-disk path, falling back to the writer's derived
+    // filename when the file was deleted in this run.
+    async touchedSlSourcePaths(workdir, touched) {
+        const service = this.deps.semanticLayerService.forWorktree(workdir);
+        const paths = [];
+        for (const source of touched) {
+            const file = await service.readSourceFile(source.connectionId, source.sourceName);
+            paths.push(file?.path ?? slSourceFilePath(source.connectionId, source.sourceName));
+        }
+        return paths;
     }
     touchedSlSourcesFromActions(actions, fallbackConnectionId) {
         return actions
@@ -1153,7 +1188,7 @@ export class IngestBundleRunner {
                         projectionTouchedSources = projection.touchedSources;
                         projectionChangedWikiPageKeys = projection.changedWikiPageKeys;
                         const projectionPaths = [
-                            ...projection.touchedSources.map((source) => `semantic-layer/${source.connectionId}/${source.sourceName}.yaml`),
+                            ...(await this.touchedSlSourcePaths(sessionWorktree.workdir, projection.touchedSources)),
                             ...projection.changedWikiPageKeys.map((pageKey) => `wiki/global/${pageKey}.md`),
                         ];
                         projectionTouchedPaths = projectionPaths;
@@ -1297,7 +1332,7 @@ export class IngestBundleRunner {
                                 await validateFinalIngestArtifacts({
                                     connectionIds: slConnectionIds,
                                     changedWikiPageKeys: this.wikiPageKeysFromPaths(touchedPaths),
-                                    touchedSlSources: this.touchedSlSourcesFromPaths(touchedPaths),
+                                    touchedSlSources: await this.touchedSlSourcesFromPaths(sessionWorktree, touchedPaths, await sessionWorktree.git.revParseHead()),
                                     wikiService: this.deps.wikiService.forWorktree(sessionWorktree.workdir),
                                     semanticLayerService: this.deps.semanticLayerService.forWorktree(sessionWorktree.workdir),
                                     validateTouchedSources: (touched) => validateWuTouchedSources({
@@ -1322,7 +1357,8 @@ export class IngestBundleRunner {
                                     touchedPaths: context.touchedPaths,
                                     trace: runTrace,
                                     reason: context.reason,
-                                    maxAttempts: 1,
+                                    verify: context.verify,
+                                    maxAttempts: 2,
                                     stepBudget: 12,
                                     abortSignal: ctx?.abortSignal,
                                 });
@@ -1340,7 +1376,8 @@ export class IngestBundleRunner {
                                     allowedPaths: context.touchedPaths,
                                     trace: runTrace,
                                     repairKind: 'patch_semantic_gate',
-                                    maxAttempts: 1,
+                                    verify: context.verify,
+                                    maxAttempts: 2,
                                     stepBudget: 16,
                                     abortSignal: ctx?.abortSignal,
                                 });
@@ -1748,17 +1785,24 @@ export class IngestBundleRunner {
                         preFinalizationSha !== postFinalizationSha
                             ? (await sessionWorktree.git.diffNameStatus(preFinalizationSha, postFinalizationSha)).map((entry) => entry.path)
                             : [];
-                    const changedConnectionIds = [
-                        ...new Set([
-                            ...slConnectionIds,
-                            ...finalizationTouchedPaths
-                                .filter((path) => path.startsWith('semantic-layer/'))
-                                .map((path) => path.split('/')[1])
-                                .filter((connectionId) => Boolean(connectionId)),
-                        ]),
-                    ].sort();
-                    const postFinalizationSourcesByConnection = await this.loadSourcesByConnection(sessionWorktree.workdir, changedConnectionIds);
-                    const scope = await deriveFinalizationTouchedSources({
+                    // Validate the write scope before deriving touched sources: attribution
+                    // by before/after diff is only defined for connections whose
+                    // pre-finalization snapshot was loaded (slConnectionIds), and an
+                    // out-of-scope write would otherwise surface downstream as a bogus
+                    // unresolved-path or declaration-mismatch failure instead of the real
+                    // policy violation.
+                    await traceTimed(runTrace, 'finalization', 'semantic_layer_target_policy', {
+                        sourceKey: job.sourceKey,
+                        allowedTargetConnectionIds: slConnectionIds,
+                        touchedPaths: [...new Set(finalizationTouchedPaths)].sort(),
+                    }, async () => {
+                        assertSemanticLayerTargetPathsAllowed({
+                            paths: finalizationTouchedPaths,
+                            allowedConnectionIds: new Set(slConnectionIds),
+                        });
+                    });
+                    const postFinalizationSourcesByConnection = await this.loadSourcesByConnection(sessionWorktree.workdir, slConnectionIds);
+                    const scope = deriveFinalizationTouchedSources({
                         changedPaths: finalizationTouchedPaths,
                         beforeSourcesByConnection: preFinalizationSourcesByConnection,
                         afterSourcesByConnection: postFinalizationSourcesByConnection,
@@ -1876,7 +1920,7 @@ export class IngestBundleRunner {
                     ...(isolatedDiffEnabled ? projectionTouchedSources : []),
                     ...workUnitOutcomes.flatMap((outcome) => outcome.touchedSlSources),
                     ...this.touchedSlSourcesFromActions(reconcileActions, job.connectionId),
-                    ...this.touchedSlSourcesFromPaths(postReconciliationPaths),
+                    ...(await this.touchedSlSourcesFromPaths(sessionWorktree, postReconciliationPaths, preReconciliationSha)),
                     ...finalizationTouchedSources,
                 ]);
                 const finalWikiGateScope = await this.wikiPageKeysForFinalGates({
@@ -1926,32 +1970,33 @@ export class IngestBundleRunner {
                 activePhase = 'final_gates';
                 activeFailureDetails = finalArtifactGateTraceData;
                 emitStageProgress('final_gates', 89, 'Running final artifact gates');
-                try {
-                    await traceTimed(runTrace, 'final_gates', 'final_artifact_gates', finalArtifactGateTraceData, async () => {
-                        await validateFinalIngestArtifacts({
-                            connectionIds: repairConnectionIds,
-                            changedWikiPageKeys: finalChangedWikiPageKeys,
-                            touchedSlSources: finalTouchedSlSources,
-                            wikiService: this.deps.wikiService.forWorktree(sessionWorktree.workdir),
+                const runFinalArtifactGates = async () => {
+                    await validateFinalIngestArtifacts({
+                        connectionIds: repairConnectionIds,
+                        changedWikiPageKeys: finalChangedWikiPageKeys,
+                        touchedSlSources: finalTouchedSlSources,
+                        wikiService: this.deps.wikiService.forWorktree(sessionWorktree.workdir),
+                        semanticLayerService: this.deps.semanticLayerService.forWorktree(sessionWorktree.workdir),
+                        validateTouchedSources: (touched) => validateWuTouchedSources({
                             semanticLayerService: this.deps.semanticLayerService.forWorktree(sessionWorktree.workdir),
-                            validateTouchedSources: (touched) => validateWuTouchedSources({
-                                semanticLayerService: this.deps.semanticLayerService.forWorktree(sessionWorktree.workdir),
-                                connections: this.deps.connections,
-                                configService: sessionWorktree.config,
-                                gitService: sessionWorktree.git,
-                                slSourcesRepository: this.deps.slSourcesRepository,
-                                probeRowCount: this.deps.settings.probeRowCount,
-                                slValidator: this.deps.slValidator,
-                            }, touched),
-                            tableExists: (connectionId, tableRef) => this.tableRefExistsInSemanticLayer(this.deps.semanticLayerService.forWorktree(sessionWorktree.workdir), [connectionId], tableRef),
-                        });
+                            connections: this.deps.connections,
+                            configService: sessionWorktree.config,
+                            gitService: sessionWorktree.git,
+                            slSourcesRepository: this.deps.slSourcesRepository,
+                            probeRowCount: this.deps.settings.probeRowCount,
+                            slValidator: this.deps.slValidator,
+                        }, touched),
+                        tableExists: (connectionId, tableRef) => this.tableRefExistsInSemanticLayer(this.deps.semanticLayerService.forWorktree(sessionWorktree.workdir), [connectionId], tableRef),
                     });
+                };
+                try {
+                    await traceTimed(runTrace, 'final_gates', 'final_artifact_gates', finalArtifactGateTraceData, runFinalArtifactGates);
                 }
                 catch (error) {
                     const gateError = this.errorMessage(error);
                     const repairPaths = finalGateRepairPaths({
                         changedWikiPageKeys: finalChangedWikiPageKeys,
-                        touchedSlSources: finalTouchedSlSources,
+                        touchedSlSourcePaths: await this.touchedSlSourcePaths(sessionWorktree.workdir, finalTouchedSlSources),
                     });
                     emitStageProgress('final_gates', 89, 'Repairing final artifact gates');
                     const gateRepair = await repairFinalGateFailure({
@@ -1961,7 +2006,16 @@ export class IngestBundleRunner {
                         allowedPaths: repairPaths,
                         trace: runTrace,
                         repairKind: 'final_artifact_gate',
-                        maxAttempts: 1,
+                        verify: async () => {
+                            try {
+                                await runFinalArtifactGates();
+                                return { ok: true };
+                            }
+                            catch (verifyError) {
+                                return { ok: false, reason: this.errorMessage(verifyError) };
+                            }
+                        },
+                        maxAttempts: 2,
                         stepBudget: 16,
                         abortSignal: ctx?.abortSignal,
                     });
@@ -1975,29 +2029,9 @@ export class IngestBundleRunner {
                         };
                         throw new Error(`${gateError}\ngate repair failed: ${gateRepair.reason}`);
                     }
+                    // The repair loop re-ran the gates via `verify` before reporting
+                    // success, so a repaired status here means the tree already passed.
                     isolatedDiffSummary.gateRepairs += 1;
-                    await traceTimed(runTrace, 'final_gates', 'final_artifact_gates_after_gate_repair', {
-                        ...finalArtifactGateTraceData,
-                        repairedPaths: gateRepair.changedPaths,
-                    }, async () => {
-                        await validateFinalIngestArtifacts({
-                            connectionIds: repairConnectionIds,
-                            changedWikiPageKeys: finalChangedWikiPageKeys,
-                            touchedSlSources: finalTouchedSlSources,
-                            wikiService: this.deps.wikiService.forWorktree(sessionWorktree.workdir),
-                            semanticLayerService: this.deps.semanticLayerService.forWorktree(sessionWorktree.workdir),
-                            validateTouchedSources: (touched) => validateWuTouchedSources({
-                                semanticLayerService: this.deps.semanticLayerService.forWorktree(sessionWorktree.workdir),
-                                connections: this.deps.connections,
-                                configService: sessionWorktree.config,
-                                gitService: sessionWorktree.git,
-                                slSourcesRepository: this.deps.slSourcesRepository,
-                                probeRowCount: this.deps.settings.probeRowCount,
-                                slValidator: this.deps.slValidator,
-                            }, touched),
-                            tableExists: (connectionId, tableRef) => this.tableRefExistsInSemanticLayer(this.deps.semanticLayerService.forWorktree(sessionWorktree.workdir), [connectionId], tableRef),
-                        });
-                    });
                     const repairCommit = await sessionWorktree.git.commitFiles(gateRepair.changedPaths, `ingest(${job.sourceKey}): repair final gates syncId=${syncId}`, this.deps.storage.systemGitAuthor.name, this.deps.storage.systemGitAuthor.email);
                     if (!repairCommit.created) {
                         isolatedDiffSummary.gateRepairFailures += 1;

package/dist/context/ingest/isolated-diff/patch-integrator.d.ts

@@ -1,33 +1,25 @@
 import type { GitService } from '../../../context/core/git.service.js';
+import type { RepairVerification } from '../constrained-repair.js';
 import type { FinalGateRepairResult } from '../final-gate-repair.js';
 import type { IngestTraceWriter } from '../ingest-trace.js';
 import type { TextualConflictResolutionResult } from './textual-conflict-resolver.js';
-type PatchIntegrationTextualResolution = {
-    status: 'repaired';
-    attempts: number;
-    changedPaths: string[];
-} | {
-    status: 'failed';
-    attempts: number;
-    reason: string;
-};
 export type PatchIntegrationResult = {
     status: 'accepted';
     commitSha: string;
     touchedPaths: string[];
-    textualResolution?: PatchIntegrationTextualResolution;
+    textualResolution?: TextualConflictResolutionResult;
     gateRepair?: FinalGateRepairResult;
 } | {
     status: 'textual_conflict';
     reason: string;
     touchedPaths: string[];
-    textualResolution?: PatchIntegrationTextualResolution;
+    textualResolution?: TextualConflictResolutionResult;
     gateRepair?: FinalGateRepairResult;
 } | {
     status: 'semantic_conflict';
     reason: string;
     touchedPaths: string[];
-    textualResolution?: PatchIntegrationTextualResolution;
+    textualResolution?: TextualConflictResolutionResult;
     gateRepair?: FinalGateRepairResult;
 };
 export interface IntegrateWorkUnitPatchInput {
@@ -47,13 +39,14 @@ export interface IntegrateWorkUnitPatchInput {
         patchPath: string;
         touchedPaths: string[];
         reason: string;
+        verify(changedPaths: string[]): Promise<RepairVerification>;
     }): Promise<TextualConflictResolutionResult>;
     repairGateFailure?(input: {
         unitKey: string;
         patchPath: string;
         touchedPaths: string[];
         reason: string;
+        verify(changedPaths: string[]): Promise<RepairVerification>;
     }): Promise<FinalGateRepairResult>;
 }
 export declare function integrateWorkUnitPatch(input: IntegrateWorkUnitPatchInput): Promise<PatchIntegrationResult>;
-export {};