@astrosheep/keiyaku 4.6.19 → 4.6.21

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

@@ -42,7 +42,7 @@ function piCreateOptions(sdk, input, services) {
             sdk.createBashToolDefinition(input.cwd, {
                 spawnHook: (context) => ({
                     ...context,
-                    env: akumaExecutionEnvironment(context.env, {}, input.requests.dir, ["PI_SESSION_ID", "PI_SESSION_FILE"]),
+                    env: akumaExecutionEnvironment(context.env, {}, input.requests.dir, ["PI_SESSION_ID", "PI_SESSION_FILE"], input.execution),
                 }),
             }),
         ];
@@ -58,17 +58,25 @@ async function createPiSession(sdk, execution, input) {
     if (execution.config !== undefined) {
         throw new TypeError("Pi provider config cannot be consumed by native CreateAgentSessionOptions");
     }
+    const personality = input.options.systemPrompt;
+    const append = [
+        ...(input.options.systemPromptMode === "append" && personality !== undefined ? [personality] : []),
+        ...(input.runtimeInstructions === undefined ? [] : [input.runtimeInstructions]),
+    ];
     const services = await sdk.createAgentSessionServices({
         cwd: input.cwd,
         agentDir: sdk.getAgentDir(),
         modelRuntimeSignal: input.signal,
-        ...(input.options.systemPrompt === undefined
-            ? {}
-            : {
-                resourceLoaderOptions: input.options.systemPromptMode === "append"
-                    ? { appendSystemPromptOverride: (base) => [...base, input.options.systemPrompt] }
-                    : { systemPromptOverride: () => input.options.systemPrompt },
-            }),
+        // A positive restriction is applied after resource loading, before startup.
+        // If the optional shipped extension is absent Pi collects an unknown-option
+        // diagnostic; it is not a setup failure and must not disable other resources.
+        extensionFlagValues: new Map([["keiyaku-request-only", true]]),
+        resourceLoaderOptions: {
+            ...(personality === undefined || input.options.systemPromptMode === "append"
+                ? {}
+                : { systemPromptOverride: () => personality }),
+            appendSystemPromptOverride: (base) => [...base, ...append],
+        },
     });
     const extensionErrors = services.resourceLoader.getExtensions().errors ?? [];
     for (const failure of extensionErrors)
@@ -170,6 +178,7 @@ async function drivePi(sdk, execution, input, signal, custody) {
     let unsubscribeAgent;
     let unsubscribe;
     let binding;
+    let prompting;
     const settle = (result) => {
         if (state.settled)
             return closed;
@@ -200,6 +209,10 @@ async function drivePi(sdk, execution, input, signal, custody) {
             catch (error) {
                 failure ??= error;
             }
+            // dispose() only requests abort. Owned tool/prompt work must actually
+            // finish before this attempt can certify retirement. The prompt callback
+            // initiates settlement without awaiting closed, so this cannot await itself.
+            await prompting;
             if (failure !== undefined)
                 throw failure;
         })().then(settleRetired, failRetired);
@@ -258,8 +271,12 @@ async function drivePi(sdk, execution, input, signal, custody) {
     const sessionModel = piSessionModel(native.model);
     if (sessionModel !== undefined)
         events.emit(modelEvent(sessionModel));
-    void runPiPrompt(native, input, eventState, state, (result) => {
-        void settle(result).catch(() => undefined);
+    prompting = Promise.resolve().then(async () => {
+        if (signal.aborted || state.settled)
+            return;
+        await runPiPrompt(native, input, eventState, state, (result) => {
+            void settle(result).catch(() => undefined);
+        });
     });
     return {
         admission: { fence: native.sessionId },

package/build/src/akuma/publication.d.ts

@@ -1,7 +1,7 @@
 import { type AkumaCaller } from "./caller.js";
 import { type Soul } from "./heart/index.js";
 import { type AllocatedAkuma, type AkumaPaths, type AkuId } from "./identity.js";
-import type { OwnedProcess } from "../runtime/proc/run.js";
+import type { LiveBodyLaunch } from "./body-launch.js";
 import type { RequestRecipe } from "./heart/facts.js";
 import type { CallInitialTell, CallInitialTellAdmission, TellResult } from "./call-initial-tell.js";
 import { type WorldRoot } from "../world.js";
@@ -14,7 +14,7 @@ export type BirthInput = Readonly<{
 export type LaunchInput = Readonly<{
     allocated: AllocatedAkuma;
     awaitAsleep?: boolean;
-    launch(allocated: AllocatedAkuma): Promise<OwnedProcess | void>;
+    launch(allocated: AllocatedAkuma): Promise<LiveBodyLaunch | void>;
     signal?: AbortSignal;
 }>;
 export declare function publishAkuma(input: BirthInput & Omit<LaunchInput, "allocated">): Promise<AllocatedAkuma>;
@@ -46,7 +46,7 @@ export type PreparedCallInitialTellAdmission = Readonly<{
 }>;
 type PreparedCallPorts = Readonly<{
     /** Spawn one already-allocated child; publication already owns the allocated directory. */
-    spawn(launch: PreparedCallSpawn): Promise<OwnedProcess | void>;
+    spawn(launch: PreparedCallSpawn): Promise<LiveBodyLaunch | void>;
     /** Admit the optional initial Tell against the just-confirmed child. */
     admitInitialTell(input: PreparedCallInitialTellAdmission): Promise<CallInitialTellAdmission>;
 }>;
@@ -82,6 +82,7 @@ type PreparedCallResult = Readonly<{
 type PreparedCallInput = Readonly<{
     archetype: string;
     cwd: string;
+    writableDirectories?: readonly string[];
     caller?: AkumaCaller;
     initialTell?: CallInitialTell;
     signal?: AbortSignal;

package/build/src/akuma/publication.js

@@ -4,11 +4,14 @@ import { acquireLeash } from "./control.js";
 import { allocateAkumaDirectory } from "./identity.js";
 import { abortableDelay } from "./abort.js";
 import { clipAllowedActions } from "./allowed.js";
-import { resolveProviderExecution } from "./providers/index.js";
+import { resolveProviderExecution, withWritableDirectories } from "./providers/index.js";
+import { writableDirectoriesOption } from "./call-input.js";
 import { World } from "../world.js";
 const POLL_MS = 100;
 const CUSTODY_HANDOFF_MS = 1_000;
 export const BIRTH_TIMEOUT_MS = 30_000;
+class LaunchCompletedError extends Error {
+}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -46,15 +49,12 @@ async function observedBirthFailure(paths) {
         leash.release();
     }
 }
-function preAdmissionDiagnostic(exit) {
-    return exit.code === null ? `pre-admission signal ${exit.signal ?? "unknown"}` : `pre-admission exit ${exit.code}`;
-}
 async function observeSettledExit(owned) {
     if (owned === undefined)
         return { kind: "pending" };
     const pending = Symbol("pending");
     try {
-        const exit = await Promise.race([owned.exited, Promise.resolve(pending)]);
+        const exit = await Promise.race([owned.completed, Promise.resolve(pending)]);
         return exit === pending ? { kind: "pending" } : { kind: "exited", exit };
     }
     catch (error) {
@@ -63,14 +63,14 @@ async function observeSettledExit(owned) {
 }
 async function observeExitWithin(owned, milliseconds) {
     return await Promise.race([
-        owned.exited.then((exit) => ({ kind: "exited", exit }), (error) => ({ kind: "exit-error", error })),
+        owned.completed.then((exit) => ({ kind: "exited", exit }), (error) => ({ kind: "exit-error", error })),
         abortableDelay(milliseconds).then(() => ({ kind: "timeout" })),
     ]);
 }
 async function attemptTermination(owned, force = false) {
     const outcome = await Promise.race([
         Promise.resolve()
-            .then(() => owned.terminate(force))
+            .then(() => owned.cancel(force))
             .then(() => ({ kind: "terminated" }), (error) => ({ kind: "error", error })),
         abortableDelay(CUSTODY_HANDOFF_MS).then(() => ({ kind: "timeout" })),
     ]);
@@ -87,7 +87,7 @@ async function awaitBirth(paths, owned, signal) {
         if (failure !== null) {
             const settled = await observeSettledExit(owned);
             if (settled.kind === "exited")
-                throw new Error(preAdmissionDiagnostic(settled.exit));
+                throw new LaunchCompletedError(settled.exit.diagnostic);
             if (settled.kind === "exit-error")
                 throw new Error(diagnostic(settled.error));
             throw new Error(failure);
@@ -106,7 +106,7 @@ async function awaitBirth(paths, owned, signal) {
         }
         const outcome = await Promise.race([
             abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal).then(() => "poll"),
-            owned.exited.then((exit) => ({ kind: "exited", exit }), (error) => ({ kind: "exit-error", error })),
+            owned.completed.then((exit) => ({ kind: "exited", exit }), (error) => ({ kind: "exit-error", error })),
         ]);
         if (outcome === "poll")
             continue;
@@ -114,7 +114,7 @@ async function awaitBirth(paths, owned, signal) {
             const settledSoul = await readSoul(paths);
             if (settledSoul !== null)
                 return settledSoul;
-            throw new Error(preAdmissionDiagnostic(outcome.exit));
+            throw new LaunchCompletedError(outcome.exit.diagnostic);
         }
         throw new Error(diagnostic(outcome.error));
     }
@@ -154,8 +154,7 @@ async function settleLaunch(allocated, owned, failure) {
     let terminationError;
     let exitError;
     let outcome;
-    const preAdmissionExit = diagnostic(failure).startsWith("pre-admission ");
-    const settled = preAdmissionExit ? await observeSettledExit(owned) : { kind: "pending" };
+    const settled = failure instanceof LaunchCompletedError ? await observeSettledExit(owned) : { kind: "pending" };
     if (settled.kind !== "exited") {
         terminationError = await attemptTermination(owned);
         const exit = await observeSettledExit(owned);
@@ -163,7 +162,7 @@ async function settleLaunch(allocated, owned, failure) {
             exitError = exit.error;
     }
     else {
-        /* An already-settled pre-admission exit needs no second termination request. */
+        /* An already-observed launch completion needs no second cancellation request. */
     }
     if ((await readSoul(allocated.paths)) !== null) {
         await allocatedSoul(allocated);
@@ -300,10 +299,12 @@ export function callDiagnostic(error) {
  * decoded execution to its adapter, admit the raw options once, and clip the
  * requested actions only when a parent ceiling applies.
  */
-async function admittedRecipe(recipe, bounds = {}) {
+async function admittedRecipe(recipe, input, bounds = {}) {
     let selected;
     try {
-        selected = await resolveProviderExecution(recipe.provider);
+        const directories = await writableDirectoriesOption(input.writableDirectories);
+        const provider = await withWritableDirectories(recipe.provider, input.cwd, directories, input.signal);
+        selected = await resolveProviderExecution(provider);
     }
     catch (error) {
         if (error instanceof TypeError)
@@ -317,10 +318,11 @@ async function admittedRecipe(recipe, bounds = {}) {
         throw new PreparedCallAdmissionError("options", admission.diagnostic);
     }
     return Object.freeze({
-        ...(recipe.description === undefined ? {} : { description: recipe.description }),
+        ...recipe,
         provider: selected.execution,
         options: admission.options,
         allowed: bounds.ceiling === undefined ? recipe.allowed : clipAllowedActions(recipe.allowed, bounds.ceiling),
+        ...(recipe.bare === undefined ? {} : { bare: recipe.bare }),
     });
 }
 /** Judge durable birth from the allocated child's own evidence, never from the caught error. */
@@ -355,8 +357,8 @@ export async function executePreparedCall(input) {
         world = custody.world;
     }
     const recipe = custody.kind === "request"
-        ? await admittedRecipe(custody.recipe, { ceiling: custody.parent.allowed, refuse: custody.refuse })
-        : await admittedRecipe(custody.recipe);
+        ? await admittedRecipe(custody.recipe, input, { ceiling: custody.parent.allowed, refuse: custody.refuse })
+        : await admittedRecipe(custody.recipe, input);
     const origin = custody.kind === "request"
         ? { kind: "request", parent: custody.parent.id, requestId: custody.requestId }
         : { kind: "direct" };
@@ -385,6 +387,7 @@ export async function executePreparedCall(input) {
                         provider: recipe.provider,
                         options: recipe.options,
                         allowed: recipe.allowed,
+                        ...(recipe.bare === undefined ? {} : { bare: recipe.bare }),
                         cwd: input.cwd,
                         origin,
                         ...(caller === undefined ? {} : { caller }),

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

@@ -101,6 +101,13 @@ declare const akumaObservationSchema: z.ZodObject<{
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"row">;
                 row: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"report">;
+                    sequence: z.ZodNumber;
+                    bodySequence: z.ZodNumber;
+                    turnSequence: z.ZodNumber;
+                    text: z.ZodString;
+                    at: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
                     kind: z.ZodLiteral<"call">;
                     sequence: z.ZodNumber;
                     turnSequence: z.ZodNumber;
@@ -306,6 +313,9 @@ declare const akumaObservationSchema: z.ZodObject<{
                     kind: z.ZodLiteral<"failed">;
                     historyId: z.ZodString;
                     diagnostic: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"canceled">;
+                    historyId: z.ZodString;
                 }, z.core.$strict>]>;
             }, z.core.$strict>>;
             entries: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
@@ -314,6 +324,13 @@ declare const akumaObservationSchema: z.ZodObject<{
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"row">;
                 row: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"report">;
+                    sequence: z.ZodNumber;
+                    bodySequence: z.ZodNumber;
+                    turnSequence: z.ZodNumber;
+                    text: z.ZodString;
+                    at: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
                     kind: z.ZodLiteral<"call">;
                     sequence: z.ZodNumber;
                     turnSequence: z.ZodNumber;
@@ -590,6 +607,13 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                 }, z.core.$strict>, z.ZodObject<{
                     kind: z.ZodLiteral<"row">;
                     row: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodLiteral<"report">;
+                        sequence: z.ZodNumber;
+                        bodySequence: z.ZodNumber;
+                        turnSequence: z.ZodNumber;
+                        text: z.ZodString;
+                        at: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"call">;
                         sequence: z.ZodNumber;
                         turnSequence: z.ZodNumber;
@@ -795,6 +819,9 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                         kind: z.ZodLiteral<"failed">;
                         historyId: z.ZodString;
                         diagnostic: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"canceled">;
+                        historyId: z.ZodString;
                     }, z.core.$strict>]>;
                 }, z.core.$strict>>;
                 entries: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
@@ -803,6 +830,13 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                 }, z.core.$strict>, z.ZodObject<{
                     kind: z.ZodLiteral<"row">;
                     row: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodLiteral<"report">;
+                        sequence: z.ZodNumber;
+                        bodySequence: z.ZodNumber;
+                        turnSequence: z.ZodNumber;
+                        text: z.ZodString;
+                        at: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"call">;
                         sequence: z.ZodNumber;
                         turnSequence: z.ZodNumber;
@@ -1361,6 +1395,13 @@ export declare const selectionResultSchemas: {
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"row">;
                         row: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                            kind: z.ZodLiteral<"report">;
+                            sequence: z.ZodNumber;
+                            bodySequence: z.ZodNumber;
+                            turnSequence: z.ZodNumber;
+                            text: z.ZodString;
+                            at: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"call">;
                             sequence: z.ZodNumber;
                             turnSequence: z.ZodNumber;
@@ -1566,6 +1607,9 @@ export declare const selectionResultSchemas: {
                             kind: z.ZodLiteral<"failed">;
                             historyId: z.ZodString;
                             diagnostic: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"canceled">;
+                            historyId: z.ZodString;
                         }, z.core.$strict>]>;
                     }, z.core.$strict>>;
                     entries: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
@@ -1574,6 +1618,13 @@ export declare const selectionResultSchemas: {
                     }, z.core.$strict>, z.ZodObject<{
                         kind: z.ZodLiteral<"row">;
                         row: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                            kind: z.ZodLiteral<"report">;
+                            sequence: z.ZodNumber;
+                            bodySequence: z.ZodNumber;
+                            turnSequence: z.ZodNumber;
+                            text: z.ZodString;
+                            at: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
                             kind: z.ZodLiteral<"call">;
                             sequence: z.ZodNumber;
                             turnSequence: z.ZodNumber;

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

@@ -1,4 +1,5 @@
 import type { WorldRoot } from "../world.js";
+import type { BodyLauncher } from "./body-launch.js";
 import type { AkumaStatus } from "./akuma.js";
 import type { SelectionRequestPort } from "./selection-request.js";
 /**
@@ -10,4 +11,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, servingBodyId?: AkumaStatus["id"]): SelectionRequestPort;
+export declare function selectionRequestPort(world: WorldRoot, spawn: BodyLauncher, servingBodyId?: AkumaStatus["id"]): SelectionRequestPort;

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

@@ -12,7 +12,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, servingBodyId) {
+export function selectionRequestPort(world, spawn, servingBodyId) {
     const prove = async (targets) => {
         for (const id of targets)
             await requireBornAkuma(world, id);
@@ -33,13 +33,14 @@ export function selectionRequestPort(world, _reportDiagnostic, servingBodyId) {
             if (request.interrupt === true && servingBodyId === target)
                 throw new AkumaSelfInterruptError(target);
             await prove([target]);
-            return await executeTellAkuma({ path: world, id: target, ...request });
+            return await executeTellAkuma({ path: world, id: target, spawn, ...request });
         },
         ask: async ({ target, ...request }) => {
             if (request.interrupt === true && servingBodyId === target)
                 throw new AkumaSelfInterruptError(target);
             await prove([target]);
             return await executeAskAkuma({
+                spawn,
                 path: world,
                 id: target,
                 ...request,
@@ -47,7 +48,7 @@ export function selectionRequestPort(world, _reportDiagnostic, servingBodyId) {
         },
         kill: async ({ targets, ...request }) => {
             await prove(targets);
-            return await executeKillAkuma({ path: world, ids: targets, ...request });
+            return await executeKillAkuma({ path: world, ids: targets, spawn, ...request });
         },
     };
 }

package/build/src/akuma/turn-drive.d.ts

@@ -1,12 +1,13 @@
 import { type ResumeCoordinate, type Soul, type TellFact } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
+import { type ExecutionAssociationReader } from "./execution-instructions.js";
 import type { CallInitialTellAdmission } from "./call-initial-tell.js";
 import type { InitialTellAdmissionRequest } from "./call-request.js";
 import { type ProviderAdapter, type TurnResult } from "./provider.js";
 import { type AkumaCallRequestChildLaunch } from "./call-request.js";
 import { type ErasedRequestCommand } from "./request-wire.js";
 import { BodySupervisor } from "./body-supervisor.js";
-import type { OwnedProcess } from "../runtime/proc/run.js";
+import type { LiveBodyLaunch } from "./body-launch.js";
 export declare function turnRecipe(paths: AkumaPaths, soul: Soul): Promise<Readonly<{
     cwd: string;
     options: Soul["options"];
@@ -30,10 +31,11 @@ export type DriveTurnInput = Readonly<{
     initiator?: string;
     schemaJson?: string;
     supervisor: BodySupervisor;
-    runtimeSpawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;
+    runtimeSpawn(launch: AkumaCallRequestChildLaunch): Promise<LiveBodyLaunch | void>;
     admitInitialTell(input: InitialTellAdmissionRequest): Promise<CallInitialTellAdmission>;
     world: import("../world.js").WorldRoot;
     externalCommands: Readonly<Record<string, ErasedRequestCommand>>;
+    executionAssociation?: ExecutionAssociationReader;
     turnStarted: Readonly<{
         emit(turnSequence: number): Promise<void>;
     }>;

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

@@ -1,6 +1,7 @@
-import { abortableDelay } from "./abort.js";
+import { abortable, abortableDelay } from "./abort.js";
 /* eslint-disable max-lines-per-function -- Turn setup and consumption each preserve one ordered lifecycle transaction. */
 import { appendActivity, beginTurn, bindTellsToTurn, BodyControlledError, breakBody, drainPendingTells, heartExists, readHeart, recordCurrentModel, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
+import { keiyakuExecutionInstructions } from "./execution-instructions.js";
 import { withoutModel } from "./provider-recipe.js";
 import { encodeAgentEvent, } from "./provider.js";
 import { akumaCallRequestCommands } from "./call-request.js";
@@ -85,10 +86,36 @@ async function writeProviderEvent(input, active, event, witness) {
     }
     await appendActivity(input.paths, { turnSequence: active.turnSequence, event: encodeAgentEvent(event), at });
 }
+function startProviderAttempt(input, setup) {
+    const { cwd, options, session } = setup.recipe;
+    const driveInput = {
+        body: input.body,
+        launchTells: setup.tells.map((tell) => ({ id: tell.id, text: tell.body })),
+        cwd,
+        options,
+        signal: setup.signal,
+        execution: {
+            akumaId: input.soul.id,
+            world: input.world,
+            bodySequence: input.bodySequence,
+            turnSequence: setup.turnSequence,
+        },
+        requests: { dir: setup.requests.directory, entry: setup.requests.entry },
+        ...(setup.runtimeInstructions === undefined ? {} : { runtimeInstructions: setup.runtimeInstructions }),
+        ...(setup.schemaJson === undefined ? {} : { schemaJson: setup.schemaJson }),
+    };
+    return session === undefined
+        ? input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
+        : input.adapter.resume({ ...driveInput, session: { kind: "resume", coordinate: session } });
+}
 async function startTurnDrive(input) {
-    const { cwd, options, session } = await turnRecipe(input.paths, input.soul);
+    if (input.supervisor.signal.aborted)
+        return { kind: "stopped" };
+    const recipe = await turnRecipe(input.paths, input.soul);
+    const { session } = recipe;
     if (session !== undefined && input.adapter.resume === undefined)
         return { kind: "resume-unsupported" };
+    const runtimeInstructions = keiyakuExecutionInstructions(input.soul, input.soul.bare !== false ? undefined : await input.executionAssociation?.());
     const boundTells = drainPendingTells(input.launchTells);
     const schemaJson = input.schemaJson ?? boundTells.find((tell) => tell.schemaJson !== undefined)?.schemaJson;
     const initiator = input.call === undefined ? boundTells[0]?.initiator : input.initiator;
@@ -107,6 +134,8 @@ async function startTurnDrive(input) {
         });
     }
     await input.turnStarted.emit(turn.sequence);
+    if (input.supervisor.signal.aborted)
+        return { kind: "stopped" };
     const { world, paths, soul: parent, runtimeSpawn: spawn, externalCommands, admitInitialTell } = input;
     const commands = composeRequestCommands(akumaCallRequestCommands({ world, paths, parent, spawn, admitInitialTell }), externalCommands);
     const requests = await BodyRequestPump.open({
@@ -117,6 +146,15 @@ async function startTurnDrive(input) {
         commands,
         signal: input.supervisor.signal,
     });
+    return await establishTurnDrive(input, turn.sequence, requests, {
+        ...recipe,
+        boundTells,
+        ...(schemaJson === undefined ? {} : { schemaJson }),
+        ...(runtimeInstructions === undefined ? {} : { runtimeInstructions }),
+    });
+}
+async function establishTurnDrive(input, turnSequence, requests, recipe) {
+    const { cwd, options, session, boundTells, schemaJson, runtimeInstructions } = recipe;
     const driveController = new AbortController();
     const cancelDrive = () => {
         if (!driveController.signal.aborted)
@@ -129,24 +167,21 @@ async function startTurnDrive(input) {
         if (!driveController.signal.aborted)
             driveController.abort(error);
     });
-    const driveInput = {
-        body: input.body,
-        launchTells: boundTells.map((tell) => ({ id: tell.id, text: tell.body })),
-        cwd,
-        options,
+    const attempt = startProviderAttempt(input, {
+        recipe,
+        tells: boundTells,
+        requests,
         signal: driveController.signal,
-        requests: { dir: requests.directory, entry: requests.entry },
-        ...(schemaJson === undefined ? {} : { schemaJson }),
-    };
-    const attempt = session === undefined
-        ? input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
-        : input.adapter.resume({ ...driveInput, session: { kind: "resume", coordinate: session } });
+        turnSequence,
+        schemaJson,
+        runtimeInstructions,
+    });
     const custodyFailure = observeFailure(attempt.closed);
     try {
-        const selected = await Promise.race([attempt.result, requests.failure, custodyFailure]);
+        const selected = await abortable(Promise.race([attempt.result, requests.failure, custodyFailure]), input.supervisor.signal);
         if (input.supervisor.signal.aborted) {
             try {
-                const retirement = await retireProviderCustody(input, turn.sequence, attempt);
+                const retirement = await retireProviderCustody(input, turnSequence, attempt);
                 await requests.close();
                 if (retirement.kind === "hung")
                     return retirement;
@@ -160,13 +195,13 @@ async function startTurnDrive(input) {
             await recordTellDeliveries(input.paths, boundTells.map((tell) => ({
                 tellId: tell.id,
                 route: "launch",
-                turnSequence: turn.sequence,
+                turnSequence,
                 fence: selected.admission.fence,
                 deliveredAt: input.now(),
             })));
         void selected.completion.then(() => requests.stopAdmission(), () => undefined);
         return {
-            turnSequence: turn.sequence,
+            turnSequence,
             attempt,
             drive: selected,
             requests,
@@ -177,7 +212,7 @@ async function startTurnDrive(input) {
         };
     }
     catch (error) {
-        const retirement = await retireProviderCustody(input, turn.sequence, attempt);
+        const retirement = await retireProviderCustody(input, turnSequence, attempt);
         if (retirement.kind === "hung") {
             try {
                 await requests.close();
@@ -187,7 +222,7 @@ async function startTurnDrive(input) {
             }
             return retirement;
         }
-        return await failedTurnSetup(input, turn.sequence, requests, cancelDrive, error);
+        return await failedTurnSetup(input, turnSequence, requests, cancelDrive, error);
     }
 }
 async function retireProviderCustody(input, turnSequence, attempt) {
@@ -206,7 +241,7 @@ async function retireProviderCustody(input, turnSequence, attempt) {
             error: new Error(`provider custody remained live after ${CONTROL_RESPONSE_MS}ms`),
         })),
     ]);
-    let outcome = await dispose(attempt.abort);
+    let outcome = await dispose(input.supervisor.forceSignal?.aborted ? attempt.forceDispose : attempt.abort);
     if (outcome.kind === "retired")
         return outcome;
     outcome = await dispose(attempt.forceDispose);
@@ -429,7 +464,9 @@ async function consumeTurnDrive(input, active) {
     /** 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;
+        if (retirement.kind === "hung")
+            return retirement;
+        return input.supervisor.signal.aborted ? { kind: "stopped" } : outcome;
     };
     wakeups.event(iterator.next());
     wakeups.heart(heart);

package/build/src/akuma-body.d.ts

@@ -1,11 +1 @@
-import { type BodyLaunch } from "./akuma/body.js";
-import { World } from "./world.js";
-type BodyProcessConfiguration = Readonly<{
-    home?: string;
-    gitPath?: string;
-}>;
-export declare function externalRequestCommandsFor(launch: BodyLaunch, processConfiguration: BodyProcessConfiguration): Promise<Readonly<{
-    world: Awaited<ReturnType<typeof World.prove>>;
-    commands: Readonly<Record<string, import("./akuma/request-wire.js").ErasedRequestCommand>>;
-}>>;
 export {};