@astrosheep/keiyaku 4.5.28 → 4.6.1

package/build/src/akuma/akuma-call.d.ts

@@ -0,0 +1,53 @@
+import type { Settings } from "../settings.js";
+import type { WorldRoot } from "../world.js";
+import { type AllowedAction } from "./allowed.js";
+import { type TellResult } from "./body.js";
+import type { CallInitialTell } from "./call-initial-tell.js";
+import { type AllocatedAkuma } from "./identity.js";
+import { type ExecutionContext } from "./requests.js";
+import type { Schema } from "./schema.js";
+type AkumaCallExecution = Readonly<{
+    cwd: string;
+    source: "input" | "caller" | "process" | "world";
+}>;
+export type AkumaCallInput = Readonly<{
+    archetype: string;
+    body?: string;
+    cwd?: string;
+    allowed?: readonly AllowedAction[];
+    schema?: Schema<unknown>;
+    initiator?: string;
+    signal?: AbortSignal;
+}>;
+type AkumaCallContext = Readonly<{
+    initiatorCwd?: string;
+    cwdCanonical?: true;
+}>;
+export type AkumaConfiguration = Readonly<{
+    home?: string;
+    settings?: Settings;
+    execution?: ExecutionContext;
+}>;
+export type InitialCallTell = CallInitialTell;
+/** One admitted call: the leading child identity plus the exact live initial Tell evidence when supplied. */
+export type AdmittedAkumaCall = Readonly<{
+    id: AllocatedAkuma["id"];
+    cwd: string;
+    execution: AkumaCallExecution;
+    /** True when the serving process was reached through the one direct-parent request channel. */
+    requested: boolean;
+    tell?: TellResult;
+    /** The native local failure, or the request transport's diagnostic text, after a confirmed birth. */
+    failure?: unknown;
+}>;
+type AkumaCallLaunchInput = Omit<AkumaCallInput, "body" | "schema"> & Readonly<{
+    initialTell?: InitialCallTell;
+    contractId?: string;
+}>;
+/**
+ * The one lower recipe preparer and admission edge used by plural creation and
+ * standalone birth: load the caller Archetype/Settings, freeze allowed and cwd,
+ * then invoke the P3 prepared-call executor under local or request custody.
+ */
+export declare function admitAkumaCall(path: WorldRoot, configuration: AkumaConfiguration, input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AdmittedAkumaCall>;
+export {};

package/build/src/akuma/akuma-call.js

@@ -0,0 +1,113 @@
+import { randomUUID } from "node:crypto";
+import { settings as readSettings } from "../settings.js";
+import { readAkumaBirthCwd } from "./akuma-observe.js";
+import { AkumaOwner } from "./akuma-owner.js";
+import { decodeAllowedActions, unionAllowedActions } from "./allowed.js";
+import { AkumaArchetypeError, loadPreparedArchetype } from "./archetype.js";
+import { spawnAkumaBody } from "./body.js";
+import { canonicalBirthCwd } from "./call-input.js";
+import { requestForwardedAkumaCall } from "./call-request.js";
+import { archetypeName } from "./identity.js";
+import { PreparedCallAdmissionError, executePreparedCall } from "./publication.js";
+import { executionChannel } from "./requests.js";
+async function admitBodyRequest(input) {
+    const cwd = input.call.cwd === undefined
+        ? undefined
+        : input.context.cwdCanonical === true
+            ? input.call.cwd
+            : await canonicalBirthCwd(input.call.cwd);
+    const response = await requestForwardedAkumaCall({
+        directory: input.execution.directory,
+        id: randomUUID(),
+        world: input.path,
+        archetype: input.name,
+        ...(input.call.initialTell === undefined ? {} : { initialTell: input.call.initialTell }),
+        ...(cwd === undefined ? {} : { cwd }),
+        recipe: input.recipe,
+        ...(input.call.signal === undefined ? {} : { signal: input.call.signal }),
+    });
+    const bornCwd = await readAkumaBirthCwd(input.path, response.id);
+    return {
+        id: response.id,
+        cwd: bornCwd,
+        requested: true,
+        execution: { cwd: bornCwd, source: cwd === undefined ? "caller" : "input" },
+        ...(response.kind === "live" && response.tell !== undefined ? { tell: response.tell } : {}),
+        ...(response.kind === "live" && response.tellFailure !== undefined ? { failure: response.tellFailure } : {}),
+        ...(response.kind === "reference" && input.call.initialTell !== undefined
+            ? { failure: `Akuma ${response.id} was born without its exact initial Tell receipt` }
+            : {}),
+    };
+}
+async function admitDirect(input) {
+    const initiatorCwd = input.context.initiatorCwd;
+    const selectedCwd = input.call.cwd ?? initiatorCwd ?? input.path;
+    const cwd = input.call.cwd !== undefined && input.context.cwdCanonical === true
+        ? input.call.cwd
+        : await canonicalBirthCwd(selectedCwd);
+    let result;
+    try {
+        result = await executePreparedCall({
+            archetype: input.archetype.name,
+            cwd,
+            ...(input.call.initialTell === undefined ? {} : { initialTell: input.call.initialTell }),
+            ...(input.call.signal === undefined ? {} : { signal: input.call.signal }),
+            custody: {
+                kind: "local",
+                world: input.path,
+                recipe: input.recipe,
+                spawn: async (launch) => await spawnAkumaBody({
+                    paths: launch.paths,
+                    seed: launch.seed,
+                    ...(input.call.contractId === undefined ? {} : { completion: { contractId: input.call.contractId } }),
+                }),
+                admitInitialTell: async ({ id, initialTell, signal }) => await new AkumaOwner(id, input.path).admitInitialTell(initialTell, {
+                    ...(signal === undefined ? {} : { signal }),
+                }),
+            },
+        });
+    }
+    catch (error) {
+        // The executor owns provider admission; this local edge restores the
+        // Archetype-classified refusal the initiating caller has always seen.
+        if (error instanceof PreparedCallAdmissionError) {
+            throw new AkumaArchetypeError(input.archetype.name, [input.archetype.path], error.stage === "options" ? `is unsupported: ${error.diagnostic}` : `uses ${error.diagnostic}`);
+        }
+        throw error;
+    }
+    return {
+        id: result.child.id,
+        cwd,
+        requested: false,
+        execution: {
+            cwd,
+            source: input.call.cwd !== undefined ? "input" : initiatorCwd === undefined ? "world" : "process",
+        },
+        ...(result.tell === undefined ? {} : { tell: result.tell }),
+        ...(result.failure === undefined ? {} : { failure: result.failure }),
+    };
+}
+/**
+ * The one lower recipe preparer and admission edge used by plural creation and
+ * standalone birth: load the caller Archetype/Settings, freeze allowed and cwd,
+ * then invoke the P3 prepared-call executor under local or request custody.
+ */
+export async function admitAkumaCall(path, configuration, input, context) {
+    const name = archetypeName(input.archetype);
+    const home = configuration.home === undefined ? {} : { home: configuration.home };
+    const settings = configuration.settings ?? (await readSettings({ root: path, ...home }));
+    const archetype = await loadPreparedArchetype({ name, project: path, ...home, settings });
+    const allowed = input.allowed === undefined
+        ? archetype.allowed
+        : unionAllowedActions(archetype.allowed, decodeAllowedActions(input.allowed, "Akuma call allowed"));
+    const execution = executionChannel(configuration.execution);
+    const requestRecipe = Object.freeze({
+        ...(archetype.description === undefined ? {} : { description: archetype.description }),
+        provider: archetype.provider,
+        options: archetype.options,
+        allowed,
+    });
+    if (execution.kind === "body-request")
+        return await admitBodyRequest({ call: input, context, path, name, recipe: requestRecipe, execution });
+    return await admitDirect({ call: input, context, path, archetype, recipe: requestRecipe });
+}

package/build/src/akuma/akuma-instance.d.ts

@@ -1,18 +1,19 @@
-import type { AllowedAction } from "./allowed.js";
-import type { AkumaStatus } from "./akuma.js";
-import type { InterruptReceipt, KillEvidence } from "./akuma.js";
-import { type WaitReason } from "./akuma-observe.js";
-import { type AkuId } from "./identity.js";
-import { type ActivityHistory } from "./projection.js";
 import type { Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
+import { type InterruptReceipt } from "./akuma-owner.js";
+import { type AkumaStatus } from "./akuma.js";
+import type { AllowedAction } from "./allowed.js";
+import { type KillEvidence } from "./heart/index.js";
+import { type AkuId } from "./identity.js";
+import type { ActivityHistory } from "./projection.js";
 import { type Schema, type StandardSchemaV1 } from "./schema.js";
+import { type AkumaAskResult, type AkumaTellResult } from "./selection-observation.js";
 export type AkumaIdleOptions = Readonly<{
     timeoutMs?: number;
     signal?: AbortSignal;
 }>;
 export type AkumaIdleResult = Readonly<{
-    reason: WaitReason;
+    reason: "completed" | "deadline";
     status: AkumaStatus;
 }>;
 export type AkumaHistoryOptions = Readonly<{
@@ -28,30 +29,30 @@ export type AkumaBirthInput = Readonly<{
     cwd?: string;
     home?: string;
     settings?: Settings;
-    readonly?: true;
     allowed?: readonly AllowedAction[];
 }>;
-export type AkumaTellOptions<T> = Readonly<{
-    schema: Schema<T> | StandardSchemaV1<T>;
+export type AkumaTellOptions = AkumaSignalOptions & Readonly<{
     interrupt?: boolean;
     initiator?: string;
 }>;
+export type AkumaAskOptions<T> = AkumaTellOptions & Readonly<{
+    timeoutMs?: number;
+    schema?: Schema<T> | StandardSchemaV1<T>;
+}>;
+export type { AkumaAskResult, AkumaTellResult, InterruptReceipt, KillEvidence };
 export declare class Akuma {
     readonly id: AkuId;
     private readonly root;
     private constructor();
-    private get paths();
+    private owner;
     static birth(archetype: string, input: AkumaBirthInput): Promise<Akuma>;
     static select(root: WorldRoot, selector: string): Akuma;
-    tell(text: string, options?: Readonly<{
-        initiator?: string;
-        signal?: AbortSignal;
-    }>): Promise<string>;
-    tell<T>(text: string, options: AkumaTellOptions<T> & AkumaSignalOptions): Promise<T>;
+    tell(text: string, options?: AkumaTellOptions): Promise<AkumaTellResult>;
+    ask(text: string, options?: AkumaAskOptions<string>): Promise<AkumaAskResult<string>>;
+    ask<T>(text: string, options: AkumaAskOptions<T> & Readonly<{
+        schema: Schema<T> | StandardSchemaV1<T>;
+    }>): Promise<AkumaAskResult<T>>;
     status(): Promise<AkumaStatus>;
-    interrupt(text: string, options?: AkumaSignalOptions & Readonly<{
-        initiator?: string;
-    }>): Promise<InterruptReceipt>;
     idle(options?: AkumaIdleOptions): Promise<AkumaIdleResult>;
     history(options?: AkumaHistoryOptions): Promise<ActivityHistory>;
     kill(options?: AkumaSignalOptions): Promise<KillEvidence>;

package/build/src/akuma/akuma-instance.js

@@ -1,19 +1,10 @@
-import { randomUUID } from "node:crypto";
-import { callReadonly, canonicalBirthCwd } from "./call-input.js";
-import { spawnAkumaBody } from "./body.js";
-import { decodeAllowedActions, unionAllowedActions } from "./allowed.js";
-import { AkumaDecodeError, AkumaProviderError } from "./akuma-errors.js";
-import { AkumaHandle } from "./akuma-handle.js";
-import { bornStatus, defaultWaitComplete, waitForObservation } from "./akuma-observe.js";
-import { loadArchetype } from "./archetype.js";
-import { activitySlice } from "./heart/index.js";
-import { parseAkuId, pathsForAkuId } from "./identity.js";
-import { birthAkuma, launchAkuma } from "./publication.js";
-import { projectTurns, selectHistory } from "./projection.js";
-import { settings as readSettings } from "../settings.js";
-import { schemaFromStandard, schemaJsonText } from "./schema.js";
 import { abortable } from "./abort.js";
-const HISTORY_LIMIT = 12;
+import { admitAkumaCall } from "./akuma-call.js";
+import { defaultWaitComplete } from "./akuma-observe.js";
+import { AkumaOwner } from "./akuma-owner.js";
+import { decodeAskObservation, executeAskAkuma, executeTellAkuma } from "./akuma-selection-execution.js";
+import { parseAkuId } from "./identity.js";
+import { schemaFromStandard, schemaJsonText } from "./schema.js";
 function signalOption(value) {
     if (value === undefined)
         return undefined;
@@ -21,63 +12,6 @@ function signalOption(value) {
         throw new TypeError("signal must be an AbortSignal");
     return value;
 }
-function recordedTell(result) {
-    if (result.wake.kind === "failed")
-        throw new AkumaProviderError(result.wake.diagnostic);
-    return { tellId: result.admission.tellId };
-}
-async function recordPlainTell(input) {
-    const { id, root, body, tellId, initiator, signal } = input;
-    const admitted = await new AkumaHandle(id, root).tell(body, tellId, undefined, undefined, {
-        ...(initiator === undefined ? {} : { initiator }),
-        ...(signal === undefined ? {} : { signal }),
-    });
-    return recordedTell(admitted);
-}
-function plainTellInput(input) {
-    return {
-        id: input.id,
-        root: input.root,
-        body: input.body,
-        tellId: input.tellId,
-        ...(input.options?.initiator === undefined ? {} : { initiator: input.options.initiator }),
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    };
-}
-async function recordSchemaTell(input) {
-    const { id, body, tellId, schema, root } = input;
-    if (input.interrupt === true) {
-        const interrupted = await new AkumaHandle(id, root).interrupt(body, {
-            tellId,
-            schemaJson: schemaJsonText(schema),
-            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-        });
-        if (interrupted.kind === "unavailable") {
-            throw new AkumaProviderError(`schema interrupt unavailable: ${interrupted.evidence}`);
-        }
-        return recordedTell(interrupted.tell);
-    }
-    const admitted = await new AkumaHandle(id, root).tell(body, tellId, undefined, undefined, {
-        schemaJson: schemaJsonText(schema),
-        ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    });
-    return recordedTell(admitted);
-}
-function outcomeError(outcome) {
-    if (outcome.kind === "invalid-output")
-        throw new AkumaDecodeError(outcome.diagnostic, outcome.answer);
-    if (outcome.kind === "failed")
-        throw new AkumaProviderError(outcome.diagnostic);
-    throw new AkumaProviderError("Akuma answered without a value");
-}
-async function awaitTellOutcome(handle, tellId, signal) {
-    const observed = await handle.tellOutcome(tellId, signal === undefined ? {} : { signal });
-    if (observed.outcome !== null)
-        return observed.outcome;
-    throw new AkumaProviderError(`recorded Tell ${tellId} reached a terminal delivery without a Turn binding`);
-}
 export class Akuma {
     id;
     root;
@@ -86,8 +20,8 @@ export class Akuma {
         this.root = root;
         Object.freeze(this);
     }
-    get paths() {
-        return pathsForAkuId(this.root, this.id);
+    owner() {
+        return new AkumaOwner(this.id, this.root);
     }
     static async birth(archetype, input) {
         if (typeof input !== "object" || input === null || Array.isArray(input)) {
@@ -95,103 +29,72 @@ export class Akuma {
         }
         if (typeof input.root !== "string")
             throw new TypeError("Akuma birth root must be a WorldRoot");
-        const name = archetype;
-        const home = input.home === undefined ? {} : { home: input.home };
-        const settings = input.settings ?? (await readSettings({ root: input.root, ...home }));
-        const readonly = callReadonly(input.readonly, "Akuma birth readonly must be true");
-        const loaded = await loadArchetype({ name, project: input.root, ...home, settings, ...readonly });
-        const allowed = input.allowed === undefined
-            ? loaded.allowed
-            : unionAllowedActions(loaded.allowed, decodeAllowedActions(input.allowed, "Akuma birth allowed"));
-        const cwd = input.cwd === undefined ? input.root : await canonicalBirthCwd(input.cwd);
-        const allocated = await birthAkuma({ worldPath: input.root, archetype: loaded.name });
-        await launchAkuma({
-            allocated,
-            launch: async (born) => await spawnAkumaBody({
-                paths: born.paths,
-                seed: {
-                    id: born.id,
-                    archetype: born.archetype,
-                    ...(loaded.description === undefined ? {} : { description: loaded.description }),
-                    provider: loaded.provider,
-                    options: loaded.options,
-                    ...(loaded.readonly === undefined ? {} : { readonly: loaded.readonly }),
-                    allowed,
-                    cwd,
-                    origin: { kind: "direct" },
-                },
-            }),
-        });
-        return new Akuma(allocated.id, input.root);
+        const admitted = await admitAkumaCall(input.root, {
+            ...(input.home === undefined ? {} : { home: input.home }),
+            ...(input.settings === undefined ? {} : { settings: input.settings }),
+        }, {
+            archetype,
+            ...(input.cwd === undefined ? {} : { cwd: input.cwd }),
+            ...(input.allowed === undefined ? {} : { allowed: input.allowed }),
+        }, {});
+        if (admitted.failure !== undefined)
+            throw admitted.failure;
+        return new Akuma(admitted.id, input.root);
     }
     static select(root, selector) {
         if (typeof root !== "string")
             throw new TypeError("Akuma.select root must be a WorldRoot");
         return new Akuma(parseAkuId(selector).id, root);
     }
-    async tell(text, options) {
+    async tell(text, options = {}) {
         if (typeof text !== "string")
             throw new TypeError("Akuma tell text must be a string");
-        const signal = signalOption(options?.signal);
+        if (typeof options !== "object" || options === null || Array.isArray(options))
+            throw new TypeError("Akuma tell options must be an object");
+        if ("schema" in options)
+            throw new TypeError("Akuma tell does not accept schema; use ask");
+        const unknown = Object.keys(options).find((key) => !["interrupt", "initiator", "signal"].includes(key));
+        if (unknown !== undefined)
+            throw new TypeError(`Akuma tell options has unknown field: ${unknown}`);
+        const signal = signalOption(options.signal);
         signal?.throwIfAborted();
-        const tellId = randomUUID();
-        const schemaOptions = options !== undefined && "schema" in options ? options : undefined;
-        const schema = schemaOptions === undefined ? undefined : schemaFromStandard(schemaOptions.schema);
-        const recorded = schemaOptions === undefined || schema === undefined
-            ? await recordPlainTell(plainTellInput({
-                id: this.id,
-                root: this.root,
-                body: text,
-                tellId,
-                options,
-                signal,
-            }))
-            : await recordSchemaTell({
-                id: this.id,
-                body: text,
-                tellId,
-                schema,
-                root: this.root,
-                ...(schemaOptions.interrupt === undefined ? {} : { interrupt: schemaOptions.interrupt }),
-                ...(schemaOptions.initiator === undefined ? {} : { initiator: schemaOptions.initiator }),
-                ...(signal === undefined ? {} : { signal }),
-            });
-        const outcome = await awaitTellOutcome(new AkumaHandle(this.id, this.root), recorded.tellId, signal);
-        if (outcome.kind !== "answered")
-            outcomeError(outcome);
-        if (schema === undefined)
-            return outcome.answer;
-        const raw = outcome.answerJson ?? outcome.answer;
-        let parsed;
-        try {
-            parsed = JSON.parse(raw);
-        }
-        catch (error) {
-            throw new AkumaDecodeError(error instanceof Error ? error.message : "Answer is not valid JSON", outcome.answer);
-        }
-        try {
-            return schema.decode(parsed);
-        }
-        catch (error) {
-            throw new AkumaDecodeError(error instanceof Error ? error.message : "Answer failed schema decode", outcome.answer);
-        }
-    }
-    async status() {
-        return (await bornStatus(this.paths, this.id, { aperture: "monitoring" })).status;
+        return await executeTellAkuma({
+            path: this.root,
+            id: this.id,
+            body: text,
+            ...(options.interrupt === true ? { interrupt: true } : {}),
+            ...(options.initiator === undefined ? {} : { initiator: options.initiator }),
+            ...(signal === undefined ? {} : { signal }),
+        });
     }
-    async interrupt(text, options = {}) {
+    async ask(text, options = {}) {
         if (typeof text !== "string")
-            throw new TypeError("Akuma interrupt text must be a string");
-        if (typeof options !== "object" || options === null || Array.isArray(options)) {
-            throw new TypeError("Akuma interrupt options must be an object");
-        }
+            throw new TypeError("Akuma ask text must be a string");
+        if (typeof options !== "object" || options === null || Array.isArray(options))
+            throw new TypeError("Akuma ask options must be an object");
+        const unknown = Object.keys(options).find((key) => !["schema", "timeoutMs", "interrupt", "initiator", "signal"].includes(key));
+        if (unknown !== undefined)
+            throw new TypeError(`Akuma ask options has unknown field: ${unknown}`);
+        if (options.timeoutMs !== undefined &&
+            (!Number.isFinite(options.timeoutMs) || !Number.isInteger(options.timeoutMs) || options.timeoutMs < 0))
+            throw new TypeError("Akuma ask timeoutMs must be a nonnegative finite millisecond duration");
         const signal = signalOption(options.signal);
         signal?.throwIfAborted();
-        const operation = new AkumaHandle(this.id, this.root).interrupt(text, {
-            ...(signal === undefined ? {} : { signal }),
+        const schema = options.schema === undefined ? undefined : schemaFromStandard(options.schema);
+        const result = await executeAskAkuma({
+            path: this.root,
+            id: this.id,
+            body: text,
+            ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+            ...(schema === undefined ? {} : { schemaJson: schemaJsonText(schema) }),
+            ...(options.interrupt === true ? { interrupt: true } : {}),
             ...(options.initiator === undefined ? {} : { initiator: options.initiator }),
+            ...(signal === undefined ? {} : { signal }),
         });
-        return await abortable(operation, signal ?? new AbortController().signal);
+        return (schema === undefined ? result : { ...result, observation: decodeAskObservation(result.observation, schema) });
+    }
+    async status() {
+        return await this.owner().status();
     }
     async idle(options = {}) {
         if (typeof options !== "object" || options === null || Array.isArray(options)) {
@@ -204,13 +107,11 @@ export class Akuma {
             throw new TypeError("Akuma idle timeoutMs must be a nonnegative finite millisecond duration");
         }
         const signal = signalOption(options.signal);
-        const waited = await waitForObservation({
+        const waited = await this.owner().waitReceipt(defaultWaitComplete, {
             ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
             ...(signal === undefined ? {} : { signal }),
-            observe: async () => (await bornStatus(this.paths, this.id, { aperture: "monitoring" })).status,
-            complete: defaultWaitComplete,
         });
-        return { reason: waited.reason, status: waited.value };
+        return { reason: waited.reason, status: waited.status };
     }
     async history(options = {}) {
         if (typeof options !== "object" || options === null || Array.isArray(options)) {
@@ -222,24 +123,11 @@ export class Akuma {
         if (options.before !== undefined && options.since !== undefined) {
             throw new TypeError("Akuma history before and since are mutually exclusive");
         }
-        for (const [name, value] of [
-            ["before", options.before],
-            ["since", options.since],
-        ]) {
-            if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {
-                throw new TypeError(`Akuma history ${name} must be a positive safe integer`);
-            }
-        }
-        const limit = options.limit ?? HISTORY_LIMIT;
-        if (!Number.isSafeInteger(limit) || limit <= 0 || limit > 5_000) {
-            throw new TypeError("Akuma history limit must be a positive safe integer no greater than 5000");
-        }
-        const slice = await activitySlice(this.paths);
-        return selectHistory(projectTurns(slice.rows, { lowestRetained: slice.lowestRetained, highest: slice.highest }), {
+        return (await this.owner().history({
             ...(options.before === undefined ? {} : { before: options.before }),
             ...(options.since === undefined ? {} : { since: options.since }),
-            limit,
-        });
+            ...(options.limit === undefined ? {} : { limit: options.limit }),
+        }));
     }
     async kill(options = {}) {
         if (typeof options !== "object" || options === null || Array.isArray(options)) {
@@ -247,6 +135,6 @@ export class Akuma {
         }
         const signal = signalOption(options.signal);
         signal?.throwIfAborted();
-        return await abortable(new AkumaHandle(this.id, this.root).kill(signal === undefined ? {} : { signal }), signal ?? new AbortController().signal);
+        return await abortable(this.owner().kill(signal === undefined ? {} : { signal }), signal ?? new AbortController().signal);
     }
 }

package/build/src/akuma/akuma-observe.d.ts

@@ -1,9 +1,10 @@
 import { type AkuId, type AkumaPaths } from "./identity.js";
 import { selectHistory, type ActivityHistory, type ActivityRow, type ActivitySnapshot } from "./projection.js";
 import type { WorldRoot } from "../world.js";
+import type { AkumaAlias } from "../identity/selector.js";
 import type { AkumaListRow, AkumaStatus, UnbornAkumaListRow } from "./akuma.js";
-export declare function fleetListRow(paths: AkumaPaths, expected: AkuId): Promise<AkumaListRow | UnbornAkumaListRow>;
-export type BudgetedStatusObservation = Readonly<{
+export declare function rosterListRow(paths: AkumaPaths, expected: AkuId, aliases?: readonly AkumaAlias[]): Promise<AkumaListRow | UnbornAkumaListRow>;
+type BudgetedStatusObservation = Readonly<{
     status: AkumaStatus;
     ordinarySelected: number;
 }>;
@@ -26,11 +27,6 @@ export declare function bornStatus(paths: AkumaPaths, expected: AkuId, input: Re
     ordinaryBudget?: number;
     admittedTellId?: string;
 }>): Promise<BudgetedStatusObservation>;
-export declare function readBudgetedStatus(worldPath: WorldRoot, id: AkuId, input: Readonly<{
-    aperture: "monitoring" | "receipt";
-    ordinaryBudget?: number;
-    admittedTellId?: string;
-}>): Promise<BudgetedStatusObservation>;
 export declare function readLiveStatus(worldPath: WorldRoot, id: AkuId, input: Readonly<{
     aperture: "monitoring" | "receipt";
     ordinaryBudget?: number;
@@ -55,19 +51,5 @@ export declare function waitForObservation<T>(input: Readonly<{
     reason: WaitReason;
     value: T;
 }>>;
-/**
- * Successive status observations of one already born Akuma until its
- * observation window closes. Every acquired observation is reported to
- * `observe` before completion or deadline judgment, including the first
- * already-complete observation; the last status is returned.
- */
-export declare function observeAkumaStatus(worldPath: WorldRoot, expected: AkuId, input: Readonly<{
-    timeoutMs: number;
-    signal?: AbortSignal;
-    observe: (status: LiveStatusObservation) => void;
-}>): Promise<Readonly<{
-    reason: WaitReason;
-    status: AkumaStatus;
-}>>;
 export declare function readAkumaBirthCwd(worldPath: WorldRoot, id: AkuId): Promise<string>;
 export { selectHistory, type ActivityHistory, type ActivitySnapshot };

package/build/src/akuma/akuma-observe.js

@@ -4,7 +4,7 @@ import { ordinarySnapshotBudget, projectTurns, selectHistory, selectSnapshot, }
 import { resolveProviderExecution } from "./providers/index.js";
 import { abortableDelay } from "./abort.js";
 import { AkumaNotBornError } from "./akuma-errors.js";
-export async function fleetListRow(paths, expected) {
+export async function rosterListRow(paths, expected, aliases = []) {
     const snapshot = await readHeart(paths);
     if (snapshot.soul !== null) {
         const observed = await bornObservation(paths, expected, () => readHeart(paths), snapshot);
@@ -16,17 +16,20 @@ export async function fleetListRow(paths, expected) {
             lifeAt: lifeAt(observed.currentLife, observed.snapshot.latestBody, observed.snapshot.latestKill, observed.soul.createdAt),
             lastActivityAt: observed.snapshot.lastActivityAt,
             pending: observed.snapshot.pending.map((tell) => tell.id),
+            aliases,
         };
     }
     try {
         if ((await probeLeash(paths)) === "held")
-            return { id: expected, life: "unborn" };
+            return { id: expected, life: "unborn", aliases };
         const seal = await readSeal(paths);
-        return seal === null ? { id: expected, life: "unborn" } : { id: expected, life: "stillborn", seal };
+        return seal === null
+            ? { id: expected, life: "unborn", aliases }
+            : { id: expected, life: "stillborn", seal, aliases };
     }
     catch (error) {
         if (isHeartAbsent(error))
-            return { id: expected, life: "unborn" };
+            return { id: expected, life: "unborn", aliases };
         throw error;
     }
 }
@@ -77,7 +80,6 @@ export async function bornLiveStatus(paths, expected, input) {
             life: currentLife,
             cwd: soul.cwd,
             allowed: soul.allowed,
-            ...(soul.readonly === undefined ? {} : { readonly: soul.readonly }),
             ...(resumeUnsupported ? { strandedReason: "resume-unsupported" } : {}),
             timeline: selected.snapshot,
         },
@@ -89,9 +91,6 @@ export async function bornStatus(paths, expected, input) {
     const { rows: _rows, ...status } = await bornLiveStatus(paths, expected, input);
     return status;
 }
-export async function readBudgetedStatus(worldPath, id, input) {
-    return await bornStatus(pathsForAkuId(worldPath, id), id, input);
-}
 export async function readLiveStatus(worldPath, id, input) {
     return await bornLiveStatus(pathsForAkuId(worldPath, id), id, input);
 }
@@ -136,23 +135,6 @@ export async function waitForObservation(input) {
             : Math.min(OBSERVATION_POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
     }
 }
-/**
- * Successive status observations of one already born Akuma until its
- * observation window closes. Every acquired observation is reported to
- * `observe` before completion or deadline judgment, including the first
- * already-complete observation; the last status is returned.
- */
-export async function observeAkumaStatus(worldPath, expected, input) {
-    const paths = pathsForAkuId(worldPath, expected);
-    const waited = await waitForObservation({
-        timeoutMs: input.timeoutMs,
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-        observe: async () => await bornLiveStatus(paths, expected, { aperture: "monitoring" }),
-        complete: (observation) => defaultWaitComplete(observation.status),
-        onObserve: input.observe,
-    });
-    return { reason: waited.reason, status: waited.value.status };
-}
 export async function readAkumaBirthCwd(worldPath, id) {
     const soul = await readSoul(pathsForAkuId(worldPath, id));
     if (soul === null)