pi-watchdog-supervisor 0.1.0

package/test/registry.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, it } from 'vitest';
+import {
+  applyEvent,
+  classifyKind,
+  createTargetRegistry,
+  syncFromRecords,
+  toWatchdogTarget,
+  type SubagentRecordLike,
+} from '../src/registry.ts';
+import type { WatchdogTarget } from '../src/types.ts';
+
+const record = (overrides: Partial<SubagentRecordLike> = {}): SubagentRecordLike => ({
+  id: 'a1',
+  type: 'Explore',
+  description: 'explore campaign-list',
+  status: 'running',
+  toolUses: 12,
+  startedAt: 1000,
+  ...overrides,
+});
+
+const targetsOf = (...items: WatchdogTarget[]): Map<string, WatchdogTarget> =>
+  new Map(items.map((item) => [item.id, item]));
+
+describe('classifyKind', () => {
+  it('detects watchdog by type (case-insensitive)', () => {
+    expect(classifyKind('Watchdog', 'anything')).toBe('watchdog');
+    expect(classifyKind('my-watchdog-agent', '')).toBe('watchdog');
+  });
+
+  it('detects watchdog by description', () => {
+    expect(classifyKind('Explore', 'Watchdog supervisor for tasks')).toBe('watchdog');
+  });
+
+  it('classifies regular agents as task', () => {
+    expect(classifyKind('Explore', 'fix type errors')).toBe('task');
+  });
+
+  it('returns unknown when nothing to classify', () => {
+    expect(classifyKind(undefined, undefined)).toBe('unknown');
+    expect(classifyKind('', '')).toBe('unknown');
+  });
+});
+
+describe('toWatchdogTarget', () => {
+  it('maps record fields', () => {
+    const target = toWatchdogTarget(record());
+    expect(target).toEqual({
+      id: 'a1',
+      name: 'explore campaign-list',
+      kind: 'task',
+      status: 'running',
+      toolCallCount: 12,
+      createdAt: 1000,
+      lastActiveAt: 1000,
+    });
+  });
+
+  it('uses completedAt as lastActiveAt when present', () => {
+    const target = toWatchdogTarget(record({ status: 'completed', completedAt: 5000 }));
+    expect(target.lastActiveAt).toBe(5000);
+  });
+});
+
+describe('applyEvent', () => {
+  it('updates status and lastActiveAt of an existing target on started', () => {
+    const existing = { ...toWatchdogTarget(record({ status: 'queued' })) };
+    const next = applyEvent(targetsOf(existing), 'subagents:started', { id: 'a1' }, 2000);
+    expect(next.get('a1')?.status).toBe('running');
+    expect(next.get('a1')?.lastActiveAt).toBe(2000);
+  });
+
+  it('creates a minimal target for an unknown id', () => {
+    const next = applyEvent(
+      new Map(),
+      'subagents:created',
+      { id: 'b2', type: 'Explore', description: 'new agent' },
+      3000,
+    );
+    const created = next.get('b2');
+    expect(created?.status).toBe('queued');
+    expect(created?.kind).toBe('task');
+    expect(created?.createdAt).toBe(3000);
+  });
+
+  it('takes failed status from payload when valid', () => {
+    const existing = toWatchdogTarget(record());
+    const next = applyEvent(
+      targetsOf(existing),
+      'subagents:failed',
+      { id: 'a1', status: 'aborted' },
+      4000,
+    );
+    expect(next.get('a1')?.status).toBe('aborted');
+  });
+
+  it('defaults failed status to error when payload has no valid status', () => {
+    const existing = toWatchdogTarget(record());
+    const next = applyEvent(targetsOf(existing), 'subagents:failed', { id: 'a1' }, 4000);
+    expect(next.get('a1')?.status).toBe('error');
+  });
+
+  it('only touches lastActiveAt on steered and compacted', () => {
+    const existing = toWatchdogTarget(record());
+    for (const channel of ['subagents:steered', 'subagents:compacted']) {
+      const next = applyEvent(targetsOf(existing), channel, { id: 'a1' }, 6000);
+      expect(next.get('a1')?.status).toBe('running');
+      expect(next.get('a1')?.lastActiveAt).toBe(6000);
+    }
+  });
+
+  it('ignores payloads without a string id', () => {
+    const existing = toWatchdogTarget(record());
+    const targets = targetsOf(existing);
+    expect(applyEvent(targets, 'subagents:started', {}, 2000)).toBe(targets);
+    expect(applyEvent(targets, 'subagents:started', null, 2000)).toBe(targets);
+  });
+});
+
+describe('syncFromRecords', () => {
+  it('adds new records as targets', () => {
+    const next = syncFromRecords(new Map(), [record()]);
+    expect(next.get('a1')?.name).toBe('explore campaign-list');
+  });
+
+  it('keeps the newer lastActiveAt on existing targets', () => {
+    const existing = { ...toWatchdogTarget(record()), lastActiveAt: 9000 };
+    const next = syncFromRecords(targetsOf(existing), [record({ toolUses: 20 })]);
+    expect(next.get('a1')?.lastActiveAt).toBe(9000);
+    expect(next.get('a1')?.toolCallCount).toBe(20);
+  });
+
+  it('keeps targets missing from the record list', () => {
+    const existing = toWatchdogTarget(record({ id: 'gone' }));
+    const next = syncFromRecords(targetsOf(existing), []);
+    expect(next.get('gone')).toBeDefined();
+  });
+});
+
+describe('createTargetRegistry', () => {
+  it('accumulates events and record syncs', () => {
+    const registry = createTargetRegistry();
+    registry.applyEvent('subagents:created', { id: 'a1', type: 'watchdog' }, 1000);
+    registry.syncFromRecords([record({ id: 'b2' })]);
+    const ids = registry.list().map((target) => target.id);
+    expect(ids).toContain('a1');
+    expect(ids).toContain('b2');
+  });
+});

package/test/store.test.ts

@@ -0,0 +1,176 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { getOrCreateStore, resetStoreForTest } from '../src/store.ts';
+
+afterEach(() => {
+  resetStoreForTest();
+});
+
+const event = (overrides: Record<string, unknown> = {}) => ({
+  at: 1000,
+  type: 'tool_call' as const,
+  summary: 'bash: rg "X" src',
+  ...overrides,
+});
+
+describe('getOrCreateStore', () => {
+  it('returns the same instance across calls (globalThis shared)', () => {
+    const a = getOrCreateStore(10);
+    const b = getOrCreateStore(10);
+    expect(a).toBe(b);
+  });
+});
+
+describe('registerChild / getChild', () => {
+  it('registers and resolves a child session', () => {
+    const store = getOrCreateStore(10);
+    store.registerChild('sess-1', 'parent-1');
+    expect(store.getChild('sess-1')).toEqual({ parentSessionId: 'parent-1' });
+    expect(store.getChild('sess-x')).toBeUndefined();
+  });
+});
+
+describe('appendEvent / getEvents', () => {
+  it('assigns sequential ids and targetId', () => {
+    const store = getOrCreateStore(10);
+    store.appendEvent('sess-1', event());
+    store.appendEvent('sess-1', event({ at: 2000 }));
+    const events = store.getEvents('sess-1');
+    expect(events).toHaveLength(2);
+    expect(events[0]?.id).toBe('sess-1-1');
+    expect(events[1]?.id).toBe('sess-1-2');
+    expect(events[0]?.targetId).toBe('sess-1');
+  });
+
+  it('drops oldest events beyond maxEventsPerAgent (ring buffer)', () => {
+    const store = getOrCreateStore(3);
+    for (let i = 1; i <= 5; i += 1) {
+      store.appendEvent('sess-1', event({ at: i }));
+    }
+    const events = store.getEvents('sess-1');
+    expect(events).toHaveLength(3);
+    expect(events[0]?.at).toBe(3);
+    expect(events[2]?.at).toBe(5);
+  });
+
+  it('returns the latest limit entries in chronological order', () => {
+    const store = getOrCreateStore(10);
+    for (let i = 1; i <= 4; i += 1) {
+      store.appendEvent('sess-1', event({ at: i }));
+    }
+    const events = store.getEvents('sess-1', 2);
+    expect(events.map((e) => e.at)).toEqual([3, 4]);
+  });
+
+  it('returns empty array for unknown target', () => {
+    const store = getOrCreateStore(10);
+    expect(store.getEvents('nope')).toEqual([]);
+  });
+});
+
+describe('linkAgent / resolveTargetKey', () => {
+  it('resolves both agentId and sessionId to the session key', () => {
+    const store = getOrCreateStore(10);
+    store.registerChild('sess-1', 'parent-1');
+    store.linkAgent('agent-1', 'sess-1');
+    expect(store.resolveTargetKey('agent-1')).toBe('sess-1');
+    expect(store.resolveTargetKey('sess-1')).toBe('sess-1');
+    expect(store.resolveTargetKey('unknown')).toBeUndefined();
+  });
+});
+
+describe('getLastAlert / recordAlert', () => {
+  it('round-trips the last alert per target', () => {
+    const store = getOrCreateStore(10);
+    expect(store.getLastAlert('sess-1')).toBeUndefined();
+    store.recordAlert('sess-1', 'key-1', 5000);
+    expect(store.getLastAlert('sess-1')).toEqual({ at: 5000, evidenceKey: 'key-1' });
+    store.recordAlert('sess-1', 'key-2', 6000);
+    expect(store.getLastAlert('sess-1')).toEqual({ at: 6000, evidenceKey: 'key-2' });
+  });
+
+  it('is shared across getOrCreateStore calls', () => {
+    getOrCreateStore(10).recordAlert('sess-1', 'key-1', 5000);
+    expect(getOrCreateStore(10).getLastAlert('sess-1')).toEqual({ at: 5000, evidenceKey: 'key-1' });
+  });
+});
+
+describe('paused state (shared)', () => {
+  it('starts unpaused and toggles via setPaused', () => {
+    const store = getOrCreateStore(10);
+    expect(store.isPaused()).toBe(false);
+    store.setPaused(true);
+    expect(store.isPaused()).toBe(true);
+    store.setPaused(false);
+    expect(store.isPaused()).toBe(false);
+  });
+
+  it('is shared across getOrCreateStore calls', () => {
+    getOrCreateStore(10).setPaused(true);
+    expect(getOrCreateStore(10).isPaused()).toBe(true);
+  });
+});
+
+describe('rescue message override (shared)', () => {
+  it('starts undefined and round-trips', () => {
+    const store = getOrCreateStore(10);
+    expect(store.getRescueMessage()).toBeUndefined();
+    store.setRescueMessage('custom message');
+    expect(store.getRescueMessage()).toBe('custom message');
+  });
+});
+
+describe('config override (shared)', () => {
+  it('starts empty and merges successive sets', () => {
+    const store = getOrCreateStore(10);
+    expect(store.getConfigOverride()).toEqual({});
+    store.setConfigOverride({ llmRepeatThreshold: 5 });
+    store.setConfigOverride({ cooldownSec: 120 });
+    expect(store.getConfigOverride()).toEqual({ llmRepeatThreshold: 5, cooldownSec: 120 });
+  });
+});
+
+describe('alert sink', () => {
+  it('returns false when no sink is registered', () => {
+    const store = getOrCreateStore(10);
+    expect(store.alert('hello', 'warning')).toBe(false);
+  });
+
+  it('delivers message and severity to the registered sink', () => {
+    const store = getOrCreateStore(10);
+    const received: Array<[string, string]> = [];
+    store.setAlertSink((message, severity) => {
+      received.push([message, severity]);
+    });
+    expect(store.alert('hello', 'critical')).toBe(true);
+    expect(received).toEqual([['hello', 'critical']]);
+  });
+});
+
+describe('resolveAgentId', () => {
+  it('maps a sessionId back to its linked agentId and passes agentIds through', () => {
+    const store = getOrCreateStore(10);
+    store.registerChild('sess-1');
+    store.linkAgent('agent-1', 'sess-1');
+    expect(store.resolveAgentId('sess-1')).toBe('agent-1');
+    expect(store.resolveAgentId('agent-1')).toBe('agent-1');
+    expect(store.resolveAgentId('unknown')).toBeUndefined();
+  });
+});
+
+describe('FIFO agent linking', () => {
+  it('pairs session-created and started events in order', () => {
+    const store = getOrCreateStore(10);
+    store.registerChild('sess-1');
+    store.registerChild('sess-2');
+    store.linkNextAgent('agent-1');
+    store.linkNextAgent('agent-2');
+    expect(store.resolveTargetKey('agent-1')).toBe('sess-1');
+    expect(store.resolveTargetKey('agent-2')).toBe('sess-2');
+  });
+
+  it('ignores linkNextAgent when no unlinked child is pending', () => {
+    const store = getOrCreateStore(10);
+    store.linkNextAgent('agent-1');
+    expect(store.resolveTargetKey('agent-1')).toBeUndefined();
+  });
+});

package/test/tools.test.ts

@@ -0,0 +1,315 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { DEFAULT_CONFIG } from '../src/config.ts';
+import { createTargetRegistry } from '../src/registry.ts';
+import { getOrCreateStore, resetStoreForTest } from '../src/store.ts';
+import type { SubagentsIntegration } from '../src/integrations/gotgenes-subagents.ts';
+import {
+  executeAlertMain,
+  executeConfig,
+  executeDetectStuck,
+  executeListTargets,
+  executeReadEvents,
+  executeSteerSubagent,
+  formatAlert,
+  type ToolDeps,
+} from '../src/tools.ts';
+
+afterEach(() => {
+  resetStoreForTest();
+});
+
+const NOW = 1_000_000;
+
+const record = (overrides: Record<string, unknown> = {}) => ({
+  id: 'agent-1',
+  type: 'Explore',
+  description: 'explore stuff',
+  status: 'running' as const,
+  toolUses: 3,
+  startedAt: NOW - 10_000,
+  ...overrides,
+});
+
+const makeDeps = (overrides: Partial<ToolDeps> = {}): ToolDeps => ({
+  store: getOrCreateStore(50),
+  registry: createTargetRegistry(),
+  getIntegration: async () => ({ available: false, reason: 'test' }),
+  baseConfig: DEFAULT_CONFIG,
+  now: () => NOW,
+  ...overrides,
+});
+
+const availableIntegration = (
+  records: ReturnType<typeof record>[],
+  steered: Array<[string, string]> = [],
+): SubagentsIntegration => ({
+  available: true,
+  listAgents: () => records,
+  steer: async (id, message) => {
+    steered.push([id, message]);
+    return true;
+  },
+});
+
+// Feed N repeated llm_output events so the detector flags repeated_llm_output
+const feedRepeatedResults = (
+  deps: ToolDeps,
+  sessionId: string,
+  times: number,
+  baseAt = NOW - times * 1000,
+) => {
+  deps.store.registerChild(sessionId);
+  for (let i = 0; i < times; i += 1) {
+    deps.store.appendEvent(sessionId, {
+      at: baseAt + i * 1000,
+      type: 'llm_output',
+      summary: 'llm_output: same body',
+      commandKey: 'llm_output',
+      outputHash: 'hash-same',
+    });
+  }
+};
+
+describe('executeListTargets', () => {
+  it('reports unavailable integration', async () => {
+    const text = await executeListTargets(makeDeps(), {});
+    expect(text).toContain('unavailable');
+  });
+
+  it('filters completed targets by default and includes them on request', async () => {
+    const deps = makeDeps({
+      getIntegration: async () =>
+        availableIntegration([record(), record({ id: 'agent-2', status: 'completed' })]),
+    });
+    const defaultText = await executeListTargets(deps, {});
+    const defaultParsed = JSON.parse(defaultText);
+    expect(defaultParsed.targets).toHaveLength(1);
+    expect(defaultParsed.targets[0].id).toBe('agent-1');
+
+    const allText = await executeListTargets(deps, { includeCompleted: true });
+    expect(JSON.parse(allText).targets).toHaveLength(2);
+  });
+
+  it('marks likelyStuck from buffered events', async () => {
+    const deps = makeDeps({
+      getIntegration: async () => availableIntegration([record()]),
+    });
+    feedRepeatedResults(deps, 'sess-1', 3);
+    deps.store.linkAgent('agent-1', 'sess-1');
+    const parsed = JSON.parse(await executeListTargets(deps, {}));
+    expect(parsed.targets[0].likelyStuck).toBe(true);
+    expect(parsed.targets[0].repeatedMessageCount).toBe(3);
+  });
+});
+
+describe('executeReadEvents', () => {
+  it('returns an error message for an unknown target', () => {
+    expect(executeReadEvents(makeDeps(), { targetId: 'nope' })).toContain('Unknown target');
+  });
+
+  it('returns recent events as JSON', () => {
+    const deps = makeDeps();
+    feedRepeatedResults(deps, 'sess-1', 2);
+    const parsed = JSON.parse(executeReadEvents(deps, { targetId: 'sess-1' }));
+    expect(parsed.targetId).toBe('sess-1');
+    expect(parsed.events).toHaveLength(2);
+  });
+});
+
+describe('executeDetectStuck', () => {
+  it('includes analysis and the suggested rescue message', () => {
+    const deps = makeDeps();
+    feedRepeatedResults(deps, 'sess-1', 3);
+    const parsed = JSON.parse(executeDetectStuck(deps, { targetId: 'sess-1' }));
+    expect(parsed.likelyStuck).toBe(true);
+    expect(parsed.evidence.some((e: { type: string }) => e.type === 'repeated_llm_output')).toBe(true);
+    expect(parsed.suggestedRescueMessage).toBe(DEFAULT_CONFIG.rescueMessage);
+  });
+
+  it('prefers the shared rescue message override', () => {
+    const deps = makeDeps();
+    feedRepeatedResults(deps, 'sess-1', 3);
+    deps.store.setRescueMessage('custom rescue');
+    const parsed = JSON.parse(executeDetectStuck(deps, { targetId: 'sess-1' }));
+    expect(parsed.suggestedRescueMessage).toBe('custom rescue');
+  });
+});
+
+describe('executeAlertMain', () => {
+  it('suppresses alerts while paused', () => {
+    const deps = makeDeps();
+    deps.store.setPaused(true);
+    expect(executeAlertMain(deps, { targetId: 'sess-1', message: 'stuck!' })).toContain('paused');
+  });
+
+  it('delivers the alert to the sink and records it', () => {
+    const deps = makeDeps();
+    feedRepeatedResults(deps, 'sess-1', 3);
+    const received: string[] = [];
+    deps.store.setAlertSink((message) => {
+      received.push(message);
+    });
+    const result = executeAlertMain(deps, { targetId: 'sess-1', message: 'stuck!' });
+    expect(result).toContain('alert sent');
+    expect(received).toHaveLength(1);
+    expect(received[0]).toContain('[Watchdog Alert]');
+    expect(deps.store.getLastAlert('sess-1')).toBeDefined();
+  });
+
+  it('suppresses a repeat alert for the same evidence within a positive cooldown', () => {
+    const deps = makeDeps();
+    deps.store.setConfigOverride({ cooldownSec: 60 });
+    feedRepeatedResults(deps, 'sess-1', 3);
+    deps.store.setAlertSink(() => {});
+    executeAlertMain(deps, { targetId: 'sess-1', message: 'stuck!' });
+    // the loop keeps repeating after the alert, but the cooldown blocks a re-alert
+    feedRepeatedResults(deps, 'sess-1', 3, NOW + 1000);
+    const second = executeAlertMain(deps, { targetId: 'sess-1', message: 'stuck!' });
+    expect(second).toContain('cooldown');
+  });
+
+  it('re-alerts with the default no-cooldown (0) once the loop repeats after the alert', () => {
+    const deps = makeDeps();
+    feedRepeatedResults(deps, 'sess-1', 3);
+    deps.store.setAlertSink(() => {});
+    executeAlertMain(deps, { targetId: 'sess-1', message: 'stuck!' });
+    // counter resets at the alert; fresh repeats after it re-trigger
+    feedRepeatedResults(deps, 'sess-1', 3, NOW + 1000);
+    const second = executeAlertMain(deps, { targetId: 'sess-1', message: 'stuck!' });
+    expect(second).toContain('alert sent to main session');
+  });
+
+  it('reports a missing sink as an error', () => {
+    const deps = makeDeps();
+    feedRepeatedResults(deps, 'sess-1', 3);
+    expect(executeAlertMain(deps, { targetId: 'sess-1', message: 'stuck!' })).toContain('no alert sink');
+  });
+});
+
+describe('executeSteerSubagent', () => {
+  it('defaults to dry-run with the effective rescue message', async () => {
+    const deps = makeDeps();
+    deps.store.registerChild('sess-1');
+    const result = await executeSteerSubagent(deps, { targetId: 'sess-1' });
+    expect(result).toContain('would steer');
+    expect(result).toContain(DEFAULT_CONFIG.rescueMessage);
+  });
+
+  it('refuses a real steer in main_only mode', async () => {
+    const deps = makeDeps();
+    deps.store.registerChild('sess-1');
+    const result = await executeSteerSubagent(deps, { targetId: 'sess-1', dryRun: false });
+    expect(result).toContain('main_only');
+  });
+
+  it('performs a real steer when alertMode allows it', async () => {
+    const steered: Array<[string, string]> = [];
+    const deps = makeDeps({
+      baseConfig: { ...DEFAULT_CONFIG, alertMode: 'both' },
+      getIntegration: async () => availableIntegration([record()], steered),
+    });
+    deps.store.registerChild('sess-1');
+    deps.store.linkAgent('agent-1', 'sess-1');
+    const result = await executeSteerSubagent(deps, {
+      targetId: 'sess-1',
+      message: 'wake up',
+      dryRun: false,
+    });
+    expect(result).toContain('steered');
+    expect(steered).toEqual([['agent-1', 'wake up']]);
+  });
+
+  it('steers without an explicit dryRun when steerDryRunDefault is false', async () => {
+    const steered: Array<[string, string]> = [];
+    const deps = makeDeps({
+      baseConfig: { ...DEFAULT_CONFIG, alertMode: 'both', steerDryRunDefault: false },
+      getIntegration: async () => availableIntegration([record()], steered),
+    });
+    deps.store.registerChild('sess-1');
+    deps.store.linkAgent('agent-1', 'sess-1');
+    const result = await executeSteerSubagent(deps, { targetId: 'sess-1', message: 'wake up' });
+    expect(result).toContain('steered');
+    expect(steered).toEqual([['agent-1', 'wake up']]);
+  });
+
+  it('keeps the dry-run default when steerDryRunDefault is null', async () => {
+    const deps = makeDeps({
+      baseConfig: { ...DEFAULT_CONFIG, alertMode: 'both', steerDryRunDefault: null },
+    });
+    deps.store.registerChild('sess-1');
+    const result = await executeSteerSubagent(deps, { targetId: 'sess-1' });
+    expect(result).toContain('would steer');
+  });
+
+  it('keeps an explicit dryRun: true even when steerDryRunDefault is false', async () => {
+    const deps = makeDeps({
+      baseConfig: { ...DEFAULT_CONFIG, alertMode: 'both', steerDryRunDefault: false },
+    });
+    deps.store.registerChild('sess-1');
+    const result = await executeSteerSubagent(deps, { targetId: 'sess-1', dryRun: true });
+    expect(result).toContain('would steer');
+  });
+
+  it('still refuses in main_only mode when steerDryRunDefault is false', async () => {
+    const deps = makeDeps({
+      baseConfig: { ...DEFAULT_CONFIG, steerDryRunDefault: false },
+    });
+    deps.store.registerChild('sess-1');
+    const result = await executeSteerSubagent(deps, { targetId: 'sess-1' });
+    expect(result).toContain('main_only');
+  });
+});
+
+describe('executeConfig', () => {
+  it('returns the effective config including overrides', () => {
+    const deps = makeDeps();
+    deps.store.setConfigOverride({ llmRepeatThreshold: 7 });
+    const parsed = JSON.parse(executeConfig(deps, { action: 'get' }));
+    expect(parsed.llmRepeatThreshold).toBe(7);
+    expect(parsed.alertMode).toBe(DEFAULT_CONFIG.alertMode);
+  });
+
+  it('applies only known fields on set', () => {
+    const deps = makeDeps();
+    executeConfig(deps, {
+      action: 'set',
+      config: { cooldownSec: 90, bogus: true } as never,
+    });
+    expect(deps.store.getConfigOverride()).toEqual({ cooldownSec: 90 });
+  });
+});
+
+describe('formatAlert', () => {
+  it('renders the requirement §8.2 template', () => {
+    const deps = makeDeps();
+    feedRepeatedResults(deps, 'sess-1', 3);
+    const alert = formatAlert(
+      'sess-1',
+      JSON.parse(executeDetectStuck(deps, { targetId: 'sess-1' })),
+      deps.store.getEvents('sess-1'),
+      'stuck!',
+      DEFAULT_CONFIG.rescueMessage,
+    );
+    expect(alert).toBe(
+      [
+        '[Watchdog Alert]',
+        '',
+        'Target: sess-1',
+        'Status: likely stuck',
+        'Confidence: medium',
+        '',
+        'Evidence:',
+        '- llm message repeated 3 times: same LLM output body (hash hash-sam)',
+        '',
+        'Note:',
+        'stuck!',
+        '',
+        'Last command:',
+        'llm_output',
+        '',
+        'Suggested rescue:',
+        DEFAULT_CONFIG.rescueMessage,
+      ].join('\n'),
+    );
+  });
+});

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['test/**/*.test.ts'],
+  },
+});