@kaelio/ktx 0.11.0 → 0.13.0

package/dist/managed-python-http.js

@@ -12,7 +12,7 @@ function normalizedBaseUrl(baseUrl) {
 function parseJsonObject(raw, path) {
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(`KTX daemon HTTP ${path} returned non-object JSON`);
+        throw new Error(`ktx daemon HTTP ${path} returned non-object JSON`);
     }
     return parsed;
 }
@@ -35,7 +35,7 @@ async function postManagedDaemonJson(baseUrl, path, payload) {
                 const text = Buffer.concat(chunks).toString('utf8');
                 const statusCode = response.statusCode ?? 0;
                 if (statusCode < 200 || statusCode >= 300) {
-                    reject(new Error(`KTX daemon HTTP ${path} failed with ${statusCode}: ${text}`));
+                    reject(new Error(`ktx daemon HTTP ${path} failed with ${statusCode}: ${text}`));
                     return;
                 }
                 try {
@@ -72,7 +72,7 @@ export function createManagedPythonDaemonBaseUrlResolver(options) {
             force: false,
         });
         const verb = daemon.status === 'started' ? 'Started' : 'Using existing';
-        writePrefixedLines((chunk) => options.io.stderr.write(chunk), `${verb} KTX daemon: ${daemon.baseUrl}`);
+        writePrefixedLines((chunk) => options.io.stderr.write(chunk), `${verb} ktx daemon: ${daemon.baseUrl}`);
         cachedBaseUrl = daemon.baseUrl;
         return cachedBaseUrl;
     };

package/dist/managed-python-runtime.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { type ManagedUvArtifact, type ManagedUvPlatformKey } from './managed-uv-release.js';
 export declare const runtimeFeatureSchema: z.ZodEnum<{
     core: "core";
     "local-embeddings": "local-embeddings";
@@ -92,6 +93,7 @@ export interface ManagedPythonRuntimeInstallOptions extends ManagedPythonRuntime
     features: KtxRuntimeFeature[];
     force?: boolean;
     exec?: ManagedPythonRuntimeExec;
+    fetchUvArtifact?: ManagedUvFetchArtifact;
 }
 export interface ManagedPythonRuntimeInstallResult {
     status: 'ready' | 'installed';
@@ -113,8 +115,22 @@ export interface ManagedPythonRuntimeDoctorCheck {
     detail: string;
     fix?: string;
 }
+export type ManagedUvFetchArtifact = (url: string) => Promise<Uint8Array>;
 /** @internal */
-export declare const MISSING_UV_RUNTIME_INSTALL_MESSAGE = "uv is required to install the KTX Python runtime. KTX does not download uv automatically. Install uv, make sure it is on PATH, and retry: ktx admin runtime install --yes";
+export interface ManagedUvRelease {
+    version: string;
+    artifacts: Partial<Record<ManagedUvPlatformKey, ManagedUvArtifact>>;
+}
+/** @internal */
+export interface EnsureManagedUvOptions {
+    platform?: NodeJS.Platform;
+    arch?: string;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    runtimeRoot?: string;
+    fetchArtifact?: ManagedUvFetchArtifact;
+    release?: ManagedUvRelease;
+}
 /** @internal */
 export declare function managedPythonRuntimeLayout(options: ManagedPythonRuntimeLayoutOptions): ManagedPythonRuntimeLayout;
 export declare function managedPythonDaemonLayout(options: ManagedPythonDaemonLayoutOptions): ManagedPythonDaemonLayout;
@@ -122,9 +138,22 @@ export declare function managedPythonDaemonLayout(options: ManagedPythonDaemonLa
 export declare function verifyRuntimeAsset(input: {
     assetDir: string;
 }): Promise<ManagedRuntimeAsset>;
+/** @internal */
+export declare function managedUvPath(options?: EnsureManagedUvOptions): string;
+/**
+ * ktx provisions its own pinned uv under the runtime root; uv on PATH is never
+ * consulted, so runtime installs behave identically on every machine. All
+ * failures here are environment outcomes (offline host, intercepting proxy,
+ * unsupported platform) and stay out of Error Tracking via KtxExpectedError —
+ * except a pin/layout mismatch inside a checksum-verified archive, which is a
+ * ktx release fault and must reach Error Tracking.
+ * @internal
+ */
+export declare function ensureManagedUv(options?: EnsureManagedUvOptions): Promise<string>;
 export declare function installManagedPythonRuntime(options: ManagedPythonRuntimeInstallOptions): Promise<ManagedPythonRuntimeInstallResult>;
 export declare function readManagedPythonRuntimeStatus(options: ManagedPythonRuntimeLayoutOptions): Promise<ManagedPythonRuntimeStatus>;
 export declare function doctorManagedPythonRuntime(options: ManagedPythonRuntimeLayoutOptions & {
     exec?: ManagedPythonRuntimeExec;
+    fetchUvArtifact?: ManagedUvFetchArtifact;
 }): Promise<ManagedPythonRuntimeDoctorCheck[]>;
 export {};

package/dist/managed-python-runtime.js

@@ -1,12 +1,14 @@
 import { execFile } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { access, appendFile, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { access, appendFile, chmod, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { basename, join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
-import { strFromU8, unzipSync } from 'fflate';
+import { gunzipSync, strFromU8, unzipSync } from 'fflate';
 import { z } from 'zod';
+import { KtxExpectedError } from './errors.js';
+import { MANAGED_UV_ARTIFACTS, MANAGED_UV_VERSION, } from './managed-uv-release.js';
 const execFileAsync = promisify(execFile);
 export const runtimeFeatureSchema = z.enum(['core', 'local-embeddings']);
 const runtimeAssetManifestSchema = z.object({
@@ -32,8 +34,10 @@ const installedRuntimeManifestSchema = z.object({
     }),
     installLog: z.string().min(1),
 });
-/** @internal */
-export const MISSING_UV_RUNTIME_INSTALL_MESSAGE = 'uv is required to install the KTX Python runtime. KTX does not download uv automatically. Install uv, make sure it is on PATH, and retry: ktx admin runtime install --yes';
+const PINNED_UV_RELEASE = {
+    version: MANAGED_UV_VERSION,
+    artifacts: MANAGED_UV_ARTIFACTS,
+};
 function defaultAssetDir() {
     return fileURLToPath(new URL('../assets/python/', import.meta.url));
 }
@@ -144,7 +148,7 @@ export async function verifyRuntimeAsset(input) {
             throw new Error([
                 `Missing bundled Python runtime manifest: ${manifestPath}`,
                 'In a source checkout, build the local runtime assets with: pnpm run artifacts:build',
-                'Then retry the runtime-backed KTX command.',
+                'Then retry the runtime-backed ktx command.',
             ].join('\n'));
         }
         throw error;
@@ -221,13 +225,123 @@ async function runLogged(input) {
 function managedRuntimeUvEnv(baseEnv) {
     return { ...baseEnv, UV_NO_CONFIG: '1' };
 }
-async function ensureUv(exec, env) {
+function managedUvBinaryName(platform) {
+    return platform === 'win32' ? 'uv.exe' : 'uv';
+}
+/** @internal */
+export function managedUvPath(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? homedir();
+    const runtimeRoot = options.runtimeRoot ?? runtimeRootFor({ env, homeDir });
+    const version = (options.release ?? PINNED_UV_RELEASE).version;
+    return join(runtimeRoot, 'uv', version, managedUvBinaryName(platform));
+}
+async function defaultFetchUvArtifact(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+    }
+    return new Uint8Array(await response.arrayBuffer());
+}
+function readTarField(block, start, length) {
+    const field = block.subarray(start, start + length);
+    const end = field.indexOf(0);
+    return strFromU8(end < 0 ? field : field.subarray(0, end));
+}
+function findTarEntry(archive, matches) {
+    let offset = 0;
+    while (offset + 512 <= archive.length) {
+        const block = archive.subarray(offset, offset + 512);
+        const name = readTarField(block, 0, 100);
+        if (!name) {
+            return undefined;
+        }
+        const size = Number.parseInt(readTarField(block, 124, 12).trim() || '0', 8);
+        if (matches(name)) {
+            return archive.subarray(offset + 512, offset + 512 + size);
+        }
+        offset += 512 + Math.ceil(size / 512) * 512;
+    }
+    return undefined;
+}
+function extractUvFromArchive(input) {
+    const entry = input.file.endsWith('.zip')
+        ? unzipSync(input.contents)[input.binaryName]
+        : findTarEntry(gunzipSync(input.contents), (name) => name === input.binaryName || name.endsWith(`/${input.binaryName}`));
+    if (!entry) {
+        throw new Error(`uv archive ${input.file} is missing the ${input.binaryName} binary`);
+    }
+    return entry;
+}
+/**
+ * ktx provisions its own pinned uv under the runtime root; uv on PATH is never
+ * consulted, so runtime installs behave identically on every machine. All
+ * failures here are environment outcomes (offline host, intercepting proxy,
+ * unsupported platform) and stay out of Error Tracking via KtxExpectedError —
+ * except a pin/layout mismatch inside a checksum-verified archive, which is a
+ * ktx release fault and must reach Error Tracking.
+ * @internal
+ */
+export async function ensureManagedUv(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const arch = options.arch ?? process.arch;
+    const release = options.release ?? PINNED_UV_RELEASE;
+    const binaryName = managedUvBinaryName(platform);
+    const uvPath = managedUvPath(options);
+    if (await pathExists(uvPath)) {
+        return uvPath;
+    }
+    const artifact = release.artifacts[`${platform}-${arch}`];
+    if (!artifact) {
+        throw new KtxExpectedError(`ktx does not bundle uv for ${platform}-${arch}. Place a uv ${release.version} binary at ${uvPath} and retry: ktx admin runtime install --yes`);
+    }
+    const url = `https://github.com/astral-sh/uv/releases/download/${release.version}/${artifact.file}`;
+    let contents;
     try {
-        const result = await exec('uv', ['--version'], { env });
-        return result.stdout.trim() || 'uv available';
+        contents = await (options.fetchArtifact ?? defaultFetchUvArtifact)(url);
     }
-    catch {
-        throw new Error(MISSING_UV_RUNTIME_INSTALL_MESSAGE);
+    catch (error) {
+        throw new KtxExpectedError(`ktx could not download uv ${release.version} (required to install the ktx Python runtime). ` +
+            'Check network access to github.com and retry: ktx admin runtime install --yes. ' +
+            `Air-gapped hosts: place the uv binary at ${uvPath}.`, { cause: error });
+    }
+    const sha256 = createHash('sha256').update(contents).digest('hex');
+    if (sha256 !== artifact.sha256) {
+        throw new KtxExpectedError(`Downloaded uv ${release.version} failed checksum verification (a proxy or captive portal may have altered the download). Retry: ktx admin runtime install --yes`);
+    }
+    const binary = extractUvFromArchive({ file: artifact.file, contents, binaryName });
+    await mkdir(dirname(uvPath), { recursive: true });
+    const stagedPath = `${uvPath}.${process.pid}.download`;
+    await writeFile(stagedPath, binary);
+    await chmod(stagedPath, 0o755);
+    try {
+        await rename(stagedPath, uvPath);
+    }
+    catch (error) {
+        // On Windows a concurrent install may have won the rename; the binary at
+        // uvPath is checksum-pinned identical, so reuse it.
+        await rm(stagedPath, { force: true });
+        if (!(await pathExists(uvPath))) {
+            throw error;
+        }
+    }
+    return uvPath;
+}
+async function ensureUv(input) {
+    const uvPath = await ensureManagedUv({
+        platform: input.options.platform,
+        env: input.options.env,
+        homeDir: input.options.homeDir,
+        runtimeRoot: input.options.runtimeRoot,
+        fetchArtifact: input.options.fetchUvArtifact,
+    });
+    try {
+        const result = await input.exec(uvPath, ['--version'], { env: input.uvEnv });
+        return { uvPath, version: result.stdout.trim() || `uv ${MANAGED_UV_VERSION}` };
+    }
+    catch (error) {
+        throw new KtxExpectedError(`Managed uv at ${uvPath} failed to run. Delete it and retry: ktx admin runtime install --yes`, { cause: error });
     }
 }
 export async function installManagedPythonRuntime(options) {
@@ -246,21 +360,23 @@ export async function installManagedPythonRuntime(options) {
         (await pathExists(existing.python.daemonExecutable))) {
         return { status: 'ready', layout, asset, manifest: existing };
     }
+    // uv is acquired before the version dir is wiped, so a failed acquisition
+    // never destroys a previously installed runtime.
+    const { uvPath } = await ensureUv({ exec, uvEnv, options });
     await rm(layout.versionDir, { recursive: true, force: true });
     await mkdir(layout.versionDir, { recursive: true });
     await writeFile(layout.installLogPath, '');
-    await ensureUv(exec, uvEnv);
     await runLogged({
         exec,
         logPath: layout.installLogPath,
-        command: 'uv',
+        command: uvPath,
         args: ['python', 'install', asset.requiresPython.minimumVersion],
         env: uvEnv,
     });
     await runLogged({
         exec,
         logPath: layout.installLogPath,
-        command: 'uv',
+        command: uvPath,
         args: ['venv', '--python', asset.requiresPython.minimumVersion, layout.venvDir],
         env: uvEnv,
     });
@@ -268,7 +384,7 @@ export async function installManagedPythonRuntime(options) {
     await runLogged({
         exec,
         logPath: layout.installLogPath,
-        command: 'uv',
+        command: uvPath,
         args: ['pip', 'install', '--python', layout.pythonPath, wheelSpec],
         env: uvEnv,
     });
@@ -326,15 +442,15 @@ export async function doctorManagedPythonRuntime(options) {
     const exec = options.exec ?? defaultExec;
     const checks = [];
     try {
-        const version = await ensureUv(exec, managedRuntimeUvEnv(options.env ?? process.env));
-        checks.push(check('pass', { id: 'uv', label: 'uv', detail: version }));
+        const uv = await ensureUv({ exec, uvEnv: managedRuntimeUvEnv(options.env ?? process.env), options });
+        checks.push(check('pass', { id: 'uv', label: 'uv', detail: `${uv.version} (managed: ${uv.uvPath})` }));
     }
     catch (error) {
         checks.push(check('fail', {
             id: 'uv',
             label: 'uv',
             detail: error instanceof Error ? error.message : String(error),
-            fix: 'Install uv, make sure it is on PATH, and run: ktx admin runtime install --yes',
+            fix: 'Check network access to github.com and run: ktx admin runtime install --yes',
         }));
     }
     try {

package/dist/managed-uv-release.d.ts

@@ -0,0 +1,7 @@
+export type ManagedUvPlatformKey = 'darwin-arm64' | 'darwin-x64' | 'linux-arm64' | 'linux-x64' | 'win32-arm64' | 'win32-x64';
+export interface ManagedUvArtifact {
+    file: string;
+    sha256: string;
+}
+export declare const MANAGED_UV_VERSION = "0.11.21";
+export declare const MANAGED_UV_ARTIFACTS: Record<ManagedUvPlatformKey, ManagedUvArtifact>;

package/dist/managed-uv-release.js

@@ -0,0 +1,11 @@
+// Generated by scripts/refresh-uv-manifest.mjs. Do not edit by hand.
+// Regenerate with: node scripts/refresh-uv-manifest.mjs [<uv-version>]
+export const MANAGED_UV_VERSION = '0.11.21';
+export const MANAGED_UV_ARTIFACTS = {
+    'darwin-arm64': { file: 'uv-aarch64-apple-darwin.tar.gz', sha256: '1f921d491ba5ffeea774eb04d6681ecee379101341cbb1500394993b541bf3f4' }, // pragma: allowlist secret
+    'darwin-x64': { file: 'uv-x86_64-apple-darwin.tar.gz', sha256: 'f3c8e5708a84b920c18b691214d54d2b0da6b984789caae95d47c95120cb7765' }, // pragma: allowlist secret
+    'linux-arm64': { file: 'uv-aarch64-unknown-linux-musl.tar.gz', sha256: 'e71badaed2a2c3a404a0a00974b51c7ed5f5bc7be947916846005b739c68a5a2' }, // pragma: allowlist secret
+    'linux-x64': { file: 'uv-x86_64-unknown-linux-musl.tar.gz', sha256: '9dadff5b9e7b1d2d011e41852a1cbca713d9d5d88194f2eb6bd240fa4fb0a719' }, // pragma: allowlist secret
+    'win32-arm64': { file: 'uv-aarch64-pc-windows-msvc.zip', sha256: '74e443f8004022dde57a1bd0d10c097830f9ea8feb4ec927db52cd5d805c2f48' }, // pragma: allowlist secret
+    'win32-x64': { file: 'uv-x86_64-pc-windows-msvc.zip', sha256: 'ace861f360c6de2babedc1607d0f454b6b09a820dbc8182dc15af927e4df9589' }, // pragma: allowlist secret
+};

package/dist/mcp-http-server.js

@@ -38,7 +38,7 @@ function fullOrigin(value) {
 }
 export function buildMcpSecurityConfig(input) {
     if (!isLoopbackHost(input.host) && !input.token) {
-        throw new Error(`Binding KTX MCP to ${input.host} requires --token or KTX_MCP_TOKEN`);
+        throw new Error(`Binding ktx MCP to ${input.host} requires --token or KTX_MCP_TOKEN`);
     }
     const allowedHostSet = new Set(DEFAULT_ALLOWED_HOSTS);
     if (!isLoopbackHost(input.host)) {
@@ -63,16 +63,16 @@ function headerValue(headers, name) {
 export function isMcpRequestAuthorized(request, config) {
     const host = headerValue(request.headers, 'host');
     if (!host || !config.allowedHosts.includes(normalizeHostHeader(host))) {
-        return { ok: false, status: 403, message: 'Host header is not allowed for KTX MCP.' };
+        return { ok: false, status: 403, message: 'Host header is not allowed for ktx MCP.' };
     }
     const origin = headerValue(request.headers, 'origin');
     if (origin && !config.allowedOrigins.includes(origin)) {
-        return { ok: false, status: 403, message: 'Origin header is not allowed for KTX MCP.' };
+        return { ok: false, status: 403, message: 'Origin header is not allowed for ktx MCP.' };
     }
     if (request.path === '/mcp' && config.token) {
         const auth = headerValue(request.headers, 'authorization');
         if (auth !== `Bearer ${config.token}`) {
-            return { ok: false, status: 401, message: 'Missing or invalid KTX MCP bearer token.' };
+            return { ok: false, status: 401, message: 'Missing or invalid ktx MCP bearer token.' };
         }
     }
     return { ok: true };

package/dist/mcp-server-factory.js

@@ -5,7 +5,7 @@ import { createLocalProjectMemoryIngest } from './context/memory/local-memory.js
 import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
 import { createKtxCliIngestQueryExecutor } from './ingest-query-executor.js';
 import { createKtxCliScanConnector } from './local-scan-connectors.js';
-import { createManagedPythonSemanticLayerComputePort } from './managed-python-command.js';
+import { createLazyManagedPythonSemanticLayerComputePort } from './managed-python-command.js';
 import { createManagedDaemonSqlAnalysisPort } from './managed-python-http.js';
 function noopMcpIo() {
     return {
@@ -16,7 +16,7 @@ function noopMcpIo() {
 export async function createKtxMcpServerFactory(input) {
     const io = input.io ?? noopMcpIo();
     const queryExecutor = createKtxCliIngestQueryExecutor(input.project);
-    const semanticLayerCompute = await createManagedPythonSemanticLayerComputePort({
+    const semanticLayerCompute = createLazyManagedPythonSemanticLayerComputePort({
         cliVersion: input.cliVersion,
         installPolicy: 'auto',
         io,
@@ -54,7 +54,7 @@ export async function createKtxMcpServerFactory(input) {
         });
     }
     catch (error) {
-        io.stderr.write(`KTX MCP memory_ingest disabled: ${error instanceof Error ? error.message : String(error)}\n`);
+        io.stderr.write(`ktx MCP memory_ingest disabled: ${error instanceof Error ? error.message : String(error)}\n`);
     }
     return () => createDefaultKtxMcpServer({
         name: 'ktx',

package/dist/mcp-stdio-server.js

@@ -37,7 +37,7 @@ export async function runKtxMcpStdioServer(options) {
         };
         transport.onclose = () => settle(resolve);
         transport.onerror = (error) => {
-            options.io?.stderr.write(`KTX MCP stdio transport error: ${error.message}\n`);
+            options.io?.stderr.write(`ktx MCP stdio transport error: ${error.message}\n`);
             settle(() => reject(error));
         };
         stdin.once('end', closeTransport);

package/dist/memory-flow-hud.js

@@ -198,7 +198,7 @@ export function ActivityFeed(props) {
     const barWidth = Math.min(40, props.width - 20);
     return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [!diffEvent && !workStarted && (_jsxs(Text, { color: props.theme.active, children: [spinner(props.frame), " Connecting to ", src.type.toLowerCase(), "..."] })), diffEvent && (_jsxs(Text, { color: props.theme.complete, children: ["\u2713 Connected \u2014 found ", src.sourceCount, " ", src.itemNounPlural, " to ingest"] })), diffEvent && isIncremental && (_jsx(Text, { color: props.theme.complete, children: "\u2713 Compared with last sync \u2014 only re-analyzing what changed" })), diffEvent && !planEvent && !workStarted && (_jsxs(Text, { color: props.theme.active, children: [spinner(props.frame), " Grouping related ", src.itemNounPlural, " together for deeper analysis..."] })), planEvent && (_jsxs(Text, { color: props.theme.complete, children: ["\u2713 Grouped into ", planEvent.chunkCount, " business area", planEvent.chunkCount === 1 ? '' : 's'] })), workStarted && !allWorkDone && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { color: props.theme.active, children: [spinner(props.frame), " Ingesting \u2014 ", finishedAreas, "/", totalChunks || '?', " business area", totalChunks === 1 ? '' : 's', " done"] }), _jsxs(Text, { color: props.theme.muted, children: ['  ', src.ingestDescription] }), totalChunks > 0 && (_jsxs(Text, { color: props.theme.active, children: ['  ', progressBarOverall(finishedAreas, actives.length, totalChunks, barWidth, props.frame)] }))] })), insights.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: props.theme.text, children: "  Created so far:" }), insights.map((insight, idx) => (_jsxs(Text, { color: props.theme.muted, children: ['    ', insight.icon, " ", insight.text] }, `result-${idx}`)))] })), isReconciling && (_jsxs(Text, { color: props.theme.active, children: [spinner(props.frame), " Deduplicating \u2014 removing overlaps between business areas and checking for conflicts..."] })), reconEvent && (_jsxs(Text, { color: props.theme.complete, children: ["\u2713 Deduplicated", reconEvent.conflictCount > 0
                         ? ` — ${reconEvent.conflictCount} conflict${reconEvent.conflictCount === 1 ? '' : 's'} resolved`
-                        : ' — no conflicts'] })), isSaving && (_jsxs(Text, { color: props.theme.active, children: [spinner(props.frame), " Saving to context layer..."] })), savedEvent && (_jsx(Text, { color: props.theme.complete, children: "\u2713 Saved \u2014 your agents can now use the KTX context layer" })), props.showCompletion && (isDone || isError) && (_jsx(CompletionSummary, { input: props.input, theme: props.theme, frame: props.completionFrame, holdComplete: props.holdComplete }))] }));
+                        : ' — no conflicts'] })), isSaving && (_jsxs(Text, { color: props.theme.active, children: [spinner(props.frame), " Saving to context layer..."] })), savedEvent && (_jsx(Text, { color: props.theme.complete, children: "\u2713 Saved \u2014 your agents can now use the ktx context layer" })), props.showCompletion && (isDone || isError) && (_jsx(CompletionSummary, { input: props.input, theme: props.theme, frame: props.completionFrame, holdComplete: props.holdComplete }))] }));
 }
 function CompletionSummary(props) {
     const saved = [...props.input.events].reverse().find((e) => e.type === 'saved');
@@ -207,5 +207,5 @@ function CompletionSummary(props) {
     const isError = props.input.status === 'error';
     const sl = counterValue(slCount, props.frame);
     const wiki = counterValue(wikiCount, props.frame);
-    return (_jsx(Box, { flexDirection: "column", marginTop: 1, children: isError ? (_jsx(Text, { bold: true, color: props.theme.failed, children: "\u2717 Something went wrong \u2014 review the errors above." })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: props.theme.border, children: '─'.repeat(60) }), _jsx(Text, { bold: true, color: props.theme.complete, children: "\u2605 KTX finished ingesting your data" }), (sl > 0 || wiki > 0) && (_jsxs(_Fragment, { children: [_jsx(Text, {}), _jsx(Text, { color: props.theme.text, children: "KTX created:" }), sl > 0 && (_jsxs(Text, { color: props.theme.active, children: ['  ', "\uD83D\uDCCA ", sl, " query definition", sl === 1 ? '' : 's', " \u2014 so agents can write accurate SQL for your data"] })), wiki > 0 && (_jsxs(Text, { color: props.theme.complete, children: ['  ', "\uD83D\uDCDD ", wiki, " wiki page", wiki === 1 ? '' : 's', " \u2014 so agents understand your business context"] }))] })), _jsx(Text, {}), _jsx(Text, { color: props.theme.text, children: "What to do next:" }), formatNextStepLines().map((line) => (_jsx(Text, { color: props.theme.active, children: line }, line))), props.holdComplete && (_jsxs(_Fragment, { children: [_jsx(Text, {}), _jsx(Text, { color: props.theme.muted, children: "Press q to exit" })] }))] })) }));
+    return (_jsx(Box, { flexDirection: "column", marginTop: 1, children: isError ? (_jsx(Text, { bold: true, color: props.theme.failed, children: "\u2717 Something went wrong \u2014 review the errors above." })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: props.theme.border, children: '─'.repeat(60) }), _jsx(Text, { bold: true, color: props.theme.complete, children: "\u2605 ktx finished ingesting your data" }), (sl > 0 || wiki > 0) && (_jsxs(_Fragment, { children: [_jsx(Text, {}), _jsx(Text, { color: props.theme.text, children: "ktx created:" }), sl > 0 && (_jsxs(Text, { color: props.theme.active, children: ['  ', "\uD83D\uDCCA ", sl, " query definition", sl === 1 ? '' : 's', " \u2014 so agents can write accurate SQL for your data"] })), wiki > 0 && (_jsxs(Text, { color: props.theme.complete, children: ['  ', "\uD83D\uDCDD ", wiki, " wiki page", wiki === 1 ? '' : 's', " \u2014 so agents understand your business context"] }))] })), _jsx(Text, {}), _jsx(Text, { color: props.theme.text, children: "What to do next:" }), formatNextStepLines().map((line) => (_jsx(Text, { color: props.theme.active, children: line }, line))), props.holdComplete && (_jsxs(_Fragment, { children: [_jsx(Text, {}), _jsx(Text, { color: props.theme.muted, children: "Press q to exit" })] }))] })) }));
 }

package/dist/next-steps.js

@@ -31,7 +31,7 @@ function commandLines(commands, indent) {
 }
 export function formatNextStepLines(indent = '  ') {
     return [
-        `${indent}KTX context is ready for agents. Open your coding agent from the KTX project directory and ask a data question.`,
+        `${indent}ktx context is ready for agents. Open your coding agent from the ktx project directory and ask a data question.`,
         `${indent}Verify with:`,
         ...commandLines(KTX_NEXT_STEP_DIRECT_COMMANDS, indent),
     ];
@@ -59,7 +59,7 @@ export function formatSetupNextStepLines(state, indent = '  ') {
     }
     if (!state.agentIntegrationReady) {
         return [
-            `${indent}KTX context is built. Install agent rules when you want your coding agent to use it.`,
+            `${indent}ktx context is built. Install agent rules when you want your coding agent to use it.`,
             `${indent}$ ${'ktx setup --agents'.padEnd(KTX_NEXT_STEP_COMMAND_WIDTH)}  Install CLI-based agent rules`,
             `${indent}$ ${'ktx status'.padEnd(KTX_NEXT_STEP_COMMAND_WIDTH)}  Check setup and context readiness`,
         ];

package/dist/prompt-navigation.d.ts

@@ -1,7 +1,24 @@
 /** @internal */
+export declare const MULTISELECT_NAVIGATION_FRAGMENTS: {
+    readonly move: "Up/Down to move";
+    readonly expand: "Right/Left to expand or collapse";
+    readonly select: "Tab to select or unselect";
+    readonly search: "Type to search";
+    readonly confirm: "Enter to confirm";
+    readonly back: "Escape to go back";
+    readonly backSearchableTree: "Escape to clear search or go back";
+    readonly exit: "Ctrl+C to exit";
+};
+/** @internal */
+export declare const FLAT_MULTISELECT_NAVIGATION_HINT: string;
+/** @internal */
+export declare const SEARCHABLE_MULTISELECT_NAVIGATION_HINT: string;
+export declare const TREE_PICKER_NAVIGATION_HINT: string;
+/** @internal */
 export declare function withMenuOptionSpacing(message: string): string;
 export declare function withMenuOptionsSpacing<T extends {
     message: string;
 }>(options: T): T;
 export declare function withMultiselectNavigation(message: string): string;
+export declare function withSearchableMultiselectNavigation(message: string): string;
 export declare function withTextInputNavigation(message: string): string;

package/dist/prompt-navigation.js

@@ -1,4 +1,44 @@
-const MULTISELECT_MENU_NAVIGATION_HINT = 'Use Up/Down to move, Space to select or unselect, Enter to confirm, Escape to go back, or Ctrl+C to exit.';
+/** @internal */
+export const MULTISELECT_NAVIGATION_FRAGMENTS = {
+    move: 'Up/Down to move',
+    expand: 'Right/Left to expand or collapse',
+    select: 'Tab to select or unselect',
+    search: 'Type to search',
+    confirm: 'Enter to confirm',
+    back: 'Escape to go back',
+    backSearchableTree: 'Escape to clear search or go back',
+    exit: 'Ctrl+C to exit',
+};
+function composeNavigationHint(fragments) {
+    return `${fragments.join(', ')}.`;
+}
+const fragment = MULTISELECT_NAVIGATION_FRAGMENTS;
+/** @internal */
+export const FLAT_MULTISELECT_NAVIGATION_HINT = composeNavigationHint([
+    fragment.move,
+    fragment.select,
+    fragment.confirm,
+    fragment.back,
+    fragment.exit,
+]);
+/** @internal */
+export const SEARCHABLE_MULTISELECT_NAVIGATION_HINT = composeNavigationHint([
+    fragment.move,
+    fragment.select,
+    fragment.search,
+    fragment.confirm,
+    fragment.back,
+    fragment.exit,
+]);
+export const TREE_PICKER_NAVIGATION_HINT = composeNavigationHint([
+    fragment.move,
+    fragment.expand,
+    fragment.select,
+    fragment.search,
+    fragment.confirm,
+    fragment.backSearchableTree,
+    fragment.exit,
+]);
 const TEXT_INPUT_NAVIGATION_HINT = 'Press Escape to go back.';
 function removeTrailingBlankLines(message) {
     return message.replace(/\n+$/, '');
@@ -45,10 +85,16 @@ export function withMenuOptionsSpacing(options) {
     return { ...options, message: withMenuOptionSpacing(options.message) };
 }
 export function withMultiselectNavigation(message) {
-    if (message.includes(MULTISELECT_MENU_NAVIGATION_HINT)) {
+    if (message.includes(FLAT_MULTISELECT_NAVIGATION_HINT)) {
+        return message;
+    }
+    return `${message}\n${FLAT_MULTISELECT_NAVIGATION_HINT}`;
+}
+export function withSearchableMultiselectNavigation(message) {
+    if (message.includes(SEARCHABLE_MULTISELECT_NAVIGATION_HINT)) {
         return message;
     }
-    return `${message}\n${MULTISELECT_MENU_NAVIGATION_HINT}`;
+    return `${message}\n${SEARCHABLE_MULTISELECT_NAVIGATION_HINT}`;
 }
 export function withTextInputNavigation(message) {
     const messageWithoutHint = removeTrailingBlankLines(message)

package/dist/prompts/memory_agent_bundle_ingest_work_unit.md

@@ -2,7 +2,7 @@
 You are processing ONE WorkUnit of a multi-file ingest bundle. The WorkUnit
 gives you a slice of raw source files (LookML views, dbt/MetricFlow YAMLs,
 Metabase card JSONs, Notion pages, or similar) and you must translate that
-slice into KTX semantic-layer sources and/or knowledge wiki pages, in one pass.
+slice into ktx semantic-layer sources and/or knowledge wiki pages, in one pass.
 You run in an isolated WorkUnit worktree. Deterministic projection output,
 existing project memory, and listed dependency paths are visible; sibling
 WorkUnit edits from this same job are not visible until the runner integrates
@@ -10,7 +10,7 @@ accepted patches.
 </role>
 
 <stance>
-Assertive. The bundle was explicitly submitted for ingest. Default to capturing everything the raw files declare that maps cleanly to KTX: one SL source per table/view, one wiki page per non-obvious business rule or alias. Do not abandon a WorkUnit because "some content overlaps with another WU"; use `ingest_triage` to reconcile, do not skip.
+Assertive. The bundle was explicitly submitted for ingest. Default to capturing everything the raw files declare that maps cleanly to ktx: one SL source per table/view, one wiki page per non-obvious business rule or alias. Do not abandon a WorkUnit because "some content overlaps with another WU"; use `ingest_triage` to reconcile, do not skip.
 </stance>
 
 <workflow>

package/dist/prompts/memory_agent_external_ingest.md

@@ -1,5 +1,5 @@
 <role>
-You are ingesting an external technical artifact (a LookML view, dbt model, schema description, business glossary, or other reference document) into KTX organizational memory. The user has explicitly submitted this content for bulk ingest. Assume it is intentional and worth capturing.
+You are ingesting an external technical artifact (a LookML view, dbt model, schema description, business glossary, or other reference document) into ktx organizational memory. The user has explicitly submitted this content for bulk ingest. Assume it is intentional and worth capturing.
 </role>
 
 <stance>
@@ -18,7 +18,7 @@ A single artifact typically produces multiple actions: one SL source per table/v
 </workflow>
 
 <scope>
-All wiki writes go to the GLOBAL scope - they will be visible to every user of this KTX project. Phrase wiki pages as objective business knowledge, not personal preference. The `wiki_write` tool handles scope selection automatically for external ingest.
+All wiki writes go to the GLOBAL scope - they will be visible to every user of this ktx project. Phrase wiki pages as objective business knowledge, not personal preference. The `wiki_write` tool handles scope selection automatically for external ingest.
 </scope>
 
 <do_not>

package/dist/public-ingest-copy.js

@@ -7,7 +7,7 @@ const DATABASE_INGEST_REPLACEMENTS = [
     [/\bWriting schema artifacts\b/gi, 'Writing schema context'],
     [/\bEnriching schema metadata\b/gi, 'Building enriched schema context'],
     [
-        /\bKTX scan enrichment failed after structural scan completed\b/gi,
+        /\bktx scan enrichment failed after structural scan completed\b/gi,
         'Database enrichment failed after schema context completed',
     ],
     [/\bstructural scan\b/gi, 'schema context'],

package/dist/public-ingest.js

@@ -535,8 +535,8 @@ function createPlainPublicIngestProgress(io, options) {
     };
 }
 const INTERNAL_STATUS_LINE_RE = /^(Report|Run|Job|Status|Adapter|Connection|Sync|Diff|Tasks|Work units|Failed tasks|Saved memory|Provenance rows):\s*/;
-const ACTIONABLE_FAILURE_LINE_RE = /^(Missing bundled Python runtime manifest|KTX Python runtime is required|KTX daemon HTTP|Error:|Failed\b|Could not\b|Cannot\b)/;
-const RUNTIME_BACKED_RETRY_LINE_RE = /^Then retry the runtime-backed KTX command\.?$/;
+const ACTIONABLE_FAILURE_LINE_RE = /^(Missing bundled Python runtime manifest|ktx Python runtime is required|ktx daemon HTTP|Error:|Failed\b|Could not\b|Cannot\b)/;
+const RUNTIME_BACKED_RETRY_LINE_RE = /^Then retry the runtime-backed ktx command\.?$/;
 function trimErrorPrefix(line) {
     return line.replace(/^Error:\s*/, '');
 }
@@ -545,7 +545,7 @@ function capturedFailureMessage(output) {
         .split(/\r?\n/)
         .map((line) => line.trim())
         .filter((line) => line.length > 0)
-        .filter((line) => !line.startsWith('KTX scan completed'))
+        .filter((line) => !line.startsWith('ktx scan completed'))
         .filter((line) => !INTERNAL_STATUS_LINE_RE.test(line))
         .map(publicIngestOutputLine);
     const actionableIndex = lines.findIndex((line) => ACTIONABLE_FAILURE_LINE_RE.test(line));

package/dist/release-version.js

@@ -1,7 +1,7 @@
 const semverPattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 export function assertCliVersion(value, source) {
     if (typeof value !== 'string' || !semverPattern.test(value)) {
-        throw new Error(`Invalid KTX CLI version in ${source}`);
+        throw new Error(`Invalid ktx CLI version in ${source}`);
     }
     return value;
 }

package/dist/runtime-requirements.js

@@ -44,7 +44,7 @@ export function resolveProjectRuntimeRequirements(config, options = {}) {
         requirements.push({
             feature: 'core',
             reason: 'database-introspection',
-            detail: 'Database introspection fallback uses the KTX daemon.',
+            detail: 'Database introspection fallback uses the ktx daemon.',
         });
     }
     for (const [connectionId, connection] of Object.entries(config.connections)) {