@kaelio/ktx 0.4.1 → 0.6.0

package/dist/status-project.js

@@ -1,15 +1,13 @@
-import { basename } from 'node:path';
-import { runClaudeCodeAuthProbe } from '@ktx/context';
+import { stat as statAsync, readdir as readdirAsync } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { runClaudeCodeAuthProbe } from './context/llm/claude-code-runtime.js';
+import { ktxLocalStateDbPath } from './context/project/local-state-db.js';
+import { isQueryHistoryEnabled, queryHistoryDialectForConnection, } from './context/ingest/adapters/historic-sql/connection-dialect.js';
+import { historicSqlProbeCatalogName, runHistoricSqlReadinessProbe, } from './context/ingest/historic-sql-probes.js';
 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' };
@@ -26,6 +24,12 @@ function resolveRef(value, env) {
     }
     return { resolved: trimmed, via: 'literal' };
 }
+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 envHint(value) {
     if (typeof value === 'string' && value.trim().startsWith('env:')) {
         return value.trim().slice(4).trim();
@@ -87,8 +91,16 @@ async function buildLlmStatus(config, options) {
     }
     if (backend === 'claude-code') {
         const modelName = model ?? 'sonnet';
+        if (options.fast === true) {
+            return {
+                backend,
+                model: modelName,
+                status: 'skipped',
+                detail: 'auth probe skipped (--fast)',
+            };
+        }
         const probe = options.claudeCodeAuthProbe ?? runClaudeCodeAuthProbe;
-        const auth = await probe({ projectDir: options.projectDir, model: modelName, env });
+        const auth = await withSpinner(options.useSpinner === true, 'Probing Claude Code authentication', () => probe({ projectDir: options.projectDir, model: modelName, env }));
         if (auth.ok) {
             return {
                 backend,
@@ -145,9 +157,8 @@ function buildEmbeddingsStatus(config, env) {
             backend,
             model,
             dimensions,
-            status: 'warn',
-            detail: 'no base_url configured',
-            fix: 'Rerun `ktx setup`',
+            status: 'ok',
+            detail: 'managed local embeddings daemon',
         };
     }
     return { backend, model, dimensions, status: 'warn', detail: 'unknown embedding backend' };
@@ -158,7 +169,6 @@ function buildConnectionStatus(name, conn, env) {
     const warn = (detail, fix) => ({ name, driver, status: 'warn', detail, fix });
     switch (driver) {
         case 'postgres':
-        case 'postgresql':
         case 'mysql':
         case 'clickhouse':
         case 'sqlserver': {
@@ -230,116 +240,85 @@ function buildConnectionStatus(name, conn, env) {
             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))
+        .filter(([, connection]) => isQueryHistoryEnabled(connection))
         .sort(([left], [right]) => left.localeCompare(right));
-    const probe = options.postgresQueryHistoryProbe ?? defaultPostgresQueryHistoryProbe;
+    const probe = options.queryHistoryReadinessProbe ?? runHistoricSqlReadinessProbe;
     const env = options.env ?? process.env;
     const statuses = [];
     for (const [connectionId, connection] of targets) {
-        if (!isPostgresDriver(connection)) {
+        const driver = String(connection.driver ?? 'unknown').toLowerCase();
+        const dialect = queryHistoryDialectForConnection(connection);
+        if (!dialect) {
             statuses.push({
                 connection: connectionId,
-                dialect: 'postgres',
+                driver,
+                dialect: driver,
                 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`,
+                detail: `query history is not supported for driver "${driver}"`,
+                fix: `Disable connections.${connectionId}.context.queryHistory, or use a postgres, snowflake, or bigquery connection`,
             });
             continue;
         }
-        try {
-            const result = await probe({ projectDir: project.projectDir, connectionId, connection, env });
+        const catalogName = historicSqlProbeCatalogName(dialect);
+        if (options.fast === true) {
             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}\``,
-                    }
-                    : {}),
+                driver,
+                dialect,
+                status: 'skipped',
+                detail: `${catalogName} probe skipped (--fast)`,
             });
+            continue;
         }
-        catch (error) {
+        const outcome = await withSpinner(options.useSpinner === true, `Probing ${catalogName} on ${connectionId}`, () => probe({
+            projectDir: project.projectDir,
+            connectionId,
+            connection,
+            env,
+        }));
+        if (!outcome) {
             statuses.push({
                 connection: connectionId,
-                dialect: 'postgres',
+                driver,
+                dialect: driver,
                 status: 'fail',
-                detail: failureDetail(error),
-                fix: queryHistoryFailureFix(error, connectionId, project.projectDir),
+                detail: `query history is not supported for driver "${driver}"`,
+                fix: `Disable connections.${connectionId}.context.queryHistory, or use a postgres, snowflake, or bigquery connection`,
+            });
+            continue;
+        }
+        if (outcome.ok) {
+            const { detail, warnings } = outcome.runner.formatSuccessDetail(outcome.result);
+            statuses.push({
+                connection: connectionId,
+                driver,
+                dialect,
+                status: warnings.length > 0 ? 'warn' : 'ok',
+                detail,
+                ...(dialect === 'postgres' && warnings.length > 0
+                    ? {
+                        fix: `Update the Postgres parameter group or config, then rerun \`ktx status --project-dir ${project.projectDir}\``,
+                    }
+                    : {}),
             });
+            continue;
         }
+        const advice = outcome.runner.fixAdvice(outcome.error);
+        statuses.push({
+            connection: connectionId,
+            driver,
+            dialect,
+            status: 'fail',
+            detail: advice.failHeadline,
+            fix: advice.remediation,
+        });
     }
     return statuses;
 }
 const ADAPTER_DRIVER_REQUIREMENT = {
-    'live-database': ['postgres', 'postgresql', 'mysql', 'snowflake', 'bigquery', 'clickhouse', 'sqlite', 'sqlserver'],
+    'live-database': ['postgres', 'mysql', 'snowflake', 'bigquery', 'clickhouse', 'sqlite', 'sqlserver'],
     dbt: ['dbt', 'dbt-core', 'dbt-cloud'],
     notion: ['notion'],
     metabase: ['metabase'],
@@ -369,45 +348,6 @@ function buildStorageStatus(config) {
 }
 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)
@@ -467,7 +407,7 @@ function buildVerdict(llm, embeddings, connections, queryHistory, warnings) {
             reasons.push('embedding credentials missing');
         }
     }
-    const missing = connections.filter((c) => c.status !== 'ok').length;
+    const missing = connections.filter((c) => c.status !== 'ok' && c.status !== 'skipped').length;
     if (missing > 0)
         reasons.push(`${missing} connection${missing === 1 ? '' : 's'} need configuration`);
     const queryHistoryWarnings = queryHistory.filter((entry) => entry.status === 'warn').length;
@@ -489,6 +429,22 @@ function buildVerdict(llm, embeddings, connections, queryHistory, warnings) {
         nextActions: ['ktx setup'],
     };
 }
+async function withSpinner(useSpinner, label, run) {
+    if (!useSpinner)
+        return run();
+    const { spinner } = await import('@clack/prompts');
+    const s = spinner();
+    s.start(label);
+    try {
+        const result = await run();
+        s.stop(label);
+        return result;
+    }
+    catch (error) {
+        s.stop(`${label} — failed`);
+        throw error;
+    }
+}
 function buildConfigStatus(issues) {
     const list = issues ?? [];
     if (list.length === 0) {
@@ -500,6 +456,167 @@ function buildConfigStatus(issues) {
         issues: list,
     };
 }
+async function summarizeDir(dir, maxDepth = 10) {
+    let fileCount = 0;
+    let bytes = 0;
+    const walk = async (current, depth) => {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = await readdirAsync(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            try {
+                const s = await statAsync(full);
+                fileCount += 1;
+                bytes += s.size;
+            }
+            catch {
+                // skip individual stat failures
+            }
+        }
+    };
+    await walk(dir, 0);
+    return { fileCount, bytes };
+}
+async function fileSizeOrNull(filePath) {
+    try {
+        const s = await statAsync(filePath);
+        return s.isFile() ? s.size : null;
+    }
+    catch {
+        return null;
+    }
+}
+function tryQuery(run, fallback) {
+    try {
+        return run();
+    }
+    catch {
+        return fallback;
+    }
+}
+/** @internal */
+export async function buildLocalStatsStatus(project) {
+    const dbPath = ktxLocalStateDbPath(project);
+    const dbSqliteBytes = await fileSizeOrNull(dbPath);
+    const projectDirSummary = {
+        dbSqliteBytes,
+        ktxCacheBytes: (await summarizeDir(join(project.projectDir, '.ktx', 'cache'))).bytes,
+        rawSources: await summarizeDir(join(project.projectDir, 'raw-sources')),
+    };
+    if (dbSqliteBytes === null) {
+        return {
+            ingest: { totalCompletedRuns: 0, perConnection: [] },
+            wikiPages: [],
+            semanticLayer: [],
+            projectDir: projectDirSummary,
+            unavailable: 'no .ktx/db.sqlite yet',
+        };
+    }
+    let database = null;
+    try {
+        const { default: Database } = await import('better-sqlite3');
+        database = new Database(dbPath, { readonly: true, fileMustExist: true });
+        const db = database;
+        const totalCompletedRuns = tryQuery(() => db
+            .prepare(`SELECT COUNT(*) AS n FROM local_ingest_reports WHERE status = 'done'`)
+            .get()?.n ?? 0, 0);
+        const ingestRows = tryQuery(() => db
+            .prepare(`SELECT connection_id, adapter, MAX(completed_at) AS last_completed_at
+             FROM local_ingest_reports
+             WHERE status = 'done'
+             GROUP BY connection_id, adapter`)
+            .all(), []);
+        const perConnectionMap = new Map();
+        for (const row of ingestRows) {
+            const existing = perConnectionMap.get(row.connection_id);
+            if (!existing || row.last_completed_at > existing.lastCompletedAt) {
+                perConnectionMap.set(row.connection_id, {
+                    connectionId: row.connection_id,
+                    adapter: row.adapter,
+                    lastCompletedAt: row.last_completed_at,
+                });
+            }
+        }
+        const perConnection = [...perConnectionMap.values()].sort((left, right) => left.connectionId.localeCompare(right.connectionId));
+        const wikiRows = tryQuery(() => db
+            .prepare(`SELECT scope, COUNT(*) AS n, SUM(CASE WHEN embedding_json IS NOT NULL THEN 1 ELSE 0 END) AS embedded
+             FROM knowledge_pages
+             GROUP BY scope
+             ORDER BY scope`)
+            .all(), []);
+        const wikiPages = wikiRows.map((row) => ({
+            scope: row.scope,
+            count: row.n,
+            embeddedCount: row.embedded ?? 0,
+        }));
+        const sourceRows = tryQuery(() => db
+            .prepare(`SELECT connection_id, COUNT(*) AS n, SUM(CASE WHEN embedding_json IS NOT NULL THEN 1 ELSE 0 END) AS embedded
+             FROM local_sl_sources
+             GROUP BY connection_id`)
+            .all(), []);
+        const dictionaryRows = tryQuery(() => db
+            .prepare(`SELECT connection_id, COUNT(*) AS n FROM local_sl_dictionary_values GROUP BY connection_id`)
+            .all(), []);
+        const slMap = new Map();
+        for (const row of sourceRows) {
+            slMap.set(row.connection_id, {
+                connectionId: row.connection_id,
+                sourceCount: row.n,
+                embeddedSourceCount: row.embedded ?? 0,
+                dictionaryValueCount: 0,
+            });
+        }
+        for (const row of dictionaryRows) {
+            const existing = slMap.get(row.connection_id) ?? {
+                connectionId: row.connection_id,
+                sourceCount: 0,
+                embeddedSourceCount: 0,
+                dictionaryValueCount: 0,
+            };
+            existing.dictionaryValueCount = row.n;
+            slMap.set(row.connection_id, existing);
+        }
+        const semanticLayer = [...slMap.values()].sort((left, right) => left.connectionId.localeCompare(right.connectionId));
+        return {
+            ingest: { totalCompletedRuns, perConnection },
+            wikiPages,
+            semanticLayer,
+            projectDir: projectDirSummary,
+        };
+    }
+    catch (error) {
+        return {
+            ingest: { totalCompletedRuns: 0, perConnection: [] },
+            wikiPages: [],
+            semanticLayer: [],
+            projectDir: projectDirSummary,
+            unavailable: failureDetail(error),
+        };
+    }
+    finally {
+        if (database) {
+            try {
+                database.close();
+            }
+            catch {
+                // ignore close failures
+            }
+        }
+    }
+}
 export async function buildProjectStatus(project, options = {}) {
     const env = options.env ?? process.env;
     const config = project.config;
@@ -508,6 +625,8 @@ export async function buildProjectStatus(project, options = {}) {
         projectDir: project.projectDir,
         env,
         claudeCodeAuthProbe: options.claudeCodeAuthProbe,
+        fast: options.fast,
+        useSpinner: options.useSpinner,
     });
     const embeddings = buildEmbeddingsStatus(config.ingest.embeddings, env);
     const storage = buildStorageStatus(config);
@@ -515,6 +634,7 @@ export async function buildProjectStatus(project, options = {}) {
     const queryHistory = await buildQueryHistoryStatus(project, options);
     const pipeline = buildPipelineStatus(config);
     const warnings = buildWarnings(config, connections, llm, embeddings);
+    const localStats = await buildLocalStatsStatus(project);
     const { verdict, reason, nextActions } = buildVerdict(llm, embeddings, connections, queryHistory, warnings);
     return {
         projectName: basename(project.projectDir) || project.projectDir,
@@ -527,6 +647,7 @@ export async function buildProjectStatus(project, options = {}) {
         queryHistory,
         pipeline,
         warnings,
+        localStats,
         verdict,
         verdictReason: reason,
         nextActions,
@@ -553,11 +674,53 @@ export async function buildProjectStatus(project, options = {}) {
     };
 }
 // ─── Rendering ──────────────────────────────────────────────────────────────
-const SYMBOL = { ok: '✓', warn: '⚠', fail: '✗' };
+const SYMBOL = { ok: '✓', warn: '⚠', fail: '✗', skipped: '-' };
 function colorForLevel(useColor, level, text) {
     if (!useColor)
         return text;
-    return level === 'ok' ? green(text) : level === 'warn' ? yellow(text) : red(text);
+    if (level === 'ok')
+        return green(text);
+    if (level === 'warn')
+        return yellow(text);
+    if (level === 'fail')
+        return red(text);
+    return _dim(text);
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ['KiB', 'MiB', 'GiB', 'TiB'];
+    let value = bytes / 1024;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    const precision = value >= 100 ? 0 : value >= 10 ? 1 : 2;
+    return `${value.toFixed(precision)} ${units[unitIndex]}`;
+}
+const RELATIVE_TIME_DIVISIONS = [
+    { amount: 60, name: 'second' },
+    { amount: 60, name: 'minute' },
+    { amount: 24, name: 'hour' },
+    { amount: 7, name: 'day' },
+    { amount: 4.34524, name: 'week' },
+    { amount: 12, name: 'month' },
+    { amount: Number.POSITIVE_INFINITY, name: 'year' },
+];
+function formatRelativeFromNow(iso) {
+    const parsed = Date.parse(iso);
+    if (Number.isNaN(parsed))
+        return iso;
+    const formatter = new Intl.RelativeTimeFormat('en', { numeric: 'auto' });
+    let duration = (parsed - Date.now()) / 1000;
+    for (const division of RELATIVE_TIME_DIVISIONS) {
+        if (Math.abs(duration) < division.amount) {
+            return formatter.format(Math.round(duration), division.name);
+        }
+        duration /= division.amount;
+    }
+    return iso;
 }
 function abbreviateHome(filePath, env) {
     const home = env.HOME;
@@ -566,6 +729,58 @@ function abbreviateHome(filePath, env) {
     }
     return filePath;
 }
+function renderLocalStats(lines, stats, dim, bold) {
+    lines.push(`  ${bold('Local data')}`);
+    if (stats.unavailable) {
+        lines.push(`    ${dim(`(—) ${stats.unavailable}`)}`);
+        lines.push('');
+        return;
+    }
+    const localLabelWidth = Math.max('Ingest'.length, 'Wiki'.length, 'Semantic layer'.length, 'Disk'.length);
+    const lLabel = (text) => text.padEnd(localLabelWidth);
+    const ingest = stats.ingest;
+    const ingestSummary = ingest.totalCompletedRuns === 0
+        ? dim('no completed runs yet')
+        : `${ingest.totalCompletedRuns} completed run${ingest.totalCompletedRuns === 1 ? '' : 's'}`;
+    lines.push(`    ${lLabel('Ingest')}   ${ingestSummary}`);
+    if (ingest.perConnection.length > 0) {
+        const nameWidth = Math.max(...ingest.perConnection.map((entry) => entry.connectionId.length));
+        const adapterWidth = Math.max(...ingest.perConnection.map((entry) => entry.adapter.length));
+        for (const entry of ingest.perConnection) {
+            lines.push(`      ${entry.connectionId.padEnd(nameWidth)}   ${dim(entry.adapter.padEnd(adapterWidth))}   ${dim(`last ${formatRelativeFromNow(entry.lastCompletedAt)}`)}`);
+        }
+    }
+    if (stats.wikiPages.length === 0) {
+        lines.push(`    ${lLabel('Wiki')}   ${dim('no pages yet')}`);
+    }
+    else {
+        const wikiText = stats.wikiPages
+            .map((entry) => `${entry.scope}=${entry.count} ${dim(`(${entry.embeddedCount} embedded)`)}`)
+            .join(` ${dim('·')} `);
+        lines.push(`    ${lLabel('Wiki')}   ${wikiText}`);
+    }
+    if (stats.semanticLayer.length === 0) {
+        lines.push(`    ${lLabel('Semantic layer')}   ${dim('no indexed sources yet')}`);
+    }
+    else {
+        const nameWidth = Math.max(...stats.semanticLayer.map((entry) => entry.connectionId.length));
+        let firstLine = true;
+        for (const entry of stats.semanticLayer) {
+            const prefix = firstLine ? lLabel('Semantic layer') : ' '.repeat(localLabelWidth);
+            const sourcesText = `${entry.sourceCount} source${entry.sourceCount === 1 ? '' : 's'} (${entry.embeddedSourceCount} embedded)`;
+            const dictText = `${entry.dictionaryValueCount} dictionary value${entry.dictionaryValueCount === 1 ? '' : 's'}`;
+            lines.push(`    ${prefix}   ${entry.connectionId.padEnd(nameWidth)}   ${dim(`${sourcesText} · ${dictText}`)}`);
+            firstLine = false;
+        }
+    }
+    const disk = stats.projectDir;
+    const diskBits = [];
+    diskBits.push(`db=${disk.dbSqliteBytes === null ? '–' : formatBytes(disk.dbSqliteBytes)}`);
+    diskBits.push(`cache=${formatBytes(disk.ktxCacheBytes)}`);
+    diskBits.push(`raw-sources=${disk.rawSources.fileCount} file${disk.rawSources.fileCount === 1 ? '' : 's'} (${formatBytes(disk.rawSources.bytes)})`);
+    lines.push(`    ${lLabel('Disk')}   ${dim(diskBits.join(`  ${dim('·')}  `))}`);
+    lines.push('');
+}
 export function renderProjectStatus(status, options = {}) {
     const verbose = options.verbose ?? false;
     const useColor = options.useColor ?? false;
@@ -652,6 +867,8 @@ export function renderProjectStatus(status, options = {}) {
         : dim('disabled');
     lines.push(`    ${pLabel('Research agent')}   ${agentDetail}`);
     lines.push('');
+    // Local data
+    renderLocalStats(lines, status.localStats, dim, bold);
     // Warnings
     if (status.warnings.length > 0) {
         lines.push(`  ${bold('Warnings')}`);

package/dist/telemetry/command-hook.d.ts

@@ -0,0 +1,28 @@
+export type CommandOutcome = 'ok' | 'error' | 'aborted';
+interface CommandSpan {
+    commandPath: string[];
+    flagsPresent: Record<string, boolean>;
+    projectDir?: string;
+    hasProject: boolean;
+    attachProjectGroup: boolean;
+    startedAt: number;
+}
+export interface CompletedCommandSpan {
+    commandPath: string[];
+    durationMs: number;
+    outcome: CommandOutcome;
+    errorClass?: string;
+    flagsPresent: Record<string, boolean>;
+    hasProject: boolean;
+    projectDir?: string;
+    projectGroupAttached: boolean;
+}
+export declare function beginCommandSpan(input: CommandSpan): void;
+export declare function completeCommandSpan(input: {
+    completedAt: number;
+    outcome: CommandOutcome;
+    error?: unknown;
+}): CompletedCommandSpan | undefined;
+/** @internal */
+export declare function resetCommandSpan(): void;
+export {};