@sema-agent/core 7.55.0 → 7.57.0

package/LICENSE

@@ -5,7 +5,7 @@ Parameters
 Licensor:             clay (github.com/clayboby)
 Licensed Work:        @sema-agent/core (sema-core) and the satellite packages
                       published from this repository (currently
-                      @sema-agent/mods-kernel)
+                      @sema-agent/mods-kernel, @sema-agent/primitives and @sema-agent/core-stores-sql)
                       (formerly published as @sema-ai/core)
                       The Licensed Work is (c) 2026 clay.
 Additional Use Grant: You may make production use of the Licensed Work for

package/dist/agents/cascade.js

@@ -206,7 +206,7 @@ export async function runCascade(runner, spec, config, internals) {
         return {
             taskId: spec.taskId ?? "",
             sessionId: "",
-            result: `runCascade: the overall wall-clock budget (totalTimeoutMs ${config.totalTimeoutMs}ms) was already spent when the ladder was entered — no rung dispatched`,
+            result: `runCascade: the overall wall-clock budget (totalTimeoutMs ${config.totalTimeoutMs}ms) was already spent when the ladder was entered — no rung dispatched`, resultEntryIds: [],
             terminal: { kind: "failed", code: CASCADE_NO_DISPATCH_ERROR_CODE },
             stats: { tokens: 0, turns: 0, costMicroUsd: 0 },
             cascadeOutcome: "exhausted",

package/dist/agents/cc-peer-directory.js

@@ -107,6 +107,7 @@ export function createCcPeerDirectory(opts) {
             ...(typeof r["peerProtocol"] === "number" ? { peerProtocol: r["peerProtocol"] } : {}),
             ...(features !== undefined ? { peerFeatures: features } : {}),
             sockPath,
+            where: "this_machine",
         });
         if (!read.ok)
             return void skip(file, "invalid_row", read.field !== undefined ? `${read.reason}: ${read.field}` : read.reason);

package/dist/agents/child-model-seat.d.ts

@@ -18,17 +18,6 @@ export declare function deploymentStatesSubagentModel(roles: ModelRoles | undefi
  * already reflects when the parent ran on it).
  */
 export declare function deploymentSubagentThinking(roles: ModelRoles | undefined): ThinkingLevel | undefined;
-/**
- * Did the deployment STATE a system prompt for its subagents — and which? The `systemPrompt` member of an
- * object-form `roles.subagent` entry; a string ref, a `Model` object or an entry without the member states
- * none. The third axis, read off the SAME seat as {@link deploymentSubagentThinking}. It has no parent rung:
- * a child never inherits its PARENT's system prompt, only the deployment's statement for subagents. Which
- * station needs to read it: one whose default persona is written onto the spec itself (the workflow lane
- * frames an empty `systemPrompt` with the workflow-subagent persona, so the preset must be written first, as
- * a custom persona to that frame); the delegation station's default rides the trusted internals channel
- * below the role chain, so prepare reads the preset there without this helper.
- */
-export declare function deploymentSubagentSystemPrompt(roles: ModelRoles | undefined): string | undefined;
 /**
  * The child run's THINKING seat — {@link childModelSeat}'s sister, the same rung order on the other axis
  * (#651): an EXPLICIT level for this spawn wins (the agent definition's `thinking`; a fork's explicit is the

package/dist/agents/child-model-seat.js

@@ -23,9 +23,6 @@ export function deploymentStatesSubagentModel(roles) {
 export function deploymentSubagentThinking(roles) {
     return subagentRolePresets(roles)?.thinking;
 }
-export function deploymentSubagentSystemPrompt(roles) {
-    return subagentRolePresets(roles)?.systemPrompt;
-}
 function subagentRolePresets(roles) {
     const s = roles?.subagent;
     if (s == null || typeof s === "string")

package/dist/agents/list-agents-tool.d.ts

@@ -1,7 +1,7 @@
 import { Type } from "typebox";
 import type { TaskAccess } from "../core/task-registry.js";
 import { type RosterEntry } from "./roster-store.js";
-import { type PeerDirectory, type PeerPresence, type PeerSessionRecord } from "./peer-directory.js";
+import { type PeerDirectory, type PeerPresence, type PeerSessionRecord, type PeerSessionWhere } from "./peer-directory.js";
 import type { SubagentTranscriptTier } from "../core/wiring-manifest.js";
 import { formatAgo, type AgentState, type AgentStateSource } from "../core/agent-state.js";
 import type { CheckpointSeat } from "../core/checkpoint-seat.js";
@@ -89,6 +89,8 @@ export interface ListAgentsRow {
     cwd?: string;
     /** Peer rows: the session's self-reported presence, when it reported any. */
     presence?: PeerPresence;
+    /** Peer rows: where the session runs, as the directory's row says it ({@link PeerSessionWhere}). */
+    where?: PeerSessionWhere;
     /** What SendMessage accepts: on both AGENT lanes the registry `task_id` VERBATIM (no prefixing or
      *  re-minting), never the child's session id — a different domain, tabled in INTEGRATION-CORE §1.6a.
      *  Peer rows carry the `session.<id>` box handle instead. */

package/dist/agents/list-agents-tool.js

@@ -3,7 +3,7 @@ import { defineTool } from "../core/tools.js";
 import { inlineUntrusted } from "../core/untrusted-text.js";
 import { formatPeerNameRef } from "./cross-session-ref.js";
 import { entryAccessible } from "./roster-store.js";
-import { mintPeerSessionCandidates, PEER_PRESENCE_MAX_CHARS, peerSessionBoxHandle } from "./peer-directory.js";
+import { listPeerDirectory, mintPeerSessionCandidates, PEER_PRESENCE_MAX_CHARS, PEER_SESSION_WHERE_LABELS, peerSessionBoxHandle } from "./peer-directory.js";
 import { PEER_LANE_DEFAULTS } from "./peer-admission.js";
 import { mountRuleFace, toolFace } from "../core/tool-catalog-entries.js";
 import { thrownText } from "../core/thrown-value.js";
@@ -45,8 +45,7 @@ const PEER_ROW_STATE = {
 function peerRowState(r) {
     if (r.liveness === "dead")
         return "offline";
-    const tempo = r.tempo;
-    return tempo !== undefined && Object.hasOwn(PEER_ROW_STATE, tempo) ? PEER_ROW_STATE[tempo] : "unknown";
+    return r.tempo !== undefined ? PEER_ROW_STATE[r.tempo] : "unknown";
 }
 function renderPresence(p) {
     const parts = [...(p.agent !== undefined ? [`agent=${inlineUntrusted(p.agent, PEER_PRESENCE_MAX_CHARS)}`] : []), ...(p.intent !== undefined ? [`intent=${inlineUntrusted(p.intent, PEER_PRESENCE_MAX_CHARS)}`] : [])];
@@ -66,7 +65,7 @@ export function createListAgentsTool(opts) {
         isConcurrencySafe: () => true,
         description: `List the agents${peers ? " and peer sessions" : ""} you can message with SendMessage. ` +
             (peers
-                ? `Peer sessions are other sessions of this engine running for the same user, shown as \`name [ref] · state · active <N> ago · <directory> · self: agent=…, intent=…\`; send to one with its name (or \`name [ref]\` ` +
+                ? `Peer sessions are other sessions of this engine running for the same user, shown as \`name [ref] · state · active <N> ago · <directory> · self: agent=…, intent=… · peer session <where>\` (where it runs: ${Object.values(PEER_SESSION_WHERE_LABELS).join(", or ")}); send to one with its name (or \`name [ref]\` ` +
                     `when a name is ambiguous, or its \`session.<id>\` address). By default only FRESH peers are listed (working now, or active within the last ${formatAgo(windowMs)}); ` +
                     `pass includeAll: true to also list stale and offline ones. A peer that is offline or unlisted still accepts messages — they are parked ` +
                     `durably in its session box and delivered when it next runs. `
@@ -84,7 +83,7 @@ export function createListAgentsTool(opts) {
             let directoryFault;
             if (opts.peerDirectory !== undefined) {
                 try {
-                    peerRows = await opts.peerDirectory.listPeerSessions({ scope: opts.self.scope });
+                    peerRows = await listPeerDirectory(opts.peerDirectory, { scope: opts.self.scope });
                 }
                 catch (e) {
                     directoryFault = thrownText(e);
@@ -108,6 +107,7 @@ export function createListAgentsTool(opts) {
                     ...(r.liveness === "live" ? { lastActiveAt: r.updatedAt } : r.diedAt !== undefined ? { offlineAt: r.diedAt } : {}),
                     ...(r.cwd !== undefined ? { cwd: cwdTail(r.cwd) } : {}),
                     ...(presence.agent !== undefined || presence.intent !== undefined ? { presence } : {}),
+                    where: r.where,
                 });
             }
             let registryCapped = false;
@@ -172,13 +172,13 @@ export function createListAgentsTool(opts) {
                 const age = r.kind !== "peer_session" ? undefined : r.lastActiveAt !== undefined ? `active ${formatAgo(now - r.lastActiveAt)} ago` : r.offlineAt !== undefined ? `offline ${formatAgo(now - r.offlineAt)} ago` : "offline";
                 const activity = r.agentState !== undefined ? agentActivityClause(r.agentState) : undefined;
                 const approval = r.agentState?.approval !== undefined ? agentApprovalClause(r.agentState.approval, r.agentState.readAt) : undefined;
-                const cols = [label, r.state, age, activity, approval, r.cwd !== undefined ? inlineUntrusted(r.cwd, 64) : undefined, r.presence !== undefined ? renderPresence(r.presence) : undefined, r.kind === "peer_session" ? "peer session" : r.kind === "roster" ? rosterLabel : "agent", r.address];
+                const cols = [label, r.state, age, activity, approval, r.cwd !== undefined ? inlineUntrusted(r.cwd, 64) : undefined, r.presence !== undefined ? renderPresence(r.presence) : undefined, r.kind === "peer_session" ? `peer session ${PEER_SESSION_WHERE_LABELS[r.where]}` : r.kind === "roster" ? rosterLabel : "agent", r.address];
                 return cols.filter((c) => c !== undefined).join("  ·  ");
             });
             const finishedCount = rows.filter((r) => r.state === "finished").length;
             const header = rows.length === 0 ? "No agents or peer sessions are listed right now." : `${rows.length} listed:`;
             const finishedNote = finishedCount > 0 ? `\n(${finishedCount} finished agent(s): continuable by SendMessage only ${finishedReach} — otherwise SendMessage answers with an honest refusal)` : "";
-            const fault = (directoryFault !== undefined ? `\n(peer-session directory unreadable: ${inlineUntrusted(directoryFault, 200)} — peer rows may be missing)` : "") +
+            const fault = (directoryFault !== undefined ? `\n(peer-session directory unreadable: ${inlineUntrusted(directoryFault, 200)} — no peer row is listed until its host fixes it)` : "") +
                 (registryCapped ? "\n(the live task list is at its 500-row window: older background agents may be missing from this listing — address them by task_id)" : "");
             let content = `${header}${lines.length > 0 ? `\n${lines.join("\n")}` : ""}${finishedNote}${fault}`;
             if (content.length > LIST_AGENTS_MAX_RESULT_CHARS)

package/dist/agents/org-delivery-gate.js

@@ -7,9 +7,8 @@ export function principalInboxConsumerOf(deps) {
     const raw = deps.principalInboxConsumer;
     if (raw === undefined)
         return { kind: "none" };
-    if (raw === "terminals") {
-        throw consumerRefusal(`RunnerDeps.principalInboxConsumer "terminals" is not available yet: the shared held decision ledger is not yet available, so a letter a person refused in one terminal could be delivered by another. Declare { assistant: "<agent handle>" } or leave the seat absent.`, "terminals_unsupported");
-    }
+    if (raw === "terminals")
+        return { kind: "terminals" };
     if (raw !== null && typeof raw === "object" && !Array.isArray(raw) && Object.getPrototypeOf(raw) === Object.prototype) {
         const keys = Reflect.ownKeys(raw);
         const handle = raw.assistant;
@@ -32,7 +31,7 @@ export function isOrgDeliveryRefusalCode(value) {
 export function mintCrossPrincipalRecord(input) {
     const { from, body, receiptId, sentAt, consumer } = input;
     if (consumer?.kind !== "terminals" && consumer?.kind !== "assistant") {
-        throw consumerRefusal(`an organization delivery gate is minting a principal-inbox letter, but the deployment declares no principal-inbox consumer (RunnerDeps.principalInboxConsumer is absent): nobody would ever read it. Declare { assistant: "<agent handle>" }.`, "no_consumer");
+        throw consumerRefusal(`an organization delivery gate is minting a principal-inbox letter, but the deployment declares no principal-inbox consumer (RunnerDeps.principalInboxConsumer is absent): nobody would ever read it. Declare "terminals" or { assistant: "<agent handle>" }.`, "no_consumer");
     }
     if (typeof body.content !== "string")
         throw new TypeError("mintCrossPrincipalRecord: body.content must be a string");

package/dist/agents/peer-directory.d.ts

@@ -22,8 +22,20 @@ export declare function peerPresenceLabelValid(v: unknown): v is string | undefi
 /** Prepare's door: `TaskSpec.peerPresence` is a plain object whose `agent` / `intent` each pass {@link peerPresenceLabelValid}
  *  — else `config.peer_presence_invalid`, naming the field. */
 export declare function assertPeerPresenceValue(v: unknown): void;
+/**
+ * WHERE a peer session runs — the directory's word, like `liveness`. `this_machine` = a process on the ACCESSOR's
+ * machine, said only by a directory that reads that machine ({@link PeerDirectoryAccess} names a scope, not a
+ * machine); `hosted` = a session a hosting service runs, reached only through the store. `pid` / `procStartMs` /
+ * `sockPath` ride a `this_machine` row only ({@link readPeerSessionRecord}), so none of their readers reads `where` —
+ * for a row of plain data members: the reader does not snapshot an accessor member, which can answer differently per read.
+ */
+export declare const PEER_SESSION_WHERE_VALUES: readonly ["this_machine", "hosted"];
+export type PeerSessionWhere = (typeof PEER_SESSION_WHERE_VALUES)[number];
+/** THE wording of each value — the listing's kind column and the ambiguity error read this one table. */
+export declare const PEER_SESSION_WHERE_LABELS: Readonly<Record<PeerSessionWhere, string>>;
 /** The registration row. Field set = CC's load-bearing subset + sema's `scope` axis + the sema-only
- *  liveness/tombstone members. A host writes it; every terminal reads it through {@link readPeerSessionRecord}. */
+ *  liveness/tombstone/where members. A host writes it; every terminal reads it through {@link readPeerSessionRecord}
+ *  (the engine: {@link listPeerDirectory}; `peerDirectoryContract` checks a directory lists only rows it accepts). */
 export interface PeerSessionRecord {
     schemaVersion: number;
     /** The session's durable identity: its box address is `session.<sessionId>` ({@link peerSessionBoxHandle}). */
@@ -52,6 +64,8 @@ export interface PeerSessionRecord {
     liveness: PeerSessionLiveness;
     /** Present iff `liveness !== "live"`: when the row was marked dead (or the tombstone was written). */
     diedAt?: number;
+    /** Where the session runs ({@link PeerSessionWhere}) — the directory's word, never derived from the other members. */
+    where: PeerSessionWhere;
     /** The host's activity word. A stale `tempo` is the host's to clear: a row that says `active` is
      *  listed as fresh regardless of its age. */
     tempo?: PeerSessionTempo;
@@ -135,10 +149,10 @@ export interface PeerLivenessProbe {
 export declare const defaultPeerLivenessProbe: PeerLivenessProbe;
 /**
  * Is the row's process alive? `false` when the pid is gone, OR when the probe knows a start time and it
- * disagrees with the row's (PID reuse — a different process wears the number). A row with no pid has
- * no process to probe and is judged by its declared liveness alone.
+ * disagrees with the row's (PID reuse — a different process wears the number). A row with no LOCAL process
+ * (no pid, or not `this_machine`: its pid is not this machine's to signal) is judged by its declared liveness alone.
  */
-export declare function isPeerSessionProcessAlive(record: Pick<PeerSessionRecord, "pid" | "procStartMs" | "liveness">, probe?: PeerLivenessProbe): boolean;
+export declare function isPeerSessionProcessAlive(record: Pick<PeerSessionRecord, "pid" | "procStartMs" | "liveness" | "where">, probe?: PeerLivenessProbe): boolean;
 export interface PeerDirectoryAccess {
     /** The accessor's scope — rows of any other scope are never returned (§10 wall). */
     scope: string;
@@ -167,6 +181,10 @@ export interface PeerDirectory {
      */
     restorePeerSession?(record: PeerSessionRecord): boolean | Promise<boolean>;
 }
+/** THE engine's read of a directory: every listed row through {@link readPeerSessionRecord}. A row it refuses
+ *  faults the WHOLE listing (thrown, so each consumer's fault arm speaks), never a partial set — refs are minted and
+ *  names resolved over the full set, and dropping one row would change both. */
+export declare function listPeerDirectory(dir: PeerDirectory, access: PeerDirectoryAccess): Promise<PeerSessionRecord[]>;
 export interface PeerSessionCandidate {
     record: PeerSessionRecord;
     /** The listing-minted ref (6..12 hex) of this row — stable across the live/dead filter because it is

package/dist/agents/peer-directory.js

@@ -19,6 +19,12 @@ export function assertPeerPresenceValue(v) {
     e.code = "config.peer_presence_invalid";
     throw e;
 }
+export const PEER_SESSION_WHERE_VALUES = Object.freeze(["this_machine", "hosted"]);
+function isPeerSessionWhere(v) {
+    return PEER_SESSION_WHERE_VALUES.some((w) => w === v);
+}
+export const PEER_SESSION_WHERE_LABELS = Object.freeze({ this_machine: "on this machine", hosted: "hosted by the service" });
+const MACHINE_BOUND_MEMBERS = ["pid", "procStartMs", "sockPath"];
 export const SEMA_MAILBOX_FEATURE_PREFIX = "sema_mailbox_v1_";
 export function semaMailboxFeature(storeIdentity) {
     return `${SEMA_MAILBOX_FEATURE_PREFIX}${createHash("sha256").update(storeIdentity).digest("hex").slice(0, 16)}`;
@@ -109,6 +115,12 @@ export function readPeerSessionRecord(raw) {
     const inboundPosture = r["inboundPosture"];
     if (inboundPosture !== undefined && inboundPosture !== "available" && inboundPosture !== "unavailable")
         return bad("inboundPosture");
+    const where = r["where"];
+    if (!isPeerSessionWhere(where))
+        return bad("where");
+    const misplaced = where === "this_machine" ? undefined : MACHINE_BOUND_MEMBERS.find((k) => r[k] !== undefined);
+    if (misplaced !== undefined)
+        return bad(misplaced);
     const record = {
         schemaVersion: r["schemaVersion"],
         sessionId: r["sessionId"],
@@ -125,6 +137,7 @@ export function readPeerSessionRecord(raw) {
         updatedAt: r["updatedAt"],
         liveness,
         ...(r["diedAt"] !== undefined ? { diedAt: r["diedAt"] } : {}),
+        where,
         ...(tempo !== undefined ? { tempo } : {}),
         ...(r["entrypoint"] !== undefined ? { entrypoint: r["entrypoint"] } : {}),
         ...(r["peerProtocol"] !== undefined ? { peerProtocol: r["peerProtocol"] } : {}),
@@ -148,7 +161,7 @@ export const defaultPeerLivenessProbe = {
 export function isPeerSessionProcessAlive(record, probe = defaultPeerLivenessProbe) {
     if (record.liveness !== "live")
         return false;
-    if (record.pid === undefined)
+    if (record.pid === undefined || record.where !== "this_machine")
         return true;
     if (!probe.processExists(record.pid))
         return false;
@@ -159,6 +172,15 @@ export function isPeerSessionProcessAlive(record, probe = defaultPeerLivenessPro
     }
     return true;
 }
+export async function listPeerDirectory(dir, access) {
+    return (await dir.listPeerSessions(access)).map((raw) => {
+        const read = readPeerSessionRecord(raw);
+        if (read.ok)
+            return read.record;
+        const id = typeof raw?.sessionId === "string" ? inlineUntrusted(raw.sessionId, 80) : "(no session id)";
+        throw new Error(`the directory listed a row this engine cannot read (${id}: ${read.reason}${read.field !== undefined ? `: ${read.field}` : ""}); no peer row is used until its host fixes it`);
+    });
+}
 export function mintPeerSessionCandidates(records, self) {
     const entries = records.map((record) => ({ kind: "session", id: record.sessionId.toLowerCase(), record }));
     const selfEntry = self !== undefined && !records.some((r) => r.sessionId.toLowerCase() === self.sessionId.toLowerCase()) ? { kind: "session", id: self.sessionId.toLowerCase() } : undefined;
@@ -166,7 +188,7 @@ export function mintPeerSessionCandidates(records, self) {
 }
 function describeCandidate(c) {
     const state = c.record.liveness === "live" ? "" : c.record.liveness === "dead" ? " (offline)" : " (deleted)";
-    return `${formatPeerNameRef(inlineUntrusted(c.record.name, 64), c.ref)}${state} → ${peerSessionBoxHandle(c.record.sessionId)}`;
+    return `${formatPeerNameRef(inlineUntrusted(c.record.name, 64), c.ref)}${state}, ${PEER_SESSION_WHERE_LABELS[c.record.where]} → ${peerSessionBoxHandle(c.record.sessionId)}`;
 }
 export function resolvePeerSessions(records, to, self) {
     const candidates = mintPeerSessionCandidates(records, self);

package/dist/agents/peer-held-queue.d.ts

@@ -1,10 +1,12 @@
-import type { MailboxPeerMeta } from "../core/mailbox-store.js";
+import { type MailboxPeerMeta, type MailboxDecisionOutcome, type MailboxDecision } from "../core/mailbox-store.js";
 import type { CrossSessionHoldCause, CrossSessionInboundVerdict } from "./cross-session-judge.js";
 import { type PeerDeliveryReceiptState } from "./peer-notices.js";
 /** The `cause` vocabulary of a `peer.inbound_disposition{disposition:"held"}` notice: the parity
  *  judge's causes plus the drain-stage gate's TRANSIENT `rate_limited` (a bucket-wait, not a review
  *  hold — it never enters the held queue; the drain stops at that seq and re-judges next pass). */
 export type PeerInboundHoldCause = CrossSessionHoldCause | "rate_limited";
+/** The decisions a card can stand for: held, approved, or handed over but not yet injected. */
+export type PeerCardDecision = Extract<MailboxDecision, "held" | "approved" | "delivered">;
 export interface PeerHeldEntry {
     /** The recipient box seq of the held record (its identity for the review face). */
     readonly seq: number;
@@ -21,12 +23,16 @@ export interface PeerHeldEntry {
     readonly heldAt: number;
     /** The cause last announced for this entry (re-judgment may move it). */
     cause: CrossSessionHoldCause;
-    /** Approved by the review face while no run of the session was live: delivered at the next flush
-     *  (a re-judgment that now refuses still wins — CC `l0e`'s approve arm re-checks policy). */
-    released?: boolean;
+    /** The record's decision as this queue last read or wrote it: `held`; `approved` (deliverable,
+     *  waiting for a lease-holding pass — a re-judgment that now refuses still wins); `delivered` (this
+     *  queue took the hand-over move and the injection is still owed; a policy that now refuses ends it as `dropped`). */
+    decision: PeerCardDecision;
 }
-export type PeerHeldSettlement = "expired" | "delivered" | "refused" | "denied" | "dropped";
-export type PeerHeldSettleReason = "evicted" | "deadline" | "shutdown" | "rejudge" | "approved" | "denied" | "cancelled" | "inject_failed" | "superseded";
+/** How an entry left this queue. `retired` — the CARD left this process but no decision was taken: the
+ *  record stays held in its box for the next consumer (a queue-local event no receipt announced,
+ *  or a record another consumer settled). Every other word is the record's own final fate. */
+export type PeerHeldSettlement = "expired" | "delivered" | "refused" | "denied" | "dropped" | "retired";
+export type PeerHeldSettleReason = "evicted" | "deadline" | "shutdown" | "rejudge" | "approved" | "denied" | "cancelled" | "inject_failed" | "superseded" | "decided_elsewhere";
 /** The clock/timer seam (tests inject a virtual one). Handles are opaque. */
 export interface PeerClock {
     now(): number;
@@ -36,81 +42,95 @@ export interface PeerClock {
 export declare const realPeerClock: PeerClock;
 /** The live seats a bound run gives the queue. `inject` is the ONLY member that is run-scoped (a run's
  *  own injection lane); the others survive the run (the receipt route rides the mailbox, the judge
- *  reads the deployment's settings getter) and are what a headless deadline settles through. */
+ *  reads the deployment's settings getter, the decision seat is the store) and are what a headless
+ *  deadline settles through. */
 export interface PeerHeldQueueSink {
     /** Re-judge an entry against the recipient's CURRENT settings and mode class (CC `M`). */
     judge: (entry: PeerHeldEntry) => CrossSessionInboundVerdict;
-    /** Deliver a released entry into the live run's model context. Absent ⇒ no run is live. Throws ⇒
-     *  the lane refused the frame (settled `dropped`, receipt sent). Returns `"deferred"` ⇒ the run is
-     *  live but this pass's delivery budget is spent: the entry stays released and goes at the next
-     *  pass's flush (the same wait a run-less approval takes). */
+    /** Deliver a deliverable entry into the live run's model context. Absent ⇒ no run is live. Throws ⇒
+     *  the lane refused the frame. Returns `"deferred"` ⇒ the run is live but this pass's delivery budget
+     *  is spent: the entry stays deliverable and goes at the next pass's flush (unless the policy refuses it first). */
     inject?: (entry: PeerHeldEntry) => void | "deferred";
+    /** Would {@link inject} take this entry NOW (a live pass that holds this box's lease, with budget left)?
+     *  Asked BEFORE the hand-over move (and before a refusal ends a handed-over card), so a process that cannot
+     *  deliver never takes a move out of `delivered`. Absent ⇒
+     *  the presence of `inject` decides. */
+    canInject?: (entry: PeerHeldEntry) => boolean;
     /** The receipt to the sender (the binding routes it into the sender's box). */
     receipt: (entry: PeerHeldEntry, state: PeerDeliveryReceiptState) => void;
+    /** Does a receipt about this entry reach a sender? A queue-local event (eviction, shutdown, a refused
+     *  release) is a decision about the record exactly when it does — the sender is told it is final. */
+    tellsSender: (entry: PeerHeldEntry) => boolean;
+    /** THE decision seat: the store's compare-and-set of this entry's record (`MailboxStore.moveDecision`). */
+    decide: (entry: PeerHeldEntry, expect: MailboxDecision | undefined, next: MailboxDecision) => Promise<MailboxDecisionOutcome>;
     /** Announce an entry entering the queue (or its cause changing on re-judgment). */
     onHeld?: (entry: PeerHeldEntry, heldCount: number, cause: CrossSessionHoldCause, reannounce: boolean) => void;
     /** Announce an entry leaving the queue. */
     onSettled?: (entry: PeerHeldEntry, settlement: PeerHeldSettlement, reason: PeerHeldSettleReason, heldCount: number) => void;
+    /** A decision move the store could not take (it threw): the card stays as it was and is tried again later. */
+    onFault?: (entry: PeerHeldEntry, error: unknown) => void;
 }
 export interface PeerHeldQueueConfig {
     sink: PeerHeldQueueSink;
     /** The resolved `dialogExpiry`: ms before a REVIEW-cause hold expires; `null` = never. */
     dialogExpiryMs: number | null;
 }
-export type PeerHeldSettleOutcome = "gone" | "delivered" | "released_pending" | "dropped" | "dropped_by_policy" | "denied" | "expired";
+/** The approval face's answer. `decided_elsewhere` — another consumer's move won the record first (the
+ *  card now shows that state, or left the queue when it was final); `released_pending` — approved, and a
+ *  lease-holding pass delivers it. */
+export type PeerHeldSettleOutcome = "gone" | "delivered" | "released_pending" | "dropped" | "dropped_by_policy" | "denied" | "expired" | "decided_elsewhere";
+/** What {@link PeerHeldQueue.hold} did with a record the judgment holds: `held` — this call held it
+ *  (card + `held` receipt); `adopted` — it was already held (or deliverable) and this queue now shows it
+ *  without a receipt; `uncarded` — held, but this queue is full and no card it carries can be settled to
+ *  make room (none would tell its sender); a final word — another consumer settled it; `gone` —
+ *  no such record any more; `fault` — the store refused the move (reported through `onFault`). */
+export type PeerHoldOutcome = "held" | "adopted" | "uncarded" | "denied" | "expired" | "refused" | "dropped" | "gone" | "fault";
 export interface PeerHeldQueue {
     /** The registry key (scope + box). */
     readonly key: string;
     /** Bind (or re-bind) the live seats. Idempotent per run; a later bind replaces an earlier one. */
     configure(cfg: PeerHeldQueueConfig): void;
-    /** The bound run ended: approvals now park as `released`; deadlines and receipts keep working. */
+    /** The bound run ended: approvals now wait as `approved`; deadlines and receipts keep working. */
     detachLeg(): void;
     /** `true` once {@link configure} ran at least once (the queue can route receipts). */
     configured(): boolean;
-    /** Park a message (CC `v` hold arm): evict-oldest when full, arm the deadline for a review cause,
-     *  announce, receipt `held`. */
-    hold(entry: Omit<PeerHeldEntry, "heldAt" | "released">): void;
-    /** Re-judge every entry against current settings (CC `D`): released ⇒ delivered (or parked
-     *  `released` with no live run), refused ⇒ refused with a receipt, still held ⇒ re-announced only
-     *  when the cause moved. */
-    rejudge(): {
+    /**
+     * Hold a record (CC `v` hold arm). `decision` is the record's decision in the snapshot the caller judged:
+     * absent ⇒ the move absent → `held` is taken (its winner sends the `held` receipt); `held` / `approved` ⇒
+     * the record is already held elsewhere and this queue only shows it (an approved card is not announced).
+     * At the cap, settles the oldest held card that tells its sender (it is then a decision); arms the
+     * deadline for a hold cause a person could answer.
+     */
+    hold(entry: Omit<PeerHeldEntry, "heldAt" | "decision">, decision?: PeerCardDecision): Promise<PeerHoldOutcome>;
+    /** Re-judge every entry against current settings (CC `D`): deliverable ⇒ handed over (or kept with no
+     *  live run), refused ⇒ refused with a receipt, still held ⇒ re-announced only when the cause moved.
+     *  Every move goes through the decision seat. */
+    rejudge(): Promise<{
         released: number;
         refused: number;
         held: number;
-    };
+    }>;
     /**
-     * #1036 — the box is this queue's durable seat, so an entry whose record is no longer IN the box was
-     * settled by whoever held the lease meanwhile (a takeover acked it, delivered or refused). Called by a
-     * drain right after it claims the lease, with the seqs the claimed snapshot holds (a claim marks EVERY
-     * unacked record, so absence is absence): such entries leave the queue as `expired` / `superseded`,
-     * with no receipt (the owner that settled them sent one) and no decision recorded (there is no record
-     * left to decide about). Returns how many were retired.
+     * Bring the cards in line with the box a lease-holding drain just read, seq → the record's decision
+     * (every unacked record of the box is in it, so absence is absence): a card whose record is gone was
+     * settled by whoever held the lease meanwhile — it leaves as `retired` / `superseded`, with no receipt;
+     * a card whose record another consumer settled leaves as that final state / `decided_elsewhere`, with no
+     * receipt (the winner sent it); a card whose record another consumer approved now shows `approved`.
+     * Returns how many cards left.
      */
-    reconcile(present: ReadonlySet<number>): number;
-    /** The review face (CC `l0e`): approve re-judges then delivers (or parks `released` with no live
-     *  run), deny/cancel drop with the matching receipt. `"gone"` when nothing is held under that seq. */
-    settle(seq: number, decision: "approve" | "deny" | "cancel"): PeerHeldSettleOutcome;
+    reconcile(snapshot: ReadonlyMap<number, MailboxDecision | undefined>): number;
+    /** The review face (CC `l0e`): approve re-judges then delivers (or answers `released_pending` with no
+     *  live run), deny/cancel settle with the matching receipt. `"gone"` when nothing is held under that
+     *  seq. The answer is the store's: a move another consumer won answers `decided_elsewhere`. */
+    settle(seq: number, decision: "approve" | "deny" | "cancel"): Promise<PeerHeldSettleOutcome>;
+    /** Is a card for this seq in the queue? */
+    has(seq: number): boolean;
     list(): readonly PeerHeldEntry[];
     size(): number;
-    /** CC `HBe` — a graceful shutdown settles everything still held as `expired` with receipts. */
-    shutdown(): void;
-    /**
-     * #1036 — the TERMINAL DECISIONS this queue has taken about records that are still parked in
-     * the box, seq → the settlement word. Since a held record now stays in its durable box (the box is
-     * this queue's durable seat), a decision taken BETWEEN runs — a human's deny, a deadline, an
-     * eviction — has to survive the run whose ledger recorded it, or the session's next run re-judges
-     * the record from scratch and can deliver a message a person already refused. A decision is kept
-     * only until a drain that holds the lease acks past it ({@link PeerHeldQueue.forgetDecisions}); it
-     * is process-level, like the queue itself, and a crash loses it exactly as it loses the queue.
-     */
-    decisions(): ReadonlyMap<number, PeerHeldSettlement>;
-    /** #1036 — a lease-owning drain acked these seqs out of the box: their decisions are spent. */
-    forgetDecisions(seqs: Iterable<number>): void;
+    /** CC `HBe` — a graceful shutdown settles everything still held as `expired` with receipts (where a
+     *  receipt reaches a sender; elsewhere the cards just leave this process). */
+    shutdown(): Promise<void>;
 }
-/** #1036 — how many terminal decisions about still-parked records one box's queue remembers
- *  (see {@link PeerHeldQueue.decisions}). Several times the queue's own cap: the queue bounds what is
- *  LIVE, this bounds what has been decided and not yet observed as consumed. */
-export declare const PEER_HELD_DECISION_MEMORY: number;
 export declare function createPeerHeldQueue(key: string, opts?: {
     cap?: number;
     clock?: PeerClock;