@exaudeus/workrail 0.8.6 → 0.9.0

package/dist/v2/projections/gaps.d.ts

@@ -0,0 +1,29 @@
+import type { Result } from 'neverthrow';
+import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+export type ProjectionError = {
+    readonly code: 'PROJECTION_INVARIANT_VIOLATION';
+    readonly message: string;
+} | {
+    readonly code: 'PROJECTION_CORRUPTION_DETECTED';
+    readonly message: string;
+};
+type GapRecordedEventV1 = Extract<DomainEventV1, {
+    kind: 'gap_recorded';
+}>;
+export interface GapV2 {
+    readonly gapId: string;
+    readonly severity: GapRecordedEventV1['data']['severity'];
+    readonly reason: GapRecordedEventV1['data']['reason'];
+    readonly summary: string;
+    readonly recordedAtEventIndex: number;
+    readonly nodeId: string;
+    readonly runId: string;
+    readonly resolution: GapRecordedEventV1['data']['resolution'];
+}
+export interface GapsProjectionV2 {
+    readonly byGapId: Readonly<Record<string, GapV2>>;
+    readonly resolvedGapIds: ReadonlySet<string>;
+    readonly unresolvedCriticalByRunId: Readonly<Record<string, readonly GapV2[]>>;
+}
+export declare function projectGapsV2(events: readonly DomainEventV1[]): Result<GapsProjectionV2, ProjectionError>;
+export {};

package/dist/v2/projections/gaps.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectGapsV2 = projectGapsV2;
+const neverthrow_1 = require("neverthrow");
+function projectGapsV2(events) {
+    for (let i = 1; i < events.length; i++) {
+        if (events[i].eventIndex < events[i - 1].eventIndex) {
+            return (0, neverthrow_1.err)({ code: 'PROJECTION_INVARIANT_VIOLATION', message: 'Events must be sorted by eventIndex ascending' });
+        }
+    }
+    const byGapId = {};
+    const resolved = new Set();
+    for (const e of events) {
+        if (e.kind !== 'gap_recorded')
+            continue;
+        const gap = {
+            gapId: e.data.gapId,
+            severity: e.data.severity,
+            reason: e.data.reason,
+            summary: e.data.summary,
+            recordedAtEventIndex: e.eventIndex,
+            nodeId: e.scope.nodeId,
+            runId: e.scope.runId,
+            resolution: e.data.resolution,
+        };
+        byGapId[gap.gapId] = gap;
+        if (gap.resolution.kind === 'resolves') {
+            resolved.add(gap.resolution.resolvesGapId);
+        }
+    }
+    const unresolvedCriticalByRunId = {};
+    for (const gap of Object.values(byGapId)) {
+        if (resolved.has(gap.gapId))
+            continue;
+        if (gap.resolution.kind !== 'unresolved')
+            continue;
+        if (gap.severity !== 'critical')
+            continue;
+        const list = unresolvedCriticalByRunId[gap.runId] ?? [];
+        list.push(gap);
+        unresolvedCriticalByRunId[gap.runId] = list;
+    }
+    for (const runId of Object.keys(unresolvedCriticalByRunId)) {
+        unresolvedCriticalByRunId[runId] = unresolvedCriticalByRunId[runId]
+            .slice()
+            .sort((a, b) => a.recordedAtEventIndex - b.recordedAtEventIndex || a.gapId.localeCompare(b.gapId));
+    }
+    return (0, neverthrow_1.ok)({ byGapId, resolvedGapIds: resolved, unresolvedCriticalByRunId });
+}

package/dist/v2/projections/node-outputs.d.ts

@@ -0,0 +1,34 @@
+import type { Result } from 'neverthrow';
+import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+export type ProjectionError = {
+    readonly code: 'PROJECTION_INVARIANT_VIOLATION';
+    readonly message: string;
+} | {
+    readonly code: 'PROJECTION_CORRUPTION_DETECTED';
+    readonly message: string;
+};
+export type OutputChannelV2 = 'recap' | 'artifact';
+export type OutputPayloadV2 = {
+    readonly payloadKind: 'notes';
+    readonly notesMarkdown: string;
+} | {
+    readonly payloadKind: 'artifact_ref';
+    readonly sha256: string;
+    readonly contentType: string;
+    readonly byteLength: number;
+};
+export interface NodeOutputV2 {
+    readonly outputId: string;
+    readonly outputChannel: OutputChannelV2;
+    readonly payload: OutputPayloadV2;
+    readonly supersedesOutputId?: string;
+    readonly createdAtEventIndex: number;
+}
+export interface NodeOutputsViewV2 {
+    readonly historyByChannel: Readonly<Record<OutputChannelV2, readonly NodeOutputV2[]>>;
+    readonly currentByChannel: Readonly<Record<OutputChannelV2, readonly NodeOutputV2[]>>;
+}
+export interface NodeOutputsProjectionV2 {
+    readonly nodesById: Readonly<Record<string, NodeOutputsViewV2>>;
+}
+export declare function projectNodeOutputsV2(events: readonly DomainEventV1[]): Result<NodeOutputsProjectionV2, ProjectionError>;

package/dist/v2/projections/node-outputs.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectNodeOutputsV2 = projectNodeOutputsV2;
+const neverthrow_1 = require("neverthrow");
+function projectNodeOutputsV2(events) {
+    const byNode = {};
+    const ensure = (nodeId) => {
+        const existing = byNode[nodeId];
+        if (existing)
+            return existing;
+        const created = { byChannel: { recap: [], artifact: [] } };
+        byNode[nodeId] = created;
+        return created;
+    };
+    for (let i = 1; i < events.length; i++) {
+        if (events[i].eventIndex < events[i - 1].eventIndex) {
+            return (0, neverthrow_1.err)({ code: 'PROJECTION_INVARIANT_VIOLATION', message: 'Events must be sorted by eventIndex ascending' });
+        }
+    }
+    for (const e of events) {
+        if (e.kind !== 'node_output_appended')
+            continue;
+        const nodeId = e.scope.nodeId;
+        const out = {
+            outputId: e.data.outputId,
+            outputChannel: e.data.outputChannel,
+            payload: e.data.payload,
+            supersedesOutputId: e.data.supersedesOutputId,
+            createdAtEventIndex: e.eventIndex,
+        };
+        ensure(nodeId).byChannel[out.outputChannel].push(out);
+    }
+    const nodesById = {};
+    for (const [nodeId, record] of Object.entries(byNode)) {
+        const historyByChannel = {
+            recap: record.byChannel.recap,
+            artifact: record.byChannel.artifact,
+        };
+        const currentByChannel = {
+            recap: [],
+            artifact: [],
+        };
+        for (const channel of ['recap', 'artifact']) {
+            const history = historyByChannel[channel];
+            const superseded = new Set();
+            for (const o of history) {
+                if (!o.supersedesOutputId)
+                    continue;
+                const target = history.find((x) => x.outputId === o.supersedesOutputId);
+                if (!target) {
+                    return (0, neverthrow_1.err)({
+                        code: 'PROJECTION_CORRUPTION_DETECTED',
+                        message: `supersedesOutputId references missing output (nodeId=${nodeId}, channel=${channel}, supersedes=${o.supersedesOutputId})`,
+                    });
+                }
+                superseded.add(o.supersedesOutputId);
+            }
+            const current = history.filter((o) => !superseded.has(o.outputId));
+            if (channel === 'recap' && current.length > 1) {
+                return (0, neverthrow_1.err)({
+                    code: 'PROJECTION_CORRUPTION_DETECTED',
+                    message: `Multiple current recap outputs detected for nodeId=${nodeId}`,
+                });
+            }
+            currentByChannel[channel] = current;
+        }
+        nodesById[nodeId] = {
+            historyByChannel,
+            currentByChannel,
+        };
+    }
+    return (0, neverthrow_1.ok)({ nodesById });
+}

package/dist/v2/projections/preferences.d.ts

@@ -0,0 +1,28 @@
+import type { Result } from 'neverthrow';
+import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+export type ProjectionError = {
+    readonly code: 'PROJECTION_INVARIANT_VIOLATION';
+    readonly message: string;
+} | {
+    readonly code: 'PROJECTION_CORRUPTION_DETECTED';
+    readonly message: string;
+};
+type PreferencesChangedEventV1 = Extract<DomainEventV1, {
+    kind: 'preferences_changed';
+}>;
+export type AutonomyV2 = 'guided' | 'full_auto_stop_on_user_deps' | 'full_auto_never_stop';
+export type RiskPolicyV2 = 'conservative' | 'balanced' | 'aggressive';
+export interface EffectivePreferencesV2 {
+    readonly autonomy: AutonomyV2;
+    readonly riskPolicy: RiskPolicyV2;
+}
+export interface NodePreferencesV2 {
+    readonly nodeId: string;
+    readonly effective: EffectivePreferencesV2;
+    readonly changesAtThisNode: readonly PreferencesChangedEventV1[];
+}
+export interface PreferencesProjectionV2 {
+    readonly byNodeId: Readonly<Record<string, NodePreferencesV2>>;
+}
+export declare function projectPreferencesV2(events: readonly DomainEventV1[], parentByNodeId: Readonly<Record<string, string | null>>): Result<PreferencesProjectionV2, ProjectionError>;
+export {};

package/dist/v2/projections/preferences.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectPreferencesV2 = projectPreferencesV2;
+const neverthrow_1 = require("neverthrow");
+const defaultPrefs = { autonomy: 'guided', riskPolicy: 'conservative' };
+function projectPreferencesV2(events, parentByNodeId) {
+    for (let i = 1; i < events.length; i++) {
+        if (events[i].eventIndex < events[i - 1].eventIndex) {
+            return (0, neverthrow_1.err)({ code: 'PROJECTION_INVARIANT_VIOLATION', message: 'Events must be sorted by eventIndex ascending' });
+        }
+    }
+    const changesByNodeId = {};
+    for (const e of events) {
+        if (e.kind !== 'preferences_changed')
+            continue;
+        const list = changesByNodeId[e.scope.nodeId] ?? [];
+        list.push(e);
+        changesByNodeId[e.scope.nodeId] = list;
+    }
+    const byNodeId = {};
+    const ancestorChainOf = (nodeId) => {
+        const chain = [];
+        let cur = nodeId;
+        const visited = new Set();
+        while (cur) {
+            if (visited.has(cur))
+                break;
+            visited.add(cur);
+            chain.push(cur);
+            cur = parentByNodeId[cur] ?? null;
+        }
+        return chain.reverse();
+    };
+    for (const nodeId of Object.keys(parentByNodeId)) {
+        const chain = ancestorChainOf(nodeId);
+        let effective = defaultPrefs;
+        const changesAtThisNode = [];
+        for (const ancestor of chain) {
+            const changes = changesByNodeId[ancestor] ?? [];
+            for (const change of changes) {
+                effective = change.data.effective;
+                if (ancestor === nodeId) {
+                    changesAtThisNode.push(change);
+                }
+            }
+        }
+        byNodeId[nodeId] = { nodeId, effective, changesAtThisNode };
+    }
+    return (0, neverthrow_1.ok)({ byNodeId });
+}

package/dist/v2/projections/run-dag.d.ts

@@ -0,0 +1,42 @@
+import type { Result } from 'neverthrow';
+import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+export type NodeKindV2 = 'step' | 'checkpoint';
+export type EdgeKindV2 = 'acked_step' | 'checkpoint';
+export type ProjectionError = {
+    readonly code: 'PROJECTION_INVARIANT_VIOLATION';
+    readonly message: string;
+} | {
+    readonly code: 'PROJECTION_CORRUPTION_DETECTED';
+    readonly message: string;
+};
+export interface RunDagNodeV2 {
+    readonly nodeId: string;
+    readonly nodeKind: NodeKindV2;
+    readonly parentNodeId: string | null;
+    readonly workflowHash: string;
+    readonly snapshotRef: string;
+    readonly createdAtEventIndex: number;
+}
+export interface RunDagEdgeV2 {
+    readonly edgeKind: EdgeKindV2;
+    readonly fromNodeId: string;
+    readonly toNodeId: string;
+    readonly cause: {
+        readonly kind: string;
+        readonly eventId: string;
+    };
+    readonly createdAtEventIndex: number;
+}
+export interface RunDagRunV2 {
+    readonly runId: string;
+    readonly workflowId: string | null;
+    readonly workflowHash: string | null;
+    readonly nodesById: Readonly<Record<string, RunDagNodeV2>>;
+    readonly edges: readonly RunDagEdgeV2[];
+    readonly tipNodeIds: readonly string[];
+    readonly preferredTipNodeId: string | null;
+}
+export interface RunDagProjectionV2 {
+    readonly runsById: Readonly<Record<string, RunDagRunV2>>;
+}
+export declare function projectRunDagV2(events: readonly DomainEventV1[]): Result<RunDagProjectionV2, ProjectionError>;

package/dist/v2/projections/run-dag.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectRunDagV2 = projectRunDagV2;
+const neverthrow_1 = require("neverthrow");
+function projectRunDagV2(events) {
+    for (let i = 1; i < events.length; i++) {
+        if (events[i].eventIndex < events[i - 1].eventIndex) {
+            return (0, neverthrow_1.err)({
+                code: 'PROJECTION_INVARIANT_VIOLATION',
+                message: 'Events must be sorted by eventIndex ascending',
+            });
+        }
+    }
+    const runs = {};
+    const ensureRun = (runId) => {
+        const existing = runs[runId];
+        if (existing)
+            return existing;
+        const created = {
+            runId,
+            workflowId: null,
+            workflowHash: null,
+            nodesById: {},
+            edges: [],
+            tipNodeIds: [],
+            preferredTipNodeId: null,
+        };
+        runs[runId] = created;
+        return created;
+    };
+    for (const e of events) {
+        switch (e.kind) {
+            case 'run_started': {
+                const runId = e.scope.runId;
+                const run = ensureRun(runId);
+                if (run.workflowHash && run.workflowHash !== e.data.workflowHash) {
+                    return (0, neverthrow_1.err)({
+                        code: 'PROJECTION_CORRUPTION_DETECTED',
+                        message: `run_started workflowHash mismatch for runId=${runId}`,
+                    });
+                }
+                run.workflowId = e.data.workflowId;
+                run.workflowHash = e.data.workflowHash;
+                break;
+            }
+            case 'node_created': {
+                const runId = e.scope.runId;
+                const nodeId = e.scope.nodeId;
+                const run = ensureRun(runId);
+                const existing = run.nodesById[nodeId];
+                const node = {
+                    nodeId,
+                    nodeKind: e.data.nodeKind,
+                    parentNodeId: e.data.parentNodeId,
+                    workflowHash: e.data.workflowHash,
+                    snapshotRef: e.data.snapshotRef,
+                    createdAtEventIndex: e.eventIndex,
+                };
+                if (existing) {
+                    if (JSON.stringify(existing) !== JSON.stringify(node)) {
+                        return (0, neverthrow_1.err)({
+                            code: 'PROJECTION_CORRUPTION_DETECTED',
+                            message: `node_created conflict for runId=${runId} nodeId=${nodeId}`,
+                        });
+                    }
+                }
+                else {
+                    if (node.parentNodeId && !run.nodesById[node.parentNodeId]) {
+                        return (0, neverthrow_1.err)({
+                            code: 'PROJECTION_INVARIANT_VIOLATION',
+                            message: `node_created references missing parentNodeId=${node.parentNodeId} (runId=${runId} nodeId=${nodeId})`,
+                        });
+                    }
+                    run.nodesById[nodeId] = node;
+                }
+                break;
+            }
+            case 'edge_created': {
+                const runId = e.scope.runId;
+                const run = ensureRun(runId);
+                const edge = {
+                    edgeKind: e.data.edgeKind,
+                    fromNodeId: e.data.fromNodeId,
+                    toNodeId: e.data.toNodeId,
+                    cause: e.data.cause,
+                    createdAtEventIndex: e.eventIndex,
+                };
+                const from = run.nodesById[edge.fromNodeId];
+                const to = run.nodesById[edge.toNodeId];
+                if (!from || !to) {
+                    return (0, neverthrow_1.err)({
+                        code: 'PROJECTION_INVARIANT_VIOLATION',
+                        message: `edge_created references missing node(s) (runId=${runId} from=${edge.fromNodeId} to=${edge.toNodeId})`,
+                    });
+                }
+                if (to.parentNodeId !== edge.fromNodeId) {
+                    return (0, neverthrow_1.err)({
+                        code: 'PROJECTION_CORRUPTION_DETECTED',
+                        message: `edge_created violates parent linkage (runId=${runId} to.parentNodeId=${String(to.parentNodeId)} from=${edge.fromNodeId})`,
+                    });
+                }
+                run.edges.push(edge);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    for (const runId of Object.keys(runs)) {
+        const run = runs[runId];
+        const hasOutgoing = new Set(run.edges.map((e) => e.fromNodeId));
+        const tips = Object.keys(run.nodesById).filter((id) => !hasOutgoing.has(id)).sort();
+        run.tipNodeIds = tips;
+        if (tips.length === 0) {
+            run.preferredTipNodeId = null;
+            continue;
+        }
+        const parentById = {};
+        for (const n of Object.values(run.nodesById))
+            parentById[n.nodeId] = n.parentNodeId;
+        const ancestryOf = (leafId) => {
+            const set = new Set();
+            let cur = leafId;
+            while (cur) {
+                if (set.has(cur))
+                    break;
+                set.add(cur);
+                cur = parentById[cur] ?? null;
+            }
+            return set;
+        };
+        const lastActivityFor = (leafId) => {
+            const ancestors = ancestryOf(leafId);
+            let max = run.nodesById[leafId].createdAtEventIndex;
+            for (const e of events) {
+                if (e.kind === 'edge_created') {
+                    if (ancestors.has(e.data.fromNodeId) || ancestors.has(e.data.toNodeId)) {
+                        if (e.eventIndex > max)
+                            max = e.eventIndex;
+                    }
+                    continue;
+                }
+                const nodeId = e.scope?.nodeId;
+                if (nodeId && ancestors.has(nodeId)) {
+                    if (e.eventIndex > max)
+                        max = e.eventIndex;
+                }
+            }
+            return max;
+        };
+        let bestTip = tips[0];
+        let bestActivity = lastActivityFor(bestTip);
+        for (let i = 1; i < tips.length; i++) {
+            const tip = tips[i];
+            const activity = lastActivityFor(tip);
+            if (activity > bestActivity) {
+                bestTip = tip;
+                bestActivity = activity;
+            }
+            else if (activity === bestActivity) {
+                const bestCreated = run.nodesById[bestTip].createdAtEventIndex;
+                const tipCreated = run.nodesById[tip].createdAtEventIndex;
+                if (tipCreated > bestCreated) {
+                    bestTip = tip;
+                }
+                else if (tipCreated === bestCreated && tip < bestTip) {
+                    bestTip = tip;
+                }
+            }
+        }
+        run.preferredTipNodeId = bestTip;
+    }
+    const runsById = {};
+    for (const [runId, run] of Object.entries(runs)) {
+        runsById[runId] = {
+            runId,
+            workflowId: run.workflowId,
+            workflowHash: run.workflowHash,
+            nodesById: run.nodesById,
+            edges: run.edges,
+            tipNodeIds: run.tipNodeIds,
+            preferredTipNodeId: run.preferredTipNodeId,
+        };
+    }
+    return (0, neverthrow_1.ok)({ runsById });
+}

package/dist/v2/projections/run-status-signals.d.ts

@@ -0,0 +1,26 @@
+import type { Result } from 'neverthrow';
+import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+export type ProjectionError = {
+    readonly code: 'PROJECTION_INVARIANT_VIOLATION';
+    readonly message: string;
+} | {
+    readonly code: 'PROJECTION_CORRUPTION_DETECTED';
+    readonly message: string;
+};
+export type AutonomyV2 = 'guided' | 'full_auto_stop_on_user_deps' | 'full_auto_never_stop';
+export type RiskPolicyV2 = 'conservative' | 'balanced' | 'aggressive';
+export interface PreferencesSnapshotV2 {
+    readonly autonomy: AutonomyV2;
+    readonly riskPolicy: RiskPolicyV2;
+}
+export interface RunStatusSignalsV2 {
+    readonly runId: string;
+    readonly preferredTipNodeId: string | null;
+    readonly effectivePreferencesAtTip: PreferencesSnapshotV2;
+    readonly hasUnresolvedCriticalGaps: boolean;
+    readonly isBlocked: boolean;
+}
+export interface RunStatusSignalsProjectionV2 {
+    readonly byRunId: Readonly<Record<string, RunStatusSignalsV2>>;
+}
+export declare function projectRunStatusSignalsV2(events: readonly DomainEventV1[]): Result<RunStatusSignalsProjectionV2, ProjectionError>;

package/dist/v2/projections/run-status-signals.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectRunStatusSignalsV2 = projectRunStatusSignalsV2;
+const neverthrow_1 = require("neverthrow");
+const run_dag_js_1 = require("./run-dag.js");
+const gaps_js_1 = require("./gaps.js");
+const advance_outcomes_js_1 = require("./advance-outcomes.js");
+function projectRunStatusSignalsV2(events) {
+    const dagRes = (0, run_dag_js_1.projectRunDagV2)(events);
+    if (dagRes.isErr())
+        return (0, neverthrow_1.err)(dagRes.error);
+    const dag = dagRes.value;
+    const gapsRes = (0, gaps_js_1.projectGapsV2)(events);
+    if (gapsRes.isErr())
+        return (0, neverthrow_1.err)(gapsRes.error);
+    const gaps = gapsRes.value;
+    const advanceRes = (0, advance_outcomes_js_1.projectAdvanceOutcomesV2)(events);
+    if (advanceRes.isErr())
+        return (0, neverthrow_1.err)(advanceRes.error);
+    const advances = advanceRes.value;
+    const prefsByNodeId = {};
+    for (const e of events) {
+        if (e.kind !== 'preferences_changed')
+            continue;
+        prefsByNodeId[e.scope.nodeId] = e.data.effective;
+    }
+    const defaultPrefs = { autonomy: 'guided', riskPolicy: 'conservative' };
+    const byRunId = {};
+    for (const [runId, run] of Object.entries(dag.runsById)) {
+        const tip = run.preferredTipNodeId;
+        const prefs = tip ? prefsByNodeId[tip] ?? defaultPrefs : defaultPrefs;
+        const critical = gaps.unresolvedCriticalByRunId[runId] ?? [];
+        const hasUnresolvedCriticalGaps = critical.length > 0;
+        const hasBlockingCategoryGap = (gaps.unresolvedCriticalByRunId[runId] ?? []).some((g) => g.reason.category === 'user_only_dependency' ||
+            g.reason.category === 'contract_violation' ||
+            g.reason.category === 'capability_missing');
+        const latestAdvance = tip ? advances.byNodeId[tip] : undefined;
+        const blockedByAdvance = latestAdvance?.outcome.kind === 'blocked';
+        const isBlocked = prefs.autonomy !== 'full_auto_never_stop' && (blockedByAdvance || hasBlockingCategoryGap);
+        byRunId[runId] = {
+            runId,
+            preferredTipNodeId: tip,
+            effectivePreferencesAtTip: prefs,
+            hasUnresolvedCriticalGaps,
+            isBlocked,
+        };
+    }
+    return (0, neverthrow_1.ok)({ byRunId });
+}

package/dist/v2/projections/session-health.d.ts

@@ -0,0 +1,18 @@
+import type { Result } from 'neverthrow';
+import type { LoadedSessionTruthV2 } from '../ports/session-event-log-store.port.js';
+export type SessionHealthV2 = {
+    readonly kind: 'healthy';
+} | {
+    readonly kind: 'corrupted';
+    readonly reason: {
+        readonly code: 'MANIFEST_INVALID';
+        readonly message: string;
+    } | {
+        readonly code: 'EVENT_LOG_INVALID';
+        readonly message: string;
+    } | {
+        readonly code: 'RUN_DAG_INVALID';
+        readonly message: string;
+    };
+};
+export declare function projectSessionHealthV2(truth: LoadedSessionTruthV2): Result<SessionHealthV2, never>;

package/dist/v2/projections/session-health.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectSessionHealthV2 = projectSessionHealthV2;
+const neverthrow_1 = require("neverthrow");
+const run_dag_js_1 = require("./run-dag.js");
+function projectSessionHealthV2(truth) {
+    const dag = (0, run_dag_js_1.projectRunDagV2)(truth.events);
+    if (dag.isErr()) {
+        return (0, neverthrow_1.ok)({
+            kind: 'corrupted',
+            reason: { code: 'RUN_DAG_INVALID', message: dag.error.message },
+        });
+    }
+    return (0, neverthrow_1.ok)({ kind: 'healthy' });
+}

package/dist/v2/read-only/v1-to-v2-shim.d.ts

@@ -0,0 +1,3 @@
+import type { Workflow } from '../../types/workflow.js';
+import type { CompiledWorkflowSnapshotV1 } from '../durable-core/schemas/compiled-workflow/index.js';
+export declare function compileV1WorkflowToV2CompiledSnapshotV1(workflow: Workflow): CompiledWorkflowSnapshotV1;

package/dist/v2/read-only/v1-to-v2-shim.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileV1WorkflowToV2CompiledSnapshotV1 = compileV1WorkflowToV2CompiledSnapshotV1;
+function compileV1WorkflowToV2CompiledSnapshotV1(workflow) {
+    const firstStep = workflow.definition.steps[0];
+    if (!firstStep) {
+        return {
+            schemaVersion: 1,
+            sourceKind: 'v1_shim',
+            workflowId: workflow.definition.id,
+            name: workflow.definition.name,
+            description: workflow.definition.description,
+            version: workflow.definition.version,
+            preview: {
+                stepId: '(missing)',
+                title: 'Invalid workflow: missing first step',
+                prompt: 'This workflow has no steps. It is invalid and cannot be previewed.',
+            },
+        };
+    }
+    const isLoop = firstStep.type === 'loop';
+    const prompt = !isLoop && typeof firstStep.prompt === 'string'
+        ? firstStep.prompt
+        : `Loop step '${firstStep.id}' cannot be previewed in v2 Slice 1 (loop execution/compilation not implemented yet).`;
+    return {
+        schemaVersion: 1,
+        sourceKind: 'v1_shim',
+        workflowId: workflow.definition.id,
+        name: workflow.definition.name,
+        description: workflow.definition.description,
+        version: workflow.definition.version,
+        preview: {
+            stepId: firstStep.id,
+            title: firstStep.title ?? firstStep.id,
+            prompt,
+        },
+    };
+}