groove-dev 0.27.182 → 0.27.184

package/packages/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/packages/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/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;
   }
@@ -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) {