@astrosheep/keiyaku 4.6.3 → 4.6.6

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

@@ -1,8 +1,9 @@
 ---
 name: keiyaku-akuma
 description: >-
-  Calling an Akuma: delegate work to a new or existing worker, then observe,
-  guide, and collect the result.
+  Use when the work involves Akuma or Aku, or when you want other hands on
+  it: delegating a job, or fanning out research, checks, or other parallel
+  work.
 ---
 
 # Keiyaku Akuma
@@ -15,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
@@ -22,7 +29,7 @@ waiting for the first answer. Use explicit `--wait <duration>` when this
 invocation should block while observing that initial work. `--wait` only bounds
 this command; it never stops the Akuma. Read `call --help` for flag syntax,
 defaults, and action vocabulary.
-For seat grants see `keiyaku-workflow`'s table; Reviewers need `--allowed contract.review`.
+To hand a Contract role to an Akuma, use the grant table in `keiyaku-workflow`.
 
 The selected Akuma name is a reusable worker configuration, not an individual.
 Calling it again creates an independent Akuma. Use different names for
@@ -33,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
@@ -69,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-akuma/references/automation.md

@@ -46,8 +46,8 @@ skeptics to break the finalists, and generate replacements only for the
 identified weaknesses. Bound rounds and cost; "keep improving" is not a useful
 stop condition.
 
-Independent judgment needs independent contexts. Create separate Akuma for
-blind comparisons or adversarial verification. Reuse an identity for follow-up
+Blind comparisons and adversarial checks need separate contexts. Create
+separate Akuma for them. Reuse an identity for follow-up
 investigation, not as a supposedly fresh judge of its own earlier answer.
 
 ## Public Entry And A Single Structured Turn

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

@@ -52,7 +52,7 @@ does not move without you.
 | Observed shape | First response |
 | --- | --- |
 | Silent wedge: initial answer empty and worktree clean | Inspect status and history, then send one steering `tell`. If the worker remains unresponsive, `kill` and call a new Akuma; an empty answer alone is not proof the Contract failed. |
-| Verdict record refused with `not-allowed` | Read the worker's analysis in history; call a new Reviewer with the grant from `keiyaku-workflow`, then have it inspect current work and record a fresh verdict. The refused request wrote no Contract testimony. |
+| Verdict record refused with `not-allowed` | Read the worker's analysis in history. Record the verdict yourself if you did not deliver the candidate, or call a new Reviewer with the grant from `keiyaku-workflow` and have it inspect current work and record a fresh verdict. The refused request wrote no Contract testimony. |
 | Review stale after changed candidate tender | Normal content-currentness result. Give the same Reviewer the changed diff and current terms with `tell`; have it re-examine and record current testimony. A target move alone does not stale review. |
 | Target moved under the appointed worktree | Have the Deliverer inspect target movement and merge the target branch (main when selected) in that worktree when required; resolve conflicts there, then audit again. Do not resolve against a stale integration preview. |
 | Typed refusal names its rule | Fix the named input or physical condition, then retry from a fresh observation. Do not repeat the same request blindly. |

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:
 
@@ -205,7 +204,7 @@ waiting, the stated prerequisites remain; do not bind a duplicate Contract.
 
 The holder now owns the lifecycle:
 
-1. Start the work directly or delegate Tasks, Arc chapters, Akumas, or seats.
+1. Start the work directly or delegate Tasks, Arc chapters, Akumas, or Contract roles.
 2. Run independent work in parallel and let it converge on the one acceptance
    boundary.
 3. Prepare and deliver the candidate.

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

@@ -38,13 +38,26 @@ to create parallel work.
 Use `after` only when one `kei` requires another to be accepted first. Ordinary
 overlap is not a dependency.
 
-## 3. Hold the `kei`
+## 3. Roles
 
-Every `kei` has exactly one holder. The holder coordinates the work and owns
-acceptance until the Contract is accepted or abandoned. Delegation does not
-transfer that responsibility. An Akuma holding the whole loop needs the `kei`, current Arc
-when one exists, appointed worktree, holder duties, and actions its commission
-will perform. Birth freezes permissions; Contract association grants none.
+A `kei` has three roles. They are responsibilities, not people, and one agent
+may fill more than one of them, with one exception below.
+
+- **Holder:** exactly one per `kei`. Owns the fulfillment loop and acceptance
+  until the Contract is accepted or abandoned. Handing work to others never
+  transfers this responsibility.
+- **Deliverer:** produces the candidate in the appointed worktree and tenders
+  it with `deliver`.
+- **Reviewer:** judges the complete Contract against its acceptance conditions
+  and records the verdict with `review`.
+
+Review is independent when the Reviewer did not deliver the candidate under
+review. That is the whole requirement. The holder may review its own `kei`; a
+fresh Akuma is not what makes review independent. Keiyaku does not check who
+reviews, so keeping the Reviewer apart from the Deliverer is the holder's duty.
+
+Any role may be filled directly or handed to an Akuma. Hand one over when other
+hands help the work, not to make review count.
 
 ## 4. Lifecycle
 
@@ -59,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.
@@ -78,31 +91,30 @@ Placement judges declared gates, not the producer's identity. Review does not
 replace Verification; audit never requests placement. Read the final receipt
 for stops and reconciliation lag after an admitted act.
 
-## 5. Seats And Capabilities
+## 5. Handing A Role To An Akuma
 
 This is the one commissioning map. `call --help` owns the exact action
-vocabulary and default set. `--contract` records association, not authority.
+vocabulary and default set. The flagship acting directly needs no grant.
+Birth freezes an Akuma's actions; `--contract` records association, not
+authority.
 
-| Seat | Grant and commission | Return |
+| Role | Grant at birth | Return |
 | --- | --- | --- |
-| Holder | Direct flagship commands need no Akuma grant. A delegated holder gets only its birth-time actions; include review when the delegated loop records review. | Own the acceptance loop and inspect receipts. |
-| Deliverer | The ordinary baseline includes every Task mutation, Contract audit and delivery, and Akuma management. `keiyaku -C <repo> call worker --alias @deliverer --contract <kei/...> --workdir <appointed-path> -` | Produce and tender the candidate; return the receipt. |
-| Reviewer | Add `--allowed contract.review` at birth: `keiyaku -C <repo> call review-akuma --alias @reviewer --contract <kei/...> --workdir <appointed-path> --allowed contract.review -` | Record a verdict and return its receipt. Without the grant, `not-allowed` refuses the mutation; no Contract verdict is recorded. |
+| Holder | The actions the delegated loop will perform; include `contract.review` when this holder will review. Commission with the `kei`, current Arc when one exists, appointed worktree, and holder duties. | Acceptance or abandonment, with receipts. |
+| Deliverer | The ordinary baseline: every Task mutation, Contract audit and delivery, and Akuma management. `keiyaku -C <repo> call worker --alias @deliverer --contract <kei/...> --workdir <appointed-path> -` | The delivery receipt. |
+| Reviewer | `--allowed contract.review`: `keiyaku -C <repo> call review-akuma --alias @reviewer --contract <kei/...> --workdir <appointed-path> --allowed contract.review -` | The verdict receipt. Without the grant, `not-allowed` refuses and no verdict is recorded. |
 
-An Archetype's explicit allowed set replaces the ordinary baseline. Check
+An Archetype's explicit allowed set replaces the ordinary baseline; check
 `status` for effective actions. `tell` and `fork` cannot add a grant to a live
-Akuma; call a fresh one with the grant. Nested calls cannot exceed their direct
-parent's actions.
-
-## 6. Delegate the Work
+Akuma, so call a fresh one with the grant. Nested calls cannot exceed their
+direct parent's actions.
 
 Commission with a clear objective, current Arc when one exists, appointed
-worktree, and expected result. A Deliverer produces the candidate. A Reviewer
-checks the complete Contract against its acceptance conditions and returns
-verdict evidence. Use `keiyaku-akuma` for invocation and observation, and
-command help for exact syntax.
+worktree, and expected result. Never ask the Akuma that delivered a candidate
+to review it. Use `keiyaku-akuma` for invocation and observation, and command
+help for exact syntax.
 
-## 7. Decide What Happens Next
+## 6. Decide What Happens Next
 
 The holder checks candidate, verification, review, prerequisites, and gates.
 

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);