@astrosheep/keiyaku 4.5.22 → 4.5.24

package/build/src/cli/commands/akuma-invoke.d.ts

@@ -1,6 +1,7 @@
 import { type AkuId } from "../../akuma/identity.js";
 import { type ActivityHistory } from "../../akuma/akuma.js";
 import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaObservation, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
+import { type WaitSelectedIdentity } from "../render/akuma-activity.js";
 import type { Settings } from "../../settings.js";
 import type { WorldRoot } from "../../world.js";
 import type { InvokedAkumaCommand } from "./akuma.js";
@@ -23,6 +24,10 @@ export type AkumaInvocationResult = Readonly<{
     result: AkumaWaitResult;
     alias?: string;
     streamed?: boolean;
+    /** The moment this invocation began waiting, so a non-streamed scoreboard asserts real waiting. */
+    startedAt?: number;
+    /** The frozen selected set, so a non-streamed render names each target as the caller selected it. */
+    selection?: readonly WaitSelectedIdentity[];
 }> | Readonly<{
     kind: "akuma";
     action: "tell";

package/build/src/cli/commands/akuma-invoke.js

@@ -82,9 +82,12 @@ async function promptBody(command, input) {
  * baseline, so an already settled Akuma prints no backlog rows. When the wait
  * ends, `conclude` prints its closing scoreboard on the same channel.
  */
-function waitObserver(stream) {
+function waitObserver(stream, onSelected) {
     return {
-        selected: (selected) => stream.select(selected),
+        selected: (selected) => {
+            onSelected?.(selected);
+            stream.select(selected);
+        },
         observe: (observed) => {
             const lines = stream.observe(observed);
             if (lines.length > 0)
@@ -95,13 +98,24 @@ function waitObserver(stream) {
 async function invokeWait(command, input) {
     const alias = command.akuma.length === 1 ? inputAlias(command.akuma[0]) : undefined;
     const stream = command.output === "text" ? waitObservationStream(resultContext()) : undefined;
+    const startedAt = Date.now();
+    let selection;
+    const observer = stream === undefined
+        ? undefined
+        : waitObserver(stream, (selected) => {
+            selection = selected;
+        });
     const result = await waitAkuma({
         path: input.path,
         akuma: command.akuma,
         ...(input.repo === undefined ? {} : { repo: input.repo }),
         ...(command.completion === undefined ? {} : { completion: command.completion }),
         ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
-    }, input.execution ?? localExecutionContext(), stream === undefined ? undefined : waitObserver(stream));
+    }, input.execution ?? localExecutionContext(), observer);
+    const frozen = {
+        startedAt,
+        ...(selection === undefined ? {} : { selection }),
+    };
     if (stream !== undefined && stream.streamed()) {
         const closing = stream.conclude(result);
         if (closing.length > 0)
@@ -112,6 +126,7 @@ async function invokeWait(command, input) {
             result,
             streamed: true,
             ...(alias === undefined ? {} : { alias }),
+            ...frozen,
         };
     }
     return {
@@ -119,6 +134,7 @@ async function invokeWait(command, input) {
         action: "wait",
         result,
         ...(alias === undefined ? {} : { alias }),
+        ...frozen,
     };
 }
 async function inputInitiator(input) {

package/build/src/cli/render/akuma-activity.d.ts

@@ -60,6 +60,7 @@ export type WaitConclusionResult = Readonly<{
 export type WaitSelectedIdentity = Readonly<{
     id: string;
     alias?: string;
+    contract?: DispatchAssociation;
 }>;
 export type WaitObservationStream = Readonly<{
     /** Freeze the selected set's identities so the source column is stable before the first row. */
@@ -72,9 +73,11 @@ export type WaitObservationStream = Readonly<{
 }>;
 /**
  * Live view over a wait's successive observation rounds, one append-only
- * stream per selected Akuma. Each Akuma's stream opens with its identity frame
- * — the identity and Contract association the observed facts carry — before any
- * row; an already settled Akuma prints that frame and never replays backlog
+ * stream per selected Akuma. A plural wait opens one aggregate frame naming
+ * its selected set before any activity row and never opens a per-target frame
+ * during observation; a single-target wait opens that Akuma's own identity
+ * frame — the identity and Contract association the observed facts carry —
+ * and an already settled Akuma prints that frame while replaying no backlog
  * rows. `conclude` renders the closing rows once the wait ends: one row per
  * observed Akuma in `<clock> <mark> <verb> — <duration>` grammar, with a target
  * named for a multi-target scoreboard and no activity replay.

package/build/src/cli/render/akuma-activity.js

@@ -30,7 +30,7 @@ export function snapshotHeading(id, alias, contract) {
     return [...head, frameRule(head)];
 }
 function answeredHeading(id, alias) {
-    const heading = `✓ came back ${identity(id, alias)}`;
+    const heading = `✓ answered ${identity(id, alias)}`;
     return [heading, frameRule([heading])];
 }
 function contractFacts(contract) {
@@ -436,18 +436,18 @@ export function activityStream(context, layout = plainLayout()) {
 }
 function conclusionMarkVerb(status, answered) {
     if (status.life === "running")
-        return { mark: "●", verb: "still running", waited: true };
+        return { mark: "●", verb: "still running" };
     if (answered)
-        return { mark: "✓", verb: "answered", waited: false };
+        return { mark: "✓", verb: "answered" };
     if (status.life === "asleep")
-        return { mark: "!", verb: "failed", waited: false };
+        return { mark: "!", verb: "failed" };
     if (status.life === "killed")
-        return { mark: "×", verb: "killed", waited: false };
+        return { mark: "×", verb: "killed" };
     if (status.life === "hung")
-        return { mark: "?", verb: "hung", waited: false };
+        return { mark: "?", verb: "hung" };
     if (status.life === "untidy")
-        return { mark: "!", verb: "untidy", waited: false };
-    return { mark: "!", verb: "stranded", waited: false };
+        return { mark: "!", verb: "untidy" };
+    return { mark: "!", verb: "stranded" };
 }
 /**
  * The durable moment an Akuma settled, read from the outcome row its own timeline
@@ -473,51 +473,105 @@ function durationText(durationMs) {
 function createWaitObservationState() {
     return {
         streams: new Map(),
-        attributed: new Map(),
         sources: new Map(),
+        contracts: new Map(),
         settledAt: new Map(),
         sourceWidth: 0,
-        opened: false,
+        plural: undefined,
+        headerEmitted: false,
         observed: false,
     };
 }
-function registerWaitSource(state, id, alias) {
+/** Register one selected or newly observed source; the set freezes the column before the first row. */
+function registerWaitSource(state, id, alias, contract) {
     if (state.sources.has(id))
         return;
     const label = alias ?? id;
     state.sources.set(id, label);
-    state.sourceWidth = Math.max(state.sourceWidth, displayColumns(label));
+    if (contract !== undefined)
+        state.contracts.set(id, contract);
+    if (!state.headerEmitted)
+        state.sourceWidth = Math.max(state.sourceWidth, displayColumns(label));
+}
+/**
+ * The one aggregate head a plural wait prints before any activity row: the
+ * selected set read as a list, each target on its own line named by the alias
+ * addressing it, otherwise its complete identity, with its `· kei/<contract>`
+ * association inline when one exists, all closed by the frame's single rule.
+ */
+function aggregateHeading(state) {
+    const head = [...state.sources].map(([id, label]) => {
+        const contractId = associatedContractId(state.contracts.get(id) ?? { kind: "none" });
+        return contractId === undefined ? label : `${label} · ${contractId}`;
+    });
+    return [...head, frameRule(head)];
 }
 function observeWaitRound(state, round, context, now) {
     state.observed = true;
     // Establish the whole round's sources before any row so widths stay aligned within it.
     for (const member of round)
-        registerWaitSource(state, member.status.id, member.alias);
+        registerWaitSource(state, member.status.id, member.alias, member.contract);
     const lines = [];
-    for (const { status, alias, contract } of round) {
+    // The observation subject opens once: an aggregate head for a plural set, the observed
+    // identity frame for a single target. Every later round only appends attributed rows.
+    if (!state.headerEmitted && round.length > 0) {
+        state.headerEmitted = true;
+        state.plural ??= state.sources.size > 1;
+        if (state.plural) {
+            lines.push(...aggregateHeading(state));
+        }
+        else {
+            const sole = round[0];
+            lines.push(...snapshotHeading(sole.status.id, sole.alias, sole.contract));
+        }
+    }
+    for (const { status } of round) {
         const known = state.streams.get(status.id);
-        if (known === undefined) {
-            if (state.opened)
-                lines.push("");
-            lines.push(...snapshotHeading(status.id, alias, contract));
-            state.opened = true;
-            state.attributed.set(status.id, alias);
+        if (known !== undefined) {
+            lines.push(...known(status.timeline));
+        }
+        else {
             // Only a plural wait attributes its rows; a single-target stream keeps the plain row grammar.
-            const stream = activityStream(context, state.sources.size > 1
+            const stream = activityStream(context, state.plural === true
                 ? sourceLayout(state.sources.get(status.id) ?? status.id, () => state.sourceWidth)
                 : plainLayout());
             state.streams.set(status.id, stream);
             // A wait starts at the current settled frontier: its backlog is neither evidence nor budget.
             lines.push(...stream.seed(status.timeline));
         }
-        else {
-            lines.push(...known(status.timeline));
-        }
         if (!state.settledAt.has(status.id) && waitComplete(status))
             state.settledAt.set(status.id, settleMoment(status) ?? now());
     }
     return lines;
 }
+/**
+ * A conclusion clause asserts real waiting: a target that settled at or after
+ * this wait began keeps its duration, a target already settled names no
+ * duration, and an unfinished target carries the elapsed wait.
+ */
+function conclusionClause(at, startedAt, complete, end) {
+    if (!complete)
+        return ` — waited ${durationText(Math.max(0, end - startedAt))}`;
+    return at >= startedAt ? ` — ${durationText(Math.max(0, at - startedAt))}` : "";
+}
+/** Present ids in frozen selection order, then any result member the selection never named. */
+function orderedWaitIds(state, result) {
+    const ids = [...state.sources.keys()];
+    const known = new Set(ids);
+    for (const observation of result.observations) {
+        if (!known.has(observation.status.id)) {
+            known.add(observation.status.id);
+            ids.push(observation.status.id);
+        }
+    }
+    for (const member of result.unobserved) {
+        if (!known.has(member.id)) {
+            known.add(member.id);
+            ids.push(member.id);
+        }
+    }
+    return ids;
+}
 function concludeWaitStream(state, result, startedAt, now) {
     const tail = [];
     // The returned observation can be newer than the final callback. Advance every known stream
@@ -530,19 +584,26 @@ function concludeWaitStream(state, result, startedAt, now) {
     for (const stream of state.streams.values())
         tail.push(...stream.flush());
     const end = now();
-    const total = result.observations.length + result.unobserved.length;
-    const multi = total > 1;
-    const conclusions = result.observations.map((observation) => {
+    const order = orderedWaitIds(state, result);
+    const multi = order.length > 1;
+    const observationById = new Map(result.observations.map((observation) => [observation.status.id, observation]));
+    const unobservedById = new Map(result.unobserved.map((member) => [member.id, member]));
+    // A multi-target scoreboard names the frozen source label; a single target keeps the bare diagnostic.
+    const label = (id) => (multi ? (state.sources.get(id) ?? id) : id);
+    const unobservedLines = order
+        .filter((id) => unobservedById.has(id))
+        .map((id) => unobservedText(label(id), unobservedById.get(id).diagnostic));
+    const conclusions = order.flatMap((id) => {
+        const observation = observationById.get(id);
+        if (observation === undefined)
+            return [];
         const status = observation.status;
-        const answered = statusAnswer(observation) !== undefined;
         const complete = waitComplete(status);
-        const at = complete ? (state.settledAt.get(status.id) ?? end) : end;
-        const durationMs = Math.max(0, at - startedAt);
-        const { mark, verb, waited } = conclusionMarkVerb(status, answered);
-        const target = multi ? ` ${padToDisplay(state.sources.get(status.id) ?? status.id, state.sourceWidth)}` : "";
-        return `${clockFromMs(at)}${target} ${mark} ${verb} — ${waited ? "waited " : ""}${durationText(durationMs)}`;
+        const at = complete ? (state.settledAt.get(id) ?? end) : end;
+        const { mark, verb } = conclusionMarkVerb(status, statusAnswer(observation) !== undefined);
+        const target = multi ? ` ${padToDisplay(state.sources.get(id) ?? id, state.sourceWidth)}` : "";
+        return [`${clockFromMs(at)}${target} ${mark} ${verb}${conclusionClause(at, startedAt, complete, end)}`];
     });
-    const unobservedLines = result.unobserved.map((member) => unobservedText(member.id, member.diagnostic));
     const answeredSingle = !multi && result.observations.length === 1 && statusAnswer(result.observations[0]) !== undefined;
     const blocks = [
         ...(unobservedLines.length > 0 ? [unobservedLines.join("\n")] : []),
@@ -554,9 +615,11 @@ function concludeWaitStream(state, result, startedAt, now) {
 }
 /**
  * Live view over a wait's successive observation rounds, one append-only
- * stream per selected Akuma. Each Akuma's stream opens with its identity frame
- * — the identity and Contract association the observed facts carry — before any
- * row; an already settled Akuma prints that frame and never replays backlog
+ * stream per selected Akuma. A plural wait opens one aggregate frame naming
+ * its selected set before any activity row and never opens a per-target frame
+ * during observation; a single-target wait opens that Akuma's own identity
+ * frame — the identity and Contract association the observed facts carry —
+ * and an already settled Akuma prints that frame while replaying no backlog
  * rows. `conclude` renders the closing rows once the wait ends: one row per
  * observed Akuma in `<clock> <mark> <verb> — <duration>` grammar, with a target
  * named for a multi-target scoreboard and no activity replay.
@@ -567,7 +630,8 @@ export function waitObservationStream(context, options = {}) {
     const state = createWaitObservationState();
     const select = (selected) => {
         for (const member of selected)
-            registerWaitSource(state, member.id, member.alias);
+            registerWaitSource(state, member.id, member.alias, member.contract);
+        state.plural ??= selected.length > 1;
     };
     const observe = (round) => observeWaitRound(state, round, context, now);
     const conclude = (result) => concludeWaitStream(state, result, startedAt, now);
@@ -616,10 +680,10 @@ export function callObservationStream(context, head, options = {}) {
         const end = now();
         const status = observation.status;
         const answered = statusAnswer({ status }) !== undefined;
-        const at = waitComplete(status) ? (settleMoment(status) ?? end) : end;
-        const durationMs = Math.max(0, at - startedAt);
-        const { mark, verb, waited } = conclusionMarkVerb(status, answered);
-        lines.push(`${clockFromMs(at)} ${mark} ${verb} — ${waited ? "waited " : ""}${durationText(durationMs)}`);
+        const complete = waitComplete(status);
+        const at = complete ? (settleMoment(status) ?? end) : end;
+        const { mark, verb } = conclusionMarkVerb(status, answered);
+        lines.push(`${clockFromMs(at)} ${mark} ${verb}${conclusionClause(at, startedAt, complete, end)}`);
         const failure = failedOutcomeDiagnostic(status);
         if (failure !== undefined)
             lines.push(`! error ${safeText(failure)}`);
@@ -783,20 +847,73 @@ export function akumaRawAnswer(result) {
 }
 export function waitText(result, context) {
     const alias = result.alias;
-    const total = result.result.observations.length + result.result.unobserved.length;
-    const done = result.result.observations.filter((observation) => waitComplete(observation.status)).length;
+    const observations = result.result.observations;
+    const unobserved = result.result.unobserved;
+    const total = observations.length + unobserved.length;
+    if (total <= 1) {
+        const single = [
+            ...observations.map((observation) => {
+                const answer = statusAnswer(observation);
+                if (answer !== undefined)
+                    return answeredBlock(observation, answer, alias, context.columns);
+                return snapshotText(observation, context, { ...(alias === undefined ? {} : { alias }) });
+            }),
+            ...unobserved.map((member) => unobservedText(member.id, member.diagnostic)),
+        ];
+        return single.join("\n\n");
+    }
+    const end = Date.now();
+    const startedAt = result.startedAt ?? end;
+    const order = [];
+    const labels = new Map();
+    const remember = (id, frozenAlias) => {
+        if (labels.has(id))
+            return;
+        labels.set(id, frozenAlias ?? id);
+        order.push(id);
+    };
+    for (const member of result.selection ?? [])
+        remember(member.id, member.alias);
+    for (const observation of observations)
+        remember(observation.status.id);
+    for (const member of unobserved)
+        remember(member.id);
+    const label = (id) => labels.get(id) ?? id;
+    const observationById = new Map(observations.map((observation) => [observation.status.id, observation]));
+    const unobservedById = new Map(unobserved.map((member) => [member.id, member]));
+    const sourceWidth = order.reduce((width, id) => Math.max(width, displayColumns(label(id))), 0);
     const blocks = [
-        ...result.result.observations.map((observation) => {
+        ...order.flatMap((id) => {
+            const observation = observationById.get(id);
+            if (observation === undefined)
+                return [];
             const answer = statusAnswer(observation);
             if (answer !== undefined)
-                return answeredBlock(observation, answer, alias, context.columns);
-            return snapshotText(observation, context, { ...(alias === undefined ? {} : { alias }) });
+                return [answeredBlock(observation, answer, undefined, context.columns)];
+            return [snapshotText(observation, context)];
         }),
-        ...result.result.unobserved.map((member) => unobservedText(member.id, member.diagnostic)),
+        ...(unobserved.length > 0
+            ? [
+                order
+                    .filter((id) => unobservedById.has(id))
+                    .map((id) => unobservedText(label(id), unobservedById.get(id).diagnostic))
+                    .join("\n"),
+            ]
+            : []),
     ];
-    if (total <= 1)
-        return blocks.join("\n\n");
-    return [...blocks, `${done} of ${total} done`].join("\n\n");
+    const rows = order.flatMap((id) => {
+        const observation = observationById.get(id);
+        if (observation === undefined)
+            return [];
+        const status = observation.status;
+        const complete = waitComplete(status);
+        const at = complete ? (settleMoment(status) ?? end) : end;
+        const { mark, verb } = conclusionMarkVerb(status, statusAnswer(observation) !== undefined);
+        return [
+            `${clockFromMs(at)} ${padToDisplay(label(id), sourceWidth)} ${mark} ${verb}${conclusionClause(at, startedAt, complete, end)}`,
+        ];
+    });
+    return rows.length > 0 ? [...blocks, rows.join("\n")].join("\n\n") : blocks.join("\n\n");
 }
 export function historyText(command, result, context) {
     if (result.mode === "exact") {

package/build/src/cli/runtime.js

@@ -151,7 +151,7 @@ async function commandFailureText(error, command) {
     const diagnostic = error instanceof Error ? error.message : String(error);
     if (command.output === "json" || error instanceof CliUsageError)
         return diagnostic;
-    const { KeiyakuRefused } = await import("../index.js");
+    const { KeiyakuRefused } = await import("../library/refusal.js");
     if (error instanceof KeiyakuRefused) {
         if (error.refusal.kind === "contract-missing") {
             return renderUsageMessage(diagnostic, {
@@ -177,7 +177,7 @@ export async function runCliCommand(invocation) {
         return await writeResult(command, result);
     }
     catch (error) {
-        const { executionReceipt } = await import("../index.js");
+        const { executionReceipt } = await import("../library/execution-result.js");
         const receipt = executionReceipt(error);
         if (receipt !== undefined) {
             const diagnostic = error instanceof Error ? error.message : String(error);

package/build/src/index.d.ts

@@ -1,7 +1,8 @@
 export * from "./library/keiyaku.js";
 export { Akuma, Schema, ALLOWED_ACTIONS, AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError, } from "./akuma/index.js";
-export type { AkumaBirthInput, AkumaHistoryOptions, AkumaIdleOptions, AkumaSignalOptions, AkumaTellOptions, InterruptReceipt, KillEvidence, JsonSchema, JsonSchemaDocument, AkuId, AkumaStatus, ActivityHistory, ActivityRow, AllowedAction, AllowedActions, } from "./akuma/index.js";
+export type { AkumaBirthInput, AkumaHistoryOptions, AkumaIdleOptions, AkumaIdleResult, AkumaSignalOptions, AkumaTellOptions, InterruptReceipt, KillEvidence, JsonSchema, JsonSchemaDocument, StandardSchemaV1, SchemaLike, AkuId, AkumaStatus, ActivityHistory, ActivityRow, AllowedAction, AllowedActions, } from "./akuma/index.js";
 export { settings } from "./settings.js";
+export { z } from "zod";
 export { World, WorldError } from "./world.js";
 export type { WorldResolution, WorldResolutionInput, WorldRoot } from "./world.js";
 export type { KeiyakuPlugin, PluginContext, PluginHooks, PluginInstance, PluginManifest, PluginBodyEnd, PluginOutcome, PluginSignal, PluginSignalMap, } from "./plugin/public.js";

package/build/src/index.js

@@ -1,4 +1,5 @@
 export * from "./library/keiyaku.js";
 export { Akuma, Schema, ALLOWED_ACTIONS, AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError, } from "./akuma/index.js";
 export { settings } from "./settings.js";
+export { z } from "zod";
 export { World, WorldError } from "./world.js";

package/build/src/kanshi/read.js

@@ -2,12 +2,12 @@ import { Repo } from "../library/repo.js";
 import { scopeForRepo } from "../library/repo.js";
 import { observeTaskBoard } from "../task/operations.js";
 import { contractNamespace } from "../task/identity.js";
-import { readAkumaCatalog, readAkumaTimeline } from "../akuma/akuma.js";
+import { readAkumaCatalog, readAkumaTimeline, withoutReportedChanges } from "../akuma/akuma.js";
 import { readAliases } from "../alias/index.js";
 import { readDispatchesAt } from "../dispatch/index.js";
 import { readTaskHolderProjectionAt } from "../settlement/holder.js";
 import { observeCurrentPhysicalIssue } from "../protocol/read/observation.js";
-import { readContractBoard, readContractCatalogue } from "../protocol/read/status.js";
+import { readContractBoard, readContractCatalogue, readContractPhase } from "../protocol/read/status.js";
 import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
 import { decodeContractDocument } from "../body/decode.js";
 import { assertRegionPattern } from "../body/region.js";
@@ -262,7 +262,27 @@ async function readTasks(path, holders, observeContract) {
         value: { root: path, hasMore: recent.hasMore, rows: joinTasks(recent.rows, holders, observeContract) },
     }), (error) => ({ kind: "failed", failure: taskFailure(error) }));
 }
-async function joinAkuma(path, observeContract, dispatches, aliases) {
+/**
+ * Placement discharge for the observed fleet snapshots: an associated Contract
+ * whose own observation proves it claimed has placed the candidate those
+ * reported changes describe, so the composite report no longer presents them
+ * as pending. An unproven or failed Contract read keeps the changes.
+ */
+async function claimedAssociatedContracts(observation, dispatches) {
+    const ids = [...new Set(dispatches.map((dispatch) => dispatch.contractId))];
+    const claimed = new Set();
+    await Promise.all(ids.map(async (id) => {
+        try {
+            if ((await readContractPhase(observation, id)) === "claimed")
+                claimed.add(id);
+        }
+        catch {
+            /* unproven placement keeps reported changes */
+        }
+    }));
+    return claimed;
+}
+async function joinAkuma(path, observeContract, isContractClaimed, dispatches, aliases) {
     if (aliases.kind !== "present")
         return aliases;
     try {
@@ -301,7 +321,10 @@ async function joinAkuma(path, observeContract, dispatches, aliases) {
                 ...source,
                 rows: rows.map((row) => {
                     const snapshot = snapshots.get(row.id);
-                    return snapshot === undefined ? row : { ...row, snapshot };
+                    if (snapshot === undefined)
+                        return row;
+                    const placed = row.contract !== undefined && isContractClaimed(row.contract.id);
+                    return { ...row, snapshot: placed ? withoutReportedChanges(snapshot) : snapshot };
                 }),
             },
         };
@@ -332,7 +355,7 @@ async function observeWithoutRepo(world, region, observedAt, branch) {
     const observeContract = contractEndpointObserver(contracts);
     const tasks = world === null ? { kind: "absent" } : await readTasks(world, holders, observeContract);
     const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
-    const akuma = world === null ? { kind: "absent" } : await joinAkuma(world, observeContract, [], aliases);
+    const akuma = world === null ? { kind: "absent" } : await joinAkuma(world, observeContract, () => false, [], aliases);
     return {
         report: {
             root: world,
@@ -364,11 +387,14 @@ async function observeRepo(input) {
             const observeContract = contractEndpointObserver(contracts);
             const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
             const tasks = world === null ? { kind: "absent" } : await readTasks(world, holders, observeContract);
+            const claimed = dispatches.kind === "present"
+                ? await claimedAssociatedContracts(observation, dispatches.value)
+                : new Set();
             const akuma = world === null
                 ? { kind: "absent" }
                 : dispatches.kind === "failed"
                     ? dispatches
-                    : await joinAkuma(world, observeContract, dispatches.value, aliases);
+                    : await joinAkuma(world, observeContract, (id) => claimed.has(id), dispatches.value, aliases);
             const assembled = {
                 root: world,
                 observedAt,

package/build/src/library/address.d.ts

@@ -51,6 +51,9 @@ export declare function addressAkuma(input: UncheckedAkumaAddressInput): Promise
 }>>;
 export declare function addressAkumaSet(input: UncheckedAkumaAddressInput): Promise<Readonly<{
     path: WorldRoot;
+    /** The complete selected set in canonical order: the durable result order. */
     ids: readonly AkuId[];
+    /** The same set in the caller's selector order, for surfaces that name the selection as chosen. */
+    orderedIds: readonly AkuId[];
 }>>;
 export {};

package/build/src/library/address.js

@@ -158,9 +158,10 @@ export async function addressAkumaSet(input) {
     const sources = { fleetIds, aliases, dispatches };
     for (const selector of selectors)
         addSelectorIds(selector, sources, selected, contractMembers);
+    const orderedIds = [...selected];
     const ids = [...selected].sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
     if (ids.length === 0)
         throw new TypeError("Akuma selector snapshot is empty");
     await refuseForeignContractMembers(path, ids, contractMembers);
-    return { path, ids };
+    return { path, ids, orderedIds };
 }