@kaelio/ktx 0.1.0 → 0.1.1

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: '',
@@ -375,7 +405,7 @@ describe('doctorManagedPythonRuntime', () => {
         expect(checks[2]?.fix).toBe('Run: ktx dev 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');
         });

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/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',

package/dist/setup-agents.js

@@ -965,7 +965,9 @@ export async function runKtxSetupAgentsStep(args, io, deps = {}) {
     if (targets.includes('back'))
         return { status: 'back', projectDir: args.projectDir };
     if (targets.length === 0) {
-        io.stderr.write('Missing agent target: pass --target or use interactive setup.\n');
+        io.stderr.write(args.inputMode === 'disabled'
+            ? 'Run in a TTY, or pass --target <target>.\n'
+            : 'Missing agent target: pass --target or use interactive setup.\n');
         return { status: 'missing-input', projectDir: args.projectDir };
     }
     const scopeTargets = targets.filter((target) => target !== 'claude-desktop');

package/dist/setup-agents.test.js

@@ -163,6 +163,40 @@ describe('setup agents', () => {
         expect(await readKtxSetupState(tempDir)).toEqual({ completed_steps: ['agents'] });
         expect(io.stderr()).toBe('');
     });
+    it('installs a specified target in non-interactive mode without --yes', async () => {
+        const io = makeIo();
+        await expect(runKtxSetupAgentsStep({
+            projectDir: tempDir,
+            inputMode: 'disabled',
+            yes: false,
+            agents: true,
+            target: 'claude-code',
+            scope: 'project',
+            mode: 'mcp',
+            skipAgents: false,
+        }, io.io)).resolves.toMatchObject({
+            status: 'ready',
+            projectDir: tempDir,
+            installs: [{ target: 'claude-code', scope: 'project', mode: 'mcp' }],
+        });
+        await expect(stat(join(tempDir, '.claude/skills/ktx-analytics/SKILL.md'))).resolves.toBeDefined();
+        const mcpConfig = JSON.parse(await readFile(join(tempDir, '.mcp.json'), 'utf-8'));
+        expect(mcpConfig.mcpServers).toHaveProperty('ktx');
+        expect(io.stderr()).toBe('');
+    });
+    it('prints concrete target guidance when non-interactive agent setup has no target', async () => {
+        const io = makeIo();
+        await expect(runKtxSetupAgentsStep({
+            projectDir: tempDir,
+            inputMode: 'disabled',
+            yes: false,
+            agents: true,
+            scope: 'project',
+            mode: 'mcp',
+            skipAgents: false,
+        }, io.io)).resolves.toEqual({ status: 'missing-input', projectDir: tempDir });
+        expect(io.stderr()).toBe('Run in a TTY, or pass --target <target>.\n');
+    });
     it('prints standalone agent next actions after successful installation', async () => {
         const io = makeIo();
         const result = await runKtxSetupAgentsStep({

package/dist/setup-embeddings.d.ts

@@ -49,6 +49,7 @@ export interface KtxSetupEmbeddingsDeps {
     healthCheck?: (config: KtxEmbeddingConfig) => Promise<KtxEmbeddingHealthCheckResult>;
     ensureLocalEmbeddings?: (options: {
         cliVersion: string;
+        projectDir: string;
         installPolicy: KtxManagedPythonInstallPolicy;
         io: KtxCliIo;
     }) => Promise<ManagedLocalEmbeddingsDaemon>;

package/dist/setup-embeddings.js

@@ -1,4 +1,4 @@
-import { writeFile } from 'node:fs/promises';
+import { readFile, writeFile } from 'node:fs/promises';
 import { resolveKtxConfigReference } from '@ktx/context/core';
 import { loadKtxProject, markKtxSetupStateStepComplete, readKtxSetupState, serializeKtxProjectConfig, } from '@ktx/context/project';
 import { runKtxEmbeddingHealthCheck } from '@ktx/llm';
@@ -20,13 +20,13 @@ const LOCAL_EMBEDDING_BACKEND = 'sentence-transformers';
 const EMBEDDING_OPTION_PROMPT_CONTEXT = 'KTX uses embeddings for semantic search over semantic-layer sources, wiki context, schema metadata, ' +
     'and relationship evidence.';
 const LOCAL_EMBEDDING_HEALTH_TIMEOUT_MS = 120_000;
+const LOCAL_EMBEDDING_STDERR_TAIL_LINES = 40;
 function createPromptAdapter() {
     return createKtxSetupPromptAdapter({ selectCancelValue: 'back' });
 }
 async function hasCompletedEmbeddings(projectDir, config) {
     return ((await readKtxSetupState(projectDir)).completed_steps.includes('embeddings') &&
         config.ingest.embeddings.backend !== 'none' &&
-        config.ingest.embeddings.backend !== 'deterministic' &&
         typeof config.ingest.embeddings.model === 'string' &&
         config.ingest.embeddings.model.length > 0 &&
         config.ingest.embeddings.dimensions > 0);
@@ -190,14 +190,33 @@ async function chooseEmbeddingBackend(args, deps) {
     }
     return 'back';
 }
-function localEmbeddingSetupMessage(message) {
-    return [
+async function readLocalEmbeddingDaemonStderrTail(stderrLog) {
+    if (!stderrLog) {
+        return [];
+    }
+    try {
+        const lines = (await readFile(stderrLog, 'utf8'))
+            .split(/\r?\n/)
+            .map((line) => line.trimEnd())
+            .filter((line) => line.trim().length > 0);
+        return lines.slice(-LOCAL_EMBEDDING_STDERR_TAIL_LINES);
+    }
+    catch {
+        return [];
+    }
+}
+function localEmbeddingSetupMessage(message, stderrTail = []) {
+    const lines = [
         `Local embedding health check failed: ${message}`,
         'Local embeddings use the KTX-managed Python runtime.',
         'Prepare the runtime with: ktx dev runtime start --feature local-embeddings',
         'Use --yes with setup to install and start the runtime without prompting.',
         'The first run may download Python packages and the all-MiniLM-L6-v2 model.',
-    ].join('\n');
+    ];
+    if (stderrTail.length > 0) {
+        lines.push('Recent local embeddings daemon stderr:', ...stderrTail);
+    }
+    return lines.join('\n');
 }
 async function promptAfterLocalEmbeddingFailure(deps) {
     const choice = await (deps.prompts ?? createPromptAdapter()).select({
@@ -324,8 +343,11 @@ export async function runKtxSetupEmbeddingsStep(args, io, deps = {}) {
             return { status: 'ready', projectDir: args.projectDir };
         }
         progress.fail('Embedding test failed');
+        const stderrTail = selectedBackend === 'sentence-transformers'
+            ? await readLocalEmbeddingDaemonStderrTail(managedLocalEmbeddings?.stderrLog)
+            : [];
         io.stderr.write(selectedBackend === 'sentence-transformers'
-            ? `${localEmbeddingSetupMessage(health.message)}\n`
+            ? `${localEmbeddingSetupMessage(health.message, stderrTail)}\n`
             : `Embedding health check failed: ${health.message}\n`);
         if (args.inputMode === 'disabled') {
             return { status: 'failed', projectDir: args.projectDir };

package/dist/setup-embeddings.test.js

@@ -39,9 +39,11 @@ function makePromptAdapter(options) {
         cancel: vi.fn(),
     };
 }
-function managedDaemon(baseUrl = 'http://127.0.0.1:61234') {
+function managedDaemon(baseUrl = 'http://127.0.0.1:61234', logs = {}) {
     return {
         baseUrl,
+        stdoutLog: logs.stdoutLog ?? '/tmp/ktx-daemon.stdout.log',
+        stderrLog: logs.stderrLog ?? '/tmp/ktx-daemon.stderr.log',
         env: {
             KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL: baseUrl,
         },
@@ -251,11 +253,51 @@ describe('setup embeddings step', () => {
         expect(result.status).toBe('failed');
         const config = parseKtxProjectConfig(await readFile(join(tempDir, 'ktx.yaml'), 'utf-8'));
         expect(await readFile(join(tempDir, 'ktx.yaml'), 'utf-8')).not.toContain('completed_steps:');
-        expect(config.ingest.embeddings.backend).toBe('deterministic');
+        expect(config.ingest.embeddings.backend).toBe('none');
         expect(io.stderr()).toContain('Local embedding health check failed: 401 invalid api key [redacted]');
         expect(io.stderr()).toContain('Prepare the runtime with: ktx dev runtime start --feature local-embeddings');
         expect(io.stderr()).not.toContain('skip for now');
     });
+    it('prints the recent daemon stderr tail when local embedding health check fails', async () => {
+        const io = makeIo();
+        const stderrLog = join(tempDir, '.ktx', 'runtime', 'daemon.stderr.log');
+        await mkdir(join(tempDir, '.ktx', 'runtime'), { recursive: true });
+        await writeFile(stderrLog, Array.from({ length: 45 }, (_value, index) => `daemon traceback line ${index + 1}`).join('\n'));
+        const result = await runKtxSetupEmbeddingsStep({
+            projectDir: tempDir,
+            inputMode: 'disabled',
+            cliVersion: '0.2.0',
+            runtimeInstallPolicy: 'auto',
+            skipEmbeddings: false,
+        }, io.io, {
+            env: {},
+            ensureLocalEmbeddings: vi.fn(async () => managedDaemon('http://127.0.0.1:61234', { stderrLog })),
+            healthCheck: vi.fn(async () => ({ ok: false, message: 'HTTP 500' })),
+        });
+        expect(result.status).toBe('failed');
+        expect(io.stderr()).toContain('Recent local embeddings daemon stderr:');
+        expect(io.stderr()).toContain('daemon traceback line 6');
+        expect(io.stderr()).toContain('daemon traceback line 45');
+        expect(io.stderr()).not.toContain('daemon traceback line 5');
+    });
+    it('does not print daemon stderr diagnostics when the log is unavailable or empty', async () => {
+        const io = makeIo();
+        const result = await runKtxSetupEmbeddingsStep({
+            projectDir: tempDir,
+            inputMode: 'disabled',
+            cliVersion: '0.2.0',
+            runtimeInstallPolicy: 'auto',
+            skipEmbeddings: false,
+        }, io.io, {
+            env: {},
+            ensureLocalEmbeddings: vi.fn(async () => managedDaemon('http://127.0.0.1:61234', {
+                stderrLog: join(tempDir, '.ktx', 'runtime', 'missing.stderr.log'),
+            })),
+            healthCheck: vi.fn(async () => ({ ok: false, message: 'HTTP 500' })),
+        });
+        expect(result.status).toBe('failed');
+        expect(io.stderr()).not.toContain('Recent local embeddings daemon stderr:');
+    });
     it('uses fixed OpenAI defaults and only asks for credentials when OpenAI is selected', async () => {
         const io = makeIo();
         const healthCheck = vi.fn(async () => ({ ok: true }));
@@ -342,7 +384,7 @@ describe('setup embeddings step', () => {
         expect(result.status).toBe('skipped');
         const config = parseKtxProjectConfig(await readFile(join(tempDir, 'ktx.yaml'), 'utf-8'));
         expect(await readFile(join(tempDir, 'ktx.yaml'), 'utf-8')).not.toContain('completed_steps:');
-        expect(config.ingest.embeddings.backend).toBe('deterministic');
+        expect(config.ingest.embeddings.backend).toBe('none');
     });
     it('returns back without writing config when the local health check fails and Back is selected', async () => {
         const prompts = makePromptAdapter({ selectValues: ['sentence-transformers', 'back'] });
@@ -360,7 +402,7 @@ describe('setup embeddings step', () => {
         });
         expect(result.status).toBe('back');
         const config = parseKtxProjectConfig(await readFile(join(tempDir, 'ktx.yaml'), 'utf-8'));
-        expect(config.ingest.embeddings.backend).toBe('deterministic');
+        expect(config.ingest.embeddings.backend).toBe('none');
     });
     it('preserves already completed embeddings setup when no embedding args request changes', async () => {
         await mkdir(join(tempDir, '.ktx'), { recursive: true });

package/dist/setup-models.d.ts

@@ -10,7 +10,6 @@ export interface KtxSetupModelArgs {
     anthropicApiKeyEnv?: string;
     anthropicApiKeyFile?: string;
     llmModel?: string;
-    anthropicModel?: string;
     vertexProject?: string;
     vertexLocation?: string;
     forcePrompt?: boolean;

package/dist/setup-models.js

@@ -312,13 +312,13 @@ function requestedBackend(args) {
     if (args.vertexProject || args.vertexLocation) {
         return 'vertex';
     }
-    if (args.anthropicApiKeyEnv || args.anthropicApiKeyFile || args.llmModel || args.anthropicModel) {
+    if (args.anthropicApiKeyEnv || args.anthropicApiKeyFile || args.llmModel) {
         return 'anthropic';
     }
     return undefined;
 }
 function requestedModel(args) {
-    return args.llmModel ?? args.anthropicModel;
+    return args.llmModel;
 }
 async function chooseBackend(args, io, deps) {
     const explicit = requestedBackend(args);
@@ -701,7 +701,6 @@ export async function runKtxSetupAnthropicModelStep(args, io, deps = {}) {
         !args.anthropicApiKeyEnv &&
         !args.anthropicApiKeyFile &&
         !args.llmModel &&
-        !args.anthropicModel &&
         !args.vertexProject &&
         !args.vertexLocation) {
         io.stdout.write(`│  LLM ready: yes (${project.config.llm.models.default})\n`);

package/dist/setup-models.test.js

@@ -216,7 +216,7 @@ describe('setup Anthropic model step', () => {
             projectDir: tempDir,
             inputMode: 'disabled',
             anthropicApiKeyEnv: 'ANTHROPIC_API_KEY', // pragma: allowlist secret
-            anthropicModel: 'claude-sonnet-4-6',
+            llmModel: 'claude-sonnet-4-6',
             skipLlm: false,
         }, io.io, {
             env: { ANTHROPIC_API_KEY: 'sk-ant-test' }, // pragma: allowlist secret
@@ -253,7 +253,7 @@ describe('setup Anthropic model step', () => {
             llmBackend: 'vertex',
             vertexProject: 'local-gcp-project',
             vertexLocation: 'us-east5',
-            anthropicModel: 'claude-sonnet-4-6',
+            llmModel: 'claude-sonnet-4-6',
             skipLlm: false,
         }, io.io, { env: {}, healthCheck, spinner });
         expect(result.status).toBe('ready');
@@ -476,7 +476,7 @@ describe('setup Anthropic model step', () => {
             llmBackend: 'vertex',
             vertexProject: 'kaelio-orbit-looker-20260430',
             vertexLocation: 'us-east5',
-            anthropicModel: 'claude-sonnet-4-6',
+            llmModel: 'claude-sonnet-4-6',
             skipLlm: false,
         }, io.io, {
             env: {},
@@ -497,7 +497,7 @@ describe('setup Anthropic model step', () => {
             projectDir: tempDir,
             inputMode: 'disabled',
             anthropicApiKeyFile: secretPath,
-            anthropicModel: 'claude-sonnet-4-6',
+            llmModel: 'claude-sonnet-4-6',
             skipLlm: false,
         }, io.io, { env: {}, healthCheck });
         expect(result.status).toBe('ready');
@@ -525,7 +525,7 @@ describe('setup Anthropic model step', () => {
             projectDir: tempDir,
             inputMode: 'disabled',
             anthropicApiKeyFile: missingSecretPath,
-            anthropicModel: 'claude-sonnet-4-6',
+            llmModel: 'claude-sonnet-4-6',
             skipLlm: false,
         }, io.io, { env: {}, healthCheck });
         expect(result.status).toBe('missing-input');
@@ -720,7 +720,7 @@ describe('setup Anthropic model step', () => {
             projectDir: tempDir,
             inputMode: 'disabled',
             anthropicApiKeyEnv: 'ANTHROPIC_API_KEY', // pragma: allowlist secret
-            anthropicModel: 'claude-sonnet-4-6',
+            llmModel: 'claude-sonnet-4-6',
             skipLlm: false,
         }, io.io, {
             env: { ANTHROPIC_API_KEY: 'sk-ant-test' }, // pragma: allowlist secret
@@ -830,8 +830,7 @@ describe('setup Anthropic model step', () => {
             '    default: claude-sonnet-4-6',
             'ingest:',
             '  embeddings:',
-            '    backend: deterministic',
-            '    model: deterministic',
+            '    backend: none',
             '    dimensions: 8',
         ].join('\n'), 'utf-8');
         await writeKtxSetupState(tempDir, { completed_steps: ['project', 'llm'] });
@@ -865,8 +864,7 @@ describe('setup Anthropic model step', () => {
             `    default: ${fixture.model}`,
             'ingest:',
             '  embeddings:',
-            '    backend: deterministic',
-            '    model: deterministic',
+            '    backend: none',
             '    dimensions: 8',
         ].join('\n'), 'utf-8');
         await writeKtxSetupState(tempDir, { completed_steps: ['project', 'llm'] });

package/dist/setup-project.d.ts

@@ -1,7 +1,7 @@
 import { initKtxProject, type KtxLocalProject, loadKtxProject } from '@ktx/context/project';
 import type { KtxCliIo } from './cli-runtime.js';
 import { type KtxSetupPromptOption } from './setup-prompts.js';
-export type KtxSetupProjectMode = 'auto' | 'new' | 'existing' | 'prompt-new';
+export type KtxSetupProjectMode = 'auto' | 'prompt-new';
 export type KtxSetupInputMode = 'auto' | 'disabled';
 export interface KtxSetupProjectArgs {
     projectDir: string;
@@ -10,11 +10,19 @@ export interface KtxSetupProjectArgs {
     yes: boolean;
     allowBack?: boolean;
 }
+export type KtxSetupCreatedProjectCleanup = {
+    kind: 'remove-project-dir';
+    projectDir: string;
+} | {
+    kind: 'remove-ktx-scaffold';
+    projectDir: string;
+};
 export type KtxSetupProjectResult = {
     status: 'ready';
     projectDir: string;
     project: KtxLocalProject;
     confirmedCreation?: boolean;
+    createdProjectCleanup?: KtxSetupCreatedProjectCleanup;
 } | {
     status: 'back';
     projectDir: string;