@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,22 +1,23 @@
 /** @architectureCompositionRoot */
-import { appendFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
-import { moveAlias } from "../alias/index.js";
-import { createAkumaProduct } from "../akuma/akuma-product.js";
-import { pathsForAkuId } from "../akuma/identity.js";
+import { appendFile } from "node:fs/promises";
+import { admitAkumaCall } from "../akuma/akuma-call.js";
+import { AkumaOwner } from "../akuma/akuma-owner.js";
+import { decodeAskObservation, observeAdmittedAskAkuma } from "../akuma/akuma-selection-execution.js";
+import { canonicalBirthCwd } from "../akuma/call-input.js";
 import { readSoul } from "../akuma/heart/index.js";
+import { pathsForAkuId } from "../akuma/identity.js";
+import { localExecutionContext } from "../akuma/requests.js";
+import { schemaJsonText } from "../akuma/schema.js";
+import { moveAlias } from "../alias/index.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
 import { emitCalledPluginSignal } from "../plugin/akuma-signals.js";
 import { World } from "../world.js";
-import { schemaJsonText } from "../akuma/schema.js";
-import { decodeTellWaitObservation, observeAdmittedTellWaitAkuma, } from "../akuma/fleet-execution.js";
-import { localExecutionContext } from "../akuma/requests.js";
-import { canonicalBirthCwd } from "../akuma/call-input.js";
-import { requireInput } from "./input.js";
 import { addressAkuma } from "./address.js";
-import { seatForKeiyaku } from "./contract-handle.js";
+import { requireInput } from "./input.js";
+import { seatForKeiyaku } from "./keiyaku.js";
 import { scopeForRepo } from "./repo.js";
 function nonblank(value, label) {
     if (typeof value !== "string" || value.trim().length === 0) {
@@ -44,13 +45,6 @@ function homeOption(value) {
         return undefined;
     return nonblank(value, "home");
 }
-function akumaWorld(path, home, settings, execution) {
-    return createAkumaProduct(path, {
-        ...(home === undefined ? {} : { home }),
-        ...(settings === undefined ? {} : { settings }),
-        ...(execution === undefined ? {} : { execution }),
-    });
-}
 function onlyKeys(values, allowed, label) {
     const accepted = new Set(allowed);
     for (const key of Object.keys(values)) {
@@ -71,6 +65,15 @@ function callMode(value) {
         return "wait";
     throw new TypeError("mode must be wait or detach");
 }
+function callBody(value) {
+    return value === undefined ? undefined : text(value, "body");
+}
+function validateCallBodyOptions(body, values, mode) {
+    if (body === undefined && values.schema !== undefined)
+        throw new TypeError("schema requires body");
+    if (body === undefined && (mode === "wait" || values.timeoutMs !== undefined))
+        throw new TypeError("wait and timeoutMs require body");
+}
 function callTimeout(value, mode) {
     if (mode === "detach" && value !== undefined) {
         throw new TypeError("timeoutMs is not valid in detach mode");
@@ -97,10 +100,8 @@ function callSeat(contract) {
         throw new TypeError("contract must be a Keiyaku");
     return seat;
 }
-async function callerAkuId(path, born) {
-    if (born.kind !== "requested")
-        return undefined;
-    const soul = await readSoul(pathsForAkuId(path, born.id));
+async function requestedParent(path, id) {
+    const soul = await readSoul(pathsForAkuId(path, id));
     return soul?.origin.kind === "request" ? soul.origin.parent : undefined;
 }
 function pluginDiagnostic(error) {
@@ -115,10 +116,16 @@ async function recordPluginDiagnostic(paths, error) {
         // Plugin diagnostic loss must not change an already admitted call.
     }
 }
+/**
+ * The submitting process's optional called-plugin observation. It runs once,
+ * after the prepared executor returned its local value or the forwarded caller
+ * received its exact live output, and it never gates birth, initial Tell, or a
+ * later integration stage. A failed delivery stays a diagnostic.
+ */
 async function emitCalledSignal(input) {
     try {
-        const callerAkumaId = await callerAkuId(input.path, input.born);
-        const paths = input.born.kind === "requested" ? pathsForAkuId(input.path, input.akumaId) : input.born.allocated.paths;
+        const paths = pathsForAkuId(input.path, input.admitted.id);
+        const callerAkumaId = input.admitted.requested ? await requestedParent(input.path, input.admitted.id) : undefined;
         const reportDiagnostic = (message) => {
             void recordPluginDiagnostic(paths, message);
         };
@@ -127,7 +134,7 @@ async function emitCalledSignal(input) {
                 world: input.path,
                 ...(input.settings === undefined ? {} : { settings: input.settings }),
                 reportDiagnostic,
-                akumaId: input.akumaId,
+                akumaId: input.admitted.id,
                 ...(callerAkumaId === undefined ? {} : { callerAkumaId }),
                 ...(input.contractId === undefined ? {} : { contractId: input.contractId }),
             });
@@ -140,18 +147,6 @@ async function emitCalledSignal(input) {
         // Plugin delivery must not change an already admitted call.
     }
 }
-async function admitCall(input) {
-    const born = await input.world.admit(input.call, input.context);
-    const akuma = born.kind === "requested" ? born.id : born.allocated.id;
-    await emitCalledSignal({
-        path: input.path,
-        ...(input.settings === undefined ? {} : { settings: input.settings }),
-        born,
-        akumaId: akuma,
-        ...(input.contractId === undefined ? {} : { contractId: input.contractId }),
-    });
-    return { born, akuma };
-}
 async function dispatchStage(input) {
     try {
         const published = await publishDispatch(input);
@@ -223,10 +218,11 @@ async function parseCallInput(input) {
     onlyKeys(values, CALL_INPUT_KEYS, "Akumas.call input");
     const path = await World.prove(nonblank(values.path, "path"));
     const archetype = nonblank(values.archetype, "archetype");
-    const body = text(values.body, "body");
+    const body = callBody(values.body);
     const initiator = values.initiator === undefined ? undefined : text(values.initiator, "initiator");
     const cwd = values.cwd === undefined ? undefined : nonblank(values.cwd, "cwd");
     const mode = callMode(values.mode);
+    validateCallBodyOptions(body, values, mode);
     const timeoutMs = callTimeout(values.timeoutMs, mode);
     const signal = callSignal(values.signal);
     const home = homeOption(values.home);
@@ -236,13 +232,15 @@ async function parseCallInput(input) {
     const schema = values.schema;
     const schemaJson = schema === undefined ? undefined : schemaJsonText(schema);
     const observe = values.observe;
-    const initialTell = {
-        tellId: randomUUID(),
-        body,
-        ...(schemaJson === undefined ? {} : { schemaJson }),
-        ...(schema === undefined ? {} : { schema }),
-        ...(initiator === undefined ? {} : { initiator }),
-    };
+    const initialTell = body === undefined
+        ? undefined
+        : {
+            tellId: randomUUID(),
+            body,
+            ...(schemaJson === undefined ? {} : { schemaJson }),
+            ...(schema === undefined ? {} : { schema }),
+            ...(initiator === undefined ? {} : { initiator }),
+        };
     return {
         path,
         archetype,
@@ -255,171 +253,156 @@ async function parseCallInput(input) {
         ...(alias === undefined ? {} : { alias }),
         ...(values.allowed === undefined ? {} : { allowed: values.allowed }),
         seat,
-        initialTell,
+        ...(initialTell === undefined ? {} : { initialTell }),
         ...(observe === undefined ? {} : { observe }),
     };
 }
+function callConfiguration(input, execution) {
+    return {
+        ...(input.home === undefined ? {} : { home: input.home }),
+        ...(input.settings === undefined ? {} : { settings: input.settings }),
+        execution,
+    };
+}
 function callAdmissionInput(input, execution) {
     return {
         archetype: input.archetype,
-        initialTell: {
-            tellId: input.initialTell.tellId,
-            body: input.initialTell.body,
-            ...(input.initialTell.schemaJson === undefined ? {} : { schemaJson: input.initialTell.schemaJson }),
-            ...(input.initialTell.initiator === undefined ? {} : { initiator: input.initialTell.initiator }),
-        },
+        ...(input.initialTell === undefined
+            ? {}
+            : {
+                initialTell: {
+                    tellId: input.initialTell.tellId,
+                    body: input.initialTell.body,
+                    ...(input.initialTell.schemaJson === undefined ? {} : { schemaJson: input.initialTell.schemaJson }),
+                    ...(input.initialTell.initiator === undefined ? {} : { initiator: input.initialTell.initiator }),
+                },
+            }),
         ...(input.allowed === undefined ? {} : { allowed: input.allowed }),
         ...(execution === undefined ? {} : { cwd: execution.cwd }),
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     };
 }
-async function prepareCall(input, context) {
-    const parsed = await parseCallInput(input);
-    const execution = await resolveCallExecution(parsed.cwd === undefined ? {} : { cwd: parsed.cwd });
-    const world = akumaWorld(parsed.path, parsed.home, parsed.settings, context);
-    const { born, akuma } = await admitCall({
-        path: parsed.path,
-        world,
-        call: callAdmissionInput(parsed, execution),
-        context: execution === undefined ? {} : { cwdCanonical: true },
-        ...(parsed.settings === undefined ? {} : { settings: parsed.settings }),
-        ...(parsed.seat === undefined ? {} : { contractId: parsed.seat.id }),
-    });
-    const completedExecution = execution ?? born.execution;
-    const dispatch = parsed.seat === undefined
-        ? { kind: "none" }
-        : await dispatchStage({ repository: parsed.seat.scope, akuId: akuma, contractId: parsed.seat.id });
-    const aliasStage = await resolveAliasStage(parsed.path, parsed.alias, dispatch, akuma);
+function callResultOf(akuma, execution, dispatch, alias, initialTell) {
     return {
-        path: parsed.path,
-        born,
-        execution: completedExecution,
-        mode: parsed.mode,
-        timeoutMs: parsed.timeoutMs,
-        ...(parsed.signal === undefined ? {} : { signal: parsed.signal }),
+        kind: "called",
+        akuma,
+        execution,
         dispatch,
-        alias: aliasStage,
-        initialTell: parsed.initialTell,
-        ...(parsed.observe === undefined ? {} : { observe: parsed.observe }),
+        alias,
+        ...(initialTell?.schema === undefined ? {} : { structured: true }),
     };
 }
-async function publishCallTarget(born) {
-    const world = akumaWorld(born.path);
-    const contractId = born.dispatch.kind === "dispatched" ? born.dispatch.dispatch.contractId : undefined;
-    const handle = await world.publish(born.born, { ...(contractId === undefined ? {} : { contractId }) }, born.signal);
+function failedCall(result, tellId, error, tell) {
     return {
-        born,
-        handle,
-        result: {
-            kind: "called",
-            akuma: handle.id,
-            execution: born.execution,
-            dispatch: born.dispatch,
-            alias: born.alias,
-            ...(born.initialTell.schema === undefined ? {} : { structured: true }),
-        },
-    };
-}
-function failedCall(call, error, tell) {
-    return {
-        ...call.result,
+        ...result,
         observation: {
             kind: "failed",
-            tellId: call.born.initialTell.tellId,
+            tellId,
             ...(tell === undefined ? {} : { tell }),
             failure: integrationFailure(error),
         },
     };
 }
-async function admitCallTell(call) {
-    const { born, handle } = call;
-    if (born.born.kind === "requested")
-        return { kind: "admitted" };
-    let admitted;
-    try {
-        admitted = await handle.admitInitialTell(born.initialTell, {
-            ...(born.signal === undefined ? {} : { signal: born.signal }),
-        });
-    }
-    catch (error) {
-        if (born.signal?.aborted)
-            throw error;
-        return { kind: "failed", result: failedCall(call, error) };
-    }
-    if (admitted.kind === "birth-failed")
-        return { kind: "failed", result: failedCall(call, new Error(admitted.diagnostic)) };
-    if (admitted.kind === "not-born")
-        return {
-            kind: "failed",
-            result: failedCall(call, new Error(`Akuma ${handle.id} was not born for its initial Tell`)),
-        };
-    const wake = admitted.wake;
-    void wake.catch(() => undefined);
-    return { kind: "admitted", wake };
-}
-async function detachCall(call, admission) {
-    let tell;
-    try {
-        tell =
-            admission.wake === undefined
-                ? await call.handle.admittedReceipt(call.born.initialTell.tellId)
-                : await admission.wake;
-        return { ...call.result, observation: { kind: "detached", tell } };
-    }
-    catch (error) {
-        if (admission.wake !== undefined)
-            tell = await call.handle.admittedReceipt(call.born.initialTell.tellId).catch(() => undefined);
-        return failedCall(call, error, tell);
-    }
-}
-async function observeCall(call, admission) {
-    const { born, handle } = call;
-    let tell;
+async function observeCall(input) {
     const onObserve = {
         admitted: async (receipt, id) => {
-            tell = receipt;
-            await born.observe?.admitted?.(receipt, id, {
-                dispatch: born.dispatch,
-                alias: born.alias,
+            await input.observe?.admitted?.(receipt, id, {
+                dispatch: input.result.dispatch,
+                alias: input.result.alias,
             });
         },
-        ...(born.observe?.observe === undefined ? {} : { observe: born.observe.observe }),
+        ...(input.observe?.observe === undefined ? {} : { observe: input.observe.observe }),
     };
     try {
-        const observed = await observeAdmittedTellWaitAkuma({
-            path: born.path,
-            id: handle.id,
-            tellId: born.initialTell.tellId,
-            timeoutMs: born.timeoutMs,
-            ...(admission.wake === undefined ? {} : { wake: admission.wake }),
-            ...(born.signal === undefined ? {} : { signal: born.signal }),
+        const observed = await observeAdmittedAskAkuma({
+            path: input.path,
+            id: input.akuma,
+            tellId: input.initialTell.tellId,
+            timeoutMs: input.timeoutMs,
+            receipt: input.receipt,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
             onObserve,
         });
         return {
-            ...call.result,
+            ...input.result,
             observation: {
                 kind: "observed",
                 tell: observed.tell,
-                observation: born.initialTell.schema === undefined
+                observation: input.initialTell.schema === undefined
                     ? observed.observation
-                    : decodeTellWaitObservation(observed.observation, born.initialTell.schema),
+                    : decodeAskObservation(observed.observation, input.initialTell.schema),
                 ...(observed.completedAt === undefined ? {} : { completedAt: observed.completedAt }),
             },
         };
     }
     catch (error) {
-        if (born.signal?.aborted)
+        if (input.signal?.aborted)
             throw error;
-        return failedCall(call, error, tell);
+        return failedCall(input.result, input.initialTell.tellId, error, input.receipt);
     }
 }
+/** One failure that still names the child the invocation durably admitted. */
+function knownChildFailure(reason, akuma) {
+    const error = reason instanceof Error ? reason : new Error(reason === undefined ? "call aborted" : String(reason));
+    Object.defineProperty(error, "akuma", { value: akuma, enumerable: false });
+    return error;
+}
+/** Preserve a native failure identity; only an unknown shape becomes a fresh Error. */
+function asError(failure) {
+    return failure instanceof Error ? failure : new Error(failure === undefined ? "call failed" : String(failure));
+}
 export async function callAkumas(input, execution = localExecutionContext()) {
-    const born = await prepareCall(input, execution);
-    const call = await publishCallTarget(born);
-    const admission = await admitCallTell(call);
-    if (admission.kind === "failed")
-        return admission.result;
-    return born.mode === "detach" ? await detachCall(call, admission) : await observeCall(call, admission);
+    const parsed = await parseCallInput(input);
+    const selectedExecution = await resolveCallExecution(parsed.cwd === undefined ? {} : { cwd: parsed.cwd });
+    const seat = parsed.seat;
+    const admitted = await admitAkumaCall(parsed.path, callConfiguration(parsed, execution), {
+        ...callAdmissionInput(parsed, selectedExecution),
+        ...(seat === undefined ? {} : { contractId: seat.id }),
+    }, selectedExecution === undefined ? {} : { cwdCanonical: true });
+    // One caller-wiring sequence, after the prepared executor returned its local value
+    // or the forwarded caller received its exact live output, before outcome observation.
+    await emitCalledSignal({
+        path: parsed.path,
+        ...(parsed.settings === undefined ? {} : { settings: parsed.settings }),
+        admitted,
+        ...(seat === undefined ? {} : { contractId: seat.id }),
+    });
+    const dispatch = seat === undefined
+        ? { kind: "none" }
+        : await dispatchStage({ repository: seat.scope, akuId: admitted.id, contractId: seat.id });
+    const aliasStage = await resolveAliasStage(parsed.path, parsed.alias, dispatch, admitted.id);
+    const result = callResultOf(admitted.id, selectedExecution ?? admitted.execution, dispatch, aliasStage, parsed.initialTell);
+    if (parsed.initialTell === undefined) {
+        // A prompt-free call must not report a clean birth when a launch stage failed
+        // after the child was durably born; keep the native failure and the child.
+        if (admitted.failure !== undefined)
+            throw knownChildFailure(admitted.failure, admitted.id);
+        return { ...result, observation: { kind: "born" } };
+    }
+    const receipt = admitted.tell;
+    if (receipt === undefined) {
+        if (parsed.signal?.aborted === true && admitted.failure !== undefined) {
+            // Cancellation keeps its native meaning, and the already-born child stays
+            // attached as private invocation evidence rather than being discarded.
+            throw knownChildFailure(parsed.signal.reason, admitted.id);
+        }
+        const failure = admitted.failure === undefined
+            ? new Error(`Akuma ${admitted.id} returned no exact initial Tell receipt`)
+            : asError(admitted.failure);
+        return failedCall(result, parsed.initialTell.tellId, failure);
+    }
+    return parsed.mode === "detach"
+        ? { ...result, observation: { kind: "detached", tell: receipt } }
+        : await observeCall({
+            path: parsed.path,
+            akuma: admitted.id,
+            result,
+            initialTell: parsed.initialTell,
+            receipt,
+            timeoutMs: parsed.timeoutMs,
+            ...(parsed.signal === undefined ? {} : { signal: parsed.signal }),
+            ...(parsed.observe === undefined ? {} : { observe: parsed.observe }),
+        });
 }
 export async function forkAkumas(input) {
     const values = requireInput(input, "Akumas.fork input");
@@ -428,7 +411,7 @@ export async function forkAkumas(input) {
     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 createAkumaProduct(path).selectHandle({ id: akuma }).fork({ at });
+    const receipt = await new AkumaOwner(akuma, path).fork({ at });
     if (receipt.kind !== "forked")
         return { ...receipt, parent: akuma };
     const dispatch = repository === undefined

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

@@ -1,27 +1,20 @@
+/** @architectureCompositionRoot */
 import type { AkumaList, AkumaListInput } from "../akuma/akuma.js";
-import { type ExecutionContext, type LibraryExecution } from "../akuma/requests.js";
-import type { CallInput as LibraryCallInput, CallResult, CallWaitHead, DispatchStage, ForkInput as LibraryForkInput, ForkResult } from "./akuma-creation.js";
-import { type AkumaHistoryInput as LibraryAkumaHistoryInput, type AkumaHistoryResult, type AkumaInterruptInput as LibraryAkumaInterruptInput, type AkumaInterruptResult, type AkumaKillInput as LibraryAkumaKillInput, type AkumaKillResult, type AkumaObservation, type AkumaObservationStage, type AkumaTellInput as LibraryAkumaTellInput, type AkumaTellResult, type AkumaWaitInput as LibraryAkumaWaitInput, type AkumaWaitResult } from "./fleet.js";
-import type { AkumaAddressInput as LibraryAkumaAddressInput, AkumaWorldScopeRefusal } from "./address.js";
-export { AkumaWorldScopeError, AkumaAddressError } from "./address.js";
-import type { TellResult, TellWake } from "../akuma/akuma.js";
+import type { TellResult, TellWake } from "../akuma/body.js";
+import { type ExecutionContext } from "../akuma/requests.js";
 import type { DispatchAssociation } from "../dispatch/association.js";
 import type { CreatedTaskObservation } from "../task/created-observation.js";
 import { type WorldRoot } from "../world.js";
-export type AkumaAddressInput = Omit<LibraryAkumaAddressInput, "path">;
-export type AkumaWaitInput = Omit<LibraryAkumaWaitInput, "path">;
-export type AkumaKillInput = Omit<LibraryAkumaKillInput, "path">;
-export type AkumaTellInput = Omit<LibraryAkumaTellInput, "path">;
-export type AkumaInterruptInput = Omit<LibraryAkumaInterruptInput, "path">;
-export type AkumaHistoryInput = Omit<LibraryAkumaHistoryInput, "path">;
-export type CallInput = Omit<LibraryCallInput, "path">;
-export type ForkInput = Omit<LibraryForkInput, "path">;
-export type AkumasOfInput = Readonly<{
-    execution?: LibraryExecution;
-}>;
-export type { AkumaHistoryResult, AkumaInterruptResult, AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellResult, AkumaWaitResult, CallResult, CallWaitHead, CreatedTaskObservation, DispatchStage, DispatchAssociation, ForkResult, TellResult, TellWake, };
-export type { AkumaWorldScopeRefusal };
-export type { AkumaList, AkumaListInput };
+import type { AkumaAddressInput, AkumaWorldScopeRefusal } from "./address.js";
+import type { CallInput, CallResult, CallWaitHead, DispatchStage, ForkInput, ForkResult } from "./akuma-creation.js";
+import { type AkumaAskInput, type AkumaAskResult, type AkumaHistoryInput, type AkumaHistoryResult, type AkumaKillInput, type AkumaKillResult, type AkumaObservation, type AkumaObservationStage, type AkumaTellInput, type AkumaTellResult, type AkumaWaitInput, type AkumaWaitResult } from "./selection.js";
+export { AkumaAddressError, AkumaWorldScopeError } from "./address.js";
+export type { AkumaAddressInput } from "./address.js";
+export type { CallInput, ForkInput } from "./akuma-creation.js";
+export type { AkumaAskInput, AkumaHistoryInput, AkumaKillInput, AkumaTellInput, AkumaWaitInput } from "./selection.js";
+export type { AkumaAskResult, AkumaHistoryResult, AkumaKillResult, AkumaList, AkumaListInput, AkumaObservation, AkumaObservationStage, AkumaTellResult, AkumaWaitResult, AkumaWorldScopeRefusal, CallResult, CallWaitHead, CreatedTaskObservation, DispatchAssociation, DispatchStage, ForkResult, TellResult, TellWake, };
+/** The existing native wait-observation seam, exposed type-only for CLI composition. */
+export type { WaitObservedAkuma, WaitObserver, WaitSelectedAkuma } from "../akuma/akuma-wait.js";
 export type Akumas = AkumasHandle;
 declare class AkumasHandle {
     #private;
@@ -31,12 +24,17 @@ declare class AkumasHandle {
     fork(input: ForkInput): Promise<ForkResult>;
     status(input: AkumaAddressInput): Promise<AkumaObservation>;
     tell(input: AkumaTellInput): Promise<AkumaTellResult>;
+    ask<T = string>(input: AkumaAskInput<T>): Promise<AkumaAskResult<T>>;
     wait(input: AkumaWaitInput): Promise<AkumaWaitResult>;
     kill(input: AkumaKillInput): Promise<AkumaKillResult>;
     history(input: AkumaHistoryInput): Promise<AkumaHistoryResult>;
-    interrupt(input: AkumaInterruptInput): Promise<AkumaInterruptResult>;
     private withWorld;
 }
+/**
+ * The one Akumas composition. Public `of` fixes local execution; CLI and Body pass their captured
+ * internal channel through `akumasWithExecution` instead of a second constructor.
+ */
+export declare function akumasWithExecution(world: WorldRoot, execution: ExecutionContext): Akumas;
 export declare const Akumas: Readonly<{
-    of(world: WorldRoot, input?: AkumasOfInput): Akumas;
+    of(world: WorldRoot): Akumas;
 }>;

package/build/src/library/akumas.js

@@ -1,21 +1,28 @@
-/** @architectureCompositionRoot */
-import { readAkumaCatalog } from "../akuma/akuma.js";
-import { libraryExecution, localExecutionContext, } from "../akuma/requests.js";
+import { readAkumaRoster } from "../akuma/akuma.js";
+import { localExecutionContext } from "../akuma/requests.js";
+import { readAliases } from "../alias/index.js";
+import { World } from "../world.js";
 import { callAkumas, forkAkumas } from "./akuma-creation.js";
-import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma, } from "./fleet.js";
 import { requireInput } from "./input.js";
-export { AkumaWorldScopeError, AkumaAddressError } from "./address.js";
-import { World } from "../world.js";
+import { askAkumaOn, historyAkuma, killAkumaOn, selectionSeam, statusAkuma, tellAkumaOn, waitAkumaOn, } from "./selection.js";
+export { AkumaAddressError, AkumaWorldScopeError } from "./address.js";
 class AkumasHandle {
     #world;
     #execution;
+    #selection;
     constructor(world, execution) {
         this.#world = world;
         this.#execution = execution;
+        // One typed route seam captured at construction: no operation re-derives it.
+        this.#selection = selectionSeam(execution);
         Object.freeze(this);
     }
     async list(input) {
-        return readAkumaCatalog(await World.prove(this.#world), input);
+        const path = await World.prove(this.#world);
+        const roster = await readAkumaRoster(path, input);
+        if (roster.rows.length === 0)
+            return roster;
+        return withRosterAliases(roster, await readAliases(path));
     }
     call(input) {
         return callAkumas(this.withWorld(input, "Akumas.call input"), this.#execution);
@@ -27,20 +34,20 @@ class AkumasHandle {
         return statusAkuma(this.withWorld(input, "Akumas.status input"));
     }
     tell(input) {
-        return tellAkuma(this.withWorld(input, "Akumas.tell input"), this.#execution);
+        return tellAkumaOn(this.#selection, this.withWorld(input, "Akumas.tell input"));
+    }
+    ask(input) {
+        return askAkumaOn(this.#selection, this.withWorld(input, "Akumas.ask input"));
     }
     wait(input) {
-        return waitAkuma(this.withWorld(input, "Akumas.wait input"), this.#execution);
+        return waitAkumaOn(this.#selection, this.withWorld(input, "Akumas.wait input"));
     }
     kill(input) {
-        return killAkuma(this.withWorld(input, "Akumas.kill input"), this.#execution);
+        return killAkumaOn(this.#selection, this.withWorld(input, "Akumas.kill input"));
     }
     history(input) {
         return historyAkuma(this.withWorld(input, "Akumas.history input"));
     }
-    interrupt(input) {
-        return interruptAkuma(this.withWorld(input, "Akumas.interrupt input"));
-    }
     withWorld(input, label) {
         const values = requireInput(input, label);
         if (Object.hasOwn(values, "path"))
@@ -48,14 +55,30 @@ class AkumasHandle {
         return { ...values, path: this.#world };
     }
 }
-function executionFor(input) {
-    const values = requireInput(input === undefined ? {} : input, "Akumas.of input", ["execution"]);
-    return values.execution === undefined ? localExecutionContext() : libraryExecution(values.execution);
+/**
+ * Upper World composition attaches the frozen Alias context to the lower
+ * roster's native membership and semantic order without reopening its extent.
+ */
+function withRosterAliases(roster, bindings) {
+    const byId = new Map();
+    for (const binding of bindings) {
+        const aliases = byId.get(binding.akuId) ?? [];
+        aliases.push(binding.alias);
+        byId.set(binding.akuId, aliases);
+    }
+    return { ...roster, rows: roster.rows.map((row) => ({ ...row, aliases: byId.get(row.id) ?? [] })) };
+}
+/**
+ * The one Akumas composition. Public `of` fixes local execution; CLI and Body pass their captured
+ * internal channel through `akumasWithExecution` instead of a second constructor.
+ */
+export function akumasWithExecution(world, execution) {
+    if (typeof world !== "string")
+        throw new TypeError("Akumas.of world must be a WorldRoot");
+    return new AkumasHandle(world, execution);
 }
 export const Akumas = Object.freeze({
-    of(world, input) {
-        if (typeof world !== "string")
-            throw new TypeError("Akumas.of world must be a WorldRoot");
-        return new AkumasHandle(world, executionFor(input));
+    of(world) {
+        return akumasWithExecution(world, localExecutionContext());
     },
 });