@astrosheep/keiyaku 4.5.18 → 4.5.19

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

@@ -8,17 +8,13 @@ import { resolveProviderExecution } from "./providers/index.js";
 import { publishAkuma } from "./publication.js";
 import { spawnAkumaBody } from "./body.js";
 import { AkumaNotBornError } from "./akuma-errors.js";
-import { bornStatus } from "./akuma-observe.js";
+import { bornStatus, defaultWaitComplete, readWaitComplete } from "./akuma-observe.js";
 const CALL_EXECUTION = Symbol("akuma-call-execution");
 const POLL_MS = 100;
 const wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function defaultWaitComplete(status) {
-    return (status.life !== "running" &&
-        !status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending"));
-}
 async function takeLeashUntilSignal(paths, bodySequence, signal, unbounded = false) {
     const leash = await acquireLeash(paths, {
         bodySequence,
@@ -35,7 +31,7 @@ async function takeLeashUntilSignal(paths, bodySequence, signal, unbounded = fal
     return { kind: "unavailable", evidence: "unavailable" };
 }
 export async function settleAkumaKill(paths, signal, retainLeash = false) {
-    const request = await requestStop(paths, new Date().toISOString());
+    const request = await requestStop(paths, new Date().toISOString(), signal);
     if (request.kind !== "requested") {
         if (!retainLeash)
             return { evidence: request.kind };
@@ -141,9 +137,13 @@ export class AkumaHandle {
         }
         const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
         for (;;) {
-            const status = await this.status();
-            if (predicate(status) || (deadline !== undefined && performance.now() >= deadline))
-                return status;
+            if (predicate !== defaultWaitComplete ||
+                (deadline !== undefined && performance.now() >= deadline) ||
+                (await readWaitComplete(this.worldPath, this.id))) {
+                const status = await this.status();
+                if (predicate(status) || (deadline !== undefined && performance.now() >= deadline))
+                    return status;
+            }
             await wait(deadline === undefined ? POLL_MS : Math.min(POLL_MS, Math.max(0, deadline - performance.now())));
         }
     }
@@ -160,7 +160,7 @@ export class AkumaHandle {
         return await wakeRecordedTell(this.paths, admitted.tell.id, runtime);
     }
     async interrupt(body, options = {}) {
-        const request = await requestPause(this.paths, new Date().toISOString());
+        const request = await requestPause(this.paths, new Date().toISOString(), options.signal);
         if (request.kind === "not-born") {
             throw new AkumaNotBornError(this.id);
         }

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

@@ -17,5 +17,7 @@ export declare function readBudgetedStatus(worldPath: WorldRoot, id: AkuId, inpu
     ordinaryBudget?: number;
     admittedTellId?: string;
 }>): Promise<BudgetedStatusObservation>;
+export declare function defaultWaitComplete(status: AkumaStatus): boolean;
+export declare function readWaitComplete(worldPath: WorldRoot, id: AkuId): Promise<boolean>;
 export declare function readAkumaBirthCwd(worldPath: WorldRoot, id: AkuId): Promise<string>;
 export { selectHistory, type ActivityHistory, type ActivitySnapshot };

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

@@ -1,12 +1,22 @@
-import { activitySlice, HeldAkumaLeash, isHeartAbsent, life, lifeAt, probeLeash, readHeart, readSeal, readSoul, } from "./heart/index.js";
+import { readStatusFacts, 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";
 import { AkumaNotBornError } from "./akuma-errors.js";
 export async function fleetListRow(paths, expected) {
     const snapshot = await readHeart(paths);
-    if (snapshot.soul !== null)
-        return (await bornObservation(paths, expected, snapshot)).row;
+    if (snapshot.soul !== null) {
+        const observed = await bornObservation(paths, expected, () => readHeart(paths), snapshot);
+        return {
+            id: observed.soul.id,
+            archetype: observed.soul.archetype,
+            ...(observed.soul.description === undefined ? {} : { description: observed.soul.description }),
+            life: observed.currentLife,
+            lifeAt: lifeAt(observed.currentLife, observed.snapshot.latestBody, observed.snapshot.latestKill, observed.soul.createdAt),
+            lastActivityAt: observed.snapshot.lastActivityAt,
+            pending: observed.snapshot.pending.map((tell) => tell.id),
+        };
+    }
     try {
         if ((await probeLeash(paths)) === "held")
             return { id: expected, life: "unborn" };
@@ -19,8 +29,8 @@ export async function fleetListRow(paths, expected) {
         throw error;
     }
 }
-async function bornObservation(paths, expected, snapshot) {
-    snapshot ??= await readHeart(paths);
+async function bornObservation(paths, expected, read, snapshot) {
+    snapshot ??= await read();
     if (snapshot.soul === null)
         throw new AkumaNotBornError(expected);
     const claim = await HeldAkumaLeash.try(paths);
@@ -28,7 +38,7 @@ async function bornObservation(paths, expected, snapshot) {
         // A Body may finish after the first read. Refresh under the free seat so
         // neither its release nor a successor can manufacture an untidy observation.
         if (claim !== null)
-            snapshot = await readHeart(paths);
+            snapshot = await read();
         const soul = snapshot.soul;
         if (soul === null)
             throw new AkumaNotBornError(expected);
@@ -39,19 +49,7 @@ async function bornObservation(paths, expected, snapshot) {
             body: snapshot.latestBody,
             kill: snapshot.latestKill,
         });
-        return {
-            snapshot,
-            soul,
-            row: {
-                id: soul.id,
-                archetype: soul.archetype,
-                ...(soul.description === undefined ? {} : { description: soul.description }),
-                life: currentLife,
-                lifeAt: lifeAt(currentLife, snapshot.latestBody, snapshot.latestKill, soul.createdAt),
-                lastActivityAt: snapshot.lastActivityAt,
-                pending: snapshot.pending.map((tell) => tell.id),
-            },
-        };
+        return { snapshot, soul, currentLife };
     }
     finally {
         claim?.release();
@@ -60,20 +58,20 @@ async function bornObservation(paths, expected, snapshot) {
 export async function bornStatus(paths, expected, input) {
     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, row: current } = await bornObservation(paths, expected);
-    const resumeUnsupported = current.life === "stranded" &&
+    const { snapshot, soul, currentLife } = await bornObservation(paths, expected, () => readLifeSnapshot(paths));
+    const resumeUnsupported = currentLife === "stranded" &&
         snapshot.latestSession?.provider === soul.provider.name &&
         (await resolveProviderExecution(soul.provider)).adapter.resume === undefined;
-    const slice = await activitySlice(paths);
-    const selected = selectSnapshot(projectTurns(slice.rows), {
+    const facts = await readStatusFacts(paths, input);
+    const selected = selectSnapshot(projectTurns(facts), {
         aperture: input.aperture,
         budget: ordinarySnapshotBudget(input.ordinaryBudget),
         ...(input.admittedTellId === undefined ? {} : { admittedTellId: input.admittedTellId }),
     });
     return {
         status: {
-            id: current.id,
-            life: current.life,
+            id: soul.id,
+            life: currentLife,
             ...(soul.readonly === undefined ? {} : { readonly: soul.readonly }),
             ...(resumeUnsupported ? { strandedReason: "resume-unsupported" } : {}),
             timeline: selected.snapshot,
@@ -84,6 +82,17 @@ export async function bornStatus(paths, expected, input) {
 export async function readBudgetedStatus(worldPath, id, input) {
     return await bornStatus(pathsForAkuId(worldPath, id), id, input);
 }
+function complete(life, pending) {
+    return life !== "running" && !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);
+}
 export async function readAkumaBirthCwd(worldPath, id) {
     const soul = await readSoul(pathsForAkuId(worldPath, id));
     if (soul === null)

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

@@ -408,8 +408,7 @@ export declare const akumaStatusSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type AkumaStatus = z.infer<typeof akumaStatusSchema>;
 export declare function parseAkumaStatus(value: unknown): AkumaStatus;
-/** The default completion judgment over one complete status snapshot. */
-export declare function defaultWaitComplete(status: AkumaStatus): boolean;
+export { defaultWaitComplete } from "./akuma-observe.js";
 export type { ReadonlyRestraint } from "./provider-recipe.js";
 export type * from "./projection.js";
 export type UnbornAkumaListRow = Readonly<{

package/build/src/akuma/akuma.js

@@ -33,11 +33,7 @@ export const akumaStatusSchema = z
 export function parseAkumaStatus(value) {
     return akumaStatusSchema.parse(value);
 }
-/** The default completion judgment over one complete status snapshot. */
-export function defaultWaitComplete(status) {
-    return (status.life !== "running" &&
-        !status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending"));
-}
+export { defaultWaitComplete } from "./akuma-observe.js";
 export { AkumaNotBornError } from "./akuma-errors.js";
 export function wait(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));

package/build/src/akuma/body.js

@@ -3,7 +3,7 @@ import { fileURLToPath } from "node:url";
 import { abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import { driveTurn, turnRecipe } from "./turn-drive.js";
-import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, provePendingTellDispositionCustody, readHeart, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readNonterminalRequests, recordUndeliveredPendingTells, resolvePendingTellDisposition, } from "./heart/index.js";
+import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, readHeart, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readNonterminalRequests, resolvePendingTellDisposition, } from "./heart/index.js";
 import { worldRootForAkumaPaths } from "./identity.js";
 import { pluginRuntime } from "../plugin/runtime.js";
 import { World } from "../world.js";
@@ -369,15 +369,10 @@ async function settleUndeliveredDisposition(paths, disposition, error) {
     if (!(await heartExists(paths)))
         return;
     const at = new Date().toISOString();
-    await recordUndeliveredPendingTells(paths, at, disposition.tellIds);
-    await resolvePendingTellDisposition(paths, disposition.bodySequence, at);
+    await resolvePendingTellDisposition(paths, disposition.bodySequence, at, "undelivered");
 }
 async function consumeProvenDisposition(paths, disposition) {
-    const proof = await provePendingTellDispositionCustody(paths, disposition);
-    if (proof.kind !== "proven")
-        return false;
-    await resolvePendingTellDisposition(paths, disposition.bodySequence, new Date().toISOString());
-    return true;
+    return await resolvePendingTellDisposition(paths, disposition.bodySequence, new Date().toISOString());
 }
 /**
  * Wait for Heart custody proof of the frozen Tell-id snapshot, or for the
@@ -386,7 +381,7 @@ async function consumeProvenDisposition(paths, disposition) {
  */
 async function awaitDispositionCustody(paths, disposition, child, schedule) {
     for (;;) {
-        if ((await provePendingTellDispositionCustody(paths, disposition)).kind === "proven") {
+        if (await consumeProvenDisposition(paths, disposition)) {
             child.release();
             return { kind: "proven" };
         }
@@ -405,7 +400,7 @@ async function awaitDispositionCustody(paths, disposition, child, schedule) {
             continue;
         timerController.abort();
         await timer.catch(() => undefined);
-        if ((await provePendingTellDispositionCustody(paths, disposition)).kind === "proven") {
+        if (await consumeProvenDisposition(paths, disposition)) {
             child.release();
             return { kind: "proven" };
         }
@@ -417,10 +412,8 @@ async function resolveDecidedPendingTellDisposition(paths, disposition, spawn) {
         if (await consumeProvenDisposition(paths, disposition))
             return;
         const wake = await awaitDispositionCustody(paths, disposition, await spawn({ paths, refuseIfHeld: true }), abortableDelay);
-        if (wake.kind === "proven") {
-            await resolvePendingTellDisposition(paths, disposition.bodySequence, new Date().toISOString());
+        if (wake.kind === "proven")
             return;
-        }
         // Predecessor still holds the leash: leave the Heart disposition open.
         if (wake.kind === "held")
             return;

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

@@ -1,6 +1,6 @@
 import { AkumaNotBornError, defaultWaitComplete } from "./akuma.js";
 import { createAkumaProduct } from "./akuma-product.js";
-import { readBudgetedStatus } from "./akuma.js";
+import { readBudgetedStatus, readWaitComplete } from "./akuma-observe.js";
 import { NO_DISPATCH_ASSOCIATION } from "./dispatch-association.js";
 import { EMPTY_CREATED_TASK_OBSERVATION } from "../task/created-observation.js";
 import { fleetResultSchemas, parseAkumaObservation, } from "./fleet-observation.js";
@@ -45,6 +45,29 @@ async function observeWaitRound(path, ids, signal) {
     }
     return { statuses, unobserved };
 }
+async function probeWaitRound(input) {
+    let observed = 0;
+    let complete = 0;
+    for (const id of input.ids) {
+        input.signal?.throwIfAborted();
+        try {
+            if (await readWaitComplete(input.path, id))
+                complete += 1;
+            observed += 1;
+        }
+        catch (error) {
+            if (input.ids.length <= 1 || error instanceof AkumaNotBornError)
+                throw error;
+            // Plural wait retries unreadable members; final rendering owns diagnostics.
+        }
+    }
+    return observed > 0 && (input.completion === "any" ? complete > 0 : complete === input.ids.length);
+}
+function roundComplete(round, completion) {
+    const settled = round.statuses.map(defaultWaitComplete);
+    return (settled.length > 0 &&
+        (completion === "any" ? settled.some(Boolean) : round.unobserved.length === 0 && settled.every(Boolean)));
+}
 function delay(milliseconds, signal) {
     return new Promise((resolve, reject) => {
         let timer;
@@ -67,16 +90,17 @@ function delay(milliseconds, signal) {
 export async function executeWaitAkuma(input) {
     const deadline = input.timeoutMs === undefined ? undefined : performance.now() + input.timeoutMs;
     for (;;) {
-        const round = await observeWaitRound(input.path, input.ids, input.signal);
-        const settled = round.statuses.map(defaultWaitComplete);
-        const completed = round.statuses.length > 0 &&
-            (input.completion === "any" ? settled.some(Boolean) : round.unobserved.length === 0 && settled.every(Boolean));
-        if (completed || (deadline !== undefined && performance.now() >= deadline)) {
-            return fleetResultSchemas.wait.parse({
-                completion: input.completion,
-                observations: round.statuses.map(akumaOnlyObservation),
-                unobserved: round.unobserved,
-            });
+        if ((deadline !== undefined && performance.now() >= deadline) || (await probeWaitRound(input))) {
+            const round = await observeWaitRound(input.path, input.ids, input.signal);
+            input.signal?.throwIfAborted();
+            // The probe is not a completion receipt. Judge the actual returned values.
+            if (roundComplete(round, input.completion) || (deadline !== undefined && performance.now() >= deadline)) {
+                return fleetResultSchemas.wait.parse({
+                    completion: input.completion,
+                    observations: round.statuses.map(akumaOnlyObservation),
+                    unobserved: round.unobserved,
+                });
+            }
         }
         await delay(deadline === undefined ? POLL_MS : Math.min(POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
     }

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

@@ -2,7 +2,7 @@ import type { AkumaPaths } from "../identity.js";
 import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, SealFact, SessionFact, Soul, TellDeliveryInput, TellFact, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact } from "./facts.js";
 export type { CallFact } from "./facts.js";
 import type { ActivityFact } from "./rows.js";
-import { type ActivityFactSlice } from "./timeline.js";
+import { type StatusFactInput, type ActivityFactSlice } from "./timeline.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
 export { admitRequest, beginRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, unproveRequest, voidRequest, } from "./request-authority.js";
 export { AkumaBusyError, life, lifeAt, projectTell } from "./facts.js";
@@ -22,6 +22,12 @@ export type ActivitySlice = ActivityFactSlice;
 export type { ActivityFact };
 export type { TimelineFact } from "./timeline.js";
 export declare function activitySlice(paths: AkumaPaths): Promise<ActivitySlice>;
+export declare function readStatusFacts(paths: AkumaPaths, input: StatusFactInput): Promise<ActivitySlice["rows"]>;
+type LifeSnapshot = Pick<HeartSnapshot, "soul" | "latestBody" | "latestSession" | "latestKill"> & Readonly<{
+    hasPendingTell: boolean;
+}>;
+/** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
+export declare function readLifeSnapshot(paths: AkumaPaths): Promise<LifeSnapshot>;
 export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">, options?: Readonly<{
     interrupt?: boolean;
 }>): Promise<Readonly<{
@@ -43,29 +49,17 @@ export declare function decidePendingTellDisposition(paths: AkumaPaths, input: R
     handoff: boolean;
 }>): Promise<PendingTellDisposition | null>;
 export declare function readOpenPendingTellDisposition(paths: AkumaPaths): Promise<PendingTellDisposition | null>;
-export declare function resolvePendingTellDisposition(paths: AkumaPaths, bodySequence: number, at: string): Promise<void>;
-/**
- * Heart-owned disposition custody proof. Sequence growth, spawn resolution, and
- * an unqualified held leash are never proof. Returns the successor Body sequence
- * when that exact Body took the frozen Tell-id snapshot by delivery, or true when
- * the snapshot is already fully settled (no longer pending).
- */
-export declare function provePendingTellDispositionCustody(paths: AkumaPaths, disposition: PendingTellDisposition): Promise<Readonly<{
-    kind: "proven";
-    successorBodySequence?: number;
-} | {
-    kind: "unproven";
-}>>;
-export declare function recordUndeliveredPendingTells(paths: AkumaPaths, at: string, tellIds: readonly string[]): Promise<void>;
+/** Prove and consume the persisted decision in one transaction, never a caller's stale member list. */
+export declare function resolvePendingTellDisposition(paths: AkumaPaths, bodySequence: number, at: string, outcome?: "custody" | "undelivered"): Promise<boolean>;
 export declare function readKill(paths: AkumaPaths, bodySequence: number): Promise<KillFact | null>;
-export declare function requestStop(paths: AkumaPaths, at: string): Promise<Readonly<{
+export declare function requestStop(paths: AkumaPaths, at: string, signal?: AbortSignal): Promise<Readonly<{
     kind: "requested";
     body: BodyFact;
 }> | Readonly<{
     kind: "already-killed" | "already-stopped";
     body: BodyFact;
 }>>;
-export declare function requestPause(paths: AkumaPaths, at: string): Promise<Readonly<{
+export declare function requestPause(paths: AkumaPaths, at: string, signal?: AbortSignal): Promise<Readonly<{
     kind: "not-born";
 } | {
     kind: "requested";