@astrosheep/keiyaku 2.9.4 → 2.9.6

package/build/core/projection/projection-execution-observer.js

@@ -1,22 +1,27 @@
 import { claimAllInbox, listTellIds, markTellSubmitted, markTellConsumed, readTellSubmitted, readTellOriginal, isTellCausallyConsumed, appendGenerationEvent, } from "./projection-core.js";
 import { openProjectionTellObserver, } from "./tell/database.js";
 const LIVE_TELL_DELIVERY_THROTTLE_MS = 200;
-function submitEligible(projectionDirectory, executionId, control, requireInbox, submitting, observer, pendingCompletionEvidence) {
+export function renderProjectionTellFrame(tellId, text) {
+    return `--- tell ${tellId} ---\n${text}`;
+}
+function submitEligible(projectionDirectory, executionId, control, requireInbox, submitting, submissions, excludedTellIds, observer, pendingCompletionEvidence) {
     if (requireInbox && !observer?.hasInbox())
         return;
     claimAllInbox(projectionDirectory);
     for (const tellId of listTellIds(projectionDirectory, "inflight")) {
+        if (excludedTellIds.has(tellId))
+            continue;
         if (submitting.has(tellId))
             continue;
         // Construct before pin: a sync read/build failure must not leave submitting stuck.
         const original = readTellOriginal(projectionDirectory, "inflight", tellId);
         const tell = {
             id: tellId,
-            text: `--- tell ${tellId} ---\n${original.text}`,
+            text: renderProjectionTellFrame(tellId, original.text),
             ...(original.effort ? { effort: original.effort } : {}),
         };
         submitting.add(tellId);
-        void Promise.resolve()
+        const submission = Promise.resolve()
             .then(() => control.enqueue(tell))
             .then((ack) => {
             if (!ack)
@@ -39,6 +44,8 @@ function submitEligible(projectionDirectory, executionId, control, requireInbox,
             pendingCompletionEvidence.delete(tellId);
         })
             .finally(() => submitting.delete(tellId));
+        submissions.add(submission);
+        void submission.finally(() => submissions.delete(submission));
     }
 }
 export function createLiveTellDeliveryController(projectionDirectory, executionId, dependencies = {}) {
@@ -47,8 +54,10 @@ export function createLiveTellDeliveryController(projectionDirectory, executionI
     const clearTimer = dependencies.clearTimer ?? ((timer) => clearTimeout(timer));
     const openObserver = dependencies.openObserver ?? openProjectionTellObserver;
     const submitting = new Set();
+    const submissions = new Set();
     // In-memory only: bridges completion-before-ack when a tell is still submitting.
     const pendingCompletionEvidence = new Map();
+    const initial = new Set(dependencies.initialTellIds);
     let observer;
     let timer;
     let nextOpportunityAt = 0;
@@ -93,7 +102,7 @@ export function createLiveTellDeliveryController(projectionDirectory, executionI
         try {
             observer ??= openObserver(projectionDirectory);
             if (observer.hasDataVersionChanged()) {
-                submitEligible(projectionDirectory, executionId, control, true, submitting, observer, pendingCompletionEvidence);
+                submitEligible(projectionDirectory, executionId, control, true, submitting, submissions, initial, observer, pendingCompletionEvidence);
             }
         }
         catch {
@@ -131,7 +140,14 @@ export function createLiveTellDeliveryController(projectionDirectory, executionI
                 return;
             latestControl = control;
             cancelOpportunity();
-            submitEligible(projectionDirectory, executionId, control, false, submitting, observer, pendingCompletionEvidence);
+            for (const tellId of initial) {
+                markTellSubmitted(projectionDirectory, tellId, {
+                    executionId,
+                    fence: checkpoint.fence,
+                });
+                initial.delete(tellId);
+            }
+            submitEligible(projectionDirectory, executionId, control, false, submitting, submissions, initial, observer, pendingCompletionEvidence);
             if (!checkpoint.consumptionEvidence)
                 return;
             for (const tellId of listTellIds(projectionDirectory, "submitted")) {
@@ -149,13 +165,14 @@ export function createLiveTellDeliveryController(projectionDirectory, executionI
                     pendingCompletionEvidence.set(tellId, [checkpoint.fence]);
             }
         },
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            cancelOpportunity();
-            discardObserver();
+        async close() {
+            if (!closed) {
+                closed = true;
+                cancelOpportunity();
+                discardObserver();
+            }
             // Do not drop pendingCompletionEvidence: in-flight acks may still submit/consume.
+            await Promise.all([...submissions]);
         },
     };
 }
@@ -174,8 +191,8 @@ export function buildSyncCheckpointCallback(projectionDirectory, executionId) {
  */
 export function createProjectionExecutionObserver(input, dependencies = {}) {
     const appendEvent = dependencies.appendGenerationEvent ?? appendGenerationEvent;
-    const tellController = createLiveTellDeliveryController(input.projectionDirectory, input.executionId);
-    let closed = false;
+    const tellController = createLiveTellDeliveryController(input.projectionDirectory, input.executionId, { initialTellIds: input.initialTellIds });
+    let closePromise;
     const observer = {
         onEvent(event) {
             appendEvent(input.projectionDirectory, input.executionId, event);
@@ -190,15 +207,12 @@ export function createProjectionExecutionObserver(input, dependencies = {}) {
     return {
         observer,
         close() {
-            if (closed)
-                return;
-            closed = true;
-            try {
-                tellController.close();
-            }
-            catch {
+            if (closePromise)
+                return closePromise;
+            closePromise = tellController.close().catch(() => {
                 // Controller cleanup cannot change provider completion.
-            }
+            });
+            return closePromise;
         },
     };
 }

package/build/core/projection/projection-life-observer.js

@@ -1,4 +1,4 @@
-import { openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
+import { isIncompatibleProjectionGenerationStoreError, openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
 import { deriveProjectionLife, selectCurrentGeneration, } from "./projection-life-protocol.js";
 import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
 function errorDetail(error) {
@@ -25,7 +25,11 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
             records = readRecords();
         }
         catch (error) {
+            if (isIncompatibleProjectionGenerationStoreError(error)) {
+                return { compatibility: "incompatible", diagnostic: errorDetail(error) };
+            }
             return {
+                compatibility: "current",
                 life: {
                     phase: "unknown",
                     diagnostic: `generation history could not be observed: ${errorDetail(error)}`,
@@ -35,6 +39,7 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
         const current = selectCurrentGeneration(records);
         if (!current || current.verdict || !current.adoption) {
             return {
+                compatibility: "current",
                 life: deriveProjectionLife({
                     records,
                     nowMs: options.nowMs,
@@ -49,7 +54,11 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
             after = readRecords();
         }
         catch (error) {
+            if (isIncompatibleProjectionGenerationStoreError(error)) {
+                return { compatibility: "incompatible", diagnostic: errorDetail(error) };
+            }
             return {
+                compatibility: "current",
                 life: {
                     phase: "unknown",
                     executionId: current.launch.executionId,
@@ -62,6 +71,7 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
         if (records.length !== after.length || beforeTail !== afterTail)
             continue;
         return {
+            compatibility: "current",
             life: deriveProjectionLife({
                 records,
                 runnerLock: lock.state === "held"
@@ -76,6 +86,7 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
         };
     }
     return {
+        compatibility: "current",
         life: {
             phase: "unknown",
             diagnostic: "generation history changed during runner-lock observation",
@@ -83,5 +94,8 @@ export function observeProjectionLifeSnapshot(projectionDirectory, options) {
     };
 }
 export function observeProjectionLife(projectionDirectory, options) {
-    return observeProjectionLifeSnapshot(projectionDirectory, options).life;
+    const snapshot = observeProjectionLifeSnapshot(projectionDirectory, options);
+    return snapshot.compatibility === "current"
+        ? snapshot.life
+        : { phase: "unknown", diagnostic: snapshot.diagnostic };
 }

package/build/core/projection/projection-status.js

@@ -10,10 +10,11 @@ import { readProjectionTellCounts } from "./tell/store.js";
 import { ProjectionGenerationStoreError, } from "./generation/store.js";
 import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./generation/projection-generation-launcher.js";
 import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { selectCurrentGeneration } from "./projection-life-protocol.js";
+import { selectCurrentGeneration, } from "./projection-life-protocol.js";
 import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents } from "../stored-agent-event.js";
 import { worktreeContainsCoordinate } from "../worktree-path.js";
 import { projectTerminalFailure, } from "./projection-terminal-failure.js";
+import { extractTerminalTimestamp } from "./generation/model.js";
 const MAX_STATUS_FILE_BYTES = 256 * 1024;
 const STATUS_GROUP = {
     "startup-timeout": 0,
@@ -26,13 +27,15 @@ const STATUS_GROUP = {
     done: 3,
     killed: 4,
     dismissed: 4,
+    incompatible: 5,
 };
 function isOmissibleProjectionStatusState(state) {
     return state === "failed"
         || state === "dead"
         || state === "done"
         || state === "killed"
-        || state === "dismissed";
+        || state === "dismissed"
+        || state === "incompatible";
 }
 function rowSortTime(row) {
     if (row.activityAtMs !== undefined && Number.isFinite(row.activityAtMs)) {
@@ -71,6 +74,7 @@ export function prioritizeProjectionStatusRows(rows, showAll) {
         done: 0,
         killed: 0,
         dismissed: 0,
+        incompatible: 0,
     };
     for (const row of ordered) {
         if (isOmissibleProjectionStatusState(row.state))
@@ -239,64 +243,99 @@ function readStoredEvents(projectionDir, executionId, diagnostics) {
     }
     return values;
 }
-function latestValidEventAtMs(events) {
+function latestValidEvent(events) {
     let latest;
     for (const event of events) {
         const atMs = Date.parse(event.at);
         if (!Number.isFinite(atMs))
             continue;
-        if (latest === undefined || atMs > latest)
-            latest = atMs;
+        if (latest === undefined || atMs > latest.atMs)
+            latest = { at: event.at, atMs };
     }
     return latest;
 }
-function readActivityFacts(projectionDir, executionId, nowMs, diagnostics, fallbackAtMs) {
-    if (!executionId)
-        return {};
+function readActivityFacts(projectionDir, executionId, nowMs, diagnostics, fallbackAt) {
+    const fallbackAtMs = fallbackAt === undefined ? undefined : Date.parse(fallbackAt);
+    const validFallback = fallbackAt !== undefined && Number.isFinite(fallbackAtMs)
+        ? { at: fallbackAt, atMs: fallbackAtMs }
+        : undefined;
+    if (!executionId) {
+        return validFallback
+            ? { activityAt: validFallback.at, activityAtMs: validFallback.atMs, activityAgeMs: Math.max(0, nowMs - validFallback.atMs) }
+            : {};
+    }
     const stored = readStoredEvents(projectionDir, executionId, diagnostics);
     const { events, malformed } = selectValidStoredAgentEvents(stored);
     const invalidActivity = invalidActivityEventDiagnostic(malformed);
     if (invalidActivity)
         diagnostics.push(invalidActivity);
-    const activityAtMs = latestValidEventAtMs(events) ?? fallbackAtMs;
+    const latest = latestValidEvent(events) ?? validFallback;
     return {
         ...(events.length > 0 ? { activity: foldPublicProjectionActivity(events) } : {}),
-        ...(activityAtMs !== undefined
+        ...(latest !== undefined
             ? {
-                activityAtMs,
-                activityAgeMs: Math.max(0, nowMs - activityAtMs),
+                activityAt: latest.at,
+                activityAtMs: latest.atMs,
+                activityAgeMs: Math.max(0, nowMs - latest.atMs),
             }
             : {}),
     };
 }
+function terminalTimestamp(current) {
+    return extractTerminalTimestamp(current?.verdict?.facts);
+}
 function readProjectionRow(projectionDir, id, alias, nowMs) {
     const diagnostics = [];
+    const snapshot = observeProjectionLifeSnapshot(projectionDir, {
+        nowMs,
+        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
+    });
+    if (snapshot.compatibility === "incompatible") {
+        return {
+            id,
+            ...(alias ? { alias } : {}),
+            state: "incompatible",
+            observation: snapshot,
+            tellCounts: emptyTellCounts(),
+            diagnostics,
+        };
+    }
     const identityFacts = readIdentityFacts(projectionDir, diagnostics);
     const tellCounts = identityFacts.identity
         ? readHeartTellCounts(projectionDir, diagnostics)
         : emptyTellCounts();
     if (!identityFacts.identity) {
+        const diagnostic = diagnostics.map((entry) => entry.detail).find((detail) => detail !== undefined)
+            ?? "projection identity could not be observed";
         return {
             id,
+            ...(alias ? { alias } : {}),
             state: "unknown",
+            observation: {
+                compatibility: "current",
+                lifecycle: { phase: "unknown", diagnostic },
+            },
             tellCounts,
             diagnostics,
         };
     }
-    const observation = observeProjectionLifeSnapshot(projectionDir, {
-        nowMs,
-        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
-    });
-    const life = observation.life;
-    const current = observation.records
-        ? selectCurrentGeneration(observation.records)
+    const life = snapshot.life;
+    const current = snapshot.records
+        ? selectCurrentGeneration(snapshot.records)
         : null;
     const adoptedAt = current?.adoption?.facts.adoptedAt;
     const adoptedAtMs = typeof adoptedAt === "string"
         ? Date.parse(adoptedAt)
         : Number.NaN;
-    const activityFacts = readActivityFacts(projectionDir, life.executionId, nowMs, diagnostics, Number.isFinite(adoptedAtMs) ? adoptedAtMs : undefined);
+    const activityFacts = readActivityFacts(projectionDir, life.executionId, nowMs, diagnostics, typeof adoptedAt === "string" && Number.isFinite(adoptedAtMs) ? adoptedAt : identityFacts.mintedAt);
     const mintedAtMs = Date.parse(identityFacts.mintedAt ?? "");
+    const terminalAt = terminalTimestamp(current);
+    const durationAnchorMs = current?.verdict
+        ? (terminalAt === undefined ? Number.NaN : Date.parse(terminalAt))
+        : nowMs;
+    const durationMs = Number.isFinite(mintedAtMs) && Number.isFinite(durationAnchorMs)
+        ? Math.max(0, durationAnchorMs - mintedAtMs)
+        : undefined;
     const displayAgeMs = activityFacts.activityAgeMs
         ?? (Number.isFinite(mintedAtMs) ? Math.max(0, nowMs - mintedAtMs) : undefined);
     if (life.phase === "unknown" && life.diagnostic) {
@@ -311,10 +350,13 @@ function readProjectionRow(projectionDir, id, alias, nowMs) {
         id,
         ...(alias ? { alias } : {}),
         state,
+        observation: { compatibility: "current", lifecycle: life },
         akuma: identityFacts.akuma,
         provider: identityFacts.provider,
         pid: identityFacts.pid,
         mintedAt: identityFacts.mintedAt,
+        ...(terminalAt ? { terminalAt } : {}),
+        ...(durationMs !== undefined ? { durationMs } : {}),
         ...(identityFacts.workspaceRoot ? { workspaceRoot: identityFacts.workspaceRoot } : {}),
         ...activityFacts,
         ...(displayAgeMs !== undefined ? { activityAgeMs: displayAgeMs } : {}),
@@ -448,10 +490,13 @@ export async function hasStrandableProjectionGeneration(input) {
                 || !worktreeContainsCoordinate(input.deliveryWorktree, identity.workspaceRoot)) {
                 continue;
             }
-            const phase = observeProjectionLifeSnapshot(projectionDir, {
+            const observation = observeProjectionLifeSnapshot(projectionDir, {
                 nowMs: input.nowMs,
                 startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
-            }).life.phase;
+            });
+            if (observation.compatibility !== "current")
+                continue;
+            const phase = observation.life.phase;
             if (phase === "active"
                 || phase === "minting"
                 || phase === "startup-timeout"

package/build/core/projection/projection-terminal-failure.js

@@ -3,6 +3,8 @@ import { RESPONSE_ARTIFACT_ID_RE } from "../response-artifact-id.js";
 import { OUTCOME_ERROR_VERSION } from "../../agents/types.js";
 const HARNESS_FAILURE_CODES = new Set([
     "SUBAGENT_TIMEOUT",
+    "SUBAGENT_TRANSPORT_ERROR",
+    "SUBAGENT_POLICY_BUDGET",
     "SUBAGENT_NON_ZERO_EXIT",
     "SUBAGENT_SPAWN_ERROR",
     "SUBAGENT_EXEC_ERROR",

package/build/core/projection/projection-wait.js

@@ -4,6 +4,7 @@ import { foldPublicProjectionActivity } from "./projection-activity.js";
 import { readGenerationEvents, isProjectionId, projectionRoot, } from "./projection-core.js";
 import { readProjectionIdentity } from "./projection-identity.js";
 import { RESPONSE_ARTIFACT_ID_RE } from "../response-artifact-id.js";
+import { extractTerminalTimestamp } from "./generation/model.js";
 import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./generation/projection-generation-launcher.js";
 import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
 import { selectCurrentGeneration } from "./projection-life-protocol.js";
@@ -100,13 +101,7 @@ function relativeEventLedgerFile(executionId) {
     return `${executionId}.events.jsonl`;
 }
 function timestampFact(current, nowMs) {
-    const facts = current.verdict?.facts;
-    for (const key of ["completedAt", "failedAt", "dismissedAt", "killedAt"]) {
-        const value = facts?.[key];
-        if (typeof value === "string" && Number.isFinite(Date.parse(value)))
-            return value;
-    }
-    return new Date(nowMs).toISOString();
+    return extractTerminalTimestamp(current.verdict?.facts) ?? new Date(nowMs).toISOString();
 }
 function verdictFromCurrent(current, nowMs) {
     if (!current.verdict)
@@ -180,10 +175,12 @@ export async function waitForProjection(input) {
             nowMs: observedAtMs,
             startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
         });
-        const current = observation.records
+        const current = observation.compatibility === "current" && observation.records
             ? selectCurrentGeneration(observation.records)
             : null;
-        const life = observation.life;
+        const life = observation.compatibility === "current"
+            ? observation.life
+            : { phase: "unknown", diagnostic: observation.diagnostic };
         const verdict = current ? verdictFromCurrent(current, observedAtMs) : undefined;
         const terminal = verdict !== undefined;
         const terminalAtMs = verdict === undefined ? undefined : Date.parse(verdict.at);

package/build/core/projection/projection-wake.js

@@ -6,9 +6,25 @@ import { applyContinuationEffort, snapshotPendingTells, } from "./generation/pro
 import { createProjectionExecutionId } from "./generation/projection-generation-identity.js";
 import { PROJECTION_ADOPTION_POLL_MS, PROJECTION_ADOPTION_TIMEOUT_MS, startProjectionGeneration, } from "./generation/projection-generation-launcher.js";
 import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
-import { observeProjectionLife } from "./projection-life-observer.js";
+import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
 import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
 import { setTimeout as delay } from "node:timers/promises";
+function incompatibleProjectionError(projectionId) {
+    const subject = projectionId ? `Projection '${projectionId}'` : "Projection";
+    return new FlowError("PROJECTION_INCOMPATIBLE", `${subject} has incompatible historical storage; keiyaku status --all can inspect it, but tell cannot change it.`);
+}
+/**
+ * Tell is a current-schema mutation only. This gate runs before the handler
+ * writes an inbox row, so historical storage never acquires pending mail.
+ */
+export function assertProjectionTellable(projectionDirectory) {
+    const observation = observeProjectionLifeSnapshot(projectionDirectory, {
+        nowMs: Date.now(),
+        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
+    });
+    if (observation.compatibility === "incompatible")
+        throw incompatibleProjectionError();
+}
 function readCurrentGeneration(projectionDirectory) {
     const store = openProjectionGenerationStoreReadOnly(projectionDirectory);
     try {
@@ -28,7 +44,7 @@ function successorFacts(current, snapshot, nowMs, requireContinuation) {
         : {};
     const session = verdictFacts?.session ?? inputs.session;
     const launchSnapshot = parseResolvedAkumaLaunchSnapshot(inputs.launchSnapshot);
-    const recoverableSession = isRecoverableSessionEnvelope(launchSnapshot.provider.name, session);
+    const recoverableSession = isRecoverableSessionEnvelope(launchSnapshot.provider.kind, session);
     if (requireContinuation && !recoverableSession) {
         throw new FlowError("PROJECTION_WAKE_FAILED", "The tell was saved, but the successor could not be started because its provider session is not recoverable.");
     }
@@ -86,7 +102,7 @@ async function startCommittedSuccessor(projectionDirectory, projectionId, execut
     const started = await startGeneration(projectionDirectory, executionId);
     if (started.status === "adopted")
         return "woken";
-    throw new FlowError("PROJECTION_WAKE_FAILED", `The tell was saved for '${projectionId}', but its successor could not be started.`, {
+    throw new FlowError("PROJECTION_WAKE_FAILED", `The tell was saved for '${projectionId}', but its successor could not be started (cause: ${started.cause}).`, {
         facts: {
             kind: "projection_wake_failure",
             projectionId,
@@ -96,7 +112,7 @@ async function startCommittedSuccessor(projectionDirectory, projectionId, execut
     });
 }
 function sessionWakeFailure(projectionId, cause) {
-    return new FlowError("PROJECTION_WAKE_FAILED", `The tell was saved for '${projectionId}', but its successor could not be started.`, {
+    return new FlowError("PROJECTION_WAKE_FAILED", `The tell was saved for '${projectionId}', but its successor could not be started (cause: session_unrecoverable).`, {
         cause,
         facts: {
             kind: "projection_wake_failure",
@@ -112,10 +128,14 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
     const observationStartedAt = Date.now();
     for (;;) {
         const nowMs = Date.now();
-        const life = observeProjectionLife(projectionDirectory, {
+        const observation = observeProjectionLifeSnapshot(projectionDirectory, {
             nowMs,
             startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
         });
+        if (observation.compatibility === "incompatible") {
+            throw incompatibleProjectionError(projectionId);
+        }
+        const life = observation.life;
         if (life.phase === "active")
             return "active";
         if (life.phase === "minting" || life.phase === "quiescent") {
@@ -148,6 +168,7 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
         const store = openProjectionGenerationStore(projectionDirectory);
         try {
             if (life.phase === "startup-timeout") {
+                const terminalAt = new Date(nowMs).toISOString();
                 const transition = store.supersedeStartupTimeout({
                     executionId: current.launch.executionId,
                     observedAtMs: nowMs,
@@ -155,6 +176,7 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
                     diagnostic: { detail: "runner did not adopt before startup timeout" },
                     successorExecutionId,
                     successorFacts: facts,
+                    terminalAt,
                 });
                 if (transition.status === "committed") {
                     return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration);
@@ -168,11 +190,13 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
                 const lock = observeProjectionRunnerLock(projectionDirectory);
                 if (lock.state !== "released")
                     return lock.state === "held" ? "active" : "pending";
+                const terminalAt = new Date(nowMs).toISOString();
                 const transition = store.replaceDeadRunner({
                     executionId: current.launch.executionId,
-                    releasedLockEvidence: { observedAt: new Date(nowMs).toISOString() },
+                    releasedLockEvidence: { observedAt: terminalAt },
                     successorExecutionId,
                     successorFacts: facts,
+                    terminalAt,
                 });
                 if (transition.status === "committed") {
                     return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration);