@astrosheep/keiyaku 4.1.4 → 4.2.0

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

@@ -1,7 +1,10 @@
 import { AkumaHandle } from "./akuma-handle.js";
-import type { AkumaCallContext, AkumaCallInput, AkumaConfiguration, AkumaList, AkumaListInput } from "./akuma.js";
+import type { AkumaCallContext, AkumaCallInput, AkumaConfiguration, AkumaList, AkumaListInput, ResultRoute } from "./akuma.js";
 import { CALL_WITH_CONTEXT } from "./akuma-product-symbols.js";
 import type { WorldRoot } from "../world.js";
+type AkumaCallLaunchInput = AkumaCallInput & Readonly<{
+    resultRoute?: ResultRoute;
+}>;
 export declare class Akuma {
     private readonly path;
     private readonly configuration;
@@ -11,8 +14,9 @@ export declare class Akuma {
         id: string;
     }>): AkumaHandle;
     listArchetypes(): Promise<readonly string[]>;
-    call(input: AkumaCallInput): Promise<AkumaHandle>;
-    [CALL_WITH_CONTEXT](input: AkumaCallInput, context: AkumaCallContext): Promise<AkumaHandle>;
+    call(input: AkumaCallLaunchInput): Promise<AkumaHandle>;
+    [CALL_WITH_CONTEXT](input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaHandle>;
     list(input?: AkumaListInput): Promise<AkumaList>;
 }
-export declare function callAkumaWithContext(akuma: Akuma, input: AkumaCallInput, context: AkumaCallContext): Promise<AkumaHandle>;
+export declare function callAkumaWithContext(akuma: Akuma, input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaHandle>;
+export {};

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

@@ -102,6 +102,7 @@ export class Akuma {
                     origin: { kind: "direct" },
                 },
                 initialBody: input.body,
+                ...(input.resultRoute === undefined ? {} : { resultRoute: input.resultRoute }),
             }),
         });
         return new AkumaHandle(published.id, this.path, {

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

@@ -57,6 +57,8 @@ export type AkumaCallInput = Readonly<{
     readonly?: true;
     allowed?: readonly AllowedAction[];
 }>;
+/** Opaque, serializable caller result address carried across the Body process. */
+export type ResultRoute = Readonly<unknown>;
 export type AkumaCallContext = Readonly<{
     initiatorCwd?: string;
     cwdCanonical?: true;

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

@@ -1,6 +1,7 @@
 import { type SessionFact, type Soul } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 import type { ProviderAdapter } from "./provider.js";
+import type { ResultRoute } from "./akuma.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;
@@ -11,6 +12,7 @@ export type BodyLaunch = Readonly<{
     birthSession?: Omit<SessionFact, "sequence">;
     initialBody?: string;
     refuseIfHeld?: boolean;
+    resultRoute?: ResultRoute;
 }>;
 export type TellWake = Readonly<{
     kind: "told";
@@ -43,6 +45,10 @@ type BodyRuntime = Readonly<{
     now(): string;
     spawnChild?(launch: RequestChildLaunch): Promise<void>;
     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,3 +1,4 @@
+import { appendFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
@@ -58,24 +59,52 @@ async function launchCwd(launch) {
     return (await turnRecipe(launch.paths, soul)).cwd;
 }
 async function persistTurn(paths, turnSequence, result, completedAt) {
-    await endTurn(paths, {
-        turnSequence,
-        outcome: result.kind === "answered" && result.session !== undefined
-            ? {
+    if (result.kind === "answered" && result.session !== undefined) {
+        await endTurn(paths, {
+            turnSequence,
+            outcome: {
                 kind: "answered",
                 session: result.session,
                 answer: result.answer,
                 ...(result.historyId === undefined ? {} : { historyId: result.historyId }),
-            }
-            : result.kind === "answered"
-                ? { kind: "failed", diagnostic: "Provider answered without a resumable session" }
-                : { kind: "failed", diagnostic: result.diagnostic },
-        completedAt,
-    });
-    return result.kind === "answered" && result.session === undefined ? "failed" : result.kind;
+            },
+            completedAt,
+        });
+        return { outcome: "answered", answer: result.answer };
+    }
+    const diagnostic = result.kind === "answered" ? "Provider answered without a resumable session" : result.diagnostic;
+    await endTurn(paths, { turnSequence, outcome: { kind: "failed", diagnostic }, completedAt });
+    return { outcome: "failed", diagnostic };
+}
+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;
+    try {
+        const express = runtime.express ?? (await import("@astrosheep/square")).express;
+        await express(launch.resultRoute, {
+            as: "keiyaku",
+            body: JSON.stringify({ akuma: soul.id, ...outcome }),
+        });
+    }
+    catch (error) {
+        try {
+            await appendFile(launch.paths.log, `result-route express failed: ${boundedDiagnostic(error)}\n`);
+        }
+        catch {
+            /* express loss never changes Heart truth */
+        }
+    }
 }
 function defaultRuntime() {
-    return { now: () => new Date().toISOString(), spawnChild: handoffAkumaBody, spawnBody: spawnAkumaBody };
+    return {
+        now: () => new Date().toISOString(),
+        spawnChild: handoffAkumaBody,
+        spawnBody: spawnAkumaBody,
+    };
 }
 export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url) {
     const encoded = Buffer.from(JSON.stringify(launch), "utf8").toString("base64url");
@@ -84,11 +113,10 @@ export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url)
         throw new Error("Akuma wake has no born soul");
     const source = bodyModuleUrl.endsWith(".ts");
     const entry = fileURLToPath(new URL(source ? "../akuma-body.ts" : "../akuma-body.js", bodyModuleUrl));
-    const argv = source
-        ? [process.execPath, "--import", import.meta.resolve("tsx"), entry, encoded]
-        : [process.execPath, entry, encoded];
     return {
-        argv,
+        argv: source
+            ? [process.execPath, "--import", import.meta.resolve("tsx"), entry, encoded]
+            : [process.execPath, entry, encoded],
         cwd: await launchCwd(launch),
         env: { ...process.env, KEIYAKU_ACTOR_ID: actorId },
         log: launch.paths.log,
@@ -170,8 +198,14 @@ async function runBodyTurns(input) {
             await breakBody(launch.paths, { sequence: bodySequence, end: "put-down", at: runtime.now() });
             return;
         }
-        if (result.kind === "resume-unsupported" ||
-            (await persistTurn(launch.paths, result.turnSequence, result, runtime.now())) === "failed") {
+        if (result.kind === "resume-unsupported") {
+            await breakBody(launch.paths, { sequence: bodySequence, end: "broke-off", at: runtime.now() });
+            return;
+        }
+        const outcome = await persistTurn(launch.paths, result.turnSequence, result, runtime.now());
+        if (initial !== undefined)
+            await expressInitialOutcome(launch, soul, outcome, runtime);
+        if (outcome.outcome === "failed") {
             await breakBody(launch.paths, { sequence: bodySequence, end: "broke-off", at: runtime.now() });
             return;
         }

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

@@ -1,7 +1,7 @@
 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 { AkumaCallInput, ResultRoute } from "./akuma.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";
 export type { AllowedAction, AllowedActions } from "./allowed.js";
 export type { WorldRoot } from "../world.js";

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

@@ -1,4 +1,5 @@
 import { type AkuId, type ActivityHistory } from "../../akuma/index.js";
+import type { ResultRoute } from "../../akuma/akuma.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,6 +73,7 @@ type InvokeInput = Readonly<{
     settings?: Settings;
     contract?: KeiyakuContract;
     repo?: Repo;
+    resultRoute?: ResultRoute;
     readStdin(): Promise<string>;
 }>;
 export declare function invokeAkuma(command: InvokedAkumaCommand, input: InvokeInput): Promise<AkumaInvocationResult>;

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

@@ -113,6 +113,7 @@ export async function invokeAkuma(command, input) {
                 ...(input.contract === undefined ? {} : { contract: input.contract }),
                 ...(command.alias === undefined ? {} : { alias: command.alias }),
                 ...(command.allowed === undefined ? {} : { allowed: command.allowed }),
+                ...(input.resultRoute === undefined ? {} : { resultRoute: input.resultRoute }),
             });
             return { kind: "akuma", action: "call", result, world: input.path };
         }

package/build/src/cli/invoke.js

@@ -1,3 +1,4 @@
+import { captureRoute } from "@astrosheep/square";
 import { resolveActor } from "./actor.js";
 import { isParsedAkumaCommand } from "./commands/akuma.js";
 import { invokeContractMutation } from "./commands/contract-invoke.js";
@@ -105,12 +106,14 @@ 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 }),
             readStdin: edge.readStdin,
         });
     }
@@ -325,6 +328,7 @@ async function invokeParsed(invocation, runtime) {
             located: world,
             candidate: candidateWorld,
             establish: coordinates.establishWorld,
+            invocationCwd: cwd,
             ...(cwdSource === "input" ? { statedCwd: cwd } : {}),
             ...(repo === undefined ? {} : { repo }),
             ...(home === undefined ? {} : { home }),

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

@@ -1,5 +1,5 @@
 import { type AliasBinding } from "../alias/index.js";
-import { type AkumaStatus, type ForkReceipt, type ReadonlyRestraint } from "../akuma/akuma.js";
+import { type AkumaStatus, type ForkReceipt, type ReadonlyRestraint, type ResultRoute } from "../akuma/akuma.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,9 +48,11 @@ 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;

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

@@ -77,9 +77,10 @@ function callTimeout(value, mode) {
     }
     return value;
 }
-async function observeCall(handle, mode, timeoutMs) {
-    if (mode === "detach")
-        return { kind: "detached" };
+async function observeCall(handle, mode, timeoutMs, resultRoute) {
+    if (mode === "detach") {
+        return { kind: "detached", resultRoute: resultRoute === undefined ? "not-captured" : "captured" };
+    }
     try {
         return { kind: "observed", status: await handle.wait(undefined, { timeoutMs }) };
     }
@@ -179,6 +180,7 @@ export async function callKeiyaku(input) {
         "contract",
         "alias",
         "allowed",
+        "resultRoute",
     ], "Keiyaku.call input");
     const path = nonblank(values.path, "path");
     const archetype = nonblank(values.archetype, "archetype");
@@ -191,6 +193,7 @@ 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 }),
@@ -203,6 +206,7 @@ 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);
@@ -226,7 +230,7 @@ export async function callKeiyaku(input) {
             }
         }
     }
-    const observation = await observeCall(handle, mode, timeoutMs);
+    const observation = await observeCall(handle, mode, timeoutMs, resultRoute);
     return {
         kind: "called",
         akuma: handle.id,

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

@@ -7,7 +7,7 @@ export function platformLaunchPolicy(intent, platform = process.platform) {
         return { kind: "windows-launcher" };
     return {
         kind: "spawn",
-        detached: platform !== "win32",
+        detached: true,
         windowsHide: true,
         shell: false,
     };

package/package.json

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