switchroom 0.5.0 → 0.7.8

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

@@ -0,0 +1,145 @@
+/**
+ * Tests for the structured card-event logger — the audit trail for the
+ * pinned progress card lifecycle. Mirrors `pin-event-log.test.ts`.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, readFileSync, existsSync, rmSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import {
+  logCardEvent,
+  emitCardEvent,
+  resolveCardEventPath,
+  _resetForTests,
+  type CardEvent,
+} from '../card-event-log.js'
+
+let tmpDir: string
+const prevStateDir = process.env.STATE_DIR
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), 'card-event-log-'))
+  _resetForTests()
+})
+
+afterEach(() => {
+  _resetForTests()
+  if (prevStateDir === undefined) delete process.env.STATE_DIR
+  else process.env.STATE_DIR = prevStateDir
+  try { rmSync(tmpDir, { recursive: true, force: true }) } catch { /* ignore */ }
+})
+
+describe('logCardEvent (injected writer)', () => {
+  it('writes one JSON line per call', () => {
+    const lines: string[] = []
+    const ev: CardEvent = {
+      ts: 1700000000000,
+      agent: 'klanker',
+      chatId: '100',
+      turnKey: '100::1',
+      cardMessageId: 4242,
+      event: 'rendered',
+      htmlHash: 'abc123def456',
+    }
+    logCardEvent(ev, (l) => lines.push(l))
+    expect(lines).toHaveLength(1)
+    expect(lines[0].endsWith('\n')).toBe(true)
+    const payload = JSON.parse(lines[0].trimEnd())
+    expect(payload).toEqual(ev)
+  })
+
+  it('omits undefined optional fields cleanly', () => {
+    const lines: string[] = []
+    logCardEvent(
+      {
+        ts: 1,
+        agent: 'a',
+        chatId: 'c',
+        turnKey: 'c::1',
+        event: 'finalized',
+      },
+      (l) => lines.push(l),
+    )
+    const raw = lines[0].trimEnd()
+    expect(raw).not.toContain('undefined')
+    const payload = JSON.parse(raw)
+    expect(payload.cardMessageId).toBeUndefined()
+    expect(payload.reason).toBeUndefined()
+    expect(payload.subagents).toBeUndefined()
+  })
+
+  it('preserves subagents array and durationMs', () => {
+    const lines: string[] = []
+    logCardEvent(
+      {
+        ts: 2,
+        agent: 'a',
+        chatId: 'c',
+        turnKey: 'c::1',
+        event: 'deferred',
+        reason: 'in-flight-sub-agents',
+        subagents: ['agent-1', 'agent-2'],
+        durationMs: 12345,
+      },
+      (l) => lines.push(l),
+    )
+    const payload = JSON.parse(lines[0].trimEnd())
+    expect(payload.subagents).toEqual(['agent-1', 'agent-2'])
+    expect(payload.durationMs).toBe(12345)
+    expect(payload.reason).toBe('in-flight-sub-agents')
+  })
+})
+
+describe('emitCardEvent', () => {
+  it('fills ts when omitted', () => {
+    const lines: string[] = []
+    const before = Date.now()
+    emitCardEvent(
+      { agent: 'a', chatId: 'c', turnKey: 'c::1', event: 'edited' },
+      (l) => lines.push(l),
+    )
+    const after = Date.now()
+    const payload = JSON.parse(lines[0].trimEnd())
+    expect(payload.ts).toBeGreaterThanOrEqual(before)
+    expect(payload.ts).toBeLessThanOrEqual(after)
+  })
+
+  it('respects an explicit ts', () => {
+    const lines: string[] = []
+    emitCardEvent(
+      { ts: 999, agent: 'a', chatId: 'c', turnKey: 'c::1', event: 'edited' },
+      (l) => lines.push(l),
+    )
+    expect(JSON.parse(lines[0].trimEnd()).ts).toBe(999)
+  })
+})
+
+describe('resolveCardEventPath', () => {
+  it('returns <STATE_DIR>/card-events.jsonl when STATE_DIR is set', () => {
+    expect(resolveCardEventPath({ STATE_DIR: '/tmp/x' })).toBe('/tmp/x/card-events.jsonl')
+  })
+
+  it('returns null when STATE_DIR is unset', () => {
+    expect(resolveCardEventPath({})).toBeNull()
+  })
+
+  it('returns null when STATE_DIR is empty', () => {
+    expect(resolveCardEventPath({ STATE_DIR: '' })).toBeNull()
+  })
+})
+
+describe('default writer (filesystem)', () => {
+  it('appends to <STATE_DIR>/card-events.jsonl when STATE_DIR is set', () => {
+    process.env.STATE_DIR = tmpDir
+    _resetForTests()
+    emitCardEvent({ agent: 'a', chatId: 'c', turnKey: 'c::1', event: 'rendered' })
+    emitCardEvent({ agent: 'a', chatId: 'c', turnKey: 'c::1', event: 'finalized' })
+    const target = join(tmpDir, 'card-events.jsonl')
+    expect(existsSync(target)).toBe(true)
+    const contents = readFileSync(target, 'utf8').trimEnd().split('\n')
+    expect(contents).toHaveLength(2)
+    expect(JSON.parse(contents[0]).event).toBe('rendered')
+    expect(JSON.parse(contents[1]).event).toBe('finalized')
+  })
+})

package/telegram-plugin/tests/gateway-startup-mutex.test.ts

@@ -166,6 +166,108 @@ describe("acquireStartupLock", () => {
     expect(acquired).toContain(`pid=${ourPid}`);
   });
 
+  it("(c.boot-id) auto-recovers a lock from a different boot, even if the recorded PID number is alive (#884)", async () => {
+    // Reproduces the v0.7 docker container-restart bug: the previous
+    // gateway lived in a now-gone container's PID namespace and was
+    // PID 10. The new container's PID 10 is some unrelated process
+    // (autoaccept-poll, tini's child, etc.). isPidAlive(10) reports
+    // alive, but the holder isn't actually the gateway — it's a stale
+    // record from a different boot. Pre-#884 this caused the new
+    // gateway to report blocked, retry 10x, then exit non-zero with
+    // "another_gateway_is_live" — leaving the agent without a
+    // gateway daemon.
+    const { dir, path } = tmpLockPath();
+    cleanups.push(dir);
+    const collidingPid = 10;
+    const stale = { ...makeRecord(collidingPid, Date.now() - 5_000_000), bootId: "pid1:111111111" };
+    writeFileSync(path, JSON.stringify(stale), "utf-8");
+
+    const { lines, log } = noopLog();
+    const result = await acquireStartupLock({
+      path,
+      record: makeRecord(99999),
+      // Inject a DIFFERENT current bootId (this is what readCurrentBootId
+      // would return inside a fresh container).
+      currentBootId: "pid1:222222222",
+      // Crucially: report the holder PID as ALIVE — the bug was that the
+      // PID number is reused by an unrelated current-namespace process.
+      isPidAlive: () => true,
+      log,
+      agentName: "test-agent",
+    });
+
+    expect(result.status).toBe("acquired");
+    if (result.status !== "acquired") throw new Error("unreachable");
+    expect(result.recoveredFrom).toBeDefined();
+    expect(result.recoveredFrom?.pid).toBe(collidingPid);
+    expect(result.recoveredFrom?.bootId).toBe("pid1:111111111");
+
+    // Our record should now own the file AND carry the new bootId so
+    // future boots can apply the same gate.
+    const onDisk = JSON.parse(readFileSync(path, "utf-8")) as MutexRecord;
+    expect(onDisk.pid).toBe(99999);
+    expect(onDisk.bootId).toBe("pid1:222222222");
+
+    const recovered = lines.find((l) => l.includes("boot.lock_stale_recovered_boot_mismatch"));
+    expect(recovered).toBeDefined();
+    expect(recovered).toContain(`prior_pid=${collidingPid}`);
+    expect(recovered).toContain("prior_boot=pid1:111111111");
+    expect(recovered).toContain("current_boot=pid1:222222222");
+
+    // Should NOT have logged boot.lock_blocked — that's the bug we're
+    // pinning against.
+    const blocked = lines.find((l) => l.includes("boot.lock_blocked"));
+    expect(blocked).toBeUndefined();
+  });
+
+  it("(c.legacy-record) falls back to PID check when the existing record predates the bootId field", async () => {
+    // Records written by pre-#884 gateways have no bootId. We must
+    // preserve the legacy kill-based check for those — otherwise an
+    // upgrade would treat every legacy live holder as stale and
+    // potentially clobber a working sibling.
+    const { dir, path } = tmpLockPath();
+    cleanups.push(dir);
+    const livePid = 12345;
+    const legacy = makeRecord(livePid, Date.now() - 5000); // no bootId
+    writeFileSync(path, JSON.stringify(legacy), "utf-8");
+
+    const { log } = noopLog();
+    const result = await acquireStartupLock({
+      path,
+      record: makeRecord(99999),
+      currentBootId: "pid1:any",
+      isPidAlive: (pid) => pid === livePid,
+      log,
+      agentName: "test-agent",
+    });
+
+    expect(result.status).toBe("blocked");
+  });
+
+  it("(c.same-boot) treats matching bootId as same-boot and trusts the PID check", async () => {
+    // Within the same container/host boot, the PID-namespace recycling
+    // problem doesn't exist. A holder record with the same bootId as
+    // ours should be evaluated by isPidAlive verbatim — both for blocked
+    // (live holder) and stale-recovered (dead holder) outcomes.
+    const { dir, path } = tmpLockPath();
+    cleanups.push(dir);
+    const livePid = 12345;
+    const sameBoot = { ...makeRecord(livePid, Date.now() - 5000), bootId: "pid1:same" };
+    writeFileSync(path, JSON.stringify(sameBoot), "utf-8");
+
+    const { log } = noopLog();
+    const result = await acquireStartupLock({
+      path,
+      record: makeRecord(99999),
+      currentBootId: "pid1:same",
+      isPidAlive: (pid) => pid === livePid,
+      log,
+      agentName: "test-agent",
+    });
+
+    expect(result.status).toBe("blocked");
+  });
+
   it("(c.bonus) double-acquire by the SAME process does NOT corrupt state", async () => {
     // Defensive: if the boot path somehow runs acquireStartupLock twice
     // in the same process, we should detect ourselves as the holder and

package/telegram-plugin/tests/ipc-server-validate-inject-inbound.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Validation contract for the Phase 2 cron-fold-in `inject_inbound`
+ * IPC message — the wire envelope the in-agent scheduler sibling
+ * uses to ask the gateway to forward a synthesized InboundMessage to
+ * a registered bridge.
+ *
+ * The gateway's `validateClientMessage` is the security boundary on
+ * the client→gateway direction. The wrapped `inbound` payload is
+ * forwarded verbatim to the bridge as a `type: "inbound"` envelope —
+ * the bridge's validateGatewayMessage runs on the other end and is
+ * lenient (only checks `chatId` + `text`), so this validator carries
+ * the structural checks the bridge silently relies on.
+ *
+ * Companion to ipc-server-validate-{operator,pty-partial,update-placeholder}.test.ts.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { validateClientMessage } from '../gateway/ipc-server.js'
+
+function baseInbound() {
+  return {
+    type: 'inbound' as const,
+    chatId: '-1001234567890',
+    messageId: 1_700_000_000_000,
+    user: 'cron',
+    userId: 0,
+    ts: 1_700_000_000_000,
+    text: 'Morning briefing',
+    meta: {
+      source: 'cron',
+      schedule_index: '0',
+      prompt_key: 'abcdef012345',
+    },
+  }
+}
+
+function base() {
+  return {
+    type: 'inject_inbound' as const,
+    agentName: 'klanker',
+    inbound: baseInbound(),
+  }
+}
+
+describe('validateClientMessage — inject_inbound', () => {
+  it('accepts a well-formed cron fire', () => {
+    expect(validateClientMessage(base())).toBe(true)
+  })
+
+  it('rejects when agentName is missing or malformed', () => {
+    const noName = { ...base() } as Record<string, unknown>
+    delete noName.agentName
+    expect(validateClientMessage(noName)).toBe(false)
+    expect(validateClientMessage({ ...base(), agentName: '' })).toBe(false)
+    // Same regex as register/heartbeat — uppercase rejected.
+    expect(validateClientMessage({ ...base(), agentName: 'Klanker' })).toBe(false)
+    // Path traversal / shell metacharacters rejected.
+    expect(validateClientMessage({ ...base(), agentName: '../etc/passwd' })).toBe(false)
+    expect(validateClientMessage({ ...base(), agentName: 'a$(rm -rf)' })).toBe(false)
+    expect(validateClientMessage({ ...base(), agentName: 42 })).toBe(false)
+  })
+
+  it('rejects when inbound is not an object', () => {
+    expect(validateClientMessage({ ...base(), inbound: null })).toBe(false)
+    expect(validateClientMessage({ ...base(), inbound: 'string' })).toBe(false)
+    expect(validateClientMessage({ ...base(), inbound: 42 })).toBe(false)
+    const noInbound = { ...base() } as Record<string, unknown>
+    delete noInbound.inbound
+    expect(validateClientMessage(noInbound)).toBe(false)
+  })
+
+  it("requires inbound.type === 'inbound'", () => {
+    expect(validateClientMessage({
+      ...base(),
+      inbound: { ...baseInbound(), type: 'permission' },
+    })).toBe(false)
+    expect(validateClientMessage({
+      ...base(),
+      inbound: { ...baseInbound(), type: 'Inbound' },
+    })).toBe(false)
+  })
+
+  it('requires non-empty inbound.chatId (string) and string inbound.text', () => {
+    expect(validateClientMessage({
+      ...base(),
+      inbound: { ...baseInbound(), chatId: '' },
+    })).toBe(false)
+    expect(validateClientMessage({
+      ...base(),
+      inbound: { ...baseInbound(), chatId: 42 },
+    })).toBe(false)
+    expect(validateClientMessage({
+      ...base(),
+      inbound: { ...baseInbound(), text: 42 },
+    })).toBe(false)
+  })
+
+  it('requires numeric messageId, userId, ts (the bridge does not coerce)', () => {
+    expect(validateClientMessage({
+      ...base(),
+      inbound: { ...baseInbound(), messageId: '0' },
+    })).toBe(false)
+    expect(validateClientMessage({
+      ...base(),
+      inbound: { ...baseInbound(), userId: '0' },
+    })).toBe(false)
+    expect(validateClientMessage({
+      ...base(),
+      inbound: { ...baseInbound(), ts: '0' },
+    })).toBe(false)
+  })
+
+  it('requires meta to be an object (Record<string, string> on the wire)', () => {
+    expect(validateClientMessage({
+      ...base(),
+      inbound: { ...baseInbound(), meta: null },
+    })).toBe(false)
+    const noMeta = { ...baseInbound() } as Record<string, unknown>
+    delete noMeta.meta
+    expect(validateClientMessage({ ...base(), inbound: noMeta })).toBe(false)
+    // Empty meta is acceptable — the gateway doesn't enforce specific keys
+    // here; meta.source filtering is policy that lives at the handler.
+    expect(validateClientMessage({
+      ...base(),
+      inbound: { ...baseInbound(), meta: {} },
+    })).toBe(true)
+  })
+
+  it('rejects unknown type aliases that look similar', () => {
+    expect(validateClientMessage({ ...base(), type: 'inject_inbounds' })).toBe(false)
+    expect(validateClientMessage({ ...base(), type: 'inject-inbound' })).toBe(false)
+    expect(validateClientMessage({ ...base(), type: 'inbound' })).toBe(false)
+  })
+})

package/telegram-plugin/tests/progress-card-delay-842.test.ts

@@ -0,0 +1,160 @@
+/**
+ * #842 — first-render delay (45s default) with explicit-background bypass.
+ *
+ * Behavioural contract:
+ *   1. Turn that ends BEFORE the threshold trips → no card emit at all.
+ *   2. Turn that runs PAST the threshold → exactly one card emit at the
+ *      threshold, rendering the full buffered event stream (verified by
+ *      checking the rendered HTML reflects accumulated state).
+ *   3. Explicit `Agent({ run_in_background: true })` dispatch with
+ *      `delay_ms_background=0` → card emits immediately on the
+ *      tool_use, regardless of the long `delay_ms` budget.
+ *   4. Threshold timer is cleared on early turn_end (no late phantom
+ *      emit when wall-clock advances past the threshold afterwards).
+ *   5. Pre-threshold buffer matches post-threshold render — i.e. the
+ *      first emit's HTML reflects every tool_use that landed during
+ *      the suppression window (no events lost).
+ */
+
+import { describe, it, expect } from 'vitest'
+import { makeHarness, enqueue } from './_progress-card-harness.js'
+import type { SessionEvent } from '../session-tail.js'
+
+const tu = (
+  toolName: string,
+  toolUseId: string,
+  input: Record<string, unknown> = {},
+): SessionEvent => ({
+  kind: 'tool_use',
+  toolName,
+  toolUseId,
+  input,
+})
+
+const tr = (toolUseId: string): SessionEvent => ({
+  kind: 'tool_result',
+  toolUseId,
+  isError: false,
+  errorText: null,
+})
+
+describe('#842 progress-card first-render delay', () => {
+  it('AC2 + AC6: turn ends BEFORE the 45s threshold → no card is ever posted', () => {
+    const { driver, emits, advance } = makeHarness({ initialDelayMs: 45_000 })
+    driver.ingest(enqueue('chat-fast'), null)
+    advance(5_000)
+    driver.ingest(tu('Read', 'tu1', { file_path: '/tmp/a.ts' }), 'chat-fast')
+    advance(10_000)
+    driver.ingest(tr('tu1'), 'chat-fast')
+    advance(10_000)
+    driver.ingest({ kind: 'turn_end' }, 'chat-fast')
+    // Turn finished at t=25s — well before 45s. No card should have
+    // been emitted, and no late phantom emit when we keep the clock
+    // running.
+    advance(60_000)
+    expect(emits.length).toBe(0)
+  })
+
+  it('AC3 + AC6: turn that crosses 45s → one card emit at threshold, full backfill', () => {
+    const { driver, emits, advance } = makeHarness({ initialDelayMs: 45_000 })
+    driver.ingest(enqueue('chat-long'), null)
+    // Buffer some events through the suppression window.
+    advance(10_000)
+    driver.ingest(tu('Read', 'tu1', { file_path: '/tmp/a.ts' }), 'chat-long')
+    advance(10_000)
+    driver.ingest(tr('tu1'), 'chat-long')
+    advance(10_000)
+    driver.ingest(tu('Bash', 'tu2', { description: 'check commits' }), 'chat-long')
+    // No emits yet — still within the 45s window.
+    expect(emits.length).toBe(0)
+    // Cross the threshold.
+    advance(20_000) // total elapsed ~50s
+    // Exactly one initial emit at threshold, rendering the buffered
+    // state. The first emit must reflect the tool_use accumulation
+    // that happened during the suppression window — i.e. the renderer
+    // saw the buffer.
+    expect(emits.length).toBeGreaterThanOrEqual(1)
+    const first = emits[0]
+    expect(first.html.length).toBeGreaterThan(0)
+    // Buffer included a Bash with a human description — render must
+    // include the description text (non-trivial: proves the reducer
+    // ate the events before the first flush). This is the
+    // "pre-threshold buffer matches post-threshold render" assertion.
+    expect(first.html).toContain('check commits')
+  })
+
+  it('AC4: explicit Agent({run_in_background:true}) bypasses the long delay', () => {
+    const { driver, emits, advance } = makeHarness({
+      initialDelayMs: 45_000,
+      initialDelayMsBackground: 0,
+    })
+    driver.ingest(enqueue('chat-bg'), null)
+    advance(2_000)
+    driver.ingest(
+      tu('Agent', 'tu-bg', {
+        prompt: 'do bg work',
+        description: 'bg-job',
+        run_in_background: true,
+      }),
+      'chat-bg',
+    )
+    // Card should emit immediately — no need to advance the clock.
+    expect(emits.length).toBeGreaterThanOrEqual(1)
+    expect(emits[0].html.length).toBeGreaterThan(0)
+  })
+
+  it('AC4 (foreground variant): non-background Agent does NOT bypass the delay', () => {
+    const { driver, emits, advance } = makeHarness({
+      initialDelayMs: 45_000,
+      initialDelayMsBackground: 0,
+    })
+    driver.ingest(enqueue('chat-fg'), null)
+    advance(2_000)
+    driver.ingest(
+      tu('Agent', 'tu-fg', { prompt: 'p', description: 'fg-job' }),
+      'chat-fg',
+    )
+    // No emit yet — foreground Agent should follow the 45s rule.
+    // (`promoteOnSubAgent` only fires once `sub_agent_started` lands;
+    // this test stops at the parent tool_use to isolate the
+    // background-bypass branch.)
+    expect(emits.length).toBe(0)
+  })
+
+  it('AC4 (with positive background budget): timer rescheduled to short budget', () => {
+    const { driver, emits, advance } = makeHarness({
+      initialDelayMs: 45_000,
+      initialDelayMsBackground: 5_000,
+    })
+    driver.ingest(enqueue('chat-bg-short'), null)
+    advance(1_000)
+    driver.ingest(
+      tu('Agent', 'tu-bg2', {
+        prompt: 'p',
+        description: 'bg',
+        run_in_background: true,
+      }),
+      'chat-bg-short',
+    )
+    // No immediate emit — budget is 5s.
+    expect(emits.length).toBe(0)
+    // Advance past 45s budget would emit, but we expect the
+    // background bypass to fire by 5s elapsed.
+    advance(5_000)
+    expect(emits.length).toBeGreaterThanOrEqual(1)
+  })
+
+  it('AC5: timer cleared on early turn_end — no phantom emit when clock keeps running', () => {
+    const { driver, emits, advance } = makeHarness({ initialDelayMs: 45_000 })
+    driver.ingest(enqueue('chat-fast2'), null)
+    advance(5_000)
+    driver.ingest(tu('Read', 'tu1', { file_path: '/x' }), 'chat-fast2')
+    advance(5_000)
+    driver.ingest({ kind: 'turn_end' }, 'chat-fast2')
+    expect(emits.length).toBe(0)
+    // Push the clock far past the original threshold. If the timer
+    // wasn't cleared, a phantom flush would land here.
+    advance(120_000)
+    expect(emits.length).toBe(0)
+  })
+})

package/telegram-plugin/tests/quota-check.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest'
-import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'fs'
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync, existsSync, readFileSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
 import {
@@ -379,6 +379,42 @@ describe('fetchAccountQuota — cache + token resolution', () => {
       rmSync(home, { recursive: true, force: true })
     }
   })
+
+  it('persists the snapshot under the supplied home, not the real homedir (issue #708 regression)', async () => {
+    const home = makeAccountHome({
+      'work@example.com': { accessToken: 'tok' },
+    })
+    const fakeFetch = async () =>
+      new Response('{}', {
+        status: 200,
+        headers: {
+          'anthropic-ratelimit-unified-5h-utilization': '0.42',
+          'anthropic-ratelimit-unified-7d-utilization': '0.17',
+        },
+      })
+    try {
+      const r = await fetchAccountQuota('work@example.com', {
+        home,
+        fetchImpl: fakeFetch as typeof fetch,
+      })
+      expect(r.ok).toBe(true)
+      const snapPath = join(
+        home,
+        '.switchroom',
+        'accounts',
+        'work@example.com',
+        'quota.json',
+      )
+      // The bug: writeAccountQuota was called without opts.home, so the
+      // snapshot landed under the real $HOME instead of the test home.
+      expect(existsSync(snapPath)).toBe(true)
+      const snap = JSON.parse(readFileSync(snapPath, 'utf-8'))
+      expect(snap.fiveHourPct).toBeCloseTo(42, 0)
+      expect(snap.sevenDayPct).toBeCloseTo(17, 0)
+    } finally {
+      rmSync(home, { recursive: true, force: true })
+    }
+  })
 })
 
 describe('getCachedAccountQuota + prefetchAccountQuotaIfStale', () => {

package/telegram-plugin/tests/subagent-registry-bugs.test.ts

@@ -219,6 +219,11 @@ function makeHarnessWithDb(opts: {
     agentDir,
     sendNotification: (text) => notifications.push(text),
     stallThresholdMs,
+    // Mirror the active-loop threshold for fixtures with toolCount=0;
+    // tests that need the silent-synthesis vs active-loop distinction
+    // pass a separate value explicitly. See subagent-watcher.ts adaptive
+    // threshold logic.
+    silentSynthesisStallThresholdMs: stallThresholdMs,
     rescanMs: 500,
     now: () => currentTime,
     setInterval: (fn, ms) => {