@astrosheep/keiyaku 2.9.12 → 2.9.13

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

@@ -5,7 +5,6 @@ import { isProjectionId, projectionRoot, projectionRootAtCoordinate } from "./pr
 import { projectionAliasRootAtCoordinate, readProjectionAliasAtRoot, } from "./projection-alias.js";
 import { resolveProjectionCoordinate } from "./projection-coordinate.js";
 import { readProjectionIdentity } from "./projection-identity.js";
-import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./generation/projection-generation-launcher.js";
 import { observeProjectionLifeSnapshot, } from "./projection-life-observer.js";
 import { worktreeContainsCoordinate } from "../worktree-path.js";
 import { readProjectionRow, readProjectionSummary } from "./projection-status-observation.js";
@@ -75,6 +74,104 @@ export function prioritizeProjectionStatusRows(rows) {
     const total = Object.values(byState).reduce((sum, count) => sum + count, 0);
     return total > 0 ? { rows: visible, omitted: { total, byState } } : { rows: visible };
 }
+const TRIAGE_UNKNOWN_LIMIT = 8;
+const TRIAGE_ACTIVE_LIMIT = 8;
+const TRIAGE_RECENT_TERMINAL_LIMIT = 3;
+function isTerminalVerdictState(state) {
+    return state === "failed"
+        || state === "dead"
+        || state === "done"
+        || state === "killed"
+        || state === "dismissed"
+        || state === "incompatible";
+}
+function isUnknownRow(row) {
+    return row.state === "lost" || row.state === "unknown";
+}
+function isStartupFailedRow(row) {
+    return row.state === "startup-timeout";
+}
+function isActiveRow(row) {
+    return row.state === "minting" || row.state === "out";
+}
+/**
+ * Main status is a bounded lifecycle summary, not a second roster. Keep
+ * category limits here so JSON and the human renderer receive the same rows.
+ */
+export function triageProjectionStatusRows(rows) {
+    if (rows.length === 0)
+        return { rows: [] };
+    const ordered = [...rows].sort(compareProjectionStatusRows);
+    const startupFailedRows = ordered.filter(isStartupFailedRow);
+    const unknownRows = ordered.filter(isUnknownRow);
+    const activeRows = ordered.filter(isActiveRow);
+    const terminalRows = ordered.filter((row) => isTerminalVerdictState(row.state));
+    const boundedObservationFailures = ordered
+        .filter((row) => isStartupFailedRow(row) || isUnknownRow(row))
+        .slice(0, TRIAGE_UNKNOWN_LIMIT);
+    const startupFailed = boundedObservationFailures.filter(isStartupFailedRow);
+    const unknown = boundedObservationFailures.filter(isUnknownRow);
+    const selected = new Set(boundedObservationFailures.map((row) => row.id));
+    const active = ordered.filter((row) => !selected.has(row.id) && isActiveRow(row)).slice(0, TRIAGE_ACTIVE_LIMIT);
+    active.forEach((row) => selected.add(row.id));
+    const recentTerminal = ordered
+        .filter((row) => !selected.has(row.id) && isTerminalVerdictState(row.state))
+        .slice(0, TRIAGE_RECENT_TERMINAL_LIMIT);
+    recentTerminal.forEach((row) => selected.add(row.id));
+    const omittedRows = ordered.filter((row) => !selected.has(row.id));
+    const byState = {
+        failed: 0, dead: 0, done: 0, killed: 0, dismissed: 0, incompatible: 0,
+    };
+    for (const row of omittedRows) {
+        if (isOmissibleProjectionStatusState(row.state))
+            byState[row.state] += 1;
+    }
+    const omittedTerminalTotal = Object.values(byState).reduce((sum, count) => sum + count, 0);
+    return {
+        rows: [...startupFailed, ...unknown, ...active, ...recentTerminal],
+        triage: {
+            startupFailed,
+            unknown,
+            active,
+            recentTerminal,
+            totals: {
+                startupFailed: startupFailedRows.length,
+                unknown: unknownRows.length,
+                active: activeRows.length,
+                terminal: terminalRows.length,
+            },
+            overflow: omittedRows.length,
+        },
+        ...(omittedTerminalTotal > 0 ? { omitted: { total: omittedTerminalTotal, byState } } : {}),
+    };
+}
+/** Terminal history is pageable; active observations stay complete. */
+export function paginateProjectionStatusRoster(board, input) {
+    const limit = input.limit ?? 20;
+    const offset = input.offset ?? 0;
+    const nonterminal = board.rows.filter((row) => !isTerminalVerdictState(row.state));
+    const terminal = board.rows.filter((row) => isTerminalVerdictState(row.state));
+    const selectedTerminal = terminal.slice(offset, offset + limit);
+    const omittedRows = [...terminal.slice(0, offset), ...terminal.slice(offset + limit)];
+    const byState = {
+        failed: 0, dead: 0, done: 0, killed: 0, dismissed: 0, incompatible: 0,
+    };
+    for (const row of omittedRows) {
+        if (isOmissibleProjectionStatusState(row.state))
+            byState[row.state] += 1;
+    }
+    return {
+        rows: [...nonterminal, ...selectedTerminal],
+        ...(omittedRows.length > 0 ? { omitted: { total: omittedRows.length, byState } } : {}),
+        pagination: {
+            limit,
+            offset,
+            returned: selectedTerminal.length,
+            total: terminal.length,
+            hasMore: offset + selectedTerminal.length < terminal.length,
+        },
+    };
+}
 export function requiresProjectionStatusDetails(state) {
     return !isOmissibleProjectionStatusState(state);
 }
@@ -161,7 +258,29 @@ export async function readOperationalProjectionStatusBoard(cwd, nowMs) {
     const rows = summaries.map((summary) => readProjectionRow(summary, nowMs, requiresProjectionStatusDetails(summary.state)));
     // A published root is an observable surface even when it currently has no
     // rows. The caller must distinguish that fact from an unavailable root.
-    return prioritizeProjectionStatusRows(rows);
+    return triageProjectionStatusRows(rows);
+}
+/** Full roster read. The main board applies triage separately; this surface never caps stored projections. */
+export async function readProjectionRosterStatusBoard(cwd, nowMs) {
+    const coordinate = await resolveProjectionCoordinate(cwd);
+    const topology = readProjectionRootTopology(coordinate);
+    if (!topology)
+        return null;
+    const aliases = await readProjectionStatusAliases(projectionAliasRootAtCoordinate(coordinate));
+    const summaries = [];
+    for (const akuma of topology.akumas) {
+        if (akuma.startsWith("."))
+            continue;
+        const scoped = readAkumaProjectionStatusSummaries(topology.root, akuma, aliases, nowMs);
+        if (scoped === null)
+            return null;
+        summaries.push(...scoped);
+    }
+    return {
+        rows: summaries
+            .map((summary) => readProjectionRow(summary, nowMs, requiresProjectionStatusDetails(summary.state)))
+            .sort(compareProjectionStatusRows),
+    };
 }
 export async function readExactProjectionStatus(cwd, nowMs, projectionId) {
     if (!isProjectionId(projectionId))
@@ -191,6 +310,36 @@ export async function readExactProjectionStatus(cwd, nowMs, projectionId) {
     const aliases = await readProjectionStatusAliases(projectionAliasRootAtCoordinate(coordinate));
     return readProjectionRow(readProjectionSummary(dir, projectionId, aliases.get(projectionId), nowMs), nowMs, true);
 }
+/** Shared bounded selector for human and structured status consumers. */
+export async function selectProjectionStatus(cwd, nowMs, input) {
+    if (input.kind === "operational")
+        return { input, board: await readOperationalProjectionStatusBoard(cwd, nowMs) };
+    const coordinate = await resolveProjectionCoordinate(cwd);
+    const canonicalId = isProjectionId(input.token)
+        ? input.token
+        : await readProjectionAliasAtRoot(projectionAliasRootAtCoordinate(coordinate), input.token);
+    if (!canonicalId)
+        return { input, board: null };
+    const row = await readExactProjectionStatus(cwd, nowMs, canonicalId);
+    if (!row)
+        return { input, board: null };
+    const aliasMovedTo = input.token === canonicalId
+        ? undefined
+        : await readProjectionAliasAtRoot(projectionAliasRootAtCoordinate(coordinate), input.token);
+    return {
+        input,
+        board: {
+            rows: [{
+                    ...row,
+                    addressedBy: {
+                        token: input.token,
+                        kind: input.token === canonicalId ? "canonical" : "alias",
+                        ...(aliasMovedTo && aliasMovedTo !== canonicalId ? { aliasMovedTo } : {}),
+                    },
+                }],
+        },
+    };
+}
 export async function readAkumaNonterminalProjectionStatus(cwd, nowMs, akuma) {
     if (!isProjectionId(`${akuma}/00000000`))
         return null;
@@ -278,14 +427,12 @@ export async function hasStrandableProjectionGeneration(input) {
             }
             const observation = observeProjectionLifeSnapshot(projectionDir, {
                 nowMs: input.nowMs,
-                startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
             });
             if (observation.compatibility !== "current")
                 continue;
             const phase = observation.life.phase;
             if (phase === "active"
                 || phase === "minting"
-                || phase === "startup-timeout"
                 || phase === "unknown") {
                 return true;
             }

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

@@ -6,9 +6,7 @@ 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 { PROJECTION_ADOPTION_TIMEOUT_MS } from "./generation/projection-generation-launcher.js";
 import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { deriveProjectionLife } from "./projection-life-protocol.js";
 import { readProjectionGenerationContinuationSnapshot, } from "./generation/projection-generation-continuation.js";
 import { projectTerminalFailure, } from "./projection-terminal-failure.js";
 import { invalidActivityEventDiagnostic, selectValidStoredAgentEvents, } from "../stored-agent-event.js";
@@ -179,26 +177,16 @@ export async function waitForProjection(input) {
         const observedAtMs = now();
         const continuation = readContinuationSnapshot(input.projectionDirectory, 10);
         const current = continuation.current;
-        let life = deriveProjectionLife({
-            records: continuation.records,
+        const observation = observeProjectionLifeSnapshot(input.projectionDirectory, {
             nowMs: observedAtMs,
-            startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
         });
-        if (current && !current.verdict && current.adoption) {
-            const observation = observeProjectionLifeSnapshot(input.projectionDirectory, {
-                nowMs: observedAtMs,
-                startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
-            });
-            if (observation.compatibility === "incompatible") {
-                life = { phase: "unknown", diagnostic: observation.diagnostic };
-            }
-            else if ((observation.records?.at(-1)?.seq ?? 0) !== continuation.generationSequence) {
-                continue;
-            }
-            else {
-                life = observation.life;
-            }
+        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"
@@ -225,7 +213,10 @@ export async function waitForProjection(input) {
         const terminalAtMs = verdict === undefined ? undefined : Date.parse(verdict.at);
         const terminalWithinDeadline = terminal && (deadline === undefined
             || (typeof terminalAtMs === "number" && Number.isFinite(terminalAtMs) && terminalAtMs < deadline));
-        if (terminalWithinDeadline || (deadline !== undefined && observedAtMs >= 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;
@@ -253,6 +244,9 @@ export async function waitForProjection(input) {
                     ...(text ? { outcomeText: text } : {}),
                 };
             }
+            if (runnerDiedWithoutVerdict) {
+                return { state: "lost", pact, snapshot };
+            }
             return {
                 state: "timeout",
                 pact,
@@ -276,7 +270,9 @@ export async function waitForProjectionSet(input) {
     if (input.signal?.aborted)
         abort();
     input.signal?.addEventListener("abort", abort, { once: true });
-    const members = [...input.projections].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    // 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 {
@@ -285,7 +281,13 @@ export async function waitForProjectionSet(input) {
             ...(deadlineMs === undefined ? {} : { deadlineMs }),
             now,
             signal: controller.signal,
-        }).then((result) => ({ index, id: member.id, result }), (error) => ({ index, id: member.id, error })));
+        }).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) {
@@ -294,23 +296,40 @@ export async function waitForProjectionSet(input) {
             }
             return {
                 selection: "all",
-                results: settled.map((item) => ({ id: item.id, result: item.result })),
+                results: settled.map((item) => {
+                    const value = item;
+                    return memberResult(value.member, value.result);
+                }),
             };
         }
         const pending = new Set(waits.keys());
-        const observed = [];
+        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();
-                return { selection: "any", selectedId: next.id, results: [{ id: next.id, result: next.result }] };
+                // 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.push({ id: next.id, result: next.result });
+            observed.set(next.index, next.result);
         }
-        return { selection: "any", results: observed.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0) };
+        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

@@ -4,11 +4,13 @@ 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 { PROJECTION_ADOPTION_POLL_MS, PROJECTION_ADOPTION_TIMEOUT_MS, startProjectionGeneration, } from "./generation/projection-generation-launcher.js";
+import { startProjectionGeneration } from "./generation/projection-generation-launcher.js";
 import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
 import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { acquireProjectionRunnerLock, acquireProjectionRunnerSettlementLock, ProjectionRunnerLockUnavailableError, } from "./projection-runner-lock.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>";
@@ -21,7 +23,6 @@ function incompatibleProjectionError(projectionId) {
 export function assertProjectionTellable(projectionDirectory) {
     const observation = observeProjectionLifeSnapshot(projectionDirectory, {
         nowMs: Date.now(),
-        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
     });
     if (observation.compatibility === "incompatible")
         throw incompatibleProjectionError();
@@ -165,12 +166,10 @@ export function persistInterruptWakeFailure(projectionDirectory, error, nowMs =
 export async function tellProjection(projectionDirectory, projectionId, effort, dependencies = {}) {
     const startGeneration = dependencies.startGeneration ?? startProjectionGeneration;
     const sleep = dependencies.sleep ?? ((milliseconds) => delay(milliseconds));
-    const observationStartedAt = Date.now();
     for (;;) {
         const nowMs = Date.now();
         const observation = observeProjectionLifeSnapshot(projectionDirectory, {
             nowMs,
-            startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
         });
         if (observation.compatibility === "incompatible") {
             throw incompatibleProjectionError(projectionId);
@@ -179,10 +178,7 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
         if (life.phase === "active")
             return "active";
         if (life.phase === "minting" || life.phase === "quiescent") {
-            if (life.phase === "quiescent" && nowMs - observationStartedAt >= PROJECTION_ADOPTION_TIMEOUT_MS) {
-                throw sessionWakeFailure(projectionId, new Error("projection has no generation continuation"));
-            }
-            await sleep(PROJECTION_ADOPTION_POLL_MS);
+            await sleep(PROJECTION_WAKE_POLL_MS);
             continue;
         }
         if (life.phase === "unknown") {
@@ -200,7 +196,7 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
         const successorExecutionId = createProjectionExecutionId(nowMs);
         let facts;
         try {
-            facts = successorFacts(current, { ...snapshot, ...(effort ? { effort } : {}) }, nowMs, life.phase !== "startup-timeout");
+            facts = successorFacts(current, { ...snapshot, ...(effort ? { effort } : {}) }, nowMs, current.adoption !== undefined);
         }
         catch (error) {
             if (error instanceof FlowError && error.code === "PROJECTION_WAKE_FAILED") {
@@ -210,80 +206,13 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
         }
         const store = openProjectionGenerationStore(projectionDirectory);
         try {
-            if (life.phase === "startup-timeout") {
-                const terminalAt = new Date(nowMs).toISOString();
-                let deathEvidence;
-                try {
-                    deathEvidence = acquireProjectionRunnerSettlementLock(projectionDirectory);
-                }
-                catch (error) {
-                    if (error instanceof ProjectionRunnerLockUnavailableError)
-                        return "pending";
-                    return "pending";
-                }
-                try {
-                    store.beginWriteTransaction();
-                    const protectedCurrent = store.readCurrentGeneration();
-                    if (protectedCurrent?.launch.executionId !== current.launch.executionId
-                        || protectedCurrent.adoption
-                        || protectedCurrent.verdict) {
-                        store.rollbackWriteTransaction();
-                        return "pending";
-                    }
-                    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";
-                    }
-                    deathEvidence.close();
-                    let launchOwnership;
-                    try {
-                        launchOwnership = acquireProjectionRunnerLock(projectionDirectory);
-                    }
-                    catch (error) {
-                        store.rollbackWriteTransaction();
-                        if (error instanceof ProjectionRunnerLockUnavailableError)
-                            return "pending";
-                        return "pending";
-                    }
-                    return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration, {
-                        commitLaunch: () => {
-                            const transition = store.supersedeStartupTimeout({
-                                executionId: current.launch.executionId,
-                                releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
-                                diagnostic: { detail: "runner did not adopt before startup timeout" },
-                                successorExecutionId,
-                                successorFacts: facts,
-                                terminalAt,
-                            });
-                            if (transition.status === "committed")
-                                store.commitWriteTransaction();
-                            else
-                                store.rollbackWriteTransaction();
-                            return transition.status === "committed";
-                        },
-                        launchOwnership,
-                    });
-                }
-                finally {
-                    store.rollbackWriteTransaction();
-                    deathEvidence.close();
-                }
-            }
             if (life.phase === "lost" && !current.verdict) {
                 let deathEvidence;
                 try {
-                    deathEvidence = acquireProjectionRunnerSettlementLock(projectionDirectory);
+                    deathEvidence = acquireRunnerLostProof(projectionRunnerLeasePath(projectionDirectory));
                 }
                 catch (error) {
-                    if (error instanceof ProjectionRunnerLockUnavailableError)
+                    if (error instanceof RunnerLeaseUnavailableError)
                         return "active";
                     return "pending";
                 }
@@ -291,7 +220,6 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
                     store.beginWriteTransaction();
                     const protectedCurrent = store.readCurrentGeneration();
                     if (protectedCurrent?.launch.executionId !== current.launch.executionId
-                        || !protectedCurrent.adoption
                         || protectedCurrent.verdict) {
                         store.rollbackWriteTransaction();
                         return "pending";
@@ -309,26 +237,36 @@ export async function tellProjection(projectionDirectory, projectionId, effort,
                             store.rollbackWriteTransaction();
                         return "pending";
                     }
+                    const currentWasAdopted = protectedCurrent.adoption !== undefined;
                     deathEvidence.close();
                     let launchOwnership;
                     try {
-                        launchOwnership = acquireProjectionRunnerLock(projectionDirectory);
+                        launchOwnership = acquireRunnerLease(projectionRunnerLeasePath(projectionDirectory));
                     }
                     catch (error) {
                         store.rollbackWriteTransaction();
-                        if (error instanceof ProjectionRunnerLockUnavailableError)
+                        if (error instanceof RunnerLeaseUnavailableError)
                             return "active";
                         return "pending";
                     }
                     return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration, {
                         commitLaunch: () => {
-                            const transition = store.replaceDeadRunner({
-                                executionId: current.launch.executionId,
-                                releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
-                                successorExecutionId,
-                                successorFacts: facts,
-                                terminalAt,
-                            });
+                            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

package/build/core/projection/tell/launch-store.js

@@ -1,5 +1,5 @@
 import { ProjectionStateError } from "../../atomic-publish.js";
-import { withRead, withWrite } from "./database.js";
+import { withProjectionHeartRead as withRead, withProjectionHeartWrite as withWrite, } from "../generation/database.js";
 import { parseFence, requireExecutionId, submittedFromRow } from "./model.js";
 function selectTell(database, tellId) {
     return database.prepare(`

package/build/core/projection/tell/store.js

@@ -1,5 +1,5 @@
 import { ProjectionStateError, randomHex8 } from "../../atomic-publish.js";
-import { withRead, withReadSnapshot, withWrite } from "./database.js";
+import { withProjectionHeartRead as withRead, withProjectionHeartReadSnapshot as withReadSnapshot, withProjectionHeartWrite as withWrite, } from "../generation/database.js";
 import { assertTellIdRandomHex, originalFromRow, PENDING_PROJECTION_TELL_STATES, parseFence, requireExecutionId, submittedFromRow, } from "./model.js";
 export { bindTellLaunchReservation, claimAndReserveFencedTells, claimFencedTells, isTellLaunchAdmissionMember, listTellLaunchAdmissions, listTellLaunchBatch, markTellSubmitted, } from "./launch-store.js";
 function selectTell(database, tellId) {