@astrosheep/keiyaku 4.6.11 → 4.6.13

package/build/src/akuma/providers/opencode-sdk/session.d.ts

@@ -54,7 +54,7 @@ export type OpencodeSdkLoader = (cwd: string, execution: ProviderExecution, sign
     ready?: Promise<void>;
 }>>;
 export declare const OPENCODE_SDK_PROVIDER: "opencode-sdk";
-export declare function messageId(sequence?: number): string;
+export declare function messageId(): string;
 export declare function parseModel(model: string): Readonly<{
     providerID: string;
     id: string;
@@ -69,12 +69,14 @@ export type OpencodeRuntime = Readonly<{
 }>;
 /** A successful HTML fallback, or a JSON response from another API, is not readiness. */
 export declare function waitReady(json: (path: string) => Promise<unknown>, signal: AbortSignal): Promise<void>;
-export declare function loadOpencode(input: Readonly<{
+type LoadOpencodeInput = Readonly<{
     execution: ProviderExecution;
     cwd: string;
     signal: AbortSignal;
     loader?: OpencodeSdkLoader;
     onRuntime?: (runtime: OpencodeRuntime) => void;
     requests?: string;
-}>): Promise<OpencodeRuntime>;
+}>;
+export declare function loadOpencode(input: LoadOpencodeInput): Promise<OpencodeRuntime>;
 export declare function coordinate(sessionId: string): ResumeCoordinate;
+export {};

package/build/src/akuma/providers/opencode-sdk/session.js

@@ -1,3 +1,4 @@
+import { SessionMessage } from "@opencode/schema/session-message";
 import net from "node:net";
 import { randomBytes } from "node:crypto";
 import { abortable } from "../../abort.js";
@@ -6,9 +7,8 @@ import { spawnDetachedProcess } from "../../../runtime/proc/run.js";
 import { object } from "../decode.js";
 import { createNativeClient } from "./native-http.js";
 export const OPENCODE_SDK_PROVIDER = "opencode-sdk";
-export function messageId(sequence = 0) {
-    const timestamp = BigInt(Date.now()) * 0x1000n + BigInt(sequence);
-    return `msg_${timestamp.toString(16)}${randomBytes(14).toString("hex")}`;
+export function messageId() {
+    return SessionMessage.ID.create();
 }
 export function parseModel(model) {
     const slash = model.indexOf("/");
@@ -73,31 +73,36 @@ async function availablePort() {
     });
 }
 export async function loadOpencode(input) {
-    const { execution, cwd, signal, loader, onRuntime, requests } = input;
-    if (loader !== undefined) {
-        const loaded = await abortable(loader(cwd, {
-            ...execution,
-            env: akumaExecutionEnvironment(process.env, execution.env, requests),
-        }, signal), signal);
-        let closing;
-        const runtime = {
-            client: loaded.client,
-            close: () => (closing ??= Promise.resolve()
-                .then(() => loaded.close?.())
-                .then(() => undefined)),
-        };
-        onRuntime?.(runtime);
-        try {
-            if (loaded.ready !== undefined)
-                await abortable(loaded.ready, signal);
-            signal.throwIfAborted();
-            return runtime;
-        }
-        catch (error) {
-            await runtime.close();
-            throw error;
-        }
+    const { loader } = input;
+    return loader === undefined ? loadNativeOpencode(input) : loadInjectedOpencode(input, loader);
+}
+async function loadInjectedOpencode(input, loader) {
+    const { execution, cwd, signal, onRuntime, requests } = input;
+    const loaded = await abortable(loader(cwd, {
+        ...execution,
+        env: akumaExecutionEnvironment(process.env, execution.env, requests),
+    }, signal), signal);
+    let closing;
+    const runtime = {
+        client: loaded.client,
+        close: () => (closing ??= Promise.resolve()
+            .then(() => loaded.close?.())
+            .then(() => undefined)),
+    };
+    onRuntime?.(runtime);
+    try {
+        if (loaded.ready !== undefined)
+            await abortable(loaded.ready, signal);
+        signal.throwIfAborted();
+        return runtime;
     }
+    catch (error) {
+        await runtime.close();
+        throw error;
+    }
+}
+async function loadNativeOpencode(input) {
+    const { execution, cwd, signal, onRuntime, requests } = input;
     const port = await availablePort();
     signal.throwIfAborted();
     const password = execution.env?.OPENCODE_PASSWORD ??

package/build/src/akuma/providers/paseo/index.js

@@ -248,8 +248,6 @@ class PaseoDrive {
             admission: { fence },
             events: this.turn.events,
             completion,
-            abort: () => this.retire(true),
-            forceDispose: () => this.retire(true),
         };
     }
     async existingAgent(coordinate, signal) {

package/build/src/akuma/providers/pi/index.js

@@ -1,6 +1,6 @@
 import { abortable } from "../../abort.js";
 import { akumaExecutionEnvironment } from "../execution-environment.js";
-import { AgentEventChannel, createProviderAttempt, launchPrompt, modelEvent, tellRegistry, } from "../../provider.js";
+import { AgentEventChannel, createProviderAttempt, launchPrompt, modelEvent, noteEvent, tellRegistry, } from "../../provider.js";
 import { piSessionModel, piTerminalFailure, translatePiEvent } from "./events.js";
 const PI_THINKING_LEVELS = new Set(["minimal", "low", "medium", "high", "xhigh", "max"]);
 const MODEL_PATTERN = /^[^/\s]+\/[^\s]+$/u;
@@ -70,9 +70,13 @@ async function createPiSession(sdk, execution, input) {
                     : { systemPromptOverride: () => input.options.systemPrompt },
             }),
     });
+    const extensionErrors = services.resourceLoader.getExtensions().errors ?? [];
+    for (const failure of extensionErrors)
+        console.error(`Pi extension load failed: ${failure.path}\n${failure.error}`);
     try {
         input.signal?.throwIfAborted();
-        return await sdk.createAgentSessionFromServices(piCreateOptions(sdk, input, services));
+        const created = await sdk.createAgentSessionFromServices(piCreateOptions(sdk, input, services));
+        return { created, extensionErrors };
     }
     catch (error) {
         // Before a session owns the extension runtime, failed selection/setup must
@@ -139,7 +143,7 @@ async function retirePiSession(native) {
         throw failure;
 }
 async function drivePi(sdk, execution, input, signal, custody) {
-    const created = await createPiSession(sdk, execution, input);
+    const { created, extensionErrors } = await createPiSession(sdk, execution, input);
     const native = created.session;
     let settleRetired;
     let failRetired;
@@ -201,12 +205,24 @@ async function drivePi(sdk, execution, input, signal, custody) {
         })().then(settleRetired, failRetired);
         return closed;
     };
+    const abort = async () => {
+        if (state.settled)
+            return;
+        state.aborting = true;
+        try {
+            await native.abort();
+        }
+        catch {
+            /* prompt settlement still proves local cleanup */
+        }
+        await settle({ kind: "failed", diagnostic: "Pi session aborted" });
+    };
     const forceDispose = async () => {
         if (!state.settled)
             state.aborting = true;
         await settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
     };
-    custody?.own({ closed, abort: forceDispose, forceDispose });
+    custody?.own({ closed, abort, forceDispose });
     try {
         unsubscribeAgent = agent.subscribe((event) => {
             if (event.type === "message_end")
@@ -236,6 +252,9 @@ async function drivePi(sdk, execution, input, signal, custody) {
     await abortable(binding, signal);
     signal.throwIfAborted();
     events.emit({ type: "session", coordinate: { sessionFile: native.sessionFile, sessionId: native.sessionId } });
+    for (const failure of extensionErrors) {
+        events.emit(noteEvent(`Pi extension load failed: ${failure.path}: ${failure.error}`));
+    }
     const sessionModel = piSessionModel(native.model);
     if (sessionModel !== undefined)
         events.emit(modelEvent(sessionModel));
@@ -263,22 +282,6 @@ async function drivePi(sdk, execution, input, signal, custody) {
             }
             return submission;
         },
-        abort: () => {
-            state.abortRequest ??= (async () => {
-                if (state.settled)
-                    return;
-                state.aborting = true;
-                try {
-                    await native.abort();
-                }
-                catch {
-                    /* prompt settlement still proves local cleanup */
-                }
-                await settle({ kind: "failed", diagnostic: "Pi session aborted" });
-            })();
-            return state.abortRequest;
-        },
-        forceDispose,
     };
 }
 function piSessionFile(coordinate) {

package/build/src/akuma/selection-observation.d.ts

@@ -47,10 +47,9 @@ declare const akumaObservationSchema: z.ZodObject<{
             "akuma.call": "akuma.call";
             "akuma.kill": "akuma.kill";
             "akuma.tell": "akuma.tell";
-            "contract.audit": "contract.audit";
             "contract.deliver": "contract.deliver";
             "contract.review": "contract.review";
-        }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+        }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.deliver" | "contract.review")[]>>;
         timeline: z.ZodUnion<readonly [z.ZodObject<{
             reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 sequence: z.ZodNumber;
@@ -537,10 +536,9 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                 "akuma.call": "akuma.call";
                 "akuma.kill": "akuma.kill";
                 "akuma.tell": "akuma.tell";
-                "contract.audit": "contract.audit";
                 "contract.deliver": "contract.deliver";
                 "contract.review": "contract.review";
-            }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+            }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.deliver" | "contract.review")[]>>;
             timeline: z.ZodUnion<readonly [z.ZodObject<{
                 reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                     sequence: z.ZodNumber;
@@ -979,9 +977,9 @@ declare const akumaKillResultSchema: z.ZodObject<{
             killed: "killed";
             hung: "hung";
             unavailable: "unavailable";
+            untidy: "untidy";
             "already-killed": "already-killed";
             "already-stopped": "already-stopped";
-            untidy: "untidy";
         }>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
@@ -1072,6 +1070,24 @@ declare const akumaTellResultSchema: z.ZodObject<{
                 };
             } | undefined;
         }>>]>;
+        interruption: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"completed">;
+            bodySequence: z.ZodNumber;
+            putDown: z.ZodEnum<{
+                "was-idle": "was-idle";
+                "self-aborted": "self-aborted";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"pending">;
+            bodySequence: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unavailable">;
+            bodySequence: z.ZodNumber;
+            evidence: z.ZodEnum<{
+                hung: "hung";
+                untidy: "untidy";
+            }>;
+        }, z.core.$strict>], "kind">>;
     }, z.core.$strict>;
 }, z.core.$strict>;
 declare const askObservationSchema: z.ZodUnion<readonly [z.ZodObject<{
@@ -1176,6 +1192,24 @@ declare const akumaAskResultSchema: z.ZodObject<{
                 };
             } | undefined;
         }>>]>;
+        interruption: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"completed">;
+            bodySequence: z.ZodNumber;
+            putDown: z.ZodEnum<{
+                "was-idle": "was-idle";
+                "self-aborted": "self-aborted";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"pending">;
+            bodySequence: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unavailable">;
+            bodySequence: z.ZodNumber;
+            evidence: z.ZodEnum<{
+                hung: "hung";
+                untidy: "untidy";
+            }>;
+        }, z.core.$strict>], "kind">>;
     }, z.core.$strict>;
     observation: z.ZodUnion<readonly [z.ZodObject<{
         reason: z.ZodLiteral<"answered">;
@@ -1273,10 +1307,9 @@ export declare const selectionResultSchemas: {
                     "akuma.call": "akuma.call";
                     "akuma.kill": "akuma.kill";
                     "akuma.tell": "akuma.tell";
-                    "contract.audit": "contract.audit";
                     "contract.deliver": "contract.deliver";
                     "contract.review": "contract.review";
-                }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+                }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.deliver" | "contract.review")[]>>;
                 timeline: z.ZodUnion<readonly [z.ZodObject<{
                     reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                         sequence: z.ZodNumber;
@@ -1795,6 +1828,24 @@ export declare const selectionResultSchemas: {
                     };
                 } | undefined;
             }>>]>;
+            interruption: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"completed">;
+                bodySequence: z.ZodNumber;
+                putDown: z.ZodEnum<{
+                    "was-idle": "was-idle";
+                    "self-aborted": "self-aborted";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"pending">;
+                bodySequence: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unavailable">;
+                bodySequence: z.ZodNumber;
+                evidence: z.ZodEnum<{
+                    hung: "hung";
+                    untidy: "untidy";
+                }>;
+            }, z.core.$strict>], "kind">>;
         }, z.core.$strict>;
     }, z.core.$strict>;
     ask: z.ZodObject<{
@@ -1884,6 +1935,24 @@ export declare const selectionResultSchemas: {
                     };
                 } | undefined;
             }>>]>;
+            interruption: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"completed">;
+                bodySequence: z.ZodNumber;
+                putDown: z.ZodEnum<{
+                    "was-idle": "was-idle";
+                    "self-aborted": "self-aborted";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"pending">;
+                bodySequence: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unavailable">;
+                bodySequence: z.ZodNumber;
+                evidence: z.ZodEnum<{
+                    hung: "hung";
+                    untidy: "untidy";
+                }>;
+            }, z.core.$strict>], "kind">>;
         }, z.core.$strict>;
         observation: z.ZodUnion<readonly [z.ZodObject<{
             reason: z.ZodLiteral<"answered">;
@@ -1909,9 +1978,9 @@ export declare const selectionResultSchemas: {
                 killed: "killed";
                 hung: "hung";
                 unavailable: "unavailable";
+                untidy: "untidy";
                 "already-killed": "already-killed";
                 "already-stopped": "already-stopped";
-                untidy: "untidy";
             }>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
@@ -1919,9 +1988,9 @@ export declare const selectionResultSchemas: {
         killed: "killed";
         hung: "hung";
         unavailable: "unavailable";
+        untidy: "untidy";
         "already-killed": "already-killed";
         "already-stopped": "already-stopped";
-        untidy: "untidy";
     }>;
 };
 export {};

package/build/src/akuma/selection-owner-port.d.ts

@@ -1,4 +1,5 @@
 import type { WorldRoot } from "../world.js";
+import type { AkumaStatus } from "./akuma.js";
 import type { SelectionRequestPort } from "./selection-request.js";
 /**
  * The parent's Selection owner boundary: one forwarded request arrives as complete
@@ -9,4 +10,4 @@ import type { SelectionRequestPort } from "./selection-request.js";
  * unaddressable member never starts; the executor's own access to the target is
  * then the product act, never a second addressing probe.
  */
-export declare function selectionRequestPort(world: WorldRoot, reportDiagnostic: (message: string) => void): SelectionRequestPort;
+export declare function selectionRequestPort(world: WorldRoot, reportDiagnostic: (message: string) => void, servingBodyId?: AkumaStatus["id"]): SelectionRequestPort;

package/build/src/akuma/selection-owner-port.js

@@ -1,3 +1,4 @@
+import { AkumaSelfInterruptError } from "./akuma-errors.js";
 import { outcomePluginObserver } from "../plugin/akuma-signals.js";
 import { requireBornAkuma } from "./akuma-probe.js";
 import { executeAskAkuma, executeKillAkuma, executeTellAkuma } from "./akuma-selection-execution.js";
@@ -12,7 +13,7 @@ import { akumaObservationOf } from "./selection-observation.js";
  * unaddressable member never starts; the executor's own access to the target is
  * then the product act, never a second addressing probe.
  */
-export function selectionRequestPort(world, reportDiagnostic) {
+export function selectionRequestPort(world, reportDiagnostic, servingBodyId) {
     const prove = async (targets) => {
         for (const id of targets)
             await requireBornAkuma(world, id);
@@ -31,10 +32,14 @@ export function selectionRequestPort(world, reportDiagnostic) {
             return { ...native, observations: native.observations.map(akumaObservationOf) };
         },
         tell: async ({ target, ...request }) => {
+            if (request.interrupt === true && servingBodyId === target)
+                throw new AkumaSelfInterruptError(target);
             await prove([target]);
             return await executeTellAkuma({ path: world, id: target, ...request });
         },
         ask: async ({ target, observer, ...request }) => {
+            if (request.interrupt === true && servingBodyId === target)
+                throw new AkumaSelfInterruptError(target);
             await prove([target]);
             return await executeAskAkuma({
                 path: world,

package/build/src/akuma/selection-request.d.ts

@@ -90,9 +90,9 @@ declare const killServiceSchema: z.ZodObject<{
             killed: "killed";
             hung: "hung";
             unavailable: "unavailable";
+            untidy: "untidy";
             "already-killed": "already-killed";
             "already-stopped": "already-stopped";
-            untidy: "untidy";
         }>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;

package/build/src/akuma/selection-request.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { AkumaNotBornError, AkumaObservationError } from "./akuma-errors.js";
+import { AkumaNotBornError, AkumaObservationError, AkumaSelfInterruptError } from "./akuma-errors.js";
 import { akumaIdSchema } from "./identity.js";
 import { requestBodyCommand } from "./request-rendezvous.js";
 import { eraseRequestCommand, } from "./request-wire.js";
@@ -80,6 +80,7 @@ const killServiceSchema = z
 const selectionRefusalSchema = z.union([
     z.object({ kind: z.literal("akuma-not-born"), id: akumaIdSchema }).strict(),
     z.object({ kind: z.literal("akuma-observation"), id: akumaIdSchema, diagnostic: z.string() }).strict(),
+    z.object({ kind: z.literal("akuma-self-interrupt"), id: akumaIdSchema }).strict(),
 ]);
 const selectionLiveFailureSchema = z.object({ kind: z.literal("refused"), failure: selectionRefusalSchema }).strict();
 export function encodeSelectionLiveFailure(error) {
@@ -87,7 +88,9 @@ export function encodeSelectionLiveFailure(error) {
         ? { kind: "akuma-not-born", id: error.id }
         : error instanceof AkumaObservationError
             ? { kind: "akuma-observation", id: error.id, diagnostic: error.diagnostic }
-            : null;
+            : error instanceof AkumaSelfInterruptError
+                ? { kind: "akuma-self-interrupt", id: error.id }
+                : null;
     return failure === null ? null : { kind: "refused", failure };
 }
 export function decodeSelectionLiveFailure(value) {
@@ -97,7 +100,9 @@ export function decodeSelectionLiveFailure(value) {
     const failure = parsed.data.failure;
     return failure.kind === "akuma-not-born"
         ? new AkumaNotBornError(failure.id)
-        : new AkumaObservationError(failure.id, failure.diagnostic);
+        : failure.kind === "akuma-self-interrupt"
+            ? new AkumaSelfInterruptError(failure.id)
+            : new AkumaObservationError(failure.id, failure.diagnostic);
 }
 function decodeSelectionRequest(action, value) {
     const schema = action === "akuma.wait"

package/build/src/akuma/turn-drive.js

@@ -1,6 +1,6 @@
 import { abortableDelay } from "./abort.js";
 /* eslint-disable max-lines-per-function -- Turn setup and consumption each preserve one ordered lifecycle transaction. */
-import { appendActivity, beginTurn, bindTellsToTurn, breakBody, drainPendingTells, heartExists, readHeart, recordCurrentModel, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
+import { appendActivity, beginTurn, bindTellsToTurn, BodyControlledError, breakBody, drainPendingTells, heartExists, readHeart, recordCurrentModel, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
 import { withoutModel } from "./provider-recipe.js";
 import { encodeAgentEvent, } from "./provider.js";
 import { akumaCallRequestCommands } from "./call-request.js";
@@ -168,7 +168,6 @@ async function startTurnDrive(input) {
         return {
             turnSequence: turn.sequence,
             attempt,
-            custodyFailure,
             drive: selected,
             requests,
             cwd,
@@ -252,9 +251,6 @@ function pumpReceipts(writers) {
 function observeFailure(settlement) {
     return settlement.then(() => new Promise(() => { }), (error) => Promise.reject(error));
 }
-function observeCompletionFailure(drive) {
-    return drive.completion.then(() => new Promise(() => { }), (error) => ({ kind: "completion-failed", error }));
-}
 async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
     const { input, turnSequence, drive, writeWitness, mayWrite } = writers;
     for (const tell of pending) {
@@ -262,10 +258,10 @@ async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
             continue;
         attempted.add(tell.id);
         const outcome = await writeWitness(async () => {
+            await bindTellsToTurn(input.paths, { turnSequence, tellIds: [tell.id], boundAt: input.now() });
             const submission = await tellLive({ id: tell.id, text: tell.body });
             if (!mayWrite() || submission.kind === "turn-ended")
                 return "turn-ended";
-            await bindTellsToTurn(input.paths, { turnSequence, tellIds: [tell.id], boundAt: input.now() });
             await recordTellDeliveries(input.paths, [
                 {
                     tellId: tell.id,
@@ -344,8 +340,14 @@ function createTurnWakeups(observeHeart) {
         failure: (source) => {
             void source.then(() => undefined, (error) => publish({ kind: "failed", error }));
         },
-        completionFailed: (source) => {
-            void source.then((wakeup) => publish(wakeup));
+        completion: (source) => {
+            void source.then((result) => publish({ kind: "completion", result }), (error) => publish({ kind: "failed", error }));
+        },
+        closure: (source) => {
+            void source.then(() => publish({ kind: "closed" }), (error) => publish({ kind: "failed", error }));
+        },
+        drained: (source) => {
+            void source.then(() => publish({ kind: "drained" }), (error) => publish({ kind: "failed", error }));
         },
         next: () => {
             const ready = queue.shift();
@@ -372,72 +374,101 @@ async function consumeTurnDrive(input, active) {
     const mayWrite = () => writesOpen && !input.supervisor.signal.aborted;
     const writers = { input, turnSequence, drive, writeWitness, mayWrite };
     const receiptFailure = observeFailure(pumpReceipts(writers));
-    const completionFailure = observeCompletionFailure(drive);
     const iterator = drive.events[Symbol.asyncIterator]();
     const witness = { written: false, model: undefined };
     let liveTells = true;
     let tellPump = null;
+    let eventsEnded = false;
+    let result;
+    let attemptClosed = false;
+    let effectsDrained = false;
+    let drainArmed = false;
+    let drainingEffects;
     const wakeups = createTurnWakeups((after) => input.supervisor.next(after));
+    /**
+     * Consumes exactly one wake. A replaced Heart snapshot rearms its own observation, a settled Tell
+     * pump releases that source, and a provider event keeps its order: end, write, coordinate, next pull.
+     */
+    const reduceWakeup = async (next) => {
+        switch (next.kind) {
+            case "failed":
+                throw next.error;
+            case "heart":
+                heart = next.observation;
+                wakeups.heart(heart);
+                return;
+            case "tell":
+                tellPump = null;
+                liveTells = next.result === "live";
+                return;
+            case "completion":
+                result = next.result;
+                liveTells = false;
+                return;
+            case "closed":
+                attemptClosed = true;
+                return;
+            case "drained":
+                effectsDrained = true;
+                drainArmed = false;
+                return;
+            case "event":
+                break;
+        }
+        if (next.event.done) {
+            eventsEnded = true;
+            return;
+        }
+        await writeProviderEvent(input, active, next.event.value, witness);
+        if (next.event.value.type === "session")
+            turnSession = next.event.value.coordinate;
+        wakeups.event(iterator.next());
+    };
+    /** Completion waits for ended events, an outcome, a closed attempt, and no live Tell pump. */
+    const ready = () => eventsEnded && result !== undefined && attemptClosed && tellPump === null;
+    /** Retirement decides the ending: only a provider that could not retire replaces the requested one. */
+    const stopAndReturn = async (outcome) => {
+        const retirement = await stopActiveDrive(input, active);
+        return retirement.kind === "hung" ? retirement : outcome;
+    };
     wakeups.event(iterator.next());
     wakeups.heart(heart);
     wakeups.failure(receiptFailure);
     wakeups.failure(requests.failure);
-    wakeups.failure(active.custodyFailure);
-    wakeups.completionFailed(completionFailure);
+    wakeups.completion(drive.completion);
+    wakeups.closure(active.attempt.closed);
     try {
         for (;;) {
             if (input.supervisor.signal.aborted) {
                 writesOpen = false;
-                const retirement = await stopActiveDrive(input, active);
-                return retirement.kind === "hung" ? retirement : { kind: "stopped" };
+                return await stopAndReturn({ kind: "stopped" });
             }
-            if (hasUnattemptedTell(liveTells, tellPump, heart.pending, attempted)) {
+            if (result === undefined && hasUnattemptedTell(liveTells, tellPump, heart.pending, attempted)) {
                 if (drive.tell === undefined) {
                     writesOpen = false;
-                    const retirement = await stopActiveDrive(input, active);
-                    return retirement.kind === "hung" ? retirement : { kind: "handoff" };
+                    return await stopAndReturn({ kind: "handoff" });
                 }
                 tellPump = submitPendingLiveTells(writers, heart.pending, attempted, drive.tell);
                 wakeups.tell(tellPump);
             }
-            const next = await wakeups.next();
-            if (next.kind === "completion-failed") {
-                requests.stopAdmission();
-                throw next.error;
+            await reduceWakeup(await wakeups.next());
+            if (ready() && !drainArmed) {
+                drainingEffects ??= writeWitness.drain();
+                drainArmed = true;
+                wakeups.drained(drainingEffects);
             }
-            if (next.kind === "failed")
-                throw next.error;
-            if (next.kind === "heart") {
-                heart = next.observation;
-                wakeups.heart(heart);
-                continue;
-            }
-            if (next.kind === "tell") {
-                tellPump = null;
-                liveTells = next.result === "live";
-                continue;
+            if (ready() && effectsDrained) {
+                writesOpen = false;
+                return await settleCompletion(result, turnSession, active);
             }
-            if (next.event.done)
-                break;
-            await writeProviderEvent(input, active, next.event.value, witness);
-            if (next.event.value.type === "session")
-                turnSession = next.event.value.coordinate;
-            wakeups.event(iterator.next());
         }
-        const result = await drive.completion;
-        await active.attempt.closed;
-        if (tellPump !== null)
-            await tellPump;
-        await writeWitness.drain();
-        writesOpen = false;
-        return await settleCompletion(result, turnSession, active);
     }
     catch (error) {
         writesOpen = false;
-        if (input.supervisor.signal.aborted) {
-            const retirement = await stopActiveDrive(input, active);
-            return retirement.kind === "hung" ? retirement : { kind: "stopped" };
-        }
+        if (error instanceof BodyControlledError)
+            input.supervisor.cancel("control");
+        if (input.supervisor.signal.aborted)
+            return await stopAndReturn({ kind: "stopped" });
         const retirement = await retireProviderCustody(input, turnSequence, active.attempt);
         try {
             await requests.close();