@kaelio/ktx 0.11.0 → 0.13.0

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

package/dist/context/ingest/stages/validate-wu-sources.js

@@ -1,13 +1,118 @@
+import { findMissingJoinTargets, formatMissingJoinTarget } from '../../../context/sl/semantic-layer.service.js';
+export function formatInvalidWuSources(invalid) {
+    return invalid.map((entry) => `${entry.source} (${entry.errors.join('; ')})`).join(', ');
+}
+function uniqueTouchedSources(sources) {
+    const seen = new Set();
+    const unique = [];
+    for (const source of sources) {
+        const key = `${source.connectionId}:${source.sourceName}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        unique.push(source);
+    }
+    return unique.sort((left, right) => {
+        const byConnection = left.connectionId.localeCompare(right.connectionId);
+        return byConnection === 0 ? left.sourceName.localeCompare(right.sourceName) : byConnection;
+    });
+}
+/**
+ * Expand the touched set with direct join neighbors that exist: targets the
+ * touched sources join to, and existing sources that join to a touched one.
+ * Missing targets are not added here — they are reported as join-target
+ * errors on the source that declares them, so the failure names the file
+ * that must change instead of the phantom neighbor.
+ */
+function expandWithExistingJoinNeighbors(touched, sourcesByConnection) {
+    const expanded = [...touched];
+    const touchedByConnection = new Map();
+    for (const source of touched) {
+        const bucket = touchedByConnection.get(source.connectionId) ?? new Set();
+        bucket.add(source.sourceName);
+        touchedByConnection.set(source.connectionId, bucket);
+    }
+    for (const [connectionId, sources] of sourcesByConnection) {
+        const touchedNames = touchedByConnection.get(connectionId);
+        if (!touchedNames || touchedNames.size === 0) {
+            continue;
+        }
+        const existingNames = new Set(sources.map((source) => source.name));
+        for (const source of sources) {
+            if (touchedNames.has(source.name)) {
+                for (const join of source.joins ?? []) {
+                    if (existingNames.has(join.to)) {
+                        expanded.push({ connectionId, sourceName: join.to });
+                    }
+                }
+            }
+            if ((source.joins ?? []).some((join) => touchedNames.has(join.to))) {
+                expanded.push({ connectionId, sourceName: source.name });
+            }
+        }
+    }
+    return uniqueTouchedSources(expanded);
+}
+/**
+ * Join-target errors attributable to this change set: every join declared by
+ * a touched source must resolve, and no source may be left joining to a name
+ * this change set removed. Pre-existing dangling joins on untouched sources
+ * are out of scope — they must not block unrelated work. Resolution is the
+ * Python engine's: exact source-name match within the connection.
+ */
+function findJoinTargetErrors(touched, sourcesByConnection) {
+    const errorsBySource = new Map();
+    const touchedByConnection = new Map();
+    for (const source of touched) {
+        const bucket = touchedByConnection.get(source.connectionId) ?? new Set();
+        bucket.add(source.sourceName);
+        touchedByConnection.set(source.connectionId, bucket);
+    }
+    for (const [connectionId, sources] of sourcesByConnection) {
+        const touchedNames = touchedByConnection.get(connectionId);
+        if (!touchedNames || touchedNames.size === 0) {
+            continue;
+        }
+        const existingNames = sources.map((source) => source.name);
+        for (const source of sources) {
+            const sourceIsTouched = touchedNames.has(source.name);
+            const candidateJoins = sourceIsTouched
+                ? source.joins
+                : (source.joins ?? []).filter((join) => touchedNames.has(join.to));
+            const missing = findMissingJoinTargets(candidateJoins, existingNames);
+            if (missing.length === 0) {
+                continue;
+            }
+            const key = `${connectionId}:${source.name}`;
+            const messages = missing.map(formatMissingJoinTarget);
+            errorsBySource.set(key, [...(errorsBySource.get(key) ?? []), ...messages]);
+        }
+    }
+    return errorsBySource;
+}
 export async function validateWuTouchedSources(deps, touched) {
+    if (touched.length === 0) {
+        return { validSources: [], invalidSources: [] };
+    }
+    const sourcesByConnection = new Map();
+    for (const connectionId of new Set(touched.map((source) => source.connectionId))) {
+        const { sources } = await deps.semanticLayerService.loadAllSources(connectionId);
+        sourcesByConnection.set(connectionId, sources);
+    }
+    const expanded = expandWithExistingJoinNeighbors(touched, sourcesByConnection);
+    const joinTargetErrors = findJoinTargetErrors(touched, sourcesByConnection);
     const valid = [];
     const invalid = [];
-    for (const source of touched) {
+    for (const source of expanded) {
+        const key = `${source.connectionId}:${source.sourceName}`;
         const result = await deps.slValidator.validateSingleSource(deps, source.connectionId, source.sourceName);
-        if (result.errors.length === 0) {
-            valid.push(`${source.connectionId}:${source.sourceName}`);
+        const errors = [...result.errors, ...(joinTargetErrors.get(key) ?? [])];
+        if (errors.length === 0) {
+            valid.push(key);
         }
         else {
-            invalid.push(`${source.connectionId}:${source.sourceName}`);
+            invalid.push({ source: key, errors });
         }
     }
     return { validSources: valid, invalidSources: invalid };

package/dist/context/ingest/tools/warehouse-verification/create-warehouse-verification-tools.d.ts

@@ -1,8 +1,10 @@
 import type { KtxFileStorePort } from '../../../core/file-store.js';
 import type { SlConnectionCatalogPort } from '../../../sl/ports.js';
+import type { SqlAnalysisPort } from '../../../sql-analysis/ports.js';
 import type { BaseTool } from '../../../tools/base-tool.js';
 export declare function createWarehouseVerificationTools(deps: {
     connections: SlConnectionCatalogPort;
+    sqlAnalysis?: SqlAnalysisPort;
     fallbackFileStore: KtxFileStorePort;
     wikiSearchTool: BaseTool;
     slDiscoverTool: BaseTool;

package/dist/context/ingest/tools/warehouse-verification/create-warehouse-verification-tools.js

@@ -8,7 +8,7 @@ export function createWarehouseVerificationTools(deps) {
     });
     return [
         new EntityDetailsTool(catalogFactory),
-        new SqlExecutionTool(deps.connections),
+        new SqlExecutionTool(deps.connections, deps.sqlAnalysis),
         new DiscoverDataTool({
             wikiSearchTool: deps.wikiSearchTool,
             slDiscoverTool: deps.slDiscoverTool,

package/dist/context/ingest/tools/warehouse-verification/discover-data.tool.js

@@ -47,7 +47,7 @@ export class DiscoverDataTool extends BaseTool {
             };
         }
         if (input.sourceName) {
-            const sl = await this.deps.slDiscoverTool.call({ sourceName: input.sourceName, connectionId: input.connectionId }, context);
+            const sl = (await this.deps.slDiscoverTool.call({ sourceName: input.sourceName, connectionId: input.connectionId }, context));
             return { markdown: sl.markdown, structured: { wiki: null, sl: sl.structured, raw: null } };
         }
         const query = input.query?.trim() || '';
@@ -57,13 +57,13 @@ export class DiscoverDataTool extends BaseTool {
         let sl = null;
         let raw = null;
         if (query) {
-            const wikiResult = await this.deps.wikiSearchTool.call({ query, limit }, context);
+            const wikiResult = (await this.deps.wikiSearchTool.call({ query, limit }, context));
             if (totalFound(wikiResult.structured) > 0) {
                 parts.push('## Wiki Pages', '> use `wiki_read(blockKey)` for full content', wikiResult.markdown, '');
                 wiki = wikiResult.structured;
             }
         }
-        const slResult = await this.deps.slDiscoverTool.call({ query: query || undefined, connectionId: input.connectionId }, context);
+        const slResult = (await this.deps.slDiscoverTool.call({ query: query || undefined, connectionId: input.connectionId }, context));
         if (totalSources(slResult.structured) > 0) {
             parts.push('## Semantic Layer Sources', '> use `sl_read_source(sourceName)` for the YAML, or `entity_details` for warehouse-shape details', slResult.markdown, '');
             sl = slResult.structured;

package/dist/context/ingest/tools/warehouse-verification/sql-execution.tool.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import type { SlConnectionCatalogPort } from '../../../../context/sl/ports.js';
+import type { SqlAnalysisPort } from '../../../../context/sql-analysis/ports.js';
 import { BaseTool, type ToolContext, type ToolOutput } from '../../../../context/tools/base-tool.js';
 declare const sqlExecutionInputSchema: z.ZodObject<{
     connectionId: z.ZodString;
@@ -18,8 +19,9 @@ export interface SqlExecutionStructured {
 }
 export declare class SqlExecutionTool extends BaseTool<typeof sqlExecutionInputSchema> {
     private readonly connections;
+    private readonly sqlAnalysis?;
     readonly name = "sql_execution";
-    constructor(connections: SlConnectionCatalogPort);
+    constructor(connections: SlConnectionCatalogPort, sqlAnalysis?: SqlAnalysisPort | undefined);
     get description(): string;
     get inputSchema(): z.ZodObject<{
         connectionId: z.ZodString;

package/dist/context/ingest/tools/warehouse-verification/sql-execution.tool.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { assertReadOnlySql, limitSqlForExecution } from '../../../../context/connections/read-only-sql.js';
+import { sqlAnalysisDialectForDriver } from '../../../../context/sql-analysis/dialect.js';
 import { BaseTool } from '../../../../context/tools/base-tool.js';
 const sqlExecutionInputSchema = z.object({
     connectionId: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/),
@@ -23,10 +24,12 @@ function markdownTable(headers, rows, totalRows) {
 }
 export class SqlExecutionTool extends BaseTool {
     connections;
+    sqlAnalysis;
     name = 'sql_execution';
-    constructor(connections) {
+    constructor(connections, sqlAnalysis) {
         super();
         this.connections = connections;
+        this.sqlAnalysis = sqlAnalysis;
     }
     get description() {
         return 'Run a single read-only SELECT or WITH probe against an allowed warehouse connection and return a capped markdown table or the warehouse error.';
@@ -50,9 +53,20 @@ export class SqlExecutionTool extends BaseTool {
                 },
             };
         }
+        if (!this.sqlAnalysis) {
+            throw new Error('sql_execution requires parser-backed SQL validation.');
+        }
         let sql;
         let wrappedSql;
         try {
+            const connection = await this.connections.getConnectionById(input.connectionId);
+            if (!connection) {
+                throw new Error(`Connection not found: ${input.connectionId}`);
+            }
+            const validation = await this.sqlAnalysis.validateReadOnly(input.sql, sqlAnalysisDialectForDriver(connection.connectionType));
+            if (!validation.ok) {
+                throw new Error(validation.error ?? 'SQL is not read-only.');
+            }
             sql = assertReadOnlySql(input.sql);
             wrappedSql = limitSqlForExecution(sql, input.rowLimit);
         }