@kaelio/ktx 0.2.0 → 0.3.0

package/node_modules/@ktx/context/dist/ingest/report-snapshot.d.ts

@@ -221,6 +221,77 @@ export declare const ingestReportSnapshotSchema: z.ZodObject<{
             errorCount: z.ZodNumber;
             toolNames: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>>;
+        finalization: z.ZodOptional<z.ZodObject<{
+            sourceKey: z.ZodString;
+            status: z.ZodEnum<{
+                success: "success";
+                skipped: "skipped";
+                failed: "failed";
+            }>;
+            commitSha: z.ZodNullable<z.ZodString>;
+            touchedPaths: z.ZodArray<z.ZodString>;
+            declaredTouchedSources: z.ZodArray<z.ZodObject<{
+                connectionId: z.ZodString;
+                sourceName: z.ZodString;
+            }, z.core.$strip>>;
+            derivedTouchedSources: z.ZodArray<z.ZodObject<{
+                connectionId: z.ZodString;
+                sourceName: z.ZodString;
+            }, z.core.$strip>>;
+            declaredChangedWikiPageKeys: z.ZodArray<z.ZodString>;
+            derivedChangedWikiPageKeys: z.ZodArray<z.ZodString>;
+            mismatches: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                artifactKind: z.ZodEnum<{
+                    wiki: "wiki";
+                    sl: "sl";
+                }>;
+                key: z.ZodString;
+                direction: z.ZodEnum<{
+                    missing_from_adapter_declaration: "missing_from_adapter_declaration";
+                    extra_in_adapter_declaration: "extra_in_adapter_declaration";
+                }>;
+            }, z.core.$strip>>>;
+            result: z.ZodOptional<z.ZodUnknown>;
+            errors: z.ZodArray<z.ZodString>;
+            warnings: z.ZodArray<z.ZodString>;
+            actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                target: z.ZodEnum<{
+                    wiki: "wiki";
+                    sl: "sl";
+                }>;
+                type: z.ZodEnum<{
+                    created: "created";
+                    updated: "updated";
+                    removed: "removed";
+                }>;
+                key: z.ZodString;
+                detail: z.ZodString;
+                targetConnectionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                rawPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            provenanceExclusions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                action: z.ZodObject<{
+                    target: z.ZodEnum<{
+                        wiki: "wiki";
+                        sl: "sl";
+                    }>;
+                    type: z.ZodEnum<{
+                        created: "created";
+                        updated: "updated";
+                        removed: "removed";
+                    }>;
+                    key: z.ZodString;
+                    detail: z.ZodString;
+                    targetConnectionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    rawPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                reason: z.ZodEnum<{
+                    missing_raw_paths: "missing_raw_paths";
+                    raw_path_not_defensible: "raw_path_not_defensible";
+                }>;
+                invalidRawPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
         memoryFlow: z.ZodOptional<z.ZodType<import("./index.js").MemoryFlowReplayInput, unknown, z.core.$ZodTypeInternals<import("./index.js").MemoryFlowReplayInput, unknown>>>;
     }, z.core.$loose>;
 }, z.core.$loose>;

package/node_modules/@ktx/context/dist/ingest/report-snapshot.js

@@ -114,6 +114,32 @@ const ingestReportFailureSchema = z.object({
     message: z.string().min(1),
     details: z.record(z.string(), z.unknown()).optional(),
 });
+const finalizationMismatchSchema = z.object({
+    artifactKind: z.enum(['sl', 'wiki']),
+    key: z.string().min(1),
+    direction: z.enum(['missing_from_adapter_declaration', 'extra_in_adapter_declaration']),
+});
+const finalizationProvenanceExclusionSchema = z.object({
+    action: ingestActionSchema,
+    reason: z.enum(['missing_raw_paths', 'raw_path_not_defensible']),
+    invalidRawPaths: z.array(z.string()).optional(),
+});
+const finalizationOutcomeSchema = z.object({
+    sourceKey: z.string().min(1),
+    status: z.enum(['success', 'failed', 'skipped']),
+    commitSha: z.string().nullable(),
+    touchedPaths: z.array(z.string()),
+    declaredTouchedSources: z.array(touchedSlSourceSchema),
+    derivedTouchedSources: z.array(touchedSlSourceSchema),
+    declaredChangedWikiPageKeys: z.array(z.string()),
+    derivedChangedWikiPageKeys: z.array(z.string()),
+    mismatches: z.array(finalizationMismatchSchema).default([]),
+    result: z.unknown().optional(),
+    errors: z.array(z.string()),
+    warnings: z.array(z.string()),
+    actions: z.array(ingestActionSchema).default([]),
+    provenanceExclusions: z.array(finalizationProvenanceExclusionSchema).default([]),
+});
 export const ingestReportSnapshotSchema = z
     .object({
     id: z.string().min(1),
@@ -171,6 +197,7 @@ export const ingestReportSnapshotSchema = z
         overrideOf: z.string().nullable().default(null),
         provenanceRows: z.array(provenanceDetailSchema).default([]),
         toolTranscripts: z.array(toolTranscriptSummarySchema).default([]),
+        finalization: finalizationOutcomeSchema.optional(),
         memoryFlow: memoryFlowReplayInputSchema.optional(),
     })
         .passthrough(),

package/node_modules/@ktx/context/dist/ingest/reports.d.ts

@@ -29,13 +29,31 @@ export interface IngestReportToolTranscriptSummary {
     errorCount: number;
     toolNames: string[];
 }
-export interface IngestReportPostProcessorOutcome {
+export interface IngestReportFinalizationMismatch {
+    artifactKind: 'sl' | 'wiki';
+    key: string;
+    direction: 'missing_from_adapter_declaration' | 'extra_in_adapter_declaration';
+}
+export interface IngestReportFinalizationProvenanceExclusion {
+    action: MemoryAction;
+    reason: 'missing_raw_paths' | 'raw_path_not_defensible';
+    invalidRawPaths?: string[];
+}
+export interface IngestReportFinalizationOutcome {
     sourceKey: string;
-    status: 'success' | 'failed';
+    status: 'success' | 'failed' | 'skipped';
+    commitSha: string | null;
+    touchedPaths: string[];
+    declaredTouchedSources: TouchedSlSource[];
+    derivedTouchedSources: TouchedSlSource[];
+    declaredChangedWikiPageKeys: string[];
+    derivedChangedWikiPageKeys: string[];
+    mismatches: IngestReportFinalizationMismatch[];
     result?: unknown;
     errors: string[];
     warnings: string[];
-    touchedSources: TouchedSlSource[];
+    actions: MemoryAction[];
+    provenanceExclusions: IngestReportFinalizationProvenanceExclusion[];
 }
 export interface IngestReportFailure {
     phase: string;
@@ -79,7 +97,7 @@ export interface IngestReportBody {
     overrideOf: string | null;
     provenanceRows: IngestReportProvenanceDetail[];
     toolTranscripts: IngestReportToolTranscriptSummary[];
-    postProcessor?: IngestReportPostProcessorOutcome;
+    finalization?: IngestReportFinalizationOutcome;
     wikiSlRefRepairs?: WikiSlRefRepair[];
     wikiSlRefRepairWarnings?: string[];
     memoryFlow?: MemoryFlowReplayInput;
@@ -97,6 +115,6 @@ export interface IngestSavedMemoryCounts {
     wikiCount: number;
     slCount: number;
 }
-export declare function postProcessorSavedMemoryCounts(postProcessor: IngestReportPostProcessorOutcome | undefined): IngestSavedMemoryCounts;
+export declare function finalizationSavedMemoryCounts(finalization: IngestReportFinalizationOutcome | undefined): IngestSavedMemoryCounts;
 export declare function savedMemoryCountsForReport(report: IngestReportSnapshot): IngestSavedMemoryCounts;
 export declare function buildStageIndexFromReportBody(jobId: string, connectionId: string, body: IngestReportBody): StageIndex;

package/node_modules/@ktx/context/dist/ingest/reports.js

@@ -1,36 +1,19 @@
-function numericResultField(result, field) {
-    const value = result[field];
-    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;
-}
-export function postProcessorSavedMemoryCounts(postProcessor) {
-    if (!postProcessor || postProcessor.sourceKey !== 'historic-sql') {
-        return { wikiCount: 0, slCount: 0 };
-    }
-    const result = postProcessor.result;
-    if (!result || typeof result !== 'object' || Array.isArray(result)) {
-        return { wikiCount: 0, slCount: 0 };
-    }
-    const record = result;
+export function finalizationSavedMemoryCounts(finalization) {
+    const actions = finalization?.actions ?? [];
     return {
-        wikiCount: numericResultField(record, 'patternPagesWritten') +
-            numericResultField(record, 'stalePatternPagesMarked') +
-            numericResultField(record, 'archivedPatternPages'),
-        slCount: numericResultField(record, 'tableUsageMerged') + numericResultField(record, 'staleTablesMarked'),
+        wikiCount: actions.filter((action) => action.target === 'wiki').length,
+        slCount: actions.filter((action) => action.target === 'sl').length,
     };
 }
 export function savedMemoryCountsForReport(report) {
     const workUnitActions = report.body.workUnits.flatMap((workUnit) => workUnit.actions);
     const reconciliationActions = report.body.reconciliationActions ?? [];
-    const actions = [...workUnitActions, ...reconciliationActions];
-    const directCounts = {
+    const finalizationActions = report.body.finalization?.actions ?? [];
+    const actions = [...workUnitActions, ...reconciliationActions, ...finalizationActions];
+    return {
         wikiCount: actions.filter((action) => action.target === 'wiki').length,
         slCount: actions.filter((action) => action.target === 'sl').length,
     };
-    const postProcessorCounts = postProcessorSavedMemoryCounts(report.body.postProcessor);
-    return {
-        wikiCount: directCounts.wikiCount + postProcessorCounts.wikiCount,
-        slCount: directCounts.slCount + postProcessorCounts.slCount,
-    };
 }
 export function buildStageIndexFromReportBody(jobId, connectionId, body) {
     return {

package/node_modules/@ktx/context/dist/ingest/types.d.ts

@@ -1,6 +1,10 @@
 import type { KtxEmbeddingPort } from '../core/embedding.js';
+import type { MemoryAction } from '../memory/index.js';
 import type { SemanticLayerService } from '../sl/index.js';
+import type { TouchedSlSource } from '../tools/index.js';
 import type { MemoryFlowEventSink } from './memory-flow/types.js';
+import type { StageIndex } from './stages/stage-index.types.js';
+import type { WorkUnitOutcome } from './stages/stage-3-work-units.js';
 export type IngestTrigger = 'upload' | 'scheduled_pull' | 'manual_resync' | 'manual_override';
 export interface DiffSet {
     added: string[];
@@ -99,6 +103,34 @@ export interface ProjectionResult {
     changedWikiPageKeys: string[];
     result?: unknown;
 }
+export interface FinalizationOverrideReplay {
+    priorJobId: string;
+    priorRunId: string;
+    priorSyncId: string;
+    evictionRawPaths: string[];
+}
+export interface DeterministicFinalizationContext {
+    connectionId: string;
+    sourceKey: string;
+    syncId: string;
+    jobId: string;
+    runId: string;
+    stagedDir: string;
+    workdir: string;
+    parseArtifacts?: unknown;
+    stageIndex: StageIndex;
+    workUnitOutcomes: WorkUnitOutcome[];
+    reconciliationActions: MemoryAction[];
+    overrideReplay?: FinalizationOverrideReplay;
+}
+export interface FinalizationResult {
+    warnings: string[];
+    errors: string[];
+    touchedSources: TouchedSlSource[];
+    changedWikiPageKeys: string[];
+    actions?: MemoryAction[];
+    result?: unknown;
+}
 export interface SourceAdapter {
     readonly source: string;
     readonly skillNames: string[];
@@ -113,6 +145,7 @@ export interface SourceAdapter {
     chunk(stagedDir: string, diffSet?: DiffSet): Promise<ChunkResult>;
     clusterWorkUnits?(ctx: ClusterWorkUnitsContext): Promise<WorkUnit[]>;
     project?(ctx: DeterministicProjectionContext): Promise<ProjectionResult>;
+    finalize?(ctx: DeterministicFinalizationContext): Promise<FinalizationResult>;
     describeScope?(stagedDir: string): Promise<ScopeDescriptor>;
     onPullSucceeded?(ctx: {
         connectionId: string;

package/node_modules/@ktx/context/dist/llm/index.d.ts

@@ -10,4 +10,4 @@ export { RuntimeAgentRunner } from './runtime-port.js';
 export { createAiSdkToolSet, createClaudeSdkTools, createRuntimeToolDescriptorFromAiTool, createRuntimeToolSetFromAiSdkTools, normalizeKtxRuntimeToolOutput, } from './runtime-tools.js';
 export type { KtxLlmDebugProviderOptionsEntry, KtxLlmDebugRequest, KtxLlmDebugRequestRecorder, SummarizeKtxLlmDebugRequestInput, } from './debug-request-recorder.js';
 export { createJsonlKtxLlmDebugRequestRecorder, summarizeKtxLlmDebugRequest, } from './debug-request-recorder.js';
-export { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV, createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmProviderFromConfig, createLocalKtxLlmRuntimeFromConfig, resolveLocalKtxEmbeddingConfig, resolveLocalKtxLlmConfig, } from './local-config.js';
+export { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmProviderFromConfig, createLocalKtxLlmRuntimeFromConfig, resolveLocalKtxEmbeddingConfig, resolveLocalKtxLlmConfig, } from './local-config.js';

package/node_modules/@ktx/context/dist/llm/index.js

@@ -7,4 +7,4 @@ export { generateKtxObject, generateKtxText } from './generation.js';
 export { RuntimeAgentRunner } from './runtime-port.js';
 export { createAiSdkToolSet, createClaudeSdkTools, createRuntimeToolDescriptorFromAiTool, createRuntimeToolSetFromAiSdkTools, normalizeKtxRuntimeToolOutput, } from './runtime-tools.js';
 export { createJsonlKtxLlmDebugRequestRecorder, summarizeKtxLlmDebugRequest, } from './debug-request-recorder.js';
-export { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV, createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmProviderFromConfig, createLocalKtxLlmRuntimeFromConfig, resolveLocalKtxEmbeddingConfig, resolveLocalKtxLlmConfig, } from './local-config.js';
+export { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmProviderFromConfig, createLocalKtxLlmRuntimeFromConfig, resolveLocalKtxEmbeddingConfig, resolveLocalKtxLlmConfig, } from './local-config.js';

package/node_modules/@ktx/context/dist/llm/local-config.d.ts

@@ -13,7 +13,6 @@ interface LocalConfigDeps {
     }) => KtxLlmRuntimePort;
 }
 export declare const MANAGED_SENTENCE_TRANSFORMERS_BASE_URL = "managed:local-embeddings";
-export declare const MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV = "KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL";
 export declare function resolveLocalKtxLlmConfig(config: KtxProjectLlmConfig, env: NodeJS.ProcessEnv): KtxLlmConfig | null;
 export declare function createLocalKtxLlmProviderFromConfig(config: KtxProjectLlmConfig, deps?: LocalConfigDeps): KtxLlmProvider | null;
 export declare function createLocalKtxLlmRuntimeFromConfig(config: KtxProjectLlmConfig, deps?: LocalConfigDeps): KtxLlmRuntimePort | null;

package/node_modules/@ktx/context/dist/llm/local-config.js

@@ -3,7 +3,6 @@ import { resolveKtxConfigReference } from '../core/config-reference.js';
 import { AiSdkKtxLlmRuntime } from './ai-sdk-runtime.js';
 import { ClaudeCodeKtxLlmRuntime } from './claude-code-runtime.js';
 export const MANAGED_SENTENCE_TRANSFORMERS_BASE_URL = 'managed:local-embeddings';
-export const MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV = 'KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL';
 function resolveOptional(value, env) {
     return resolveKtxConfigReference(value, env) || undefined;
 }
@@ -94,22 +93,13 @@ export function createLocalKtxLlmRuntimeFromConfig(config, deps = {}) {
     const llmProvider = (deps.createKtxLlmProvider ?? createKtxLlmProvider)(resolved);
     return (deps.createAiSdkRuntime ?? ((runtimeDeps) => new AiSdkKtxLlmRuntime(runtimeDeps)))({ llmProvider });
 }
-function resolveSentenceTransformersBaseUrl(value, env) {
-    if (!value) {
-        return undefined;
-    }
-    if (value === MANAGED_SENTENCE_TRANSFORMERS_BASE_URL) {
-        return resolveOptional(`env:${MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV}`, env);
-    }
-    return value;
-}
 export function resolveLocalKtxEmbeddingConfig(config, env) {
     if (config.backend === 'none') {
         return null;
     }
     if (config.backend === 'sentence-transformers') {
-        const baseURL = resolveSentenceTransformersBaseUrl(config.sentenceTransformers?.base_url, env);
-        if (!baseURL) {
+        const baseURL = config.sentenceTransformers?.base_url;
+        if (!baseURL || baseURL === MANAGED_SENTENCE_TRANSFORMERS_BASE_URL) {
             return null;
         }
         return {

package/node_modules/@ktx/context/dist/llm/local-config.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
 import { buildDefaultKtxProjectConfig, } from '../project/config.js';
-import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV, createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmProviderFromConfig, resolveLocalKtxEmbeddingConfig, resolveLocalKtxLlmConfig, } from './local-config.js';
+import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmProviderFromConfig, resolveLocalKtxEmbeddingConfig, resolveLocalKtxLlmConfig, } from './local-config.js';
 describe('local KTX LLM config', () => {
     it('resolves env and file references into a KtxLlmConfig', () => {
         const config = {
@@ -116,28 +116,7 @@ describe('local KTX embedding config', () => {
             batchSize: 16,
         });
     });
-    it('resolves managed sentence-transformers config from the CLI-provided daemon URL', () => {
-        const config = {
-            backend: 'sentence-transformers',
-            model: 'all-MiniLM-L6-v2',
-            dimensions: 384,
-            sentenceTransformers: {
-                base_url: MANAGED_SENTENCE_TRANSFORMERS_BASE_URL,
-                pathPrefix: '',
-            },
-            batchSize: 32,
-        };
-        expect(resolveLocalKtxEmbeddingConfig(config, {
-            [MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV]: 'http://127.0.0.1:61234',
-        })).toEqual({
-            backend: 'sentence-transformers',
-            model: 'all-MiniLM-L6-v2',
-            dimensions: 384,
-            sentenceTransformers: { baseURL: 'http://127.0.0.1:61234', pathPrefix: '' },
-            batchSize: 32,
-        });
-    });
-    it('returns null for managed sentence-transformers when no daemon URL is available', () => {
+    it('returns null when sentence-transformers base_url is still the unresolved managed sentinel', () => {
         const config = {
             backend: 'sentence-transformers',
             model: 'all-MiniLM-L6-v2',

package/node_modules/@ktx/context/dist/package-exports.test.js

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 const scanTypeExportCoverage = {};
+const ingestFinalizationTypeExportCoverage = {};
 describe('@ktx/context package exports', () => {
     it('exports package entry points used by host adapters', async () => {
         const core = await import('./core/index.js');
@@ -31,6 +32,7 @@ describe('@ktx/context package exports', () => {
         expect(connections.notionConnectionToPullConfig).toBeTypeOf('function');
         expect(scan).toBeDefined();
         expect(scanTypeExportCoverage).toEqual({});
+        expect(ingestFinalizationTypeExportCoverage).toEqual({});
         expect(scan.createKtxConnectorCapabilities).toBeTypeOf('function');
         expect(`liveDatabaseSnapshotToKtx${'SchemaSnapshot'}` in scan).toBe(false);
         expect(scan.normalizeKtxNativeType).toBeTypeOf('function');
@@ -122,7 +124,6 @@ describe('@ktx/context package exports', () => {
         expect(root.assertSearchBackendCapabilities).toBeTypeOf('function');
         expect(root.createLocalKtxEmbeddingProviderFromConfig).toBeTypeOf('function');
         expect(root.MANAGED_SENTENCE_TRANSFORMERS_BASE_URL).toBe('managed:local-embeddings');
-        expect(root.MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV).toBe('KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL');
         expect(agent).toBeDefined();
         expect(agent.AgentRunnerService).toBeTypeOf('function');
         expect(root.AgentRunnerService).toBeTypeOf('function');
@@ -231,7 +232,6 @@ describe('@ktx/context package exports', () => {
         expect(ingest.historicSqlEvidenceEnvelopeSchema).toBeDefined();
         expect(ingest.historicSqlEvidencePath).toBeTypeOf('function');
         expect(ingest.createEmitHistoricSqlEvidenceTool).toBeTypeOf('function');
-        expect(ingest.HistoricSqlProjectionPostProcessor).toBeTypeOf('function');
         expect(ingest.SqliteContextEvidenceStore).toBeTypeOf('function');
         expect(ingest.SqliteBundleIngestStore).toBeTypeOf('function');
         expect(ingest.CuratorPaginationService).toBeTypeOf('function');

package/node_modules/@ktx/context/dist/project/config.d.ts

@@ -195,27 +195,35 @@ declare const storageSchema: z.ZodObject<{
 declare const connectionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     driver: z.ZodLiteral<"postgres">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"postgresql">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"mysql">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"snowflake">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"bigquery">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"sqlite">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"clickhouse">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"sqlserver">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"metabase">;
     api_url: z.ZodString;
@@ -301,27 +309,35 @@ declare const ktxProjectConfigSchema: z.ZodObject<{
     connections: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
         driver: z.ZodLiteral<"postgres">;
         url: z.ZodOptional<z.ZodString>;
+        enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"postgresql">;
         url: z.ZodOptional<z.ZodString>;
+        enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"mysql">;
         url: z.ZodOptional<z.ZodString>;
+        enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"snowflake">;
         url: z.ZodOptional<z.ZodString>;
+        enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"bigquery">;
         url: z.ZodOptional<z.ZodString>;
+        enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"sqlite">;
         url: z.ZodOptional<z.ZodString>;
+        enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"clickhouse">;
         url: z.ZodOptional<z.ZodString>;
+        enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"sqlserver">;
         url: z.ZodOptional<z.ZodString>;
+        enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$loose>, z.ZodObject<{
         driver: z.ZodLiteral<"metabase">;
         api_url: z.ZodString;

package/node_modules/@ktx/context/dist/project/driver-schemas.d.ts

@@ -2,27 +2,35 @@ import * as z from 'zod';
 export declare const connectionConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     driver: z.ZodLiteral<"postgres">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"postgresql">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"mysql">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"snowflake">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"bigquery">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"sqlite">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"clickhouse">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"sqlserver">;
     url: z.ZodOptional<z.ZodString>;
+    enabled_tables: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>, z.ZodObject<{
     driver: z.ZodLiteral<"metabase">;
     api_url: z.ZodString;

package/node_modules/@ktx/context/dist/project/driver-schemas.js

@@ -19,6 +19,10 @@ function warehouseConnectionSchema(driver) {
             .min(1)
             .optional()
             .describe('Warehouse connection URL or DSN; may contain environment-variable references like env:DATABASE_URL.'),
+        enabled_tables: z
+            .array(z.string().min(1))
+            .optional()
+            .describe('Optional allowlist of fully-qualified table names ("schema.table") to ingest. When set, live-database ingest discards any table whose schema-qualified name is not in this list. Useful for smoke-testing deep ingest on a single table.'),
     })
         .describe(`${driver} warehouse connection. Additional driver-tunable fields (e.g. historicSql, context.queryHistory) are accepted and passed through.`);
 }

package/node_modules/@ktx/context/dist/scan/enabled-tables.d.ts

@@ -0,0 +1,3 @@
+import type { KtxSchemaSnapshot } from './types.js';
+export declare function resolveEnabledTables(connection: Record<string, unknown> | undefined): Set<string> | null;
+export declare function filterSnapshotTables(snapshot: KtxSchemaSnapshot, enabledTables: Set<string>): KtxSchemaSnapshot;

package/node_modules/@ktx/context/dist/scan/enabled-tables.js

@@ -0,0 +1,15 @@
+export function resolveEnabledTables(connection) {
+    const raw = connection?.enabled_tables;
+    if (!Array.isArray(raw) || raw.length === 0)
+        return null;
+    return new Set(raw.filter((v) => typeof v === 'string'));
+}
+export function filterSnapshotTables(snapshot, enabledTables) {
+    return {
+        ...snapshot,
+        tables: snapshot.tables.filter((table) => {
+            const key = table.db ? `${table.db}.${table.name}` : table.name;
+            return enabledTables.has(key);
+        }),
+    };
+}

package/node_modules/@ktx/context/dist/scan/local-scan.d.ts

@@ -4,7 +4,7 @@ import type { KtxProjectLlmConfig, KtxScanEnrichmentConfig } from '../project/co
 import type { KtxLocalProject } from '../project/index.js';
 import { type KtxLocalScanEnrichmentProviders } from './local-enrichment.js';
 import { SqliteLocalScanEnrichmentStateStore } from './sqlite-local-enrichment-state-store.js';
-import type { KtxProgressPort, KtxScanConnector, KtxScanMode, KtxScanReport, KtxScanTrigger, KtxSchemaSnapshot } from './types.js';
+import type { KtxProgressPort, KtxScanConnector, KtxScanMode, KtxScanReport, KtxScanTrigger } from './types.js';
 export interface RunLocalScanOptions {
     project: KtxLocalProject;
     connectionId: string;
@@ -60,9 +60,7 @@ interface LocalScanEnrichmentProviderDeps {
     projectDir?: string;
 }
 export declare function createLocalScanEnrichmentProvidersFromConfig(config: KtxScanEnrichmentConfig, llmConfig: KtxProjectLlmConfig, deps?: LocalScanEnrichmentProviderDeps): KtxLocalScanEnrichmentProviders | null;
-export declare function resolveEnabledTables(connection: Record<string, unknown> | undefined): Set<string> | null;
-export declare function filterSnapshotTables(snapshot: KtxSchemaSnapshot, enabledTables: Set<string>): KtxSchemaSnapshot;
+export { filterSnapshotTables, resolveEnabledTables } from './enabled-tables.js';
 export declare function runLocalScan(options: RunLocalScanOptions): Promise<LocalScanRunResult>;
 export declare function getLocalScanReport(project: KtxLocalProject, runId: string): Promise<KtxScanReport | null>;
 export declare function getLocalScanStatus(project: KtxLocalProject, runId: string): Promise<LocalScanStatusResponse | null>;
-export {};

package/node_modules/@ktx/context/dist/scan/local-scan.js

@@ -2,6 +2,7 @@ import { createDefaultLocalIngestAdapters, getLocalStageOnlyIngestStatus, runLoc
 import { createLocalKtxEmbeddingProviderFromConfig, createLocalKtxLlmRuntimeFromConfig, KtxScanEmbeddingPortAdapter, } from '../llm/index.js';
 import { ktxLocalStateDbPath } from '../project/local-state-db.js';
 import { redactKtxScanReport } from './credentials.js';
+import { filterSnapshotTables, resolveEnabledTables } from './enabled-tables.js';
 import { completedKtxScanEnrichmentStateSummary } from './enrichment-state.js';
 import { failedKtxScanEnrichmentSummary, ktxScanErrorMessage } from './enrichment-summary.js';
 import { createDeterministicLocalScanEnrichmentProviders, runLocalScanEnrichment, } from './local-enrichment.js';
@@ -182,21 +183,6 @@ async function readScanReport(project, connectionId, syncId) {
         return null;
     }
 }
-export function resolveEnabledTables(connection) {
-    const raw = connection?.enabled_tables;
-    if (!Array.isArray(raw) || raw.length === 0)
-        return null;
-    return new Set(raw.filter((v) => typeof v === 'string'));
-}
-export function filterSnapshotTables(snapshot, enabledTables) {
-    return {
-        ...snapshot,
-        tables: snapshot.tables.filter((table) => {
-            const key = table.db ? `${table.db}.${table.name}` : table.name;
-            return enabledTables.has(key);
-        }),
-    };
-}
 function createFilteredConnector(connector, enabledTables) {
     return {
         ...connector,
@@ -206,6 +192,7 @@ function createFilteredConnector(connector, enabledTables) {
         },
     };
 }
+export { filterSnapshotTables, resolveEnabledTables } from './enabled-tables.js';
 function withInternalLiveDatabaseAdapter(project) {
     if (project.config.ingest.adapters.includes(LIVE_DATABASE_ADAPTER)) {
         return project;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaelio/ktx",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Standalone KTX context layer for database agents",
   "private": false,
   "type": "module",

package/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/post-processor.d.ts

@@ -1,4 +0,0 @@
-import type { IngestBundlePostProcessorInput, IngestBundlePostProcessorPort, IngestBundlePostProcessorResult } from '../../ports.js';
-export declare class HistoricSqlProjectionPostProcessor implements IngestBundlePostProcessorPort {
-    run(input: IngestBundlePostProcessorInput): Promise<IngestBundlePostProcessorResult>;
-}