@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -1,337 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { foldPublicProjectionActivity } from "./projection-activity.js";
-import { readGenerationEvents, isProjectionId, projectionRootAtCoordinate, } from "./projection-core.js";
-import { resolveProjectionCoordinate } from "./projection-coordinate.js";
-import { readProjectionIdentity } from "./projection-identity.js";
-import { RESPONSE_ARTIFACT_ID_RE } from "../response-artifact-id.js";
-import { extractTerminalTimestamp } from "./generation/model.js";
-import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { readProjectionGenerationContinuationSnapshot, } from "./generation/projection-generation-continuation.js";
-import { projectTerminalFailure, } from "./projection-terminal-failure.js";
-import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents, } from "../stored-agent-event.js";
-import { tellProjection } from "./projection-wake.js";
-import { FlowError } from "../../flow-error.js";
-/** Return the commission-bound projection IDs visible at one admission instant. */
-export async function snapshotCommissionProjectionIds(cwd, commissionId) {
-    return snapshotCommissionProjectionIdsAtCoordinate(await resolveProjectionCoordinate(cwd), commissionId);
-}
-/** Scan one already-resolved projection coordinate for commission-bound IDs. */
-export async function snapshotCommissionProjectionIdsAtCoordinate(coordinate, commissionId) {
-    const root = projectionRootAtCoordinate(coordinate);
-    let akumas;
-    try {
-        akumas = fs.readdirSync(root).sort();
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-    const ids = [];
-    for (const akuma of akumas) {
-        if (akuma.startsWith("."))
-            continue;
-        const akumaDirectory = path.join(root, akuma);
-        try {
-            if (!fs.lstatSync(akumaDirectory).isDirectory())
-                continue;
-        }
-        catch {
-            continue;
-        }
-        let projections;
-        try {
-            projections = fs.readdirSync(akumaDirectory).sort();
-        }
-        catch {
-            continue;
-        }
-        for (const hex of projections) {
-            const id = `${akuma}/${hex}`;
-            if (!isProjectionId(id))
-                continue;
-            const directory = path.join(akumaDirectory, hex);
-            try {
-                if (!fs.lstatSync(directory).isDirectory())
-                    continue;
-            }
-            catch {
-                continue;
-            }
-            let pact;
-            try {
-                pact = readProjectionIdentity(directory);
-            }
-            catch {
-                // A commission snapshot admits only identities that can prove their
-                // binding. Missing or corrupt unrelated storage is not such proof.
-                continue;
-            }
-            if (pact.binding.kind === "commission" && pact.binding.commissionId === commissionId)
-                ids.push(id);
-        }
-    }
-    return ids;
-}
-const WAIT_POLL_MS = 100;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function latestValidEventAgeMs(events, nowMs) {
-    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;
-    }
-    return latest === undefined ? undefined : Math.max(0, nowMs - latest);
-}
-function adoptionAgeMs(current, nowMs) {
-    const adoptedAt = current?.adoption?.facts.adoptedAt;
-    if (typeof adoptedAt !== "string")
-        return undefined;
-    const adoptedAtMs = Date.parse(adoptedAt);
-    return Number.isFinite(adoptedAtMs)
-        ? Math.max(0, nowMs - adoptedAtMs)
-        : undefined;
-}
-function relativeEventLedgerFile(executionId) {
-    return `${executionId}.events.jsonl`;
-}
-function timestampFact(current, nowMs) {
-    return extractTerminalTimestamp(current.verdict?.facts) ?? new Date(nowMs).toISOString();
-}
-function verdictFromCurrent(current, nowMs) {
-    if (!current.verdict)
-        return undefined;
-    const state = current.verdict.facts.state;
-    if (typeof state !== "string")
-        return undefined;
-    const terminalFailure = projectTerminalFailure(state, current.verdict.facts);
-    return {
-        state: state,
-        at: timestampFact(current, nowMs),
-        ...(terminalFailure ? { terminalFailure } : {}),
-    };
-}
-function outcomeText(current) {
-    if (current.verdict?.facts.state !== "completed")
-        return undefined;
-    const finalMessage = current.verdict?.facts.finalMessage;
-    if (typeof finalMessage === "string" && finalMessage.trim())
-        return finalMessage;
-    return undefined;
-}
-function buildSnapshot(input) {
-    const { projectionDirectory, pact, phase, current, events, malformedEvents, nowMs, tells } = input;
-    const anchorAt = current?.verdict ? timestampFact(current, nowMs) : new Date(nowMs).toISOString();
-    const anchorMs = Date.parse(anchorAt);
-    const mintedAtMs = Date.parse(pact.mintedAt);
-    const activityAgeMs = latestValidEventAgeMs(events, nowMs)
-        ?? adoptionAgeMs(current, nowMs);
-    const invalidActivity = invalidActivityEventDiagnostic(malformedEvents);
-    const artifactId = current?.verdict?.facts.artifactId;
-    const responsePath = current?.verdict?.facts.responsePath;
-    const completed = current?.verdict?.facts.state === "completed";
-    return {
-        phase,
-        observedAtMs: Number.isFinite(anchorMs) ? anchorMs : nowMs,
-        durationMs: Number.isFinite(mintedAtMs) && Number.isFinite(anchorMs)
-            ? Math.max(0, anchorMs - mintedAtMs)
-            : 0,
-        ...(activityAgeMs !== undefined ? { activityAgeMs } : {}),
-        tells,
-        activity: foldPublicProjectionActivity(events),
-        ...(invalidActivity ? { eventDiagnostics: [invalidActivity] } : {}),
-        workspaceRoot: pact.workspaceRoot,
-        ...(current ? {
-            executionId: current.launch.executionId,
-            eventLedgerFile: relativeEventLedgerFile(current.launch.executionId),
-        } : {}),
-        ...(completed && typeof responsePath === "string" && responsePath.trim() ? { responsePath } : {}),
-        ...(completed && typeof artifactId === "string" && RESPONSE_ARTIFACT_ID_RE.test(artifactId) ? { artifactId } : {}),
-    };
-}
-export async function waitForProjection(input) {
-    const now = input.now ?? Date.now;
-    let pact;
-    try {
-        pact = readProjectionIdentity(input.projectionDirectory);
-    }
-    catch (error) {
-        return {
-            state: "unknown",
-            diagnostic: `projection identity could not be observed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    const deadline = input.deadlineMs
-        ?? (input.timeoutMs === undefined ? undefined : now() + input.timeoutMs);
-    const wakeProjection = input.wakeProjection ?? ((directory, id) => tellProjection(directory, id));
-    const readContinuationSnapshot = input.readContinuationSnapshot ?? readProjectionGenerationContinuationSnapshot;
-    let wakeAttempted = false;
-    for (;;) {
-        input.signal?.throwIfAborted();
-        const observedAtMs = now();
-        const continuation = readContinuationSnapshot(input.projectionDirectory, 10);
-        const current = continuation.current;
-        const observation = observeProjectionLifeSnapshot(input.projectionDirectory, {
-            nowMs: observedAtMs,
-        });
-        if (observation.compatibility === "incompatible") {
-            return { state: "unknown", diagnostic: observation.diagnostic };
-        }
-        if ((observation.records?.at(-1)?.seq ?? 0) !== continuation.generationSequence) {
-            continue;
-        }
-        const life = observation.life;
-        if (!wakeAttempted
-            && current
-            && life.phase !== "active"
-            && life.phase !== "minting"
-            && life.phase !== "quiescent"
-            && life.phase !== "unknown"
-            && continuation.requiresWake) {
-            wakeAttempted = true;
-            try {
-                const wakeState = await wakeProjection(input.projectionDirectory, `${pact.akuma}/${path.basename(input.projectionDirectory)}`);
-                if (wakeState === "active" || wakeState === "woken")
-                    continue;
-            }
-            catch (error) {
-                if (!(error instanceof FlowError) || error.code !== "PROJECTION_WAKE_FAILED")
-                    throw error;
-                // The wake path persisted any launch/adoption failure. Refresh once so
-                // this invocation reports that typed truth without retrying in a loop.
-                continue;
-            }
-        }
-        const verdict = current ? verdictFromCurrent(current, observedAtMs) : undefined;
-        const terminal = verdict !== undefined;
-        const terminalAtMs = verdict === undefined ? undefined : Date.parse(verdict.at);
-        const terminalWithinDeadline = terminal && (deadline === undefined
-            || (typeof terminalAtMs === "number" && Number.isFinite(terminalAtMs) && terminalAtMs < deadline));
-        const runnerDiedWithoutVerdict = verdict === undefined && life.phase === "lost";
-        if (terminalWithinDeadline
-            || runnerDiedWithoutVerdict
-            || (deadline !== undefined && observedAtMs >= deadline)) {
-            const revalidated = readContinuationSnapshot(input.projectionDirectory, 10);
-            if (revalidated.generationSequence !== continuation.generationSequence)
-                continue;
-            const stored = current
-                ? readGenerationEvents(input.projectionDirectory, current.launch.executionId)
-                : [];
-            const { events, malformed } = selectValidStoredAgentEvents(stored);
-            const snapshot = buildSnapshot({
-                projectionDirectory: input.projectionDirectory,
-                pact,
-                phase: life.phase,
-                current,
-                events,
-                malformedEvents: malformed,
-                nowMs: observedAtMs,
-                tells: revalidated.tells,
-            });
-            if (terminalWithinDeadline && current) {
-                const text = outcomeText(current);
-                return {
-                    state: "terminal",
-                    pact,
-                    verdict,
-                    snapshot,
-                    ...(text ? { outcomeText: text } : {}),
-                };
-            }
-            if (runnerDiedWithoutVerdict) {
-                return { state: "lost", pact, snapshot };
-            }
-            return {
-                state: "timeout",
-                pact,
-                snapshot,
-                ...(terminal ? { terminalSnapshot: true } : {}),
-            };
-        }
-        const waitMs = deadline === undefined
-            ? WAIT_POLL_MS
-            : Math.max(0, Math.min(WAIT_POLL_MS, deadline - observedAtMs));
-        await sleep(waitMs);
-    }
-}
-/**
- * Observe a fixed projection set. Admission owns the set snapshot; this reader
- * never discovers or adds a projection while it is waiting.
- */
-export async function waitForProjectionSet(input) {
-    const controller = new AbortController();
-    const abort = () => controller.abort(input.signal?.reason);
-    if (input.signal?.aborted)
-        abort();
-    input.signal?.addEventListener("abort", abort, { once: true });
-    // Admission order is provenance. Presentation applies its own operational
-    // triage ordering after this fixed set has been observed.
-    const members = [...input.projections];
-    const now = input.now ?? Date.now;
-    const deadlineMs = input.timeoutMs === undefined ? undefined : now() + input.timeoutMs;
-    try {
-        const waits = members.map((member, index) => waitForProjection({
-            projectionDirectory: member.projectionDirectory,
-            ...(deadlineMs === undefined ? {} : { deadlineMs }),
-            now,
-            signal: controller.signal,
-        }).then((result) => ({ index, member, result }), (error) => ({ index, member, error })));
-        const memberResult = (member, result) => ({
-            id: member.id,
-            ...(member.inputToken ? { inputToken: member.inputToken } : {}),
-            ...(member.alias ? { alias: member.alias } : {}),
-            result,
-        });
-        if (input.selection === "all") {
-            const settled = await Promise.all(waits);
-            for (const item of settled) {
-                if ("error" in item)
-                    throw item.error;
-            }
-            return {
-                selection: "all",
-                results: settled.map((item) => {
-                    const value = item;
-                    return memberResult(value.member, value.result);
-                }),
-            };
-        }
-        const pending = new Set(waits.keys());
-        const observed = new Map();
-        while (pending.size > 0) {
-            const next = await Promise.race([...pending].map((index) => waits[index]));
-            pending.delete(next.index);
-            if ("error" in next)
-                throw next.error;
-            if (next.result.state === "terminal") {
-                observed.set(next.index, next.result);
-                controller.abort();
-                // A winner ends the waiting condition, not the admitted read set. Let
-                // in-flight readers unwind, then take one immediate read-only snapshot
-                // of every member under a shared cutoff.
-                await Promise.all(waits);
-                const snapshotDeadlineMs = now();
-                const snapshots = await Promise.all(members.map(async (member, index) => memberResult(member, observed.get(index) ?? await waitForProjection({
-                    projectionDirectory: member.projectionDirectory,
-                    deadlineMs: snapshotDeadlineMs,
-                    now,
-                }))));
-                return { selection: "any", selectedId: next.member.id, results: snapshots };
-            }
-            observed.set(next.index, next.result);
-        }
-        return {
-            selection: "any",
-            results: members.map((member, index) => memberResult(member, observed.get(index))),
-        };
-    }
-    finally {
-        input.signal?.removeEventListener("abort", abort);
-    }
-}

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

@@ -1,298 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { parseResolvedAkumaLaunchSnapshot } from "../../agents/launch-snapshot/model.js";
-import { isRecoverableSessionEnvelope } from "../../agents/harness/index.js";
-import { ProjectionStateError } from "../atomic-publish.js";
-import { applyContinuationEffort, readProjectionGenerationContinuationSnapshot, } from "./generation/projection-generation-continuation.js";
-import { createProjectionExecutionId } from "./generation/projection-generation-identity.js";
-import { startProjectionGeneration } from "./generation/projection-generation-launcher.js";
-import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
-import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { acquireRunnerLease, acquireRunnerLostProof, RunnerLeaseUnavailableError, } from "../run-control/runner-lease.js";
-import { projectionRunnerLeasePath } from "./generation/projection-generation-identity.js";
-import { setTimeout as delay } from "node:timers/promises";
-const PROJECTION_WAKE_POLL_MS = 20;
-function incompatibleProjectionError(projectionId) {
-    const subject = projectionId ? `Projection '${projectionId}'` : "Projection";
-    const statusCoordinate = projectionId ?? "<projection-id>";
-    return new FlowError("PROJECTION_INCOMPATIBLE", `${subject} has incompatible historical storage; inspect it with keiyaku status ${statusCoordinate}, 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(),
-    });
-    if (observation.compatibility === "incompatible")
-        throw incompatibleProjectionError();
-}
-function readCurrentGeneration(projectionDirectory) {
-    const store = openProjectionGenerationStoreReadOnly(projectionDirectory);
-    try {
-        return store.readCurrentGeneration();
-    }
-    finally {
-        store.close();
-    }
-}
-function successorFacts(current, snapshot, nowMs, requireContinuation) {
-    const verdictFacts = current.verdict?.facts;
-    const originalInputs = current.launch.facts.inputs;
-    const inputs = originalInputs
-        && typeof originalInputs === "object"
-        && !Array.isArray(originalInputs)
-        ? originalInputs
-        : {};
-    const session = verdictFacts?.session ?? inputs.session;
-    const launchSnapshot = parseResolvedAkumaLaunchSnapshot(inputs.launchSnapshot);
-    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.");
-    }
-    const { sourceArtifactId: _sourceArtifactId, ...inheritedInputs } = inputs;
-    const resumePath = typeof verdictFacts?.responsePath === "string"
-        ? verdictFacts.responsePath
-        : typeof inputs.resumePath === "string"
-            ? inputs.resumePath
-            : undefined;
-    const continuedInputs = {
-        ...inheritedInputs,
-        ...(recoverableSession ? {
-            session,
-            ...(resumePath ? { resumePath } : {}),
-        } : {}),
-    };
-    const { tellFence: _oldFence, ...inherited } = current.launch.facts;
-    return {
-        ...inherited,
-        createdAt: new Date(nowMs).toISOString(),
-        launchedBy: "tell-wake",
-        parentExecutionId: current.launch.executionId,
-        tellFence: snapshot.tellIds,
-        inputs: applyContinuationEffort(continuedInputs, snapshot.effort),
-    };
-}
-export function assertTellEffortSupported(projectionDirectory, effort) {
-    if (!effort)
-        return;
-    const current = readCurrentGeneration(projectionDirectory);
-    if (!current)
-        throw new ProjectionStateError("projection has no immutable generation launch");
-    const inputs = current.launch.facts.inputs;
-    if (!inputs || typeof inputs !== "object" || Array.isArray(inputs)) {
-        throw new ProjectionStateError("generation launch inputs are missing");
-    }
-    let launchSnapshot;
-    try {
-        launchSnapshot = parseResolvedAkumaLaunchSnapshot(inputs.launchSnapshot);
-    }
-    catch (error) {
-        throw new ProjectionStateError("generation launch has an invalid immutable launchSnapshot", { cause: error });
-    }
-    if (launchSnapshot.akuma.model === undefined) {
-        throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${effort}' requires an explicit model.`);
-    }
-    const effortOptions = launchSnapshot.akuma.effortOptions;
-    if (effortOptions === undefined)
-        return;
-    if (!effortOptions.includes(effort)) {
-        throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${effort}' is not permitted; legal values: ${effortOptions.join(", ")}.`);
-    }
-}
-async function startCommittedSuccessor(projectionDirectory, projectionId, executionId, startGeneration, dependencies = {}) {
-    let started;
-    try {
-        started = await startGeneration(projectionDirectory, executionId, dependencies);
-    }
-    finally {
-        dependencies.launchOwnership?.close();
-    }
-    if (started.status === "adopted")
-        return "woken";
-    if (started.status === "pending")
-        return "pending";
-    const reconciled = readCurrentGeneration(projectionDirectory);
-    if (reconciled?.launch.executionId === executionId && reconciled.adoption)
-        return "woken";
-    if (reconciled && !reconciled.verdict && reconciled.launch.executionId !== executionId) {
-        return reconciled.adoption ? "active" : "pending";
-    }
-    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,
-            cause: started.cause,
-            tellRetained: true,
-        },
-    });
-}
-function sessionWakeFailure(projectionId, cause) {
-    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",
-            projectionId,
-            cause: "session_unrecoverable",
-            tellRetained: true,
-        },
-    });
-}
-export function persistInterruptWakeFailure(projectionDirectory, error, nowMs = Date.now()) {
-    if (!(error instanceof FlowError)
-        || error.code !== "PROJECTION_WAKE_FAILED"
-        || error.facts?.kind !== "projection_wake_failure")
-        return;
-    const continuation = readProjectionGenerationContinuationSnapshot(projectionDirectory, 10);
-    const current = continuation.current;
-    if (current?.verdict?.facts.state !== "interrupted" || !continuation.requiresWake)
-        return;
-    const successorExecutionId = createProjectionExecutionId(nowMs);
-    const facts = successorFacts(current, continuation.successor, nowMs, false);
-    const store = openProjectionGenerationStore(projectionDirectory);
-    try {
-        store.failInterruptWakeIfSettled({
-            predecessorExecutionId: current.launch.executionId,
-            successorExecutionId,
-            successorFacts: facts,
-            cause: error.facts.cause,
-            terminalAt: new Date(nowMs).toISOString(),
-        });
-    }
-    finally {
-        store.close();
-    }
-}
-export async function tellProjection(projectionDirectory, projectionId, effort, dependencies = {}) {
-    const startGeneration = dependencies.startGeneration ?? startProjectionGeneration;
-    const sleep = dependencies.sleep ?? ((milliseconds) => delay(milliseconds));
-    for (;;) {
-        const nowMs = Date.now();
-        const observation = observeProjectionLifeSnapshot(projectionDirectory, {
-            nowMs,
-        });
-        if (observation.compatibility === "incompatible") {
-            throw incompatibleProjectionError(projectionId);
-        }
-        const life = observation.life;
-        if (life.phase === "active")
-            return "active";
-        if (life.phase === "minting" || life.phase === "quiescent") {
-            await sleep(PROJECTION_WAKE_POLL_MS);
-            continue;
-        }
-        if (life.phase === "unknown") {
-            return "pending";
-        }
-        const continuation = readProjectionGenerationContinuationSnapshot(projectionDirectory, 10);
-        const current = continuation.current;
-        if (!current)
-            return "pending";
-        if (current.killIntent && !current.verdict)
-            return "pending";
-        if (!continuation.requiresWake)
-            return "pending";
-        const snapshot = continuation.successor;
-        const successorExecutionId = createProjectionExecutionId(nowMs);
-        let facts;
-        try {
-            facts = successorFacts(current, { ...snapshot, ...(effort ? { effort } : {}) }, nowMs, current.adoption !== undefined);
-        }
-        catch (error) {
-            if (error instanceof FlowError && error.code === "PROJECTION_WAKE_FAILED") {
-                throw sessionWakeFailure(projectionId, error);
-            }
-            throw error;
-        }
-        const store = openProjectionGenerationStore(projectionDirectory);
-        try {
-            if (life.phase === "lost" && !current.verdict) {
-                let deathEvidence;
-                try {
-                    deathEvidence = acquireRunnerLostProof(projectionRunnerLeasePath(projectionDirectory));
-                }
-                catch (error) {
-                    if (error instanceof RunnerLeaseUnavailableError)
-                        return "active";
-                    return "pending";
-                }
-                try {
-                    store.beginWriteTransaction();
-                    const protectedCurrent = store.readCurrentGeneration();
-                    if (protectedCurrent?.launch.executionId !== current.launch.executionId
-                        || protectedCurrent.verdict) {
-                        store.rollbackWriteTransaction();
-                        return "pending";
-                    }
-                    const terminalAt = new Date(nowMs).toISOString();
-                    if (protectedCurrent.killIntent) {
-                        const settled = store.settleKillIfRunnerDead({
-                            executionId: current.launch.executionId,
-                            releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
-                            terminalAt,
-                        });
-                        if (settled.status === "committed")
-                            store.commitWriteTransaction();
-                        else
-                            store.rollbackWriteTransaction();
-                        return "pending";
-                    }
-                    const currentWasAdopted = protectedCurrent.adoption !== undefined;
-                    deathEvidence.close();
-                    let launchOwnership;
-                    try {
-                        launchOwnership = acquireRunnerLease(projectionRunnerLeasePath(projectionDirectory));
-                    }
-                    catch (error) {
-                        store.rollbackWriteTransaction();
-                        if (error instanceof RunnerLeaseUnavailableError)
-                            return "active";
-                        return "pending";
-                    }
-                    return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration, {
-                        commitLaunch: () => {
-                            const transition = currentWasAdopted
-                                ? store.replaceDeadRunner({
-                                    executionId: current.launch.executionId,
-                                    releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
-                                    successorExecutionId,
-                                    successorFacts: facts,
-                                    terminalAt,
-                                })
-                                : store.supersedeStartupTimeout({
-                                    executionId: current.launch.executionId,
-                                    releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
-                                    diagnostic: { detail: "startup owner died before adoption" },
-                                    successorExecutionId,
-                                    successorFacts: facts,
-                                    terminalAt,
-                                });
-                            if (transition.status === "committed")
-                                store.commitWriteTransaction();
-                            else
-                                store.rollbackWriteTransaction();
-                            return transition.status === "committed";
-                        },
-                        launchOwnership,
-                    });
-                }
-                finally {
-                    store.rollbackWriteTransaction();
-                    deathEvidence.close();
-                }
-            }
-            if (!["done", "failed", "lost", "dismissed", "killed"].includes(life.phase)) {
-                return "pending";
-            }
-            return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration, {
-                commitLaunch: () => store.launchIfSettled({
-                    executionId: successorExecutionId,
-                    facts,
-                }).status === "committed",
-            });
-        }
-        finally {
-            store.close();
-        }
-    }
-}