pi-watchdog-supervisor 0.1.0

package/test/config.test.ts

@@ -0,0 +1,131 @@
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
+import { tmpdir, homedir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import {
+  DEFAULT_CONFIG,
+  getConfigPaths,
+  loadConfigFile,
+  loadEffectiveConfig,
+  mergeConfig,
+} from '../src/config.ts';
+
+const tempDirs: string[] = [];
+
+const makeTempDir = () => {
+  const dir = mkdtempSync(join(tmpdir(), 'watchdog-test-'));
+  tempDirs.push(dir);
+  return dir;
+};
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    rmSync(tempDirs.pop()!, { recursive: true, force: true });
+  }
+});
+
+describe('DEFAULT_CONFIG', () => {
+  it('has the documented default values', () => {
+    expect(DEFAULT_CONFIG.enabled).toBe(true);
+    expect(DEFAULT_CONFIG.rescueMessage).toContain('might be stuck');
+    expect(DEFAULT_CONFIG.llmRepeatThreshold).toBe(3);
+    expect(DEFAULT_CONFIG.idleNoProgressSec).toBe(0);
+    expect(DEFAULT_CONFIG.cooldownSec).toBe(0);
+    expect(DEFAULT_CONFIG.maxPreviewLines).toBe(20);
+    expect(DEFAULT_CONFIG.maxEventsPerAgent).toBe(200);
+    expect(DEFAULT_CONFIG.alertMode).toBe('main_only');
+    expect(DEFAULT_CONFIG.steerDryRunDefault).toBeNull();
+    expect(DEFAULT_CONFIG.debug).toBe(false);
+  });
+});
+
+describe('getConfigPaths', () => {
+  it('returns global path under home and project path under project dir', () => {
+    const { globalPath, projectPath } = getConfigPaths('/proj');
+    expect(globalPath).toBe(
+      join(homedir(), '.pi', 'agent', 'watchdog-supervisor', 'config.json'),
+    );
+    expect(projectPath).toBe(join('/proj', '.pi', 'watchdog-supervisor.json'));
+  });
+});
+
+describe('loadConfigFile', () => {
+  it('returns null config without warning when file does not exist', () => {
+    const { config, warning } = loadConfigFile(join(makeTempDir(), 'missing.json'));
+    expect(config).toBeNull();
+    expect(warning).toBeUndefined();
+  });
+
+  it('returns parsed partial config for a valid file', () => {
+    const dir = makeTempDir();
+    const path = join(dir, 'config.json');
+    writeFileSync(path, JSON.stringify({ llmRepeatThreshold: 5 }));
+    const { config, warning } = loadConfigFile(path);
+    expect(config).toEqual({ llmRepeatThreshold: 5 });
+    expect(warning).toBeUndefined();
+  });
+
+  it('returns null config with warning for invalid JSON', () => {
+    const dir = makeTempDir();
+    const path = join(dir, 'config.json');
+    writeFileSync(path, '{ not json');
+    const { config, warning } = loadConfigFile(path);
+    expect(config).toBeNull();
+    expect(warning).toContain(path);
+  });
+
+  it('ignores unknown fields', () => {
+    const dir = makeTempDir();
+    const path = join(dir, 'config.json');
+    writeFileSync(path, JSON.stringify({ llmRepeatThreshold: 5, bogus: true }));
+    const { config } = loadConfigFile(path);
+    expect(config).toEqual({ llmRepeatThreshold: 5 });
+  });
+});
+
+describe('mergeConfig', () => {
+  it('returns defaults when no parts are given', () => {
+    expect(mergeConfig()).toEqual(DEFAULT_CONFIG);
+    expect(mergeConfig(null, undefined)).toEqual(DEFAULT_CONFIG);
+  });
+
+  it('overrides defaults with global values, keeping unspecified defaults', () => {
+    const merged = mergeConfig({ llmRepeatThreshold: 10 });
+    expect(merged.llmRepeatThreshold).toBe(10);
+    expect(merged.cooldownSec).toBe(DEFAULT_CONFIG.cooldownSec);
+  });
+
+  it('lets later parts (project) override earlier parts (global)', () => {
+    const merged = mergeConfig(
+      { llmRepeatThreshold: 10, cooldownSec: 120 },
+      { llmRepeatThreshold: 7 },
+    );
+    expect(merged.llmRepeatThreshold).toBe(7);
+    expect(merged.cooldownSec).toBe(120);
+    expect(merged.idleNoProgressSec).toBe(DEFAULT_CONFIG.idleNoProgressSec);
+  });
+});
+
+describe('loadEffectiveConfig', () => {
+  it('merges project config over defaults and collects no warnings for valid files', () => {
+    const projectDir = makeTempDir();
+    mkdirSync(join(projectDir, '.pi'));
+    writeFileSync(
+      join(projectDir, '.pi', 'watchdog-supervisor.json'),
+      JSON.stringify({ llmRepeatThreshold: 5 }),
+    );
+    const { config, warnings } = loadEffectiveConfig(projectDir);
+    expect(config.llmRepeatThreshold).toBe(5);
+    expect(config.alertMode).toBe('main_only');
+    expect(warnings).toEqual([]);
+  });
+
+  it('falls back and reports warning when project config is invalid JSON', () => {
+    const projectDir = makeTempDir();
+    mkdirSync(join(projectDir, '.pi'));
+    writeFileSync(join(projectDir, '.pi', 'watchdog-supervisor.json'), '{ oops');
+    const { config, warnings } = loadEffectiveConfig(projectDir);
+    expect(config.llmRepeatThreshold).toBe(DEFAULT_CONFIG.llmRepeatThreshold);
+    expect(warnings).toHaveLength(1);
+  });
+});

package/test/detector.test.ts

@@ -0,0 +1,224 @@
+import { describe, expect, it } from 'vitest';
+import { detectStuck, shouldAlert } from '../src/detector.ts';
+import { DEFAULT_CONFIG } from '../src/config.ts';
+import type { WatchdogEvent, WatchdogEventType } from '../src/types.ts';
+
+const NOW = 1_000_000_000;
+
+let seq = 0;
+const ev = (
+  type: WatchdogEventType,
+  at: number,
+  commandKey?: string,
+  outputHash?: string,
+): WatchdogEvent => ({
+  id: `s1-${++seq}`,
+  targetId: 's1',
+  at,
+  type,
+  summary: `${type}: ${commandKey ?? ''}`,
+  commandKey,
+  outputHash,
+});
+
+// N consecutive llm events of one type with configurable body hashes
+const llmRun = (
+  type: 'llm_input' | 'llm_output',
+  count: number,
+  hash: string | ((i: number) => string),
+) =>
+  Array.from({ length: count }, (_, i) =>
+    ev(type, NOW - 10_000 + i * 1000, type, typeof hash === 'string' ? hash : hash(i)),
+  );
+
+describe('detectStuck: repeated llm messages', () => {
+  it('flags repeated_llm_output for 3x identical normalized output body', () => {
+    const analysis = detectStuck(llmRun('llm_output', 3, 'body-1'), DEFAULT_CONFIG, NOW);
+    expect(analysis.likelyStuck).toBe(true);
+    expect(analysis.confidence).toBe('medium');
+    expect(analysis.evidence.map((item) => item.type)).toEqual(['repeated_llm_output']);
+  });
+
+  it('flags repeated_llm_input for 3x identical input body', () => {
+    const analysis = detectStuck(llmRun('llm_input', 3, 'body-1'), DEFAULT_CONFIG, NOW);
+    expect(analysis.evidence.map((item) => item.type)).toEqual(['repeated_llm_input']);
+  });
+
+  it('flags both types with high confidence when input and output both loop', () => {
+    const events = [0, 1, 2].flatMap((i) => [
+      ev('llm_input', NOW - 10_000 + i * 2000, 'llm_input', 'in-same'),
+      ev('llm_output', NOW - 9000 + i * 2000, 'llm_output', 'out-same'),
+    ]);
+    const analysis = detectStuck(events, DEFAULT_CONFIG, NOW);
+    expect(analysis.likelyStuck).toBe(true);
+    expect(analysis.confidence).toBe('high');
+  });
+
+  it('does not flag 2x identical body', () => {
+    const analysis = detectStuck(llmRun('llm_output', 2, 'body-1'), DEFAULT_CONFIG, NOW);
+    expect(analysis.likelyStuck).toBe(false);
+    expect(analysis.evidence).toEqual([]);
+  });
+
+  it('does not flag when bodies differ', () => {
+    const analysis = detectStuck(llmRun('llm_output', 5, (i) => `body-${i}`), DEFAULT_CONFIG, NOW);
+    expect(analysis.likelyStuck).toBe(false);
+  });
+
+  it('requires the repeats to be consecutive', () => {
+    const events = [
+      ...llmRun('llm_output', 2, 'body-1'),
+      ev('llm_output', NOW - 7000, 'llm_output', 'body-other'),
+      ev('llm_output', NOW - 6000, 'llm_output', 'body-1'),
+    ];
+    const analysis = detectStuck(events, DEFAULT_CONFIG, NOW);
+    expect(analysis.likelyStuck).toBe(false);
+  });
+
+  it('resets the counter via sinceAt: only events after the last alert count', () => {
+    const events = llmRun('llm_output', 5, 'body-1');
+    // alert happened after the 3rd event → only 2 remain countable
+    const sinceAt = events[2].at;
+    const analysis = detectStuck(events, DEFAULT_CONFIG, NOW, sinceAt);
+    expect(analysis.likelyStuck).toBe(false);
+    // three more repeats after the alert → triggers again
+    const more = [...events, ...llmRun('llm_output', 1, 'body-1').map((e) => ({ ...e, at: NOW - 1000 }))];
+    expect(detectStuck(more, DEFAULT_CONFIG, NOW, sinceAt).likelyStuck).toBe(true);
+  });
+
+  it('counts the full buffer when sinceAt is omitted', () => {
+    const analysis = detectStuck(llmRun('llm_output', 3, 'body-1'), DEFAULT_CONFIG, NOW);
+    expect(analysis.likelyStuck).toBe(true);
+  });
+
+  it('ignores interleaved tool events when counting the run', () => {
+    const events = [0, 1, 2].flatMap((i) => [
+      ev('llm_output', NOW - 10_000 + i * 2000, 'llm_output', 'out-same'),
+      ev('tool_result', NOW - 9500 + i * 2000, 'edit src/a.ts', `tool-${i}`),
+      ev('edit', NOW - 9200 + i * 2000, 'edit src/a.ts'),
+    ]);
+    const analysis = detectStuck(events, DEFAULT_CONFIG, NOW);
+    expect(analysis.evidence.map((item) => item.type)).toEqual(['repeated_llm_output']);
+  });
+});
+
+describe('detectStuck: idle no progress', () => {
+  // R4 is disabled by default (idleNoProgressSec: 0); enable it for these tests
+  const IDLE_CONFIG = { ...DEFAULT_CONFIG, idleNoProgressSec: 300 };
+  const IDLE = IDLE_CONFIG.idleNoProgressSec * 1000;
+
+  const busyNoEditEvents = (toolEventCount: number) =>
+    Array.from({ length: toolEventCount }, (_, i) =>
+      ev(
+        i % 2 === 0 ? 'tool_call' : 'tool_result',
+        NOW - IDLE - 60_000 + i * ((IDLE + 30_000) / toolEventCount),
+        `cmd-${i}`,
+        `h-${i}`,
+      ),
+    );
+
+  it('flags idle_no_progress when tools keep running without edits', () => {
+    const events = [...busyNoEditEvents(6), ev('tool_call', NOW - 30_000, 'cmd-last')];
+    const analysis = detectStuck(events, IDLE_CONFIG, NOW);
+    expect(analysis.evidence.map((item) => item.type)).toContain('idle_no_progress');
+  });
+
+  it('does not flag with fewer than 5 tool events', () => {
+    const events = [
+      ev('tool_call', NOW - IDLE - 10_000, 'cmd-a'),
+      ev('tool_result', NOW - IDLE - 9000, 'cmd-a', 'ha'),
+      ev('tool_call', NOW - 30_000, 'cmd-b'),
+    ];
+    const analysis = detectStuck(events, IDLE_CONFIG, NOW);
+    expect(analysis.evidence.map((item) => item.type)).not.toContain('idle_no_progress');
+  });
+
+  it('does not flag when the agent has gone quiet', () => {
+    const events = busyNoEditEvents(6).map((event) => ({ ...event, at: event.at - 120_000 }));
+    const analysis = detectStuck(events, IDLE_CONFIG, NOW);
+    expect(analysis.evidence.map((item) => item.type)).not.toContain('idle_no_progress');
+  });
+
+  it('does not flag when a recent edit shows progress', () => {
+    const events = [...busyNoEditEvents(6), ev('edit', NOW - 60_000, 'edit src/a.ts'), ev('tool_call', NOW - 30_000, 'cmd-last')];
+    const analysis = detectStuck(events, IDLE_CONFIG, NOW);
+    expect(analysis.evidence.map((item) => item.type)).not.toContain('idle_no_progress');
+  });
+
+  it('is disabled when idleNoProgressSec is 0 (the default)', () => {
+    const events = [...busyNoEditEvents(6), ev('tool_call', NOW - 30_000, 'cmd-last')];
+    const analysis = detectStuck(events, DEFAULT_CONFIG, NOW);
+    expect(analysis.evidence.map((item) => item.type)).not.toContain('idle_no_progress');
+  });
+});
+
+describe('detectStuck: zero thresholds disable rules', () => {
+  it('never flags llm repetition when llmRepeatThreshold is 0', () => {
+    const config = { ...DEFAULT_CONFIG, llmRepeatThreshold: 0 };
+    const analysis = detectStuck(llmRun('llm_output', 5, 'body-1'), config, NOW);
+    expect(analysis.likelyStuck).toBe(false);
+    expect(analysis.evidence).toEqual([]);
+  });
+});
+
+describe('detectStuck: evidenceKey and empty buffer', () => {
+  it('is stable for the same input and differs across evidence sets', () => {
+    const repeated = llmRun('llm_output', 3, 'body-1');
+    const first = detectStuck(repeated, DEFAULT_CONFIG, NOW);
+    const second = detectStuck(repeated, DEFAULT_CONFIG, NOW);
+    const other = detectStuck(llmRun('llm_input', 3, 'body-2'), DEFAULT_CONFIG, NOW);
+    expect(first.evidenceKey).toBe(second.evidenceKey);
+    expect(first.evidenceKey).not.toBe(other.evidenceKey);
+  });
+
+  it('returns not stuck for an empty buffer', () => {
+    const analysis = detectStuck([], DEFAULT_CONFIG, NOW);
+    expect(analysis.likelyStuck).toBe(false);
+    expect(analysis.evidenceKey).toBe('');
+  });
+});
+
+describe('shouldAlert', () => {
+  const stuck = detectStuck(llmRun('llm_output', 3, 'body-1'), DEFAULT_CONFIG, NOW);
+  const calm = detectStuck([], DEFAULT_CONFIG, NOW);
+  const COOLDOWN = 60;
+
+  it('never alerts when not stuck', () => {
+    expect(shouldAlert(undefined, calm, NOW, COOLDOWN)).toBe(false);
+  });
+
+  it('alerts when there is no previous alert', () => {
+    expect(shouldAlert(undefined, stuck, NOW, COOLDOWN)).toBe(true);
+  });
+
+  it('suppresses the same evidence during cooldown', () => {
+    const lastAlert = { at: NOW - 30_000, evidenceKey: stuck.evidenceKey };
+    expect(shouldAlert(lastAlert, stuck, NOW, COOLDOWN)).toBe(false);
+  });
+
+  it('alerts for new evidence even during cooldown', () => {
+    const lastAlert = { at: NOW - 30_000, evidenceKey: 'other-key' };
+    expect(shouldAlert(lastAlert, stuck, NOW, COOLDOWN)).toBe(true);
+  });
+
+  it('alerts again after cooldown expires', () => {
+    const lastAlert = { at: NOW - COOLDOWN * 1000 - 1, evidenceKey: stuck.evidenceKey };
+    expect(shouldAlert(lastAlert, stuck, NOW, COOLDOWN)).toBe(true);
+  });
+
+  it('treats cooldownSec -1 as infinite: same evidence alerts only once', () => {
+    const lastAlert = { at: NOW - 999_999_999, evidenceKey: stuck.evidenceKey };
+    expect(shouldAlert(lastAlert, stuck, NOW, -1)).toBe(false);
+  });
+
+  it('still alerts for new evidence when cooldownSec is -1', () => {
+    const lastAlert = { at: NOW - 30_000, evidenceKey: 'other-key' };
+    expect(shouldAlert(lastAlert, stuck, NOW, -1)).toBe(true);
+  });
+
+  it('treats cooldownSec 0 (the default) as no cooldown: same evidence alerts every time', () => {
+    const lastAlert = { at: NOW - 1, evidenceKey: stuck.evidenceKey };
+    expect(shouldAlert(lastAlert, stuck, NOW, 0)).toBe(true);
+    expect(shouldAlert(lastAlert, stuck, NOW, DEFAULT_CONFIG.cooldownSec)).toBe(true);
+  });
+});

package/test/integration.test.ts

@@ -0,0 +1,57 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { connectSubagents } from '../src/integrations/gotgenes-subagents.ts';
+
+const SERVICE_KEY = Symbol.for('@gotgenes/pi-subagents:service');
+const globalRecord = globalThis as Record<symbol, unknown>;
+
+afterEach(() => {
+  delete globalRecord[SERVICE_KEY];
+});
+
+describe('connectSubagents', () => {
+  it('reports unavailable when the service is not published', async () => {
+    const integration = await connectSubagents();
+    expect(integration.available).toBe(false);
+    if (!integration.available) {
+      expect(integration.reason).toContain('not published');
+    }
+  });
+
+  it('exposes listAgents when the service is published', async () => {
+    const records = [
+      {
+        id: 'a1',
+        type: 'Explore',
+        description: 'explore stuff',
+        status: 'running',
+        toolUses: 2,
+        startedAt: 1000,
+      },
+    ];
+    globalRecord[SERVICE_KEY] = { listAgents: () => records, steer: async () => true };
+
+    const integration = await connectSubagents();
+    expect(integration.available).toBe(true);
+    if (integration.available) {
+      expect(integration.listAgents()).toEqual(records);
+    }
+  });
+
+  it('exposes steer when the service is published', async () => {
+    const steered: Array<[string, string]> = [];
+    globalRecord[SERVICE_KEY] = {
+      listAgents: () => [],
+      steer: async (id: string, message: string) => {
+        steered.push([id, message]);
+        return true;
+      },
+    };
+
+    const integration = await connectSubagents();
+    expect(integration.available).toBe(true);
+    if (integration.available) {
+      await expect(integration.steer('a1', 'wake up')).resolves.toBe(true);
+      expect(steered).toEqual([['a1', 'wake up']]);
+    }
+  });
+});

package/test/lmdebug.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from 'vitest';
+import {
+  describeAssistantMessage,
+  describeSentPayload,
+  registerLmDebugWidget,
+} from '../src/lmdebug.ts';
+
+const NOW = new Date('2026-07-08T14:15:23').getTime();
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- bivariant fake for overloads
+type Handler = (event: any, ctx: any) => void;
+
+const createFakePi = () => {
+  const handlers = new Map<string, Handler[]>();
+  const widgets: Array<{ key: string; content: string[] | undefined; options: unknown }> = [];
+  const ctx = {
+    hasUI: true,
+    ui: {
+      setWidget: (key: string, content: string[] | undefined, options?: unknown) => {
+        widgets.push({ key, content, options });
+      },
+    },
+  };
+  return {
+    pi: {
+      on: (event: string, handler: Handler) => {
+        handlers.set(event, [...(handlers.get(event) ?? []), handler]);
+      },
+    },
+    emit: (event: string, payload: unknown) => {
+      for (const handler of handlers.get(event) ?? []) {
+        handler(payload, ctx);
+      }
+    },
+    widgets,
+  };
+};
+
+describe('describeSentPayload', () => {
+  it('summarizes the last message of an OpenAI-style payload', () => {
+    const text = describeSentPayload({
+      messages: [
+        { role: 'system', content: 'sys' },
+        { role: 'user', content: 'fix the bug in index.tsx' },
+      ],
+    });
+    expect(text).toBe('#2 user:\nfix the bug in index.tsx');
+  });
+
+  it('handles content parts arrays and missing payloads', () => {
+    expect(
+      describeSentPayload({ messages: [{ role: 'tool', content: [{ type: 'text', text: 'ok' }] }] }),
+    ).toBe('#1 tool:\nok');
+    expect(describeSentPayload(undefined)).toBe('no messages in payload');
+  });
+});
+
+describe('describeAssistantMessage', () => {
+  it('includes text and toolCall blocks with newlines preserved', () => {
+    const text = describeAssistantMessage({
+      role: 'assistant',
+      content: [
+        { type: 'text', text: 'I will edit\nthe file' },
+        { type: 'toolCall', name: 'edit', arguments: {} },
+      ],
+    });
+    expect(text).toBe('assistant:\nI will edit\nthe file\n[toolCall edit]');
+  });
+
+  it('returns undefined for non-assistant messages', () => {
+    expect(describeAssistantMessage({ role: 'user', content: [] })).toBeUndefined();
+  });
+});
+
+describe('registerLmDebugWidget', () => {
+  it('registers nothing when debug is false (the default)', () => {
+    const { pi, emit, widgets } = createFakePi();
+    registerLmDebugWidget(pi, false, () => NOW);
+    emit('before_provider_request', {
+      payload: { messages: [{ role: 'user', content: 'hello' }] },
+    });
+    expect(widgets).toHaveLength(0);
+  });
+
+  it('renders full multi-line messages with timestamps into a belowEditor widget', () => {
+    const { pi, emit, widgets } = createFakePi();
+    registerLmDebugWidget(pi, true, () => NOW);
+    emit('before_provider_request', {
+      payload: { messages: [{ role: 'user', content: 'hello\nsecond line' }] },
+    });
+    emit('message_end', {
+      message: { role: 'assistant', content: [{ type: 'text', text: 'hi there\nmore detail' }] },
+    });
+    expect(widgets).toHaveLength(2);
+    expect(widgets[1].key).toBe('watchdog-lm-debug');
+    expect(widgets[1].options).toEqual({ placement: 'belowEditor' });
+    expect(widgets[1].content).toEqual([
+      '▲ sent 14:15:23 #1 user:',
+      'hello',
+      'second line',
+      '',
+      '▼ recv 14:15:23 assistant:',
+      'hi there',
+      'more detail',
+    ]);
+  });
+
+  it('ignores non-assistant message_end events', () => {
+    const { pi, emit, widgets } = createFakePi();
+    registerLmDebugWidget(pi, true, () => NOW);
+    emit('message_end', { message: { role: 'toolResult', content: [] } });
+    expect(widgets).toHaveLength(0);
+  });
+});

package/test/normalize.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+import { hashOutput, normalizeCommand, normalizeLlmBody } from '../src/normalize.ts';
+
+describe('normalizeCommand', () => {
+  it('strips ANSI escape codes', () => {
+    expect(normalizeCommand('\u001b[31mrg\u001b[0m "X" src')).toBe('rg "X" src');
+  });
+
+  it('trims and collapses repeated whitespace', () => {
+    expect(normalizeCommand('  rg   "X"\t src  ')).toBe('rg "X" src');
+  });
+
+  it('returns empty string for whitespace-only input', () => {
+    expect(normalizeCommand('   \t  ')).toBe('');
+  });
+});
+
+describe('normalizeLlmBody', () => {
+  it('makes bodies differing only in timestamps identical', () => {
+    const a = normalizeLlmBody('done at 2026-07-08T14:15:23.018Z, retry 10:15:46 PM');
+    const b = normalizeLlmBody('done at 2026-07-08T14:16:41.777Z, retry 10:17:02 PM');
+    expect(a).toBe(b);
+  });
+
+  it('makes bodies differing only in ids and sequence numbers identical', () => {
+    const a = normalizeLlmBody('call tc-17 session 019f4213-974b-742e-883c-12f525463fb2 hash a1b2c3d4e5f6');
+    const b = normalizeLlmBody('call tc-42 session 22222222-974b-742e-883c-125254632222 hash ffffffffffff');
+    expect(a).toBe(b);
+  });
+
+  it('keeps genuinely different bodies different', () => {
+    expect(normalizeLlmBody('read file a.ts')).not.toBe(normalizeLlmBody('edit file a.ts'));
+  });
+
+  it('collapses whitespace and strips ANSI', () => {
+    expect(normalizeLlmBody('\u001b[31mok\u001b[0m   done\n\n now')).toBe('ok done now');
+  });
+});
+
+describe('hashOutput', () => {
+  it('is stable for identical input', () => {
+    const a = hashOutput('same output', { previewLines: 5 });
+    const b = hashOutput('same output', { previewLines: 5 });
+    expect(a.hash).toBe(b.hash);
+    expect(a.hash).toMatch(/^[0-9a-f]{64}$/);
+  });
+
+  it('differs for different input', () => {
+    expect(hashOutput('one', { previewLines: 5 }).hash).not.toBe(
+      hashOutput('two', { previewLines: 5 }).hash,
+    );
+  });
+
+  it('strips ANSI before hashing', () => {
+    expect(hashOutput('\u001b[32mok\u001b[0m', { previewLines: 5 }).hash).toBe(
+      hashOutput('ok', { previewLines: 5 }).hash,
+    );
+  });
+
+  it('truncates to maxBytes before hashing', () => {
+    const long = 'x'.repeat(100);
+    expect(hashOutput(long, { maxBytes: 10, previewLines: 5 }).hash).toBe(
+      hashOutput(long.slice(0, 10), { previewLines: 5 }).hash,
+    );
+  });
+
+  it('limits preview to previewLines lines', () => {
+    const output = ['l1', 'l2', 'l3', 'l4'].join('\n');
+    const { preview } = hashOutput(output, { previewLines: 2 });
+    expect(preview).toBe('l1\nl2');
+  });
+
+  it('handles empty input', () => {
+    const { hash, preview } = hashOutput('', { previewLines: 5 });
+    expect(hash).toMatch(/^[0-9a-f]{64}$/);
+    expect(preview).toBe('');
+  });
+});