@kaelio/ktx 0.4.0 → 0.5.0

package/dist/memory-flow-hud.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryFlowReplayInput } from '@ktx/context/ingest/memory-flow';
+import type { MemoryFlowReplayInput } from './context/ingest/memory-flow/types.js';
 import { type ReactNode } from 'react';
 interface HudTheme {
     text: string;

package/dist/memory-flow-interactive.d.ts

@@ -1,4 +1,4 @@
-import { type MemoryFlowInteractionCommand, type MemoryFlowInteractionState, type MemoryFlowReplayInput } from '@ktx/context/ingest';
+import type { MemoryFlowInteractionCommand, MemoryFlowInteractionState, MemoryFlowReplayInput } from './context/ingest/memory-flow/types.js';
 interface KtxMemoryFlowKey {
     name?: string;
     ctrl?: boolean;
@@ -24,6 +24,7 @@ interface KtxMemoryFlowInteractiveIo {
 interface RenderMemoryFlowInteractiveOptions {
     prepareKeypressEvents?(stdin: KtxMemoryFlowStdin): void;
 }
+/** @internal */
 export declare function memoryFlowCommandForKey(chunk: string, search: MemoryFlowInteractionState['search'], key: KtxMemoryFlowKey): MemoryFlowInteractionCommand | null;
 export declare function renderMemoryFlowInteractively(input: MemoryFlowReplayInput, io: KtxMemoryFlowInteractiveIo, options?: RenderMemoryFlowInteractiveOptions): Promise<void>;
 export {};

package/dist/memory-flow-interactive.js

@@ -1,8 +1,11 @@
 import { emitKeypressEvents } from 'node:readline';
-import { buildMemoryFlowViewModel, createInitialMemoryFlowInteractionState, reduceMemoryFlowInteractionState, renderMemoryFlowInteractive, } from '@ktx/context/ingest';
+import { buildMemoryFlowViewModel } from './context/ingest/memory-flow/view-model.js';
+import { createInitialMemoryFlowInteractionState, reduceMemoryFlowInteractionState } from './context/ingest/memory-flow/interaction.js';
+import { renderMemoryFlowInteractive } from './context/ingest/memory-flow/interactive-render.js';
 function defaultPrepareKeypressEvents(stdin) {
     emitKeypressEvents(stdin);
 }
+/** @internal */
 export function memoryFlowCommandForKey(chunk, search, key) {
     if (search.editing) {
         if (key.name === 'escape')

package/dist/memory-flow-tui.d.ts

@@ -1,4 +1,4 @@
-import { type MemoryFlowInteractionCommand, type MemoryFlowInteractionState, type MemoryFlowReplayInput } from '@ktx/context/ingest';
+import type { MemoryFlowInteractionCommand, MemoryFlowInteractionState, MemoryFlowReplayInput } from './context/ingest/memory-flow/types.js';
 import { type ReactNode } from 'react';
 export interface KtxMemoryFlowTuiIo {
     stdin?: {
@@ -19,13 +19,14 @@ export interface MemoryFlowTuiLiveSession {
     close(): void;
     isClosed(): boolean;
 }
+/** @internal */
 export interface MemoryFlowInkInstance {
     rerender(tree: ReactNode): void;
     unmount(): void;
     waitUntilExit(): Promise<void>;
     clear?(): void;
 }
-export interface MemoryFlowInkRenderOptions {
+interface MemoryFlowInkRenderOptions {
     stdin?: KtxMemoryFlowTuiIo['stdin'];
     stdout: KtxMemoryFlowTuiIo['stdout'];
     stderr: KtxMemoryFlowTuiIo['stderr'];
@@ -69,7 +70,9 @@ interface MemoryFlowTuiAppProps {
     showBoot?: boolean;
 }
 export declare function sanitizeMemoryFlowTuiError(error: unknown): string;
+/** @internal */
 export declare function memoryFlowCommandForInkInput(input: string, key: InkKey, search?: MemoryFlowInteractionState['search']): MemoryFlowInteractionCommand | null;
+/** @internal */
 export declare function MemoryFlowTuiApp(props: MemoryFlowTuiAppProps): ReactNode;
 export declare function renderMemoryFlowTui(input: MemoryFlowReplayInput, io: KtxMemoryFlowTuiIo, options?: RenderMemoryFlowTuiOptions): Promise<boolean>;
 export declare function startLiveMemoryFlowTui(input: MemoryFlowReplayInput, io: KtxMemoryFlowTuiIo, options?: StartLiveMemoryFlowTuiOptions): Promise<MemoryFlowTuiLiveSession | null>;

package/dist/memory-flow-tui.js

@@ -1,6 +1,7 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 /* @jsxImportSource react */
-import { buildMemoryFlowViewModel, createInitialMemoryFlowInteractionState, findMemoryFlowSearchMatches, reduceMemoryFlowInteractionState, selectedMemoryFlowColumn, selectedMemoryFlowDetails, } from '@ktx/context/ingest';
+import { buildMemoryFlowViewModel } from './context/ingest/memory-flow/view-model.js';
+import { createInitialMemoryFlowInteractionState, findMemoryFlowSearchMatches, reduceMemoryFlowInteractionState, selectedMemoryFlowColumn, selectedMemoryFlowDetails, } from './context/ingest/memory-flow/interaction.js';
 import { Box, Text, render as renderInkRuntime, useApp, useInput } from 'ink';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { ActivityFeed, Hud, Logo, } from './memory-flow-hud.js';
@@ -50,6 +51,7 @@ export function sanitizeMemoryFlowTuiError(error) {
         .replace(/[a-z][a-z0-9+.-]*:\/\/[^\s]+/gi, '[redacted-url]')
         .replace(/\b(api[_-]?key|password|token|secret)=\S+/gi, '[redacted]');
 }
+/** @internal */
 export function memoryFlowCommandForInkInput(input, key, search = { editing: false, query: '', matchIndex: 0 }) {
     if (search.editing) {
         if (key.escape)
@@ -150,6 +152,7 @@ function TrustIssues(props) {
     }
     return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: props.theme.warning, children: "Validation notes" }), props.view.trustIssues.slice(0, 4).map((issue) => (_jsxs(Text, { color: issue.severity === 'failed' ? props.theme.failed : props.theme.warning, children: [issue.severity === 'failed' ? 'FAILED' : 'WARNING', " ", humanizeDemoText(issue.title), ":", ' ', humanizeDemoText(issue.detail)] }, `${issue.severity}-${issue.title}`)))] }));
 }
+/** @internal */
 export function MemoryFlowTuiApp(props) {
     const app = useApp();
     const totalEvents = props.input.events.length;

package/dist/next-steps.d.ts

@@ -1,3 +1,4 @@
+/** @internal */
 export declare const KTX_CONTEXT_BUILD_COMMANDS: readonly [{
     readonly command: "ktx ingest";
     readonly description: "Build or refresh agent-ready context from all configured connections";
@@ -15,6 +16,7 @@ export declare const KTX_NEXT_STEP_DIRECT_COMMANDS: readonly [{
     readonly command: "ktx wiki";
     readonly description: "Inspect generated wiki pages";
 }];
+/** @internal */
 export declare const KTX_NEXT_STEP_COMMANDS: readonly [{
     readonly command: "ktx status --json";
     readonly description: "Verify project setup and context readiness";
@@ -25,7 +27,6 @@ export declare const KTX_NEXT_STEP_COMMANDS: readonly [{
     readonly command: "ktx wiki";
     readonly description: "Inspect generated wiki pages";
 }];
-export declare const KTX_NEXT_STEP_COMMAND_WIDTH: number;
 export interface KtxSetupNextStepState {
     setupReady: boolean;
     hasContextTargets: boolean;

package/dist/next-steps.js

@@ -1,3 +1,4 @@
+/** @internal */
 export const KTX_CONTEXT_BUILD_COMMANDS = [
     {
         command: 'ktx ingest',
@@ -22,8 +23,9 @@ export const KTX_NEXT_STEP_DIRECT_COMMANDS = [
         description: 'Inspect generated wiki pages',
     },
 ];
+/** @internal */
 export const KTX_NEXT_STEP_COMMANDS = [...KTX_NEXT_STEP_DIRECT_COMMANDS];
-export const KTX_NEXT_STEP_COMMAND_WIDTH = Math.max(...[...KTX_CONTEXT_BUILD_COMMANDS, ...KTX_NEXT_STEP_COMMANDS].map((step) => step.command.length));
+const KTX_NEXT_STEP_COMMAND_WIDTH = Math.max(...[...KTX_CONTEXT_BUILD_COMMANDS, ...KTX_NEXT_STEP_COMMANDS].map((step) => step.command.length));
 function commandLines(commands, indent) {
     return commands.map((step) => `${indent}$ ${step.command.padEnd(KTX_NEXT_STEP_COMMAND_WIDTH)}  ${step.description}`);
 }

package/dist/notion-page-picker.d.ts

@@ -1,5 +1,5 @@
-import { type NotionApi } from '@ktx/context/ingest';
-import type { KtxProjectConnectionConfig } from '@ktx/context/project';
+import { type NotionApi } from './context/ingest/adapters/notion/notion-client.js';
+import type { KtxProjectConnectionConfig } from './context/project/config.js';
 import type { KtxCliIo } from './cli-runtime.js';
 import { type PickerState, type TreePickerNodeInput } from './tree-picker-state.js';
 import { type TreePickerChrome, type TreePickerResult, type TreePickerTuiIo } from './tree-picker-tui.js';
@@ -7,6 +7,7 @@ export interface PickNotionRootPagesArgs {
     connectionId: string;
     connection: KtxProjectConnectionConfig;
 }
+/** @internal */
 export type NotionPickerApi = Pick<NotionApi, 'search' | 'retrieveBotUser'>;
 export type NotionRootPagePickResult = {
     kind: 'selected';
@@ -22,8 +23,11 @@ export interface NotionRootPagePickerDeps {
     createNotionApi?: (authToken: string) => NotionPickerApi;
     renderPicker?: (chrome: TreePickerChrome, initialState: PickerState, io: TreePickerTuiIo) => Promise<TreePickerResult>;
 }
+/** @internal */
 export declare function normalizeNotionPageId(value: string): string;
+/** @internal */
 export declare function notionPickerPageFromSearchResult(result: Record<string, unknown>): TreePickerNodeInput;
+/** @internal */
 export declare function discoverNotionPickerPages(api: NotionPickerApi, options?: {
     cap?: number;
 }): Promise<{
@@ -31,5 +35,6 @@ export declare function discoverNotionPickerPages(api: NotionPickerApi, options?
     cappedAtCount: number | null;
     warnings: string[];
 }>;
+/** @internal */
 export declare function resolveNotionWorkspaceLabel(api: NotionPickerApi, connectionId: string): Promise<string>;
 export declare function pickNotionRootPages(args: PickNotionRootPagesArgs, io?: KtxCliIo, deps?: NotionRootPagePickerDeps): Promise<NotionRootPagePickResult>;

package/dist/notion-page-picker.js

@@ -1,5 +1,5 @@
-import { resolveNotionConnectionAuthToken } from '@ktx/context/connections';
-import { NotionClient } from '@ktx/context/ingest';
+import { resolveNotionConnectionAuthToken } from './context/connections/notion-config.js';
+import { NotionClient } from './context/ingest/adapters/notion/notion-client.js';
 import { profileMark } from './startup-profile.js';
 import { buildInitialState, buildPickerTree, flattenSelection, } from './tree-picker-state.js';
 import { renderTreePickerTui, } from './tree-picker-tui.js';
@@ -11,6 +11,7 @@ function assertSafeNotionPickerConnectionId(connectionId) {
         throw new Error(`Unsafe connection id: ${connectionId}`);
     }
 }
+/** @internal */
 export function normalizeNotionPageId(value) {
     const trimmed = value.trim();
     const compact = trimmed.includes('-') ? trimmed.replace(/-/g, '') : trimmed;
@@ -63,6 +64,7 @@ function extractParentPageId(page) {
     }
     return normalizeNotionPageId(parent.page_id);
 }
+/** @internal */
 export function notionPickerPageFromSearchResult(result) {
     const id = typeof result.id === 'string' ? normalizeNotionPageId(result.id) : '';
     if (!id) {
@@ -75,6 +77,7 @@ export function notionPickerPageFromSearchResult(result) {
         parentId: extractParentPageId(result),
     };
 }
+/** @internal */
 export async function discoverNotionPickerPages(api, options = {}) {
     const cap = options.cap ?? NOTION_PICKER_PAGE_CAP;
     const pages = [];
@@ -110,6 +113,7 @@ export async function discoverNotionPickerPages(api, options = {}) {
     }
     return { pages, cappedAtCount: cap, warnings };
 }
+/** @internal */
 export async function resolveNotionWorkspaceLabel(api, connectionId) {
     try {
         const bot = (await api.retrieveBotUser());

package/dist/print-command-tree.js

@@ -1,5 +1,6 @@
 import { fileURLToPath } from 'node:url';
 import { buildKtxProgram } from './cli-program.js';
+import { getKtxCliPackageInfo } from './cli-runtime.js';
 import { formatCommandTree, walkCommandTree } from './command-tree.js';
 function silentIo() {
     return {
@@ -7,18 +8,11 @@ function silentIo() {
         stderr: { write: () => { } },
     };
 }
-function stubPackageInfo() {
-    return {
-        name: '@ktx/cli',
-        version: '0.0.0-docs',
-        contextPackageName: '@ktx/context',
-    };
-}
 export function renderKtxCommandTree() {
     const program = buildKtxProgram({
         io: silentIo(),
         deps: {},
-        packageInfo: stubPackageInfo(),
+        packageInfo: getKtxCliPackageInfo(),
         runInit: async () => 0,
     });
     return formatCommandTree(walkCommandTree(program));

package/dist/prompt-navigation.d.ts

@@ -1,3 +1,4 @@
+/** @internal */
 export declare function withMenuOptionSpacing(message: string): string;
 export declare function withMenuOptionsSpacing<T extends {
     message: string;

package/dist/prompt-navigation.js

@@ -34,6 +34,7 @@ function withTextInputBodySpacing(message) {
     }
     return `${title}\n\n${bodyLines.join('\n')}`;
 }
+/** @internal */
 export function withMenuOptionSpacing(message) {
     if (!message.includes('\n') || message.endsWith('\n')) {
         return message;

package/dist/public-ingest.d.ts

@@ -1,5 +1,5 @@
-import { type KtxLocalProject } from '@ktx/context/project';
-import type { KtxProgressPort } from '@ktx/context/scan';
+import { type KtxLocalProject } from './context/project/project.js';
+import type { KtxProgressPort } from './context/scan/types.js';
 import type { KtxCliIo } from './index.js';
 import type { KtxIngestArgs, KtxIngestDeps, KtxIngestProgressUpdate } from './ingest.js';
 import { type KtxDatabaseContextDepth } from './ingest-depth.js';

package/dist/public-ingest.js

@@ -1,9 +1,12 @@
-import { loadKtxCliProject } from './cli-project.js';
+import { getKtxCliPackageInfo } from './cli-runtime.js';
+import { loadKtxProject } from './context/project/project.js';
 import { databaseContextDepth, deepReadinessGaps, isDatabaseDriver, normalizeConnectionDriver, } from './ingest-depth.js';
 import { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
 import { publicIngestOutputLine } from './public-ingest-copy.js';
 import { resolvePublicIngestRuntimeRequirements } from './runtime-requirements.js';
 import { profileMark } from './startup-profile.js';
+import { isDemoConnection } from './telemetry/demo-detect.js';
+import { emitProjectStackSnapshot, emitTelemetryEvent } from './telemetry/index.js';
 profileMark('module:public-ingest');
 const sourceAdapterByDriver = new Map([
     ['metabase', 'metabase'],
@@ -335,30 +338,82 @@ function markTargetResult(target, args, status, failedOperation, failureDetail)
         }),
     };
 }
+function markTargetWithSkippedQueryHistory(target, args, detail) {
+    const baseline = markTargetResult(target, args, 'done');
+    return {
+        ...baseline,
+        steps: baseline.steps.map((step) => step.operation === 'query-history' ? { ...step, status: 'skipped', detail } : step),
+    };
+}
+function queryHistoryFailureDetail(input) {
+    const captured = capturedFailureMessage(input.capturedOutput ?? '');
+    return failureDetailWithRetry({
+        target: input.target,
+        args: input.args,
+        failedOperation: 'query-history',
+        failureDetail: captured,
+    });
+}
 function resultFailed(result) {
     return result.steps.some((step) => step.status === 'failed');
 }
+function resultSkippedQueryHistory(result) {
+    const skipped = result.steps.find((step) => step.operation === 'query-history' && step.status === 'skipped' && step.detail !== undefined);
+    return skipped?.detail ? { connectionId: result.connectionId, detail: skipped.detail } : null;
+}
+function rowsBucket() {
+    return '<10k';
+}
+async function emitIngestCompleted(input) {
+    const failed = resultFailed(input.result);
+    await emitTelemetryEvent({
+        name: 'ingest_completed',
+        projectDir: input.args.projectDir,
+        io: input.io,
+        fields: {
+            driver: input.target.driver,
+            isDemoConnection: isDemoConnection(input.target.connectionId, input.project.config.connections[input.target.connectionId]),
+            schemaCount: 0,
+            tableCount: 0,
+            columnCount: 0,
+            rowsBucket: rowsBucket(),
+            durationMs: Math.max(0, performance.now() - input.startedAt),
+            outcome: failed ? 'error' : 'ok',
+        },
+    });
+}
 function stepStatus(result, operation) {
     return result.steps.find((step) => step.operation === operation)?.status ?? 'not-run';
 }
 function renderPlainResults(results, io) {
     const failures = results.filter(resultFailed);
-    io.stdout.write(failures.length > 0 ? 'Ingest finished with partial failures\n' : 'Ingest finished\n');
+    const skippedQueryHistory = results.map(resultSkippedQueryHistory).filter((entry) => entry !== null);
+    const headerSuffix = failures.length > 0
+        ? ' with partial failures'
+        : skippedQueryHistory.length > 0
+            ? ' with skipped query history'
+            : '';
+    io.stdout.write(`Ingest finished${headerSuffix}\n`);
     io.stdout.write('\n');
     io.stdout.write('Source         Database schema  Query history  Source ingest  Memory update\n');
     for (const result of results) {
         io.stdout.write(`${result.connectionId.padEnd(14)} ${stepStatus(result, 'database-schema').padEnd(16)} ${stepStatus(result, 'query-history').padEnd(14)} ${stepStatus(result, 'source-ingest').padEnd(14)} ${stepStatus(result, 'memory-update')}\n`);
     }
-    if (failures.length === 0) {
-        return;
+    if (failures.length > 0) {
+        io.stdout.write('\nFailed sources:\n');
+        for (const result of failures) {
+            const failedStep = result.steps.find((step) => step.status === 'failed');
+            if (!failedStep) {
+                continue;
+            }
+            io.stdout.write(`  ${failedStep.detail ?? `${result.connectionId} failed.`}\n`);
+        }
     }
-    io.stdout.write('\nFailed sources:\n');
-    for (const result of failures) {
-        const failedStep = result.steps.find((step) => step.status === 'failed');
-        if (!failedStep) {
-            continue;
+    if (skippedQueryHistory.length > 0) {
+        io.stdout.write('\nSkipped query history:\n');
+        for (const { detail } of skippedQueryHistory) {
+            io.stdout.write(`  ${detail}\n`);
         }
-        io.stdout.write(`  ${failedStep.detail ?? `${result.connectionId} failed.`}\n`);
     }
 }
 function hasInteractiveInput(io) {
@@ -501,8 +556,13 @@ export async function executePublicIngestTarget(target, args, io, deps) {
                 ? await runIngest(ingestArgs, ingestIo, ingestDeps)
                 : await runIngest(ingestArgs, ingestIo);
             if (qhExitCode !== 0) {
-                deps.onPhaseEnd?.('query-history', 'failed');
-                return markTargetResult(target, args, 'failed', 'query-history', capturedIngestIo ? capturedFailureMessage(capturedIngestIo.capturedOutput()) : undefined);
+                const detail = queryHistoryFailureDetail({
+                    target,
+                    args,
+                    capturedOutput: capturedIngestIo ? capturedIngestIo.capturedOutput() : undefined,
+                });
+                deps.onPhaseEnd?.('query-history', 'failed', detail);
+                return markTargetWithSkippedQueryHistory(target, args, detail);
             }
             deps.onPhaseEnd?.('query-history', 'done');
         }
@@ -536,22 +596,19 @@ export async function executePublicIngestTarget(target, args, io, deps) {
     return markTargetResult(target, args, exitCode === 0 ? 'done' : 'failed', 'source-ingest', capturedIngestIo ? capturedFailureMessage(capturedIngestIo.capturedOutput()) : undefined);
 }
 export async function runKtxPublicIngest(args, io, deps = {}) {
-    const loadProject = deps.loadProject ??
-        ((options) => loadKtxCliProject({
-            projectDir: options.projectDir,
-            cliVersion: args.cliVersion ?? '0.0.0-private',
-            installPolicy: args.runtimeInstallPolicy ?? 'never',
-            io,
-        }));
+    const loadProject = deps.loadProject ?? ((options) => loadKtxProject({ projectDir: options.projectDir }));
     const project = await loadProject({ projectDir: args.projectDir });
     if (shouldUseForegroundContextBuildView(args, io)) {
         const plan = buildPublicIngestPlan(project, args);
-        const requirements = resolvePublicIngestRuntimeRequirements(plan, { env: deps.env ?? process.env });
+        const requirements = resolvePublicIngestRuntimeRequirements(plan, {
+            config: project.config,
+            env: deps.env ?? process.env,
+        });
         const ensureRuntime = deps.ensureRuntime ?? ensureManagedPythonCommandRuntime;
         for (const feature of requirements.features) {
             try {
                 await ensureRuntime({
-                    cliVersion: args.cliVersion ?? '0.0.0-private',
+                    cliVersion: args.cliVersion ?? getKtxCliPackageInfo().version,
                     installPolicy: args.runtimeInstallPolicy ?? 'prompt',
                     io,
                     feature,
@@ -591,7 +648,10 @@ export async function runKtxPublicIngest(args, io, deps = {}) {
         }
     }
     for (const target of plan.targets) {
-        results.push(await executePublicIngestTarget(target, args, io, deps));
+        const startedAt = performance.now();
+        const result = await executePublicIngestTarget(target, args, io, deps);
+        results.push(result);
+        await emitIngestCompleted({ args, project, target, result, startedAt, io });
     }
     if (args.json) {
         io.stdout.write(`${JSON.stringify({ plan, results }, null, 2)}\n`);
@@ -599,5 +659,6 @@ export async function runKtxPublicIngest(args, io, deps = {}) {
     else {
         renderPlainResults(results, io);
     }
+    await emitProjectStackSnapshot({ projectDir: args.projectDir, io });
     return results.some(resultFailed) ? 1 : 0;
 }

package/dist/public-ingest.test.js

@@ -1,5 +1,9 @@
-import { buildDefaultKtxProjectConfig } from '@ktx/context/project';
-import { describe, expect, it, vi } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildDefaultKtxProjectConfig } from './context/project/config.js';
+import { initKtxProject } from './context/project/project.js';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import { buildPublicIngestPlan, runKtxPublicIngest, } from './public-ingest.js';
 function makeIo(options = {}) {
     let stdout = '';
@@ -325,6 +329,9 @@ describe('buildPublicIngestPlan', () => {
     });
 });
 describe('runKtxPublicIngest', () => {
+    afterEach(() => {
+        vi.unstubAllEnvs();
+    });
     it('maps fast and deep database targets to scan internals', async () => {
         const io = makeIo();
         const project = deepReadyProject({
@@ -336,6 +343,26 @@ describe('runKtxPublicIngest', () => {
         expect(runScan).toHaveBeenNthCalledWith(1, expect.objectContaining({ connectionId: 'deep', mode: 'enriched', detectRelationships: true }), expect.anything());
         expect(runScan).toHaveBeenNthCalledWith(2, expect.objectContaining({ connectionId: 'fast', mode: 'structural', detectRelationships: false }), expect.anything());
     });
+    it('emits debug telemetry for ingest targets and project snapshots without project paths', async () => {
+        vi.stubEnv('KTX_TELEMETRY_DEBUG', '1');
+        vi.stubEnv('CI', '');
+        const projectDir = await mkdtemp(join(tmpdir(), 'ktx-public-ingest-telemetry-'));
+        try {
+            await initKtxProject({ projectDir });
+            const io = makeIo({ isTTY: true });
+            const project = projectWithConnections({
+                warehouse: { driver: 'sqlite', path: join(projectDir, 'warehouse.sqlite') },
+            });
+            const code = await runKtxPublicIngest({ command: 'run', projectDir, targetConnectionId: 'warehouse', all: false, json: false, inputMode: 'disabled' }, io.io, { loadProject: vi.fn(async () => project), runScan: vi.fn(async () => 0) });
+            expect(code).toBe(0);
+            expect(io.stderr()).toContain('"event":"ingest_completed"');
+            expect(io.stderr()).toContain('"event":"project_stack_snapshot"');
+            expect(io.stderr()).not.toContain(projectDir);
+        }
+        finally {
+            await rm(projectDir, { recursive: true, force: true });
+        }
+    });
     it('runs query history after schema ingest with current-run window override', async () => {
         const io = makeIo();
         const runtimeIo = makeIo({ isTTY: true });
@@ -615,6 +642,52 @@ describe('runKtxPublicIngest', () => {
             feature: 'core',
         }));
     });
+    it('preflights foreground managed embeddings runtime before starting the context-build view', async () => {
+        const io = makeIo({ isTTY: true, interactive: true });
+        const config = buildDefaultKtxProjectConfig();
+        const project = {
+            projectDir: '/tmp/project',
+            config: {
+                ...config,
+                connections: {
+                    warehouse: { driver: 'postgres' },
+                },
+                ingest: {
+                    ...config.ingest,
+                    embeddings: {
+                        backend: 'sentence-transformers',
+                        model: 'all-MiniLM-L6-v2',
+                        dimensions: 384,
+                    },
+                },
+            },
+        };
+        const ensureRuntime = vi.fn(async () => {
+            return {};
+        });
+        const runContextBuild = vi.fn(async () => ({ exitCode: 0 }));
+        await expect(runKtxPublicIngest({
+            command: 'run',
+            projectDir: '/tmp/project',
+            targetConnectionId: 'warehouse',
+            all: false,
+            json: false,
+            inputMode: 'auto',
+            queryHistory: 'default',
+            cliVersion: '0.2.0',
+            runtimeInstallPolicy: 'prompt',
+        }, io.io, {
+            loadProject: vi.fn(async () => project),
+            ensureRuntime,
+            runContextBuild,
+        })).resolves.toBe(0);
+        expect(ensureRuntime).toHaveBeenCalledWith(expect.objectContaining({
+            cliVersion: '0.2.0',
+            installPolicy: 'prompt',
+            feature: 'local-embeddings',
+        }));
+        expect(runContextBuild).toHaveBeenCalled();
+    });
     it('runs all independent targets and reports partial failures', async () => {
         const io = makeIo();
         const project = projectWithConnections({
@@ -650,7 +723,7 @@ describe('runKtxPublicIngest', () => {
         expect(io.stdout()).toContain('Retry: ktx ingest warehouse --project-dir /tmp/project --fast');
         expect(io.stdout()).not.toContain('Debug:');
     });
-    it('prints query-history retry guidance for query-history facet failures', async () => {
+    it('skips the query-history facet but keeps the target green when query-history fails', async () => {
         const io = makeIo();
         const project = deepReadyProject({
             warehouse: { driver: 'postgres', context: { depth: 'deep' } },
@@ -668,9 +741,11 @@ describe('runKtxPublicIngest', () => {
             json: false,
             inputMode: 'disabled',
             queryHistory: 'enabled',
-        }, io.io, { loadProject: vi.fn(async () => project), runScan, runIngest })).resolves.toBe(1);
-        expect(io.stdout()).toMatch(/warehouse\s+done\s+failed\s+skipped\s+skipped/);
-        expect(io.stdout()).toContain('warehouse failed: Query history failed for 60 tasks. First failure: Google Cloud authentication failed while analyzing query history');
+        }, io.io, { loadProject: vi.fn(async () => project), runScan, runIngest })).resolves.toBe(0);
+        expect(io.stdout()).toContain('Ingest finished with skipped query history');
+        expect(io.stdout()).toMatch(/warehouse\s+done\s+skipped\s+skipped\s+skipped/);
+        expect(io.stdout()).toContain('Skipped query history:');
+        expect(io.stdout()).toContain('Query history failed for 60 tasks. First failure: Google Cloud authentication failed while analyzing query history');
         expect(io.stdout()).not.toContain('warehouse failed: Error:');
         expect(io.stdout()).toContain('Retry: ktx ingest warehouse --project-dir /tmp/project --deep --query-history');
         expect(io.stdout()).not.toContain('historic-sql');
@@ -695,7 +770,8 @@ describe('runKtxPublicIngest', () => {
             json: false,
             inputMode: 'disabled',
             queryHistory: 'enabled',
-        }, io.io, { loadProject: vi.fn(async () => project), runScan, runIngest })).resolves.toBe(1);
+        }, io.io, { loadProject: vi.fn(async () => project), runScan, runIngest })).resolves.toBe(0);
+        expect(io.stdout()).toContain('Ingest finished with skipped query history');
         expect(io.stdout()).toContain('Missing bundled Python runtime manifest');
         expect(io.stdout()).toContain('In a source checkout, build the local runtime assets with: pnpm run artifacts:build');
         expect(io.stdout()).toContain('Retry: ktx ingest warehouse --project-dir /tmp/project --deep --query-history');

package/dist/runtime-requirements.d.ts

@@ -1,4 +1,4 @@
-import type { KtxProjectConfig } from '@ktx/context/project';
+import type { KtxProjectConfig } from './context/project/config.js';
 import type { KtxRuntimeFeature } from './managed-python-runtime.js';
 import type { KtxPublicIngestPlan } from './public-ingest.js';
 type KtxRuntimeRequirementReason = 'query-history' | 'looker-source' | 'database-introspection' | 'local-embeddings';
@@ -16,6 +16,7 @@ export interface KtxProjectRuntimeRequirementOptions {
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
 }
 export interface KtxPublicIngestRuntimeRequirementOptions {
+    config?: KtxProjectConfig;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
 }
 export declare function resolveProjectRuntimeRequirements(config: KtxProjectConfig, options?: KtxProjectRuntimeRequirementOptions): KtxRuntimeRequirements;

package/dist/runtime-requirements.js

@@ -1,4 +1,3 @@
-import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL } from '@ktx/context';
 function normalizeDriver(driver) {
     return String(driver ?? '').trim().toLowerCase();
 }
@@ -22,7 +21,7 @@ function requiresManagedLocalEmbeddings(embeddings) {
         return false;
     }
     const baseUrl = embeddings.sentenceTransformers?.base_url;
-    return baseUrl === undefined || baseUrl === '' || baseUrl === MANAGED_SENTENCE_TRANSFORMERS_BASE_URL;
+    return baseUrl === undefined || baseUrl === '';
 }
 function uniqueRequirements(requirements) {
     const seen = new Set();
@@ -95,5 +94,12 @@ export function resolvePublicIngestRuntimeRequirements(plan, options = {}) {
             });
         }
     }
+    if (options.config && requiresManagedLocalEmbeddings(options.config.ingest.embeddings)) {
+        requirements.push({
+            feature: 'local-embeddings',
+            reason: 'local-embeddings',
+            detail: 'Local sentence-transformers embeddings use the managed Python runtime.',
+        });
+    }
     return uniqueRequirements(requirements);
 }

package/dist/runtime-requirements.test.js

@@ -1,5 +1,4 @@
-import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL } from '@ktx/context';
-import { buildDefaultKtxProjectConfig } from '@ktx/context/project';
+import { buildDefaultKtxProjectConfig } from './context/project/config.js';
 import { describe, expect, it } from 'vitest';
 import { resolveProjectRuntimeRequirements, resolvePublicIngestRuntimeRequirements, } from './runtime-requirements.js';
 describe('runtime requirement detection', () => {
@@ -37,7 +36,7 @@ describe('runtime requirement detection', () => {
                     model: 'all-MiniLM-L6-v2',
                     dimensions: 384,
                     sentenceTransformers: {
-                        base_url: MANAGED_SENTENCE_TRANSFORMERS_BASE_URL,
+                        base_url: '',
                     },
                 },
             },
@@ -45,6 +44,17 @@ describe('runtime requirement detection', () => {
         expect(resolveProjectRuntimeRequirements(config).features).toEqual(['local-embeddings']);
     });
     it('detects foreground ingest runtime needs from selected query-history targets', () => {
+        const config = {
+            ...buildDefaultKtxProjectConfig(),
+            ingest: {
+                ...buildDefaultKtxProjectConfig().ingest,
+                embeddings: {
+                    backend: 'sentence-transformers',
+                    model: 'all-MiniLM-L6-v2',
+                    dimensions: 384,
+                },
+            },
+        };
         expect(resolvePublicIngestRuntimeRequirements({
             projectDir: '/tmp/project',
             warnings: [],
@@ -58,6 +68,6 @@ describe('runtime requirement detection', () => {
                     queryHistory: { enabled: true },
                 },
             ],
-        }).features).toEqual(['core']);
+        }, { config }).features).toEqual(['core', 'local-embeddings']);
     });
 });