@sema-agent/core 7.29.0 → 7.30.1

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;