@astrosheep/keiyaku 4.5.7 → 4.5.8

package/build/src/library/fleet-result.js

@@ -0,0 +1,96 @@
+import { akumaIdSchema, akumaStatusSchema } from "../akuma/akuma.js";
+import { contractId } from "../core/facts/types.js";
+import { taskRowsSchema } from "../task/board.js";
+import { z } from "zod";
+const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
+const contractIdSchema = z.string().transform((value, context) => {
+    try {
+        return contractId(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "expected ContractId" });
+        return z.NEVER;
+    }
+});
+const killEvidenceSchema = z.enum([
+    "killed",
+    "already-killed",
+    "already-stopped",
+    "hung",
+    "untidy",
+    "unavailable",
+]);
+const dispatchAssociationSchema = z.union([
+    z.object({ kind: z.literal("none") }).strict(),
+    z.object({ kind: z.literal("associated"), contractId: contractIdSchema }).strict(),
+    z.object({ kind: z.literal("failed"), diagnostic: z.string() }).strict(),
+]);
+const createdTaskObservationSchema = z.union([
+    z.object({ kind: z.literal("present"), rows: taskRowsSchema }).strict(),
+    z.object({ kind: z.literal("failed"), diagnostic: z.string() }).strict(),
+]);
+const akumaObservationSchema = z
+    .object({
+    status: akumaStatusSchema,
+    contract: dispatchAssociationSchema,
+    createdTasks: createdTaskObservationSchema,
+})
+    .strict();
+const runLogReferenceSchema = z
+    .object({ path: z.string(), from: z.number().int().nonnegative(), to: z.number().int().nonnegative() })
+    .strict();
+const failedTellWakeSchema = z
+    .object({
+    kind: z.literal("failed"),
+    diagnostic: z.string(),
+    child: z
+        .object({ code: z.number().int().nullable(), signal: z.string().nullable(), log: runLogReferenceSchema })
+        .strict()
+        .optional(),
+})
+    .strict()
+    .transform(({ child, ...wake }) => (child === undefined ? wake : { ...wake, child }));
+const tellWakeSchema = z.union([
+    z.object({ kind: z.literal("told") }).strict(),
+    z.object({ kind: z.literal("held") }).strict(),
+    z.object({ kind: z.literal("pursuing"), bodySequence: z.number().int().nonnegative() }).strict(),
+    failedTellWakeSchema,
+]);
+const tellResultSchema = z
+    .object({
+    admission: z.object({ fact: z.literal("recorded"), tellId: nonblankTextSchema }).strict(),
+    wake: tellWakeSchema,
+})
+    .strict();
+const akumaUnobservedSchema = z.object({ id: akumaIdSchema, diagnostic: z.string() }).strict();
+const akumaKillResultItemSchema = z.object({ id: akumaIdSchema, evidence: killEvidenceSchema }).strict();
+const akumaWaitResultSchema = z
+    .object({
+    completion: z.enum(["any", "all"]),
+    observations: z.array(akumaObservationSchema),
+    unobserved: z.array(akumaUnobservedSchema),
+})
+    .strict();
+const akumaKillResultSchema = z.object({ results: z.array(akumaKillResultItemSchema) }).strict();
+const akumaTellResultSchema = z.object({ akuma: akumaIdSchema, tell: tellResultSchema }).strict();
+export function parseCreatedTaskObservation(value) {
+    return createdTaskObservationSchema.parse(value);
+}
+export function parseAkumaObservation(value) {
+    return akumaObservationSchema.parse(value);
+}
+export function isWaitResult(value) {
+    return akumaWaitResultSchema.safeParse(value).success;
+}
+export function isKillResult(value) {
+    return akumaKillResultSchema.safeParse(value).success;
+}
+export function isTellResult(value) {
+    return akumaTellResultSchema.safeParse(value).success;
+}
+export const fleetResultSchemas = {
+    wait: akumaWaitResultSchema,
+    tell: akumaTellResultSchema,
+    kill: akumaKillResultSchema,
+    killEvidence: killEvidenceSchema,
+};

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

@@ -1,64 +1,19 @@
-import { type ActivityHistory, type OutcomeRow, type AkumaStatus, type InterruptReceipt, type KillEvidence, type TellResult } from "../akuma/index.js";
-import type { ContractId } from "../core/facts/types.js";
-import type { TaskRow } from "../task/index.js";
+import { type ActivityHistory, type OutcomeRow, type AkumaStatus, type InterruptReceipt, type KillEvidence } from "../akuma/index.js";
+import { type ExecutionContext } from "../akuma/requests.js";
+import { type ErasedRequestCommand, type RequestCommand } from "../akuma/request-wire.js";
 import type { WorldRoot } from "../world.js";
 import { type AkumaAddressInput, type AkumaSetAddressInput } from "./address.js";
+import { type AkumaKillResult, type AkumaObservation, type AkumaObservationStage, type AkumaTellResult, type AkumaWaitResult, type DispatchAssociation } from "./fleet-result.js";
+export type { AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellResult, AkumaUnobserved, AkumaWaitResult, CreatedTaskObservation, DispatchAssociation, } from "./fleet-result.js";
 import { type Repo } from "./repo.js";
-export type CreatedTaskObservation = Readonly<{
-    kind: "present";
-    rows: readonly TaskRow[];
-}> | Readonly<{
-    kind: "failed";
-    diagnostic: string;
-}>;
-export type DispatchAssociation = Readonly<{
-    kind: "none";
-}> | Readonly<{
-    kind: "associated";
-    contractId: ContractId;
-}> | Readonly<{
-    kind: "failed";
-    diagnostic: string;
-}>;
-export type AkumaObservation = Readonly<{
-    status: AkumaStatus;
-    contract: DispatchAssociation;
-    createdTasks: CreatedTaskObservation;
-}>;
-export type AkumaObservationStage = (Readonly<{
-    kind: "observed";
-}> & AkumaObservation) | Readonly<{
-    kind: "unobserved";
-    diagnostic: string;
-}>;
-export type AkumaUnobserved = Readonly<{
-    id: AkumaStatus["id"];
-    diagnostic: string;
-}>;
+import { z } from "zod";
 export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
     completion?: "any" | "all";
     timeoutMs?: number;
 }>;
-export type AkumaWaitResult = Readonly<{
-    completion: "any" | "all";
-    observations: readonly AkumaObservation[];
-    unobserved: readonly AkumaUnobserved[];
-}>;
-export type AkumaKillResult = Readonly<{
-    results: readonly Readonly<{
-        id: AkumaStatus["id"];
-        evidence: KillEvidence;
-        observation: AkumaObservationStage;
-    }>[];
-}>;
 export type AkumaTellInput = AkumaAddressInput & Readonly<{
     body: string;
 }>;
-export type AkumaTellResult = Readonly<{
-    akuma: AkumaStatus["id"];
-    tell: TellResult;
-    observation: AkumaObservationStage;
-}>;
 export type { TellResult, TellWake } from "../akuma/index.js";
 export type AkumaInterruptInput = AkumaAddressInput & Readonly<{
     body: string;
@@ -126,9 +81,112 @@ type KillExecutionInput = Readonly<{
     signal?: AbortSignal;
 }>;
 export declare function executeKillAkuma(input: KillExecutionInput): Promise<AkumaKillResult>;
+declare const waitRequestSchema: z.ZodPipe<z.ZodObject<{
+    targets: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>>;
+    completion: z.ZodEnum<{
+        any: "any";
+        all: "all";
+    }>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodTransform<{
+    timeoutMs?: number;
+    targets: import("../akuma/identity.js").AkuId[];
+    completion: "any" | "all";
+    action: "akuma.wait";
+}, {
+    targets: import("../akuma/identity.js").AkuId[];
+    completion: "any" | "all";
+    timeoutMs?: number | undefined;
+}>>;
+declare const tellRequestSchema: z.ZodPipe<z.ZodObject<{
+    target: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+    body: z.ZodString;
+}, z.core.$strict>, z.ZodTransform<{
+    target: import("../akuma/identity.js").AkuId;
+    body: string;
+    action: "akuma.tell";
+}, {
+    target: import("../akuma/identity.js").AkuId;
+    body: string;
+}>>;
+declare const killRequestSchema: z.ZodPipe<z.ZodObject<{
+    targets: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>>;
+}, z.core.$strict>, z.ZodTransform<{
+    targets: import("../akuma/identity.js").AkuId[];
+    action: "akuma.kill";
+}, {
+    targets: import("../akuma/identity.js").AkuId[];
+}>>;
+declare const waitServiceSchema: z.ZodObject<{
+    action: z.ZodLiteral<"akuma.wait">;
+}, z.core.$strict>;
+declare const tellServiceSchema: z.ZodObject<{
+    action: z.ZodLiteral<"akuma.tell">;
+    target: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+    tellId: z.ZodString;
+}, z.core.$strict>;
+declare const killServiceSchema: z.ZodObject<{
+    action: z.ZodLiteral<"akuma.kill">;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
+        evidence: z.ZodEnum<{
+            unavailable: "unavailable";
+            killed: "killed";
+            "already-killed": "already-killed";
+            "already-stopped": "already-stopped";
+            hung: "hung";
+            untidy: "untidy";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type FleetRequest = (Omit<z.infer<typeof waitRequestSchema>, "targets"> & Readonly<{
+    targets: readonly AkumaStatus["id"][];
+}>) | z.infer<typeof tellRequestSchema> | (Omit<z.infer<typeof killRequestSchema>, "targets"> & Readonly<{
+    targets: readonly AkumaStatus["id"][];
+}>);
+type FleetService = z.infer<typeof waitServiceSchema> | z.infer<typeof tellServiceSchema> | (Omit<z.infer<typeof killServiceSchema>, "results"> & Readonly<{
+    results: readonly Readonly<{
+        id: AkumaStatus["id"];
+        evidence: KillEvidence;
+    }>[];
+}>);
+export type FleetRequestPort = Readonly<{
+    wait(input: Readonly<{
+        targets: readonly AkumaStatus["id"][];
+        completion: "any" | "all";
+        timeoutMs?: number;
+        signal: AbortSignal;
+    }>): Promise<AkumaWaitResult>;
+    tell(input: Readonly<{
+        target: AkumaStatus["id"];
+        body: string;
+        tellId: string;
+        recordedAt: string;
+        signal: AbortSignal;
+    }>): Promise<AkumaTellResult>;
+    kill(input: Readonly<{
+        targets: readonly AkumaStatus["id"][];
+        signal: AbortSignal;
+    }>): Promise<AkumaKillResult | Readonly<{
+        result: unknown;
+        service: readonly Readonly<{
+            id: AkumaStatus["id"];
+            evidence: KillEvidence;
+        }>[];
+    }>>;
+}>;
+type FleetExecutionContext = Readonly<{
+    id: string;
+    admittedAt: string;
+    signal: AbortSignal;
+    upstream: FleetRequestPort;
+}>;
+/** Fleet owns its Body Request payload, live result, and durable service codecs. */
+export declare function fleetRequestCommand(action: FleetRequest["action"]): RequestCommand<FleetRequest, unknown, FleetService, FleetService, FleetExecutionContext>;
+export declare function fleetRequestCommands(): Readonly<Record<"akuma.wait" | "akuma.tell" | "akuma.kill", ErasedRequestCommand>>;
 export declare function statusAkuma(input: AkumaAddressInput): Promise<AkumaObservation>;
-export declare function waitAkuma(input: AkumaWaitInput): Promise<AkumaWaitResult>;
-export declare function killAkuma(input: AkumaSetAddressInput): Promise<AkumaKillResult>;
-export declare function tellAkuma(input: AkumaTellInput): Promise<AkumaTellResult>;
+export declare function waitAkuma(input: AkumaWaitInput, execution?: ExecutionContext): Promise<AkumaWaitResult>;
+export declare function killAkuma(input: AkumaSetAddressInput, execution?: ExecutionContext): Promise<AkumaKillResult>;
+export declare function tellAkuma(input: AkumaTellInput, execution?: ExecutionContext): Promise<AkumaTellResult>;
 export declare function interruptAkuma(input: AkumaInterruptInput): Promise<AkumaInterruptResult>;
 export declare function historyAkuma(input: AkumaHistoryInput): Promise<AkumaHistoryResult>;

package/build/src/library/fleet.js

@@ -1,12 +1,16 @@
-import { Akuma, AkumaNotBornError, defaultWaitComplete, } from "../akuma/index.js";
+/* eslint-disable max-lines -- Fleet owns one coherent public operation surface. */
+import { Akuma, AkumaNotBornError, akumaIdSchema, defaultWaitComplete, } from "../akuma/index.js";
 import { readBudgetedStatus, tellAkumaWithId } from "../akuma/akuma.js";
-import { injectedBodyRequests, requestBodyKill, requestBodyTell, requestBodyWait, } from "../akuma/requests.js";
+import { executionChannel, localExecutionContext, requestBodyCommand, } from "../akuma/requests.js";
+import { eraseRequestCommand } from "../akuma/request-wire.js";
 import { readDispatch } from "../dispatch/index.js";
 import { observeTaskBoard } from "../task/operations.js";
 import { addressAkuma, addressAkumaSet } from "./address.js";
 import { requireInput } from "./input.js";
+import { isKillResult, isTellResult, isWaitResult, fleetResultSchemas, parseAkumaObservation, parseCreatedTaskObservation, } from "./fleet-result.js";
 import { scopeForRepo } from "./repo.js";
 import { parsePublicHistoryId } from "../akuma/identity.js";
+import { z } from "zod";
 function source(path) {
     return Akuma.of(path);
 }
@@ -37,14 +41,17 @@ async function createdTasksFor(path, statuses) {
         const failed = { kind: "failed", diagnostic: createdTaskDiagnostic(error) };
         return statuses.map(() => failed);
     }
-    return statuses.map((status) => ({ kind: "present", rows: board.selectCreatedBy(status.id) }));
+    return statuses.map((status) => parseCreatedTaskObservation({ kind: "present", rows: board.selectCreatedBy(status.id) }));
 }
 async function observeAkuma(status, path, repo) {
     return (await observeAkumaSet([status], path, repo))[0];
 }
-async function observeAkumaStage(path, id, repo) {
+async function observeAkumaStage(path, id, repo, admittedTellId) {
     try {
-        const observed = await readBudgetedStatus(path, id, { aperture: "receipt" });
+        const observed = await readBudgetedStatus(path, id, {
+            aperture: "receipt",
+            ...(admittedTellId === undefined ? {} : { admittedTellId }),
+        });
         return { kind: "observed", ...(await observeAkuma(observed.status, path, repo)) };
     }
     catch (error) {
@@ -55,7 +62,7 @@ async function observeAkumaStage(path, id, repo) {
 }
 async function observeAkumaSet(statuses, path, repo) {
     const created = await createdTasksFor(path, statuses);
-    return await Promise.all(statuses.map(async (status, index) => ({
+    return await Promise.all(statuses.map(async (status, index) => parseAkumaObservation({
         status,
         contract: await dispatchAssociation(repo, status.id),
         createdTasks: created[index],
@@ -124,11 +131,11 @@ export async function executeWaitAkuma(input) {
         const completed = round.statuses.length > 0 &&
             (input.completion === "any" ? settled.some(Boolean) : round.unobserved.length === 0 && settled.every(Boolean));
         if (completed || (deadline !== undefined && performance.now() >= deadline)) {
-            return {
+            return fleetResultSchemas.wait.parse({
                 completion: input.completion,
                 observations: await observeAkumaSet(round.statuses, input.path, input.repo),
                 unobserved: round.unobserved,
-            };
+            });
         }
         await delay(deadline === undefined ? POLL_MS : Math.min(POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
     }
@@ -146,31 +153,177 @@ export async function executeTellAkuma(input) {
             ...(input.recordedAt === undefined ? {} : { recordedAt: input.recordedAt }),
         });
     input.signal?.throwIfAborted();
-    return {
+    return fleetResultSchemas.tell.parse({
         akuma: input.id,
         tell,
-        observation: await observeAkumaStage(input.path, input.id, input.repo),
-    };
+    });
 }
 export async function executeKillAkuma(input) {
     input.signal?.throwIfAborted();
     const handles = input.ids.map((id) => source(input.path).of({ id }));
     const evidence = await Promise.all(handles.map(async (handle) => await handle.kill()));
     input.signal?.throwIfAborted();
+    return fleetResultSchemas.kill.parse({
+        results: input.ids.map((id, index) => ({ id, evidence: evidence[index] })),
+    });
+}
+function forwardedFleetCommandResult(response, action) {
+    if (response.kind === "returned") {
+        if (action === "akuma.wait" && isWaitResult(response.result))
+            return response.result;
+        if (action === "akuma.tell" && isTellResult(response.result))
+            return response.result;
+        if (action === "akuma.kill" && isKillResult(response.result))
+            return response.result;
+        throw new Error(`transport integrity: request Fleet ${action} returned an invalid live result`);
+    }
+    throw new Error("Akuma body request terminal Fleet reference cannot reproduce an expired live result");
+}
+const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
+const fleetTargetsSchema = z
+    .array(akumaIdSchema)
+    .min(1)
+    .superRefine((ids, context) => {
+    if (ids.some((id, index) => index > 0 && ids[index - 1] >= id))
+        context.addIssue({ code: "custom", message: "expected a strictly ordered target set" });
+});
+const waitRequestSchema = z
+    .object({
+    targets: fleetTargetsSchema,
+    completion: z.enum(["any", "all"]),
+    timeoutMs: z.number().int().nonnegative().optional(),
+})
+    .strict()
+    .transform(({ timeoutMs, ...request }) => ({
+    action: "akuma.wait",
+    ...request,
+    ...(timeoutMs === undefined ? {} : { timeoutMs }),
+}));
+const tellRequestSchema = z
+    .object({ target: akumaIdSchema, body: z.string() })
+    .strict()
+    .transform((request) => ({ action: "akuma.tell", ...request }));
+const killRequestSchema = z
+    .object({ targets: fleetTargetsSchema })
+    .strict()
+    .transform((request) => ({ action: "akuma.kill", ...request }));
+const waitServiceSchema = z.object({ action: z.literal("akuma.wait") }).strict();
+const tellServiceSchema = z
+    .object({ action: z.literal("akuma.tell"), target: akumaIdSchema, tellId: nonblankTextSchema })
+    .strict();
+const killServiceSchema = z
+    .object({
+    action: z.literal("akuma.kill"),
+    results: z.array(z.object({ id: akumaIdSchema, evidence: fleetResultSchemas.killEvidence }).strict()),
+})
+    .strict();
+function decodeFleetExecutionContext(value) {
+    const context = fleetPayload(value);
+    if (context === null ||
+        typeof context.id !== "string" ||
+        context.id.trim() === "" ||
+        typeof context.admittedAt !== "string" ||
+        !isAbortSignal(context.signal) ||
+        !isFleetRequestPort(context.upstream))
+        throw new Error("invalid Fleet execution context");
+    return {
+        id: context.id,
+        admittedAt: context.admittedAt,
+        signal: context.signal,
+        upstream: context.upstream,
+    };
+}
+function isAbortSignal(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        typeof value.throwIfAborted === "function");
+}
+function isFleetRequestPort(value) {
+    const port = fleetPayload(value);
+    return (port !== null &&
+        typeof port.wait === "function" &&
+        typeof port.tell === "function" &&
+        typeof port.kill === "function");
+}
+function fleetPayload(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function decodeFleetRequest(action, value) {
+    const schema = action === "akuma.wait" ? waitRequestSchema : action === "akuma.tell" ? tellRequestSchema : 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 parsed = schema.safeParse(value);
+    if (!parsed.success)
+        throw new Error("malformed stored Fleet service evidence");
+    return parsed.data;
+}
+/** Fleet owns its Body Request payload, live result, and durable service codecs. */
+export function fleetRequestCommand(action) {
     return {
-        results: await Promise.all(input.ids.map(async (id, index) => ({
-            id,
-            evidence: evidence[index],
-            observation: await observeAkumaStage(input.path, id, input.repo),
-        }))),
+        action,
+        encodeRequest: (request) => {
+            const { action: _action, ...payload } = request;
+            return payload;
+        },
+        decodeRequest: (payload) => decodeFleetRequest(action, payload),
+        encodeResult: (result) => result,
+        decodeResult: (result) => {
+            const schema = action === "akuma.wait"
+                ? fleetResultSchemas.wait
+                : action === "akuma.tell"
+                    ? fleetResultSchemas.tell
+                    : fleetResultSchemas.kill;
+            const parsed = schema.safeParse(result);
+            if (!parsed.success)
+                throw new Error(`Akuma body request returned an invalid live result for ${action}`);
+            return parsed.data;
+        },
+        encodeService: (service) => decodeFleetService(action, service),
+        decodeService: (service) => decodeFleetService(action, service),
+        projectService: (service) => decodeFleetService(action, service),
+        decodeReference: (reference) => decodeFleetService(action, reference),
+        isPermitted: (allowed) => action === "akuma.wait" || allowed.includes(action),
+        decodeExecutionContext: decodeFleetExecutionContext,
+        execute: async (request, context) => {
+            if (request.action === "akuma.wait") {
+                return {
+                    result: await context.upstream.wait({ ...request, signal: context.signal }),
+                    service: { action: request.action },
+                };
+            }
+            if (request.action === "akuma.tell") {
+                return {
+                    result: await context.upstream.tell({
+                        target: request.target,
+                        body: request.body,
+                        tellId: context.id,
+                        recordedAt: context.admittedAt,
+                        signal: context.signal,
+                    }),
+                    service: { action: request.action, target: request.target, tellId: context.id },
+                };
+            }
+            const result = await context.upstream.kill({ targets: request.targets, signal: context.signal });
+            if ("result" in result)
+                return { result: result.result, service: { action: request.action, results: result.service } };
+            return {
+                result,
+                service: { action: request.action, results: result.results.map(({ id, evidence }) => ({ id, evidence })) },
+            };
+        },
     };
 }
-function upstreamResult(outcome) {
-    if (outcome.kind === "returned")
-        return outcome.result;
-    if (outcome.failure.kind === "akuma-not-born")
-        throw new AkumaNotBornError(outcome.failure.id);
-    throw new Error(outcome.failure.diagnostic);
+export function fleetRequestCommands() {
+    return {
+        "akuma.wait": eraseRequestCommand(fleetRequestCommand("akuma.wait")),
+        "akuma.tell": eraseRequestCommand(fleetRequestCommand("akuma.tell")),
+        "akuma.kill": eraseRequestCommand(fleetRequestCommand("akuma.kill")),
+    };
 }
 function needsDispatchAttach(association) {
     return association.kind === "none";
@@ -180,34 +333,13 @@ async function attachObservationContract(repo, observation) {
         return observation;
     return { ...observation, contract: await dispatchAssociation(repo, observation.status.id) };
 }
-async function attachObservationStage(repo, observation) {
-    if (repo === undefined || observation.kind !== "observed")
-        return observation;
-    return { ...observation, ...(await attachObservationContract(repo, observation)) };
-}
 async function attachWaitContracts(repo, result) {
-    return repo === undefined
-        ? result
-        : {
-            ...result,
-            observations: await Promise.all(result.observations.map((observation) => attachObservationContract(repo, observation))),
-        };
-}
-async function attachTellContract(repo, result) {
-    return repo === undefined
-        ? result
-        : { ...result, observation: await attachObservationStage(repo, result.observation) };
-}
-async function attachKillContracts(repo, result) {
-    return repo === undefined
-        ? result
-        : {
-            ...result,
-            results: await Promise.all(result.results.map(async (entry) => ({
-                ...entry,
-                observation: await attachObservationStage(repo, entry.observation),
-            }))),
-        };
+    if (repo === undefined)
+        return result;
+    return fleetResultSchemas.wait.parse({
+        ...result,
+        observations: await Promise.all(result.observations.map((observation) => attachObservationContract(repo, observation))),
+    });
 }
 function directAddress(values) {
     return {
@@ -227,7 +359,7 @@ export async function statusAkuma(input) {
     const addressed = await addressAkuma(input);
     return await observeAkuma(await source(addressed.path).of({ id: addressed.id }).status(), addressed.path, input.repo);
 }
-export async function waitAkuma(input) {
+export async function waitAkuma(input, execution = localExecutionContext()) {
     const values = requireInput(input, "Keiyaku.wait input");
     for (const key of Object.keys(values)) {
         if (!["path", "akuma", "repo", "completion", "timeoutMs"].includes(key)) {
@@ -244,15 +376,19 @@ export async function waitAkuma(input) {
     }
     const selected = completion ?? "all";
     const timeoutMs = timeout(values.timeoutMs);
-    const requests = injectedBodyRequests();
-    if (requests !== null) {
-        const outcome = await requestBodyWait({
-            directory: requests,
-            targets: addressed.ids,
-            completion: selected,
-            ...(timeoutMs === undefined ? {} : { timeoutMs }),
+    const channel = executionChannel(execution);
+    if (channel.kind === "body-request") {
+        const response = await requestBodyCommand({
+            directory: channel.directory,
+            command: fleetRequestCommand("akuma.wait"),
+            value: {
+                action: "akuma.wait",
+                targets: addressed.ids,
+                completion: selected,
+                ...(timeoutMs === undefined ? {} : { timeoutMs }),
+            },
         });
-        return await attachWaitContracts(values.repo, upstreamResult(outcome));
+        return await attachWaitContracts(values.repo, forwardedFleetCommandResult(response, "akuma.wait"));
     }
     return await executeWaitAkuma({
         path: addressed.path,
@@ -262,12 +398,16 @@ export async function waitAkuma(input) {
         ...(values.repo === undefined ? {} : { repo: values.repo }),
     });
 }
-export async function killAkuma(input) {
+export async function killAkuma(input, execution = localExecutionContext()) {
     const addressed = await addressAkumaSet(input);
-    const requests = injectedBodyRequests();
-    if (requests !== null) {
-        const outcome = await requestBodyKill({ directory: requests, targets: addressed.ids });
-        return await attachKillContracts(input.repo, upstreamResult(outcome));
+    const channel = executionChannel(execution);
+    if (channel.kind === "body-request") {
+        const response = await requestBodyCommand({
+            directory: channel.directory,
+            command: fleetRequestCommand("akuma.kill"),
+            value: { action: "akuma.kill", targets: addressed.ids },
+        });
+        return forwardedFleetCommandResult(response, "akuma.kill");
     }
     return await executeKillAkuma({
         path: addressed.path,
@@ -275,7 +415,7 @@ export async function killAkuma(input) {
         ...(input.repo === undefined ? {} : { repo: input.repo }),
     });
 }
-export async function tellAkuma(input) {
+export async function tellAkuma(input, execution = localExecutionContext()) {
     const values = requireInput(input, "Keiyaku.tell input");
     for (const key of Object.keys(values)) {
         if (!["path", "akuma", "body", "repo"].includes(key)) {
@@ -285,14 +425,14 @@ export async function tellAkuma(input) {
     if (typeof values.body !== "string")
         throw new TypeError("body must be a string");
     const addressed = await addressAkuma(directAddress(values));
-    const requests = injectedBodyRequests();
-    if (requests !== null) {
-        const outcome = await requestBodyTell({
-            directory: requests,
-            target: addressed.id,
-            body: values.body,
+    const channel = executionChannel(execution);
+    if (channel.kind === "body-request") {
+        const response = await requestBodyCommand({
+            directory: channel.directory,
+            command: fleetRequestCommand("akuma.tell"),
+            value: { action: "akuma.tell", target: addressed.id, body: values.body },
         });
-        return await attachTellContract(values.repo, upstreamResult(outcome));
+        return forwardedFleetCommandResult(response, "akuma.tell");
     }
     return await executeTellAkuma({
         path: addressed.path,

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

@@ -7,6 +7,8 @@ export declare function actorOption(actor: unknown): Readonly<{
 }>;
 export declare function requireMarkdown(value: unknown, label?: string): string;
 export declare function requireInput(value: unknown, label: string): Record<string, unknown>;
+/** Shared public-input failure path for operation owners. */
+export declare function invalidInput(message: string): never;
 export declare function taskOption(value: unknown): TaskId | undefined;
 export declare function optionalNonblank(value: unknown, label: string): string | undefined;
 export declare function optionalBoolean(value: unknown, label: string): boolean | undefined;