@astrosheep/keiyaku 4.6.8 → 4.6.10

package/build/skills/keiyaku-workflow/SKILL.md

@@ -33,7 +33,7 @@ to create parallel work.
 
 - Separate `kei`s have independently acceptable outcomes.
 - An Arc is a chapter of one `kei`; it is not separately accepted.
-- A Task stores decomposition or dependencies that outlive this conversation.
+- A Debt records confirmed unresolved work and its dependencies.
 
 Use `after` only when one `kei` requires another to be accepted first. Ordinary
 overlap is not a dependency.
@@ -101,7 +101,7 @@ authority.
 | Role | Grant at birth | Return |
 | --- | --- | --- |
 | 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. |
+| Deliverer | The ordinary baseline: every Debt 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

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

@@ -1,6 +1,7 @@
 import type { AkumaCaller } from "./caller.js";
 import type { Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
+import type { AkumaStreamSnapshot } from "./akuma-stream.js";
 import { type InterruptReceipt } from "./akuma-owner.js";
 import { type AkumaStatus } from "./akuma.js";
 import type { AllowedAction } from "./allowed.js";
@@ -66,5 +67,6 @@ export declare class Akuma {
     status(): Promise<AkumaStatus>;
     idle(options?: AkumaIdleOptions): Promise<AkumaIdleResult>;
     history(options?: AkumaHistoryOptions): Promise<ActivityHistory>;
+    stream(options?: AkumaSignalOptions): AsyncIterable<AkumaStreamSnapshot>;
     kill(options?: AkumaSignalOptions): Promise<KillEvidence>;
 }

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

@@ -151,6 +151,16 @@ export class Akuma {
             ...(options.limit === undefined ? {} : { limit: options.limit }),
         }));
     }
+    stream(options = {}) {
+        if (typeof options !== "object" || options === null || Array.isArray(options)) {
+            throw new TypeError("Akuma stream options must be an object");
+        }
+        const unknown = Object.keys(options).find((key) => key !== "signal");
+        if (unknown !== undefined)
+            throw new TypeError(`Akuma stream options has unknown field: ${unknown}`);
+        const signal = signalOption(options.signal);
+        return this.owner(true).stream(signal === undefined ? {} : { signal });
+    }
     async kill(options = {}) {
         if (typeof options !== "object" || options === null || Array.isArray(options)) {
             throw new TypeError("Akuma kill options must be an object");

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

@@ -1,5 +1,5 @@
 import { type AkuId, type AkumaPaths } from "./identity.js";
-import { selectHistory, selectSnapshot, type ActivityHistory, type ActivityRow, type ActivitySnapshot, type TurnLedger } from "./projection.js";
+import { selectHistory, type ActivityHistory, type ActivityRow, type ActivitySnapshot } from "./projection.js";
 import type { WorldRoot } from "../world.js";
 import type { AkumaAlias } from "../identity/selector.js";
 import type { AkumaListRow, AkumaStatus, UnbornAkumaListRow } from "./akuma.js";
@@ -25,23 +25,47 @@ type StatusObservationInput = Readonly<{
     ordinaryBudget?: number;
     admittedTellId?: string;
 }>;
-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;
+    execution(signal?: AbortSignal): Promise<import("./heart/facts.js").AkumaLife>;
+    tellOutcome: (id: string, signal?: AbortSignal) => Promise<{
+        tell: Readonly<{
+            kind: "tell";
+            sequence: number;
+            id: string;
+            body: string;
+            initiator?: string;
+            schemaJson?: string;
+            recordedAt: string;
+            state: "pending" | "told";
+            deliveries: readonly import("./heart/facts.js").TellDelivery[];
+            binding?: import("./heart/facts.js").TellBinding;
+        }> | null;
+        end: Readonly<{
+            kind: "turn-end";
+            sequence: number;
+            turnSequence: number;
+            outcome: import("./heart/facts.js").TurnOutcome;
+            completedAt: string;
+        }> | undefined;
+    }>;
+    complete(signal?: AbortSignal): Promise<boolean>;
     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>;
+/** One-shot observations use the same reader and always release it. */
+export declare function bornLiveStatus(paths: AkumaPaths, expected: AkuId, input: StatusObservationInput, signal?: AbortSignal): 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 type ExecutionProgress = "settled" | "advancing" | "stopped";
+/** Pending input is not execution. An owned launch can bridge the admission gap. */
+export declare function executionProgress(life: AkumaStatus["life"], pending: boolean, wake?: "launching" | "settled" | "failed"): ExecutionProgress;
 export declare function defaultWaitComplete(status: AkumaStatus): 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 declare function readWaitComplete(worldPath: WorldRoot, ids: readonly AkuId[], completion: "any" | "all", signal?: AbortSignal, probe?: (id: AkuId) => Promise<boolean>): Promise<boolean>;
 export type WaitReason = "completed" | "deadline";
+/** The one observation cadence public waiting and timeline streaming share. */
+export declare const OBSERVATION_POLL_MS = 100;
 /**
  * The one deadline-aware observation loop for public Akuma waiting.  It always
  * reads once before judging a passed deadline, so a zero-duration wait remains
@@ -49,6 +73,7 @@ export type WaitReason = "completed" | "deadline";
  */
 export declare function waitForObservation<T>(input: Readonly<{
     timeoutMs?: number;
+    pollMs?: number;
     signal?: AbortSignal;
     probe?(): Promise<boolean>;
     observe(): Promise<T>;

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

@@ -1,5 +1,5 @@
 import { projectAkumaBirth } from "./caller.js";
-import { readStatusFacts, createStatusFactReader, readLifeSnapshot, HeldAkumaLeash, isHeartAbsent, life, lifeAt, probeLeash, readHeart, readSeal, readSoul, } from "./heart/index.js";
+import { 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";
@@ -89,60 +89,75 @@ export function createLiveStatusReader(paths, expected) {
     };
     return {
         clear,
-        async read(input, signal) {
+        async execution(signal) {
+            return (await bornObservation(paths, expected, () => reader.life(signal))).currentLife;
+        },
+        tellOutcome: reader.tellOutcome,
+        async complete(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 };
-                });
+                const observed = await bornObservation(paths, expected, () => reader.life(signal));
+                return complete(observed.currentLife, observed.snapshot.hasPendingTell);
             }
             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, 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, signal));
-    const resumeUnsupported = currentLife === "stranded" &&
-        snapshot.latestSession?.provider === soul.provider.name &&
-        (await resolveProviderExecution(soul.provider)).adapter.resume === undefined;
-    const { ledger, selected } = readProjection === undefined ? await readStatusProjection(paths, input, signal) : await readProjection();
-    return {
-        status: {
-            id: soul.id,
-            birth: projectAkumaBirth(soul),
-            life: currentLife,
-            cwd: soul.cwd,
-            allowed: soul.allowed,
-            ...(resumeUnsupported ? { strandedReason: "resume-unsupported" } : {}),
-            timeline: selected.snapshot,
+        async read(input, signal) {
+            try {
+                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, () => reader.life(signal));
+                const resumeUnsupported = currentLife === "stranded" &&
+                    snapshot.latestSession?.provider === soul.provider.name &&
+                    (await resolveProviderExecution(soul.provider)).adapter.resume === undefined;
+                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 {
+                    status: {
+                        id: soul.id,
+                        birth: projectAkumaBirth(soul),
+                        life: currentLife,
+                        cwd: soul.cwd,
+                        // The execution adapter and its one current model are what this Akuma
+                        // actually runs; a birth request the Soul still only seeded is not a
+                        // claim that a native runtime ever used it.
+                        provider: soul.provider.name,
+                        ...(soul.options.model === undefined ? {} : { model: soul.options.model }),
+                        allowed: soul.allowed,
+                        ...(resumeUnsupported ? { strandedReason: "resume-unsupported" } : {}),
+                        timeline: selected.snapshot,
+                    },
+                    ordinarySelected: selected.ordinaryCount,
+                    rows: ledger.rows,
+                };
+            }
+            catch (error) {
+                clear();
+                throw error;
+            }
         },
-        ordinarySelected: selected.ordinaryCount,
-        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)),
-    };
+/** One-shot observations use the same reader and always release it. */
+export async function bornLiveStatus(paths, expected, input, signal) {
+    const reader = createLiveStatusReader(paths, expected);
+    try {
+        return await reader.read(input, signal);
+    }
+    finally {
+        reader.clear();
+    }
 }
 export async function bornStatus(paths, expected, input) {
     const { rows: _rows, ...status } = await bornLiveStatus(paths, expected, input);
@@ -151,21 +166,33 @@ export async function bornStatus(paths, expected, input) {
 export async function readLiveStatus(worldPath, id, input, signal) {
     return await bornLiveStatus(pathsForAkuId(worldPath, id), id, input, signal);
 }
+/** Pending input is not execution. An owned launch can bridge the admission gap. */
+export function executionProgress(life, pending, wake = "settled") {
+    if (wake === "launching" || life === "running")
+        return "advancing";
+    if (wake === "failed")
+        return "stopped";
+    if (life === "asleep")
+        return pending ? "advancing" : "settled";
+    return "stopped";
+}
 function complete(life, pending) {
-    return life !== "running" && !pending;
+    return executionProgress(life, pending) !== "advancing";
 }
 export function defaultWaitComplete(status) {
     return complete(status.life, status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending"));
 }
 /** Probe completion only; returned statuses still come from a full observation. */
-export async function readWaitComplete(worldPath, ids, completion, signal) {
+export async function readWaitComplete(worldPath, ids, completion, signal, probe) {
     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)) {
+            const ready = probe === undefined
+                ? await bornObservation(paths, id, () => readLifeSnapshot(paths, signal)).then((observed) => complete(observed.currentLife, observed.snapshot.hasPendingTell))
+                : await probe(id);
+            if (ready) {
                 if (completion === "any")
                     return true;
                 completed += 1;
@@ -178,7 +205,8 @@ export async function readWaitComplete(worldPath, ids, completion, signal) {
     }
     return ids.length > 0 && completed === ids.length;
 }
-const OBSERVATION_POLL_MS = 100;
+/** The one observation cadence public waiting and timeline streaming share. */
+export const OBSERVATION_POLL_MS = 100;
 /**
  * The one deadline-aware observation loop for public Akuma waiting.  It always
  * reads once before judging a passed deadline, so a zero-duration wait remains
@@ -190,22 +218,18 @@ export async function waitForObservation(input) {
         input.signal?.throwIfAborted();
         const ready = input.probe === undefined || (await input.probe());
         input.signal?.throwIfAborted();
-        if (!ready && (deadline === undefined || performance.now() < deadline)) {
-            await abortableDelay(deadline === undefined
-                ? OBSERVATION_POLL_MS
-                : Math.min(OBSERVATION_POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
-            continue;
+        if (ready || (deadline !== undefined && performance.now() >= deadline)) {
+            const value = await input.observe();
+            input.signal?.throwIfAborted();
+            await input.onObserve?.(value);
+            if (input.complete(value))
+                return { reason: "completed", value };
+            if (deadline !== undefined && performance.now() >= deadline)
+                return { reason: "deadline", value };
         }
-        const value = await input.observe();
-        input.signal?.throwIfAborted();
-        await input.onObserve?.(value);
-        if (input.complete(value))
-            return { reason: "completed", value };
-        if (deadline !== undefined && performance.now() >= deadline)
-            return { reason: "deadline", value };
         await abortableDelay(deadline === undefined
-            ? OBSERVATION_POLL_MS
-            : Math.min(OBSERVATION_POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
+            ? (input.pollMs ?? OBSERVATION_POLL_MS)
+            : Math.min(input.pollMs ?? OBSERVATION_POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
     }
 }
 export async function readAkumaBirthCwd(worldPath, id) {

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

@@ -1,6 +1,7 @@
 import { type AkumaCaller } from "./caller.js";
 import type { WorldRoot } from "../world.js";
 import { type OutcomeObserver, type LiveStatusObservation, type WaitReason } from "./akuma-observe.js";
+import { type AkumaStreamSnapshot } from "./akuma-stream.js";
 import type { AkumaStatus } from "./akuma.js";
 import { type TellResult, type TellWakeRuntime } from "./body.js";
 import { type CallInitialTell, type CallInitialTellAdmission } from "./call-initial-tell.js";
@@ -64,7 +65,7 @@ export declare function killAkumaWithRecovery(paths: AkumaPaths, recover?: (path
  * The one lower native Akuma owner: standalone identity, plural selection and
  * the request service all consume these same single-target algorithms. It reads
  * only Heart, leash, provider and filesystem state; optional Alias, Dispatch,
- * Task and Contract associations are composed above this boundary.
+ * Debt and Contract associations are composed above this boundary.
  */
 export declare class AkumaOwner {
     readonly id: AkuId;
@@ -81,6 +82,14 @@ export declare class AkumaOwner {
         since?: number;
         limit?: number;
     }>): Promise<ActivityHistory | ExactHistory>;
+    /**
+     * Continuously observe that same retained timeline. Each emission is the whole
+     * latest bounded window through the existing history projection, and the
+     * operation observes until its caller stops pulling or aborts.
+     */
+    stream(options?: Readonly<{
+        signal?: AbortSignal;
+    }>): AsyncIterable<AkumaStreamSnapshot>;
     waitReceipt(predicate?: (status: AkumaStatus) => boolean, options?: Readonly<{
         timeoutMs?: number;
         signal?: AbortSignal;
@@ -122,12 +131,12 @@ export declare class AkumaOwner {
         timeoutMs?: number;
         signal?: AbortSignal;
         observe?: (observation: LiveStatusObservation) => void | Promise<void>;
+        wake?: () => "launching" | "settled" | "failed";
     }>): Promise<Readonly<{
         reason: WaitReason;
         outcome: TurnOutcome | null;
         completedAt: string | null;
     }>>;
-    private boundTellOutcome;
     interrupt(body: string, options?: Readonly<{
         tellId?: string;
         schemaJson?: string;

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

@@ -1,12 +1,13 @@
 import { decodeAkumaCaller } from "./caller.js";
 import { randomUUID } from "node:crypto";
 import { AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
-import { bornLiveStatus, bornStatus, defaultWaitComplete, observeOutcomeRows, observeStatusOutcome, waitForObservation, } from "./akuma-observe.js";
+import { createLiveStatusReader, bornStatus, defaultWaitComplete, executionProgress, observeOutcomeRows, observeStatusOutcome, waitForObservation, } from "./akuma-observe.js";
 import { executeWaitAkuma } from "./akuma-wait.js";
+import { createAkumaStream } from "./akuma-stream.js";
 import { handoffPendingTells, spawnAkumaBody, wakeRecordedTell, } from "./body.js";
 import { admitCallInitialTell } from "./call-initial-tell.js";
 import { acquireLeash } from "./control.js";
-import { HeldAkumaLeash, activitySlice, projectTell, readForkPoint, readHeart, readKill, readLastAnsweredTurn, readSoul, readTell, readTurn, recordTell, requestPause, requestStop, } from "./heart/index.js";
+import { HeldAkumaLeash, activitySlice, projectTell, readForkPoint, readHeart, readKill, readLastAnsweredTurn, readSoul, readTell, recordTell, requestPause, requestStop, } from "./heart/index.js";
 import { parsePublicHistoryId, pathsForAkuId } from "./identity.js";
 import { projectTurns, selectExactHistory, selectHistory } from "./projection.js";
 import { resolveProviderExecution } from "./providers/index.js";
@@ -84,7 +85,7 @@ export async function killAkumaWithRecovery(paths, recover, signal) {
  * The one lower native Akuma owner: standalone identity, plural selection and
  * the request service all consume these same single-target algorithms. It reads
  * only Heart, leash, provider and filesystem state; optional Alias, Dispatch,
- * Task and Contract associations are composed above this boundary.
+ * Debt and Contract associations are composed above this boundary.
  */
 export class AkumaOwner {
     id;
@@ -146,6 +147,14 @@ export class AkumaOwner {
         await observeOutcomeRows(this.id, history.rows, this.outcomeObserved);
         return history;
     }
+    /**
+     * Continuously observe that same retained timeline. Each emission is the whole
+     * latest bounded window through the existing history projection, and the
+     * operation observes until its caller stops pulling or aborts.
+     */
+    stream(options = {}) {
+        return createAkumaStream(this.paths, this.id, options, this.outcomeObserved);
+    }
     async waitReceipt(predicate = defaultWaitComplete, options = {}) {
         if (options.timeoutMs !== undefined && (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 0)) {
             throw new TypeError("Akuma wait timeoutMs must be a nonnegative finite millisecond duration");
@@ -224,38 +233,39 @@ export class AkumaOwner {
     }
     /** Observe the exact admitted Tell's bound Turn without substituting Akuma-wide idleness. */
     async tellOutcome(tellId, options = {}) {
-        const waited = await waitForObservation({
-            ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
-            ...(options.signal === undefined ? {} : { signal: options.signal }),
-            observe: async () => {
-                const tell = await readTell(this.paths, tellId);
-                if (tell === null)
-                    throw new AkumaProviderError(`recorded Tell ${tellId} is missing from Heart`);
-                const outcome = await this.boundTellOutcome(tell);
-                if (outcome.historyId !== undefined)
-                    await this.outcomeObserved?.(this.id, [outcome.historyId]);
-                if (options.observe !== undefined) {
-                    await options.observe(await bornLiveStatus(this.paths, this.id, { aperture: "monitoring", admittedTellId: tellId }));
-                }
-                return { ...outcome, terminalWithoutTurn: tell.state === "told" && tell.binding === undefined };
-            },
-            complete: (observed) => observed.outcome !== null || observed.terminalWithoutTurn,
-        });
-        return {
-            reason: waited.reason,
-            outcome: waited.value.outcome,
-            completedAt: waited.value.completedAt,
-        };
-    }
-    async boundTellOutcome(tell) {
-        if (tell.binding === undefined)
-            return { outcome: null, completedAt: null };
-        const end = (await readTurn(this.paths, tell.binding.turnSequence))?.end;
-        return {
-            outcome: end?.outcome ?? null,
-            completedAt: end?.completedAt ?? null,
-            ...(end === undefined ? {} : { historyId: `turn/${tell.binding.turnSequence}` }),
-        };
+        const reader = createLiveStatusReader(this.paths, this.id);
+        try {
+            const waited = await waitForObservation({
+                ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+                observe: async () => {
+                    const currentLife = await reader.execution(options.signal);
+                    const progress = executionProgress(currentLife, true, options.wake?.());
+                    const { tell, end } = await reader.tellOutcome(tellId, options.signal);
+                    if (tell === null)
+                        throw new AkumaProviderError(`recorded Tell ${tellId} is missing from Heart`);
+                    if (end !== undefined)
+                        await this.outcomeObserved?.(this.id, [`turn/${end.turnSequence}`]);
+                    if (options.observe !== undefined) {
+                        await options.observe(await reader.read({ aperture: "monitoring", admittedTellId: tellId }, options.signal));
+                    }
+                    return {
+                        outcome: end?.outcome ?? null,
+                        completedAt: end?.completedAt ?? null,
+                        terminalWithoutTurn: (tell.state === "told" && tell.binding === undefined) || progress === "stopped",
+                    };
+                },
+                complete: (observed) => observed.outcome !== null || observed.terminalWithoutTurn,
+            });
+            return {
+                reason: waited.reason,
+                outcome: waited.value.outcome,
+                completedAt: waited.value.completedAt,
+            };
+        }
+        finally {
+            reader.clear();
+        }
     }
     async interrupt(body, options = {}) {
         const admitted = await this.admitInterrupt(body, options);

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

@@ -68,9 +68,12 @@ export async function observeAdmittedAskAkuma(input) {
     const tell = input.receipt ?? (await owner.admittedReceipt(input.tellId));
     await input.onObserve?.admitted?.(tell, input.id);
     let settled;
+    let wakeError;
+    let wakeState = input.wake === undefined ? "settled" : "launching";
     void input.wake?.then((receipt) => {
         settled = receipt;
-    }, () => undefined);
+        wakeState = receipt.wake.kind === "failed" ? "failed" : "settled";
+    }, (error) => { wakeError = { error }; wakeState = "failed"; });
     const admittedAt = Date.parse(tell.row.at);
     const observedAt = performance.timeOrigin + performance.now();
     const elapsed = input.startedAt === undefined
@@ -79,6 +82,11 @@ export async function observeAdmittedAskAkuma(input) {
             : 0
         : Math.max(0, performance.now() - input.startedAt);
     const observed = await owner.tellOutcome(input.tellId, {
+        wake: () => {
+            if (wakeError !== undefined)
+                throw wakeError.error;
+            return wakeState;
+        },
         ...(input.timeoutMs === undefined ? {} : { timeoutMs: Math.max(0, input.timeoutMs - elapsed) }),
         ...(input.signal === undefined ? {} : { signal: input.signal }),
         ...(input.onObserve?.observe === undefined ? {} : { observe: input.onObserve.observe }),

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

@@ -0,0 +1,22 @@
+import { type OutcomeObserver } from "./akuma-observe.js";
+import type { AkuId, AkumaPaths } from "./identity.js";
+import { type ActivityHistory } from "./projection.js";
+/** The complete bounded latest timeline window one stream emission carries; never a delta. */
+export type AkumaStreamSnapshot = ActivityHistory;
+/**
+ * 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 declare function createAkumaStream(paths: AkumaPaths, id: AkuId, options?: Readonly<{
+    signal?: AbortSignal;
+}>, observe?: OutcomeObserver): AsyncIterableIterator<AkumaStreamSnapshot>;