@staix/agent-hub 0.30.0 → 0.31.0

package/src/memory/capture.ts

@@ -1,6 +1,7 @@
+import { reviewCaptureExcluded } from "../hub/memory-policy.ts";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { defaultCapturePeer } from "../adapters/definitions/native-identity-defaults.ts";
-import { BOUNDED_TASK_TOOLS, CAPABILITY_TOOLS, HANDOFF_TOOLS, STUDY_TOOLS } from "../hub/hub-tools.ts";
+import { BOUNDED_TASK_TOOLS, CAPABILITY_TOOLS, HANDOFF_TOOLS, QUESTION_TOOLS, STUDY_TOOLS } from "../hub/hub-tools.ts";
 import { MEMORY_READ_TOOLS } from "../hub/read-tools.ts";
 import { isDenied } from "../local/deny.ts";
 import type { MemoryClient } from "./client.ts";
@@ -38,7 +39,9 @@ export class Capture {
   }
 
   observe(call: { tool: string; args: string; output: string; id: string; paths: string[]; sourceId?: string }): void {
-    if (!this.sessionId || ((MEMORY_READ_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || BOUNDED_TASK_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || CAPABILITY_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || STUDY_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || HANDOFF_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, ""))) || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_memory_correct") || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_source_read" || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_set_title" || this.opts.skip?.includes(call.tool)) return;
+    if (!this.sessionId || reviewCaptureExcluded(call.tool, call.args) || ((MEMORY_READ_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || BOUNDED_TASK_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || CAPABILITY_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || STUDY_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || HANDOFF_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, ""))) || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_memory_correct") || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_source_read" || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_set_title" || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_evidence_record" || this.opts.skip?.includes(call.tool)) return;
+    // #1053: a question and its answer are the person's and the peer's words: never memory evidence, whatever the call's paths say.
+    if (QUESTION_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, ""))) return;
     // Anything that names a denylisted path is kept out of memory entirely, input and output alike.
     if (call.paths.some((p) => isDenied(p, this.opts.deny) || p.split(/\s+/).some((word) => isDenied(word, this.opts.deny)))) return;
     // ponytail: legacy callers without a host sourceId dedupe native ids within a summary interval; all live LocalPeer calls supply invocation identity. Require that port for other hosts.

package/src/pet/config.ts

@@ -8,7 +8,14 @@ const PALETTES: Record<string, PetPalette> = { a: "blue", b: "teal", c: "violet"
 export function petPalette(value: unknown): PetPalette | undefined {
   return typeof value === "string" ? PALETTES[value.toLowerCase()] : undefined;
 }
-export interface PetConfig { enabled: boolean; blink: boolean; bell: boolean; character?: CharacterId; size?: PetSize; glyphs?: PetGlyphs; palette?: PetPalette; notice?: string; window?: boolean }
+export const PET_WINDOW_RETIRED_NOTICE = "The floating pet window moved to acon Mini; run acon ui and open Mini.";
+/** Source compatibility only. Removed window data is never a terminal option or a settings capability. */
+export function stripLegacyPetWindow(value: unknown): unknown {
+  if (!value || typeof value !== "object" || Array.isArray(value) || !Object.hasOwn(value, "window")) return value;
+  const { window: _retired, ...terminal } = value as Record<string, unknown>;
+  return terminal;
+}
+export interface PetConfig { enabled: boolean; blink: boolean; bell: boolean; character?: CharacterId; size?: PetSize; glyphs?: PetGlyphs; palette?: PetPalette; notice?: string }
 /** Console-local presentation only; it merges pet.palette into config.local.json and grants no authority. */
 export function savePetPalette(cwd: string, value: string): string {
   const palette = petPalette(value);
@@ -35,34 +42,39 @@ export function savePetPalette(cwd: string, value: string): string {
 /** Console-local presentation only; this reader never writes config or grants authority. */
 export function loadPetConfig(cwd: string): PetConfig {
   let value: unknown;
-  let enabled = true;
+  let enabled = true, retiredWindow = false;
   for (const name of ["config.json", "config.local.json"]) {
     try {
       const file = JSON.parse(readFileSync(join(cwd, ".agenthub", name), "utf8"));
-      // A window-only local opt-in does not undo inherited pet:false presentation.
-      if (file.pet === false) enabled = false;
-      else if (file.pet !== undefined && !(file.pet && typeof file.pet === "object" && !Array.isArray(file.pet) && Object.keys(file.pet).length === 1 && Object.hasOwn(file.pet, "window"))) enabled = true;
-      if (file.pet !== undefined) value = value && typeof value === "object" && file.pet && typeof file.pet === "object" ? { ...value, ...file.pet } : file.pet;
+      const pet = stripLegacyPetWindow(file.pet);
+      if (pet !== file.pet) {
+        retiredWindow = true;
+        // A retired-only block contributes no terminal override, including no enablement over inherited pet:false.
+        if (pet && typeof pet === "object" && !Object.keys(pet).length) continue;
+      }
+      if (pet === false) enabled = false;
+      else if (pet !== undefined) enabled = true;
+      if (pet !== undefined) value = value && typeof value === "object" && pet && typeof pet === "object" ? { ...value, ...pet } : pet;
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
     }
   }
-  if (value === false) return { enabled: false, blink: true, bell: false };
+  const notice = (other?: string) => [retiredWindow ? PET_WINDOW_RETIRED_NOTICE : undefined, other].filter(Boolean).join(" ");
+  if (value === false) return { enabled: false, blink: true, bell: false, ...(retiredWindow ? { notice: notice() } : {}) };
   const defaults = { enabled: true, blink: true, bell: false };
-  if (value === undefined) return defaults;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return { ...defaults, notice: "Unknown pet configuration; using stai line defaults." };
+  if (value === undefined) return { ...defaults, ...(retiredWindow ? { notice: notice() } : {}) };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { ...defaults, notice: notice("Unknown pet configuration; using stai line defaults.") };
   const row = value as Record<string, unknown>;
-  const invalid = Object.keys(row).some(key => !["character", "size", "glyphs", "blink", "bell", "palette", "window"].includes(key)) ||
+  const invalid = Object.keys(row).some(key => !["character", "size", "glyphs", "blink", "bell", "palette"].includes(key)) ||
     row.character !== undefined && !characterId(row.character) || row.size !== undefined && !["line", "mini", "full"].includes(row.size as string) ||
     row.glyphs !== undefined && (typeof row.glyphs !== "string" || !["auto", "ascii", "blocks"].includes(row.glyphs)) ||
     row.palette !== undefined && !petPalette(row.palette) ||
-    row.blink !== undefined && typeof row.blink !== "boolean" || row.bell !== undefined && typeof row.bell !== "boolean" || row.window !== undefined && typeof row.window !== "boolean";
+    row.blink !== undefined && typeof row.blink !== "boolean" || row.bell !== undefined && typeof row.bell !== "boolean";
   const palette = petPalette(row.palette);
   return { enabled, blink: typeof row.blink === "boolean" ? row.blink : true, bell: typeof row.bell === "boolean" ? row.bell : false,
-    ...(typeof row.window === "boolean" ? { window: row.window } : {}),
     ...(characterId(row.character) && row.character !== "stai" ? { character: row.character } : {}),
     ...(row.size === "mini" || row.size === "full" ? { size: row.size } : {}),
     ...(row.glyphs === "ascii" || row.glyphs === "blocks" ? { glyphs: row.glyphs } : {}),
     ...(palette && palette !== "teal" ? { palette } : {}),
-    ...(invalid ? { notice: "Unknown pet option; using stai line defaults for that option." } : {}) };
+    ...(invalid || retiredWindow ? { notice: notice(invalid ? "Unknown pet option; using stai line defaults for that option." : undefined) } : {}) };
 }

package/src/rooms/link.ts

@@ -3,7 +3,7 @@ import { createBrokerAuth, decodeBrokerChallenge, encodeBrokerControl } from "..
 import { assertRoomCryptoReady, encodeBase64url, sha256, RoomCryptoError } from "./crypto.ts";
 import { brokerUrl, canonicalBytes, decodeFrame, decodeRoster, openFrame, roomMembers, sealFrame, verifyPublicRoster, RoomWireError, type FrameWire, type FrameOpenResult, type VerifiedPublicRoster } from "./wire.ts";
 import type { RoomRefusalReason, RoomState, RoomStore } from "./store.ts";
-import { RoomUnmatchedReceiptError, RoomFreshChatCapacityError, type RoomOutgoingInput } from "./store.ts";
+import { RoomUnmatchedReceiptError, RoomFreshChatCapacityError, RoomStoreError, type RoomOutgoingInput } from "./store.ts";
 import { decodeRoomMessage, encodeRoomMessage, type RoomMessage } from "./application.ts";
 
 export type RoomLinkState = "offline" | "connecting" | "online";
@@ -28,6 +28,7 @@ export interface RoomLinkApplication {
   stored(context: RoomLinkContext, input: { digest: string; seq: string }): void;
   /** Fixed transport metadata only; never application completion or authority. */
   transportAck?(context: RoomLinkContext, input: { digest: string }): void;
+  receiptTtlMs?(context: RoomLinkContext): number;
   capacityChanged?(context: RoomLinkContext): void;
   gap?(context: RoomLinkContext, input: { sender: string; count: string }): void;
 }
@@ -40,12 +41,31 @@ export class RoomLinkError extends Error {
     super(`Room link: ${code}`); this.name = "RoomLinkError";
   }
 }
+/** Only before durable application enqueue: the Bus may retain its original queue item. */
+export class RoomNotSentError extends Error {
+  readonly code = "not_sent";
+  constructor() { super("room application was not queued; retry when the link is ready"); this.name = "RoomNotSentError"; }
+}
+const RECEIPT_TTL_MS = 24 * 3_600_000;
 const LIMITS = Object.freeze({ packets: 8, queuedBytes: 2_097_152, packetBytes: 1_048_576, backpressure: 1_048_576, handshakeMs: 30_000, reconnectMaxMs: 300_000 });
 const decoder = new TextDecoder("utf-8", { fatal: true });
 const PEER_ID = /^[a-z][a-z0-9-]{0,31}$/;
 const DIGEST = /^[A-Za-z0-9_-]{43}$/;
 const STATES: readonly string[] = ["idle", "busy", "paused", "offline"];
+interface PendingFrame { wire: Uint8Array; digest: string; presence: boolean; requestReply: boolean; current: () => boolean; retained?: () => boolean; onSent?: () => void; afterInboundAck?: string }
 interface Session {
+  processingFrame?: string;
+  acknowledgedFrame?: string;
+  pendingPresenceReplies: Set<string>;
+  presenceAsked: boolean;
+  presenceRoster?: string;
+  outbound: PendingFrame[];
+  outboundBytes: number;
+  frameSent: boolean;
+  retryAttempt: number;
+  frameRetry?: ReturnType<typeof setTimeout>;
+  lastPresence?: string;
+  ephemeral?: boolean;
   ws: WebSocket;
   generation: number;
   room: string;
@@ -165,6 +185,7 @@ export class RoomLink {
     if (!this.publicationCurrent(session, row.current.digest) || !this.options.store.ordinaryInboxAvailable(this.options.name, bytes)) return;
     // Intent survives coalescing, ordinary responses and publication failure.
     // Only an actually sent request with current capacity may clear the numeric flag.
+    if (!this.forcePresenceRequest) { session.pendingPresenceReplies.clear(); session.presenceAsked = false; }
     session.requestPresenceReply = true; this.forcePresenceRequest = true;
     try { await this.publishPresence(); }
     catch (error) { this.retry(session); throw error; }
@@ -233,6 +254,8 @@ export class RoomLink {
     this.republish = undefined;
     if (session) {
       clearTimeout(session.handshake);
+      if (session.frameRetry) clearTimeout(session.frameRetry);
+      session.outbound.length = 0; session.outboundBytes = 0; session.pendingPresenceReplies.clear();
       session.queue.length = 0; session.queuedBytes = 0; session.deferredFrame = undefined;
       try { session.ws.close(1000, "disconnected"); } catch { /* already closed */ }
     }
@@ -259,10 +282,11 @@ export class RoomLink {
     } catch { this.setState("offline"); return; }
     url.pathname = `/v1/rooms/${row.current.room}`;
     let ws: WebSocket;
-    try { ws = new WebSocket(url.href); } catch { this.retry(); return; }
+    // ponytail: negotiate only ephemeral here; replace this opt-in with #1204 T4 codec capabilities.
+    try { ws = new WebSocket(url.href, { headers: { "x-agent-hub-ephemeral": "1" } }); } catch { this.retry(); return; }
     ws.binaryType = "arraybuffer";
     const generation = ++this.generation;
-    const session: Session = { ws, generation, room: row.current.room, broker: row.broker, phase: "challenge", queue: [], queuedBytes: 0, processing: false, initialRoster: true, requestPresenceReply: true,
+    const session: Session = { ws, generation, room: row.current.room, broker: row.broker, phase: "challenge", pendingPresenceReplies: new Set(), presenceAsked: false, outbound: [], outboundBytes: 0, frameSent: false, retryAttempt: 0, queue: [], queuedBytes: 0, processing: false, initialRoster: true, requestPresenceReply: true,
       handshake: setTimeout(() => this.retry(session), LIMITS.handshakeMs) };
     session.handshake.unref?.();
     this.session = session;
@@ -276,6 +300,59 @@ export class RoomLink {
     if (bytes.length > LIMITS.packetBytes || session.ws.bufferedAmount > LIMITS.backpressure) fail("limit");
     session.ws.send(bytes);
   }
+  private queueFrame(session: Session, wire: Uint8Array, digest: string, requestReply = false, current: () => boolean = () => true, presence = false, retained?: () => boolean, onSent?: () => void, afterInboundAck?: string): void {
+    this.current(session);
+    // Only an unsent observation may be replaced. Never reorder an attempted frame.
+    if (presence) {
+      const at = session.outbound.findIndex((frame, index) => frame.presence && (!frame.requestReply || requestReply) && (index > 0 || !session.frameSent && !session.frameRetry));
+      if (at >= 0) session.outboundBytes -= session.outbound.splice(at, 1)[0]!.wire.byteLength;
+    }
+    if (session.outbound.length >= LIMITS.packets || session.outboundBytes + wire.byteLength > LIMITS.queuedBytes) fail("limit");
+    session.outbound.push({ wire, digest, presence, requestReply, current, retained, onSent, afterInboundAck }); session.outboundBytes += wire.byteLength;
+    this.pumpFrames(session);
+  }
+  private pumpFrames(session: Session): void {
+    if (session.frameSent || session.frameRetry || !session.outbound.length) return;
+    this.current(session);
+    const frame = session.outbound[0]!;
+    if (frame.retained && !frame.retained()) {
+      // Disposed/expired intent cannot survive in the transport's RAM queue.
+      session.outbound.shift(); session.outboundBytes -= frame.wire.byteLength; session.retryAttempt = 0;
+      this.pumpFrames(session); return;
+    }
+    if (!frame.current()) {
+      if (!frame.presence) fail("state_changed");
+      session.outbound.shift(); session.outboundBytes -= frame.wire.byteLength; session.lastPresence = undefined;
+      this.pumpFrames(session);
+      void this.publishPresence().catch(() => this.retry(session));
+      return;
+    }
+    // A foreground receipt follows the chat ACK on the socket. Otherwise broker
+    // verification/storage of the receipt can pin the chat's one-packet slot.
+    if (frame.afterInboundAck && session.processingFrame === frame.afterInboundAck && session.acknowledgedFrame !== frame.afterInboundAck) return;
+    this.send(session, frame.wire); session.frameSent = true;
+    const onSent = frame.onSent; frame.onSent = undefined; onSent?.();
+  }
+  private storedFrame(session: Session, digest: string): void {
+    if (session.outbound[0]?.digest !== digest) return;
+    const frame = session.outbound.shift()!; session.outboundBytes -= frame.wire.byteLength;
+    session.frameSent = false; session.retryAttempt = 0;
+    if (session.frameRetry) clearTimeout(session.frameRetry);
+    session.frameRetry = undefined;
+    this.pumpFrames(session);
+  }
+  private backoffFrame(session: Session, digest: string): void {
+    if (session.outbound[0]?.digest !== digest || session.frameRetry) return;
+    session.frameSent = false;
+    const delay = Math.min(30_000, 250 * 2 ** Math.min(session.retryAttempt++, 7));
+    session.frameRetry = setTimeout(() => {
+      session.frameRetry = undefined;
+      if (this.session !== session || !this.running || session.phase !== "ready") return;
+      try { this.pumpFrames(session); } catch { this.retry(session); }
+    }, delay);
+    session.frameRetry.unref?.();
+    this.pumpFrames(session);
+  }
   private receive(session: Session, data: unknown): void {
     if (this.session !== session || !this.running) return;
     if (!(data instanceof ArrayBuffer) || data.byteLength === 0 || data.byteLength > LIMITS.packetBytes || session.queue.length + (session.deferredFrame ? 1 : 0) >= LIMITS.packets || session.queuedBytes + (session.deferredFrame?.byteLength ?? 0) + data.byteLength > LIMITS.queuedBytes) { this.retry(session); return; }
@@ -327,13 +404,19 @@ export class RoomLink {
       return;
     }
     if (message.type === "ready") {
-      const ready = exact(message, ["v", "type", "room", "member", "epoch", "digest"]), roster = session.roster;
+      const ready = exact(message, ["v", "type", "room", "member", "epoch", "digest", ...(Object.hasOwn(message, "ephemeral") ? ["ephemeral"] : [])]), roster = session.roster;
+      if (ready.ephemeral !== undefined && ready.ephemeral !== true) fail();
       if (!roster || ready.room !== local.current.room || ready.member !== this.options.store.identity.public.fingerprint || ready.epoch !== roster.epoch || ready.digest !== roster.digest) fail("untrusted");
       if (roster.digest !== local.current.digest) {
         if (roster.owner !== this.options.store.identity.public.fingerprint || BigInt(roster.epoch) >= BigInt(local.current.epoch)) fail("untrusted");
         session.ownerUpgrading = true;
         this.send(session, local.wire); return;
       }
+      if (session.presenceRoster !== roster.digest) {
+        session.presenceRoster = roster.digest; session.pendingPresenceReplies.clear(); session.presenceAsked = false;
+        session.requestPresenceReply = true; session.lastPresence = undefined;
+      }
+      session.ephemeral = ready.ephemeral === true;
       session.phase = "ready"; session.ownerUpgrading = false; clearTimeout(session.handshake); this.attempts = 0;
       if (session.deferredFrame) {
         session.queue.unshift(session.deferredFrame); session.queuedBytes += session.deferredFrame.byteLength; session.deferredFrame = undefined;
@@ -341,6 +424,7 @@ export class RoomLink {
       this.setState("online");
       const context = this.context(session, local.current.digest);
       this.options.application?.members(context);
+      this.restoreReceipts(session);
       await this.retryPendingApplications();
       this.current(session, local.current.digest);
       await this.options.application?.online(context);
@@ -365,7 +449,14 @@ export class RoomLink {
     if (message.type === "stored") {
       const row = exact(message, ["v", "type", "digest", "seq", "duplicate"]);
       if (typeof row.digest !== "string" || !DIGEST.test(row.digest) || typeof row.seq !== "string" || !/^[1-9][0-9]{0,19}$/.test(row.seq) || typeof row.duplicate !== "boolean") fail();
+      const receipt = this.options.store.receiptSendable(this.options.name, row.digest);
+      if (receipt) {
+        this.options.store.markStored(this.options.name, row.digest, row.seq);
+        this.options.store.retireStoredReceipt(this.options.name, row.digest);
+      }
+      this.storedFrame(session, row.digest);
       this.options.application?.stored(this.context(session, local.current.digest), { digest: row.digest, seq: row.seq });
+      this.restoreReceipts(session);
       return; // Broker storage is not a signed recipient application-completion receipt.
     }
     if (message.type === "queue_ack") {
@@ -381,10 +472,17 @@ export class RoomLink {
       return;
     }
     if (message.type === "error") {
-      const error = exact(message, ["v", "type", "code"]);
+      const error = exact(message, Object.hasOwn(message, "digest") ? ["v", "type", "code", "digest"] : ["v", "type", "code"]);
+      if (error.digest !== undefined && (error.code !== "queue_full" || typeof error.digest !== "string" || !DIGEST.test(error.digest))) fail();
+      if (error.code === "queue_full") {
+        // Older brokers omit correlation; one frame in flight makes its head unambiguous.
+        const digest = typeof error.digest === "string" ? error.digest : session.outbound[0]?.digest;
+        if (digest) this.backoffFrame(session, digest);
+        return;
+      }
       // X2 declares these refusal controls nonterminal. Their unsigned control
       // cannot settle any application; its local ACK deadline records uncertainty.
-      if (error.code === "queue_full" || error.code === "replay_refused" || error.code === "unexpected_ack") return;
+      if (error.code === "replay_refused" || error.code === "unexpected_ack") return;
       fail("unavailable");
     }
     fail();
@@ -449,6 +547,7 @@ export class RoomLink {
       else throw error;
     }
     const acceptedDigest = await this.frameDigest(bytes);
+    session.processingFrame = acceptedDigest;
     const latest = this.frameCurrent(session, frame);
     if (latest.current.digest !== digest) refused = "trust_changed";
     if (result?.status === "stale") {
@@ -471,6 +570,8 @@ export class RoomLink {
       } else {
         const peers = presence(result.plaintext, sender.exposedPeers);
         this.current(session, digest);
+        session.pendingPresenceReplies.delete(frame.sender);
+        if (session.presenceAsked && session.pendingPresenceReplies.size === 0) session.requestPresenceReply = false;
         try { this.options.onPresence?.({ member: frame.sender, peers }); } catch { /* validated observation only */ }
         this.current(session, digest);
         this.options.store.settleInbox(this.options.name, acceptedDigest);
@@ -486,9 +587,32 @@ export class RoomLink {
     this.frameCurrent(session, frame);
     // This ACK only retires ciphertext from the broker queue. A durable refusal
     // or stale drop is never a signed recipient application-completion receipt.
-    this.send(session, encodeBrokerControl({ v: 1, type: "received", digest: acceptedDigest }));
+    this.retireFrame(session, frame, acceptedDigest);
+    session.processingFrame = undefined; session.acknowledgedFrame = undefined;
     await this.refreshPresenceIfCapacityFree().catch(() => undefined);
   }
+  private retireFrame(session: Session, frame: FrameWire, digest: string): void {
+    this.frameCurrent(session, frame);
+    // Final admission commits its receipt; deferred admission retains the durable inbox.
+    // Waiting for broker storage or deferred admission would pin capacity one indefinitely.
+    if (this.options.store.applicationReceipt(this.options.name, digest)
+      && !this.options.store.receiptStored(this.options.name, digest)) fail("unavailable");
+    this.send(session, encodeBrokerControl({ v: 1, type: "received", digest }));
+    session.acknowledgedFrame = digest;
+    this.pumpFrames(session);
+  }
+  private restoreReceipts(session: Session): void {
+    this.current(session);
+    this.options.store.expireReceipts(this.options.name);
+    for (const entry of this.options.store.outbox(this.options.name)) {
+      if (entry.kind !== "receipt" || session.outbound.some(frame => frame.digest === entry.digest)) continue;
+      if (session.outbound.length >= LIMITS.packets || session.outboundBytes + entry.wire.byteLength > LIMITS.queuedBytes) break;
+      const roster = this.current(session).current.digest;
+      this.queueFrame(session, entry.wire, entry.digest, false, () => this.publicationCurrent(session, roster), false,
+        () => this.options.store.receiptSendable(this.options.name, entry.digest), undefined,
+        entry.receiptFor === session.processingFrame ? entry.receiptFor : undefined);
+    }
+  }
   private async frameDigest(bytes: Uint8Array): Promise<string> {
     return encodeBase64url(await sha256(bytes));
   }
@@ -511,29 +635,86 @@ export class RoomLink {
   async publishApplication(message: RoomMessage, recipient: string, outgoing?: RoomOutgoingInput, current: () => boolean = () => true): Promise<string> {
     const plaintext = encodeRoomMessage(message), metadata = outgoing ? { ...outgoing } : undefined;
     const session = this.session;
-    if (!session || session.phase !== "ready") fail("unavailable");
+    if (!session || session.phase !== "ready") { if (metadata) throw new RoomNotSentError(); fail("unavailable"); }
     const digest = this.current(session).current.digest;
     const allowed = () => this.publicationCurrent(session, digest) && current();
-    return this.serialSend(async () => {
+    let queueStarted = false;
+    try {
+      let presenceWork: Promise<void> | undefined;
+      // A chat is the transport barrier for earlier observations. Receipts keep
+      // their durable-commit/ACK path and do not wait behind a new observation.
+      if (message.type === "chat" && this.republish) {
+        clearTimeout(this.republish); this.republish = undefined;
+        presenceWork = this.publishPresence();
+        // It may fail before reaching the serial lane. Observe rejection now;
+        // the reserved chat slot still awaits the original error below.
+        void presenceWork.catch(() => undefined);
+      }
+      // Reserve this chat's FIFO slot before yielding to the earlier observation.
+      return await this.serialSend(async () => {
+      if (presenceWork) await presenceWork;
       if (!allowed()) fail("state_changed");
+      if (metadata && (session.outbound.length >= LIMITS.packets || session.outboundBytes + plaintext.byteLength > LIMITS.queuedBytes
+        || session.ws.bufferedAmount > LIMITS.backpressure)) throw new RoomNotSentError();
+      if (message.type === "receipt") {
+        const pending = this.options.store.receiptStored(this.options.name, message.frame);
+        if (pending?.state === "dispatching") {
+          if (!decodeFrame(pending.wire).recipients.includes(recipient)) fail("untrusted");
+          this.restoreReceipts(session);
+          return pending.digest;
+        }
+      }
       const row = this.current(session, digest);
       if (!roomMembers(row.current).some(member => member.fingerprint === recipient) || recipient === this.options.store.identity.public.fingerprint) fail("untrusted");
-      const wire = await sealFrame({ epoch: row.current, identity: this.options.store.identity, recipients: [recipient], plaintext, sequence: this.options.store.sequence });
+      let wire = await sealFrame({ epoch: row.current, identity: this.options.store.identity, recipients: [recipient], plaintext, sequence: this.options.store.sequence });
       if (!allowed()) fail("state_changed");
-      const record = metadata ? await this.options.store.queueApplication(this.options.name, wire, metadata, allowed) : undefined;
-      const frameDigest = record?.digest ?? await this.frameDigest(wire);
+      let frameDigest: string;
+      if (metadata) {
+        queueStarted = true;
+        let record: Awaited<ReturnType<RoomStore["queueApplication"]>>;
+        try { record = await this.options.store.queueApplication(this.options.name, wire, metadata, allowed); }
+        catch (error) {
+          // An explicit atomic refusal plus absent durable intent is positive not-sent evidence.
+          if (error instanceof RoomStoreError && ["limit", "invalid", "untrusted", "state_changed"].includes(error.code)
+            && !this.options.store.applicationOutbox(this.options.name).some(row => row.deliveryId === metadata.deliveryId || row.application === metadata.application)) throw new RoomNotSentError();
+          throw error;
+        }
+        frameDigest = record.frameDigest ?? record.digest;
+      } else if (message.type === "receipt") {
+        const ttlMs = this.options.application?.receiptTtlMs?.(this.context(session, digest)) ?? RECEIPT_TTL_MS;
+        const receipt = await this.options.store.queueReceipt(this.options.name, message.frame, wire, { ttlMs, replaceExisting: true }, allowed);
+        if (!allowed()) fail("state_changed");
+        if (receipt.state === "accepted") return receipt.digest; // Existing broker-stored proof needs no pending wire slot.
+        frameDigest = receipt.digest; wire = receipt.wire;
+      } else frameDigest = await this.frameDigest(wire);
       if (!allowed()) fail("state_changed");
-      this.send(session, wire);
+      try {
+        this.queueFrame(session, wire, frameDigest, false, allowed, false,
+          metadata ? () => this.options.store.applicationSendable(this.options.name, frameDigest)
+            : message.type === "receipt" ? () => this.options.store.receiptSendable(this.options.name, frameDigest) : undefined,
+          undefined, message.type === "receipt" && message.frame === session.processingFrame ? message.frame : undefined);
+      } catch (error) {
+        // The durable outbox owns retry after local backpressure; this is no uncertainty.
+        if (!allowed() || !(error instanceof RoomLinkError) || error.code !== "limit" || !metadata && message.type !== "receipt") throw error;
+        if (session.outbound[0]?.digest === frameDigest) this.backoffFrame(session, frameDigest);
+      }
       return frameDigest;
-    });
+    }); } catch (error) {
+      if (metadata && !queueStarted) throw new RoomNotSentError();
+      throw error;
+    }
   }
   async publishPresence(): Promise<void> {
     const session = this.session;
     if (!session || session.phase !== "ready") return;
     if (this.publishing) { this.publishDirty = true; return; }
+    // Keep the already scheduled coalesced snapshot. Cancelling it on every
+    // state flip turns an awaited burst back into one durable seal per call.
+    if (this.republish && !this.replyPresence && !this.forcePresenceRequest) { this.publishDirty = true; return; }
     if (this.republish) clearTimeout(this.republish);
     this.republish = undefined; this.publishDirty = false;
-    const response = this.replyPresence && !this.forcePresenceRequest;
+    const forceRequest = this.forcePresenceRequest;
+    const response = this.replyPresence && !forceRequest;
     if (response) this.replyPresence = false;
     this.forcePresenceRequest = false;
     let sent = false;
@@ -549,17 +730,24 @@ export class RoomLink {
       await this.serialSend(async () => {
         if (!this.publicationCurrent(session, row.current.digest)) return;
         const requestReply = !response && session.requestPresenceReply;
-        const wire = await sealFrame({ epoch: row.current, identity, recipients, plaintext: canonicalBytes({ v: 1, type: "presence", peers, ...(requestReply ? { requestReply: true } : {}) }), sequence: this.options.store.sequence });
+        const presenceKey = JSON.stringify([row.current.digest, recipients, peers, requestReply]);
+        if (!response && !forceRequest && session.lastPresence === presenceKey) return;
+        const wire = await sealFrame({ epoch: row.current, identity, recipients, plaintext: canonicalBytes({ v: 1, type: "presence", peers, ...(requestReply ? { requestReply: true } : {}) }), ...(session.ephemeral ? { ephemeral: true as const } : {}), sequence: this.options.store.sequence });
         if (!this.publicationCurrent(session, row.current.digest)) return;
         // Machine-local exposure can change during reserve/encryption/signing even
         // when the signed roster is unchanged. Never emit an id it now withholds.
+        const frameDigest = await this.frameDigest(wire);
+        if (!this.publicationCurrent(session, row.current.digest)) return;
         const allowed = new Set(this.currentPresence(own.exposedPeers).map(peer => peer.id));
         if (peers.some(peer => !allowed.has(peer.id))) return;
-        this.send(session, wire); sent = true;
-        if (requestReply) {
-          session.requestPresenceReply = false;
-          if (this.retiredPresenceBytes && this.options.store.ordinaryInboxAvailable(this.options.name, this.retiredPresenceBytes)) this.retiredPresenceBytes = 0;
-        }
+        this.queueFrame(session, wire, frameDigest, requestReply,
+          () => this.publicationCurrent(session, row.current.digest) && peers.every(peer => this.currentPresence(own.exposedPeers).some(value => value.id === peer.id)), true, undefined,
+          requestReply ? () => {
+            if (!session.presenceAsked) { session.pendingPresenceReplies = new Set(recipients); session.presenceAsked = true; }
+            session.requestPresenceReply = session.pendingPresenceReplies.size > 0;
+            if (this.retiredPresenceBytes && this.options.store.ordinaryInboxAvailable(this.options.name, this.retiredPresenceBytes)) this.retiredPresenceBytes = 0;
+          } : undefined);
+        session.lastPresence = presenceKey; sent = true;
       });
     } catch (error) {
       this.retry(session); // Existing bounded reconnect, never a self-polling refresh retry.