switchroom 0.19.41 → 0.19.43

package/telegram-plugin/tests/rollout-status-edit-retry-policy.test.ts

@@ -0,0 +1,366 @@
+/**
+ * #4065 follow-up — the SECOND inertness layer: the retry policy's benign-400
+ * swallow.
+ *
+ * Why this file exists
+ * --------------------
+ * `rollout-status-edit.test.ts` drives `handleRolloutStatusEdit` with an
+ * injected `editMessage` that throws a PLAIN `Error`, so `robustApiCall` is
+ * never in the loop. Production wires that same `editMessage` through
+ * `robustApiCall` (gateway.ts, `onRolloutStatusEdit`), and the retry policy
+ * classifies `400 "message to edit not found"` as a BENIGN 400
+ * (`classifyBenignTelegram400` → `'message_not_found'`) and RESOLVES
+ * `undefined` instead of rethrowing.
+ *
+ * The handler reads success from the absence of a throw. So on the real path,
+ * for the exact scenario the feature was written for — a seeded-resume
+ * narrator holding a carried `narration_message_id` whose card the operator
+ * deleted — the handler replied `{ok:true}`, hostd recorded a frozen card as
+ * live, and no re-post ever happened. Worse than pre-fix: hostd positively
+ * believed the card was fine. The `gone` signal was unreachable for its
+ * primary trigger while every test for it was green.
+ *
+ * So this suite refuses the fake seam twice over:
+ *
+ *   - the edit goes through a `robustApiCall` composed EXACTLY as gateway.ts
+ *     composes it (real `createSendGate.gate` wrapping the real
+ *     `createRetryApiCall`), with a REAL `GrammyError` carrying Telegram's
+ *     real `description`;
+ *   - and the outcome is asserted where the operator feels it — the REAL
+ *     `LogTailRolloutNarrator`, which must answer a deleted card with exactly
+ *     one fresh post.
+ *
+ * A test that only asserted `{ok:false, gone:true}` would not have failed on
+ * the original #4065 bug either, so this one asserts the re-post.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { GrammyError } from 'grammy'
+import { createRetryApiCall, type RetryCallOpts } from '../retry-api-call.js'
+import { createSendGate } from '../send-gate.js'
+import { handleRolloutStatusEdit } from '../gateway/rollout-status-edit.js'
+import type { RolloutStatusEditMessage } from '../gateway/ipc-protocol.js'
+import {
+  LogTailRolloutNarrator,
+  type RolloutCardEscalation,
+  type RolloutEditOutcome,
+  type RolloutNarrationRelay,
+} from '../../src/host-control/rollout-narrator.js'
+import type { StatusEntry } from '../../src/host-control/server.js'
+import type { RolloutPhase } from '../../src/cli/rollout.js'
+
+/** A real grammy 400, byte-identical in shape to what Bot API returns. */
+function telegram400(description: string): GrammyError {
+  return new GrammyError(
+    "Call to 'editMessageText' failed!",
+    {
+      ok: false,
+      error_code: 400,
+      description: `Bad Request: ${description}`,
+    } as never,
+    'editMessageText',
+    {} as never,
+  )
+}
+
+/**
+ * `robustApiCall` composed exactly as gateway.ts:~5740 composes it:
+ * `sendGate.gate(() => rawRetry(fn, opts), opts)`. No stubs on either layer —
+ * this is the production sandwich, and the bug lived between its two slices.
+ */
+function makeProductionRobustApiCall(): <T>(
+  fn: () => Promise<T>,
+  opts?: RetryCallOpts,
+) => Promise<T> {
+  const rawRetry = createRetryApiCall({
+    // Only the sleep is injected (fake timers would otherwise stall the
+    // network-retry backoff); every classification branch is the real one.
+    sleep: async () => {},
+  })
+  const sendGate = createSendGate({ initialWindows: [], bootRamp: {} })
+  return <T>(fn: () => Promise<T>, opts?: RetryCallOpts): Promise<T> =>
+    sendGate.gate(() => rawRetry(fn, opts), opts) as Promise<T>
+}
+
+/**
+ * The gateway's `onRolloutStatusEdit` deps, reproduced with the SAME
+ * `robustApiCall` opts the production call site passes — including
+ * `rethrowBenign400: true`, the fix under test.
+ */
+function editThroughGateway(
+  fail: (() => never) | null,
+  seen: { edits: number },
+): (chatId: string | number, messageId: number, text: string) => Promise<unknown> {
+  const robustApiCall = makeProductionRobustApiCall()
+  return (chatId, messageId, _text) =>
+    robustApiCall(
+      async () => {
+        seen.edits++
+        if (fail) fail()
+        return { message_id: messageId }
+      },
+      {
+        chat_id: String(chatId),
+        verb: 'rollout-status-edit',
+        priorityClass: 'critical',
+        rethrowBenign400: true,
+      },
+    )
+}
+
+/** Run one `rollout_status_edit` end-to-end and return the reply hostd sees. */
+async function relayOneEdit(
+  fail: (() => never) | null,
+  messageId = 4242,
+): Promise<{ reply: Record<string, unknown> | undefined; edits: number }> {
+  const seen = { edits: 0 }
+  const sent: Record<string, unknown>[] = []
+  await handleRolloutStatusEdit(
+    {
+      selfAgentName: 'overlord',
+      operatorChatId: () => 12345,
+      editMessage: editThroughGateway(fail, seen),
+      log: () => {},
+    },
+    { send: (m) => void sent.push(m as unknown as Record<string, unknown>) },
+    {
+      type: 'rollout_status_edit',
+      requestId: 'ro-1',
+      agentName: 'overlord',
+      messageId,
+      text: 'phase: self-bump-done',
+    } as RolloutStatusEditMessage,
+  )
+  return { reply: sent[0], edits: seen.edits }
+}
+
+describe('rollout-status-edit through the REAL retry policy', () => {
+  it('a DELETED card surfaces gone:true (the benign-400 swallow is opted out of)', async () => {
+    // Before the fix this resolved `{ok:true}` — the swallow ate the 400 and
+    // the handler saw no throw. That is the whole bug.
+    const { reply, edits } = await relayOneEdit(() => {
+      throw telegram400('message to edit not found')
+    })
+    expect(edits).toBe(1) // not retried — a benign 400 is terminal
+    expect(reply).toMatchObject({
+      type: 'rollout_status_edited',
+      requestId: 'ro-1',
+      ok: false,
+      gone: true,
+    })
+  })
+
+  it('"message is not modified" is a SUCCESS, not a gone (the card is live and correct)', async () => {
+    // Also swallowed by default; rethrowing it puts ONE classifier in charge
+    // rather than leaving the right answer to a coincidence.
+    const { reply } = await relayOneEdit(() => {
+      throw telegram400('message is not modified')
+    })
+    expect(reply).toMatchObject({ type: 'rollout_status_edited', ok: true })
+    expect(reply).not.toHaveProperty('gone')
+  })
+
+  it("\"message can't be edited\" is also gone", async () => {
+    const { reply } = await relayOneEdit(() => {
+      throw telegram400("message can't be edited")
+    })
+    expect(reply).toMatchObject({ ok: false, gone: true })
+  })
+
+  it('a NON-benign rejection stays transient (no duplicate card)', async () => {
+    const { reply } = await relayOneEdit(() => {
+      throw telegram400('chat not found')
+    })
+    expect(reply).toMatchObject({ ok: false, gone: false })
+  })
+
+  it('an applied edit still replies ok:true', async () => {
+    const { reply, edits } = await relayOneEdit(null)
+    expect(edits).toBe(1)
+    expect(reply).toEqual({ type: 'rollout_status_edited', requestId: 'ro-1', ok: true })
+  })
+})
+
+describe('rethrowBenign400 is scoped — other callers keep the swallow', () => {
+  it('a call WITHOUT the opt-out still resolves undefined on a benign 400', async () => {
+    const robustApiCall = makeProductionRobustApiCall()
+    const res = await robustApiCall(
+      async () => {
+        throw telegram400('message to edit not found')
+      },
+      { chat_id: '12345', verb: 'some-card-repaint' },
+    )
+    expect(res).toBeUndefined()
+  })
+
+  it('the benign observer still fires when the error is rethrown', async () => {
+    const kinds: string[] = []
+    const retry = createRetryApiCall({
+      sleep: async () => {},
+      observer: { onBenign: ({ kind }) => void kinds.push(kind) },
+    })
+    await expect(
+      retry(
+        async () => {
+          throw telegram400('message to edit not found')
+        },
+        { rethrowBenign400: true },
+      ),
+    ).rejects.toBeInstanceOf(GrammyError)
+    expect(kinds).toEqual(['message_not_found'])
+  })
+})
+
+// ── The operator-visible outcome: a deleted card gets a fresh one ────────────
+//
+// The reply shape above is a means, not the end. What the operator feels is
+// whether a roll whose card was deleted still ends on a truthful ✅/❌. So the
+// last test drives the REAL narrator whose relay is the REAL handler over the
+// REAL retry policy, and asserts the re-post.
+
+function makeEntry(over: Partial<StatusEntry> = {}): StatusEntry {
+  return {
+    request_id: 'ro-1',
+    caller: { kind: 'agent', name: 'overlord' },
+    op: 'rollout',
+    result: 'started',
+    exit_code: null,
+    started_at: Date.now(),
+    finished_at: null,
+    stdout_tail: '',
+    stderr_tail: '',
+    pin: 'v1.2.3',
+    ...over,
+  }
+}
+
+const phase = (p: string, over: Partial<RolloutPhase> = {}): RolloutPhase =>
+  ({ phase: p as RolloutPhase['phase'], target: 'v1.2.3', ...over }) as RolloutPhase
+
+/**
+ * Drive the narrator's debounce to quiescence.
+ *
+ * This file is swept by BOTH runners (vitest and the `bun test` sweep over
+ * telegram-plugin/), so it must stay on the dual-run-safe timer API: SYNC
+ * `advanceTimersByTime` + a microtask flush, never `vi.runAllTimersAsync`
+ * (undefined under bun — same trap as tests/draft-stream.test.ts). Looped,
+ * because a debounced flush awaits an async relay round-trip that can arm the
+ * next timer.
+ */
+async function drainNarrator(): Promise<void> {
+  for (let i = 0; i < 12; i++) {
+    vi.advanceTimersByTime(2000)
+    for (let j = 0; j < 12; j++) await Promise.resolve()
+  }
+}
+
+/**
+ * A narration relay whose `edit()` runs the REAL gateway handler over the REAL
+ * retry policy and maps the reply exactly as `SocketRolloutNarrationRelay`
+ * does (`ok===true` → `{ok:true}`, else `{ok:false, gone: obj.gone===true}`).
+ * The socket transport between them is pinned separately by
+ * `rollout-narration-edit-socket.test.ts`; what is under test here is the
+ * classification, which has to happen where the error still exists.
+ */
+function makeRealPathRelay(
+  deadMessageIds: Set<number>,
+  nextMessageId: number | null,
+): RolloutNarrationRelay & { posts: number[]; edits: { messageId: number; text: string }[] } {
+  const posts: number[] = []
+  const edits: { messageId: number; text: string }[] = []
+  return {
+    posts,
+    edits,
+    async post() {
+      posts.push(nextMessageId ?? -1)
+      return nextMessageId
+    },
+    async edit(args): Promise<RolloutEditOutcome> {
+      edits.push({ messageId: args.messageId, text: args.text })
+      const dead = deadMessageIds.has(args.messageId)
+      const seen = { edits: 0 }
+      const sent: Record<string, unknown>[] = []
+      await handleRolloutStatusEdit(
+        {
+          selfAgentName: args.agentName,
+          operatorChatId: () => 12345,
+          editMessage: editThroughGateway(
+            dead
+              ? () => {
+                  throw telegram400('message to edit not found')
+                }
+              : null,
+            seen,
+          ),
+          log: () => {},
+        },
+        { send: (m) => void sent.push(m as unknown as Record<string, unknown>) },
+        {
+          type: 'rollout_status_edit',
+          requestId: args.requestId,
+          agentName: args.agentName,
+          messageId: args.messageId,
+          text: args.text,
+        } as RolloutStatusEditMessage,
+      )
+      const reply = sent[0]
+      if (reply?.ok === true) return { ok: true }
+      return {
+        ok: false,
+        gone: reply?.gone === true,
+        ...(typeof reply?.reason === 'string' ? { reason: reply.reason } : {}),
+      }
+    },
+  }
+}
+
+describe('a deleted rollout card produces a re-post, driven through the real retry policy', () => {
+  beforeEach(() => void vi.useFakeTimers())
+  afterEach(() => void vi.useRealTimers())
+
+  it('seeded narrator + operator-deleted card → exactly one fresh post, terminal lands on it', async () => {
+    // Card 4242 was carried across the self-bump and then deleted by the
+    // operator. 5555 (the re-post) is editable.
+    const relay = makeRealPathRelay(new Set([4242]), 5555)
+    const escalations: RolloutCardEscalation[] = []
+    const n = new LogTailRolloutNarrator(relay, {
+      debounceMs: 1000,
+      escalate: (e) => void escalations.push(e),
+    })
+    const entry = makeEntry()
+
+    n.seedPostedMessage('ro-1', 'overlord', 4242)
+    n.onPhase(entry, phase('self-bump-done'))
+    await drainNarrator()
+
+    // THE ASSERTION THIS WHOLE FILE EXISTS FOR. With the benign-400 swallow in
+    // place the handler replied ok:true, the narrator saw a healthy edit, and
+    // `posts` stayed empty forever.
+    expect(relay.posts).toEqual([5555])
+
+    n.onTerminal(makeEntry({ result: 'completed', rolled: ['a', 'b'] }))
+    await drainNarrator()
+
+    // Exactly one re-post (no storm), and the operator's live card carries the
+    // terminal outcome.
+    expect(relay.posts).toEqual([5555])
+    expect(relay.edits.at(-1)!.messageId).toBe(5555)
+    expect(relay.edits.at(-1)!.text).toContain('✅')
+    // A restored card is not a failure.
+    expect(escalations).toEqual([])
+  })
+
+  it('a live card is never re-posted (no duplicate on the happy path)', async () => {
+    const relay = makeRealPathRelay(new Set(), 5555)
+    const n = new LogTailRolloutNarrator(relay, { debounceMs: 1000 })
+    const entry = makeEntry()
+
+    n.seedPostedMessage('ro-1', 'overlord', 4242)
+    n.onPhase(entry, phase('self-bump-done'))
+    await drainNarrator()
+    n.onTerminal(makeEntry({ result: 'completed', rolled: ['a'] }))
+    await drainNarrator()
+
+    expect(relay.posts).toEqual([])
+    expect(relay.edits.at(-1)!.messageId).toBe(4242)
+  })
+})

package/telegram-plugin/tests/rollout-status-edit.test.ts

@@ -0,0 +1,140 @@
+/**
+ * #4065 — the rollout card's edit relay must tell hostd the TRUTH about an
+ * edit, so a seeded-resume narrator can notice it is editing a card that no
+ * longer exists instead of leaving the operator with a frozen card.
+ *
+ * Outcome under test (gateway half): "message to edit not found" replies
+ * `gone:true` (the only class that may trigger a re-post), everything else
+ * replies `gone:false`, and "message is not modified" is a SUCCESS — the live
+ * card already carries that exact body, so re-posting it would duplicate a
+ * perfectly good card.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  classifyRolloutEditError,
+  handleRolloutStatusEdit,
+  type RolloutStatusEditDeps,
+} from '../gateway/rollout-status-edit.js'
+import type {
+  RolloutStatusEditMessage,
+  RolloutStatusEditedEvent,
+} from '../gateway/ipc-protocol.js'
+
+const MSG: RolloutStatusEditMessage = {
+  type: 'rollout_status_edit',
+  requestId: 'ro-1',
+  agentName: 'overlord',
+  messageId: 4242,
+  text: 'rolling…',
+}
+
+function harness(
+  over: Partial<RolloutStatusEditDeps> = {},
+): { deps: RolloutStatusEditDeps; sent: RolloutStatusEditedEvent[]; client: { send(m: RolloutStatusEditedEvent): void } } {
+  const sent: RolloutStatusEditedEvent[] = []
+  const deps: RolloutStatusEditDeps = {
+    selfAgentName: 'overlord',
+    operatorChatId: () => 12345,
+    editMessage: async () => ({ message_id: 4242 }),
+    log: () => {},
+    ...over,
+  }
+  return { deps, sent, client: { send: (m) => sent.push(m) } }
+}
+
+/** A grammy-shaped API error (the real thing carries `description`). */
+function tgError(description: string): Error & { description: string } {
+  const e = new Error(description) as Error & { description: string }
+  e.description = description
+  return e
+}
+
+describe('classifyRolloutEditError', () => {
+  it('classifies a deleted / uneditable target as gone', () => {
+    expect(
+      classifyRolloutEditError(tgError('Bad Request: message to edit not found')),
+    ).toBe('gone')
+    expect(
+      classifyRolloutEditError(tgError("Bad Request: message can't be edited")),
+    ).toBe('gone')
+    expect(classifyRolloutEditError(tgError('Bad Request: MESSAGE_ID_INVALID'))).toBe(
+      'gone',
+    )
+  })
+
+  it('classifies an unchanged body as not-modified (the card is live)', () => {
+    expect(
+      classifyRolloutEditError(
+        tgError('Bad Request: message is not modified: specified new message content...'),
+      ),
+    ).toBe('not-modified')
+  })
+
+  it('classifies everything else as transient — a re-post would duplicate a live card', () => {
+    expect(classifyRolloutEditError(tgError('Too Many Requests: retry after 12'))).toBe(
+      'transient',
+    )
+    expect(classifyRolloutEditError(new Error('socket hang up'))).toBe('transient')
+    expect(classifyRolloutEditError(undefined)).toBe('transient')
+  })
+})
+
+describe('handleRolloutStatusEdit', () => {
+  it('replies ok on a successful edit', async () => {
+    const h = harness()
+    await handleRolloutStatusEdit(h.deps, h.client, MSG)
+    expect(h.sent).toEqual([{ type: 'rollout_status_edited', requestId: 'ro-1', ok: true }])
+  })
+
+  it('replies gone:true when the card no longer exists (the #4065 signal)', async () => {
+    const h = harness({
+      editMessage: async () => {
+        throw tgError('Bad Request: message to edit not found')
+      },
+    })
+    await handleRolloutStatusEdit(h.deps, h.client, MSG)
+    expect(h.sent).toHaveLength(1)
+    expect(h.sent[0]).toMatchObject({ requestId: 'ro-1', ok: false, gone: true })
+  })
+
+  it('replies gone:false on a transient failure', async () => {
+    const h = harness({
+      editMessage: async () => {
+        throw tgError('Too Many Requests: retry after 12')
+      },
+    })
+    await handleRolloutStatusEdit(h.deps, h.client, MSG)
+    expect(h.sent[0]).toMatchObject({ ok: false, gone: false })
+  })
+
+  it('treats "not modified" as success — the live card already says this', async () => {
+    const h = harness({
+      editMessage: async () => {
+        throw tgError('Bad Request: message is not modified')
+      },
+    })
+    await handleRolloutStatusEdit(h.deps, h.client, MSG)
+    expect(h.sent).toEqual([{ type: 'rollout_status_edited', requestId: 'ro-1', ok: true }])
+  })
+
+  it('rejects an agent mismatch without editing, and never reports gone', async () => {
+    let edits = 0
+    const h = harness({
+      selfAgentName: 'someone-else',
+      editMessage: async () => {
+        edits++
+        return {}
+      },
+    })
+    await handleRolloutStatusEdit(h.deps, h.client, MSG)
+    expect(edits).toBe(0)
+    expect(h.sent[0]).toMatchObject({ ok: false, gone: false, reason: 'agent mismatch' })
+  })
+
+  it('replies (never throws) when there is no operator chat', async () => {
+    const h = harness({ operatorChatId: () => undefined })
+    await handleRolloutStatusEdit(h.deps, h.client, MSG)
+    expect(h.sent[0]).toMatchObject({ ok: false, gone: false, reason: 'no operator chat' })
+  })
+})

package/telegram-plugin/tests/rollout-status-wiring.test.ts

@@ -10,7 +10,9 @@
  *      OPERATOR chat (allowFrom[0]) as an ORDINARY message (no pin, no
  *      inline_keyboard card), and replies with the message_id.
  *   3. the EDIT handler edits in place via the wrapped retry path
- *      (swallowingApiCall) — fire-and-forget, never a raw bot.api call.
+ *      (robustApiCall) — never a raw bot.api call — and, since #4065, replies
+ *      with the outcome so hostd can tell an applied edit from an edit into a
+ *      deleted card. Its body lives in gateway/rollout-status-edit.ts.
  *   4. NEITHER handler pins a message — this is in-chat narration, not the
  *      retired pinned card (chat-is-the-single-source-of-truth).
  */
@@ -19,6 +21,10 @@ import { readFileSync } from "node:fs";
 
 const gw = readFileSync(new URL("../gateway/gateway.ts", import.meta.url), "utf8");
 const ipcServer = readFileSync(new URL("../gateway/ipc-server.ts", import.meta.url), "utf8");
+const editModule = readFileSync(
+  new URL("../gateway/rollout-status-edit.ts", import.meta.url),
+  "utf8",
+);
 
 describe("rollout_status_* — ipc-server routing", () => {
   it("validates + dispatches rollout_status_post", () => {
@@ -61,21 +67,48 @@ describe("onRolloutStatusPost — gateway handler invariants", () => {
 });
 
 describe("onRolloutStatusEdit — gateway handler invariants", () => {
-  const start = gw.indexOf("onRolloutStatusEdit(_client: IpcClient, msg: RolloutStatusEditMessage)");
+  // #4065 moved the handler BODY into gateway/rollout-status-edit.ts (which has
+  // its own behavioural suite, rollout-status-edit.test.ts). gateway.ts keeps
+  // only the wiring, so the invariants are pinned across both files.
+  const start = gw.indexOf("onRolloutStatusEdit(client: IpcClient, msg: RolloutStatusEditMessage)");
   const next = gw.indexOf("onInjectInbound(", start);
   const handler = gw.slice(start, next > start ? next : start + 2000);
 
   it("the handler exists", () => {
     expect(start).toBeGreaterThan(0);
   });
-  it("fences the agent", () => {
-    expect(handler).toMatch(/msg\.agentName !== self/);
+  it("delegates to the extracted edit handler", () => {
+    expect(handler).toMatch(/handleRolloutStatusEdit\(/);
+    expect(gw).toMatch(
+      /import \{ handleRolloutStatusEdit \} from '\.\/rollout-status-edit\.js'/,
+    );
+  });
+  it("fences the agent (agentName must match this gateway's own)", () => {
+    expect(handler).toMatch(/selfAgentName: process\.env\.SWITCHROOM_AGENT_NAME/);
+    expect(editModule).toMatch(/msg\.agentName !== self/);
+  });
+  it("edits the OPERATOR chat in place via the wrapped retry path", () => {
+    expect(handler).toMatch(/loadAccess\(\)\.allowFrom\[0\]/);
+    expect(handler).toMatch(/robustApiCall\(/);
+    expect(handler).toMatch(/bot\.api\.editMessageText\(chatId, messageId/);
+  });
+  // Routing through robustApiCall is necessary but NOT sufficient, and pinning
+  // only that enshrines the bug it hides: the retry policy's benign-400 swallow
+  // resolves `400 "message to edit not found"` instead of throwing, and this
+  // handler reads success from the absence of a throw. Both opt-outs are what
+  // make the wrapped path safe here, so both are pinned. The BEHAVIOUR lives in
+  // tests/rollout-status-edit-retry-policy.test.ts (real retry policy, real
+  // GrammyError, asserts the re-post); this is the structural backstop.
+  it("opts out of BOTH inertness layers — send-gate shed and benign-400 swallow", () => {
+    expect(handler).toMatch(/priorityClass: 'critical'/);
+    expect(handler).toMatch(/rethrowBenign400: true/);
   });
-  it("edits in place via the wrapped retry path (fire-and-forget)", () => {
-    expect(handler).toMatch(/swallowingApiCall\(/);
-    expect(handler).toMatch(/bot\.api\.editMessageText\(operator, msg\.messageId/);
+  it("reports the edit outcome back to hostd (#4065 — no more edit-into-void)", () => {
+    expect(editModule).toMatch(/rollout_status_edited/);
+    expect(editModule).toMatch(/gone: cls === 'gone'/);
   });
   it("does NOT pin (edits an ordinary message)", () => {
     expect(handler).not.toMatch(/pinChatMessage/);
+    expect(editModule).not.toMatch(/pinChatMessage/);
   });
 });

package/telegram-plugin/tests/tg-post-logger-error-shape.test.ts

@@ -77,6 +77,10 @@ afterEach(() => {
 })
 
 describe('tg-post logger — resolved ok:false responses (#3927)', () => {
+  // These calls are made directly on `bot.api.*` with NO enclosing retry
+  // policy, so every rejection here IS the outcome and stays `status=err`.
+  // The `status=retry` tier (#3931) only applies inside `createRetryApiCall`
+  // — see `tg-post-retry-attribution.test.ts`.
   it('logs a 429 flood-wait as status=err code=429 (FAILS before the fix: logged status=ok)', async () => {
     const lines = await tgPostLinesFor({
       ok: false,