@astrosheep/keiyaku 4.5.15 → 4.5.16

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

@@ -250,7 +250,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,

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, () => {

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

@@ -25,9 +25,7 @@ function tellDeliveries(database, id) {
         : { turnSequence: row.turn_sequence, route: row.route, receipt: row.receipt, deliveredAt: row.delivered_at });
 }
 function tellBinding(database, id) {
-    const row = database
-        .prepare("SELECT turn_sequence, bound_at FROM tell_bindings WHERE tell_id = ?")
-        .get(id);
+    const row = database.prepare("SELECT turn_sequence, bound_at FROM tell_bindings WHERE tell_id = ?").get(id);
     return row === undefined ? undefined : { turnSequence: row.turn_sequence, boundAt: row.bound_at };
 }
 function decodeTellRow(database, row) {
@@ -195,9 +193,7 @@ export function insertTellBindingFact(database, input) {
     const result = database
         .prepare("INSERT OR IGNORE INTO tell_bindings(tell_id, turn_sequence, bound_at) VALUES (?, ?, ?)")
         .run(input.tellId, input.turnSequence, input.boundAt);
-    const row = database
-        .prepare("SELECT turn_sequence FROM tell_bindings WHERE tell_id = ?")
-        .get(input.tellId);
+    const row = database.prepare("SELECT turn_sequence FROM tell_bindings WHERE tell_id = ?").get(input.tellId);
     if (row === undefined || (result.changes === 0 && row.turn_sequence !== input.turnSequence)) {
         throw new Error(`tell ${input.tellId} is already bound to a different Turn`);
     }

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

@@ -1,17 +1,10 @@
-import { type AkuId } from "./identity.js";
-import type { WorldRoot } from "../world.js";
-export { Akuma, AkumaHandle, AkumaNotBornError, akumaIdSchema, akumaStatusSchema, defaultWaitComplete, parseAkumaStatus, } from "./akuma.js";
-export type { AkumaCallInput } from "./akuma.js";
+export { Akuma } from "./akuma-instance.js";
+export type { AkumaBirthInput, AkumaTellOptions } from "./akuma-instance.js";
+export { Schema, JsonSchema } from "./schema.js";
+export type { JsonSchemaDocument } from "./schema.js";
+export type { AkuId } from "./identity.js";
+export type { ActivityHistory, ActivityRow } from "./projection.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";
 export type { AllowedAction, AllowedActions } from "./allowed.js";
 export type { WorldRoot } from "../world.js";
-export declare function probeBornAkuma(worldPath: WorldRoot, id: AkuId): Promise<boolean>;
-export { AkumaArchetypeError, listArchetypeDefinitions, listArchetypes } from "./archetype.js";
-export type { ArchetypeCatalogRow } from "./archetype.js";
-export { AkumaBodyRequestError } from "./requests.js";
-export type { AkumaList, AkumaListInput, AkumaListRow, AkumaStatus, ActivityHistory, ExactHistory, ActivityRow, ActivitySnapshot, ActivitySnapshotEntry, ForkReceipt, InterruptReceipt, TellResult, TellWake, UnbornAkumaListRow, } from "./akuma.js";
-export type { ActiveToolRow, ClosedTurn, ClosedTurnRow, CompletedToolRow, HistoryCursor, HistoryPage, IdleSnapshotRow, OpenSnapshotRow, OpenTurn, OpenTurnRow, OutcomeRow, ReportedFileChange, RetainedWindow, Snapshot, SnapshotRow, TellRow, TurnLedger, TurnOutcome, TurnStartRow, UnsettledToolRow, } from "./akuma.js";
-export type { AgentEvent, ToolCall, ToolEvent, ToolResult } from "./provider.js";
-export type { AkuId } from "./identity.js";
-export type { KillEvidence, ResumeCoordinate, TurnFact } from "./heart/index.js";
-export type { ProviderOptions, ReadonlyRestraint } from "./provider-recipe.js";
+export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";

package/build/src/akuma/index.js

@@ -1,10 +1,4 @@
-import { readSoul } from "./heart/index.js";
-import { pathsForAkuId } from "./identity.js";
-export { Akuma, AkumaHandle, AkumaNotBornError, akumaIdSchema, akumaStatusSchema, defaultWaitComplete, parseAkumaStatus, } from "./akuma.js";
+export { Akuma } from "./akuma-instance.js";
+export { Schema, JsonSchema } from "./schema.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";
-export async function probeBornAkuma(worldPath, id) {
-    const soul = await readSoul(pathsForAkuId(worldPath, id));
-    return soul !== null;
-}
-export { AkumaArchetypeError, listArchetypeDefinitions, listArchetypes } from "./archetype.js";
-export { AkumaBodyRequestError } from "./requests.js";
+export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";

package/build/src/akuma/providers/claude/index.js

@@ -88,7 +88,12 @@ function claudeQueryOptions(input, execution, abortController) {
         ...(input.session.kind === "fresh" ? {} : { resume: claudeSessionId(input.session.coordinate) }),
         ...(input.schemaJson === undefined
             ? {}
-            : { outputFormat: { type: "json_schema", schema: JSON.parse(input.schemaJson) } }),
+            : {
+                outputFormat: {
+                    type: "json_schema",
+                    schema: JSON.parse(input.schemaJson),
+                },
+            }),
     };
 }
 async function forkClaude(load, execution, input) {

package/build/src/akuma/providers/pi/index.js

@@ -79,7 +79,9 @@ async function createPiSession(sdk, execution, input) {
 }
 async function runPiPrompt(native, input, events, state, settle) {
     try {
-        const prompt = [input.body, ...input.launchTells.map((tell) => tell.text)].filter((part) => part.length > 0).join("\n\n");
+        const prompt = [input.body, ...input.launchTells.map((tell) => tell.text)]
+            .filter((part) => part.length > 0)
+            .join("\n\n");
         const schemaPrompt = input.schemaJson === undefined
             ? prompt
             : [prompt, "Respond with JSON matching this JSON Schema and no other text:", input.schemaJson]

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

@@ -0,0 +1,16 @@
+import { type ZodType } from "zod";
+export type JsonSchemaDocument = Readonly<{
+    readonly [key: string]: unknown;
+}>;
+export declare class Schema<T> {
+    readonly jsonSchema: JsonSchemaDocument;
+    readonly jsonText: string;
+    readonly decode: (value: unknown) => T;
+    private constructor();
+    get json(): JsonSchemaDocument;
+    static zod<Output>(schema: ZodType<Output>): Schema<Output>;
+    static json(schema: unknown): Schema<unknown>;
+    static json<Output>(schema: unknown, decode: (value: unknown) => Output): Schema<Output>;
+    parse(value: unknown): T;
+}
+export declare function JsonSchema(schema: unknown): Schema<unknown>;

package/build/src/akuma/schema.js

@@ -0,0 +1,85 @@
+import { fromJSONSchema, toJSONSchema } from "zod";
+const SCHEMA_JSON_MAX_BYTES = 65_536;
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sortValue(value) {
+    if (Array.isArray(value))
+        return value.map(sortValue);
+    if (!isPlainObject(value))
+        return value;
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+        if (key === "~standard")
+            continue;
+        sorted[key] = sortValue(value[key]);
+    }
+    return sorted;
+}
+function freezeValue(value) {
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            freezeValue(entry);
+        return Object.freeze(value);
+    }
+    if (!isPlainObject(value))
+        return value;
+    for (const key of Object.keys(value))
+        freezeValue(value[key]);
+    return Object.freeze(value);
+}
+function canonicalDocument(value, label) {
+    const sorted = sortValue(value);
+    if (!isPlainObject(sorted))
+        throw new TypeError(`${label} must be a JSON object`);
+    const jsonText = JSON.stringify(sorted);
+    if (new TextEncoder().encode(jsonText).byteLength > SCHEMA_JSON_MAX_BYTES) {
+        throw new TypeError(`${label} exceeds the ${SCHEMA_JSON_MAX_BYTES}-byte bound`);
+    }
+    return { json: freezeValue(JSON.parse(jsonText)), jsonText };
+}
+function decodeJsonDocument(schema) {
+    if (typeof schema === "string") {
+        try {
+            return JSON.parse(schema);
+        }
+        catch (error) {
+            throw new TypeError(error instanceof Error ? error.message : "JSON Schema is not valid JSON");
+        }
+    }
+    if (isPlainObject(schema) || Array.isArray(schema))
+        return schema;
+    throw new TypeError("JSON Schema must be a JSON object or JSON text");
+}
+export class Schema {
+    jsonSchema;
+    jsonText;
+    decode;
+    constructor(jsonSchema, jsonText, decode) {
+        this.jsonSchema = jsonSchema;
+        this.jsonText = jsonText;
+        this.decode = decode;
+        Object.freeze(this);
+    }
+    get json() {
+        return this.jsonSchema;
+    }
+    static zod(schema) {
+        const payload = toJSONSchema(schema, { target: "draft-07", unrepresentable: "throw", cycles: "throw" });
+        const canonical = canonicalDocument(payload, "Zod JSON Schema");
+        return new Schema(canonical.json, canonical.jsonText, (value) => schema.parse(value));
+    }
+    static json(schema, decode) {
+        const document = decodeJsonDocument(schema);
+        const canonical = canonicalDocument(document, "JSON Schema");
+        const decoder = decode ??
+            ((value) => fromJSONSchema(JSON.parse(canonical.jsonText)).parse(value));
+        return new Schema(canonical.json, canonical.jsonText, decoder);
+    }
+    parse(value) {
+        return this.decode(value);
+    }
+}
+export function JsonSchema(schema) {
+    return Schema.json(schema);
+}

package/build/src/akuma/turn-drive.js

@@ -275,9 +275,7 @@ async function stopActiveDrive(input, active) {
     }
 }
 function hasUnattemptedTell(liveTells, tellPump, pending, attempted) {
-    return (liveTells &&
-        tellPump === null &&
-        pending.some((tell) => !attempted.has(tell.id) && tell.schemaJson === undefined));
+    return (liveTells && tellPump === null && pending.some((tell) => !attempted.has(tell.id) && tell.schemaJson === undefined));
 }
 async function settleCompletion(result, session, active) {
     try {

package/build/src/akuma-body.js

@@ -2,6 +2,8 @@ import { LEASH_HELD_EXIT, runAkumaBody } from "./akuma/body.js";
 import { worldRootForAkumaPaths } from "./akuma/identity.js";
 import { World } from "./world.js";
 import { executeKillAkuma, executeTellAkuma, executeWaitAkuma } from "./akuma/fleet-execution.js";
+import { Akuma as PublicAkuma } from "./akuma/akuma-instance.js";
+import { JsonSchema } from "./akuma/schema.js";
 import { fleetRequestCommands } from "./akuma/fleet-request.js";
 import { worktreeHooksFrom } from "./git/hooks.js";
 import { contractRequestCommands, executeForwardedAudit, executeForwardedDeliver, executeForwardedReview, } from "./library/contract-operations.js";
@@ -82,6 +84,10 @@ function fleetRequestPort(world) {
             recordedAt: input.recordedAt,
             signal: input.signal,
         }),
+        tellAnswer: async (input) => await PublicAkuma.select(world, input.target).tell(input.body, {
+            schema: JsonSchema(input.schemaJson),
+            ...(input.interrupt === undefined ? {} : { interrupt: input.interrupt }),
+        }),
         kill: async (input) => {
             const result = await executeKillAkuma({ path: world, ids: input.targets, signal: input.signal });
             return result;

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

@@ -1,4 +1,5 @@
-import { type AkuId, type ActivityHistory } from "../../akuma/index.js";
+import { type AkuId } from "../../akuma/identity.js";
+import { type ActivityHistory } from "../../akuma/akuma.js";
 import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaObservation, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
 import type { Settings } from "../../settings.js";
 import type { WorldRoot } from "../../world.js";
@@ -10,6 +11,7 @@ export type AkumaInvocationResult = Readonly<{
     action: "call";
     result: CallResult;
     world: WorldRoot;
+    schemaAnswer?: unknown;
 }> | Readonly<{
     kind: "akuma";
     action: "status";
@@ -27,6 +29,13 @@ export type AkumaInvocationResult = Readonly<{
     result: AkumaTellResult;
     body: string;
     alias?: string;
+}> | Readonly<{
+    kind: "akuma";
+    action: "tell";
+    mode: "schema";
+    result: unknown;
+    body: string;
+    alias?: string;
 }> | Readonly<{
     kind: "akuma";
     action: "tell";

package/build/src/cli/commands/akuma-invoke.js

@@ -1,7 +1,35 @@
+import { readFile } from "node:fs/promises";
 import { Keiyaku, } from "../../index.js";
 import { beginCall, finishCall } from "../../library/akuma-creation.js";
 import { killAkuma, tellAkuma, waitAkuma } from "../../library/fleet.js";
 import { localExecutionContext } from "../../akuma/requests.js";
+import { Akuma, JsonSchema } from "../../akuma/index.js";
+import { addressAkuma } from "../../library/address.js";
+import { executionChannel } from "../../akuma/requests.js";
+import { requestForwardedFleetTellAnswer } from "../../akuma/fleet-request.js";
+async function schemaFromFile(path) {
+    try {
+        return JsonSchema(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`cannot read JSON Schema file ${path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function firstSchemaAnswer(id, world, schema) {
+    const history = await Akuma.select(world, id).history();
+    const outcome = history.rows.find((row) => row.kind === "outcome" && row.outcome.kind === "answered");
+    if (outcome === undefined || outcome.kind !== "outcome" || outcome.outcome.kind !== "answered") {
+        throw new Error("schema call completed without an answered Turn");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(outcome.outcome.answer);
+    }
+    catch (error) {
+        throw new Error(`schema answer is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return schema.decode(parsed);
+}
 function inputAlias(selector) {
     return selector.startsWith("@") ? selector : undefined;
 }
@@ -25,6 +53,36 @@ async function invokeWait(command, input) {
 }
 async function invokeTell(command, input) {
     const body = await promptBody(command, input);
+    if (command.schema !== undefined) {
+        const schema = await schemaFromFile(command.schema);
+        const addressed = await addressAkuma({
+            path: input.path,
+            akuma: command.akuma,
+            ...(input.repo === undefined ? {} : { repo: input.repo }),
+        });
+        const channel = executionChannel(input.execution);
+        const answer = channel.kind === "body-request"
+            ? await requestForwardedFleetTellAnswer({
+                directory: channel.directory,
+                target: addressed.id,
+                body,
+                schema,
+                interrupt: command.interrupt,
+            })
+            : await Akuma.select(addressed.path, addressed.id).tell(body, {
+                schema,
+                ...(command.interrupt ? { interrupt: true } : {}),
+            });
+        const alias = inputAlias(command.akuma);
+        return {
+            kind: "akuma",
+            action: "tell",
+            mode: "schema",
+            result: answer,
+            body,
+            ...(alias === undefined ? {} : { alias }),
+        };
+    }
     if (command.interrupt) {
         const result = await Keiyaku.interrupt({
             path: input.path,
@@ -106,6 +164,7 @@ export async function invokeAkuma(command, input) {
     switch (command.command) {
         case "call": {
             const body = await promptBody(command, input);
+            const schema = command.schema === undefined ? undefined : await schemaFromFile(command.schema);
             const born = await beginCall({
                 path: input.path,
                 archetype: command.archetype,
@@ -119,8 +178,13 @@ export async function invokeAkuma(command, input) {
                 ...(input.contract === undefined ? {} : { contract: input.contract }),
                 ...(command.alias === undefined ? {} : { alias: command.alias }),
                 ...(command.allowed === undefined ? {} : { allowed: command.allowed }),
+                ...(schema === undefined ? {} : { schema }),
             }, input.execution ?? localExecutionContext());
             const result = await (input.finishCall ?? finishCall)(born);
+            if (schema !== undefined && command.mode === "wait" && result.observation.kind === "observed") {
+                const answer = await firstSchemaAnswer(result.akuma, input.path, schema);
+                return { kind: "akuma", action: "call", result, world: input.path, schemaAnswer: answer };
+            }
             return { kind: "akuma", action: "call", result, world: input.path };
         }
         case "wait":

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

@@ -24,6 +24,7 @@ export type ParsedAkumaCommand = Output & ((Readonly<{
     timeoutMs?: number;
     readonly?: true;
     allowed?: AllowedActions;
+    schema?: string;
 }> & Prompted) | Readonly<{
     command: "kill";
     akuma: readonly string[];
@@ -35,6 +36,7 @@ export type ParsedAkumaCommand = Output & ((Readonly<{
 }> | (Readonly<{
     command: "tell";
     interrupt: boolean;
+    schema?: string;
 }> & Addressed & Prompted) | (Readonly<{
     command: "history";
     last: boolean;

package/build/src/cli/commands/akuma.js

@@ -16,8 +16,9 @@ const AKUMA_COMMAND_SPECS = {
             readonly: "boolean",
             allowed: "repeatable",
             json: "boolean",
+            schema: "value",
         },
-        usage: "call <akuma-name> [--contract <kei/...>] [--alias @name] [--readonly] [--allowed <product.action>]... [--wait <duration> | -d | --detach] [--json] (<prompt> | -)",
+        usage: "call <akuma-name> [--contract <kei/...>] [--alias @name] [--readonly] [--allowed <product.action>]... [--schema <file>] [--wait <duration> | -d | --detach] [--json] (<prompt> | -)",
         purpose: "Birth an Akuma from <akuma-name> with one prompt.",
         details: [
             "Give <prompt> as one argument, or use - to read stdin.",
@@ -26,6 +27,7 @@ const AKUMA_COMMAND_SPECS = {
             "--alias assigns the world-local @name selector to the born Akuma.",
             "--readonly adds the one-way read-only birth restriction.",
             "Repeated --allowed adds actions to the selected Akuma's defaults.",
+            "--schema reads a JSON Schema file for the answer contract; stdin remains the prompt source.",
             "With --contract, Dispatch succeeds first. If @name exists, the alias then moves.",
         ].join("\n"),
     },
@@ -39,12 +41,13 @@ const AKUMA_COMMAND_SPECS = {
     tell: {
         arity: 1,
         stdin: true,
-        flags: { interrupt: "boolean", json: "boolean" },
-        usage: "tell <aku/...|@alias> [--interrupt] [--json] (<prompt> | -)",
+        flags: { interrupt: "boolean", schema: "value", json: "boolean" },
+        usage: "tell <aku/...|@alias> [--interrupt] [--schema <file>] [--json] (<prompt> | -)",
         purpose: "Send one prompt to an existing Akuma and wake it.",
         details: [
             "Give <prompt> as one argument, or use - to read stdin.",
             "--interrupt ends the current Body before recording the prompt and waking its successor.",
+            "--schema reads a JSON Schema file for the answer contract; stdin remains the prompt source.",
         ].join("\n"),
     },
     history: {
@@ -265,7 +268,15 @@ function parsePrompted(action, positionals, stdin, fail) {
     };
 }
 function parseTell(flags, subject, prompt, output, fail) {
-    return { command: "tell", akuma: validateDirect(subject, fail), interrupt: flags.interrupt === true, prompt, output };
+    const schema = flags.schema === undefined ? undefined : stringFlag(flags.schema, "tell --schema requires a file", fail);
+    return {
+        command: "tell",
+        akuma: validateDirect(subject, fail),
+        interrupt: flags.interrupt === true,
+        ...(schema === undefined ? {} : { schema }),
+        prompt,
+        output,
+    };
 }
 function parseAllowedFlag(raw, fail) {
     if (raw === undefined)
@@ -295,6 +306,7 @@ function parseCall(flags, archetype, prompt, output, fail) {
     const mode = flags.detach === true ? "detach" : "wait";
     const timeoutMs = flags.wait === undefined ? undefined : parseDuration(flags.wait, "--wait", fail);
     const allowed = parseAllowedFlag(flags.allowed, fail);
+    const schema = flags.schema === undefined ? undefined : stringFlag(flags.schema, "call --schema requires a file", fail);
     return {
         command: "call",
         archetype,
@@ -304,6 +316,7 @@ function parseCall(flags, archetype, prompt, output, fail) {
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
         ...(flags.readonly === true ? { readonly: true } : {}),
         ...(allowed === undefined ? {} : { allowed }),
+        ...(schema === undefined ? {} : { schema }),
         prompt,
         output,
     };

package/build/src/cli/render/akuma-activity.d.ts

@@ -1,4 +1,4 @@
-import type { KillEvidence } from "../../akuma/index.js";
+import type { KillEvidence } from "../../akuma/akuma.js";
 import type { AkumaObservation, AkumaObservationStage, CreatedTaskObservation, DispatchAssociation } from "../../index.js";
 import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
 import type { ParsedCommand } from "../parse.js";

package/build/src/cli/render/akuma-tool.d.ts

@@ -1,4 +1,4 @@
-import type { ActivityRow, SnapshotRow } from "../../akuma/index.js";
+import type { ActivityRow, SnapshotRow } from "../../akuma/akuma.js";
 import type { AkumaObservation } from "../../index.js";
 type FleetTimelineRow = Extract<AkumaObservation["status"]["timeline"]["entries"][number], {
     kind: "row";

package/build/src/cli/render/akuma.js

@@ -19,6 +19,8 @@ function posixShellArgument(value) {
     return `'${value.replace(/'/g, `'\"'\"'`)}'`;
 }
 function callText(result, context) {
+    if (result.schemaAnswer !== undefined)
+        return JSON.stringify(result.schemaAnswer);
     const alias = result.result.alias.kind === "aliased" ? result.result.alias.alias.alias : undefined;
     const contractId = result.result.dispatch.kind === "dispatched" ? result.result.dispatch.dispatch.contractId : undefined;
     const facts = [...dispatchLines(result.result.dispatch)];
@@ -63,6 +65,8 @@ export function renderAkumaText(command, result, context = DEFAULT_CONTEXT) {
         const cwd = executionCwdLine(result.result);
         return cwd.length === 0 ? answer : `${cwd.join("\n")}\n${answer}`;
     }
+    if (result.action === "tell" && result.mode === "schema")
+        return JSON.stringify(result.result);
     switch (result.action) {
         case "call":
             return callText(result, context);
@@ -111,6 +115,8 @@ function killExitCode(result) {
         : 0;
 }
 function tellExitCode(result) {
+    if (result.mode === "schema")
+        return 0;
     return result.mode === "ordinary"
         ? result.result.tell.wake.kind === "failed"
             ? 2
@@ -145,7 +151,7 @@ export function akumaExitCode(result) {
 }
 export function akumaJsonValue(result) {
     if (result.action === "call")
-        return result.result;
+        return result.schemaAnswer === undefined ? result.result : result.schemaAnswer;
     if (result.action === "fork")
         return result.receipt;
     if (result.action === "status")
@@ -153,7 +159,7 @@ export function akumaJsonValue(result) {
     if (result.action === "wait")
         return result.result;
     if (result.action === "tell")
-        return result.result;
+        return result.mode === "schema" ? result.result : result.result;
     if (result.action === "kill")
         return result.result;
     return result.historyResult;

package/build/src/kanshi/read.js

@@ -2,7 +2,7 @@ import { Repo } from "../library/repo.js";
 import { scopeForRepo } from "../library/repo.js";
 import { observeTaskBoard } from "../task/operations.js";
 import { contractNamespace } from "../task/identity.js";
-import { Akuma } from "../akuma/index.js";
+import { Akuma } from "../akuma/akuma.js";
 import { readAliases } from "../alias/index.js";
 import { readDispatchesAt } from "../dispatch/index.js";
 import { readTaskHolderProjectionAt } from "../settlement/holder.js";

package/build/src/kanshi/report.d.ts

@@ -1,6 +1,6 @@
 import type { ContractBoard, ContractDisposition, ContractPhase } from "../library/contract.js";
 import type { TaskId, TaskRef, TaskRow } from "../task/index.js";
-import type { AkumaList, AkumaListRow, UnbornAkumaListRow, ActivitySnapshot } from "../akuma/index.js";
+import type { AkumaList, AkumaListRow, UnbornAkumaListRow, ActivitySnapshot } from "../akuma/akuma.js";
 import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
 import type { ContractId } from "../library/contract.js";

package/build/src/library/address.js

@@ -1,7 +1,7 @@
 /** @architectureCompositionRoot */
 import { readAliases } from "../alias/index.js";
 import { Akuma } from "../akuma/akuma.js";
-import { probeBornAkuma } from "../akuma/index.js";
+import { probeBornAkuma } from "../akuma/akuma-probe.js";
 import { parseAkuId } from "../akuma/identity.js";
 import { contractId } from "../core/facts/types.js";
 import { readDispatches } from "../dispatch/index.js";

package/build/src/library/akuma-creation.d.ts

@@ -8,6 +8,7 @@ import { type AkumaAlias } from "../identity/selector.js";
 import type { Settings } from "../settings.js";
 import { type WorldRoot } from "../world.js";
 import type { AllowedAction } from "../akuma/allowed.js";
+import type { Schema } from "../akuma/schema.js";
 import { type ExecutionContext } from "../akuma/requests.js";
 import { type Keiyaku } from "./contract.js";
 import { type Repo } from "./repo.js";
@@ -52,6 +53,7 @@ export type CallInput = Readonly<{
     contract?: Keiyaku;
     alias?: AkumaAlias;
     allowed?: readonly AllowedAction[];
+    schema?: Schema<unknown>;
 }>;
 export type CallObservation = Readonly<{
     kind: "detached";

package/build/src/library/akuma-creation.js

@@ -242,6 +242,7 @@ export async function beginCall(input, context) {
         "contract",
         "alias",
         "allowed",
+        "schema",
     ], "Keiyaku.call input");
     const path = await World.prove(nonblank(values.path, "path"));
     const archetype = nonblank(values.archetype, "archetype");
@@ -265,6 +266,7 @@ export async function beginCall(input, context) {
         body,
         ...(readonlyRequested === undefined ? {} : { readonly: readonlyRequested }),
         ...(values.allowed === undefined ? {} : { allowed: values.allowed }),
+        ...(values.schema === undefined ? {} : { schema: values.schema }),
         ...(execution === undefined ? {} : { cwd: execution.cwd }),
     };
     const { born, akuma } = await admitCall({

package/build/src/library/fleet.d.ts

@@ -1,5 +1,5 @@
 /** @architectureCompositionRoot */
-import { type ActivityHistory, type OutcomeRow, type AkumaStatus, type InterruptReceipt } from "../akuma/index.js";
+import { type ActivityHistory, type OutcomeRow, type AkumaStatus, type InterruptReceipt } from "../akuma/akuma.js";
 import { type ExecutionContext } from "../akuma/requests.js";
 import { type DispatchAssociation } from "../dispatch/index.js";
 import { type AkumaAddressInput, type AkumaSetAddressInput } from "./address.js";
@@ -11,7 +11,7 @@ export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
 export type AkumaTellInput = AkumaAddressInput & Readonly<{
     body: string;
 }>;
-export type { TellResult, TellWake } from "../akuma/index.js";
+export type { TellResult, TellWake } from "../akuma/akuma.js";
 export type AkumaInterruptInput = AkumaAddressInput & Readonly<{
     body: string;
 }>;

package/build/src/library/fleet.js

@@ -1,6 +1,5 @@
 /** @architectureCompositionRoot */
-import { Akuma, AkumaNotBornError, } from "../akuma/index.js";
-import { readBudgetedStatus } from "../akuma/akuma.js";
+import { Akuma, AkumaNotBornError, readBudgetedStatus, } from "../akuma/akuma.js";
 import { executionChannel, localExecutionContext } from "../akuma/requests.js";
 import { requestForwardedFleetKill, requestForwardedFleetTell, requestForwardedFleetWait, } from "../akuma/fleet-request.js";
 import { executeKillAkuma, executeTellAkuma, executeWaitAkuma } from "../akuma/fleet-execution.js";

package/build/src/library/keiyaku.d.ts

@@ -22,7 +22,7 @@ export type { Dispatch, DispatchFailure } from "../dispatch/index.js";
 export type { AkumaAlias } from "../identity/selector.js";
 export type { AkumaGlob } from "../identity/selector.js";
 export type { AkuId } from "../akuma/identity.js";
-export type { TellResult, TellWake } from "../akuma/index.js";
+export type { TellResult, TellWake } from "../akuma/akuma.js";
 export type { AllowedAction, AllowedActions } from "../akuma/allowed.js";
 export type { Catalog, CatalogInput, CatalogQuery } from "./catalog.js";
 export type { NukeInput, NukeResult } from "./nuke.js";

package/build/src/plugin/runtime.js

@@ -374,10 +374,7 @@ async function createPluginRuntime(input) {
                 while (inFlight.size > 0)
                     await Promise.all([...inFlight]);
             };
-            await Promise.race([
-                settle(),
-                new Promise((resolve) => setTimeout(resolve, PLUGIN_DRAIN_TIMEOUT_MS)),
-            ]);
+            await Promise.race([settle(), new Promise((resolve) => setTimeout(resolve, PLUGIN_DRAIN_TIMEOUT_MS))]);
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.15",
+  "version": "4.5.16",
   "workspaces": [
     "plugins/*"
   ],
@@ -77,7 +77,7 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
-    "@astrosheep/keiyaku-plugin-square": "0.1.3",
+    "@astrosheep/keiyaku-plugin-square": "0.1.4",
     "@earendil-works/pi-coding-agent": "0.80.10",
     "@opencode-ai/sdk": "1.18.3",
     "cross-spawn": "^7.0.6",