switchroom 0.5.0

package/telegram-plugin/tests/reply-terminal-reaction.test.ts

@@ -0,0 +1,149 @@
+/**
+ * PR #602 follow-up — plain `reply` tool must fire the terminal 👍
+ * reaction on real delivery (post-sendMessage), mirroring Bug Z's
+ * stream_reply contract.
+ *
+ * Background. Bug D removed the premature `setDone()` call from the
+ * gateway's turn-flush dedup-suppress branch (it was firing 👍 off a
+ * 500ms-lagged read of local history rather than from a real Telegram
+ * delivery confirmation). Bug Z then wired stream_reply's
+ * post-finalize callback to fire `endStatusReaction('done')` on
+ * delivery.
+ *
+ * That left a regression: turns whose only outbound came through the
+ * plain `reply` tool (not `stream_reply`) had no remaining 👍 emitter
+ * — the dedup branch's setDone was the only thing firing for that
+ * path, and removing it meant reply-only turns silently lost their
+ * terminal reaction.
+ *
+ * The follow-up wires `executeReply` to call
+ * `endStatusReaction(chat_id, threadId, 'done')` after at least one
+ * `bot.api.sendMessage` resolves successfully (i.e. `sentIds.length
+ * > 0`). The reply tool has no lane concept (unlike stream_reply, where
+ * named lanes like 'progress'/'thinking' are internal driver emits),
+ * so no lane gate is needed — every reply is by definition the
+ * user-visible answer.
+ *
+ * The gateway IIFE / executeReply body are too entangled to import
+ * directly. Following the same pattern as
+ * `turn-flush-dedup-controller.test.ts`, we model the contract as a
+ * pure function below and pin the post-fix invariant. If executeReply
+ * is ever refactored to extract this branch, the same assertions
+ * apply unchanged.
+ */
+import { describe, it, expect, vi } from 'vitest'
+
+interface ReplyTerminalDeps {
+  endStatusReaction: (chatId: string, threadId: number | undefined, outcome: 'done' | 'error') => void
+  writeError: (line: string) => void
+}
+
+/**
+ * Extract of the gateway executeReply post-send block. Mirrors the
+ * code at `telegram-plugin/gateway/gateway.ts` (post-fix, in the
+ * `if (sentIds.length > 0) { ... }` block after the send loop).
+ *
+ * Returns true if the terminal 👍 was fired.
+ */
+function applyReplyTerminalReaction(
+  chatId: string,
+  threadId: number | undefined,
+  sentIdsLength: number,
+  deps: ReplyTerminalDeps,
+): boolean {
+  if (sentIdsLength <= 0) return false
+  try {
+    deps.endStatusReaction(chatId, threadId, 'done')
+    return true
+  } catch (err) {
+    deps.writeError(`telegram gateway: reply: endStatusReaction hook threw: ${err}\n`)
+    return false
+  }
+}
+
+describe('PR #602 follow-up — plain reply tool terminal 👍', () => {
+  it('fires endStatusReaction("done") after at least one chunk lands', () => {
+    const endStatusReaction = vi.fn()
+    const writeError = vi.fn()
+
+    const fired = applyReplyTerminalReaction('-100', 42, 1, {
+      endStatusReaction,
+      writeError,
+    })
+
+    expect(fired).toBe(true)
+    expect(endStatusReaction).toHaveBeenCalledTimes(1)
+    expect(endStatusReaction).toHaveBeenCalledWith('-100', 42, 'done')
+    expect(writeError).not.toHaveBeenCalled()
+  })
+
+  it('passes threadId=undefined through unchanged for non-forum chats', () => {
+    // Plain DMs and non-forum supergroups don't carry a thread id —
+    // the controller key is `chatId:_`, not `chatId:<thread>`. Pin
+    // that the wiring forwards undefined rather than coercing to 0.
+    const endStatusReaction = vi.fn()
+    const writeError = vi.fn()
+
+    applyReplyTerminalReaction('123', undefined, 3, {
+      endStatusReaction,
+      writeError,
+    })
+
+    expect(endStatusReaction).toHaveBeenCalledWith('123', undefined, 'done')
+  })
+
+  it('does NOT fire when sentIds is empty (zero successful sends)', () => {
+    // The send loop's catch arm rethrows on persistent failure; we
+    // never reach the post-send block in that case. But pin the
+    // gating invariant: sentIds.length > 0 is the necessary
+    // precondition. A reply that fails before any chunk lands must
+    // not claim delivery.
+    const endStatusReaction = vi.fn()
+    const writeError = vi.fn()
+
+    const fired = applyReplyTerminalReaction('-200', undefined, 0, {
+      endStatusReaction,
+      writeError,
+    })
+
+    expect(fired).toBe(false)
+    expect(endStatusReaction).not.toHaveBeenCalled()
+  })
+
+  it('swallows endStatusReaction throws and surfaces them via writeError', () => {
+    // Defence-in-depth: the controller lookup may race a concurrent
+    // purge. The reply path must not surface a status-reaction
+    // bookkeeping failure to the agent — the message itself already
+    // landed. Pin that the throw is logged, not propagated.
+    const endStatusReaction = vi.fn(() => {
+      throw new Error('controller missing')
+    })
+    const writeError = vi.fn()
+
+    const fired = applyReplyTerminalReaction('-300', undefined, 1, {
+      endStatusReaction,
+      writeError,
+    })
+
+    expect(fired).toBe(false)
+    expect(endStatusReaction).toHaveBeenCalledTimes(1)
+    expect(writeError).toHaveBeenCalledTimes(1)
+    expect(writeError.mock.calls[0][0]).toMatch(/endStatusReaction hook threw/)
+  })
+
+  it('fires for multi-chunk replies as well as single-chunk', () => {
+    // Long replies are split across multiple sendMessage calls. As
+    // long as at least one chunk landed, the user saw the answer —
+    // the terminal 👍 reflects "delivered", not "delivered in one
+    // piece".
+    const endStatusReaction = vi.fn()
+    const writeError = vi.fn()
+
+    applyReplyTerminalReaction('-400', 7, 5, {
+      endStatusReaction,
+      writeError,
+    })
+
+    expect(endStatusReaction).toHaveBeenCalledWith('-400', 7, 'done')
+  })
+})

package/telegram-plugin/tests/resolve-calling-subagent.test.ts

@@ -0,0 +1,269 @@
+/**
+ * Unit tests for resolveCallingSubagent (issue #305 Option A).
+ *
+ * The resolver picks which sub-agent's row body should host the
+ * progress_update narrative when called from a sub-agent context.
+ * Resolution priority:
+ *   1. agentIdHint  → exact match on subagents.jsonl_agent_id
+ *   2. toolUseIdHint → exact match on subagents.id
+ *   3. Heuristic   → most-recently-started running sub-agent in the active turn
+ *
+ * Tests run against an in-memory bun:sqlite DB with the same schema that
+ * production uses (turns + subagents tables). Run via:
+ *   bun test telegram-plugin/tests/resolve-calling-subagent.test.ts
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import {
+  openSubagentsDbInMemory,
+  recordSubagentStart,
+} from '../registry/subagents-schema.js'
+import { resolveCallingSubagent } from '../gateway/resolve-calling-subagent.js'
+
+type Db = ReturnType<typeof openSubagentsDbInMemory>
+
+function insertOpenTurn(db: Db, turnKey: string, chatId: string, startedAt: number): void {
+  db.prepare(`
+    INSERT INTO turns
+      (turn_key, chat_id, thread_id, started_at, last_user_msg_id, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(turnKey, chatId, null, startedAt, 'msg-1', startedAt, startedAt)
+}
+
+describe('resolveCallingSubagent', () => {
+  let db: Db
+
+  beforeEach(() => {
+    db = openSubagentsDbInMemory()
+  })
+
+  afterEach(() => {
+    db.close()
+  })
+
+  it('returns null when db is null', () => {
+    const result = resolveCallingSubagent({
+      db: null,
+      chatId: 'c1',
+      agentIdHint: 'jsonl-1',
+      toolUseIdHint: null,
+    })
+    expect(result).toBeNull()
+  })
+
+  it('matches by agentIdHint (jsonl_agent_id)', () => {
+    insertOpenTurn(db, 'c1:1', 'c1', 1000)
+    recordSubagentStart(db, {
+      id: 'toolu_alpha',
+      parentTurnKey: 'c1:1',
+      jsonlAgentId: 'jsonl-alpha',
+      background: false,
+      startedAt: 1100,
+    })
+    recordSubagentStart(db, {
+      id: 'toolu_beta',
+      parentTurnKey: 'c1:1',
+      jsonlAgentId: 'jsonl-beta',
+      background: false,
+      startedAt: 1200,
+    })
+
+    const result = resolveCallingSubagent({
+      db,
+      chatId: 'c1',
+      agentIdHint: 'jsonl-alpha',
+      toolUseIdHint: null,
+    })
+    expect(result).toEqual({ agentId: 'jsonl-alpha' })
+  })
+
+  it('agentIdHint miss on completed sub-agent does NOT match (only running rows)', () => {
+    insertOpenTurn(db, 'c1:1', 'c1', 1000)
+    recordSubagentStart(db, {
+      id: 'toolu_done',
+      parentTurnKey: 'c1:1',
+      jsonlAgentId: 'jsonl-done',
+      background: false,
+      startedAt: 1100,
+    })
+    // Mark as completed via direct SQL.
+    db.prepare("UPDATE subagents SET status = 'completed', ended_at = 2000 WHERE id = ?")
+      .run('toolu_done')
+
+    const result = resolveCallingSubagent({
+      db,
+      chatId: 'c1',
+      agentIdHint: 'jsonl-done',
+      toolUseIdHint: null,
+    })
+    expect(result).toBeNull()
+  })
+
+  it('matches by toolUseIdHint (subagents.id) when agentIdHint absent', () => {
+    insertOpenTurn(db, 'c1:1', 'c1', 1000)
+    recordSubagentStart(db, {
+      id: 'toolu_via_id',
+      parentTurnKey: 'c1:1',
+      jsonlAgentId: 'jsonl-via-id',
+      background: false,
+      startedAt: 1100,
+    })
+
+    const result = resolveCallingSubagent({
+      db,
+      chatId: 'c1',
+      agentIdHint: null,
+      toolUseIdHint: 'toolu_via_id',
+    })
+    expect(result).toEqual({ agentId: 'jsonl-via-id' })
+  })
+
+  it('heuristic fallback: returns most-recently-started running sub-agent in active turn', () => {
+    insertOpenTurn(db, 'c1:1', 'c1', 1000)
+    recordSubagentStart(db, {
+      id: 'toolu_old',
+      parentTurnKey: 'c1:1',
+      jsonlAgentId: 'jsonl-old',
+      background: false,
+      startedAt: 1100,
+    })
+    recordSubagentStart(db, {
+      id: 'toolu_new',
+      parentTurnKey: 'c1:1',
+      jsonlAgentId: 'jsonl-new',
+      background: false,
+      startedAt: 1500, // strictly newer
+    })
+
+    const result = resolveCallingSubagent({
+      db,
+      chatId: 'c1',
+      agentIdHint: null,
+      toolUseIdHint: null,
+    })
+    expect(result).toEqual({ agentId: 'jsonl-new' })
+  })
+
+  it('heuristic skips sub-agents without jsonl_agent_id', () => {
+    insertOpenTurn(db, 'c1:1', 'c1', 1000)
+    recordSubagentStart(db, {
+      id: 'toolu_nojson',
+      parentTurnKey: 'c1:1',
+      jsonlAgentId: null,
+      background: false,
+      startedAt: 1500,
+    })
+    recordSubagentStart(db, {
+      id: 'toolu_withjson',
+      parentTurnKey: 'c1:1',
+      jsonlAgentId: 'jsonl-resolved',
+      background: false,
+      startedAt: 1100,
+    })
+
+    const result = resolveCallingSubagent({
+      db,
+      chatId: 'c1',
+      agentIdHint: null,
+      toolUseIdHint: null,
+    })
+    expect(result).toEqual({ agentId: 'jsonl-resolved' })
+  })
+
+  it('heuristic returns null when no active turn exists', () => {
+    // Insert an ENDED turn.
+    db.prepare(`
+      INSERT INTO turns
+        (turn_key, chat_id, thread_id, started_at, ended_at, last_user_msg_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run('c1:1', 'c1', null, 1000, 2000, 'msg-1', 1000, 2000)
+    recordSubagentStart(db, {
+      id: 'toolu_orphan',
+      parentTurnKey: 'c1:1',
+      jsonlAgentId: 'jsonl-orphan',
+      background: false,
+      startedAt: 1100,
+    })
+
+    const result = resolveCallingSubagent({
+      db,
+      chatId: 'c1',
+      agentIdHint: null,
+      toolUseIdHint: null,
+    })
+    expect(result).toBeNull()
+  })
+
+  it('heuristic returns null when no running sub-agents in active turn', () => {
+    insertOpenTurn(db, 'c1:1', 'c1', 1000)
+    // No sub-agents inserted.
+    const result = resolveCallingSubagent({
+      db,
+      chatId: 'c1',
+      agentIdHint: null,
+      toolUseIdHint: null,
+    })
+    expect(result).toBeNull()
+  })
+
+  it('heuristic ignores sub-agents from a different chat', () => {
+    insertOpenTurn(db, 'c1:1', 'c1', 1000)
+    insertOpenTurn(db, 'c2:1', 'c2', 1000)
+    recordSubagentStart(db, {
+      id: 'toolu_other',
+      parentTurnKey: 'c2:1',
+      jsonlAgentId: 'jsonl-other-chat',
+      background: false,
+      startedAt: 1100,
+    })
+
+    const result = resolveCallingSubagent({
+      db,
+      chatId: 'c1',
+      agentIdHint: null,
+      toolUseIdHint: null,
+    })
+    expect(result).toBeNull()
+  })
+
+  it('agentIdHint takes priority over toolUseIdHint and heuristic', () => {
+    insertOpenTurn(db, 'c1:1', 'c1', 1000)
+    recordSubagentStart(db, {
+      id: 'toolu_priority',
+      parentTurnKey: 'c1:1',
+      jsonlAgentId: 'jsonl-priority',
+      background: false,
+      startedAt: 1100,
+    })
+    recordSubagentStart(db, {
+      id: 'toolu_other',
+      parentTurnKey: 'c1:1',
+      jsonlAgentId: 'jsonl-other',
+      background: false,
+      startedAt: 1500, // newer; would win heuristic
+    })
+
+    const result = resolveCallingSubagent({
+      db,
+      chatId: 'c1',
+      agentIdHint: 'jsonl-priority',
+      toolUseIdHint: 'toolu_other',
+    })
+    expect(result).toEqual({ agentId: 'jsonl-priority' })
+  })
+
+  it('returns null on SQL error (broken db.prepare)', () => {
+    const brokenDb = {
+      prepare: (): never => {
+        throw new Error('boom')
+      },
+    }
+    const result = resolveCallingSubagent({
+      db: brokenDb as unknown as Parameters<typeof resolveCallingSubagent>[0]['db'],
+      chatId: 'c1',
+      agentIdHint: 'whatever',
+      toolUseIdHint: null,
+    })
+    expect(result).toBeNull()
+  })
+})

package/telegram-plugin/tests/restart-watchdog.test.ts

@@ -0,0 +1,224 @@
+/**
+ * Tests for the restart-watchdog decision logic + systemd output parsing.
+ * Issue #92 + #30 task 4 — surface unexpected systemd-driven agent
+ * restarts as `agent-restarted-unexpectedly` operator events.
+ *
+ * The pure decision function `decideWatchdogTick` is the hot path here.
+ * The polling integration (timers, execFileSync) is exercised via the
+ * `startRestartWatchdog` smoke test with injected callbacks.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  parseSystemdShowOutput,
+  decideWatchdogTick,
+  startRestartWatchdog,
+  type SystemdShowResult,
+} from '../gateway/restart-watchdog.js'
+
+// ─── parseSystemdShowOutput ───────────────────────────────────────────────────
+
+describe('parseSystemdShowOutput', () => {
+  it('parses the canonical two-line output', () => {
+    const raw = 'NRestarts=3\nActiveEnterTimestampMonotonic=12345678\n'
+    expect(parseSystemdShowOutput(raw)).toEqual({
+      nRestarts: 3,
+      activeEnterTimestampMonotonic: 12345678,
+    })
+  })
+
+  it('handles CRLF line endings', () => {
+    const raw = 'NRestarts=0\r\nActiveEnterTimestampMonotonic=999\r\n'
+    expect(parseSystemdShowOutput(raw)).toEqual({
+      nRestarts: 0,
+      activeEnterTimestampMonotonic: 999,
+    })
+  })
+
+  it('ignores unrelated keys interleaved by systemctl', () => {
+    const raw = [
+      'Description=switchroom-gymbro',
+      'NRestarts=2',
+      'ActiveState=active',
+      'ActiveEnterTimestampMonotonic=42',
+      'SubState=running',
+    ].join('\n')
+    expect(parseSystemdShowOutput(raw)?.nRestarts).toBe(2)
+    expect(parseSystemdShowOutput(raw)?.activeEnterTimestampMonotonic).toBe(42)
+  })
+
+  it('returns null when NRestarts is missing', () => {
+    expect(parseSystemdShowOutput('ActiveEnterTimestampMonotonic=1\n')).toBeNull()
+  })
+
+  it('returns null when ActiveEnterTimestampMonotonic is missing', () => {
+    expect(parseSystemdShowOutput('NRestarts=1\n')).toBeNull()
+  })
+
+  it('returns null on empty input', () => {
+    expect(parseSystemdShowOutput('')).toBeNull()
+  })
+
+  it('returns null when values are unparseable', () => {
+    expect(parseSystemdShowOutput('NRestarts=foo\nActiveEnterTimestampMonotonic=42\n')).toBeNull()
+    expect(parseSystemdShowOutput('NRestarts=-1\nActiveEnterTimestampMonotonic=42\n')).toBeNull()
+  })
+})
+
+// ─── decideWatchdogTick ───────────────────────────────────────────────────────
+
+function snap(nRestarts: number, activeEnter = 1000): SystemdShowResult {
+  return { nRestarts, activeEnterTimestampMonotonic: activeEnter }
+}
+
+describe('decideWatchdogTick', () => {
+  it('first tick after boot just records the baseline (no emit)', () => {
+    const decision = decideWatchdogTick({
+      current: snap(5),
+      previous: null,
+      recentPlannedRestart: false,
+    })
+    expect(decision.emit).toBe(false)
+    expect(decision.nextSnapshot).toEqual(snap(5))
+  })
+
+  it('no change in NRestarts → no emit', () => {
+    const decision = decideWatchdogTick({
+      current: snap(3),
+      previous: snap(3),
+      recentPlannedRestart: false,
+    })
+    expect(decision.emit).toBe(false)
+  })
+
+  it('NRestarts increased + no planned-restart marker → emit', () => {
+    const decision = decideWatchdogTick({
+      current: snap(4),
+      previous: snap(3),
+      recentPlannedRestart: false,
+    })
+    expect(decision.emit).toBe(true)
+    expect(decision.detail).toContain('unexpectedly')
+    expect(decision.nextSnapshot).toEqual(snap(4))
+  })
+
+  it('NRestarts increased + planned-restart marker present → no emit, but advances baseline', () => {
+    const decision = decideWatchdogTick({
+      current: snap(4),
+      previous: snap(3),
+      recentPlannedRestart: true,
+    })
+    expect(decision.emit).toBe(false)
+    expect(decision.detail).toContain('planned restart')
+    // The baseline MUST advance even on suppressed emits — otherwise the
+    // next tick (post-marker-clear) would re-emit the same delta.
+    expect(decision.nextSnapshot).toEqual(snap(4))
+  })
+
+  it('multi-restart delta > 1 → emit with count in detail', () => {
+    const decision = decideWatchdogTick({
+      current: snap(7),
+      previous: snap(3),
+      recentPlannedRestart: false,
+    })
+    expect(decision.emit).toBe(true)
+    expect(decision.detail).toContain('4 times')
+  })
+
+  it('NRestarts went DOWN (unit reloaded) → no emit', () => {
+    // Counter resets on `daemon-reload`. Don't crash; just rebaseline.
+    const decision = decideWatchdogTick({
+      current: snap(0),
+      previous: snap(5),
+      recentPlannedRestart: false,
+    })
+    expect(decision.emit).toBe(false)
+    expect(decision.nextSnapshot).toEqual(snap(0))
+  })
+})
+
+// ─── startRestartWatchdog (smoke test) ───────────────────────────────────────
+
+describe('startRestartWatchdog', () => {
+  it('disabled when pollIntervalMs is 0', () => {
+    const emit = vi.fn()
+    const handle = startRestartWatchdog({
+      agentName: 'gymbro',
+      pollIntervalMs: 0,
+      execShow: () => 'NRestarts=0\nActiveEnterTimestampMonotonic=0\n',
+      isPlannedRestartFresh: () => false,
+      emit,
+    })
+    expect(emit).not.toHaveBeenCalled()
+    handle.stop()
+  })
+
+  it('first tick establishes baseline; second tick fires on delta', async () => {
+    let nRestarts = 0
+    const emit = vi.fn()
+    const handle = startRestartWatchdog({
+      agentName: 'gymbro',
+      pollIntervalMs: 5,  // tight interval for the test
+      execShow: () => `NRestarts=${nRestarts}\nActiveEnterTimestampMonotonic=1\n`,
+      isPlannedRestartFresh: () => false,
+      emit,
+    })
+    // First tick (synchronous in startRestartWatchdog) sets baseline at 0.
+    expect(emit).not.toHaveBeenCalled()
+
+    // Bump and wait for the next interval.
+    nRestarts = 1
+    await new Promise((r) => setTimeout(r, 30))
+
+    expect(emit).toHaveBeenCalledTimes(1)
+    expect(emit.mock.calls[0][0]).toContain('unexpectedly')
+
+    handle.stop()
+  })
+
+  it('skips ticks where execShow throws (no emit, no crash)', async () => {
+    const emit = vi.fn()
+    const handle = startRestartWatchdog({
+      agentName: 'gymbro',
+      pollIntervalMs: 5,
+      execShow: () => {
+        throw new Error('systemctl not found')
+      },
+      isPlannedRestartFresh: () => false,
+      emit,
+    })
+    await new Promise((r) => setTimeout(r, 30))
+    expect(emit).not.toHaveBeenCalled()
+    handle.stop()
+  })
+
+  it('skips ticks where systemctl returns garbage (parse fails)', async () => {
+    const emit = vi.fn()
+    const handle = startRestartWatchdog({
+      agentName: 'gymbro',
+      pollIntervalMs: 5,
+      execShow: () => 'this is not key=value output',
+      isPlannedRestartFresh: () => false,
+      emit,
+    })
+    await new Promise((r) => setTimeout(r, 30))
+    expect(emit).not.toHaveBeenCalled()
+    handle.stop()
+  })
+
+  it('does not emit when the planned-restart marker is fresh', async () => {
+    let nRestarts = 0
+    const emit = vi.fn()
+    const handle = startRestartWatchdog({
+      agentName: 'gymbro',
+      pollIntervalMs: 5,
+      execShow: () => `NRestarts=${nRestarts}\nActiveEnterTimestampMonotonic=1\n`,
+      isPlannedRestartFresh: () => true,
+      emit,
+    })
+    nRestarts = 1
+    await new Promise((r) => setTimeout(r, 30))
+    expect(emit).not.toHaveBeenCalled()
+    handle.stop()
+  })
+})