@astrosheep/keiyaku 4.6.19 → 4.6.20

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

@@ -1,24 +1,15 @@
-import { outcomePluginObserver, stderrPluginDiagnostic, withAkumaWaitDeferrals } from "../plugin/akuma-signals.js";
+import { emitPluginSignal, outcomePluginObserver, stderrPluginDiagnostic, withAkumaWaitDeferrals, } from "../plugin/akuma-signals.js";
 import { abortable } from "./abort.js";
 import { admitAkumaCall } from "./akuma-call.js";
 import { defaultWaitComplete } from "./akuma-observe.js";
 import { AkumaOwner } from "./akuma-owner.js";
 import { decodeAskObservation, executeAskAkuma, executeTellAkuma } from "./akuma-selection-execution.js";
+import { captureAkumaHost } from "../body-host.js";
 import { parseAkuId } from "./identity.js";
 import { schemaFromStandard, schemaJsonText } from "./schema.js";
 /** Capture the observer capability, not the caller's mutable options object. */
 export function captureAkumaHostDiagnostic(host) {
-    if (host === undefined)
-        return undefined;
-    if (typeof host !== "object" || host === null || Array.isArray(host))
-        throw new TypeError("Akuma host options must be an object");
-    const unknown = Object.keys(host).find((key) => key !== "reportDiagnostic");
-    if (unknown !== undefined)
-        throw new TypeError(`Akuma host options has unknown field: ${unknown}`);
-    const reportDiagnostic = host.reportDiagnostic;
-    if (reportDiagnostic !== undefined && typeof reportDiagnostic !== "function")
-        throw new TypeError("Akuma host reportDiagnostic must be a function");
-    return reportDiagnostic;
+    return captureAkumaHost(host).reportDiagnostic;
 }
 function signalOption(value) {
     if (value === undefined)
@@ -27,46 +18,21 @@ function signalOption(value) {
         throw new TypeError("signal must be an AbortSignal");
     return value;
 }
-export class Akuma {
+class AkumaHandle {
     id;
     root;
     reportDiagnostic;
-    constructor(id, root, reportDiagnostic) {
+    spawn;
+    constructor(id, root, reportDiagnostic, spawn) {
         this.id = id;
         this.root = root;
         this.reportDiagnostic = reportDiagnostic;
+        this.spawn = spawn;
         Object.freeze(this);
     }
     owner(observing = false) {
         return new AkumaOwner(this.id, this.root, observing ? outcomePluginObserver({ world: this.root, reportDiagnostic: this.reportDiagnostic }) : undefined);
     }
-    static async birth(archetype, input) {
-        if (typeof input !== "object" || input === null || Array.isArray(input)) {
-            throw new TypeError("Akuma birth input must be an object");
-        }
-        if (typeof input.root !== "string")
-            throw new TypeError("Akuma birth root must be a WorldRoot");
-        const reportDiagnostic = captureAkumaHostDiagnostic(input.host) ?? stderrPluginDiagnostic;
-        const admitted = await admitAkumaCall(input.root, {
-            ...(input.home === undefined ? {} : { home: input.home }),
-            ...(input.settings === undefined ? {} : { settings: input.settings }),
-        }, {
-            archetype,
-            ...(input.cwd === undefined ? {} : { cwd: input.cwd }),
-            ...(input.allowed === undefined ? {} : { allowed: input.allowed }),
-            ...(input.caller === undefined ? {} : { caller: input.caller }),
-            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-        }, {});
-        if (admitted.failure !== undefined)
-            throw admitted.failure;
-        return new Akuma(admitted.id, input.root, reportDiagnostic);
-    }
-    static select(root, selector, host) {
-        if (typeof root !== "string")
-            throw new TypeError("Akuma.select root must be a WorldRoot");
-        const reportDiagnostic = captureAkumaHostDiagnostic(host) ?? stderrPluginDiagnostic;
-        return new Akuma(parseAkuId(selector).id, root, reportDiagnostic);
-    }
     async tell(text, options = {}) {
         if (typeof text !== "string")
             throw new TypeError("Akuma tell text must be a string");
@@ -80,6 +46,7 @@ export class Akuma {
         const signal = signalOption(options.signal);
         signal?.throwIfAborted();
         return await executeTellAkuma({
+            spawn: this.spawn,
             path: this.root,
             id: this.id,
             body: text,
@@ -103,6 +70,7 @@ export class Akuma {
         signal?.throwIfAborted();
         const schema = options.schema === undefined ? undefined : schemaFromStandard(options.schema);
         const result = await executeAskAkuma({
+            spawn: this.spawn,
             path: this.root,
             id: this.id,
             outcomeObserved: outcomePluginObserver({ world: this.root, reportDiagnostic: this.reportDiagnostic }),
@@ -115,6 +83,40 @@ export class Akuma {
         });
         return (schema === undefined ? result : { ...result, observation: decodeAskObservation(result.observation, schema) });
     }
+    async report(text, options) {
+        if (typeof text !== "string" || text.trim() === "")
+            throw new TypeError("Akuma report text must be nonblank");
+        if (typeof options !== "object" || options === null || Array.isArray(options))
+            throw new TypeError("Akuma report requires exact execution options");
+        const unknown = Object.keys(options).find((key) => !["bodySequence", "turnSequence", "signal"].includes(key));
+        if (unknown !== undefined)
+            throw new TypeError(`Akuma report options has unknown field: ${unknown}`);
+        for (const key of ["bodySequence", "turnSequence"]) {
+            if (!Number.isSafeInteger(options[key]) || options[key] <= 0)
+                throw new TypeError(`Akuma report ${key} must be a positive safe integer`);
+        }
+        const signal = signalOption(options.signal);
+        const result = await this.owner().report({
+            bodySequence: options.bodySequence,
+            turnSequence: options.turnSequence,
+            text,
+            at: new Date().toISOString(),
+        }, signal);
+        if (result.kind !== "recorded")
+            return result;
+        const { report, initiator } = result;
+        await emitPluginSignal({ world: this.root, reportDiagnostic: this.reportDiagnostic }, {
+            kind: "akuma.reported",
+            akumaId: this.id,
+            bodySequence: report.bodySequence,
+            turnSequence: report.turnSequence,
+            reportSequence: report.sequence,
+            text: report.text,
+            at: report.at,
+            ...(initiator === undefined ? {} : { initiator }),
+        });
+        return { kind: "recorded", report };
+    }
     async status() {
         return await this.owner(true).status();
     }
@@ -169,6 +171,47 @@ export class Akuma {
         }
         const signal = signalOption(options.signal);
         signal?.throwIfAborted();
-        return await abortable(this.owner().kill(signal === undefined ? {} : { signal }), signal ?? new AbortController().signal);
+        return await abortable(this.owner().kill(this.spawn, signal === undefined ? {} : { signal }), signal ?? new AbortController().signal);
+    }
+}
+export class Akuma extends AkumaHandle {
+    constructor(id, root, reportDiagnostic, spawn) {
+        super(id, root, reportDiagnostic, spawn);
     }
+    static async birth(archetype, input) {
+        if (typeof input !== "object" || input === null || Array.isArray(input)) {
+            throw new TypeError("Akuma birth input must be an object");
+        }
+        if (typeof input.root !== "string")
+            throw new TypeError("Akuma birth root must be a WorldRoot");
+        const { spawn, reportDiagnostic = stderrPluginDiagnostic } = captureAkumaHost(input.host);
+        const admitted = await admitAkumaCall(input.root, {
+            ...(input.home === undefined ? {} : { home: input.home }),
+            ...(input.settings === undefined ? {} : { settings: input.settings }),
+        }, {
+            archetype,
+            ...(input.cwd === undefined ? {} : { cwd: input.cwd }),
+            ...(input.allowed === undefined ? {} : { allowed: input.allowed }),
+            ...(input.writableDirectories === undefined ? {} : { writableDirectories: input.writableDirectories }),
+            ...(input.bare === undefined ? {} : { bare: input.bare }),
+            ...(input.caller === undefined ? {} : { caller: input.caller }),
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+        }, {}, spawn);
+        if (admitted.failure !== undefined)
+            throw admitted.failure;
+        return new Akuma(admitted.id, input.root, reportDiagnostic, spawn);
+    }
+    static select(root, selector, host) {
+        if (typeof root !== "string")
+            throw new TypeError("Akuma.select root must be a WorldRoot");
+        const { spawn, reportDiagnostic = stderrPluginDiagnostic } = captureAkumaHost(host);
+        return new Akuma(parseAkuId(selector).id, root, reportDiagnostic, spawn);
+    }
+}
+/** Internal product composition; hosting is captured independently of public operation inputs. */
+export function akumaWithLauncher(root, selector, spawn, host) {
+    if (typeof root !== "string")
+        throw new TypeError("Akuma.select root must be a WorldRoot");
+    const reportDiagnostic = captureAkumaHostDiagnostic(host) ?? stderrPluginDiagnostic;
+    return new AkumaHandle(parseAkuId(selector).id, root, reportDiagnostic, spawn);
 }

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

@@ -3,10 +3,12 @@ import type { WorldRoot } from "../world.js";
 import { type OutcomeObserver, type LiveStatusObservation, type WaitReason } from "./akuma-observe.js";
 import { type AkumaStreamSnapshot } from "./akuma-stream.js";
 import type { AkumaStatus } from "./akuma.js";
+import type { BodyLauncher } from "./body-launch.js";
 import { type TellResult, type TellWakeRuntime } from "./body.js";
 import { type CallInitialTell, type CallInitialTellAdmission } from "./call-initial-tell.js";
 import { HeldAkumaLeash, type InterruptTellAdmission, type KillEvidence, type ResumeCoordinate, type TellFact, type TurnOutcome } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
+import type { ReportAdmission } from "./heart/facts.js";
 import type { ActivityHistory, ExactHistory } from "./projection.js";
 export type InterruptReceipt = TellResult | Extract<InterruptTellAdmission, {
     kind: "unavailable";
@@ -68,6 +70,12 @@ export declare class AkumaOwner {
     private get paths();
     private projectHistoryTurns;
     private exactHistory;
+    report(input: Readonly<{
+        bodySequence: number;
+        turnSequence: number;
+        text: string;
+        at: string;
+    }>, signal?: AbortSignal): Promise<ReportAdmission>;
     status(): Promise<AkumaStatus>;
     history(input?: Readonly<{
         id?: string;
@@ -94,11 +102,11 @@ export declare class AkumaOwner {
         timeoutMs?: number;
         signal?: AbortSignal;
     }>): Promise<AkumaStatus>;
-    admitInitialTell(initialTell: CallInitialTell, options?: Readonly<{
+    admitInitialTell(initialTell: CallInitialTell, options: Readonly<{
         signal?: AbortSignal;
-        runtime?: TellWakeRuntime;
+        runtime: TellWakeRuntime;
     }>): Promise<InitialTellAdmission>;
-    tell(body: string, tellId?: string, recordedAt?: string, runtime?: TellWakeRuntime, options?: Readonly<{
+    tell(body: string, tellId: string | undefined, recordedAt: string | undefined, runtime: TellWakeRuntime, options?: Readonly<{
         schemaJson?: string;
         initiator?: string;
         signal?: AbortSignal;
@@ -108,7 +116,7 @@ export declare class AkumaOwner {
      * caller starts its own deadline at this admission boundary while the wake
      * continues in the background; the unbounded public Tell awaits `wake`.
      */
-    admitTell(body: string, tellId?: string, recordedAt?: string, runtime?: TellWakeRuntime, options?: Readonly<{
+    admitTell(body: string, tellId: string | undefined, recordedAt: string | undefined, runtime: TellWakeRuntime, options?: Readonly<{
         schemaJson?: string;
         initiator?: string;
         signal?: AbortSignal;
@@ -130,13 +138,13 @@ export declare class AkumaOwner {
         outcome: TurnOutcome | null;
         completedAt: string | null;
     }>>;
-    interrupt(body: string, options?: Readonly<{
+    interrupt(body: string, options: Readonly<{
         tellId?: string;
         recordedAt?: string;
         schemaJson?: string;
         initiator?: string;
         signal?: AbortSignal;
-        runtime?: TellWakeRuntime;
+        runtime: TellWakeRuntime;
     }>): Promise<InterruptReceipt>;
     /** Atomic Tell-plus-barrier admission; no leash wait or completion observation occurs here. */
     admitInterrupt(body: string, options?: Readonly<{
@@ -149,13 +157,14 @@ export declare class AkumaOwner {
     /** Complete only the exact admitted predecessor barrier, then wake the stable Tell. */
     completeInterruptAdmission(admission: Extract<InterruptAdmission, {
         kind: "admitted";
-    }>, runtime?: TellWakeRuntime, signal?: AbortSignal): Promise<TellResult>;
+    }>, runtime: TellWakeRuntime, signal?: AbortSignal): Promise<TellResult>;
     fork(input: Readonly<{
         at: string;
+        bare?: boolean;
         caller?: AkumaCaller;
         initiator?: string;
-    }>): Promise<ForkReceipt>;
-    kill(options?: Readonly<{
+    }>, spawn: BodyLauncher): Promise<ForkReceipt>;
+    kill(spawn: BodyLauncher, options?: Readonly<{
         signal?: AbortSignal;
     }>): Promise<KillEvidence>;
     lastAnswer(): Promise<LastAnswer>;

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

@@ -1,13 +1,14 @@
+import { bareOption } from "./call-input.js";
 import { decodeAkumaCaller } from "./caller.js";
 import { randomUUID } from "node:crypto";
 import { AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 import { createLiveStatusReader, bornStatus, defaultWaitComplete, executionProgress, observeOutcomeRows, observeStatusOutcome, waitForObservation, } from "./akuma-observe.js";
 import { executeWaitAkuma } from "./akuma-wait.js";
 import { createAkumaStream } from "./akuma-stream.js";
-import { handoffPendingTells, spawnAkumaBody, wakeRecordedTell, } from "./body.js";
+import { handoffPendingTells, wakeRecordedTell } from "./body.js";
 import { admitCallInitialTell } from "./call-initial-tell.js";
 import { acquireLeash } from "./control.js";
-import { activitySlice, projectTell, readForkPoint, readHeart, readInterruptCompletion, readKill, readLastAnsweredTurn, readSoul, readTell, recordTell, requestStop, } from "./heart/index.js";
+import { activitySlice, projectTell, readForkPoint, readHeart, readInterruptCompletion, readKill, readLastAnsweredTurn, readSoul, readTell, recordReport, recordTell, requestStop, } from "./heart/index.js";
 import { parsePublicHistoryId, pathsForAkuId } from "./identity.js";
 import { projectTurns, selectExactHistory, selectHistory } from "./projection.js";
 import { resolveProviderExecution } from "./providers/index.js";
@@ -73,6 +74,8 @@ export async function settleAkumaKill(paths, signal, retainLeash = false) {
         if (settledBody?.sequence !== target.sequence) {
             return { evidence: (await readKill(paths, target.sequence)) === null ? "unavailable" : "killed" };
         }
+        if (settledBody.hung !== undefined)
+            return { evidence: "hung" };
         if (settledBody.end !== "put-down") {
             await leash.clearStop(paths);
             return { evidence: "untidy" };
@@ -128,6 +131,9 @@ export class AkumaOwner {
             throw new TypeError("Akuma history id must match turn/<positive safe integer>");
         return selectExactHistory((await this.projectHistoryTurns()).rows, input.id);
     }
+    async report(input, signal) {
+        return await recordReport(this.paths, input, signal);
+    }
     async status() {
         const { status } = await bornStatus(this.paths, this.id, { aperture: "monitoring" });
         await observeStatusOutcome(status, this.outcomeObserved);
@@ -190,7 +196,7 @@ export class AkumaOwner {
     async wait(predicate = defaultWaitComplete, options = {}) {
         return (await this.waitReceipt(predicate, options)).status;
     }
-    async admitInitialTell(initialTell, options = {}) {
+    async admitInitialTell(initialTell, options) {
         return await admitCallInitialTell({
             world: this.worldPath,
             id: this.id,
@@ -284,7 +290,7 @@ export class AkumaOwner {
             reader.clear();
         }
     }
-    async interrupt(body, options = {}) {
+    async interrupt(body, options) {
         const admitted = await this.admitInterrupt(body, options);
         if (admitted.kind === "unavailable")
             return admitted;
@@ -332,7 +338,8 @@ export class AkumaOwner {
             },
         };
     }
-    async fork(input) {
+    async fork(input, spawn) {
+        const bare = bareOption(input.bare);
         const caller = decodeAkumaCaller(input.caller);
         const source = await readSoul(this.paths);
         if (source === null)
@@ -369,24 +376,23 @@ export class AkumaOwner {
                 worldPath: this.worldPath,
                 archetype: source.archetype,
                 awaitAsleep: true,
-                launch: async (allocated) => {
-                    return await spawnAkumaBody({
-                        paths: allocated.paths,
-                        seed: {
-                            id: allocated.id,
-                            archetype: source.archetype,
-                            ...(source.description === undefined ? {} : { description: source.description }),
-                            provider: source.provider,
-                            options: source.options,
-                            allowed: source.allowed,
-                            cwd: source.cwd,
-                            origin: { kind: "fork", parent: this.id, at: input.at },
-                            ...(caller === undefined ? {} : { caller }),
-                        },
-                        birthSession,
-                        ...(input.initiator === undefined ? {} : { birthInitiator: input.initiator }),
-                    });
-                },
+                launch: async (allocated) => await spawn({
+                    paths: allocated.paths,
+                    seed: {
+                        id: allocated.id,
+                        archetype: source.archetype,
+                        ...(source.description === undefined ? {} : { description: source.description }),
+                        provider: source.provider,
+                        options: source.options,
+                        allowed: source.allowed,
+                        bare: source.bare === true || bare === true,
+                        cwd: source.cwd,
+                        origin: { kind: "fork", parent: this.id, at: input.at },
+                        ...(caller === undefined ? {} : { caller }),
+                    },
+                    birthSession,
+                    ...(input.initiator === undefined ? {} : { birthInitiator: input.initiator }),
+                }),
             });
             return { kind: "forked", child: child.id };
         }
@@ -398,8 +404,8 @@ export class AkumaOwner {
             };
         }
     }
-    async kill(options = {}) {
-        return await killAkumaWithRecovery(this.paths, handoffPendingTells, options.signal);
+    async kill(spawn, options = {}) {
+        return await killAkumaWithRecovery(this.paths, (paths) => handoffPendingTells(paths, spawn), options.signal);
     }
     async lastAnswer() {
         const turn = await readLastAnsweredTurn(this.paths);

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

@@ -1,7 +1,8 @@
 import type { WorldRoot } from "../world.js";
 import type { LiveStatusObservation, OutcomeObserver } from "./akuma-observe.js";
 import type { AkumaStatus } from "./akuma.js";
-import type { TellResult } from "./body.js";
+import { type TellResult } from "./body.js";
+import type { BodyLauncher } from "./body-launch.js";
 import type { Schema } from "./schema.js";
 import type { AkumaAskObservation, AkumaAskResult, AkumaKillResult, AkumaTellResult } from "./selection-observation.js";
 export type AskObserver = Readonly<{
@@ -9,6 +10,7 @@ export type AskObserver = Readonly<{
     observe?: (observation: LiveStatusObservation) => void | Promise<void>;
 }>;
 type TellExecutionInput = Readonly<{
+    spawn: BodyLauncher;
     path: WorldRoot;
     id: AkumaStatus["id"];
     body: string;
@@ -46,6 +48,7 @@ export declare function observeAdmittedAskAkuma(input: Readonly<{
 }>): Promise<AkumaAskResult>;
 export declare function executeAskAkuma(input: AskExecutionInput): Promise<AkumaAskResult>;
 type KillExecutionInput = Readonly<{
+    spawn: BodyLauncher;
     path: WorldRoot;
     ids: readonly AkumaStatus["id"][];
     signal?: AbortSignal;

package/build/src/akuma/akuma-selection-execution.js

@@ -1,11 +1,13 @@
 import { AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 import { AkumaOwner } from "./akuma-owner.js";
+import { tellWakeRuntime } from "./body.js";
 export async function executeTellAkuma(input) {
     input.signal?.throwIfAborted();
     const owner = new AkumaOwner(input.id, input.path);
     let tell;
     if (input.interrupt === true) {
         const interrupted = await owner.interrupt(input.body, {
+            runtime: tellWakeRuntime(input.spawn),
             ...(input.tellId === undefined ? {} : { tellId: input.tellId }),
             ...(input.recordedAt === undefined ? {} : { recordedAt: input.recordedAt }),
             ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
@@ -16,7 +18,7 @@ export async function executeTellAkuma(input) {
         tell = interrupted;
     }
     else {
-        tell = await owner.tell(input.body, input.tellId, input.recordedAt, undefined, {
+        tell = await owner.tell(input.body, input.tellId, input.recordedAt, tellWakeRuntime(input.spawn), {
             ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
         });
@@ -27,6 +29,8 @@ export async function executeTellAkuma(input) {
 function askObservation(observed) {
     if (observed.outcome === null)
         return observed.reason === "deadline" ? { reason: "deadline" } : { reason: "unanswered" };
+    if (observed.outcome.kind === "canceled")
+        return { reason: "unanswered" };
     if (observed.outcome.kind === "answered")
         return { reason: "answered", answer: observed.outcome.answerJson ?? observed.outcome.answer };
     if (observed.outcome.kind === "failed")
@@ -120,7 +124,7 @@ async function executeInterruptAskAkuma(input, owner) {
         throw new AkumaProviderError(`Tell interrupt unavailable: ${admission.evidence}`);
     const observing = new AbortController();
     const signal = input.signal === undefined ? observing.signal : AbortSignal.any([input.signal, observing.signal]);
-    const wake = owner.completeInterruptAdmission(admission, undefined, signal);
+    const wake = owner.completeInterruptAdmission(admission, tellWakeRuntime(input.spawn), signal);
     try {
         const receipt = admission.barrier === undefined
             ? undefined
@@ -152,7 +156,7 @@ export async function executeAskAkuma(input) {
     const owner = new AkumaOwner(input.id, input.path);
     if (input.interrupt === true)
         return await executeInterruptAskAkuma(input, owner);
-    const admission = await owner.admitTell(input.body, input.tellId, input.recordedAt, undefined, {
+    const admission = await owner.admitTell(input.body, input.tellId, input.recordedAt, tellWakeRuntime(input.spawn), {
         ...(input.schemaJson === undefined ? {} : { schemaJson: input.schemaJson }),
         ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
         ...(input.signal === undefined ? {} : { signal: input.signal }),
@@ -174,7 +178,7 @@ export async function executeAskAkuma(input) {
 export async function executeKillAkuma(input) {
     input.signal?.throwIfAborted();
     const owners = input.ids.map((id) => new AkumaOwner(id, input.path));
-    const evidence = await Promise.all(owners.map(async (owner) => await owner.kill(input.signal === undefined ? {} : { signal: input.signal })));
+    const evidence = await Promise.all(owners.map(async (owner) => await owner.kill(input.spawn, input.signal === undefined ? {} : { signal: input.signal })));
     input.signal?.throwIfAborted();
     return {
         results: input.ids.map((id, index) => ({ id, evidence: evidence[index] })),

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

@@ -135,6 +135,13 @@ export declare const akumaStatusSchema: z.ZodObject<{
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"row">;
             row: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"report">;
+                sequence: z.ZodNumber;
+                bodySequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                text: z.ZodString;
+                at: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"call">;
                 sequence: z.ZodNumber;
                 turnSequence: z.ZodNumber;
@@ -340,6 +347,9 @@ export declare const akumaStatusSchema: z.ZodObject<{
                 kind: z.ZodLiteral<"failed">;
                 historyId: z.ZodString;
                 diagnostic: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"canceled">;
+                historyId: z.ZodString;
             }, z.core.$strict>]>;
         }, z.core.$strict>>;
         entries: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
@@ -348,6 +358,13 @@ export declare const akumaStatusSchema: z.ZodObject<{
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"row">;
             row: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"report">;
+                sequence: z.ZodNumber;
+                bodySequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                text: z.ZodString;
+                at: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"call">;
                 sequence: z.ZodNumber;
                 turnSequence: z.ZodNumber;

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

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import type { TellWake } from "./call-initial-tell.js";
+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("./index.js").AkumaOrigin;
+        caller?: import("./caller.js").AkumaCaller;
+        allowed: import("./allowed.js").AllowedActions;
+        bare?: boolean;
+        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<{
+                replace: "replace";
+                append: "append";
+            }>>;
+        }, z.core.$strip>, z.ZodTransform<Readonly<{
+            systemPromptMode?: "replace" | "append";
+            systemPrompt?: string;
+            network?: "disabled" | "enabled";
+            effort?: string;
+            model?: string;
+        }>, {
+            model?: string | undefined;
+            effort?: string | undefined;
+            network?: "disabled" | "enabled" | undefined;
+            systemPrompt?: string | undefined;
+            systemPromptMode?: "replace" | "append" | undefined;
+        }>>;
+        admittedAt: z.ZodString;
+    }, z.core.$strict>>;
+    initialBody: z.ZodOptional<z.ZodString>;
+    initiator: z.ZodOptional<z.ZodString>;
+    birthInitiator: z.ZodOptional<z.ZodString>;
+    initialSchemaJson: z.ZodOptional<z.ZodString>;
+    refuseIfHeld: z.ZodOptional<z.ZodBoolean>;
+    handoffFromBodySequence: z.ZodOptional<z.ZodNumber>;
+    completion: z.ZodOptional<z.ZodObject<{
+        contractId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type BodyLaunch = z.infer<typeof bodyLaunchSchema>;
+/** Live launch evidence only; Heart and leash alone judge birth and settlement. */
+export type BodyLaunchEnd = Readonly<{
+    diagnostic: string;
+    held?: boolean;
+    child?: Extract<TellWake, {
+        child: unknown;
+    }>["child"];
+}>;
+export type LiveBodyLaunch = Readonly<{
+    /** Launch completion evidence, never a product outcome or closure proof. */
+    completed: Promise<BodyLaunchEnd>;
+    /** Ask owned resources to retire; force requests supported disposal, not shared-host termination or rollback. */
+    cancel(force?: boolean): Promise<void>;
+    /** Relinquish this holder's custody, not kill or closure, with no guarantee of host survival. */
+    release(): void;
+}>;
+export type BodyLauncher = (launch: BodyLaunch) => Promise<LiveBodyLaunch>;
+/** Observe durable custody first, including once more after live launch completion. */
+export declare function observeBodyLaunch<T>(child: LiveBodyLaunch, observe: () => Promise<T | null>, schedule?: (milliseconds: number, signal: AbortSignal) => Promise<void>, signal?: AbortSignal): Promise<Readonly<{
+    kind: "observed";
+    value: T;
+}> | Readonly<{
+    kind: "completed";
+    end: BodyLaunchEnd;
+}>>;
+export declare function launchEndWake(end: BodyLaunchEnd): Extract<TellWake, {
+    kind: "held" | "failed";
+}>;