@astrosheep/keiyaku 4.5.7 → 4.5.8

package/build/src/library/address.js

@@ -5,6 +5,7 @@ import { parseAkuId } from "../akuma/identity.js";
 import { contractId } from "../core/facts/types.js";
 import { readDispatches } from "../dispatch/index.js";
 import { matchesAkumaGlob, parseAkumaAlias, parseAkumaGlob, } from "../identity/selector.js";
+import { World } from "../world.js";
 import { requireInput } from "./input.js";
 import { scopeForRepo } from "./repo.js";
 export class AkumaWorldScopeError extends TypeError {
@@ -72,7 +73,7 @@ export async function addressAkuma(input) {
     }
     if (values.repo !== undefined)
         scopeForRepo(values.repo);
-    const path = nonblank(values.path, "path");
+    const path = await World.prove(nonblank(values.path, "path"));
     return { path, id: await directId(path, nonblank(values.akuma, "akuma")) };
 }
 function idsFromFleet(fleet) {
@@ -143,7 +144,7 @@ export async function addressAkumaSet(input) {
     }
     if (!Array.isArray(values.akuma) || values.akuma.length === 0)
         throw new TypeError("akuma must be a nonempty selector array");
-    const path = nonblank(values.path, "path");
+    const path = await World.prove(nonblank(values.path, "path"));
     const selectors = values.akuma.map(parseSetSelector);
     if (hasSelectorKind(selectors, "contract") && values.repo === undefined) {
         throw new TypeError("Contract Akuma selector requires repo");

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

@@ -5,8 +5,9 @@ import type { AkuId } from "../akuma/identity.js";
 import { type Dispatch, type DispatchFailure } from "../dispatch/index.js";
 import { type AkumaAlias } from "../identity/selector.js";
 import type { Settings } from "../settings.js";
-import type { WorldRoot } from "../world.js";
+import { type WorldRoot } from "../world.js";
 import type { AllowedAction } from "../akuma/allowed.js";
+import { type ExecutionContext } from "../akuma/requests.js";
 import { type Keiyaku } from "./contract.js";
 import { type Repo } from "./repo.js";
 export type { AkumaStatus } from "../akuma/akuma.js";
@@ -98,7 +99,7 @@ export type ForkResult = Readonly<{
 }>> & Readonly<{
     parent: AkuId;
 }>);
-export declare function beginCall(input: CallInput): Promise<BornCall>;
+export declare function beginCall(input: CallInput, context: ExecutionContext): Promise<BornCall>;
 export declare function finishCall(born: BornCall, participantName?: string): Promise<CallResult>;
-export declare function callKeiyaku(input: CallInput): Promise<CallResult>;
+export declare function callKeiyaku(input: CallInput, execution?: ExecutionContext): Promise<CallResult>;
 export declare function forkKeiyaku(input: ForkInput): Promise<ForkResult>;

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

@@ -6,9 +6,12 @@ import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
 import { readManagedWorktreeAppointment } from "../workspace-place.js";
+import { World } from "../world.js";
+import { localExecutionContext } from "../akuma/requests.js";
 import { requireInput } from "./input.js";
 import { addressAkuma } from "./address.js";
-import { KeiyakuRefused, seatForKeiyaku } from "./contract.js";
+import { KeiyakuRefused } from "./contract.js";
+import { seatForKeiyaku } from "./contract-handle.js";
 import { scopeForRepo } from "./repo.js";
 function nonblank(value, label) {
     if (typeof value !== "string" || value.trim().length === 0) {
@@ -36,10 +39,11 @@ function homeOption(value) {
         return undefined;
     return nonblank(value, "home");
 }
-function akumaWorld(path, home, settings) {
+function akumaWorld(path, home, settings, execution) {
     return Akuma.of(path, {
         ...(home === undefined ? {} : { home }),
         ...(settings === undefined ? {} : { settings }),
+        ...(execution === undefined ? {} : { execution }),
     });
 }
 function onlyKeys(values, allowed, label) {
@@ -151,6 +155,8 @@ async function resolveCallExecution(input) {
     }
     if (input.contract !== undefined) {
         const seat = seatForKeiyaku(input.contract);
+        if (seat === null)
+            throw new TypeError("contract must be a Keiyaku");
         const state = await currentManagedContract(input.contract, seat.id);
         const appointment = await readManagedWorktreeAppointment(seat.scope, state.id);
         if (appointment.kind === "unappointed") {
@@ -166,7 +172,7 @@ async function resolveCallExecution(input) {
     }
     return undefined;
 }
-export async function beginCall(input) {
+export async function beginCall(input, context) {
     const values = requireInput(input, "Keiyaku.call input");
     onlyKeys(values, [
         "path",
@@ -182,7 +188,7 @@ export async function beginCall(input) {
         "alias",
         "allowed",
     ], "Keiyaku.call input");
-    const path = nonblank(values.path, "path");
+    const path = await World.prove(nonblank(values.path, "path"));
     const archetype = nonblank(values.archetype, "archetype");
     const body = text(values.body, "body");
     const readonlyRequested = callReadonly(values.readonly);
@@ -192,13 +198,16 @@ export async function beginCall(input) {
     const home = homeOption(values.home);
     const settings = settingsOption(values.settings);
     const alias = values.alias === undefined ? undefined : parseAkumaAlias(nonblank(values.alias, "alias"));
-    const seat = values.contract === undefined ? undefined : seatForKeiyaku(values.contract);
+    const selectedSeat = values.contract === undefined ? undefined : seatForKeiyaku(values.contract);
+    if (values.contract !== undefined && selectedSeat === null)
+        throw new TypeError("contract must be a Keiyaku");
+    const seat = selectedSeat ?? undefined;
     const execution = await resolveCallExecution({
         path,
         ...(cwd === undefined ? {} : { cwd }),
         ...(seat === undefined ? {} : { contract: values.contract }),
     });
-    const world = akumaWorld(path, home, settings);
+    const world = akumaWorld(path, home, settings, context);
     const call = {
         archetype,
         body,
@@ -255,18 +264,15 @@ export async function finishCall(born, participantName) {
         observation,
     };
 }
-export async function callKeiyaku(input) {
-    return await finishCall(await beginCall(input));
+export async function callKeiyaku(input, execution = localExecutionContext()) {
+    return await finishCall(await beginCall(input, execution));
 }
 export async function forkKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.fork input");
     onlyKeys(values, ["path", "akuma", "at", "repo"], "Keiyaku.fork input");
-    const path = nonblank(values.path, "path");
     const at = nonblank(values.at, "at");
-    const akuma = (await addressAkuma({
-        path,
-        akuma: nonblank(values.akuma, "akuma"),
-    })).id;
+    const addressed = await addressAkuma({ path: values.path, akuma: nonblank(values.akuma, "akuma") });
+    const { path, id: akuma } = addressed;
     const repository = values.repo === undefined ? undefined : scopeForRepo(values.repo);
     const receipt = await Akuma.of(path).of({ id: akuma }).fork({ at });
     if (receipt.kind !== "forked")

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

@@ -1,6 +1,6 @@
 import type { ContractId } from "../core/facts/types.js";
 import { type AuditReport } from "../protocol/audit.js";
-import type { RepositoryScope } from "../protocol/operations.js";
+import { type RepositoryScope } from "../protocol/operations.js";
 import { type WorktreeHooks } from "./configuration.js";
 import { type MutationResult } from "./mutation.js";
 export type AuditInput = Readonly<{

package/build/src/library/audit.js

@@ -1,6 +1,7 @@
 import { decodeContractDocument } from "../body/decode.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
 import { auditOperation } from "../protocol/audit.js";
+import { withScopeAbortSignal } from "../protocol/operations.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { actorOption, documentDerivation, optionalBoolean, optionalSignal, requireInput } from "./input.js";
 import { completeMutation } from "./mutation.js";
@@ -20,9 +21,10 @@ function normalizeAuditInput(input) {
 /** Normalize public audit input and project the protocol audit operation. */
 export async function auditContract(input) {
     const normalized = normalizeAuditInput(input.input);
-    return withGitDecodeChannel(input.scope, async (channel) => {
+    const scope = withScopeAbortSignal(input.scope, normalized.signal);
+    return withGitDecodeChannel(scope, async (channel) => {
         const accepted = requireAccepted(await auditOperation({
-            scope: input.scope,
+            scope,
             channel,
             contractId: input.contractId,
             deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
@@ -33,7 +35,7 @@ export async function auditContract(input) {
             ...(normalized.actor === undefined ? {} : { actor: normalized.actor }),
         }));
         return completeMutation({
-            scope: input.scope,
+            scope,
             channel,
             contractId: input.contractId,
             accepted,

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

@@ -3,9 +3,10 @@ import { type ArchetypeCatalogRow } from "../akuma/archetype.js";
 import type { TaskRow } from "../task/index.js";
 import { type ContractBoard } from "./contract.js";
 import { Repo } from "./repo.js";
-import type { WorldRoot } from "../world.js";
+import { type WorldRoot } from "../world.js";
 export type CatalogQuery = Readonly<{
     kind: "tasks";
+    namespace?: readonly string[];
 }> | Readonly<{
     kind: "contracts";
 }> | Readonly<{
@@ -52,6 +53,7 @@ export type Catalog = Readonly<{
     kind: "akuma";
     root: WorldRoot;
     archetype: string | null;
+    observedAt: string;
     rows: AkumaList["rows"];
     searched: readonly string[];
 }>;

package/build/src/library/catalog.js

@@ -1,9 +1,10 @@
 import { Akuma } from "../akuma/akuma.js";
 import { listArchetypeDefinitions } from "../akuma/archetype.js";
-import { observeTaskCatalogRows } from "../task/operations.js";
+import { observeTaskCatalogRows } from "../task/catalog.js";
 import { listKeiyaku } from "./contract.js";
 import { requireInput } from "./input.js";
 import { Repo } from "./repo.js";
+import { World } from "../world.js";
 function optionalHome(value) {
     if (value === undefined)
         return undefined;
@@ -12,10 +13,18 @@ function optionalHome(value) {
     }
     return value;
 }
-function worldRoot(value) {
+async function worldRoot(value) {
     if (typeof value !== "string" || value.trim().length === 0)
         throw new TypeError("path must be a WorldRoot");
-    return value;
+    return await World.prove(value);
+}
+function taskQueryValue(query) {
+    if (query.namespace !== undefined && !Array.isArray(query.namespace))
+        throw new TypeError("Keiyaku.ls Task namespace must be an array");
+    return {
+        kind: "tasks",
+        ...(query.namespace === undefined ? {} : { namespace: query.namespace }),
+    };
 }
 function queryValue(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -26,10 +35,14 @@ function queryValue(value) {
         throw new TypeError("Keiyaku.ls query kind is invalid");
     }
     for (const key of Object.keys(query)) {
-        if (key !== "kind" && !(query.kind === "akuma" && key === "archetype")) {
+        if (key !== "kind" &&
+            !(query.kind === "akuma" && key === "archetype") &&
+            !(query.kind === "tasks" && key === "namespace")) {
             throw new TypeError(`Keiyaku.ls query has unknown field: ${key}`);
         }
     }
+    if (query.kind === "tasks")
+        return taskQueryValue(query);
     if (query.kind !== "akuma")
         return { kind: query.kind };
     if (query.archetype !== undefined && typeof query.archetype !== "string") {
@@ -62,15 +75,16 @@ export async function listCatalog(input) {
             rows: await listArchetypeDefinitions(home === undefined ? {} : { home }),
         };
     }
-    const path = worldRoot(values.path);
+    const path = await worldRoot(values.path);
     if (query.kind === "tasks") {
-        return { kind: "tasks", root: path, rows: await observeTaskCatalogRows(path) };
+        return { kind: "tasks", root: path, rows: await observeTaskCatalogRows(path, query.namespace) };
     }
     const listed = await Akuma.of(path).list(query.archetype === undefined ? undefined : { archetype: query.archetype });
     return {
         kind: "akuma",
         root: path,
         archetype: query.archetype ?? null,
+        observedAt: listed.observedAt,
         rows: listed.rows,
         searched: listed.searched,
     };

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

@@ -0,0 +1,371 @@
+import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku } from "./contract.js";
+import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
+import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma } from "./fleet.js";
+import { listCatalog } from "./catalog.js";
+import { nukeKeiyaku } from "./nuke.js";
+import { type ExecutionContext } from "../akuma/requests.js";
+/** Internal composition root for one immutable execution channel. */
+export declare function composeLibrary(context?: ExecutionContext): Readonly<{
+    prototype: KeiyakuHandle;
+    [Symbol.hasInstance]: (value: unknown) => boolean;
+    bind: (input: Parameters<typeof bindKeiyaku>[0]) => Promise<import("./contract-types.js").BindResult>;
+    call: (input: Parameters<typeof callKeiyaku>[0]) => Promise<Readonly<{
+        kind: "called";
+        akuma: import("./keiyaku.js").AkuId;
+        readonly?: import("../akuma/provider-recipe.js").ReadonlyRestraint;
+        execution: Readonly<{
+            cwd: string;
+            source: "input" | "contract-worktree" | "caller" | "process" | "world";
+        }>;
+        dispatch: import("./akuma-creation.js").DispatchStage;
+        alias: import("./akuma-creation.js").AliasStage;
+        observation: import("./akuma-creation.js").CallObservation;
+    }>>;
+    fork: typeof forkKeiyaku;
+    history: typeof historyAkuma;
+    interrupt: typeof interruptAkuma;
+    kill: (input: Parameters<typeof killAkuma>[0]) => Promise<{
+        results: {
+            id: import("./keiyaku.js").AkuId;
+            evidence: "unavailable" | "killed" | "already-killed" | "already-stopped" | "hung" | "untidy";
+        }[];
+    }>;
+    ls: typeof listCatalog;
+    nuke: typeof nukeKeiyaku;
+    list: typeof listKeiyaku;
+    observe: typeof observeKeiyaku;
+    of: (input: Parameters<typeof keiyakuOf>[0]) => KeiyakuHandle;
+    status: typeof statusAkuma;
+    tell: (input: Parameters<typeof tellAkuma>[0]) => Promise<{
+        akuma: import("./keiyaku.js").AkuId;
+        tell: {
+            admission: {
+                fact: "recorded";
+                tellId: string;
+            };
+            wake: {
+                kind: "failed";
+                diagnostic: string;
+            } | {
+                child: {
+                    code: number | null;
+                    signal: string | null;
+                    log: {
+                        path: string;
+                        from: number;
+                        to: number;
+                    };
+                };
+                kind: "failed";
+                diagnostic: string;
+            } | {
+                kind: "told";
+            } | {
+                kind: "held";
+            } | {
+                kind: "pursuing";
+                bodySequence: number;
+            };
+        };
+    }>;
+    wait: (input: Parameters<typeof waitAkuma>[0]) => Promise<{
+        completion: "any" | "all";
+        observations: {
+            status: {
+                id: import("./keiyaku.js").AkuId;
+                life: "killed" | "hung" | "untidy" | "running" | "asleep" | "stranded";
+                timeline: {
+                    reportedChanges: readonly {
+                        sequence: number;
+                        at: string;
+                        op: "add" | "update" | "delete" | "unspecified";
+                        path: string;
+                        diffstat?: {
+                            added: number;
+                            removed: number;
+                        } | undefined;
+                    }[];
+                    reportedChangesOmitted: number;
+                    kind: "unborn";
+                    entries: readonly never[];
+                    omitted: 0;
+                } | {
+                    reportedChanges: readonly {
+                        sequence: number;
+                        at: string;
+                        op: "add" | "update" | "delete" | "unspecified";
+                        path: string;
+                        diffstat?: {
+                            added: number;
+                            removed: number;
+                        } | undefined;
+                    }[];
+                    reportedChangesOmitted: number;
+                    kind: "open";
+                    turn: {
+                        kind: "turn";
+                        sequence: number;
+                        turnSequence: number;
+                        bodySequence: number;
+                        at: string;
+                    };
+                    entries: readonly ({
+                        kind: "gap";
+                        count: number;
+                    } | {
+                        kind: "row";
+                        row: {
+                            kind: "call";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            text: string;
+                        } | {
+                            kind: "note" | "thought" | "said";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            text: string;
+                            truncated?: true | undefined;
+                        } | {
+                            kind: "tell";
+                            sequence: number;
+                            at: string;
+                            tellId: string;
+                            text: string;
+                            state: "pending" | "told";
+                            deliveries: readonly {
+                                deliveredAt: string;
+                                route: "live" | "launch";
+                                turnSequence: number;
+                                receipt?: "required" | "unavailable" | undefined;
+                            }[];
+                        } | {
+                            kind: "tool";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            name: string;
+                            call: {
+                                kind: "run";
+                                command: string;
+                            } | {
+                                kind: "read";
+                                path: string;
+                                offset?: number | undefined;
+                                limit?: number | undefined;
+                            } | {
+                                kind: "search";
+                                query: string;
+                                scope?: "content" | "files" | "web" | undefined;
+                                path?: string | undefined;
+                                glob?: string | undefined;
+                            } | {
+                                kind: "fileChange";
+                                changes: readonly {
+                                    op: "add" | "update" | "delete" | "unspecified";
+                                    path: string;
+                                    diffstat?: {
+                                        added: number;
+                                        removed: number;
+                                    } | undefined;
+                                }[];
+                            } | {
+                                kind: "other";
+                                display: string;
+                            };
+                            state: "active";
+                            truncated?: true | undefined;
+                        } | {
+                            kind: "tool";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            name: string;
+                            call: {
+                                kind: "run";
+                                command: string;
+                            } | {
+                                kind: "read";
+                                path: string;
+                                offset?: number | undefined;
+                                limit?: number | undefined;
+                            } | {
+                                kind: "search";
+                                query: string;
+                                scope?: "content" | "files" | "web" | undefined;
+                                path?: string | undefined;
+                                glob?: string | undefined;
+                            } | {
+                                kind: "fileChange";
+                                changes: readonly {
+                                    op: "add" | "update" | "delete" | "unspecified";
+                                    path: string;
+                                    diffstat?: {
+                                        added: number;
+                                        removed: number;
+                                    } | undefined;
+                                }[];
+                            } | {
+                                kind: "other";
+                                display: string;
+                            };
+                            state: {
+                                status: "error" | "ok";
+                                message?: string | undefined;
+                                exitCode?: number | undefined;
+                            };
+                            completedAt?: string | undefined;
+                            durationMs?: number | undefined;
+                            truncated?: true | undefined;
+                        };
+                    })[];
+                    omitted: number;
+                } | {
+                    reportedChanges: readonly {
+                        sequence: number;
+                        at: string;
+                        op: "add" | "update" | "delete" | "unspecified";
+                        path: string;
+                        diffstat?: {
+                            added: number;
+                            removed: number;
+                        } | undefined;
+                    }[];
+                    reportedChangesOmitted: number;
+                    kind: "idle";
+                    entries: readonly ({
+                        kind: "gap";
+                        count: number;
+                    } | {
+                        kind: "row";
+                        row: {
+                            kind: "call";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            text: string;
+                        } | {
+                            kind: "note" | "thought" | "said";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            text: string;
+                            truncated?: true | undefined;
+                        } | {
+                            kind: "tell";
+                            sequence: number;
+                            at: string;
+                            tellId: string;
+                            text: string;
+                            state: "pending" | "told";
+                            deliveries: readonly {
+                                deliveredAt: string;
+                                route: "live" | "launch";
+                                turnSequence: number;
+                                receipt?: "required" | "unavailable" | undefined;
+                            }[];
+                        } | {
+                            kind: "tool";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            name: string;
+                            call: {
+                                kind: "run";
+                                command: string;
+                            } | {
+                                kind: "read";
+                                path: string;
+                                offset?: number | undefined;
+                                limit?: number | undefined;
+                            } | {
+                                kind: "search";
+                                query: string;
+                                scope?: "content" | "files" | "web" | undefined;
+                                path?: string | undefined;
+                                glob?: string | undefined;
+                            } | {
+                                kind: "fileChange";
+                                changes: readonly {
+                                    op: "add" | "update" | "delete" | "unspecified";
+                                    path: string;
+                                    diffstat?: {
+                                        added: number;
+                                        removed: number;
+                                    } | undefined;
+                                }[];
+                            } | {
+                                kind: "other";
+                                display: string;
+                            };
+                            state: {
+                                status: "error" | "ok";
+                                message?: string | undefined;
+                                exitCode?: number | undefined;
+                            };
+                            completedAt?: string | undefined;
+                            durationMs?: number | undefined;
+                            truncated?: true | undefined;
+                        };
+                    })[];
+                    omitted: number;
+                    outcome?: {
+                        kind: "outcome";
+                        sequence: number;
+                        turnSequence: number;
+                        at: string;
+                        outcome: {
+                            kind: "answered";
+                            historyId: string;
+                            answer: string;
+                        } | {
+                            kind: "failed";
+                            historyId: string;
+                            diagnostic: string;
+                        };
+                    } | undefined;
+                };
+                readonly?: {
+                    enforcement: "native";
+                } | {
+                    enforcement: "none";
+                    diagnostic: string;
+                } | undefined;
+                strandedReason?: "resume-unsupported" | undefined;
+            };
+            contract: {
+                kind: "none";
+            } | {
+                kind: "associated";
+                contractId: import("./contract.js").ContractId;
+            } | {
+                kind: "failed";
+                diagnostic: string;
+            };
+            createdTasks: {
+                kind: "present";
+                rows: readonly {
+                    id: `task/${string}`;
+                    title: string;
+                    state: "open" | "in_progress" | "on_hold" | "done" | "drop";
+                    priority: 0 | 1 | 2 | 3;
+                    disposition: "in_progress" | "on_hold" | "done" | "drop" | "ready" | "blocked";
+                    updatedAt: string;
+                    bodyPresent: boolean;
+                    children?: {
+                        live: number;
+                        total: number;
+                    } | undefined;
+                }[];
+            } | {
+                kind: "failed";
+                diagnostic: string;
+            };
+        }[];
+        unobserved: {
+            id: import("./keiyaku.js").AkuId;
+            diagnostic: string;
+        }[];
+    }>;
+}>;

package/build/src/library/composition.js

@@ -0,0 +1,28 @@
+import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku } from "./contract.js";
+import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
+import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma } from "./fleet.js";
+import { listCatalog } from "./catalog.js";
+import { nukeKeiyaku } from "./nuke.js";
+import { executionChannel, localExecutionContext } from "../akuma/requests.js";
+/** Internal composition root for one immutable execution channel. */
+export function composeLibrary(context = localExecutionContext()) {
+    const captured = Object.freeze({ channel: executionChannel(context) });
+    return Object.freeze({
+        prototype: KeiyakuHandle.prototype,
+        [Symbol.hasInstance]: (value) => value instanceof KeiyakuHandle,
+        bind: (input) => bindKeiyaku(input, captured),
+        call: (input) => callKeiyaku(input, captured),
+        fork: forkKeiyaku,
+        history: historyAkuma,
+        interrupt: interruptAkuma,
+        kill: (input) => killAkuma(input, captured),
+        ls: listCatalog,
+        nuke: nukeKeiyaku,
+        list: listKeiyaku,
+        observe: observeKeiyaku,
+        of: (input) => keiyakuOf(input, captured),
+        status: statusAkuma,
+        tell: (input) => tellAkuma(input, captured),
+        wait: (input) => waitAkuma(input, captured),
+    });
+}