@astrosheep/keiyaku 4.6.7 → 4.6.9

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

@@ -1,11 +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";
@@ -83,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;
@@ -145,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");
@@ -223,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);
@@ -319,6 +330,7 @@ export class AkumaOwner {
         };
     }
     async fork(input) {
+        const caller = decodeAkumaCaller(input.caller);
         const source = await readSoul(this.paths);
         if (source === null)
             throw new AkumaNotBornError(this.id);
@@ -366,8 +378,10 @@ export class AkumaOwner {
                             allowed: source.allowed,
                             cwd: source.cwd,
                             origin: { kind: "fork", parent: this.id, at: input.at },
+                            ...(caller === undefined ? {} : { caller }),
                         },
                         birthSession,
+                        ...(input.initiator === undefined ? {} : { birthInitiator: input.initiator }),
                     });
                 },
             });

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

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

@@ -3,7 +3,7 @@ import { type BoundedList } from "../bounded-list.js";
 import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
 import type { AkumaLife } from "./heart/index.js";
-import { type AkuId } from "./identity.js";
+import { type AkuId, type AkumaPaths } from "./identity.js";
 export type AkumaListRow = Readonly<{
     id: AkuId;
     archetype: string;
@@ -34,6 +34,30 @@ export type AkumaListInput = Readonly<{
 }>;
 export declare const akumaStatusSchema: z.ZodObject<{
     id: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+    birth: z.ZodObject<{
+        origin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"direct">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"request">;
+            parent: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+            requestId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"fork">;
+            parent: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+            at: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        caller: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"akuma">;
+            world: z.ZodCustom<WorldRoot, WorldRoot>;
+            akuId: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"external">;
+            integration: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strict>], "kind">, z.ZodObject<{
+            kind: z.ZodLiteral<"unknown">;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>;
     life: z.ZodEnum<{
         killed: "killed";
         hung: "hung";
@@ -43,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;
@@ -204,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;
@@ -218,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">;
@@ -254,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;
@@ -273,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>]>>>;
@@ -307,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;
@@ -412,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;
@@ -431,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>]>>>;
@@ -441,10 +471,16 @@ export declare const akumaStatusSchema: z.ZodObject<{
     strandedReason: z.ZodOptional<z.ZodLiteral<"resume-unsupported">>;
 }, z.core.$strict>;
 export type AkumaStatus = z.infer<typeof akumaStatusSchema>;
-export declare function parseAkumaStatus(value: unknown): AkumaStatus;
-export declare function listAkumaArchetypes(path: WorldRoot, input?: Readonly<{
-    home?: string;
-}>): Promise<readonly string[]>;
+/** One recognized Akuma directory under this World's run root. */
+export type KnownAkuma = Readonly<{
+    id: AkuId;
+    paths: AkumaPaths;
+}>;
+/** Enumerate the recognized Akuma directories under this World's run root. */
+export declare function knownAkuma(path: WorldRoot, selected?: string): Promise<Readonly<{
+    runRoot: string;
+    rows: readonly KnownAkuma[];
+}>>;
 /**
  * The bounded recent-activity roster: native membership, semantic order and
  * observed extent. World Alias context is attached by the upper composition.