@astrosheep/keiyaku 4.6.13 → 4.6.14

package/build/plugins/claude/skills/keiyaku/SKILL.md

@@ -36,6 +36,9 @@ selects the Contract repository; it never retargets that World. `call
 cwd). Without it, the call uses the invocation cwd; `--contract` associates a
 Contract without selecting an execution directory.
 
+An Akuma caller can find its own delegation tree with `keiyaku ls --mine` (or an
+explicit `--caller`); see `keiyaku-akuma` for the roster and its text labels.
+
 `deliver` and `review` may take time after their leading admission.
 `deliver --dry-run` only observes the prospective candidate, standing evidence,
 and target followability; it never runs Verification or hooks or admits work.

package/build/plugins/claude/skills/keiyaku-akuma/SKILL.md

@@ -87,16 +87,36 @@ keiyaku status
 keiyaku status @reviewer
 keiyaku ls aku/
 keiyaku ls "aku/*/*"
+keiyaku ls --mine
 keiyaku history @reviewer --last
 keiyaku history @reviewer --id turn/3
 ```
 
 `status` shows the roster or one Akuma's workdir and effective actions.
 `ls aku/` shows callable names; `ls "aku/*/*"` shows born workers.
+`ls --mine` narrows that roster to Akumas this process's caller called and their
+transitive descendants in this World; `--caller <integration>:<id>` or
+`--caller aku/<name>/<suffix>` names the same selection explicitly. Descendant
+rows show their immediate caller as `· by <akuId>`. The selection is World-local
+and refuses for Contract, Debt, and Akuma-name catalogues.
 `history --last` reads the latest complete answer; `history --id` reads an
 exact result named by status or wait. Use the complete AkuId when an alias may
 move; see `history --help` for paging.
 
+## Retention
+
+An Akuma whose latest durable life or activity is older than fifteen days may be
+retired after a later successful `call` or `fork`. Retention keeps any running
+Akuma, any current alias target, any Akuma dispatched to a Contract that is not
+yet `claimed` or `abandoned`, unborn or stillborn allocations, and unreadable
+entries. It removes only the Akuma's recognized runtime custody; it never kills
+a worker and never rewrites another Akuma, Contract, Debt, or alias. Its final
+Heart re-read keeps a pending Tell it observes; a Tell admitted immediately
+after that read is best-effort, not atomic. There is no timer and no prune
+command. Observation and Tell commands (`status`, `ls`, `history`, `wait`,
+`tell`, `ask`) never trigger retention; without a later successful
+`call`/`fork`, old entries simply remain.
+
 ## Stop and branch
 
 ```bash

package/build/plugins/codex/skills/keiyaku/SKILL.md

@@ -36,6 +36,9 @@ selects the Contract repository; it never retargets that World. `call
 cwd). Without it, the call uses the invocation cwd; `--contract` associates a
 Contract without selecting an execution directory.
 
+An Akuma caller can find its own delegation tree with `keiyaku ls --mine` (or an
+explicit `--caller`); see `keiyaku-akuma` for the roster and its text labels.
+
 `deliver` and `review` may take time after their leading admission.
 `deliver --dry-run` only observes the prospective candidate, standing evidence,
 and target followability; it never runs Verification or hooks or admits work.

package/build/plugins/codex/skills/keiyaku-akuma/SKILL.md

@@ -87,16 +87,36 @@ keiyaku status
 keiyaku status @reviewer
 keiyaku ls aku/
 keiyaku ls "aku/*/*"
+keiyaku ls --mine
 keiyaku history @reviewer --last
 keiyaku history @reviewer --id turn/3
 ```
 
 `status` shows the roster or one Akuma's workdir and effective actions.
 `ls aku/` shows callable names; `ls "aku/*/*"` shows born workers.
+`ls --mine` narrows that roster to Akumas this process's caller called and their
+transitive descendants in this World; `--caller <integration>:<id>` or
+`--caller aku/<name>/<suffix>` names the same selection explicitly. Descendant
+rows show their immediate caller as `· by <akuId>`. The selection is World-local
+and refuses for Contract, Debt, and Akuma-name catalogues.
 `history --last` reads the latest complete answer; `history --id` reads an
 exact result named by status or wait. Use the complete AkuId when an alias may
 move; see `history --help` for paging.
 
+## Retention
+
+An Akuma whose latest durable life or activity is older than fifteen days may be
+retired after a later successful `call` or `fork`. Retention keeps any running
+Akuma, any current alias target, any Akuma dispatched to a Contract that is not
+yet `claimed` or `abandoned`, unborn or stillborn allocations, and unreadable
+entries. It removes only the Akuma's recognized runtime custody; it never kills
+a worker and never rewrites another Akuma, Contract, Debt, or alias. Its final
+Heart re-read keeps a pending Tell it observes; a Tell admitted immediately
+after that read is best-effort, not atomic. There is no timer and no prune
+command. Observation and Tell commands (`status`, `ls`, `history`, `wait`,
+`tell`, `ask`) never trigger retention; without a later successful
+`call`/`fork`, old entries simply remain.
+
 ## Stop and branch
 
 ```bash

package/build/plugins/opencode/skills/keiyaku/SKILL.md

@@ -36,6 +36,9 @@ selects the Contract repository; it never retargets that World. `call
 cwd). Without it, the call uses the invocation cwd; `--contract` associates a
 Contract without selecting an execution directory.
 
+An Akuma caller can find its own delegation tree with `keiyaku ls --mine` (or an
+explicit `--caller`); see `keiyaku-akuma` for the roster and its text labels.
+
 `deliver` and `review` may take time after their leading admission.
 `deliver --dry-run` only observes the prospective candidate, standing evidence,
 and target followability; it never runs Verification or hooks or admits work.

package/build/plugins/opencode/skills/keiyaku-akuma/SKILL.md

@@ -87,16 +87,36 @@ keiyaku status
 keiyaku status @reviewer
 keiyaku ls aku/
 keiyaku ls "aku/*/*"
+keiyaku ls --mine
 keiyaku history @reviewer --last
 keiyaku history @reviewer --id turn/3
 ```
 
 `status` shows the roster or one Akuma's workdir and effective actions.
 `ls aku/` shows callable names; `ls "aku/*/*"` shows born workers.
+`ls --mine` narrows that roster to Akumas this process's caller called and their
+transitive descendants in this World; `--caller <integration>:<id>` or
+`--caller aku/<name>/<suffix>` names the same selection explicitly. Descendant
+rows show their immediate caller as `· by <akuId>`. The selection is World-local
+and refuses for Contract, Debt, and Akuma-name catalogues.
 `history --last` reads the latest complete answer; `history --id` reads an
 exact result named by status or wait. Use the complete AkuId when an alias may
 move; see `history --help` for paging.
 
+## Retention
+
+An Akuma whose latest durable life or activity is older than fifteen days may be
+retired after a later successful `call` or `fork`. Retention keeps any running
+Akuma, any current alias target, any Akuma dispatched to a Contract that is not
+yet `claimed` or `abandoned`, unborn or stillborn allocations, and unreadable
+entries. It removes only the Akuma's recognized runtime custody; it never kills
+a worker and never rewrites another Akuma, Contract, Debt, or alias. Its final
+Heart re-read keeps a pending Tell it observes; a Tell admitted immediately
+after that read is best-effort, not atomic. There is no timer and no prune
+command. Observation and Tell commands (`status`, `ls`, `history`, `wait`,
+`tell`, `ask`) never trigger retention; without a later successful
+`call`/`fork`, old entries simply remain.
+
 ## Stop and branch
 
 ```bash

package/build/skills/keiyaku/SKILL.md

@@ -36,6 +36,9 @@ selects the Contract repository; it never retargets that World. `call
 cwd). Without it, the call uses the invocation cwd; `--contract` associates a
 Contract without selecting an execution directory.
 
+An Akuma caller can find its own delegation tree with `keiyaku ls --mine` (or an
+explicit `--caller`); see `keiyaku-akuma` for the roster and its text labels.
+
 `deliver` and `review` may take time after their leading admission.
 `deliver --dry-run` only observes the prospective candidate, standing evidence,
 and target followability; it never runs Verification or hooks or admits work.

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

@@ -87,16 +87,36 @@ keiyaku status
 keiyaku status @reviewer
 keiyaku ls aku/
 keiyaku ls "aku/*/*"
+keiyaku ls --mine
 keiyaku history @reviewer --last
 keiyaku history @reviewer --id turn/3
 ```
 
 `status` shows the roster or one Akuma's workdir and effective actions.
 `ls aku/` shows callable names; `ls "aku/*/*"` shows born workers.
+`ls --mine` narrows that roster to Akumas this process's caller called and their
+transitive descendants in this World; `--caller <integration>:<id>` or
+`--caller aku/<name>/<suffix>` names the same selection explicitly. Descendant
+rows show their immediate caller as `· by <akuId>`. The selection is World-local
+and refuses for Contract, Debt, and Akuma-name catalogues.
 `history --last` reads the latest complete answer; `history --id` reads an
 exact result named by status or wait. Use the complete AkuId when an alias may
 move; see `history --help` for paging.
 
+## Retention
+
+An Akuma whose latest durable life or activity is older than fifteen days may be
+retired after a later successful `call` or `fork`. Retention keeps any running
+Akuma, any current alias target, any Akuma dispatched to a Contract that is not
+yet `claimed` or `abandoned`, unborn or stillborn allocations, and unreadable
+entries. It removes only the Akuma's recognized runtime custody; it never kills
+a worker and never rewrites another Akuma, Contract, Debt, or alias. Its final
+Heart re-read keeps a pending Tell it observes; a Tell admitted immediately
+after that read is best-effort, not atomic. There is no timer and no prune
+command. Observation and Tell commands (`status`, `ls`, `history`, `wait`,
+`tell`, `ask`) never trigger retention; without a later successful
+`call`/`fork`, old entries simply remain.
+
 ## Stop and branch
 
 ```bash

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

@@ -1,4 +1,4 @@
-import { outcomePluginObserver, stderrPluginDiagnostic } from "../plugin/akuma-signals.js";
+import { outcomePluginObserver, stderrPluginDiagnostic, withAkumaWaitDeferrals } from "../plugin/akuma-signals.js";
 import { abortable } from "./abort.js";
 import { admitAkumaCall } from "./akuma-call.js";
 import { defaultWaitComplete } from "./akuma-observe.js";
@@ -129,11 +129,13 @@ export class Akuma {
             throw new TypeError("Akuma idle timeoutMs must be a nonnegative finite millisecond duration");
         }
         const signal = signalOption(options.signal);
-        const waited = await this.owner(true).waitReceipt(defaultWaitComplete, {
-            ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
-            ...(signal === undefined ? {} : { signal }),
+        return await withAkumaWaitDeferrals({ world: this.root, reportDiagnostic: this.reportDiagnostic }, [this.id], signal, async () => {
+            const waited = await this.owner(true).waitReceipt(defaultWaitComplete, {
+                ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+                ...(signal === undefined ? {} : { signal }),
+            });
+            return { reason: waited.reason, status: waited.status };
         });
-        return { reason: waited.reason, status: waited.status };
     }
     async history(options = {}) {
         if (typeof options !== "object" || options === null || Array.isArray(options)) {

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

@@ -18,6 +18,7 @@ export async function rosterListRow(paths, expected, aliases = []) {
             lastActivityAt: observed.snapshot.lastActivityAt,
             pending: observed.snapshot.pending.map((tell) => tell.id),
             aliases,
+            ...(observed.soul.caller === undefined ? {} : { caller: observed.soul.caller }),
         };
     }
     try {

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

@@ -179,12 +179,13 @@ export class AkumaOwner {
             path: this.worldPath,
             ids: [this.id],
             completion: "all",
-            ...(this.outcomeObserved === undefined ? {} : { outcomeObserved: this.outcomeObserved }),
             ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
             ...(options.signal === undefined ? {} : { signal: options.signal }),
             ...(predicate === defaultWaitComplete ? {} : { predicate }),
         });
-        return { reason: waited.reason, status: waited.observations[0] };
+        const status = waited.observations[0];
+        await observeStatusOutcome(status, this.outcomeObserved);
+        return { reason: waited.reason, status };
     }
     async wait(predicate = defaultWaitComplete, options = {}) {
         return (await this.waitReceipt(predicate, options)).status;

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

@@ -1,5 +1,5 @@
 import type { WorldRoot } from "../world.js";
-import { type OutcomeObserver, type WaitReason } from "./akuma-observe.js";
+import { type WaitReason } from "./akuma-observe.js";
 import type { AkumaStatus } from "./akuma.js";
 import type { AkumaUnobserved } from "./selection-observation.js";
 type WaitExecutionInput = Readonly<{
@@ -10,7 +10,6 @@ type WaitExecutionInput = Readonly<{
     signal?: AbortSignal;
     /** Internal custom completion judge over the full final observation where supplied. */
     predicate?: (status: AkumaStatus) => boolean;
-    outcomeObserved?: OutcomeObserver;
 }>;
 /** One wait's association-free native evidence; upper composition attaches cross-product context. */
 export type NativeWaitResult = Readonly<{

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

@@ -1,5 +1,5 @@
 import { AkumaNotBornError } from "./akuma-errors.js";
-import { createLiveStatusReader, defaultWaitComplete, readWaitComplete, observeStatusOutcome, waitForObservation, } from "./akuma-observe.js";
+import { createLiveStatusReader, defaultWaitComplete, readWaitComplete, waitForObservation, } from "./akuma-observe.js";
 import { pathsForAkuId } from "./identity.js";
 const SHARED_ORDINARY_BUDGET = 30;
 async function observeWaitRound(ids, readerFor, signal) {
@@ -56,9 +56,6 @@ export async function executeWaitAkuma(input) {
                 : {}),
             observe: async () => await observeWaitRound(input.ids, readerFor, input.signal),
             complete: (round) => roundComplete(round, input.completion, input.predicate),
-            onObserve: async (round) => {
-                await Promise.all(round.observations.map(({ status }) => observeStatusOutcome(status, input.outcomeObserved)));
-            },
         });
         return {
             mode: input.completion,

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

@@ -1,3 +1,4 @@
+import { type AkumaCaller } from "./caller.js";
 import { z } from "zod";
 import { type BoundedList } from "../bounded-list.js";
 import type { AkumaAlias } from "../identity/selector.js";
@@ -13,6 +14,7 @@ export type AkumaListRow = Readonly<{
     lastActivityAt: string | null;
     pending: readonly string[];
     aliases: readonly AkumaAlias[];
+    caller?: AkumaCaller;
 }>;
 export type UnbornAkumaListRow = Readonly<{
     id: AkuId;
@@ -30,6 +32,7 @@ export type AkumaList = BoundedList<AkumaListRow | UnbornAkumaListRow> & Readonl
 export type AkumaCompleteList = Omit<AkumaList, "hasMore">;
 export type AkumaListInput = Readonly<{
     archetype?: string;
+    caller?: AkumaCaller;
     limit?: number;
 }>;
 export declare const akumaStatusSchema: z.ZodObject<{
@@ -480,16 +483,18 @@ export declare function knownAkuma(path: WorldRoot, selected?: string): Promise<
     runRoot: string;
     rows: readonly KnownAkuma[];
 }>>;
+/** The bounded recent-activity roster input: native membership and observed extent. */
+export declare function readAkumaRoster(path: WorldRoot, input?: AkumaListInput): Promise<AkumaList>;
 /**
  * The bounded recent-activity roster: native membership, semantic order and
- * observed extent. World Alias context is attached by the upper composition.
+ * observed extent. A caller-scoped roster filters its World-local closure before
+ * this same activity order and bound; World Alias context is attached above.
  */
-export declare function readAkumaRoster(path: WorldRoot, input?: AkumaListInput): Promise<AkumaList>;
-/** Internal recent observation with an aperture already validated by the composition. */
-export declare function observeAkumaRoster(path: WorldRoot, limit: number, selected?: string): Promise<AkumaList>;
+export declare function observeAkumaRoster(path: WorldRoot, limit: number, selected?: string, caller?: AkumaCaller): Promise<AkumaList>;
 /** The complete native roster for callers whose semantics require a frozen set. */
 export declare function readAkumaCompleteRoster(path: WorldRoot, input?: Readonly<{
     archetype?: string;
+    caller?: AkumaCaller;
 }>): Promise<AkumaCompleteList>;
 /** Internal timeline observation for composition owners. */
 export declare function readAkumaTimeline(path: WorldRoot, id: AkuId): Promise<AkumaStatus["timeline"]>;

package/build/src/akuma/akuma.js

@@ -1,12 +1,14 @@
-import { akumaBirthSchema } from "./caller.js";
+import { akumaBirthSchema, akumaCallerKey, decodeAkumaCaller } from "./caller.js";
 import { readdir, stat } from "node:fs/promises";
 import { z } from "zod";
 import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
 import { rosterListRow } from "./akuma-observe.js";
 import { AkumaOwner } from "./akuma-owner.js";
 import { allowedActionsSchema } from "./allowed.js";
-import { akuIdFromDirectoryName, akumaIdSchema, akumaPaths, akumaRunRoot, } from "./identity.js";
+import { readSoul } from "./heart/index.js";
+import { akuIdFromDirectoryName, akumaIdSchema, akumaPaths, akumaRunRoot, parseAkuId, pathsForAkuId, } from "./identity.js";
 import { validateAkumaName } from "../identity/normalize.js";
+import { readAkumaLineage, readDirectAkumaLineage, invalidateAkumaLineage, rebuildAkumaLineage, } from "./lineage-cache.js";
 import { activitySnapshotSchema } from "./projection.js";
 import { PAGE_POOL_SIZE, boundedMap } from "./read-pool.js";
 export const akumaStatusSchema = z
@@ -91,6 +93,11 @@ export async function knownAkuma(path, selected) {
     }
     return { runRoot, rows };
 }
+/** Preorder candidates by their freshest Heart mtime so paging reads changed rows first. */
+async function freshnessOrdered(rows) {
+    const bounded = await boundedMap(rows, async (row) => ({ ...row, bound: await mtimeBound(row.paths) }));
+    return [...bounded].sort((left, right) => right.bound - left.bound);
+}
 async function readableRows(rows) {
     const loaded = await boundedMap(rows, async ({ id, paths }) => {
         try {
@@ -100,43 +107,152 @@ async function readableRows(rows) {
             return null;
         }
     });
-    return [...loaded].filter((row) => row !== null);
+    const values = [...loaded].filter((row) => row !== null);
+    return { rows: values, skipped: loaded.length - values.length };
 }
-function rosterArchetype(input, allowLimit) {
+function rosterInput(input, allowLimit) {
     if (typeof input !== "object" || input === null || Array.isArray(input))
         throw new TypeError("Akuma list input must be an object");
-    const allowed = allowLimit ? ["archetype", "limit"] : ["archetype"];
+    const allowed = allowLimit ? ["archetype", "caller", "limit"] : ["archetype", "caller"];
     const unknown = Object.keys(input).find((key) => !allowed.includes(key));
     if (unknown !== undefined)
         throw new TypeError(`Akuma list input has unknown field: ${unknown}`);
-    return input.archetype === undefined ? undefined : validateAkumaName(input.archetype);
+    const caller = decodeAkumaCaller(input.caller);
+    return {
+        ...(input.archetype === undefined ? {} : { archetype: validateAkumaName(input.archetype) }),
+        ...(caller === undefined ? {} : { caller }),
+    };
 }
 /**
- * The bounded recent-activity roster: native membership, semantic order and
- * observed extent. World Alias context is attached by the upper composition.
+ * The caller closure follows only frozen Soul edges: the exact root coordinate,
+ * then Akuma coordinates inside this selected World. Fork origin is not an edge.
+ * Known identities deduplicate repeated and cyclic edges.
  */
-export async function readAkumaRoster(path, input = {}) {
-    const selected = rosterArchetype(input, true);
-    const limit = boundedListLimit(input.limit);
-    return observeAkumaRoster(path, limit, selected);
+function callerClosure(lineage, root, world) {
+    if (root.kind === "akuma" && root.world !== world)
+        return new Set();
+    const children = new Map();
+    for (const [akuId, caller] of lineage) {
+        if (caller === null)
+            continue;
+        const key = akumaCallerKey(caller);
+        const siblings = children.get(key);
+        if (siblings === undefined)
+            children.set(key, [akuId]);
+        else
+            siblings.push(akuId);
+    }
+    const included = new Set();
+    const visited = new Set();
+    const queue = [root];
+    while (queue.length > 0) {
+        const caller = queue.shift();
+        const key = akumaCallerKey(caller);
+        if (visited.has(key))
+            continue;
+        visited.add(key);
+        for (const akuId of children.get(key) ?? []) {
+            if (included.has(akuId))
+                continue;
+            included.add(akuId);
+            queue.push({ kind: "akuma", world, akuId });
+        }
+    }
+    return included;
 }
-/** Internal recent observation with an aperture already validated by the composition. */
-export async function observeAkumaRoster(path, limit, selected) {
-    const observedAt = new Date().toISOString();
-    const known = await knownAkuma(path, selected);
-    const candidatesWithBounds = await boundedMap(known.rows, async (row) => ({
-        ...row,
-        bound: await mtimeBound(row.paths),
-    }));
-    const candidates = [...candidatesWithBounds].sort((left, right) => right.bound - left.bound);
-    const readable = [];
+function sameCallerEvidence(left, right) {
+    if (left === null || right === null)
+        return left === right;
+    return akumaCallerKey(left) === akumaCallerKey(right);
+}
+async function readCallerSoul(world, akuId) {
+    try {
+        const soul = await readSoul(pathsForAkuId(world, akuId));
+        return soul === null ? { kind: "absent" } : { kind: "born", caller: soul.caller ?? null };
+    }
+    catch {
+        return { kind: "unreadable" };
+    }
+}
+async function soulEdgeFor(verification, akuId) {
+    const observed = verification.souls.get(akuId);
+    if (observed !== undefined)
+        return await observed;
+    const pending = readCallerSoul(verification.world, akuId);
+    verification.souls.set(akuId, pending);
+    return await pending;
+}
+/**
+ * The cache may propose a member; only the born Soul chain can justify it. Each
+ * returned member's own edge is compared with its born Soul, and every parent
+ * link on that chain is proven the same way back to the exact query root.
+ * Any disagreement means the record cannot be trusted for this answer.
+ */
+async function verifyCallerMember(verification, id, observedCaller) {
+    const { lineage, root } = verification;
+    const rowCaller = observedCaller ?? null;
+    const cached = lineage.get(id);
+    if (cached === undefined)
+        return "invalid-cache";
+    if (!sameCallerEvidence(cached, rowCaller))
+        return "invalid-cache";
+    const rootKey = akumaCallerKey(root);
+    const seen = new Set();
+    let current = rowCaller;
+    for (;;) {
+        if (current === null)
+            return "excluded";
+        const key = akumaCallerKey(current);
+        if (key === rootKey)
+            return "included";
+        if (seen.has(key))
+            return "excluded";
+        seen.add(key);
+        if (current.kind === "external")
+            return "excluded";
+        if (current.world !== verification.world)
+            return "excluded";
+        const parentId = current.akuId;
+        const parentCached = lineage.get(parentId);
+        const edge = await soulEdgeFor(verification, parentId);
+        if (edge.kind === "unreadable")
+            return "unknown";
+        // A cached parent that has no born Soul cannot seed a real chain.
+        if (edge.kind === "absent")
+            return "invalid-cache";
+        if (parentCached === undefined)
+            return "excluded";
+        if (!sameCallerEvidence(parentCached, edge.caller))
+            return "invalid-cache";
+        current = edge.caller;
+    }
+}
+/**
+ * Read only the matching candidates needed for the requested page and its
+ * lookahead. `admit` proves each readable member; without it the selected
+ * closure's own born Soul edges are the proof. Unprovable members are skipped
+ * honestly instead of reported as no more.
+ */
+async function pageCallerRows(candidates, limit, admit) {
+    const rows = [];
+    let skipped = 0;
     let cursor = 0;
     while (cursor < candidates.length) {
         const batch = candidates.slice(cursor, cursor + PAGE_POOL_SIZE);
-        readable.push(...(await readableRows(batch)));
+        const observed = await readableRows(batch);
         cursor += batch.length;
-        const ranked = readable.sort(compareRows);
-        const lookahead = ranked[limit];
+        skipped += observed.skipped;
+        for (const row of observed.rows) {
+            const verdict = admit === undefined ? "included" : await admit(row);
+            if (verdict === "invalid-cache")
+                return { rows, skipped, invalid: true };
+            if (verdict === "included")
+                rows.push(row);
+            else if (verdict === "unknown")
+                skipped += 1;
+        }
+        rows.sort(compareRows);
+        const lookahead = rows[limit];
         const activity = lookahead === undefined ? null : activityAt(lookahead);
         const unreadBound = candidates[cursor]?.bound;
         if (lookahead !== undefined &&
@@ -148,20 +264,77 @@ export async function observeAkumaRoster(path, limit, selected) {
             break;
         }
     }
-    const ranked = readable.sort(compareRows);
-    return {
-        observedAt,
-        searched: [known.runRoot],
-        ...projectBoundedList(ranked, limit),
-    };
+    return { rows: rows.sort(compareRows), skipped, invalid: false };
+}
+/**
+ * The caller closure across every Archetype, before the requested one narrows
+ * it, ordered so paging reads freshly changed members first.
+ */
+async function callerCandidates(rows, lineage, root, world, selected) {
+    const closure = callerClosure(lineage, root, world);
+    return await freshnessOrdered(rows.filter((row) => closure.has(row.id) && (selected === undefined || parseAkuId(row.id).archetype === selected)));
+}
+/**
+ * One caller-scoped page. The World-local record only proposes members: each is
+ * re-proven against its born Soul chain, and one disagreement discards the
+ * record and answers from direct Soul evidence instead of an empty success.
+ */
+async function readCallerPage(path, limit, selected, caller) {
+    const known = await knownAkuma(path);
+    const cached = await readAkumaLineage(path, known.rows);
+    const verification = { world: path, root: caller, lineage: cached, souls: new Map() };
+    const attempted = await pageCallerRows(await callerCandidates(known.rows, cached, caller, path, selected), limit, 
+    // A cache-proposed identity without a born Soul cannot justify inclusion.
+    async (row) => ("lifeAt" in row ? await verifyCallerMember(verification, row.id, row.caller) : "invalid-cache"));
+    if (!attempted.invalid)
+        return attempted;
+    // One wrong edge makes the whole disposable record untrustworthy.
+    await invalidateAkumaLineage(path);
+    const direct = await readDirectAkumaLineage(known.rows);
+    const repaired = await pageCallerRows(await callerCandidates(known.rows, direct, caller, path, selected), limit);
+    await rebuildAkumaLineage(path, direct);
+    return repaired;
+}
+/** The bounded recent-activity roster input: native membership and observed extent. */
+export async function readAkumaRoster(path, input = {}) {
+    const selection = rosterInput(input, true);
+    const limit = boundedListLimit(input.limit);
+    return observeAkumaRoster(path, limit, selection.archetype, selection.caller);
+}
+/**
+ * The bounded recent-activity roster: native membership, semantic order and
+ * observed extent. A caller-scoped roster filters its World-local closure before
+ * this same activity order and bound; World Alias context is attached above.
+ */
+export async function observeAkumaRoster(path, limit, selected, caller) {
+    const observedAt = new Date().toISOString();
+    if (caller !== undefined) {
+        const page = await readCallerPage(path, limit, selected, caller);
+        const bounded = projectBoundedList(page.rows, limit);
+        return {
+            observedAt,
+            // A skipped or unprovable candidate leaves the extent unknowable, never empty.
+            hasMore: bounded.hasMore || page.skipped > 0,
+            rows: bounded.rows,
+            searched: [akumaRunRoot(path)],
+        };
+    }
+    const known = await knownAkuma(path, selected);
+    const ranked = await pageCallerRows(await freshnessOrdered(known.rows), limit);
+    return { observedAt, searched: [known.runRoot], ...projectBoundedList(ranked.rows, limit) };
 }
 /** The complete native roster for callers whose semantics require a frozen set. */
 export async function readAkumaCompleteRoster(path, input = {}) {
-    const selected = rosterArchetype(input, false);
-    const known = await knownAkuma(path, selected);
+    const selection = rosterInput(input, false);
+    const observedAt = new Date().toISOString();
+    if (selection.caller !== undefined) {
+        const page = await readCallerPage(path, Number.POSITIVE_INFINITY, selection.archetype, selection.caller);
+        return { observedAt, rows: page.rows, searched: [akumaRunRoot(path)] };
+    }
+    const known = await knownAkuma(path, selection.archetype);
     return {
-        observedAt: new Date().toISOString(),
-        rows: [...(await readableRows(known.rows))].sort(compareRows),
+        observedAt,
+        rows: [...(await readableRows(known.rows)).rows].sort(compareRows),
         searched: [known.runRoot],
     };
 }

package/build/src/akuma/body.js

@@ -9,6 +9,7 @@ import { BodySupervisor } from "./body-supervisor.js";
 import { driveTurn, turnRecipe } from "./turn-drive.js";
 import { HeldAkumaLeash, BodyControlledError, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, readHeart, readLatestTurnForBody, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readTurnParticipants, readNonterminalRequests, resolvePendingTellDisposition, } from "./heart/index.js";
 import { akumaPathsSchema, pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
+import { recordAkumaLineage } from "./lineage-cache.js";
 import { admitCallInitialTell, } from "./call-initial-tell.js";
 import { akumaExecutionEnvironment } from "./providers/execution-environment.js";
 import { emitPluginSignal } from "../plugin/akuma-signals.js";
@@ -247,6 +248,9 @@ async function prepareBodyExecution(launch, leash, runtime, adapter) {
     const birth = await bornSoul(launch, leash, runtime.now());
     if (birth === null)
         return null;
+    // The immutable caller edge refreshes after Soul durability, best-effort.
+    if (birth.created)
+        void recordAkumaLineage(runtime.world, birth.soul);
     const { soul } = birth;
     if (!(await prepareBodyStart(launch.paths, leash)))
         return null;

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

@@ -37,3 +37,5 @@ export declare const akumaBirthSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare function projectAkumaBirth(soul: Soul): z.infer<typeof akumaBirthSchema>;
 export declare function decodeAkumaCaller(value: unknown): AkumaCaller | undefined;
+/** One stable comparison coordinate for stored and queried caller attribution. */
+export declare function akumaCallerKey(caller: AkumaCaller): string;