@astrosheep/keiyaku 4.1.1 → 4.1.3

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

@@ -118,8 +118,91 @@ function finishClaudeInput(input, terminal) {
     else
         input.close();
 }
+async function consumeClaudeQuery(context) {
+    const { query, input, events, observation, progress, admit, rejectAdmission, settle, controls } = context;
+    let admitted = false;
+    let terminal = null;
+    let historyId;
+    try {
+        for await (const message of query) {
+            if (!admitted && "session_id" in message && typeof message.session_id === "string") {
+                admitted = true;
+                events.emit({ type: "session", coordinate: { sessionId: message.session_id } });
+                admit();
+            }
+            emitClaudeMessage(message, events, observation);
+            if (message.type === "assistant" &&
+                message.parent_tool_use_id === null &&
+                typeof message.uuid === "string" &&
+                message.uuid.length > 0)
+                historyId = message.uuid;
+            if (message.type !== "result")
+                continue;
+            if (message.subtype === "success") {
+                terminal = successfulResult(message, historyId);
+                progress.checkpoint += 1;
+                controls.flushReceipts();
+                queueMicrotask(controls.closeWhenIdle);
+            }
+            else {
+                terminal = { kind: "failed", diagnostic: message.errors.join("; ") || message.subtype };
+                input.close();
+            }
+        }
+        progress.ended = true;
+        const result = terminal ?? { kind: "failed", diagnostic: "Claude query ended without a result" };
+        if (!admitted)
+            rejectAdmission(new Error(result.kind === "failed" ? result.diagnostic : "Claude query ended before session admission"));
+        settle(result);
+    }
+    catch (error) {
+        progress.ended = true;
+        input.fail(error);
+        const failure = error instanceof Error ? error : new Error(String(error));
+        if (!admitted)
+            rejectAdmission(failure);
+        settle({ kind: "failed", diagnostic: failure.message });
+    }
+    finally {
+        finishClaudeInput(input, terminal);
+        events.end();
+        controls.settleReceipts();
+    }
+}
+function claudeTell(input, observed, accepted, state, run) {
+    return (tell) => {
+        if (observed.ended || input.closed)
+            return Promise.resolve({ kind: "turn-ended" });
+        state.openSubmissions += 1;
+        const ordinal = ++state.submission;
+        return new Promise((resolve, reject) => {
+            const pending = { id: tell.id, afterCheckpoint: 0, visible: false };
+            void input
+                .push(claudeUserMessage(tell.text), () => {
+                pending.afterCheckpoint = observed.checkpoint;
+                accepted.push(pending);
+            })
+                .then(() => {
+                state.openSubmissions -= 1;
+                resolve({ kind: "accepted", fence: `claude:${run}:${ordinal}` });
+                queueMicrotask(() => {
+                    pending.visible = true;
+                    observed.flushReceipts();
+                    observed.settleReceipts();
+                });
+            }, (error) => {
+                state.openSubmissions -= 1;
+                if (isClaudeTurnEnded(error))
+                    resolve({ kind: "turn-ended" });
+                else
+                    reject(error);
+                observed.settleReceipts();
+            });
+        });
+    };
+}
 function observeClaudeQuery(context) {
-    const { query, input, events, receipts, accepted, state } = context;
+    const { input, receipts, accepted, state } = context;
     const observation = { tools: new Map() };
     let admit;
     let rejectAdmission;
@@ -131,15 +214,15 @@ function observeClaudeQuery(context) {
     const completion = new Promise((resolve) => {
         settle = resolve;
     });
-    let checkpoint = 0, ended = false;
+    const progress = { checkpoint: 0, ended: false };
     const settleReceipts = () => {
-        if (ended && state.openSubmissions === 0 && accepted.every((tell) => tell.visible))
+        if (progress.ended && state.openSubmissions === 0 && accepted.every((tell) => tell.visible))
             receipts.end();
     };
     const flushReceipts = () => {
         for (let index = 0; index < accepted.length;) {
             const tell = accepted[index];
-            if (!tell.visible || tell.afterCheckpoint >= checkpoint) {
+            if (!tell.visible || tell.afterCheckpoint >= progress.checkpoint) {
                 index += 1;
                 continue;
             }
@@ -153,64 +236,23 @@ function observeClaudeQuery(context) {
         if (state.openSubmissions === 0 && accepted.length === 0 && input.pending === 0)
             input.close();
     };
-    void (async () => {
-        let admitted = false;
-        let terminal = null;
-        let historyId;
-        try {
-            for await (const message of query) {
-                if (!admitted && "session_id" in message && typeof message.session_id === "string") {
-                    admitted = true;
-                    events.emit({ type: "session", coordinate: { sessionId: message.session_id } });
-                    admit();
-                }
-                emitClaudeMessage(message, events, observation);
-                if (message.type === "assistant" &&
-                    message.parent_tool_use_id === null &&
-                    typeof message.uuid === "string" &&
-                    message.uuid.length > 0)
-                    historyId = message.uuid;
-                if (message.type !== "result")
-                    continue;
-                if (message.subtype === "success") {
-                    terminal = successfulResult(message, historyId);
-                    checkpoint += 1;
-                    flushReceipts();
-                    queueMicrotask(closeWhenIdle);
-                }
-                else {
-                    terminal = { kind: "failed", diagnostic: message.errors.join("; ") || message.subtype };
-                    input.close();
-                }
-            }
-            ended = true;
-            const result = terminal ?? { kind: "failed", diagnostic: "Claude query ended without a result" };
-            if (!admitted)
-                rejectAdmission(new Error(result.kind === "failed" ? result.diagnostic : "Claude query ended before session admission"));
-            settle(result);
-        }
-        catch (error) {
-            ended = true;
-            input.fail(error);
-            const failure = error instanceof Error ? error : new Error(String(error));
-            if (!admitted)
-                rejectAdmission(failure);
-            settle({ kind: "failed", diagnostic: failure.message });
-        }
-        finally {
-            finishClaudeInput(input, terminal);
-            events.end();
-            settleReceipts();
-        }
-    })();
+    void consumeClaudeQuery({
+        ...context,
+        observation,
+        progress,
+        admit,
+        rejectAdmission,
+        settle,
+        controls: { flushReceipts, settleReceipts, closeWhenIdle },
+    });
     return {
         admission,
         completion,
         get ended() {
-            return ended;
+            return progress.ended;
         },
         get checkpoint() {
-            return checkpoint;
+            return progress.checkpoint;
         },
         flushReceipts,
         settleReceipts,
@@ -229,8 +271,7 @@ async function driveClaude(load, execution, drive) {
     const abortController = new AbortController();
     const run = randomUUID();
     const accepted = [];
-    let submission = 0;
-    let openSubmissions = 0;
+    const driveState = { submission: 0, openSubmissions: 0 };
     const launchAcknowledged = input.push(claudeUserMessage(launchText(drive)));
     const query = sdk.query({
         prompt: input.iterable,
@@ -251,7 +292,7 @@ async function driveClaude(load, execution, drive) {
         accepted,
         state: {
             get openSubmissions() {
-                return openSubmissions;
+                return driveState.openSubmissions;
             },
         },
     });
@@ -266,36 +307,7 @@ async function driveClaude(load, execution, drive) {
         events,
         receipts,
         completion: observed.completion,
-        tell(tell) {
-            if (observed.ended || input.closed)
-                return Promise.resolve({ kind: "turn-ended" });
-            openSubmissions += 1;
-            const ordinal = ++submission;
-            return new Promise((resolve, reject) => {
-                const pending = { id: tell.id, afterCheckpoint: 0, visible: false };
-                void input
-                    .push(claudeUserMessage(tell.text), () => {
-                    pending.afterCheckpoint = observed.checkpoint;
-                    accepted.push(pending);
-                })
-                    .then(() => {
-                    openSubmissions -= 1;
-                    resolve({ kind: "accepted", fence: `claude:${run}:${ordinal}` });
-                    queueMicrotask(() => {
-                        pending.visible = true;
-                        observed.flushReceipts();
-                        observed.settleReceipts();
-                    });
-                }, (error) => {
-                    openSubmissions -= 1;
-                    if (isClaudeTurnEnded(error))
-                        resolve({ kind: "turn-ended" });
-                    else
-                        reject(error);
-                    observed.settleReceipts();
-                });
-            });
-        },
+        tell: claudeTell(input, observed, accepted, driveState, run),
         async abort() {
             shutDown(new Error("Claude query aborted"));
             await observed.completion;

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

@@ -124,12 +124,8 @@ async function abortTurn(server, state, settle) {
         settle({ kind: "failed", diagnostic: "codex app-server interrupted" });
     await server.close(true);
 }
-async function startCodex(execution, input) {
-    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 = new LineRpcProcess({
+function codexServer(execution, input) {
+    return new LineRpcProcess({
         argv: [execution.executable ?? "codex", "app-server", "--listen", "stdio://"],
         cwd: input.cwd,
         ...(execution.env === undefined && input.requests === undefined
@@ -142,6 +138,13 @@ async function startCodex(execution, input) {
                 },
             }),
     });
+}
+async function startCodex(execution, input) {
+    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 state = { settled: false, tools: new Map() };
     let settle;
     const completion = new Promise((resolve) => {

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

@@ -201,6 +201,26 @@ 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({
+        ...execution,
+        env: {
+            ...execution.env,
+            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
+        },
+    }, input.cwd, signal, loader), signal, async (late) => await late.close());
+}
+async function openDriveSession(runtime, input, resumeSessionId, signal) {
+    const session = runtime.client.session;
+    const response = await abortable(input.session.kind === "fresh"
+        ? session.create({ query: { directory: input.cwd }, throwOnError: true })
+        : session.get({ path: { id: resumeSessionId }, query: { directory: input.cwd }, throwOnError: true }), signal);
+    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) {
     admit(input.options);
     const signal = input.signal ?? new AbortController().signal;
@@ -209,13 +229,7 @@ async function drive(execution, input, loader) {
     const abortSetup = () => abortController.abort(signal.reason);
     signal.addEventListener("abort", abortSetup, { once: true });
     signal.throwIfAborted();
-    const runtime = await abortable(loadOpencode({
-        ...execution,
-        env: {
-            ...execution.env,
-            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
-        },
-    }, input.cwd, abortController.signal, loader), abortController.signal, async (late) => await late.close());
+    const runtime = await loadDriveRuntime(execution, input, abortController.signal, loader);
     let closing;
     let iterator;
     const closeOnce = () => {
@@ -223,14 +237,7 @@ async function drive(execution, input, loader) {
         return closing;
     };
     try {
-        const session = runtime.client.session;
-        const sessionResponse = await abortable(input.session.kind === "fresh"
-            ? session.create({ query: { directory: input.cwd }, throwOnError: true })
-            : session.get({ path: { id: resumeSessionId }, query: { directory: input.cwd }, throwOnError: true }), abortController.signal);
-        const info = object(object(sessionResponse)?.data) ?? object(sessionResponse);
-        const sessionId = text(info?.id) ?? resumeSessionId;
-        if (sessionId === undefined)
-            throw new Error("OpenCode did not return a session id");
+        const { session, sessionId } = await openDriveSession(runtime, input, resumeSessionId, abortController.signal);
         const events = new AgentEventChannel();
         const state = createEventState(sessionId);
         const messageID = `msg_${randomUUID().replaceAll("-", "")}`;

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

@@ -83,6 +83,32 @@ function forceDisposePi(dispose, settle, setAborting) {
     settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
     return Promise.resolve();
 }
+async function runPiPrompt(native, input, events, state, settle) {
+    try {
+        await native.prompt([input.body, ...input.launchTells.map((tell) => tell.text)].join("\n\n"));
+        let result;
+        if (state.aborting)
+            result = { kind: "failed", diagnostic: "Pi session aborted" };
+        else if (state.terminalFailure !== null)
+            result = { kind: "failed", diagnostic: state.terminalFailure };
+        else if (!events.assistantSeen)
+            result = { kind: "failed", diagnostic: "Pi completed without a native assistant answer" };
+        else {
+            const historyId = native.sessionManager.getLeafId();
+            result = {
+                kind: "answered",
+                answer: events.answer,
+                ...(historyId === null ? {} : { historyId }),
+            };
+        }
+        settle(result);
+    }
+    catch (error) {
+        settle(state.aborting
+            ? { kind: "failed", diagnostic: "Pi session aborted" }
+            : { kind: "failed", diagnostic: diagnostic(error) });
+    }
+}
 async function drivePi(sdk, execution, input, signal) {
     const created = await createPiSession(sdk, execution, input, signal);
     const native = created.session;
@@ -95,16 +121,17 @@ async function drivePi(sdk, execution, input, signal) {
         throw new Error("Pi session admitted without sessionFile");
     }
     const events = new AgentEventChannel();
-    const state = { answer: "", assistantSeen: false, tools: new Map() };
-    let terminalFailure = null;
-    let disposed = false;
-    let abortRequest;
-    let aborting = false;
-    let settled = false;
+    const eventState = { answer: "", assistantSeen: false, tools: new Map() };
+    const state = {
+        terminalFailure: null,
+        disposed: false,
+        aborting: false,
+        settled: false,
+    };
     const dispose = () => {
-        if (disposed)
+        if (state.disposed)
             return;
-        disposed = true;
+        state.disposed = true;
         try {
             unsubscribe();
         }
@@ -119,8 +146,8 @@ async function drivePi(sdk, execution, input, signal) {
     };
     const unsubscribe = native.subscribe((event) => {
         if (event.type === "agent_end" && !event.willRetry)
-            terminalFailure = piTerminalFailure(event.messages);
-        for (const translated of translatePiEvent(event, state))
+            state.terminalFailure = piTerminalFailure(event.messages);
+        for (const translated of translatePiEvent(event, eventState))
             events.emit(translated);
     });
     events.emit({ type: "session", coordinate: { sessionFile: native.sessionFile, sessionId: native.sessionId } });
@@ -129,47 +156,22 @@ async function drivePi(sdk, execution, input, signal) {
         settleCompletion = resolve;
     });
     const settle = (result) => {
-        if (settled)
+        if (state.settled)
             return;
-        settled = true;
+        state.settled = true;
         dispose();
         settleCompletion(result);
     };
-    void (async () => {
-        try {
-            await native.prompt([input.body, ...input.launchTells.map((tell) => tell.text)].join("\n\n"));
-            let result;
-            if (aborting)
-                result = { kind: "failed", diagnostic: "Pi session aborted" };
-            else if (terminalFailure !== null)
-                result = { kind: "failed", diagnostic: terminalFailure };
-            else if (!state.assistantSeen)
-                result = { kind: "failed", diagnostic: "Pi completed without a native assistant answer" };
-            else {
-                const historyId = native.sessionManager.getLeafId();
-                result = {
-                    kind: "answered",
-                    answer: state.answer,
-                    ...(historyId === null ? {} : { historyId }),
-                };
-            }
-            settle(result);
-        }
-        catch (error) {
-            settle(aborting
-                ? { kind: "failed", diagnostic: "Pi session aborted" }
-                : { kind: "failed", diagnostic: diagnostic(error) });
-        }
-    })();
+    void runPiPrompt(native, input, eventState, state, settle);
     return {
         admission: { fence: native.sessionId },
         events,
         completion,
         abort: () => {
-            abortRequest ??= (async () => {
-                if (settled)
+            state.abortRequest ??= (async () => {
+                if (state.settled)
                     return;
-                aborting = true;
+                state.aborting = true;
                 try {
                     await native.abort();
                 }
@@ -178,10 +180,10 @@ async function drivePi(sdk, execution, input, signal) {
                 }
                 settle({ kind: "failed", diagnostic: "Pi session aborted" });
             })();
-            return abortRequest;
+            return state.abortRequest;
         },
         forceDispose: () => forceDisposePi(dispose, settle, () => {
-            aborting = true;
+            state.aborting = true;
         }),
     };
 }

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

@@ -1,10 +1,11 @@
 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<{
     worldPath: string;
     archetype: string;
     awaitAsleep?: boolean;
     reserve?(allocated: AllocatedAkuma): Promise<void>;
-    launch(allocated: AllocatedAkuma): Promise<void>;
+    launch(allocated: AllocatedAkuma): Promise<OwnedProcess | void>;
     signal?: AbortSignal;
 }>): Promise<AllocatedAkuma>;

package/build/src/akuma/publication.js

@@ -40,7 +40,40 @@ async function observedBirthFailure(paths) {
         leash.release();
     }
 }
-async function awaitBirth(paths, signal) {
+function preAdmissionDiagnostic(exit) {
+    return exit.code === null ? `pre-admission signal ${exit.signal ?? "unknown"}` : `pre-admission exit ${exit.code}`;
+}
+async function sealObservedExit(paths, exit) {
+    const evidence = preAdmissionDiagnostic(exit);
+    try {
+        const leash = await HeldAkumaLeash.try(paths);
+        if (leash !== null) {
+            try {
+                await leash.sealIfUnborn(paths, { evidence, at: new Date().toISOString() });
+            }
+            finally {
+                leash.release();
+            }
+        }
+    }
+    catch {
+        /* Parent evidence remains authoritative when best-effort sealing fails. */
+    }
+    throw new Error(evidence);
+}
+async function observeSettledExit(owned) {
+    if (owned === undefined)
+        return { kind: "pending" };
+    const pending = Symbol("pending");
+    try {
+        const exit = await Promise.race([owned.exited, Promise.resolve(pending)]);
+        return exit === pending ? { kind: "pending" } : { kind: "exited", exit };
+    }
+    catch (error) {
+        return { kind: "exit-error", error };
+    }
+}
+async function awaitBirth(paths, owned, signal) {
     const deadline = performance.now() + BIRTH_TIMEOUT_MS;
     for (;;) {
         signal?.throwIfAborted();
@@ -48,14 +81,37 @@ async function awaitBirth(paths, signal) {
         if (soul !== null)
             return soul;
         const failure = await observedBirthFailure(paths);
-        if (failure !== null)
+        if (failure !== null) {
+            const settled = await observeSettledExit(owned);
+            if (settled.kind === "exited")
+                await sealObservedExit(paths, settled.exit);
+            if (settled.kind === "exit-error")
+                throw new Error(diagnostic(settled.error));
             throw new Error(failure);
+        }
         if (performance.now() >= deadline) {
             const settled = await settleTimedOutBirth(paths);
             if (settled !== null)
                 return settled;
         }
-        await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal);
+        if (owned === undefined) {
+            await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal);
+            continue;
+        }
+        const outcome = await Promise.race([
+            abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal).then(() => "poll"),
+            owned.exited.then((exit) => ({ kind: "exited", exit }), (error) => ({ kind: "exit-error", error })),
+        ]);
+        if (outcome === "poll")
+            continue;
+        if (outcome.kind === "exited") {
+            const settledSoul = await readSoul(paths);
+            if (settledSoul !== null)
+                return settledSoul;
+            await sealObservedExit(paths, outcome.exit);
+            continue;
+        }
+        throw new Error(diagnostic(outcome.error));
     }
 }
 async function takeLeashUntil(paths, deadline) {
@@ -108,17 +164,22 @@ export async function publishAkuma(input) {
         input.signal?.throwIfAborted();
         await input.reserve?.(allocated);
         input.signal?.throwIfAborted();
-        await input.launch(allocated);
-        input.signal?.throwIfAborted();
+        const owned = await input.launch(allocated);
+        try {
+            input.signal?.throwIfAborted();
+            const soul = await awaitBirth(allocated.paths, owned ?? undefined, input.signal);
+            if (soul.id !== allocated.id)
+                throw new Error("Akuma birth returned a different identity");
+            if (input.awaitAsleep === true)
+                await awaitAsleepBirth(allocated.paths);
+            return allocated;
+        }
+        finally {
+            owned?.release();
+        }
     }
     catch (error) {
         await sealLocalFailure(allocated, error);
         throw error;
     }
-    const soul = await awaitBirth(allocated.paths, input.signal);
-    if (soul.id !== allocated.id)
-        throw new Error("Akuma birth returned a different identity");
-    if (input.awaitAsleep === true)
-        await awaitAsleepBirth(allocated.paths);
-    return allocated;
 }

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

@@ -0,0 +1,8 @@
+import type { UpstreamRequestService } from "./heart/index.js";
+import type { ServeInput, UpstreamFact } from "./request-serve.js";
+type ExecutionResult = Readonly<{
+    result: unknown;
+    service?: UpstreamRequestService;
+}>;
+export declare function executeRequest(input: ServeInput, request: UpstreamFact): Promise<ExecutionResult>;
+export {};