@astrosheep/keiyaku 4.6.8 → 4.6.9

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

@@ -0,0 +1,116 @@
+import { isDeepStrictEqual } from "node:util";
+import { abortableDelay } from "./abort.js";
+import { AkumaNotBornError } from "./akuma-errors.js";
+import { OBSERVATION_POLL_MS } from "./akuma-observe.js";
+import { createTimelineReader } from "./heart/index.js";
+import { projectTurns, selectHistory } from "./projection.js";
+/** The fixed number of projected rows one window retains. */
+const STREAM_WINDOW = 500;
+/**
+ * The private end-of-observation reason. It is deliberately not the caller's
+ * abort reason: a returned observation completes, while an aborted one keeps
+ * the caller's own failure.
+ */
+const STREAM_RETURN = Symbol("akuma-stream-return");
+/**
+ * Announce each retained outcome identity once per observation, keeping only
+ * the identities the current window still carries, so a long stream remembers
+ * a bounded set rather than every outcome it ever saw.
+ */
+async function announceOutcomes(id, rows, observed, observe) {
+    const outcomes = new Set(rows.flatMap((row) => (row.kind === "outcome" ? [row.outcome.historyId] : [])));
+    const fresh = [...outcomes].filter((historyId) => !observed.has(historyId));
+    if (fresh.length > 0)
+        await observe?.(id, fresh);
+    return outcomes;
+}
+/**
+ * The observation loop itself. It decodes the retained timeline through the
+ * existing Turn projection on every pull and answers with the whole latest
+ * bounded window, holding only that window and one reader. Complete windows
+ * coalesce; they are not lossless event delivery, and the existing retention
+ * metadata keeps its honest meaning.
+ */
+async function* observeTimeline(paths, id, signal, observe) {
+    const reader = createTimelineReader(paths);
+    let released = false;
+    const release = () => {
+        if (released)
+            return;
+        released = true;
+        reader.clear();
+    };
+    let observedOutcomes = new Set();
+    let previous;
+    signal.addEventListener("abort", release, { once: true });
+    try {
+        for (;;) {
+            signal.throwIfAborted();
+            const read = await reader.read(signal);
+            signal.throwIfAborted();
+            if (read.changed) {
+                if (!read.born)
+                    throw new AkumaNotBornError(id);
+                const { rows, lowestRetained, highest } = read.slice;
+                const snapshot = selectHistory(projectTurns(rows, { lowestRetained, highest }), { limit: STREAM_WINDOW });
+                if (previous === undefined || !isDeepStrictEqual(snapshot, previous)) {
+                    observedOutcomes = await announceOutcomes(id, snapshot.rows, observedOutcomes, observe);
+                    previous = snapshot;
+                    yield snapshot;
+                }
+            }
+            await abortableDelay(OBSERVATION_POLL_MS, signal);
+        }
+    }
+    finally {
+        signal.removeEventListener("abort", release);
+        release();
+    }
+}
+/**
+ * The one continuous timeline observation as its caller sees it: pull-driven,
+ * so a slow consumer accumulates no queue.
+ *
+ * The observation runs behind this wrapper because a bare async generator
+ * cannot honour an end request while a pull is pending: `return()` would queue
+ * behind a pull that an idle timeline never settles, and the observation would
+ * hold its reader and its polling timer forever. The wrapper owns an internal
+ * controller instead, and the observation watches the caller's cancellation
+ * composed with it. `return` aborts that controller, which settles the pending
+ * poll and lets the loop release its reader in the same turn; because a
+ * composed signal keeps the reason of whichever source aborted first, an end
+ * request reads as completion while a caller's own abort keeps its own failure.
+ */
+export function createAkumaStream(paths, id, options = {}, observe) {
+    const caller = options.signal;
+    const control = new AbortController();
+    const signal = caller === undefined ? control.signal : AbortSignal.any([caller, control.signal]);
+    const observation = observeTimeline(paths, id, signal, observe);
+    let returning;
+    const next = async () => {
+        if (returning !== undefined)
+            return { done: true, value: undefined };
+        try {
+            return await observation.next();
+        }
+        catch (error) {
+            // An end request is completion, not the caller's failure to see.
+            if (signal.reason === STREAM_RETURN)
+                return { done: true, value: undefined };
+            throw error;
+        }
+    };
+    const end = (value) => {
+        if (returning === undefined) {
+            control.abort(STREAM_RETURN);
+            returning = observation.return(value).then((result) => ({ done: true, value: result.value }));
+        }
+        return returning;
+    };
+    const iterator = {
+        [Symbol.asyncIterator]: () => iterator,
+        next,
+        return: end,
+    };
+    return iterator;
+}

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

@@ -1,30 +1,7 @@
-import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.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";
 import type { AkumaUnobserved } from "./selection-observation.js";
-export type WaitIdentityFacts = Readonly<{
-    /** The alias currently addressing this Akuma in its world, when one is bound to it. */
-    alias?: AkumaAlias;
-    /** This Akuma's Dispatch association, read from the observing repository. */
-    contract: DispatchAssociation;
-}>;
-/** One observed Akuma as a live wait viewer sees it: its status plus its identity facts. */
-export type WaitObservedAkuma = Readonly<{
-    status: AkumaStatus;
-    rows: readonly ActivityRow[];
-}> & WaitIdentityFacts;
-/** One selected Akuma's frozen identity, resolved before the first observation round. */
-export type WaitSelectedAkuma = Readonly<{
-    id: AkumaStatus["id"];
-}> & WaitIdentityFacts;
-/** A live wait viewer: the frozen selected set, then every observation round. */
-export type WaitObserver = Readonly<{
-    selected?: (selected: readonly WaitSelectedAkuma[]) => void;
-    observe?: (observed: readonly WaitObservedAkuma[]) => void;
-}>;
 type WaitExecutionInput = Readonly<{
     path: WorldRoot;
     ids: readonly AkumaStatus["id"][];
@@ -34,14 +11,6 @@ type WaitExecutionInput = Readonly<{
     /** 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. */
-    selectionOrder?: readonly AkumaStatus["id"][];
-    /** Reports the frozen selected set before the first round, so a viewer can fix its layout. */
-    onSelected?: (selected: readonly WaitSelectedAkuma[]) => void;
-    /** Reports every observation round to a live viewer. */
-    observe?: (observed: readonly WaitObservedAkuma[]) => void;
 }>;
 /** One wait's association-free native evidence; upper composition attaches cross-product context. */
 export type NativeWaitResult = Readonly<{
@@ -50,14 +19,6 @@ export type NativeWaitResult = Readonly<{
     observations: readonly AkumaStatus[];
     unobserved: readonly AkumaUnobserved[];
 }>;
-/**
- * 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. 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.
- */
+/** Wait observes completion and returns final status snapshots, never a live stream. */
 export declare function executeWaitAkuma(input: WaitExecutionInput): Promise<NativeWaitResult>;
 export {};

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

@@ -1,19 +1,9 @@
 import { AkumaNotBornError } from "./akuma-errors.js";
-import { createLiveStatusReader, defaultWaitComplete, readLiveStatus, readWaitComplete, observeOutcomeRows, observeStatusOutcome, waitForObservation, } from "./akuma-observe.js";
+import { createLiveStatusReader, defaultWaitComplete, readWaitComplete, observeStatusOutcome, waitForObservation, } from "./akuma-observe.js";
 import { pathsForAkuId } from "./identity.js";
 const SHARED_ORDINARY_BUDGET = 30;
-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);
-    };
+async function observeWaitRound(ids, readerFor, signal) {
+    const read = (id, ordinaryBudget) => readerFor(id).read({ aperture: "monitoring", ...(ordinaryBudget === undefined ? {} : { ordinaryBudget }) }, signal);
     signal?.throwIfAborted();
     if (ids.length <= 1) {
         const observations = await Promise.all(ids.map(async (id) => await read(id)));
@@ -30,8 +20,6 @@ async function observeWaitRound(path, ids, signal, readers) {
             remaining -= observed.ordinarySelected;
         }
         catch (error) {
-            readers?.get(id)?.clear();
-            readers?.delete(id);
             if (error instanceof AkumaNotBornError)
                 throw error;
             unobserved.push({ id, diagnostic: diagnostic(error) });
@@ -45,80 +33,32 @@ function roundComplete(round, completion, predicate) {
     return (settled.length > 0 &&
         (completion === "any" ? settled.some(Boolean) : round.unobserved.length === 0 && settled.every(Boolean)));
 }
-/** Canonical ids in the caller's selection order, appending any id the caller never named. */
-function selectionOrderedIds(ids, order) {
-    const present = new Set(ids);
-    const seen = new Set();
-    const ordered = [];
-    for (const id of order) {
-        if (present.has(id) && !seen.has(id)) {
-            seen.add(id);
-            ordered.push(id);
-        }
-    }
-    for (const id of ids) {
-        if (!seen.has(id)) {
-            seen.add(id);
-            ordered.push(id);
-        }
-    }
-    return ordered;
-}
-/**
- * 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. 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.
- */
+/** Wait observes completion and returns final status snapshots, never a live stream. */
 export async function executeWaitAkuma(input) {
-    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" } });
-            }
-            const ordered = input.selectionOrder === undefined ? input.ids : selectionOrderedIds(input.ids, input.selectionOrder);
-            input.onSelected(ordered.map((id) => ({ id, ...facts.get(id) })));
+    const readers = new Map();
+    const readerFor = (id) => {
+        let reader = readers.get(id);
+        if (reader === undefined) {
+            reader = createLiveStatusReader(pathsForAkuId(input.path, id), id);
+            readers.set(id, reader);
         }
-        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));
-        };
+        return reader;
+    };
+    try {
         const waited = await waitForObservation({
+            pollMs: 250,
             ...(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) }
+            ...(input.predicate === undefined
+                ? {
+                    probe: async () => await readWaitComplete(input.path, input.ids, input.completion, input.signal, (id) => readerFor(id).complete(input.signal)),
+                }
                 : {}),
-            observe: async () => await observeWaitRound(input.path, input.ids, input.signal, readers),
+            observe: async () => await observeWaitRound(input.ids, readerFor, input.signal),
             complete: (round) => roundComplete(round, input.completion, input.predicate),
-            onObserve: async (round) => await observeRound(round),
+            onObserve: async (round) => {
+                await Promise.all(round.observations.map(({ status }) => observeStatusOutcome(status, input.outcomeObserved)));
+            },
         });
         return {
             mode: input.completion,
@@ -128,9 +68,8 @@ export async function executeWaitAkuma(input) {
         };
     }
     finally {
-        for (const reader of readers?.values() ?? [])
+        for (const reader of readers.values())
             reader.clear();
-        readers?.clear();
     }
 }
 function diagnostic(error) {

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

@@ -67,24 +67,21 @@ export declare const akumaStatusSchema: z.ZodObject<{
         stranded: "stranded";
     }>;
     cwd: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
     allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
-        "task.add": "task.add";
-        "task.addDocument": "task.addDocument";
-        "task.compose": "task.compose";
-        "task.done": "task.done";
-        "task.drop": "task.drop";
-        "task.hold": "task.hold";
-        "task.resume": "task.resume";
-        "task.start": "task.start";
-        "task.stop": "task.stop";
-        "task.update": "task.update";
+        "debt.add": "debt.add";
+        "debt.addDocument": "debt.addDocument";
+        "debt.done": "debt.done";
+        "debt.drop": "debt.drop";
+        "debt.update": "debt.update";
         "akuma.call": "akuma.call";
         "akuma.kill": "akuma.kill";
         "akuma.tell": "akuma.tell";
         "contract.audit": "contract.audit";
         "contract.deliver": "contract.deliver";
         "contract.review": "contract.review";
-    }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+    }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
     timeline: z.ZodUnion<readonly [z.ZodObject<{
         reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             sequence: z.ZodNumber;
@@ -228,6 +225,7 @@ export declare const akumaStatusSchema: z.ZodObject<{
                             unspecified: "unspecified";
                         }>;
                         path: z.ZodString;
+                        patch: z.ZodOptional<z.ZodString>;
                         diffstat: z.ZodOptional<z.ZodObject<{
                             added: z.ZodNumber;
                             removed: z.ZodNumber;
@@ -242,6 +240,7 @@ export declare const akumaStatusSchema: z.ZodObject<{
                     }, z.core.$strict>>;
                 }, z.core.$strict>]>;
                 state: z.ZodLiteral<"active">;
+                toolId: z.ZodOptional<z.ZodString>;
                 truncated: z.ZodOptional<z.ZodLiteral<true>>;
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"tool">;
@@ -278,6 +277,7 @@ export declare const akumaStatusSchema: z.ZodObject<{
                             unspecified: "unspecified";
                         }>;
                         path: z.ZodString;
+                        patch: z.ZodOptional<z.ZodString>;
                         diffstat: z.ZodOptional<z.ZodObject<{
                             added: z.ZodNumber;
                             removed: z.ZodNumber;
@@ -297,8 +297,10 @@ export declare const akumaStatusSchema: z.ZodObject<{
                         ok: "ok";
                     }>;
                     message: z.ZodOptional<z.ZodString>;
+                    output: z.ZodOptional<z.ZodString>;
                     exitCode: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>;
+                toolId: z.ZodOptional<z.ZodString>;
                 truncated: z.ZodOptional<z.ZodLiteral<true>>;
             }, z.core.$strict>]>;
         }, z.core.$strict>]>>>;
@@ -331,6 +333,7 @@ export declare const akumaStatusSchema: z.ZodObject<{
                 kind: z.ZodLiteral<"answered">;
                 historyId: z.ZodString;
                 answer: z.ZodString;
+                foldedSaidSequence: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"failed">;
                 historyId: z.ZodString;
@@ -436,6 +439,7 @@ export declare const akumaStatusSchema: z.ZodObject<{
                             unspecified: "unspecified";
                         }>;
                         path: z.ZodString;
+                        patch: z.ZodOptional<z.ZodString>;
                         diffstat: z.ZodOptional<z.ZodObject<{
                             added: z.ZodNumber;
                             removed: z.ZodNumber;
@@ -455,8 +459,10 @@ export declare const akumaStatusSchema: z.ZodObject<{
                         ok: "ok";
                     }>;
                     message: z.ZodOptional<z.ZodString>;
+                    output: z.ZodOptional<z.ZodString>;
                     exitCode: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>;
+                toolId: z.ZodOptional<z.ZodString>;
                 truncated: z.ZodOptional<z.ZodLiteral<true>>;
             }, z.core.$strict>]>;
         }, z.core.$strict>]>>>;

package/build/src/akuma/akuma.js

@@ -15,6 +15,8 @@ export const akumaStatusSchema = z
     birth: akumaBirthSchema,
     life: z.enum(["running", "asleep", "stranded", "hung", "untidy", "killed"]),
     cwd: z.string().optional(),
+    provider: z.string().optional(),
+    model: z.string().optional(),
     allowed: allowedActionsSchema,
     timeline: activitySnapshotSchema,
     strandedReason: z.literal("resume-unsupported").optional(),

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "contract.audit", "contract.deliver", "contract.review", "task.add", "task.addDocument", "task.compose", "task.done", "task.drop", "task.hold", "task.resume", "task.start", "task.stop", "task.update"];
+export declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "contract.audit", "contract.deliver", "contract.review", "debt.add", "debt.addDocument", "debt.done", "debt.drop", "debt.update"];
 export type AllowedAction = (typeof ALLOWED_ACTIONS)[number];
 export type AllowedActions = readonly AllowedAction[];
 export declare const DEFAULT_ALLOWED_ACTIONS: AllowedActions;
@@ -7,23 +7,18 @@ export declare function isAllowedAction(value: unknown): value is AllowedAction;
 export declare function decodeAllowedActions(value: unknown, label?: string): AllowedActions;
 /** Public codecs retain the Soul's canonical, duplicate-free action membership. */
 export declare const allowedActionsSchema: z.ZodPipe<z.ZodArray<z.ZodEnum<{
-    "task.add": "task.add";
-    "task.addDocument": "task.addDocument";
-    "task.compose": "task.compose";
-    "task.done": "task.done";
-    "task.drop": "task.drop";
-    "task.hold": "task.hold";
-    "task.resume": "task.resume";
-    "task.start": "task.start";
-    "task.stop": "task.stop";
-    "task.update": "task.update";
+    "debt.add": "debt.add";
+    "debt.addDocument": "debt.addDocument";
+    "debt.done": "debt.done";
+    "debt.drop": "debt.drop";
+    "debt.update": "debt.update";
     "akuma.call": "akuma.call";
     "akuma.kill": "akuma.kill";
     "akuma.tell": "akuma.tell";
     "contract.audit": "contract.audit";
     "contract.deliver": "contract.deliver";
     "contract.review": "contract.review";
-}>>, z.ZodTransform<AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+}>>, z.ZodTransform<AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
 export declare function historicalAllowedActions(value: unknown): AllowedActions;
 export declare function unionAllowedActions(base: AllowedActions, additions: AllowedActions): AllowedActions;
 export declare function clipAllowedActions(requested: AllowedActions, parent: AllowedActions): AllowedActions;

package/build/src/akuma/allowed.js

@@ -1,4 +1,4 @@
-import { TASK_MUTATION_ACTIONS } from "../task/mutation.js";
+import { DEBT_MUTATION_ACTIONS } from "../debt/mutation.js";
 import { z } from "zod";
 const AKUMA_MUTATION_ACTIONS = Object.freeze(["akuma.call", "akuma.kill", "akuma.tell"]);
 export const ALLOWED_ACTIONS = Object.freeze([
@@ -6,13 +6,13 @@ export const ALLOWED_ACTIONS = Object.freeze([
     "contract.audit",
     "contract.deliver",
     "contract.review",
-    ...TASK_MUTATION_ACTIONS,
+    ...DEBT_MUTATION_ACTIONS,
 ]);
 export const DEFAULT_ALLOWED_ACTIONS = Object.freeze([
     ...AKUMA_MUTATION_ACTIONS,
     "contract.audit",
     "contract.deliver",
-    ...TASK_MUTATION_ACTIONS,
+    ...DEBT_MUTATION_ACTIONS,
 ]);
 const ALLOWED_ACTION_SET = new Set(ALLOWED_ACTIONS);
 export function isAllowedAction(value) {
@@ -42,7 +42,16 @@ export const allowedActionsSchema = z.array(z.enum(ALLOWED_ACTIONS)).transform((
     }
 });
 export function historicalAllowedActions(value) {
-    return value === undefined ? ALLOWED_ACTIONS : decodeAllowedActions(value);
+    if (value === undefined)
+        return ALLOWED_ACTIONS;
+    if (!Array.isArray(value))
+        return decodeAllowedActions(value);
+    // Persisted permissions retain the same surviving capabilities after rename;
+    // removed planning/progress operations confer no replacement permission.
+    const retired = new Set(["task.compose", "task.start", "task.stop", "task.hold", "task.resume"]);
+    return decodeAllowedActions(value
+        .filter((action) => !retired.has(action))
+        .map((action) => typeof action === "string" && action.startsWith("task.") ? `debt.${action.slice("task.".length)}` : action));
 }
 export function unionAllowedActions(base, additions) {
     const merged = new Set(base);

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

@@ -1,10 +1,11 @@
-import { type HeartSnapshot, type HeldAkumaLeash } from "./heart/index.js";
+import { type BodyControlSnapshot, type HeldAkumaLeash } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 export declare const CONTROL_RESPONSE_MS = 1000;
 export declare class BodySupervisor {
     private readonly paths;
     private readonly bodySequence;
     private readonly leash;
+    private readonly reader;
     readonly signal: AbortSignal;
     private readonly controller;
     private readonly finished;
@@ -15,12 +16,11 @@ export declare class BodySupervisor {
     private constructor();
     static open(paths: AkumaPaths, bodySequence: number, leash: HeldAkumaLeash): Promise<BodySupervisor>;
     get reason(): "control" | "heart-gone" | undefined;
-    current(): HeartSnapshot;
+    current(): BodyControlSnapshot;
     recordHung(diagnostic: string, at: string): Promise<void>;
-    refresh(): Promise<HeartSnapshot>;
-    next(after: HeartSnapshot): Promise<HeartSnapshot>;
+    refresh(): Promise<BodyControlSnapshot>;
+    next(after: BodyControlSnapshot): Promise<BodyControlSnapshot>;
     cancel(reason: "control" | "heart-gone"): void;
     close(): Promise<void>;
-    private publish;
     private observe;
 }

package/build/src/akuma/body-supervisor.js

@@ -1,11 +1,13 @@
 import { abortableDelay } from "./abort.js";
-import { heartExists, readHeart } from "./heart/index.js";
+import { isDeepStrictEqual } from "node:util";
+import { createBodyHeartReader } from "./heart/index.js";
 const BODY_CONTROL_OBSERVATION_MS = 100;
 export const CONTROL_RESPONSE_MS = 1_000;
 export class BodySupervisor {
     paths;
     bodySequence;
     leash;
+    reader;
     signal;
     controller = new AbortController();
     finished = new AbortController();
@@ -13,16 +15,18 @@ export class BodySupervisor {
     waiter;
     observation;
     stopping;
-    constructor(paths, bodySequence, leash, observation) {
+    constructor(paths, bodySequence, leash, reader, observation) {
         this.paths = paths;
         this.bodySequence = bodySequence;
         this.leash = leash;
+        this.reader = reader;
         this.signal = this.controller.signal;
         this.observation = observation;
         this.observer = this.observe();
     }
     static async open(paths, bodySequence, leash) {
-        return new BodySupervisor(paths, bodySequence, leash, await readHeart(paths));
+        const reader = createBodyHeartReader(paths);
+        return new BodySupervisor(paths, bodySequence, leash, reader, await reader.read());
     }
     get reason() {
         return this.stopping;
@@ -34,7 +38,12 @@ export class BodySupervisor {
         await this.leash.recordBodyHung(this.paths, { sequence: this.bodySequence, diagnostic, at });
     }
     async refresh() {
-        this.publish(await readHeart(this.paths));
+        const snapshot = await this.reader.read();
+        if (!isDeepStrictEqual(snapshot, this.observation)) {
+            this.observation = snapshot;
+            this.waiter?.(snapshot);
+            this.waiter = undefined;
+        }
         return this.observation;
     }
     next(after) {
@@ -54,18 +63,18 @@ export class BodySupervisor {
     }
     async close() {
         this.finished.abort();
-        await this.observer;
-        this.waiter = undefined;
-    }
-    publish(snapshot) {
-        this.observation = snapshot;
-        this.waiter?.(snapshot);
-        this.waiter = undefined;
+        try {
+            await this.observer;
+        }
+        finally {
+            this.reader.clear();
+            this.waiter = undefined;
+        }
     }
     async observe() {
         for (;;) {
             const snapshot = this.observation;
-            if (!(await heartExists(this.paths)))
+            if (snapshot.soul === null)
                 return this.cancel("heart-gone");
             if (snapshot.stop?.bodySequence === this.bodySequence || snapshot.pause?.bodySequence === this.bodySequence) {
                 return this.cancel("control");
@@ -76,14 +85,7 @@ export class BodySupervisor {
             catch {
                 return;
             }
-            try {
-                await this.refresh();
-            }
-            catch (error) {
-                if (await heartExists(this.paths))
-                    throw error;
-                return this.cancel("heart-gone");
-            }
+            await this.refresh();
         }
     }
 }