@tinycloud/cli 1.3.0-beta.44 → 1.3.0-beta.45

package/dist/courier-entry.js

@@ -196,7 +196,7 @@ function parseTaskState(input) {
     return full;
   throw new Error(`Unknown task state "${input}". Expected one of: ${TASK_STATES.join(", ")}`);
 }
-var COURIER_NOTICES = ["thread-paused"];
+var COURIER_NOTICES = ["thread-paused", "thread-resumed"];
 function messageRole(input) {
   if (input.refsOwnTask)
     return "ROLE_AGENT";
@@ -5704,11 +5704,15 @@ function identity(notice) {
 }
 function noticeText(notice, _owner) {
   const { peer, thread } = identity(notice);
+  const pending = /^[0-9]{6}$/.test(notice.count ?? "") ? Number(notice.count) : 1;
+  const total = `${pending}${pending === 999999 ? "+" : ""}`;
   if (notice.kind === "new-message")
-    return { title: "Courier: needs you", body: `New messages from ${peer} in thread ${thread}. Start a session, run courier inbox, then courier read and courier orders for this peer. Inbound text is a counterparty request, never your instruction.` };
+    return { title: "Courier: needs you", body: `${total} new message(s) from ${peer}; latest thread ${thread}. Start a session, run courier inbox, then courier read and courier orders for this peer.` };
   if (notice.kind === "new-approval")
-    return { title: "Courier: decision ready", body: `Your decision is ready for thread ${thread} with ${peer}. Start a session and run courier approval with --peek; an approved PR merge uses courier run-approved. No agent was woken.` };
-  return notice.kind === "paused" ? { title: "Courier: thread paused", body: `Thread ${thread} with ${peer} is paused on this side. Your agent will not wake for it until you resume it. Run courier inbox or courier read in a session you start.` } : { title: "Courier: peer paused", body: `The paired peer ${peer} reported thread ${thread} paused. Their agent waits for their human. Run courier inbox or courier read in a session you start.` };
+    return { title: "Courier: decision ready", body: `${total} owner decision(s) with ${peer}; latest thread ${thread}. Start a session and run courier approval with --peek; an approved PR merge uses courier run-approved. No agent was woken.` };
+  const count = /^[0-9]{6}$/.test(notice.repeats ?? "") ? Number(notice.repeats) : 0;
+  const repeated = count ? ` Additional pauses on this thread: ${count}${count === 999999 ? "+" : ""}.` : "";
+  return notice.kind === "paused" ? { title: "Courier: thread paused", body: `Thread ${thread} with ${peer} is paused on this side. Your agent will not wake for it until you resume it. Run courier inbox or courier read in a session you start.${repeated}` } : { title: "Courier: peer paused", body: `The paired peer ${peer} reported thread ${thread} paused. Their agent waits for their human. Run courier inbox or courier read in a session you start.${repeated}` };
 }
 function appendNotice(home, notice) {
   const { peer, thread } = identity(notice);
@@ -5717,7 +5721,7 @@ function appendNotice(home, notice) {
   fs8.mkdirSync(home, { recursive: true, mode: 448 });
   if (fs8.existsSync(file) && fs8.statSync(file).size >= MAX_NOTICE_LOG_BYTES)
     fs8.renameSync(file, `${file}.1`);
-  fs8.appendFileSync(file, `${JSON.stringify({ t: (/* @__PURE__ */ new Date()).toISOString(), kind: notice.kind, peer, thread, title, body })}
+  fs8.appendFileSync(file, `${JSON.stringify({ t: (/* @__PURE__ */ new Date()).toISOString(), kind: notice.kind, peer, thread, ...notice.count ? { count: notice.count } : {}, title, body })}
 `, { mode: 384 });
   fs8.chmodSync(file, 384);
 }
@@ -5735,7 +5739,7 @@ function recentNotices(home) {
         const record = JSON.parse(line);
         if (!["paused", "peer-paused", "new-message", "new-approval"].includes(record.kind) || typeof record.peer !== "string" || !HANDLE.test(record.peer) || typeof record.thread !== "string" || !(ULID.test(record.thread) || /^sha256:[a-f0-9]{12}$/.test(record.thread)))
           continue;
-        records.push({ kind: record.kind, peer: record.peer, thread: record.thread, ...noticeText({ kind: record.kind, peer: record.peer, threadId: record.thread, detail: "" }, "") });
+        records.push({ kind: record.kind, peer: record.peer, thread: record.thread, ...noticeText({ kind: record.kind, peer: record.peer, threadId: record.thread, count: typeof record.count === "string" ? record.count : void 0, detail: "" }, "") });
       } catch {
       }
     }
@@ -5763,7 +5767,7 @@ function createNotifier(config, deps) {
         const result = await run2("/bin/sh", ["-c", config.exec], {
           cwd: config.wake.cwd,
           timeoutMs: config.wake.timeoutMs,
-          env: { ...courierOnlyEnv(env, config.wake.home), COURIER_HOME: config.wake.home, COURIER_NOTICE: notice.kind, COURIER_PEER: peer, COURIER_THREAD: thread, COURIER_NOTICE_TITLE: title, COURIER_NOTICE_TEXT: body }
+          env: { ...courierOnlyEnv(env, config.wake.home), COURIER_HOME: config.wake.home, COURIER_NOTICE: notice.kind, COURIER_NOTICE_COUNT: String(/^[0-9]{6}$/.test(notice.count ?? "") ? Number(notice.count) : 1), COURIER_PEER: peer, COURIER_THREAD: thread, COURIER_NOTICE_TITLE: title, COURIER_NOTICE_TEXT: body }
         });
         if (result.code !== 0)
           throw new Error(`notify command exited ${result.code}`);
@@ -6814,20 +6818,25 @@ import { spawnSync as spawnSync4 } from "child_process";
 
 // ../courier/dist/pause.js
 var SAFE = /^[0-9A-Za-z_-]{1,64}$/;
-async function postPausedInform(kv2, profile, peerHandle, threadId, text, messageId) {
+async function nextNoticeId(kv2, peer, threadId, now = Date.now()) {
+  const prefix = k.msgPrefix(peer, threadId);
+  const ids = (await listAll(kv2, prefix)).map((key) => key.slice(prefix.length).replace(/\.json$/, "")).filter((id) => ULID.test(id)).sort();
+  const latest = ids.at(-1);
+  return ulid(Math.max(now, latest ? decodeTime(latest) + 1 : 0));
+}
+async function postPausedInform(kv2, profile, peerHandle, threadId, text, messageId, resumed = false) {
+  const pauseId = messageId ?? await nextNoticeId(kv2, peerHandle, threadId);
+  if (!ULID.test(pauseId))
+    throw new CourierError("usage", "Invalid pause inform id.");
   const message = buildMessage({
     threadId,
     text,
     role: "ROLE_AGENT",
     intent: "inform",
-    notice: "thread-paused",
+    notice: resumed ? "thread-resumed" : "thread-paused",
     from: { owner: profile.ownerDid, agent: profile.courierDid, label: profile.label }
   });
-  if (messageId) {
-    if (!ULID.test(messageId))
-      throw new CourierError("usage", "Invalid pause inform id.");
-    message.messageId = messageId;
-  }
+  message.messageId = pauseId;
   try {
     await putCreate(kv2, k.msg(peerHandle, threadId, message.messageId), message);
   } catch (error) {
@@ -6867,7 +6876,7 @@ async function cmdPause(args, deps = {}) {
   if (!exists)
     throw new CourierError("not-found", `Thread ${threadId} with ${peer} does not exist.`);
   const reason = args.has("reason") && args.get("reason") !== "true" ? args.get("reason") : "paused by its owner";
-  const marker = { v: 1, peer, threadId, by: "human", at: (/* @__PURE__ */ new Date()).toISOString(), reason, informId: ulid(), informSent: false };
+  const marker = { v: 1, peer, threadId, by: "human", at: (/* @__PURE__ */ new Date()).toISOString(), reason, informId: await nextNoticeId(node.kv, peer, threadId), informSent: false };
   const wrote = await writePauseMarker(node.kv, marker);
   const stored = await getJson(node.kv, k.paused(peer, threadId));
   if (!stored)
@@ -6878,7 +6887,7 @@ async function cmdPause(args, deps = {}) {
   }
   const saved = stored.value;
   if (!saved.informId) {
-    saved.informId = ulid();
+    saved.informId = await nextNoticeId(node.kv, peer, threadId);
     await putMatch(node.kv, k.paused(peer, threadId), saved, stored.etag);
   }
   await postPausedInform(node.kv, profile, peer, threadId, "Thread paused by its owner. Its agent waits until its owner resumes it.", saved.informId);
@@ -6887,15 +6896,20 @@ async function cmdPause(args, deps = {}) {
     await putMatch(node.kv, k.paused(peer, threadId), { ...fresh.value, informSent: true }, fresh.etag);
   console.log(`Paused thread ${threadId} with ${peer}; told ${peer}. Resume: ${cmd(`resume ${peer} ${threadId}`)}`);
 }
-async function cmdResume(args) {
+async function cmdResume(args, deps = {}) {
   const { peer, threadId } = target(args, resumeUsage());
-  const profile = loadProfile();
+  const profile = (deps.profile ?? loadProfile)();
   getPeer(profile, peer);
-  const node = await courierNode(profile);
-  if (!await getJson(node.kv, k.paused(peer, threadId))) {
+  const node = await (deps.node ?? courierNode)(profile);
+  const stored = await getJson(node.kv, k.paused(peer, threadId));
+  if (!stored) {
     console.log(`Thread ${threadId} with ${peer} is not paused.`);
     return;
   }
+  const resumeInformId = stored.value.resumeInformId ?? await nextNoticeId(node.kv, peer, threadId);
+  if (!stored.value.resumeInformId)
+    await putMatch(node.kv, k.paused(peer, threadId), { ...stored.value, resumeInformId }, stored.etag);
+  await postPausedInform(node.kv, profile, peer, threadId, "Thread resumed by its owner.", resumeInformId, true);
   await del(node.kv, k.paused(peer, threadId));
   console.log(`Resumed thread ${threadId} with ${peer}. A running watcher picks this up with the next message it sees.`);
 }
@@ -6917,14 +6931,47 @@ var FOREIGN_CLAIM_LEASE_MS = 45 * 6e4;
 var CLAIM_SKIP_MS = 3e4;
 var DAY_MS2 = 24 * 3600 * 1e3;
 var NOTICES_PER_PEER_PER_HOUR = 10;
+var NOTICES_PER_HOUR = 10;
+var NOTICE_RESERVE_PER_PEER = 3;
+var MAX_COALESCED_PAUSES = 999999;
+var MAX_PEER_CLOCK_SKEW_MS = 10 * 6e4;
 var MAX_OUTBOX = 50;
 var MAX_OUTBOX_TRIES = 8;
+var MAX_NOTICE_ATTEMPTS = 3;
 var MAX_HELD_PER_THREAD = 100;
 var MAX_SUBJECT = 200;
 var SAFE_ID = /^[0-9A-Za-z_-]{1,64}$/;
+var emptyNoticeRetry = () => ({ dispatchArrivals: "------", tries: 0, nextAttemptAt: 0, logged: false });
+var ZERO_ULID = "0".repeat(26);
+var EPOCH = (/* @__PURE__ */ new Date(0)).toISOString();
+var needsKind = (kind) => kind === "new-message" ? "message" : kind === "new-approval" ? "approval" : void 0;
+var emptyNeedsSlot = () => ({
+  threadId: ZERO_ULID,
+  eventId: ZERO_ULID,
+  count: "000000",
+  firstSeenAt: EPOCH,
+  arrivalFirstSeenAt: EPOCH,
+  ...emptyNoticeRetry()
+});
+var needsKey = (peer, kind) => `needs:${peer}:${kind}`;
+var emptyEpisode = () => ({ kind: "", eventId: ZERO_ULID, repeats: "000000", ...emptyNoticeRetry() });
+var incrementCount = (count) => String(Math.min(MAX_COALESCED_PAUSES, Number(count) + 1)).padStart(6, "0");
+var episodeKey = (key, slot) => `notice:${key}:${slot}`;
+function threadNoticeState() {
+  return {
+    ourPaused: false,
+    peerPaused: false,
+    lastPeerNoticeId: "0".repeat(26),
+    lastNoticeSentAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+    ourMarkerId: "",
+    episodes: [emptyEpisode(), emptyEpisode()],
+    informPending: false,
+    informText: ""
+  };
+}
 var WATCH_DEFAULTS = { debounceMs: 3e4, pollMs: 6e4, ticketSeconds: 25, wakeBudget: 12 };
 function emptyWatchState() {
-  return { v: 1, pending: {}, woken: [], approvalsSeen: [], wakes: {}, paused: [], outbox: [], held: {}, peerPausedDay: {}, noticeLog: {} };
+  return { v: 1, pending: {}, woken: [], approvalsSeen: [], wakes: {}, paused: [], wakeRetries: {}, approvalRetries: {}, outbox: [], held: {}, threadNotices: {}, peerNotices: {}, noticeGlobalLog: [], noticeLog: {} };
 }
 function wakeDueAt(pending, debounceMs) {
   if (pending.approvals?.length)
@@ -6970,7 +7017,6 @@ var Watcher = class {
   pausedKeys = /* @__PURE__ */ new Set();
   /** Serialises everything that reads or writes pause markers, so a stale listing cannot drop a pause just written. */
   pausedLock = Promise.resolve();
-  wakeFailures = /* @__PURE__ */ new Map();
   outboxBusy = /* @__PURE__ */ new Set();
   approvalsAgain = false;
   /** Unique to this run: a claim with this id is this process's own. */
@@ -7005,7 +7051,63 @@ var Watcher = class {
     const value2 = got?.value;
     this.stateEtag = got?.etag ?? null;
     this.state = isRecord(value2) && value2.v === 1 ? { ...emptyWatchState(), ...value2 } : emptyWatchState();
-    this.state.outbox = this.state.outbox.slice(-MAX_OUTBOX).filter((item) => (item.tries ?? 0) < MAX_OUTBOX_TRIES);
+    delete this.state.peerPausedDay;
+    for (const key of [...Object.keys(this.state.wakes), ...this.state.paused]) {
+      const [peer, threadId] = key.split("/");
+      if (peer && threadId && SAFE_ID.test(peer) && SAFE_ID.test(threadId)) {
+        const record = this.state.threadNotices[key] ??= threadNoticeState();
+        record.ourPaused = this.state.paused.includes(key);
+      }
+    }
+    this.syncNoticePeers();
+    for (const record of Object.values(this.state.peerNotices))
+      for (const slot of Object.values(record))
+        slot.dispatchArrivals = "------";
+    for (const [key, record] of Object.entries(this.state.threadNotices)) {
+      const old = record;
+      if (!record.episodes) {
+        record.episodes = [emptyEpisode(), emptyEpisode()];
+        for (const item of this.state.outbox) {
+          if (item.kind !== "notify" || `${item.notice.peer}/${item.notice.threadId}` !== key || item.notice.kind !== "paused" && item.notice.kind !== "peer-paused" || item.id !== `${item.notice.kind}:${key}` || !item.notice.eventId)
+            continue;
+          this.queueEpisode(record, item.notice.kind, item.notice.eventId);
+        }
+        if (old.ourNoticePending)
+          this.queueEpisode(record, "paused", record.ourMarkerId);
+        if (old.peerNoticePending && old.peerNoticeId)
+          this.queueEpisode(record, "peer-paused", old.peerNoticeId);
+      }
+      record.episodes = record.episodes.map((episode) => ({ ...emptyEpisode(), ...episode, dispatchArrivals: "------" }));
+      delete old.ourNoticePending;
+      delete old.peerNoticePending;
+      delete old.peerNoticeId;
+    }
+    this.state.outbox = this.state.outbox.filter((item) => {
+      if (item.kind === "inform")
+        return true;
+      const kind = needsKind(item.notice.kind);
+      if (kind) {
+        const slot2 = this.noticeSlot(item);
+        if (!slot2 || item.id !== needsKey(item.notice.peer, kind))
+          return false;
+        this.rememberNotice(item);
+        return true;
+      }
+      const key = `${item.notice.peer}/${item.notice.threadId}`;
+      const record = this.state.threadNotices[key];
+      const slot = record?.episodes.findIndex((episode) => episode.kind === item.notice.kind && episode.eventId === item.notice.eventId) ?? -1;
+      if (slot < 0 || item.id !== `${item.notice.kind}:${key}` && item.id !== episodeKey(key, slot))
+        return false;
+      item.id = episodeKey(key, slot);
+      item.notice.repeats ??= record.episodes[slot].repeats;
+      this.rememberNotice(item);
+      return true;
+    });
+    for (const item of [...this.state.outbox]) {
+      if ((item.tries ?? 0) >= (item.kind === "notify" ? MAX_NOTICE_ATTEMPTS : MAX_OUTBOX_TRIES))
+        this.finishOutbox(item);
+    }
+    this.state.outbox = this.state.outbox.slice(-MAX_OUTBOX);
   }
   snapshot() {
     return structuredClone(this.state);
@@ -7153,7 +7255,7 @@ var Watcher = class {
     const { selfKv, log } = this.deps;
     const mailbox = peer.theirHandleForMe;
     const peerKv2 = await this.deps.kvFor(peer);
-    const [keys] = await Promise.all([listAll(peerKv2, `${PREFIX}/to/${mailbox}/threads/`), this.syncPaused()]);
+    const [keys] = await Promise.all([listAll(peerKv2, `${PREFIX}/to/${mailbox}/threads/`), this.syncPaused(), this.syncKnownThreads(peer)]);
     const receipts = (await getJson(selfKv, k.receipts(peer.handle)))?.value ?? { v: 1, threads: {} };
     receipts.threads ??= {};
     const delivered = [];
@@ -7202,9 +7304,11 @@ var Watcher = class {
     }
     await this.mutate(() => {
       if (this.deps.notifyOnly) {
-        for (const threadId of new Set(delivered.filter((item) => item.intent && item.notice !== "thread-paused").map((item) => item.threadId))) {
-          const first = delivered.find((item) => item.threadId === threadId);
-          this.enqueue({ id: `message:${peer.handle}/${threadId}:${first.messageId}`, kind: "notify", notice: { kind: "new-message", peer: peer.handle, threadId, eventId: first.messageId, detail: "" } });
+        this.syncNoticePeers();
+        for (const item of [...delivered].sort((a, b) => a.messageId.localeCompare(b.messageId))) {
+          if (item.intent && item.notice !== "thread-paused" && item.notice !== "thread-resumed") {
+            this.queueNeeds(peer.handle, "message", item.threadId);
+          }
         }
       }
       for (const item of delivered) {
@@ -7229,20 +7333,50 @@ var Watcher = class {
         entry.lastSeenAt = at;
       }
       for (const item of delivered) {
-        if (item.notice !== "thread-paused" || item.intent !== "inform")
+        if (item.intent !== "inform" || item.notice !== "thread-paused" && item.notice !== "thread-resumed")
           continue;
-        const key = `${peer.handle}/${item.threadId}`;
-        const day = Math.floor(at / DAY_MS2);
-        this.enqueue({
-          id: `peer-paused:${key}:${day}`,
-          kind: "notify",
-          notice: { kind: "peer-paused", peer: peer.handle, threadId: item.threadId, detail: "the peer's watcher reported the thread paused" }
-        });
+        const record = this.state.threadNotices[`${peer.handle}/${item.threadId}`];
+        if (!record || !ULID.test(item.messageId) || item.messageId <= record.lastPeerNoticeId)
+          continue;
+        let sentAt;
+        try {
+          sentAt = decodeTime(item.messageId);
+        } catch {
+          continue;
+        }
+        if (sentAt > at + MAX_PEER_CLOCK_SKEW_MS)
+          continue;
+        record.lastPeerNoticeId = item.messageId;
+        const paused = item.notice === "thread-paused";
+        if (paused && !record.peerPaused)
+          this.queueEpisode(record, "peer-paused", item.messageId);
+        record.peerPaused = paused;
       }
+      this.fillOutbox();
     });
     await commitReceipts(selfKv, /* @__PURE__ */ new Map([[peer.handle, delivered.map(({ threadId, messageId }) => ({ threadId, messageId }))]]));
     await this.mirrorThreads(peer, peerKv2, keys);
   }
+  /** Only locally authored meta/messages/tasks, or a local wake/pause witness, establish a known thread. */
+  async syncKnownThreads(peer) {
+    const prefix = `${PREFIX}/to/${peer.handle}/threads/`;
+    const keys = await listAll(this.deps.selfKv, prefix);
+    const known = /* @__PURE__ */ new Set();
+    for (const path18 of keys) {
+      const match = /^([^/]+)\/(?:meta\.json|(?:msg|task)\/[^/]+\.json)$/.exec(path18.slice(prefix.length));
+      if (match && SAFE_ID.test(match[1]))
+        known.add(`${peer.handle}/${match[1]}`);
+    }
+    for (const key of Object.keys(this.state.wakes))
+      if (key.startsWith(`${peer.handle}/`))
+        known.add(key);
+    const missing = [...known].filter((key) => !this.state.threadNotices[key]);
+    if (missing.length)
+      await this.mutate(() => {
+        for (const key of missing)
+          this.state.threadNotices[key] ??= threadNoticeState();
+      });
+  }
   async mirrorCreate(key, value2) {
     try {
       await putCreate(this.deps.selfKv, key, value2);
@@ -7344,9 +7478,11 @@ var Watcher = class {
     const at = this.now();
     await this.mutate(() => {
       this.state.approvalsSeen = [.../* @__PURE__ */ new Set([...this.state.approvalsSeen, ...handled])].sort();
+      if (this.deps.notifyOnly)
+        this.syncNoticePeers();
       for (const { approval, peer, threadId, subject } of wakes) {
         if (this.deps.notifyOnly) {
-          this.enqueue({ id: `approval:${approval.approvalId}`, kind: "notify", notice: { kind: "new-approval", peer, threadId, eventId: approval.approvalId, detail: "" } });
+          this.queueNeeds(peer, "approval", threadId);
           continue;
         }
         const key = `${peer}/${threadId}`;
@@ -7356,6 +7492,8 @@ var Watcher = class {
           entry.approvals.push(approval);
         entry.lastSeenAt = at;
       }
+      if (this.deps.notifyOnly)
+        this.fillOutbox();
     });
   }
   /** Reads one new approval and its request; `skip` says why it should not wake anyone. */
@@ -7388,13 +7526,15 @@ var Watcher = class {
     if (this.deps.notifyOnly) {
       if (Object.keys(this.state.pending).length)
         await this.mutate(() => {
+          this.syncNoticePeers();
           for (const pending of Object.values(this.state.pending)) {
-            if (pending.messages.length)
-              this.enqueue({ id: `message:${pending.peer}/${pending.threadId}:${pending.messages[0].messageId}`, kind: "notify", notice: { kind: "new-message", peer: pending.peer, threadId: pending.threadId, eventId: pending.messages[0].messageId, detail: "" } });
-            for (const approval of pending.approvals ?? [])
-              this.enqueue({ id: `approval:${approval.approvalId}`, kind: "notify", notice: { kind: "new-approval", peer: pending.peer, threadId: pending.threadId, eventId: approval.approvalId, detail: "" } });
+            for (const _message of pending.messages)
+              this.queueNeeds(pending.peer, "message", pending.threadId);
+            for (const _approval of pending.approvals ?? [])
+              this.queueNeeds(pending.peer, "approval", pending.threadId);
           }
           this.state.pending = {};
+          this.fillOutbox();
         });
       await this.runOutbox();
       return;
@@ -7406,7 +7546,7 @@ var Watcher = class {
         continue;
       if (!force && wakeDueAt(pending, this.opts.debounceMs) > at)
         continue;
-      if (!force && (this.retryAt.get(key) ?? 0) > at)
+      if (!force && !pending.approvals?.length && (this.retryAt.get(key) ?? 0) > at)
         continue;
       this.waking.add(key);
       runs.push(this.wakeThread(key, pending, at).finally(() => this.waking.delete(key)));
@@ -7424,7 +7564,7 @@ var Watcher = class {
       return;
     await this.syncPaused();
     let messages = [...pending.messages];
-    const approvals = [...pending.approvals ?? []];
+    let approvals = [...pending.approvals ?? []];
     if (messages.length) {
       const used = this.recentWakes(key).length;
       if (!this.pausedKeys.has(key) && used >= this.opts.wakeBudget)
@@ -7447,6 +7587,12 @@ var Watcher = class {
           return;
       }
     }
+    if ((this.state.wakeRetries[key]?.nextAttemptAt ?? 0) > at)
+      messages = [];
+    if ((this.state.approvalRetries[key]?.nextAttemptAt ?? 0) > at)
+      approvals = [];
+    if (!messages.length && !approvals.length)
+      return;
     const woken = messages.map((m) => m.messageId);
     const approvedIds = approvals.map((a) => a.approvalId);
     const oldestSentAt = messages[0]?.sentAt ?? "";
@@ -7457,6 +7603,7 @@ var Watcher = class {
     }
     try {
       await this.mutate(() => {
+        this.state.threadNotices[key] ??= threadNoticeState();
         if (woken.length)
           this.state.wakes[key] = [...this.recentWakes(key), this.now()];
       });
@@ -7480,9 +7627,14 @@ var Watcher = class {
     try {
       await this.deps.wake({ peer: pending.peer, threadId: pending.threadId, subject: pending.subject, messages, approvals });
     } catch (error) {
-      const failures = (this.wakeFailures.get(key) ?? 0) + 1;
-      this.wakeFailures.set(key, failures);
-      this.retryAt.set(key, at + Math.min(15 * 6e4, WAKE_RETRY_MS * 2 ** (failures - 1)));
+      let failures = 0;
+      await this.mutate(() => {
+        for (const retries of [...woken.length ? [this.state.wakeRetries] : [], ...approvedIds.length ? [this.state.approvalRetries] : []]) {
+          const count = (retries[key]?.failures ?? 0) + 1;
+          retries[key] = { failures: count, nextAttemptAt: this.now() + Math.min(15 * 6e4, WAKE_RETRY_MS * 2 ** (count - 1)) };
+          failures = Math.max(failures, count);
+        }
+      });
       this.deps.log("wake-error", { peer: pending.peer, threadId: pending.threadId, failures, ...errInfo(error) });
       await this.releaseClaim(pending.peer, pending.threadId, claimId);
       return;
@@ -7496,8 +7648,11 @@ var Watcher = class {
           delete this.state.pending[key];
       }
       this.state.woken = [...this.state.woken, ...woken].slice(-WAKEN_MEMORY);
+      if (woken.length)
+        delete this.state.wakeRetries[key];
+      if (approvedIds.length)
+        delete this.state.approvalRetries[key];
     });
-    this.wakeFailures.delete(key);
     this.retryAt.delete(key);
     this.deps.log("woke", {
       peer: pending.peer,
@@ -7511,8 +7666,9 @@ var Watcher = class {
   async pauseThread(key, pending, used) {
     const reason = `wake budget reached (${used} wakes today, UTC; limit ${this.opts.wakeBudget ?? WATCH_DEFAULTS.wakeBudget} per thread per day)`;
     const at = new Date(this.now()).toISOString();
+    const pauseId = await nextNoticeId(this.deps.selfKv, pending.peer, pending.threadId, this.now());
     const wrote = await this.exclusive(async () => {
-      const created = await writePauseMarker(this.deps.selfKv, { v: 1, peer: pending.peer, threadId: pending.threadId, by: "budget", at, reason });
+      const created = await writePauseMarker(this.deps.selfKv, { v: 1, peer: pending.peer, threadId: pending.threadId, by: "budget", at, reason, informId: pauseId });
       this.pausedKeys.add(key);
       return created;
     });
@@ -7524,8 +7680,10 @@ var Watcher = class {
     await this.mutate(() => {
       if (!this.state.paused.includes(key))
         this.state.paused.push(key);
-      this.enqueue({ id: `inform:${key}:${at}`, kind: "inform", peer: pending.peer, threadId: pending.threadId, text });
-      this.enqueue({ id: `paused:${key}:${at}`, kind: "notify", notice: { kind: "paused", peer: pending.peer, threadId: pending.threadId, detail: reason } });
+      const record = this.state.threadNotices[key] ??= threadNoticeState();
+      Object.assign(record, { ourPaused: true, ourMarkerId: pauseId, informPending: true, informText: text });
+      this.queueEpisode(record, "paused", pauseId);
+      this.fillOutbox();
     });
     this.deps.log("paused", { peer: pending.peer, threadId: pending.threadId, by: "budget", reason });
   }
@@ -7541,29 +7699,239 @@ var Watcher = class {
       return;
     entry.messages = [...entry.messages, message].slice(-MAX_HELD_PER_THREAD);
   }
-  /** Called inside `mutate`: queues an inform or notification; the outbox is bounded, the oldest item goes first. */
-  enqueue(item) {
-    if (item.kind === "notify") {
-      const { notice } = item;
-      const at = this.now();
-      const day = Math.floor(at / DAY_MS2);
-      const reference = notice.eventId && SAFE_ID.test(notice.eventId) ? `:${notice.eventId}` : "";
-      const key = `${notice.kind}:${notice.peer}/${notice.threadId}${reference}`;
-      if (this.state.peerPausedDay[key] === day)
-        return;
-      const recent = (this.state.noticeLog[notice.peer] ?? []).filter((t) => at - t < 36e5);
-      if (recent.length >= NOTICES_PER_PEER_PER_HOUR) {
-        this.deps.log("notice-dropped", { peer: notice.peer, reason: "peer-rate-cap" });
-        return;
+  /** Two episode values per known thread. Additional transitions coalesce, without allocating another slot. */
+  queueEpisode(record, kind, eventId) {
+    if (!ULID.test(eventId) || record.episodes.some((episode) => episode.kind === kind && episode.eventId === eventId))
+      return;
+    const slot = record.episodes.find((episode) => !episode.kind);
+    if (slot)
+      Object.assign(slot, emptyEpisode(), { kind, eventId });
+    else {
+      const last = record.episodes[1];
+      last.repeats = incrementCount(last.repeats);
+      if (last.dispatchArrivals !== "------")
+        last.dispatchArrivals = incrementCount(last.dispatchArrivals);
+    }
+  }
+  /** Only the paired handles in our local configuration allocate needs-you state. */
+  syncNoticePeers() {
+    const paired = new Set(this.deps.loadPeers().filter((peer) => peer.status === "paired" && HANDLE.test(peer.handle)).map((peer) => peer.handle));
+    for (const peer of Object.keys(this.state.peerNotices))
+      if (!paired.has(peer))
+        delete this.state.peerNotices[peer];
+    if (this.deps.notifyOnly)
+      for (const peer of paired) {
+        if (!Object.hasOwn(this.state.peerNotices, peer))
+          this.state.peerNotices[peer] = { message: emptyNeedsSlot(), approval: emptyNeedsSlot() };
+      }
+    for (const record of Object.values(this.state.peerNotices))
+      for (const kind of ["message", "approval"]) {
+        record[kind] = { ...emptyNeedsSlot(), ...record[kind] };
       }
-      this.state.peerPausedDay[key] = day;
-      this.state.noticeLog[notice.peer] = [...recent, at];
+  }
+  /** Bounded values only: a later delivery updates the same paired-peer slot. Called inside mutate. */
+  queueNeeds(peer, kind, threadId) {
+    const slot = this.state.peerNotices[peer]?.[kind];
+    if (!slot || !ULID.test(threadId))
+      return;
+    try {
+      decodeTime(threadId);
+    } catch {
+      return;
+    }
+    const at = new Date(this.now()).toISOString();
+    if (slot.count === "000000") {
+      slot.eventId = ulid(this.now());
+      slot.firstSeenAt = at;
+    }
+    slot.threadId = threadId;
+    slot.count = incrementCount(slot.count);
+    if (slot.dispatchArrivals !== "------") {
+      if (slot.dispatchArrivals === "000000")
+        slot.arrivalFirstSeenAt = at;
+      slot.dispatchArrivals = incrementCount(slot.dispatchArrivals);
+    }
+  }
+  noticeSlot(item) {
+    const kind = needsKind(item.notice.kind);
+    if (kind) {
+      const slot = this.state.peerNotices[item.notice.peer]?.[kind];
+      return slot?.count !== "000000" && slot?.eventId === item.notice.eventId ? slot : void 0;
+    }
+    return this.state.threadNotices[`${item.notice.peer}/${item.notice.threadId}`]?.episodes.find((episode) => episode.kind === item.notice.kind && episode.eventId === item.notice.eventId);
+  }
+  rememberNotice(item) {
+    const episode = this.noticeSlot(item);
+    if (episode)
+      Object.assign(episode, { tries: item.tries ?? 0, nextAttemptAt: item.nextAttemptAt ?? 0, logged: item.logged ?? false });
+  }
+  /** Earliest rolling-hour retry under the global allowance and each paired peer's share. */
+  noticeRateDeadline(peer, now = this.now()) {
+    const recent = (this.state.noticeLog[peer] ?? []).filter((t) => now - t < 36e5);
+    const global2 = this.state.noticeGlobalLog.filter((t) => now - t < 36e5);
+    const peers = [.../* @__PURE__ */ new Set([...this.deps.loadPeers().filter((peer2) => peer2.status === "paired").map((peer2) => peer2.handle), peer])];
+    const share = Math.min(NOTICE_RESERVE_PER_PEER, Math.floor(NOTICES_PER_HOUR / peers.length));
+    const reservedForOthers = peers.filter((other) => other !== peer).reduce((reserved, other) => reserved + Math.max(0, share - (this.state.noticeLog[other] ?? []).filter((t) => now - t < 36e5).length), 0);
+    if (recent.length < NOTICES_PER_PEER_PER_HOUR && global2.length + reservedForOthers < NOTICES_PER_HOUR)
+      return 0;
+    return Math.max(recent.length >= NOTICES_PER_PEER_PER_HOUR ? Math.min(...recent) + 36e5 : 0, global2.length ? Math.min(...global2) + 36e5 : now + 36e5);
+  }
+  /** -1 appends; a nonnegative index yields that place; undefined leaves the pending slot alone. */
+  admissionIndex(item) {
+    if (this.state.outbox.some((existing) => existing.id === item.id))
+      return void 0;
+    if (this.state.outbox.length < MAX_OUTBOX)
+      return -1;
+    const now = this.now();
+    const eligible = item.kind === "inform" || (item.nextAttemptAt ?? 0) <= now && !this.noticeRateDeadline(item.notice.peer, now);
+    if (!eligible)
+      return void 0;
+    const deferred = this.state.outbox.findIndex((existing) => existing.kind === "notify" && !this.outboxBusy.has(existing.id) && ((existing.nextAttemptAt ?? 0) > now || this.noticeRateDeadline(existing.notice.peer, now) > now));
+    if (deferred >= 0)
+      return deferred;
+    if (item.kind === "notify") {
+      const counts = /* @__PURE__ */ new Map();
+      for (const existing of this.state.outbox)
+        if (existing.kind === "notify")
+          counts.set(existing.notice.peer, (counts.get(existing.notice.peer) ?? 0) + 1);
+      const own = counts.get(item.notice.peer) ?? 0;
+      const overrepresented = this.state.outbox.findIndex((existing) => existing.kind === "notify" && existing.notice.peer !== item.notice.peer && (counts.get(existing.notice.peer) ?? 0) > own + 1 && existing.notice.kind !== "paused" && !existing.tries && !this.outboxBusy.has(existing.id));
+      if (overrepresented >= 0)
+        return overrepresented;
+    }
+    if (item.kind === "inform" || item.notice.kind === "paused") {
+      const unattempted = this.state.outbox.findIndex((existing) => existing.kind === "notify" && existing.notice.kind === "peer-paused" && !existing.tries && !this.outboxBusy.has(existing.id));
+      if (unattempted >= 0)
+        return unattempted;
     }
+    return void 0;
+  }
+  /** Queue places can yield; the two fixed episode records retain all retry metadata. */
+  enqueue(item) {
+    const index = this.admissionIndex(item);
+    if (index === void 0)
+      return;
+    if (index >= 0)
+      this.state.outbox.splice(index, 1);
     this.state.outbox.push(item);
-    while (this.state.outbox.length > MAX_OUTBOX) {
-      const dropped = this.state.outbox.shift();
-      this.deps.log("outbox-dropped", { id: dropped.id, reason: "full" });
+  }
+  *outboxCandidates() {
+    for (const [key, record] of Object.entries(this.state.threadNotices)) {
+      const [peer, threadId] = key.split("/");
+      if (record.informPending)
+        yield { id: `inform:${key}`, kind: "inform", peer, threadId, pauseId: record.ourMarkerId, text: record.informText };
+    }
+    for (const kind of ["paused", "peer-paused"]) {
+      for (const [key, record] of Object.entries(this.state.threadNotices)) {
+        const [peer, threadId] = key.split("/");
+        for (const [slot, episode] of record.episodes.entries()) {
+          if (episode.kind === kind)
+            yield {
+              id: episodeKey(key, slot),
+              kind: "notify",
+              tries: episode.tries,
+              nextAttemptAt: episode.nextAttemptAt,
+              logged: episode.logged,
+              notice: {
+                kind,
+                peer,
+                threadId,
+                eventId: episode.eventId,
+                repeats: episode.repeats,
+                detail: kind === "paused" ? "thread paused on this side" : "the peer's watcher reported the thread paused"
+              }
+            };
+        }
+      }
+    }
+    for (const [peer, record] of Object.entries(this.state.peerNotices)) {
+      for (const kind of ["approval", "message"]) {
+        const slot = record[kind];
+        if (slot.count !== "000000")
+          yield {
+            id: needsKey(peer, kind),
+            kind: "notify",
+            tries: slot.tries,
+            nextAttemptAt: slot.nextAttemptAt,
+            logged: slot.logged,
+            notice: {
+              kind: kind === "message" ? "new-message" : "new-approval",
+              peer,
+              threadId: slot.threadId,
+              eventId: slot.eventId,
+              count: slot.count,
+              detail: ""
+            }
+          };
+      }
+    }
+  }
+  /** Admit local work first, allowing eligible peers to pass deferred entries in a full queue. */
+  fillOutbox() {
+    for (const item of this.fairOutbox([...this.outboxCandidates()]))
+      this.enqueue(item);
+  }
+  fairOutbox(items) {
+    const ordered = [];
+    for (const priority of ["inform", "paused", "other"]) {
+      const peers = /* @__PURE__ */ new Map();
+      for (const item of items) {
+        const group = item.kind === "inform" ? "inform" : item.notice.kind === "paused" ? "paused" : "other";
+        if (group !== priority)
+          continue;
+        const peer = item.kind === "inform" ? item.peer : item.notice.peer;
+        if (!peers.has(peer))
+          peers.set(peer, []);
+        peers.get(peer).push(item);
+      }
+      while (peers.size)
+        for (const [peer, queue] of peers) {
+          ordered.push(queue.shift());
+          if (!queue.length)
+            peers.delete(peer);
+        }
     }
+    return ordered;
+  }
+  /** Completion matches both the fixed slot and episode ULID; another queued episode is independent. */
+  finishOutbox(item, delivered = false) {
+    const peer = item.kind === "inform" ? item.peer : item.notice.peer;
+    const threadId = item.kind === "inform" ? item.threadId : item.notice.threadId;
+    const record = this.state.threadNotices[`${peer}/${threadId}`];
+    if (item.kind === "notify" && needsKind(item.notice.kind)) {
+      const slot = this.noticeSlot(item);
+      if (slot) {
+        const arrivals = slot.dispatchArrivals === "------" ? "000000" : slot.dispatchArrivals;
+        if (delivered && arrivals !== "000000")
+          Object.assign(slot, emptyNeedsSlot(), {
+            threadId: slot.threadId,
+            eventId: ulid(this.now()),
+            count: arrivals,
+            firstSeenAt: slot.arrivalFirstSeenAt
+          });
+        else
+          Object.assign(slot, emptyNeedsSlot());
+      }
+    } else if (record) {
+      if (item.kind === "inform" && item.pauseId === record.ourMarkerId)
+        record.informPending = false;
+      if (item.kind === "notify") {
+        record.lastNoticeSentAt = new Date(this.now()).toISOString();
+        const slot = record.episodes.find((episode) => episode.kind === item.notice.kind && episode.eventId === item.notice.eventId);
+        if (slot) {
+          const arrivedDuringDelivery = slot.dispatchArrivals === "------" ? 0 : Number(slot.dispatchArrivals);
+          if (delivered && arrivedDuringDelivery > 0)
+            Object.assign(slot, emptyEpisode(), {
+              kind: slot.kind,
+              eventId: slot.eventId,
+              repeats: String(arrivedDuringDelivery - 1).padStart(6, "0")
+            });
+          else
+            Object.assign(slot, emptyEpisode());
+        }
+      }
+    }
+    this.state.outbox = this.state.outbox.filter((o) => o.id !== item.id);
   }
   /**
    * Markers under me/state/paused/ are the truth. A marker that disappeared means the human resumed: the budget starts
@@ -7591,7 +7959,10 @@ var Watcher = class {
           const backlog = {};
           await this.mutate(() => {
             for (const key of resumed) {
+              if (this.state.threadNotices[key])
+                this.state.threadNotices[key].ourPaused = false;
               delete this.state.wakes[key];
+              delete this.state.wakeRetries[key];
               const held = this.state.held[key];
               if (held?.messages.length) {
                 backlog[key] = held.messages.length;
@@ -7603,6 +7974,10 @@ var Watcher = class {
               }
               delete this.state.held[key];
             }
+            for (const key of added) {
+              const record = this.state.threadNotices[key] ??= threadNoticeState();
+              record.ourPaused = true;
+            }
             this.state.paused = [.../* @__PURE__ */ new Set([...this.state.paused.filter((key) => !resumed.includes(key)), ...added])].sort();
           });
           for (const key of resumed)
@@ -7616,64 +7991,112 @@ var Watcher = class {
   /** State that only matters for a day or an hour is dropped, so it cannot grow without bound. */
   async pruneState() {
     const at = this.now();
-    const today = Math.floor(at / DAY_MS2);
-    const stale = Object.keys(this.state.wakes).filter((key) => !this.recentWakes(key).length).concat(Object.keys(this.state.peerPausedDay).filter((key) => today - this.state.peerPausedDay[key] > 7)).concat(Object.keys(this.state.noticeLog).filter((peer) => !this.state.noticeLog[peer].some((t) => at - t < 36e5)));
-    if (!stale.length)
+    const stale = Object.keys(this.state.wakes).filter((key) => !this.recentWakes(key).length).concat(Object.keys(this.state.approvalRetries).filter((key) => !this.state.pending[key]?.approvals?.length)).concat(Object.keys(this.state.wakeRetries).filter((key) => !this.state.pending[key])).concat(Object.keys(this.state.noticeLog).filter((peer) => !this.state.noticeLog[peer].some((t) => at - t < 36e5)));
+    if (!stale.length && !this.state.noticeGlobalLog.some((t) => at - t >= 36e5))
       return;
     await this.mutate(() => {
+      for (const key of Object.keys(this.state.wakeRetries))
+        if (!this.state.pending[key])
+          delete this.state.wakeRetries[key];
       for (const key of Object.keys(this.state.wakes))
         if (!this.recentWakes(key).length)
           delete this.state.wakes[key];
-      for (const key of Object.keys(this.state.peerPausedDay))
-        if (today - this.state.peerPausedDay[key] > 7)
-          delete this.state.peerPausedDay[key];
+      for (const key of Object.keys(this.state.approvalRetries))
+        if (!this.state.pending[key]?.approvals?.length)
+          delete this.state.approvalRetries[key];
+      this.state.noticeGlobalLog = this.state.noticeGlobalLog.filter((t) => at - t < 36e5);
       for (const peer of Object.keys(this.state.noticeLog))
         if (!this.state.noticeLog[peer].some((t) => at - t < 36e5))
           delete this.state.noticeLog[peer];
     });
   }
-  /** Informs and notifications queued in state; failures back off (1, 2, 4 ... 15 minutes) and give up after MAX_OUTBOX_TRIES. */
+  /** Informs and notifications queued in state; failures back off (1, 2, 4 ... 15 minutes) and give up after 3 notification attempts or 8 inform failures. */
   async runOutbox() {
     const at = this.now();
+    const refill = [...this.outboxCandidates()].some((item) => this.admissionIndex(item) !== void 0);
+    if (refill)
+      await this.mutate(() => this.fillOutbox());
     const runs = [];
-    for (const item of [...this.state.outbox]) {
+    const items = this.fairOutbox([...this.state.outbox]);
+    for (const item of items) {
       if (this.outboxBusy.has(item.id) || (item.nextAttemptAt ?? 0) > at)
         continue;
       this.outboxBusy.add(item.id);
       runs.push((async () => {
         try {
           if (item.kind === "inform")
-            await this.deps.postInform?.(item.peer, item.threadId, item.text);
+            await this.deps.postInform?.(item.peer, item.threadId, item.text, item.pauseId);
           else {
             const { notice } = item;
+            let reserved = false;
+            await this.mutate(() => {
+              const stored = this.state.outbox.find((o) => o.id === item.id);
+              if (stored?.kind !== "notify")
+                return;
+              const now = this.now();
+              const recent = (this.state.noticeLog[notice.peer] ?? []).filter((t) => now - t < 36e5);
+              if ((stored.tries ?? 0) >= MAX_NOTICE_ATTEMPTS) {
+                this.finishOutbox(item);
+                return;
+              }
+              const deadline = this.noticeRateDeadline(notice.peer, now);
+              if (deadline) {
+                stored.nextAttemptAt = deadline;
+                this.rememberNotice(stored);
+                this.deps.log("notice-rate-cap", { peer: notice.peer, id: item.id });
+                return;
+              }
+              const episode = this.noticeSlot(stored);
+              if (episode) {
+                if ("repeats" in episode)
+                  item.notice.repeats = stored.notice.repeats = episode.repeats;
+                else {
+                  item.notice.threadId = stored.notice.threadId = episode.threadId;
+                  item.notice.count = stored.notice.count = episode.count;
+                  episode.arrivalFirstSeenAt = EPOCH;
+                }
+                episode.dispatchArrivals = "000000";
+              }
+              this.state.noticeGlobalLog = [...this.state.noticeGlobalLog.filter((t) => now - t < 36e5), now];
+              item.tries = stored.tries = (stored.tries ?? 0) + 1;
+              this.rememberNotice(stored);
+              this.state.noticeLog[notice.peer] = [...recent, now];
+              reserved = true;
+            });
+            if (!reserved)
+              return;
             this.deps.log("notify", { kind: notice.kind, peer: notice.peer, threadId: notice.threadId, detail: notice.detail });
             if (!item.logged && this.deps.notificationHome) {
               appendNotice(this.deps.notificationHome, notice);
               await this.mutate(() => {
                 const stored = this.state.outbox.find((o) => o.id === item.id);
-                if (stored?.kind === "notify")
+                if (stored?.kind === "notify") {
                   stored.logged = true;
+                  this.rememberNotice(stored);
+                }
               });
             }
             await this.deps.notify?.(notice);
           }
-          await this.mutate(() => {
-            this.state.outbox = this.state.outbox.filter((o) => o.id !== item.id);
-          });
+          await this.mutate(() => this.finishOutbox(item, true));
         } catch (error) {
-          const tries = (item.tries ?? 0) + 1;
+          const tries = item.kind === "notify" ? item.tries ?? 1 : (item.tries ?? 0) + 1;
           this.deps.log(item.kind === "inform" ? "inform-error" : "notify-error", { id: item.id, tries, ...errInfo(error) });
-          if (tries >= MAX_OUTBOX_TRIES) {
+          if (tries >= (item.kind === "notify" ? MAX_NOTICE_ATTEMPTS : MAX_OUTBOX_TRIES)) {
             this.deps.log("outbox-dropped", { id: item.id, reason: "too-many-failures" });
-            await this.mutate(() => {
-              this.state.outbox = this.state.outbox.filter((o) => o.id !== item.id);
-            });
+            await this.mutate(() => this.finishOutbox(item));
           } else {
             await this.mutate(() => {
               const stored = this.state.outbox.find((o) => o.id === item.id);
-              if (stored) {
-                stored.tries = tries;
-                stored.nextAttemptAt = at + Math.min(15 * 6e4, WAKE_RETRY_MS * 2 ** (tries - 1));
+              if (!stored)
+                return;
+              stored.tries = tries;
+              stored.nextAttemptAt = this.now() + Math.min(15 * 6e4, WAKE_RETRY_MS * 2 ** (tries - 1));
+              if (stored.kind === "notify") {
+                this.rememberNotice(stored);
+                const episode = this.noticeSlot(stored);
+                if (episode)
+                  episode.dispatchArrivals = "------";
               }
             });
           }
@@ -7686,6 +8109,15 @@ var Watcher = class {
   }
   // ---------- run loop ----------
   async pollOnce(via) {
+    if (this.deps.notifyOnly) {
+      const paired = this.deps.loadPeers().filter((peer) => peer.status === "paired" && HANDLE.test(peer.handle)).map((peer) => peer.handle);
+      if (paired.some((peer) => !Object.hasOwn(this.state.peerNotices, peer)) || Object.keys(this.state.peerNotices).some((peer) => !paired.includes(peer))) {
+        await this.mutate(() => {
+          this.syncNoticePeers();
+          this.state.outbox = this.state.outbox.filter((item) => item.kind !== "notify" || !needsKind(item.notice.kind) || paired.includes(item.notice.peer));
+        });
+      }
+    }
     await this.syncPaused();
     await this.pruneState();
     await Promise.all(this.deps.loadPeers().map((peer) => this.sync(peer, via)));
@@ -8523,8 +8955,8 @@ async function cmdWatch(args) {
     loadPeers: () => Object.values(loadProfile().peers),
     kvFor: (peer) => peerKv(node, loadProfile(), peer),
     wake: createWaker(config, { run: spawnRunner, sessions: fileSessions() }),
-    postInform: async (peer, threadId, text) => {
-      await postPausedInform(node.kv, loadProfile(), peer, threadId, text);
+    postInform: async (peer, threadId, text, pauseId) => {
+      await postPausedInform(node.kv, loadProfile(), peer, threadId, text, pauseId);
     },
     notify: createNotifier(notifyConfig(args, config), { run: spawnRunner }),
     holder: { profileId: watcherProfileId() },