@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/akuma/body.js

@@ -1,11 +1,13 @@
+import { z } from "zod";
+import { decodeSoulSeed } from "./heart/soul.js";
+import { sessionAdmissionSchema } from "./heart/rows.js";
 import { appendFile, stat } from "node:fs/promises";
-import { basename, delimiter, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { abortable, abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import { driveTurn, turnRecipe } from "./turn-drive.js";
-import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, readHeart, readLatestTurnForBody, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readNonterminalRequests, resolvePendingTellDisposition, } from "./heart/index.js";
-import { pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
+import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, readHeart, readLatestTurnForBody, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readTurnParticipants, readNonterminalRequests, resolvePendingTellDisposition, } from "./heart/index.js";
+import { akumaPathsSchema, pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
 import { admitCallInitialTell, } from "./call-initial-tell.js";
 import { akumaExecutionEnvironment } from "./providers/execution-environment.js";
 import { pluginRuntime } from "../plugin/runtime.js";
@@ -17,6 +19,27 @@ const LEASH_RETRY_MS = 100;
 const WAKE_REREAD_MS = 100;
 export const LEASH_HELD_EXIT = 75;
 export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
+const launchSeedSchema = z.unknown().transform((value, context) => {
+    try {
+        return decodeSoulSeed(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "invalid Body birth seed" });
+        return z.NEVER;
+    }
+});
+export const bodyLaunchSchema = z
+    .object({
+    paths: akumaPathsSchema,
+    seed: launchSeedSchema.optional(),
+    birthSession: sessionAdmissionSchema.optional(),
+    initialBody: z.string().optional(),
+    initiator: z.string().optional(),
+    initialSchemaJson: z.string().optional(),
+    refuseIfHeld: z.boolean().optional(),
+    completion: z.object({ contractId: z.string().optional() }).strict().optional(),
+})
+    .strict();
 function missing(error) {
     return isHeartAbsent(error) || error.code === "ENOENT";
 }
@@ -148,64 +171,63 @@ const DEFAULT_RUNTIME = {
     spawnBody: spawnAkumaBody,
 };
 /**
- * The runtime executable this process recorded at its birth. A package-manager
- * upgrade can remove the file under a live process, so a wake re-resolves that
- * record instead of surfacing a bare missing-file launch failure.
+ * The Body spawn executable is the waking process's own executable, resolved
+ * at use time. There is no recorded path and no re-resolution chain: when the
+ * file is genuinely gone the spawn fails honestly and the wake diagnostic
+ * names the missing piece.
  */
-const RECORDED_RUNTIME = process.execPath;
-async function runtimeFileExists(path) {
+async function executableMissing(path) {
     try {
-        return (await stat(path)).isFile();
+        return !(await stat(path)).isFile();
     }
     catch {
-        return false;
+        return true;
     }
 }
-async function runtimeCommandOnPath(command, path, exists) {
-    if (command.length === 0 || command.includes("/") || command.includes("\\"))
-        return null;
-    for (const directory of (path ?? "").split(delimiter)) {
-        if (directory.length === 0)
-            continue;
-        const candidate = join(directory, command);
-        if (await exists(candidate))
-            return candidate;
+async function frozenCwdMissing(path) {
+    try {
+        await stat(path);
+        return false;
     }
-    return null;
-}
-class StaleRuntimeError extends Error {
-    constructor(recorded, current, command) {
-        super(`recorded Body runtime ${recorded} no longer exists and re-resolution failed: neither this process executable ` +
-            `${current} nor the command "${command}" on PATH names an existing file; kill this Akuma and call a fresh one`);
-        this.name = "StaleRuntimeError";
+    catch {
+        return true;
     }
 }
 /**
- * Resolve the runtime executable a Body spawn will use. The path recorded for
- * this process's birth wins while it exists. Once it is gone, wake re-resolves
- * the runtime before any spawn can fail: the current process executable while
- * that is a different live value, then the recorded executable basename on the
- * present PATH. An unresolvable runtime refuses with the stale record, the
- * failed re-resolution, and the kill-and-call-fresh remedy.
+ * Diagnose an ENOENT Body spawn failure by checking the attempted executable
+ * and the frozen execution cwd separately. The message names the genuinely
+ * missing piece(s) with the kill-and-call-fresh remedy; a missing cwd likely
+ * means its Contract was accepted and the worktree cleaned up. When both
+ * pieces still exist the original failure passes through unchanged, as does
+ * any non-ENOENT spawn failure.
  */
-export async function resolveRuntimeExecutable(recorded = RECORDED_RUNTIME, environment = {}) {
-    const exists = environment.exists ?? runtimeFileExists;
-    if (await exists(recorded))
-        return recorded;
-    const current = environment.current ?? process.execPath;
-    const command = basename(recorded);
-    const reResolved = (current !== recorded && (await exists(current)) ? current : null) ??
-        (await runtimeCommandOnPath(command, environment.path ?? process.env.PATH, exists));
-    if (reResolved === null)
-        throw new StaleRuntimeError(recorded, current, command);
-    return reResolved;
-}
-export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url, runtime = {}) {
+async function diagnoseSpawnEnoent(input, cause) {
+    const executable = input.argv[0] ?? process.execPath;
+    const cwd = input.cwd;
+    const [noExecutable, noCwd] = await Promise.all([executableMissing(executable), frozenCwdMissing(cwd)]);
+    if (!noExecutable && !noCwd)
+        return cause instanceof Error ? cause : new Error(String(cause));
+    const missing = [];
+    if (noCwd)
+        missing.push(`frozen execution directory ${cwd} no longer exists`);
+    if (noExecutable)
+        missing.push(`waking process executable ${executable} no longer exists (the host likely removed the running process binary)`);
+    const remedies = [];
+    if (noCwd)
+        remedies.push("a missing execution directory likely means its Contract was accepted and the worktree cleaned up, with deliverables already in Git");
+    if (noExecutable)
+        remedies.push("a missing executable likely means the host removed the running process binary: re-enter with a fresh CLI process and retry");
+    const remedy = `kill this Akuma and call a fresh one; ${remedies.join("; ")}`;
+    const error = new Error(`Body spawn failed: ${missing.join(" and ")}; ${remedy}`, { cause });
+    error.code = "ENOENT";
+    return error;
+}
+export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url) {
     const encoded = Buffer.from(JSON.stringify(launch), "utf8").toString("base64url");
     const actorId = launch.seed?.id ?? (await readHeart(launch.paths)).soul?.id;
     if (actorId === undefined)
         throw new Error("Akuma wake has no born soul");
-    const executable = await resolveRuntimeExecutable(runtime.recorded, runtime.environment);
+    const executable = process.execPath;
     const source = bodyModuleUrl.endsWith(".ts");
     const entry = fileURLToPath(new URL(source ? "../akuma-body.ts" : "../akuma-body.js", bodyModuleUrl));
     return {
@@ -295,6 +317,7 @@ function turnOutcomeEmitter(launch, soul) {
                 const turn = await readTurn(launch.paths, turnSequence);
                 if (turn === null)
                     throw new Error(`Committed Turn ${turnSequence} is missing from Heart`);
+                const participants = await readTurnParticipants(launch.paths, turnSequence);
                 plugins ??= pluginRuntime({
                     world: await World.at(worldRootForAkumaPaths(launch.paths)),
                     reportDiagnostic,
@@ -305,6 +328,7 @@ function turnOutcomeEmitter(launch, soul) {
                     bodySequence: turn.bodySequence,
                     turnSequence,
                     ...(turn.initiator === undefined ? {} : { initiator: turn.initiator }),
+                    ...(participants.length === 0 ? {} : { participants }),
                     outcome: outcome.outcome === "answered"
                         ? { kind: "answered", text: outcome.answer }
                         : { kind: "failed", reason: outcome.diagnostic },
@@ -324,7 +348,9 @@ function bodyEndEmitter(launch, soul) {
     };
     return (bodySequence, end, diagnostic) => (async () => {
         try {
-            const initiator = (await readLatestTurnForBody(launch.paths, bodySequence))?.initiator;
+            const latestTurn = await readLatestTurnForBody(launch.paths, bodySequence);
+            const initiator = latestTurn?.initiator;
+            const participants = latestTurn === null ? [] : await readTurnParticipants(launch.paths, latestTurn.sequence);
             plugins ??= pluginRuntime({
                 world: await World.at(worldRootForAkumaPaths(launch.paths)),
                 reportDiagnostic,
@@ -336,6 +362,7 @@ function bodyEndEmitter(launch, soul) {
                 bodySequence,
                 end,
                 ...(initiator === undefined ? {} : { initiator }),
+                ...(participants.length === 0 ? {} : { participants }),
                 ...(diagnostic === undefined ? {} : { diagnostic }),
                 ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
             }, reportDiagnostic);
@@ -576,8 +603,16 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
             await finished.notification;
     }
 }
-export async function spawnAkumaBody(launch, runtime = {}) {
-    return await spawnDetachedProcess(await bodyProcessInput(launch, import.meta.url, runtime));
+export async function spawnAkumaBody(launch) {
+    const input = await bodyProcessInput(launch, import.meta.url);
+    try {
+        return await spawnDetachedProcess(input);
+    }
+    catch (error) {
+        if (error?.code !== "ENOENT")
+            throw error;
+        throw await diagnoseSpawnEnoent(input, error);
+    }
 }
 export async function runAkumaBody(launch, world, externalCommands) {
     return await driveAkumaBody(launch, undefined, { world, externalCommands });

package/build/src/akuma/call-initial-tell.d.ts

@@ -1,40 +1,148 @@
-import { type TellFact, type TellRow } from "./heart/index.js";
-import { type AkuId } from "./identity.js";
+import { z } from "zod";
 import type { WorldRoot } from "../world.js";
+import { type TellFact } from "./heart/index.js";
+import { type AkuId } from "./identity.js";
 export type CallInitialTell = Readonly<{
     tellId: string;
     body: string;
     schemaJson?: string;
     initiator?: string;
 }>;
-export type TellWake = Readonly<{
-    kind: "told";
-}> | Readonly<{
-    kind: "pursuing";
-    bodySequence: number;
-}> | Readonly<{
-    kind: "held";
-}> | Readonly<{
+declare const tellWakeSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"told">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"held">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"pursuing">;
+    bodySequence: z.ZodNumber;
+}, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+    kind: z.ZodLiteral<"failed">;
+    diagnostic: z.ZodString;
+    child: z.ZodOptional<z.ZodObject<{
+        code: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        log: z.ZodObject<{
+            path: z.ZodString;
+            from: z.ZodNumber;
+            to: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodTransform<{
+    kind: "failed";
+    diagnostic: string;
+} | {
+    child: {
+        code: number | null;
+        signal: string | null;
+        log: {
+            path: string;
+            from: number;
+            to: number;
+        };
+    };
     kind: "failed";
     diagnostic: string;
-    child?: Readonly<{
+}, {
+    kind: "failed";
+    diagnostic: string;
+    child?: {
         code: number | null;
         signal: string | null;
-        log: Readonly<{
+        log: {
             path: string;
             from: number;
             to: number;
+        };
+    } | undefined;
+}>>]>;
+export declare const tellResultSchema: z.ZodObject<{
+    admission: z.ZodObject<{
+        fact: z.ZodLiteral<"recorded">;
+        tellId: z.ZodString;
+    }, z.core.$strict>;
+    row: z.ZodObject<{
+        kind: z.ZodLiteral<"tell">;
+        sequence: z.ZodNumber;
+        at: z.ZodString;
+        tellId: z.ZodString;
+        text: z.ZodString;
+        state: z.ZodEnum<{
+            pending: "pending";
+            told: "told";
         }>;
-    }>;
-}>;
-export type TellResult = Readonly<{
-    admission: Readonly<{
-        tellId: string;
-        fact: "recorded";
-    }>;
-    row: TellRow;
-    wake: TellWake;
-}>;
+        deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
+            deliveredAt: z.ZodString;
+            route: z.ZodEnum<{
+                live: "live";
+                launch: "launch";
+            }>;
+            turnSequence: z.ZodNumber;
+            receipt: z.ZodOptional<z.ZodEnum<{
+                required: "required";
+                unavailable: "unavailable";
+            }>>;
+        }, z.core.$strict>, z.ZodTransform<Readonly<{
+            turnSequence: number;
+            route: "launch" | "live";
+            receipt?: "unavailable" | "required";
+            deliveredAt: string;
+        }>, {
+            deliveredAt: string;
+            route: "live" | "launch";
+            turnSequence: number;
+            receipt?: "required" | "unavailable" | undefined;
+        }>>>>;
+    }, z.core.$strict>;
+    wake: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"told">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"held">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"pursuing">;
+        bodySequence: z.ZodNumber;
+    }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+        kind: z.ZodLiteral<"failed">;
+        diagnostic: z.ZodString;
+        child: z.ZodOptional<z.ZodObject<{
+            code: z.ZodNullable<z.ZodNumber>;
+            signal: z.ZodNullable<z.ZodString>;
+            log: z.ZodObject<{
+                path: z.ZodString;
+                from: z.ZodNumber;
+                to: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodTransform<{
+        kind: "failed";
+        diagnostic: string;
+    } | {
+        child: {
+            code: number | null;
+            signal: string | null;
+            log: {
+                path: string;
+                from: number;
+                to: number;
+            };
+        };
+        kind: "failed";
+        diagnostic: string;
+    }, {
+        kind: "failed";
+        diagnostic: string;
+        child?: {
+            code: number | null;
+            signal: string | null;
+            log: {
+                path: string;
+                from: number;
+                to: number;
+            };
+        } | undefined;
+    }>>]>;
+}, z.core.$strict>;
+export type TellWake = z.infer<typeof tellWakeSchema>;
+export type TellResult = z.infer<typeof tellResultSchema>;
 export type CallInitialTellAdmission = Readonly<{
     kind: "admitted";
     tell: TellFact;
@@ -53,3 +161,4 @@ export declare function admitCallInitialTell(input: Readonly<{
     now?: () => string;
     wake(tell: TellFact): Promise<TellResult>;
 }>): Promise<CallInitialTellAdmission>;
+export {};

package/build/src/akuma/call-initial-tell.js

@@ -1,7 +1,37 @@
-import { defaultWaitComplete, bornStatus, readWaitComplete, waitForObservation } from "./akuma-observe.js";
+import { z } from "zod";
+import { bornStatus, defaultWaitComplete, readWaitComplete, waitForObservation } from "./akuma-observe.js";
 import { recordTell } from "./heart/index.js";
 import { pathsForAkuId } from "./identity.js";
+import { tellRowSchema } from "./projection.js";
 import { BIRTH_TIMEOUT_MS } from "./publication.js";
+const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
+const runLogReferenceSchema = z
+    .object({ path: z.string(), from: z.number().int().nonnegative(), to: z.number().int().nonnegative() })
+    .strict();
+const failedTellWakeSchema = z
+    .object({
+    kind: z.literal("failed"),
+    diagnostic: z.string(),
+    child: z
+        .object({ code: z.number().int().nullable(), signal: z.string().nullable(), log: runLogReferenceSchema })
+        .strict()
+        .optional(),
+})
+    .strict()
+    .transform(({ child, ...wake }) => (child === undefined ? wake : { ...wake, child }));
+const tellWakeSchema = z.union([
+    z.object({ kind: z.literal("told") }).strict(),
+    z.object({ kind: z.literal("held") }).strict(),
+    z.object({ kind: z.literal("pursuing"), bodySequence: z.number().int().nonnegative() }).strict(),
+    failedTellWakeSchema,
+]);
+export const tellResultSchema = z
+    .object({
+    admission: z.object({ fact: z.literal("recorded"), tellId: nonblankTextSchema }).strict(),
+    row: tellRowSchema,
+    wake: tellWakeSchema,
+})
+    .strict();
 export async function admitCallInitialTell(input) {
     const paths = pathsForAkuId(input.world, input.id);
     const birth = await waitForObservation({