@kaelio/ktx 0.1.0-rc.5 → 0.1.0

package/dist/index.test.js

@@ -31,7 +31,9 @@ describe('getKtxCliPackageInfo', () => {
     it('identifies the CLI package and its context dependency', () => {
         expect(getKtxCliPackageInfo()).toEqual({
             name: '@ktx/cli',
-            version: '0.0.0-private',
+            version: '0.1.0-rc.1',
+            packageVersion: '0.0.0-private',
+            runtimeVersion: '0.1.0-rc.1',
             contextPackageName: '@ktx/context',
         });
     });
@@ -49,6 +51,8 @@ describe('getKtxCliPackageInfo', () => {
         })).toEqual({
             name: '@kaelio/ktx',
             version: '0.1.0',
+            packageVersion: '0.1.0',
+            runtimeVersion: '0.1.0',
             contextPackageName: '@ktx/context',
         });
     });
@@ -86,7 +90,7 @@ describe('runKtxCli', () => {
     it('prints version information', async () => {
         const testIo = makeIo();
         await expect(runKtxCli(['--version'], testIo.io)).resolves.toBe(0);
-        expect(testIo.stdout()).toBe('@ktx/cli 0.0.0-private\n');
+        expect(testIo.stdout()).toBe('@ktx/cli 0.1.0-rc.1\n');
         expect(testIo.stderr()).toBe('');
     });
     it('prints the public command surface in root help', async () => {
@@ -129,6 +133,16 @@ describe('runKtxCli', () => {
             json: false,
             limit: 5,
         }, searchIo.io);
+        const debugSearchIo = makeIo();
+        await expect(runKtxCli(['--project-dir', tempDir, '--debug', 'wiki', 'search', 'revenue'], debugSearchIo.io, { knowledge })).resolves.toBe(0);
+        expect(knowledge).toHaveBeenLastCalledWith({
+            command: 'search',
+            projectDir: tempDir,
+            query: 'revenue',
+            userId: 'local',
+            json: false,
+            debug: true,
+        }, debugSearchIo.io);
     });
     it('rejects removed public wiki read and write commands', async () => {
         const knowledge = vi.fn(async () => 0);
@@ -171,7 +185,7 @@ describe('runKtxCli', () => {
         await expect(runKtxCli(['--project-dir', tempDir, 'sl', 'list', '--query', 'revenue'], listIo.io, { sl })).resolves.toBe(1);
         expect(listIo.stderr()).toContain("unknown option '--query'");
     });
-    it('routes runtime management commands with the CLI package version', async () => {
+    it('routes runtime management commands with the release runtime version', async () => {
         const runtime = vi.fn(async () => 0);
         const installIo = makeIo();
         const startIo = makeIo();
@@ -189,32 +203,32 @@ describe('runKtxCli', () => {
         await expect(runKtxCli(['dev', 'runtime', 'prune', '--dry-run'], pruneIo.io, { runtime })).resolves.toBe(1);
         expect(runtime).toHaveBeenNthCalledWith(1, {
             command: 'install',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             feature: 'local-embeddings',
             force: true,
         }, installIo.io);
         expect(runtime).toHaveBeenNthCalledWith(2, {
             command: 'start',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             projectDir: expect.any(String),
             feature: 'local-embeddings',
             force: true,
         }, startIo.io);
         expect(runtime).toHaveBeenNthCalledWith(3, {
             command: 'stop',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             projectDir: expect.any(String),
             all: false,
         }, stopIo.io);
         expect(runtime).toHaveBeenNthCalledWith(4, {
             command: 'stop',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             projectDir: expect.any(String),
             all: true,
         }, stopAllIo.io);
         expect(runtime).toHaveBeenNthCalledWith(5, {
             command: 'status',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             json: true,
         }, statusIo.io);
         expect(runtime).toHaveBeenCalledTimes(5);
@@ -261,7 +275,7 @@ describe('runKtxCli', () => {
         expect(sl).toHaveBeenLastCalledWith(expect.objectContaining({
             command: 'query',
             projectDir: tempDir,
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             runtimeInstallPolicy: 'prompt',
             query: expect.objectContaining({ measures: ['orders.order_count'], dimensions: [] }),
         }), promptIo.io);
@@ -270,13 +284,13 @@ describe('runKtxCli', () => {
             sl,
         })).resolves.toBe(0);
         expect(sl).toHaveBeenLastCalledWith(expect.objectContaining({
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             runtimeInstallPolicy: 'auto',
         }), autoIo.io);
         const noInputIo = makeIo();
         await expect(runKtxCli(['--project-dir', tempDir, 'sl', 'query', '--measure', 'orders.order_count', '--no-input'], noInputIo.io, { sl })).resolves.toBe(0);
         expect(sl).toHaveBeenLastCalledWith(expect.objectContaining({
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             runtimeInstallPolicy: 'never',
         }), noInputIo.io);
     });
@@ -389,7 +403,7 @@ describe('runKtxCli', () => {
                 skipAgents: false,
                 inputMode: 'auto',
                 yes: false,
-                cliVersion: '0.0.0-private',
+                cliVersion: '0.1.0-rc.1',
                 skipLlm: false,
                 skipEmbeddings: false,
                 databaseSchemas: [],
@@ -498,7 +512,7 @@ describe('runKtxCli', () => {
             inputMode: 'disabled',
             depth: 'fast',
             queryHistory: 'default',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             runtimeInstallPolicy: 'never',
         }, testIo.io);
         expect(testIo.stderr()).toBe(`Project: ${tempDir}\n`);
@@ -517,11 +531,32 @@ describe('runKtxCli', () => {
             inputMode: 'auto',
             depth: 'deep',
             queryHistory: 'default',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             runtimeInstallPolicy: 'prompt',
         }, testIo.io);
         expect(testIo.stderr()).toBe('');
     });
+    it('routes public ingest --yes as automatic runtime installation', async () => {
+        const testIo = makeIo();
+        const publicIngest = vi.fn().mockResolvedValue(0);
+        await expect(runKtxCli(['--project-dir', tempDir, 'ingest', 'warehouse', '--yes'], testIo.io, {
+            publicIngest,
+        })).resolves.toBe(0);
+        expect(publicIngest).toHaveBeenCalledWith(expect.objectContaining({
+            projectDir: tempDir,
+            targetConnectionId: 'warehouse',
+            runtimeInstallPolicy: 'auto',
+        }), testIo.io);
+    });
+    it('rejects conflicting public ingest runtime install modes', async () => {
+        const testIo = makeIo();
+        const publicIngest = vi.fn().mockResolvedValue(0);
+        await expect(runKtxCli(['--project-dir', tempDir, 'ingest', 'warehouse', '--yes', '--no-input'], testIo.io, {
+            publicIngest,
+        })).resolves.toBe(1);
+        expect(publicIngest).not.toHaveBeenCalled();
+        expect(testIo.stderr()).toContain('Choose only one runtime install mode: --yes or --no-input');
+    });
     it('rejects mutually exclusive public ingest depth flags before dispatch', async () => {
         const testIo = makeIo();
         const publicIngest = vi.fn().mockResolvedValue(0);
@@ -545,7 +580,7 @@ describe('runKtxCli', () => {
             json: false,
             inputMode: 'disabled',
             queryHistory: 'default',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             runtimeInstallPolicy: 'never',
         }, testIo.io);
     });
@@ -750,7 +785,7 @@ describe('runKtxCli', () => {
             command: 'run',
             projectDir: tempDir,
             inputMode: 'disabled',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             anthropicApiKeyEnv: 'ANTHROPIC_API_KEY', // pragma: allowlist secret
             anthropicModel: 'claude-sonnet-4-6',
             skipLlm: false,
@@ -777,7 +812,7 @@ describe('runKtxCli', () => {
             command: 'run',
             projectDir: tempDir,
             inputMode: 'disabled',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             llmBackend: 'vertex',
             vertexProject: 'local-gcp-project',
             vertexLocation: 'us-east5',
@@ -802,7 +837,7 @@ describe('runKtxCli', () => {
             command: 'run',
             projectDir: tempDir,
             inputMode: 'disabled',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             llmBackend: 'claude-code',
             llmModel: 'opus',
             skipLlm: false,
@@ -877,7 +912,7 @@ describe('runKtxCli', () => {
             projectDir: '/tmp/project',
             inputMode: 'disabled',
             yes: true,
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             skipLlm: true,
             skipEmbeddings: true,
             databaseDrivers: ['postgres'],
@@ -1080,7 +1115,7 @@ describe('runKtxCli', () => {
             queryFile: '/tmp/query.json',
             execute: false,
             format: 'json',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             runtimeInstallPolicy: 'auto',
         }, autoIo.io);
         expect(sl).toHaveBeenNthCalledWith(2, {
@@ -1090,7 +1125,7 @@ describe('runKtxCli', () => {
             queryFile: '/tmp/query.json',
             execute: false,
             format: 'json',
-            cliVersion: '0.0.0-private',
+            cliVersion: '0.1.0-rc.1',
             runtimeInstallPolicy: 'never',
         }, neverIo.io);
         expect(conflictIo.stderr()).toContain('Choose only one runtime install mode: --yes or --no-input');

package/dist/ingest.js

@@ -1,4 +1,4 @@
-import { buildMemoryFlowViewModel, createMemoryFlowLiveBuffer, formatMemoryFlowFinalSummary, getLatestLocalIngestStatus, getLocalIngestStatus, ingestReportToMemoryFlowReplay, renderMemoryFlowReplay, runLocalIngest, runLocalMetabaseIngest, savedMemoryCountsForReport, } from '@ktx/context/ingest';
+import { buildMemoryFlowViewModel, createMemoryFlowLiveBuffer, formatMemoryFlowFinalSummary, getLatestLocalIngestStatus, getLocalIngestStatus, ingestReportToMemoryFlowReplay, renderMemoryFlowReplay, runLocalIngest, runLocalMetabaseIngest, savedMemoryCountsForReport, sanitizeMemoryFlowError, } from '@ktx/context/ingest';
 import { loadKtxProject } from '@ktx/context/project';
 import { createKtxCliIngestQueryExecutor } from './ingest-query-executor.js';
 import { readIngestReportSnapshotFile } from './ingest-report-file.js';
@@ -10,7 +10,7 @@ import { resolveVizFallback, warnVizFallbackOnce } from './viz-fallback.js';
 import { profileMark } from './startup-profile.js';
 profileMark('module:ingest');
 function reportStatus(report) {
-    return report.body.failedWorkUnits.length > 0 ? 'error' : 'done';
+    return report.body.status === 'failed' || report.body.failedWorkUnits.length > 0 ? 'error' : 'done';
 }
 const REPORT_SOURCE_LABELS = new Map([
     ['live-database', 'Database schema'],
@@ -33,17 +33,83 @@ function reportSourceLabel(sourceKey) {
         .map((part) => `${part[0]?.toUpperCase() ?? ''}${part.slice(1)}`)
         .join(' ');
 }
+function jsonObjectFromFailureReason(reason) {
+    const trimmed = reason.trim();
+    const start = trimmed.indexOf('{');
+    const end = trimmed.lastIndexOf('}');
+    if (start < 0 || end < start) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed.slice(start, end + 1));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+function isGoogleReauthFailure(record) {
+    const error = stringField(record, 'error')?.toLowerCase() ?? '';
+    const description = stringField(record, 'error_description')?.toLowerCase() ?? '';
+    const subtype = stringField(record, 'error_subtype')?.toLowerCase() ?? '';
+    return error === 'invalid_grant' && (description.includes('reauth') || subtype === 'invalid_rapt');
+}
+function formatFailureReason(sourceKey, reason) {
+    const parsed = jsonObjectFromFailureReason(reason);
+    if (!parsed) {
+        return sanitizeMemoryFlowError(reason);
+    }
+    if (sourceKey === 'historic-sql' && isGoogleReauthFailure(parsed)) {
+        return 'Google Cloud authentication failed while analyzing query history: application-default credentials expired or require reauthentication (invalid_grant / invalid_rapt). Run `gcloud auth application-default login`, then retry.';
+    }
+    const error = stringField(parsed, 'error');
+    const description = stringField(parsed, 'error_description');
+    const subtype = stringField(parsed, 'error_subtype');
+    const parts = [error, description].filter((part) => Boolean(part));
+    const message = parts.length > 0 ? parts.join(': ') : reason;
+    return subtype ? `${message} (${subtype})` : message;
+}
+function failedReportMessage(report) {
+    if (report.body.status === 'failed' && report.body.failure?.message) {
+        return sanitizeMemoryFlowError(report.body.failure.message);
+    }
+    const failedCount = report.body.failedWorkUnits.length;
+    if (failedCount === 0) {
+        return null;
+    }
+    const firstFailure = report.body.workUnits.find((workUnit) => workUnit.status === 'failed' && typeof workUnit.reason === 'string' && workUnit.reason.trim());
+    const sourceLabel = reportSourceLabel(report.sourceKey);
+    const prefix = `${sourceLabel} failed for ${pluralize(failedCount, 'task')}.`;
+    if (!firstFailure?.reason) {
+        return prefix;
+    }
+    return `${prefix} First failure: ${formatFailureReason(report.sourceKey, firstFailure.reason)}`;
+}
 function writeReportStatus(report, io) {
     const counts = savedMemoryCountsForReport(report);
+    const failedMessage = failedReportMessage(report);
     io.stdout.write(`Report: ${report.id}\n`);
     io.stdout.write(`Run: ${report.runId}\n`);
     io.stdout.write(`Job: ${report.jobId}\n`);
+    if (report.body.tracePath) {
+        io.stdout.write(`Trace: ${report.body.tracePath}\n`);
+    }
     io.stdout.write(`Status: ${reportStatus(report)}\n`);
     io.stdout.write(`Source: ${reportSourceLabel(report.sourceKey)}\n`);
     io.stdout.write(`Connection: ${report.connectionId}\n`);
     io.stdout.write(`Sync: ${report.body.syncId}\n`);
     io.stdout.write(`Diff: +${report.body.diffSummary.added}/~${report.body.diffSummary.modified}/-${report.body.diffSummary.deleted}/=${report.body.diffSummary.unchanged}\n`);
     io.stdout.write(`Tasks: ${report.body.workUnits.length}\n`);
+    if (report.body.failedWorkUnits.length > 0) {
+        io.stdout.write(`Failed tasks: ${report.body.failedWorkUnits.length}\n`);
+    }
+    if (failedMessage) {
+        io.stdout.write(`Error: ${failedMessage}\n`);
+    }
     io.stdout.write(`Saved memory: ${counts.wikiCount} wiki, ${counts.slCount} SL\n`);
     io.stdout.write(`Provenance rows: ${report.body.provenanceRows.length}\n`);
 }
@@ -106,7 +172,11 @@ function formatDiffProgress(event) {
     return `+${event.added}/~${event.modified}/-${event.deleted}/=${event.unchanged}`;
 }
 function workUnitEventsThrough(snapshot, eventIndex) {
-    return snapshot.events.slice(0, eventIndex + 1);
+    const latestPlanIndex = snapshot.events
+        .slice(0, eventIndex + 1)
+        .findLastIndex((event) => event.type === 'chunks_planned');
+    const startIndex = latestPlanIndex >= 0 ? latestPlanIndex + 1 : 0;
+    return snapshot.events.slice(startIndex, eventIndex + 1);
 }
 function completedWorkUnitCountThrough(snapshot, eventIndex) {
     return workUnitEventsThrough(snapshot, eventIndex).filter((event) => event.type === 'work_unit_finished').length;
@@ -127,7 +197,8 @@ function plannedWorkUnitCountThrough(snapshot, eventIndex) {
     if (snapshot.plannedWorkUnits.length > 0) {
         return snapshot.plannedWorkUnits.length;
     }
-    const planEvent = workUnitEventsThrough(snapshot, eventIndex)
+    const planEvent = snapshot.events
+        .slice(0, eventIndex + 1)
         .filter((event) => event.type === 'chunks_planned')
         .at(-1);
     return planEvent?.workUnitCount ?? completedWorkUnitCountThrough(snapshot, eventIndex);
@@ -167,6 +238,12 @@ function plainIngestEventProgress(event, snapshot, eventIndex) {
             };
         case 'stage_skipped':
             return { percent: 45, message: `Skipped ${event.stage}: ${event.reason}` };
+        case 'stage_progress':
+            return {
+                percent: event.percent,
+                message: event.message,
+                ...(event.transient !== undefined ? { transient: event.transient } : {}),
+            };
         case 'work_unit_started': {
             const total = plannedWorkUnitCountThrough(snapshot, eventIndex);
             const ordinal = workUnitOrdinalThrough(snapshot, eventIndex, event.unitKey);
@@ -431,26 +508,54 @@ export async function runKtxIngest(args, io = process, deps = {}) {
             }
             if (args.adapter === 'metabase') {
                 const executeMetabaseFanout = deps.runLocalMetabaseIngest ?? runLocalMetabaseIngest;
+                const runOutputMode = effectiveIngestOutputMode(args.outputMode, io, env, {
+                    requireInput: (args.inputMode ?? 'auto') === 'auto',
+                });
+                const plainProgress = shouldWritePlainIngestProgress(runOutputMode, io, env)
+                    ? createPlainIngestProgressRenderer(args, io)
+                    : null;
+                const structuredProgress = deps.progress
+                    ? createPlainIngestProgressObserver(args, deps.progress)
+                    : null;
+                const initialMemoryFlow = plainProgress || structuredProgress ? initialRunMemoryFlowInput(args, 'pending') : undefined;
+                const memoryFlow = initialMemoryFlow
+                    ? createMemoryFlowLiveBuffer(initialMemoryFlow, {
+                        onChange: (snapshot) => {
+                            plainProgress?.update(snapshot);
+                            structuredProgress?.update(snapshot);
+                        },
+                    })
+                    : undefined;
                 const progress = args.outputMode === 'json' && !deps.progress
                     ? undefined
                     : createMetabaseFanoutProgress(args.connectionId, args.outputMode === 'json'
                         ? { ...io, stderr: { write: () => undefined } }
                         : io, deps.progress);
-                const result = await executeMetabaseFanout({
-                    project: ingestProject,
-                    adapters: createAdapters(ingestProject, adapterOptions),
-                    metabaseConnectionId: args.connectionId,
-                    ...localIngestOptions,
-                    queryExecutor,
-                    trigger: 'manual_resync',
-                    jobIdFactory: deps.jobIdFactory,
-                    ...(progress ? { progress } : {}),
-                });
-                if (args.outputMode === 'json') {
-                    io.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+                plainProgress?.start();
+                structuredProgress?.start();
+                let result;
+                try {
+                    result = await executeMetabaseFanout({
+                        project: ingestProject,
+                        adapters: createAdapters(ingestProject, adapterOptions),
+                        metabaseConnectionId: args.connectionId,
+                        ...localIngestOptions,
+                        queryExecutor,
+                        trigger: 'manual_resync',
+                        jobIdFactory: deps.jobIdFactory,
+                        ...(memoryFlow ? { memoryFlow } : {}),
+                        ...(progress ? { progress } : {}),
+                    });
+                    plainProgress?.flush();
+                    if (args.outputMode === 'json') {
+                        io.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+                    }
+                    else {
+                        writeMetabaseFanoutStatus(result, io);
+                    }
                 }
-                else {
-                    writeMetabaseFanoutStatus(result, io);
+                finally {
+                    plainProgress?.flush();
                 }
                 return result.status === 'all_succeeded' ? 0 : 1;
             }

package/dist/ingest.test.js

@@ -12,6 +12,11 @@ describe('runKtxIngest', () => {
     let tempDir;
     let originalTerm;
     const interactiveEnv = () => ({ ...process.env, CI: 'false' });
+    const runtimeReady = (projectDir) => ({
+        status: 'ready',
+        projectDir,
+        requirements: { features: ['core'], requirements: [] },
+    });
     beforeEach(async () => {
         resetVizFallbackWarningsForTest();
         originalTerm = process.env.TERM;
@@ -203,6 +208,7 @@ describe('runKtxIngest', () => {
                 historicSqlProbe: async () => ({ ok: true, lines: ['PASS Historic SQL probe skipped in test'] }),
             },
             context: async () => ({ status: 'skipped', projectDir }),
+            runtime: async () => runtimeReady(projectDir),
         })).resolves.toBe(0);
         const sourceDir = join(tempDir, 'source');
         await mkdir(join(sourceDir, 'orders'), { recursive: true });
@@ -485,6 +491,106 @@ describe('runKtxIngest', () => {
         expect(io.stdout()).toContain('"status": "all_succeeded"');
         expect(io.stderr()).not.toContain('Metabase ingest: prod-metabase');
     });
+    it('emits structured child ingest progress during Metabase fan-out', async () => {
+        const projectDir = join(tempDir, 'project');
+        await writeMetabaseConfig(projectDir);
+        const io = makeIo();
+        const progressEvents = [];
+        await expect(runKtxIngest({
+            command: 'run',
+            projectDir,
+            connectionId: 'prod-metabase',
+            adapter: 'metabase',
+            outputMode: 'json',
+        }, io.io, {
+            progress: (event) => progressEvents.push(event),
+            runLocalMetabaseIngest: async (input) => {
+                input.progress?.onMetabaseFanoutPlanned?.({
+                    metabaseConnectionId: 'prod-metabase',
+                    children: [{ metabaseDatabaseId: 1, targetConnectionId: 'warehouse_a' }],
+                });
+                input.progress?.onMetabaseChildStarted?.({
+                    metabaseConnectionId: 'prod-metabase',
+                    metabaseDatabaseId: 1,
+                    targetConnectionId: 'warehouse_a',
+                    jobId: 'metabase-child-1',
+                });
+                input.memoryFlow?.update({
+                    plannedWorkUnits: [
+                        {
+                            unitKey: 'metabase-col-6',
+                            rawFiles: ['cards/40.json'],
+                            peerFileCount: 0,
+                            dependencyCount: 0,
+                        },
+                    ],
+                });
+                input.memoryFlow?.emit({ type: 'chunks_planned', chunkCount: 1, workUnitCount: 1, evictionCount: 0 });
+                input.memoryFlow?.emit({
+                    type: 'work_unit_started',
+                    unitKey: 'metabase-col-6',
+                    skills: ['sl_capture'],
+                    stepBudget: 40,
+                });
+                input.memoryFlow?.emit({
+                    type: 'work_unit_step',
+                    unitKey: 'metabase-col-6',
+                    stepIndex: 7,
+                    stepBudget: 40,
+                });
+                input.memoryFlow?.emit({
+                    type: 'stage_progress',
+                    stage: 'integration',
+                    percent: 81,
+                    message: 'Resolving text conflict for metabase-col-6',
+                });
+                input.memoryFlow?.emit({ type: 'work_unit_finished', unitKey: 'metabase-col-6', status: 'success' });
+                input.memoryFlow?.update({
+                    plannedWorkUnits: [
+                        {
+                            unitKey: 'metabase-col-7',
+                            rawFiles: ['cards/48.json'],
+                            peerFileCount: 0,
+                            dependencyCount: 0,
+                        },
+                    ],
+                });
+                input.memoryFlow?.emit({ type: 'chunks_planned', chunkCount: 1, workUnitCount: 1, evictionCount: 0 });
+                input.memoryFlow?.emit({
+                    type: 'work_unit_started',
+                    unitKey: 'metabase-col-7',
+                    skills: ['sl_capture'],
+                    stepBudget: 40,
+                });
+                input.progress?.onMetabaseChildCompleted?.({
+                    metabaseConnectionId: 'prod-metabase',
+                    metabaseDatabaseId: 1,
+                    targetConnectionId: 'warehouse_a',
+                    jobId: 'metabase-child-1',
+                    status: 'done',
+                });
+                return {
+                    metabaseConnectionId: 'prod-metabase',
+                    status: 'all_succeeded',
+                    totals: { workUnits: 1, failedWorkUnits: 0 },
+                    children: [],
+                };
+            },
+        })).resolves.toBe(0);
+        expect(progressEvents).toEqual(expect.arrayContaining([
+            { percent: 45, message: 'Planned 1 task' },
+            { percent: 55, message: 'Processing 1/1 tasks: metabase-col-6' },
+            {
+                percent: 60,
+                message: 'Processing tasks: 0/1 complete, 1 active; latest metabase-col-6 step 7/40',
+                transient: true,
+            },
+            { percent: 81, message: 'Resolving text conflict for metabase-col-6' },
+            { percent: 81, message: 'Processing 1/1 tasks: metabase-col-7' },
+        ]));
+        expect(io.stdout()).toContain('"status": "all_succeeded"');
+        expect(io.stderr()).not.toContain('Metabase ingest: prod-metabase');
+    });
     it('runs Metabase scheduled ingest through the public CLI command path with real fan-out', async () => {
         const projectDir = join(tempDir, 'metabase-cli-project');
         await writeWarehouseConfig(projectDir);
@@ -759,6 +865,106 @@ describe('runKtxIngest', () => {
         expect(io.stderr()).toBe('');
         expect(io.stdout()).toContain('Status: error\n');
     });
+    it('prints trace path and error status for stored failed ingest reports', async () => {
+        const projectDir = join(tempDir, 'project');
+        await writeWarehouseConfig(projectDir);
+        const io = makeIo();
+        const report = {
+            id: 'report-failed',
+            runId: 'run-failed',
+            jobId: 'job-failed',
+            connectionId: 'warehouse',
+            sourceKey: 'metabase',
+            createdAt: '2026-05-17T12:00:00.000Z',
+            body: {
+                status: 'failed',
+                syncId: 'sync-failed',
+                diffSummary: { added: 1, modified: 0, deleted: 0, unchanged: 0 },
+                commitSha: null,
+                tracePath: '/project/.ktx/ingest-traces/job-failed/trace.jsonl',
+                failure: { phase: 'final_gates', message: 'final artifact gates failed' },
+                workUnits: [],
+                failedWorkUnits: [],
+                reconciliationSkipped: true,
+                conflictsResolved: [],
+                evictionsApplied: [],
+                unmappedFallbacks: [],
+                evictionInputs: [],
+                unresolvedCards: [],
+                supersededBy: null,
+                overrideOf: null,
+                provenanceRows: [],
+                toolTranscripts: [],
+            },
+        };
+        await runKtxIngest({
+            command: 'status',
+            projectDir,
+            reportFile: '/project/report-failed.json',
+            runId: 'run-failed',
+            outputMode: 'plain',
+            inputMode: 'disabled',
+        }, io.io, {
+            readReportFile: vi.fn().mockResolvedValue(report),
+        });
+        expect(io.stdout()).toContain('Trace: /project/.ktx/ingest-traces/job-failed/trace.jsonl');
+        expect(io.stdout()).toContain('Status: error');
+        expect(io.stdout()).toContain('Error: final artifact gates failed');
+    });
+    it('prints a clear first failure reason when query-history work units fail', async () => {
+        const projectDir = join(tempDir, 'project');
+        await writeWarehouseConfig(projectDir);
+        const rawReason = '{"error":"invalid_grant","error_description":"reauth related error (invalid_rapt)","error_uri":"https://support.google.com/a/answer/9368756","error_subtype":"invalid_rapt"}';
+        const runLocal = vi.fn(async (input) => {
+            const failedWorkUnit = {
+                ...localFakeBundleReport('query-history-failed').body.workUnits[0],
+                unitKey: 'historic-sql-table-orders',
+                rawFiles: ['tables/orders.json'],
+                status: 'failed',
+                reason: rawReason,
+                actions: [],
+                touchedSlSources: [],
+            };
+            const report = localFakeBundleReport('query-history-failed', {
+                id: 'report-query-history-failed',
+                runId: 'run-query-history-failed',
+                connectionId: input.connectionId,
+                sourceKey: 'historic-sql',
+                body: {
+                    workUnits: [failedWorkUnit],
+                    failedWorkUnits: [failedWorkUnit.unitKey],
+                },
+            });
+            return {
+                result: {
+                    jobId: 'query-history-failed',
+                    runId: report.runId,
+                    syncId: report.body.syncId,
+                    diffSummary: report.body.diffSummary,
+                    workUnitCount: report.body.workUnits.length,
+                    failedWorkUnits: report.body.failedWorkUnits,
+                    artifactsWritten: report.body.provenanceRows.length,
+                    commitSha: report.body.commitSha,
+                },
+                report,
+            };
+        });
+        const io = makeIo();
+        await expect(runKtxIngest({
+            command: 'run',
+            projectDir,
+            connectionId: 'warehouse',
+            adapter: 'historic-sql',
+            outputMode: 'plain',
+        }, io.io, {
+            runLocalIngest: runLocal,
+            jobIdFactory: () => 'query-history-failed',
+        })).resolves.toBe(1);
+        expect(io.stdout()).toContain('Status: error\n');
+        expect(io.stdout()).toContain('Failed tasks: 1\n');
+        expect(io.stdout()).toContain('Error: Query history failed for 1 task. First failure: Google Cloud authentication failed while analyzing query history: application-default credentials expired or require reauthentication (invalid_grant / invalid_rapt). Run `gcloud auth application-default login`, then retry.');
+        expect(io.stdout()).not.toContain('error_uri');
+    });
     it('passes the debug LLM request file to local ingest runs', async () => {
         const projectDir = join(tempDir, 'project');
         await writeWarehouseConfig(projectDir);