@kaelio/ktx 0.11.0 → 0.12.0

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;

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

@@ -1,58 +1,26 @@
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
+import { readFile } from 'node:fs/promises';
 import { z } from 'zod';
-import { traceTimed } from '../ingest-trace.js';
-const readIntegrationFileSchema = z.object({
-    path: z.string().min(1),
-});
-const writeIntegrationFileSchema = z.object({
-    path: z.string().min(1),
-    content: z.string(),
-});
-const deleteIntegrationFileSchema = z.object({
-    path: z.string().min(1),
-});
-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(`resolver 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(`resolver 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 { buildDeleteRepairFileTool, runConstrainedRepairLoop } from '../constrained-repair.js';
 function buildResolverSystemPrompt() {
     return `<role>
-You repair one failed KTX isolated-diff patch inside the integration worktree.
+You repair one failed ktx isolated-diff patch inside the integration worktree.
 </role>
 
 <rules>
 - Preserve accepted integration content that is unrelated to the failed patch.
 - Incorporate the failed patch only when the patch evidence is compatible with the current file.
+- If the current file already represents everything the failed patch contributes (for example a
+  duplicate page created by another work unit), call declare_patch_redundant instead of editing.
 - Edit only paths exposed by the resolver tools.
 - Prefer the smallest text edit that makes the composed artifact coherent.
 - Do not create new facts that are absent from the current file or failed patch.
-- Stop after writing the repaired file content.
+- Stop after writing the repaired file content or declaring the patch redundant.
 </rules>`;
 }
 function buildResolverUserPrompt(input) {
+    const previousFailureBlock = input.previousFailure
+        ? `\nPrevious attempt did not pass the artifact gates:\n${input.previousFailure}\n`
+        : '';
     return `Repair isolated-diff textual conflict.
 
 WorkUnit: ${input.unitKey}
@@ -63,11 +31,18 @@ ${input.touchedPaths.map((path) => `- ${path}`).join('\n')}
 
 Git apply failure:
 ${input.reason}
-
-Use read_failed_patch first. Then read the touched integration files, write the
-repaired content, and stop.`;
+${previousFailureBlock}
+Use read_failed_patch first. Then read the touched integration files and either
+write the repaired content or, when the patch adds nothing the current files do
+not already cover, call declare_patch_redundant. Then stop.`;
 }
-function buildToolSet(input) {
+function buildResolverExtraTools(input) {
+    const declareSchema = z.object({
+        reason: z
+            .string()
+            .min(1)
+            .describe('Why the integration tree already represents everything this patch contributes.'),
+    });
     return {
         read_failed_patch: {
             name: 'read_failed_patch',
@@ -81,111 +56,58 @@ function buildToolSet(input) {
                 };
             },
         },
-        read_integration_file: {
-            name: 'read_integration_file',
-            description: 'Read one allowed file from the current integration worktree.',
-            inputSchema: readIntegrationFileSchema,
-            execute: async ({ path }) => {
-                const normalized = assertAllowedPath(path, input.allowedPaths);
-                const file = await readOptionalFile(join(input.workdir, normalized));
+        ...buildDeleteRepairFileTool(input.context),
+        declare_patch_redundant: {
+            name: 'declare_patch_redundant',
+            description: 'Declare that the failed patch needs no integration because the current worktree already ' +
+                'represents its content (for example a duplicate page created by another work unit).',
+            inputSchema: declareSchema,
+            execute: async ({ reason }) => {
+                input.context.declareNoChange(reason);
                 return {
-                    markdown: file.exists ? file.content : `(missing file: ${normalized})`,
-                    structured: { path: normalized, exists: file.exists },
-                };
-            },
-        },
-        write_integration_file: {
-            name: 'write_integration_file',
-            description: 'Replace one allowed integration worktree file with repaired text content.',
-            inputSchema: writeIntegrationFileSchema,
-            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) },
-                };
-            },
-        },
-        delete_integration_file: {
-            name: 'delete_integration_file',
-            description: 'Delete one allowed integration worktree file when the failed patch proves the deletion is correct.',
-            inputSchema: deleteIntegrationFileSchema,
-            execute: async ({ path }) => {
-                const normalized = assertAllowedPath(path, input.allowedPaths);
-                await rm(join(input.workdir, normalized), { force: true });
-                input.editedPaths.add(normalized);
-                return {
-                    markdown: `Deleted ${normalized}`,
-                    structured: { path: normalized },
+                    markdown: `Declared patch redundant: ${reason}`,
+                    structured: { reason },
                 };
             },
         },
     };
 }
 export async function resolveTextualConflict(input) {
-    const allowedPaths = new Set(input.touchedPaths.map(normalizeRepoPath));
-    const maxAttempts = input.maxAttempts ?? 1;
-    const stepBudget = input.stepBudget ?? 12;
-    let lastFailure = 'resolver did not run';
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const editedPaths = new Set();
-        const traceData = {
+    const sortedTouchedPaths = [...input.touchedPaths].sort();
+    return runConstrainedRepairLoop({
+        agentRunner: input.agentRunner,
+        workdir: input.workdir,
+        allowedPaths: input.touchedPaths,
+        trace: input.trace,
+        tracePhase: 'resolver',
+        traceEventName: 'textual_conflict_resolver',
+        traceData: {
+            unitKey: input.unitKey,
+            patchPath: input.patchPath,
+            touchedPaths: sortedTouchedPaths,
+            reason: input.reason,
+        },
+        systemPrompt: buildResolverSystemPrompt(),
+        buildUserPrompt: ({ attempt, maxAttempts, previousFailure }) => buildResolverUserPrompt({
             unitKey: input.unitKey,
             patchPath: input.patchPath,
-            touchedPaths: [...allowedPaths].sort(),
+            touchedPaths: sortedTouchedPaths,
+            reason: input.reason,
             attempt,
             maxAttempts,
-            reason: input.reason,
-        };
-        const result = await traceTimed(input.trace, 'resolver', 'textual_conflict_resolver', traceData, async () => input.agentRunner.runLoop({
-            modelRole: 'repair',
-            systemPrompt: buildResolverSystemPrompt(),
-            userPrompt: buildResolverUserPrompt({
-                unitKey: input.unitKey,
-                patchPath: input.patchPath,
-                touchedPaths: [...allowedPaths].sort(),
-                reason: input.reason,
-                attempt,
-                maxAttempts,
-            }),
-            toolSet: buildToolSet({
-                workdir: input.workdir,
-                patchPath: input.patchPath,
-                allowedPaths,
-                editedPaths,
-            }),
-            stepBudget,
-            telemetryTags: {
-                operationName: 'ingest-isolated-diff-textual-resolver',
-                source: input.trace.context.sourceKey,
-                jobId: input.trace.context.jobId,
-                unitKey: input.unitKey,
-            },
-            abortSignal: input.abortSignal,
-        }));
-        if (result.stopReason === 'error') {
-            lastFailure = result.error?.message ?? 'resolver agent loop errored';
-            await input.trace.event('error', 'resolver', 'textual_conflict_resolver_failed', traceData, result.error);
-            continue;
-        }
-        const changedPaths = [...editedPaths].sort();
-        if (changedPaths.length === 0) {
-            lastFailure = 'resolver completed without editing an allowed path';
-            await input.trace.event('error', 'resolver', 'textual_conflict_resolver_failed', {
-                ...traceData,
-                reason: lastFailure,
-            });
-            continue;
-        }
-        await input.trace.event('debug', 'resolver', 'textual_conflict_resolver_repaired', {
-            ...traceData,
-            changedPaths,
-        });
-        return { status: 'repaired', attempts: attempt, changedPaths };
-    }
-    return { status: 'failed', attempts: maxAttempts, reason: lastFailure };
+            previousFailure,
+        }),
+        buildExtraTools: (context) => buildResolverExtraTools({ patchPath: input.patchPath, context }),
+        verify: input.verify,
+        noChangeFailureReason: 'resolver completed without editing an allowed path or declaring the patch redundant',
+        telemetryTags: {
+            operationName: 'ingest-isolated-diff-textual-resolver',
+            source: input.trace.context.sourceKey,
+            jobId: input.trace.context.jobId,
+            unitKey: input.unitKey,
+        },
+        maxAttempts: input.maxAttempts,
+        stepBudget: input.stepBudget ?? 12,
+        abortSignal: input.abortSignal,
+    });
 }

package/dist/context/ingest/local-bundle-runtime.d.ts

@@ -1,4 +1,5 @@
 import type { KtxSqlQueryExecutorPort } from '../../context/connections/query-executor.js';
+import type { SqlAnalysisPort } from '../../context/sql-analysis/ports.js';
 import type { KtxLogger } from '../../context/core/config.js';
 import type { KtxSemanticLayerComputePort } from '../../context/daemon/semantic-layer-compute.js';
 import { createLocalKtxLlmRuntimeFromConfig } from '../../context/llm/local-config.js';
@@ -20,6 +21,7 @@ export interface CreateLocalBundleIngestRuntimeOptions {
     memoryModel?: string;
     semanticLayerCompute?: KtxSemanticLayerComputePort;
     queryExecutor?: KtxSqlQueryExecutorPort;
+    sqlAnalysis?: SqlAnalysisPort;
     jobIdFactory?: () => string;
     logger?: KtxLogger;
     embeddingProvider?: KtxEmbeddingProvider | null;

package/dist/context/ingest/local-bundle-runtime.js

@@ -52,7 +52,7 @@ import { SourceAdapterRegistry } from './source-adapter-registry.js';
 import { SqliteBundleIngestStore } from './sqlite-bundle-ingest-store.js';
 const promptsDir = fileURLToPath(new URL('../../prompts', import.meta.url));
 const skillsDir = fileURLToPath(new URL('../../skills', import.meta.url));
-const LOCAL_AUTHOR = { name: 'KTX Local', email: 'local@ktx.local' };
+const LOCAL_AUTHOR = { name: 'ktx Local', email: 'local@ktx.local' };
 const LOCAL_SHAPE_WARNING = 'Local ingest validates semantic-layer YAML shape only.';
 const INGEST_TRACE_LEVELS = new Set(['error', 'info', 'debug', 'trace']);
 function ingestTraceLevelFromEnv(env = process.env) {
@@ -169,7 +169,8 @@ class LocalSlPythonPort {
 }
 class LocalShapeOnlySlValidator {
     validateParsedSource(sourceName, parsed) {
-        const isOverlay = parsed.table == null && parsed.sql == null;
+        const fields = (parsed ?? {});
+        const isOverlay = fields.table == null && fields.sql == null;
         const result = (isOverlay ? sourceOverlaySchema : sourceDefinitionSchema).safeParse(parsed);
         return result.success
             ? { errors: [], warnings: [LOCAL_SHAPE_WARNING] }
@@ -200,16 +201,12 @@ class LocalShapeOnlySlValidator {
         }
     }
     async validateSingleSource(deps, connectionId, sourceName) {
-        let content;
-        try {
-            const file = await deps.semanticLayerService.readSourceFile(connectionId, sourceName);
-            content = file.content;
-        }
-        catch (error) {
-            return this.validateComposedSource(deps, connectionId, sourceName, error);
+        const file = await deps.semanticLayerService.readSourceFile(connectionId, sourceName);
+        if (!file) {
+            return this.validateComposedSource(deps, connectionId, sourceName, 'no standalone or overlay file found');
         }
         try {
-            const parsed = YAML.parse(content);
+            const parsed = YAML.parse(file.content);
             return this.validateParsedSource(sourceName, parsed);
         }
         catch (error) {
@@ -439,6 +436,7 @@ class LocalIngestToolsetFactory {
         const slDiscoverTool = new SlDiscoverTool(slDeps, { maxSources: 25, minRrfScore: 0, maxDetailedSources: 5 });
         const warehouseVerificationTools = createWarehouseVerificationTools({
             connections: deps.connections,
+            ...(deps.sqlAnalysis ? { sqlAnalysis: deps.sqlAnalysis } : {}),
             fallbackFileStore: deps.project.fileStore,
             wikiSearchTool,
             slDiscoverTool,
@@ -556,6 +554,7 @@ export function createLocalBundleIngestRuntime(options) {
         authorResolver: new LocalAuthorResolver(),
         slSourcesRepository,
         connections,
+        ...(options.sqlAnalysis ? { sqlAnalysis: options.sqlAnalysis } : {}),
         contextStore,
         embedding,
     });

package/dist/context/ingest/local-ingest.d.ts

@@ -1,4 +1,5 @@
 import type { KtxSqlQueryExecutorPort } from '../../context/connections/query-executor.js';
+import type { SqlAnalysisPort } from '../../context/sql-analysis/ports.js';
 import type { KtxLogger } from '../../context/core/config.js';
 import type { KtxSemanticLayerComputePort } from '../../context/daemon/semantic-layer-compute.js';
 import type { AgentRunnerPort, KtxLlmRuntimePort } from '../../context/llm/runtime-port.js';
@@ -23,6 +24,7 @@ export interface RunLocalIngestOptions {
     memoryModel?: string;
     semanticLayerCompute?: KtxSemanticLayerComputePort;
     queryExecutor?: KtxSqlQueryExecutorPort;
+    sqlAnalysis?: SqlAnalysisPort;
     logger?: KtxLogger;
     embeddingProvider?: import('../../llm/types.js').KtxEmbeddingProvider | null;
     abortSignal?: AbortSignal;

package/dist/context/ingest/local-ingest.js

@@ -102,6 +102,7 @@ export async function runLocalIngest(options) {
             memoryModel: options.memoryModel,
             semanticLayerCompute: options.semanticLayerCompute,
             queryExecutor: options.queryExecutor,
+            sqlAnalysis: options.sqlAnalysis,
             logger: options.logger,
             embeddingProvider: options.embeddingProvider,
             abortSignal: options.abortSignal,
@@ -259,6 +260,7 @@ export async function runLocalMetabaseIngest(options) {
                 memoryModel: options.memoryModel,
                 semanticLayerCompute: options.semanticLayerCompute,
                 queryExecutor: options.queryExecutor,
+                sqlAnalysis: options.sqlAnalysis,
                 logger: options.logger,
                 embeddingProvider: options.embeddingProvider,
                 abortSignal: options.abortSignal,

package/dist/context/ingest/memory-flow/view-model.js

@@ -436,7 +436,7 @@ export function buildMemoryFlowViewModel(input) {
         ? [...new Set(sources.map((s) => humanizeAdapter(s.adapter)))].join(' + ')
         : `${input.connectionId}/${input.adapter}`;
     return {
-        title: `KTX memory flow  ${titleSources}  ${input.status}`,
+        title: `ktx memory flow  ${titleSources}  ${input.status}`,
         subtitle: `Run ${input.runId}  Sync ${input.syncId}`,
         status: input.status,
         activeLine: activeLine(input),

package/dist/context/ingest/stages/stage-3-work-units.d.ts

@@ -2,18 +2,15 @@ import type { KtxModelRole } from '../../../llm/types.js';
 import type { AgentRunnerPort, KtxRuntimeToolSet, RunLoopMetrics } from '../../../context/llm/runtime-port.js';
 import type { CaptureSession, MemoryAction } from '../../../context/memory/types.js';
 import { type TouchedSlSource } from '../../../context/tools/touched-sl-sources.js';
+import { type WuValidationResult } from './validate-wu-sources.js';
 import type { WorkUnit } from '../types.js';
-interface TouchedValidationResult {
-    invalidSources: string[];
-    validSources: string[];
-}
 export interface WorkUnitExecutionDeps {
     sessionWorktreeGit: {
         revParseHead(): Promise<string | null>;
     };
     agentRunner: AgentRunnerPort;
     validateWikiRefs?: (actions: MemoryAction[]) => Promise<string[]>;
-    validateTouchedSources: (touched: TouchedSlSource[]) => Promise<TouchedValidationResult>;
+    validateTouchedSources: (touched: TouchedSlSource[]) => Promise<WuValidationResult>;
     resetHardTo: (targetSha: string) => Promise<void>;
     buildSystemPrompt: (wu: WorkUnit) => string;
     buildUserPrompt: (wu: WorkUnit) => string;
@@ -45,4 +42,3 @@ export interface WorkUnitOutcome {
     metrics?: RunLoopMetrics;
 }
 export declare function executeWorkUnit(deps: WorkUnitExecutionDeps, wu: WorkUnit): Promise<WorkUnitOutcome>;
-export {};

package/dist/context/ingest/stages/stage-3-work-units.js

@@ -1,5 +1,6 @@
 import { isAbortError } from '../../core/abort.js';
 import { listTouchedSlSources } from '../../../context/tools/touched-sl-sources.js';
+import { formatInvalidWuSources } from './validate-wu-sources.js';
 const MAX_WORK_UNIT_PROMPT_CHARS = 240_000;
 export async function executeWorkUnit(deps, wu) {
     const preSha = (await deps.sessionWorktreeGit.revParseHead()) ?? '';
@@ -97,7 +98,7 @@ export async function executeWorkUnit(deps, wu) {
             // Spec: invalid SL writes reset the session worktree to the WU's pre-state, WU is marked failed,
             // its files are absent from the Stage Index. Per-source surgical revert is the
             // memory-agent pattern — NOT the bundle-ingest pattern.
-            return failWithReset(`sl_validate failed for: ${validation.invalidSources.join(', ')}`);
+            return failWithReset(`sl_validate failed for: ${formatInvalidWuSources(validation.invalidSources)}`);
         }
     }
     return {

package/dist/context/ingest/stages/validate-wu-sources.d.ts

@@ -1,10 +1,16 @@
 import type { SlValidationDeps } from '../../../context/sl/tools/sl-warehouse-validation.js';
 import type { SlValidatorPort } from '../../../context/sl/sl-validator.port.js';
 import type { TouchedSlSource } from '../../../context/tools/touched-sl-sources.js';
+export interface InvalidWuSource {
+    /** `${connectionId}:${sourceName}` */
+    source: string;
+    errors: string[];
+}
 export interface WuValidationResult {
     validSources: string[];
-    invalidSources: string[];
+    invalidSources: InvalidWuSource[];
 }
+export declare function formatInvalidWuSources(invalid: InvalidWuSource[]): string;
 export declare function validateWuTouchedSources(deps: SlValidationDeps & {
     slValidator: SlValidatorPort<SlValidationDeps>;
 }, touched: TouchedSlSource[]): Promise<WuValidationResult>;