groove-dev 0.27.182 → 0.27.184

package/node_modules/@groove-dev/gui/src/stores/groove.js

@@ -369,54 +369,39 @@ export const useGrooveStore = create((set, get) => ({
           break;
         }
 
-        case 'innerchat:sent': {
-          const ic = msg.data;
-          get().addChatMessage(ic.to.id, 'innerchat', ic.message, false);
-          set((s) => {
-            const icMsgs = { ...s.innerchatMessages };
-            icMsgs[ic.id] = ic;
-            persistJSON('groove:innerchatMessages', icMsgs);
-            return { innerchatMessages: icMsgs };
-          });
-          // Tag the chat message with innerchat metadata
-          set((s) => {
-            const history = { ...s.chatHistory };
-            const arr = history[ic.to.id] || [];
-            if (arr.length > 0) {
-              const last = arr[arr.length - 1];
-              if (last.from === 'innerchat' && last.text === ic.message) {
-                arr[arr.length - 1] = { ...last, innerchat: { messageId: ic.id, fromAgent: ic.from } };
-                history[ic.to.id] = arr;
-                persistJSON('groove:chatHistory', history);
-                return { chatHistory: history };
-              }
-            }
-            return {};
-          });
-          break;
-        }
+        case 'innerchat:turn': {
+          const { thread, turn } = msg.data;
+          if (turn.status === 'failed') {
+            get().addToast('error', `Relay to ${turn.to.name} failed`, turn.error);
+          }
 
-        case 'innerchat:response': {
-          const ic = msg.data;
-          get().addChatMessage(ic.from.id, 'innerchat', ic.response, false);
+          // The turn lands in the recipient's chat, badged with who sent it.
           set((s) => {
-            const icMsgs = { ...s.innerchatMessages };
-            icMsgs[ic.id] = ic;
-            persistJSON('groove:innerchatMessages', icMsgs);
-            // Tag the response chat message with innerchat metadata
             const history = { ...s.chatHistory };
-            const arr = history[ic.from.id] || [];
-            if (arr.length > 0) {
-              const last = arr[arr.length - 1];
-              if (last.from === 'innerchat' && last.text === ic.response) {
-                arr[arr.length - 1] = { ...last, innerchat: { messageId: ic.id, fromAgent: ic.to } };
-                history[ic.from.id] = arr;
-                persistJSON('groove:chatHistory', history);
-              }
-            }
-            return { innerchatMessages: icMsgs, chatHistory: history };
+            const arr = [...(history[turn.to.id] || [])];
+            arr.push({
+              from: 'innerchat',
+              text: turn.text,
+              timestamp: turn.timestamp,
+              isQuery: false,
+              innerchat: {
+                turnId: turn.id,
+                threadId: thread.id,
+                kind: turn.kind,
+                fromAgent: turn.from,
+              },
+            });
+            history[turn.to.id] = arr.slice(-100);
+            persistJSON('groove:chatHistory', history);
+
+            const threads = { ...s.innerchatThreads, [thread.id]: thread };
+            persistJSON('groove:innerchatThreads', threads);
+            return { chatHistory: history, innerchatThreads: threads };
           });
-          get().addToast('info', `${ic.to.name} replied to ${ic.from.name}`, 'InnerChat response received');
+
+          if (turn.kind === 'reply' && turn.status !== 'failed') {
+            get().addToast('info', `${turn.from.name} replied`, `Forwarded to ${turn.to.name}`);
+          }
           break;
         }
 
@@ -620,6 +605,12 @@ export const useGrooveStore = create((set, get) => ({
           get().fetchTeams();
           break;
 
+        // Reordering already applied optimistically on the client that did it;
+        // this keeps every other window in sync.
+        case 'teams:reordered':
+          if (msg.teams) set({ teams: msg.teams });
+          break;
+
         case 'approval:request':
           set((s) => ({ pendingApprovals: [...s.pendingApprovals, msg.data] }));
           break;

package/node_modules/@groove-dev/gui/src/stores/slices/agents-slice.js

@@ -104,20 +104,43 @@ export const createAgentsSlice = (set, get) => ({
     }
   },
 
+  // Move an agent to another team. Teams are an organizational grouping —
+  // this re-labels the agent and does NOT relocate its working directory, so a
+  // running process keeps working where it is.
+  async moveAgentToTeam(agentId, teamId) {
+    const agent = get().agents.find((a) => a.id === agentId);
+    if (!agent || agent.teamId === teamId) return;
+    const team = get().teams.find((t) => t.id === teamId);
+    try {
+      await api.patch(`/agents/${encodeURIComponent(agentId)}`, { teamId });
+      get().addToast('success', `Moved ${agent.name} → ${team?.name || 'team'}`);
+    } catch (err) {
+      get().addToast('error', 'Move failed', err.message);
+    }
+  },
+
   // ── InnerChat ─────────────────────────────────────────────
 
-  innerchatMessages: loadJSON('groove:innerchatMessages') || {},
+  innerchatThreads: loadJSON('groove:innerchatThreads') || {},
 
-  async sendInnerChat(fromId, toId, message) {
+  // Relay a message from one agent to another. Pass threadId to continue an
+  // existing exchange rather than opening a new one.
+  async sendInnerChat(fromId, toId, message, threadId = null) {
     try {
-      const msg = await api.post('/innerchat/send', { from: fromId, to: toId, message });
-      return msg;
+      return await api.post('/innerchat/send', { from: fromId, to: toId, message, threadId });
     } catch (err) {
       get().addToast('error', 'InnerChat failed', err.message);
       throw err;
     }
   },
 
+  // Threads this agent is a participant in, most recent first.
+  innerchatThreadsFor(agentId) {
+    return Object.values(get().innerchatThreads)
+      .filter((t) => t.participants.some((p) => p.id === agentId))
+      .sort((a, b) => b.updatedAt - a.updatedAt);
+  },
+
   // ── Chat ──────────────────────────────────────────────────
 
   addChatMessage(agentId, from, text, isQuery = false, attachments = undefined) {

package/node_modules/@groove-dev/gui/src/stores/slices/teams-slice.js

@@ -173,6 +173,28 @@ export const createTeamsSlice = (set, get) => ({
     }
   },
 
+  // Move a team to a new index in the sidebar. Applied optimistically so the
+  // drop lands instantly, then reconciled with whatever the daemon persisted.
+  async reorderTeams(draggedId, targetId) {
+    const current = get().teams;
+    const from = current.findIndex((t) => t.id === draggedId);
+    const to = current.findIndex((t) => t.id === targetId);
+    if (from === -1 || to === -1 || from === to) return;
+
+    const next = [...current];
+    const [moved] = next.splice(from, 1);
+    next.splice(to, 0, moved);
+    set({ teams: next });
+
+    try {
+      const { teams } = await api.post('/teams/reorder', { orderedIds: next.map((t) => t.id) });
+      if (teams) set({ teams });
+    } catch (err) {
+      set({ teams: current });
+      get().addToast('error', 'Failed to reorder teams', err.message);
+    }
+  },
+
   async promoteTeam(id) {
     try {
       const team = await api.post(`/teams/${encodeURIComponent(id)}/promote`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groove-dev",
-  "version": "0.27.182",
+  "version": "0.27.184",
   "description": "Open-source agent orchestration layer — the AI company OS. Local model agent engine (GGUF/Ollama/llama-server), HuggingFace model browser, MCP integrations (Slack, Gmail, Stripe, 15+), agent scheduling (cron), business roles (CMO, CFO, EA). GUI dashboard, multi-agent coordination, zero cold-start, infinite sessions. Works with Claude Code, Codex, Gemini CLI, Ollama, any local model.",
   "license": "FSL-1.1-Apache-2.0",
   "author": "Groove Dev <hello@groovedev.ai> (https://groovedev.ai)",

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.182",
+  "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.182",
+  "version": "0.27.184",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/packages/daemon/src/deliver.js

@@ -0,0 +1,130 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { wrapWithRoleReminder } from './process.js';
+import { getProvider } from './providers/index.js';
+
+// Reviving a >5M-token claude session has crashed the CLI mid-HTTP-parse
+// (V8 fatal in JsonStringifier) — past this ceiling the rotator's handoff
+// brief sidesteps the resume entirely.
+const SESSION_RESUME_CEILING = 5_000_000;
+
+/**
+ * Deliver a message to an agent, whatever state it's in.
+ *
+ * This is the single pipe every inbound message travels — user chat from the
+ * GUI and InnerChat relays alike. Handles agent-loop delivery, one-shot and
+ * non-interactive providers, queueing behind a running task, session resume,
+ * and full rotation when the session is too large to revive.
+ *
+ * Respawn paths mint a NEW agent id. Callers that track the agent afterwards
+ * (InnerChat keys response capture on it) must use the returned `agentId`,
+ * not the one they passed in.
+ *
+ * @returns {Promise<{agentId: string, status: string, resumed: boolean, agent: object|null}>}
+ */
+export async function deliverInstruction(daemon, agentId, message, opts = {}) {
+  const { recordFeedback = true } = opts;
+
+  const agent = daemon.registry.get(agentId);
+  if (!agent) throw new Error('Agent not found');
+
+  const finalMessage = message.trim();
+  if (!finalMessage) throw new Error('message is required');
+
+  // Journalist/rotator treat this as a human steering signal — InnerChat
+  // relays opt out so agent-to-agent chatter doesn't pollute user feedback.
+  if (recordFeedback) {
+    if (daemon.journalist) daemon.journalist.recordUserFeedback(agent, finalMessage);
+    if (daemon.rotator) daemon.rotator.recordUserMessage(agentId);
+  }
+
+  const wrappedMessage = wrapWithRoleReminder(agent.role, finalMessage);
+
+  // Agent loop path — send straight to the running loop.
+  if (daemon.processes.hasAgentLoop(agentId)) {
+    const sent = await daemon.processes.sendMessage(agentId, wrappedMessage);
+    if (sent) {
+      daemon.audit.log('agent.chat', { id: agentId });
+      return { agentId, status: 'message_sent', resumed: false, agent };
+    }
+    // Loop exists but isn't running — fall through to resume/rotate.
+  }
+
+  const provider = getProvider(agent.provider);
+
+  // One-shot providers (groove-network): kill any running instance and respawn
+  // with the message as --prompt. No handoff brief, no resume, no queue.
+  if (provider?.constructor?.isOneShot) {
+    const oldConfig = { ...agent };
+    if (daemon.processes.isRunning(agentId)) {
+      await daemon.processes.kill(agentId);
+    }
+    daemon.registry.remove(agentId, { silent: true });
+    daemon.locks.release(agentId);
+
+    const newAgent = await respawn(daemon, {
+      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,
+    });
+    daemon.audit.log('agent.instruct', { id: agentId, newId: newAgent.id, resumed: false });
+    return { agentId: newAgent.id, status: 'respawned', resumed: false, agent: newAgent };
+  }
+
+  // Non-interactive CLI providers (e.g. Gemini): one prompt per spawn, cannot
+  // resume — respawn preserving the original introContext.
+  if (provider?.constructor?.nonInteractive && !daemon.processes.isRunning(agentId)) {
+    const oldConfig = { ...agent };
+    daemon.registry.remove(agentId, { silent: true });
+    daemon.locks.release(agentId);
+
+    const newAgent = await respawn(daemon, {
+      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,
+    });
+    daemon.audit.log('agent.instruct', { id: agentId, newId: newAgent.id, resumed: false });
+    return { agentId: newAgent.id, status: 'respawned', resumed: false, agent: newAgent };
+  }
+
+  // Running CLI agent (no loop) — queue behind the current task rather than
+  // killing and respawning mid-work.
+  if (daemon.processes.isRunning(agentId)) {
+    daemon.processes.queueMessage(agentId, wrappedMessage);
+    daemon.audit.log('agent.chat.queued', { id: agentId });
+    return { agentId, status: 'message_queued', resumed: false, agent };
+  }
+
+  // Stopped CLI agent — resume the session, or rotate past the ceiling.
+  const resumed = !!agent.sessionId && (agent.tokensUsed || 0) < SESSION_RESUME_CEILING;
+  const newAgent = resumed
+    ? await daemon.processes.resume(agentId, wrappedMessage)
+    : await daemon.rotator.rotate(agentId, { additionalPrompt: wrappedMessage });
+
+  daemon.audit.log('agent.instruct', { id: agentId, newId: newAgent.id, resumed });
+  return { agentId: newAgent.id, status: resumed ? 'resumed' : 'rotated', resumed, agent: newAgent };
+}
+
+// Spawn, flushing the registry's pending removals if it fails so a failed
+// respawn doesn't silently erase the agent it was replacing.
+async function respawn(daemon, config) {
+  try {
+    return await daemon.processes.spawn(config);
+  } catch (spawnErr) {
+    daemon.registry.flushPendingRemovals();
+    throw spawnErr;
+  }
+}

package/packages/daemon/src/index.js

@@ -10,7 +10,7 @@ import express from 'express';
 import { WebSocketServer } from 'ws';
 import { Registry } from './registry.js';
 import { createApi } from './api.js';
-import { ProcessManager } from './process.js';
+import { ProcessManager, sanitizeFilename } from './process.js';
 import { StateManager } from './state.js';
 import { Introducer } from './introducer.js';
 import { LockManager } from './lockmanager.js';
@@ -750,7 +750,11 @@ export class Daemon {
     try {
       // Build set of agent names still in the registry — never remove their logs
       const allAgents = this.registry.getAll();
-      const activeNames = new Set(allAgents.map((a) => a.name));
+      // Raw logs are keyed by sanitized name; GROOVE_AGENT_LOGS/ subdirectories
+      // are keyed by agent id (journalist.js). Comparing either against the
+      // wrong set deletes live agents' history.
+      const activeNames = new Set(allAgents.map((a) => sanitizeFilename(a.name)));
+      const activeIds = new Set(allAgents.map((a) => a.id));
 
       // Safety: if registry is empty but log files exist, state may have been
       // lost (corrupt JSON, partial write). Skip log cleanup to prevent
@@ -778,7 +782,7 @@ export class Daemon {
       if (existsSync(agentLogsDir)) {
         for (const dir of readdirSync(agentLogsDir, { withFileTypes: true })) {
           if (!dir.isDirectory()) continue;
-          if (activeNames.has(dir.name)) continue;
+          if (activeIds.has(dir.name)) continue;
           try { rmSync(resolve(agentLogsDir, dir.name), { recursive: true }); cleaned++; } catch { /* skip */ }
         }
         // Remove GROOVE_AGENT_LOGS/ itself if empty

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.',
+  ];
+}