@astrosheep/keiyaku 4.5.7 → 4.5.9

package/build/src/akuma/providers/codex-app-server/index.js

@@ -1,5 +1,5 @@
 import { LineRpcProcess } from "../../../runtime/proc/line-rpc.js";
-import { AgentEventChannel, AKUMA_REQUESTS_ENV, } from "../../provider.js";
+import { AgentEventChannel, AKUMA_REQUESTS_ENV, createProviderAttempt, } from "../../provider.js";
 import { codexNotificationResult, codexObject, codexText } from "./events.js";
 export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
 function diagnostic(error) {
@@ -97,7 +97,7 @@ async function admitTurn(server, input, state, events, config) {
         sandboxPolicy: sandbox(input.cwd, input.options, input.requests),
     }));
 }
-async function forkCodex(execution, input) {
+async function forkCodex(execution, input, custody) {
     if (!("sessionId" in input.session))
         throw new Error("Codex app-server fork requires sessionId");
     const server = new LineRpcProcess({
@@ -105,6 +105,12 @@ async function forkCodex(execution, input) {
         cwd: input.cwd,
         ...(execution.env === undefined ? {} : { env: { ...process.env, ...execution.env } }),
     });
+    const closed = new Promise((resolve) => server.onExit(() => resolve()));
+    custody.own({
+        closed,
+        abort: async () => await server.close(true),
+        forceDispose: async () => await server.close(true),
+    });
     try {
         await initialize(server);
         const child = threadId(await server.request("thread/fork", {
@@ -139,12 +145,18 @@ function codexServer(execution, input) {
             }),
     });
 }
-async function startCodex(execution, input) {
+async function startCodex(execution, input, custody) {
     const signal = input.signal ?? new AbortController().signal;
     if (input.session.kind === "resume" && !("sessionId" in input.session.coordinate))
         throw new Error("Codex app-server resume requires sessionId");
     const events = new AgentEventChannel();
     const server = codexServer(execution, input);
+    const closed = new Promise((resolve) => server.onExit(() => resolve()));
+    custody.own({
+        closed,
+        abort: async () => await server.close(true),
+        forceDispose: async () => await server.close(true),
+    });
     const state = { settled: false, tools: new Map() };
     let settle;
     const completion = new Promise((resolve) => {
@@ -220,8 +232,8 @@ export function createCodexAppServerProvider(input = "codex") {
                 ...(options.readonly === undefined ? {} : { readonly: { enforcement: "native" } }),
             };
         },
-        fork: (input) => forkCodex(execution, input),
-        start: (input) => startCodex(execution, input),
-        resume: (input) => startCodex(execution, input),
+        fork: (input) => createProviderAttempt(new AbortController().signal, async (custody) => await forkCodex(execution, input, custody)),
+        start: (input) => createProviderAttempt(input.signal, async (custody) => await startCodex(execution, { ...input, signal: custody.signal }, custody)),
+        resume: (input) => createProviderAttempt(input.signal, async (custody) => await startCodex(execution, { ...input, signal: custody.signal }, custody)),
     };
 }

package/build/src/akuma/providers/grok-build/index.js

@@ -1,3 +1,4 @@
+import { createProviderAttempt } from "../../provider.js";
 import { startAcpSession, } from "../acp/core.js";
 const INTERJECT_METHOD = "x.ai/interject";
 function nonblank(value) {
@@ -131,7 +132,7 @@ function withInterject(live) {
 export function createGrokBuildProvider(execution, dependencies = {}) {
     if (execution.executable === undefined)
         throw new TypeError("Grok Build provider execution requires executable");
-    const drive = async (input) => {
+    const drive = async (input, custody) => {
         const launch = {
             argv: argv(execution, input.options),
             ...(execution.env === undefined ? {} : { env: execution.env }),
@@ -140,11 +141,11 @@ export function createGrokBuildProvider(execution, dependencies = {}) {
             ...dependencies,
             interpretTool: interpretGrokTool,
             ...grokSessionMeta(execution.config, input.options),
-        }));
+        }, custody));
     };
     return {
         admitOptions: optionAdmission,
-        start: async (input) => await drive(input),
-        resume: async (input) => await drive(input),
+        start: (input) => createProviderAttempt(input.signal, async (custody) => await drive({ ...input, signal: custody.signal }, custody)),
+        resume: (input) => createProviderAttempt(input.signal, async (custody) => await drive({ ...input, signal: custody.signal }, custody)),
     };
 }

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

@@ -1,6 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { abortable } from "../../abort.js";
-import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, createProviderAttempt, } from "../../provider.js";
 import { createEventState, mapEvent } from "./events.js";
 import { coordinate, loadOpencode, OPENCODE_SDK_PROVIDER, parseModel } from "./session.js";
 function object(value) {
@@ -201,27 +200,51 @@ async function forceDisposeOpencode(abortController, close, finish) {
     await close();
     await finish({ kind: "failed", diagnostic: "OpenCode session force-disposed" });
 }
-async function loadDriveRuntime(execution, input, signal, loader) {
-    return await abortable(loadOpencode({
+async function loadDriveRuntime(execution, input, signal, loader, onRuntime) {
+    const runtime = await loadOpencode({
         ...execution,
         env: {
             ...execution.env,
             ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
         },
-    }, input.cwd, signal, loader), signal, async (late) => await late.close());
+    }, input.cwd, signal, loader, onRuntime);
+    if (signal.aborted) {
+        await runtime.close();
+        signal.throwIfAborted();
+    }
+    return runtime;
+}
+function ownRuntime(custody, runtime) {
+    let closing;
+    let settleRuntimeClosed;
+    let rejectRuntimeClosed;
+    const runtimeClosed = new Promise((resolve, reject) => {
+        settleRuntimeClosed = resolve;
+        rejectRuntimeClosed = reject;
+    });
+    const close = () => {
+        if (closing === undefined) {
+            closing = runtime.close();
+            void closing.then(settleRuntimeClosed, rejectRuntimeClosed);
+        }
+        return closing;
+    };
+    custody?.own({ closed: runtimeClosed, abort: close, forceDispose: close });
+    return close;
 }
 async function openDriveSession(runtime, input, resumeSessionId, signal) {
     const session = runtime.client.session;
-    const response = await abortable(input.session.kind === "fresh"
+    const response = await (input.session.kind === "fresh"
         ? session.create({ query: { directory: input.cwd }, throwOnError: true })
-        : session.get({ path: { id: resumeSessionId }, query: { directory: input.cwd }, throwOnError: true }), signal);
+        : session.get({ path: { id: resumeSessionId }, query: { directory: input.cwd }, throwOnError: true }));
+    signal.throwIfAborted();
     const info = object(object(response)?.data) ?? object(response);
     const sessionId = text(info?.id) ?? resumeSessionId;
     if (sessionId === undefined)
         throw new Error("OpenCode did not return a session id");
     return { session, sessionId };
 }
-async function drive(execution, input, loader) {
+async function drive(execution, input, loader, custody) {
     admit(input.options);
     const signal = input.signal ?? new AbortController().signal;
     const resumeSessionId = input.session.kind === "resume" ? opencodeSessionId(input.session.coordinate) : undefined;
@@ -229,13 +252,11 @@ async function drive(execution, input, loader) {
     const abortSetup = () => abortController.abort(signal.reason);
     signal.addEventListener("abort", abortSetup, { once: true });
     signal.throwIfAborted();
-    const runtime = await loadDriveRuntime(execution, input, abortController.signal, loader);
-    let closing;
+    let closeOnce;
+    const runtime = await loadDriveRuntime(execution, input, abortController.signal, loader, (ready) => {
+        closeOnce = ownRuntime(custody, ready);
+    });
     let iterator;
-    const closeOnce = () => {
-        closing ??= runtime.close();
-        return closing;
-    };
     try {
         const { session, sessionId } = await openDriveSession(runtime, input, resumeSessionId, abortController.signal);
         const events = new AgentEventChannel();
@@ -243,9 +264,11 @@ async function drive(execution, input, loader) {
         const messageID = `msg_${randomUUID().replaceAll("-", "")}`;
         const submissionState = { started: false };
         events.emit({ type: "session", coordinate: coordinate(sessionId) });
-        const streamResult = await abortable(runtime.client.event.subscribe({ query: { directory: input.cwd } }), abortController.signal, async (late) => {
-            await late.stream[Symbol.asyncIterator]().return?.(undefined);
-        });
+        const streamResult = await runtime.client.event.subscribe({ query: { directory: input.cwd } });
+        if (abortController.signal.aborted) {
+            await streamResult.stream[Symbol.asyncIterator]().return?.(undefined);
+            abortController.signal.throwIfAborted();
+        }
         iterator = streamResult.stream[Symbol.asyncIterator]();
         const { completion, finish } = terminalSettlement(events, closeOnce);
         const observation = observeTurn({
@@ -259,12 +282,13 @@ async function drive(execution, input, loader) {
             submissionState,
         });
         submissionState.started = true;
-        await abortable(session.promptAsync({
+        await session.promptAsync({
             path: { id: sessionId },
             query: { directory: input.cwd },
             body: promptBody(input, messageID),
             throwOnError: true,
-        }), abortController.signal);
+        });
+        abortController.signal.throwIfAborted();
         void observation.then(finish);
         signal.removeEventListener("abort", abortSetup);
         return {
@@ -312,11 +336,28 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
                     }),
             };
         },
-        start: (input) => drive(execution, input, loader),
-        resume: (input) => drive(execution, input, loader),
-        fork: async (input) => {
+        start: (input) => createProviderAttempt(input.signal, async (custody) => await drive(execution, { ...input, signal: custody.signal }, loader, custody)),
+        resume: (input) => createProviderAttempt(input.signal, async (custody) => await drive(execution, { ...input, signal: custody.signal }, loader, custody)),
+        fork: (input) => createProviderAttempt(new AbortController().signal, async (custody) => {
             const sessionId = opencodeSessionId(input.session);
-            const runtime = await loadOpencode(execution, input.cwd, new AbortController().signal, loader);
+            let close;
+            const runtime = await loadOpencode(execution, input.cwd, custody.signal, loader, (ready) => {
+                let closing;
+                let settleRuntimeClosed;
+                let rejectRuntimeClosed;
+                const runtimeClosed = new Promise((resolve, reject) => {
+                    settleRuntimeClosed = resolve;
+                    rejectRuntimeClosed = reject;
+                });
+                close = () => {
+                    if (closing === undefined) {
+                        closing = ready.close();
+                        void closing.then(settleRuntimeClosed, rejectRuntimeClosed);
+                    }
+                    return closing;
+                };
+                custody.own({ closed: runtimeClosed, abort: close, forceDispose: close });
+            });
             try {
                 const result = await runtime.client.session.fork({
                     path: { id: sessionId },
@@ -330,8 +371,8 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
                 return { session: coordinate(id) };
             }
             finally {
-                await runtime.close();
+                await close();
             }
-        },
+        }),
     };
 }

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

@@ -3,12 +3,13 @@ import type { ResumeCoordinate } from "../../heart/index.js";
 import type { ProviderExecution } from "../../provider-recipe.js";
 export type OpencodeSdkSession = Pick<OpencodeClient["session"], "create" | "get" | "fork" | "abort" | "promptAsync" | "messages">;
 export type OpencodeSdkEvent = Pick<OpencodeClient["event"], "subscribe">;
-export type OpencodeSdkLoader = (cwd: string, execution: ProviderExecution) => Promise<Readonly<{
+export type OpencodeSdkLoader = (cwd: string, execution: ProviderExecution, signal: AbortSignal) => Promise<Readonly<{
     client: {
         session: OpencodeSdkSession;
         event: OpencodeSdkEvent;
     };
     close?: () => Promise<void> | void;
+    ready?: Promise<void>;
 }>>;
 export declare const OPENCODE_SDK_PROVIDER: "opencode-sdk";
 export declare function parseModel(model: string): Readonly<{
@@ -22,5 +23,5 @@ export type OpencodeRuntime = Readonly<{
     };
     close: () => Promise<void>;
 }>;
-export declare function loadOpencode(execution: ProviderExecution, cwd: string, signal: AbortSignal, loader?: OpencodeSdkLoader): Promise<OpencodeRuntime>;
+export declare function loadOpencode(execution: ProviderExecution, cwd: string, signal: AbortSignal, loader?: OpencodeSdkLoader, onRuntime?: (runtime: OpencodeRuntime) => void): Promise<OpencodeRuntime>;
 export declare function coordinate(sessionId: string): ResumeCoordinate;

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

@@ -37,15 +37,28 @@ async function availablePort() {
         });
     });
 }
-export async function loadOpencode(execution, cwd, signal, loader) {
+export async function loadOpencode(execution, cwd, signal, loader, onRuntime) {
     if (loader) {
-        const loaded = await loader(cwd, execution);
-        return {
+        const loaded = await abortable(loader(cwd, execution, signal), signal);
+        let closing;
+        const runtime = {
             client: loaded.client,
             close: async () => {
-                await loaded.close?.();
+                closing ??= Promise.resolve(loaded.close?.()).then(() => undefined);
+                await closing;
             },
         };
+        onRuntime?.(runtime);
+        try {
+            if (loaded.ready !== undefined)
+                await abortable(loaded.ready, signal);
+            signal.throwIfAborted();
+            return runtime;
+        }
+        catch (error) {
+            await runtime.close();
+            throw error;
+        }
     }
     const port = await availablePort();
     const owned = await spawnDetachedProcess({
@@ -60,19 +73,23 @@ export async function loadOpencode(execution, cwd, signal, loader) {
     });
     const { createOpencodeClient } = await import("@opencode-ai/sdk");
     const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}`, directory: cwd });
+    let closing;
+    const runtime = {
+        client,
+        close: async () => {
+            closing ??= owned.terminate();
+            await closing;
+        },
+    };
+    onRuntime?.(runtime);
     try {
         await waitReady(client, cwd, signal);
     }
     catch (error) {
-        await owned.terminate();
+        await runtime.close();
         throw error;
     }
-    return {
-        client,
-        close: async () => {
-            await owned.terminate();
-        },
-    };
+    return runtime;
 }
 export function coordinate(sessionId) {
     return { sessionId };

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

@@ -1,5 +1,5 @@
 import { abortable } from "../../abort.js";
-import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, createProviderAttempt, } from "../../provider.js";
 import { piTerminalFailure, translatePiEvent } from "./events.js";
 const PI_THINKING_LEVELS = new Set(["minimal", "low", "medium", "high", "xhigh", "max"]);
 const MODEL_PATTERN = /^[^/\s]+\/[^\s]+$/u;
@@ -68,20 +68,14 @@ async function piCreateOptions(sdk, input) {
         ...(customTools === undefined ? {} : { customTools }),
     };
 }
-async function createPiSession(sdk, execution, input, signal) {
+async function createPiSession(sdk, execution, input) {
     const setup = piCreateOptions(sdk, input).then(async (options) => {
         if (execution.config !== undefined) {
             throw new TypeError("Pi provider config cannot be consumed by native CreateAgentSessionOptions");
         }
         return await sdk.createAgentSession(options);
     });
-    return await abortable(setup, signal, (created) => created.session.dispose());
-}
-function forceDisposePi(dispose, settle, setAborting) {
-    setAborting();
-    dispose();
-    settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
-    return Promise.resolve();
+    return await setup;
 }
 async function runPiPrompt(native, input, events, state, settle) {
     try {
@@ -109,60 +103,81 @@ async function runPiPrompt(native, input, events, state, settle) {
             : { kind: "failed", diagnostic: diagnostic(error) });
     }
 }
-async function drivePi(sdk, execution, input, signal) {
-    const created = await createPiSession(sdk, execution, input, signal);
+async function drivePi(sdk, execution, input, signal, custody) {
+    const created = await createPiSession(sdk, execution, input);
     const native = created.session;
-    if (signal.aborted) {
-        native.dispose();
-        signal.throwIfAborted();
-    }
-    if (native.sessionFile === undefined || native.sessionFile.trim().length === 0) {
-        native.dispose();
-        throw new Error("Pi session admitted without sessionFile");
-    }
+    let settleRetired;
+    let failRetired;
+    const closed = new Promise((resolve, reject) => {
+        settleRetired = resolve;
+        failRetired = reject;
+    });
     const events = new AgentEventChannel();
     const eventState = { answer: "", assistantSeen: false, tools: new Map() };
     const state = {
         terminalFailure: null,
-        disposed: false,
         aborting: false,
         settled: false,
     };
-    const dispose = () => {
-        if (state.disposed)
-            return;
-        state.disposed = true;
+    let settleCompletion;
+    const completion = new Promise((resolve) => {
+        settleCompletion = resolve;
+    });
+    const unsubscribe = native.subscribe((event) => {
+        if (event.type === "agent_end" && !event.willRetry)
+            state.terminalFailure = piTerminalFailure(event.messages);
+        for (const translated of translatePiEvent(event, eventState))
+            events.emit(translated);
+    });
+    const settle = (result) => {
+        if (state.settled)
+            return closed;
+        state.settled = true;
+        let failure;
         try {
             unsubscribe();
         }
+        catch (error) {
+            failure = error;
+        }
         finally {
             try {
-                native.dispose();
+                events.end();
             }
             finally {
-                events.end();
+                settleCompletion(result);
+                try {
+                    native.dispose();
+                }
+                catch (error) {
+                    failure ??= error;
+                }
             }
         }
+        if (failure === undefined)
+            settleRetired();
+        else
+            failRetired(failure);
+        return closed;
     };
-    const unsubscribe = native.subscribe((event) => {
-        if (event.type === "agent_end" && !event.willRetry)
-            state.terminalFailure = piTerminalFailure(event.messages);
-        for (const translated of translatePiEvent(event, eventState))
-            events.emit(translated);
-    });
+    const forceDispose = async () => {
+        if (!state.settled)
+            state.aborting = true;
+        await settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
+    };
+    custody?.own({ closed, abort: forceDispose, forceDispose });
+    if (signal.aborted) {
+        await settle({ kind: "failed", diagnostic: "Pi session aborted" });
+        signal.throwIfAborted();
+    }
+    if (native.sessionFile === undefined || native.sessionFile.trim().length === 0) {
+        await settle({ kind: "failed", diagnostic: "Pi session admitted without sessionFile" });
+        throw new Error("Pi session admitted without sessionFile");
+    }
     events.emit({ type: "session", coordinate: { sessionFile: native.sessionFile, sessionId: native.sessionId } });
-    let settleCompletion;
-    const completion = new Promise((resolve) => {
-        settleCompletion = resolve;
+    void runPiPrompt(native, input, eventState, state, (result) => {
+        void settle(result);
     });
-    const settle = (result) => {
-        if (state.settled)
-            return;
-        state.settled = true;
-        dispose();
-        settleCompletion(result);
-    };
-    void runPiPrompt(native, input, eventState, state, settle);
     return {
         admission: { fence: native.sessionId },
         events,
@@ -178,13 +193,11 @@ async function drivePi(sdk, execution, input, signal) {
                 catch {
                     /* prompt settlement still proves local cleanup */
                 }
-                settle({ kind: "failed", diagnostic: "Pi session aborted" });
+                await settle({ kind: "failed", diagnostic: "Pi session aborted" });
             })();
             return state.abortRequest;
         },
-        forceDispose: () => forceDisposePi(dispose, settle, () => {
-            state.aborting = true;
-        }),
+        forceDispose,
     };
 }
 function piSessionFile(coordinate) {
@@ -216,21 +229,22 @@ export function createPiProvider(execution = { name: "pi", kind: "pi" }, load =
     if (execution.env !== undefined && Object.keys(execution.env).length > 0) {
         throw new TypeError("env injection not supported for provider pi");
     }
-    const drive = async (input) => {
-        const signal = input.signal ?? new AbortController().signal;
-        signal.throwIfAborted();
-        return drivePi(await abortable(load(), signal), execution, input, signal);
+    const drive = async (input, custody) => {
+        custody.signal.throwIfAborted();
+        const sdk = await abortable(load(), custody.signal);
+        custody.signal.throwIfAborted();
+        return await drivePi(sdk, execution, { ...input, signal: custody.signal }, custody.signal, custody);
     };
     return {
         admitOptions: admitPiOptions,
-        start: drive,
-        resume: async (input) => {
+        start: (input) => createProviderAttempt(input.signal, async (custody) => await drive(input, custody)),
+        resume: (input) => createProviderAttempt(input.signal, async (custody) => {
             piSessionFile(input.session.coordinate);
-            return drive(input);
-        },
-        fork: async (input) => {
+            return await drive(input, custody);
+        }),
+        fork: (input) => createProviderAttempt(new AbortController().signal, async () => {
             piSessionFile(input.session);
-            return forkPi(await load(), input);
-        },
+            return await forkPi(await load(), input);
+        }),
     };
 }

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

@@ -1,28 +1,22 @@
 import { type Soul } from "./heart/index.js";
 import { type AkumaPaths } from "./identity.js";
-import { type StructuralRequestClaim } from "./request-wire.js";
-import type { OwnedProcess } from "../runtime/proc/run.js";
-export type RequestChildLaunch = Readonly<{
-    paths: AkumaPaths;
-    seed: Omit<Soul, "createdAt">;
-    initialBody: string;
-}>;
+import { type RequestEnvelope } from "./request-wire.js";
 export type PumpInput = Readonly<{
     paths: AkumaPaths;
     parent: Soul;
     bodySequence: number;
     now(): string;
-    spawn(launch: RequestChildLaunch): Promise<OwnedProcess | void>;
+    spawn(launch: unknown): Promise<unknown>;
     upstream?: unknown;
     signal: AbortSignal;
 }>;
 type ServeClaim = (input: PumpInput & Readonly<{
     directory: string;
     transportId: string;
-    claim: StructuralRequestClaim;
+    claim: RequestEnvelope;
     signal: AbortSignal;
     admissionOpen(): boolean;
-}>) => Promise<void>;
+}>) => Promise<boolean>;
 export declare class BodyRequestPump {
     private readonly input;
     private readonly serveClaim;

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

@@ -2,9 +2,9 @@ import { access, mkdir, readFile, readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { abortableDelay } from "./abort.js";
 import { HeldAkumaLeash, readNonterminalRequests, readSoul, serveRequest, voidRequest, } from "./heart/index.js";
-import { pathsForAkuId } from "./identity.js";
+import { pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
 import { BIRTH_TIMEOUT_MS } from "./publication.js";
-import { decodeClaim } from "./request-wire.js";
+import { decodeEnvelope } from "./request-wire.js";
 const POLL_MS = 100;
 export class BodyRequestPump {
     input;
@@ -45,14 +45,14 @@ export class BodyRequestPump {
                 if (this.handled.has(transportId))
                     continue;
                 const path = join(this.directory, name);
-                const claim = decodeClaim(await readFile(path, "utf8"), transportId);
+                const claim = decodeEnvelope(await readFile(path, "utf8"), transportId);
                 if (claim === null) {
                     await rm(path, { force: true });
                     this.handled.add(transportId);
                     continue;
                 }
                 if (!this.admissionClosed) {
-                    await this.serveClaim({
+                    const served = await this.serveClaim({
                         directory: this.directory,
                         transportId,
                         claim,
@@ -60,6 +60,8 @@ export class BodyRequestPump {
                         signal: this.executionSignal.signal,
                         admissionOpen: () => !this.admissionClosed,
                     });
+                    if (!served)
+                        await rm(path, { force: true });
                 }
                 this.handled.add(transportId);
             }
@@ -111,7 +113,7 @@ async function settleReservedSoul(paths, parent, request, soul) {
         : voidRequest(paths, request.id, "reserved child origin does not match the request"));
 }
 async function settleReserved(paths, parent, request, now, signal) {
-    const childPaths = pathsForAkuId(request.world, request.child);
+    const childPaths = pathsForAkuId(worldRootForAkumaPaths(paths), request.child);
     const deadline = performance.now() + BIRTH_TIMEOUT_MS;
     for (;;) {
         signal?.throwIfAborted();

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

@@ -0,0 +1,26 @@
+import { type RequestCommand } from "./request-wire.js";
+export declare class AkumaBodyRequestError extends Error {
+    readonly action: string;
+    readonly outcome: "refused" | "voided";
+    readonly diagnostic: string;
+    readonly kind = "akuma-body-request";
+    constructor(action: string, outcome: "refused" | "voided", diagnostic: string);
+}
+/** Generic rendezvous only: operation owners supply their own request and result codecs. */
+export declare function requestBodyCommand<Input, Output, Service, Reference = Service>(input: Readonly<{
+    directory: string;
+    id?: string;
+    command: RequestCommand<Input, Output, Service, Reference>;
+    value: Input;
+    signal?: AbortSignal;
+}>): Promise<Readonly<{
+    kind: "returned";
+    result: Output;
+    requestId: string;
+    action: string;
+}> | Readonly<{
+    kind: "reference";
+    reference: Reference;
+    requestId: string;
+    action: string;
+}>>;