@astrosheep/keiyaku 4.5.28 → 4.6.1

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

@@ -1,48 +1,87 @@
+import { z } from "zod";
 import type { AkumaCallRequestChildLaunch } from "./call-request.js";
-import { type SessionFact, type Soul, type TellRow } from "./heart/index.js";
 import { type AkumaPaths } from "./identity.js";
+import { type TellResult } from "./call-initial-tell.js";
+export type { TellResult, TellWake } from "./call-initial-tell.js";
 import { type WorldRoot } from "../world.js";
 import type { ProviderAdapter } from "./provider.js";
 import type { ErasedRequestCommand } from "./request-wire.js";
-import { type OwnedProcess, type RunLogReference } from "../runtime/proc/run.js";
+import { type OwnedProcess } from "../runtime/proc/run.js";
 export declare const LEASH_HELD_EXIT = 75;
 export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
-export type BodyLaunch = Readonly<{
-    paths: AkumaPaths;
-    seed?: Omit<Soul, "createdAt">;
-    birthSession?: Omit<SessionFact, "sequence">;
-    initialBody?: string;
-    initiator?: string;
-    initialSchemaJson?: string;
-    refuseIfHeld?: boolean;
-    completion?: Readonly<{
-        contractId?: string;
-    }>;
-}>;
-export type TellWake = Readonly<{
-    kind: "told";
-}> | Readonly<{
-    kind: "pursuing";
-    bodySequence: number;
-}> | Readonly<{
-    kind: "held";
-}> | Readonly<{
-    kind: "failed";
-    diagnostic: string;
-    child?: Readonly<{
-        code: number | null;
-        signal: string | null;
-        log: RunLogReference;
-    }>;
-}>;
-export type TellResult = Readonly<{
-    admission: Readonly<{
-        tellId: string;
-        fact: "recorded";
-    }>;
-    row: TellRow;
-    wake: TellWake;
-}>;
+export declare const bodyLaunchSchema: z.ZodObject<{
+    paths: z.ZodObject<{
+        directory: z.ZodString;
+        heart: z.ZodString;
+        leash: z.ZodString;
+        log: z.ZodString;
+        requests: z.ZodString;
+    }, z.core.$strict>;
+    seed: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<Omit<Readonly<{
+        id: import("./identity.js").AkuId;
+        archetype: string;
+        description?: string;
+        provider: import("./provider-recipe.js").ProviderExecution;
+        options: import("./provider-recipe.js").ProviderOptions;
+        cwd: string;
+        origin: import("./heart/facts.js").AkumaOrigin;
+        allowed: import("./allowed.js").AllowedActions;
+        createdAt: string;
+    }>, "createdAt">, unknown>>>;
+    birthSession: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        coordinate: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+            sessionFile: z.ZodString;
+            sessionId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodTransform<{
+            sessionFile: string;
+            sessionId?: never;
+        } | {
+            sessionFile: string;
+            sessionId: string;
+        }, {
+            sessionFile: string;
+            sessionId?: string | undefined;
+        }>>, z.ZodObject<{
+            sessionId: z.ZodString;
+        }, z.core.$strict>]>;
+        cwd: z.ZodString;
+        options: z.ZodPipe<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            effort: z.ZodOptional<z.ZodString>;
+            network: z.ZodOptional<z.ZodEnum<{
+                disabled: "disabled";
+                enabled: "enabled";
+            }>>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            systemPromptMode: z.ZodOptional<z.ZodEnum<{
+                append: "append";
+                replace: "replace";
+            }>>;
+        }, z.core.$strip>, z.ZodTransform<Readonly<{
+            systemPromptMode?: "append" | "replace";
+            systemPrompt?: string;
+            network?: "disabled" | "enabled";
+            effort?: string;
+            model?: string;
+        }>, {
+            model?: string | undefined;
+            effort?: string | undefined;
+            network?: "disabled" | "enabled" | undefined;
+            systemPrompt?: string | undefined;
+            systemPromptMode?: "append" | "replace" | undefined;
+        }>>;
+        admittedAt: z.ZodString;
+    }, z.core.$strict>>;
+    initialBody: z.ZodOptional<z.ZodString>;
+    initiator: z.ZodOptional<z.ZodString>;
+    initialSchemaJson: z.ZodOptional<z.ZodString>;
+    refuseIfHeld: z.ZodOptional<z.ZodBoolean>;
+    completion: z.ZodOptional<z.ZodObject<{
+        contractId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type BodyLaunch = z.infer<typeof bodyLaunchSchema>;
 export type TellWakeRuntime = Readonly<{
     spawn(paths: AkumaPaths): Promise<OwnedProcess>;
     schedule?(milliseconds: number, signal: AbortSignal): Promise<void>;
@@ -54,28 +93,7 @@ type BodyRuntime = Readonly<{
     world: WorldRoot;
     externalCommands: Readonly<Record<string, ErasedRequestCommand>>;
 }>;
-type RuntimeEnvironment = Readonly<{
-    /** The current process executable, preferred only while it is a different live value. */
-    current?: string;
-    /** The present PATH used to resolve the recorded executable basename. */
-    path?: string | undefined;
-    exists?: (path: string) => boolean | Promise<boolean>;
-}>;
-/** One Body launch's runtime input: the runtime recorded for it and its resolution environment. */
-export type BodyLaunchRuntime = Readonly<{
-    recorded?: string;
-    environment?: RuntimeEnvironment;
-}>;
-/**
- * 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.
- */
-export declare function resolveRuntimeExecutable(recorded?: string, environment?: RuntimeEnvironment): Promise<string>;
-export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string, runtime?: BodyLaunchRuntime): Promise<{
+export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string): Promise<{
     argv: string[];
     cwd: string;
     env: Record<string, string>;
@@ -83,6 +101,6 @@ export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: str
 }>;
 export declare function handoffPendingTells(paths: AkumaPaths, spawn?: (launch: BodyLaunch) => Promise<OwnedProcess>): Promise<void>;
 export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtimeInput?: Partial<BodyRuntime>): Promise<"held" | void>;
-export declare function spawnAkumaBody(launch: BodyLaunch, runtime?: BodyLaunchRuntime): Promise<OwnedProcess>;
+export declare function spawnAkumaBody(launch: BodyLaunch): Promise<OwnedProcess>;
 export declare function runAkumaBody(launch: BodyLaunch, world: WorldRoot, externalCommands: Readonly<Record<string, ErasedRequestCommand>>): Promise<"held" | void>;
 export declare function wakeRecordedTell(paths: AkumaPaths, tellId: string, runtime?: TellWakeRuntime, signal?: AbortSignal): Promise<TellResult>;

package/build/src/akuma/body.js

@@ -1,21 +1,45 @@
+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 { 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";
 import { World } from "../world.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { clearBodyRequestTransport, settleBodyRequests } from "./request-serve.js";
-import { spawnDetachedProcess, } from "../runtime/proc/run.js";
+import { spawnDetachedProcess } from "../runtime/proc/run.js";
 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";
 }
@@ -147,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 {
@@ -294,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,
@@ -304,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 },
@@ -323,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,
@@ -335,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);
@@ -344,6 +372,20 @@ function bodyEndEmitter(launch, soul) {
         }
     })();
 }
+async function admitInitialCallTell(runtime, input) {
+    const paths = pathsForAkuId(runtime.world, input.id);
+    return await admitCallInitialTell({
+        world: runtime.world,
+        id: input.id,
+        initialTell: input.initialTell,
+        signal: input.signal,
+        now: runtime.now,
+        wake: async (tell) => await wakeRecordedTell(paths, tell.id, {
+            spawn: async (tellPaths) => await (runtime.spawnBody ?? spawnAkumaBody)({ paths: tellPaths, refuseIfHeld: true }),
+            schedule: abortableDelay,
+        }, input.signal),
+    });
+}
 async function runBodyTurns(input) {
     const { launch, soul, adapter, bodySequence, supervisor, runtime, turnOutcome } = input;
     let initial = launch.initialBody;
@@ -371,6 +413,7 @@ async function runBodyTurns(input) {
             bodySequence,
             supervisor,
             runtimeSpawn: runtime.spawnChild ?? spawnAkumaBody,
+            admitInitialTell: async (admission) => await admitInitialCallTell(runtime, admission),
             body: initial ?? "",
             ...(initial === undefined ? {} : { call: initial }),
             ...(launch.initiator === undefined ? {} : { initiator: launch.initiator }),
@@ -560,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

@@ -0,0 +1,164 @@
+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;
+}>;
+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;
+}, {
+    kind: "failed";
+    diagnostic: string;
+    child?: {
+        code: number | null;
+        signal: string | null;
+        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";
+        }>;
+        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;
+    wake: Promise<TellResult>;
+}> | Readonly<{
+    kind: "not-born";
+}> | Readonly<{
+    kind: "birth-failed";
+    diagnostic: string;
+}>;
+export declare function admitCallInitialTell(input: Readonly<{
+    world: WorldRoot;
+    id: AkuId;
+    initialTell: CallInitialTell;
+    signal?: AbortSignal;
+    now?: () => string;
+    wake(tell: TellFact): Promise<TellResult>;
+}>): Promise<CallInitialTellAdmission>;
+export {};

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

@@ -0,0 +1,62 @@
+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({
+        timeoutMs: BIRTH_TIMEOUT_MS,
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        probe: async () => await readWaitComplete(input.world, input.id),
+        observe: async () => (await bornStatus(paths, input.id, { aperture: "receipt" })).status,
+        complete: defaultWaitComplete,
+    });
+    if (birth.reason !== "completed" || birth.value.life !== "asleep") {
+        return {
+            kind: "birth-failed",
+            diagnostic: `Akuma ${input.id} prompt-free birth did not settle cleanly`,
+        };
+    }
+    input.signal?.throwIfAborted();
+    const recorded = await recordTell(paths, {
+        kind: "tell",
+        id: input.initialTell.tellId,
+        body: input.initialTell.body,
+        recordedAt: input.now?.() ?? new Date().toISOString(),
+        ...(input.initialTell.schemaJson === undefined ? {} : { schemaJson: input.initialTell.schemaJson }),
+        ...(input.initialTell.initiator === undefined ? {} : { initiator: input.initialTell.initiator }),
+    });
+    if (recorded.kind === "not-born")
+        return recorded;
+    return { kind: "admitted", tell: recorded.tell, wake: input.wake(recorded.tell) };
+}

package/build/src/akuma/call-input.d.ts

@@ -1,4 +1 @@
-export declare function callReadonly(value: unknown, diagnostic?: string): Readonly<{
-    readonly?: true;
-}>;
 export declare function canonicalBirthCwd(input: string, diagnostic?: string): Promise<string>;

package/build/src/akuma/call-input.js

@@ -1,12 +1,5 @@
 import { realpath, stat } from "node:fs/promises";
 import { resolve } from "node:path";
-export function callReadonly(value, diagnostic = "Akuma call readonly must be true") {
-    if (value === undefined)
-        return {};
-    if (value !== true)
-        throw new TypeError(diagnostic);
-    return { readonly: true };
-}
 export async function canonicalBirthCwd(input, diagnostic = `cwd is not an existing directory: ${input}`) {
     const selected = resolve(input);
     try {