groove-dev 0.27.182 → 0.27.184

package/packages/daemon/src/innerchat.js

@@ -1,100 +1,307 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
 import { randomUUID } from 'crypto';
+import { deliverInstruction } from './deliver.js';
 
+// 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 consultation.
+ *
+ * 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 question reaches its target whether it's mid-task, idle, or stopped.
+ */
 export class InnerChat {
   constructor(daemon) {
     this.daemon = daemon;
-    this.messages = new Map();
-    this.pendingResponses = new Map();
+    this.threads = new Map();
+    // 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();
   }
 
-  async send(fromAgentId, toAgentId, message) {
+  /**
+   * 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 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('An agent cannot ask itself');
+    if (!message || !message.trim()) throw new Error('message is required');
+
+    // 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 id = randomUUID().slice(0, 12);
-    const msg = {
-      id,
-      from: { id: fromAgent.id, name: fromAgent.name, role: fromAgent.role },
-      to: { id: toAgent.id, name: toAgent.name, role: toAgent.role },
-      message,
-      response: null,
-      status: 'sent',
+    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: 'ask',
+      status: 'sending',
       timestamp: Date.now(),
-      respondedAt: null,
     };
+    t.turns.push(turn);
 
-    this.messages.set(id, msg);
-    this.pendingResponses.set(toAgentId, id);
+    const wrapped = this._wrap(t, fromAgent, toAgent, message.trim());
 
-    const wrapped = `[InnerChat from ${fromAgent.name} (${fromAgent.role})]\n\n${message}\n\nReply normally — your response will be relayed back to ${fromAgent.name}.`;
+    let result;
+    try {
+      result = await deliverInstruction(this.daemon, toAgentId, wrapped, { recordFeedback: false });
+    } catch (err) {
+      turn.status = 'failed';
+      turn.error = err.message;
+      t.status = 'failed';
+      this._broadcast(t, turn);
+      throw new Error(`Could not reach ${toAgent.name}: ${err.message}`);
+    }
 
-    let deliveryStatus = 'sent';
-    if (this.daemon.processes.hasAgentLoop(toAgentId)) {
-      const sent = await this.daemon.processes.sendMessage(toAgentId, wrapped, 'agent');
-      deliveryStatus = sent ? 'delivered' : 'queued';
-    } else if (this.daemon.processes.isRunning(toAgentId)) {
-      this.daemon.processes.queueMessage(toAgentId, wrapped);
-      deliveryStatus = 'queued';
-    } else {
-      throw new Error(`Target agent ${toAgent.name} is not running`);
+    // A stopped target gets resumed or rotated, which mints a new agent id.
+    // 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;
     }
 
-    msg.status = deliveryStatus;
-    this.daemon.broadcast({ type: 'innerchat:sent', data: msg });
-    this.daemon.audit.log('innerchat.send', { id, from: fromAgentId, to: toAgentId });
+    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 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;
+
+    const reply = await this._awaitReply(t, fromAgentId, targetId, { skipResults, timeoutMs });
 
-    return msg;
+    return {
+      reply,
+      threadId: t.id,
+      exchanges: exchanges + 1,
+      remaining: MAX_EXCHANGES - (exchanges + 1),
+    };
+  }
+
+  _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 answer to an outstanding question.
+   * Called from the process manager's output handler.
+   */
   onAgentOutput(agentId, output) {
-    const messageId = this.pendingResponses.get(agentId);
-    if (!messageId) return;
+    const pending = this.awaiting.get(agentId);
+    if (!pending) return;
     if (output.type !== 'result') return;
 
-    const msg = this.messages.get(messageId);
-    if (!msg) return;
+    const thread = this.threads.get(pending.threadId);
+    if (!thread) { pending.reject(new Error('Conversation was lost')); return; }
+
+    const text = extractText(output.data);
+    if (!text) return;
+
+    // Burn off results belonging to work already underway when we queued.
+    if (pending.skipResults > 0) {
+      pending.skipResults -= 1;
+      return;
+    }
+
+    const responder = this.daemon.registry.get(agentId);
+    thread.turns.push({
+      id: randomUUID().slice(0, 12),
+      from: responder ? peer(responder) : { id: agentId, name: agentId, role: 'agent' },
+      to: this._otherParticipant(thread, agentId),
+      text,
+      kind: 'answer',
+      status: 'delivered',
+      timestamp: Date.now(),
+    });
+    thread.status = 'idle';
+    thread.updatedAt = Date.now();
+
+    this._broadcast(thread, thread.turns.at(-1));
+    this.daemon.audit.log('innerchat.answer', { thread: thread.id, from: agentId });
+
+    pending.resolve(text);
+  }
+
+  /**
+   * 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`));
+  }
+
+  // ── Threads ─────────────────────────────────────────────────
+
+  _createThread(fromAgent, toAgent) {
+    const thread = {
+      id: randomUUID().slice(0, 12),
+      participants: [peer(fromAgent), peer(toAgent)],
+      turns: [],
+      status: 'idle',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+    this.threads.set(thread.id, thread);
+    return thread;
+  }
 
-    let responseText = '';
-    if (typeof output.data === 'string') {
-      responseText = output.data;
-    } else if (Array.isArray(output.data)) {
-      responseText = output.data.filter(b => b.type === 'text').map(b => b.text).join('\n');
+  // 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 — ${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)}`);
+      lines.push('');
     }
-    if (!responseText.trim()) return;
-
-    msg.response = responseText.trim();
-    msg.status = 'responded';
-    msg.respondedAt = Date.now();
-    this.pendingResponses.delete(agentId);
-
-    const relay = `[InnerChat reply from ${msg.to.name} (${msg.to.role})]\n\n${msg.response}`;
-    const senderId = msg.from.id;
-    if (this.daemon.processes.hasAgentLoop(senderId)) {
-      this.daemon.processes.sendMessage(senderId, relay, 'agent').catch(() => {});
-    } else if (this.daemon.processes.isRunning(senderId)) {
-      this.daemon.processes.queueMessage(senderId, relay);
+
+    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.',
+    );
+    return lines.join('\n');
+  }
+
+  _otherParticipant(thread, agentId) {
+    return thread.participants.find((p) => p.id !== agentId) || thread.participants[0];
+  }
+
+  _remapParticipant(thread, oldId, newId) {
+    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);
+      this.awaiting.set(newId, pending);
     }
+  }
 
-    this.daemon.broadcast({ type: 'innerchat:response', data: msg });
-    this.daemon.audit.log('innerchat.response', { id: messageId, from: msg.from.id, to: msg.to.id });
+  _broadcast(thread, turn) {
+    this.daemon.broadcast({ type: 'innerchat:turn', data: { thread, turn } });
   }
 
-  getMessages(agentId = null) {
-    const all = Array.from(this.messages.values());
+  // ── Queries ─────────────────────────────────────────────────
+
+  getThreads(agentId = null) {
+    const all = Array.from(this.threads.values()).sort((a, b) => b.updatedAt - a.updatedAt);
     if (!agentId) return all;
-    return all.filter(m => m.from.id === agentId || m.to.id === agentId);
+    return all.filter((t) => t.participants.some((p) => p.id === agentId));
   }
 
-  getMessage(id) {
-    return this.messages.get(id) || null;
+  getThread(id) {
+    return this.threads.get(id) || null;
   }
 
   getPending(agentId) {
-    const messageId = this.pendingResponses.get(agentId);
-    return messageId ? this.messages.get(messageId) : null;
+    const pending = this.awaiting.get(agentId);
+    return pending ? this.threads.get(pending.threadId) : null;
+  }
+}
+
+function peer(agent) {
+  return { id: agent.id, name: agent.name, role: agent.role };
+}
+
+function truncate(text, max) {
+  return text.length <= max ? text : `${text.slice(0, max)}… [truncated]`;
+}
+
+function extractText(data) {
+  if (typeof data === 'string') return data.trim();
+  if (Array.isArray(data)) {
+    return data.filter((b) => b.type === 'text').map((b) => b.text).join('\n').trim();
   }
+  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');
@@ -320,7 +321,7 @@ const PERMISSION_PROMPTS = {
   supervised: null,  // Maps to auto (supervised removed — too expensive)
 };
 
-function sanitizeFilename(name) {
+export function sanitizeFilename(name) {
   return String(name).replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
 }
 
@@ -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/registry.js

@@ -79,12 +79,16 @@ export class Registry extends EventEmitter {
     return Array.from(this.agents.values());
   }
 
-  update(id, updates) {
+  update(id, updates, { allowRename = false } = {}) {
     const agent = this.agents.get(id);
     if (!agent) return null;
 
     // Only allow known fields to prevent prototype pollution
     for (const key of Object.keys(updates)) {
+      // Logs, personalities and agent-files are keyed by name — renaming
+      // without migrating them orphans the lot, and the GC then deletes it.
+      // renameAgent() (rename.js) does the migration and opts in here.
+      if (key === 'name' && !allowRename) continue;
       if (SAFE_FIELDS.has(key)) {
         agent[key] = updates[key];
       }

package/packages/daemon/src/rename.js

@@ -0,0 +1,72 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { resolve } from 'path';
+import { existsSync, renameSync } from 'fs';
+import { sanitizeFilename } from './process.js';
+
+/**
+ * Rename an agent, migrating everything keyed by its name.
+ *
+ * Agent logs, personalities and scratch files are keyed by NAME rather than id
+ * on purpose — rotation mints a new id, and name-keying is what carries an
+ * agent's history across it (see agentLogPath in process.js). The cost is that
+ * a bare rename orphans all of it, and the log GC then deletes the orphan. So
+ * a rename has to move those artifacts itself.
+ *
+ * Note the live process keeps the old name in its env (GROOVE_AGENT_NAME) and
+ * system prompt until it next respawns — the daemon-side view is what changes.
+ */
+export function renameAgent(daemon, agentId, newName) {
+  const agent = daemon.registry.get(agentId);
+  if (!agent) throw new Error('Agent not found');
+
+  const trimmed = String(newName || '').trim();
+  if (!trimmed) throw new Error('name is required');
+
+  // The name becomes a path segment (agent-files/<name>, personalities/<name>.md),
+  // so anything with a separator or a dot-segment would escape the directory.
+  if (!/^[A-Za-z0-9._-]+$/.test(trimmed) || /^\.+$/.test(trimmed)) {
+    throw new Error('name may only contain letters, numbers, dots, dashes and underscores');
+  }
+  if (trimmed.length > 64) throw new Error('name must be 64 characters or fewer');
+
+  if (trimmed === agent.name) return agent;
+
+  // Two agents sharing a name means two agents sharing one log file.
+  const collision = daemon.registry.getAll()
+    .some((a) => a.id !== agentId && a.name === trimmed);
+  if (collision) throw new Error(`An agent named ${trimmed} already exists`);
+
+  const oldName = agent.name;
+  const { grooveDir, projectDir } = daemon;
+
+  const moves = [
+    // Raw log — the one whose loss breaks chat resume and synthesis.
+    [resolve(grooveDir, 'logs', `${sanitizeFilename(oldName)}.log`),
+     resolve(grooveDir, 'logs', `${sanitizeFilename(trimmed)}.log`)],
+    [resolve(grooveDir, 'personalities', `${oldName}.md`),
+     resolve(grooveDir, 'personalities', `${trimmed}.md`)],
+    [resolve(projectDir, 'agent-files', oldName),
+     resolve(projectDir, 'agent-files', trimmed)],
+  ];
+
+  const moved = [];
+  try {
+    for (const [from, to] of moves) {
+      if (!existsSync(from) || existsSync(to)) continue;
+      renameSync(from, to);
+      moved.push([from, to]);
+    }
+  } catch (err) {
+    // Roll back so a partial migration can't leave artifacts split across
+    // two names — that's the state the GC would then eat.
+    for (const [from, to] of moved.reverse()) {
+      try { renameSync(to, from); } catch { /* best effort */ }
+    }
+    throw new Error(`Rename failed while migrating files: ${err.message}`);
+  }
+
+  const updated = daemon.registry.update(agentId, { name: trimmed }, { allowRename: true });
+  daemon.audit.log('agent.rename', { id: agentId, from: oldName, to: trimmed });
+  return updated;
+}