@kaelio/ktx 0.1.0 → 0.2.0

package/dist/managed-python-daemon.js

@@ -5,6 +5,7 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { promisify } from 'node:util';
 import { z } from 'zod';
 import { installManagedPythonRuntime, managedPythonDaemonLayout, runtimeFeatureSchema, } from './managed-python-runtime.js';
+import { sanitizeChildProxyEnv } from './proxy-env.js';
 const execFileAsync = promisify(execFile);
 const daemonStateSchema = z.object({
     schemaVersion: z.literal(1),
@@ -483,10 +484,10 @@ export async function startManagedPythonDaemon(options) {
         const child = spawnDaemon(installed.manifest.python.daemonExecutable, ['serve-http', '--host', '127.0.0.1', '--port', String(port)], {
             detached: true,
             stdio: ['ignore', stdout.fd, stderr.fd],
-            env: {
+            env: sanitizeChildProxyEnv({
                 ...process.env,
                 KTX_DAEMON_VERSION: options.cliVersion,
-            },
+            }),
         });
         child.unref();
         if (!child.pid) {

package/dist/managed-python-daemon.test.js

@@ -59,6 +59,7 @@ function installResult(root, features = ['core']) {
         asset: {
             manifest: manifest(root, features).asset,
             wheelPath: join(root, 'assets', 'python', 'kaelio_ktx-0.2.0-py3-none-any.whl'),
+            requiresPython: { specifier: '>=3.13', minimumVersion: '3.13' },
         },
         manifest: manifest(root, features),
     };
@@ -105,6 +106,7 @@ describe('managed Python daemon lifecycle', () => {
         tempDir = await mkdtemp(join(tmpdir(), 'ktx-managed-daemon-'));
     });
     afterEach(async () => {
+        vi.unstubAllEnvs();
         await rm(tempDir, { recursive: true, force: true });
     });
     it('reports stopped when no daemon state exists', async () => {
@@ -150,6 +152,24 @@ describe('managed Python daemon lifecycle', () => {
             stderrLog: layout(tempDir).daemonStderrPath,
         });
     });
+    it('sanitizes IPv6 CIDR entries from child NO_PROXY env', async () => {
+        vi.stubEnv('NO_PROXY', 'localhost,fd07:b51a:cc66:f0::/64,127.0.0.0/8');
+        vi.stubEnv('no_proxy', '::1,fd00::/8,*.orb.local');
+        const spawnDaemon = makeSpawn(5555);
+        await startManagedPythonDaemon({
+            ...daemonOptionsBase(tempDir),
+            features: ['local-embeddings'],
+            installRuntime: vi.fn(async () => installResult(tempDir, ['core', 'local-embeddings'])),
+            spawnDaemon,
+            fetch: makeFetch(),
+            allocatePort: vi.fn(async () => 61234),
+            now: () => new Date('2026-05-11T00:00:00.000Z'),
+            pollIntervalMs: 1,
+        });
+        const env = vi.mocked(spawnDaemon).mock.calls[0]?.[2].env;
+        expect(env?.NO_PROXY).toBe('localhost,127.0.0.0/8,::1,*.orb.local');
+        expect(env?.no_proxy).toBe(env?.NO_PROXY);
+    });
     it('makes a final health probe before reporting startup failure', async () => {
         const spawnDaemon = makeSpawn(5556);
         const installRuntime = vi.fn(async () => installResult(tempDir));

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

@@ -75,6 +75,10 @@ export interface ManagedPythonDaemonLayout extends ManagedPythonRuntimeLayout {
 export interface ManagedRuntimeAsset {
     manifest: KtxRuntimeAssetManifest;
     wheelPath: string;
+    requiresPython: {
+        specifier: string;
+        minimumVersion: string;
+    };
 }
 export type ManagedPythonRuntimeExec = (command: string, args: string[], options?: {
     cwd?: string;
@@ -108,7 +112,7 @@ export interface ManagedPythonRuntimeDoctorCheck {
     detail: string;
     fix?: string;
 }
-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 dev runtime install --yes";
+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 declare function managedPythonRuntimeLayout(options: ManagedPythonRuntimeLayoutOptions): ManagedPythonRuntimeLayout;
 export declare function managedPythonDaemonLayout(options: ManagedPythonDaemonLayoutOptions): ManagedPythonDaemonLayout;
 export declare function verifyRuntimeAsset(input: {

package/dist/managed-python-runtime.js

@@ -5,6 +5,7 @@ import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
+import { strFromU8, unzipSync } from 'fflate';
 import { z } from 'zod';
 const execFileAsync = promisify(execFile);
 export const runtimeFeatureSchema = z.enum(['core', 'local-embeddings']);
@@ -31,7 +32,7 @@ const installedRuntimeManifestSchema = z.object({
     }),
     installLog: z.string().min(1),
 });
-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 dev runtime install --yes';
+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';
 function defaultAssetDir() {
     return fileURLToPath(new URL('../assets/python/', import.meta.url));
 }
@@ -100,6 +101,35 @@ async function readJsonFile(path) {
 function isErrnoException(error, code) {
     return typeof error === 'object' && error !== null && 'code' in error && error.code === code;
 }
+function parseRequiresPythonFromWheel(input) {
+    let files;
+    try {
+        files = unzipSync(new Uint8Array(input.contents));
+    }
+    catch (error) {
+        throw new Error(`Unable to read bundled Python runtime wheel metadata: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const metadataEntry = Object.entries(files).find(([path]) => path.endsWith('.dist-info/METADATA'));
+    if (!metadataEntry) {
+        throw new Error(`Bundled Python runtime wheel metadata is missing: ${input.wheelPath}`);
+    }
+    const metadata = strFromU8(metadataEntry[1]);
+    const requiresPython = metadata
+        .split(/\r?\n/)
+        .map((line) => line.match(/^Requires-Python:\s*(.+)\s*$/i)?.[1]?.trim())
+        .find((value) => typeof value === 'string' && value.length > 0);
+    if (!requiresPython) {
+        throw new Error('Bundled Python runtime wheel metadata is missing Requires-Python');
+    }
+    const minimumMatch = requiresPython.match(/(?:^|[,\s])>=\s*([0-9]+)\.([0-9]+)(?:\.[0-9]+)?\b/);
+    if (!minimumMatch) {
+        throw new Error(`Unsupported bundled Python runtime Requires-Python: ${requiresPython}`);
+    }
+    return {
+        specifier: requiresPython,
+        minimumVersion: `${minimumMatch[1]}.${minimumMatch[2]}`,
+    };
+}
 export async function verifyRuntimeAsset(input) {
     const manifestPath = join(input.assetDir, 'manifest.json');
     let manifestData;
@@ -124,7 +154,7 @@ export async function verifyRuntimeAsset(input) {
     if (sha256 !== manifest.wheel.sha256 || wheel.byteLength !== manifest.wheel.bytes) {
         throw new Error(`Bundled Python runtime wheel checksum mismatch: ${wheelPath}`);
     }
-    return { manifest, wheelPath };
+    return { manifest, wheelPath, requiresPython: parseRequiresPythonFromWheel({ wheelPath, contents: wheel }) };
 }
 function normalizeFeatures(features) {
     const requested = new Set(['core', ...features]);
@@ -155,6 +185,13 @@ function errorOutput(error) {
         stderr: typeof value.stderr === 'string' ? value.stderr : '',
     };
 }
+function installFailureMessage(input) {
+    const output = [input.stderr.trim(), input.stdout.trim()].filter((part) => part.length > 0).join('\n');
+    if (!output) {
+        return `Python runtime install failed. Install log: ${input.logPath}`;
+    }
+    return `Python runtime install failed.\n${output}\nInstall log: ${input.logPath}`;
+}
 async function runLogged(input) {
     await appendFile(input.logPath, `$ ${input.command} ${input.args.join(' ')}\n`);
     try {
@@ -175,7 +212,7 @@ async function runLogged(input) {
         if (output.stderr) {
             await appendFile(input.logPath, output.stderr.endsWith('\n') ? output.stderr : `${output.stderr}\n`);
         }
-        throw new Error(`Python runtime install failed. Install log: ${input.logPath}`);
+        throw new Error(installFailureMessage({ logPath: input.logPath, stdout: output.stdout, stderr: output.stderr }));
     }
 }
 function managedRuntimeUvEnv(baseEnv) {
@@ -214,7 +251,14 @@ export async function installManagedPythonRuntime(options) {
         exec,
         logPath: layout.installLogPath,
         command: 'uv',
-        args: ['venv', layout.venvDir],
+        args: ['python', 'install', asset.requiresPython.minimumVersion],
+        env: uvEnv,
+    });
+    await runLogged({
+        exec,
+        logPath: layout.installLogPath,
+        command: 'uv',
+        args: ['venv', '--python', asset.requiresPython.minimumVersion, layout.venvDir],
         env: uvEnv,
     });
     const wheelSpec = features.includes('local-embeddings') ? `${asset.wheelPath}[local-embeddings]` : asset.wheelPath;
@@ -287,7 +331,7 @@ export async function doctorManagedPythonRuntime(options) {
             id: 'uv',
             label: 'uv',
             detail: error instanceof Error ? error.message : String(error),
-            fix: 'Install uv, make sure it is on PATH, and run: ktx dev runtime install --yes',
+            fix: 'Install uv, make sure it is on PATH, and run: ktx admin runtime install --yes',
         }));
     }
     try {
@@ -307,7 +351,7 @@ export async function doctorManagedPythonRuntime(options) {
         id: 'runtime',
         label: 'Managed Python runtime',
         detail: status.detail,
-        ...(status.kind === 'ready' ? {} : { fix: 'Run: ktx dev runtime install --yes' }),
+        ...(status.kind === 'ready' ? {} : { fix: 'Run: ktx admin runtime install --yes' }),
     }));
     return checks;
 }

package/dist/managed-python-runtime.test.js

@@ -2,12 +2,28 @@ import { createHash } from 'node:crypto';
 import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { strToU8, zipSync } from 'fflate';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { MISSING_UV_RUNTIME_INSTALL_MESSAGE, doctorManagedPythonRuntime, installManagedPythonRuntime, managedPythonDaemonLayout, managedPythonRuntimeLayout, readManagedPythonRuntimeStatus, verifyRuntimeAsset, } from './managed-python-runtime.js';
-async function writeAsset(root, contents = 'wheel-bytes') {
+function runtimeWheelContents(input = {}) {
+    const label = input.label ?? 'runtime-wheel';
+    const requiresPython = input.requiresPython === null ? [] : [`Requires-Python: ${input.requiresPython ?? '>=3.13'}`];
+    return Buffer.from(zipSync({
+        'kaelio_ktx-0.1.0.dist-info/METADATA': strToU8([
+            'Metadata-Version: 2.4',
+            'Name: kaelio-ktx',
+            'Version: 0.1.0',
+            ...requiresPython,
+            `Summary: ${label}`,
+            '',
+        ].join('\n')),
+    }));
+}
+async function writeAsset(root, options = {}) {
     const assetDir = join(root, 'assets', 'python');
     await mkdir(assetDir, { recursive: true });
     const wheelPath = join(assetDir, 'kaelio_ktx-0.1.0-py3-none-any.whl');
+    const contents = options.contents ?? runtimeWheelContents(options);
     await writeFile(wheelPath, contents);
     await writeFile(join(assetDir, 'manifest.json'), `${JSON.stringify({
         schemaVersion: 1,
@@ -17,7 +33,7 @@ async function writeAsset(root, contents = 'wheel-bytes') {
         wheel: {
             file: 'kaelio_ktx-0.1.0-py3-none-any.whl',
             sha256: createHash('sha256').update(contents).digest('hex'),
-            bytes: Buffer.byteLength(contents),
+            bytes: contents.byteLength,
         },
     }, null, 2)}\n`);
     return { assetDir, wheelPath };
@@ -112,19 +128,20 @@ describe('verifyRuntimeAsset', () => {
         await rm(tempDir, { recursive: true, force: true });
     });
     it('reads the manifest and verifies the wheel checksum', async () => {
-        const { assetDir, wheelPath } = await writeAsset(tempDir, 'valid-wheel');
+        const { assetDir, wheelPath } = await writeAsset(tempDir, { label: 'valid-wheel' });
         const asset = await verifyRuntimeAsset({ assetDir });
         expect(asset.manifest.distributionName).toBe('kaelio-ktx');
         expect(asset.manifest.normalizedName).toBe('kaelio_ktx');
         expect(asset.wheelPath).toBe(wheelPath);
+        expect(asset.requiresPython).toEqual({ specifier: '>=3.13', minimumVersion: '3.13' });
     });
     it('rejects a wheel whose checksum does not match the manifest', async () => {
-        const { assetDir, wheelPath } = await writeAsset(tempDir, 'original');
+        const { assetDir, wheelPath } = await writeAsset(tempDir, { label: 'original' });
         await writeFile(wheelPath, 'tampered');
         await expect(verifyRuntimeAsset({ assetDir })).rejects.toThrow(/Bundled Python runtime wheel checksum mismatch/);
     });
     it('rejects an unsafe wheel filename in the manifest', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'valid-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'valid-wheel' });
         await writeFile(join(assetDir, 'manifest.json'), `${JSON.stringify({
             schemaVersion: 1,
             distributionName: 'kaelio-ktx',
@@ -142,6 +159,14 @@ describe('verifyRuntimeAsset', () => {
         const assetDir = join(tempDir, 'packages', 'cli', 'assets', 'python');
         await expect(verifyRuntimeAsset({ assetDir })).rejects.toThrow(/Missing bundled Python runtime manifest.*pnpm run artifacts:build/s);
     });
+    it('rejects a bundled wheel without Requires-Python metadata', async () => {
+        const { assetDir } = await writeAsset(tempDir, { requiresPython: null });
+        await expect(verifyRuntimeAsset({ assetDir })).rejects.toThrow(/Bundled Python runtime wheel metadata is missing Requires-Python/);
+    });
+    it('rejects a bundled wheel without a supported minimum Python version', async () => {
+        const { assetDir } = await writeAsset(tempDir, { requiresPython: '<4' });
+        await expect(verifyRuntimeAsset({ assetDir })).rejects.toThrow(/Unsupported bundled Python runtime Requires-Python: <4/);
+    });
 });
 describe('installManagedPythonRuntime', () => {
     let tempDir;
@@ -152,7 +177,7 @@ describe('installManagedPythonRuntime', () => {
         await rm(tempDir, { recursive: true, force: true });
     });
     it('creates a venv, installs the core wheel, and writes a manifest', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const commands = [];
         const exec = vi.fn(async (command, args) => {
             commands.push({ command, args });
@@ -168,7 +193,8 @@ describe('installManagedPythonRuntime', () => {
         expect(result.status).toBe('installed');
         expect(commands).toEqual([
             { command: 'uv', args: ['--version'] },
-            { command: 'uv', args: ['venv', result.layout.venvDir] },
+            { command: 'uv', args: ['python', 'install', '3.13'] },
+            { command: 'uv', args: ['venv', '--python', '3.13', result.layout.venvDir] },
             {
                 command: 'uv',
                 args: ['pip', 'install', '--python', result.layout.pythonPath, result.asset.wheelPath],
@@ -181,7 +207,7 @@ describe('installManagedPythonRuntime', () => {
         expect(manifest.python.daemonExecutable).toBe(result.layout.daemonPath);
     });
     it('disables repo uv config for managed runtime uv commands', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const commands = [];
         const exec = vi.fn(async (command, args, options) => {
             commands.push({ command, args, env: options?.env });
@@ -197,12 +223,13 @@ describe('installManagedPythonRuntime', () => {
         });
         expect(commands.map((call) => [call.command, call.args[0], call.env?.UV_NO_CONFIG, call.env?.PATH])).toEqual([
             ['uv', '--version', '1', '/opt/homebrew/bin'],
+            ['uv', 'python', '1', '/opt/homebrew/bin'],
             ['uv', 'venv', '1', '/opt/homebrew/bin'],
             ['uv', 'pip', '1', '/opt/homebrew/bin'],
         ]);
     });
     it('installs the local-embeddings extra when requested', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'embedding-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'embedding-wheel' });
         const commands = [];
         const exec = vi.fn(async (command, args) => {
             commands.push({ command, args });
@@ -223,7 +250,7 @@ describe('installManagedPythonRuntime', () => {
         expect(manifest.features).toEqual(['core', 'local-embeddings']);
     });
     it('fails with the hard-prerequisite message when uv is missing', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const commands = [];
         const exec = vi.fn(async (command, args) => {
             commands.push({ command, args });
@@ -239,7 +266,7 @@ describe('installManagedPythonRuntime', () => {
         expect(commands).toEqual([{ command: 'uv', args: ['--version'] }]);
     });
     it('reuses an existing compatible runtime when force is false', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const exec = vi.fn(async (command, args) => ({
             stdout: command === 'uv' && args[0] === '--version' ? 'uv 0.9.5\n' : '',
             stderr: '',
@@ -262,13 +289,16 @@ describe('installManagedPythonRuntime', () => {
             exec,
         });
         expect(second.status).toBe('ready');
-        expect(exec).toHaveBeenCalledTimes(3);
+        expect(exec).toHaveBeenCalledTimes(4);
     });
     it('keeps failed install logs in the versioned runtime directory', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const exec = vi.fn(async (command, args) => {
             if (command === 'uv' && args[0] === 'venv') {
-                throw Object.assign(new Error('uv venv failed'), { stdout: 'creating\n', stderr: 'bad python\n' });
+                throw Object.assign(new Error('uv venv failed'), {
+                    stdout: 'creating\n',
+                    stderr: '× No solution found\n╰─▶ current Python version (3.12.3) does not satisfy Python>=3.13\n',
+                });
             }
             return { stdout: command === 'uv' && args[0] === '--version' ? 'uv 0.9.5\n' : '', stderr: '' };
         });
@@ -278,10 +308,10 @@ describe('installManagedPythonRuntime', () => {
             assetDir,
             features: ['core'],
             exec,
-        })).rejects.toThrow(/Python runtime install failed/);
+        })).rejects.toThrow(/current Python version \(3\.12\.3\) does not satisfy Python>=3\.13/);
         const log = await readFile(join(tempDir, 'runtime', '0.2.0', 'install.log'), 'utf8');
-        expect(log).toContain('$ uv venv');
-        expect(log).toContain('bad python');
+        expect(log).toContain('$ uv venv --python 3.13');
+        expect(log).toContain('current Python version (3.12.3) does not satisfy Python>=3.13');
     });
 });
 describe('readManagedPythonRuntimeStatus', () => {
@@ -302,7 +332,7 @@ describe('readManagedPythonRuntimeStatus', () => {
         expect(status.detail).toContain('No runtime manifest');
     });
     it('reports ready when manifest and executables exist', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const exec = vi.fn(async (command, args) => ({
             stdout: command === 'uv' && args[0] === '--version' ? 'uv 0.9.5\n' : '',
             stderr: '',
@@ -326,7 +356,7 @@ describe('readManagedPythonRuntimeStatus', () => {
         expect(status.manifest?.features).toEqual(['core']);
     });
     it('reports broken when an executable is missing', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const exec = vi.fn(async (command, args) => ({
             stdout: command === 'uv' && args[0] === '--version' ? 'uv 0.9.5\n' : '',
             stderr: '',
@@ -356,7 +386,7 @@ describe('doctorManagedPythonRuntime', () => {
         await rm(tempDir, { recursive: true, force: true });
     });
     it('checks uv, bundled assets, and installed runtime status', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const exec = vi.fn(async (command, args) => ({
             stdout: command === 'uv' && args[0] === '--version' ? 'uv 0.9.5\n' : '',
             stderr: '',
@@ -372,10 +402,10 @@ describe('doctorManagedPythonRuntime', () => {
             ['asset', 'pass'],
             ['runtime', 'fail'],
         ]);
-        expect(checks[2]?.fix).toBe('Run: ktx dev runtime install --yes');
+        expect(checks[2]?.fix).toBe('Run: ktx admin runtime install --yes');
     });
     it('reports uv as a hard prerequisite when uv is missing', async () => {
-        const { assetDir } = await writeAsset(tempDir, 'core-wheel');
+        const { assetDir } = await writeAsset(tempDir, { label: 'core-wheel' });
         const exec = vi.fn(async () => {
             throw new Error('spawn uv ENOENT');
         });
@@ -390,7 +420,7 @@ describe('doctorManagedPythonRuntime', () => {
             label: 'uv',
             status: 'fail',
             detail: MISSING_UV_RUNTIME_INSTALL_MESSAGE,
-            fix: 'Install uv, make sure it is on PATH, and run: ktx dev runtime install --yes',
+            fix: 'Install uv, make sure it is on PATH, and run: ktx admin runtime install --yes',
         });
     });
 });

package/dist/memory-flow-tui.test.js

@@ -145,8 +145,8 @@ describe('MemoryFlowTuiApp', () => {
         expect(frame).toContain('order lifecycle');
         expect(frame).toContain('customer metrics');
         expect(frame).toContain('KTX finished ingesting your data');
-        expect(frame).toContain('ktx sl list');
-        expect(frame).toContain('ktx wiki list');
+        expect(frame).toContain('ktx sl');
+        expect(frame).toContain('ktx wiki');
         expect(frame).not.toContain('ktx serve --mcp stdio --user-id local');
         expect(frame).not.toContain(['ktx', 'ask'].join(' '));
         expect(frame).not.toContain(['ktx', 'mcp'].join(' '));

package/dist/next-steps.d.ts

@@ -1,6 +1,6 @@
 export declare const KTX_CONTEXT_BUILD_COMMANDS: readonly [{
-    readonly command: "ktx ingest --all";
-    readonly description: "Build or refresh agent-ready context from configured connections";
+    readonly command: "ktx ingest";
+    readonly description: "Build or refresh agent-ready context from all configured connections";
 }, {
     readonly command: "ktx status";
     readonly description: "Check setup and context readiness";
@@ -9,20 +9,20 @@ export declare const KTX_NEXT_STEP_DIRECT_COMMANDS: readonly [{
     readonly command: "ktx status --json";
     readonly description: "Verify project setup and context readiness";
 }, {
-    readonly command: "ktx sl list";
+    readonly command: "ktx sl";
     readonly description: "Inspect generated semantic-layer sources";
 }, {
-    readonly command: "ktx wiki list";
+    readonly command: "ktx wiki";
     readonly description: "Inspect generated wiki pages";
 }];
 export declare const KTX_NEXT_STEP_COMMANDS: readonly [{
     readonly command: "ktx status --json";
     readonly description: "Verify project setup and context readiness";
 }, {
-    readonly command: "ktx sl list";
+    readonly command: "ktx sl";
     readonly description: "Inspect generated semantic-layer sources";
 }, {
-    readonly command: "ktx wiki list";
+    readonly command: "ktx wiki";
     readonly description: "Inspect generated wiki pages";
 }];
 export declare const KTX_NEXT_STEP_COMMAND_WIDTH: number;

package/dist/next-steps.js

@@ -1,7 +1,7 @@
 export const KTX_CONTEXT_BUILD_COMMANDS = [
     {
-        command: 'ktx ingest --all',
-        description: 'Build or refresh agent-ready context from configured connections',
+        command: 'ktx ingest',
+        description: 'Build or refresh agent-ready context from all configured connections',
     },
     {
         command: 'ktx status',
@@ -14,11 +14,11 @@ export const KTX_NEXT_STEP_DIRECT_COMMANDS = [
         description: 'Verify project setup and context readiness',
     },
     {
-        command: 'ktx sl list',
+        command: 'ktx sl',
         description: 'Inspect generated semantic-layer sources',
     },
     {
-        command: 'ktx wiki list',
+        command: 'ktx wiki',
         description: 'Inspect generated wiki pages',
     },
 ];

package/dist/next-steps.test.js

@@ -4,8 +4,8 @@ describe('KTX demo next steps', () => {
     it('uses supported context-build commands before agent usage', () => {
         expect(KTX_CONTEXT_BUILD_COMMANDS).toEqual([
             {
-                command: 'ktx ingest --all',
-                description: 'Build or refresh agent-ready context from configured connections',
+                command: 'ktx ingest',
+                description: 'Build or refresh agent-ready context from all configured connections',
             },
             {
                 command: 'ktx status',
@@ -20,11 +20,11 @@ describe('KTX demo next steps', () => {
                 description: 'Verify project setup and context readiness',
             },
             {
-                command: 'ktx sl list',
+                command: 'ktx sl',
                 description: 'Inspect generated semantic-layer sources',
             },
             {
-                command: 'ktx wiki list',
+                command: 'ktx wiki',
                 description: 'Inspect generated wiki pages',
             },
         ]);
@@ -54,7 +54,7 @@ describe('KTX demo next steps', () => {
         }).join('\n');
         expect(rendered).toContain('Build KTX context next.');
         expect(rendered).toContain('Run ingest to build database schema context before context-source ingest.');
-        expect(rendered).toContain('ktx ingest --all');
+        expect(rendered).toContain('ktx ingest');
         expect(rendered).not.toContain('resume');
         expect(rendered).not.toContain('scan');
         expect(rendered).toContain('ktx status');

package/dist/print-command-tree.test.js

@@ -8,7 +8,7 @@ describe('renderKtxCommandTree', () => {
         const topLevel = lines
             .filter((line) => /^ {2}[├└]── \S/.test(line))
             .map((line) => line.replace(/^ {2}[├└]── /, '').trim().split(' ')[0]);
-        for (const expected of ['setup', 'connection', 'ingest', 'sl', 'mcp', 'dev']) {
+        for (const expected of ['setup', 'connection', 'ingest', 'sl', 'mcp', 'admin']) {
             expect(topLevel).toContain(expected);
         }
         expect(output).toContain('│   └── test [connectionId]');

package/dist/proxy-env.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeChildProxyEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;

package/dist/proxy-env.js

@@ -0,0 +1,23 @@
+const NO_PROXY_KEYS = ['NO_PROXY', 'no_proxy'];
+function isIpv6CidrNoProxyEntry(entry) {
+    return entry.includes('/') && entry.includes(':');
+}
+function cleanedNoProxyValue(env) {
+    const entries = NO_PROXY_KEYS.flatMap((key) => (env[key] ?? '').split(','))
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0 && !isIpv6CidrNoProxyEntry(entry));
+    if (!NO_PROXY_KEYS.some((key) => env[key] !== undefined)) {
+        return undefined;
+    }
+    return [...new Set(entries)].join(',');
+}
+export function sanitizeChildProxyEnv(env) {
+    const sanitized = { ...env };
+    const noProxy = cleanedNoProxyValue(env);
+    if (noProxy === undefined) {
+        return sanitized;
+    }
+    sanitized.NO_PROXY = noProxy;
+    sanitized.no_proxy = noProxy;
+    return sanitized;
+}

package/dist/proxy-env.test.d.ts

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

package/dist/proxy-env.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { sanitizeChildProxyEnv } from './proxy-env.js';
+describe('sanitizeChildProxyEnv', () => {
+    it('drops IPv6 CIDR no-proxy entries and normalizes both env keys', () => {
+        const env = sanitizeChildProxyEnv({
+            NO_PROXY: 'localhost,127.0.0.1,127.0.0.0/8,fd07:b51a:cc66:f0::/64,*.orb.local',
+            no_proxy: '::1,0.250.250.0/24,fd00::/8,*.orb.internal',
+        });
+        expect(env.NO_PROXY).toBe('localhost,127.0.0.1,127.0.0.0/8,*.orb.local,::1,0.250.250.0/24,*.orb.internal');
+        expect(env.no_proxy).toBe(env.NO_PROXY);
+    });
+    it('preserves the input object and leaves missing proxy env unset', () => {
+        const input = { PATH: '/usr/bin' };
+        expect(sanitizeChildProxyEnv(input)).toEqual({ PATH: '/usr/bin' });
+        expect(input).toEqual({ PATH: '/usr/bin' });
+    });
+});

package/dist/public-ingest.js

@@ -234,12 +234,10 @@ function targetForConnection(connectionId, connection, projectConfig, args, warn
     throw new Error(`Connection "${connectionId}" uses unsupported public ingest driver "${driver || 'unknown'}"`);
 }
 export function buildPublicIngestPlan(project, args) {
-    if (!args.all && !args.targetConnectionId) {
-        throw new Error('Context build requires a connection id or all targets');
-    }
+    const allConnections = args.all || !args.targetConnectionId;
     const entries = Object.entries(project.config.connections).sort(([a], [b]) => a.localeCompare(b));
-    const selected = args.all ? entries : entries.filter(([connectionId]) => connectionId === args.targetConnectionId);
-    if (!args.all && selected.length === 0) {
+    const selected = allConnections ? entries : entries.filter(([connectionId]) => connectionId === args.targetConnectionId);
+    if (!allConnections && selected.length === 0) {
         throw new Error(`Connection "${args.targetConnectionId}" is not configured in ktx.yaml`);
     }
     if (selected.length === 0) {

package/dist/public-ingest.test.js

@@ -109,9 +109,13 @@ describe('buildPublicIngestPlan', () => {
             warnings: [],
         });
     });
-    it('rejects bare non-interactive ingest until the interactive confirmation slice exists', () => {
-        const project = projectWithConnections({ warehouse: { driver: 'postgres' } });
-        expect(() => buildPublicIngestPlan(project, { projectDir: '/tmp/project', all: false })).toThrow('Context build requires a connection id or all targets');
+    it('treats a bare invocation (no connection id, no --all) as all configured connections', () => {
+        const project = projectWithConnections({
+            warehouse: { driver: 'postgres' },
+            docs: { driver: 'notion' },
+        });
+        const plan = buildPublicIngestPlan(project, { projectDir: '/tmp/project', all: false });
+        expect(plan.targets.map((target) => target.connectionId).sort()).toEqual(['docs', 'warehouse']);
     });
     it('resolves database depth from flags, stored context, and defaults', () => {
         const project = projectWithConnections({

package/dist/runtime.test.js

@@ -40,6 +40,7 @@ describe('runKtxRuntime', () => {
                 },
                 asset: {
                     wheelPath: '/assets/python/kaelio_ktx-0.1.0-py3-none-any.whl',
+                    requiresPython: { specifier: '>=3.13', minimumVersion: '3.13' },
                     manifest: {
                         schemaVersion: 1,
                         distributionName: 'kaelio-ktx',
@@ -245,7 +246,7 @@ describe('runKtxRuntime', () => {
                     label: 'Managed Python runtime',
                     status: 'fail',
                     detail: 'No runtime manifest at /runtime/0.2.0/manifest.json',
-                    fix: 'Run: ktx dev runtime install --yes',
+                    fix: 'Run: ktx admin runtime install --yes',
                 },
             ]),
         };