@astrosheep/keiyaku 4.1.3 → 4.1.5

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

@@ -1,7 +1,11 @@
+import type { SquareRoute } from "@astrosheep/square";
 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 { WorldRoot } from "../world.js";
+type AkumaCallLaunchInput = AkumaCallInput & Readonly<{
+    resultRoute?: SquareRoute;
+}>;
 export declare class Akuma {
     private readonly path;
     private readonly configuration;
@@ -11,8 +15,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/body.d.ts

@@ -1,3 +1,4 @@
+import type { SquareRoute } from "@astrosheep/square";
 import { type SessionFact, type Soul } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 import type { ProviderAdapter } from "./provider.js";
@@ -11,6 +12,7 @@ export type BodyLaunch = Readonly<{
     birthSession?: Omit<SessionFact, "sequence">;
     initialBody?: string;
     refuseIfHeld?: boolean;
+    resultRoute?: SquareRoute;
 }>;
 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: SquareRoute, 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";
@@ -74,8 +75,35 @@ async function persistTurn(paths, turnSequence, result, completedAt) {
     });
     return result.kind === "answered" && result.session === undefined ? "failed" : result.kind;
 }
+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 +112,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 +197,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 === "failed") {
             await breakBody(launch.paths, { sequence: bodySequence, end: "broke-off", at: runtime.now() });
             return;
         }

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

@@ -1,3 +1,4 @@
+import type { SquareRoute } from "@astrosheep/square";
 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";
@@ -72,6 +73,7 @@ type InvokeInput = Readonly<{
     settings?: Settings;
     contract?: KeiyakuContract;
     repo?: Repo;
+    resultRoute?: SquareRoute;
     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,3 +1,4 @@
+import type { SquareRoute } from "@astrosheep/square";
 import { type AliasBinding } from "../alias/index.js";
 import { type AkumaStatus, type ForkReceipt, type ReadonlyRestraint } from "../akuma/akuma.js";
 import type { AkuId } from "../akuma/identity.js";
@@ -48,9 +49,11 @@ export type CallInput = Readonly<{
     contract?: Keiyaku;
     alias?: AkumaAlias;
     allowed?: readonly AllowedAction[];
+    resultRoute?: SquareRoute;
 }>;
 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/build/src/runtime/proc/run.js

@@ -128,16 +128,23 @@ async function retainDetachedExitEvidence(log, path, from, code, signal) {
 export async function spawnDetachedProcess(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("retained", input, ["ignore", log.fd, log.fd]));
-        await new Promise((resolve, reject) => {
-            child.once("spawn", resolve);
-            child.once("error", reject);
-        });
-        if (child.pid === undefined)
-            throw new Error("detached process spawned without a pid");
-        const pid = child.pid;
+        let state = "active";
+        let termination;
+        const invalidate = () => {
+            state = "inert";
+        };
+        child.once("exit", invalidate);
+        child.once("close", invalidate);
         const exited = new Promise((resolve, reject) => {
             child.once("close", (code, signal) => {
                 void (async () => {
@@ -151,7 +158,7 @@ export async function spawnDetachedProcess(input) {
                         failure = error;
                     }
                     try {
-                        await log.close();
+                        await closeLog();
                     }
                     catch (error) {
                         failure ??= error;
@@ -164,13 +171,13 @@ export async function spawnDetachedProcess(input) {
             });
         });
         void exited.catch(() => undefined);
-        let state = "active";
-        let termination;
-        const invalidate = () => {
-            state = "inert";
-        };
-        child.once("exit", invalidate);
-        child.once("close", invalidate);
+        await new Promise((resolve, reject) => {
+            child.once("spawn", resolve);
+            child.once("error", reject);
+        });
+        if (child.pid === undefined)
+            throw new Error("detached process spawned without a pid");
+        const pid = child.pid;
         launched = true;
         return {
             pid,
@@ -194,7 +201,7 @@ export async function spawnDetachedProcess(input) {
     }
     finally {
         if (!launched)
-            await log.close();
+            await closeLog();
     }
 }
 function terminalOutcome(code, stdout, stderr, consuming) {

package/package.json

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