@exaudeus/workrail 3.14.0 → 3.16.0

package/dist/v2/infra/local/session-store/index.js

@@ -39,20 +39,22 @@ const jsonl_js_1 = require("../../../durable-core/canonical/jsonl.js");
 const index_js_1 = require("../../../durable-core/schemas/session/index.js");
 const constants_js_1 = require("../../../durable-core/constants.js");
 const path = __importStar(require("path"));
+const _utf8Decoder = new TextDecoder();
+const _createdEventsDirs = new Set();
 class LocalSessionEventLogStoreV2 {
     constructor(dataDir, fs, sha256) {
         this.dataDir = dataDir;
         this.fs = fs;
         this.sha256 = sha256;
     }
-    append(lock, plan) {
+    append(lock, plan, preloadedTruth) {
         if (!lock.assertHeld()) {
             return (0, neverthrow_1.errAsync)({
                 code: 'SESSION_STORE_INVARIANT_VIOLATION',
                 message: 'WithHealthySessionLock used after gate callback ended (witness misuse-after-release)',
             });
         }
-        return this.appendImpl(lock.sessionId, plan);
+        return this.appendImpl(lock.sessionId, plan, preloadedTruth);
     }
     load(sessionId) {
         return this.loadImpl(sessionId);
@@ -60,13 +62,20 @@ class LocalSessionEventLogStoreV2 {
     loadValidatedPrefix(sessionId) {
         return this.loadValidatedPrefixImpl(sessionId);
     }
-    appendImpl(sessionId, plan) {
+    appendImpl(sessionId, plan, preloadedTruth) {
         const sessionDir = this.dataDir.sessionDir(sessionId);
         const eventsDir = this.dataDir.sessionEventsDir(sessionId);
         const manifestPath = this.dataDir.sessionManifestPath(sessionId);
-        return this.fs.mkdirp(eventsDir)
-            .mapErr(mapFsToStoreError)
-            .andThen(() => this.loadTruthOrEmpty(sessionId))
+        const mkdirpResult = _createdEventsDirs.has(eventsDir)
+            ? (0, neverthrow_1.okAsync)(undefined)
+            : this.fs.mkdirp(eventsDir).mapErr(mapFsToStoreError).map(() => { _createdEventsDirs.add(eventsDir); });
+        const truthSource = preloadedTruth !== undefined
+            ? mkdirpResult.andThen(() => (0, neverthrow_1.okAsync)({
+                manifest: preloadedTruth.manifest,
+                events: preloadedTruth.events,
+            }))
+            : mkdirpResult.andThen(() => this.loadTruthOrEmpty(sessionId));
+        return truthSource
             .andThen(({ manifest, events: existingEvents }) => {
             const contiguityRes = validateManifestContiguity(manifest);
             if (contiguityRes.isErr())
@@ -116,24 +125,23 @@ class LocalSessionEventLogStoreV2 {
                     sha256: digest,
                     bytes: segmentBytes.length,
                 };
-                return this.appendManifestRecords(manifestPath, [segClosed])
-                    .andThen(() => {
-                    const pins = sortedPins(plan.snapshotPins);
-                    if (pins.length === 0)
-                        return (0, neverthrow_1.okAsync)(undefined);
-                    const startIndex = segClosed.manifestIndex + 1;
-                    const records = pins.map((p, i) => ({
-                        v: 1,
-                        manifestIndex: startIndex + i,
-                        sessionId,
-                        kind: constants_js_1.MANIFEST_KIND.SNAPSHOT_PINNED,
-                        eventIndex: p.eventIndex,
-                        snapshotRef: p.snapshotRef,
-                        createdByEventId: p.createdByEventId,
-                    }));
-                    return this.appendManifestRecords(manifestPath, records);
-                });
+                const pins = sortedPins(plan.snapshotPins);
+                const startIndex = segClosed.manifestIndex + 1;
+                const pinRecords = pins.map((p, i) => ({
+                    v: 1,
+                    manifestIndex: startIndex + i,
+                    sessionId,
+                    kind: constants_js_1.MANIFEST_KIND.SNAPSHOT_PINNED,
+                    eventIndex: p.eventIndex,
+                    snapshotRef: p.snapshotRef,
+                    createdByEventId: p.createdByEventId,
+                }));
+                return this.appendManifestRecords(manifestPath, [segClosed, ...pinRecords]);
             });
+        })
+            .orElse((error) => {
+            _createdEventsDirs.delete(eventsDir);
+            return (0, neverthrow_1.errAsync)(error);
         });
     }
     loadImpl(sessionId) {
@@ -147,7 +155,7 @@ class LocalSessionEventLogStoreV2 {
             if (segRes.isErr())
                 return (0, neverthrow_1.errAsync)(segRes.error);
             const segments = manifest.filter((m) => m.kind === constants_js_1.MANIFEST_KIND.SEGMENT_CLOSED);
-            return loadSegmentsRecursive({
+            return loadSegmentsParallel({
                 segments,
                 sessionDir,
                 sha256: this.sha256,
@@ -334,17 +342,14 @@ function validateAppendPlan(sessionId, plan, expectedFirstEventIndex) {
         });
     }
     for (let i = 0; i < plan.events.length; i++) {
-        const e = index_js_1.DomainEventV1Schema.safeParse(plan.events[i]);
-        if (!e.success) {
-            return (0, neverthrow_1.err)({ code: 'SESSION_STORE_INVARIANT_VIOLATION', message: `Invalid domain event at index ${i}` });
-        }
-        if (e.data.sessionId !== sessionId) {
+        const e = plan.events[i];
+        if (e.sessionId !== sessionId) {
             return (0, neverthrow_1.err)({
                 code: 'SESSION_STORE_INVARIANT_VIOLATION',
                 message: `Domain event sessionId mismatch at index ${i}`,
             });
         }
-        if (i > 0 && plan.events[i].eventIndex !== plan.events[i - 1].eventIndex + 1) {
+        if (i > 0 && e.eventIndex !== plan.events[i - 1].eventIndex + 1) {
             return (0, neverthrow_1.err)({
                 code: 'SESSION_STORE_INVARIANT_VIOLATION',
                 message: `Non-contiguous eventIndex in AppendPlan at index ${i}`,
@@ -439,7 +444,7 @@ function parseJsonlText(text, schema) {
     return (0, neverthrow_1.ok)(out);
 }
 function parseJsonlLines(bytes, schema) {
-    const text = new TextDecoder().decode(bytes);
+    const text = _utf8Decoder.decode(bytes);
     return parseJsonlText(text, schema);
 }
 function extractSnapshotPinsFromEvents(events) {
@@ -573,41 +578,46 @@ function processSegmentForSalvage(args) {
         });
     });
 }
-function loadSegmentsRecursive(args) {
+function loadSegmentsParallel(args) {
     if (args.segments.length === 0)
         return (0, neverthrow_1.okAsync)([]);
-    const [head, ...tail] = args.segments;
-    const segmentPath = path.join(args.sessionDir, head.segmentRelPath);
-    return args.fs.readFileBytes(segmentPath)
-        .mapErr((e) => {
+    return neverthrow_1.ResultAsync.fromPromise(Promise.all(args.segments.map((seg) => args.fs.readFileBytes(path.join(args.sessionDir, seg.segmentRelPath))
+        .match((bytes) => ({ ok: true, bytes, seg }), (e) => {
         if (e.code === 'FS_NOT_FOUND') {
             return {
-                code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                location: 'tail',
-                reason: { code: 'missing_attested_segment', message: `Missing attested segment: ${head.segmentRelPath}` },
-                message: `Missing attested segment: ${head.segmentRelPath}`,
+                ok: false,
+                error: {
+                    code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                    location: 'tail',
+                    reason: { code: 'missing_attested_segment', message: `Missing attested segment: ${seg.segmentRelPath}` },
+                    message: `Missing attested segment: ${seg.segmentRelPath}`,
+                },
             };
         }
-        return mapFsToStoreError(e);
-    })
-        .andThen((bytes) => {
-        const actual = args.sha256.sha256(bytes);
-        if (actual !== head.sha256) {
-            return (0, neverthrow_1.errAsync)({
-                code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                location: 'tail',
-                reason: { code: 'digest_mismatch', message: `Segment digest mismatch: ${head.segmentRelPath}` },
-                message: `Segment digest mismatch: ${head.segmentRelPath}`,
-            });
+        return { ok: false, error: mapFsToStoreError(e) };
+    }))), (e) => ({ code: 'SESSION_STORE_IO_ERROR', message: String(e) })).andThen((readResults) => {
+        const allEvents = [];
+        for (const result of readResults) {
+            if (!result.ok)
+                return (0, neverthrow_1.err)(result.error);
+            const { bytes, seg } = result;
+            const actual = args.sha256.sha256(bytes);
+            if (actual !== seg.sha256) {
+                return (0, neverthrow_1.err)({
+                    code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                    location: 'tail',
+                    reason: { code: 'digest_mismatch', message: `Segment digest mismatch: ${seg.segmentRelPath}` },
+                    message: `Segment digest mismatch: ${seg.segmentRelPath}`,
+                });
+            }
+            const parsedRes = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
+            if (parsedRes.isErr())
+                return (0, neverthrow_1.err)(parsedRes.error);
+            const boundsResult = validateSegmentBounds(parsedRes.value, seg);
+            if (boundsResult.isErr())
+                return (0, neverthrow_1.err)(boundsResult.error);
+            allEvents.push(...parsedRes.value);
         }
-        const parsedRes = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
-        if (parsedRes.isErr())
-            return (0, neverthrow_1.errAsync)(parsedRes.error);
-        const parsed = parsedRes.value;
-        const boundsResult = validateSegmentBounds(parsed, head);
-        if (boundsResult.isErr())
-            return (0, neverthrow_1.errAsync)(boundsResult.error);
-        return (0, neverthrow_1.okAsync)(parsed);
-    })
-        .andThen((events) => loadSegmentsRecursive({ ...args, segments: tail }).map((rest) => [...events, ...rest]));
+        return (0, neverthrow_1.ok)(allEvents);
+    });
 }

package/dist/v2/infra/local/session-summary-provider/index.js

@@ -8,6 +8,7 @@ const session_health_js_1 = require("../../../projections/session-health.js");
 const run_dag_js_1 = require("../../../projections/run-dag.js");
 const node_outputs_js_1 = require("../../../projections/node-outputs.js");
 const run_context_js_1 = require("../../../projections/run-context.js");
+const sorted_event_log_js_1 = require("../../../durable-core/sorted-event-log.js");
 const snapshot_state_js_1 = require("../../../durable-core/projections/snapshot-state.js");
 const index_js_1 = require("../../../durable-core/ids/index.js");
 const constants_js_1 = require("../../../durable-core/constants.js");
@@ -87,6 +88,10 @@ function projectSessionSummary(sessionId, truth, mtimeMs) {
     const workflow = extractWorkflowIdentity(truth.events, bestRun.run.runId);
     if (!workflow)
         return null;
+    const sortedEventsRes = (0, sorted_event_log_js_1.asSortedEventLog)(truth.events);
+    const sessionTitle = sortedEventsRes.isOk()
+        ? deriveSessionTitle(sortedEventsRes.value, bestRun.run.runId)
+        : null;
     const outputsRes = (0, node_outputs_js_1.projectNodeOutputsV2)(truth.events);
     const recapSnippet = outputsRes.isOk()
         ? extractAggregateRecap(outputsRes.value, bestRun.run, bestRun.tipNodeId)
@@ -102,7 +107,7 @@ function projectSessionSummary(sessionId, truth, mtimeMs) {
             recapSnippet,
             observations: extractObservations(truth.events),
             workflow,
-            sessionTitle: deriveSessionTitle(truth.events, bestRun.run.runId),
+            sessionTitle,
             lastModifiedMs: mtimeMs,
             pendingStepId: null,
             isComplete: false,
@@ -150,8 +155,8 @@ function extractWorkflowIdentity(events, runId) {
         workflowHash: (0, index_js_1.asWorkflowHash)((0, index_js_1.asSha256Digest)(event.data.workflowHash)),
     };
 }
-function deriveSessionTitle(events, runId) {
-    const contextRes = (0, run_context_js_1.projectRunContextV2)(events);
+function deriveSessionTitle(sortedEvents, runId) {
+    const contextRes = (0, run_context_js_1.projectRunContextV2)(sortedEvents);
     if (contextRes.isOk()) {
         const runCtx = contextRes.value.byRunId[runId];
         if (runCtx) {
@@ -163,7 +168,7 @@ function deriveSessionTitle(events, runId) {
             }
         }
     }
-    return extractTitleFromFirstRecap(events);
+    return extractTitleFromFirstRecap(sortedEvents);
 }
 function extractTitleFromFirstRecap(events) {
     const outputsRes = (0, node_outputs_js_1.projectNodeOutputsV2)(events);

package/dist/v2/infra/local/snapshot-store/index.js

@@ -5,6 +5,7 @@ const neverthrow_1 = require("neverthrow");
 const index_js_1 = require("../../../durable-core/ids/index.js");
 const index_js_2 = require("../../../durable-core/schemas/execution-snapshot/index.js");
 const jcs_js_1 = require("../../../durable-core/canonical/jcs.js");
+const _utf8Decoder = new TextDecoder();
 class LocalSnapshotStoreV2 {
     constructor(dataDir, fs, crypto) {
         this.dataDir = dataDir;
@@ -41,7 +42,7 @@ class LocalSnapshotStoreV2 {
             .andThen((bytes) => {
             let parsed;
             try {
-                parsed = JSON.parse(new TextDecoder().decode(bytes));
+                parsed = JSON.parse(_utf8Decoder.decode(bytes));
             }
             catch {
                 return (0, neverthrow_1.errAsync)({

package/dist/v2/infra/local/workspace-anchor/index.js

@@ -33,7 +33,10 @@ class LocalWorkspaceAnchorV2 {
     }
     async runGitCommands(cwd) {
         const anchors = [];
-        const repoRoot = await this.gitCommand('git rev-parse --show-toplevel', cwd);
+        const gitCommonDir = await this.gitCommand('git rev-parse --path-format=absolute --git-common-dir', cwd);
+        if (!gitCommonDir)
+            return anchors;
+        const repoRoot = gitCommonDir.replace(/\/\.git\/?$/, '').trim() || null;
         if (!repoRoot)
             return anchors;
         const repoRootHash = hashRepoRoot(repoRoot);

package/dist/v2/ports/session-event-log-store.port.d.ts

@@ -48,5 +48,5 @@ export interface SessionEventLogReadonlyStorePortV2 {
     loadValidatedPrefix(sessionId: SessionId): ResultAsync<LoadedValidatedPrefixV2, SessionEventLogStoreError>;
 }
 export interface SessionEventLogAppendStorePortV2 {
-    append(lock: WithHealthySessionLock, plan: AppendPlanV2): ResultAsync<void, SessionEventLogStoreError>;
+    append(lock: WithHealthySessionLock, plan: AppendPlanV2, preloadedTruth?: LoadedSessionTruthV2): ResultAsync<void, SessionEventLogStoreError>;
 }

package/dist/v2/projections/assessment-consequences.d.ts

@@ -1,5 +1,6 @@
 import type { Result } from 'neverthrow';
 import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+import type { SortedEventLog } from '../durable-core/sorted-event-log.js';
 import type { ProjectionError } from './projection-error.js';
 type AssessmentConsequenceAppliedEventV1 = Extract<DomainEventV1, {
     kind: 'assessment_consequence_applied';
@@ -14,6 +15,6 @@ export interface AppliedAssessmentConsequenceViewV2 {
 export interface AssessmentConsequencesProjectionV2 {
     readonly byNodeId: Readonly<Record<string, readonly AppliedAssessmentConsequenceViewV2[]>>;
 }
-export declare function projectAssessmentConsequencesV2(events: readonly DomainEventV1[]): Result<AssessmentConsequencesProjectionV2, ProjectionError>;
+export declare function projectAssessmentConsequencesV2(events: SortedEventLog): Result<AssessmentConsequencesProjectionV2, ProjectionError>;
 export declare function getLatestAssessmentConsequenceForNode(projection: AssessmentConsequencesProjectionV2, nodeId: string): AppliedAssessmentConsequenceViewV2 | undefined;
 export {};

package/dist/v2/projections/assessment-consequences.js

@@ -5,11 +5,6 @@ exports.getLatestAssessmentConsequenceForNode = getLatestAssessmentConsequenceFo
 const neverthrow_1 = require("neverthrow");
 const constants_js_1 = require("../durable-core/constants.js");
 function projectAssessmentConsequencesV2(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 byNodeId = {};
     for (const event of events) {
         if (event.kind !== constants_js_1.EVENT_KIND.ASSESSMENT_CONSEQUENCE_APPLIED)

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

@@ -1,5 +1,6 @@
 import type { Result } from 'neverthrow';
 import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+import type { SortedEventLog } from '../durable-core/sorted-event-log.js';
 import type { ProjectionError } from './projection-error.js';
 type AssessmentRecordedEventV1 = Extract<DomainEventV1, {
     kind: 'assessment_recorded';
@@ -16,6 +17,6 @@ export interface RecordedAssessmentViewV2 {
 export interface AssessmentsProjectionV2 {
     readonly byNodeId: Readonly<Record<string, readonly RecordedAssessmentViewV2[]>>;
 }
-export declare function projectAssessmentsV2(events: readonly DomainEventV1[]): Result<AssessmentsProjectionV2, ProjectionError>;
+export declare function projectAssessmentsV2(events: SortedEventLog): Result<AssessmentsProjectionV2, ProjectionError>;
 export declare function getLatestAssessmentForNode(projection: AssessmentsProjectionV2, nodeId: string): RecordedAssessmentViewV2 | undefined;
 export {};

package/dist/v2/projections/assessments.js

@@ -5,10 +5,8 @@ exports.getLatestAssessmentForNode = getLatestAssessmentForNode;
 const neverthrow_1 = require("neverthrow");
 const constants_js_1 = require("../durable-core/constants.js");
 function projectAssessmentsV2(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' });
-        }
+    if (!events.some((e) => e.kind === constants_js_1.EVENT_KIND.ASSESSMENT_RECORDED)) {
+        return (0, neverthrow_1.ok)({ byNodeId: {} });
     }
     const byNodeId = {};
     for (const event of events) {

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

@@ -1,5 +1,6 @@
 import type { Result } from 'neverthrow';
 import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+import type { SortedEventLog } from '../durable-core/sorted-event-log.js';
 import type { ProjectionError } from './projection-error.js';
 type GapRecordedEventV1 = Extract<DomainEventV1, {
     kind: 'gap_recorded';
@@ -19,5 +20,5 @@ export interface GapsProjectionV2 {
     readonly resolvedGapIds: ReadonlySet<string>;
     readonly unresolvedCriticalByRunId: Readonly<Record<string, readonly GapV2[]>>;
 }
-export declare function projectGapsV2(events: readonly DomainEventV1[]): Result<GapsProjectionV2, ProjectionError>;
+export declare function projectGapsV2(events: SortedEventLog): Result<GapsProjectionV2, ProjectionError>;
 export {};

package/dist/v2/projections/gaps.js

@@ -4,11 +4,6 @@ exports.projectGapsV2 = projectGapsV2;
 const neverthrow_1 = require("neverthrow");
 const constants_js_1 = require("../durable-core/constants.js");
 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) {

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

@@ -1,5 +1,6 @@
 import type { Result } from 'neverthrow';
 import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+import type { SortedEventLog } from '../durable-core/sorted-event-log.js';
 import type { AutonomyV2, RiskPolicyV2 } from '../durable-core/schemas/session/preferences.js';
 import type { ProjectionError } from './projection-error.js';
 type PreferencesChangedEventV1 = Extract<DomainEventV1, {
@@ -17,5 +18,5 @@ export interface NodePreferencesV2 {
 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 declare function projectPreferencesV2(events: SortedEventLog, parentByNodeId: Readonly<Record<string, string | null>>): Result<PreferencesProjectionV2, ProjectionError>;
 export {};

package/dist/v2/projections/preferences.js

@@ -5,11 +5,6 @@ const neverthrow_1 = require("neverthrow");
 const constants_js_1 = require("../durable-core/constants.js");
 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 !== constants_js_1.EVENT_KIND.PREFERENCES_CHANGED)

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

@@ -1,5 +1,5 @@
 import type { Result } from 'neverthrow';
-import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+import type { SortedEventLog } from '../durable-core/sorted-event-log.js';
 import type { JsonObject } from '../durable-core/canonical/json-types.js';
 import type { RunId } from '../durable-core/ids/index.js';
 import type { ProjectionError } from './projection-error.js';
@@ -13,4 +13,4 @@ export interface RunContextV2 {
 export interface RunContextProjectionV2 {
     readonly byRunId: Readonly<Record<string, RunContextV2>>;
 }
-export declare function projectRunContextV2(events: readonly DomainEventV1[]): Result<RunContextProjectionV2, ProjectionError>;
+export declare function projectRunContextV2(events: SortedEventLog): Result<RunContextProjectionV2, ProjectionError>;

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

@@ -5,11 +5,6 @@ const neverthrow_1 = require("neverthrow");
 const constants_js_1 = require("../durable-core/constants.js");
 const index_js_1 = require("../durable-core/ids/index.js");
 function projectRunContextV2(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 byRunId = {};
     for (const e of events) {
         if (e.kind !== constants_js_1.EVENT_KIND.CONTEXT_SET)

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

@@ -151,7 +151,13 @@ function projectRunDagV2(events) {
                     createdAtEventIndex: e.eventIndex,
                 };
                 if (existing) {
-                    if (JSON.stringify(existing) !== JSON.stringify(node)) {
+                    const differs = existing.nodeId !== node.nodeId ||
+                        existing.nodeKind !== node.nodeKind ||
+                        existing.parentNodeId !== node.parentNodeId ||
+                        existing.workflowHash !== node.workflowHash ||
+                        existing.snapshotRef !== node.snapshotRef ||
+                        existing.createdAtEventIndex !== node.createdAtEventIndex;
+                    if (differs) {
                         return (0, neverthrow_1.err)({
                             code: 'PROJECTION_CORRUPTION_DETECTED',
                             message: `node_created conflict for runId=${runId} nodeId=${nodeId}`,

package/dist/v2/projections/run-execution-trace.d.ts

@@ -0,0 +1,8 @@
+import type { Result } from 'neverthrow';
+import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+import type { ProjectionError } from './projection-error.js';
+import type { ConsoleExecutionTraceSummary } from '../usecases/console-types.js';
+export interface RunExecutionTraceProjectionV2 {
+    readonly byRunId: Readonly<Record<string, ConsoleExecutionTraceSummary>>;
+}
+export declare function projectRunExecutionTraceV2(events: readonly DomainEventV1[]): Result<RunExecutionTraceProjectionV2, ProjectionError>;

package/dist/v2/projections/run-execution-trace.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectRunExecutionTraceV2 = projectRunExecutionTraceV2;
+const neverthrow_1 = require("neverthrow");
+const constants_js_1 = require("../durable-core/constants.js");
+const CONTEXT_KEYS_TO_ELEVATE = ['taskComplexity'];
+function projectRunExecutionTraceV2(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 itemsByRunId = {};
+    const contextFactsByRunId = {};
+    const pushItem = (runId, item) => {
+        const existing = itemsByRunId[runId] ?? [];
+        existing.push(item);
+        itemsByRunId[runId] = existing;
+    };
+    for (const event of events) {
+        switch (event.kind) {
+            case constants_js_1.EVENT_KIND.DECISION_TRACE_APPENDED: {
+                const runId = event.scope.runId;
+                const nodeRef = { kind: 'node_id', value: event.scope.nodeId };
+                for (const entry of event.data.entries) {
+                    pushItem(runId, {
+                        kind: entry.kind,
+                        summary: entry.summary,
+                        recordedAtEventIndex: event.eventIndex,
+                        refs: [nodeRef, ...mapDecisionTraceRefs(entry.refs)],
+                    });
+                }
+                break;
+            }
+            case constants_js_1.EVENT_KIND.DIVERGENCE_RECORDED: {
+                const runId = event.scope.runId;
+                const refs = [
+                    { kind: 'node_id', value: event.scope.nodeId },
+                ];
+                if (event.data.relatedStepId) {
+                    refs.push({ kind: 'step_id', value: event.data.relatedStepId });
+                }
+                pushItem(runId, {
+                    kind: 'divergence',
+                    summary: event.data.summary,
+                    recordedAtEventIndex: event.eventIndex,
+                    refs,
+                });
+                break;
+            }
+            case constants_js_1.EVENT_KIND.CONTEXT_SET: {
+                const context = event.data.context;
+                if (!context || typeof context !== 'object' || Array.isArray(context)) {
+                    return (0, neverthrow_1.err)({
+                        code: 'PROJECTION_CORRUPTION_DETECTED',
+                        message: `context_set event has invalid context type (runId=${event.scope.runId}, eventId=${event.eventId})`,
+                    });
+                }
+                const contextObj = context;
+                const facts = CONTEXT_KEYS_TO_ELEVATE.flatMap((key) => {
+                    const value = contextObj[key];
+                    if (value === undefined || value === null)
+                        return [];
+                    return [{ key, value: stringifyContextValue(value) }];
+                });
+                if (facts.length > 0) {
+                    contextFactsByRunId[event.scope.runId] = facts;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    const runIds = new Set([
+        ...Object.keys(itemsByRunId),
+        ...Object.keys(contextFactsByRunId),
+    ]);
+    const byRunId = {};
+    for (const runId of runIds) {
+        byRunId[runId] = {
+            items: itemsByRunId[runId] ?? [],
+            contextFacts: contextFactsByRunId[runId] ?? [],
+        };
+    }
+    return (0, neverthrow_1.ok)({ byRunId });
+}
+function mapDecisionTraceRefs(refs) {
+    if (!refs || refs.length === 0)
+        return [];
+    const mapped = [];
+    for (const ref of refs) {
+        switch (ref.kind) {
+            case 'step_id':
+                if (ref.stepId) {
+                    mapped.push({ kind: 'step_id', value: ref.stepId });
+                }
+                break;
+            case 'loop_id':
+                if (ref.loopId) {
+                    mapped.push({ kind: 'loop_id', value: ref.loopId });
+                }
+                break;
+            case 'condition_id':
+                if (ref.conditionId) {
+                    mapped.push({ kind: 'condition_id', value: ref.conditionId });
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return mapped;
+}
+function stringifyContextValue(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    return JSON.stringify(value);
+}

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

@@ -1,5 +1,5 @@
 import type { Result } from 'neverthrow';
-import type { DomainEventV1 } from '../durable-core/schemas/session/index.js';
+import type { SortedEventLog } from '../durable-core/sorted-event-log.js';
 import type { AutonomyV2, RiskPolicyV2 } from '../durable-core/schemas/session/preferences.js';
 import type { ProjectionError } from './projection-error.js';
 export interface PreferencesSnapshotV2 {
@@ -16,4 +16,4 @@ export interface RunStatusSignalsV2 {
 export interface RunStatusSignalsProjectionV2 {
     readonly byRunId: Readonly<Record<string, RunStatusSignalsV2>>;
 }
-export declare function projectRunStatusSignalsV2(events: readonly DomainEventV1[]): Result<RunStatusSignalsProjectionV2, ProjectionError>;
+export declare function projectRunStatusSignalsV2(events: SortedEventLog): Result<RunStatusSignalsProjectionV2, ProjectionError>;

package/dist/v2/usecases/console-routes.d.ts

@@ -1,3 +1,5 @@
 import type { Application } from 'express';
 import type { ConsoleService } from './console-service.js';
-export declare function mountConsoleRoutes(app: Application, consoleService: ConsoleService): void;
+import type { WorkflowService } from '../../application/services/workflow-service.js';
+import type { ToolCallTimingRingBuffer } from '../../mcp/tool-call-timing.js';
+export declare function mountConsoleRoutes(app: Application, consoleService: ConsoleService, workflowService?: WorkflowService, timingRingBuffer?: ToolCallTimingRingBuffer): () => void;