@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/akuma/{fleet-observation.d.ts → selection-observation.d.ts}

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { type AkumaStatus } from "./akuma.js";
 declare const akumaObservationSchema: z.ZodObject<{
     status: z.ZodObject<{
         id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
@@ -192,7 +193,6 @@ declare const akumaObservationSchema: z.ZodObject<{
                     sequence: z.ZodNumber;
                     turnSequence: z.ZodNumber;
                     at: z.ZodString;
-                    completedAt: z.ZodOptional<z.ZodString>;
                     durationMs: z.ZodOptional<z.ZodNumber>;
                     name: z.ZodString;
                     call: z.ZodUnion<readonly [z.ZodObject<{
@@ -351,7 +351,6 @@ declare const akumaObservationSchema: z.ZodObject<{
                     sequence: z.ZodNumber;
                     turnSequence: z.ZodNumber;
                     at: z.ZodString;
-                    completedAt: z.ZodOptional<z.ZodString>;
                     durationMs: z.ZodOptional<z.ZodNumber>;
                     name: z.ZodString;
                     call: z.ZodUnion<readonly [z.ZodObject<{
@@ -462,10 +461,10 @@ declare const akumaWaitResultSchema: z.ZodObject<{
         all: "all";
     }>;
     reason: z.ZodEnum<{
-        deadline: "deadline";
         completed: "completed";
+        deadline: "deadline";
     }>;
-    observations: z.ZodArray<z.ZodObject<{
+    observations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         status: z.ZodObject<{
             id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
             life: z.ZodEnum<{
@@ -658,7 +657,6 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                         sequence: z.ZodNumber;
                         turnSequence: z.ZodNumber;
                         at: z.ZodString;
-                        completedAt: z.ZodOptional<z.ZodString>;
                         durationMs: z.ZodOptional<z.ZodNumber>;
                         name: z.ZodString;
                         call: z.ZodUnion<readonly [z.ZodObject<{
@@ -817,7 +815,6 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                         sequence: z.ZodNumber;
                         turnSequence: z.ZodNumber;
                         at: z.ZodString;
-                        completedAt: z.ZodOptional<z.ZodString>;
                         durationMs: z.ZodOptional<z.ZodNumber>;
                         name: z.ZodString;
                         call: z.ZodUnion<readonly [z.ZodObject<{
@@ -917,24 +914,24 @@ declare const akumaWaitResultSchema: z.ZodObject<{
             kind: z.ZodLiteral<"failed">;
             diagnostic: z.ZodString;
         }, z.core.$strict>]>;
-    }, z.core.$strict>>;
-    unobserved: z.ZodArray<z.ZodObject<{
+    }, z.core.$strict>>>;
+    unobserved: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
         diagnostic: z.ZodString;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 declare const akumaKillResultSchema: z.ZodObject<{
-    results: z.ZodArray<z.ZodObject<{
+    results: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
         evidence: z.ZodEnum<{
-            unavailable: "unavailable";
             killed: "killed";
+            hung: "hung";
+            unavailable: "unavailable";
             "already-killed": "already-killed";
             "already-stopped": "already-stopped";
-            hung: "hung";
             untidy: "untidy";
         }>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 declare const akumaTellResultSchema: z.ZodObject<{
     akuma: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
@@ -1025,7 +1022,7 @@ declare const akumaTellResultSchema: z.ZodObject<{
         }>>]>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-declare const tellWaitObservationSchema: z.ZodUnion<readonly [z.ZodObject<{
+declare const askObservationSchema: z.ZodUnion<readonly [z.ZodObject<{
     reason: z.ZodLiteral<"answered">;
     answer: z.ZodUnknown;
 }, z.core.$strict>, z.ZodObject<{
@@ -1040,7 +1037,7 @@ declare const tellWaitObservationSchema: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strict>, z.ZodObject<{
     reason: z.ZodLiteral<"deadline">;
 }, z.core.$strict>]>;
-declare const akumaTellWaitResultSchema: z.ZodObject<{
+declare const akumaAskResultSchema: z.ZodObject<{
     akuma: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
     tell: z.ZodObject<{
         admission: z.ZodObject<{
@@ -1156,24 +1153,30 @@ export type AkumaUnobserved = z.infer<typeof akumaUnobservedSchema>;
 export type AkumaWaitResult = z.infer<typeof akumaWaitResultSchema>;
 export type AkumaKillResult = z.infer<typeof akumaKillResultSchema>;
 export type AkumaTellResult = z.infer<typeof akumaTellResultSchema>;
-export type AkumaTellWaitObservation = z.infer<typeof tellWaitObservationSchema>;
-export type AkumaTellWaitResult = z.infer<typeof akumaTellWaitResultSchema>;
-export declare function parseAkumaObservation(value: unknown): AkumaObservation;
-export declare function isWaitResult(value: unknown): value is AkumaWaitResult;
-export declare function isKillResult(value: unknown): value is AkumaKillResult;
+export type AkumaAskObservation<T = unknown> = Exclude<z.infer<typeof askObservationSchema>, {
+    reason: "answered";
+}> | Readonly<{
+    reason: "answered";
+    answer: T;
+}>;
+export type AkumaAskResult<T = unknown> = Omit<z.infer<typeof akumaAskResultSchema>, "observation"> & Readonly<{
+    observation: AkumaAskObservation<T>;
+}>;
+/** Compose one native status into the canonical observation its crossing transports. */
+export declare function akumaObservationOf(status: AkumaStatus): AkumaObservation;
 export declare function isTellResult(value: unknown): value is AkumaTellResult;
-export declare function isTellWaitResult(value: unknown): value is AkumaTellWaitResult;
-export declare const fleetResultSchemas: {
+export declare function isAskResult(value: unknown): value is AkumaAskResult;
+export declare const selectionResultSchemas: {
     wait: z.ZodObject<{
         mode: z.ZodEnum<{
             any: "any";
             all: "all";
         }>;
         reason: z.ZodEnum<{
-            deadline: "deadline";
             completed: "completed";
+            deadline: "deadline";
         }>;
-        observations: z.ZodArray<z.ZodObject<{
+        observations: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             status: z.ZodObject<{
                 id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
                 life: z.ZodEnum<{
@@ -1366,7 +1369,6 @@ export declare const fleetResultSchemas: {
                             sequence: z.ZodNumber;
                             turnSequence: z.ZodNumber;
                             at: z.ZodString;
-                            completedAt: z.ZodOptional<z.ZodString>;
                             durationMs: z.ZodOptional<z.ZodNumber>;
                             name: z.ZodString;
                             call: z.ZodUnion<readonly [z.ZodObject<{
@@ -1525,7 +1527,6 @@ export declare const fleetResultSchemas: {
                             sequence: z.ZodNumber;
                             turnSequence: z.ZodNumber;
                             at: z.ZodString;
-                            completedAt: z.ZodOptional<z.ZodString>;
                             durationMs: z.ZodOptional<z.ZodNumber>;
                             name: z.ZodString;
                             call: z.ZodUnion<readonly [z.ZodObject<{
@@ -1625,11 +1626,11 @@ export declare const fleetResultSchemas: {
                 kind: z.ZodLiteral<"failed">;
                 diagnostic: z.ZodString;
             }, z.core.$strict>]>;
-        }, z.core.$strict>>;
-        unobserved: z.ZodArray<z.ZodObject<{
+        }, z.core.$strict>>>;
+        unobserved: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
             diagnostic: z.ZodString;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>;
     tell: z.ZodObject<{
         akuma: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
@@ -1720,7 +1721,7 @@ export declare const fleetResultSchemas: {
             }>>]>;
         }, z.core.$strict>;
     }, z.core.$strict>;
-    tellWait: z.ZodObject<{
+    ask: z.ZodObject<{
         akuma: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
         tell: z.ZodObject<{
             admission: z.ZodObject<{
@@ -1826,24 +1827,24 @@ export declare const fleetResultSchemas: {
         completedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strict>;
     kill: z.ZodObject<{
-        results: z.ZodArray<z.ZodObject<{
+        results: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
             evidence: z.ZodEnum<{
-                unavailable: "unavailable";
                 killed: "killed";
+                hung: "hung";
+                unavailable: "unavailable";
                 "already-killed": "already-killed";
                 "already-stopped": "already-stopped";
-                hung: "hung";
                 untidy: "untidy";
             }>;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>;
     killEvidence: z.ZodEnum<{
-        unavailable: "unavailable";
         killed: "killed";
+        hung: "hung";
+        unavailable: "unavailable";
         "already-killed": "already-killed";
         "already-stopped": "already-stopped";
-        hung: "hung";
         untidy: "untidy";
     }>;
 };

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

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { EMPTY_CREATED_TASK_OBSERVATION, createdTaskObservationSchema } from "../task/created-observation.js";
+import { akumaStatusSchema } from "./akuma.js";
+import { tellResultSchema } from "./call-initial-tell.js";
+import { NO_DISPATCH_ASSOCIATION, dispatchAssociationSchema } from "./dispatch-association.js";
+import { akumaIdSchema } from "./identity.js";
+const killEvidenceSchema = z.enum([
+    "killed",
+    "already-killed",
+    "already-stopped",
+    "hung",
+    "untidy",
+    "unavailable",
+]);
+const akumaObservationSchema = z
+    .object({
+    status: akumaStatusSchema,
+    contract: dispatchAssociationSchema,
+    createdTasks: createdTaskObservationSchema,
+})
+    .strict();
+const akumaUnobservedSchema = z.object({ id: akumaIdSchema, diagnostic: z.string() }).strict();
+const akumaKillResultItemSchema = z.object({ id: akumaIdSchema, evidence: killEvidenceSchema }).strict();
+const akumaWaitResultSchema = z
+    .object({
+    mode: z.enum(["any", "all"]),
+    reason: z.enum(["completed", "deadline"]),
+    observations: z.array(akumaObservationSchema).readonly(),
+    unobserved: z.array(akumaUnobservedSchema).readonly(),
+})
+    .strict();
+const akumaKillResultSchema = z.object({ results: z.array(akumaKillResultItemSchema).readonly() }).strict();
+const akumaTellResultSchema = z.object({ akuma: akumaIdSchema, tell: tellResultSchema }).strict();
+const askObservationSchema = z.union([
+    z.object({ reason: z.literal("answered"), answer: z.unknown() }).strict(),
+    z.object({ reason: z.literal("failed"), diagnostic: z.string() }).strict(),
+    z.object({ reason: z.literal("invalid-output"), diagnostic: z.string(), answer: z.string() }).strict(),
+    z.object({ reason: z.literal("unanswered") }).strict(),
+    z.object({ reason: z.literal("deadline") }).strict(),
+]);
+const akumaAskResultSchema = z
+    .object({
+    akuma: akumaIdSchema,
+    tell: tellResultSchema,
+    observation: askObservationSchema,
+    completedAt: z.string().datetime({ offset: true }).nullable().optional(),
+})
+    .strict();
+/** Compose one native status into the canonical observation its crossing transports. */
+export function akumaObservationOf(status) {
+    return { status, contract: NO_DISPATCH_ASSOCIATION, createdTasks: EMPTY_CREATED_TASK_OBSERVATION };
+}
+export function isTellResult(value) {
+    return akumaTellResultSchema.safeParse(value).success;
+}
+export function isAskResult(value) {
+    return akumaAskResultSchema.safeParse(value).success;
+}
+export const selectionResultSchemas = {
+    wait: akumaWaitResultSchema,
+    tell: akumaTellResultSchema,
+    ask: akumaAskResultSchema,
+    kill: akumaKillResultSchema,
+    killEvidence: killEvidenceSchema,
+};

package/build/src/akuma/{fleet-owner-port.d.ts → selection-owner-port.d.ts}

@@ -1,7 +1,7 @@
-import type { FleetRequestPort } from "./fleet-request.js";
 import type { WorldRoot } from "../world.js";
+import type { SelectionRequestPort } from "./selection-request.js";
 /**
- * The parent's Fleet owner boundary: one forwarded request arrives as complete
+ * The parent's Selection owner boundary: one forwarded request arrives as complete
  * identities the child resolved without reading a Heart, and this side answers
  * for them. It proves every target through the one addressability
  * normalization before the operation begins, so a refusal that reaches the wire
@@ -9,4 +9,4 @@ import type { WorldRoot } from "../world.js";
  * unaddressable member never starts; the executor's own access to the target is
  * then the product act, never a second addressing probe.
  */
-export declare function fleetRequestPort(world: WorldRoot): FleetRequestPort;
+export declare function selectionRequestPort(world: WorldRoot): SelectionRequestPort;

package/build/src/akuma/{fleet-owner-port.js → selection-owner-port.js}

@@ -1,9 +1,9 @@
 import { requireBornAkuma } from "./akuma-probe.js";
-import { Akuma as PublicAkuma } from "./akuma-instance.js";
-import { executeKillAkuma, executeTellAkuma, executeTellWaitAkuma, executeWaitAkuma } from "./fleet-execution.js";
-import { Schema } from "./schema.js";
+import { executeAskAkuma, executeKillAkuma, executeTellAkuma } from "./akuma-selection-execution.js";
+import { executeWaitAkuma } from "./akuma-wait.js";
+import { akumaObservationOf } from "./selection-observation.js";
 /**
- * The parent's Fleet owner boundary: one forwarded request arrives as complete
+ * The parent's Selection owner boundary: one forwarded request arrives as complete
  * identities the child resolved without reading a Heart, and this side answers
  * for them. It proves every target through the one addressability
  * normalization before the operation begins, so a refusal that reaches the wire
@@ -11,7 +11,7 @@ import { Schema } from "./schema.js";
  * unaddressable member never starts; the executor's own access to the target is
  * then the product act, never a second addressing probe.
  */
-export function fleetRequestPort(world) {
+export function selectionRequestPort(world) {
     const prove = async (targets) => {
         for (const id of targets)
             await requireBornAkuma(world, id);
@@ -19,24 +19,18 @@ export function fleetRequestPort(world) {
     return {
         wait: async ({ targets, ...request }) => {
             await prove(targets);
-            return await executeWaitAkuma({ path: world, ids: targets, ...request });
+            // The lower wait owner returns association-free native evidence; the
+            // actual request crossing composes its canonical transport shape.
+            const native = await executeWaitAkuma({ path: world, ids: targets, ...request });
+            return { ...native, observations: native.observations.map(akumaObservationOf) };
         },
         tell: async ({ target, ...request }) => {
             await prove([target]);
             return await executeTellAkuma({ path: world, id: target, ...request });
         },
-        tellWait: async ({ target, ...request }) => {
+        ask: async ({ target, ...request }) => {
             await prove([target]);
-            return await executeTellWaitAkuma({ path: world, id: target, ...request });
-        },
-        tellAnswer: async ({ target, ...request }) => {
-            await prove([target]);
-            return await PublicAkuma.select(world, target).tell(request.body, {
-                schema: Schema.json(JSON.parse(request.schemaJson), (value) => value),
-                ...(request.interrupt === undefined ? {} : { interrupt: request.interrupt }),
-                ...(request.initiator === undefined ? {} : { initiator: request.initiator }),
-                signal: request.signal,
-            });
+            return await executeAskAkuma({ path: world, id: target, ...request });
         },
         kill: async ({ targets, ...request }) => {
             await prove(targets);

package/build/src/akuma/{fleet-request.d.ts → selection-request.d.ts}

@@ -1,11 +1,11 @@
+import { z } from "zod";
+import type { AkumaStatus } from "./akuma.js";
 import type { KillEvidence } from "./heart/index.js";
 import { type ErasedRequestCommand, type RequestProtocol, type ServiceRequestCommand } from "./request-wire.js";
-import type { AkumaStatus } from "./akuma.js";
-import { type AkumaKillResult, type AkumaTellResult, type AkumaTellWaitResult, type AkumaWaitResult } from "./fleet-observation.js";
-import { z } from "zod";
 import type { Schema } from "./schema.js";
+import { type AkumaAskResult, type AkumaKillResult, type AkumaTellResult, type AkumaWaitResult } from "./selection-observation.js";
 declare const waitRequestSchema: z.ZodPipe<z.ZodObject<{
-    targets: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>>;
+    targets: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>>>;
     completion: z.ZodEnum<{
         any: "any";
         all: "all";
@@ -13,11 +13,11 @@ declare const waitRequestSchema: z.ZodPipe<z.ZodObject<{
     timeoutMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>, z.ZodTransform<{
     timeoutMs?: number;
-    targets: import("./identity.js").AkuId[];
+    targets: readonly import("./identity.js").AkuId[];
     completion: "any" | "all";
     action: "akuma.wait";
 }, {
-    targets: import("./identity.js").AkuId[];
+    targets: readonly import("./identity.js").AkuId[];
     completion: "any" | "all";
     timeoutMs?: number | undefined;
 }>>;
@@ -25,66 +25,49 @@ declare const tellRequestSchema: z.ZodPipe<z.ZodObject<{
     target: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
     body: z.ZodString;
     initiator: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>, z.ZodTransform<{
-    target: import("./identity.js").AkuId;
-    body: string;
-    initiator?: string | undefined;
-    action: "akuma.tell";
-}, {
-    target: import("./identity.js").AkuId;
-    body: string;
-    initiator?: string | undefined;
-}>>;
-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;
-    initiator: z.ZodOptional<z.ZodString>;
     interrupt: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>, z.ZodTransform<{
     target: import("./identity.js").AkuId;
     body: string;
-    schemaJson: string;
     initiator?: string | undefined;
     interrupt?: boolean | undefined;
-    action: "akuma.tell-answer";
+    action: "akuma.tell";
 }, {
     target: import("./identity.js").AkuId;
     body: string;
-    schemaJson: string;
     initiator?: string | undefined;
     interrupt?: boolean | undefined;
 }>>;
-declare const tellWaitRequestSchema: z.ZodPipe<z.ZodObject<{
+declare const askRequestSchema: z.ZodPipe<z.ZodObject<{
     target: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
     body: z.ZodString;
-    timeoutMs: z.ZodNumber;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
     schemaJson: z.ZodOptional<z.ZodString>;
     initiator: z.ZodOptional<z.ZodString>;
     interrupt: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>, z.ZodTransform<{
     target: import("./identity.js").AkuId;
     body: string;
-    timeoutMs: number;
+    timeoutMs?: number | undefined;
     schemaJson?: string | undefined;
     initiator?: string | undefined;
     interrupt?: boolean | undefined;
-    action: "akuma.tell-wait";
+    action: "akuma.ask";
 }, {
     target: import("./identity.js").AkuId;
     body: string;
-    timeoutMs: number;
+    timeoutMs?: number | undefined;
     schemaJson?: string | undefined;
     initiator?: string | undefined;
     interrupt?: boolean | undefined;
 }>>;
 declare const killRequestSchema: z.ZodPipe<z.ZodObject<{
-    targets: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>>;
+    targets: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>>>;
 }, z.core.$strict>, z.ZodTransform<{
-    targets: import("./identity.js").AkuId[];
+    targets: readonly import("./identity.js").AkuId[];
     action: "akuma.kill";
 }, {
-    targets: import("./identity.js").AkuId[];
+    targets: readonly import("./identity.js").AkuId[];
 }>>;
 declare const waitServiceSchema: z.ZodObject<{
     action: z.ZodLiteral<"akuma.wait">;
@@ -94,39 +77,31 @@ declare const tellServiceSchema: z.ZodObject<{
     target: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
     tellId: z.ZodString;
 }, z.core.$strict>;
-declare const tellWaitServiceSchema: z.ZodObject<{
-    action: z.ZodLiteral<"akuma.tell-wait">;
+declare const askServiceSchema: z.ZodObject<{
+    action: z.ZodLiteral<"akuma.ask">;
     target: z.ZodPipe<z.ZodString, z.ZodTransform<import("./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<{
+    results: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
         evidence: z.ZodEnum<{
-            unavailable: "unavailable";
             killed: "killed";
+            hung: "hung";
+            unavailable: "unavailable";
             "already-killed": "already-killed";
             "already-stopped": "already-stopped";
-            hung: "hung";
             untidy: "untidy";
         }>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
-export declare function encodeFleetLiveFailure(error: unknown): unknown | null;
-export declare function decodeFleetLiveFailure(value: unknown): Error | null;
-export type FleetRequest = (Omit<z.infer<typeof waitRequestSchema>, "targets"> & Readonly<{
-    targets: readonly AkumaStatus["id"][];
-}>) | z.infer<typeof tellRequestSchema> | z.infer<typeof tellAnswerRequestSchema> | z.infer<typeof tellWaitRequestSchema> | (Omit<z.infer<typeof killRequestSchema>, "targets"> & Readonly<{
-    targets: readonly AkumaStatus["id"][];
-}>);
-export type FleetService = z.infer<typeof waitServiceSchema> | z.infer<typeof tellServiceSchema> | z.infer<typeof tellWaitServiceSchema> | (Omit<z.infer<typeof killServiceSchema>, "results"> & Readonly<{
-    results: readonly Readonly<{
-        id: AkumaStatus["id"];
-        evidence: KillEvidence;
-    }>[];
-}>);
-export type FleetRequestPort = Readonly<{
+export declare function encodeSelectionLiveFailure(error: unknown): unknown | null;
+export declare function decodeSelectionLiveFailure(value: unknown): Error | null;
+export type SelectionRequest = z.infer<typeof waitRequestSchema> | z.infer<typeof tellRequestSchema> | z.infer<typeof askRequestSchema> | z.infer<typeof killRequestSchema>;
+export type SelectionService = z.infer<typeof waitServiceSchema> | z.infer<typeof tellServiceSchema> | z.infer<typeof askServiceSchema> | z.infer<typeof killServiceSchema>;
+type SelectionResult = AkumaWaitResult | AkumaTellResult | AkumaAskResult | AkumaKillResult;
+export type SelectionRequestPort = Readonly<{
     wait(input: Readonly<{
         targets: readonly AkumaStatus["id"][];
         completion: "any" | "all";
@@ -139,32 +114,25 @@ export type FleetRequestPort = Readonly<{
         tellId: string;
         recordedAt: string;
         initiator?: string;
-        signal: AbortSignal;
-    }>): Promise<AkumaTellResult>;
-    tellAnswer?(input: Readonly<{
-        target: AkumaStatus["id"];
-        body: string;
-        schemaJson: string;
-        initiator?: string;
         interrupt?: boolean;
         signal: AbortSignal;
-    }>): Promise<unknown>;
-    tellWait?(input: Readonly<{
+    }>): Promise<AkumaTellResult>;
+    ask?(input: Readonly<{
         target: AkumaStatus["id"];
         body: string;
         tellId: string;
         recordedAt: string;
-        timeoutMs: number;
+        timeoutMs?: number;
         schemaJson?: string;
         initiator?: string;
         interrupt?: boolean;
         signal: AbortSignal;
-    }>): Promise<AkumaTellWaitResult>;
+    }>): Promise<AkumaAskResult>;
     kill(input: Readonly<{
         targets: readonly AkumaStatus["id"][];
         signal: AbortSignal;
     }>): Promise<AkumaKillResult | Readonly<{
-        result: unknown;
+        result: AkumaKillResult;
         service: readonly Readonly<{
             id: AkumaStatus["id"];
             evidence: KillEvidence;
@@ -172,43 +140,35 @@ 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.tell-answer" | "akuma.tell-wait" | "akuma.kill", ErasedRequestCommand>>;
-export declare function requestForwardedFleetTellAnswer(input: Readonly<{
-    directory: string;
-    target: AkumaStatus["id"];
-    body: string;
-    schema: Schema<unknown>;
-    initiator?: string;
-    interrupt?: boolean;
-    signal?: AbortSignal;
-}>): Promise<unknown>;
-export declare function requestForwardedFleetWait(input: Readonly<{
+export declare function selectionRequestProtocol<Result extends SelectionResult = SelectionResult>(action: SelectionRequest["action"]): RequestProtocol<SelectionRequest, Result, SelectionService>;
+export declare function selectionRequestCommand(action: SelectionRequest["action"], port: SelectionRequestPort): ServiceRequestCommand<SelectionRequest, SelectionResult, SelectionService, SelectionService>;
+export declare function selectionRequestCommands(port: SelectionRequestPort): Readonly<Record<"akuma.wait" | "akuma.tell" | "akuma.ask" | "akuma.kill", ErasedRequestCommand>>;
+export declare function requestForwardedSelectionWait(input: Readonly<{
     directory: string;
     targets: readonly AkumaStatus["id"][];
     completion: "any" | "all";
     timeoutMs?: number;
     signal?: AbortSignal;
 }>): Promise<AkumaWaitResult>;
-export declare function requestForwardedFleetTell(input: Readonly<{
+export declare function requestForwardedSelectionTell(input: Readonly<{
     directory: string;
     target: AkumaStatus["id"];
     body: string;
     initiator?: string;
+    interrupt?: boolean;
     signal?: AbortSignal;
 }>): Promise<AkumaTellResult>;
-export declare function requestForwardedFleetTellWait(input: Readonly<{
+export declare function requestForwardedSelectionAsk(input: Readonly<{
     directory: string;
     target: AkumaStatus["id"];
     body: string;
-    timeoutMs: number;
+    timeoutMs?: number;
     schema?: Schema<unknown>;
     initiator?: string;
     interrupt?: boolean;
     signal?: AbortSignal;
-}>): Promise<AkumaTellWaitResult>;
-export declare function requestForwardedFleetKill(input: Readonly<{
+}>): Promise<AkumaAskResult>;
+export declare function requestForwardedSelectionKill(input: Readonly<{
     directory: string;
     targets: readonly AkumaStatus["id"][];
     signal?: AbortSignal;