@astrosheep/keiyaku 4.3.0 → 4.5.0

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

@@ -1,11 +1,36 @@
 import { AkumaHandle } from "./akuma-handle.js";
 import type { AkumaCallContext, AkumaCallInput, AkumaConfiguration, AkumaList, AkumaListInput } from "./akuma.js";
 import { CALL_WITH_CONTEXT } from "./akuma-product-symbols.js";
-import type { ResultRoute } from "./result-route.js";
 import type { WorldRoot } from "../world.js";
-type AkumaCallLaunchInput = AkumaCallInput & Readonly<{
-    resultRoute?: ResultRoute;
+import type { BodyLaunch } from "./body.js";
+import type { AllocatedAkuma } from "./identity.js";
+type AkumaCallRecipe = Omit<NonNullable<BodyLaunch["seed"]>, "id" | "archetype" | "cwd" | "origin">;
+type BornExecution = Readonly<{
+    cwd: string;
+    source: "input" | "caller" | "process" | "world";
 }>;
+export type BornAkumaCall = Readonly<{
+    kind: "born";
+    allocated: AllocatedAkuma;
+    seed: AkumaCallRecipe & Readonly<{
+        id: AllocatedAkuma["id"];
+        archetype: string;
+        cwd: string;
+        origin: {
+            kind: "direct";
+        };
+    }>;
+    initialBody: string;
+    execution: BornExecution;
+}>;
+export type RequestedAkumaCall = Readonly<{
+    kind: "requested";
+    id: AllocatedAkuma["id"];
+    cwd: string;
+    execution: BornExecution;
+}>;
+export type AkumaBornCall = BornAkumaCall | RequestedAkumaCall;
+type AkumaCallLaunchInput = AkumaCallInput;
 export declare class Akuma {
     private readonly path;
     private readonly configuration;
@@ -16,8 +41,12 @@ export declare class Akuma {
     }>): AkumaHandle;
     listArchetypes(): Promise<readonly string[]>;
     call(input: AkumaCallLaunchInput): Promise<AkumaHandle>;
+    beginCall(input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaBornCall>;
+    finishCall(born: AkumaBornCall): Promise<AkumaHandle>;
     [CALL_WITH_CONTEXT](input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaHandle>;
     list(input?: AkumaListInput): Promise<AkumaList>;
 }
 export declare function callAkumaWithContext(akuma: Akuma, input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaHandle>;
+export declare function beginAkumaCall(akuma: Akuma, input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaBornCall>;
+export declare function finishAkumaCall(akuma: Akuma, born: AkumaBornCall): Promise<AkumaHandle>;
 export {};

package/build/src/akuma/akuma-product.js

@@ -6,7 +6,7 @@ import { CALL_WITH_CONTEXT } from "./akuma-product-symbols.js";
 import { fleetListRow, readAkumaBirthCwd } from "./akuma-observe.js";
 import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, archetypeName, parseAkuId } from "./identity.js";
 import { loadArchetype, listArchetypes as readArchetypes } from "./archetype.js";
-import { publishAkuma } from "./publication.js";
+import { birthAkuma, launchAkuma } from "./publication.js";
 import { spawnAkumaBody } from "./body.js";
 import { injectedBodyRequests, requestBodyCall } from "./requests.js";
 import { decodeAllowedActions, unionAllowedActions } from "./allowed.js";
@@ -51,7 +51,7 @@ export class Akuma {
     async call(input) {
         return await this[CALL_WITH_CONTEXT](input, { initiatorCwd: process.cwd() });
     }
-    async [CALL_WITH_CONTEXT](input, context) {
+    async beginCall(input, context) {
         const readonly = callReadonly(input.readonly);
         const name = archetypeName(input.archetype);
         const home = this.configuration.home === undefined ? {} : { home: this.configuration.home };
@@ -84,32 +84,50 @@ export class Akuma {
                 recipe: requestRecipe,
             });
             const bornCwd = await readAkumaBirthCwd(this.path, child);
-            return new AkumaHandle(child, this.path, { cwd: bornCwd, source: cwd === undefined ? "caller" : "input" });
+            return {
+                kind: "requested",
+                id: child,
+                cwd: bornCwd,
+                execution: { cwd: bornCwd, source: cwd === undefined ? "caller" : "input" },
+            };
         }
         const initiatorCwd = context.initiatorCwd;
         const selectedCwd = input.cwd ?? initiatorCwd ?? this.path;
         const cwd = input.cwd !== undefined && context?.cwdCanonical === true ? input.cwd : await canonicalBirthCwd(selectedCwd);
-        const published = await publishAkuma({
-            worldPath: this.path,
-            archetype: archetype.name,
-            launch: async (allocated) => await spawnAkumaBody({
-                paths: allocated.paths,
-                seed: {
-                    id: allocated.id,
-                    archetype: allocated.archetype,
-                    ...requestRecipe,
-                    cwd,
-                    origin: { kind: "direct" },
-                },
-                initialBody: input.body,
-                ...(input.resultRoute === undefined ? {} : { resultRoute: input.resultRoute }),
-            }),
+        const allocated = await birthAkuma({ worldPath: this.path, archetype: archetype.name });
+        return {
+            kind: "born",
+            allocated,
+            seed: {
+                id: allocated.id,
+                archetype: allocated.archetype,
+                ...requestRecipe,
+                cwd,
+                origin: { kind: "direct" },
+            },
+            initialBody: input.body,
+            execution: {
+                cwd,
+                source: input.cwd !== undefined ? "input" : initiatorCwd === undefined ? "world" : "process",
+            },
+        };
+    }
+    async finishCall(born) {
+        if (born.kind === "requested") {
+            return new AkumaHandle(born.id, this.path, { cwd: born.cwd, source: born.execution.source });
+        }
+        const published = await launchAkuma({
+            allocated: born.allocated,
+            launch: async (allocated) => await spawnAkumaBody({ paths: allocated.paths, seed: born.seed, initialBody: born.initialBody }),
         });
         return new AkumaHandle(published.id, this.path, {
-            cwd,
-            source: input.cwd !== undefined ? "input" : initiatorCwd === undefined ? "world" : "process",
+            cwd: born.execution.cwd,
+            source: born.execution.source,
         });
     }
+    async [CALL_WITH_CONTEXT](input, context) {
+        return await this.finishCall(await this.beginCall(input, context));
+    }
     async list(input = {}) {
         if (typeof input !== "object" || input === null || Array.isArray(input))
             throw new TypeError("Akuma list input must be an object");
@@ -153,3 +171,9 @@ export class Akuma {
 export async function callAkumaWithContext(akuma, input, context) {
     return await akuma[CALL_WITH_CONTEXT](input, context);
 }
+export async function beginAkumaCall(akuma, input, context) {
+    return await akuma.beginCall(input, context);
+}
+export async function finishAkumaCall(akuma, born) {
+    return await akuma.finishCall(born);
+}

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

@@ -62,7 +62,6 @@ export type AkumaCallContext = Readonly<{
     cwdCanonical?: true;
 }>;
 export type { TellResult, TellWake } from "./body.js";
-export type { ResultRoute } from "./result-route.js";
 export type InterruptReceipt = Readonly<{
     kind: "unavailable";
     evidence: "hung" | "untidy" | "unavailable";

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

@@ -1,7 +1,6 @@
 import { type SessionFact, type Soul } from "./heart/index.js";
-import type { AkumaPaths } from "./identity.js";
+import { type AkumaPaths } from "./identity.js";
 import type { ProviderAdapter } from "./provider.js";
-import type { ResultRoute } from "./result-route.js";
 import { type UpstreamExecutionPort, type RequestChildLaunch } from "./request-serve.js";
 import { type OwnedProcess, type RunLogReference } from "../runtime/proc/run.js";
 export declare const LEASH_HELD_EXIT = 75;
@@ -12,7 +11,6 @@ export type BodyLaunch = Readonly<{
     birthSession?: Omit<SessionFact, "sequence">;
     initialBody?: string;
     refuseIfHeld?: boolean;
-    resultRoute?: ResultRoute;
 }>;
 export type TellWake = Readonly<{
     kind: "told";
@@ -45,10 +43,6 @@ type BodyRuntime = Readonly<{
     now(): string;
     spawnChild?(launch: RequestChildLaunch): Promise<OwnedProcess>;
     spawnBody?(launch: BodyLaunch): Promise<OwnedProcess>;
-    express?(route: ResultRoute, options: Readonly<{
-        as: string;
-        body: string;
-    }>): Promise<unknown>;
     upstream?: UpstreamExecutionPort;
 }>;
 export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string): Promise<{

package/build/src/akuma/body.js

@@ -1,9 +1,11 @@
 import { appendFile } from "node:fs/promises";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import { driveTurn, turnRecipe } from "./turn-drive.js";
 import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, readNonterminalRequests, watchHeart, } from "./heart/index.js";
+import { worldRootForAkumaPaths } from "./identity.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { clearBodyRequestTransport, settleBodyRequests, } from "./request-serve.js";
 import { spawnDetachedProcess, } from "../runtime/proc/run.js";
@@ -76,23 +78,37 @@ async function persistTurn(paths, turnSequence, result, completedAt) {
     await endTurn(paths, { turnSequence, outcome: { kind: "failed", diagnostic }, completedAt });
     return { outcome: "failed", diagnostic };
 }
+const OUTCOME_PREVIEW_LIMIT = 1_000;
+function outcomePreview(identity, outcome) {
+    const text = outcome.outcome === "answered" ? outcome.answer : outcome.diagnostic;
+    if (text.length <= OUTCOME_PREVIEW_LIMIT)
+        return text;
+    return `${text.slice(0, OUTCOME_PREVIEW_LIMIT)}\n\nkeiyaku history ${identity} --last`;
+}
 function boundedDiagnostic(error) {
     const text = diagnostic(error);
     return text.length <= 500 ? text : `${text.slice(0, 500)}...`;
 }
-async function expressInitialOutcome(launch, soul, outcome, runtime) {
-    if (launch.resultRoute === undefined)
-        return;
+async function expressInitialOutcome(launch, outcome) {
     try {
-        const express = runtime.express ?? (await import("@astrosheep/square")).express;
-        await express(launch.resultRoute, {
-            as: "keiyaku",
-            body: JSON.stringify({ akuma: soul.id, ...outcome }),
-        });
+        const { Square } = await import("@astrosheep/square");
+        const identity = launch.seed?.id ?? (await readHeart(launch.paths)).soul?.id;
+        if (identity === undefined)
+            return;
+        const square = await Square.at({ path: join(worldRootForAkumaPaths(launch.paths), ".square", "PUBLIC.square") });
+        try {
+            const joined = await square.implicitJoin(identity);
+            if (joined.state === "done" || joined.participant === undefined)
+                return;
+            await joined.participant.express(outcomePreview(identity, outcome));
+        }
+        finally {
+            await square.close();
+        }
     }
     catch (error) {
         try {
-            await appendFile(launch.paths.log, `result-route express failed: ${boundedDiagnostic(error)}\n`);
+            await appendFile(launch.paths.log, `square outcome express failed: ${boundedDiagnostic(error)}\n`);
         }
         catch {
             /* express loss never changes Heart truth */
@@ -201,7 +217,7 @@ async function runBodyTurns(input) {
         }
         const outcome = await persistTurn(launch.paths, result.turnSequence, result, runtime.now());
         if (initial !== undefined)
-            await expressInitialOutcome(launch, soul, outcome, runtime);
+            await expressInitialOutcome(launch, outcome);
         if (outcome.outcome === "failed") {
             await breakBody(launch.paths, { sequence: bodySequence, end: "broke-off", at: runtime.now() });
             return;

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

@@ -2,7 +2,6 @@ import { type AkuId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
 export { Akuma, AkumaHandle, AkumaNotBornError, defaultWaitComplete } from "./akuma.js";
 export type { AkumaCallInput } from "./akuma.js";
-export type { ResultRoute } from "./result-route.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";
 export type { AllowedAction, AllowedActions } from "./allowed.js";
 export type { WorldRoot } from "../world.js";

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

@@ -1,11 +1,17 @@
 import { type AllocatedAkuma } from "./identity.js";
 import type { OwnedProcess } from "../runtime/proc/run.js";
 export declare const BIRTH_TIMEOUT_MS = 30000;
-export declare function publishAkuma(input: Readonly<{
+export type BirthInput = Readonly<{
     worldPath: string;
     archetype: string;
+    signal?: AbortSignal;
+}>;
+export type LaunchInput = Readonly<{
+    allocated: AllocatedAkuma;
     awaitAsleep?: boolean;
-    reserve?(allocated: AllocatedAkuma): Promise<void>;
     launch(allocated: AllocatedAkuma): Promise<OwnedProcess | void>;
     signal?: AbortSignal;
-}>): Promise<AllocatedAkuma>;
+}>;
+export declare function birthAkuma(input: BirthInput): Promise<AllocatedAkuma>;
+export declare function launchAkuma(input: LaunchInput): Promise<AllocatedAkuma>;
+export declare function publishAkuma(input: BirthInput & Omit<LaunchInput, "allocated">): Promise<AllocatedAkuma>;

package/build/src/akuma/publication.js

@@ -156,15 +156,25 @@ async function sealLocalFailure(allocated, error) {
         /* the original local publication failure remains authoritative */
     }
 }
-export async function publishAkuma(input) {
+export async function birthAkuma(input) {
     input.signal?.throwIfAborted();
     const allocated = await allocateAkumaDirectory({ worldRoot: input.worldPath, archetype: input.archetype });
     try {
         await initializeHeart(allocated.paths);
         input.signal?.throwIfAborted();
-        await input.reserve?.(allocated);
+        return allocated;
+    }
+    catch (error) {
+        await sealLocalFailure(allocated, error);
+        throw error;
+    }
+}
+export async function launchAkuma(input) {
+    const { allocated } = input;
+    let owned;
+    try {
         input.signal?.throwIfAborted();
-        const owned = await input.launch(allocated);
+        owned = await input.launch(allocated);
         try {
             input.signal?.throwIfAborted();
             const soul = await awaitBirth(allocated.paths, owned ?? undefined, input.signal);
@@ -183,3 +193,7 @@ export async function publishAkuma(input) {
         throw error;
     }
 }
+export async function publishAkuma(input) {
+    const allocated = await birthAkuma(input);
+    return await launchAkuma({ ...input, allocated });
+}

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

@@ -111,14 +111,10 @@ async function serveCall(input) {
             worldPath: world,
             archetype: request.archetype,
             signal: input.signal,
-            reserve: async (allocated) => {
-                if (!input.admissionOpen())
-                    throw new Error("body closed request admission");
-                fact = await reserveRequest(input.paths, request.id, allocated.id);
-            },
             launch: async (allocated) => {
                 if (!input.admissionOpen())
                     throw new Error("body closed request admission");
+                fact = await reserveRequest(input.paths, request.id, allocated.id);
                 return await input.spawn({
                     paths: allocated.paths,
                     seed: {

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

@@ -1,4 +1,4 @@
-import { type AkuId, type ActivityHistory, type ResultRoute } from "../../akuma/index.js";
+import { type AkuId, type ActivityHistory } from "../../akuma/index.js";
 import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaObservation, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
 import type { Settings } from "../../settings.js";
 import type { WorldRoot } from "../../world.js";
@@ -72,7 +72,7 @@ type InvokeInput = Readonly<{
     settings?: Settings;
     contract?: KeiyakuContract;
     repo?: Repo;
-    resultRoute?: ResultRoute;
+    environment: NodeJS.ProcessEnv;
     readStdin(): Promise<string>;
 }>;
 export declare function invokeAkuma(command: InvokedAkumaCommand, input: InvokeInput): Promise<AkumaInvocationResult>;

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

@@ -1,4 +1,6 @@
 import { Keiyaku, } from "../../index.js";
+import { beginCall, finishCall } from "../../library/akuma-creation.js";
+import { recognizeAndListen } from "../square-edge.js";
 function inputAlias(selector) {
     return selector.startsWith("@") ? selector : undefined;
 }
@@ -100,7 +102,7 @@ export async function invokeAkuma(command, input) {
     switch (command.command) {
         case "call": {
             const body = await promptBody(command, input);
-            const result = await Keiyaku.call({
+            const born = await beginCall({
                 path: input.path,
                 archetype: command.archetype,
                 body,
@@ -113,8 +115,25 @@ 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.resultRoute === undefined ? {} : { resultRoute: input.resultRoute }),
             });
+            const listener = born.born.kind === "born"
+                ? await recognizeAndListen(input.path, input.environment, born.born.allocated)
+                : undefined;
+            let result;
+            try {
+                result = await finishCall(born);
+            }
+            catch (error) {
+                if (listener?.committed === true) {
+                    try {
+                        await listener.rollback();
+                    }
+                    catch {
+                        /* preserve launch failure */
+                    }
+                }
+                throw error;
+            }
             return { kind: "akuma", action: "call", result, world: input.path };
         }
         case "wait":

package/build/src/cli/invoke.js

@@ -1,4 +1,3 @@
-import { captureRoute } from "@astrosheep/square";
 import { resolveActor } from "./actor.js";
 import { isParsedAkumaCommand } from "./commands/akuma.js";
 import { invokeContractMutation } from "./commands/contract-invoke.js";
@@ -106,14 +105,13 @@ async function invokeAkumaFromEdge(parsed, input) {
         const contract = parsed.command === "call" && parsed.contract !== undefined
             ? (await import("./selectors.js")).contractFromInput(repo, parsed.contract).contract
             : undefined;
-        const resultRoute = parsed.command === "call" ? captureRoute({ cwd: input.invocationCwd, env: edge.environment }) : null;
         return await invokeAkuma(parsed, {
             path,
             ...(statedCwd === undefined ? {} : { statedCwd }),
             ...(home === undefined ? {} : { home }),
             ...(configuration === undefined ? {} : { settings: configuration }),
             ...(contract === undefined ? (repo === undefined ? {} : { repo }) : { contract }),
-            ...(resultRoute === null ? {} : { resultRoute }),
+            environment: edge.environment,
             readStdin: edge.readStdin,
         });
     }

package/build/src/cli/square-edge.d.ts

@@ -0,0 +1,6 @@
+import type { AllocatedAkuma } from "../akuma/identity.js";
+import type { WorldRoot } from "../world.js";
+export declare function recognizeAndListen(worldRoot: WorldRoot, environment: NodeJS.ProcessEnv, allocated: AllocatedAkuma): Promise<{
+    committed: boolean;
+    rollback(): Promise<void>;
+} | void>;

package/build/src/cli/square-edge.js

@@ -0,0 +1,48 @@
+import { Square } from "@astrosheep/square";
+import { join } from "node:path";
+export async function recognizeAndListen(worldRoot, environment, allocated) {
+    const path = join(worldRoot, ".square", "PUBLIC.square");
+    let square;
+    try {
+        square = await Square.at({ path });
+    }
+    catch (error) {
+        if (error.code === "ENOENT" || error.code === "unavailable")
+            return;
+        throw error;
+    }
+    try {
+        const recognize = square.recognize;
+        if (recognize === undefined)
+            return;
+        const participant = await recognize.call(square, environment);
+        if (participant === null)
+            return;
+        const listener = participant;
+        const change = await listener.listen(allocated.id);
+        if (change.activity === null)
+            return;
+        return {
+            committed: true,
+            rollback: async () => {
+                const rollbackSquare = await Square.at({ path });
+                try {
+                    const current = rollbackSquare
+                        .recognize;
+                    if (current === undefined)
+                        return;
+                    const rollbackParticipant = await current.call(rollbackSquare, environment);
+                    if (rollbackParticipant === null)
+                        return;
+                    await rollbackParticipant.ignore(allocated.id);
+                }
+                finally {
+                    await rollbackSquare.close();
+                }
+            },
+        };
+    }
+    finally {
+        await square.close();
+    }
+}

package/build/src/library/akuma-creation.d.ts

@@ -1,5 +1,6 @@
 import { type AliasBinding } from "../alias/index.js";
-import { type AkumaStatus, type ForkReceipt, type ReadonlyRestraint, type ResultRoute } from "../akuma/akuma.js";
+import { type AkumaStatus, type ForkReceipt, type ReadonlyRestraint } from "../akuma/akuma.js";
+import { type AkumaBornCall } from "../akuma/akuma-product.js";
 import type { AkuId } from "../akuma/identity.js";
 import { type Dispatch, type DispatchFailure } from "../dispatch/index.js";
 import { type AkumaAlias } from "../identity/selector.js";
@@ -48,11 +49,9 @@ export type CallInput = Readonly<{
     contract?: Keiyaku;
     alias?: AkumaAlias;
     allowed?: readonly AllowedAction[];
-    resultRoute?: ResultRoute;
 }>;
 export type CallObservation = Readonly<{
     kind: "detached";
-    resultRoute: "captured" | "not-captured";
 }> | Readonly<{
     kind: "observed";
     status: AkumaStatus;
@@ -72,6 +71,16 @@ export type CallResult = Readonly<{
     alias: AliasStage;
     observation: CallObservation;
 }>;
+type CallExecution = CallResult["execution"];
+export type BornCall = Readonly<{
+    path: WorldRoot;
+    born: AkumaBornCall;
+    execution: CallExecution;
+    mode: "wait" | "detach";
+    timeoutMs: number;
+    dispatch: DispatchStage;
+    alias: AliasStage;
+}>;
 export type ForkInput = Readonly<{
     path: WorldRoot;
     akuma: string;
@@ -89,5 +98,7 @@ export type ForkResult = Readonly<{
 }>> & Readonly<{
     parent: AkuId;
 }>);
+export declare function beginCall(input: CallInput): Promise<BornCall>;
+export declare function finishCall(born: BornCall): Promise<CallResult>;
 export declare function callKeiyaku(input: CallInput): Promise<CallResult>;
 export declare function forkKeiyaku(input: ForkInput): Promise<ForkResult>;

package/build/src/library/akuma-creation.js

@@ -1,6 +1,7 @@
 import { realpath, stat } from "node:fs/promises";
 import { moveAlias } from "../alias/index.js";
-import { Akuma, akumaCallExecution, callAkumaWithContext, } from "../akuma/akuma.js";
+import { Akuma } from "../akuma/akuma.js";
+import { beginAkumaCall, finishAkumaCall } from "../akuma/akuma-product.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
@@ -77,9 +78,9 @@ function callTimeout(value, mode) {
     }
     return value;
 }
-async function observeCall(handle, mode, timeoutMs, resultRoute) {
+async function observeCall(handle, mode, timeoutMs) {
     if (mode === "detach") {
-        return { kind: "detached", resultRoute: resultRoute === undefined ? "not-captured" : "captured" };
+        return { kind: "detached" };
     }
     try {
         return { kind: "observed", status: await handle.wait(undefined, { timeoutMs }) };
@@ -165,7 +166,7 @@ async function resolveCallExecution(input) {
     }
     return undefined;
 }
-export async function callKeiyaku(input) {
+export async function beginCall(input) {
     const values = requireInput(input, "Keiyaku.call input");
     onlyKeys(values, [
         "path",
@@ -180,7 +181,6 @@ export async function callKeiyaku(input) {
         "contract",
         "alias",
         "allowed",
-        "resultRoute",
     ], "Keiyaku.call input");
     const path = nonblank(values.path, "path");
     const archetype = nonblank(values.archetype, "archetype");
@@ -193,7 +193,6 @@ export async function callKeiyaku(input) {
     const settings = settingsOption(values.settings);
     const alias = values.alias === undefined ? undefined : parseAkumaAlias(nonblank(values.alias, "alias"));
     const seat = values.contract === undefined ? undefined : seatForKeiyaku(values.contract);
-    const resultRoute = values.resultRoute;
     const execution = await resolveCallExecution({
         path,
         ...(cwd === undefined ? {} : { cwd }),
@@ -206,23 +205,20 @@ export async function callKeiyaku(input) {
         ...(readonlyRequested === undefined ? {} : { readonly: readonlyRequested }),
         ...(values.allowed === undefined ? {} : { allowed: values.allowed }),
         ...(execution === undefined ? {} : { cwd: execution.cwd }),
-        ...(resultRoute === undefined ? {} : { resultRoute }),
     };
-    const handle = execution === undefined ? await world.call(call) : await callAkumaWithContext(world, call, { cwdCanonical: true });
-    const completedExecution = execution ?? akumaCallExecution(handle);
-    if (completedExecution === undefined)
-        throw new Error("Akuma call is missing its birth execution");
-    const readonly = (await handle.status()).readonly;
+    const born = await beginAkumaCall(world, call, execution === undefined ? {} : { cwdCanonical: true });
+    const akuma = born.kind === "requested" ? born.id : born.allocated.id;
+    const completedExecution = execution ?? born.execution;
     const dispatch = seat === undefined
         ? { kind: "none" }
-        : await dispatchStage({ repository: seat.scope, akuId: handle.id, contractId: seat.id });
+        : await dispatchStage({ repository: seat.scope, akuId: akuma, contractId: seat.id });
     let aliasStage = { kind: "none" };
     if (alias !== undefined) {
         if (dispatch.kind === "failed")
             aliasStage = { kind: "skipped", reason: "dispatch-failed" };
         else {
             try {
-                const moved = await moveAlias({ world: path, alias, akuId: handle.id });
+                const moved = await moveAlias({ world: path, alias, akuId: akuma });
                 aliasStage = { kind: "aliased", alias: moved.alias, previous: moved.previous };
             }
             catch (error) {
@@ -230,17 +226,34 @@ export async function callKeiyaku(input) {
             }
         }
     }
-    const observation = await observeCall(handle, mode, timeoutMs, resultRoute);
     return {
-        kind: "called",
-        akuma: handle.id,
-        ...(readonly === undefined ? {} : { readonly }),
+        path,
+        born,
         execution: completedExecution,
+        mode,
+        timeoutMs,
         dispatch,
         alias: aliasStage,
+    };
+}
+export async function finishCall(born) {
+    const world = akumaWorld(born.path);
+    const handle = await finishAkumaCall(world, born.born);
+    const readonly = (await handle.status()).readonly;
+    const observation = await observeCall(handle, born.mode, born.timeoutMs);
+    return {
+        kind: "called",
+        akuma: handle.id,
+        ...(readonly === undefined ? {} : { readonly }),
+        execution: born.execution,
+        dispatch: born.dispatch,
+        alias: born.alias,
         observation,
     };
 }
+export async function callKeiyaku(input) {
+    return await finishCall(await beginCall(input));
+}
 export async function forkKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.fork input");
     onlyKeys(values, ["path", "akuma", "at", "repo"], "Keiyaku.fork input");

package/build/src/runtime/proc/process-exit.js

@@ -5,12 +5,17 @@ export function detachedExitStatus(code, signal) {
 export async function retainDetachedExitEvidence(log, path, from, code, signal) {
     const status = detachedExitStatus(code, signal);
     const marker = Buffer.from(`[child ${status}]\n`);
+    const before = await log.stat();
+    if (before.size < from)
+        throw new Error("run log shrank before exit evidence was retained");
     let written = 0;
+    let position = before.size;
     while (written < marker.byteLength) {
-        const write = await log.write(marker, written, marker.byteLength - written);
+        const write = await log.write(marker, written, marker.byteLength - written, position);
         if (write.bytesWritten === 0)
             throw new Error("run log exit marker write made no progress");
         written += write.bytesWritten;
+        position += write.bytesWritten;
     }
     const evidence = await log.stat();
     if (evidence.size < from)

package/build/src/runtime/proc/run.js

@@ -40,13 +40,6 @@ export async function spawnDetachedProcess(input) {
         return spawnWindowsRetainedProcess(input);
     const log = await open(input.log, "a");
     let launched = false;
-    let logClosed = false;
-    const closeLog = async () => {
-        if (logClosed)
-            return;
-        logClosed = true;
-        await log.close();
-    };
     try {
         const from = (await log.stat()).size;
         const child = spawn(input.argv[0], input.argv.slice(1), spawnOptionsFor(input, ["ignore", log.fd, log.fd]));
@@ -62,14 +55,16 @@ export async function spawnDetachedProcess(input) {
                     const status = detachedExitStatus(code, signal);
                     let failure;
                     let result;
+                    let exitLog;
                     try {
-                        result = await retainDetachedExitEvidence(log, input.log, from, code, signal);
+                        exitLog = await open(input.log, "r+");
+                        result = await retainDetachedExitEvidence(exitLog, input.log, from, code, signal);
                     }
                     catch (error) {
                         failure = error;
                     }
                     try {
-                        await closeLog();
+                        await exitLog?.close();
                     }
                     catch (error) {
                         failure ??= error;
@@ -89,6 +84,7 @@ export async function spawnDetachedProcess(input) {
         if (child.pid === undefined)
             throw new Error("detached process spawned without a pid");
         const pid = child.pid;
+        await log.close();
         launched = true;
         return {
             pid,
@@ -99,7 +95,7 @@ export async function spawnDetachedProcess(input) {
     }
     finally {
         if (!launched)
-            await closeLog();
+            await log.close();
     }
 }
 function terminalOutcome(code, stdout, stderr, consuming) {

package/build/src/runtime/proc/termination.d.ts

@@ -1,3 +1,4 @@
 import { type ChildProcess } from "node:child_process";
 export declare function terminateWindowsTree(pid: number): Promise<void>;
+export declare function settleWindowsTermination(exit: Promise<void>): Promise<void>;
 export declare function terminateOwnedProcess(child: ChildProcess, force?: boolean): Promise<void>;

package/build/src/runtime/proc/termination.js

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import { setTimeout as delay } from "node:timers/promises";
 import { promisify } from "node:util";
 const TERMINATION_GRACE_MS = 250;
+const WINDOWS_TERMINATION_SETTLE_MS = 250;
 const WINDOWS_TERMINATION_TIMEOUT_MS = 1_000;
 const execFileAsync = promisify(execFile);
 function ignoreMissingProcess(error) {
@@ -23,6 +24,20 @@ export async function terminateWindowsTree(pid) {
         throw error;
     }
 }
+export async function settleWindowsTermination(exit) {
+    const settled = await Promise.race([
+        exit.then(() => true),
+        delay(WINDOWS_TERMINATION_TIMEOUT_MS, false, { ref: false }).then(() => false),
+    ]);
+    if (!settled)
+        throw new Error("Windows process did not exit after taskkill");
+    await delay(WINDOWS_TERMINATION_SETTLE_MS);
+}
+function closeWindowsStreams(child) {
+    child.stdin?.destroy();
+    child.stdout?.destroy();
+    child.stderr?.destroy();
+}
 export async function terminateOwnedProcess(child, force = false) {
     const pid = child.pid;
     if (pid === undefined || child.exitCode !== null || child.signalCode !== null)
@@ -39,8 +54,13 @@ export async function terminateOwnedProcess(child, force = false) {
         });
     });
     if (process.platform === "win32") {
-        await terminateWindowsTree(pid);
-        await exit;
+        try {
+            await terminateWindowsTree(pid);
+            await settleWindowsTermination(exit);
+        }
+        finally {
+            closeWindowsStreams(child);
+        }
         return;
     }
     if (force) {

package/build/src/runtime/proc/windows-run.js

@@ -3,8 +3,8 @@ import { createInterface } from "node:readline";
 import { launchFailure, spawnWindowsLauncher } from "./launch.js";
 import { detachedExitStatus, retainDetachedExitEvidence } from "./process-exit.js";
 import { createProcessLifecycle } from "./lifecycle.js";
-import { terminateWindowsTree } from "./termination.js";
-function createWindowsContext(input, log, from, closeLog) {
+import { settleWindowsTermination, terminateWindowsTree } from "./termination.js";
+function createWindowsContext(input, from, closeLog) {
     const child = spawnWindowsLauncher(input);
     const reader = createInterface({ input: child.stdout });
     let startedResolve;
@@ -23,7 +23,6 @@ function createWindowsContext(input, log, from, closeLog) {
     child.stderr?.setEncoding("utf8");
     const context = {
         input,
-        log,
         from,
         closeLog,
         child,
@@ -31,6 +30,7 @@ function createWindowsContext(input, log, from, closeLog) {
         stderr: "",
         started: false,
         targetPid: undefined,
+        released: false,
         finished: false,
         startedPromise,
         startedResolve,
@@ -45,6 +45,8 @@ function createWindowsContext(input, log, from, closeLog) {
     return context;
 }
 function failWindows(context, error) {
+    if (context.released)
+        return;
     context.lifecycle?.markInert();
     if (!context.started)
         context.startedReject(error);
@@ -76,14 +78,16 @@ function recordWindowsExit(context, code) {
     void (async () => {
         let failure;
         let result;
+        let exitLog;
         try {
-            result = await retainDetachedExitEvidence(context.log, context.input.log, context.from, code, null);
+            exitLog = await open(context.input.log, "r+");
+            result = await retainDetachedExitEvidence(exitLog, context.input.log, context.from, code, null);
         }
         catch (error) {
             failure = error;
         }
         try {
-            await context.closeLog();
+            await exitLog?.close();
         }
         catch (error) {
             failure ??= error;
@@ -95,6 +99,7 @@ function recordWindowsExit(context, code) {
             const status = detachedExitStatus(code, null);
             throw new Error(`pre-admission ${status}: run-log evidence unavailable: ${failure instanceof Error ? failure.message : String(failure)}`);
         }
+        await settleWindowsTermination(Promise.resolve());
         context.exitResolve(result);
     })().catch(context.exitReject);
 }
@@ -126,6 +131,8 @@ function handleWindowsLine(context, line) {
 function installWindowsProtocol(context) {
     context.child.once("error", (error) => failWindows(context, error));
     context.child.once("close", () => {
+        if (context.released)
+            return;
         if (!context.started) {
             failWindows(context, launchFailure(context.input.argv[0] ?? "windows-launch.exe", context.stderr.trim()));
         }
@@ -138,8 +145,9 @@ function installWindowsProtocol(context) {
 function ownedWindowsProcess(context, pid) {
     const lifecycle = createProcessLifecycle(async () => {
         await terminateWindowsTree(pid);
-        await context.exited;
+        await settleWindowsTermination(context.exited.then(() => undefined));
     }, () => {
+        context.released = true;
         context.reader.close();
         context.child.stdin?.write("release\n");
         context.child.stdin?.end();
@@ -164,10 +172,11 @@ export async function spawnWindowsRetainedProcess(input) {
         logClosed = true;
         await log.close();
     };
-    const context = createWindowsContext(input, log, (await log.stat()).size, closeLog);
+    const context = createWindowsContext(input, (await log.stat()).size, closeLog);
     installWindowsProtocol(context);
     try {
         const pid = await context.startedPromise;
+        await closeLog();
         return ownedWindowsProcess(context, pid);
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.3.0",
+  "version": "4.5.0",
   "files": [
     "build"
   ],
@@ -59,7 +59,7 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
-    "@astrosheep/square": "0.3.13",
+    "@astrosheep/square": "0.3.17",
     "@earendil-works/pi-coding-agent": "0.80.10",
     "@opencode-ai/sdk": "1.18.3",
     "cross-spawn": "^7.0.6",

package/build/src/akuma/result-route.d.ts

@@ -1,2 +0,0 @@
-/** Opaque, serializable caller result address carried across the Body process. */
-export type ResultRoute = Readonly<unknown>;

package/build/src/akuma/result-route.js

@@ -1 +0,0 @@
-export {};