@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/projection/index.js

@@ -5,17 +5,18 @@
  */
 export { heartPath } from "./heart.js";
 export { AGENT_ACTIVITY_WINDOW_SIZE, foldAgentActivity, } from "./projection-activity.js";
-export { assertProjectionAlias, isProjectionAlias, moveProjectionAlias, projectionAliasRoot, readProjectionAlias, } from "./projection-alias.js";
+export { assertProjectionAlias, isProjectionAlias, moveProjectionAlias, projectionAliasRoot, projectionAliasRootAtCoordinate, readProjectionAlias, readProjectionAliasAtRoot, } from "./projection-alias.js";
 export { resolveProjectionCoordinate } from "./projection-coordinate.js";
-export { appendGenerationEvent, executionEventsPath, isProjectionId, isPublishedProjection, isoFromNowMs, projectionDir, projectionRoot, readProjectionEvents, } from "./projection-core.js";
+export { appendGenerationEvent, executionEventsPath, isProjectionId, isPublishedProjection, isoFromNowMs, projectionDir, projectionDirAtCoordinate, projectionRoot, readProjectionEvents, readGenerationEventsWithRetention, } from "./projection-core.js";
 export { readProjectionIdentity } from "./projection-identity.js";
 export { interruptProjectionGeneration, killProjectionGeneration } from "./projection-kill.js";
 export { observeProjectionLife, observeProjectionLifeSnapshot, } from "./projection-life-observer.js";
 export { mintProjection, mintRepositoryProjection, ProjectionMintCollisionError, } from "./projection-mint.js";
 export { acquireProjectionRunnerLock, acquireProjectionRunnerSettlementLock, acquireProjectionRunnerTransferTarget, initializeProjectionRunnerLockDatabase, isProjectionRunnerLockPlatformSupported, observeProjectionRunnerLock, projectionRunnerLockPath, } from "./projection-runner-lock.js";
 export { hasStrandableProjectionGeneration, prioritizeProjectionStatusRows, readAkumaNonterminalProjectionStatus, readExactProjectionStatus, readOperationalProjectionStatusBoard, } from "./projection-status.js";
+export { PROJECTION_HISTORY_FILTER_COMPLETION, PROJECTION_HISTORY_FILTER_FIELDS, PROJECTION_HISTORY_FILTER_GRAMMAR, parseProjectionHistoryFilter, parseProjectionHistorySort, readProjectionHistoryAddress, readExactProjectionHistory, readProjectionHistory, resolveProjectionHistoryAddress, selectProjectionHistory, } from "./projection-history.js";
 export { projectTerminalFailure, } from "./projection-terminal-failure.js";
-export { snapshotCommissionProjectionIds, waitForProjection, waitForProjectionSet, } from "./projection-wait.js";
+export { snapshotCommissionProjectionIds, snapshotCommissionProjectionIdsAtCoordinate, waitForProjection, waitForProjectionSet, } from "./projection-wait.js";
 export { assertTellEffortSupported, assertProjectionTellable, tellProjection, } from "./projection-wake.js";
 export { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, ProjectionGenerationStore, } from "./generation/store.js";
 export { createProjectionExecutionId } from "./generation/projection-generation-identity.js";
@@ -24,4 +25,4 @@ export { projectionGenerationRunnerArgv, spawnProjectionGenerationRunner, } from
 export { runProjectionGeneration, } from "./generation/projection-generation-runner.js";
 export { executeProjectionGeneration, prepareProjectionGenerationExecution, } from "./generation/projection-generation-execution.js";
 export { runProjectionGenerationRuntime } from "./generation/projection-generation-runtime.js";
-export { claimFencedTells, claimTellToInflight, listTellIds, markTellConsumed, markTellSubmitted, readPendingTellWindow, readProjectionTellCounts, readTellOriginal, readTellSubmitted, writeInboxTell, } from "./tell/store.js";
+export { bindTellLaunchReservation, claimAndReserveFencedTells, claimFencedTells, claimTellToInflight, listTellLaunchBatch, listTellLaunchAdmissions, isTellLaunchAdmissionMember, listTellIds, markTellSubmitted, recordTellReceipt, recordTellReceiptCapabilities, readTellReceiptCapabilities, readPendingTellWindow, readProjectionTellCounts, readTellOriginal, readTellSubmitted, writeInboxTell, } from "./tell/store.js";

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

@@ -40,7 +40,7 @@ function sortEvents(events) {
         .map(({ event, order }) => ({ event, order }));
 }
 /** Fold the provider-neutral event ledger once into the bounded UI activity model. */
-export function foldAgentActivity(events) {
+export function foldAgentActivity(events, retentionOverride) {
     const sorted = sortEvents(events);
     const latestActivity = new Map();
     const firstActivityCall = new Map();
@@ -56,13 +56,19 @@ export function foldAgentActivity(events) {
     let latestPlan;
     let diagnostic;
     let failure;
+    let compacted = false;
     for (const indexed of sorted) {
         const event = indexed.event;
         switch (event.type) {
             case "message":
-                latestMessage.set(JSON.stringify([event.turn, event.id]), indexed);
+                {
+                    const key = JSON.stringify([event.turn, event.id]);
+                    compacted ||= latestMessage.has(key);
+                    latestMessage.set(key, indexed);
+                }
                 break;
             case "activity": {
+                compacted ||= latestActivity.has(event.id);
                 latestActivity.set(event.id, indexed);
                 if (event.phase !== "updated" && !firstActivityCall.has(event.id))
                     firstActivityCall.set(event.id, event.call);
@@ -80,6 +86,7 @@ export function foldAgentActivity(events) {
                 break;
             }
             case "thought": {
+                compacted ||= latestThought.has(event.id);
                 latestThought.set(event.id, indexed);
                 thoughtEventCount.set(event.id, (thoughtEventCount.get(event.id) ?? 0) + 1);
                 const at = eventTime(event.at);
@@ -88,13 +95,14 @@ export function foldAgentActivity(events) {
                 break;
             }
             case "warning": {
-                const identity = warningIdentity(event.warning);
+                const identity = `${event.historyExecutionId ?? ""}:${warningIdentity(event.warning)}`;
                 const prior = warnings.get(identity);
+                compacted ||= prior !== undefined;
                 warnings.set(identity, { latest: indexed, count: (prior?.count ?? 0) + 1 });
                 break;
             }
             case "usage":
-                usageByTurn.set(event.turn, event);
+                usageByTurn.set(event.historyTurnKey ?? String(event.turn), event);
                 break;
             case "plan":
                 latestPlan = indexed;
@@ -174,7 +182,7 @@ export function foldAgentActivity(events) {
             continue;
         }
         if (event.type === "warning") {
-            const aggregate = warnings.get(warningIdentity(event.warning));
+            const aggregate = warnings.get(`${event.historyExecutionId ?? ""}:${warningIdentity(event.warning)}`);
             if (aggregate?.latest !== indexed)
                 continue;
             settled.push({
@@ -189,7 +197,7 @@ export function foldAgentActivity(events) {
             continue;
         }
         if (event.type === "turn" && event.phase === "completed") {
-            const usage = usageByTurn.get(event.turn);
+            const usage = usageByTurn.get(event.historyTurnKey ?? String(event.turn));
             turns.push({
                 kind: "turn",
                 order: indexed.order,
@@ -211,11 +219,15 @@ export function foldAgentActivity(events) {
     settled.sort((left, right) => left.order - right.order);
     pinned.sort((left, right) => left.order - right.order);
     const window = settled.slice(-AGENT_ACTIVITY_WINDOW_SIZE);
+    const omittedSettledCount = Math.max(0, settled.length - window.length);
     const visibleOrders = [...window, ...pinned].map((row) => row.order);
     const relevantTurns = visibleOrders.length === 0
         ? turns.slice(-1)
         : turns.filter((row) => row.order >= Math.min(...visibleOrders));
     const timeline = [...window, ...relevantTurns, ...pinned].sort((left, right) => left.order - right.order);
+    const retainedTimeline = [...settled, ...turns, ...pinned].sort((left, right) => left.order - right.order);
+    const truncated = retainedTimeline.some((row) => (row.kind === "ran" || row.kind === "thought") && row.truncated);
+    const bounded = sorted.some(({ event }) => event.type === "truncation");
     let plan;
     if (latestPlan?.event.type === "plan") {
         const event = latestPlan.event;
@@ -232,8 +244,17 @@ export function foldAgentActivity(events) {
     }
     return {
         window,
+        omittedSettledCount,
         pinned,
         timeline,
+        retainedTimeline,
+        retention: {
+            state: retentionOverride ?? (bounded ? "bounded" : truncated ? "truncated" : compacted ? "compacted" : "complete"),
+            retainedCount: retainedTimeline.length,
+            range: retainedTimeline.length > 0
+                ? { first: retainedTimeline[0].order, last: retainedTimeline.at(-1).order }
+                : null,
+        },
         ledgerActivities,
         ledgerTurns: turns,
         ...(plan ? { plan } : {}),
@@ -246,7 +267,7 @@ export function foldAgentActivity(events) {
  * prose. Diagnostic and fail-event text remains available to artifact/internal
  * consumers through the full fold, but has no JSON or human projection path.
  */
-export function foldPublicProjectionActivity(events) {
-    const { diagnostic: _diagnostic, failure: _failure, ...activity } = foldAgentActivity(events);
+export function foldPublicProjectionActivity(events, retentionOverride) {
+    const { diagnostic: _diagnostic, failure: _failure, ...activity } = foldAgentActivity(events, retentionOverride);
     return activity;
 }

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

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { isErrnoException } from "../../errno.js";
 import { syncDirectorySync } from "../../fs/durability.js";
 import { ProjectionStateError, randomHex8 } from "../atomic-publish.js";
-import { projectionCoordinateRoot } from "./projection-coordinate.js";
+import { resolveProjectionCoordinate } from "./projection-coordinate.js";
 import { isProjectionId } from "./projection-core.js";
 export const PROJECTION_ALIAS_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 const MAX_ALIAS_REF_BYTES = 1024;
@@ -16,12 +16,18 @@ export function assertProjectionAlias(value) {
     }
     return value;
 }
+export function projectionAliasRootAtCoordinate(coordinate) {
+    return path.join(coordinate.physicalRoot, ".keiyaku", "projection-alias");
+}
 export async function projectionAliasRoot(cwd) {
-    return path.join(await projectionCoordinateRoot(cwd), ".keiyaku", "projection-alias");
+    return projectionAliasRootAtCoordinate(await resolveProjectionCoordinate(cwd));
 }
-export async function projectionAliasPath(cwd, alias) {
+function projectionAliasPathAtRoot(root, alias) {
     assertProjectionAlias(alias);
-    return path.join(await projectionAliasRoot(cwd), alias);
+    return path.join(root, alias);
+}
+export async function projectionAliasPath(cwd, alias) {
+    return projectionAliasPathAtRoot(await projectionAliasRoot(cwd), alias);
 }
 function invalidAliasRef(filePath) {
     return new ProjectionStateError(`invalid projection alias ref: ${filePath}`);
@@ -62,8 +68,8 @@ function readBoundedRegularAliasRef(filePath) {
     }
 }
 /** Undefined means no ref; malformed refs fail closed with their exact sidecar path. */
-export async function readProjectionAlias(cwd, alias) {
-    const filePath = await projectionAliasPath(cwd, alias);
+export async function readProjectionAliasAtRoot(root, alias) {
+    const filePath = projectionAliasPathAtRoot(root, alias);
     const content = readBoundedRegularAliasRef(filePath);
     if (content === undefined)
         return undefined;
@@ -74,15 +80,18 @@ export async function readProjectionAlias(cwd, alias) {
         throw invalidAliasRef(filePath);
     return id;
 }
+/** Cwd-facing compatibility entry point; multi-alias callers should reuse a resolved root. */
+export async function readProjectionAlias(cwd, alias) {
+    return readProjectionAliasAtRoot(await projectionAliasRoot(cwd), alias);
+}
 /** Atomically replace one alias ref. Aliases intentionally have no multi-ref transaction. */
-export async function moveProjectionAlias(cwd, alias, id) {
+async function moveProjectionAliasAtRoot(root, alias, id) {
     assertProjectionAlias(alias);
     if (!isProjectionId(id))
         throw new ProjectionStateError(`invalid projection id: ${id}`);
-    const previous = await readProjectionAlias(cwd, alias);
-    const root = await projectionAliasRoot(cwd);
+    const previous = await readProjectionAliasAtRoot(root, alias);
     fs.mkdirSync(root, { recursive: true });
-    const target = await projectionAliasPath(cwd, alias);
+    const target = projectionAliasPathAtRoot(root, alias);
     let temp;
     try {
         for (let attempt = 0; attempt < 16; attempt += 1) {
@@ -116,3 +125,7 @@ export async function moveProjectionAlias(cwd, alias, id) {
     }
     return previous;
 }
+/** Cwd-facing compatibility entry point; writers with a resolved root avoid rediscovery. */
+export async function moveProjectionAlias(cwd, alias, id) {
+    return moveProjectionAliasAtRoot(await projectionAliasRoot(cwd), alias, id);
+}

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

@@ -1,25 +1,35 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { isErrnoException } from "../../errno.js";
-import { projectionCoordinateRoot } from "./projection-coordinate.js";
+import { resolveProjectionCoordinate } from "./projection-coordinate.js";
 import { ProjectionStateError, } from "../atomic-publish.js";
 export { atomicPublishFile, ProjectionStateError, randomHex8 } from "../atomic-publish.js";
 export { isTellCausallyConsumed, } from "./tell/model.js";
-export { claimAllInbox, claimFencedTells, claimTellToInflight, listTellIds, markTellConsumed, markTellSubmitted, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./tell/store.js";
+export { bindTellLaunchReservation, claimAllInbox, claimAndReserveFencedTells, claimFencedTells, listTellLaunchBatch, listTellLaunchAdmissions, isTellLaunchAdmissionMember, claimTellToInflight, listTellIds, markTellSubmitted, recordTellReceiptCapabilities, recordTellReceipt, readTellReceiptCapabilities, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./tell/store.js";
 /** Relative segments for `.keiyaku/projection`. */
 export const PROJECTION_ROOT_SEGMENTS = [".keiyaku", "projection"];
 export const PROJECTION_ID_PATTERN = /^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*\/[0-9a-f]{8}$/;
 export function isProjectionId(value) {
     return PROJECTION_ID_PATTERN.test(value);
 }
+/** Derive one projection storage root from already-resolved repository authority. */
+export function projectionRootAtCoordinate(coordinate) {
+    return path.join(coordinate.physicalRoot, ...PROJECTION_ROOT_SEGMENTS);
+}
 export async function projectionRoot(cwd) {
-    return path.join(await projectionCoordinateRoot(cwd), ...PROJECTION_ROOT_SEGMENTS);
+    return projectionRootAtCoordinate(await resolveProjectionCoordinate(cwd));
 }
-export async function projectionDir(cwd, id) {
+/** Derive one projection directory from already-resolved repository authority. */
+export function projectionDirAtCoordinate(coordinate, id) {
     if (!isProjectionId(id))
         throw new ProjectionStateError(`invalid projection id: ${id}`);
     const [akuma, hex] = id.split("/");
-    return path.join(await projectionRoot(cwd), akuma, hex);
+    return path.join(projectionRootAtCoordinate(coordinate), akuma, hex);
+}
+export async function projectionDir(cwd, id) {
+    if (!isProjectionId(id))
+        throw new ProjectionStateError(`invalid projection id: ${id}`);
+    return projectionDirAtCoordinate(await resolveProjectionCoordinate(cwd), id);
 }
 export function encodeProjectionJson(value) {
     return `${JSON.stringify(value)}\n`;
@@ -59,13 +69,17 @@ export function appendGenerationEvent(projectionDirectory, executionId, event) {
  * Earlier complete lines remain strict ledger records.
  */
 export function readGenerationEvents(projectionDirectory, executionId) {
+    return readGenerationEventsWithRetention(projectionDirectory, executionId).events;
+}
+/** Distinguishes a deliberately empty ledger from an absent generation ledger. */
+export function readGenerationEventsWithRetention(projectionDirectory, executionId) {
     let content;
     try {
         content = fs.readFileSync(executionEventsPath(projectionDirectory, executionId), "utf8");
     }
     catch (error) {
         if (isErrnoException(error) && error.code === "ENOENT")
-            return [];
+            return { events: [], retention: "unavailable" };
         throw error;
     }
     const lines = content.split("\n");
@@ -83,7 +97,7 @@ export function readGenerationEvents(projectionDirectory, executionId) {
             // A concurrent append can leave only this final record incomplete.
         }
     }
-    return events;
+    return { events, retention: "available" };
 }
 export function readProjectionEvents(projectionDirectory) {
     let entries;

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

@@ -1,10 +1,11 @@
-import { claimAllInbox, listTellIds, markTellSubmitted, markTellConsumed, readTellSubmitted, readTellOriginal, isTellCausallyConsumed, appendGenerationEvent, } from "./projection-core.js";
+import { claimAllInbox, isTellLaunchAdmissionMember, listTellLaunchAdmissions, listTellIds, markTellSubmitted, bindTellLaunchReservation, recordTellReceiptCapabilities, recordTellReceipt, readTellSubmitted, readTellOriginal, isTellCausallyConsumed, appendGenerationEvent, } from "./projection-core.js";
 import { openProjectionTellObserver, } from "./tell/database.js";
 const LIVE_TELL_DELIVERY_THROTTLE_MS = 200;
 export function renderProjectionTellFrame(tellId, text) {
-    return `--- tell ${tellId} ---\n${text}`;
+    void tellId;
+    return text;
 }
-function submitEligible(projectionDirectory, executionId, control, requireInbox, submitting, submissions, excludedTellIds, observer, pendingCompletionEvidence) {
+function submitEligible(projectionDirectory, executionId, control, requireInbox, submitting, submissions, excludedTellIds, observer, pendingReceipts, pendingFenceReceipts) {
     if (requireInbox && !observer?.hasInbox())
         return;
     claimAllInbox(projectionDirectory);
@@ -27,27 +28,53 @@ function submitEligible(projectionDirectory, executionId, control, requireInbox,
             if (!ack)
                 throw new Error("provider enqueue resolved without TellSubmitAck");
             markTellSubmitted(projectionDirectory, tellId, { executionId, fence: ack.fence });
-            const pending = pendingCompletionEvidence.get(tellId);
-            if (!pending)
-                return;
-            for (const evidence of pending) {
-                if (isTellCausallyConsumed(ack.fence, evidence)) {
-                    markTellConsumed(projectionDirectory, tellId);
-                    break;
-                }
-            }
-            pendingCompletionEvidence.delete(tellId);
+            reconcileAcknowledgedTell(projectionDirectory, executionId, tellId, ack.fence, pendingReceipts, pendingFenceReceipts);
         })
             .catch(() => {
             // Leave in inflight for the next checkpoint or ingress opportunity.
             // Reject means this crossing never accepted the tell; drop stale evidence.
-            pendingCompletionEvidence.delete(tellId);
+            pendingReceipts.delete(tellId);
         })
             .finally(() => submitting.delete(tellId));
         submissions.add(submission);
         void submission.finally(() => submissions.delete(submission));
     }
 }
+/**
+ * An acknowledgement establishes the submission fence. Native exact and fence
+ * evidence may arrive on either side of that acknowledgement, so both buffers
+ * reduce through this one monotonic path. Exact visibility runs first only to
+ * supply the required heart predecessor for an already-buffered consumption.
+ */
+function reconcileAcknowledgedTell(projectionDirectory, executionId, tellId, submissionFence, pendingExactReceipts, pendingFenceReceipts) {
+    for (const receipt of pendingExactReceipts.get(tellId) ?? []) {
+        const launchInput = "launchInput" in receipt ? receipt.launchInput : undefined;
+        recordTellReceipt(projectionDirectory, {
+            tellId,
+            executionId,
+            stage: receipt.stage,
+            correlation: launchInput ? "inherited" : "exact",
+            ...(launchInput ? { fence: launchInput.fence } : {}),
+        });
+    }
+    pendingExactReceipts.delete(tellId);
+    const submitted = readTellSubmitted(projectionDirectory, tellId);
+    if (isTellLaunchAdmissionMember(projectionDirectory, executionId, tellId))
+        return;
+    for (const receipt of pendingFenceReceipts) {
+        if (receipt.correlation.kind !== "fence")
+            continue;
+        if (!isTellCausallyConsumed(submissionFence, receipt.correlation.fence))
+            continue;
+        recordTellReceipt(projectionDirectory, {
+            tellId,
+            executionId,
+            stage: receipt.stage,
+            correlation: submitted.replayedFrom?.length ? "inherited" : "fence",
+            fence: receipt.correlation.fence,
+        });
+    }
+}
 export function createLiveTellDeliveryController(projectionDirectory, executionId, dependencies = {}) {
     const now = dependencies.now ?? Date.now;
     const setTimer = dependencies.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
@@ -55,9 +82,12 @@ export function createLiveTellDeliveryController(projectionDirectory, executionI
     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);
+    // In-memory only: bridges a native exact receipt that races its enqueue ack.
+    const pendingReceipts = new Map();
+    // Native completion can race the steer RPC acknowledgement. The receipt is
+    // retained until each acknowledged fence can be reconciled causally.
+    const pendingFenceReceipts = [];
+    const initial = new Set(dependencies.reservedLaunchTellIds ?? []);
     let observer;
     let timer;
     let nextOpportunityAt = 0;
@@ -102,7 +132,7 @@ export function createLiveTellDeliveryController(projectionDirectory, executionI
         try {
             observer ??= openObserver(projectionDirectory);
             if (observer.hasDataVersionChanged()) {
-                submitEligible(projectionDirectory, executionId, control, true, submitting, submissions, initial, observer, pendingCompletionEvidence);
+                submitEligible(projectionDirectory, executionId, control, true, submitting, submissions, initial, observer, pendingReceipts, pendingFenceReceipts);
             }
         }
         catch {
@@ -140,29 +170,39 @@ export function createLiveTellDeliveryController(projectionDirectory, executionI
                 return;
             latestControl = control;
             cancelOpportunity();
-            for (const tellId of initial) {
-                markTellSubmitted(projectionDirectory, tellId, {
+            submitEligible(projectionDirectory, executionId, control, false, submitting, submissions, initial, observer, pendingReceipts, pendingFenceReceipts);
+        },
+        receipt(receipt) {
+            if (closed)
+                return;
+            if (receipt.correlation.kind === "exact") {
+                const tellId = receipt.correlation.tellId;
+                const launchInput = "launchInput" in receipt ? receipt.launchInput : undefined;
+                if (submitting.has(tellId)) {
+                    const pending = pendingReceipts.get(tellId) ?? [];
+                    pending.push(receipt);
+                    pendingReceipts.set(tellId, pending);
+                    return;
+                }
+                recordTellReceipt(projectionDirectory, {
+                    tellId,
                     executionId,
-                    fence: checkpoint.fence,
+                    stage: receipt.stage,
+                    correlation: launchInput ? "inherited" : "exact",
+                    ...(launchInput ? { fence: launchInput.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")) {
-                const submitted = readTellSubmitted(projectionDirectory, tellId);
-                if (submitted.executionId === executionId && submitted.fence && isTellCausallyConsumed(submitted.fence, checkpoint.fence)) {
-                    markTellConsumed(projectionDirectory, tellId);
-                }
             }
-            // Capture still-in-flight enqueues so a late ack can still see this evidence.
-            for (const tellId of submitting) {
-                const pending = pendingCompletionEvidence.get(tellId);
-                if (pending)
-                    pending.push(checkpoint.fence);
-                else
-                    pendingCompletionEvidence.set(tellId, [checkpoint.fence]);
+            pendingFenceReceipts.push(receipt);
+            for (const state of ["submitted", "seen"]) {
+                for (const tellId of listTellIds(projectionDirectory, state)) {
+                    const submitted = readTellSubmitted(projectionDirectory, tellId);
+                    if (submitted.executionId !== executionId)
+                        continue;
+                    if (isTellLaunchAdmissionMember(projectionDirectory, executionId, tellId))
+                        continue;
+                    reconcileAcknowledgedTell(projectionDirectory, executionId, tellId, submitted.fence, pendingReceipts, pendingFenceReceipts);
+                }
             }
         },
         async close() {
@@ -171,7 +211,7 @@ export function createLiveTellDeliveryController(projectionDirectory, executionI
                 cancelOpportunity();
                 discardObserver();
             }
-            // Do not drop pendingCompletionEvidence: in-flight acks may still submit/consume.
+            // Do not drop pendingReceipts: in-flight acks may still persist a native receipt.
             await Promise.all([...submissions]);
         },
     };
@@ -191,7 +231,7 @@ export function buildSyncCheckpointCallback(projectionDirectory, executionId) {
  */
 export function createProjectionExecutionObserver(input, dependencies = {}) {
     const appendEvent = dependencies.appendGenerationEvent ?? appendGenerationEvent;
-    const tellController = createLiveTellDeliveryController(input.projectionDirectory, input.executionId, { initialTellIds: input.initialTellIds });
+    const tellController = createLiveTellDeliveryController(input.projectionDirectory, input.executionId, { reservedLaunchTellIds: input.reservedLaunchTellIds });
     let closePromise;
     const observer = {
         onEvent(event) {
@@ -200,6 +240,18 @@ export function createProjectionExecutionObserver(input, dependencies = {}) {
         onCheckpoint(control, checkpoint) {
             tellController.checkpoint(control, checkpoint);
         },
+        async onTellReceiptCapabilities(capabilities) {
+            recordTellReceiptCapabilities(input.projectionDirectory, input.executionId, capabilities);
+        },
+        async onLaunchAdmission(admission) {
+            bindTellLaunchReservation(input.projectionDirectory, { executionId: input.executionId, ...admission });
+        },
+        listLaunchAdmissions() {
+            return listTellLaunchAdmissions(input.projectionDirectory, input.executionId);
+        },
+        onTellReceipt(receipt) {
+            tellController.receipt(receipt);
+        },
         onDeliveryOpportunity(control) {
             tellController.requestDelivery(control);
         },