groove-dev 0.27.182 → 0.27.184

package/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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;
+}

package/node_modules/@groove-dev/daemon/src/routes/agents.js

@@ -5,6 +5,8 @@ import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, mkdirSy
 import { validateAgentConfig, validateReasoningEffort, validateVerbosity } from '../validate.js';
 import { ROLE_INTEGRATIONS, wrapWithRoleReminder } from '../process.js';
 import { getProvider } from '../providers/index.js';
+import { deliverInstruction } from '../deliver.js';
+import { renameAgent } from '../rename.js';
 
 export function registerAgentRoutes(app, daemon) {
   // List all agents
@@ -56,9 +58,21 @@ export function registerAgentRoutes(app, daemon) {
 
   // Update agent
   app.patch('/api/agents/:id', (req, res) => {
-    const agent = daemon.registry.update(req.params.id, req.body);
-    if (!agent) return res.status(404).json({ error: 'Agent not found' });
-    res.json(agent);
+    try {
+      const { name, ...rest } = req.body || {};
+
+      // Renames migrate name-keyed files, so they can't go through the plain
+      // field update — registry.update ignores `name` without the opt-in.
+      let agent = daemon.registry.get(req.params.id);
+      if (!agent) return res.status(404).json({ error: 'Agent not found' });
+
+      if (Object.keys(rest).length) agent = daemon.registry.update(req.params.id, rest);
+      if (typeof name === 'string') agent = renameAgent(daemon, req.params.id, name);
+
+      res.json(agent);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
   });
 
   // Kill an agent (add ?purge=true to also remove from registry)
@@ -426,104 +440,12 @@ export function registerAgentRoutes(app, daemon) {
         }
       }
 
-      // Record user feedback so the journalist can include it in future agent context
-      if (daemon.journalist) daemon.journalist.recordUserFeedback(agent, finalMessage);
-      if (daemon.rotator) daemon.rotator.recordUserMessage(req.params.id);
-
-      // Agent loop path — send message directly to the running loop
-      const wrappedMessage = wrapWithRoleReminder(agent.role, finalMessage);
-      if (daemon.processes.hasAgentLoop(req.params.id)) {
-        const sent = await daemon.processes.sendMessage(req.params.id, wrappedMessage);
-        if (sent) {
-          daemon.audit.log('agent.chat', { id: req.params.id });
-          return res.json({ id: agent.id, status: 'message_sent' });
-        }
-        // Loop exists but not running — fall through to resume/rotate
-      }
-
-      // One-shot providers (groove-network): kill any running instance and
-      // respawn with the user's message as --prompt. No handoff brief, no
-      // session resume, no message queue — each chat message is a fresh spawn.
-      const provider = getProvider(agent.provider);
-      if (provider?.constructor?.isOneShot) {
-        const oldConfig = { ...agent };
-        if (daemon.processes.isRunning(req.params.id)) {
-          await daemon.processes.kill(req.params.id);
-        }
-        daemon.registry.remove(req.params.id, { silent: true });
-        daemon.locks.release(req.params.id);
-
-        let newAgent;
-        try {
-          newAgent = await daemon.processes.spawn({
-            role: oldConfig.role,
-            scope: oldConfig.scope,
-            provider: oldConfig.provider,
-            model: oldConfig.model,
-            prompt: finalMessage,
-            permission: oldConfig.permission || 'full',
-            workingDir: oldConfig.workingDir,
-            name: oldConfig.name,
-            teamId: oldConfig.teamId,
-          });
-        } catch (spawnErr) {
-          daemon.registry.flushPendingRemovals();
-          throw spawnErr;
-        }
-        daemon.audit.log('agent.instruct', { id: req.params.id, newId: newAgent.id, resumed: false });
-        return res.json(newAgent);
-      }
-
-      // Non-interactive CLI providers (e.g. Gemini): respawn with the new
-      // message as the prompt, preserving original introContext. These providers
-      // run one prompt per spawn and cannot resume sessions.
-      if (provider?.constructor?.nonInteractive && !daemon.processes.isRunning(req.params.id)) {
-        const oldConfig = { ...agent };
-        daemon.registry.remove(req.params.id, { silent: true });
-        daemon.locks.release(req.params.id);
-
-        let newAgent;
-        try {
-          newAgent = await daemon.processes.spawn({
-            role: oldConfig.role,
-            scope: oldConfig.scope,
-            provider: oldConfig.provider,
-            model: oldConfig.model,
-            prompt: finalMessage,
-            introContext: oldConfig.introContext,
-            permission: oldConfig.permission || 'full',
-            workingDir: oldConfig.workingDir,
-            name: oldConfig.name,
-            teamId: oldConfig.teamId,
-          });
-        } catch (spawnErr) {
-          daemon.registry.flushPendingRemovals();
-          throw spawnErr;
-        }
-        daemon.audit.log('agent.instruct', { id: req.params.id, newId: newAgent.id, resumed: false });
-        return res.json(newAgent);
-      }
-
-      // Running CLI agent (no loop) — queue the message for delivery after
-      // the current task completes instead of killing and respawning.
-      if (daemon.processes.isRunning(req.params.id)) {
-        daemon.processes.queueMessage(req.params.id, wrappedMessage);
-        daemon.audit.log('agent.chat.queued', { id: req.params.id });
-        return res.json({ id: agent.id, status: 'message_queued' });
-      }
+      const result = await deliverInstruction(daemon, req.params.id, finalMessage);
 
-      // CLI agent path — session resume or rotation.
-      // Force rotation (fresh session + handoff brief) past the resume ceiling:
-      // reviving a >5M-token claude session has crashed the CLI mid-HTTP-parse
-      // (V8 fatal in JsonStringifier) — the rotator's handoff brief sidesteps that.
-      const SESSION_RESUME_CEILING = 5_000_000;
-      const resumed = !!agent.sessionId && (agent.tokensUsed || 0) < SESSION_RESUME_CEILING;
-      const newAgent = resumed
-        ? await daemon.processes.resume(req.params.id, wrappedMessage)
-        : await daemon.rotator.rotate(req.params.id, { additionalPrompt: wrappedMessage });
-
-      daemon.audit.log('agent.instruct', { id: req.params.id, newId: newAgent.id, resumed });
-      res.json(newAgent);
+      // Respawn paths return the fresh agent record; in-place delivery just
+      // acknowledges with a status the GUI uses to show queued vs sent.
+      if (result.agent && result.agentId !== req.params.id) return res.json(result.agent);
+      res.json({ id: agent.id, status: result.status });
     } catch (err) {
       res.status(400).json({ error: err.message });
     }

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

@@ -1,30 +1,77 @@
 // 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) {
-  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 } = 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' });
-
-      const msg = await daemon.innerchat.send(from, to, message.trim());
-      res.json(msg);
+      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 });
     }
   });
 
-  app.get('/api/innerchat/messages', (req, res) => {
+  app.get('/api/innerchat/threads', (req, res) => {
     const { agentId } = req.query;
-    res.json({ messages: daemon.innerchat.getMessages(agentId || null) });
+    res.json({ threads: daemon.innerchat.getThreads(agentId || null) });
   });
 
-  app.get('/api/innerchat/messages/:id', (req, res) => {
-    const msg = daemon.innerchat.getMessage(req.params.id);
-    if (!msg) return res.status(404).json({ error: 'Message not found' });
-    res.json(msg);
+  app.get('/api/innerchat/threads/:id', (req, res) => {
+    const thread = daemon.innerchat.getThread(req.params.id);
+    if (!thread) return res.status(404).json({ error: 'Thread not found' });
+    res.json(thread);
   });
 
   app.get('/api/innerchat/pending/:agentId', (req, res) => {

package/node_modules/@groove-dev/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/node_modules/@groove-dev/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;
   }
@@ -148,11 +176,17 @@ export class Teams {
           renameSync(oldWorkingDir, newWorkingDir);
           team.workingDir = newWorkingDir;
 
-          // Update all agents in this team with the new working directory
+          // Repoint every agent under the old tree, not just those sitting at
+          // its root — an agent in a subdirectory would otherwise keep a path
+          // that no longer exists.
           const agents = this.daemon.registry.getAll().filter((a) => a.teamId === id);
           for (const agent of agents) {
+            if (!agent.workingDir) continue;
             if (agent.workingDir === oldWorkingDir) {
               this.daemon.registry.update(agent.id, { workingDir: newWorkingDir });
+            } else if (agent.workingDir.startsWith(`${oldWorkingDir}/`)) {
+              const suffix = agent.workingDir.slice(oldWorkingDir.length);
+              this.daemon.registry.update(agent.id, { workingDir: `${newWorkingDir}${suffix}` });
             }
           }
         } catch (err) {