@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/dist/demo-scan.js

@@ -0,0 +1,171 @@
+import { getLocalIngestStatus } from '@ktx/context/ingest';
+import { loadKtxProject } from '@ktx/context/project';
+import { runLocalScan } from '@ktx/context/scan';
+import { DEMO_ADAPTER, DEMO_CONNECTION_ID, DEMO_FULL_JOB_ID, ensureDemoProject } from './demo-assets.js';
+import { loadLatestDemoReplay } from './demo-replay-store.js';
+import { createKtxCliLocalIngestAdapters } from './local-adapters.js';
+async function ensureDemoProjectForReuse(projectDir) {
+    await ensureDemoProject({ projectDir, force: false }).catch((error) => {
+        if (error instanceof Error && error.message.includes('Demo project already exists')) {
+            return;
+        }
+        throw error;
+    });
+}
+async function loadReadyDemoProject(projectDir) {
+    try {
+        return await loadKtxProject({ projectDir });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Demo project is not ready at ${projectDir}: ${reason}. Run ktx setup demo init --project-dir ${projectDir} --force --no-input to recreate it.`);
+    }
+}
+function reportDiff(report) {
+    return `+${report.diffSummary.tablesAdded}/~${report.diffSummary.tablesModified}/-${report.diffSummary.tablesDeleted}/=${report.diffSummary.tablesUnchanged}`;
+}
+function jsonReport(raw, path) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid demo scan report at ${path}: ${reason}`);
+    }
+}
+async function countFiles(project, root, predicate) {
+    const { files } = await project.fileStore.listFiles(root, true);
+    return files.filter(predicate).length;
+}
+async function findFullDemoReport(project) {
+    return getLocalIngestStatus(project, DEMO_FULL_JOB_ID);
+}
+function savedCounts(report) {
+    const actions = report.body.workUnits.flatMap((workUnit) => workUnit.actions);
+    return {
+        wikiCount: actions.filter((action) => action.target === 'wiki').length,
+        slCount: actions.filter((action) => action.target === 'sl').length,
+    };
+}
+export async function runDemoScan(options) {
+    await ensureDemoProjectForReuse(options.projectDir);
+    const project = await loadReadyDemoProject(options.projectDir);
+    const executeScan = options.runLocalScan ?? runLocalScan;
+    const result = await executeScan({
+        project,
+        connectionId: DEMO_CONNECTION_ID,
+        mode: 'structural',
+        trigger: 'cli',
+        jobId: options.jobId ?? 'demo-scan',
+        now: options.now,
+        adapters: createKtxCliLocalIngestAdapters(project),
+    });
+    return { project, result };
+}
+export async function findLatestDemoScanReport(projectDir) {
+    const project = await loadReadyDemoProject(projectDir);
+    const root = `raw-sources/${DEMO_CONNECTION_ID}/${DEMO_ADAPTER}`;
+    const { files } = await project.fileStore.listFiles(root, true);
+    const latest = files
+        .filter((path) => path.endsWith('/scan-report.json'))
+        .sort()
+        .at(-1);
+    if (!latest) {
+        return null;
+    }
+    const reportPath = `${root}/${latest}`;
+    const report = await project.fileStore.readFile(reportPath);
+    return jsonReport(report.content, reportPath);
+}
+export async function inspectDemoProject(projectDir, projectOverride, deps = {}) {
+    const project = projectOverride ?? (await loadReadyDemoProject(projectDir));
+    const scanReport = await findLatestDemoScanReport(project.projectDir);
+    const fullReport = await (deps.findFullReport ?? findFullDemoReport)(project);
+    const semanticLayerFileCount = await countFiles(project, `semantic-layer/${DEMO_CONNECTION_ID}`, (path) => path.endsWith('.yaml') || path.endsWith('.yml'));
+    const knowledgeFileCount = await countFiles(project, 'knowledge', (path) => path.endsWith('.md'));
+    const replayFileCount = await countFiles(project, 'replays', (path) => path.endsWith('.json'));
+    const latestReplay = await loadLatestDemoReplay(project.projectDir);
+    return {
+        projectDir: project.projectDir,
+        scanReport,
+        fullReport,
+        semanticLayerFileCount,
+        knowledgeFileCount,
+        replayFileCount,
+        latestReplay,
+    };
+}
+export function formatDemoScanSummary(report) {
+    return [
+        'Demo scan: done',
+        `Connection: ${report.connectionId}`,
+        `Driver: ${report.driver}`,
+        `Mode: ${report.mode}`,
+        `Tables: ${reportDiff(report)}`,
+        `Semantic-layer artifacts: ${report.artifactPaths.manifestShards.length}`,
+        `Report: ${report.artifactPaths.reportPath ?? 'none'}`,
+        'Next: ktx setup demo inspect',
+        '  Shows the files and semantic-layer draft created from the database scan.',
+        '',
+    ].join('\n');
+}
+function replayLine(replay) {
+    if (!replay?.metadata) {
+        return 'Latest replay: packaged demo replay';
+    }
+    return `Latest replay: ${replay.metadata.mode} (${replay.metadata.origin}, ${replay.metadata.timing})`;
+}
+export function formatDemoInspect(summary) {
+    const report = summary.scanReport;
+    const fullReport = summary.fullReport;
+    const fullCounts = fullReport ? savedCounts(fullReport) : null;
+    const scanLines = report
+        ? [
+            'Scan artifacts: yes',
+            `Connection: ${report.connectionId}`,
+            `Driver: ${report.driver}`,
+            `Tables: ${reportDiff(report)}`,
+            `Report: ${report.artifactPaths.reportPath ?? 'none'}`,
+        ]
+        : ['Scan artifacts: none'];
+    const memoryLines = fullReport
+        ? [
+            'Memory synthesis: ran',
+            `Full report: ${fullReport.id}`,
+            `Full run: ${fullReport.runId}`,
+            `Saved memory: ${fullCounts?.wikiCount ?? 0} wiki, ${fullCounts?.slCount ?? 0} semantic layer`,
+            `Provenance rows: ${fullReport.body.provenanceRows.length}`,
+        ]
+        : [report ? 'Memory synthesis: full mode not run' : 'Memory synthesis: not run'];
+    const next = fullReport
+        ? [
+            `Next: ktx ingest watch ${fullReport.runId} --project-dir ${summary.projectDir}`,
+            '  Opens the captured run timeline and lets you inspect what happened.',
+            'Next: ktx setup demo replay',
+            '  Replays the same visual story without calling the LLM again.',
+        ]
+        : report
+            ? [
+                'Next: ktx setup demo --mode full',
+                '  Runs the full AI-backed pass with your LLM provider.',
+                'Next: ktx setup demo replay',
+                '  Replays the packaged visual story without calling the LLM.',
+            ]
+            : [
+                'Next: ktx setup demo --no-input',
+                '  Runs the pre-seeded demo without calling the LLM.',
+                'Next: ktx setup demo --mode full',
+                '  Runs the full AI-backed pass with your LLM provider.',
+            ];
+    return [
+        `Demo project: ${summary.projectDir}`,
+        ...scanLines,
+        `Semantic-layer files: ${summary.semanticLayerFileCount}`,
+        `Knowledge files: ${summary.knowledgeFileCount}`,
+        `Replay files: ${summary.replayFileCount}`,
+        replayLine(summary.latestReplay),
+        ...memoryLines,
+        ...next,
+        '',
+    ].join('\n');
+}

package/dist/demo-scan.test.d.ts

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

package/dist/demo-scan.test.js

@@ -0,0 +1,27 @@
+import { rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { findLatestDemoScanReport, runDemoScan } from './demo-scan.js';
+describe('demo scan helpers', () => {
+    const projectDir = join(tmpdir(), `ktx-demo-scan-${process.pid}`);
+    afterEach(async () => {
+        await rm(projectDir, { recursive: true, force: true });
+    });
+    it('runs the packaged SQLite demo scan and finds the latest scan report', async () => {
+        const { result } = await runDemoScan({
+            projectDir,
+            jobId: 'demo-scan-test',
+            now: () => new Date('2026-05-06T10:00:00.000Z'),
+        });
+        expect(result.report).toMatchObject({
+            connectionId: 'orbit_demo',
+            driver: 'sqlite',
+            runId: 'demo-scan-test',
+            mode: 'structural',
+            dryRun: false,
+        });
+        expect(result.report.artifactPaths.reportPath).toContain('raw-sources/orbit_demo/live-database/');
+        await expect(findLatestDemoScanReport(projectDir)).resolves.toMatchObject({ runId: 'demo-scan-test' });
+    });
+});

package/dist/demo-seeded-inspect.d.ts

@@ -0,0 +1,127 @@
+import type { MemoryFlowReplayInput } from '@ktx/context/ingest/memory-flow';
+type SeededInspectReadiness = 'missing' | 'ready' | 'corrupt';
+export interface DemoSeededManifest {
+    demoAssetSchemaVersion: number;
+    name: string;
+    displayName: string;
+    mode: string;
+    source?: string;
+    sources: {
+        warehouse: {
+            label: string;
+            path?: string;
+            tables: number;
+            rowCounts: Record<string, number>;
+        };
+        dbt: {
+            label: string;
+            path?: string;
+            models: number;
+            sourceTables: number;
+        };
+        bi: {
+            label: string;
+            path?: string;
+            explores: number;
+            dashboards: number;
+        };
+        notion: {
+            label: string;
+            path?: string;
+            pages: number;
+        };
+    };
+    generated: {
+        semanticLayer: {
+            path?: string;
+            sourceCount: number;
+        };
+        knowledge: {
+            path?: string;
+            pageCount: number;
+        };
+        links: {
+            path?: string;
+            linkCount: number;
+        };
+    };
+}
+export interface SeededInspectSummary {
+    projectDir: string;
+    mode: 'seeded';
+    manifest: DemoSeededManifest;
+    status: {
+        status: SeededInspectReadiness;
+        missing: string[];
+    };
+    sourceBundle: {
+        warehouse: {
+            label: string;
+            path: string;
+            tableCount: number;
+            rowCounts: Record<string, number>;
+            totalRows: number;
+        };
+        dbt: {
+            label: string;
+            path: string;
+            modelCount: number;
+            sourceTableCount: number;
+        };
+        bi: {
+            label: string;
+            path: string;
+            exploreCount: number;
+            dashboardCount: number;
+        };
+        notion: {
+            label: string;
+            path: string;
+            pageCount: number;
+        };
+    };
+    generatedOutputs: {
+        semanticLayer: {
+            path: string;
+            manifestSourceCount: number;
+            fileCount: number;
+        };
+        knowledge: {
+            path: string;
+            manifestPageCount: number;
+            fileCount: number;
+        };
+        links: {
+            path: string;
+            manifestLinkCount: number;
+            linkCount: number;
+        };
+        reports: {
+            primaryPath: string;
+            fileCount: number;
+        };
+        replays: {
+            primaryPath: string;
+            latestPath: string;
+            fileCount: number;
+        };
+    };
+    modeMetadata: {
+        mode: 'seeded';
+        source: 'packaged demo project';
+        generatedContext: 'prebuilt from bundled assets';
+        llmCalls: 'none';
+        origin: string;
+        timing: string;
+        sourceReportId: string | null;
+        sourceReportPath: string | null;
+    };
+    nextCommands: Array<{
+        command: string;
+        description: string;
+    }>;
+    latestReplay: MemoryFlowReplayInput | null;
+}
+export declare function inspectSeededProject(projectDir: string): Promise<SeededInspectSummary>;
+export declare function formatSeededInspect(summary: SeededInspectSummary): string;
+export {};

package/dist/demo-seeded-inspect.js

@@ -0,0 +1,198 @@
+import { constants as fsConstants } from 'node:fs';
+import { access, readFile, readdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { loadPackagedDemoReplay } from './demo-assets.js';
+import { DEMO_LATEST_REPLAY_FILE, loadLatestDemoReplay } from './demo-replay-store.js';
+import { KTX_NEXT_STEP_COMMANDS, KTX_NEXT_STEP_COMMAND_WIDTH } from './next-steps.js';
+const REQUIRED_SEEDED_PROJECT_PATHS = [
+    'ktx.yaml',
+    'demo.db',
+    'state.sqlite',
+    'manifest.json',
+    join('replays', 'replay.memory-flow.v1.json'),
+    join('raw-sources', 'warehouse', 'accounts.csv'),
+    join('raw-sources', 'dbt', 'schema.yml'),
+    join('raw-sources', 'bi', 'revenue_exec.dashboard.lookml'),
+    join('raw-sources', 'notion', 'revenue-reporting-policy.md'),
+    join('semantic-layer', 'orbit_demo', 'accounts.yaml'),
+    join('knowledge', 'global', 'arr-contract-first.md'),
+    join('links', 'provenance.json'),
+    join('reports', 'seeded-demo-report.json'),
+];
+async function exists(path) {
+    try {
+        await access(path, fsConstants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function loadSeededManifest(projectDir) {
+    const raw = await readFile(join(projectDir, 'manifest.json'), 'utf-8');
+    return JSON.parse(raw);
+}
+async function listFilesInDir(dir, ext) {
+    try {
+        const entries = await readdir(dir, { recursive: true });
+        return entries
+            .filter((entry) => typeof entry === 'string')
+            .filter((entry) => !ext || entry.endsWith(ext))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+async function inspectSeededProjectStatus(projectDir) {
+    const missing = [];
+    for (const relativePath of REQUIRED_SEEDED_PROJECT_PATHS) {
+        if (!(await exists(join(projectDir, relativePath)))) {
+            missing.push(relativePath);
+        }
+    }
+    if (missing.length === REQUIRED_SEEDED_PROJECT_PATHS.length) {
+        return { status: 'missing', missing };
+    }
+    if (missing.length > 0) {
+        return { status: 'corrupt', missing };
+    }
+    return { status: 'ready', missing: [] };
+}
+async function loadLinksCount(projectDir) {
+    try {
+        const raw = await readFile(join(projectDir, 'links', 'provenance.json'), 'utf-8');
+        const links = JSON.parse(raw);
+        return links.length;
+    }
+    catch {
+        return 0;
+    }
+}
+async function loadSeededReplay(projectDir) {
+    const latest = await loadLatestDemoReplay(projectDir);
+    if (latest) {
+        return latest;
+    }
+    try {
+        return await loadPackagedDemoReplay();
+    }
+    catch {
+        return null;
+    }
+}
+function sourceBundleFromManifest(manifest) {
+    const warehouse = manifest.sources.warehouse;
+    const rowCounts = Object.fromEntries(Object.entries(warehouse.rowCounts).sort(([a], [b]) => a.localeCompare(b)));
+    const totalRows = Object.values(rowCounts).reduce((total, count) => total + count, 0);
+    return {
+        warehouse: {
+            label: warehouse.label,
+            path: warehouse.path ?? 'demo.db',
+            tableCount: warehouse.tables,
+            rowCounts,
+            totalRows,
+        },
+        dbt: {
+            label: manifest.sources.dbt.label,
+            path: manifest.sources.dbt.path ?? 'raw-sources/dbt',
+            modelCount: manifest.sources.dbt.models,
+            sourceTableCount: manifest.sources.dbt.sourceTables,
+        },
+        bi: {
+            label: manifest.sources.bi.label,
+            path: manifest.sources.bi.path ?? 'raw-sources/bi',
+            exploreCount: manifest.sources.bi.explores,
+            dashboardCount: manifest.sources.bi.dashboards,
+        },
+        notion: {
+            label: manifest.sources.notion.label,
+            path: manifest.sources.notion.path ?? 'raw-sources/notion',
+            pageCount: manifest.sources.notion.pages,
+        },
+    };
+}
+function nextCommands() {
+    return [...KTX_NEXT_STEP_COMMANDS];
+}
+function modeMetadataFromReplay(replay) {
+    return {
+        mode: 'seeded',
+        source: 'packaged demo project',
+        generatedContext: 'prebuilt from bundled assets',
+        llmCalls: 'none',
+        origin: replay?.metadata?.origin ?? 'packaged',
+        timing: replay?.metadata?.timing ?? 'prebuilt',
+        sourceReportId: replay?.metadata?.sourceReportId ?? 'demo-seeded-report',
+        sourceReportPath: replay?.metadata?.sourceReportPath ?? 'reports/seeded-demo-report.json',
+    };
+}
+export async function inspectSeededProject(projectDir) {
+    const root = resolve(projectDir);
+    const manifest = await loadSeededManifest(root);
+    const latestReplay = await loadSeededReplay(root);
+    const semanticLayerPath = manifest.generated.semanticLayer.path ?? 'semantic-layer/orbit_demo';
+    const knowledgePath = manifest.generated.knowledge.path ?? 'knowledge/global';
+    const linksPath = join(manifest.generated.links.path ?? 'links', 'provenance.json');
+    const reportFiles = await listFilesInDir(join(root, 'reports'), '.json');
+    const replayFiles = await listFilesInDir(join(root, 'replays'), '.json');
+    return {
+        projectDir: root,
+        mode: 'seeded',
+        manifest,
+        status: await inspectSeededProjectStatus(root),
+        sourceBundle: sourceBundleFromManifest(manifest),
+        generatedOutputs: {
+            semanticLayer: {
+                path: semanticLayerPath,
+                manifestSourceCount: manifest.generated.semanticLayer.sourceCount,
+                fileCount: (await listFilesInDir(join(root, semanticLayerPath), '.yaml')).length,
+            },
+            knowledge: {
+                path: knowledgePath,
+                manifestPageCount: manifest.generated.knowledge.pageCount,
+                fileCount: (await listFilesInDir(join(root, knowledgePath), '.md')).length,
+            },
+            links: {
+                path: linksPath,
+                manifestLinkCount: manifest.generated.links.linkCount,
+                linkCount: await loadLinksCount(root),
+            },
+            reports: {
+                primaryPath: reportFiles[0] ? join('reports', reportFiles[0]) : 'reports/seeded-demo-report.json',
+                fileCount: reportFiles.length,
+            },
+            replays: {
+                primaryPath: join('replays', 'replay.memory-flow.v1.json'),
+                latestPath: join('replays', DEMO_LATEST_REPLAY_FILE),
+                fileCount: replayFiles.length,
+            },
+        },
+        modeMetadata: modeMetadataFromReplay(latestReplay),
+        nextCommands: nextCommands(),
+        latestReplay,
+    };
+}
+function rowCountPreview(rowCounts) {
+    return Object.entries(rowCounts)
+        .map(([name, count]) => `${name} ${count}`)
+        .join(', ');
+}
+function replayLine(summary) {
+    const metadata = summary.latestReplay?.metadata ?? summary.modeMetadata;
+    return `Latest replay: ${metadata.mode} (${metadata.origin}, ${metadata.timing})`;
+}
+export function formatSeededInspect(summary) {
+    const source = summary.sourceBundle;
+    const generated = summary.generatedOutputs;
+    const lines = [`Demo project: ${summary.projectDir}`, `Status: ${summary.status.status}`];
+    if (summary.status.missing.length > 0) {
+        lines.push(`Missing: ${summary.status.missing.join(', ')}`);
+    }
+    lines.push(`Mode: seeded (pre-seeded demo project)`, `Source: ${summary.modeMetadata.source}`, `Generated context: ${summary.modeMetadata.generatedContext}`, `LLM calls: ${summary.modeMetadata.llmCalls}`, '', 'Source bundle:', `  Warehouse: ${source.warehouse.tableCount} tables, ${source.warehouse.totalRows.toLocaleString()} rows`, `    Rows: ${rowCountPreview(source.warehouse.rowCounts)}`, `  dbt: ${source.dbt.modelCount} models, ${source.dbt.sourceTableCount} source tables`, `  BI: ${source.bi.exploreCount} explores, ${source.bi.dashboardCount} dashboards`, `  Notion: ${source.notion.pageCount} pages`, '', 'Generated context:', `  Semantic-layer sources: ${generated.semanticLayer.manifestSourceCount} manifest, ${generated.semanticLayer.fileCount} files`, `  Knowledge pages: ${generated.knowledge.manifestPageCount} manifest, ${generated.knowledge.fileCount} files`, `  Evidence links: ${generated.links.manifestLinkCount} manifest, ${generated.links.linkCount} links`, '', `Report: ${generated.reports.primaryPath}`, `Replay: ${generated.replays.primaryPath}`, replayLine(summary), '', 'What to do next:');
+    for (const command of summary.nextCommands) {
+        lines.push(`  $ ${command.command.padEnd(KTX_NEXT_STEP_COMMAND_WIDTH)}  ${command.description}`);
+    }
+    lines.push('', `Your KTX project files are at: ${summary.projectDir}`, '');
+    return lines.join('\n');
+}

package/dist/demo-seeded-inspect.test.d.ts

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

package/dist/demo-seeded-inspect.test.js

@@ -0,0 +1,108 @@
+import { access, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { runDemoSeeded } from './demo-seeded.js';
+import { formatSeededInspect, inspectSeededProject } from './demo-seeded-inspect.js';
+import { KTX_NEXT_STEP_COMMANDS } from './next-steps.js';
+describe('seeded demo inspect contract', () => {
+    const projectDir = join(tmpdir(), `ktx-demo-seeded-inspect-${process.pid}`);
+    afterEach(async () => {
+        await rm(projectDir, { recursive: true, force: true });
+    });
+    it('reports the PRD source inventory, generated outputs, status, metadata, and next commands', async () => {
+        await runDemoSeeded({ projectDir });
+        const inspect = await inspectSeededProject(projectDir);
+        expect(inspect).toMatchObject({
+            projectDir,
+            mode: 'seeded',
+            status: { status: 'ready', missing: [] },
+            modeMetadata: {
+                mode: 'seeded',
+                source: 'packaged demo project',
+                generatedContext: 'prebuilt from bundled assets',
+                llmCalls: 'none',
+                origin: 'packaged',
+                timing: 'prebuilt',
+                sourceReportId: 'demo-seeded-report',
+                sourceReportPath: 'reports/seeded-demo-report.json',
+            },
+            sourceBundle: {
+                warehouse: {
+                    label: 'Warehouse',
+                    path: 'demo.db',
+                    tableCount: 8,
+                    totalRows: 11234,
+                    rowCounts: {
+                        accounts: 210,
+                        arr_movements: 720,
+                        contracts: 320,
+                        invoices: 3000,
+                        plans: 4,
+                        purchase_requests: 5200,
+                        support_tickets: 520,
+                        users: 1260,
+                    },
+                },
+                dbt: { label: 'dbt', path: 'raw-sources/dbt', modelCount: 3, sourceTableCount: 8 },
+                bi: { label: 'BI', path: 'raw-sources/bi', exploreCount: 5, dashboardCount: 2 },
+                notion: { label: 'Notion', path: 'raw-sources/notion', pageCount: 8 },
+            },
+            generatedOutputs: {
+                semanticLayer: { path: 'semantic-layer/orbit_demo', manifestSourceCount: 6, fileCount: 6 },
+                knowledge: { path: 'knowledge/global', manifestPageCount: 10, fileCount: 10 },
+                links: { path: 'links/provenance.json', manifestLinkCount: 23, linkCount: 23 },
+                reports: { primaryPath: 'reports/seeded-demo-report.json', fileCount: 1 },
+                replays: { primaryPath: 'replays/replay.memory-flow.v1.json', latestPath: 'replays/latest.memory-flow.v1.json' },
+            },
+            nextCommands: KTX_NEXT_STEP_COMMANDS,
+        });
+        expect(inspect.generatedOutputs.replays.fileCount).toBeGreaterThanOrEqual(3);
+        await expect(access(join(projectDir, inspect.generatedOutputs.reports.primaryPath))).resolves.toBeUndefined();
+        await expect(access(join(projectDir, inspect.generatedOutputs.replays.primaryPath))).resolves.toBeUndefined();
+        await expect(access(join(projectDir, inspect.generatedOutputs.replays.latestPath))).resolves.toBeUndefined();
+    });
+    it('formats seeded inspect from the normalized contract', async () => {
+        await runDemoSeeded({ projectDir });
+        const output = formatSeededInspect(await inspectSeededProject(projectDir));
+        expect(output).toContain(`Demo project: ${projectDir}`);
+        expect(output).toContain('Status: ready');
+        expect(output).toContain('Mode: seeded (pre-seeded demo project)');
+        expect(output).toContain('Source: packaged demo project');
+        expect(output).toContain('Generated context: prebuilt from bundled assets');
+        expect(output).toContain('LLM calls: none');
+        expect(output).toContain('Warehouse: 8 tables, 11,234 rows');
+        expect(output).toContain('Rows: accounts 210, arr_movements 720, contracts 320, invoices 3000');
+        expect(output).toContain('dbt: 3 models, 8 source tables');
+        expect(output).toContain('BI: 5 explores, 2 dashboards');
+        expect(output).toContain('Notion: 8 pages');
+        expect(output).toContain('Semantic-layer sources: 6 manifest, 6 files');
+        expect(output).toContain('Knowledge pages: 10 manifest, 10 files');
+        expect(output).toContain('Evidence links: 23 manifest, 23 links');
+        expect(output).toContain('Report: reports/seeded-demo-report.json');
+        expect(output).toContain('Replay: replays/replay.memory-flow.v1.json');
+        expect(output).toContain('Latest replay: seeded (packaged, prebuilt)');
+        expect(output).toContain('  $ ktx agent tools --json');
+        expect(output).toContain('  $ ktx agent context --json');
+        expect(output).toContain('  $ ktx serve --mcp stdio --user-id local');
+        expect(output.indexOf('ktx agent tools --json')).toBeLessThan(output.indexOf('ktx serve --mcp stdio --user-id local'));
+        expect(output).not.toContain('ktx ask');
+        expect(output).not.toContain('deterministic mode');
+    });
+    it('reports missing seeded paths without reading stale counts as ready', async () => {
+        await runDemoSeeded({ projectDir });
+        await rm(join(projectDir, 'links', 'provenance.json'));
+        const inspect = await inspectSeededProject(projectDir);
+        expect(inspect.status).toEqual({ status: 'corrupt', missing: ['links/provenance.json'] });
+        expect(formatSeededInspect(inspect)).toContain('Status: corrupt');
+        expect(formatSeededInspect(inspect)).toContain('Missing: links/provenance.json');
+    });
+    it('keeps provenance link counts tied to the project file', async () => {
+        await runDemoSeeded({ projectDir });
+        const inspect = await inspectSeededProject(projectDir);
+        const raw = await readFile(join(projectDir, 'links', 'provenance.json'), 'utf-8');
+        const links = JSON.parse(raw);
+        expect(inspect.generatedOutputs.links.linkCount).toBe(links.length);
+        expect(inspect.generatedOutputs.links.linkCount).toBe(23);
+    });
+});

package/dist/demo-seeded.d.ts

@@ -0,0 +1,11 @@
+import type { MemoryFlowReplayInput } from '@ktx/context/ingest/memory-flow';
+import { type SeededInspectSummary } from './demo-seeded-inspect.js';
+export { formatSeededInspect, inspectSeededProject, type DemoSeededManifest, type SeededInspectSummary, } from './demo-seeded-inspect.js';
+export interface DemoSeededResult {
+    projectDir: string;
+    replay: MemoryFlowReplayInput;
+    inspect: SeededInspectSummary;
+}
+export declare function runDemoSeeded(options: {
+    projectDir: string;
+}): Promise<DemoSeededResult>;

package/dist/demo-seeded.js

@@ -0,0 +1,19 @@
+import { ensureSeededDemoProject, loadPackagedDemoReplay, } from './demo-assets.js';
+import { writeDemoReplay } from './demo-replay-store.js';
+import { inspectSeededProject } from './demo-seeded-inspect.js';
+export { formatSeededInspect, inspectSeededProject, } from './demo-seeded-inspect.js';
+export async function runDemoSeeded(options) {
+    const result = await ensureSeededDemoProject({ projectDir: options.projectDir, force: false });
+    const replay = await loadPackagedDemoReplay();
+    const replayWithDir = {
+        ...replay,
+        sourceDir: result.projectDir,
+    };
+    await writeDemoReplay(result.projectDir, replayWithDir, { label: 'seeded' });
+    const inspect = await inspectSeededProject(result.projectDir);
+    return {
+        projectDir: result.projectDir,
+        replay: replayWithDir,
+        inspect,
+    };
+}

package/dist/demo-seeded.test.d.ts

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