switchroom 0.7.15 → 0.10.0

package/telegram-plugin/tests/foreman-write-ops.test.ts

@@ -1,214 +0,0 @@
-/**
- * Tests for Phase 3b foreman write operations:
- *   - handleRestartCommand (mocked execFileSync)
- *   - handleDeleteCommand + executeDeleteAgent (mocked exec + FS)
- *   - handleUpdateCommand (mocked combined exec)
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import {
-  handleRestartCommand,
-  handleDeleteCommand,
-  executeDeleteAgent,
-  handleUpdateCommand,
-  type SwitchroomExecFn,
-} from '../foreman/foreman-handlers.js'
-import type { execFileSync } from 'child_process'
-
-// ─── /restart ─────────────────────────────────────────────────────────────
-
-describe('foreman: handleRestartCommand — input validation', () => {
-  it('returns usage when no agent specified', () => {
-    const result = handleRestartCommand('')
-    expect(result.ok).toBe(false)
-    expect(result.text).toContain('Usage')
-  })
-
-  it('rejects invalid agent name', () => {
-    const execFile = vi.fn()
-    // 'BadName' has uppercase — first token is invalid
-    const result = handleRestartCommand('BadName', execFile as never)
-    expect(result.ok).toBe(false)
-    expect(result.text).toBe('Invalid agent name.')
-    expect(execFile).not.toHaveBeenCalled()
-  })
-
-  it('rejects path traversal', () => {
-    const execFile = vi.fn()
-    const result = handleRestartCommand('../etc/passwd', execFile as never)
-    expect(result.ok).toBe(false)
-    expect(execFile).not.toHaveBeenCalled()
-  })
-
-  it('rejects agent name with colon', () => {
-    const execFile = vi.fn()
-    const result = handleRestartCommand('bad:name', execFile as never)
-    expect(result.ok).toBe(false)
-    expect(execFile).not.toHaveBeenCalled()
-  })
-})
-
-describe('foreman: handleRestartCommand — execFileSync calls', () => {
-  it('calls systemctl --user restart with correct unit name', () => {
-    const execFile = vi.fn().mockReturnValue('')
-    const result = handleRestartCommand('gymbro', execFile as never)
-
-    expect(result.ok).toBe(true)
-    expect(execFile).toHaveBeenCalledOnce()
-    const [cmd, args] = execFile.mock.calls[0] as [string, string[]]
-    expect(cmd).toBe('systemctl')
-    expect(args).toContain('--user')
-    expect(args).toContain('restart')
-    expect(args).toContain('switchroom-gymbro')
-    // Must NOT be a shell string — second arg must be an array
-    expect(Array.isArray(args)).toBe(true)
-  })
-
-  it('uses execFileSync not execSync (no shell)', () => {
-    const execFile = vi.fn().mockReturnValue('')
-    handleRestartCommand('gymbro', execFile as never)
-    // The function is called with 3 args (cmd, args[], opts) not a shell string
-    const [, args] = execFile.mock.calls[0] as [string, string[], object]
-    expect(Array.isArray(args)).toBe(true)
-  })
-
-  it('includes agent name in success reply', () => {
-    const execFile = vi.fn().mockReturnValue('')
-    const result = handleRestartCommand('gymbro', execFile as never)
-    expect(result.ok).toBe(true)
-    expect(result.text).toContain('gymbro')
-  })
-
-  it('returns error text when systemctl fails', () => {
-    const execFile = vi.fn().mockImplementation(() => {
-      throw Object.assign(new Error('unit not found'), { stderr: 'Unit switchroom-gymbro.service not found.' })
-    })
-    const result = handleRestartCommand('gymbro', execFile as never)
-    expect(result.ok).toBe(false)
-    expect(result.text).toContain('restart failed')
-    expect(result.text).toContain('gymbro')
-  })
-
-  it('handles agent name with hyphen', () => {
-    const execFile = vi.fn().mockReturnValue('')
-    handleRestartCommand('my-agent', execFile as never)
-    const [, args] = execFile.mock.calls[0] as [string, string[]]
-    expect(args).toContain('switchroom-my-agent')
-  })
-
-  it('escapes HTML in error output', () => {
-    const execFile = vi.fn().mockImplementation(() => {
-      throw Object.assign(new Error('err'), { stderr: 'Error: <unit> not found' })
-    })
-    const result = handleRestartCommand('gymbro', execFile as never)
-    expect(result.text).not.toContain('<unit>')
-  })
-})
-
-// ─── /delete first step ───────────────────────────────────────────────────
-
-describe('foreman: handleDeleteCommand — prompt', () => {
-  it('returns usage when no agent specified', () => {
-    const result = handleDeleteCommand('')
-    expect(result.replies[0].text).toContain('Usage')
-    expect(result.needsConfirm).toBeFalsy()
-  })
-
-  it('rejects invalid agent name', () => {
-    // 'BadAgent' has uppercase — invalid
-    const result = handleDeleteCommand('BadAgent')
-    expect(result.replies[0].text).toBe('Invalid agent name.')
-    expect(result.needsConfirm).toBeFalsy()
-  })
-
-  it('returns confirmation prompt for valid agent', () => {
-    const result = handleDeleteCommand('gymbro')
-    expect(result.replies[0].text).toContain('gymbro')
-    expect(result.replies[0].text).toContain('YES')
-    expect(result.needsConfirm).toBe(true)
-    expect(result.agentForConfirm).toBe('gymbro')
-  })
-
-  it('escapes HTML in agent name in prompt', () => {
-    // valid name, but let's use one that could trip HTML — actually all valid names
-    // are alphanumeric so no HTML risk; just verify the name appears
-    const result = handleDeleteCommand('my-agent')
-    expect(result.replies[0].text).toContain('my-agent')
-    expect(result.replies[0].html).toBe(true)
-  })
-})
-
-// ─── executeDeleteAgent ───────────────────────────────────────────────────
-
-describe('foreman: executeDeleteAgent — execution', () => {
-  it('runs CLI destroy with --yes flag', () => {
-    const switchroomExec: SwitchroomExecFn = vi.fn().mockReturnValue('Removed unit.')
-    const execFile = vi.fn().mockReturnValue('')
-    const tmpDir = '/tmp/fake-agents-dir'
-
-    const result = executeDeleteAgent('gymbro', switchroomExec, execFile as never, tmpDir)
-    expect(switchroomExec).toHaveBeenCalledWith(['agent', 'destroy', '--yes', 'gymbro'])
-    expect(result.replies[0].text).toContain('gymbro')
-  })
-
-  it('reports success without archive when dir does not exist', () => {
-    const switchroomExec: SwitchroomExecFn = vi.fn().mockReturnValue('done')
-    const result = executeDeleteAgent('gymbro', switchroomExec, vi.fn() as never, '/nonexistent-agents-dir')
-    // No archive reported (dir didn't exist)
-    expect(result.replies[0].text).not.toContain('Archived')
-  })
-
-  it('rejects invalid agent name without calling CLI', () => {
-    const switchroomExec: SwitchroomExecFn = vi.fn()
-    const result = executeDeleteAgent('bad name!', switchroomExec, vi.fn() as never, '/tmp')
-    expect(result.replies[0].text).toBe('Invalid agent name.')
-    expect(switchroomExec).not.toHaveBeenCalled()
-  })
-
-  it('reports CLI error but notes archive succeeded', () => {
-    const switchroomExec: SwitchroomExecFn = vi.fn().mockImplementation(() => {
-      throw Object.assign(new Error('destroy failed'), { stderr: 'switchroom error' })
-    })
-    // Use a dir that definitely doesn't exist so no actual rename
-    const result = executeDeleteAgent('gymbro', switchroomExec, vi.fn() as never, '/nonexistent-agents-12345')
-    expect(result.replies[0].text).toContain('CLI destroy failed')
-  })
-})
-
-// ─── /update ──────────────────────────────────────────────────────────────
-
-describe('foreman: handleUpdateCommand', () => {
-  it('calls switchroomExec with ["update"]', () => {
-    const exec: SwitchroomExecFn = vi.fn().mockReturnValue('Updated successfully.')
-    handleUpdateCommand(exec)
-    expect(exec).toHaveBeenCalledWith(['update'])
-  })
-
-  it('returns output in a pre block', () => {
-    const exec: SwitchroomExecFn = vi.fn().mockReturnValue('Pulled abc123. Reconciled 2 agents.')
-    const result = handleUpdateCommand(exec)
-    expect(result.replies[0].text).toContain('Pulled abc123')
-    expect(result.replies[0].html).toBe(true)
-  })
-
-  it('returns error message when CLI throws', () => {
-    const exec: SwitchroomExecFn = vi.fn().mockImplementation(() => {
-      throw Object.assign(new Error('not a git repo'), { stderr: 'fatal: not a git repository' })
-    })
-    const result = handleUpdateCommand(exec)
-    expect(result.replies[0].text).toContain('update failed')
-  })
-
-  it('returns no-output message when CLI returns empty', () => {
-    const exec: SwitchroomExecFn = vi.fn().mockReturnValue('   \n')
-    const result = handleUpdateCommand(exec)
-    expect(result.replies[0].text).toContain('Update complete')
-  })
-
-  it('paginates output > 3 KB', () => {
-    const bigOutput = 'x'.repeat(4000)
-    const exec: SwitchroomExecFn = vi.fn().mockReturnValue(bigOutput)
-    const result = handleUpdateCommand(exec)
-    expect(result.replies.length).toBeGreaterThan(1)
-  })
-})

package/telegram-plugin/tests/harness-ordering-invariants.test.ts

@@ -1,243 +0,0 @@
-/**
- * Harness ordering invariants — table-driven scenarios.
- *
- * These tests assert cross-cutting properties that hold across a range
- * of turn shapes (Class A/B/C, retry, replay-dup, error-cascade). The
- * scenarios are deterministic and named, not random — see
- * HARNESS_UPGRADE_PLAN.md "scenario fuzzer" decision (skeptic finding 7:
- * property-based fuzzing without shrinking is worse than no fuzzing).
- *
- * Each invariant carries a `// fails when:` comment indicating the
- * production change that would break it. The test author should mentally
- * `git stash` that change and confirm the test fails — see plan
- * "Validation rule for each new test."
- *
- * Invariants:
- *
- *   INV-1 — Terminal reaction (👍) fires AT-OR-AFTER the last user-
- *           visible answer text. NEVER before. The Bug D/Z contract
- *           generalized to all turn shapes.
- *
- *   INV-2 — Exactly one terminal reaction fires per logical turn
- *           (regardless of how many tool emoji ladder steps occurred
- *           in between). Catches a future regression where setDone
- *           fires twice.
- *
- *   INV-3 — Editing a deleted message always errors. Catches a
- *           regression in the fake's delete-vs-edit ordering, which
- *           would let a buggy production module silently miss the
- *           "edit-to-deleted-message" failure mode in tests.
- *
- *   INV-4 — Outbound dedup window holds for the full TTL once the
- *           cache is wired in.
- *
- *   INV-5 — Hold-and-release ordering: an event fired while a
- *           sendMessage/editMessageText is parked at `holdNext`
- *           observes the world as it was BEFORE the held call landed.
- *           This pins the harness's own contract — necessary for
- *           future Bug-D-class tests to be expressible.
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { createRealGatewayHarness } from './real-gateway-harness.js'
-import { createFakeBotApi } from './fake-bot-api.js'
-
-const CHAT = '8248703757'
-const INBOUND_MSG = 100
-
-beforeEach(() => {
-  vi.useFakeTimers()
-})
-afterEach(() => {
-  vi.useRealTimers()
-})
-
-interface TurnShape {
-  name: string
-  /** Drive the harness through one logical turn. Resolves when turn ended. */
-  drive: (h: ReturnType<typeof createRealGatewayHarness>) => Promise<void>
-}
-
-const turnShapes: TurnShape[] = [
-  {
-    name: 'class-A reply (sub-2s, no tools)',
-    drive: async (h) => {
-      h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'hi' })
-      h.feedSessionEvent({
-        kind: 'enqueue',
-        chatId: CHAT,
-        messageId: '1',
-        threadId: null,
-        rawContent: 'hi',
-      })
-      await h.clock.advance(20)
-      await h.streamReply({ chat_id: CHAT, text: 'Hello back!', done: true })
-      await h.clock.advance(20)
-    },
-  },
-  {
-    name: 'class-B with-tools (1 tool, ~3s)',
-    drive: async (h) => {
-      h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'work' })
-      h.feedSessionEvent({
-        kind: 'enqueue',
-        chatId: CHAT,
-        messageId: '1',
-        threadId: null,
-        rawContent: 'work',
-      })
-      await h.clock.advance(50)
-      h.feedSessionEvent({ kind: 'thinking' })
-      await h.clock.advance(500)
-      h.feedSessionEvent({ kind: 'tool_use', toolName: 'Read' })
-      await h.clock.advance(2500)
-      await h.streamReply({ chat_id: CHAT, text: 'Here is the answer.', done: true })
-      await h.clock.advance(20)
-    },
-  },
-  {
-    name: 'class-C subagent (long, ~10s, sub-agent emit)',
-    drive: async (h) => {
-      h.inbound({ chatId: CHAT, messageId: INBOUND_MSG, text: 'big task' })
-      h.feedSessionEvent({
-        kind: 'enqueue',
-        chatId: CHAT,
-        messageId: '1',
-        threadId: null,
-        rawContent: 'big task',
-      })
-      await h.clock.advance(50)
-      h.feedSessionEvent({ kind: 'thinking' })
-      await h.clock.advance(500)
-      h.feedSessionEvent({ kind: 'tool_use', toolName: 'Read' })
-      await h.clock.advance(2000)
-      h.feedSessionEvent({ kind: 'tool_use', toolName: 'Grep' })
-      await h.clock.advance(2000)
-      h.feedSessionEvent({ kind: 'tool_use', toolName: 'Edit' })
-      await h.clock.advance(5000)
-      await h.streamReply({ chat_id: CHAT, text: 'Done — see the diff above.', done: true })
-      await h.clock.advance(20)
-    },
-  },
-]
-
-describe('INV-1 — terminal reaction fires AT-OR-AFTER last delivery (Bug D/Z generalized)', () => {
-  for (const shape of turnShapes) {
-    it(`${shape.name}: lastReactionEmojiAt >= lastAnswerTextDeliveredAt`, async () => {
-      // fails when: a future refactor moves setDone() from the streamReply
-      // post-await branch back to the JSONL turn_end handler — exactly
-      // Bug D's failure mode, generalized over turn shapes.
-      const h = createRealGatewayHarness({ gapMs: 0 })
-      await shape.drive(h)
-      const deliveredAt = h.lastAnswerTextDeliveredAt(CHAT)
-      const reactionAt = h.lastReactionEmojiAt(CHAT)
-      expect(deliveredAt, `no answer text delivered for ${shape.name}`).not.toBeNull()
-      expect(reactionAt, `no reaction emitted for ${shape.name}`).not.toBeNull()
-      expect(reactionAt!).toBeGreaterThanOrEqual(deliveredAt!)
-      h.finalize()
-    })
-  }
-})
-
-describe('INV-2 — terminal 👍 fires exactly once per turn (Bug Z generalized)', () => {
-  for (const shape of turnShapes) {
-    it(`${shape.name}: 👍 appears exactly once across the full reaction sequence`, async () => {
-      // fails when: a future change fires setDone() more than once
-      // for the same turn (e.g. both the streamReply post-await branch
-      // AND the turn_end JSONL handler call it). Specifically asserting
-      // the COUNT of 👍 in the full sequence — not just "the last
-      // emoji is unique" (which would be a tautology).
-      const h = createRealGatewayHarness({ gapMs: 0 })
-      await shape.drive(h)
-      const seq = h.recorder.reactionSequence()
-      expect(seq.length, `no reactions for ${shape.name}`).toBeGreaterThan(0)
-      const thumbsUpCount = seq.filter((e) => e === '👍').length
-      expect(thumbsUpCount).toBe(1)
-      // And the 👍 is the LAST reaction — terminal contract.
-      expect(seq[seq.length - 1]).toBe('👍')
-      h.finalize()
-    })
-  }
-})
-
-describe('INV-3 — editing a deleted message always errors', () => {
-  it('fake throws messageToEditNotFound after the message is deleted', async () => {
-    // fails when: someone changes fake-bot-api's editMessageText to
-    // silently succeed for deleted messages — production modules
-    // would then look correct in tests but error in real Telegram.
-    const bot = createFakeBotApi()
-    const r = (await bot.api.sendMessage('c1', 'long enough text content here ok', {})) as {
-      message_id: number
-    }
-    await bot.api.deleteMessage('c1', r.message_id)
-    await expect(
-      bot.api.editMessageText('c1', r.message_id, 'updated text content here ok', {}),
-    ).rejects.toMatchObject({ error_code: 400 })
-  })
-})
-
-describe('INV-4 — outbound dedup window holds for the full TTL', () => {
-  // Span of "now" offsets within the TTL that should all be deduped.
-  const inWindowOffsets = [0, 1000, 30_000, 59_000]
-  // Span outside the TTL that should NOT be deduped.
-  const outOfWindowOffsets = [60_001, 120_000]
-
-  for (const ms of inWindowOffsets) {
-    it(`same content at +${ms}ms is suppressed (within TTL=60s)`, async () => {
-      // fails when: TTL is silently shortened, or the cache's eviction
-      // sweep evicts entries before their TTL expires.
-      const h = createRealGatewayHarness({ gapMs: 0, withDedup: true })
-      const text = 'A long enough message to clear the 24-char dedup floor by a wide margin.'
-      await h.send({ chat_id: CHAT, text })
-      await h.clock.advance(ms)
-      const id2 = await h.send({ chat_id: CHAT, text })
-      expect(id2).toBeNull()
-      h.finalize()
-    })
-  }
-
-  for (const ms of outOfWindowOffsets) {
-    it(`same content at +${ms}ms is allowed (outside TTL)`, async () => {
-      // fails when: TTL eviction breaks (entries linger past their TTL).
-      const h = createRealGatewayHarness({ gapMs: 0, withDedup: true })
-      const text = 'A long enough message to clear the 24-char dedup floor by a wide margin.'
-      await h.send({ chat_id: CHAT, text })
-      await h.clock.advance(ms)
-      const id2 = await h.send({ chat_id: CHAT, text })
-      expect(id2).not.toBeNull()
-      h.finalize()
-    })
-  }
-})
-
-describe('INV-5 — holdNext: events fired during a held call observe pre-held state', () => {
-  it('a setMessageReaction parked at holdNext lets unrelated state mutate before its release', async () => {
-    // fails when: a future fake-bot refactor makes holdNext block
-    // mutations on OTHER methods, or makes release() synchronous when
-    // it should be async.
-    //
-    // This is the foundational seam that makes Bug-D-class tests
-    // expressible: "while editMessageText is pending, fire the 👍" —
-    // the harness must let the 👍 land while the edit is parked.
-    const bot = createFakeBotApi()
-    const r = (await bot.api.sendMessage('c1', 'long enough text content here ok', {})) as {
-      message_id: number
-    }
-    const hold = bot.holdNext('editMessageText', 'c1')
-    // Start the edit; it parks at the gate.
-    const editPromise = bot.api.editMessageText('c1', r.message_id, 'edited content here ok', {})
-    // Yield a microtask so the held call enters its await.
-    await Promise.resolve()
-    expect(hold.triggered()).toBe(true)
-    // Fire something else — setMessageReaction — and confirm it lands
-    // independently while the edit is still parked.
-    await bot.api.setMessageReaction('c1', r.message_id, [{ type: 'emoji', emoji: '👍' }])
-    expect(bot.state.reactions.length).toBe(1)
-    // The edit's text hasn't landed yet — the message is still original.
-    expect(bot.textOf(r.message_id)).toBe('long enough text content here ok')
-    // Release the edit — now the text updates.
-    hold.release()
-    await editPromise
-    expect(bot.textOf(r.message_id)).toBe('edited content here ok')
-  })
-})

package/telegram-plugin/tests/pin-event-log.test.ts

@@ -1,124 +0,0 @@
-/**
- * Tests for the structured pin/unpin event logger — the module that
- * emits one JSON line per pin API interaction so operators can audit
- * the pin lifecycle without parsing free-form log text.
- *
- * Covers spec `docs/pinned-progress-card-reliability.md` §6.1 and T9.
- */
-
-import { describe, it, expect } from "vitest";
-import {
-  logPinEvent,
-  classifyPinError,
-  errorMessage,
-  type PinEvent,
-} from "../pin-event-log.js";
-
-describe("logPinEvent", () => {
-  it("writes one JSON line prefixed with 'pin-event: '", () => {
-    const lines: string[] = [];
-    const ev: PinEvent = {
-      event: "pin",
-      chatId: "100",
-      messageId: 42,
-      turnKey: "100::1",
-      outcome: "ok",
-      durationMs: 123,
-    };
-    logPinEvent(ev, (line) => lines.push(line));
-    expect(lines).toHaveLength(1);
-    expect(lines[0]).toMatch(/^pin-event: /);
-    expect(lines[0].endsWith("\n")).toBe(true);
-    const payload = JSON.parse(lines[0].replace(/^pin-event: /, "").trimEnd());
-    expect(payload).toEqual(ev);
-  });
-
-  it("preserves all optional fields that are set", () => {
-    const lines: string[] = [];
-    logPinEvent(
-      {
-        event: "unpin-retry",
-        chatId: "c",
-        messageId: 7,
-        turnKey: "c::2",
-        outcome: "rate-limited",
-        error: "Too Many Requests",
-        durationMs: 1050,
-      },
-      (line) => lines.push(line),
-    );
-    const payload = JSON.parse(lines[0].replace(/^pin-event: /, "").trimEnd());
-    expect(payload.error).toBe("Too Many Requests");
-    expect(payload.outcome).toBe("rate-limited");
-    expect(payload.event).toBe("unpin-retry");
-  });
-
-  it("omits undefined optional fields cleanly", () => {
-    const lines: string[] = [];
-    logPinEvent(
-      {
-        event: "sweep-pin",
-        chatId: "c",
-        outcome: "ok",
-      },
-      (line) => lines.push(line),
-    );
-    const raw = lines[0].replace(/^pin-event: /, "").trimEnd();
-    expect(raw).not.toContain("undefined");
-    const payload = JSON.parse(raw);
-    expect(payload.error).toBeUndefined();
-    expect(payload.messageId).toBeUndefined();
-  });
-});
-
-describe("classifyPinError", () => {
-  it("returns 'rate-limited' for Telegram 429", () => {
-    expect(
-      classifyPinError({ error_code: 429, description: "Too Many Requests: retry after 2" }),
-    ).toBe("rate-limited");
-  });
-
-  it("returns 'forbidden' for Telegram 403", () => {
-    expect(classifyPinError({ error_code: 403, description: "Forbidden: bot was kicked" })).toBe(
-      "forbidden",
-    );
-  });
-
-  it("falls back to message substring match when error_code is absent", () => {
-    expect(classifyPinError(new Error("Bad Request: not enough rights to manage pins"))).toBe(
-      "forbidden",
-    );
-    expect(classifyPinError(new Error("connect ETIMEDOUT 1.2.3.4:443"))).toBe("timeout");
-  });
-
-  it("returns 'fail' for any unrecognised error shape", () => {
-    expect(classifyPinError(new Error("weird unexpected failure"))).toBe("fail");
-    expect(classifyPinError("random string")).toBe("fail");
-    expect(classifyPinError({})).toBe("fail");
-  });
-
-  it("returns 'fail' for null/undefined", () => {
-    expect(classifyPinError(null)).toBe("fail");
-    expect(classifyPinError(undefined)).toBe("fail");
-  });
-});
-
-describe("errorMessage", () => {
-  it("extracts message from Error instance", () => {
-    expect(errorMessage(new Error("boom"))).toBe("boom");
-  });
-
-  it("prefers description over message on grammy-shaped objects", () => {
-    expect(errorMessage({ description: "Telegram says no", message: "generic" })).toBe(
-      "Telegram says no",
-    );
-  });
-
-  it("returns empty string for null", () => {
-    expect(errorMessage(null)).toBe("");
-  });
-
-  it("stringifies unknown shapes", () => {
-    expect(errorMessage(42)).toBe("42");
-  });
-});

package/telegram-plugin/tests/progress-card-api-failure-during-deferred.test.ts

@@ -1,73 +0,0 @@
-/**
- * PR-C2 — reportApiFailure crossing its threshold while a chat is in
- * `pendingCompletion` state must not corrupt the deferred-completion
- * resolution path.
- *
- * Setup: parent turn_end while a bg sub-agent is still running →
- * chatState.pendingCompletion=true. Then `maxConsecutive4xx` permanent
- * 4xx failures arrive (the card is being abandoned locally). We then
- * resolve the bg sub-agent via sub_agent_turn_end. The driver must:
- *
- *   - Fire onTurnComplete exactly once for the originating turnKey.
- *   - Not double-flush.
- *
- * fails when: the terminal-apiFailure branch races with the
- * pendingCompletion resolution path and either swallows or duplicates
- * the completion callback.
- */
-import { describe, it, expect } from 'vitest'
-import { makeHarness, enqueue } from './_progress-card-harness.js'
-
-describe('PR-C2: API failure crossing threshold during pendingCompletion', () => {
-  it('deferred completion still resolves exactly once; no double-flush', () => {
-    const completions: string[] = []
-    const { driver } = makeHarness({
-      minIntervalMs: 0,
-      coalesceMs: 0,
-      heartbeatMs: 999_999, // keep heartbeat from racing the test
-      maxConsecutive4xx: 3,
-      promoteAfterMs: 999_999,
-      onTurnComplete: (s) => completions.push(s.turnKey),
-    })
-    const maps = driver._debugGetMaps!()
-    const CHAT = 'cA'
-
-    driver.ingest(enqueue(CHAT), null)
-    driver.ingest(
-      {
-        kind: 'tool_use',
-        toolName: 'Agent',
-        toolUseId: 'tu1',
-        input: { prompt: 'bg', run_in_background: true },
-      },
-      CHAT,
-    )
-    driver.ingest({ kind: 'sub_agent_started', agentId: 'saBG', firstPromptText: 'bg' }, CHAT)
-    driver.ingest({ kind: 'tool_use', toolName: 'mcp__switchroom-telegram__reply' }, CHAT)
-    driver.recordOutboundDelivered(CHAT)
-    driver.ingest({ kind: 'turn_end', durationMs: 100 }, CHAT)
-
-    expect(maps.chats.size).toBe(1)
-    const turnKey = [...maps.chats.keys()][0]
-    const cs = maps.chats.get(turnKey) as { pendingCompletion: boolean; apiFailures: { terminal: boolean } }
-    expect(cs.pendingCompletion).toBe(true)
-
-    // Hammer reportApiFailure past the threshold (3).
-    for (let i = 0; i < 5; i++) {
-      driver.reportApiFailure(turnKey, {
-        kind: 'permanent_4xx',
-        code: 400,
-        description: 'bad request',
-      })
-    }
-    expect(cs.apiFailures.terminal).toBe(true)
-    // No completion fired yet — bg still running.
-    expect(completions.length).toBe(0)
-
-    // Resolve the bg sub-agent. The originating turn must complete
-    // exactly once.
-    driver.ingest({ kind: 'sub_agent_turn_end', agentId: 'saBG' }, CHAT)
-    expect(completions.length).toBe(1)
-    expect(completions[0]).toBe(turnKey)
-  })
-})