@exaudeus/workrail 3.15.0 → 3.16.0

package/dist/v2/durable-core/domain/recap-recovery.js

@@ -6,18 +6,21 @@ exports.buildChildSummary = buildChildSummary;
 const neverthrow_1 = require("neverthrow");
 const constants_js_1 = require("../constants.js");
 function collectAncestryRecap(args) {
-    const buildChain = (cur, visited) => {
-        if (!cur || visited.has(cur))
-            return [];
-        const nodeData = args.dag.nodesById[cur];
-        const parent = nodeData?.parentNodeId ?? null;
-        const newVisited = new Set([...visited, cur]);
-        return [cur, ...buildChain(parent, newVisited)];
+    const buildChain = (start) => {
+        const result = [];
+        const visited = new Set();
+        let cur = start;
+        while (cur !== null && !visited.has(cur)) {
+            visited.add(cur);
+            result.push(cur);
+            cur = args.dag.nodesById[cur]?.parentNodeId ?? null;
+        }
+        return result;
     };
     const startNode = args.includeCurrentNode
         ? String(args.nodeId)
         : args.dag.nodesById[String(args.nodeId)]?.parentNodeId ?? null;
-    const chain = buildChain(startNode, new Set());
+    const chain = buildChain(startNode);
     const recaps = chain.flatMap((nodeId) => {
         const nodeOutputs = args.outputs.nodesById[nodeId];
         if (!nodeOutputs)
@@ -35,15 +38,19 @@ function collectAncestryRecap(args) {
     return (0, neverthrow_1.ok)([...recaps].reverse());
 }
 function collectDownstreamRecap(args) {
-    const buildPathBackward = (cur, visited) => {
-        if (!cur || cur === String(args.fromNodeId) || visited.has(cur))
-            return [];
-        const nodeData = args.dag.nodesById[cur];
-        const parent = nodeData?.parentNodeId ?? null;
-        const newVisited = new Set([...visited, cur]);
-        return [cur, ...buildPathBackward(parent, newVisited)];
+    const buildPathBackward = (start) => {
+        const result = [];
+        const visited = new Set();
+        const fromId = String(args.fromNodeId);
+        let cur = start;
+        while (cur !== null && cur !== fromId && !visited.has(cur)) {
+            visited.add(cur);
+            result.push(cur);
+            cur = args.dag.nodesById[cur]?.parentNodeId ?? null;
+        }
+        return result;
     };
-    const pathBackward = buildPathBackward(String(args.toNodeId), new Set());
+    const pathBackward = buildPathBackward(String(args.toNodeId));
     const recaps = [...pathBackward].reverse().flatMap((nodeId) => {
         const nodeOutputs = args.outputs.nodesById[nodeId];
         if (!nodeOutputs)

package/dist/v2/durable-core/domain/retrieval-contract.js

@@ -63,17 +63,21 @@ exports.RESUME_PREVIEW_CONTRACT = {
 };
 const encoder = new TextEncoder();
 const decoder = new TextDecoder('utf-8');
+const TIER_PRIORITY = Object.fromEntries(exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.map((t) => [t.tier, t.priority]));
+const TIER_RETENTION = Object.fromEntries(exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.map((t) => [t.tier, t.retention]));
+const RESUME_PREVIEW_TIER_PRIORITY = Object.fromEntries(exports.RESUME_PREVIEW_CONTRACT.tiers.map((t) => [t.tier, t.priority]));
+const RESUME_PREVIEW_TIER_MAX_BYTES = Object.fromEntries(exports.RESUME_PREVIEW_CONTRACT.tiers.map((t) => [t.tier, t.maxBytes]));
 function getTierPriority(tier) {
-    return exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.priority ?? Number.MAX_SAFE_INTEGER;
+    return TIER_PRIORITY[tier] ?? Number.MAX_SAFE_INTEGER;
 }
 function getTierRetention(tier) {
-    return exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.retention ?? 'tail';
+    return TIER_RETENTION[tier] ?? 'tail';
 }
 function getResumePreviewTierPriority(tier) {
-    return exports.RESUME_PREVIEW_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.priority ?? Number.MAX_SAFE_INTEGER;
+    return RESUME_PREVIEW_TIER_PRIORITY[tier] ?? Number.MAX_SAFE_INTEGER;
 }
 function getResumePreviewTierMaxBytes(tier) {
-    return exports.RESUME_PREVIEW_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.maxBytes ?? exports.RESUME_PREVIEW_CONTRACT.budgetBytes;
+    return RESUME_PREVIEW_TIER_MAX_BYTES[tier] ?? exports.RESUME_PREVIEW_CONTRACT.budgetBytes;
 }
 function compareAscii(a, b) {
     return a < b ? -1 : a > b ? 1 : 0;
@@ -283,7 +287,8 @@ function renderBudgetedRehydrateRecovery(args) {
     const initiallyIncludedTiers = tiersInOrder.filter((tier) => (sectionsByTier.get(tier) ?? []).length > 0);
     let includedTiers = initiallyIncludedTiers;
     let recoveryText = renderFromTiers(includedTiers);
-    while (encoder.encode(recoveryText).length > constants_js_1.RECOVERY_BUDGET_BYTES) {
+    let recoveryBytes = encoder.encode(recoveryText).length;
+    while (recoveryBytes > constants_js_1.RECOVERY_BUDGET_BYTES) {
         const droppableTierIndex = [...includedTiers]
             .reverse()
             .findIndex((tier) => getTierRetention(tier) === 'tail');
@@ -293,9 +298,10 @@ function renderBudgetedRehydrateRecovery(args) {
         const actualIndex = includedTiers.length - 1 - droppableTierIndex;
         includedTiers = includedTiers.filter((_, index) => index !== actualIndex);
         recoveryText = renderFromTiers(includedTiers);
+        recoveryBytes = encoder.encode(recoveryText).length;
     }
     const omittedTierCount = initiallyIncludedTiers.length - includedTiers.length;
-    const needsSuffix = omittedTierCount > 0 || encoder.encode(recoveryText).length > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0;
+    const needsSuffix = omittedTierCount > 0 || recoveryBytes > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0;
     const finalText = recoveryText.length === 0
         ? trimFinalRecoveryText(args.header, initiallyIncludedTiers.length)
         : !needsSuffix
@@ -305,6 +311,6 @@ function renderBudgetedRehydrateRecovery(args) {
         text: finalText,
         includedTiers,
         omittedTierCount,
-        truncatedWithinTier: encoder.encode(recoveryText).length > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0,
+        truncatedWithinTier: recoveryBytes > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0,
     };
 }

package/dist/v2/durable-core/session-index.d.ts

@@ -0,0 +1,22 @@
+import type { Brand } from '../../runtime/brand.js';
+import type { SortedEventLog } from './sorted-event-log.js';
+import type { DomainEventV1 } from './schemas/session/index.js';
+import type { JsonObject } from './canonical/json-types.js';
+export interface SessionIndexData {
+    readonly sortedEvents: SortedEventLog;
+    readonly runStartedByRunId: ReadonlyMap<string, Extract<DomainEventV1, {
+        kind: 'run_started';
+    }>>;
+    readonly nodeCreatedByNodeId: ReadonlyMap<string, Extract<DomainEventV1, {
+        kind: 'node_created';
+    }>>;
+    readonly hasChildEdgeByFromNodeId: ReadonlySet<string>;
+    readonly advanceRecordedByDedupeKey: ReadonlyMap<string, Extract<DomainEventV1, {
+        kind: 'advance_recorded';
+    }>>;
+    readonly nextEventIndex: number;
+    readonly hasPriorNotesByRunId: ReadonlySet<string>;
+    readonly runContextByRunId: ReadonlyMap<string, JsonObject>;
+}
+export type SessionIndex = Brand<SessionIndexData, 'v2.SessionIndex'>;
+export declare function buildSessionIndex(events: SortedEventLog): SessionIndex;

package/dist/v2/durable-core/session-index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSessionIndex = buildSessionIndex;
+const constants_js_1 = require("./constants.js");
+function buildSessionIndex(events) {
+    const runStartedByRunId = new Map();
+    const nodeCreatedByNodeId = new Map();
+    const hasChildEdgeByFromNodeId = new Set();
+    const advanceRecordedByDedupeKey = new Map();
+    const hasPriorNotesByRunId = new Set();
+    const runContextByRunId = new Map();
+    for (const event of events) {
+        switch (event.kind) {
+            case 'run_started':
+                runStartedByRunId.set(event.scope.runId, event);
+                break;
+            case 'node_created':
+                nodeCreatedByNodeId.set(event.scope.nodeId, event);
+                break;
+            case 'edge_created':
+                hasChildEdgeByFromNodeId.add(event.data.fromNodeId);
+                break;
+            case 'advance_recorded':
+                advanceRecordedByDedupeKey.set(event.dedupeKey, event);
+                break;
+            case 'node_output_appended': {
+                const outputEvt = event;
+                if (outputEvt.data.outputChannel === constants_js_1.OUTPUT_CHANNEL.RECAP &&
+                    outputEvt.data.payload.payloadKind === constants_js_1.PAYLOAD_KIND.NOTES) {
+                    hasPriorNotesByRunId.add(event.scope.runId);
+                }
+                break;
+            }
+            case 'context_set': {
+                const ctx = event.data.context;
+                if (ctx && typeof ctx === 'object' && !Array.isArray(ctx)) {
+                    runContextByRunId.set(event.scope.runId, ctx);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    const lastEvent = events[events.length - 1];
+    const nextEventIndex = lastEvent !== undefined ? lastEvent.eventIndex + 1 : 0;
+    const data = {
+        sortedEvents: events,
+        runStartedByRunId,
+        nodeCreatedByNodeId,
+        hasChildEdgeByFromNodeId,
+        advanceRecordedByDedupeKey,
+        nextEventIndex,
+        hasPriorNotesByRunId,
+        runContextByRunId,
+    };
+    return data;
+}

package/dist/v2/durable-core/sorted-event-log.d.ts

@@ -0,0 +1,6 @@
+import type { Result } from 'neverthrow';
+import type { Brand } from '../../runtime/brand.js';
+import type { DomainEventV1 } from './schemas/session/index.js';
+import type { ProjectionError } from '../projections/projection-error.js';
+export type SortedEventLog = Brand<readonly DomainEventV1[], 'v2.SortedEventLog'>;
+export declare function asSortedEventLog(events: readonly DomainEventV1[]): Result<SortedEventLog, ProjectionError>;

package/dist/v2/durable-core/sorted-event-log.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asSortedEventLog = asSortedEventLog;
+const neverthrow_1 = require("neverthrow");
+function asSortedEventLog(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 strictly ascending (no duplicates)',
+            });
+        }
+    }
+    return (0, neverthrow_1.ok)(events);
+}

package/dist/v2/infra/local/fs/index.js

@@ -166,18 +166,18 @@ class NodeFileSystemV2 {
     readdirWithMtime(dirPath) {
         return neverthrow_1.ResultAsync.fromPromise((async () => {
             const entries = await fs.readdir(dirPath);
+            const results = await Promise.allSettled(entries.map((name) => fs.stat(path.join(dirPath, name)).then((s) => ({ name, mtimeMs: s.mtimeMs }))));
             const withMtime = [];
             let skipped = 0;
-            for (const name of entries) {
-                try {
-                    const stats = await fs.stat(path.join(dirPath, name));
-                    withMtime.push({ name, mtimeMs: stats.mtimeMs });
+            for (let i = 0; i < results.length; i++) {
+                const result = results[i];
+                if (result.status === 'fulfilled') {
+                    withMtime.push(result.value);
                 }
-                catch (e) {
-                    const code = nodeErrorCode(e);
+                else {
+                    const code = nodeErrorCode(result.reason);
                     skipped++;
-                    console.error(`[workrail:session-enum] Skipping ${name}: stat failed (${code ?? 'unknown'}: ${e instanceof Error ? e.message : String(e)})`);
-                    continue;
+                    console.error(`[workrail:session-enum] Skipping ${entries[i]}: stat failed (${code ?? 'unknown'}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)})`);
                 }
             }
             if (skipped > 0) {

package/dist/v2/infra/local/session-store/index.d.ts

@@ -10,7 +10,7 @@ export declare class LocalSessionEventLogStoreV2 implements SessionEventLogReado
     private readonly fs;
     private readonly sha256;
     constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2, sha256: Sha256PortV2);
-    append(lock: WithHealthySessionLock, plan: AppendPlanV2): ResultAsync<void, SessionEventLogStoreError>;
+    append(lock: WithHealthySessionLock, plan: AppendPlanV2, preloadedTruth?: LoadedSessionTruthV2): ResultAsync<void, SessionEventLogStoreError>;
     load(sessionId: SessionId): ResultAsync<LoadedSessionTruthV2, SessionEventLogStoreError>;
     loadValidatedPrefix(sessionId: SessionId): ResultAsync<LoadedValidatedPrefixV2, SessionEventLogStoreError>;
     private appendImpl;

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/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 {};