@morty-build/cli 0.4.1 → 0.4.5

package/dist/engine/session/turn/execution-receipts.js

@@ -1,86 +1,56 @@
 import { createHash, randomUUID } from "node:crypto";
 import { decodeKnownSessionEventPayload, encodeSessionCancelBeforeStartCommand, isPromptTerminal, promptCompletion, } from "@morty-build/client/protocol";
 import { z } from "zod";
-const MAX_TERMINAL_RECEIPTS = 1_024;
-// Keep the execution claim after settlement: the outcome alone cannot decide replay safety.
-function executionStarted(state) {
-    switch (state.kind) {
-        case "pending":
-        case "settled-before-start":
-            return false;
-        case "started":
-        case "settled-after-start":
-            return true;
-        default: {
-            const unreachable = state;
-            throw new Error("Unexpected execution state", { cause: unreachable });
-        }
-    }
+const isStarted = (fate) => fate.kind === "started" || fate.kind === "settled-after-start";
+const isUnsettled = (fate) => fate.kind === "pending" || fate.kind === "started";
+const lifecyclePayload = (outcome) => {
+    const event = decodeKnownSessionEventPayload(JSON.parse(outcome));
+    return event?.type === "lifecycle-metadata" ? event.payload : undefined;
+};
+/** A restart failed the command before it started, so its identifier may run again. */
+function restartedBeforeStart(outcome) {
+    const payload = lifecyclePayload(outcome);
+    return payload?.kind === "prompt.failed-before-start" && payload.code === "runtime_restarted";
 }
-function cancelledBeforeStart(state) {
-    if (state.kind !== "settled-before-start") {
-        return false;
+/** How an unsettled command settles with `outcome`: a completion as cancelled before it started is a cancellation. */
+function settledFate(fate, outcome) {
+    if (fate.kind === "started") {
+        return { kind: "settled-after-start", startedAt: fate.startedAt, outcome };
     }
-    const outcome = decodeKnownSessionEventPayload(JSON.parse(state.outcome));
-    return (outcome?.type === "lifecycle-metadata" &&
-        outcome.payload.kind === "prompt.completed" &&
-        promptCompletion(outcome.payload).kind === "cancelled");
+    const payload = lifecyclePayload(outcome);
+    return payload?.kind === "prompt.completed" && promptCompletion(payload).kind === "cancelled"
+        ? { kind: "cancelled", outcome }
+        : { kind: "settled-before-start", outcome };
 }
-/** A restart failed the command before it started, so its identifier may run again. */
-function restartedBeforeStart(state) {
-    if (state.kind !== "settled-before-start") {
-        return false;
+function commandStanding(command, sessionId) {
+    if (command === undefined) {
+        return { kind: "unseen" };
     }
-    const outcome = decodeKnownSessionEventPayload(JSON.parse(state.outcome));
-    return (outcome?.type === "lifecycle-metadata" &&
-        outcome.payload.kind === "prompt.failed-before-start" &&
-        outcome.payload.code === "runtime_restarted");
-}
-function executionOutcome(state) {
-    switch (state.kind) {
+    if (command.sessionId !== sessionId) {
+        return { kind: "foreign" };
+    }
+    const fate = command.fate;
+    switch (fate.kind) {
         case "pending":
         case "started":
-            return null;
+            return { kind: "retained", command };
+        case "cancelled":
+            return fate.outcome === null ? { kind: "cancelled" } : { kind: "retained", command };
         case "settled-before-start":
+            return restartedBeforeStart(fate.outcome) ? { kind: "retryable" } : { kind: "retained", command };
         case "settled-after-start":
-            return state.outcome;
-        default: {
-            const unreachable = state;
-            throw new Error("Unexpected execution state", { cause: unreachable });
-        }
-    }
-}
-function settledExecution(state, outcome) {
-    return { kind: executionStarted(state) ? "settled-after-start" : "settled-before-start", outcome };
-}
-function commandStanding({ receipt, identity, cancellation }, sessionId) {
-    if (receipt !== undefined) {
-        if (receipt.sessionId !== sessionId) {
-            return { kind: "foreign" };
-        }
-        if (!executionStarted(receipt.state) &&
-            !cancelledBeforeStart(receipt.state) &&
-            cancellation?.sessionId === sessionId) {
-            // The cancellation commits before its receipt, so a crash between the two leaves this pair.
-            return { kind: "cancelled", receipt };
-        }
-        return restartedBeforeStart(receipt.state) ? { kind: "retryable", receipt } : { kind: "retained", receipt };
-    }
-    if (identity !== undefined) {
-        return identity.sessionId === sessionId
-            ? { kind: "expired", commandHash: identity.commandHash }
-            : { kind: "foreign" };
+            return fate.outcome === null
+                ? { kind: "expired", commandHash: command.commandHash }
+                : { kind: "retained", command };
+        default:
+            return fate;
     }
-    if (cancellation !== undefined) {
-        return cancellation.sessionId === sessionId ? { kind: "cancelled", receipt: undefined } : { kind: "foreign" };
-    }
-    return { kind: "unseen" };
 }
 const cancelledBeforeStartOutcome = (commandId) => ({
     type: "lifecycle-metadata",
     payload: { kind: "prompt.completed", commandId, stopReason: "cancelled", execution: "not-started" },
 });
-/** A receipt's stored outcome: the event as recorded, with its recording time. */
+/** A stored outcome: the event as recorded, with its recording time. */
 const storedOutcome = (stored) => {
     const parsed = JSON.parse(stored);
     const event = decodeKnownSessionEventPayload(parsed);
@@ -88,95 +58,74 @@ const storedOutcome = (stored) => {
         ? undefined
         : { event, recordedAt: z.object({ recordedAt: z.string() }).parse(parsed).recordedAt };
 };
-const unexpectedStanding = (standing) => {
-    throw new Error("Unexpected command standing", { cause: standing });
-};
+/**
+ * The Runtime's answers about the commands it admitted, read from the command ledger, which alone records what
+ * became of each command.
+ */
 export class ExecutionReceipts {
-    #executions = new Map();
-    #table;
-    #cancellations;
-    #closing = false;
+    #ledger;
     #onCount;
-    constructor(table, cancellations, onCount = () => undefined) {
+    /**
+     * The terminal events this process recorded with the Agent's own failure text. That text can quote user input, so
+     * it never enters the ledger, which keeps the content-free form; clients of this process still read the original.
+     */
+    #agentOutcomes = new Map();
+    /**
+     * Settlements reached while this process shuts down. They are artifacts of stopping, not of the commands, so the
+     * ledger keeps the commands unsettled and the next process reports that the restart interrupted them.
+     */
+    #shutdownSettlements = new Map();
+    #closing = false;
+    constructor(ledger, onCount = () => undefined) {
+        this.#ledger = ledger;
         this.#onCount = onCount;
-        this.#table = table;
-        this.#cancellations = cancellations;
-        const retained = [];
-        for (const { commandId, started, outcome, updatedAt: _updatedAt, ...identity } of table.list()) {
-            const pending = { kind: started ? "started" : "pending" };
-            const state = outcome === null ? pending : settledExecution(pending, outcome);
-            this.#executions.set(commandId, {
-                ...identity,
-                state,
-            });
-            if (cancelledBeforeStart(state)) {
-                retained.push({ commandId, sessionId: identity.sessionId });
-            }
-        }
-        cancellations.retain(retained);
     }
-    /** Reads every ledger that can still change the answer and classifies the identifier for the Session. */
-    #standing = (commandId, sessionId) => {
-        const receipt = this.#executions.get(commandId);
-        // A started receipt, or one settled as cancelled, is final; only the others consult the cancellation ledger.
-        const final = receipt !== undefined && (executionStarted(receipt.state) || cancelledBeforeStart(receipt.state));
-        return commandStanding({
-            receipt,
-            identity: receipt === undefined ? this.#table.identity(commandId) : undefined,
-            cancellation: final ? undefined : this.#cancellations.read(commandId),
-        }, sessionId);
+    #withShutdownSettlement = (command) => {
+        const fate = this.#shutdownSettlements.get(command.commandId);
+        return fate === undefined ? command : { ...command, fate };
     };
-    #remember = (commandId, receipt, evicted) => {
-        // Live failure detail may quote user input; only the durable receipt goes to the table.
-        this.#executions.set(commandId, receipt);
-        for (const evictedCommandId of evicted) {
-            this.#executions.delete(evictedCommandId);
-        }
-        let activeCount = 0;
-        for (const entry of this.#executions.values()) {
-            if (executionOutcome(entry.state) === null) {
-                activeCount += 1;
-            }
-        }
-        this.#onCount(activeCount);
+    #read = (commandId) => {
+        const command = this.#ledger.read(commandId);
+        return command === undefined ? undefined : this.#withShutdownSettlement(command);
     };
-    #save = (commandId, receipt, durableOutcome = executionOutcome(receipt.state)) => {
-        const { state, ...identity } = receipt;
-        if (!this.#closing && cancelledBeforeStart(state)) {
-            // Commit the non-replayable fact first. A crash before saving/pruning the receipt must not reopen work.
-            this.#cancellations.retain([{ commandId, sessionId: receipt.sessionId }]);
-            // Cancellation is already authoritative even if the detailed receipt write fails.
-            this.#remember(commandId, receipt, []);
+    #standing = (commandId, sessionId) => commandStanding(this.#read(commandId), sessionId);
+    /** The outcome clients read for a settled command: what this process recorded, else the ledger's form. */
+    #outcome = ({ commandId, fate }) => {
+        if (isUnsettled(fate) || fate.outcome === null) {
+            return undefined;
         }
-        const evicted = this.#closing
-            ? []
-            : this.#table.save({
-                ...identity,
-                commandId,
-                started: executionStarted(state),
-                outcome: durableOutcome,
-                updatedAt: new Date().toISOString(),
-            }, MAX_TERMINAL_RECEIPTS);
-        this.#remember(commandId, receipt, evicted);
+        return this.#agentOutcomes.get(commandId) ?? fate.outcome;
     };
-    #nextAdmissionOrder = () => {
-        let latest = 0;
-        for (const receipt of this.#executions.values()) {
-            latest = Math.max(latest, receipt.admissionOrder);
+    #publishCount = () => {
+        this.#onCount(this.#ledger.unsettled().filter((commandId) => !this.#shutdownSettlements.has(commandId)).length);
+    };
+    /** Settles an unsettled command. `agentOutcome` is the outcome with the Agent's text, when it differs. */
+    #settle = (commandId, fate, outcome, agentOutcome) => {
+        const settled = settledFate(fate, outcome);
+        if (agentOutcome !== undefined) {
+            this.#agentOutcomes.set(commandId, agentOutcome);
+        }
+        if (this.#closing) {
+            this.#shutdownSettlements.set(commandId, settled);
+        }
+        else {
+            for (const dropped of this.#ledger.settle(commandId, settled.kind, outcome)) {
+                this.#agentOutcomes.delete(dropped);
+            }
         }
-        return latest + 1;
+        this.#publishCount();
     };
     beginShutdown = () => {
         this.#closing = true;
     };
     outcome = (commandId) => this.restatedOutcome(commandId)?.event;
-    /** The outcome the command's receipt holds, with the time it was recorded. */
+    /** The outcome the ledger keeps for the command, with the time it was recorded. */
     restatedOutcome = (commandId) => {
-        const receipt = this.#executions.get(commandId);
-        const outcome = receipt === undefined ? null : executionOutcome(receipt.state);
-        return outcome === null ? undefined : storedOutcome(outcome);
+        const command = this.#read(commandId);
+        const outcome = command === undefined ? undefined : this.#outcome(command);
+        return outcome === undefined ? undefined : storedOutcome(outcome);
     };
-    /** The command's delivery as these receipts know it; another Session's command reads as unknown. */
+    /** The command's delivery as the ledger knows it; another Session's command reads as unknown. */
     delivery = (commandId, sessionId) => {
         const standing = this.#standing(commandId, sessionId);
         switch (standing.kind) {
@@ -192,9 +141,10 @@ export class ExecutionReceipts {
             case "retained":
                 break;
             default:
-                return unexpectedStanding(standing);
+                return standing;
         }
-        if (executionOutcome(standing.receipt.state) === null) {
+        const command = this.#read(commandId);
+        if (command === undefined || isUnsettled(command.fate)) {
             return { state: "accepted" };
         }
         const outcome = this.outcome(commandId);
@@ -210,66 +160,54 @@ export class ExecutionReceipts {
         }
     };
     /**
-     * How the Session's most recently admitted turn ended. Admission order survives updates and
-     * restarts. Commands that never started (queued, or reserved for cancellation) are not turns,
-     * unless they failed before starting. A steering command that completed as `steered` joined the
-     * turn it steered, which reports for both; a steer not known to have joined (it failed, or a
-     * restart interrupted it) keeps its own outcome. Undefined while the latest turn runs or none is
-     * retained.
+     * How the Session's most recently admitted turn ended. Commands that never started (queued, or reserved for
+     * cancellation) are not turns, unless they failed before starting. A steering command that completed as `steered`
+     * joined the turn it steered, which reports for both; a steer not known to have joined (it failed, or a restart
+     * interrupted it) keeps its own outcome. Undefined while the latest turn runs or its outcome is no longer kept.
      */
     lastTurn = (sessionId) => {
         let last;
-        let latestOrder = 0;
-        for (const [commandId, receipt] of this.#executions) {
-            if (receipt.sessionId !== sessionId) {
-                continue;
-            }
-            const outcome = this.outcome(commandId);
+        for (const stored of this.#ledger.session(sessionId)) {
+            const command = this.#withShutdownSettlement(stored);
+            const outcome = this.outcome(command.commandId);
             const payload = outcome?.type === "lifecycle-metadata" ? outcome.payload : undefined;
             const failedBeforeStart = payload?.kind === "prompt.failed-before-start";
             const steered = payload?.kind === "prompt.completed" && promptCompletion(payload).kind === "steered";
-            if ((executionStarted(receipt.state) || failedBeforeStart) &&
-                !steered &&
-                receipt.admissionOrder > latestOrder) {
-                last = commandId;
-                latestOrder = receipt.admissionOrder;
+            const kept = command.fate.kind === "started" || outcome !== undefined;
+            if (kept && (isStarted(command.fate) || failedBeforeStart) && !steered) {
+                last = { commandId: command.commandId, outcome };
             }
         }
-        const outcome = last === undefined ? undefined : this.outcome(last);
+        const outcome = last?.outcome;
         if (last === undefined || outcome?.type !== "lifecycle-metadata" || !isPromptTerminal(outcome.payload)) {
             return undefined;
         }
         switch (outcome.payload.kind) {
             case "prompt.completed":
-                return { commandId: last, state: "completed", stopReason: outcome.payload.stopReason };
+                return { commandId: last.commandId, state: "completed", stopReason: outcome.payload.stopReason };
             case "prompt.failed":
             case "prompt.failed-before-start":
                 return {
                     code: outcome.payload.code,
-                    commandId: last,
+                    commandId: last.commandId,
                     message: outcome.payload.message,
                     state: "failed",
                 };
         }
     };
-    /** When the Session's running command started, while its receipt holds the time. */
+    /** When the Session's running command started. */
     startedAt = (commandId, sessionId) => {
-        const receipt = this.#executions.get(commandId);
-        return receipt?.sessionId === sessionId && receipt.state.kind === "started"
-            ? receipt.state.startedAt
-            : undefined;
+        const command = this.#read(commandId);
+        return command?.sessionId === sessionId && command.fate.kind === "started" ? command.fate.startedAt : undefined;
     };
     /**
      * The recorded terminal events of the Session's settled prompts whose Agent reported the user message they
-     * recorded, while their receipts are retained.
+     * recorded, while the ledger keeps their outcomes.
      */
     promptOutcomes = (sessionId) => {
         const outcomes = [];
-        for (const [commandId, receipt] of this.#executions) {
-            if (receipt.sessionId !== sessionId) {
-                continue;
-            }
-            const outcome = this.restatedOutcome(commandId);
+        for (const command of this.#ledger.session(sessionId)) {
+            const outcome = this.restatedOutcome(command.commandId);
             const event = outcome?.event;
             if (outcome?.recordedAt !== undefined &&
                 event?.type === "lifecycle-metadata" &&
@@ -280,7 +218,7 @@ export class ExecutionReceipts {
         }
         return outcomes;
     };
-    /** Started identities remain authoritative after their detailed receipt is evicted. */
+    /** A command that started stays started after its outcome is no longer kept. */
     hasStarted = (commandId, sessionId) => {
         const standing = this.#standing(commandId, sessionId);
         switch (standing.kind) {
@@ -292,9 +230,9 @@ export class ExecutionReceipts {
             case "expired":
                 return true;
             case "retained":
-                return executionStarted(standing.receipt.state);
+                return isStarted(standing.command.fate);
             default:
-                return unexpectedStanding(standing);
+                return standing;
         }
     };
     /**
@@ -322,7 +260,7 @@ export class ExecutionReceipts {
             case "unseen":
                 break;
             default:
-                return unexpectedStanding(standing);
+                return standing;
         }
         const outcome = cancelledBeforeStartOutcome(commandId);
         // The identifier belongs to the cancellation, so a later prompt conflicts rather than executing.
@@ -333,22 +271,15 @@ export class ExecutionReceipts {
             sessionId,
         }))
             .digest("hex");
-        this.#save(commandId, {
-            admissionOrder: this.#nextAdmissionOrder(),
-            attemptId: randomUUID(),
-            commandHash,
-            sessionId,
-            state: {
-                kind: "settled-before-start",
-                outcome: JSON.stringify({ ...outcome, recordedAt: new Date().toISOString() }),
-            },
-        });
+        for (const dropped of this.#ledger.admitCancelled({ attemptId: randomUUID(), commandHash, commandId, sessionId }, JSON.stringify({ ...outcome, recordedAt: new Date().toISOString() }))) {
+            this.#agentOutcomes.delete(dropped);
+        }
         return { kind: "recorded", outcome };
     };
     /**
-     * Receipts follow their command's recorded lifecycle. `prompt.started` is recorded where the command is handed
+     * The ledger follows each command's recorded lifecycle. `prompt.started` is recorded where the command is handed
      * to the Agent, so the started mark and the event clients see are one transition; a terminal event settles the
-     * receipt. Nothing else marks a command started.
+     * command. Nothing else marks a command started.
      */
     record = (event) => {
         if (event.type !== "lifecycle-metadata") {
@@ -356,77 +287,65 @@ export class ExecutionReceipts {
         }
         const payload = event.payload;
         if (payload.kind === "prompt.started") {
-            const receipt = this.#executions.get(payload.commandId);
             // A start reported after settlement does not reopen the execution.
-            if (receipt?.state.kind === "pending") {
-                this.#save(payload.commandId, {
-                    ...receipt,
-                    state: { kind: "started", startedAt: event.recordedAt },
-                });
-            }
+            this.#ledger.start(payload.commandId, event.recordedAt);
             return;
         }
         if (!isPromptTerminal(payload)) {
             return;
         }
-        const receipt = this.#executions.get(payload.commandId);
-        if (receipt === undefined) {
+        const fate = this.#read(payload.commandId)?.fate;
+        if (fate === undefined || !isUnsettled(fate)) {
             return;
         }
-        const sanitized = payload.kind === "prompt.completed"
-            ? payload
-            : { ...payload, message: "The local Agent could not complete the request" };
         const outcome = { type: "lifecycle-metadata", payload, recordedAt: event.recordedAt };
-        this.#save(payload.commandId, { ...receipt, state: settledExecution(receipt.state, JSON.stringify(outcome)) }, JSON.stringify({ ...outcome, payload: sanitized }));
+        if (payload.kind === "prompt.completed") {
+            this.#settle(payload.commandId, fate, JSON.stringify(outcome));
+            return;
+        }
+        const contentFree = { ...payload, message: "The local Agent could not complete the request" };
+        this.#settle(payload.commandId, fate, JSON.stringify({ ...outcome, payload: contentFree }), JSON.stringify(outcome));
     };
     recover = () => {
         const recovered = [];
-        for (const [commandId, receipt] of [...this.#executions]) {
-            const outcome = executionOutcome(receipt.state);
-            // A cancellation committed without its receipt settles the receipt as that cancellation.
-            const restoreCancellation = this.#standing(commandId, receipt.sessionId).kind === "cancelled";
-            const event = restoreCancellation
-                ? cancelledBeforeStartOutcome(commandId)
-                : outcome === null
-                    ? {
-                        type: "lifecycle-metadata",
-                        payload: executionStarted(receipt.state)
-                            ? {
-                                kind: "prompt.failed",
-                                commandId,
-                                attemptId: receipt.attemptId,
-                                code: "runtime_restarted",
-                                message: "The local runtime restarted while this request was running",
-                            }
-                            : {
-                                kind: "prompt.failed-before-start",
-                                commandId,
-                                code: "runtime_restarted",
-                                message: "The local runtime restarted before this request started",
-                            },
-                    }
-                    : decodeKnownSessionEventPayload(JSON.parse(outcome));
-            if (event === null) {
-                continue;
-            }
-            if (!restoreCancellation && outcome !== null) {
+        for (const command of this.#ledger.all()) {
+            const fate = command.fate;
+            if (!isUnsettled(fate)) {
                 // The previous process recorded this outcome; publishing it again restates that fact.
-                const restated = storedOutcome(outcome);
+                const restated = fate.outcome === null ? undefined : storedOutcome(fate.outcome);
                 if (restated !== undefined) {
-                    recovered.push({ kind: "restated", sessionId: receipt.sessionId, outcome: restated });
+                    recovered.push({ kind: "restated", sessionId: command.sessionId, outcome: restated });
                 }
                 continue;
             }
+            const event = {
+                type: "lifecycle-metadata",
+                payload: fate.kind === "started"
+                    ? {
+                        kind: "prompt.failed",
+                        commandId: command.commandId,
+                        attemptId: command.attemptId,
+                        code: "runtime_restarted",
+                        message: "The local runtime restarted while this request was running",
+                    }
+                    : {
+                        kind: "prompt.failed-before-start",
+                        commandId: command.commandId,
+                        code: "runtime_restarted",
+                        message: "The local runtime restarted before this request started",
+                    },
+            };
             const recordedAt = new Date().toISOString();
-            recovered.push({ kind: "recorded", sessionId: receipt.sessionId, event, recordedAt });
-            this.#save(commandId, {
-                ...receipt,
-                state: settledExecution(receipt.state, JSON.stringify({ ...event, recordedAt })),
-            });
+            recovered.push({ kind: "recorded", sessionId: command.sessionId, event, recordedAt });
+            this.#settle(command.commandId, fate, JSON.stringify({ ...event, recordedAt }));
         }
         return recovered;
     };
-    claimExecution = (commandId, sessionId, commandJson) => {
+    /**
+     * Claims a command's identifier for the Session. A known identifier is answered from the ledger; a new command is
+     * recorded only when `admits` accepts it in the same step, so a command the Session refuses leaves no record.
+     */
+    claimExecution = (commandId, sessionId, commandJson, admits) => {
         const commandHash = createHash("sha256").update(commandJson).digest("hex");
         const standing = this.#standing(commandId, sessionId);
         switch (standing.kind) {
@@ -434,49 +353,44 @@ export class ExecutionReceipts {
             case "cancelled":
                 return { kind: "conflict" };
             case "retained":
-                if (standing.receipt.commandHash !== commandHash) {
+                if (standing.command.commandHash !== commandHash) {
                     return { kind: "conflict" };
                 }
                 return {
-                    attemptId: standing.receipt.attemptId,
+                    attemptId: standing.command.attemptId,
                     commandId,
                     kind: "duplicate",
-                    state: executionOutcome(standing.receipt.state) === null ? "unsettled" : "settled",
+                    state: isUnsettled(standing.command.fate) ? "unsettled" : "settled",
                 };
             case "expired":
                 return standing.commandHash === commandHash ? { kind: "expired" } : { kind: "conflict" };
             case "retryable":
-                // Forget the restart failure, then claim as if it had never been received.
-                this.#table.remove(commandId);
-                this.#executions.delete(commandId);
-                return this.claimExecution(commandId, sessionId, commandJson);
+            // A restart failed it before it started: the admission replaces that failure.
             case "unseen":
                 break;
             default:
-                return unexpectedStanding(standing);
+                return standing;
+        }
+        if (!admits()) {
+            return { kind: "refused" };
         }
         const attemptId = randomUUID();
-        this.#save(commandId, {
-            admissionOrder: this.#nextAdmissionOrder(),
-            attemptId,
-            commandHash,
-            sessionId,
-            state: { kind: "pending" },
-        });
+        this.#ledger.admit({ attemptId, commandHash, commandId, sessionId });
+        this.#publishCount();
         return { attemptId, commandId, kind: "accepted" };
     };
     /** Only commands without a terminal result can still be cancelled. */
     findUnsettledAttemptId = (commandId, sessionId) => {
-        const receipt = this.#executions.get(commandId);
-        return receipt?.sessionId === sessionId && executionOutcome(receipt.state) === null ? receipt.attemptId : null;
+        const command = this.#read(commandId);
+        return command?.sessionId === sessionId && isUnsettled(command.fate) ? command.attemptId : null;
     };
     isTerminalExecution = (commandId, sessionId) => {
-        const receipt = this.#executions.get(commandId);
-        return receipt?.sessionId === sessionId && executionOutcome(receipt.state) !== null;
+        const command = this.#read(commandId);
+        return command?.sessionId === sessionId && !isUnsettled(command.fate);
     };
     close = () => {
-        this.#executions.clear();
-        this.#cancellations.close();
+        this.#agentOutcomes.clear();
+        this.#shutdownSettlements.clear();
     };
 }
 //# sourceMappingURL=execution-receipts.js.map