@kaelio/ktx 0.11.0 → 0.13.0

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 {};

package/dist/context/ingest/isolated-diff/patch-integrator.js

@@ -38,6 +38,19 @@ export async function integrateWorkUnitPatch(input) {
             touchedPaths,
         };
     }
+    // Repair and resolution success is decided by this check, not by whether
+    // the repair agent edited files: the gates re-run over the union of the
+    // patch's paths and everything the agent changed.
+    const verifyAppliedTree = async (changedPaths) => {
+        const paths = [...new Set([...touchedPaths, ...changedPaths])].sort();
+        try {
+            await input.validateAppliedTree(paths);
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, reason: errorMessage(error) };
+        }
+    };
     try {
         await traceTimed(input.trace, 'integration', 'patch_apply', { unitKey: input.unitKey, patchPath: input.patchPath, touchedPaths }, async () => {
             await input.integrationGit.applyPatchFile3WayIndex(input.patchPath);
@@ -67,6 +80,7 @@ export async function integrateWorkUnitPatch(input) {
             patchPath: input.patchPath,
             touchedPaths,
             reason,
+            verify: verifyAppliedTree,
         });
         if (textualResolution.status === 'failed') {
             if (preApplyHead) {
@@ -79,113 +93,37 @@ export async function integrateWorkUnitPatch(input) {
                 textualResolution,
             };
         }
-        try {
-            await traceTimed(input.trace, 'integration', 'semantic_gate_after_textual_resolution', { unitKey: input.unitKey, touchedPaths: textualResolution.changedPaths }, async () => {
-                await input.validateAppliedTree(textualResolution.changedPaths);
-            });
-        }
-        catch (semanticError) {
-            const reason = errorMessage(semanticError);
-            await input.trace.event('error', 'integration', 'patch_semantic_conflict_after_textual_resolution', {
+        if (textualResolution.changedPaths.length === 0) {
+            // The resolver declared the patch redundant and the gates verified the
+            // current tree: the integration worktree already represents this work
+            // unit's content (e.g. a duplicate page created by another work unit).
+            await input.trace.event('debug', 'integration', 'patch_subsumed_after_textual_resolution', {
                 unitKey: input.unitKey,
                 patchPath: input.patchPath,
-                touchedPaths: textualResolution.changedPaths,
-                reason,
+                touchedPaths,
+                attempts: textualResolution.attempts,
             });
-            // A textual conflict and a semantic-gate failure can co-occur: the resolver
-            // reconciles the text but can leave wiki sl_refs pointing at measures the
-            // merged source no longer defines. Recover via the same gate repair the
-            // clean-apply branch uses, instead of hard-failing the whole job.
-            if (input.repairGateFailure) {
-                const gateRepair = await input.repairGateFailure({
-                    unitKey: input.unitKey,
-                    patchPath: input.patchPath,
-                    touchedPaths: textualResolution.changedPaths,
-                    reason,
-                });
-                if (gateRepair.status !== 'failed') {
-                    // The resolver wrote its merge to the worktree (unstaged); the repair
-                    // edited a subset on top. Commit the union so neither is dropped.
-                    const resolvedAndRepairedPaths = [
-                        ...new Set([...textualResolution.changedPaths, ...gateRepair.changedPaths]),
-                    ].sort();
-                    try {
-                        await traceTimed(input.trace, 'integration', 'semantic_gate_after_gate_repair', { unitKey: input.unitKey, touchedPaths: gateRepair.changedPaths }, async () => {
-                            await input.validateAppliedTree(gateRepair.changedPaths);
-                        });
-                        const commit = await input.integrationGit.commitFiles(resolvedAndRepairedPaths, `ingest: resolve WorkUnit ${input.unitKey} conflict`, input.author.name, input.author.email);
-                        if (commit.created) {
-                            await input.trace.event('debug', 'integration', 'patch_accepted_after_textual_resolution', {
-                                unitKey: input.unitKey,
-                                commitSha: commit.commitHash,
-                                touchedPaths: resolvedAndRepairedPaths,
-                                attempts: textualResolution.attempts,
-                                gateRepairAttempts: gateRepair.attempts,
-                            });
-                            return {
-                                status: 'accepted',
-                                commitSha: commit.commitHash,
-                                touchedPaths: resolvedAndRepairedPaths,
-                                textualResolution,
-                                gateRepair,
-                            };
-                        }
-                    }
-                    catch (repairValidationError) {
-                        if (preApplyHead) {
-                            await input.integrationGit.resetHardTo(preApplyHead);
-                        }
-                        await input.trace.event('error', 'integration', 'patch_semantic_conflict_after_textual_resolution', {
-                            unitKey: input.unitKey,
-                            patchPath: input.patchPath,
-                            touchedPaths: gateRepair.changedPaths,
-                            reason: errorMessage(repairValidationError),
-                        });
-                        return {
-                            status: 'semantic_conflict',
-                            reason: errorMessage(repairValidationError),
-                            touchedPaths: gateRepair.changedPaths,
-                            textualResolution,
-                            gateRepair,
-                        };
-                    }
-                }
-                if (preApplyHead) {
-                    await input.integrationGit.resetHardTo(preApplyHead);
-                }
-                return {
-                    status: 'semantic_conflict',
-                    reason: gateRepair.status === 'failed' ? gateRepair.reason : reason,
-                    touchedPaths: textualResolution.changedPaths,
-                    textualResolution,
-                    gateRepair,
-                };
-            }
-            if (preApplyHead) {
-                await input.integrationGit.resetHardTo(preApplyHead);
-            }
             return {
-                status: 'semantic_conflict',
-                reason,
-                touchedPaths: textualResolution.changedPaths,
+                status: 'accepted',
+                commitSha: preApplyHead ?? '',
+                touchedPaths: [],
                 textualResolution,
             };
         }
         const commit = await input.integrationGit.commitFiles(textualResolution.changedPaths, `ingest: resolve WorkUnit ${input.unitKey} conflict`, input.author.name, input.author.email);
         if (!commit.created) {
-            if (preApplyHead) {
-                await input.integrationGit.resetHardTo(preApplyHead);
-            }
-            const noChangeReason = 'textual resolver produced no committable changes';
-            await input.trace.event('error', 'integration', 'textual_conflict_resolver_noop', {
+            // The resolver's writes left the tree byte-identical to the accepted
+            // state, and the gates verified it — the patch is represented already.
+            await input.trace.event('debug', 'integration', 'patch_subsumed_after_textual_resolution', {
                 unitKey: input.unitKey,
                 patchPath: input.patchPath,
                 touchedPaths: textualResolution.changedPaths,
+                attempts: textualResolution.attempts,
             });
             return {
-                status: 'textual_conflict',
-                reason: noChangeReason,
-                touchedPaths: textualResolution.changedPaths,
+                status: 'accepted',
+                commitSha: preApplyHead ?? '',
+                touchedPaths: [],
                 textualResolution,
             };
         }
@@ -221,6 +159,7 @@ export async function integrateWorkUnitPatch(input) {
                 patchPath: input.patchPath,
                 touchedPaths,
                 reason,
+                verify: verifyAppliedTree,
             });
             if (gateRepair.status === 'failed') {
                 if (preApplyHead) {
@@ -233,22 +172,6 @@ export async function integrateWorkUnitPatch(input) {
                     gateRepair,
                 };
             }
-            try {
-                await traceTimed(input.trace, 'integration', 'semantic_gate_after_gate_repair', { unitKey: input.unitKey, touchedPaths: gateRepair.changedPaths }, async () => {
-                    await input.validateAppliedTree(gateRepair.changedPaths);
-                });
-            }
-            catch (repairValidationError) {
-                if (preApplyHead) {
-                    await input.integrationGit.resetHardTo(preApplyHead);
-                }
-                return {
-                    status: 'semantic_conflict',
-                    reason: errorMessage(repairValidationError),
-                    touchedPaths: gateRepair.changedPaths,
-                    gateRepair,
-                };
-            }
             const commit = await input.integrationGit.commitFiles(gateRepair.changedPaths, `ingest: repair WorkUnit ${input.unitKey} gates`, input.author.name, input.author.email);
             if (!commit.created) {
                 if (preApplyHead) {

package/dist/context/ingest/isolated-diff/textual-conflict-resolver.d.ts

@@ -1,14 +1,7 @@
 import type { AgentRunnerPort } from '../../../context/llm/runtime-port.js';
+import type { ConstrainedRepairResult, RepairVerification } from '../constrained-repair.js';
 import type { IngestTraceWriter } from '../ingest-trace.js';
-export type TextualConflictResolutionResult = {
-    status: 'repaired';
-    attempts: number;
-    changedPaths: string[];
-} | {
-    status: 'failed';
-    attempts: number;
-    reason: string;
-};
+export type TextualConflictResolutionResult = ConstrainedRepairResult;
 export interface ResolveTextualConflictInput {
     agentRunner: AgentRunnerPort;
     workdir: string;
@@ -17,6 +10,12 @@ export interface ResolveTextualConflictInput {
     touchedPaths: string[];
     trace: IngestTraceWriter;
     reason: string;
+    /**
+     * Re-runs the artifact gates against the current worktree. A resolution —
+     * including an explicit no-change declaration for a redundant patch —
+     * counts as successful only when this passes.
+     */
+    verify(changedPaths: string[]): Promise<RepairVerification>;
     maxAttempts?: number;
     stepBudget?: number;
     abortSignal?: AbortSignal;