@astrosheep/keiyaku 4.6.4 → 4.6.7

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

@@ -1,4 +1,4 @@
-import { readStatusFacts, readLifeSnapshot, HeldAkumaLeash, isHeartAbsent, life, lifeAt, probeLeash, readHeart, readSeal, readSoul, } from "./heart/index.js";
+import { readStatusFacts, createStatusFactReader, readLifeSnapshot, HeldAkumaLeash, isHeartAbsent, life, lifeAt, probeLeash, readHeart, readSeal, readSoul, } from "./heart/index.js";
 import { pathsForAkuId } from "./identity.js";
 import { ordinarySnapshotBudget, projectTurns, selectHistory, selectSnapshot, } from "./projection.js";
 import { resolveProviderExecution } from "./providers/index.js";
@@ -59,21 +59,68 @@ async function bornObservation(paths, expected, read, snapshot) {
         claim?.release();
     }
 }
+export async function observeOutcomeRows(id, rows, observer) {
+    if (observer === undefined)
+        return;
+    const historyIds = rows.flatMap((row) => (row.kind === "outcome" ? [row.outcome.historyId] : []));
+    if (historyIds.length > 0)
+        await observer(id, historyIds);
+}
+export async function observeStatusOutcome(status, observer) {
+    const snapshot = status.timeline;
+    if (snapshot.kind === "idle" && snapshot.outcome !== undefined)
+        await observer?.(status.id, [snapshot.outcome.outcome.historyId]);
+}
+function snapshotSelection(input) {
+    return {
+        aperture: input.aperture,
+        budget: ordinarySnapshotBudget(input.ordinaryBudget),
+        ...(input.admittedTellId === undefined ? {} : { admittedTellId: input.admittedTellId }),
+    };
+}
+/** Private to a live wait: retain only this member's current frontier and last selection. */
+export function createLiveStatusReader(paths, expected) {
+    const reader = createStatusFactReader(paths);
+    let memo;
+    const clear = () => {
+        reader.clear();
+        memo = undefined;
+    };
+    return {
+        clear,
+        async read(input, signal) {
+            try {
+                return await bornLiveStatus(paths, expected, input, signal, async () => {
+                    const facts = await reader.read(input, signal);
+                    const ledger = memo?.facts === facts ? memo.ledger : projectTurns(facts);
+                    const options = snapshotSelection(input);
+                    const selected = memo?.ledger === ledger &&
+                        memo.options.aperture === options.aperture &&
+                        memo.options.admittedTellId === options.admittedTellId &&
+                        memo.options.budget.tail === options.budget.tail &&
+                        memo.options.budget.voice === options.budget.voice
+                        ? memo.selected
+                        : selectSnapshot(ledger, options);
+                    memo = { facts, ledger, options, selected };
+                    return { ledger, selected };
+                });
+            }
+            catch (error) {
+                clear();
+                throw error;
+            }
+        },
+    };
+}
 /** Internal live companion for an observation loop; it is not a public result. */
-export async function bornLiveStatus(paths, expected, input) {
+export async function bornLiveStatus(paths, expected, input, signal, readProjection) {
     if (input.ordinaryBudget !== undefined && (!Number.isSafeInteger(input.ordinaryBudget) || input.ordinaryBudget < 0))
         throw new TypeError("ordinary budget must be a nonnegative safe integer");
-    const { snapshot, soul, currentLife } = await bornObservation(paths, expected, () => readLifeSnapshot(paths));
+    const { snapshot, soul, currentLife } = await bornObservation(paths, expected, () => readLifeSnapshot(paths, signal));
     const resumeUnsupported = currentLife === "stranded" &&
         snapshot.latestSession?.provider === soul.provider.name &&
         (await resolveProviderExecution(soul.provider)).adapter.resume === undefined;
-    const facts = await readStatusFacts(paths, input);
-    const ledger = projectTurns(facts);
-    const selected = selectSnapshot(ledger, {
-        aperture: input.aperture,
-        budget: ordinarySnapshotBudget(input.ordinaryBudget),
-        ...(input.admittedTellId === undefined ? {} : { admittedTellId: input.admittedTellId }),
-    });
+    const { ledger, selected } = readProjection === undefined ? await readStatusProjection(paths, input, signal) : await readProjection();
     return {
         status: {
             id: soul.id,
@@ -87,12 +134,20 @@ export async function bornLiveStatus(paths, expected, input) {
         rows: ledger.rows,
     };
 }
+async function readStatusProjection(paths, input, signal) {
+    const facts = await readStatusFacts(paths, input, signal);
+    const ledger = projectTurns(facts);
+    return {
+        ledger,
+        selected: selectSnapshot(ledger, snapshotSelection(input)),
+    };
+}
 export async function bornStatus(paths, expected, input) {
     const { rows: _rows, ...status } = await bornLiveStatus(paths, expected, input);
     return status;
 }
-export async function readLiveStatus(worldPath, id, input) {
-    return await bornLiveStatus(pathsForAkuId(worldPath, id), id, input);
+export async function readLiveStatus(worldPath, id, input, signal) {
+    return await bornLiveStatus(pathsForAkuId(worldPath, id), id, input, signal);
 }
 function complete(life, pending) {
     return life !== "running" && !pending;
@@ -100,10 +155,26 @@ function complete(life, pending) {
 export function defaultWaitComplete(status) {
     return complete(status.life, status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending"));
 }
-export async function readWaitComplete(worldPath, id) {
-    const paths = pathsForAkuId(worldPath, id);
-    const observed = await bornObservation(paths, id, () => readLifeSnapshot(paths));
-    return complete(observed.currentLife, observed.snapshot.hasPendingTell);
+/** Probe completion only; returned statuses still come from a full observation. */
+export async function readWaitComplete(worldPath, ids, completion, signal) {
+    let completed = 0;
+    for (const id of ids) {
+        signal?.throwIfAborted();
+        try {
+            const paths = pathsForAkuId(worldPath, id);
+            const observed = await bornObservation(paths, id, () => readLifeSnapshot(paths, signal));
+            if (complete(observed.currentLife, observed.snapshot.hasPendingTell)) {
+                if (completion === "any")
+                    return true;
+                completed += 1;
+            }
+        }
+        catch (error) {
+            if (ids.length === 1 || error instanceof AkumaNotBornError)
+                throw error;
+        }
+    }
+    return ids.length > 0 && completed === ids.length;
 }
 const OBSERVATION_POLL_MS = 100;
 /**

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

@@ -1,5 +1,5 @@
 import type { WorldRoot } from "../world.js";
-import { type LiveStatusObservation, type WaitReason } from "./akuma-observe.js";
+import { type OutcomeObserver, type LiveStatusObservation, type WaitReason } from "./akuma-observe.js";
 import type { AkumaStatus } from "./akuma.js";
 import { type TellResult, type TellWakeRuntime } from "./body.js";
 import { type CallInitialTell, type CallInitialTellAdmission } from "./call-initial-tell.js";
@@ -68,7 +68,8 @@ export declare function killAkumaWithRecovery(paths: AkumaPaths, recover?: (path
 export declare class AkumaOwner {
     readonly id: AkuId;
     private readonly worldPath;
-    constructor(id: AkuId, worldPath: WorldRoot);
+    private readonly outcomeObserved?;
+    constructor(id: AkuId, worldPath: WorldRoot, outcomeObserved?: OutcomeObserver | undefined);
     private get paths();
     private projectHistoryTurns;
     private exactHistory;

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

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
-import { bornLiveStatus, bornStatus, defaultWaitComplete, waitForObservation, } from "./akuma-observe.js";
+import { bornLiveStatus, bornStatus, defaultWaitComplete, observeOutcomeRows, observeStatusOutcome, waitForObservation, } from "./akuma-observe.js";
 import { executeWaitAkuma } from "./akuma-wait.js";
 import { handoffPendingTells, spawnAkumaBody, wakeRecordedTell, } from "./body.js";
 import { admitCallInitialTell } from "./call-initial-tell.js";
@@ -88,9 +88,11 @@ export async function killAkumaWithRecovery(paths, recover, signal) {
 export class AkumaOwner {
     id;
     worldPath;
-    constructor(id, worldPath) {
+    outcomeObserved;
+    constructor(id, worldPath, outcomeObserved) {
         this.id = id;
         this.worldPath = worldPath;
+        this.outcomeObserved = outcomeObserved;
     }
     get paths() {
         return pathsForAkuId(this.worldPath, this.id);
@@ -109,11 +111,17 @@ export class AkumaOwner {
         return selectExactHistory((await this.projectHistoryTurns()).rows, input.id);
     }
     async status() {
-        return (await bornStatus(this.paths, this.id, { aperture: "monitoring" })).status;
+        const { status } = await bornStatus(this.paths, this.id, { aperture: "monitoring" });
+        await observeStatusOutcome(status, this.outcomeObserved);
+        return status;
     }
     async history(input = {}) {
-        if (input.id !== undefined)
-            return this.exactHistory(input);
+        if (input.id !== undefined) {
+            const exact = await this.exactHistory(input);
+            if (exact.kind === "exact")
+                await this.outcomeObserved?.(this.id, [exact.outcome.outcome.historyId]);
+            return exact;
+        }
         if (input.before !== undefined && input.since !== undefined) {
             throw new TypeError("Akuma history before and since are mutually exclusive");
         }
@@ -129,11 +137,13 @@ export class AkumaOwner {
         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");
         }
-        return selectHistory(await this.projectHistoryTurns(), {
+        const history = selectHistory(await this.projectHistoryTurns(), {
             ...(input.before === undefined ? {} : { before: input.before }),
             ...(input.since === undefined ? {} : { since: input.since }),
             limit,
         });
+        await observeOutcomeRows(this.id, history.rows, this.outcomeObserved);
+        return history;
     }
     async waitReceipt(predicate = defaultWaitComplete, options = {}) {
         if (options.timeoutMs !== undefined && (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 0)) {
@@ -143,6 +153,7 @@ export class AkumaOwner {
             path: this.worldPath,
             ids: [this.id],
             completion: "all",
+            ...(this.outcomeObserved === undefined ? {} : { outcomeObserved: this.outcomeObserved }),
             ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
             ...(options.signal === undefined ? {} : { signal: options.signal }),
             ...(predicate === defaultWaitComplete ? {} : { predicate }),
@@ -220,6 +231,8 @@ export class AkumaOwner {
                 if (tell === null)
                     throw new AkumaProviderError(`recorded Tell ${tellId} is missing from Heart`);
                 const outcome = await this.boundTellOutcome(tell);
+                if (outcome.historyId !== undefined)
+                    await this.outcomeObserved?.(this.id, [outcome.historyId]);
                 if (options.observe !== undefined) {
                     await options.observe(await bornLiveStatus(this.paths, this.id, { aperture: "monitoring", admittedTellId: tellId }));
                 }
@@ -237,7 +250,11 @@ export class AkumaOwner {
         if (tell.binding === undefined)
             return { outcome: null, completedAt: null };
         const end = (await readTurn(this.paths, tell.binding.turnSequence))?.end;
-        return { outcome: end?.outcome ?? null, completedAt: end?.completedAt ?? null };
+        return {
+            outcome: end?.outcome ?? null,
+            completedAt: end?.completedAt ?? null,
+            ...(end === undefined ? {} : { historyId: `turn/${tell.binding.turnSequence}` }),
+        };
     }
     async interrupt(body, options = {}) {
         const admitted = await this.admitInterrupt(body, options);
@@ -369,9 +386,10 @@ export class AkumaOwner {
     }
     async lastAnswer() {
         const turn = await readLastAnsweredTurn(this.paths);
-        return turn?.end?.outcome.kind === "answered"
-            ? { kind: "answer", answer: turn.end.outcome.answer }
-            : { kind: "no-answer" };
+        if (turn?.end?.outcome.kind !== "answered")
+            return { kind: "no-answer" };
+        await this.outcomeObserved?.(this.id, [`turn/${turn.sequence}`]);
+        return { kind: "answer", answer: turn.end.outcome.answer };
     }
 }
 /* ---------------------------------------------------------------------------

package/build/src/akuma/akuma-selection-execution.d.ts

@@ -1,5 +1,5 @@
 import type { WorldRoot } from "../world.js";
-import type { LiveStatusObservation } from "./akuma-observe.js";
+import type { LiveStatusObservation, OutcomeObserver } from "./akuma-observe.js";
 import type { AkumaStatus } from "./akuma.js";
 import type { TellResult } from "./body.js";
 import type { Schema } from "./schema.js";
@@ -18,6 +18,7 @@ type TellExecutionInput = Readonly<{
     signal?: AbortSignal;
     interrupt?: boolean;
     onObserve?: AskObserver;
+    outcomeObserved?: OutcomeObserver;
 }>;
 export declare function executeTellAkuma(input: TellExecutionInput): Promise<AkumaTellResult>;
 export declare function decodeAskObservation<T>(observation: AkumaAskObservation, schema: Schema<T>): AkumaAskObservation<T>;
@@ -37,6 +38,7 @@ export declare function observeAdmittedAskAkuma(input: Readonly<{
      */
     receipt?: TellResult;
     onObserve?: AskObserver;
+    outcomeObserved?: OutcomeObserver;
 }>): Promise<AkumaAskResult>;
 export declare function executeAskAkuma(input: TellExecutionInput & Readonly<{
     timeoutMs?: number;

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

@@ -64,7 +64,7 @@ export function decodeAskObservation(observation, schema) {
     }
 }
 export async function observeAdmittedAskAkuma(input) {
-    const owner = new AkumaOwner(input.id, input.path);
+    const owner = new AkumaOwner(input.id, input.path, input.outcomeObserved);
     const tell = input.receipt ?? (await owner.admittedReceipt(input.tellId));
     await input.onObserve?.admitted?.(tell, input.id);
     let settled;
@@ -118,6 +118,7 @@ export async function executeAskAkuma(input) {
         wake: admission.wake,
         ...(input.signal === undefined ? {} : { signal: input.signal }),
         ...(input.onObserve === undefined ? {} : { onObserve: input.onObserve }),
+        ...(input.outcomeObserved === undefined ? {} : { outcomeObserved: input.outcomeObserved }),
     });
 }
 export async function executeKillAkuma(input) {

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

@@ -1,6 +1,6 @@
 import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
-import { type WaitReason } from "./akuma-observe.js";
+import { type OutcomeObserver, type WaitReason } from "./akuma-observe.js";
 import type { AkumaStatus } from "./akuma.js";
 import type { DispatchAssociation } from "./dispatch-association.js";
 import type { ActivityRow } from "./projection.js";
@@ -33,6 +33,7 @@ type WaitExecutionInput = Readonly<{
     signal?: AbortSignal;
     /** Internal custom completion judge over the full final observation where supplied. */
     predicate?: (status: AkumaStatus) => boolean;
+    outcomeObserved?: OutcomeObserver;
     /** Resolves one Akuma's identity facts; consulted once per Akuma a viewer first sees. */
     identity?: (id: AkumaStatus["id"]) => Promise<WaitIdentityFacts>;
     /** The selected set in the caller's order; a viewer's head and scoreboard follow it. */
@@ -53,9 +54,10 @@ export type NativeWaitResult = Readonly<{
  * The one lower set-observation owner for Akuma wait completion. It serves the
  * standalone one-ID association-free face and the plural any/all face with one
  * ordered round algorithm, one shared ordinary-detail budget, transient
- * unreadable peers, and an honest final deadline edge. The default completion
- * probe is used only without live row callbacks and never with a custom
- * predicate; a live viewer always observes rounds.
+ * unreadable peers, and an honest final deadline edge. A silent observation —
+ * no live row callback and no custom judge — decides which running rounds to
+ * skip with the owner's lightweight completion probe over the selected set; a
+ * live viewer or a custom judge always observes full rounds.
  */
 export declare function executeWaitAkuma(input: WaitExecutionInput): Promise<NativeWaitResult>;
 export {};

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

@@ -1,10 +1,22 @@
 import { AkumaNotBornError } from "./akuma-errors.js";
-import { defaultWaitComplete, readLiveStatus, readWaitComplete, waitForObservation, } from "./akuma-observe.js";
+import { createLiveStatusReader, defaultWaitComplete, readLiveStatus, readWaitComplete, observeOutcomeRows, observeStatusOutcome, waitForObservation, } from "./akuma-observe.js";
+import { pathsForAkuId } from "./identity.js";
 const SHARED_ORDINARY_BUDGET = 30;
-async function observeWaitRound(path, ids, signal) {
+async function observeWaitRound(path, ids, signal, readers) {
+    const read = async (id, ordinaryBudget) => {
+        const options = { aperture: "monitoring", ...(ordinaryBudget === undefined ? {} : { ordinaryBudget }) };
+        if (readers === undefined)
+            return await readLiveStatus(path, id, options, signal);
+        let reader = readers.get(id);
+        if (reader === undefined) {
+            reader = createLiveStatusReader(pathsForAkuId(path, id), id);
+            readers.set(id, reader);
+        }
+        return await reader.read(options, signal);
+    };
     signal?.throwIfAborted();
     if (ids.length <= 1) {
-        const observations = await Promise.all(ids.map(async (id) => await readLiveStatus(path, id, { aperture: "monitoring" })));
+        const observations = await Promise.all(ids.map(async (id) => await read(id)));
         return { observations, unobserved: [] };
     }
     let remaining = SHARED_ORDINARY_BUDGET;
@@ -13,11 +25,13 @@ async function observeWaitRound(path, ids, signal) {
     for (const id of ids) {
         signal?.throwIfAborted();
         try {
-            const observed = await readLiveStatus(path, id, { aperture: "monitoring", ordinaryBudget: remaining });
+            const observed = await read(id, remaining);
             observations.push(observed);
             remaining -= observed.ordinarySelected;
         }
         catch (error) {
+            readers?.get(id)?.clear();
+            readers?.delete(id);
             if (error instanceof AkumaNotBornError)
                 throw error;
             unobserved.push({ id, diagnostic: diagnostic(error) });
@@ -54,59 +68,70 @@ function selectionOrderedIds(ids, order) {
  * The one lower set-observation owner for Akuma wait completion. It serves the
  * standalone one-ID association-free face and the plural any/all face with one
  * ordered round algorithm, one shared ordinary-detail budget, transient
- * unreadable peers, and an honest final deadline edge. The default completion
- * probe is used only without live row callbacks and never with a custom
- * predicate; a live viewer always observes rounds.
+ * unreadable peers, and an honest final deadline edge. A silent observation —
+ * no live row callback and no custom judge — decides which running rounds to
+ * skip with the owner's lightweight completion probe over the selected set; a
+ * live viewer or a custom judge always observes full rounds.
  */
 export async function executeWaitAkuma(input) {
-    // Identity facts are read once per observed Akuma, not once per 100ms round.
-    const facts = new Map();
-    if (input.onSelected !== undefined) {
-        for (const id of input.ids) {
-            input.signal?.throwIfAborted();
-            const known = input.identity === undefined ? undefined : await input.identity(id);
-            facts.set(id, known ?? { contract: { kind: "none" } });
-        }
-        const ordered = input.selectionOrder === undefined ? input.ids : selectionOrderedIds(input.ids, input.selectionOrder);
-        input.onSelected(ordered.map((id) => ({ id, ...facts.get(id) })));
-    }
-    const observeRound = async (round) => {
-        if (input.observe === undefined)
-            return;
-        const observed = [];
-        for (const observation of round.observations) {
-            input.signal?.throwIfAborted();
-            const { status, rows } = observation;
-            let known = facts.get(status.id);
-            if (known === undefined && input.identity !== undefined) {
-                known = await input.identity(status.id);
-                facts.set(status.id, known);
-            }
-            if (known === undefined) {
-                observed.push({ status, rows, contract: { kind: "none" } });
-                continue;
+    const readers = input.observe === undefined ? undefined : new Map();
+    try {
+        // Identity facts are read once per observed Akuma, not once per 100ms round.
+        const facts = new Map();
+        if (input.onSelected !== undefined) {
+            for (const id of input.ids) {
+                input.signal?.throwIfAborted();
+                const known = input.identity === undefined ? undefined : await input.identity(id);
+                facts.set(id, known ?? { contract: { kind: "none" } });
             }
-            observed.push({ status, rows, ...known });
+            const ordered = input.selectionOrder === undefined ? input.ids : selectionOrderedIds(input.ids, input.selectionOrder);
+            input.onSelected(ordered.map((id) => ({ id, ...facts.get(id) })));
         }
-        input.observe(observed);
-    };
-    const live = input.observe !== undefined;
-    const waited = await waitForObservation({
-        ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-        ...(input.predicate === undefined && !live && input.ids.length === 1
-            ? { probe: async () => await readWaitComplete(input.path, input.ids[0]) }
-            : {}),
-        observe: async () => await observeWaitRound(input.path, input.ids, input.signal),
-        complete: (round) => roundComplete(round, input.completion, input.predicate),
-        onObserve: async (round) => await observeRound(round),
-    });
-    return {
-        mode: input.completion,
-        reason: waited.reason,
-        observations: waited.value.observations.map((observation) => observation.status),
-        unobserved: waited.value.unobserved,
-    };
+        const observeRound = async (round) => {
+            await Promise.all(round.observations.map(({ status, rows }) => input.observe === undefined
+                ? observeStatusOutcome(status, input.outcomeObserved)
+                : observeOutcomeRows(status.id, rows, input.outcomeObserved)));
+            if (input.observe === undefined)
+                return;
+            const observed = [];
+            for (const observation of round.observations) {
+                input.signal?.throwIfAborted();
+                const { status, rows } = observation;
+                let known = facts.get(status.id);
+                if (known === undefined && input.identity !== undefined) {
+                    known = await input.identity(status.id);
+                    facts.set(status.id, known);
+                }
+                if (known === undefined) {
+                    observed.push({ status, rows, contract: { kind: "none" } });
+                    continue;
+                }
+                observed.push({ status, rows, ...known });
+            }
+            input.observe(structuredClone(observed));
+        };
+        const waited = await waitForObservation({
+            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            ...(input.predicate === undefined && input.observe === undefined
+                ? { probe: async () => await readWaitComplete(input.path, input.ids, input.completion, input.signal) }
+                : {}),
+            observe: async () => await observeWaitRound(input.path, input.ids, input.signal, readers),
+            complete: (round) => roundComplete(round, input.completion, input.predicate),
+            onObserve: async (round) => await observeRound(round),
+        });
+        return {
+            mode: input.completion,
+            reason: waited.reason,
+            observations: waited.value.observations.map((observation) => observation.status),
+            unobserved: waited.value.unobserved,
+        };
+    }
+    finally {
+        for (const reader of readers?.values() ?? [])
+            reader.clear();
+        readers?.clear();
+    }
 }
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);

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

@@ -156,8 +156,8 @@ export declare const akumaStatusSchema: z.ZodObject<{
                     }>;
                     turnSequence: z.ZodNumber;
                     receipt: z.ZodOptional<z.ZodEnum<{
-                        required: "required";
                         unavailable: "unavailable";
+                        required: "required";
                     }>>;
                 }, z.core.$strict>, z.ZodTransform<Readonly<{
                     turnSequence: number;
@@ -168,7 +168,7 @@ export declare const akumaStatusSchema: z.ZodObject<{
                     deliveredAt: string;
                     route: "live" | "launch";
                     turnSequence: number;
-                    receipt?: "required" | "unavailable" | undefined;
+                    receipt?: "unavailable" | "required" | undefined;
                 }>>>>;
             }, z.core.$strict>]>, z.ZodObject<{
                 kind: z.ZodLiteral<"tool">;
@@ -363,8 +363,8 @@ export declare const akumaStatusSchema: z.ZodObject<{
                     }>;
                     turnSequence: z.ZodNumber;
                     receipt: z.ZodOptional<z.ZodEnum<{
-                        required: "required";
                         unavailable: "unavailable";
+                        required: "required";
                     }>>;
                 }, z.core.$strict>, z.ZodTransform<Readonly<{
                     turnSequence: number;
@@ -375,7 +375,7 @@ export declare const akumaStatusSchema: z.ZodObject<{
                     deliveredAt: string;
                     route: "live" | "launch";
                     turnSequence: number;
-                    receipt?: "required" | "unavailable" | undefined;
+                    receipt?: "unavailable" | "required" | undefined;
                 }>>>>;
             }, z.core.$strict>]>, z.ZodObject<{
                 kind: z.ZodLiteral<"tool">;
@@ -450,6 +450,8 @@ export declare function listAkumaArchetypes(path: WorldRoot, input?: Readonly<{
  * observed extent. World Alias context is attached by the upper composition.
  */
 export declare function readAkumaRoster(path: WorldRoot, input?: AkumaListInput): Promise<AkumaList>;
+/** Internal recent observation with an aperture already validated by the composition. */
+export declare function observeAkumaRoster(path: WorldRoot, limit: number, selected?: string): Promise<AkumaList>;
 /** The complete native roster for callers whose semantics require a frozen set. */
 export declare function readAkumaCompleteRoster(path: WorldRoot, input?: Readonly<{
     archetype?: string;

package/build/src/akuma/akuma.js

@@ -118,6 +118,10 @@ function rosterArchetype(input, allowLimit) {
 export async function readAkumaRoster(path, input = {}) {
     const selected = rosterArchetype(input, true);
     const limit = boundedListLimit(input.limit);
+    return observeAkumaRoster(path, limit, selected);
+}
+/** Internal recent observation with an aperture already validated by the composition. */
+export async function observeAkumaRoster(path, limit, selected) {
     const observedAt = new Date().toISOString();
     const known = await knownAkuma(path, selected);
     const candidatesWithBounds = await boundedMap(known.rows, async (row) => ({

package/build/src/akuma/body.d.ts

@@ -93,6 +93,7 @@ type BodyRuntime = Readonly<{
     world: WorldRoot;
     externalCommands: Readonly<Record<string, ErasedRequestCommand>>;
 }>;
+export declare function recordPluginDiagnostic(paths: AkumaPaths, occurrence: string, error: unknown): Promise<void>;
 export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string): Promise<{
     argv: string[];
     cwd: string;