groove-dev 0.27.184 → 0.27.186

package/node_modules/@groove-dev/daemon/src/watcher.js

@@ -0,0 +1,258 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import { deliverInstruction } from './deliver.js';
+
+// Watches are bounded so a wedged process or a condition that never comes true
+// can't poll forever or hold a slot indefinitely.
+const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+const MAX_TIMEOUT_MS = 6 * 60 * 60 * 1000;
+const DEFAULT_POLL_MS = 15 * 1000;
+const MIN_POLL_MS = 3 * 1000;
+const MAX_WATCHES_PER_AGENT = 5;
+const OUTPUT_TAIL = 4000;
+
+/**
+ * Wake-on-completion for agents.
+ *
+ * An agent promises to "report back when the tests finish", but its process
+ * ends when the turn does — so nothing is left to report. A Watch lives in the
+ * daemon, not the agent's session: it outlives the turn, and when its target
+ * finishes it resumes the agent (from `completed` if need be, via the same
+ * pipe as user chat) with the outcome.
+ *
+ * Two flavours:
+ *   - command: the daemon runs a command detached and owns its lifecycle, so
+ *     it has the real exit code and output when it finishes.
+ *   - until:   the daemon polls a check command for something already running,
+ *     and wakes the agent when the check first succeeds (exit 0).
+ */
+export class Watcher {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.watches = new Map();
+  }
+
+  create(agentId, opts = {}) {
+    const agent = this.daemon.registry.get(agentId);
+    if (!agent) throw new Error('Agent not found');
+
+    const command = typeof opts.command === 'string' ? opts.command.trim() : '';
+    const until = typeof opts.until === 'string' ? opts.until.trim() : '';
+    if (!command && !until) throw new Error('Provide either "command" (run it) or "until" (poll it)');
+    if (command && until) throw new Error('Provide only one of "command" or "until"');
+
+    const active = [...this.watches.values()].filter((w) => w.agentId === agentId && w.status === 'active');
+    if (active.length >= MAX_WATCHES_PER_AGENT) {
+      throw new Error(`You already have ${MAX_WATCHES_PER_AGENT} active watches — cancel one before adding another`);
+    }
+
+    const timeoutMs = Math.min(Number(opts.timeoutMs) || DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+    const watch = {
+      id: randomUUID().slice(0, 12),
+      agentId,
+      agentName: agent.name,
+      label: (opts.label && String(opts.label).slice(0, 120)) || command || until,
+      mode: command ? 'command' : 'until',
+      command, until,
+      cwd: agent.workingDir || this.daemon.projectDir,
+      pollMs: Math.max(Number(opts.intervalMs) || DEFAULT_POLL_MS, MIN_POLL_MS),
+      timeoutMs,
+      status: 'active',
+      createdAt: Date.now(),
+      _child: null,
+      _poll: null,
+      _deadline: null,
+    };
+
+    this.watches.set(watch.id, watch);
+    watch._deadline = setTimeout(() => this._fireTimeout(watch), timeoutMs);
+    if (watch.mode === 'command') this._runCommand(watch);
+    else this._startPolling(watch);
+
+    this.daemon.audit?.log('watch.create', { id: watch.id, agent: agentId, mode: watch.mode });
+    this.daemon.broadcast?.({ type: 'watch:created', data: this._public(watch) });
+    return this._public(watch);
+  }
+
+  // ── command mode: daemon owns the process ─────────────────────
+
+  _runCommand(watch) {
+    const child = spawn('/bin/sh', ['-c', watch.command], {
+      cwd: watch.cwd,
+      env: process.env,
+      detached: false,
+    });
+    watch._child = child;
+
+    const chunks = [];
+    let bytes = 0;
+    const collect = (buf) => {
+      // Keep only the tail — a chatty build shouldn't grow this unbounded.
+      chunks.push(buf);
+      bytes += buf.length;
+      while (bytes > OUTPUT_TAIL * 2 && chunks.length > 1) bytes -= chunks.shift().length;
+    };
+    child.stdout?.on('data', collect);
+    child.stderr?.on('data', collect);
+
+    child.on('error', (err) => {
+      this._wake(watch, {
+        outcome: 'error',
+        summary: `Could not start the command: ${err.message}`,
+      });
+    });
+
+    child.on('close', (code, signal) => {
+      if (watch.status !== 'active') return; // already timed out / cancelled
+      const output = Buffer.concat(chunks).toString('utf8').slice(-OUTPUT_TAIL).trim();
+      this._wake(watch, {
+        outcome: code === 0 ? 'success' : 'failure',
+        exitCode: code,
+        signal,
+        summary: signal
+          ? `Terminated by signal ${signal}.`
+          : `Finished with exit code ${code}.`,
+        output,
+      });
+    });
+  }
+
+  // ── until mode: poll something already running ────────────────
+
+  _startPolling(watch) {
+    const tick = () => {
+      if (watch.status !== 'active') return;
+      const check = spawn('/bin/sh', ['-c', watch.until], { cwd: watch.cwd, env: process.env });
+      const chunks = [];
+      check.stdout?.on('data', (b) => chunks.push(b));
+      check.stderr?.on('data', (b) => chunks.push(b));
+      check.on('error', () => { /* transient — try again next tick */ });
+      check.on('close', (code) => {
+        if (watch.status !== 'active') return;
+        if (code === 0) {
+          const output = Buffer.concat(chunks).toString('utf8').slice(-OUTPUT_TAIL).trim();
+          this._wake(watch, { outcome: 'success', summary: 'Your watch condition is now true.', output });
+        }
+      });
+    };
+    watch._poll = setInterval(tick, watch.pollMs);
+    tick(); // check immediately — the condition may already hold
+  }
+
+  // ── firing ────────────────────────────────────────────────────
+
+  _fireTimeout(watch) {
+    if (watch.status !== 'active') return;
+    this._wake(watch, {
+      outcome: 'timeout',
+      summary: `Your watch "${watch.label}" hit its ${Math.round(watch.timeoutMs / 60000)}-minute time limit `
+        + 'without finishing. It may still be running — check on it directly.',
+    });
+  }
+
+  async _wake(watch, result) {
+    if (watch.status !== 'active') return;
+    watch.status = 'fired';
+    watch.firedAt = Date.now();
+    watch.result = result;
+    this._cleanup(watch);
+
+    const message = this._composeMessage(watch, result);
+
+    // Resolve by name, not the id we stored at creation: over a 30-minute
+    // watch the agent has very likely been chatted with and rotated to a new
+    // id. Names are stable across rotation, so this follows the agent; a
+    // purged/gone agent simply doesn't resolve and the watch is undeliverable
+    // rather than resurrecting a killed agent under a stale id.
+    const target = this.daemon.registry.getAll().find((a) => a.name === watch.agentName);
+    if (!target) {
+      watch.status = 'undeliverable';
+      watch.deliveryError = `Agent ${watch.agentName} no longer exists`;
+      this.daemon.audit?.log('watch.undeliverable', { id: watch.id, reason: 'agent gone' });
+      this.daemon.broadcast?.({ type: 'watch:fired', data: this._public(watch) });
+      return;
+    }
+
+    try {
+      const delivered = await deliverInstruction(this.daemon, target.id, message, { recordFeedback: false });
+      watch.agentId = delivered.agentId;
+      watch.status = 'delivered';
+    } catch (err) {
+      watch.status = 'undeliverable';
+      watch.deliveryError = err.message;
+      this.daemon.audit?.log('watch.undeliverable', { id: watch.id, error: err.message });
+    }
+
+    this.daemon.broadcast?.({ type: 'watch:fired', data: this._public(watch) });
+  }
+
+  _composeMessage(watch, result) {
+    const lines = [`[Watch fired — "${watch.label}"]`, '', result.summary];
+    if (result.output) {
+      lines.push('', 'Output (tail):', '```', result.output, '```');
+    }
+    lines.push('', 'This is the notification you set up earlier. Continue from here and report to the user.');
+    return lines.join('\n');
+  }
+
+  // ── lifecycle ─────────────────────────────────────────────────
+
+  cancel(id, agentId = null) {
+    const watch = this.watches.get(id);
+    if (!watch) return false;
+    if (agentId && watch.agentId !== agentId) return false;
+    if (watch.status === 'active') {
+      watch.status = 'cancelled';
+      this._cleanup(watch);
+      this.daemon.broadcast?.({ type: 'watch:cancelled', data: this._public(watch) });
+    }
+    return true;
+  }
+
+  // An agent that is killed/purged shouldn't leave watches firing into a void.
+  cancelForAgent(agentId) {
+    for (const watch of this.watches.values()) {
+      if (watch.agentId === agentId && watch.status === 'active') {
+        watch.status = 'cancelled';
+        this._cleanup(watch);
+      }
+    }
+  }
+
+  _cleanup(watch) {
+    if (watch._deadline) { clearTimeout(watch._deadline); watch._deadline = null; }
+    if (watch._poll) { clearInterval(watch._poll); watch._poll = null; }
+    if (watch._child && watch.mode === 'command' && watch.status === 'cancelled') {
+      // Only kill the process when the user/agent cancelled — a fired watch
+      // means it exited on its own.
+      try { watch._child.kill('SIGTERM'); } catch { /* already gone */ }
+    }
+    watch._child = null;
+  }
+
+  list(agentId = null) {
+    const all = [...this.watches.values()].sort((a, b) => b.createdAt - a.createdAt);
+    return (agentId ? all.filter((w) => w.agentId === agentId) : all).map((w) => this._public(w));
+  }
+
+  stop() {
+    for (const watch of this.watches.values()) {
+      if (watch._deadline) clearTimeout(watch._deadline);
+      if (watch._poll) clearInterval(watch._poll);
+      if (watch._child) { try { watch._child.kill('SIGTERM'); } catch { /* gone */ } }
+      watch._deadline = watch._poll = watch._child = null;
+    }
+  }
+
+  _public(w) {
+    return {
+      id: w.id, agentId: w.agentId, agentName: w.agentName, label: w.label,
+      mode: w.mode, command: w.command, until: w.until, status: w.status,
+      createdAt: w.createdAt, firedAt: w.firedAt || null, result: w.result || null,
+    };
+  }
+}
+
+export { DEFAULT_TIMEOUT_MS, MAX_WATCHES_PER_AGENT };

package/node_modules/@groove-dev/daemon/test/innerchat.test.js

@@ -1,7 +1,7 @@
 // GROOVE — InnerChat Tests
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { describe, it, beforeEach } from 'node:test';
+import { describe, it, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { InnerChat, MAX_EXCHANGES } from '../src/innerchat.js';
 
@@ -72,6 +72,9 @@ describe('InnerChat', () => {
     }
   });
 
+  // Clear any un-awaited ask/tell timers so the runner can exit.
+  afterEach(() => innerchat.stop());
+
   // ── The blocking round trip ───────────────────────────────
 
   it('blocks until the target answers, then resolves with the reply', async () => {
@@ -259,4 +262,71 @@ describe('InnerChat', () => {
     assert.ok(daemon.audits.some((a) => a.type === 'innerchat.ask'));
     assert.ok(daemon.audits.some((a) => a.type === 'innerchat.answer'));
   });
+
+  // ── tell: non-blocking send ───────────────────────────────
+
+  it('tell returns immediately without waiting for a reply', async () => {
+    const res = await innerchat.tell('a1', 'a2', 'heads up, spec is on disk');
+    assert.equal(res.delivered, true);
+    assert.ok(res.threadId);
+
+    // Delivered, framed as non-blocking.
+    const msg = daemon.sent.at(-1);
+    assert.equal(msg.id, 'a2');
+    assert.match(msg.msg, /sent you a message/);
+    assert.match(msg.msg, /NOT blocked/);
+  });
+
+  it('routes an async reply back to the sender, resuming it if needed', async () => {
+    await innerchat.tell('a1', 'a2', 'when you get a sec, confirm the error shape');
+    // a1 ended its turn: stopped, no loop.
+    daemon.processes._loops.delete('a1');
+    daemon.processes._running.delete('a1');
+
+    innerchat.onAgentOutput('a2', result('confirmed: {code, message}'));
+    await tick();
+
+    // Reply delivered to a1 — via resume, since it had ended.
+    const resume = daemon.resumes.at(-1);
+    assert.equal(resume.id, 'a1');
+    assert.match(resume.msg, /InnerChat reply from fullstack-14/);
+    assert.match(resume.msg, /confirmed: \{code, message\}/);
+    assert.match(resume.msg, /you were not blocking/);
+  });
+
+  it('does not block the sender or set blockedOn for a tell', async () => {
+    await innerchat.tell('a1', 'a2', 'fyi');
+    assert.equal(innerchat.blockedOn.get('a1'), undefined);
+    assert.ok(innerchat.getPending('a2'), 'still capturing the eventual reply');
+  });
+
+  it('a tell to a target already awaited is refused', async () => {
+    // Left blocking; afterEach stop() rejects it — swallow so it isn't unhandled.
+    innerchat.ask('a1', 'a2', 'blocking q').catch(() => {});
+    await tick();
+    await assert.rejects(() => innerchat.tell('a1', 'a2', 'second'), /unanswered message/);
+  });
+
+  it('ask and tell share the exchange budget', async () => {
+    const r1 = await innerchat.tell('a1', 'a2', 'one');
+    assert.equal(r1.exchanges, 1);
+    // a2 replies to the tell, freeing the slot.
+    innerchat.onAgentOutput('a2', result('ok'));
+    await tick();
+
+    const p = innerchat.ask('a1', 'a2', 'two');
+    await tick();
+    innerchat.onAgentOutput('a2', result('answer'));
+    const r2 = await p;
+    assert.equal(r2.exchanges, 2, 'tell + ask both count');
+  });
+
+  it('an async sender that vanishes is dropped quietly', async () => {
+    await innerchat.tell('a1', 'a2', 'x');
+    daemon.registry._agents.delete('a1'); // sender gone entirely
+    // Reply arrives with nobody to route to — must not throw.
+    innerchat.onAgentOutput('a2', result('late answer'));
+    await tick();
+    assert.equal(innerchat.getPending('a2'), null);
+  });
 });

package/node_modules/@groove-dev/daemon/test/journalist.test.js

@@ -234,6 +234,65 @@ describe('Journalist', () => {
     });
   });
 
+  describe('conversation resume', () => {
+    // Build a log whose first user message is the task assignment, followed by
+    // enough later dialogue that a small budget truncates the early turns away.
+    function writeLongConversation(grooveDir, agentName, originalTask, fillerTurns = 20) {
+      const lines = [
+        JSON.stringify({ type: 'user', message: { content: originalTask } }),
+        JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: 'Understood — starting on the original task now, here is my plan.' }] } }),
+      ];
+      for (let i = 0; i < fillerTurns; i++) {
+        lines.push(JSON.stringify({ type: 'user', message: { content: `Follow-up question number ${i}: ${'detail '.repeat(50)}` } }));
+        lines.push(JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text: `Answer to follow-up ${i}: ${'context '.repeat(50)}` }] } }));
+      }
+      writeFileSync(join(grooveDir, 'logs', `${agentName}.log`), lines.join('\n'));
+    }
+
+    const agentFixture = {
+      id: 'arch-id-1', name: 'arch-1', role: 'backend',
+      provider: 'claude-code', scope: ['src/**'], workingDir: '/tmp',
+    };
+
+    it('rotation resume prompt forbids mentioning the rotation to the user', () => {
+      const { daemon, grooveDir } = createMockDaemon();
+      const journalist = new Journalist(daemon);
+      writeLongConversation(grooveDir, 'arch-1', 'Build the training pipeline', 2);
+
+      const prompt = journalist.buildConversationResumePrompt(agentFixture, '', { isRotation: true, reason: 'replay_ceiling' });
+
+      assert.ok(prompt, 'should build a resume prompt');
+      assert.ok(prompt.includes('NEVER mention the rotation'), 'must instruct the agent to keep the rotation invisible');
+    });
+
+    it('anchors the original task from the full log even when the thread window truncates it', () => {
+      const { daemon, grooveDir } = createMockDaemon();
+      // Small budget: only recent filler turns survive in the thread window
+      daemon.config = { resumeBudgetChars: 3000 };
+      const journalist = new Journalist(daemon);
+      const originalTask = 'Build a mixture-of-experts LLM training pipeline from scratch';
+      writeLongConversation(grooveDir, 'arch-1', originalTask, 20);
+
+      // Sanity: the truncated window no longer contains the original task
+      const thread = journalist.extractConversationThread(agentFixture);
+      assert.ok(thread, 'should extract a thread');
+      assert.ok(!thread.includes(originalTask), 'test setup: original task must be truncated out of the window');
+
+      const prompt = journalist.buildConversationResumePrompt(agentFixture, '', { isRotation: true, reason: 'replay_ceiling' });
+      assert.ok(prompt.includes(originalTask), 'original task must still anchor the prompt via the full log');
+    });
+
+    it('honors resumeBudgetChars config for the thread window', () => {
+      const { daemon, grooveDir } = createMockDaemon();
+      daemon.config = { resumeBudgetChars: 2000 };
+      const journalist = new Journalist(daemon);
+      writeLongConversation(grooveDir, 'arch-1', 'Build the training pipeline', 20);
+
+      const thread = journalist.extractConversationThread(agentFixture);
+      assert.ok(thread.length <= 2500, `thread should respect the configured budget, got ${thread.length}`);
+    });
+  });
+
   describe('status', () => {
     it('should report status correctly', () => {
       const { daemon } = createMockDaemon();

package/node_modules/@groove-dev/daemon/test/rotator.test.js

@@ -457,7 +457,7 @@ describe('Rotator', () => {
     const agent = {
       id: 'rc1', name: 'claude-chat', role: 'backend', status: 'running',
       provider: 'claude-code', scope: [], model: null,
-      tokensUsed: 100_000, contextUsage: 0.55, workingDir: '/tmp',
+      tokensUsed: 100_000, contextUsage: 0.85, workingDir: '/tmp',
       lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(), // idle 5 min
       spawnedAt: new Date(Date.now() - 600_000).toISOString(),
     };
@@ -470,22 +470,40 @@ describe('Rotator', () => {
     assert.equal(history[0].reason, 'replay_ceiling');
   });
 
+  it('should honor a configured replayCeiling below the default', async () => {
+    const agent = {
+      id: 'rc5', name: 'claude-cheap', role: 'backend', status: 'running',
+      provider: 'claude-code', scope: [], model: null,
+      tokensUsed: 100_000, contextUsage: 0.55, workingDir: '/tmp',
+      lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(),
+      spawnedAt: new Date(Date.now() - 600_000).toISOString(),
+    };
+    mockDaemon.registry.agents = [agent];
+    mockDaemon.config = { replayCeiling: 0.5 };
+
+    await rotator.check();
+
+    const history = rotator.getHistory();
+    assert.equal(history.length, 1);
+    assert.equal(history[0].reason, 'replay_ceiling');
+  });
+
   it('should NOT replay-ceiling rotate below the ceiling or during cooldown', async () => {
     const agent = {
       id: 'rc2', name: 'claude-chat-2', role: 'backend', status: 'running',
       provider: 'claude-code', scope: [], model: null,
-      tokensUsed: 100_000, contextUsage: 0.45, workingDir: '/tmp',
+      tokensUsed: 100_000, contextUsage: 0.75, workingDir: '/tmp',
       lastActivity: new Date(Date.now() - 5 * 60_000).toISOString(),
       spawnedAt: new Date(Date.now() - 600_000).toISOString(),
     };
     mockDaemon.registry.agents = [agent];
 
-    // Below ceiling — no rotation
+    // Below ceiling (0.75 < 0.80 default) — no rotation
     await rotator.check();
     assert.equal(rotator.getHistory().length, 0);
 
     // Above ceiling but on cooldown — still no rotation
-    agent.contextUsage = 0.60;
+    agent.contextUsage = 0.85;
     rotator.lastRotationTime.set('rc2', Date.now() - 60_000);
     await rotator.check();
     assert.equal(rotator.getHistory().length, 0);

package/node_modules/@groove-dev/daemon/test/watcher.test.js

@@ -0,0 +1,158 @@
+// GROOVE — Watcher Tests
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { Watcher } from '../src/watcher.js';
+
+// Captures what the watcher hands to deliverInstruction — the wake message and
+// which agent it woke — without needing a real process manager.
+function makeDaemon() {
+  const delivered = [];
+  const broadcasts = [];
+  return {
+    delivered, broadcasts,
+    projectDir: process.cwd(),
+    registry: {
+      _agents: new Map(),
+      add(a) { this._agents.set(a.id, a); return a; },
+      get(id) { return this._agents.get(id) || null; },
+      getAll() { return [...this._agents.values()]; },
+    },
+    audit: { log() {} },
+    broadcast(m) { broadcasts.push(m); },
+    // Stand-in for deliverInstruction's daemon-level delivery.
+    _deliver(agentId, message) { delivered.push({ agentId, message }); return { agentId }; },
+  };
+}
+
+// Point deliverInstruction at our capture by giving the agent a live loop the
+// real deliver.js would use — simpler here to stub the module boundary.
+// The watcher imports deliverInstruction directly, so we exercise it through a
+// registry whose agent looks "running with a loop" and a process manager that
+// records the send.
+function wireDelivery(daemon) {
+  daemon.processes = {
+    hasAgentLoop: () => true,
+    isRunning: () => true,
+    async sendMessage(id, msg) { daemon._deliver(id, msg); return true; },
+    queueMessage(id, msg) { daemon._deliver(id, msg); },
+  };
+  daemon.locks = { release() {} };
+}
+
+const settle = (ms = 40) => new Promise((r) => setTimeout(r, ms));
+
+describe('Watcher', () => {
+  let daemon, watcher;
+
+  beforeEach(() => {
+    daemon = makeDaemon();
+    wireDelivery(daemon);
+    watcher = new Watcher(daemon);
+    daemon.watcher = watcher;
+    daemon.registry.add({ id: 'a1', name: 'fullstack-1', role: 'fullstack', provider: 'claude-code' });
+  });
+
+  // Clear any lingering timers/intervals/children — an active poll watch has a
+  // 30-minute deadline that would otherwise keep the test runner alive.
+  afterEach(() => watcher.stop());
+
+  it('runs a command and wakes the agent with a success outcome', async () => {
+    watcher.create('a1', { command: 'echo hello && exit 0', label: 'greeting' });
+    await settle(200);
+
+    assert.equal(daemon.delivered.length, 1);
+    const { agentId, message } = daemon.delivered[0];
+    assert.equal(agentId, 'a1');
+    assert.match(message, /Watch fired — "greeting"/);
+    assert.match(message, /exit code 0/);
+    assert.match(message, /hello/);
+  });
+
+  it('reports a non-zero exit as a failure with output', async () => {
+    watcher.create('a1', { command: 'echo boom >&2 && exit 3', label: 'build' });
+    await settle(200);
+
+    const { message } = daemon.delivered[0];
+    assert.match(message, /exit code 3/);
+    assert.match(message, /boom/);
+  });
+
+  it('resolves the agent by name so a rotation to a new id still gets woken', async () => {
+    watcher.create('a1', { command: 'exit 0', label: 'x' });
+    // Agent rotates: same name, new id, old id gone — exactly what resume does.
+    daemon.registry._agents.delete('a1');
+    daemon.registry.add({ id: 'a1-r1', name: 'fullstack-1', role: 'fullstack', provider: 'claude-code' });
+    await settle(200);
+
+    assert.equal(daemon.delivered.length, 1);
+    assert.equal(daemon.delivered[0].agentId, 'a1-r1');
+  });
+
+  it('marks undeliverable when the agent is gone, without throwing', async () => {
+    watcher.create('a1', { command: 'exit 0', label: 'x' });
+    daemon.registry._agents.delete('a1'); // purged, no replacement
+    await settle(200);
+
+    assert.equal(daemon.delivered.length, 0);
+    const w = watcher.list()[0];
+    assert.equal(w.status, 'undeliverable');
+  });
+
+  it('fires an "until" watch when the condition already holds (immediate check)', async () => {
+    const fs = await import('fs');
+    const flag = `${process.cwd()}/.watch-test-flag-${Date.now()}`;
+    fs.writeFileSync(flag, 'x');
+    try {
+      // create() checks once immediately before waiting for the poll interval.
+      watcher.create('a1', { until: `test -f ${flag}`, label: 'flag present' });
+      await settle(120);
+      assert.equal(daemon.delivered.length, 1, 'woke because the condition was already true');
+      assert.match(daemon.delivered[0].message, /condition is now true/);
+    } finally {
+      try { fs.unlinkSync(flag); } catch { /* ignore */ }
+    }
+  });
+
+  it('does not fire an until-watch while the condition stays false', async () => {
+    watcher.create('a1', { until: 'exit 1', label: 'never', intervalMs: 3000 });
+    await settle(80);
+    assert.equal(daemon.delivered.length, 0);
+    assert.equal(watcher.list()[0].status, 'active');
+  });
+
+  it('fires a timeout when the command runs too long', async () => {
+    watcher.create('a1', { command: 'sleep 5', label: 'slow', timeoutMs: 60 });
+    await settle(160);
+
+    const { message } = daemon.delivered[0];
+    assert.match(message, /time limit/);
+  });
+
+  it('rejects bad input', () => {
+    assert.throws(() => watcher.create('a1', {}), /Provide either/);
+    assert.throws(() => watcher.create('a1', { command: 'x', until: 'y' }), /only one/);
+    assert.throws(() => watcher.create('nope', { command: 'x' }), /Agent not found/);
+  });
+
+  it('caps active watches per agent', () => {
+    for (let i = 0; i < 5; i++) watcher.create('a1', { command: 'sleep 5', label: `w${i}` });
+    assert.throws(() => watcher.create('a1', { command: 'sleep 5' }), /already have 5/);
+  });
+
+  it('cancels a watch and stops its process', async () => {
+    const w = watcher.create('a1', { command: 'sleep 5', label: 'cancel me' });
+    assert.equal(watcher.cancel(w.id), true);
+    assert.equal(watcher.list()[0].status, 'cancelled');
+    await settle(100);
+    assert.equal(daemon.delivered.length, 0, 'a cancelled watch never wakes the agent');
+  });
+
+  it('cancels all of an agents watches when it is removed', () => {
+    watcher.create('a1', { command: 'sleep 5', label: 'a' });
+    watcher.create('a1', { command: 'sleep 5', label: 'b' });
+    watcher.cancelForAgent('a1');
+    assert.ok(watcher.list().every((w) => w.status === 'cancelled'));
+  });
+});