@kaelio/ktx 0.1.0 → 0.2.0

package/dist/scan.test.js

@@ -287,8 +287,8 @@ describe('runKtxScan', () => {
         expect(io.stdout()).toContain('Report: raw-sources/warehouse/live-database/sync-1/scan-report.json');
         expect(io.stdout()).toContain('Next:\n');
         expect(io.stdout()).toContain('ktx status --project-dir ');
-        expect(io.stdout()).not.toContain('ktx dev scan status');
-        expect(io.stdout()).not.toContain('ktx dev scan report');
+        expect(io.stdout()).not.toContain('ktx admin scan status');
+        expect(io.stdout()).not.toContain('ktx admin scan report');
         expect(io.stdout()).not.toContain('\u001b[');
         expect(io.stdout()).not.toContain('✓');
         expect(io.stdout()).not.toContain('+1');

package/dist/setup-agents.js

@@ -426,8 +426,8 @@ function cliInstructionContent(input) {
         'Available commands:',
         '',
         `- \`${ktxCommandLine(input.launcher, ['status', ...jsonProjectDirArgs])}\``,
-        `- \`${ktxCommandLine(input.launcher, ['sl', 'list', ...jsonProjectDirArgs])}\``,
-        `- \`${ktxCommandLine(input.launcher, ['sl', 'search', '<text>', ...jsonProjectDirArgs, '--connection-id', '<id>'])}\``,
+        `- \`${ktxCommandLine(input.launcher, ['sl', ...jsonProjectDirArgs])}\``,
+        `- \`${ktxCommandLine(input.launcher, ['sl', '<text>', ...jsonProjectDirArgs, '--connection-id', '<id>'])}\``,
         `- \`${ktxCommandLine(input.launcher, [
             'sl',
             'query',
@@ -442,7 +442,7 @@ function cliInstructionContent(input) {
             '--max-rows',
             '100',
         ])}\``,
-        `- \`${ktxCommandLine(input.launcher, ['wiki', 'search', '<query>', ...jsonProjectDirArgs, '--limit', '10'])}\``,
+        `- \`${ktxCommandLine(input.launcher, ['wiki', '<query>', ...jsonProjectDirArgs, '--limit', '10'])}\``,
         '',
         'Use semantic-layer queries before direct database access. Do not print secrets or credential references.',
         '',
@@ -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

@@ -149,7 +149,7 @@ describe('setup agents', () => {
         expect(skill).toContain(`--project-dir ${tempDir}`);
         expect(skill).toContain('must not print secrets');
         expect(skill).toContain('status --json');
-        expect(skill).toContain('sl list --json');
+        expect(skill).toContain('sl --json');
         expect(skill).toContain('sl query');
         expect(skill).toContain('--format json');
         expect(skill).not.toContain('sl query --json');
@@ -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',
+        'Prepare the runtime with: ktx admin 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,
         },
@@ -223,7 +225,7 @@ describe('setup embeddings step', () => {
     it('fails non-interactive local setup when the managed local embeddings runtime is missing', async () => {
         const io = makeIo();
         const ensureLocalEmbeddings = vi.fn(async () => {
-            throw new Error('KTX Python runtime is required for this command. Run: ktx dev runtime install --feature local-embeddings --yes');
+            throw new Error('KTX Python runtime is required for this command. Run: ktx admin runtime install --feature local-embeddings --yes');
         });
         const result = await runKtxSetupEmbeddingsStep({
             projectDir: tempDir,
@@ -233,7 +235,7 @@ describe('setup embeddings step', () => {
             skipEmbeddings: false,
         }, io.io, { env: {}, ensureLocalEmbeddings });
         expect(result.status).toBe('failed');
-        expect(io.stderr()).toContain('KTX Python runtime is required for this command. Run: ktx dev runtime install --feature local-embeddings --yes');
+        expect(io.stderr()).toContain('KTX Python runtime is required for this command. Run: ktx admin runtime install --feature local-embeddings --yes');
     });
     it('does not persist embedding completion when the health check fails', async () => {
         const io = makeIo();
@@ -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()).toContain('Prepare the runtime with: ktx admin 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;

package/dist/setup-project.js

@@ -37,6 +37,15 @@ async function existingFolderState(projectDir) {
         throw error;
     }
 }
+function cleanupForFolderState(projectDir, state) {
+    if (state === 'missing') {
+        return { kind: 'remove-project-dir', projectDir };
+    }
+    if (state === 'empty-directory') {
+        return { kind: 'remove-ktx-scaffold', projectDir };
+    }
+    return undefined;
+}
 async function confirmProjectDir(selectedDir, io, prompts) {
     const state = await existingFolderState(selectedDir);
     if (state === 'not-directory') {
@@ -75,7 +84,7 @@ async function confirmProjectDir(selectedDir, io, prompts) {
         return { status: 'back' };
     if (action !== 'create')
         return { status: 'cancelled' };
-    return { status: 'confirmed', confirmedCreation: true };
+    return { status: 'confirmed', confirmedCreation: true, createdProjectCleanup: cleanupForFolderState(selectedDir, state) };
 }
 async function normalizeSetupGitignore(projectDir) {
     const gitignorePath = join(projectDir, '.ktx/.gitignore');
@@ -147,34 +156,34 @@ async function promptForNewProjectDir(projectDir, homeDir, io, prompts) {
             return { status: 'back', projectDir };
         if (confirmed.status === 'cancelled')
             return { status: 'cancelled', projectDir };
-        return { status: 'selected', projectDir: selectedDir, confirmedCreation: confirmed.confirmedCreation };
+        return {
+            status: 'selected',
+            projectDir: selectedDir,
+            confirmedCreation: confirmed.confirmedCreation,
+            ...(confirmed.createdProjectCleanup ? { createdProjectCleanup: confirmed.createdProjectCleanup } : {}),
+        };
     }
 }
+async function createProjectWithCleanup(projectDir, deps) {
+    const state = await existingFolderState(projectDir);
+    const project = await createProject(projectDir, deps);
+    const createdProjectCleanup = cleanupForFolderState(projectDir, state);
+    return {
+        project,
+        ...(createdProjectCleanup ? { createdProjectCleanup } : {}),
+    };
+}
 export async function runKtxSetupProjectStep(args, io, deps = {}) {
     const projectDir = resolve(args.projectDir);
     const homeDir = deps.homeDir ?? homedir();
     const exists = hasProjectConfig(projectDir);
-    if (args.mode === 'existing') {
-        if (!exists) {
-            io.stderr.write(`No existing KTX project found at ${projectDir}. Pass --new to create it.\n`);
-            return { status: 'missing-input', projectDir };
-        }
-        const project = await loadExistingProject(projectDir, deps);
-        printProjectSummary(io, projectDir);
-        return { status: 'ready', projectDir, project };
-    }
-    if (args.mode === 'new') {
-        const project = await createProject(projectDir, deps);
-        printProjectSummary(io, projectDir);
-        return { status: 'ready', projectDir, project };
-    }
     if (args.mode === 'prompt-new') {
         if (args.inputMode === 'disabled') {
-            io.stderr.write('Missing new project folder: pass --new --project-dir to create a project without prompts.\n');
+            io.stderr.write('Missing new project folder: pass --project-dir and --yes to create a project without prompts.\n');
             return { status: 'missing-input', projectDir };
         }
         if (!io.stdout.isTTY && !deps.prompts) {
-            io.stderr.write('Missing new project folder: pass --new --project-dir to create a project outside an interactive terminal.\n');
+            io.stderr.write('Missing new project folder: pass --project-dir and --yes to create a project outside an interactive terminal.\n');
             return { status: 'missing-input', projectDir };
         }
         const prompts = deps.prompts ?? createClackSetupProjectPromptAdapter();
@@ -192,6 +201,7 @@ export async function runKtxSetupProjectStep(args, io, deps = {}) {
             projectDir: selected.projectDir,
             project,
             confirmedCreation: selected.confirmedCreation,
+            ...(selected.createdProjectCleanup ? { createdProjectCleanup: selected.createdProjectCleanup } : {}),
         };
     }
     if (exists) {
@@ -201,15 +211,20 @@ export async function runKtxSetupProjectStep(args, io, deps = {}) {
     }
     if (args.inputMode === 'disabled') {
         if (!args.yes) {
-            io.stderr.write('Missing setup choice: pass --new or --yes to create a project in non-interactive setup.\n');
+            io.stderr.write('Missing setup choice: pass --yes to create a project in non-interactive setup.\n');
             return { status: 'missing-input', projectDir };
         }
-        const project = await createProject(projectDir, deps);
+        const { project, createdProjectCleanup } = await createProjectWithCleanup(projectDir, deps);
         printProjectSummary(io, projectDir);
-        return { status: 'ready', projectDir, project };
+        return {
+            status: 'ready',
+            projectDir,
+            project,
+            ...(createdProjectCleanup ? { createdProjectCleanup } : {}),
+        };
     }
     if (!io.stdout.isTTY && !deps.prompts) {
-        io.stderr.write('Missing setup choice: pass --new or --yes to create a project outside an interactive terminal.\n');
+        io.stderr.write('Missing setup choice: pass --yes to create a project outside an interactive terminal.\n');
         return { status: 'missing-input', projectDir };
     }
     const prompts = deps.prompts ?? createClackSetupProjectPromptAdapter();
@@ -238,9 +253,14 @@ export async function runKtxSetupProjectStep(args, io, deps = {}) {
             return { status: 'cancelled', projectDir };
         }
         if (choice === 'current') {
-            const project = await createProject(projectDir, deps);
+            const { project, createdProjectCleanup } = await createProjectWithCleanup(projectDir, deps);
             printProjectSummary(io, projectDir);
-            return { status: 'ready', projectDir, project };
+            return {
+                status: 'ready',
+                projectDir,
+                project,
+                ...(createdProjectCleanup ? { createdProjectCleanup } : {}),
+            };
         }
         if (choice === 'new-default') {
             const confirmed = await confirmProjectDir(defaultProjectDir, io, prompts);
@@ -257,6 +277,7 @@ export async function runKtxSetupProjectStep(args, io, deps = {}) {
                 projectDir: defaultProjectDir,
                 project,
                 confirmedCreation: confirmed.confirmedCreation,
+                ...(confirmed.createdProjectCleanup ? { createdProjectCleanup: confirmed.createdProjectCleanup } : {}),
             };
         }
         if (choice === 'new-custom') {
@@ -281,7 +302,13 @@ export async function runKtxSetupProjectStep(args, io, deps = {}) {
                 return { status: 'cancelled', projectDir };
             const project = await createProject(customDir, deps);
             printProjectSummary(io, customDir);
-            return { status: 'ready', projectDir: customDir, project, confirmedCreation: confirmed.confirmedCreation };
+            return {
+                status: 'ready',
+                projectDir: customDir,
+                project,
+                confirmedCreation: confirmed.confirmedCreation,
+                ...(confirmed.createdProjectCleanup ? { createdProjectCleanup: confirmed.createdProjectCleanup } : {}),
+            };
         }
         prompts.cancel('Setup cancelled.');
         return { status: 'cancelled', projectDir };

package/dist/setup-project.test.js

@@ -48,10 +48,10 @@ describe('setup project step', () => {
     afterEach(async () => {
         await rm(tempDir, { recursive: true, force: true });
     });
-    it('creates a new project with --new and marks the project step complete', async () => {
+    it('creates a new project in non-interactive auto mode with --yes and marks the project step complete', async () => {
         const projectDir = join(tempDir, 'warehouse');
         const testIo = makeIo();
-        const result = await runKtxSetupProjectStep({ projectDir, mode: 'new', inputMode: 'disabled', yes: false }, testIo.io);
+        const result = await runKtxSetupProjectStep({ projectDir, mode: 'auto', inputMode: 'disabled', yes: true }, testIo.io);
         expect(result.status).toBe('ready');
         expect(result.projectDir).toBe(projectDir);
         expect(await readFile(join(projectDir, 'ktx.yaml'), 'utf-8')).not.toContain('completed_steps:');
@@ -61,7 +61,7 @@ describe('setup project step', () => {
         expect(testIo.stdout()).toContain(`Project: ${projectDir}`);
         expect(testIo.stderr()).toBe('');
     });
-    it('loads an existing project with --existing and drops config setup progress', async () => {
+    it('loads an existing project in auto mode and drops config setup progress', async () => {
         const projectDir = join(tempDir, 'warehouse');
         await initKtxProject({ projectDir });
         await writeFile(join(projectDir, 'ktx.yaml'), [
@@ -72,7 +72,7 @@ describe('setup project step', () => {
             '    - llm',
             'connections: {}',
         ].join('\n'), 'utf-8');
-        const result = await runKtxSetupProjectStep({ projectDir, mode: 'existing', inputMode: 'disabled', yes: false }, makeIo().io);
+        const result = await runKtxSetupProjectStep({ projectDir, mode: 'auto', inputMode: 'disabled', yes: false }, makeIo().io);
         expect(result.status).toBe('ready');
         const config = parseKtxProjectConfig(await readFile(join(projectDir, 'ktx.yaml'), 'utf-8'));
         expect(config.setup).toEqual({
@@ -86,16 +86,16 @@ describe('setup project step', () => {
         const rejectedIo = makeIo();
         const acceptedIo = makeIo();
         await expect(runKtxSetupProjectStep({ projectDir, mode: 'auto', inputMode: 'disabled', yes: false }, rejectedIo.io)).resolves.toMatchObject({ status: 'missing-input' });
-        expect(rejectedIo.stderr()).toContain('Missing setup choice: pass --new or --yes');
+        expect(rejectedIo.stderr()).toContain('Missing setup choice: pass --yes');
         await expect(stat(join(projectDir, 'ktx.yaml'))).rejects.toThrow();
         await expect(runKtxSetupProjectStep({ projectDir, mode: 'auto', inputMode: 'disabled', yes: true }, acceptedIo.io)).resolves.toMatchObject({ status: 'ready', projectDir });
         await expect(stat(join(projectDir, 'ktx.yaml'))).resolves.toBeDefined();
     });
-    it('fails --existing clearly when ktx.yaml is missing', async () => {
+    it('fails clearly in no-input auto mode when ktx.yaml is missing and --yes is absent', async () => {
         const projectDir = join(tempDir, 'warehouse');
         const testIo = makeIo();
-        await expect(runKtxSetupProjectStep({ projectDir, mode: 'existing', inputMode: 'disabled', yes: false }, testIo.io)).resolves.toMatchObject({ status: 'missing-input' });
-        expect(testIo.stderr()).toContain(`No existing KTX project found at ${projectDir}`);
+        await expect(runKtxSetupProjectStep({ projectDir, mode: 'auto', inputMode: 'disabled', yes: false }, testIo.io)).resolves.toMatchObject({ status: 'missing-input' });
+        expect(testIo.stderr()).toContain('Missing setup choice: pass --yes');
     });
     it('prompts to use the current directory and creates a project in interactive auto mode', async () => {
         const projectDir = join(tempDir, 'warehouse');

package/dist/setup-runtime.test.js

@@ -56,7 +56,7 @@ describe('runKtxSetupRuntimeStep', () => {
     it('fails fast when required runtime features cannot be installed in no-input mode', async () => {
         const io = makeIo();
         const ensureRuntime = vi.fn(async () => {
-            throw new Error('KTX Python runtime is required for this command. Run: ktx dev runtime install --yes');
+            throw new Error('KTX Python runtime is required for this command. Run: ktx admin runtime install --yes');
         });
         await expect(runKtxSetupRuntimeStep({
             projectDir: tempDir,
@@ -71,12 +71,14 @@ describe('runKtxSetupRuntimeStep', () => {
         })).resolves.toMatchObject({ status: 'failed' });
         expect(ensureRuntime).toHaveBeenCalledWith(expect.objectContaining({ installPolicy: 'never' }));
         expect((await readKtxSetupState(tempDir)).completed_steps).not.toContain('runtime');
-        expect(io.stderr()).toContain('ktx dev runtime install --yes');
+        expect(io.stderr()).toContain('ktx admin runtime install --yes');
     });
     it('starts the managed local embeddings daemon for configured sentence-transformers embeddings', async () => {
         const io = makeIo();
         const ensureLocalEmbeddings = vi.fn(async () => ({
             baseUrl: 'http://127.0.0.1:61234',
+            stdoutLog: join(tempDir, '.ktx', 'runtime', 'daemon.stdout.log'),
+            stderrLog: join(tempDir, '.ktx', 'runtime', 'daemon.stderr.log'),
             env: { KTX_MANAGED_SENTENCE_TRANSFORMERS_BASE_URL: 'http://127.0.0.1:61234' },
         }));
         const config = {