@sema-agent/core 7.28.1 → 7.30.0

package/dist/agents/peer-admission.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { deliverEngineNotice } from "../core/types.js";
-export const PEER_ADMISSION_DEFAULTS = Object.freeze({
+export const PEER_LANE_DEFAULTS = Object.freeze({
     bucketCapacity: 30,
     refillPerSecond: 0.5,
     dedupWindowMs: 30_000,
@@ -9,6 +9,9 @@ export const PEER_ADMISSION_DEFAULTS = Object.freeze({
     maxTrackedSenders: 256,
     maxQueuedPeerMessages: 50,
     maxTrackedRecipients: 256,
+    maxWakesPerHour: 6,
+    maxMessagesPerRound: 5,
+    listingFreshWindowMs: 24 * 60 * 60_000,
 });
 const CONFIG_RANGES = Object.freeze({
     bucketCapacity: [5, 500],
@@ -19,10 +22,14 @@ const CONFIG_RANGES = Object.freeze({
     maxTrackedSenders: [16, 100_000],
     maxQueuedPeerMessages: [10, 5_000],
     maxTrackedRecipients: [16, 100_000],
+    maxWakesPerHour: [0, 600],
+    maxMessagesPerRound: [1, 500],
+    listingFreshWindowMs: [60_000, 30 * 24 * 60 * 60_000],
 });
+const INTEGER_FIELDS = new Set(["maxWakesPerHour", "maxMessagesPerRound"]);
 let announcedOutOfRangeBySink = new WeakMap();
 const announcedOutOfRangeConsole = new Set();
-function peerAdmissionRangeLedger(onNotice) {
+function peerLaneRangeLedger(onNotice) {
     if (typeof onNotice !== "function")
         return announcedOutOfRangeConsole;
     let lines = announcedOutOfRangeBySink.get(onNotice);
@@ -32,12 +39,12 @@ function peerAdmissionRangeLedger(onNotice) {
     }
     return lines;
 }
-export function __resetPeerAdmissionRangeAnnouncements() {
+export function __resetPeerLaneRangeAnnouncements() {
     announcedOutOfRangeBySink = new WeakMap();
     announcedOutOfRangeConsole.clear();
 }
-export function resolvePeerAdmissionConfig(overrides, onNotice) {
-    const out = { ...PEER_ADMISSION_DEFAULTS };
+export function resolvePeerLaneConfig(overrides, onNotice) {
+    const out = { ...PEER_LANE_DEFAULTS };
     if (overrides === undefined)
         return out;
     for (const k of Object.keys(CONFIG_RANGES)) {
@@ -49,12 +56,14 @@ export function resolvePeerAdmissionConfig(overrides, onNotice) {
             ? "not_a_finite_number"
             : v < lo || v > hi
                 ? "out_of_range"
-                : undefined;
+                : INTEGER_FIELDS.has(k) && !Number.isInteger(v)
+                    ? "not_an_integer"
+                    : undefined;
         if (reason === undefined) {
             out[k] = v;
             continue;
         }
-        announcePeerAdmissionFallback(k, v, reason, lo, hi, onNotice);
+        announcePeerLaneFallback(k, v, reason, lo, hi, onNotice);
     }
     return out;
 }
@@ -87,18 +96,18 @@ function configValueKey(v) {
     }
     return renderConfigValue(v);
 }
-function announcePeerAdmissionFallback(field, given, reason, lo, hi, onNotice) {
-    const fallback = PEER_ADMISSION_DEFAULTS[field];
+function announcePeerLaneFallback(field, given, reason, lo, hi, onNotice) {
+    const fallback = PEER_LANE_DEFAULTS[field];
     const shown = renderConfigValue(given);
     const key = JSON.stringify([field, typeof given, configValueKey(given)]);
-    const ledger = peerAdmissionRangeLedger(onNotice);
+    const ledger = peerLaneRangeLedger(onNotice);
     if (ledger.has(key))
         return;
     ledger.add(key);
     deliverEngineNotice(onNotice, {
         code: "config.peer_admission_out_of_range",
-        message: `Peer-admission setting ${field}=${shown} is ` +
-            (reason === "out_of_range" ? `outside its legal range [${lo}, ${hi}]` : `not a finite number`) +
+        message: `Peer-lane setting ${field}=${shown} is ` +
+            (reason === "out_of_range" ? `outside its legal range [${lo}, ${hi}]` : reason === "not_an_integer" ? `not a whole number` : `not a finite number`) +
             `; that field falls back to its default (${fallback}). Every other field is unaffected.`,
         detail: {
             field,

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

@@ -6,6 +6,22 @@ export declare const PEER_SESSION_RECORD_SCHEMA_VERSION = 1;
 export declare const PEER_SESSION_RECORD_MAX_BYTES = 262144;
 export type PeerSessionLiveness = "live" | "dead" | "deleted";
 export type PeerSessionTempo = "active" | "idle" | "blocked";
+/** A session's SELF-REPORTED presence: what it says it is (`agent`) and what it says it is doing
+ *  (`intent`). Labels a peer controls — rendered bounded and prefixed `self:`, never read by any
+ *  permission, routing or wake judgment. The same object rides `TaskSpec.peerPresence`, the wiring
+ *  manifest and the directory row a host copies it into. */
+export interface PeerPresence {
+    agent?: string;
+    intent?: string;
+}
+/** The read cap of one presence label; a longer value refuses the whole row (one rule, `field_invalid`). */
+export declare const PEER_PRESENCE_MAX_CHARS = 120;
+/** THE rule for one presence label, read by the row reader and by prepare's door on `TaskSpec.peerPresence` (a
+ *  spec the directory would refuse is refused where it is written, not when the host files the row). */
+export declare function peerPresenceLabelValid(v: unknown): v is string | undefined;
+/** 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;
 /** 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}. */
 export interface PeerSessionRecord {
@@ -24,11 +40,24 @@ export interface PeerSessionRecord {
     procStartMs?: number;
     cwd?: string;
     startedAt: number;
+    /** When the row last changed (the host's `lastActivityAt` on a server row; `markDead` writes it too). */
     updatedAt: number;
+    /**
+     * @contract peer_directory.dead_is_the_hosts_word — `dead` is the HOST's word: a host marks a row dead
+     * when the session has no leg in flight AND `updatedAt` is older than the host's retention period, and
+     * stamps `diedAt` with the marking time; that retention period is at least the engine's listing
+     * freshness window (`listingFreshWindowMs`), so a row the engine would list as fresh is never dead.
+     * The engine reads `liveness` and `updatedAt`; it never rewrites `liveness` from a row's age.
+     */
     liveness: PeerSessionLiveness;
     /** Present iff `liveness !== "live"`: when the row was marked dead (or the tombstone was written). */
     diedAt?: number;
+    /** 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;
+    /** Self-reported presence (see {@link PeerPresence}); a host copies it off the session's spec. */
+    agent?: string;
+    intent?: string;
     entrypoint?: string;
     peerProtocol?: number;
     /** CC capability bits (`/^[a-z0-9_]{1,32}$/`, ≤16); `sema_mailbox_v1` marks a store-lane peer. */

package/dist/agents/peer-directory.js

@@ -4,6 +4,18 @@ import { formatPeerNameRef, mintPeerRef, normalizePeerName, parsePeerNameRef, PE
 import { inlineUntrusted } from "../core/untrusted-text.js";
 export const PEER_SESSION_RECORD_SCHEMA_VERSION = 1;
 export const PEER_SESSION_RECORD_MAX_BYTES = 262_144;
+export const PEER_PRESENCE_MAX_CHARS = 120;
+export function peerPresenceLabelValid(v) {
+    return v === undefined || (typeof v === "string" && v.length <= PEER_PRESENCE_MAX_CHARS);
+}
+export function assertPeerPresenceValue(v) {
+    const bad = v === undefined ? undefined : v === null || typeof v !== "object" || Array.isArray(v) ? "peerPresence" : ["agent", "intent"].find((k) => !peerPresenceLabelValid(v[k]));
+    if (bad === undefined)
+        return;
+    const e = new Error(`TaskSpec.${bad === "peerPresence" ? bad : `peerPresence.${bad}`} must be ${bad === "peerPresence" ? "a plain { agent?, intent? } object" : `a string of at most ${PEER_PRESENCE_MAX_CHARS} characters`} — the peer directory refuses such a row whole, so the run would advertise a presence no listing can show`);
+    e.code = "config.peer_presence_invalid";
+    throw e;
+}
 export const SESSION_BOX_PREFIX = "session.";
 const SESSION_ID_RE = /^[A-Za-z0-9_-]{1,80}$/;
 export const PEER_SESSION_ID_GRAMMAR = "^[A-Za-z0-9_-]{1,80}$";
@@ -61,6 +73,12 @@ export function readPeerSessionRecord(raw) {
         return bad("peerProtocol");
     if (!optString(r["cwd"]))
         return bad("cwd");
+    if (!peerPresenceLabelValid(r["agent"]))
+        return bad("agent");
+    if (!peerPresenceLabelValid(r["intent"]))
+        return bad("intent");
+    const agent = typeof r["agent"] === "string" && r["agent"].trim() !== "" ? r["agent"] : undefined;
+    const intent = typeof r["intent"] === "string" && r["intent"].trim() !== "" ? r["intent"] : undefined;
     if (!optString(r["entrypoint"]))
         return bad("entrypoint");
     if (!optString(r["sockPath"]))
@@ -88,6 +106,8 @@ export function readPeerSessionRecord(raw) {
         ...(r["pid"] !== undefined ? { pid: r["pid"] } : {}),
         ...(r["procStartMs"] !== undefined ? { procStartMs: r["procStartMs"] } : {}),
         ...(r["cwd"] !== undefined ? { cwd: r["cwd"] } : {}),
+        ...(agent !== undefined ? { agent } : {}),
+        ...(intent !== undefined ? { intent } : {}),
         startedAt: r["startedAt"],
         updatedAt: r["updatedAt"],
         liveness,

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

@@ -3,7 +3,7 @@ import type { CrossSessionHoldCause, CrossSessionInboundVerdict } from "./cross-
 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 round). */
+ *  hold — it never enters the held queue; the drain stops at that seq and re-judges next pass). */
 export type PeerInboundHoldCause = CrossSessionHoldCause | "rate_limited";
 export interface PeerHeldEntry {
     /** The recipient box seq of the held record (its identity for the review face). */
@@ -26,7 +26,7 @@ export interface PeerHeldEntry {
     released?: boolean;
 }
 export type PeerHeldSettlement = "expired" | "delivered" | "refused" | "denied" | "dropped";
-export type PeerHeldSettleReason = "evicted" | "deadline" | "shutdown" | "rejudge" | "approved" | "denied" | "cancelled" | "inject_failed";
+export type PeerHeldSettleReason = "evicted" | "deadline" | "shutdown" | "rejudge" | "approved" | "denied" | "cancelled" | "inject_failed" | "superseded";
 /** The clock/timer seam (tests inject a virtual one). Handles are opaque. */
 export interface PeerClock {
     now(): number;
@@ -41,8 +41,10 @@ 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). */
-    inject?: (entry: PeerHeldEntry) => void;
+     *  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). */
+    inject?: (entry: PeerHeldEntry) => void | "deferred";
     /** The receipt to the sender (the binding routes it into the sender's box). */
     receipt: (entry: PeerHeldEntry, state: PeerDeliveryReceiptState) => void;
     /** Announce an entry entering the queue (or its cause changing on re-judgment). */
@@ -76,6 +78,15 @@ export interface PeerHeldQueue {
         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.
+     */
+    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;
@@ -83,7 +94,23 @@ export interface PeerHeldQueue {
     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;
 }
+/** #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;

package/dist/agents/peer-held-queue.js

@@ -10,11 +10,13 @@ export const realPeerClock = {
     clearTimeout: (h) => clearTimeout(h),
 };
 const crashHandlers = new WeakMap();
+export const PEER_HELD_DECISION_MEMORY = PEER_HELD_QUEUE_CAP * 4;
 export function createPeerHeldQueue(key, opts = {}) {
     const cap = opts.cap ?? PEER_HELD_QUEUE_CAP;
     const clock = opts.clock ?? realPeerClock;
     const entries = [];
     const deadlines = new Map();
+    const decisions = new Map();
     let cfg;
     const sinkOrThrow = () => {
         if (cfg === undefined)
@@ -44,6 +46,15 @@ export function createPeerHeldQueue(key, opts = {}) {
     const settleOut = (entry, settlement, reason, receipt) => {
         const sink = sinkOrThrow();
         remove(entry);
+        if (settlement !== "delivered") {
+            decisions.set(entry.seq, settlement);
+            while (decisions.size > PEER_HELD_DECISION_MEMORY) {
+                const oldest = decisions.keys().next();
+                if (oldest.done === true)
+                    break;
+                decisions.delete(oldest.value);
+            }
+        }
         if (receipt !== undefined)
             safe(() => sink.receipt(entry, receipt));
         safe(() => sink.onSettled?.(entry, settlement, reason, entries.length));
@@ -71,7 +82,8 @@ export function createPeerHeldQueue(key, opts = {}) {
         if (sink.inject === undefined)
             return "no_leg";
         try {
-            sink.inject(entry);
+            if (sink.inject(entry) === "deferred")
+                return "no_leg";
         }
         catch {
             settleOut(entry, "dropped", "inject_failed", "dropped");
@@ -80,6 +92,18 @@ export function createPeerHeldQueue(key, opts = {}) {
         settleOut(entry, "delivered", reason, "delivered");
         return "delivered";
     };
+    const reconcile = (present) => {
+        const sink = sinkOrThrow();
+        let retired = 0;
+        for (const entry of [...entries]) {
+            if (present.has(entry.seq))
+                continue;
+            remove(entry);
+            retired += 1;
+            safe(() => sink.onSettled?.(entry, "expired", "superseded", entries.length));
+        }
+        return retired;
+    };
     const rejudge = () => {
         const sink = sinkOrThrow();
         let released = 0;
@@ -151,6 +175,7 @@ export function createPeerHeldQueue(key, opts = {}) {
             safe(() => sink.receipt(entry, "held"));
         },
         rejudge,
+        reconcile,
         settle(seq, decision) {
             const sink = sinkOrThrow();
             const entry = entries.find((e) => e.seq === seq);
@@ -186,6 +211,11 @@ export function createPeerHeldQueue(key, opts = {}) {
         },
         list: () => entries.map((e) => ({ ...e, ...(e.hopChain !== undefined ? { hopChain: [...e.hopChain] } : {}), ...(e.peerMeta !== undefined ? { peerMeta: { ...e.peerMeta } } : {}) })),
         size: () => entries.length,
+        decisions: () => decisions,
+        forgetDecisions(seqs) {
+            for (const seq of seqs)
+                decisions.delete(seq);
+        },
         shutdown() {
             if (cfg === undefined) {
                 entries.length = 0;
@@ -199,6 +229,7 @@ export function createPeerHeldQueue(key, opts = {}) {
         },
     };
     crashHandlers.set(queue, () => {
+        decisions.clear();
         entries.length = 0;
         for (const h of deadlines.values())
             clock.clearTimeout(h);

package/dist/agents/peer-session-drain.d.ts

@@ -1,9 +1,10 @@
 import { type MailboxCrossProcessVerdict, type MailboxStore } from "../core/mailbox-store.js";
-import type { SessionBoxBinding, SystemInjectionPriority, TaskNotificationPayload } from "../core/task-notification.js";
+import { type SessionBoxBinding, type SystemInjectionPriority, type TaskNotificationPayload } from "../core/task-notification.js";
+import { type FrameSettlement } from "../core/frame-settlement.js";
 import { type EngineNotice, type RunnerDeps } from "../core/types.js";
 import { type PermissionModeClass } from "./cross-session-envelope.js";
 import { type CrossSessionInboundSettingLayers } from "./cross-session-judge.js";
-import { type PeerAdmissionConfig } from "./peer-admission.js";
+import { type PeerLaneConfig } from "./peer-admission.js";
 import { type PeerDirectory } from "./peer-directory.js";
 import { createListAgentsTool } from "./list-agents-tool.js";
 import type { AskEffective } from "../core/wiring-manifest.js";
@@ -46,13 +47,34 @@ export declare function judgePeerLaneMount(deps: {
  * revival lane), and a drain per child on a box nobody writes would cost a lease claim per turn on
  * every background agent. `undefined` on every refusal — silently: no host asked for a box here.
  */
-export declare function judgeSessionBoxDrain(deps: Pick<RunnerDeps, "mailboxStore" | "onError">, leg: {
+export declare function judgeSessionBoxDrain(deps: Pick<RunnerDeps, "mailboxStore" | "onError" | "sessionBoxEngineFrames">, leg: {
     sessionId: string;
     scope: string;
     isDelegatedChild: boolean;
 }): SessionBoxBinding | undefined;
-/** The disposition arms of a `peer.inbound_disposition` notice (closed set; `detail.disposition`). */
-export type PeerInboundDisposition = "refused" | "held" | "admission_refused" | "notice_unrouted" | "notice_user_only";
+/** What one pull of the box handed back: the records read (already rendered frames), and what is still waiting. */
+export interface PulledInbox {
+    delivered: TaskNotificationPayload[];
+    /** Records still leased in the box after this pull (the next pull, or the next boundaries, read them). */
+    pending: number;
+    /** How many of the waiting records their sender marked urgent. */
+    urgent: number;
+}
+/** The disposition arms of a `peer.inbound_disposition` notice (closed set; `detail.disposition`).
+ *  #1036 adds `resupply_exhausted`: a record whose frame a compaction summarized away, was
+ *  re-supplied once, and was summarized away AGAIN. It settles (leaves the box) — but as a DISCLOSED
+ *  loss, never as "the model read it". The cap is a bound on delivery attempts; it does not
+ *  manufacture a consumption proof. */
+export type PeerInboundDisposition = "refused" | "held" | "admission_refused" | "notice_unrouted" | "notice_user_only" | "resupply_exhausted";
+/**
+ * #1036 — how many times a record whose frame was summarized away is handed over again before the
+ * drain gives up and discloses. `1` = one repair, i.e. at most two occurrences of one record in one
+ * run. A cap exists because repair that cannot converge is a loop; it is this small because the
+ * second occurrence already says everything the first did. RUN-SCOPED (the ledger is in memory): a
+ * crash or a takeover re-serves the record at `attempt: 1`, the at-least-once posture this lane has
+ * always had, not a new hole.
+ */
+export declare const PEER_RESUPPLY_CAP = 1;
 export interface PeerSessionDrainOptions {
     mailbox: MailboxStore;
     /** This session (the box owner) and this leg's cycle id (the lease owner). */
@@ -64,8 +86,8 @@ export interface PeerSessionDrainOptions {
     inject: (notification: TaskNotificationPayload, opts?: {
         priority?: SystemInjectionPriority;
     }) => void;
-    /** Deployment tuning of the admission gate (the same seat SendMessage reads). */
-    admission?: Partial<PeerAdmissionConfig>;
+    /** The peer lane's knob table (admission gate + delivery budgets + listing window; the same seat SendMessage reads). */
+    lane?: Partial<PeerLaneConfig>;
     /** The recipient's self-token set for the hop check, read live (the run's peer identity ref). */
     ownTokens: () => readonly string[];
     /** The recipient's `crossSessionInbound` layers, read at every drain. */
@@ -74,7 +96,7 @@ export interface PeerSessionDrainOptions {
     selfModeClass: () => PermissionModeClass | "unknown";
     /** This session's display name (its directory row's name), for receipts and idle notices it authors. */
     selfName?: () => string | undefined;
-    /** Awaited ONCE before the first round (a directory lookup that fills `selfName`, say); a rejection is swallowed. */
+    /** Awaited ONCE before the first pass (a directory lookup that fills `selfName`, say); a rejection is swallowed. */
     warmup?: () => Promise<unknown>;
     /** The deployment's `dialogExpiry` (raw; resolved at bind — an out-of-vocabulary value is announced
      *  once through `onError` and the default applies). Absent ⇒ the default (5 m). */
@@ -89,14 +111,55 @@ export interface PeerSessionDrainOptions {
         sessionId: string;
         classification: string;
     }) => void;
+    /** #1036 — the LEG's settlement seam: the receipts the harness records when a frame reaches
+     *  the transcript and the effects the compaction commit beat records. Absent ⇒ the drain mints a
+     *  private one, which is honest but inert: nothing fills it, so every delivered record waits for a
+     *  receipt that never comes and stays parked (at-least-once). Every production binding supplies it. */
+    settlement?: FrameSettlement;
     leaseTtlMs?: number;
     /** Tests: a virtual clock for the held deadlines and idle timers (honored when this process first sees the session). */
     clock?: PeerClock;
 }
 export interface PeerSessionDrain {
-    /** One drain round (serialized: a boundary never overlaps a still-running round). */
+    /**
+     * One drain pass (serialized: a boundary never overlaps a still-running pass).
+     *
+     * @contract cross_session.settled_means_committed_and_not_summarized — a session-box record is acked
+     * only after a frame carrying it has been committed to the transcript and no compaction applied up to
+     * that settlement beat summarized that entry away. A summarized frame is re-supplied once (a new
+     * occurrence of the SAME record: same `task_id`, same `seq`, `attempt: 2`, `resupplied: true`), and a
+     * re-supplied occurrence summarized again settles as `resupply_exhausted`, disclosed — never as seen.
+     * OBSERVABLE: a `compacted` frame counting a not-yet-acked delivered record
+     * (`summarizedCrossSessionMessages >= 1`) is followed, in the same boundary's delivery half, by a
+     * re-supply frame for it or by a `resupply_exhausted` disposition — never by silence; a record
+     * committed and never summarized is never shown twice; no compaction implies no re-supply.
+     */
     drain(): Promise<void>;
-    /** Run end: ack the last batch and release the lease so the session's next cycle claims at once. */
+    /**
+     * The PULL face (the `ReadInbox` tool): one pass over the same box, same cursor, same judgments —
+     * but the records are RETURNED instead of injected, up to `limit` (default = the pass budget). A
+     * record a boundary already handed over is never returned again, and a record returned here is
+     * never injected later: one cursor (`settledUpTo`), two readers. Never acks (the next boundary does).
+     */
+    pull(limit?: number, toolCallId?: string, charBudget?: number): Promise<PulledInbox>;
+    /**
+     * #1036 — THE TURN BOUNDARY's pass, called by the boundary lane as its tail so it runs AFTER that
+     * boundary's compaction (a hook of its own would have been registration-order luck). The settlement
+     * half always runs; the delivery half only when `continues` — a boundary this leg will not follow
+     * with another request cannot produce a transcript receipt for anything handed over there.
+     */
+    boundaryRound(o: {
+        continues: boolean;
+    }): Promise<void>;
+    /** #1036 — "is this engine frame's record still parked in this box?" The terminal sweep's
+     *  per-session pend must skip those: the box re-serves them itself, and a process-local copy beside
+     *  a parked record is two sources of truth for one message. */
+    isBoxBacked(payload: unknown): boolean;
+    /** #1036 — "does this leg hold a record a landed compaction could still break?" The compaction
+     *  commit beat asks before recording its effect, so a run that will never read one records none. */
+    wantsCompactionEffects(): boolean;
+    /** Run end: settle what reached the transcript, then release the lease so the session's next cycle
+     *  claims at once. What did NOT reach it stays parked (at-least-once, next run re-serves it). */
     finish(): Promise<void>;
     /** The run began working (cancels a pending idle fire). */
     busy(): void;
@@ -112,6 +175,15 @@ export declare function createPeerSessionDrain(opts: PeerSessionDrainOptions): P
  *  before it — both read this one cell. */
 export interface PeerLaneRefs {
     askEffective?: AskEffective;
+    /** The bound drain's pull face (filled by {@link bindPeerLaneDrain}); the `ReadInbox` tool reads it late. */
+    pull?: (limit?: number, toolCallId?: string, charBudget?: number) => Promise<PulledInbox>;
+    /** #1036 — the bound drain's BOUNDARY pass (filled by {@link bindPeerLaneDrain}); the leg's
+     *  prepared seat copies it out so the turn-boundary lane can tail-call it. */
+    boundaryRound?: (o: {
+        continues: boolean;
+    }) => Promise<void>;
+    /** #1036 — the bound drain's box-backed predicate (filled by {@link bindPeerLaneDrain}). */
+    isBoxBacked?: (payload: unknown) => boolean;
 }
 /**
  * The mount verdict + its loud half: `true` = the lane mounts on this leg; `false` = no seat, or the
@@ -153,7 +225,10 @@ export declare function listAgentsMountable(face: {
 /** design/385 §5.1 — the ListAgents mount (alias ListPeers): read-only, concurrency-safe, on the peer
  *  seat's own arm beside SendMessage; a caller-supplied tool of the same name wins (skip, not throw). */
 export declare function mountListAgents(args: {
-    peerDirectory: PeerDirectory;
+    /** The directory when the peer lane is up; absent on a delegation-only mount (agent lanes list, no peer rows). */
+    peerDirectory?: PeerDirectory;
+    /** The resolved listing freshness window (the peer lane's knob table). */
+    freshWindowMs?: number;
     sessionId: string;
     scope: string;
     hostTaskId: string;
@@ -190,18 +265,21 @@ export interface PeerDrainHarness {
 export declare function bindPeerSessionDrain(harness: PeerDrainHarness, opts: PeerSessionDrainOptions): PeerSessionDrain;
 /**
  * The leg-side spelling of {@link bindPeerSessionDrain}: the deployment seats the drain reads
- * (`mailboxStore` / `peerAdmission` / `crossSessionInbound` / `crossSessionDialogExpiry` / the two
+ * (`mailboxStore` / `peerLane` / `crossSessionInbound` / `crossSessionDialogExpiry` / the two
  * sinks) come straight off deps, the recipient's mode class folds off the lane refs — one binding call
  * per leg, no per-seat plumbing.
  */
 export declare function bindPeerLaneDrain(harness: PeerDrainHarness, args: {
-    deps: Pick<RunnerDeps, "mailboxStore" | "peerDirectory" | "peerAdmission" | "crossSessionInbound" | "crossSessionDialogExpiry" | "onNotice" | "onError">;
+    deps: Pick<RunnerDeps, "mailboxStore" | "peerDirectory" | "peerLane" | "crossSessionInbound" | "crossSessionDialogExpiry" | "onNotice" | "onError">;
     sessionId: string;
     runId: string;
     scope: string;
     inject: PeerSessionDrainOptions["inject"];
     ownTokens: () => readonly string[];
     refs: PeerLaneRefs;
+    /** #1036 — the leg's settlement seam (receipts + compaction effects), minted by the
+     *  orchestrator and shared with the harness sink and the compaction commit beat. */
+    settlement?: FrameSettlement;
     selfName?: () => string | undefined;
     parked?: () => boolean;
     lastTurnText?: () => string | undefined;