@astrosheep/keiyaku 4.5.7 → 4.5.8

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

@@ -1,7 +1,8 @@
 import { type ResumeCoordinate, type Soul, type TellFact } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 import { type ProviderAdapter, type TurnResult } from "./provider.js";
-import { type RequestChildLaunch, type UpstreamExecutionPort } from "./request-serve.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";
 export declare function turnRecipe(paths: AkumaPaths, soul: Soul): Promise<Readonly<{
@@ -25,8 +26,9 @@ export type DriveTurnInput = Readonly<{
     call?: string;
     launchTells: readonly TellFact[];
     supervisor: BodySupervisor;
-    runtimeSpawn(launch: RequestChildLaunch): Promise<OwnedProcess | void>;
-    upstream?: UpstreamExecutionPort;
+    runtimeSpawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;
+    upstream?: unknown;
+    commands: Readonly<Record<string, ErasedRequestCommand>>;
     now(): string;
 }>;
 export declare function driveTurn(input: DriveTurnInput): Promise<(DrivenTurn & Readonly<{

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

@@ -1,6 +1,7 @@
 import { abortableDelay } from "./abort.js";
+/* eslint-disable max-lines-per-function -- Turn setup and consumption each preserve one ordered lifecycle transaction. */
 import { appendActivity, beginTurn, breakBody, heartExists, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
-import { encodeAgentEvent } from "./provider.js";
+import { encodeAgentEvent, } from "./provider.js";
 import { BodyRequestPump } from "./request-serve.js";
 import { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function serializeEffects() {
@@ -79,6 +80,7 @@ async function startTurnDrive(input) {
         now: input.now,
         spawn: input.runtimeSpawn,
         ...(input.upstream === undefined ? {} : { upstream: input.upstream }),
+        commands: input.commands,
         signal: input.supervisor.signal,
     });
     const driveController = new AbortController();
@@ -101,14 +103,14 @@ async function startTurnDrive(input) {
         signal: driveController.signal,
         requests: { dir: requests.directory },
     };
-    const setup = session === undefined
+    const attempt = session === undefined
         ? input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
         : input.adapter.resume({ ...driveInput, session: { kind: "resume", coordinate: session } });
     try {
-        const selected = await Promise.race([setup, requests.failure]);
+        const selected = await Promise.race([attempt.result, requests.failure]);
         if (input.supervisor.signal.aborted) {
             try {
-                const retirement = await retireProviderCustody(input, turn.sequence, selected);
+                const retirement = await retireProviderCustody(input, turn.sequence, attempt);
                 await requests.close();
                 if (retirement.kind === "hung")
                     return retirement;
@@ -129,6 +131,7 @@ async function startTurnDrive(input) {
         void selected.completion.then(() => requests.stopAdmission(), () => undefined);
         return {
             turnSequence: turn.sequence,
+            attempt,
             drive: selected,
             requests,
             cwd,
@@ -138,21 +141,39 @@ async function startTurnDrive(input) {
         };
     }
     catch (error) {
+        const retirement = await retireProviderCustody(input, turn.sequence, attempt);
+        if (retirement.kind === "hung") {
+            try {
+                await requests.close();
+            }
+            finally {
+                input.supervisor.signal.removeEventListener("abort", cancelDrive);
+            }
+            return retirement;
+        }
         return await failedTurnSetup(input, turn.sequence, requests, cancelDrive, error);
     }
 }
-async function retireProviderCustody(input, turnSequence, drive) {
+async function retireProviderCustody(input, turnSequence, attempt) {
     const dispose = async (operation) => await Promise.race([
-        operation().then(() => ({ kind: "retired" }), (error) => ({ kind: "held", error })),
+        operation().then(async () => {
+            try {
+                await attempt.closed;
+                return { kind: "retired" };
+            }
+            catch (error) {
+                return { kind: "held", error };
+            }
+        }, (error) => ({ kind: "held", error })),
         abortableDelay(CONTROL_RESPONSE_MS).then(() => ({
             kind: "held",
             error: new Error(`provider custody remained live after ${CONTROL_RESPONSE_MS}ms`),
         })),
     ]);
-    let outcome = await dispose(drive.abort);
+    let outcome = await dispose(attempt.abort);
     if (outcome.kind === "retired")
         return outcome;
-    outcome = await dispose(drive.forceDispose);
+    outcome = await dispose(attempt.forceDispose);
     if (outcome.kind === "retired")
         return outcome;
     if (await heartExists(input.paths)) {
@@ -226,7 +247,7 @@ async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
 }
 async function stopActiveDrive(input, active) {
     try {
-        const retirement = await retireProviderCustody(input, active.turnSequence, active.drive);
+        const retirement = await retireProviderCustody(input, active.turnSequence, active.attempt);
         await active.requests.close();
         return retirement;
     }
@@ -308,6 +329,7 @@ async function consumeTurnDrive(input, active) {
             pending = iterator.next();
         }
         const result = await drive.completion;
+        await active.attempt.closed;
         if (tellPump !== null)
             await tellPump;
         await writeWitness.drain();
@@ -320,7 +342,7 @@ async function consumeTurnDrive(input, active) {
             const retirement = await stopActiveDrive(input, active);
             return retirement.kind === "hung" ? retirement : { kind: "stopped" };
         }
-        const retirement = await retireProviderCustody(input, turnSequence, drive);
+        const retirement = await retireProviderCustody(input, turnSequence, active.attempt);
         try {
             await requests.close();
         }

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

@@ -1,8 +1,13 @@
 import { type BodyLaunch } from "./akuma/body.js";
-import type { UpstreamExecutionPort } from "./akuma/request-serve.js";
+import { type WorldRoot } from "./world.js";
+import { type FleetRequestPort } from "./library/fleet.js";
+import { type ContractRequestPort } from "./library/contract-operations.js";
+import { type TaskMutationRequestPort } from "./task/mutation.js";
 type BodyProcessConfiguration = Readonly<{
     home?: string;
     gitPath?: string;
 }>;
-export declare function upstreamFor(launch: BodyLaunch, processConfiguration: BodyProcessConfiguration): UpstreamExecutionPort;
+export declare function upstreamFor(launch: BodyLaunch, processConfiguration: BodyProcessConfiguration): Promise<FleetRequestPort & ContractRequestPort & TaskMutationRequestPort & Readonly<{
+    launchWorld(): WorldRoot;
+}>>;
 export {};

package/build/src/akuma-body.js

@@ -1,47 +1,45 @@
 import { LEASH_HELD_EXIT, runAkumaBody } from "./akuma/body.js";
+import { akumaCallRequestCommands } from "./akuma/call-request.js";
 import { worldRootForAkumaPaths } from "./akuma/identity.js";
+import { World } from "./world.js";
 import { executeKillAkuma, executeTellAkuma, executeWaitAkuma } from "./library/fleet.js";
+import { fleetRequestCommands } from "./library/fleet.js";
 import { requireBranchesToBeUpToDateFrom, worktreeHooksFrom } from "./library/configuration.js";
-import { executeForwardedDeliver, executeForwardedReview } from "./library/contract.js";
+import { contractRequestCommands, executeForwardedAudit, executeForwardedDeliver, executeForwardedReview, } from "./library/contract-operations.js";
 import { Repo } from "./library/repo.js";
 import { settings } from "./settings.js";
-import { executeTaskMutation } from "./task/mutation.js";
-export function upstreamFor(launch, processConfiguration) {
-    const path = worldRootForAkumaPaths(launch.paths);
+import { executeTaskMutation, taskMutationRequestCommands } from "./task/mutation.js";
+async function contractDependencies(repoRoot, processConfiguration) {
+    const repo = await Repo.at({
+        path: repoRoot,
+        ...(processConfiguration.gitPath === undefined ? {} : { gitPath: processConfiguration.gitPath }),
+    });
+    if (repo.root !== repoRoot)
+        throw new TypeError("forwarded Contract repoRoot must equal the canonical primary worktree");
+    const world = await World.prove(repo.root);
+    const configuration = await settings({
+        root: world,
+        ...(processConfiguration.home === undefined ? {} : { home: processConfiguration.home }),
+    });
+    return [repo, configuration];
+}
+function contractUpstream(processConfiguration) {
     return {
-        wait: async (input) => await executeWaitAkuma({
-            path,
-            ids: input.targets,
-            completion: input.completion,
-            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
-            signal: input.signal,
-        }),
-        tell: async (input) => await executeTellAkuma({
-            path,
-            id: input.target,
-            body: input.body,
-            tellId: input.tellId,
-            recordedAt: input.recordedAt,
-            signal: input.signal,
-        }),
-        kill: async (input) => {
-            const result = await executeKillAkuma({ path, ids: input.targets, signal: input.signal });
-            return {
-                result,
-                service: result.results.map(({ id, evidence }) => ({ id, evidence })),
-            };
+        audit: async (input) => {
+            const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
+            return await executeForwardedAudit({
+                repo,
+                contractId: input.contractId,
+                requester: input.requester,
+                includeDirty: input.includeDirty,
+                showDiff: input.showDiff,
+                requireBranchesToBeUpToDate: requireBranchesToBeUpToDateFrom({ settings: configuration }),
+                hooks: worktreeHooksFrom({ settings: configuration }),
+                signal: input.signal,
+            });
         },
         deliver: async (input) => {
-            const [repo, configuration] = await Promise.all([
-                Repo.at({
-                    path: input.repoRoot,
-                    ...(processConfiguration.gitPath === undefined ? {} : { gitPath: processConfiguration.gitPath }),
-                }),
-                settings({
-                    root: input.repoRoot,
-                    ...(processConfiguration.home === undefined ? {} : { home: processConfiguration.home }),
-                }),
-            ]);
+            const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
             return await executeForwardedDeliver({
                 repo,
                 contractId: input.contractId,
@@ -55,16 +53,7 @@ export function upstreamFor(launch, processConfiguration) {
             });
         },
         review: async (input) => {
-            const [repo, configuration] = await Promise.all([
-                Repo.at({
-                    path: input.repoRoot,
-                    ...(processConfiguration.gitPath === undefined ? {} : { gitPath: processConfiguration.gitPath }),
-                }),
-                settings({
-                    root: input.repoRoot,
-                    ...(processConfiguration.home === undefined ? {} : { home: processConfiguration.home }),
-                }),
-            ]);
+            const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
             return await executeForwardedReview({
                 repo,
                 contractId: input.contractId,
@@ -74,6 +63,32 @@ export function upstreamFor(launch, processConfiguration) {
                 hooks: worktreeHooksFrom({ settings: configuration }),
             });
         },
+    };
+}
+export async function upstreamFor(launch, processConfiguration) {
+    const world = await World.prove(worldRootForAkumaPaths(launch.paths));
+    return {
+        launchWorld: () => world,
+        ...contractUpstream(processConfiguration),
+        wait: async (input) => await executeWaitAkuma({
+            path: world,
+            ids: input.targets,
+            completion: input.completion,
+            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+            signal: input.signal,
+        }),
+        tell: async (input) => await executeTellAkuma({
+            path: world,
+            id: input.target,
+            body: input.body,
+            tellId: input.tellId,
+            recordedAt: input.recordedAt,
+            signal: input.signal,
+        }),
+        kill: async (input) => {
+            const result = await executeKillAkuma({ path: world, ids: input.targets, signal: input.signal });
+            return result;
+        },
         task: async (input) => await executeTaskMutation({
             world: input.world,
             request: input.request,
@@ -95,5 +110,12 @@ const configuration = {
     ...(mappedHome === undefined || mappedHome.length === 0 ? {} : { home: mappedHome }),
     ...(mappedGitPath === undefined ? {} : { gitPath: mappedGitPath }),
 };
-if ((await runAkumaBody(launch, upstreamFor(launch, configuration))) === "held")
+const upstream = await upstreamFor(launch, configuration);
+const commands = {
+    ...akumaCallRequestCommands(),
+    ...fleetRequestCommands(),
+    ...contractRequestCommands(),
+    ...taskMutationRequestCommands(),
+};
+if ((await runAkumaBody(launch, upstream, commands)) === "held")
     process.exitCode = LEASH_HELD_EXIT;

package/build/src/cli/accepted.d.ts

@@ -1,6 +1,6 @@
 import { type AmendResult, type AuditReport, type BindResult, type ContractId, type Delivery, type MutationResult, type Review } from "../index.js";
 import type { AcceptedAbandonResult, AcceptedAmendResult, AcceptedArcResult, AcceptedAuditResult, AcceptedBindResult, AcceptedDeliverResult, AcceptedResult, AcceptedReviewResult, InvocationResult } from "./result.js";
-type MutationObservation = Pick<MutationResult<unknown>, "facts" | "head" | "effects" | "lags" | "settlement">;
+type MutationObservation = Pick<MutationResult<unknown>, "facts" | "head" | "lags" | "settlementLags" | "recoverySnapshot">;
 type MutationCallOptions = Readonly<{
     coordinate?: ContractId;
     projectRefusal?: (refusal: unknown) => unknown;

package/build/src/cli/accepted.js

@@ -17,8 +17,8 @@ function acceptedEnvelope(result, coordinate) {
         contract,
         head: result.head,
         facts: acceptedFacts(result),
-        effects: result.effects,
-        settlement: result.settlement,
+        settlementLags: result.settlementLags,
+        ...(result.recoverySnapshot === undefined ? {} : { recoverySnapshot: result.recoverySnapshot }),
         ...(result.lags.length === 0 || firstLag === undefined ? {} : { lag: [firstLag, ...result.lags.slice(1)] }),
     };
 }

package/build/src/cli/commands/akuma-invoke.d.ts

@@ -4,6 +4,7 @@ import type { Settings } from "../../settings.js";
 import type { WorldRoot } from "../../world.js";
 import type { InvokedAkumaCommand } from "./akuma.js";
 import { finishCall } from "../../library/akuma-creation.js";
+import { type ExecutionContext } from "../../akuma/requests.js";
 export type AkumaInvocationResult = Readonly<{
     kind: "akuma";
     action: "call";
@@ -83,6 +84,7 @@ type InvokeInput = Readonly<{
     environment: NodeJS.ProcessEnv;
     readStdin(): Promise<string>;
     finishCall?: typeof finishCall;
+    execution?: ExecutionContext;
 }>;
 export declare function invokeAkuma(command: InvokedAkumaCommand, input: InvokeInput): Promise<AkumaInvocationResult>;
 export declare function invokeAkumaStatus(path: WorldRoot, akuma: string, alias?: string, repo?: Repo): Promise<AkumaInvocationResult>;

package/build/src/cli/commands/akuma-invoke.js

@@ -1,6 +1,14 @@
 import { Keiyaku, } from "../../index.js";
 import { beginCall, finishCall } from "../../library/akuma-creation.js";
+import { killAkuma, tellAkuma, waitAkuma } from "../../library/fleet.js";
+import { localExecutionContext } from "../../akuma/requests.js";
 import { recognizeAndListen } from "../square-edge.js";
+function withRollbackDiagnostic(primary, rollback) {
+    const primaryText = primary instanceof Error ? primary.message : String(primary);
+    const rollbackText = rollback instanceof Error ? rollback.message : String(rollback);
+    const error = new Error(`${primaryText}; ${rollbackText}`, { cause: primary });
+    return error;
+}
 function inputAlias(selector) {
     return selector.startsWith("@") ? selector : undefined;
 }
@@ -12,13 +20,13 @@ async function invokeWait(command, input) {
     return {
         kind: "akuma",
         action: "wait",
-        result: await Keiyaku.wait({
+        result: await waitAkuma({
             path: input.path,
             akuma: command.akuma,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
             ...(command.completion === undefined ? {} : { completion: command.completion }),
             ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
-        }),
+        }, input.execution ?? localExecutionContext()),
         ...(alias === undefined ? {} : { alias }),
     };
 }
@@ -41,12 +49,12 @@ async function invokeTell(command, input) {
             ...(alias === undefined ? {} : { alias }),
         };
     }
-    const result = await Keiyaku.tell({
+    const result = await tellAkuma({
         path: input.path,
         akuma: command.akuma,
         body,
         ...(input.repo === undefined ? {} : { repo: input.repo }),
-    });
+    }, input.execution ?? localExecutionContext());
     const alias = inputAlias(command.akuma);
     return { kind: "akuma", action: "tell", mode: "ordinary", result, body, ...(alias === undefined ? {} : { alias }) };
 }
@@ -93,11 +101,11 @@ async function invokeKill(command, input) {
     return {
         kind: "akuma",
         action: "kill",
-        result: await Keiyaku.kill({
+        result: await killAkuma({
             path: input.path,
             akuma: command.akuma,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
-        }),
+        }, input.execution ?? localExecutionContext()),
         ...(alias === undefined ? {} : { alias }),
     };
 }
@@ -118,7 +126,7 @@ export async function invokeAkuma(command, input) {
                 ...(input.contract === undefined ? {} : { contract: input.contract }),
                 ...(command.alias === undefined ? {} : { alias: command.alias }),
                 ...(command.allowed === undefined ? {} : { allowed: command.allowed }),
-            });
+            }, input.execution ?? localExecutionContext());
             const listener = born.born.kind === "born"
                 ? await recognizeAndListen(input.path, input.environment, born.born.allocated)
                 : undefined;
@@ -131,8 +139,8 @@ export async function invokeAkuma(command, input) {
                     try {
                         await listener.rollback();
                     }
-                    catch {
-                        /* preserve launch failure */
+                    catch (rollbackError) {
+                        throw withRollbackDiagnostic(error, rollbackError);
                     }
                 }
                 throw error;

package/build/src/cli/commands/akuma.js

@@ -17,7 +17,7 @@ const AKUMA_COMMAND_SPECS = {
             allowed: "repeatable",
             json: "boolean",
         },
-        usage: "call <akuma-name> [--contract <kei/...>] [--alias @name] [--readonly] [--allowed <product.action>]... [--wait <duration> | -d | --detach] (<prompt> | -)",
+        usage: "call <akuma-name> [--contract <kei/...>] [--alias @name] [--readonly] [--allowed <product.action>]... [--wait <duration> | -d | --detach] [--json] (<prompt> | -)",
         purpose: "Birth an Akuma from <akuma-name> with one prompt.",
         details: [
             "Give <prompt> as one argument, or use - to read stdin.",
@@ -33,14 +33,14 @@ const AKUMA_COMMAND_SPECS = {
         arity: "one-or-more",
         stdin: false,
         flags: { any: "boolean", all: "boolean", timeout: "value", json: "boolean" },
-        usage: "wait <akuma-selector>... [--any | --all] [--timeout <duration>]",
+        usage: "wait <akuma-selector>... [--any | --all] [--timeout <duration>] [--json]",
         purpose: "Wait for one Akuma or an explicitly selected Akuma set.",
     },
     tell: {
         arity: 1,
         stdin: true,
         flags: { interrupt: "boolean", json: "boolean" },
-        usage: "tell <aku/...|@alias> [--interrupt] (<prompt> | -)",
+        usage: "tell <aku/...|@alias> [--interrupt] [--json] (<prompt> | -)",
         purpose: "Send one prompt to an existing Akuma and wake it.",
         details: [
             "Give <prompt> as one argument, or use - to read stdin.",
@@ -51,21 +51,21 @@ const AKUMA_COMMAND_SPECS = {
         arity: 1,
         stdin: false,
         flags: { id: "value", before: "value", since: "value", limit: "value", last: "boolean", json: "boolean" },
-        usage: "history <aku/...|@alias|kei/...> [--id <historyId> | --before <index> | --since <index>] [--limit <count>] [--last]",
+        usage: "history <aku/...|@alias> [--id <historyId> | --before <index> | --since <index>] [--limit <count>] [--last] [--json]\nhistory <kei/...> [--json]",
         purpose: "Read Akuma execution history or one complete Contract journal and Dispatch timeline.",
     },
     fork: {
         arity: 1,
         stdin: false,
         flags: { at: "value", json: "boolean" },
-        usage: "fork <aku/...> --at <historyId>",
+        usage: "fork <aku/...|@alias> --at <historyId> [--json]",
         purpose: "Fork one Akuma at a retained answered history point.",
     },
     kill: {
         arity: "one-or-more",
         stdin: false,
         flags: { json: "boolean" },
-        usage: "kill <akuma-selector>...",
+        usage: "kill <akuma-selector>... [--json]",
         purpose: "Put down the current Body of an Akuma selector snapshot.",
     },
 };
@@ -76,7 +76,7 @@ export function isParsedAkumaCommand(command) {
     return isAkumaAction(command.command) && !("contract" in command && command.command === "history");
 }
 export function renderAkumaRootRows() {
-    return Object.values(AKUMA_COMMAND_SPECS).flatMap((spec) => [`  ${spec.usage}`, `    ${spec.purpose}`]);
+    return Object.entries(AKUMA_COMMAND_SPECS).map(([action, spec]) => `  keiyaku ${action}  ${spec.purpose}`);
 }
 export function renderAkumaHelp(action) {
     const spec = AKUMA_COMMAND_SPECS[action];

package/build/src/cli/commands/contract-invoke.d.ts

@@ -4,6 +4,7 @@ import type { WorktreeHooks } from "../../library/configuration.js";
 import type { Repo } from "../../library/repo.js";
 import type { Settings } from "../../settings.js";
 import type { WorldRoot } from "../../world.js";
+import type { ExecutionContext } from "../../akuma/requests.js";
 type ContractMutation = Extract<ParsedCommand, {
     command: "bind" | "amend" | "deliver" | "review" | "arc" | "abandon" | "audit";
 }>;
@@ -17,9 +18,9 @@ export type ContractMutationInput = Readonly<{
     edge: InvocationEdge;
     scope: string;
     configuration?: Settings;
-    hooks: WorktreeHooks;
+    hooks?: WorktreeHooks;
     establishWorld: () => Promise<WorldRoot>;
-    forwarded?: true;
+    execution: ExecutionContext;
 }>;
 export declare function invokeContractMutation(input: ContractMutationInput): Promise<InvocationResult>;
 export {};

package/build/src/cli/commands/contract-invoke.js

@@ -26,13 +26,13 @@ async function selectedGitPolicy(value) {
     const { requireBranchesToBeUpToDateFrom, SettingsError } = await import("../../library/configuration.js");
     return consumeSettings(() => requireBranchesToBeUpToDateFrom({ settings: value }), SettingsError);
 }
-async function selectContract(repo, selector, scope) {
+async function selectContract(repo, selector, scope, execution) {
     const { contractFromInput, resolveContextualContract } = await import("../selectors.js");
     if (selector !== undefined && !selector.startsWith("@"))
-        return contractFromInput(repo, selector);
+        return contractFromInput(repo, selector, execution);
     const { Keiyaku } = await import("../../library/keiyaku.js");
     const id = resolveContextualContract(await Keiyaku.list({ repo }), selector, scope);
-    return contractFromInput(repo, id);
+    return contractFromInput(repo, id, execution);
 }
 async function bindDraftReceipt(establishWorld, markdown) {
     const { preserveBindDraft } = await import("../draft.js");
@@ -51,7 +51,12 @@ async function invokeBind(input) {
     const { bindFromCommand } = await import("./bind.js");
     const { acceptedBind, resultFromMutationCall } = await import("../accepted.js");
     if (parsed.forkOf !== undefined) {
-        return resultFromMutationCall("bind", () => bindFromCommand({ command: parsed, repo, ...(actor === undefined ? {} : { actor }), hooks }), (accepted) => {
+        return resultFromMutationCall("bind", () => bindFromCommand({
+            command: parsed,
+            repo,
+            ...(actor === undefined ? {} : { actor }),
+            ...(hooks === undefined ? {} : { hooks }),
+        }), (accepted) => {
             const bound = accepted.facts.find((fact) => fact.kind === "bind");
             if (bound === undefined || bound.kind !== "bind")
                 throw new Error("accepted bind is missing its bind fact");
@@ -69,7 +74,7 @@ async function invokeBind(input) {
             markdown,
             gates,
             ...(actor === undefined ? {} : { actor }),
-            hooks,
+            ...(hooks === undefined ? {} : { hooks }),
         }), (accepted) => {
             const bound = accepted.facts.find((fact) => fact.kind === "bind");
             if (bound === undefined || bound.kind !== "bind")
@@ -95,10 +100,10 @@ function deliverRefusal(refusal) {
     return { ...refusal, option: { flag: "--include-dirty", available: submodules.length === 0 } };
 }
 async function existingSeat(input, parsed) {
-    const { repo, edge, scope, hooks } = input;
-    const { id, contract } = await selectContract(repo, parsed.contract, scope);
+    const { repo, edge, scope, hooks, execution } = input;
+    const { id, contract } = await selectContract(repo, parsed.contract, scope, execution);
     const actor = actorFromEdge(parsed.actor, edge.environment);
-    return { contract, id, ...(actor === undefined ? {} : { actor }), hooks };
+    return { contract, id, ...(actor === undefined ? {} : { actor }), ...(hooks === undefined ? {} : { hooks }) };
 }
 async function invokeDeliver(parsed, seat, requireBranchesToBeUpToDate) {
     const { acceptedDeliver } = await import("../accepted.js");
@@ -109,7 +114,7 @@ async function invokeDeliver(parsed, seat, requireBranchesToBeUpToDate) {
             requireBranchesToBeUpToDate,
             includeDirty: parsed.includeDirty,
             materializeConflict: parsed.materializeConflict,
-            hooks: seat.hooks,
+            ...(seat.hooks === undefined ? {} : { hooks: seat.hooks }),
         });
         if (!("facts" in delivered))
             return delivered;
@@ -132,11 +137,11 @@ async function invokeReview(parsed, seat, readStdin) {
         verdict: parsed.verdict,
         ...(seat.actor === undefined ? {} : { actor: seat.actor }),
         ...(summary === undefined ? {} : { summary }),
-        hooks: seat.hooks,
+        ...(seat.hooks === undefined ? {} : { hooks: seat.hooks }),
     }), (result) => acceptedReview(result, seat.id), { coordinate: seat.id });
 }
 export async function invokeContractMutation(input) {
-    const { parsed, repo, edge, configuration, hooks, forwarded } = input;
+    const { parsed, repo, edge, configuration, hooks } = input;
     if (parsed.command === "bind")
         return invokeBind(input);
     const seat = await existingSeat(input, parsed);
@@ -156,37 +161,39 @@ export async function invokeContractMutation(input) {
                 ...(markdown === undefined ? {} : { markdown }),
                 gates,
                 ...(actor === undefined ? {} : { actor }),
-                hooks,
+                ...(hooks === undefined ? {} : { hooks }),
             }), (result) => acceptedAmend(result, id), { coordinate: id });
         }
         case "deliver":
-            return invokeDeliver(parsed, seat, forwarded === true ? false : await selectedGitPolicy(configuration));
+            return invokeDeliver(parsed, seat, configuration === undefined ? false : await selectedGitPolicy(configuration));
         case "review":
             return invokeReview(parsed, seat, edge.readStdin);
         case "arc": {
             const markdown = await edge.readStdin();
             const { acceptedArc, resultFromMutationCall } = await import("../accepted.js");
-            return resultFromMutationCall("arc", () => contract.arc({ markdown, ...(actor === undefined ? {} : { actor }), hooks }), (result) => acceptedArc(result, id), { coordinate: id });
+            return resultFromMutationCall("arc", () => contract.arc({
+                markdown,
+                ...(actor === undefined ? {} : { actor }),
+                ...(hooks === undefined ? {} : { hooks }),
+            }), (result) => acceptedArc(result, id), { coordinate: id });
         }
         case "abandon": {
             const { acceptedAbandon, resultFromMutationCall } = await import("../accepted.js");
             return resultFromMutationCall("abandon", () => contract.abandon({
                 ...(actor === undefined ? {} : { actor }),
                 ...(parsed.note === undefined ? {} : { note: parsed.note }),
-                hooks,
+                ...(hooks === undefined ? {} : { hooks }),
             }), (result) => acceptedAbandon(result, id), { coordinate: id });
         }
         case "audit": {
-            if (configuration === undefined)
-                throw new Error("audit invocation requires Settings");
-            const requireBranchesToBeUpToDate = await selectedGitPolicy(configuration);
+            const requireBranchesToBeUpToDate = configuration === undefined ? false : await selectedGitPolicy(configuration);
             const { acceptedAudit, resultFromMutationCall } = await import("../accepted.js");
             return resultFromMutationCall("audit", () => contract.audit({
                 ...(actor === undefined ? {} : { actor }),
                 includeDirty: parsed.includeDirty,
                 showDiff: parsed.showDiff,
                 requireBranchesToBeUpToDate,
-                hooks,
+                ...(hooks === undefined ? {} : { hooks }),
             }), (result) => acceptedAudit(result, id), { coordinate: id });
         }
     }