@astrosheep/keiyaku 4.5.15 → 4.5.17

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku/SKILL.md

@@ -33,7 +33,7 @@ keiyaku -C <repo> review [<contract>|@<contract>] --satisfied
 ```
 
 ```bash
-keiyaku -C <cwd> call <akuma-name> [--contract <kei/...>] [--alias @name] [--readonly] [--allowed <product.action>]... [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
+keiyaku -C <cwd> call <akuma-name> [--contract <kei/...>] [--alias @name] [--readonly] [--allowed <product.action>]... [--schema <file>] [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
 keiyaku -C <repo> wait <akuma-selector>... [--any | --all]
 keiyaku -C <repo> tell <aku/...|@alias> (<prompt> | -)
 ```

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-akuma/SKILL.md

@@ -13,7 +13,7 @@ is accepted; the identity underneath never changes.
 ## Start One
 
 ```bash
-keiyaku -C <cwd> call <akuma-name> [--alias @name] [--readonly] [--allowed <product.action>]... [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
+keiyaku -C <cwd> call <akuma-name> [--alias @name] [--readonly] [--allowed <product.action>]... [--schema <file>] [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
 ```
 
 Give the worker's initial prompt as one argument (quote it when it contains

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

@@ -5,3 +5,14 @@ export declare class AkumaNotBornError extends Error {
     readonly kind = "akuma-not-born";
     constructor(id: AkuId);
 }
+export declare class AkumaDecodeError extends Error {
+    readonly diagnostic: string;
+    readonly answer?: string | undefined;
+    readonly kind = "akuma-decode";
+    constructor(diagnostic: string, answer?: string | undefined);
+}
+export declare class AkumaProviderError extends Error {
+    readonly diagnostic: string;
+    readonly kind = "akuma-provider";
+    constructor(diagnostic: string);
+}

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

@@ -8,3 +8,23 @@ export class AkumaNotBornError extends Error {
         this.name = "AkumaNotBornError";
     }
 }
+export class AkumaDecodeError extends Error {
+    diagnostic;
+    answer;
+    kind = "akuma-decode";
+    constructor(diagnostic, answer) {
+        super(diagnostic);
+        this.diagnostic = diagnostic;
+        this.answer = answer;
+        this.name = "AkumaDecodeError";
+    }
+}
+export class AkumaProviderError extends Error {
+    diagnostic;
+    kind = "akuma-provider";
+    constructor(diagnostic) {
+        super(diagnostic);
+        this.diagnostic = diagnostic;
+        this.name = "AkumaProviderError";
+    }
+}

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

@@ -25,6 +25,7 @@ export declare class AkumaHandle {
     }>): Promise<AkumaStatus>;
     tell(body: string): Promise<TellResult>;
     interrupt(body: string): Promise<InterruptReceipt>;
+    interruptSchema(body: string, schemaJson: string): Promise<TellResult>;
     fork(input: Readonly<{
         at: string;
     }>): Promise<ForkReceipt>;

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

@@ -196,6 +196,42 @@ export class AkumaHandle {
         }
         return { kind: "interrupted", putDown, tell: await wakeRecordedTell(this.paths, recorded.tellId) };
     }
+    async interruptSchema(body, schemaJson) {
+        const request = await requestPause(this.paths, new Date().toISOString());
+        if (request.kind === "not-born")
+            throw new AkumaNotBornError(this.id);
+        let tellId;
+        let leash = await HeldAkumaLeash.try(this.paths);
+        if (leash === null)
+            leash = await takeLeashUntil(this.paths, performance.now() + CONTROL_RESPONSE_MS);
+        if (leash === null)
+            throw new Error("schema interrupt could not acquire Body leash");
+        try {
+            const settledBody = (await readHeart(this.paths)).latestBody;
+            if (settledBody?.sequence === request.body.sequence && settledBody.hung !== undefined) {
+                await leash.clearPause(this.paths);
+                throw new Error("schema interrupt found a hung Body");
+            }
+            if (settledBody?.sequence !== request.body.sequence || settledBody.end === undefined) {
+                await leash.clearPause(this.paths);
+                throw new Error("schema interrupt could not prove Body settlement");
+            }
+            const admitted = await leash.recordInterruptTell(this.paths, {
+                kind: "tell",
+                id: randomUUID(),
+                body,
+                recordedAt: new Date().toISOString(),
+                schemaJson,
+            });
+            if (admitted.kind === "not-born")
+                throw new AkumaNotBornError(this.id);
+            tellId = admitted.tell.id;
+        }
+        finally {
+            leash.release();
+        }
+        return await wakeRecordedTell(this.paths, tellId);
+    }
     async fork(input) {
         const source = await readSoul(this.paths);
         if (source === null)

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

@@ -0,0 +1,31 @@
+import type { AllowedAction } from "./allowed.js";
+import { type AkuId } from "./identity.js";
+import { type ActivityHistory } from "./projection.js";
+import type { Settings } from "../settings.js";
+import type { WorldRoot } from "../world.js";
+import type { Schema } from "./schema.js";
+export type AkumaBirthInput = Readonly<{
+    root: WorldRoot;
+    cwd?: string;
+    home?: string;
+    settings?: Settings;
+    readonly?: true;
+    allowed?: readonly AllowedAction[];
+}>;
+export type AkumaTellOptions<T> = Readonly<{
+    schema: Schema<T>;
+    interrupt?: boolean;
+}>;
+export declare class Akuma {
+    readonly id: AkuId;
+    private readonly root;
+    private constructor();
+    private get paths();
+    static birth(archetype: string, input: AkumaBirthInput): Promise<Akuma>;
+    static select(root: WorldRoot, selector: string): Akuma;
+    tell(text: string): Promise<string>;
+    tell<T>(text: string, options: AkumaTellOptions<T>): Promise<T>;
+    idle(): Promise<void>;
+    history(): Promise<ActivityHistory>;
+    kill(): Promise<void>;
+}

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

@@ -0,0 +1,168 @@
+import { randomUUID } from "node:crypto";
+import { callReadonly, canonicalBirthCwd } from "./call-input.js";
+import { spawnAkumaBody, wakeRecordedTell } from "./body.js";
+import { decodeAllowedActions, unionAllowedActions } from "./allowed.js";
+import { AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
+import { AkumaHandle } from "./akuma-handle.js";
+import { POLL_MS, defaultWaitComplete, killAkumaWithRecovery } from "./akuma.js";
+import { bornStatus } from "./akuma-observe.js";
+import { loadArchetype } from "./archetype.js";
+import { activitySlice, readTell, readTurn, recordTell } from "./heart/index.js";
+import { parseAkuId, pathsForAkuId } from "./identity.js";
+import { birthAkuma, launchAkuma } from "./publication.js";
+import { projectTurns, selectHistory } from "./projection.js";
+import { settings as readSettings } from "../settings.js";
+const HISTORY_LIMIT = 12;
+function wait(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function recordPlainTell(paths, id, body, tellId) {
+    const admitted = await recordTell(paths, { kind: "tell", id: tellId, body, recordedAt: new Date().toISOString() });
+    if (admitted.kind === "not-born")
+        throw new AkumaNotBornError(id);
+    return admitted.tell.id;
+}
+async function recordSchemaTell(paths, id, body, tellId, options, root) {
+    if (options.interrupt === true) {
+        const interrupted = await new AkumaHandle(id, root).interruptSchema(body, options.schema.jsonText);
+        return interrupted.admission.tellId;
+    }
+    const recordedAt = new Date().toISOString();
+    const tell = {
+        kind: "tell",
+        id: tellId,
+        body,
+        recordedAt,
+        schemaJson: options.schema.jsonText,
+    };
+    const admitted = await recordTell(paths, tell);
+    if (admitted.kind === "not-born")
+        throw new AkumaNotBornError(id);
+    return admitted.tell.id;
+}
+function outcomeError(outcome) {
+    if (outcome.kind === "invalid-output")
+        throw new AkumaDecodeError(outcome.diagnostic, outcome.answer);
+    if (outcome.kind === "failed")
+        throw new AkumaProviderError(outcome.diagnostic);
+    throw new AkumaProviderError("Akuma answered without a value");
+}
+async function boundOutcome(paths, tell) {
+    if (tell.binding === undefined)
+        return null;
+    const turn = await readTurn(paths, tell.binding.turnSequence);
+    return turn?.end?.outcome ?? null;
+}
+async function awaitTellOutcome(paths, tellId) {
+    const wake = await wakeRecordedTell(paths, tellId);
+    if (wake.wake.kind === "failed")
+        throw new AkumaProviderError(wake.wake.diagnostic);
+    for (;;) {
+        const tell = await readTell(paths, tellId);
+        if (tell === null)
+            throw new AkumaProviderError(`recorded Tell ${tellId} is missing from Heart`);
+        const outcome = await boundOutcome(paths, tell);
+        if (outcome !== null)
+            return outcome;
+        if (tell.state === "told" && tell.binding === undefined) {
+            throw new AkumaProviderError(`recorded Tell ${tellId} reached a terminal delivery without a Turn binding`);
+        }
+        await wait(POLL_MS);
+    }
+}
+export class Akuma {
+    id;
+    root;
+    constructor(id, root) {
+        this.id = id;
+        this.root = root;
+        Object.freeze(this);
+    }
+    get paths() {
+        return pathsForAkuId(this.root, this.id);
+    }
+    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 name = archetype;
+        const home = input.home === undefined ? {} : { home: input.home };
+        const settings = input.settings ?? (await readSettings({ root: input.root, ...home }));
+        const readonly = callReadonly(input.readonly, "Akuma birth readonly must be true");
+        const loaded = await loadArchetype({ name, project: input.root, ...home, settings, ...readonly });
+        const allowed = input.allowed === undefined
+            ? loaded.allowed
+            : unionAllowedActions(loaded.allowed, decodeAllowedActions(input.allowed, "Akuma birth allowed"));
+        const cwd = input.cwd === undefined ? input.root : await canonicalBirthCwd(input.cwd);
+        const allocated = await birthAkuma({ worldPath: input.root, archetype: loaded.name });
+        await launchAkuma({
+            allocated,
+            launch: async (born) => await spawnAkumaBody({
+                paths: born.paths,
+                seed: {
+                    id: born.id,
+                    archetype: born.archetype,
+                    ...(loaded.description === undefined ? {} : { description: loaded.description }),
+                    provider: loaded.provider,
+                    options: loaded.options,
+                    ...(loaded.readonly === undefined ? {} : { readonly: loaded.readonly }),
+                    allowed,
+                    cwd,
+                    origin: { kind: "direct" },
+                },
+            }),
+        });
+        return new Akuma(allocated.id, input.root);
+    }
+    static select(root, selector) {
+        if (typeof root !== "string")
+            throw new TypeError("Akuma.select root must be a WorldRoot");
+        return new Akuma(parseAkuId(selector).id, root);
+    }
+    async tell(text, options) {
+        if (typeof text !== "string")
+            throw new TypeError("Akuma tell text must be a string");
+        const tellId = randomUUID();
+        const recorded = options === undefined
+            ? await recordPlainTell(this.paths, this.id, text, tellId)
+            : await recordSchemaTell(this.paths, this.id, text, tellId, options, this.root);
+        const outcome = await awaitTellOutcome(this.paths, recorded);
+        if (outcome.kind !== "answered")
+            outcomeError(outcome);
+        if (options === undefined)
+            return outcome.answer;
+        const raw = outcome.answerJson ?? outcome.answer;
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            throw new AkumaDecodeError(error instanceof Error ? error.message : "Answer is not valid JSON", outcome.answer);
+        }
+        try {
+            return options.schema.parse(parsed);
+        }
+        catch (error) {
+            throw new AkumaDecodeError(error instanceof Error ? error.message : "Answer failed schema decode", outcome.answer);
+        }
+    }
+    async idle() {
+        for (;;) {
+            const observed = await bornStatus(this.paths, this.id, { aperture: "monitoring" });
+            if (defaultWaitComplete(observed.status))
+                return;
+            await wait(POLL_MS);
+        }
+    }
+    async history() {
+        const slice = await activitySlice(this.paths);
+        return selectHistory(projectTurns(slice.rows, { lowestRetained: slice.lowestRetained, highest: slice.highest }), {
+            limit: HISTORY_LIMIT,
+        });
+    }
+    async kill() {
+        await killAkumaWithRecovery(this.paths);
+    }
+}

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

@@ -0,0 +1,3 @@
+import { type AkuId } from "./identity.js";
+import type { WorldRoot } from "../world.js";
+export declare function probeBornAkuma(worldPath: WorldRoot, id: AkuId): Promise<boolean>;

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

@@ -0,0 +1,6 @@
+import { readSoul } from "./heart/index.js";
+import { pathsForAkuId } from "./identity.js";
+export async function probeBornAkuma(worldPath, id) {
+    const soul = await readSoul(pathsForAkuId(worldPath, id));
+    return soul !== null;
+}

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

@@ -21,6 +21,7 @@ export type BornAkumaCall = Readonly<{
         };
     }>;
     initialBody: string;
+    initialSchemaJson?: string;
     execution: BornExecution;
 }>;
 export type RequestedAkumaCall = Readonly<{

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

@@ -185,6 +185,7 @@ export class Akuma {
                 origin: { kind: "direct" },
             },
             initialBody: input.body,
+            ...(input.schema === undefined ? {} : { initialSchemaJson: input.schema.jsonText }),
             execution: {
                 cwd,
                 source: input.cwd !== undefined ? "input" : initiatorCwd === undefined ? "world" : "process",
@@ -201,6 +202,7 @@ export class Akuma {
                 paths: allocated.paths,
                 seed: born.seed,
                 initialBody: born.initialBody,
+                ...(born.initialSchemaJson === undefined ? {} : { initialSchemaJson: born.initialSchemaJson }),
                 ...(Object.keys(completion).length === 0 ? {} : { completion }),
             }),
         });

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

@@ -1,5 +1,6 @@
 import { type TellResult, type TellWakeRuntime } from "./body.js";
 import { HeldAkumaLeash, type AkumaLife, type KillEvidence, type ResumeCoordinate } from "./heart/index.js";
+export type { KillEvidence };
 import { type AkuId, type AkumaPaths } from "./identity.js";
 import type { Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
@@ -7,6 +8,7 @@ import type { AllowedAction } from "./allowed.js";
 import type { ExecutionContext } from "./requests.js";
 import { z } from "zod";
 import type { BoundedList } from "../bounded-list.js";
+import type { Schema } from "./schema.js";
 export declare const POLL_MS = 100;
 export type AkumaListRow = Readonly<{
     id: AkuId;
@@ -436,6 +438,7 @@ export type AkumaCallInput = Readonly<{
     cwd?: string;
     readonly?: true;
     allowed?: readonly AllowedAction[];
+    schema?: Schema<unknown>;
 }>;
 export type AkumaCallContext = Readonly<{
     initiatorCwd?: string;
@@ -492,3 +495,4 @@ export type AkumaConfiguration = Readonly<{
 }>;
 export { AkumaHandle, akumaCallExecution, type LastAnswer } from "./akuma-handle.js";
 export { Akuma } from "./akuma-product.js";
+export { AkumaBusyError, AkumaDecodeError, AkumaProviderError } from "./akuma-errors.js";

package/build/src/akuma/akuma.js

@@ -107,3 +107,4 @@ export async function killAkumaWithRecovery(paths, recover = handoffPendingTells
 export { bornStatus, fleetListRow, readAkumaBirthCwd, readBudgetedStatus, } from "./akuma-observe.js";
 export { AkumaHandle, akumaCallExecution } from "./akuma-handle.js";
 export { Akuma } from "./akuma-product.js";
+export { AkumaBusyError, AkumaDecodeError, AkumaProviderError } from "./akuma-errors.js";

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

@@ -12,6 +12,7 @@ export type BodyLaunch = Readonly<{
     seed?: Omit<Soul, "createdAt">;
     birthSession?: Omit<SessionFact, "sequence">;
     initialBody?: string;
+    initialSchemaJson?: string;
     refuseIfHeld?: boolean;
     completion?: Readonly<{
         contractId?: string;

package/build/src/akuma/body.js

@@ -219,6 +219,34 @@ function turnOutcomeEmitter(launch, soul) {
         })();
     };
 }
+function bodyEndEmitter(launch, soul) {
+    let plugins;
+    const reportDiagnostic = (message) => {
+        void recordPluginDiagnostic(launch.paths, "body end", message);
+    };
+    return (bodySequence, end, diagnostic) => {
+        void (async () => {
+            try {
+                plugins ??= pluginRuntime({
+                    world: await World.at(worldRootForAkumaPaths(launch.paths)),
+                    reportDiagnostic,
+                });
+                const runtime = await plugins;
+                await runtime.emit({
+                    kind: "akuma.body-ended",
+                    akumaId: soul.id,
+                    bodySequence,
+                    end,
+                    ...(diagnostic === undefined ? {} : { diagnostic }),
+                    ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
+                }, reportDiagnostic);
+            }
+            catch (error) {
+                await recordPluginDiagnostic(launch.paths, "body end", error);
+            }
+        })();
+    };
+}
 async function runBodyTurns(input) {
     const { launch, soul, adapter, bodySequence, supervisor, runtime } = input;
     let initial = launch.initialBody;
@@ -250,7 +278,9 @@ async function runBodyTurns(input) {
             ...(initial === undefined ? {} : { call: initial }),
             launchTells,
             ...(launchTells.find((tell) => tell.schemaJson !== undefined)?.schemaJson === undefined
-                ? {}
+                ? launch.initialSchemaJson === undefined
+                    ? {}
+                    : { schemaJson: launch.initialSchemaJson }
                 : { schemaJson: launchTells.find((tell) => tell.schemaJson !== undefined).schemaJson }),
             world: runtime.world,
             externalCommands: runtime.externalCommands,
@@ -391,10 +421,12 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
     let pendingTellDisposition = undefined;
     let bodySequence;
     let decidedDisposition = null;
+    let emitBodyEnd;
     try {
         const soul = await bornSoul(launch, leash, runtime.now());
         if (soul === null)
             return;
+        emitBodyEnd = bodyEndEmitter(launch, soul);
         if (launch.seed === undefined && launch.initialBody === undefined) {
             const [heart, requests] = await Promise.all([readHeart(launch.paths), readNonterminalRequests(launch.paths)]);
             if (heart.pending.length === 0 && requests.length === 0)
@@ -445,6 +477,12 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
                 at: runtime.now(),
                 handoff: pendingTellDisposition === "handoff",
             });
+            const finalBody = (await readHeart(launch.paths)).latestBody;
+            if (emitBodyEnd !== undefined &&
+                finalBody?.sequence === bodySequence &&
+                (finalBody.end !== undefined || finalBody.hung !== undefined)) {
+                emitBodyEnd(bodySequence, finalBody.hung === undefined ? finalBody.end : "hung", finalBody.hung?.diagnostic);
+            }
         }
         leash.release();
         if (decidedDisposition !== null) {

package/build/src/akuma/fleet-request.d.ts

@@ -3,6 +3,7 @@ import { type ErasedRequestCommand, type RequestProtocol, type ServiceRequestCom
 import type { AkumaStatus } from "./akuma.js";
 import { type AkumaKillResult, type AkumaTellResult, type AkumaWaitResult } from "./fleet-observation.js";
 import { z } from "zod";
+import type { Schema } from "./schema.js";
 declare const waitRequestSchema: z.ZodPipe<z.ZodObject<{
     targets: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>>;
     completion: z.ZodEnum<{
@@ -31,6 +32,23 @@ declare const tellRequestSchema: z.ZodPipe<z.ZodObject<{
     target: import("./identity.js").AkuId;
     body: string;
 }>>;
+declare const tellAnswerRequestSchema: z.ZodPipe<z.ZodObject<{
+    target: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+    body: z.ZodString;
+    schemaJson: z.ZodString;
+    interrupt: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodTransform<{
+    target: import("./identity.js").AkuId;
+    body: string;
+    schemaJson: string;
+    interrupt?: boolean | undefined;
+    action: "akuma.tell-answer";
+}, {
+    target: import("./identity.js").AkuId;
+    body: string;
+    schemaJson: string;
+    interrupt?: boolean | undefined;
+}>>;
 declare const killRequestSchema: z.ZodPipe<z.ZodObject<{
     targets: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>>;
 }, z.core.$strict>, z.ZodTransform<{
@@ -63,7 +81,7 @@ declare const killServiceSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type FleetRequest = (Omit<z.infer<typeof waitRequestSchema>, "targets"> & Readonly<{
     targets: readonly AkumaStatus["id"][];
-}>) | z.infer<typeof tellRequestSchema> | (Omit<z.infer<typeof killRequestSchema>, "targets"> & Readonly<{
+}>) | z.infer<typeof tellRequestSchema> | z.infer<typeof tellAnswerRequestSchema> | (Omit<z.infer<typeof killRequestSchema>, "targets"> & Readonly<{
     targets: readonly AkumaStatus["id"][];
 }>);
 export type FleetService = z.infer<typeof waitServiceSchema> | z.infer<typeof tellServiceSchema> | (Omit<z.infer<typeof killServiceSchema>, "results"> & Readonly<{
@@ -86,6 +104,13 @@ export type FleetRequestPort = Readonly<{
         recordedAt: string;
         signal: AbortSignal;
     }>): Promise<AkumaTellResult>;
+    tellAnswer?(input: Readonly<{
+        target: AkumaStatus["id"];
+        body: string;
+        schemaJson: string;
+        interrupt?: boolean;
+        signal: AbortSignal;
+    }>): Promise<unknown>;
     kill(input: Readonly<{
         targets: readonly AkumaStatus["id"][];
         signal: AbortSignal;
@@ -100,7 +125,15 @@ export type FleetRequestPort = Readonly<{
 /** Akuma owns Body Request payload, live result, and durable service codecs for wait/tell/kill. */
 export declare function fleetRequestProtocol(action: FleetRequest["action"]): RequestProtocol<FleetRequest, unknown, FleetService>;
 export declare function fleetRequestCommand(action: FleetRequest["action"], port: FleetRequestPort): ServiceRequestCommand<FleetRequest, unknown, FleetService, FleetService>;
-export declare function fleetRequestCommands(port: FleetRequestPort): Readonly<Record<"akuma.wait" | "akuma.tell" | "akuma.kill", ErasedRequestCommand>>;
+export declare function fleetRequestCommands(port: FleetRequestPort): Readonly<Record<"akuma.wait" | "akuma.tell" | "akuma.tell-answer" | "akuma.kill", ErasedRequestCommand>>;
+export declare function requestForwardedFleetTellAnswer(input: Readonly<{
+    directory: string;
+    target: AkumaStatus["id"];
+    body: string;
+    schema: Schema<unknown>;
+    interrupt?: boolean;
+    signal?: AbortSignal;
+}>): Promise<unknown>;
 export declare function requestForwardedFleetWait(input: Readonly<{
     directory: string;
     targets: readonly AkumaStatus["id"][];

package/build/src/akuma/fleet-request.js

@@ -27,6 +27,15 @@ const tellRequestSchema = z
     .object({ target: akumaIdSchema, body: z.string() })
     .strict()
     .transform((request) => ({ action: "akuma.tell", ...request }));
+const tellAnswerRequestSchema = z
+    .object({
+    target: akumaIdSchema,
+    body: z.string(),
+    schemaJson: nonblankTextSchema,
+    interrupt: z.boolean().optional(),
+})
+    .strict()
+    .transform((request) => ({ action: "akuma.tell-answer", ...request }));
 const killRequestSchema = z
     .object({ targets: fleetTargetsSchema })
     .strict()
@@ -42,18 +51,30 @@ const killServiceSchema = z
 })
     .strict();
 function decodeFleetRequest(action, value) {
-    const schema = action === "akuma.wait" ? waitRequestSchema : action === "akuma.tell" ? tellRequestSchema : killRequestSchema;
+    const schema = action === "akuma.wait"
+        ? waitRequestSchema
+        : action === "akuma.tell"
+            ? tellRequestSchema
+            : action === "akuma.tell-answer"
+                ? tellAnswerRequestSchema
+                : killRequestSchema;
     const parsed = schema.safeParse(value);
     return parsed.success ? parsed.data : null;
 }
 function decodeFleetService(action, value) {
-    const schema = action === "akuma.wait" ? waitServiceSchema : action === "akuma.tell" ? tellServiceSchema : killServiceSchema;
+    const schema = action === "akuma.wait"
+        ? waitServiceSchema
+        : action === "akuma.tell" || action === "akuma.tell-answer"
+            ? tellServiceSchema
+            : killServiceSchema;
     const parsed = schema.safeParse(value);
     if (!parsed.success)
         throw new Error("malformed stored Fleet service evidence");
     return parsed.data;
 }
 function decodedFleetResult(action, value) {
+    if (action === "akuma.tell-answer")
+        return value;
     const schema = action === "akuma.wait"
         ? fleetResultSchemas.wait
         : action === "akuma.tell"
@@ -76,7 +97,8 @@ export function fleetRequestProtocol(action) {
         encodeResult: (result) => result,
         decodeResult: (result) => decodedFleetResult(action, result),
         decodeReference: (reference) => decodeFleetService(action, reference),
-        isPermitted: (allowed) => action === "akuma.wait" || allowed.includes(action),
+        isPermitted: (allowed) => action === "akuma.wait" ||
+            ((action === "akuma.tell" || action === "akuma.tell-answer") && allowed.includes("akuma.tell")),
     };
 }
 export function fleetRequestCommand(action, port) {
@@ -105,6 +127,20 @@ export function fleetRequestCommand(action, port) {
                     service: { action: request.action, target: request.target, tellId: facts.id },
                 };
             }
+            if (request.action === "akuma.tell-answer") {
+                if (port.tellAnswer === undefined)
+                    throw new Error("schema answer Fleet port is unavailable");
+                return {
+                    result: await port.tellAnswer({
+                        target: request.target,
+                        body: request.body,
+                        schemaJson: request.schemaJson,
+                        ...(request.interrupt === undefined ? {} : { interrupt: request.interrupt }),
+                        signal: facts.signal,
+                    }),
+                    service: { action: "akuma.tell", target: request.target, tellId: facts.id },
+                };
+            }
             const result = await port.kill({ targets: request.targets, signal: facts.signal });
             if ("result" in result)
                 return { result: result.result, service: { action: request.action, results: result.service } };
@@ -119,9 +155,27 @@ export function fleetRequestCommands(port) {
     return {
         "akuma.wait": eraseRequestCommand(fleetRequestCommand("akuma.wait", port)),
         "akuma.tell": eraseRequestCommand(fleetRequestCommand("akuma.tell", port)),
+        "akuma.tell-answer": eraseRequestCommand(fleetRequestCommand("akuma.tell-answer", port)),
         "akuma.kill": eraseRequestCommand(fleetRequestCommand("akuma.kill", port)),
     };
 }
+export async function requestForwardedFleetTellAnswer(input) {
+    const response = await requestBodyCommand({
+        directory: input.directory,
+        command: fleetRequestProtocol("akuma.tell-answer"),
+        value: {
+            action: "akuma.tell-answer",
+            target: input.target,
+            body: input.body,
+            schemaJson: input.schema.jsonText,
+            ...(input.interrupt === undefined ? {} : { interrupt: input.interrupt }),
+        },
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
+    if (response.kind !== "returned")
+        throw new Error("Akuma body request terminal schema answer cannot reproduce an expired live result");
+    return response.result;
+}
 function forwardedFleetCommandResult(response, action) {
     if (response.kind === "returned") {
         if (action === "akuma.wait" && isWaitResult(response.result))

package/build/src/akuma/heart/index.js

@@ -54,7 +54,7 @@ export async function activitySlice(paths) {
     return await withHeart(paths, (heart) => readTransaction(heart, () => activityFactSlice(heart)));
 }
 function sameTellInput(existing, tell) {
-    return existing.body === tell.body && existing.recordedAt === tell.recordedAt && existing.schemaJson === tell.schemaJson;
+    return (existing.body === tell.body && existing.recordedAt === tell.recordedAt && existing.schemaJson === tell.schemaJson);
 }
 export async function recordTell(paths, tell, options = {}) {
     return await withHeart(paths, (heart) => transaction(heart, () => {