@astrosheep/keiyaku 4.6.4 → 4.6.6

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-akuma/SKILL.md

@@ -16,6 +16,12 @@ shorter, world-local name.
 
 ## Call a new Akuma
 
+```bash
+keiyaku call worker "Summarize the recent changes in src/cli"
+keiyaku call worker --alias @reviewer --wait 10m - < brief.md
+keiyaku call worker
+```
+
 The prompt is optional for prompt-free birth. Otherwise it is the new Akuma's
 first prompt: give it as one argument, or use `-` to read stdin, never both.
 Calls are detached by default: they return the new identity after birth without
@@ -34,34 +40,57 @@ capabilities, not merely for parallelism.
 `--contract` only records the association. It does not tell the Akuma the
 Contract or worktree. Put them in the prompt explicitly:
 
-```text
-Contract: <kei/...>
-Worktree: <exact path>
-This Arc: <what to do>
+```bash
+keiyaku call worker --contract kei/add-rate-limit-a1b2 --workdir /path/to/worktree - <<'EOF'
+Contract: kei/add-rate-limit-a1b2
+Worktree: /path/to/worktree
+This Arc: implement the limiter and its tests
+EOF
 ```
 
 `--contract` does not choose a worktree. Use `--workdir <path>` when needed.
 
 ## Tell or ask an existing Akuma
 
+```bash
+keiyaku tell @reviewer "The candidate moved; re-examine the worktree"
+keiyaku tell @reviewer --interrupt - < new-priority.md
+keiyaku ask @reviewer --wait 10m "What is your verdict?"
+keiyaku ask @reviewer --schema verdict.schema.json - < question.md
+```
+
 `tell` admits the next instruction and returns its admission receipt; it does
 not await an answer. `ask` admits a Tell and observes that exact answer,
 unbounded unless `--wait` limits observation. Both require a prompt and accept
 `--interrupt` to put down current work before admitting the new Tell. Schema
 belongs only to `ask`; `tell --schema` and `tell --wait` refuse and point to
 `ask`. A deadline never withdraws an admitted Tell. Read `tell --help` and
-`ask --help` for invocation syntax.
+`ask --help` for the complete flag grammar.
 
 ## Observe work
 
+```bash
+keiyaku wait @deliverer @reviewer
+keiyaku wait --all --timeout 30m @deliverer @reviewer
+```
+
 Use `wait` for one or more existing Akumas. The default is `--any`; use
 `--all` for every selected Akuma. `--timeout` limits observation and does not
 stop workers. A completed Akuma already counts, so repeating a wait can return
-immediately. See `wait --help` for syntax. Unlike `ask`, `wait` observes
-existing Akuma-wide work, not the answer to a newly admitted Tell.
+immediately. See `wait --help` for the complete grammar. Unlike `ask`, `wait`
+observes existing Akuma-wide work, not the answer to a newly admitted Tell.
 
 ## Inspect and retrieve results
 
+```bash
+keiyaku status
+keiyaku status @reviewer
+keiyaku ls aku/
+keiyaku ls "aku/*/*"
+keiyaku history @reviewer --last
+keiyaku history @reviewer --id turn/3
+```
+
 `status` shows the roster or one Akuma's workdir and effective actions.
 `ls aku/` shows callable names; `ls "aku/*/*"` shows born workers.
 `history --last` reads the latest complete answer; `history --id` reads an
@@ -70,10 +99,16 @@ move; see `history --help` for paging.
 
 ## Stop and branch
 
+```bash
+keiyaku kill @reviewer
+keiyaku fork @reviewer --at turn/3
+```
+
 `kill` stops current work without admitting a Tell, deleting the Akuma, or
 removing its history. `fork` creates a new Akuma from one exact retained
 answered history point; the source is unchanged, and providers that cannot
-fork report that refusal. See the `kill --help` and `fork --help` syntax.
+fork report that refusal. See `kill --help` and `fork --help` for the
+complete grammar.
 
 ## JavaScript automation
 

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-bind/SKILL.md

@@ -154,14 +154,13 @@ fence containing commands runnable as written. Use separate fences when checks
 need different timeouts or results. Use an explicit timeout for bounded
 commands; `5m` is the normal baseline.
 
-Verification runs against the exact integration snapshot in a clean disposable
-worktree for that attempt. It does not run in the author's worktree or the
-target checkout. If the Contract declares Verification, `deliver` runs it when
-no current `verified` attestation exists and otherwise reuses the current
-attestation. A newly run unsatisfied result stops that delivery. `audit` runs
-Verification for a prospective candidate. `--gates reviewed` requires review
-evidence; it does not select or suppress Verification. Selected gates are
-checked at placement.
+Verification runs only when the Contract selects the `verified` gate, against
+the exact integration snapshot in a clean disposable worktree for that attempt.
+`deliver` reuses current satisfied evidence or runs the declarations; unsatisfied
+results and runtime stops prevent placement. `audit` runs declarations for a
+prospective candidate. Without `verified`, no verb runs Verification and the
+section is inert document text. `reviewed` independently requires review
+evidence. Selected gates are checked at placement.
 
 For an existing Task with real scheduling or dependency value:
 

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-workflow/SKILL.md

@@ -72,9 +72,9 @@ Each act changes a different part of the world:
   audit; when it matters, merge the target branch (main when selected) in the
   worktree and resolve conflicts there before auditing.
 - **Audit:** Previews the candidate and target without tendering or claiming.
-  Declared Verification can record a `verified` attestation for the captured
-  subject; current evidence is reused. No declaration or a stopped run records
-  no new verdict.
+  With `verified` selected, Verification runs for the captured subject and can
+  record an attestation. Without that gate, the section is inert text and no
+  verb runs Verification. A stopped run records no new verdict.
 - **Deliver:** Captures a tender and integration against the observed target;
   journal gains a delivered candidate. Ready prerequisites and gates trigger
   placement and claim in this invocation; otherwise the candidate waits.

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

@@ -1,5 +1,5 @@
 import { type AkuId, type AkumaPaths } from "./identity.js";
-import { selectHistory, type ActivityHistory, type ActivityRow, type ActivitySnapshot } from "./projection.js";
+import { selectHistory, selectSnapshot, type ActivityHistory, type ActivityRow, type ActivitySnapshot, type TurnLedger } from "./projection.js";
 import type { WorldRoot } from "../world.js";
 import type { AkumaAlias } from "../identity/selector.js";
 import type { AkumaListRow, AkumaStatus, UnbornAkumaListRow } from "./akuma.js";
@@ -16,24 +16,27 @@ type BudgetedStatusObservation = Readonly<{
 export type LiveStatusObservation = BudgetedStatusObservation & Readonly<{
     rows: readonly ActivityRow[];
 }>;
-/** Internal live companion for an observation loop; it is not a public result. */
-export declare function bornLiveStatus(paths: AkumaPaths, expected: AkuId, input: Readonly<{
-    aperture: "monitoring" | "receipt";
-    ordinaryBudget?: number;
-    admittedTellId?: string;
-}>): Promise<LiveStatusObservation>;
-export declare function bornStatus(paths: AkumaPaths, expected: AkuId, input: Readonly<{
-    aperture: "monitoring" | "receipt";
-    ordinaryBudget?: number;
-    admittedTellId?: string;
-}>): Promise<BudgetedStatusObservation>;
-export declare function readLiveStatus(worldPath: WorldRoot, id: AkuId, input: Readonly<{
+type StatusObservationInput = Readonly<{
     aperture: "monitoring" | "receipt";
     ordinaryBudget?: number;
     admittedTellId?: string;
-}>): Promise<LiveStatusObservation>;
+}>;
+type StatusProjection = Readonly<{
+    ledger: TurnLedger;
+    selected: ReturnType<typeof selectSnapshot>;
+}>;
+/** Private to a live wait: retain only this member's current frontier and last selection. */
+export declare function createLiveStatusReader(paths: AkumaPaths, expected: AkuId): {
+    clear: () => void;
+    read(input: StatusObservationInput, signal?: AbortSignal): Promise<LiveStatusObservation>;
+};
+/** Internal live companion for an observation loop; it is not a public result. */
+export declare function bornLiveStatus(paths: AkumaPaths, expected: AkuId, input: StatusObservationInput, signal?: AbortSignal, readProjection?: () => Promise<StatusProjection>): Promise<LiveStatusObservation>;
+export declare function bornStatus(paths: AkumaPaths, expected: AkuId, input: StatusObservationInput): Promise<BudgetedStatusObservation>;
+export declare function readLiveStatus(worldPath: WorldRoot, id: AkuId, input: StatusObservationInput, signal?: AbortSignal): Promise<LiveStatusObservation>;
 export declare function defaultWaitComplete(status: AkumaStatus): boolean;
-export declare function readWaitComplete(worldPath: WorldRoot, id: AkuId): Promise<boolean>;
+/** Probe completion only; returned statuses still come from a full observation. */
+export declare function readWaitComplete(worldPath: WorldRoot, ids: readonly AkuId[], completion: "any" | "all", signal?: AbortSignal): Promise<boolean>;
 export type WaitReason = "completed" | "deadline";
 /**
  * The one deadline-aware observation loop for public Akuma waiting.  It always

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,56 @@ async function bornObservation(paths, expected, read, snapshot) {
         claim?.release();
     }
 }
+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 +122,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 +143,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-wait.d.ts

@@ -53,9 +53,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, 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,67 @@ 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) => {
+            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/call-initial-tell.d.ts

@@ -78,8 +78,8 @@ export declare const tellResultSchema: z.ZodObject<{
             }>;
             turnSequence: z.ZodNumber;
             receipt: z.ZodOptional<z.ZodEnum<{
-                required: "required";
                 unavailable: "unavailable";
+                required: "required";
             }>>;
         }, z.core.$strict>, z.ZodTransform<Readonly<{
             turnSequence: number;
@@ -90,7 +90,7 @@ export declare const tellResultSchema: z.ZodObject<{
             deliveredAt: string;
             route: "live" | "launch";
             turnSequence: number;
-            receipt?: "required" | "unavailable" | undefined;
+            receipt?: "unavailable" | "required" | undefined;
         }>>>>;
     }, z.core.$strict>;
     wake: z.ZodUnion<readonly [z.ZodObject<{

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

@@ -37,7 +37,7 @@ export async function admitCallInitialTell(input) {
     const birth = await waitForObservation({
         timeoutMs: BIRTH_TIMEOUT_MS,
         ...(input.signal === undefined ? {} : { signal: input.signal }),
-        probe: async () => await readWaitComplete(input.world, input.id),
+        probe: async () => await readWaitComplete(input.world, [input.id], "all", input.signal),
         observe: async () => (await bornStatus(paths, input.id, { aperture: "receipt" })).status,
         complete: defaultWaitComplete,
     });

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

@@ -206,8 +206,8 @@ declare const liveResultSchema: z.ZodObject<{
                 }>;
                 turnSequence: z.ZodNumber;
                 receipt: z.ZodOptional<z.ZodEnum<{
-                    required: "required";
                     unavailable: "unavailable";
+                    required: "required";
                 }>>;
             }, z.core.$strict>, z.ZodTransform<Readonly<{
                 turnSequence: number;
@@ -218,7 +218,7 @@ declare const liveResultSchema: z.ZodObject<{
                 deliveredAt: string;
                 route: "live" | "launch";
                 turnSequence: number;
-                receipt?: "required" | "unavailable" | undefined;
+                receipt?: "unavailable" | "required" | undefined;
             }>>>>;
         }, z.core.$strict>;
         wake: z.ZodUnion<readonly [z.ZodObject<{

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

@@ -23,12 +23,17 @@ export type ActivitySlice = ActivityFactSlice;
 export type { ActivityFact };
 export type { TimelineFact } from "./timeline.js";
 export declare function activitySlice(paths: AkumaPaths): Promise<ActivitySlice>;
-export declare function readStatusFacts(paths: AkumaPaths, input: StatusFactInput): Promise<ActivitySlice["rows"]>;
+export declare function readStatusFacts(paths: AkumaPaths, input: StatusFactInput, signal?: AbortSignal): Promise<ActivitySlice["rows"]>;
+/** One live observation's successful raw input and decoded frontier, never a connection. */
+export declare function createStatusFactReader(paths: AkumaPaths): {
+    clear(): void;
+    read(input: StatusFactInput, signal?: AbortSignal): Promise<ActivitySlice["rows"]>;
+};
 type LifeSnapshot = Pick<HeartSnapshot, "soul" | "latestBody" | "latestSession" | "latestKill"> & Readonly<{
     hasPendingTell: boolean;
 }>;
 /** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
-export declare function readLifeSnapshot(paths: AkumaPaths): Promise<LifeSnapshot>;
+export declare function readLifeSnapshot(paths: AkumaPaths, signal?: AbortSignal): Promise<LifeSnapshot>;
 export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">, options?: Readonly<{
     interrupt?: boolean;
 }>): Promise<Readonly<{