groove-dev 0.27.184 → 0.27.186

package/.watch-test-flag-1784767927904

@@ -0,0 +1 @@
+x

package/.watch-test-flag-1784768055729

@@ -0,0 +1 @@
+x

package/.watch-test-flag-1784768066364

@@ -0,0 +1 @@
+x

package/node_modules/@groove-dev/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.184",
+  "version": "0.27.186",
   "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/node_modules/@groove-dev/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.184",
+  "version": "0.27.186",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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

@@ -28,6 +28,7 @@ import { registerFileRoutes, resetEditorRoot } from './routes/files.js';
 import { registerNetworkRoutes } from './routes/network.js';
 import { registerScheduleRoutes } from './routes/schedules.js';
 import { registerInnerChatRoutes } from './routes/innerchat.js';
+import { registerWatchRoutes } from './routes/watch.js';
 import { registerAutoAgentRoutes } from './routes/auto-agents.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -178,6 +179,7 @@ export function createApi(app, daemon) {
   registerNetworkRoutes(app, daemon);
   registerScheduleRoutes(app, daemon);
   registerInnerChatRoutes(app, daemon);
+  registerWatchRoutes(app, daemon);
   registerAutoAgentRoutes(app, daemon);
 
 
@@ -1439,6 +1441,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
       'qcThreshold', 'maxAgents', 'defaultProvider', 'defaultWorkingDir',
       'onboardingDismissed', 'defaultModel', 'defaultChatProvider', 'defaultChatModel',
       'dataSharingDismissed', 'replayCeiling', 'velocityCeiling', 'journalistModelTier',
+      'resumeBudgetChars',
     ];
     for (const key of Object.keys(req.body)) {
       if (!ALLOWED_KEYS.includes(key)) {

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

@@ -47,6 +47,7 @@ import { RepoImporter } from './repo-import.js';
 import { ConversationManager } from './conversations.js';
 import { Toys } from './toys.js';
 import { InnerChat } from './innerchat.js';
+import { Watcher } from './watcher.js';
 import { AutoState } from './autostate.js';
 import { Orchestrator } from './orchestrator.js';
 import { TrajectoryCapture, ConsentManager } from '../../../moe-training/client/index.js';
@@ -162,6 +163,7 @@ export class Daemon {
     this.modelLab = new ModelLab(this);
     this.toys = new Toys(this);
     this.innerchat = new InnerChat(this);
+    this.watcher = new Watcher(this);
     this.autoState = new AutoState(this.grooveDir);
     this.orchestrator = new Orchestrator(this);
     this.trajectoryCapture = null;
@@ -623,6 +625,19 @@ export class Daemon {
         this.federation.initialize();
         this._startGarbageCollector();
 
+        // Regenerate the on-disk registry files once on boot. They otherwise
+        // only refresh on a registry change, so a daemon upgraded with new
+        // agent-facing docs (InnerChat, Watch) would serve stale AGENTS_REGISTRY.md
+        // to already-running agents until something happened to change state.
+        if (this.registry.getAll().length > 0) {
+          try {
+            this.introducer.writeRegistryFile(this.projectDir);
+            this.introducer.injectGrooveSection(this.projectDir);
+          } catch (err) {
+            console.error('[startup] Failed to refresh registry files:', err.message);
+          }
+        }
+
         // Restore auth token from stored config so subscription polling works after restart
         const storedToken = this.skills.getToken();
         if (storedToken) {
@@ -847,6 +862,8 @@ export class Daemon {
     this.journalist.stop();
     this.rotator.stop();
     this.scheduler.stop();
+    this.watcher.stop();
+    this.innerchat.stop();
     this.orchestrator.stop();
     this.timeline.stop();
     if (this._gcInterval) clearInterval(this._gcInterval);

package/node_modules/@groove-dev/daemon/src/innerchat-docs.js

@@ -17,25 +17,80 @@ export function innerChatInstructions(port = 31415, agentName = 'YOUR_NAME') {
     'When the user asks you to reach out to, coordinate with, or get input from',
     'another agent, use this — it sends them a message and waits for their reply:',
     '',
+    '> **Do NOT use your built-in `SendMessage` / Agent tools to reach a GROOVE agent.**',
+    '> Those only address sub-agents you spawned yourself in this session, so they will',
+    '> fail with "not reachable" or ask you for an `a…-…` agent ID that does not exist',
+    '> here. GROOVE agents are separate processes. The curl below is the only way to',
+    '> reach them. Do not invent a fallback (writing a message into a file, etc.) —',
+    '> if the curl fails, read the error and report it to the user.',
+    '',
     '```bash',
     `curl -s http://localhost:${port}/api/innerchat/ask -X POST -H 'Content-Type: application/json' \\`,
     `  -d '{"from":"${agentName}","to":"AGENT_NAME","message":"YOUR_QUESTION"}'`,
     '```',
     '',
-    'The command BLOCKS until they answer, then returns:',
+    'This BLOCKS until they answer, then returns:',
     '`{"from":"...","reply":"...","exchangesUsed":N,"exchangesRemaining":N}`',
     '',
+    '> **Run the curl in the FOREGROUND and let it block.** Do not background it with',
+    "> `&`, and never put `&` inside the command — that detaches the curl and throws away",
+    "> the reply, so you get no answer and can't confirm delivery. Blocking for a minute or",
+    '> two is expected and correct; just wait for it. If you truly cannot wait, use `tell`',
+    '> (below) instead — that is the right tool for fire-and-forget, not a backgrounded ask.',
+    '',
     'Call it again to continue — prior turns are included automatically, so just say',
     'the next thing. Keep going until you reach a conclusion together, then report',
-    'that conclusion to the user.',
+    'that conclusion to the user. `ask` is best for tight back-and-forth (negotiating',
+    'an interface, resolving a blocker) where you need the answer before you proceed.',
+    '',
+    'If the other agent is heads-down and you do NOT need the answer right now, send it',
+    'without blocking instead — this returns immediately, and their reply (if any) is',
+    'delivered back to you later, waking you if your turn has ended:',
+    '',
+    '```bash',
+    `curl -s http://localhost:${port}/api/innerchat/tell -X POST -H 'Content-Type: application/json' \\`,
+    `  -d '{"from":"${agentName}","to":"AGENT_NAME","message":"YOUR_MESSAGE"}'`,
+    '```',
     '',
     '**Rules:**',
     '- Only start a conversation when the user asks you to. Never consult other agents on your own initiative.',
     `- \`from\` must be your own agent name${agentName === 'YOUR_NAME' ? ' (it is in your $GROOVE_AGENT_NAME environment variable)' : ''}.`,
     '- Agent names are listed in `AGENTS_REGISTRY.md`, including agents on other teams.',
-    '- One question per call. Wait for the answer before deciding what to ask next.',
+    '- Use `ask` when you need the reply now; use `tell` to hand off or notify without waiting.',
+    '- One message per call. With `ask`, wait for the answer before deciding what to ask next.',
+    '- Ground truth lives in files (specs, code, run output), not in chat — use InnerChat to',
+    '  negotiate and hand off, and verify claims against the actual artifacts.',
     '- Read any error you get back — it tells you what to do (unknown name, cap reached, or they are waiting on you).',
-    '- `exchangesRemaining` counts down. At 0 the conversation is over: stop and report what you have.',
-    '- If another agent asks YOU something, answer it directly in your next message. They are blocked until you do.',
+    '- `exchangesRemaining` counts down (shared by ask and tell). At 0 the conversation is over: stop and report.',
+    '- If another agent asks YOU something (a blocking ask), answer it directly in your next message — they are blocked until you do.',
+  ];
+}
+
+// Wake-on-completion. Same delivery/injection story as InnerChat above.
+export function watchInstructions(port = 31415, agentName = 'YOUR_NAME') {
+  const nameHint = agentName === 'YOUR_NAME' ? ' ($GROOVE_AGENT_NAME)' : '';
+  return [
+    '## Getting Notified When Something Finishes (Watch)',
+    '',
+    'Your process ends when your turn ends, so a test suite or long job you kicked',
+    'off has nothing to notify you — telling the user "I\'ll report back when it lands"',
+    'does not work on its own; the session is gone. Instead, set a Watch. The daemon',
+    'outlives your turn and RESUMES you with the result when it finishes:',
+    '',
+    '```bash',
+    `curl -s http://localhost:${port}/api/watch -X POST -H 'Content-Type: application/json' \\`,
+    `  -d '{"agent":"${agentName}","label":"test suite","command":"npm test"}'`,
+    '```',
+    '',
+    'This returns immediately with a `watchId`. **End your turn** — you will be woken',
+    'with the exit code and output tail when the command finishes.',
+    '',
+    '- Prefer `command` (let the daemon run it) over launching it yourself — that way',
+    '  it captures the real exit code and output.',
+    '- For something ALREADY running, poll instead with `until` (fires when the check',
+    `  exits 0): \`-d '{"agent":"${agentName}","label":"server up","until":"curl -sf localhost:3000/health"}'\`.`,
+    `- \`agent\` must be your own name${nameHint}.`,
+    '- Watches time out (default 30 min). One clear task per watch; do not watch trivial commands you could just run.',
+    '- Do not poll or sleep-loop waiting yourself — set the watch and end the turn. That is the whole point.',
   ];
 }

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

@@ -65,81 +65,127 @@ export class InnerChat {
       throw new Error(`${toAgent.name} is already answering another agent — try again shortly`);
     }
 
-    const thread = opts.threadId ? this.threads.get(opts.threadId) : this._findThread(fromAgentId, toAgentId);
-    const t = thread || this._createThread(fromAgent, toAgent);
+    const t = this._openThread(fromAgent, toAgent, opts.threadId);
+    this._checkExchangeCap(t, toAgent);
 
-    const exchanges = t.turns.filter((x) => x.kind === 'ask').length;
-    if (exchanges >= MAX_EXCHANGES) {
-      throw new Error(
-        `This conversation has reached its ${MAX_EXCHANGES}-exchange limit. Stop consulting `
-        + `${toAgent.name} and report your conclusion to the user.`,
-      );
+    const timeoutMs = Math.min(Number(opts.timeoutMs) || DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+
+    const { turn, targetId, skipResults } = await this._deliver(t, fromAgent, toAgent, message.trim(), 'ask');
+    this.daemon.audit.log('innerchat.ask', { thread: t.id, from: fromAgentId, to: targetId });
+
+    const reply = await this._awaitReply(t, fromAgentId, targetId, { skipResults, timeoutMs });
+    const exchanges = t.turns.filter((x) => x.kind === 'ask' || x.kind === 'tell').length;
+
+    return { reply, threadId: t.id, exchanges, remaining: MAX_EXCHANGES - exchanges };
+  }
+
+  /**
+   * Send a message to another agent WITHOUT blocking. Returns as soon as it's
+   * delivered. If the target later replies, the reply is routed back to the
+   * sender asynchronously — resuming the sender if its turn has ended.
+   *
+   * This is the fire-and-forget counterpart to ask(): use it to hand off to an
+   * agent that's heads-down, where waiting out a timeout would waste the turn.
+   */
+  async tell(fromAgentId, toAgentId, message, opts = {}) {
+    const fromAgent = this.daemon.registry.get(fromAgentId);
+    const toAgent = this.daemon.registry.get(toAgentId);
+    if (!fromAgent) throw new Error(`Calling agent ${fromAgentId} not found`);
+    if (!toAgent) throw new Error(`Target agent ${toAgentId} not found`);
+    if (fromAgentId === toAgentId) throw new Error('An agent cannot message itself');
+    if (!message || !message.trim()) throw new Error('message is required');
+    if (this.awaiting.has(toAgentId)) {
+      throw new Error(`${toAgent.name} already has an unanswered message — wait for its reply before sending another`);
     }
 
-    const timeoutMs = Math.min(Number(opts.timeoutMs) || DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+    const t = this._openThread(fromAgent, toAgent, opts.threadId);
+    this._checkExchangeCap(t, toAgent);
 
+    const { turn, targetId, skipResults } = await this._deliver(t, fromAgent, toAgent, message.trim(), 'tell');
+    this.daemon.audit.log('innerchat.tell', { thread: t.id, from: fromAgentId, to: targetId });
+
+    // Register async capture: the reply (if any) is forwarded, not awaited.
+    this.awaiting.set(targetId, {
+      mode: 'async',
+      threadId: t.id,
+      senderId: fromAgentId,
+      skipResults,
+      timer: setTimeout(() => this._clearAwait(targetId), MAX_TIMEOUT_MS),
+    });
+
+    const exchanges = t.turns.filter((x) => x.kind === 'ask' || x.kind === 'tell').length;
+    return { delivered: true, threadId: t.id, exchanges, remaining: MAX_EXCHANGES - exchanges };
+  }
+
+  // Shared send: push a turn, deliver it, and remap the target id if delivery
+  // resumed/rotated the agent. Returns the queued-skip count for reply capture.
+  async _deliver(thread, fromAgent, toAgent, message, kind) {
     const turn = {
       id: randomUUID().slice(0, 12),
       from: peer(fromAgent),
       to: peer(toAgent),
-      text: message.trim(),
-      kind: 'ask',
+      text: message,
+      kind,
       status: 'sending',
       timestamp: Date.now(),
     };
-    t.turns.push(turn);
+    thread.turns.push(turn);
 
-    const wrapped = this._wrap(t, fromAgent, toAgent, message.trim());
+    const wrapped = this._wrap(thread, fromAgent, toAgent, message, kind);
 
     let result;
     try {
-      result = await deliverInstruction(this.daemon, toAgentId, wrapped, { recordFeedback: false });
+      result = await deliverInstruction(this.daemon, toAgent.id, wrapped, { recordFeedback: false });
     } catch (err) {
       turn.status = 'failed';
       turn.error = err.message;
-      t.status = 'failed';
-      this._broadcast(t, turn);
+      thread.status = 'failed';
+      this._broadcast(thread, turn);
       throw new Error(`Could not reach ${toAgent.name}: ${err.message}`);
     }
 
-    // A stopped target gets resumed or rotated, which mints a new agent id.
-    // Re-key onto it or the answer will never be matched.
+    // A stopped target gets resumed or rotated, minting a new agent id.
     const targetId = result.agentId;
-    if (targetId !== toAgentId) {
-      this._remapParticipant(t, toAgentId, targetId);
+    if (targetId !== toAgent.id) {
+      this._remapParticipant(thread, toAgent.id, targetId);
       turn.to.id = targetId;
     }
 
     turn.status = result.status;
-    t.status = 'awaiting_reply';
-    t.updatedAt = Date.now();
-    this._broadcast(t, turn);
-    this.daemon.audit.log('innerchat.ask', { thread: t.id, from: fromAgentId, to: targetId });
+    thread.status = 'awaiting_reply';
+    thread.updatedAt = Date.now();
+    this._broadcast(thread, turn);
 
-    // A queued question sits behind whatever the target is already doing, so
-    // the next result belongs to that prior task, not to us — skip it.
-    const skipResults = result.status === 'message_queued' ? 1 : 0;
+    // A queued message sits behind the target's current work, so the next
+    // result belongs to that prior task, not to us — skip it.
+    return { turn, targetId, skipResults: result.status === 'message_queued' ? 1 : 0 };
+  }
 
-    const reply = await this._awaitReply(t, fromAgentId, targetId, { skipResults, timeoutMs });
+  _openThread(fromAgent, toAgent, threadId) {
+    const thread = threadId ? this.threads.get(threadId) : this._findThread(fromAgent.id, toAgent.id);
+    return thread || this._createThread(fromAgent, toAgent);
+  }
 
-    return {
-      reply,
-      threadId: t.id,
-      exchanges: exchanges + 1,
-      remaining: MAX_EXCHANGES - (exchanges + 1),
-    };
+  _checkExchangeCap(thread, toAgent) {
+    const used = thread.turns.filter((x) => x.kind === 'ask' || x.kind === 'tell').length;
+    if (used >= MAX_EXCHANGES) {
+      throw new Error(
+        `This conversation has reached its ${MAX_EXCHANGES}-exchange limit. Stop consulting `
+        + `${toAgent.name} and report your conclusion to the user.`,
+      );
+    }
   }
 
   _awaitReply(thread, askerId, targetId, { skipResults, timeoutMs }) {
     return new Promise((resolve, reject) => {
       const settle = (fn, value) => {
-        clearTimeout(record.timer);
-        this.awaiting.delete(targetId);
+        this._clearAwait(targetId);
         this.blockedOn.delete(askerId);
         fn(value);
       };
 
       const record = {
+        mode: 'block',
         threadId: thread.id,
         askerId,
         skipResults,
@@ -150,7 +196,7 @@ export class InnerChat {
           thread.updatedAt = Date.now();
           record.reject(new Error(
             `No answer within ${Math.round(timeoutMs / 1000)}s. The agent may still be working — `
-            + 'proceed on your own judgement or try again.',
+            + 'proceed on your own judgement, or use a non-blocking send (tell) next time.',
           ));
         }, timeoutMs),
       };
@@ -161,7 +207,7 @@ export class InnerChat {
   }
 
   /**
-   * Watch agent output for the answer to an outstanding question.
+   * Watch agent output for the reply to an outstanding message.
    * Called from the process manager's output handler.
    */
   onAgentOutput(agentId, output) {
@@ -170,7 +216,7 @@ export class InnerChat {
     if (output.type !== 'result') return;
 
     const thread = this.threads.get(pending.threadId);
-    if (!thread) { pending.reject(new Error('Conversation was lost')); return; }
+    if (!thread) { this._settlePending(agentId, pending, null, new Error('Conversation was lost')); return; }
 
     const text = extractText(output.data);
     if (!text) return;
@@ -182,7 +228,7 @@ export class InnerChat {
     }
 
     const responder = this.daemon.registry.get(agentId);
-    thread.turns.push({
+    const answerTurn = {
       id: randomUUID().slice(0, 12),
       from: responder ? peer(responder) : { id: agentId, name: agentId, role: 'agent' },
       to: this._otherParticipant(thread, agentId),
@@ -190,27 +236,67 @@ export class InnerChat {
       kind: 'answer',
       status: 'delivered',
       timestamp: Date.now(),
-    });
+    };
+    thread.turns.push(answerTurn);
     thread.status = 'idle';
     thread.updatedAt = Date.now();
-
-    this._broadcast(thread, thread.turns.at(-1));
+    this._broadcast(thread, answerTurn);
     this.daemon.audit.log('innerchat.answer', { thread: thread.id, from: agentId });
 
-    pending.resolve(text);
+    if (pending.mode === 'async') {
+      this._clearAwait(agentId);
+      this._forwardAsyncReply(pending, answerTurn, text);
+    } else {
+      pending.resolve(text);
+    }
+  }
+
+  // Deliver an async (tell) reply back to the original sender, resuming it if
+  // its turn has ended. The sender is not blocked, so this just wakes them.
+  async _forwardAsyncReply(pending, answerTurn, text) {
+    const sender = this.daemon.registry.get(pending.senderId)
+      || this.daemon.registry.getAll().find((a) => a.name === answerTurn.to.name);
+    if (!sender) return; // sender is gone — nothing to route back to
+
+    const msg = [
+      `[InnerChat reply from ${answerTurn.from.name} (${answerTurn.from.role})]`,
+      '',
+      text,
+      '',
+      'This is a reply to a message you sent earlier (you were not blocking on it). '
+      + 'Fold it into your work, or reply again to continue.',
+    ].join('\n');
+
+    try {
+      await deliverInstruction(this.daemon, sender.id, msg, { recordFeedback: false });
+    } catch (err) {
+      this.daemon.audit.log('innerchat.forward_failed', { to: sender.id, error: err.message });
+    }
   }
 
   /**
-   * An agent that dies mid-question would otherwise leave its asker blocked
-   * until the timeout. Called when an agent crashes or is killed.
+   * An agent that dies mid-question would otherwise leave a blocking asker
+   * stuck until timeout. Async senders aren't waiting, so just clear those.
    */
   onAgentGone(agentId, reason = 'stopped') {
     const pending = this.awaiting.get(agentId);
     if (!pending) return;
+    if (pending.mode === 'async') { this._clearAwait(agentId); return; }
     const agent = this.daemon.registry.get(agentId);
     pending.reject(new Error(`${agent?.name || agentId} ${reason} before answering`));
   }
 
+  _clearAwait(targetId) {
+    const pending = this.awaiting.get(targetId);
+    if (pending?.timer) clearTimeout(pending.timer);
+    this.awaiting.delete(targetId);
+  }
+
+  _settlePending(agentId, pending, value, err) {
+    if (pending.mode === 'async') { this._clearAwait(agentId); return; }
+    if (err) pending.reject(err); else pending.resolve(value);
+  }
+
   // ── Threads ─────────────────────────────────────────────────
 
   _createThread(fromAgent, toAgent) {
@@ -233,10 +319,15 @@ export class InnerChat {
   }
 
   // The target sees a direct message from the other agent, with enough prior
-  // turns to follow a continuing conversation.
-  _wrap(thread, fromAgent, toAgent, message) {
+  // turns to follow a continuing conversation. The closing instruction differs
+  // by kind: an ask blocks the sender (answer now), a tell does not (answer
+  // when you reach a good stopping point).
+  _wrap(thread, fromAgent, toAgent, message, kind = 'ask') {
+    const header = kind === 'tell'
+      ? `[InnerChat — ${fromAgent.name} (${fromAgent.role}) sent you a message]`
+      : `[InnerChat — ${fromAgent.name} (${fromAgent.role}) is asking you a question]`;
     const prior = thread.turns.slice(0, -1).slice(-CONTEXT_TURNS);
-    const lines = [`[InnerChat — ${fromAgent.name} (${fromAgent.role}) is asking you a question]`, ''];
+    const lines = [header, ''];
 
     if (prior.length) {
       lines.push('Earlier in this conversation:');
@@ -245,11 +336,19 @@ export class InnerChat {
     }
 
     lines.push(message, '');
-    lines.push(
-      `${fromAgent.name} is BLOCKED waiting on your answer — it cannot continue until you `
-      + 'respond. Answer directly and concisely in your next message; that message is sent '
-      + 'back to it verbatim. Do not address the user, and do not start unrelated work first.',
-    );
+    if (kind === 'tell') {
+      lines.push(
+        `${fromAgent.name} is NOT blocked on this — finish what you're doing first if you're `
+        + 'mid-task. When you reach a good stopping point, answer directly in a message; your '
+        + `reply is relayed back to ${fromAgent.name}. If no reply is needed, just carry on.`,
+      );
+    } else {
+      lines.push(
+        `${fromAgent.name} is BLOCKED waiting on your answer — it cannot continue until you `
+        + 'respond. Answer directly and concisely in your next message; that message is sent '
+        + 'back to it verbatim. Do not address the user, and do not start unrelated work first.',
+      );
+    }
     return lines.join('\n');
   }
 
@@ -286,6 +385,20 @@ export class InnerChat {
     const pending = this.awaiting.get(agentId);
     return pending ? this.threads.get(pending.threadId) : null;
   }
+
+  // Clear all outstanding timers so a shutdown (or a test) doesn't hang on
+  // pending ask/tell timeouts. Blocking asks are rejected so their HTTP
+  // requests don't hang either.
+  stop() {
+    for (const [targetId, pending] of this.awaiting) {
+      if (pending.timer) clearTimeout(pending.timer);
+      if (pending.mode === 'block') {
+        try { pending.reject(new Error('Daemon shutting down')); } catch { /* already settled */ }
+      }
+      this.awaiting.delete(targetId);
+    }
+    this.blockedOn.clear();
+  }
 }
 
 function peer(agent) {

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

@@ -4,7 +4,7 @@
 import { writeFileSync, readFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { resolve, dirname, basename } from 'path';
 import { escapeMd } from './validate.js';
-import { innerChatInstructions } from './innerchat-docs.js';
+import { innerChatInstructions, watchInstructions } from './innerchat-docs.js';
 
 const GROOVE_SECTION_START = '<!-- GROOVE:START -->';
 const GROOVE_SECTION_END = '<!-- GROOVE:END -->';
@@ -560,7 +560,8 @@ export class Introducer {
   // Written into every AGENTS_REGISTRY.md so the capability survives context
   // compaction — the spawn prompt alone can scroll out of a long session.
   _innerChatSection() {
-    return innerChatInstructions(this.daemon.port || 31415);
+    const port = this.daemon.port || 31415;
+    return [...innerChatInstructions(port), '', ...watchInstructions(port)];
   }
 
   writeRegistryFile(projectDir) {