@agfpd/iapeer 0.4.93 → 0.4.94

package/docs/19-notices.md

@@ -117,10 +117,10 @@ resets, the plan) — data, never our interpretation of the cause.
 | `summary` | string | one line, e.g. `boris · claude — rate_limit (Fable 5)` |
 | `content` | string | verbatim (claude) / rendered from typed fields (codex) |
 | `sessionId` | string? | correlates with the on-disk transcript |
-| `createdMs` | number | first detection |
-| `lastMs` | number | most recent detection folded in |
+| `createdMs` | number | first occurrence |
+| `lastMs` | number | latest OCCURRENCE (not the latest sweep that re-read it) |
 | `expiresMs` | number | TTL boundary |
-| `count` | number | detections folded into this notice (≥1) — render as `×N` |
+| `count` | number | distinct OCCURRENCES folded in (≥1) — how many times the peer actually hit the wall. Render as `×N`. The sweep window overlaps on purpose, so the same runtime event is re-read across passes; the board discriminates on the event's own timestamp, and a re-read never bumps this. |
 
 ### Snapshot
 
@@ -156,6 +156,12 @@ A mute peer re-emits its error on **every** attempted turn. So a notice carries
 a repeat detection only bumps `count` and `lastMs`: **no new id, no new log line, no new SSE
 event**. The owner sees one card saying `×7`, not seven cards.
 
+`count` means **occurrences, not sweeps**. The sweep window deliberately overlaps (so an event
+landing between two passes is never missed), which means the same transcript line is re-read on
+the next pass. The board therefore discriminates on the runtime event's OWN timestamp: a re-read
+of an already-counted event folds silently and bumps nothing. Without that, two real refusals
+would render as `×3` — a number the owner cannot check and that we would have made up.
+
 When the TTL passes (`IAPEER_NOTICE_TTL_MS`, default 1 h) the notice expires silently. If the
 peer is still broken, the next detection raises a **fresh** notice — a deliberate periodic
 reminder rather than one card that scrolls away forever. Expiry is not an event: either the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.93",
+  "version": "0.4.94",
   "description": "Run Claude Code and Codex CLI as local background agents that message each other, wake on demand, and share one memory.",
   "license": "Apache-2.0",
   "author": "agfpd",

package/src/daemon/mutewatch.ts

@@ -367,6 +367,9 @@ export function muteWatchTick(deps: MuteWatchDeps, sinceMs: number): { raised: n
         resetsAtMs: d.resetsAtMs,
         content: d.content,
         sessionId: d.sessionId,
+        // The runtime event's OWN timestamp — lets the board tell a new occurrence from the
+        // same line re-read by the deliberately-overlapping sweep window.
+        eventAtMs: d.atMs,
         summary: `${d.personality} · ${d.runtime} — ${d.errorType}${d.model ? ` (${d.model})` : ''}`,
       })
       if (!deduped) raised += 1

package/src/daemon/notices.ts

@@ -51,18 +51,27 @@ export interface NoticeInput {
   content: string
   /** The session that hit it (correlation with the transcript on disk). */
   sessionId?: string
+  /** When the underlying runtime event happened (the transcript line's own timestamp) —
+   *  NOT when we swept. This is what makes `count` mean OCCURRENCES rather than sweeps:
+   *  the sweep window deliberately overlaps, so the same line is re-read across passes.
+   *  Absent → every raise counts (the caller has no event clock to dedup against). */
+  eventAtMs?: number
 }
 
 export interface Notice extends NoticeInput {
   id: string
   summary: string
   dedupKey: string
+  /** First occurrence. */
   createdMs: number
-  /** Last time this same condition was re-detected (dedup bump). */
+  /** Latest OCCURRENCE (not the latest sweep that re-read it). */
   lastMs: number
   expiresMs: number
-  /** How many times the condition was detected while this notice stayed live (≥1). */
+  /** Distinct occurrences folded into this notice (≥1) — how many times the peer actually
+   *  hit the wall, which is what "×N" claims to the owner. */
   count: number
+  /** The newest event timestamp already counted — the overlap discriminator. */
+  lastEventMs?: number
 }
 
 export interface NoticeBoardOptions {
@@ -122,8 +131,16 @@ export class NoticeBoard {
     const dedupKey = noticeDedupKey(input)
     const existing = this.live.get(dedupKey)
     if (existing) {
-      existing.count += 1
-      existing.lastMs = nowMs
+      // Same condition. Is this a NEW occurrence, or the same runtime event re-read by an
+      // overlapping sweep? Counting the latter would inflate "×N" into a claim the owner
+      // cannot check — 2 real refusals rendering as ×3. Only a strictly newer event counts.
+      const at = input.eventAtMs
+      const isNewOccurrence = at === undefined || existing.lastEventMs === undefined || at > existing.lastEventMs
+      if (isNewOccurrence) {
+        existing.count += 1
+        existing.lastMs = nowMs
+        if (at !== undefined) existing.lastEventMs = at
+      }
       return { notice: existing, deduped: true }
     }
     const id = `n${++this.counter}`
@@ -137,6 +154,7 @@ export class NoticeBoard {
       lastMs: nowMs,
       expiresMs: nowMs + this.ttlMs,
       count: 1,
+      lastEventMs: input.eventAtMs,
     }
     this.live.set(dedupKey, notice)
     appendNoticeEvent(