groove-dev 0.27.183 → 0.27.184

package/packages/cli/package.json

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

package/packages/daemon/package.json

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

package/packages/daemon/src/innerchat-docs.js

@@ -0,0 +1,41 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+// The agent-facing InnerChat instructions, in one place.
+//
+// These are injected into a new agent's spawn prompt AND written into every
+// AGENTS_REGISTRY.md. Both are needed: the prompt reaches the agent on turn
+// one, and the file survives context compaction — an agent that has forgotten
+// the prompt can re-read the registry it already knows to consult.
+//
+// No imports on purpose — process.js and introducer.js both pull from here.
+
+export function innerChatInstructions(port = 31415, agentName = 'YOUR_NAME') {
+  return [
+    '## Consulting Other Agents (InnerChat)',
+    '',
+    'Other GROOVE agents may be working alongside you, including on other teams.',
+    '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:',
+    '',
+    '```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:',
+    '`{"from":"...","reply":"...","exchangesUsed":N,"exchangesRemaining":N}`',
+    '',
+    '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.',
+    '',
+    '**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.',
+    '- 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.',
+  ];
+}

package/packages/daemon/src/innerchat.js

@@ -3,51 +3,87 @@
 import { randomUUID } from 'crypto';
 import { deliverInstruction } from './deliver.js';
 
-// How much prior conversation to replay into each relay turn. Enough for the
-// recipient to pick up the thread without re-reading the whole exchange.
+// An unanswered ask holds an HTTP request open and blocks the calling agent,
+// so it has to be bounded.
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+const MAX_TIMEOUT_MS = 15 * 60 * 1000;
+
+// Ceiling on autonomous back-and-forth. Two agents that can call each other
+// freely will happily talk until the budget is gone; past this they're told to
+// wrap up and report to the user.
+const MAX_EXCHANGES = 12;
+
 const CONTEXT_TURNS = 4;
 const MAX_TURN_CHARS = 1200;
 
 /**
- * Agent-to-agent relay, user-initiated.
+ * Agent-to-agent consultation.
  *
- * The A→B hop is always driven by a human clicking Relay. The B→A hop is
- * automatic: B's answer is fed straight back into A so A can process it and
- * report to the user, who then decides whether to run another turn.
+ * An agent asks another agent a question and BLOCKS until it answers — the
+ * daemon holds the caller's HTTP request open, delivers the question, waits
+ * for the target's next result, and returns it as the response body. That
+ * makes a normal request/response loop available to the calling agent, so two
+ * agents can iterate to consensus without a human relaying between them.
  *
  * Delivery goes through deliverInstruction — the same pipe as user chat — so
- * a relay reaches its target whether it's mid-task, idle, or stopped.
+ * a question reaches its target whether it's mid-task, idle, or stopped.
  */
 export class InnerChat {
   constructor(daemon) {
     this.daemon = daemon;
     this.threads = new Map();
-    // agentId -> { threadId, sentAt } — which agent we're awaiting a reply from.
+    // agentId being asked -> pending record (resolve/reject/timer/threadId)
     this.awaiting = new Map();
+    // asker id -> id of the agent it is currently blocked on
+    this.blockedOn = new Map();
   }
 
   /**
-   * Relay a message from one agent to another, opening a thread or continuing
-   * an existing one.
+   * Ask another agent a question and wait for its answer.
+   *
+   * Resolves with { reply, threadId, exchanges, remaining }. Rejects when the
+   * target can't be reached, the exchange cap is hit, the call would deadlock,
+   * or the target doesn't answer inside the timeout.
    */
-  async send(fromAgentId, toAgentId, message, threadId = null) {
+  async ask(fromAgentId, toAgentId, message, opts = {}) {
     const fromAgent = this.daemon.registry.get(fromAgentId);
     const toAgent = this.daemon.registry.get(toAgentId);
-    if (!fromAgent) throw new Error(`Sender agent ${fromAgentId} not found`);
+    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('Cannot relay an agent to itself');
+    if (fromAgentId === toAgentId) throw new Error('An agent cannot ask itself');
     if (!message || !message.trim()) throw new Error('message is required');
 
-    const thread = threadId ? this.threads.get(threadId) : null;
-    if (threadId && !thread) throw new Error(`Thread ${threadId} not found`);
+    // Deadlock guard: the target is already blocked waiting on us, so it can
+    // never get far enough to read this. Tell the caller to just answer.
+    if (this.blockedOn.get(toAgentId) === fromAgentId) {
+      throw new Error(
+        `${toAgent.name} is currently waiting for YOUR answer — it cannot reply to a new `
+        + 'question until you respond. Answer its question first; your reply is what unblocks it.',
+      );
+    }
+    if (this.awaiting.has(toAgentId)) {
+      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 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 = {
       id: randomUUID().slice(0, 12),
       from: peer(fromAgent),
       to: peer(toAgent),
       text: message.trim(),
-      kind: 'relay',
+      kind: 'ask',
       status: 'sending',
       timestamp: Date.now(),
     };
@@ -62,35 +98,71 @@ export class InnerChat {
       turn.status = 'failed';
       turn.error = err.message;
       t.status = 'failed';
-      this.daemon.broadcast({ type: 'innerchat:turn', data: { thread: t, turn } });
-      throw err;
+      this._broadcast(t, 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 everything onto it or the reply will never be captured.
-    if (result.agentId !== toAgentId) {
-      this._remapParticipant(t, toAgentId, result.agentId);
-      turn.to.id = result.agentId;
+    // Re-key onto it or the answer will never be matched.
+    const targetId = result.agentId;
+    if (targetId !== toAgentId) {
+      this._remapParticipant(t, toAgentId, 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 });
 
-    // A queued relay sits behind whatever the agent is already doing, so the
-    // next result belongs to that prior task, not to us — skip it.
+    // 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;
-    this.awaiting.set(turn.to.id, { threadId: t.id, sentAt: Date.now(), skipResults });
 
-    this.daemon.broadcast({ type: 'innerchat:turn', data: { thread: t, turn } });
-    this.daemon.audit.log('innerchat.send', { thread: t.id, from: fromAgentId, to: turn.to.id });
+    const reply = await this._awaitReply(t, fromAgentId, targetId, { skipResults, timeoutMs });
+
+    return {
+      reply,
+      threadId: t.id,
+      exchanges: exchanges + 1,
+      remaining: MAX_EXCHANGES - (exchanges + 1),
+    };
+  }
 
-    return { thread: t, turn };
+  _awaitReply(thread, askerId, targetId, { skipResults, timeoutMs }) {
+    return new Promise((resolve, reject) => {
+      const settle = (fn, value) => {
+        clearTimeout(record.timer);
+        this.awaiting.delete(targetId);
+        this.blockedOn.delete(askerId);
+        fn(value);
+      };
+
+      const record = {
+        threadId: thread.id,
+        askerId,
+        skipResults,
+        resolve: (text) => settle(resolve, text),
+        reject: (err) => settle(reject, err),
+        timer: setTimeout(() => {
+          thread.status = 'timeout';
+          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.',
+          ));
+        }, timeoutMs),
+      };
+
+      this.awaiting.set(targetId, record);
+      this.blockedOn.set(askerId, targetId);
+    });
   }
 
   /**
-   * Watch agent output for the reply to an outstanding relay, then forward it
-   * back to the agent that asked.
+   * Watch agent output for the answer to an outstanding question.
+   * Called from the process manager's output handler.
    */
   onAgentOutput(agentId, output) {
     const pending = this.awaiting.get(agentId);
@@ -98,72 +170,48 @@ export class InnerChat {
     if (output.type !== 'result') return;
 
     const thread = this.threads.get(pending.threadId);
-    if (!thread) { this.awaiting.delete(agentId); return; }
+    if (!thread) { pending.reject(new Error('Conversation was lost')); return; }
 
-    const responseText = extractText(output.data);
-    if (!responseText) return;
+    const text = extractText(output.data);
+    if (!text) return;
 
-    // Burn off results belonging to work that was already underway when the
-    // relay was queued behind it.
+    // Burn off results belonging to work already underway when we queued.
     if (pending.skipResults > 0) {
       pending.skipResults -= 1;
       return;
     }
 
-    // Claim the reply before the async forward so a second result arriving
-    // mid-flight can't be captured as a duplicate.
-    this.awaiting.delete(agentId);
-
     const responder = this.daemon.registry.get(agentId);
-    const asker = this._otherParticipant(thread, agentId);
-
-    const turn = {
+    thread.turns.push({
       id: randomUUID().slice(0, 12),
       from: responder ? peer(responder) : { id: agentId, name: agentId, role: 'agent' },
-      to: asker,
-      text: responseText,
-      kind: 'reply',
-      status: 'forwarding',
+      to: this._otherParticipant(thread, agentId),
+      text,
+      kind: 'answer',
+      status: 'delivered',
       timestamp: Date.now(),
-    };
-    thread.turns.push(turn);
-    thread.status = 'forwarding';
+    });
+    thread.status = 'idle';
     thread.updatedAt = Date.now();
 
-    this._forwardReply(thread, turn, asker.id, responseText);
-  }
-
-  async _forwardReply(thread, turn, askerId, responseText) {
-    const from = turn.from;
-    const relay = [
-      `[InnerChat reply from ${from.name} (${from.role})]`,
-      '',
-      responseText,
-      '',
-      `This is the answer to what you relayed to ${from.name}. Process it and report back — `
-        + 'the user will decide whether to send another turn.',
-    ].join('\n');
+    this._broadcast(thread, thread.turns.at(-1));
+    this.daemon.audit.log('innerchat.answer', { thread: thread.id, from: agentId });
 
-    try {
-      const result = await deliverInstruction(this.daemon, askerId, relay, { recordFeedback: false });
-      if (result.agentId !== askerId) {
-        this._remapParticipant(thread, askerId, result.agentId);
-        turn.to.id = result.agentId;
-      }
-      turn.status = result.status;
-      thread.status = 'idle';
-    } catch (err) {
-      turn.status = 'failed';
-      turn.error = err.message;
-      thread.status = 'failed';
-    }
+    pending.resolve(text);
+  }
 
-    thread.updatedAt = Date.now();
-    this.daemon.broadcast({ type: 'innerchat:turn', data: { thread, turn } });
-    this.daemon.audit.log('innerchat.reply', { thread: thread.id, from: turn.from.id, to: turn.to.id });
+  /**
+   * An agent that dies mid-question would otherwise leave its asker blocked
+   * until the timeout. Called when an agent crashes or is killed.
+   */
+  onAgentGone(agentId, reason = 'stopped') {
+    const pending = this.awaiting.get(agentId);
+    if (!pending) return;
+    const agent = this.daemon.registry.get(agentId);
+    pending.reject(new Error(`${agent?.name || agentId} ${reason} before answering`));
   }
 
-  // ── Thread helpers ──────────────────────────────────────────
+  // ── Threads ─────────────────────────────────────────────────
 
   _createThread(fromAgent, toAgent) {
     const thread = {
@@ -178,24 +226,29 @@ export class InnerChat {
     return thread;
   }
 
-  // Rebuild the message the target sees. It reads as a direct message from the
-  // other agent, with enough prior turns that a continuing thread makes sense.
+  // Consecutive asks between the same pair continue one conversation, so the
+  // exchange cap actually bounds a back-and-forth rather than resetting.
+  _findThread(a, b) {
+    return this.getThreads(a).find((t) => t.participants.some((p) => p.id === b)) || null;
+  }
+
+  // The target sees a direct message from the other agent, with enough prior
+  // turns to follow a continuing conversation.
   _wrap(thread, fromAgent, toAgent, message) {
     const prior = thread.turns.slice(0, -1).slice(-CONTEXT_TURNS);
-    const lines = [`[InnerChat from ${fromAgent.name} (${fromAgent.role})]`, ''];
+    const lines = [`[InnerChat — ${fromAgent.name} (${fromAgent.role}) is asking you a question]`, ''];
 
     if (prior.length) {
       lines.push('Earlier in this conversation:');
-      for (const t of prior) {
-        lines.push(`  ${t.from.name}: ${truncate(t.text, MAX_TURN_CHARS)}`);
-      }
+      for (const t of prior) lines.push(`  ${t.from.name}: ${truncate(t.text, MAX_TURN_CHARS)}`);
       lines.push('');
     }
 
     lines.push(message, '');
     lines.push(
-      `Reply normally — your response is relayed straight back to ${fromAgent.name}. `
-      + 'Answer them directly; do not address the user.',
+      `${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');
   }
@@ -205,10 +258,7 @@ export class InnerChat {
   }
 
   _remapParticipant(thread, oldId, newId) {
-    for (const p of thread.participants) {
-      if (p.id === oldId) p.id = newId;
-    }
-    // Any relay still awaiting a reply from the old id must follow it forward.
+    for (const p of thread.participants) if (p.id === oldId) p.id = newId;
     const pending = this.awaiting.get(oldId);
     if (pending) {
       this.awaiting.delete(oldId);
@@ -216,6 +266,10 @@ export class InnerChat {
     }
   }
 
+  _broadcast(thread, turn) {
+    this.daemon.broadcast({ type: 'innerchat:turn', data: { thread, turn } });
+  }
+
   // ── Queries ─────────────────────────────────────────────────
 
   getThreads(agentId = null) {
@@ -249,3 +303,5 @@ function extractText(data) {
   }
   return '';
 }
+
+export { MAX_EXCHANGES, DEFAULT_TIMEOUT_MS };

package/packages/daemon/src/introducer.js

@@ -4,6 +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';
 
 const GROOVE_SECTION_START = '<!-- GROOVE:START -->';
 const GROOVE_SECTION_END = '<!-- GROOVE:END -->';
@@ -556,6 +557,12 @@ export class Introducer {
     return null;
   }
 
+  // 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);
+  }
+
   writeRegistryFile(projectDir) {
     const agents = this.daemon.registry.getAll();
 
@@ -596,6 +603,27 @@ export class Introducer {
         lines.push(`| ${escapeMd(a.id)} | ${escapeMd(a.name)} | ${escapeMd(a.role)} | ${escapeMd(a.provider)} | ${agentDir} | ${scope} | ${escapeMd(a.status)} |`);
       }
 
+      // Agents on other teams are reachable via InnerChat, so they have to be
+      // discoverable here — otherwise cross-team consultation means guessing
+      // names. Kept to a separate, minimal table so the team's own roster
+      // stays the primary listing.
+      const others = agents.filter((a) => (a.teamId || '_default') !== teamId);
+      if (others.length > 0) {
+        lines.push('');
+        lines.push(`## Other Teams`);
+        lines.push('');
+        lines.push(`Reachable via InnerChat (see below). Not in your scope — do not edit their files.`);
+        lines.push('');
+        lines.push(`| Name | Role | Team | Status |`);
+        lines.push(`|------|------|------|--------|`);
+        for (const a of others) {
+          const otherTeam = this.daemon.teams?.get(a.teamId)?.name || '-';
+          lines.push(`| ${escapeMd(a.name)} | ${escapeMd(a.role)} | ${escapeMd(otherTeam)} | ${escapeMd(a.status)} |`);
+        }
+      }
+
+      lines.push('');
+      lines.push(...this._innerChatSection());
       lines.push('');
       lines.push(`*Updated: ${new Date().toISOString()}*`);
 
@@ -632,7 +660,8 @@ export class Introducer {
       running.length > 0 ? '|------|------|-------|' : '',
       ...running.map((a) => `| ${a.name} | ${a.role} | ${a.scope?.join(', ') || '-'} |`),
       '',
-      `See AGENTS_REGISTRY.md for full agent state.`,
+      `See AGENTS_REGISTRY.md for full agent state, the names of agents on other teams,`,
+      `and how to consult them directly (InnerChat).`,
       '',
       `**Memory policy:** GROOVE manages project memory automatically. Do not read or write MEMORY.md or .groove/memory/ files directly.`,
       '',

package/packages/daemon/src/process.js

@@ -10,6 +10,7 @@ import { LocalProvider } from './providers/local.js';
 import { OllamaProvider } from './providers/ollama.js';
 import { AgentLoop } from './agent-loop.js';
 import { validateAgentConfig } from './validate.js';
+import { innerChatInstructions } from './innerchat-docs.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SLIDES_ENGINE_SRC = resolve(__dirname, '../templates/groove-slides.cjs');
@@ -506,6 +507,13 @@ export class ProcessManager {
 
     registry.update(agent.id, { status: finalStatus, pid: null });
 
+    // An agent that dies mid-question leaves its asker blocked on an open HTTP
+    // request — fail it now rather than making it wait out the timeout.
+    // 'completed' is normal: the answer arrives as a result before this fires.
+    if (this.daemon.innerchat && finalStatus !== 'completed') {
+      this.daemon.innerchat.onAgentGone(agent.id, finalStatus);
+    }
+
     if (this.daemon.timeline) {
       const agentData = registry.get(agent.id);
       this.daemon.timeline.recordEvent(finalStatus === 'completed' ? 'complete' : finalStatus === 'crashed' ? 'crash' : 'kill', {
@@ -1152,6 +1160,19 @@ For normal file edits within your scope, proceed without review.
       }
     }
 
+    // InnerChat — let the agent consult other agents directly.
+    // Same constraint as PM review: the agent calls back over HTTP, so
+    // sandboxed providers (Codex) can't reach it.
+    if (!sandboxedProviders.includes(providerName) && !isOneShotProvider) {
+      const port = this.daemon.port || 31415;
+      const innerChatPrompt = innerChatInstructions(port, agent.name).join('\n') + '\n\n';
+      if (spawnConfig.prompt.startsWith('# Handoff Brief')) {
+        spawnConfig.prompt += '\n\n' + innerChatPrompt.trim();
+      } else {
+        spawnConfig.prompt = innerChatPrompt + spawnConfig.prompt;
+      }
+    }
+
     // Set up log capture (shared between CLI and agent loop paths)
     const logDir = resolve(this.daemon.grooveDir, 'logs');
     mkdirSync(logDir, { recursive: true });

package/packages/daemon/src/routes/innerchat.js

@@ -1,21 +1,65 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
+import { MAX_EXCHANGES } from '../innerchat.js';
+
+// Agents know each other by name, not id — resolve either, preferring an
+// exact name match so `fullstack-1` never resolves to `fullstack-14`.
+function resolveAgent(daemon, ref) {
+  if (!ref || typeof ref !== 'string') return null;
+  const all = daemon.registry.getAll();
+  return all.find((a) => a.id === ref)
+    || all.find((a) => a.name === ref)
+    || all.find((a) => a.name.toLowerCase() === ref.toLowerCase())
+    || null;
+}
+
 export function registerInnerChatRoutes(app, daemon) {
-  // Relay a message from one agent to another. Opens a thread, or continues
-  // an existing one when threadId is supplied.
-  app.post('/api/innerchat/send', async (req, res) => {
+  /**
+   * Ask another agent a question and BLOCK until it answers.
+   *
+   * This request is held open deliberately — the calling agent is waiting on
+   * it, and the response body is the other agent's reply. That's what lets two
+   * agents iterate without a human relaying between them.
+   */
+  app.post('/api/innerchat/ask', async (req, res) => {
     try {
-      const { from, to, message, threadId } = req.body;
-      if (!from || typeof from !== 'string') return res.status(400).json({ error: 'from (agent ID) is required' });
-      if (!to || typeof to !== 'string') return res.status(400).json({ error: 'to (agent ID) is required' });
-      if (!message || typeof message !== 'string' || !message.trim()) return res.status(400).json({ error: 'message is required' });
-      if (from === to) return res.status(400).json({ error: 'cannot send a message to yourself' });
-      if (threadId && typeof threadId !== 'string') return res.status(400).json({ error: 'threadId must be a string' });
-
-      const result = await daemon.innerchat.send(from, to, message.trim(), threadId || null);
-      res.json(result);
+      const { from, to, message, timeoutMs } = req.body || {};
+
+      const fromAgent = resolveAgent(daemon, from);
+      if (!fromAgent) return res.status(404).json({ error: `Unknown calling agent: ${from}` });
+
+      const toAgent = resolveAgent(daemon, to);
+      if (!toAgent) {
+        const names = daemon.registry.getAll()
+          .filter((a) => a.id !== fromAgent.id)
+          .map((a) => a.name);
+        return res.status(404).json({
+          error: `No agent named "${to}".`,
+          availableAgents: names,
+        });
+      }
+
+      if (!message || typeof message !== 'string' || !message.trim()) {
+        return res.status(400).json({ error: 'message is required' });
+      }
+
+      // Held open until the target answers — see the class doc in innerchat.js.
+      req.setTimeout(0);
+      res.setTimeout(0);
+
+      const result = await daemon.innerchat.ask(fromAgent.id, toAgent.id, message.trim(), { timeoutMs });
+
+      res.json({
+        from: toAgent.name,
+        reply: result.reply,
+        threadId: result.threadId,
+        exchangesUsed: result.exchanges,
+        exchangesRemaining: result.remaining,
+        maxExchanges: MAX_EXCHANGES,
+      });
     } catch (err) {
-      res.status(400).json({ error: err.message });
+      // The agent reads this body — keep it actionable, it's the whole signal.
+      res.status(409).json({ error: err.message });
     }
   });
 

package/packages/daemon/src/routes/teams.js

@@ -26,6 +26,17 @@ export function registerTeamRoutes(app, daemon) {
     }
   });
 
+  // Reorder the sidebar list. Registered before /api/teams/:id so Express
+  // doesn't capture "reorder" as a team id.
+  app.post('/api/teams/reorder', (req, res) => {
+    try {
+      const teams = daemon.teams.reorder(req.body?.orderedIds);
+      res.json({ teams });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
   app.get('/api/teams/archived', (req, res) => {
     res.json({ archived: daemon.teams.listArchived() });
   });

package/packages/daemon/src/teams.js

@@ -113,6 +113,34 @@ export class Teams {
     return team;
   }
 
+  /**
+   * Reorder the team list. Teams persist as a JSON array, so Map insertion
+   * order is the display order — rebuilding the Map is the whole operation.
+   *
+   * Ids missing from `orderedIds` keep their relative order at the end, so a
+   * client working from a stale list can't drop teams.
+   */
+  reorder(orderedIds) {
+    if (!Array.isArray(orderedIds)) throw new Error('orderedIds must be an array');
+
+    const seen = new Set();
+    const next = new Map();
+    for (const id of orderedIds) {
+      const team = this.teams.get(id);
+      if (!team || seen.has(id)) continue;
+      seen.add(id);
+      next.set(id, team);
+    }
+    for (const [id, team] of this.teams) {
+      if (!seen.has(id)) next.set(id, team);
+    }
+
+    this.teams = next;
+    this._save();
+    this.daemon.broadcast({ type: 'teams:reordered', teams: this.list() });
+    return this.list();
+  }
+
   get(id) {
     return this.teams.get(id) || null;
   }