@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/context/dist/ingest/memory-flow/live-buffer.test.js

@@ -0,0 +1,77 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createMemoryFlowLiveBuffer, sanitizeMemoryFlowError } from './live-buffer.js';
+function initialReplay() {
+    return {
+        runId: 'live-run-1',
+        connectionId: 'warehouse',
+        adapter: 'fake',
+        status: 'running',
+        sourceDir: '/tmp/source',
+        syncId: 'pending',
+        errors: [],
+        events: [],
+        plannedWorkUnits: [],
+        details: { actions: [], provenance: [], transcripts: [] },
+    };
+}
+describe('createMemoryFlowLiveBuffer', () => {
+    it('emits immutable replay snapshots on every live change', () => {
+        const onChange = vi.fn();
+        const buffer = createMemoryFlowLiveBuffer(initialReplay(), { onChange });
+        buffer.emit({ type: 'source_acquired', adapter: 'fake', trigger: 'manual_resync', fileCount: 2 });
+        buffer.update({
+            syncId: 'sync-1',
+            plannedWorkUnits: [
+                {
+                    unitKey: 'fake-orders',
+                    rawFiles: ['orders.json'],
+                    peerFileCount: 0,
+                    dependencyCount: 0,
+                },
+            ],
+        });
+        buffer.emit({ type: 'chunks_planned', chunkCount: 1, workUnitCount: 1, evictionCount: 0 });
+        buffer.finish('done');
+        expect(onChange).toHaveBeenCalledTimes(4);
+        expect(buffer.snapshot()).toMatchObject({
+            runId: 'live-run-1',
+            status: 'done',
+            syncId: 'sync-1',
+            plannedWorkUnits: [{ unitKey: 'fake-orders' }],
+        });
+        expect(buffer.snapshot().events.map((event) => event.type)).toEqual(['source_acquired', 'chunks_planned']);
+        const staleSnapshot = onChange.mock.calls[1][0];
+        expect(staleSnapshot.details).toEqual({ actions: [], provenance: [], transcripts: [] });
+        staleSnapshot.events.push({ type: 'report_created', runId: 'mutated' });
+        expect(buffer.snapshot().events.map((event) => event.type)).toEqual(['source_acquired', 'chunks_planned']);
+    });
+    it('stamps live events with emittedAt without mutating caller events', () => {
+        const event = { type: 'source_acquired', adapter: 'fake', trigger: 'manual_resync', fileCount: 2 };
+        const buffer = createMemoryFlowLiveBuffer(initialReplay(), {
+            now: () => new Date('2026-05-01T10:00:00.000Z'),
+        });
+        buffer.emit(event);
+        expect(event).not.toHaveProperty('emittedAt');
+        expect(buffer.snapshot().events).toEqual([
+            {
+                type: 'source_acquired',
+                adapter: 'fake',
+                trigger: 'manual_resync',
+                fileCount: 2,
+                emittedAt: '2026-05-01T10:00:00.000Z',
+            },
+        ]);
+    });
+    it('marks failed runs with sanitized error messages', () => {
+        const onChange = vi.fn();
+        const buffer = createMemoryFlowLiveBuffer(initialReplay(), { onChange });
+        buffer.finish('error', [
+            sanitizeMemoryFlowError(new Error('Connection failed for postgres://user:password@localhost:5432/db?api_key=abc password=secret')),
+        ]);
+        expect(buffer.snapshot()).toMatchObject({
+            status: 'error',
+            errors: ['Connection failed for postgres://[redacted] password=[redacted]'],
+        });
+        expect(onChange).toHaveBeenCalledTimes(1);
+    });
+});

package/node_modules/@ktx/context/dist/ingest/memory-flow/package-export.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/memory-flow/package-export.test.js

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest';
+describe('@ktx/context/ingest/memory-flow lightweight export', () => {
+    it('exports replay parsing and text rendering without the full ingest entry point', async () => {
+        const memoryFlow = await import('./index.js');
+        expect(memoryFlow.parseMemoryFlowReplayInput).toBeTypeOf('function');
+        expect(memoryFlow.buildMemoryFlowViewModel).toBeTypeOf('function');
+        expect(memoryFlow.renderMemoryFlowReplay).toBeTypeOf('function');
+    });
+});

package/node_modules/@ktx/context/dist/ingest/memory-flow/render.d.ts

@@ -0,0 +1,2 @@
+import type { MemoryFlowRenderOptions, MemoryFlowViewModel } from './types.js';
+export declare function renderMemoryFlowReplay(view: MemoryFlowViewModel, options?: MemoryFlowRenderOptions): string;

package/node_modules/@ktx/context/dist/ingest/memory-flow/render.js

@@ -0,0 +1,84 @@
+import { renderMemoryFlowConnectorLine } from './visuals.js';
+const WIDE_COLUMN_WIDTH = 20;
+function cell(value, width = WIDE_COLUMN_WIDTH) {
+    const text = value ?? '';
+    const normalized = text.length > width ? text.slice(0, width - 1) : text;
+    return normalized.padEnd(width, ' ');
+}
+function row(values) {
+    return values.map((value) => cell(value)).join('  ').trimEnd();
+}
+function counterAt(column, index) {
+    return column.counters[index] ?? '';
+}
+function trustIssueLines(view) {
+    if (view.trustIssues.length === 0) {
+        return [];
+    }
+    return [
+        'Trust issues',
+        ...view.trustIssues.slice(0, 4).map((issue) => {
+            const label = issue.severity === 'failed' ? 'FAILED' : 'WARNING';
+            return `${label} ${issue.title}: ${issue.detail}`;
+        }),
+        ...(view.trustIssues.length > 4 ? [`+${view.trustIssues.length - 4} more trust issues`] : []),
+        '',
+    ];
+}
+function renderWide(view) {
+    const lines = [
+        view.title,
+        view.activeLine,
+        view.subtitle,
+        renderMemoryFlowConnectorLine(view),
+        ...trustIssueLines(view),
+        '',
+        row(view.columns.map((column) => column.title)),
+        row(view.columns.map((column) => column.headline)),
+        row(view.columns.map((column) => counterAt(column, 0))),
+        row(view.columns.map((column) => counterAt(column, 1))),
+        '',
+        `Selected: ${view.selectedTitle}`,
+        ...view.selectedDetails.map((detail) => `- ${detail}`),
+    ];
+    if (view.completionLine) {
+        lines.push('', view.completionLine);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function renderNarrowColumn(column) {
+    return [
+        column.title,
+        `  ${column.headline}`,
+        ...column.counters.slice(0, 3).map((counter) => `  ${counter}`),
+    ];
+}
+function renderNarrow(view) {
+    const lines = [
+        view.title,
+        view.activeLine,
+        view.subtitle,
+        renderMemoryFlowConnectorLine(view),
+        ...trustIssueLines(view),
+        '',
+        ...view.columns.flatMap((column, index) => [
+            ...(index > 0 ? [''] : []),
+            ...renderNarrowColumn(column),
+        ]),
+        '',
+        `Selected: ${view.selectedTitle}`,
+        ...view.selectedDetails.map((detail) => `- ${detail}`),
+    ];
+    if (view.completionLine) {
+        lines.push('', view.completionLine);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+export function renderMemoryFlowReplay(view, options = {}) {
+    if ((options.terminalWidth ?? 120) < 100) {
+        return renderNarrow(view);
+    }
+    return renderWide(view);
+}

package/node_modules/@ktx/context/dist/ingest/memory-flow/render.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/memory-flow/render.test.js

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest';
+import { renderMemoryFlowReplay } from './render.js';
+function view() {
+    return {
+        title: 'KTX memory flow  warehouse/metricflow  done',
+        subtitle: 'Run run-1  Sync sync-1',
+        status: 'done',
+        activeLine: 'active: complete',
+        selectedTitle: 'SOURCE',
+        selectedDetails: ['Trigger: manual_resync', 'Adapter: metricflow'],
+        completionLine: 'Saved 2 memories from 2 raw files: 1 wiki pages, 1 SL updates. Commit: abc12345  Run: run-1  Report: report-1',
+        trustIssues: [],
+        details: { actions: [], provenance: [], transcripts: [] },
+        columns: [
+            {
+                id: 'source',
+                title: 'SOURCE',
+                status: 'complete',
+                headline: '2 raw files',
+                counters: ['sync sync-1', 'scope none'],
+                chips: [{ label: 'metricflow', status: 'complete' }],
+                details: ['Trigger: manual_resync'],
+            },
+            {
+                id: 'chunks',
+                title: 'CHUNKS',
+                status: 'complete',
+                headline: '2 chunks',
+                counters: ['+1 ~1 -0 =3', '0 deletions'],
+                chips: [{ label: 'orders', status: 'complete' }],
+                details: ['Work units planned: 2'],
+            },
+            {
+                id: 'workUnits',
+                title: 'WORKUNITS',
+                status: 'warning',
+                headline: '2 WUs',
+                counters: ['1 done', '1 failed', '0 active'],
+                chips: [{ label: 'orders', status: 'complete' }],
+                details: ['orders: 1 raw, 1 peers, 1 deps'],
+            },
+            {
+                id: 'actions',
+                title: 'ACTIONS',
+                status: 'complete',
+                headline: '2 candidates',
+                counters: ['1 wiki', '1 SL'],
+                chips: [{ label: 'knowledge/orders.md', status: 'complete' }],
+                details: ['wiki created: knowledge/orders.md'],
+            },
+            {
+                id: 'gates',
+                title: 'GATES',
+                status: 'warning',
+                headline: '1 conflict, 1 fallback',
+                counters: ['1 failed', '1 flagged'],
+                chips: [{ label: 'customers', status: 'failed' }],
+                details: ['Failed work units: 1'],
+            },
+            {
+                id: 'saved',
+                title: 'SAVED',
+                status: 'complete',
+                headline: '2 memories',
+                counters: ['1 wiki', '1 SL', '3 provenance'],
+                chips: [{ label: 'abc12345', status: 'complete' }],
+                details: ['Commit: abc12345'],
+            },
+        ],
+    };
+}
+describe('renderMemoryFlowReplay', () => {
+    it('renders a six-column wide terminal snapshot', () => {
+        expect(renderMemoryFlowReplay(view(), { terminalWidth: 140 })).toContain('OK SOURCE -> OK CHUNKS -> !! WORKUNITS -> OK ACTIONS -> !! GATES -> OK SAVED');
+        expect(renderMemoryFlowReplay(view(), { terminalWidth: 140 })).toMatchInlineSnapshot(`
+      "KTX memory flow  warehouse/metricflow  done
+      active: complete
+      Run run-1  Sync sync-1
+      OK SOURCE -> OK CHUNKS -> !! WORKUNITS -> OK ACTIONS -> !! GATES -> OK SAVED
+
+      SOURCE                CHUNKS                WORKUNITS             ACTIONS               GATES                 SAVED
+      2 raw files           2 chunks              2 WUs                 2 candidates          1 conflict, 1 fallb   2 memories
+      sync sync-1           +1 ~1 -0 =3           1 done                1 wiki                1 failed              1 wiki
+      scope none            0 deletions           1 failed              1 SL                  1 flagged             1 SL
+
+      Selected: SOURCE
+      - Trigger: manual_resync
+      - Adapter: metricflow
+
+      Saved 2 memories from 2 raw files: 1 wiki pages, 1 SL updates. Commit: abc12345  Run: run-1  Report: report-1
+      "
+    `);
+    });
+    it('renders a stacked narrow terminal snapshot', () => {
+        expect(renderMemoryFlowReplay(view(), { terminalWidth: 72 })).toContain('OK SOURCE -> OK CHUNKS -> !! WORKUNITS -> OK ACTIONS -> !! GATES -> OK SAVED');
+        expect(renderMemoryFlowReplay(view(), { terminalWidth: 72 })).toContain(`SOURCE
+  2 raw files
+  sync sync-1
+  scope none`);
+        expect(renderMemoryFlowReplay(view(), { terminalWidth: 72 })).toContain(`GATES
+  1 conflict, 1 fallback
+  1 failed
+  1 flagged`);
+    });
+});

package/node_modules/@ktx/context/dist/ingest/memory-flow/schema.d.ts

@@ -0,0 +1,190 @@
+import * as z from 'zod';
+import type { MemoryFlowReplayInput } from './types.js';
+export declare const memoryFlowRunStatusSchema: z.ZodEnum<{
+    error: "error";
+    done: "done";
+    running: "running";
+}>;
+export declare const memoryFlowEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"source_acquired">;
+    adapter: z.ZodString;
+    trigger: z.ZodString;
+    fileCount: z.ZodNumber;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"scope_detected">;
+    fingerprint: z.ZodNullable<z.ZodString>;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"raw_snapshot_written">;
+    syncId: z.ZodString;
+    rawFileCount: z.ZodNumber;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"diff_computed">;
+    added: z.ZodNumber;
+    modified: z.ZodNumber;
+    deleted: z.ZodNumber;
+    unchanged: z.ZodNumber;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"chunks_planned">;
+    chunkCount: z.ZodNumber;
+    workUnitCount: z.ZodNumber;
+    evictionCount: z.ZodNumber;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"stage_skipped">;
+    stage: z.ZodEnum<{
+        source: "source";
+        workUnits: "workUnits";
+        chunks: "chunks";
+        actions: "actions";
+        gates: "gates";
+        saved: "saved";
+    }>;
+    reason: z.ZodString;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"work_unit_started">;
+    unitKey: z.ZodString;
+    skills: z.ZodArray<z.ZodString>;
+    stepBudget: z.ZodNumber;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"work_unit_step">;
+    unitKey: z.ZodString;
+    stepIndex: z.ZodNumber;
+    stepBudget: z.ZodNumber;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"candidate_action">;
+    unitKey: z.ZodString;
+    target: z.ZodEnum<{
+        wiki: "wiki";
+        sl: "sl";
+    }>;
+    action: z.ZodString;
+    key: z.ZodString;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"work_unit_finished">;
+    unitKey: z.ZodString;
+    status: z.ZodEnum<{
+        success: "success";
+        failed: "failed";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reconciliation_finished">;
+    conflictCount: z.ZodNumber;
+    fallbackCount: z.ZodNumber;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"saved">;
+    commitSha: z.ZodNullable<z.ZodString>;
+    wikiCount: z.ZodNumber;
+    slCount: z.ZodNumber;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"provenance_recorded">;
+    rowCount: z.ZodNumber;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"report_created">;
+    runId: z.ZodString;
+    reportPath: z.ZodOptional<z.ZodString>;
+} & {
+    emittedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export declare const memoryFlowPlannedWorkUnitSchema: z.ZodObject<{
+    unitKey: z.ZodString;
+    rawFiles: z.ZodArray<z.ZodString>;
+    peerFileCount: z.ZodNumber;
+    dependencyCount: z.ZodNumber;
+}, z.core.$strip>;
+export declare const memoryFlowActionDetailSchema: z.ZodObject<{
+    unitKey: z.ZodString;
+    target: z.ZodEnum<{
+        wiki: "wiki";
+        sl: "sl";
+    }>;
+    action: z.ZodEnum<{
+        created: "created";
+        updated: "updated";
+        removed: "removed";
+    }>;
+    key: z.ZodString;
+    summary: z.ZodString;
+    rawFiles: z.ZodArray<z.ZodString>;
+    status: z.ZodEnum<{
+        success: "success";
+        failed: "failed";
+    }>;
+}, z.core.$strip>;
+export declare const memoryFlowDetailSectionsSchema: z.ZodObject<{
+    actions: z.ZodArray<z.ZodObject<{
+        unitKey: z.ZodString;
+        target: z.ZodEnum<{
+            wiki: "wiki";
+            sl: "sl";
+        }>;
+        action: z.ZodEnum<{
+            created: "created";
+            updated: "updated";
+            removed: "removed";
+        }>;
+        key: z.ZodString;
+        summary: z.ZodString;
+        rawFiles: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            success: "success";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>>;
+    provenance: z.ZodArray<z.ZodObject<{
+        rawPath: z.ZodString;
+        artifactKind: z.ZodNullable<z.ZodEnum<{
+            wiki: "wiki";
+            sl: "sl";
+        }>>;
+        artifactKey: z.ZodNullable<z.ZodString>;
+        actionType: z.ZodString;
+    }, z.core.$strip>>;
+    transcripts: z.ZodArray<z.ZodObject<{
+        unitKey: z.ZodString;
+        path: z.ZodString;
+        toolCallCount: z.ZodNumber;
+        errorCount: z.ZodNumber;
+        toolNames: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const memoryFlowReplayInputSchema: z.ZodType<MemoryFlowReplayInput>;
+export declare const memoryFlowStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"snapshot">;
+    snapshot: z.ZodType<MemoryFlowReplayInput, unknown, z.core.$ZodTypeInternals<MemoryFlowReplayInput, unknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"closed">;
+    status: z.ZodEnum<{
+        error: "error";
+        done: "done";
+        running: "running";
+    }>;
+    errors: z.ZodArray<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type MemoryFlowStreamEvent = z.infer<typeof memoryFlowStreamEventSchema>;
+export declare function parseMemoryFlowReplayInput(value: unknown): MemoryFlowReplayInput;

package/node_modules/@ktx/context/dist/ingest/memory-flow/schema.js

@@ -0,0 +1,155 @@
+import * as z from 'zod';
+export const memoryFlowRunStatusSchema = z.enum(['running', 'done', 'error']);
+const memoryFlowEventTimestampShape = {
+    emittedAt: z.string().datetime().optional(),
+};
+function eventSchema(shape) {
+    return z.object({ ...shape, ...memoryFlowEventTimestampShape });
+}
+const memoryFlowReplayMetadataSchema = z.object({
+    schemaVersion: z.literal(1),
+    mode: z.enum(['full', 'deterministic', 'replay', 'seeded']),
+    origin: z.enum(['captured', 'packaged', 'synthetic-report']),
+    timing: z.enum(['captured', 'synthetic', 'not-captured', 'prebuilt']),
+    capturedAt: z.string().datetime().nullable(),
+    sourceReportId: z.string().min(1).nullable(),
+    sourceReportPath: z.string().min(1).nullable(),
+    fallbackReason: z.string().min(1).nullable(),
+});
+export const memoryFlowEventSchema = z.discriminatedUnion('type', [
+    eventSchema({
+        type: z.literal('source_acquired'),
+        adapter: z.string().min(1),
+        trigger: z.string().min(1),
+        fileCount: z.number().int().min(0),
+    }),
+    eventSchema({ type: z.literal('scope_detected'), fingerprint: z.string().nullable() }),
+    eventSchema({
+        type: z.literal('raw_snapshot_written'),
+        syncId: z.string().min(1),
+        rawFileCount: z.number().int().min(0),
+    }),
+    eventSchema({
+        type: z.literal('diff_computed'),
+        added: z.number().int().min(0),
+        modified: z.number().int().min(0),
+        deleted: z.number().int().min(0),
+        unchanged: z.number().int().min(0),
+    }),
+    eventSchema({
+        type: z.literal('chunks_planned'),
+        chunkCount: z.number().int().min(0),
+        workUnitCount: z.number().int().min(0),
+        evictionCount: z.number().int().min(0),
+    }),
+    eventSchema({
+        type: z.literal('stage_skipped'),
+        stage: z.enum(['source', 'chunks', 'workUnits', 'actions', 'gates', 'saved']),
+        reason: z.string().min(1),
+    }),
+    eventSchema({
+        type: z.literal('work_unit_started'),
+        unitKey: z.string().min(1),
+        skills: z.array(z.string().min(1)),
+        stepBudget: z.number().int().min(0),
+    }),
+    eventSchema({
+        type: z.literal('work_unit_step'),
+        unitKey: z.string().min(1),
+        stepIndex: z.number().int().min(0),
+        stepBudget: z.number().int().min(0),
+    }),
+    eventSchema({
+        type: z.literal('candidate_action'),
+        unitKey: z.string().min(1),
+        target: z.enum(['wiki', 'sl']),
+        action: z.string().min(1),
+        key: z.string().min(1),
+    }),
+    eventSchema({
+        type: z.literal('work_unit_finished'),
+        unitKey: z.string().min(1),
+        status: z.enum(['success', 'failed']),
+        reason: z.string().optional(),
+    }),
+    eventSchema({
+        type: z.literal('reconciliation_finished'),
+        conflictCount: z.number().int().min(0),
+        fallbackCount: z.number().int().min(0),
+    }),
+    eventSchema({
+        type: z.literal('saved'),
+        commitSha: z.string().nullable(),
+        wikiCount: z.number().int().min(0),
+        slCount: z.number().int().min(0),
+    }),
+    eventSchema({ type: z.literal('provenance_recorded'), rowCount: z.number().int().min(0) }),
+    eventSchema({
+        type: z.literal('report_created'),
+        runId: z.string().min(1),
+        reportPath: z.string().min(1).optional(),
+    }),
+]);
+export const memoryFlowPlannedWorkUnitSchema = z.object({
+    unitKey: z.string().min(1),
+    rawFiles: z.array(z.string()),
+    peerFileCount: z.number().int().min(0),
+    dependencyCount: z.number().int().min(0),
+});
+export const memoryFlowActionDetailSchema = z.object({
+    unitKey: z.string().min(1),
+    target: z.enum(['wiki', 'sl']),
+    action: z.enum(['created', 'updated', 'removed']),
+    key: z.string().min(1),
+    summary: z.string(),
+    rawFiles: z.array(z.string()),
+    status: z.enum(['success', 'failed']),
+});
+const memoryFlowProvenanceDetailSchema = z.object({
+    rawPath: z.string(),
+    artifactKind: z.enum(['sl', 'wiki']).nullable(),
+    artifactKey: z.string().nullable(),
+    actionType: z.string().min(1),
+});
+const memoryFlowTranscriptDetailSchema = z.object({
+    unitKey: z.string().min(1),
+    path: z.string().min(1),
+    toolCallCount: z.number().int().min(0),
+    errorCount: z.number().int().min(0),
+    toolNames: z.array(z.string()),
+});
+export const memoryFlowDetailSectionsSchema = z.object({
+    actions: z.array(memoryFlowActionDetailSchema),
+    provenance: z.array(memoryFlowProvenanceDetailSchema),
+    transcripts: z.array(memoryFlowTranscriptDetailSchema),
+});
+export const memoryFlowReplayInputSchema = z.object({
+    metadata: memoryFlowReplayMetadataSchema.optional(),
+    runId: z.string().min(1),
+    connectionId: z.string().min(1),
+    adapter: z.string().min(1),
+    status: memoryFlowRunStatusSchema,
+    sourceDir: z.string().nullable(),
+    syncId: z.string().min(1),
+    reportId: z.string().min(1).optional(),
+    reportPath: z.string().min(1).optional(),
+    errors: z.array(z.string()),
+    events: z.array(memoryFlowEventSchema),
+    plannedWorkUnits: z.array(memoryFlowPlannedWorkUnitSchema),
+    details: memoryFlowDetailSectionsSchema,
+});
+export const memoryFlowStreamEventSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('snapshot'), snapshot: memoryFlowReplayInputSchema }),
+    z.object({
+        type: z.literal('closed'),
+        status: memoryFlowRunStatusSchema,
+        errors: z.array(z.string()),
+    }),
+]);
+export function parseMemoryFlowReplayInput(value) {
+    const result = memoryFlowReplayInputSchema.safeParse(value);
+    if (!result.success) {
+        throw new Error(`Invalid memory-flow replay input: ${z.prettifyError(result.error)}`);
+    }
+    return result.data;
+}

package/node_modules/@ktx/context/dist/ingest/memory-flow/schema.test.d.ts

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