@kaelio/ktx 0.1.0-rc.5 → 0.1.0

package/node_modules/@ktx/context/dist/ingest/isolated-diff/textual-conflict-resolver.test.js

@@ -0,0 +1,101 @@
+import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { FileIngestTraceWriter } from '../ingest-trace.js';
+import { resolveTextualConflict } from './textual-conflict-resolver.js';
+async function makeHarness() {
+    const root = await mkdtemp(join(tmpdir(), 'ktx-textual-resolver-'));
+    const workdir = join(root, 'workdir');
+    const patchPath = join(root, 'failed.patch');
+    const trace = new FileIngestTraceWriter({
+        tracePath: join(root, 'trace.jsonl'),
+        jobId: 'job-1',
+        connectionId: 'warehouse',
+        sourceKey: 'metabase',
+        runId: 'run-1',
+        syncId: 'sync-1',
+        level: 'trace',
+    });
+    await mkdir(join(workdir, 'wiki/global'), { recursive: true });
+    await writeFile(join(workdir, 'wiki/global/account.md'), 'accepted line\n', 'utf-8');
+    await writeFile(patchPath, [
+        'diff --git a/wiki/global/account.md b/wiki/global/account.md',
+        'index 8877391..6f63f4d 100644',
+        '--- a/wiki/global/account.md',
+        '+++ b/wiki/global/account.md',
+        '@@ -1 +1 @@',
+        '-base line',
+        '+proposal line',
+        '',
+    ].join('\n'), 'utf-8');
+    return { root, workdir, patchPath, trace };
+}
+describe('resolveTextualConflict', () => {
+    it('lets the repair agent read the failed patch and write only touched paths', async () => {
+        const { workdir, patchPath, trace } = await makeHarness();
+        const agentRunner = {
+            runLoop: vi.fn(async (params) => {
+                const current = await params.toolSet.read_integration_file.execute({ path: 'wiki/global/account.md' });
+                expect(current.structured).toEqual({ path: 'wiki/global/account.md', exists: true });
+                expect(current.markdown).toContain('accepted line');
+                const patch = await params.toolSet.read_failed_patch.execute({});
+                expect(patch.markdown).toContain('proposal line');
+                await expect(params.toolSet.write_integration_file.execute({
+                    path: 'wiki/global/not-allowed.md',
+                    content: 'bad\n',
+                })).rejects.toThrow(/resolver path not allowed/);
+                await params.toolSet.write_integration_file.execute({
+                    path: 'wiki/global/account.md',
+                    content: 'accepted line\nproposal line\n',
+                });
+                return { stopReason: 'natural' };
+            }),
+        };
+        const result = await resolveTextualConflict({
+            agentRunner,
+            workdir,
+            unitKey: 'wu-a',
+            patchPath,
+            touchedPaths: ['wiki/global/account.md'],
+            trace,
+            reason: 'patch failed: wiki/global/account.md',
+            maxAttempts: 1,
+            stepBudget: 8,
+        });
+        expect(result).toEqual({
+            status: 'repaired',
+            attempts: 1,
+            changedPaths: ['wiki/global/account.md'],
+        });
+        await expect(readFile(join(workdir, 'wiki/global/account.md'), 'utf-8')).resolves.toBe('accepted line\nproposal line\n');
+        expect(agentRunner.runLoop).toHaveBeenCalledWith(expect.objectContaining({
+            modelRole: 'repair',
+            stepBudget: 8,
+            telemetryTags: expect.objectContaining({
+                operationName: 'ingest-isolated-diff-textual-resolver',
+                jobId: 'job-1',
+                unitKey: 'wu-a',
+            }),
+        }));
+    });
+    it('fails when the repair agent completes without editing any touched path', async () => {
+        const { workdir, patchPath, trace } = await makeHarness();
+        const result = await resolveTextualConflict({
+            agentRunner: { runLoop: vi.fn(async () => ({ stopReason: 'natural' })) },
+            workdir,
+            unitKey: 'wu-a',
+            patchPath,
+            touchedPaths: ['wiki/global/account.md'],
+            trace,
+            reason: 'patch failed: wiki/global/account.md',
+            maxAttempts: 1,
+            stepBudget: 8,
+        });
+        expect(result).toEqual({
+            status: 'failed',
+            attempts: 1,
+            reason: 'resolver completed without editing an allowed path',
+        });
+    });
+});

package/node_modules/@ktx/context/dist/ingest/isolated-diff/work-unit-executor.d.ts

@@ -0,0 +1,15 @@
+import type { IngestSessionWorktree, IngestSessionWorktreePort } from '../ports.js';
+import type { WorkUnit } from '../types.js';
+import type { IngestTraceWriter } from '../ingest-trace.js';
+import type { WorkUnitOutcome } from '../stages/stage-3-work-units.js';
+export interface RunIsolatedWorkUnitInput {
+    unitIndex: number;
+    ingestionBaseSha: string;
+    sessionWorktreeService: IngestSessionWorktreePort;
+    patchDir: string;
+    trace: IngestTraceWriter;
+    workUnit: WorkUnit;
+    run(child: IngestSessionWorktree): Promise<WorkUnitOutcome>;
+    afterSuccess?(child: IngestSessionWorktree): Promise<void>;
+}
+export declare function runIsolatedWorkUnit(input: RunIsolatedWorkUnitInput): Promise<WorkUnitOutcome>;

package/node_modules/@ktx/context/dist/ingest/isolated-diff/work-unit-executor.js

@@ -0,0 +1,61 @@
+import { mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parsePatchTouchedPaths } from './git-patch.js';
+function patchFileName(unitIndex, unitKey) {
+    const safeKey = unitKey.replace(/[^a-zA-Z0-9_.-]+/g, '-');
+    return `${String(unitIndex).padStart(4, '0')}-${safeKey}.patch`;
+}
+export async function runIsolatedWorkUnit(input) {
+    const sessionKey = `${input.trace.context.jobId}-${input.workUnit.unitKey}`;
+    let cleanupOutcome = 'crash';
+    const child = await input.sessionWorktreeService.create(sessionKey, input.ingestionBaseSha);
+    await input.trace.event('debug', 'work_unit', 'work_unit_child_created', {
+        unitKey: input.workUnit.unitKey,
+        unitIndex: input.unitIndex,
+        worktreePath: child.workdir,
+        baseSha: input.ingestionBaseSha,
+    });
+    try {
+        const outcome = await input.run(child);
+        if (outcome.status !== 'success') {
+            cleanupOutcome = 'success';
+            await input.trace.event('error', 'work_unit', 'work_unit_failed_before_patch', {
+                unitKey: input.workUnit.unitKey,
+                reason: outcome.reason ?? 'unknown failure',
+            });
+            return { ...outcome, childWorktreePath: child.workdir };
+        }
+        await input.afterSuccess?.(child);
+        await mkdir(input.patchDir, { recursive: true });
+        const patchPath = join(input.patchDir, patchFileName(input.unitIndex, input.workUnit.unitKey));
+        await child.git.writeBinaryNoRenamePatch(input.ingestionBaseSha, 'HEAD', patchPath);
+        const patch = await readFile(patchPath, 'utf-8');
+        const touched = parsePatchTouchedPaths(patch);
+        cleanupOutcome = 'success';
+        await input.trace.event('debug', 'work_unit', 'work_unit_patch_collected', {
+            unitKey: input.workUnit.unitKey,
+            patchPath,
+            touchedPaths: touched.map((entry) => entry.path),
+            patchBytes: Buffer.byteLength(patch),
+        });
+        return {
+            ...outcome,
+            patchPath,
+            patchTouchedPaths: touched.map((entry) => entry.path),
+            childWorktreePath: child.workdir,
+        };
+    }
+    catch (error) {
+        await input.trace.event('error', 'work_unit', 'work_unit_child_failed', { unitKey: input.workUnit.unitKey, worktreePath: child.workdir }, error);
+        cleanupOutcome = 'success';
+        throw error;
+    }
+    finally {
+        await input.sessionWorktreeService.cleanup(child, cleanupOutcome);
+        await input.trace.event('trace', 'work_unit', 'work_unit_child_cleanup', {
+            unitKey: input.workUnit.unitKey,
+            outcome: cleanupOutcome,
+            worktreePath: child.workdir,
+        });
+    }
+}

package/node_modules/@ktx/context/dist/ingest/isolated-diff/work-unit-executor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@ktx/context/dist/ingest/isolated-diff/work-unit-executor.test.js

@@ -0,0 +1,137 @@
+import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { GitService } from '../../core/index.js';
+import { FileIngestTraceWriter } from '../ingest-trace.js';
+import { runIsolatedWorkUnit } from './work-unit-executor.js';
+async function makeGit() {
+    const homeDir = await mkdtemp(join(tmpdir(), 'ktx-isolated-wu-'));
+    const configDir = join(homeDir, 'config');
+    const git = new GitService({
+        storage: { configDir, homeDir },
+        git: {
+            userName: 'System User',
+            userEmail: 'system@example.com',
+            bootstrapMessage: 'init',
+            bootstrapAuthor: 'system',
+            bootstrapAuthorEmail: 'system@example.com',
+        },
+    });
+    await git.onModuleInit();
+    await mkdir(join(configDir, 'raw-sources/c1/fake/s'), { recursive: true });
+    await writeFile(join(configDir, 'raw-sources/c1/fake/s/a.json'), '{}\n');
+    await git.commitFiles(['raw-sources/c1/fake/s/a.json'], 'raw snapshot', 'System User', 'system@example.com');
+    return { homeDir, configDir, git, baseSha: await git.revParseHead() };
+}
+describe('runIsolatedWorkUnit', () => {
+    it('creates a child worktree at the ingestion base and persists a patch proposal', async () => {
+        const { homeDir, git, baseSha } = await makeGit();
+        const childDir = join(homeDir, '.worktrees/session-job-1-wu-1');
+        const sessionWorktreeService = {
+            create: vi.fn(async (_key, startSha) => {
+                await mkdir(join(homeDir, '.worktrees'), { recursive: true });
+                await git.addWorktree(childDir, 'session/job-1-wu-1', startSha);
+                const childGit = git.forWorktree(childDir);
+                return {
+                    chatId: 'job-1-wu-1',
+                    workdir: childDir,
+                    branch: 'session/job-1-wu-1',
+                    baseSha: startSha,
+                    createdAt: new Date(),
+                    git: childGit,
+                    config: {},
+                };
+            }),
+            cleanup: vi.fn(async () => undefined),
+        };
+        const tracePath = join(homeDir, '.ktx/ingest-traces/job-1/trace.jsonl');
+        const trace = new FileIngestTraceWriter({
+            tracePath,
+            jobId: 'job-1',
+            connectionId: 'c1',
+            sourceKey: 'fake',
+            level: 'trace',
+        });
+        const result = await runIsolatedWorkUnit({
+            unitIndex: 0,
+            ingestionBaseSha: baseSha,
+            sessionWorktreeService: sessionWorktreeService,
+            patchDir: join(homeDir, '.ktx/ingest-patches/job-1'),
+            trace,
+            run: async (child) => {
+                await mkdir(join(child.workdir, 'wiki/global'), { recursive: true });
+                await writeFile(join(child.workdir, 'wiki/global/a.md'), '---\nsummary: A\nusage_mode: auto\n---\n\nBody\n');
+                await child.git.commitFiles(['wiki/global/a.md'], 'test: write wiki', 'KTX Test', 'system@ktx.local');
+                return {
+                    unitKey: 'wu-1',
+                    status: 'success',
+                    preSha: baseSha,
+                    postSha: await child.git.revParseHead(),
+                    actions: [{ target: 'wiki', type: 'created', key: 'a', detail: 'A' }],
+                    touchedSlSources: [],
+                };
+            },
+            workUnit: { unitKey: 'wu-1', rawFiles: ['a.json'], peerFileIndex: [], dependencyPaths: [] },
+        });
+        expect(sessionWorktreeService.create).toHaveBeenCalledWith('job-1-wu-1', baseSha);
+        expect(sessionWorktreeService.cleanup).toHaveBeenCalledWith(expect.any(Object), 'success');
+        expect(result.status).toBe('success');
+        if (result.status !== 'success') {
+            throw new Error('expected successful work unit');
+        }
+        const patchPath = result.patchPath;
+        if (!patchPath) {
+            throw new Error('expected patch path');
+        }
+        expect(patchPath).toContain('0000-wu-1.patch');
+        await expect(readFile(patchPath, 'utf-8')).resolves.toContain('wiki/global/a.md');
+        await expect(readFile(tracePath, 'utf-8')).resolves.toContain('work_unit_child_created');
+    });
+    it('removes child worktrees after failed WorkUnit outcomes are traced', async () => {
+        const { homeDir, git, baseSha } = await makeGit();
+        const childDir = join(homeDir, '.worktrees/session-job-1-wu-fail');
+        const sessionWorktreeService = {
+            create: vi.fn(async (_key, startSha) => {
+                await mkdir(join(homeDir, '.worktrees'), { recursive: true });
+                await git.addWorktree(childDir, 'session/job-1-wu-fail', startSha);
+                return {
+                    chatId: 'job-1-wu-fail',
+                    workdir: childDir,
+                    branch: 'session/job-1-wu-fail',
+                    baseSha: startSha,
+                    createdAt: new Date(),
+                    git: git.forWorktree(childDir),
+                    config: {},
+                };
+            }),
+            cleanup: vi.fn(async () => undefined),
+        };
+        const trace = new FileIngestTraceWriter({
+            tracePath: join(homeDir, '.ktx/ingest-traces/job-1/trace.jsonl'),
+            jobId: 'job-1',
+            connectionId: 'c1',
+            sourceKey: 'fake',
+            level: 'trace',
+        });
+        const result = await runIsolatedWorkUnit({
+            unitIndex: 0,
+            ingestionBaseSha: baseSha,
+            sessionWorktreeService: sessionWorktreeService,
+            patchDir: join(homeDir, '.ktx/ingest-patches/job-1'),
+            trace,
+            run: async () => ({
+                unitKey: 'wu-fail',
+                status: 'failed',
+                reason: 'agent loop errored',
+                preSha: baseSha,
+                postSha: baseSha,
+                actions: [],
+                touchedSlSources: [],
+            }),
+            workUnit: { unitKey: 'wu-fail', rawFiles: ['a.json'], peerFileIndex: [], dependencyPaths: [] },
+        });
+        expect(result.status).toBe('failed');
+        expect(sessionWorktreeService.cleanup).toHaveBeenCalledWith(expect.any(Object), 'success');
+    });
+});

package/node_modules/@ktx/context/dist/ingest/local-bundle-ingest.test.js

@@ -596,6 +596,13 @@ describe('canonical local ingest', () => {
                 ],
             },
         });
+        expect(result.report.body.isolatedDiff).toMatchObject({
+            enabled: true,
+            acceptedPatches: 0,
+            projectionSha: expect.any(String),
+        });
+        const projectedSourcePath = join(metricflowProject.projectDir, 'semantic-layer/warehouse/orders.yaml');
+        await expect(readFile(projectedSourcePath, 'utf-8')).resolves.toContain('name: orders');
         const stagedRawPath = join(metricflowProject.projectDir, 'raw-sources', 'warehouse', 'metricflow', result.report.body.syncId, 'models', 'orders.yml');
         await expect(readFile(stagedRawPath, 'utf-8')).resolves.toContain('semantic_models:');
     });

package/node_modules/@ktx/context/dist/ingest/local-bundle-runtime.js

@@ -16,6 +16,7 @@ import { createEmitHistoricSqlEvidenceTool } from './adapters/historic-sql/evide
 import { HistoricSqlProjectionPostProcessor } from './adapters/historic-sql/post-processor.js';
 import { ContextEvidenceIndexService, SqliteContextEvidenceStore } from './context-evidence/index.js';
 import { DiffSetService } from './diff-set.service.js';
+import { ingestTracePathForJob } from './ingest-trace.js';
 import { IngestBundleRunner } from './ingest-bundle.runner.js';
 import { PageTriageService } from './page-triage/index.js';
 import { createWarehouseVerificationTools } from './tools/warehouse-verification/index.js';
@@ -25,6 +26,11 @@ 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_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) {
+    const raw = env.KTX_INGEST_TRACE_LEVEL;
+    return raw && INGEST_TRACE_LEVELS.has(raw) ? raw : 'debug';
+}
 class NoopEmbeddingPort {
     maxBatchSize = 64;
     async computeEmbedding() {
@@ -51,6 +57,9 @@ class LocalIngestStorage {
     resolveTranscriptDir(jobId) {
         return join(this.project.projectDir, '.ktx/ingest-transcripts', jobId);
     }
+    resolveTracePath(jobId) {
+        return ingestTracePathForJob(this.homeDir, jobId);
+    }
 }
 class LocalIngestLock {
     async withLock(_key, fn) {
@@ -131,21 +140,55 @@ class LocalSlPythonPort {
     }
 }
 class LocalShapeOnlySlValidator {
+    validateParsedSource(sourceName, parsed) {
+        const isOverlay = parsed.table == null && parsed.sql == null;
+        const result = (isOverlay ? sourceOverlaySchema : sourceDefinitionSchema).safeParse(parsed);
+        return result.success
+            ? { errors: [], warnings: [LOCAL_SHAPE_WARNING] }
+            : {
+                errors: result.error.issues.map((issue) => `${sourceName}: ${issue.path.join('.') || 'source'} ${issue.message}`),
+                warnings: [],
+            };
+    }
+    async validateComposedSource(deps, connectionId, sourceName, readError) {
+        try {
+            const { sources, loadErrors } = await deps.semanticLayerService.loadAllSources(connectionId);
+            const source = sources.find((candidate) => candidate.name === sourceName);
+            if (source) {
+                return this.validateParsedSource(sourceName, source);
+            }
+            const detail = loadErrors.length > 0
+                ? loadErrors.join('; ')
+                : readError instanceof Error
+                    ? readError.message
+                    : String(readError);
+            return { errors: [`${sourceName}: ${detail}`], warnings: [] };
+        }
+        catch (fallbackError) {
+            return {
+                errors: [`${sourceName}: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`],
+                warnings: [],
+            };
+        }
+    }
     async validateSingleSource(deps, connectionId, sourceName) {
+        let content;
         try {
             const file = await deps.semanticLayerService.readSourceFile(connectionId, sourceName);
-            const parsed = YAML.parse(file.content);
-            const isOverlay = parsed.table == null && parsed.sql == null;
-            const result = (isOverlay ? sourceOverlaySchema : sourceDefinitionSchema).safeParse(parsed);
-            return result.success
-                ? { errors: [], warnings: [LOCAL_SHAPE_WARNING] }
-                : {
-                    errors: result.error.issues.map((issue) => `${sourceName}: ${issue.path.join('.') || 'source'} ${issue.message}`),
-                    warnings: [],
-                };
+            content = file.content;
+        }
+        catch (error) {
+            return this.validateComposedSource(deps, connectionId, sourceName, error);
+        }
+        try {
+            const parsed = YAML.parse(content);
+            return this.validateParsedSource(sourceName, parsed);
         }
         catch (error) {
-            return { errors: [`${sourceName}: ${error instanceof Error ? error.message : String(error)}`], warnings: [] };
+            return {
+                errors: [`${sourceName}: invalid YAML — ${error instanceof Error ? error.message : String(error)}`],
+                warnings: [],
+            };
         }
     }
 }
@@ -494,6 +537,7 @@ export function createLocalBundleIngestRuntime(options) {
             workUnitMaxConcurrency: options.project.config.ingest.workUnits.maxConcurrency,
             workUnitStepBudget: options.project.config.ingest.workUnits.stepBudget,
             workUnitFailureMode: options.project.config.ingest.workUnits.failureMode,
+            ingestTraceLevel: ingestTraceLevelFromEnv(),
         },
         skillsRegistry: new SkillsRegistryService({ skillsDir, logger }),
         promptService,

package/node_modules/@ktx/context/dist/ingest/local-bundle-runtime.test.js

@@ -102,6 +102,53 @@ describe('createLocalBundleIngestRuntime', () => {
             { id: 'bq', name: 'bq', connectionType: 'BIGQUERY' },
         ]);
     });
+    it('validates manifest-backed scan sources during local ingest gates', async () => {
+        await project.fileStore.writeFile('semantic-layer/warehouse/_schema/public.yaml', [
+            'tables:',
+            '  payments:',
+            '    table: public.payments',
+            '    columns:',
+            '      - name: payment_id',
+            '        type: string',
+            '      - name: amount',
+            '        type: number',
+            '',
+        ].join('\n'), 'ktx', 'ktx@example.com', 'Add warehouse manifest');
+        const agentRunner = testAgentRunner();
+        const runtime = createLocalBundleIngestRuntime({
+            project,
+            adapters: [new FakeSourceAdapter()],
+            agentRunner,
+        });
+        const deps = runtime.runner.deps;
+        await expect(deps.slValidator.validateSingleSource(deps, 'warehouse', 'payments')).resolves.toEqual({
+            errors: [],
+            warnings: expect.any(Array),
+        });
+    });
+    it('does not mask malformed direct overlays with manifest-backed fallback validation', async () => {
+        await project.fileStore.writeFile('semantic-layer/warehouse/_schema/public.yaml', [
+            'tables:',
+            '  payments:',
+            '    table: public.payments',
+            '    columns:',
+            '      - name: payment_id',
+            '        type: string',
+            '',
+        ].join('\n'), 'ktx', 'ktx@example.com', 'Add warehouse manifest');
+        await project.fileStore.writeFile('semantic-layer/warehouse/payments.yaml', ['name: payments', 'columns:', '  - [', ''].join('\n'), 'ktx', 'ktx@example.com', 'Add malformed overlay');
+        const agentRunner = testAgentRunner();
+        const runtime = createLocalBundleIngestRuntime({
+            project,
+            adapters: [new FakeSourceAdapter()],
+            agentRunner,
+        });
+        const deps = runtime.runner.deps;
+        await expect(deps.slValidator.validateSingleSource(deps, 'warehouse', 'payments')).resolves.toEqual({
+            errors: [expect.stringContaining('invalid YAML')],
+            warnings: [],
+        });
+    });
     it('passes project connection config to local ingest query executors', async () => {
         const agentRunner = testAgentRunner();
         const queryExecutor = {
@@ -130,6 +177,24 @@ describe('createLocalBundleIngestRuntime', () => {
             sql: 'select 1',
         });
     });
+    it('defaults local bundle ingest to isolated diffs without a shared-worktree fallback setting', () => {
+        const runtime = createLocalBundleIngestRuntime({
+            project,
+            adapters: [new FakeSourceAdapter()],
+            agentRunner: testAgentRunner(),
+        });
+        const settings = runtime.runner.deps.settings;
+        const fallbackSettingKey = ['sharedWorktree', 'SourceKeys'].join('');
+        expect(settings).not.toHaveProperty(fallbackSettingKey);
+        expect(Object.keys(settings).sort()).toEqual([
+            'ingestTraceLevel',
+            'memoryIngestionModel',
+            'probeRowCount',
+            'workUnitFailureMode',
+            'workUnitMaxConcurrency',
+            'workUnitStepBudget',
+        ]);
+    });
     it('accepts a debug LLM request file when constructing the default agent runner', async () => {
         await writeFile(join(project.projectDir, 'ktx.yaml'), [
             'connections:',

package/node_modules/@ktx/context/dist/ingest/memory-flow/schema.d.ts

@@ -2,8 +2,8 @@ import * as z from 'zod';
 import type { MemoryFlowReplayInput } from './types.js';
 export declare const memoryFlowRunStatusSchema: z.ZodEnum<{
     error: "error";
-    running: "running";
     done: "done";
+    running: "running";
 }>;
 export declare const memoryFlowEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"source_acquired">;
@@ -42,15 +42,33 @@ export declare const memoryFlowEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject
     type: z.ZodLiteral<"stage_skipped">;
     stage: z.ZodEnum<{
         source: "source";
-        chunks: "chunks";
         workUnits: "workUnits";
         actions: "actions";
+        chunks: "chunks";
         gates: "gates";
         saved: "saved";
     }>;
     reason: z.ZodString;
 } & {
     emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"stage_progress">;
+    stage: z.ZodEnum<{
+        source: "source";
+        report: "report";
+        integration: "integration";
+        reconciliation: "reconciliation";
+        post_processor: "post_processor";
+        wiki_sl_ref_repair: "wiki_sl_ref_repair";
+        final_gates: "final_gates";
+        save: "save";
+        provenance: "provenance";
+    }>;
+    percent: z.ZodNumber;
+    message: z.ZodString;
+    transient: z.ZodOptional<z.ZodBoolean>;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"work_unit_started">;
     unitKey: z.ZodString;
@@ -125,8 +143,8 @@ export declare const memoryFlowActionDetailSchema: z.ZodObject<{
     }>;
     action: z.ZodEnum<{
         created: "created";
-        updated: "updated";
         removed: "removed";
+        updated: "updated";
     }>;
     key: z.ZodString;
     summary: z.ZodString;
@@ -145,8 +163,8 @@ export declare const memoryFlowDetailSectionsSchema: z.ZodObject<{
         }>;
         action: z.ZodEnum<{
             created: "created";
-            updated: "updated";
             removed: "removed";
+            updated: "updated";
         }>;
         key: z.ZodString;
         summary: z.ZodString;
@@ -181,8 +199,8 @@ export declare const memoryFlowStreamEventSchema: z.ZodDiscriminatedUnion<[z.Zod
     type: z.ZodLiteral<"closed">;
     status: z.ZodEnum<{
         error: "error";
-        running: "running";
         done: "done";
+        running: "running";
     }>;
     errors: z.ZodArray<z.ZodString>;
 }, z.core.$strip>], "type">;

package/node_modules/@ktx/context/dist/ingest/memory-flow/schema.js

@@ -47,6 +47,23 @@ export const memoryFlowEventSchema = z.discriminatedUnion('type', [
         stage: z.enum(['source', 'chunks', 'workUnits', 'actions', 'gates', 'saved']),
         reason: z.string().min(1),
     }),
+    eventSchema({
+        type: z.literal('stage_progress'),
+        stage: z.enum([
+            'source',
+            'integration',
+            'reconciliation',
+            'post_processor',
+            'wiki_sl_ref_repair',
+            'final_gates',
+            'save',
+            'provenance',
+            'report',
+        ]),
+        percent: z.number().min(0).max(100),
+        message: z.string().min(1),
+        transient: z.boolean().optional(),
+    }),
     eventSchema({
         type: z.literal('work_unit_started'),
         unitKey: z.string().min(1),

package/node_modules/@ktx/context/dist/ingest/memory-flow/schema.test.js

@@ -15,6 +15,7 @@ function snapshot(overrides = {}) {
             { type: 'raw_snapshot_written', syncId: 'sync-1', rawFileCount: 2 },
             { type: 'diff_computed', added: 1, modified: 1, deleted: 0, unchanged: 0 },
             { type: 'chunks_planned', chunkCount: 1, workUnitCount: 1, evictionCount: 0 },
+            { type: 'stage_progress', stage: 'integration', percent: 80, message: 'Integrating 1/1 patches: orders' },
             { type: 'work_unit_started', unitKey: 'orders', skills: ['wiki_capture'], stepBudget: 40 },
             { type: 'work_unit_step', unitKey: 'orders', stepIndex: 1, stepBudget: 40 },
             { type: 'candidate_action', unitKey: 'orders', target: 'wiki', action: 'created', key: 'wiki/orders.md' },

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

@@ -38,6 +38,12 @@ type MemoryFlowEventPayload = {
     type: 'stage_skipped';
     stage: MemoryFlowColumnId;
     reason: string;
+} | {
+    type: 'stage_progress';
+    stage: 'source' | 'integration' | 'reconciliation' | 'post_processor' | 'wiki_sl_ref_repair' | 'final_gates' | 'save' | 'provenance' | 'report';
+    percent: number;
+    message: string;
+    transient?: boolean;
 } | {
     type: 'work_unit_started';
     unitKey: string;

package/node_modules/@ktx/context/dist/ingest/parsed-target-table.d.ts

@@ -8,9 +8,9 @@ export declare const parsedTargetTableSchema: z.ZodDiscriminatedUnion<[z.ZodObje
 }, z.core.$strip>, z.ZodObject<{
     ok: z.ZodLiteral<false>;
     reason: z.ZodEnum<{
+        no_connection_mapping: "no_connection_mapping";
         looker_template_unresolved: "looker_template_unresolved";
         derived_table_not_supported: "derived_table_not_supported";
-        no_connection_mapping: "no_connection_mapping";
         no_physical_table: "no_physical_table";
         multiple_table_references: "multiple_table_references";
         unsupported_dialect: "unsupported_dialect";