@kaelio/ktx 0.0.0 → 0.1.0-rc.1

package/dist/status-project.js

@@ -0,0 +1,723 @@
+import { basename } from 'node:path';
+import { runClaudeCodeAuthProbe } from '@ktx/context';
+import { formatClaudeCodePromptCachingFix, formatClaudeCodePromptCachingWarning, ignoredClaudeCodePromptCachingFields, } from './claude-code-prompt-caching.js';
+import { bold as _bold, dim as _dim, green, red, yellow, } from './io/symbols.js';
+import { KTX_NEXT_STEP_DIRECT_COMMANDS } from './next-steps.js';
+const PROJECT_READY_COMMANDS = KTX_NEXT_STEP_DIRECT_COMMANDS.map((step) => step.command);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function hasOwnField(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function resolveRef(value, env) {
+    if (typeof value !== 'string')
+        return { resolved: '', via: 'missing' };
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return { resolved: '', via: 'missing' };
+    if (trimmed.startsWith('env:')) {
+        const name = trimmed.slice(4).trim();
+        const v = env[name];
+        return v && v.trim().length > 0 ? { resolved: v, via: 'env' } : { resolved: '', via: 'missing' };
+    }
+    if (trimmed.startsWith('file:')) {
+        return { resolved: trimmed.slice(5), via: 'file' };
+    }
+    return { resolved: trimmed, via: 'literal' };
+}
+function envHint(value) {
+    if (typeof value === 'string' && value.trim().startsWith('env:')) {
+        return value.trim().slice(4).trim();
+    }
+    return undefined;
+}
+async function buildLlmStatus(config, options) {
+    const env = options.env;
+    const backend = config.provider.backend;
+    const model = config.models?.default;
+    if (backend === 'none') {
+        return {
+            backend,
+            model,
+            status: 'fail',
+            detail: 'no LLM configured; research agent will not run',
+            fix: 'Run: ktx setup (choose an LLM provider)',
+        };
+    }
+    if (backend === 'anthropic') {
+        const ref = config.provider.anthropic?.api_key;
+        const resolved = resolveRef(ref, env);
+        if (resolved.resolved.length > 0) {
+            return { backend, model, status: 'ok', detail: `key set${resolved.via === 'env' ? ` (env)` : ''}` };
+        }
+        if (env.ANTHROPIC_API_KEY && env.ANTHROPIC_API_KEY.trim().length > 0) {
+            return { backend, model, status: 'ok', detail: 'key set (env: ANTHROPIC_API_KEY)' };
+        }
+        const hint = envHint(ref);
+        return {
+            backend,
+            model,
+            status: 'warn',
+            detail: hint ? `key missing (env: ${hint})` : 'key missing',
+            fix: hint ? `Set ${hint}` : 'Set ANTHROPIC_API_KEY or rerun `ktx setup`',
+        };
+    }
+    if (backend === 'vertex') {
+        const project = config.provider.vertex?.project;
+        if (project && project.length > 0) {
+            return { backend, model, status: 'ok', detail: `project=${project}` };
+        }
+        return { backend, model, status: 'warn', detail: 'vertex project not configured', fix: 'Rerun `ktx setup`' };
+    }
+    if (backend === 'gateway') {
+        const ref = config.provider.gateway?.api_key;
+        const resolved = resolveRef(ref, env);
+        if (resolved.resolved.length > 0) {
+            return { backend, model, status: 'ok', detail: 'key set' };
+        }
+        const hint = envHint(ref);
+        return {
+            backend,
+            model,
+            status: 'warn',
+            detail: hint ? `key missing (env: ${hint})` : 'key missing',
+            fix: hint ? `Set ${hint}` : 'Set the gateway api_key or rerun `ktx setup`',
+        };
+    }
+    if (backend === 'claude-code') {
+        const modelName = model ?? 'sonnet';
+        const probe = options.claudeCodeAuthProbe ?? runClaudeCodeAuthProbe;
+        const auth = await probe({ projectDir: options.projectDir, model: modelName, env });
+        if (auth.ok) {
+            return {
+                backend,
+                model: modelName,
+                status: 'ok',
+                detail: 'local Claude Code session authenticated',
+            };
+        }
+        return {
+            backend,
+            model: modelName,
+            status: 'fail',
+            detail: auth.message,
+            fix: 'Authenticate Claude Code locally with the Claude Code CLI, then rerun `ktx status`.',
+        };
+    }
+    return { backend, model, status: 'warn', detail: 'unknown LLM backend' };
+}
+function buildEmbeddingsStatus(config, env) {
+    const backend = config.backend;
+    const model = config.model;
+    const dimensions = config.dimensions;
+    if (backend === 'none') {
+        return {
+            backend,
+            model,
+            dimensions,
+            status: 'warn',
+            detail: 'disabled — semantic search will be skipped',
+        };
+    }
+    if (backend === 'deterministic') {
+        return {
+            backend,
+            model,
+            dimensions,
+            status: 'warn',
+            detail: 'deterministic — semantic search degraded (lexical/dictionary lanes still work)',
+        };
+    }
+    if (backend === 'openai') {
+        const ref = config.openai?.api_key;
+        const resolved = resolveRef(ref, env);
+        if (resolved.resolved.length > 0 || (env.OPENAI_API_KEY && env.OPENAI_API_KEY.trim().length > 0)) {
+            return { backend, model, dimensions, status: 'ok', detail: 'key set' };
+        }
+        const hint = envHint(ref);
+        return {
+            backend,
+            model,
+            dimensions,
+            status: 'warn',
+            detail: hint ? `key missing (env: ${hint})` : 'key missing',
+            fix: hint ? `Set ${hint}` : 'Set OPENAI_API_KEY or rerun `ktx setup`',
+        };
+    }
+    if (backend === 'sentence-transformers') {
+        const url = config.sentenceTransformers?.base_url;
+        if (typeof url === 'string' && url.length > 0) {
+            return { backend, model, dimensions, status: 'ok', detail: `service: ${url}` };
+        }
+        return {
+            backend,
+            model,
+            dimensions,
+            status: 'warn',
+            detail: 'no base_url configured',
+            fix: 'Rerun `ktx setup`',
+        };
+    }
+    return { backend, model, dimensions, status: 'warn', detail: 'unknown embedding backend' };
+}
+function buildConnectionStatus(name, conn, env) {
+    const driver = (conn.driver ?? 'unknown').toLowerCase();
+    const ok = (detail) => ({ name, driver, status: 'ok', detail });
+    const warn = (detail, fix) => ({ name, driver, status: 'warn', detail, fix });
+    switch (driver) {
+        case 'postgres':
+        case 'postgresql':
+        case 'mysql':
+        case 'clickhouse':
+        case 'sqlserver': {
+            const urlRef = resolveRef(conn.url, env);
+            if (urlRef.resolved.length > 0)
+                return ok(`url configured`);
+            if (typeof conn.host === 'string')
+                return ok('host configured');
+            const hint = envHint(conn.url);
+            return warn(hint ? `url missing (env: ${hint})` : 'url not set', hint ? `Set ${hint}` : 'Rerun `ktx setup`');
+        }
+        case 'snowflake': {
+            const account = conn.account;
+            if (typeof account === 'string' && account.length > 0)
+                return ok(`account: ${account}`);
+            return warn('account not set', 'Rerun `ktx setup`');
+        }
+        case 'bigquery': {
+            const cred = resolveRef(conn.credentials_json, env);
+            if (cred.resolved.length > 0)
+                return ok('credentials configured');
+            const hint = envHint(conn.credentials_json);
+            return warn(hint ? `credentials missing (env: ${hint})` : 'credentials not set', hint ? `Set ${hint}` : 'Rerun `ktx setup`');
+        }
+        case 'sqlite': {
+            const path = conn.path;
+            if (typeof path === 'string' && path.length > 0)
+                return ok(`path: ${path}`);
+            return warn('path not set', 'Rerun `ktx setup`');
+        }
+        case 'notion': {
+            const tokenRef = conn.auth_token_ref ??
+                conn.auth_token;
+            const resolved = resolveRef(tokenRef, env);
+            if (resolved.resolved.length > 0)
+                return ok('auth token configured');
+            const hint = envHint(tokenRef);
+            return warn(hint ? `auth token missing (env: ${hint})` : 'auth token not set', hint ? `Set ${hint}` : 'Rerun `ktx setup`');
+        }
+        case 'dbt':
+        case 'dbt-core':
+        case 'dbt-cloud': {
+            const repoUrl = conn.repoUrl ??
+                conn.repo_url;
+            if (typeof repoUrl === 'string' && repoUrl.length > 0)
+                return ok(`repo: ${repoUrl}`);
+            return warn('repoUrl not set', 'Rerun `ktx setup`');
+        }
+        case 'metabase': {
+            const url = conn.api_url;
+            if (typeof url === 'string' && url.length > 0)
+                return ok(`url: ${url}`);
+            return warn('api_url not set', 'Rerun `ktx setup`');
+        }
+        case 'looker':
+        case 'lookml': {
+            const url = conn.base_url ?? conn.url;
+            if (typeof url === 'string' && url.length > 0)
+                return ok(`url: ${url}`);
+            return warn('base_url not set', 'Rerun `ktx setup`');
+        }
+        case 'metricflow': {
+            const repoUrl = conn.repoUrl ?? conn.repo_url;
+            if (typeof repoUrl === 'string' && repoUrl.length > 0)
+                return ok(`repo: ${repoUrl}`);
+            return warn('repoUrl not set', 'Rerun `ktx setup`');
+        }
+        default:
+            return { name, driver, status: 'ok', detail: 'configured' };
+    }
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function queryHistoryRecord(connection) {
+    const context = recordValue(connection.context);
+    return recordValue(context?.queryHistory);
+}
+function legacyHistoricSqlRecord(connection) {
+    return recordValue(connection.historicSql);
+}
+function isEnabledPostgresQueryHistory(connection) {
+    const queryHistory = queryHistoryRecord(connection);
+    if (queryHistory) {
+        return queryHistory.enabled === true;
+    }
+    const legacy = legacyHistoricSqlRecord(connection);
+    return legacy?.enabled === true && legacy.dialect === 'postgres';
+}
+function isPostgresDriver(connection) {
+    const driver = String(connection.driver ?? '').toLowerCase();
+    return driver === 'postgres' || driver === 'postgresql';
+}
+function queryHistoryFailureFix(error, connectionId, projectDir) {
+    if (error instanceof Error && error.name === 'HistoricSqlExtensionMissingError' && 'remediation' in error) {
+        return String(error.remediation);
+    }
+    if (error instanceof Error && error.name === 'HistoricSqlGrantsMissingError' && 'remediation' in error) {
+        return String(error.remediation);
+    }
+    if (error instanceof Error && error.name === 'HistoricSqlVersionUnsupportedError') {
+        return 'Use PostgreSQL 14 or newer, or disable query history for this connection';
+    }
+    return `Fix connections.${connectionId} Postgres settings, then rerun \`ktx status --project-dir ${projectDir}\``;
+}
+function failureDetail(error) {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return error.message.trim().split('\n')[0] ?? error.message.trim();
+    }
+    return String(error);
+}
+function readinessDetail(result) {
+    const warningText = result.warnings.length > 0 ? ` with warnings: ${result.warnings.join('; ')}` : '';
+    const info = result.info ?? [];
+    const infoText = info.length > 0 ? `; info: ${info.join('; ')}` : '';
+    return `pg_stat_statements ready (${result.pgServerVersion})${warningText}${infoText}`;
+}
+async function defaultPostgresQueryHistoryProbe(input) {
+    const [{ PostgresPgssReader }, { KtxPostgresHistoricSqlQueryClient, isKtxPostgresConnectionConfig }] = await Promise.all([import('@ktx/context/ingest'), import('@ktx/connector-postgres')]);
+    const inputDriver = input.connection.driver ?? 'unknown';
+    if (!isKtxPostgresConnectionConfig(input.connection)) {
+        throw new Error(`Native PostgreSQL connector cannot run driver "${inputDriver}"`);
+    }
+    const client = new KtxPostgresHistoricSqlQueryClient({
+        connectionId: input.connectionId,
+        connection: input.connection,
+        env: input.env,
+    });
+    try {
+        return await new PostgresPgssReader().probe(client);
+    }
+    finally {
+        await client.cleanup();
+    }
+}
+async function buildQueryHistoryStatus(project, options) {
+    const targets = Object.entries(project.config.connections)
+        .filter(([, connection]) => isEnabledPostgresQueryHistory(connection))
+        .sort(([left], [right]) => left.localeCompare(right));
+    const probe = options.postgresQueryHistoryProbe ?? defaultPostgresQueryHistoryProbe;
+    const env = options.env ?? process.env;
+    const statuses = [];
+    for (const [connectionId, connection] of targets) {
+        if (!isPostgresDriver(connection)) {
+            statuses.push({
+                connection: connectionId,
+                dialect: 'postgres',
+                status: 'fail',
+                detail: `connections.${connectionId}.context.queryHistory is enabled but driver is ${String(connection.driver)}`,
+                fix: `Set connections.${connectionId}.driver to postgres or disable query history for this connection`,
+            });
+            continue;
+        }
+        try {
+            const result = await probe({ projectDir: project.projectDir, connectionId, connection, env });
+            statuses.push({
+                connection: connectionId,
+                dialect: 'postgres',
+                status: result.warnings.length > 0 ? 'warn' : 'ok',
+                detail: readinessDetail(result),
+                ...(result.warnings.length > 0
+                    ? {
+                        fix: `Update the Postgres parameter group or config, then rerun \`ktx status --project-dir ${project.projectDir}\``,
+                    }
+                    : {}),
+            });
+        }
+        catch (error) {
+            statuses.push({
+                connection: connectionId,
+                dialect: 'postgres',
+                status: 'fail',
+                detail: failureDetail(error),
+                fix: queryHistoryFailureFix(error, connectionId, project.projectDir),
+            });
+        }
+    }
+    return statuses;
+}
+const ADAPTER_DRIVER_REQUIREMENT = {
+    'live-database': ['postgres', 'postgresql', 'mysql', 'snowflake', 'bigquery', 'clickhouse', 'sqlite', 'sqlserver'],
+    dbt: ['dbt', 'dbt-core', 'dbt-cloud'],
+    notion: ['notion'],
+    metabase: ['metabase'],
+    looker: ['looker', 'lookml'],
+    lookml: ['looker', 'lookml'],
+    metricflow: ['metricflow'],
+};
+function buildPipelineStatus(config) {
+    return {
+        adapters: config.ingest.adapters,
+        enrichmentMode: config.scan.enrichment.mode,
+        relationshipsEnabled: config.scan.relationships.enabled,
+        relationshipsLlmProposals: config.scan.relationships.llmProposals,
+        relationshipsValidationRequired: config.scan.relationships.validationRequiredForManifest,
+        agentEnabled: config.agent.run_research.enabled,
+        agentTools: config.agent.run_research.default_toolset,
+        agentMaxIterations: config.agent.run_research.max_iterations,
+    };
+}
+function buildStorageStatus(config) {
+    return {
+        state: config.storage.state,
+        search: config.storage.search,
+        gitAutoCommit: config.storage.git.auto_commit,
+        gitAuthor: config.storage.git.author,
+    };
+}
+function buildWarnings(config, connections, llm, embeddings) {
+    const warnings = [];
+    for (const [connectionId, connection] of Object.entries(config.connections)) {
+        const driver = String(connection.driver ?? '').toLowerCase();
+        if (hasOwnField(connection, 'readonly')) {
+            warnings.push({
+                message: `connections.${connectionId}.readonly is no longer used.`,
+                fix: `Remove connections.${connectionId}.readonly from ktx.yaml.`,
+            });
+        }
+        if ((driver === 'sqlite' || driver === 'sqlite3') && hasOwnField(connection, 'file_path')) {
+            warnings.push({
+                message: `connections.${connectionId}.file_path was removed.`,
+                fix: `Rename connections.${connectionId}.file_path to path.`,
+            });
+        }
+        if (driver === 'notion' && hasOwnField(connection, 'last_successful_cursor')) {
+            warnings.push({
+                message: `connections.${connectionId}.last_successful_cursor is local sync state.`,
+                fix: 'Remove it from ktx.yaml. KTX stores the Notion cursor in .ktx/db.sqlite.',
+            });
+        }
+        const historicSql = isRecord(connection.historicSql) ? connection.historicSql : null;
+        if (!historicSql) {
+            continue;
+        }
+        if (hasOwnField(historicSql, 'concurrency')) {
+            warnings.push({
+                message: `connections.${connectionId}.historicSql.concurrency is no longer used.`,
+                fix: `Remove connections.${connectionId}.historicSql.concurrency from ktx.yaml.`,
+            });
+        }
+        const historicDialect = String(historicSql.dialect ?? driver).toLowerCase();
+        if ((historicDialect === 'postgres' || historicDialect === 'postgresql') &&
+            hasOwnField(historicSql, 'windowDays')) {
+            warnings.push({
+                message: `connections.${connectionId}.historicSql.windowDays does not constrain pg_stat_statements.`,
+                fix: `Remove connections.${connectionId}.historicSql.windowDays from ktx.yaml.`,
+            });
+        }
+    }
+    for (const adapter of config.ingest.adapters) {
+        const requiredDrivers = ADAPTER_DRIVER_REQUIREMENT[adapter];
+        if (!requiredDrivers)
+            continue;
+        const hasMatching = connections.some((c) => requiredDrivers.includes(c.driver));
+        if (!hasMatching) {
+            warnings.push({
+                message: `Adapter "${adapter}" is enabled but no connection of type ${requiredDrivers.slice(0, 2).join('/')} is configured.`,
+                fix: 'Rerun `ktx setup` to add a connection, or remove the adapter from ingest.adapters.',
+            });
+        }
+    }
+    if (config.agent.run_research.enabled && llm.backend === 'none') {
+        warnings.push({
+            message: 'Research agent is enabled but LLM is not configured.',
+            fix: 'Set up an LLM provider via `ktx setup` or disable agent.run_research.enabled.',
+        });
+    }
+    if (embeddings.backend === 'none' && config.ingest.adapters.includes('live-database')) {
+        warnings.push({
+            message: 'Semantic search is off (embeddings backend = none). Lexical/dictionary lanes still work.',
+        });
+    }
+    const warning = formatClaudeCodePromptCachingWarning(ignoredClaudeCodePromptCachingFields(config.llm));
+    if (warning) {
+        warnings.push({
+            message: warning,
+            fix: formatClaudeCodePromptCachingFix(),
+        });
+    }
+    return warnings;
+}
+function buildVerdict(llm, embeddings, connections, queryHistory, warnings) {
+    if (llm.status === 'fail') {
+        return {
+            verdict: 'blocked',
+            reason: 'LLM not configured; research agent will not run.',
+            nextActions: ['ktx setup'],
+        };
+    }
+    const failedQueryHistory = queryHistory.filter((entry) => entry.status === 'fail').length;
+    if (failedQueryHistory > 0) {
+        return {
+            verdict: 'blocked',
+            reason: `Query history readiness failed for ${failedQueryHistory} connection${failedQueryHistory === 1 ? '' : 's'}.`,
+            nextActions: ['ktx status --verbose'],
+        };
+    }
+    const reasons = [];
+    if (llm.status === 'warn')
+        reasons.push('LLM credentials missing');
+    if (embeddings.status === 'warn') {
+        if (embeddings.backend === 'deterministic' || embeddings.backend === 'none') {
+            reasons.push('semantic search disabled');
+        }
+        else {
+            reasons.push('embedding credentials missing');
+        }
+    }
+    const missing = connections.filter((c) => c.status !== 'ok').length;
+    if (missing > 0)
+        reasons.push(`${missing} connection${missing === 1 ? '' : 's'} need configuration`);
+    const queryHistoryWarnings = queryHistory.filter((entry) => entry.status === 'warn').length;
+    if (queryHistoryWarnings > 0) {
+        reasons.push(`${queryHistoryWarnings} query history warning${queryHistoryWarnings === 1 ? '' : 's'}`);
+    }
+    if (warnings.length > 0)
+        reasons.push(`${warnings.length} config warning${warnings.length === 1 ? '' : 's'}`);
+    if (reasons.length === 0) {
+        return {
+            verdict: 'ready',
+            reason: 'Ready.',
+            nextActions: [...PROJECT_READY_COMMANDS],
+        };
+    }
+    return {
+        verdict: 'partial',
+        reason: `Partially ready — ${reasons.join('; ')}.`,
+        nextActions: ['ktx setup'],
+    };
+}
+function buildConfigStatus(issues) {
+    const list = issues ?? [];
+    if (list.length === 0) {
+        return { status: 'ok', detail: 'ktx.yaml schema valid', issues: [] };
+    }
+    return {
+        status: 'warn',
+        detail: `${list.length} issue${list.length === 1 ? '' : 's'} in ktx.yaml`,
+        issues: list,
+    };
+}
+export async function buildProjectStatus(project, options = {}) {
+    const env = options.env ?? process.env;
+    const config = project.config;
+    const configStatus = buildConfigStatus(options.configIssues);
+    const llm = await buildLlmStatus(config.llm, {
+        projectDir: project.projectDir,
+        env,
+        claudeCodeAuthProbe: options.claudeCodeAuthProbe,
+    });
+    const embeddings = buildEmbeddingsStatus(config.ingest.embeddings, env);
+    const storage = buildStorageStatus(config);
+    const connections = Object.entries(config.connections).map(([name, conn]) => buildConnectionStatus(name, conn, env));
+    const queryHistory = await buildQueryHistoryStatus(project, options);
+    const pipeline = buildPipelineStatus(config);
+    const warnings = buildWarnings(config, connections, llm, embeddings);
+    const { verdict, reason, nextActions } = buildVerdict(llm, embeddings, connections, queryHistory, warnings);
+    return {
+        projectName: basename(project.projectDir) || project.projectDir,
+        projectDir: project.projectDir,
+        config: configStatus,
+        llm,
+        embeddings,
+        storage,
+        connections,
+        queryHistory,
+        pipeline,
+        warnings,
+        verdict,
+        verdictReason: reason,
+        nextActions,
+        promptCaching: config.llm.promptCaching
+            ? {
+                enabled: config.llm.promptCaching.enabled ?? false,
+                systemTtl: config.llm.promptCaching.systemTtl,
+                toolsTtl: config.llm.promptCaching.toolsTtl,
+                historyTtl: config.llm.promptCaching.historyTtl,
+            }
+            : undefined,
+        workUnits: {
+            stepBudget: config.ingest.workUnits.stepBudget,
+            maxConcurrency: config.ingest.workUnits.maxConcurrency,
+            failureMode: config.ingest.workUnits.failureMode,
+        },
+        memoryAutoCommit: config.memory.auto_commit,
+        relationshipsDetail: {
+            acceptThreshold: config.scan.relationships.acceptThreshold,
+            reviewThreshold: config.scan.relationships.reviewThreshold,
+            maxLlmTablesPerBatch: config.scan.relationships.maxLlmTablesPerBatch,
+            validationConcurrency: config.scan.relationships.validationConcurrency,
+        },
+    };
+}
+// ─── Rendering ──────────────────────────────────────────────────────────────
+const SYMBOL = { ok: '✓', warn: '⚠', fail: '✗' };
+function colorForLevel(useColor, level, text) {
+    if (!useColor)
+        return text;
+    return level === 'ok' ? green(text) : level === 'warn' ? yellow(text) : red(text);
+}
+function abbreviateHome(filePath, env) {
+    const home = env.HOME;
+    if (home && (filePath === home || filePath.startsWith(`${home}/`))) {
+        return filePath === home ? '~' : `~${filePath.slice(home.length)}`;
+    }
+    return filePath;
+}
+export function renderProjectStatus(status, options = {}) {
+    const verbose = options.verbose ?? false;
+    const useColor = options.useColor ?? false;
+    const env = options.env ?? process.env;
+    const dim = useColor ? _dim : (s) => s;
+    const bold = useColor ? _bold : (s) => s;
+    const color = (level, s) => colorForLevel(useColor, level, s);
+    const sym = (level) => color(level, SYMBOL[level]);
+    const lines = [];
+    const dirStr = abbreviateHome(status.projectDir, env);
+    lines.push(`${bold('KTX status')} ${dim('·')} ${status.projectName} ${dim(`(${dirStr})`)}`);
+    lines.push('');
+    const labelPad = 'Connections'.length;
+    const label = (text) => text.padEnd(labelPad);
+    // Core readiness rows
+    const llmDetail = [status.llm.backend, status.llm.model].filter(Boolean).join(` ${dim('·')} `);
+    lines.push(`  ${label('LLM')}   ${llmDetail}  ${sym(status.llm.status)} ${dim(status.llm.detail)}`);
+    const embedParts = [status.embeddings.backend];
+    if (status.embeddings.model)
+        embedParts.push(status.embeddings.model);
+    const embedDim = status.embeddings.dimensions ? `(${status.embeddings.dimensions}d)` : '';
+    const embedDetail = `${embedParts.join(` ${dim('·')} `)}${embedDim ? ` ${embedDim}` : ''}`;
+    lines.push(`  ${label('Embeddings')}   ${embedDetail}  ${sym(status.embeddings.status)} ${dim(status.embeddings.detail)}`);
+    lines.push(`  ${label('Storage')}   ${dim(`${status.storage.state} (state) · ${status.storage.search} (search)`)}`);
+    lines.push(`  ${label('Config')}   ${sym(status.config.status)} ${dim(status.config.detail)}`);
+    if (status.config.issues.length > 0) {
+        for (const issue of status.config.issues) {
+            lines.push(`      ${color('warn', SYMBOL.warn)} ${issue.message}`);
+            if (issue.fix)
+                lines.push(`        ${dim(`→ ${issue.fix}`)}`);
+        }
+    }
+    lines.push('');
+    // Connections
+    if (status.connections.length === 0) {
+        lines.push(`  ${bold('Connections')} ${dim('(none)')}`);
+        lines.push(`      ${dim('No connections configured. Run `ktx setup` to add one.')}`);
+    }
+    else {
+        lines.push(`  ${bold('Connections')} ${dim(`(${status.connections.length})`)}`);
+        const nameWidth = Math.max(...status.connections.map((c) => c.name.length));
+        const driverWidth = Math.max(...status.connections.map((c) => c.driver.length));
+        for (const conn of status.connections) {
+            lines.push(`    ${sym(conn.status)} ${conn.name.padEnd(nameWidth)}   ${dim(conn.driver.padEnd(driverWidth))}   ${conn.detail}`);
+            if (conn.fix && conn.status !== 'ok') {
+                const indent = 6 + nameWidth + 3 + driverWidth + 3;
+                lines.push(`${' '.repeat(indent)}${dim(`→ ${conn.fix}`)}`);
+            }
+        }
+    }
+    lines.push('');
+    if (status.queryHistory.length > 0) {
+        lines.push(`  ${bold('Query history')}`);
+        const connectionWidth = Math.max(...status.queryHistory.map((entry) => entry.connection.length));
+        for (const entry of status.queryHistory) {
+            lines.push(`    ${sym(entry.status)} ${entry.connection.padEnd(connectionWidth)}   ${dim(entry.dialect)}   ${entry.detail}`);
+            if (entry.fix && entry.status !== 'ok') {
+                const indent = 6 + connectionWidth + 3 + entry.dialect.length + 3;
+                lines.push(`${' '.repeat(indent)}${dim(`→ ${entry.fix}`)}`);
+            }
+        }
+        lines.push('');
+    }
+    // Pipeline
+    lines.push(`  ${bold('Pipeline')}`);
+    const pipelineLabelWidth = Math.max('Adapters'.length, 'Enrichment'.length, 'Research agent'.length);
+    const pLabel = (text) => text.padEnd(pipelineLabelWidth);
+    lines.push(`    ${pLabel('Adapters')}   ${status.pipeline.adapters.length > 0 ? status.pipeline.adapters.join(', ') : dim('(none)')}`);
+    const enrichmentDetail = [`${status.pipeline.enrichmentMode} mode`];
+    if (status.pipeline.relationshipsEnabled) {
+        const bits = ['relationships on'];
+        if (status.pipeline.relationshipsLlmProposals)
+            bits.push('LLM proposals');
+        if (status.pipeline.relationshipsValidationRequired)
+            bits.push('validation required');
+        enrichmentDetail.push(bits.join(', '));
+    }
+    else {
+        enrichmentDetail.push('relationships off');
+    }
+    lines.push(`    ${pLabel('Enrichment')}   ${enrichmentDetail.join(` ${dim('·')} `)}`);
+    const agentDetail = status.pipeline.agentEnabled
+        ? `enabled ${dim(`(${status.pipeline.agentTools.length} tool${status.pipeline.agentTools.length === 1 ? '' : 's'})`)}`
+        : dim('disabled');
+    lines.push(`    ${pLabel('Research agent')}   ${agentDetail}`);
+    lines.push('');
+    // Warnings
+    if (status.warnings.length > 0) {
+        lines.push(`  ${bold('Warnings')}`);
+        for (const w of status.warnings) {
+            lines.push(`    ${color('warn', SYMBOL.warn)} ${w.message}`);
+            if (w.fix)
+                lines.push(`        ${dim(`→ ${w.fix}`)}`);
+        }
+        lines.push('');
+    }
+    // Verbose extras
+    if (verbose) {
+        if (options.toolchainChecks && options.toolchainChecks.length > 0) {
+            lines.push(`  ${bold('Toolchain')}`);
+            for (const check of options.toolchainChecks) {
+                const lv = check.status === 'pass' ? 'ok' : check.status === 'warn' ? 'warn' : 'fail';
+                lines.push(`    ${sym(lv)} ${check.label}: ${check.detail}`);
+                if (check.fix && lv !== 'ok')
+                    lines.push(`        ${dim(`→ ${check.fix}`)}`);
+            }
+            lines.push('');
+        }
+        if (status.promptCaching) {
+            const pc = status.promptCaching;
+            const bits = [`enabled=${pc.enabled}`];
+            if (pc.systemTtl)
+                bits.push(`system=${pc.systemTtl}`);
+            if (pc.toolsTtl)
+                bits.push(`tools=${pc.toolsTtl}`);
+            if (pc.historyTtl)
+                bits.push(`history=${pc.historyTtl}`);
+            lines.push(`  ${bold('Prompt caching')}   ${dim(bits.join(', '))}`);
+        }
+        if (status.workUnits) {
+            const wu = status.workUnits;
+            lines.push(`  ${bold('Work units')}       ${dim(`stepBudget=${wu.stepBudget}, maxConcurrency=${wu.maxConcurrency}, failureMode=${wu.failureMode}`)}`);
+        }
+        if (status.relationshipsDetail) {
+            const r = status.relationshipsDetail;
+            lines.push(`  ${bold('Relationships')}    ${dim(`accept=${r.acceptThreshold}, review=${r.reviewThreshold}, maxLlmTables=${r.maxLlmTablesPerBatch}, concurrency=${r.validationConcurrency}`)}`);
+        }
+        lines.push(`  ${bold('Agent')}            ${dim(`max_iterations=${status.pipeline.agentMaxIterations}, tools=${status.pipeline.agentTools.join(', ') || '(none)'}`)}`);
+        lines.push(`  ${bold('Memory')}           ${dim(`auto_commit=${status.memoryAutoCommit}`)}`);
+        lines.push(`  ${bold('Git')}              ${dim(`auto_commit=${status.storage.gitAutoCommit}, author=${status.storage.gitAuthor}`)}`);
+        lines.push('');
+    }
+    // Verdict + next steps
+    const verdictLevel = status.verdict === 'ready' ? 'ok' : status.verdict === 'partial' ? 'warn' : 'fail';
+    const duration = options.durationMs !== undefined ? ` ${dim(`(${(options.durationMs / 1000).toFixed(2)}s)`)}` : '';
+    if (status.verdict === 'ready') {
+        const hint = `  ${dim('Try:')} ${status.nextActions.join(dim('  ·  '))}`;
+        lines.push(`${color(verdictLevel, status.verdictReason)}${hint}${duration}`);
+    }
+    else {
+        const hint = status.nextActions.length > 0 ? `  ${dim('Next:')} ${status.nextActions.join(dim('  ·  '))}` : '';
+        lines.push(`${color(verdictLevel, status.verdictReason)}${hint}${duration}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}