switchroom 0.21.7 → 0.21.8

package/telegram-plugin/gateway/gateway.ts

@@ -979,6 +979,7 @@ import {
 } from './resume-inbound-builder.js'
 import { maybeQueueBootBriefing } from './boot-briefing-wiring.js'
 import { writePendingTurnEnv } from './pending-turn-env.js'
+import { shouldSkipBootResumeForGatewayOnlyRespawn, markBootResumeComplete } from './agent-process-liveness.js'
 import {
   createBridgeDeadWatchdog,
   consumeBridgeDeadEscalationMarker,
@@ -1655,8 +1656,8 @@ let pendingRedelivery: { turn: Turn; maxAgeMs: number } | null = null
 // #3038 cross-boot damper: consecutive bridge-dead escalations by PRIOR
 // boots (the consumed marker's `count`; 0 when no fresh marker). Set in
 // the boot block below, consumed by the watchdog constructor further down.
-let bridgeDeadPriorStreak = 0
-if (isGatewayMain) try {  // #2996 P0c: gated — opens bun:sqlite + writes .pending-turn.env
+let bridgeDeadPriorStreak = 0; let bootResumeThrew = false // #4641: set by the block's catch below. A SWALLOWED throw is not a completed boot resume — the reaper at the top of the block may already have durably stamped the in-flight turn `ended_via='restart'` while `bootResumeInbound` stayed null — so the generation token must not be stamped on that path. See "WHERE the token is stamped" in agent-process-liveness.ts. (Joined: gateway.ts sits at its line ratchet.)
+bootResumeInit: if (isGatewayMain) try {  // #2996 P0c: gated — opens bun:sqlite + writes .pending-turn.env
   // STATE_DIR is `<agentDir>/telegram` in production. openTurnsDb expects
   // the parent (agent dir) and joins `telegram/registry.db` itself.
   const agentDir = STATE_DIR.endsWith('/telegram')
@@ -1667,6 +1668,7 @@ if (isGatewayMain) try {  // #2996 P0c: gated — opens bun:sqlite + writes .pen
   // schema; subagents lives alongside in registry.db. Idempotent — safe on
   // pre-existing DBs (handles the jsonl_agent_id column migration).
   applySubagentsSchema(turnsDb)
+  if (shouldSkipBootResumeForGatewayOnlyRespawn(STATE_DIR)) break bootResumeInit // #4641: this container generation's boot resume is already done — ONLY the gateway respawned. The break skips ALL of: the orphan-turn reaper, consumeBridgeDeadEscalationMarker (already consumed by the gateway that stamped the token), the bridge-dead idle notice, the resume/report synthetic, the pendingRedelivery capture (the turn is still running and will answer itself — redelivering would double-send), the bridgeDeadPriorStreak seed for the #3038 cross-boot damper (left 0: the streak belongs to the gateway that consumed the marker, and re-seeding it here would double-count) and writePendingTurnEnv. Each is safe ONLY because the token proves one gateway already did it this generation; see "What `break bootResumeInit` skips" in agent-process-liveness.ts.
 
   // Read the turn-active marker (the in-flight turn the watchdog tracks)
   // BEFORE classifying — its mtime is "ms since last tool progress" and its
@@ -1948,14 +1950,13 @@ if (isGatewayMain) try {  // #2996 P0c: gated — opens bun:sqlite + writes .pen
     }
   }
 
-  // Diagnostic env file (one-shot, sourced by start.sh) — kept for the
-  // wake-audit context. The injected inbound above is the real wake signal;
-  // these vars are passive context only. Extracted to pending-turn-env.ts
-  // (atomic tmp+rename writer; never throws).
-  writePendingTurnEnv(agentDir, pending)
+  // Diagnostic env file (one-shot, sourced by start.sh) — kept for wake-audit
+  // context. The injected inbound above is the real wake signal; these vars are
+  // passive context only. pending-turn-env.ts: atomic writer, never throws.
+  writePendingTurnEnv(agentDir, pending) // #4641: the generation token is deliberately NOT stamped here. This block only builds `bootResumeInbound` IN MEMORY; the resume becomes crash-survivable ~8k lines below, at the `inboundSpool.put` — and that is where the stamp lives. See the comment at that call site.
 } catch (err) {
   process.stderr.write(`telegram gateway: turn-registry init failed (${(err as Error).message}) — turn tracking disabled\n`)
-  turnsDb = null
+  turnsDb = null; bootResumeThrew = true // #4641: swallow-and-continue must NOT stamp the token — see the declaration above.
 }
 
 /**
@@ -10167,6 +10168,7 @@ if (isGatewayMain && bootResumeInbound != null) {
     }
   }
 }
+if (isGatewayMain && !bootResumeThrew) markBootResumeComplete(STATE_DIR) // #4641 generation token, stamped HERE — AFTER the boot-resume inbound is durably spooled above, never at the tail of the `bootResumeInit` block (which only builds it in memory). Same ordering rule, same reason, as `markTurnResumed` directly above: a crash between the block and this line must leave NO token, so the successor re-mints the resume rather than suppressing it. Unconditional on whether there was anything to resume (a boot that found nothing still completed this generation's boot resume) but NOT on success: a swallowed throw in the block (`bootResumeThrew`) leaves the token unstamped, because the reaper may have durably stamped a turn `ended_via='restart'` that then never got spooled. Full argument: "WHERE the token is stamped" in agent-process-liveness.ts. (One line: gateway.ts sits at its line ratchet — scripts/gateway-line-ratchet.txt.)
 // Boot-replay: re-queue every un-acked spooled inbound into the
 // in-memory buffer so the existing drain triggers (onClientRegistered
 // / silence-poke #1546 / idle-drain #1549) deliver them. push →
@@ -11633,14 +11635,14 @@ if (isGatewayMain) ipcServer = createIpcServer({
   // fall inside the source slice send-outbound-wiring.test.ts takes between
   // onSendOutbound and onQuotaWallDetected.
   onPostSkillProposal(_client: IpcClient, msg: PostSkillProposalMessage) {
-    handlePostSkillProposal(msg, { bot, assertAllowedChat, swallowingApiCall })
+    handlePostSkillProposal(msg, { bot, assertAllowedChat, swallowingApiCall, deliverResumeSyntheticOrBuffer })
   },
 
   // RFC amendment §"corrections as eval cases" — thin delegate; the
   // DETERMINISTIC applier runs on Approve in handleEvalCaseProposalCallback,
   // NOT a model turn. Body in self-improve-proposal-wiring.ts.
   onPostEvalCaseProposal(_client: IpcClient, msg: PostEvalCaseProposalMessage) {
-    handlePostEvalCaseProposal(msg, { bot, assertAllowedChat, swallowingApiCall })
+    handlePostEvalCaseProposal(msg, { bot, assertAllowedChat, swallowingApiCall, deliverResumeSyntheticOrBuffer })
   },
 
   // Buzz Phase 2b: the duplex peer's advisory publish outcome — no-op unless the hub mirror booted.

package/telegram-plugin/gateway/pending-inbound-buffer.ts

@@ -24,19 +24,97 @@
  *     5-minute delay, not a permanent stall.
  *
  * Per-agent cap prevents a never-reconnecting bridge from leaking
- * unbounded memory. When the cap is hit, the OLDEST entry is dropped
- * — the assumption is the freshest wake-up is the most relevant. A
- * dropped entry is logged via the provided logger.
+ * unbounded memory. When the cap is hit exactly one entry is dropped and
+ * logged via the provided logger. The victim is NOT simply the oldest —
+ * see `selectEvictionVictim`. "Oldest wins" was wrong precisely because
+ * the oldest entry is the one most likely to be a synthetic approval
+ * outcome that has been waiting through an entire turn, and an approval
+ * outcome is the one inbound class the operator cannot resend.
  */
 
 import type { InboundMessage } from './ipc-protocol.js'
 import type { InboundSpool } from './inbound-spool.js'
 import { stampsHandbackMarker } from './subagent-handback-marker.js'
+import { createApprovalOutcomeDropNotifier, isApprovalOutcome } from './approval-outcome-sources.js'
 
 /** Default cap per agent. Tuned for `should fit a reasonable backlog of
  *  approval cards stacked while bridge is offline` but no more. */
 export const DEFAULT_PENDING_INBOUND_CAP = 32
 
+/**
+ * How long an approval outcome keeps its eviction protection.
+ *
+ * Matched to the inbound spool's default `escalateAfterMs`
+ * (`inbound-spool.ts:286`, 15 min). Past that the spool has already escalated
+ * the entry and tombstoned it, so holding a buffer slot for it buys nothing.
+ *
+ * What this bound is NOT: it is not what keeps the buffer live. Liveness is
+ * structural and belongs entirely to tier 3 of `selectEvictionVictim`, which
+ * returns `index 0` unconditionally — the buffer can never refuse to evict, so
+ * there is no live pin for an age bound to release. An earlier version of this
+ * comment claimed otherwise; it was wrong.
+ *
+ * What it actually buys is victim QUALITY within the all-outcomes tier: given a
+ * choice among outcomes, drop one the spool has already escalated rather than
+ * one still inside its delivery window. Note this only changes the victim when
+ * the queue is NOT in `ts`-ascending order — in normal insertion order the
+ * oldest entry is also the stalest, so tier 2 and tier 3 select the same index
+ * and differ only in the `reason` they report. The test `selectEvictionVictim
+ * tiers > prefers a STALE outcome over a fresher one queued ahead of it` pins
+ * the case where they diverge; without it, deleting this bound is invisible.
+ */
+export const APPROVAL_OUTCOME_PROTECTION_MS = 15 * 60 * 1000
+
+/** Why `selectEvictionVictim` picked the entry it picked. */
+export type EvictionReason = 'non-outcome' | 'stale-outcome' | 'all-outcomes'
+
+/**
+ * Choose which buffered entry to evict when the cap is hit. Pure, so the
+ * tiering can be pinned exhaustively.
+ *
+ * Three tiers, in order:
+ *   1. The oldest entry that is NOT an approval outcome. An ordinary chat
+ *      message is resendable and its loss is already surfaced by the
+ *      coalesced `onEvict` notice; an approval outcome is not resendable at
+ *      all (see approval-outcome-sources.ts). In every realistic overflow —
+ *      a burst of user messages while a turn is in flight — this tier hits,
+ *      so an outcome can no longer be evicted out from under an agent that
+ *      is blocked on it.
+ *   2. The oldest outcome past `protectMaxAgeMs` — one the spool has already
+ *      escalated, so it is the least costly outcome to lose. This tier is a
+ *      victim-QUALITY preference, NOT a liveness guarantee (tier 3 supplies
+ *      liveness); it only changes the choice when the queue is out of `ts`
+ *      order, since otherwise the oldest entry is also the stalest.
+ *   3. Pathological: every entry is a fresh outcome. The oldest goes and the
+ *      caller is told via `onEvictCritical` — a dropped outcome the agent is
+ *      never informed of is a permanent block, which is strictly worse than
+ *      a dropped outcome it knows about. This tier returns UNCONDITIONALLY,
+ *      which is what guarantees the buffer always makes progress.
+ *
+ * Insertion order of the SURVIVORS is unchanged in every tier (a splice of
+ * one element preserves relative order), so the FIFO contract `drain` and
+ * `planBufferedRedelivery` rely on still holds.
+ *
+ * Returns index 0 on an empty queue; the caller's `splice` then yields
+ * `undefined` and is guarded, matching the previous `q.shift()` behaviour.
+ */
+export function selectEvictionVictim(
+  q: readonly InboundMessage[],
+  nowMs: number,
+  protectMaxAgeMs: number = APPROVAL_OUTCOME_PROTECTION_MS,
+): { index: number; reason: EvictionReason } {
+  for (let i = 0; i < q.length; i++) {
+    if (!isApprovalOutcome(q[i]!)) return { index: i, reason: 'non-outcome' }
+  }
+  for (let i = 0; i < q.length; i++) {
+    const ts = q[i]!.ts
+    if (typeof ts === 'number' && Number.isFinite(ts) && nowMs - ts >= protectMaxAgeMs) {
+      return { index: i, reason: 'stale-outcome' }
+    }
+  }
+  return { index: 0, reason: 'all-outcomes' }
+}
+
 export interface PendingInboundBuffer {
   /** Append `msg` to `agent`'s queue. Returns true if accepted, false if
    *  the cap forced an eviction (the message is STILL accepted; `false`
@@ -88,8 +166,46 @@ export interface PendingInboundBufferOptions {
    * drop into a visible deferral (chat-is-the-single-source-of-truth:
    * surface the loss window, don't hide it). Best-effort: a throw here
    * never breaks the push hot path.
+   *
+   * Fires ONLY for a non-outcome eviction. When the victim is an approval
+   * outcome, `onEvictCritical` fires INSTEAD — the two notices would
+   * contradict each other otherwise. `onEvict`'s copy promises the message is
+   * "saved and will be handled … I'll ask you to resend it", which is exactly
+   * the promise that cannot be kept for a dropped approval outcome (the
+   * operator's tap already happened; there is nothing to resend).
    */
   onEvict?: (agent: string, evicted: InboundMessage) => void
+  /**
+   * DEFAULTS ON — leave it unset and `createPendingInboundBuffer` wires
+   * `createApprovalOutcomeDropNotifier` against its own `push`. Set it to
+   * override the notice, or to an explicit no-op to opt out.
+   *
+   * Called instead of `onEvict` when the evicted entry is an APPROVAL OUTCOME
+   * — either a stale one past `approvalOutcomeProtectionMs`, or the
+   * pathological case where every buffered entry is a fresh outcome so there
+   * is nothing else to drop.
+   *
+   * This is the one eviction the spool cannot make good on: `sweepEscalations`
+   * (`inbound-spool.ts:564-600`) tombstones and posts "couldn't deliver, please
+   * resend", which is meaningless for a `vault_grant_approved`. The gateway
+   * wires this to a distinct greppable log plus a synthetic notice inbound so
+   * the agent learns the outcome is gone rather than blocking on it forever.
+   *
+   * RE-ENTRANCY: the handler MUST NOT push into this buffer inside the call
+   * frame — it is invoked from the middle of `push`, on a queue that is at cap.
+   * Defer with `queueMicrotask`. The `try/catch` around this call protects the
+   * hot path from a throw; it does nothing against recursion.
+   *
+   * Best-effort: a throw here never breaks the push hot path.
+   */
+  onEvictCritical?: (agent: string, evicted: InboundMessage) => void
+  /**
+   * How long an approval outcome resists eviction. Defaults to
+   * `APPROVAL_OUTCOME_PROTECTION_MS` (the spool's escalation window).
+   */
+  approvalOutcomeProtectionMs?: number
+  /** Clock seam for the age bound. Defaults to `Date.now`. */
+  now?: () => number
   /**
    * fix/backstop-duplicate-reply MUST-FIX 2 — called on every push of a
    * `subagent_handback` envelope (live synthesis AND boot-replay re-push),
@@ -364,9 +480,11 @@ export function createPendingInboundBuffer(
   const cap = opts.capPerAgent ?? DEFAULT_PENDING_INBOUND_CAP
   const log = opts.log ?? ((line: string) => process.stderr.write(line))
   const spool = opts.spool
+  const now = opts.now ?? (() => Date.now())
+  const protectionMs = opts.approvalOutcomeProtectionMs ?? APPROVAL_OUTCOME_PROTECTION_MS
   const queues = new Map<string, InboundMessage[]>()
 
-  return {
+  const buffer: PendingInboundBuffer = {
     push(agent, msg) {
       let q = queues.get(agent)
       if (q == null) {
@@ -375,11 +493,17 @@ export function createPendingInboundBuffer(
       }
       let evicted = false
       if (q.length >= cap) {
-        const dropped = q.shift()
+        // Victim selection is TIERED, not `q.shift()`. The oldest entry is
+        // exactly the one most likely to be an approval outcome that has been
+        // waiting through an entire turn — and an approval outcome is the one
+        // inbound class the operator cannot resend. See selectEvictionVictim.
+        const { index, reason } = selectEvictionVictim(q, now(), protectionMs)
+        const dropped = q.splice(index, 1)[0]
         evicted = true
         log(
           `pending-inbound-buffer: agent=${agent} cap=${cap} reached — ` +
-          `dropped oldest entry source=${dropped?.meta?.source ?? '-'} ts=${dropped?.ts ?? '-'}\n`,
+          `dropped entry idx=${index} reason=${reason} ` +
+          `source=${dropped?.meta?.source ?? '-'} ts=${dropped?.ts ?? '-'}\n`,
         )
         // #2789 A: the cap eviction is no longer a SILENT in-session
         // drop. `dropped` still lives in the durable spool (it was
@@ -387,11 +511,19 @@ export function createPendingInboundBuffer(
         // escalation — but it won't be re-delivered THIS session. Hand
         // it to the caller so a coalesced "N messages deferred" notice
         // can be surfaced. Best-effort: never let the notice break push.
-        if (dropped != null && opts.onEvict != null) {
-          try {
-            opts.onEvict(agent, dropped)
-          } catch {
-            /* user-facing notice is best-effort; never break the hot path */
+        //
+        // An APPROVAL OUTCOME victim routes to `onEvictCritical` instead: the
+        // "saved, I'll ask you to resend" copy behind `onEvict` is a promise
+        // that cannot be kept for a verdict the operator already tapped.
+        if (dropped != null) {
+          const critical = reason !== 'non-outcome'
+          const cb = critical ? onEvictCritical : opts.onEvict
+          if (cb != null) {
+            try {
+              cb(agent, dropped)
+            } catch {
+              /* user-facing notice is best-effort; never break the hot path */
+            }
           }
         }
       }
@@ -453,4 +585,28 @@ export function createPendingInboundBuffer(
     },
     beforeRedeliver: opts.beforeRedeliver,
   }
+
+  // The critical-eviction notifier DEFAULTS ON, wired to this buffer's own
+  // `push`. Same reasoning as `beforeRedeliver` and the handback-marker stamp
+  // above: the guarantee we want is "a dropped approval outcome is never
+  // silent", and a guarantee that depends on each construction site
+  // remembering to pass a callback is discipline, not a mechanism. Defaulting
+  // it here makes it true by construction at every site, including future ones.
+  //
+  // A caller may still override to route the notice elsewhere. Passing an
+  // explicit no-op is the (deliberately explicit) way to opt out.
+  //
+  // The buffer can self-wire because it owns `push` — no caller plumbing, and
+  // notably no new inline code in gateway.ts, which is under a hard line
+  // ratchet (`scripts/check-gateway-line-ratchet.mjs`) with 2 lines of grace.
+  const onEvictCritical =
+    opts.onEvictCritical ??
+    createApprovalOutcomeDropNotifier({
+      push: (a, m) => {
+        buffer.push(a, m)
+      },
+      log,
+    })
+
+  return buffer
 }

package/telegram-plugin/gateway/self-improve-proposal-wiring.test.ts

@@ -0,0 +1,333 @@
+/**
+ * Unit tests for the self-improvement proposal IPC handlers.
+ *
+ * The handlers are factored out of gateway.ts so they can be exercised
+ * without booting grammy — `bot`, `assertAllowedChat` and
+ * `swallowingApiCall` all come in through the ProposalWiringDeps seam, and
+ * the proposal stores are real files under a fresh tmpdir.
+ *
+ * The assertions here are OBSERVABLE: a suppressed proposal writes NO new
+ * record to the store and posts NO card (`swallowingApiCall` never fires).
+ * "The suppression branch ran" is not a test.
+ *
+ * Run with: npx vitest run telegram-plugin/gateway/self-improve-proposal-wiring.test.ts
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import type { Bot, Context } from 'grammy'
+
+import {
+  handlePostSkillProposal,
+  handlePostEvalCaseProposal,
+  isEvalCaseProposalSuppressed,
+  type ProposalWiringDeps,
+} from './self-improve-proposal-wiring.js'
+import type {
+  PostSkillProposalMessage,
+  PostEvalCaseProposalMessage,
+  InboundMessage,
+} from './ipc-protocol.js'
+import {
+  enqueueProposal as enqueueSkillProposal,
+  setProposalStatus as setSkillProposalStatus,
+  REJECTION_TTL_MS,
+} from '../../src/self-improve/skill-proposals.js'
+import {
+  enqueueEvalCaseProposal,
+  readEvalCaseProposals,
+  setEvalCaseProposalStatus,
+} from '../../src/self-improve/eval-case-proposals.js'
+
+const CHAT = '424242'
+
+function makeDeps(): {
+  deps: ProposalWiringDeps
+  sent: string[]
+  woken: Array<{ agent: string; inbound: InboundMessage }>
+} {
+  const sent: string[] = []
+  const woken: Array<{ agent: string; inbound: InboundMessage }> = []
+  const bot = {
+    api: {
+      sendMessage: vi.fn(async (_chat: string, text: string) => {
+        sent.push(text)
+        return { message_id: 1 }
+      }),
+    },
+  } as unknown as Bot<Context>
+  const deps: ProposalWiringDeps = {
+    bot,
+    assertAllowedChat: () => {},
+    swallowingApiCall: async <T>(fn: () => Promise<T>) => await fn(),
+    deliverResumeSyntheticOrBuffer: (agent, inbound) => {
+      woken.push({ agent, inbound })
+      return true
+    },
+  }
+  return { deps, sent, woken }
+}
+
+const evalCase = {
+  prompt: 'When the operator says "ship it", run the smoke suite first.',
+  expectations: ['runs the smoke suite before deploying'],
+  source: 'correction 2026-08-13',
+}
+
+function evalMsg(
+  over: Partial<PostEvalCaseProposalMessage> = {},
+): PostEvalCaseProposalMessage {
+  return {
+    type: 'post_eval_case_proposal',
+    agentName: 'carrie',
+    chatId: CHAT,
+    skillSlug: 'deploy-checklist',
+    skillDir: '/skills/deploy-checklist',
+    case: evalCase,
+    fingerprint: 'aaaa1111',
+    heldOut: false,
+    ...over,
+  }
+}
+
+const skillDraft = {
+  'SKILL.md':
+    '---\nname: deploy-checklist\ndescription: deploy steps\n---\n\n' +
+    '1. run smoke suite\n2. check dashboards\n3. promote\n',
+}
+
+function skillMsg(
+  over: Partial<PostSkillProposalMessage> = {},
+): PostSkillProposalMessage {
+  return {
+    type: 'post_skill_proposal',
+    agentName: 'carrie',
+    chatId: CHAT,
+    skillSlug: 'deploy-checklist',
+    isNew: true,
+    lesson: 'Always run the smoke suite before promoting a deploy',
+    draft: skillDraft,
+    evidence: 'seen across 3 sessions',
+    ...over,
+  } as PostSkillProposalMessage
+}
+
+describe('self-improve proposal wiring — rejection suppression', () => {
+  let dir: string
+  const savedStateDir = process.env.TELEGRAM_STATE_DIR
+  const savedAgent = process.env.SWITCHROOM_AGENT_NAME
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'proposal-wiring-'))
+    process.env.TELEGRAM_STATE_DIR = dir
+    delete process.env.SWITCHROOM_AGENT_NAME
+  })
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true })
+    if (savedStateDir == null) delete process.env.TELEGRAM_STATE_DIR
+    else process.env.TELEGRAM_STATE_DIR = savedStateDir
+    if (savedAgent == null) delete process.env.SWITCHROOM_AGENT_NAME
+    else process.env.SWITCHROOM_AGENT_NAME = savedAgent
+  })
+
+  // ── the sibling skill path (the shape the eval path must mirror) ──
+
+  it('does not re-post a skill proposal the operator already dismissed', () => {
+    const p = enqueueSkillProposal(dir, {
+      skill_slug: 'deploy-checklist',
+      is_new: true,
+      lesson: skillMsg().lesson,
+      draft: skillDraft,
+      evidence: 'x',
+    })
+    setSkillProposalStatus(dir, p.id, 'rejected')
+
+    const { deps, sent } = makeDeps()
+    handlePostSkillProposal(skillMsg(), deps)
+
+    expect(sent).toEqual([])
+  })
+
+  // ── eval-case path: the defect this PR fixes ──
+
+  it('does not enqueue or post an eval case whose fingerprint was dismissed', () => {
+    const p = enqueueEvalCaseProposal(dir, {
+      skill_slug: 'deploy-checklist',
+      skill_dir: '/skills/deploy-checklist',
+      case: evalCase,
+      fingerprint: 'aaaa1111',
+      held_out: false,
+    })
+    setEvalCaseProposalStatus(dir, p.id, 'rejected')
+    const before = readEvalCaseProposals(dir).length
+
+    const { deps, sent } = makeDeps()
+    handlePostEvalCaseProposal(evalMsg(), deps)
+
+    // Observable 1: no card posted.
+    expect(sent).toEqual([])
+    // Observable 2: no new record written to the store.
+    expect(readEvalCaseProposals(dir)).toHaveLength(before)
+  })
+
+  // ── the suppressed exit must not be SILENT (cross-PR #4662 + #4664) ──
+  //
+  // #4662 makes the agent's contract "propose, end your turn, wait for the
+  // outcome inbound". This branch posts no card, so without a wake-up the agent
+  // waits forever — the exact silent block #4662 exists to eliminate. Remove the
+  // `deliverResumeSyntheticOrBuffer` call in the suppressed branch and this test
+  // fails with `woken` empty: the agent is left with no outcome.
+
+  it('a suppressed eval case still WAKES the agent — the silent exit is the bug', () => {
+    const p = enqueueEvalCaseProposal(dir, {
+      skill_slug: 'deploy-checklist',
+      skill_dir: '/skills/deploy-checklist',
+      case: evalCase,
+      fingerprint: 'aaaa1111',
+      held_out: false,
+    })
+    setEvalCaseProposalStatus(dir, p.id, 'rejected')
+
+    const { deps, sent, woken } = makeDeps()
+    handlePostEvalCaseProposal(evalMsg({ threadId: 7 }), deps)
+
+    // No card — that part is unchanged.
+    expect(sent).toEqual([])
+    // But the agent is TOLD, exactly once, and routed back to its own topic.
+    expect(woken).toHaveLength(1)
+    expect(woken[0]!.agent).toBe('carrie')
+    expect(woken[0]!.inbound.meta.source).toBe('eval_case_suppressed')
+    expect(woken[0]!.inbound.meta.skill_slug).toBe('deploy-checklist')
+    expect(woken[0]!.inbound.meta.fingerprint).toBe('aaaa1111')
+    expect(woken[0]!.inbound.threadId).toBe(7)
+    expect(woken[0]!.inbound.meta.message_thread_id).toBe('7')
+    // The instruction that keeps the agent from waiting or retrying.
+    expect(woken[0]!.inbound.text).toContain('do NOT wait')
+    expect(woken[0]!.inbound.text).toContain('Do NOT re-propose')
+    // Suppression is the system working, not a failure — an agent told only
+    // "no card" would reasonably retry, which is the loop this PR removes.
+    expect(woken[0]!.inbound.text).toContain('EXPECTED')
+  })
+
+  it('a NORMAL (unsuppressed) proposal posts a card and does NOT wake the agent', () => {
+    const { deps, sent, woken } = makeDeps()
+    handlePostEvalCaseProposal(evalMsg(), deps)
+
+    // Proves the wake above is specific to the suppressed branch, not something
+    // this handler does on every call.
+    expect(sent).toHaveLength(1)
+    expect(woken).toEqual([])
+  })
+
+  it('never suppresses on an empty fingerprint — it carries no identity', () => {
+    // A stored rejection with an empty fingerprint must not swallow a later
+    // proposal that also lacks one: two different cases, no shared identity.
+    const p = enqueueEvalCaseProposal(dir, {
+      skill_slug: 'deploy-checklist',
+      skill_dir: '/skills/deploy-checklist',
+      case: evalCase,
+      fingerprint: '',
+      held_out: false,
+    })
+    setEvalCaseProposalStatus(dir, p.id, 'rejected')
+
+    expect(
+      isEvalCaseProposalSuppressed(dir, {
+        skillSlug: 'deploy-checklist',
+        fingerprint: '',
+      }),
+    ).toBe(false)
+
+    // …and the handler still posts the card rather than silently dropping it.
+    const { deps, sent } = makeDeps()
+    handlePostEvalCaseProposal(evalMsg({ fingerprint: '' }), deps)
+    expect(sent).toHaveLength(1)
+  })
+
+  it('still enqueues and posts an eval case with a different fingerprint', () => {
+    const p = enqueueEvalCaseProposal(dir, {
+      skill_slug: 'deploy-checklist',
+      skill_dir: '/skills/deploy-checklist',
+      case: { prompt: 'something else entirely' },
+      fingerprint: 'bbbb2222',
+      held_out: false,
+    })
+    setEvalCaseProposalStatus(dir, p.id, 'rejected')
+
+    const { deps, sent } = makeDeps()
+    handlePostEvalCaseProposal(evalMsg({ fingerprint: 'aaaa1111' }), deps)
+
+    expect(sent).toHaveLength(1)
+    expect(
+      readEvalCaseProposals(dir).some(
+        (r) => r.fingerprint === 'aaaa1111' && r.status === 'pending',
+      ),
+    ).toBe(true)
+  })
+
+  it('still enqueues the same fingerprint for a DIFFERENT skill slug', () => {
+    const p = enqueueEvalCaseProposal(dir, {
+      skill_slug: 'other-skill',
+      skill_dir: '/skills/other-skill',
+      case: evalCase,
+      fingerprint: 'aaaa1111',
+      held_out: false,
+    })
+    setEvalCaseProposalStatus(dir, p.id, 'rejected')
+
+    const { deps, sent } = makeDeps()
+    handlePostEvalCaseProposal(evalMsg(), deps)
+
+    expect(sent).toHaveLength(1)
+  })
+
+  it('a PENDING or APPROVED proposal does not suppress a re-proposal', () => {
+    enqueueEvalCaseProposal(dir, {
+      skill_slug: 'deploy-checklist',
+      skill_dir: '/skills/deploy-checklist',
+      case: evalCase,
+      fingerprint: 'aaaa1111',
+      held_out: false,
+    })
+    const approved = enqueueEvalCaseProposal(dir, {
+      skill_slug: 'deploy-checklist',
+      skill_dir: '/skills/deploy-checklist',
+      case: evalCase,
+      fingerprint: 'cccc3333',
+      held_out: false,
+    })
+    setEvalCaseProposalStatus(dir, approved.id, 'approved')
+
+    expect(isEvalCaseProposalSuppressed(dir, evalMsg())).toBe(false)
+    expect(
+      isEvalCaseProposalSuppressed(dir, evalMsg({ fingerprint: 'cccc3333' })),
+    ).toBe(false)
+  })
+
+  it('suppression expires after the rejection TTL', () => {
+    const t0 = Date.UTC(2026, 0, 1)
+    const p = enqueueEvalCaseProposal(
+      dir,
+      {
+        skill_slug: 'deploy-checklist',
+        skill_dir: '/skills/deploy-checklist',
+        case: evalCase,
+        fingerprint: 'aaaa1111',
+        held_out: false,
+      },
+      { now: () => t0 },
+    )
+    setEvalCaseProposalStatus(dir, p.id, 'rejected')
+
+    expect(
+      isEvalCaseProposalSuppressed(dir, evalMsg(), { now: () => t0 + 1000 }),
+    ).toBe(true)
+    expect(
+      isEvalCaseProposalSuppressed(dir, evalMsg(), {
+        now: () => t0 + REJECTION_TTL_MS + 1,
+      }),
+    ).toBe(false)
+  })
+})