groove-dev 0.27.192 → 0.27.194

package/node_modules/@groove-dev/cli/package.json

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

package/node_modules/@groove-dev/daemon/package.json

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

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

@@ -131,7 +131,13 @@ export class InnerChat {
     };
     thread.turns.push(turn);
 
-    const wrapped = this._wrap(thread, fromAgent, toAgent, message, kind);
+    // Only replay earlier turns when the recipient has LOST them. A running
+    // agent already has this thread's history in its live session — re-injecting
+    // it every exchange duplicates content and balloons context. A stopped agent
+    // will be resumed/rotated (fresh context), so it needs the recap.
+    const recipientHasContext =
+      this.daemon.processes.isRunning(toAgent.id) || this.daemon.processes.hasAgentLoop(toAgent.id);
+    const wrapped = this._wrap(thread, fromAgent, toAgent, message, kind, !recipientHasContext);
 
     let result;
     try {
@@ -322,11 +328,11 @@ export class InnerChat {
   // turns to follow a continuing conversation. The closing instruction differs
   // by kind: an ask blocks the sender (answer now), a tell does not (answer
   // when you reach a good stopping point).
-  _wrap(thread, fromAgent, toAgent, message, kind = 'ask') {
+  _wrap(thread, fromAgent, toAgent, message, kind = 'ask', includePrior = true) {
     const header = kind === 'tell'
       ? `[InnerChat — ${fromAgent.name} (${fromAgent.role}) sent you a message]`
       : `[InnerChat — ${fromAgent.name} (${fromAgent.role}) is asking you a question]`;
-    const prior = thread.turns.slice(0, -1).slice(-CONTEXT_TURNS);
+    const prior = includePrior ? thread.turns.slice(0, -1).slice(-CONTEXT_TURNS) : [];
     const lines = [header, ''];
 
     if (prior.length) {

package/node_modules/@groove-dev/daemon/src/process.js

@@ -367,7 +367,7 @@ export class ProcessManager {
     this.daemon = daemon;
     this.handles = new Map(); // agentId -> { proc, logStream }
     this.peakContextUsage = new Map(); // agentId -> highest contextUsage seen
-    this.pendingMessages = new Map(); // agentId -> { message, timestamp }
+    this.pendingMessages = new Map(); // agentId -> [{ message, timestamp }, …] FIFO queue
     this._streamThrottle = new Map(); // agentId -> { timer, pending }
     this._rotatingAgents = new Set(); // agentIds currently being rotated (rotator wrote handoff)
     this._stalledAgents = new Set(); // agentIds already flagged as stalled (avoids duplicate broadcasts)
@@ -3222,7 +3222,13 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
   queueMessage(agentId, message) {
     const agent = this.daemon.registry.get(agentId);
     const wrapped = agent ? wrapWithRoleReminder(agent.role, message) : message;
-    this.pendingMessages.set(agentId, { message: wrapped, timestamp: Date.now() });
+    // Append to a FIFO queue rather than overwriting the slot. Two messages
+    // arriving while an agent is busy — a user chat and an InnerChat message,
+    // or two different agents reaching out — must BOTH survive. The old
+    // single-slot version silently dropped whichever arrived first.
+    const queue = this.pendingMessages.get(agentId) || [];
+    queue.push({ message: wrapped, timestamp: Date.now() });
+    this.pendingMessages.set(agentId, queue);
     if (this.daemon.rotator) {
       this.daemon.rotator.recordUserMessage(agentId);
     }
@@ -3230,9 +3236,13 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
   }
 
   consumePendingMessage(agentId) {
-    const pending = this.pendingMessages.get(agentId);
-    if (pending) this.pendingMessages.delete(agentId);
-    return pending || null;
+    const queue = this.pendingMessages.get(agentId);
+    if (!queue || queue.length === 0) return null;
+    this.pendingMessages.delete(agentId);
+    // Deliver everything queued in one turn, in arrival order, clearly
+    // separated so the agent can tell the messages apart.
+    const message = queue.map((q) => q.message).join('\n\n---\n\n');
+    return { message, timestamp: queue[0].timestamp, count: queue.length };
   }
 
   async killAll() {

package/node_modules/@groove-dev/daemon/test/innerchat.test.js

@@ -232,7 +232,9 @@ describe('InnerChat', () => {
 
   // ── Conversation context ──────────────────────────────────
 
-  it('replays prior turns so neither side re-explains', async () => {
+  it('does NOT replay prior turns to a running agent (it already has them)', async () => {
+    // a2 stays running throughout — re-injecting history it already holds would
+    // balloon its context.
     const p1 = innerchat.ask('a1', 'a2', 'What shape?');
     await tick(); innerchat.onAgentOutput('a2', result('REST'));
     await p1;
@@ -240,12 +242,32 @@ describe('InnerChat', () => {
     const p2 = innerchat.ask('a1', 'a2', 'Versioned?');
     await tick();
     const msg = daemon.sent.at(-1).msg;
+    assert.doesNotMatch(msg, /Earlier in this conversation/, 'no redundant recap to a live agent');
+    assert.match(msg, /Versioned\?/);
+
+    innerchat.onAgentOutput('a2', result('v2'));
+    await p2;
+  });
+
+  it('DOES replay prior turns when the recipient was stopped (lost its context)', async () => {
+    const p1 = innerchat.ask('a1', 'a2', 'What shape?');
+    await tick(); innerchat.onAgentOutput('a2', result('REST'));
+    await p1;
+
+    // a2 ends its turn — a resume/rotate gives it a fresh context, so it needs
+    // the recap to follow the thread.
+    daemon.processes._loops.delete('a2');
+    daemon.processes._running.delete('a2');
+
+    const p2 = innerchat.ask('a1', 'a2', 'Versioned?');
+    await tick();
+    const newId = daemon.resumes.at(-1).newId;
+    const msg = daemon.resumes.at(-1).msg;
     assert.match(msg, /Earlier in this conversation/);
     assert.match(msg, /fullstack-1: What shape\?/);
     assert.match(msg, /fullstack-14: REST/);
-    assert.match(msg, /Versioned\?/);
 
-    innerchat.onAgentOutput('a2', result('v2'));
+    innerchat.onAgentOutput(newId, result('v2'));
     await p2;
   });
 

package/node_modules/@groove-dev/daemon/test/pending-messages.test.js

@@ -0,0 +1,60 @@
+// GROOVE — Pending message queue tests
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { ProcessManager } from '../src/process.js';
+
+function makeDaemon() {
+  return {
+    registry: { get: (id) => ({ id, role: 'fullstack', name: id }) },
+    rotator: { recordUserMessage() {} },
+    broadcast() {},
+  };
+}
+
+describe('pending message queue', () => {
+  let pm;
+
+  beforeEach(() => { pm = new ProcessManager(makeDaemon()); });
+  afterEach(() => { if (pm._stallWatchdog) clearInterval(pm._stallWatchdog); });
+
+  it('keeps BOTH messages when two arrive while an agent is busy', () => {
+    pm.queueMessage('a1', 'message from the user');
+    pm.queueMessage('a1', 'question from another agent');
+
+    const drained = pm.consumePendingMessage('a1');
+    assert.equal(drained.count, 2);
+    assert.match(drained.message, /message from the user/);
+    assert.match(drained.message, /question from another agent/);
+    // arrival order preserved
+    assert.ok(drained.message.indexOf('user') < drained.message.indexOf('another agent'));
+  });
+
+  it('drains the queue so nothing is delivered twice', () => {
+    pm.queueMessage('a1', 'one');
+    pm.consumePendingMessage('a1');
+    assert.equal(pm.consumePendingMessage('a1'), null);
+  });
+
+  it('returns null when nothing is queued', () => {
+    assert.equal(pm.consumePendingMessage('nobody'), null);
+  });
+
+  it('queues are independent per agent', () => {
+    pm.queueMessage('a1', 'for a1');
+    pm.queueMessage('a2', 'for a2');
+    assert.match(pm.consumePendingMessage('a1').message, /for a1/);
+    assert.match(pm.consumePendingMessage('a2').message, /for a2/);
+  });
+
+  it('preserves order across three queued messages', () => {
+    pm.queueMessage('a1', 'first');
+    pm.queueMessage('a1', 'second');
+    pm.queueMessage('a1', 'third');
+    const { message, count } = pm.consumePendingMessage('a1');
+    assert.equal(count, 3);
+    assert.ok(message.indexOf('first') < message.indexOf('second'));
+    assert.ok(message.indexOf('second') < message.indexOf('third'));
+  });
+});

package/node_modules/@groove-dev/gui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/gui",
-  "version": "0.27.192",
+  "version": "0.27.194",
   "description": "GROOVE GUI — visual agent control plane",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/package.json

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

package/packages/daemon/src/innerchat.js

@@ -131,7 +131,13 @@ export class InnerChat {
     };
     thread.turns.push(turn);
 
-    const wrapped = this._wrap(thread, fromAgent, toAgent, message, kind);
+    // Only replay earlier turns when the recipient has LOST them. A running
+    // agent already has this thread's history in its live session — re-injecting
+    // it every exchange duplicates content and balloons context. A stopped agent
+    // will be resumed/rotated (fresh context), so it needs the recap.
+    const recipientHasContext =
+      this.daemon.processes.isRunning(toAgent.id) || this.daemon.processes.hasAgentLoop(toAgent.id);
+    const wrapped = this._wrap(thread, fromAgent, toAgent, message, kind, !recipientHasContext);
 
     let result;
     try {
@@ -322,11 +328,11 @@ export class InnerChat {
   // turns to follow a continuing conversation. The closing instruction differs
   // by kind: an ask blocks the sender (answer now), a tell does not (answer
   // when you reach a good stopping point).
-  _wrap(thread, fromAgent, toAgent, message, kind = 'ask') {
+  _wrap(thread, fromAgent, toAgent, message, kind = 'ask', includePrior = true) {
     const header = kind === 'tell'
       ? `[InnerChat — ${fromAgent.name} (${fromAgent.role}) sent you a message]`
       : `[InnerChat — ${fromAgent.name} (${fromAgent.role}) is asking you a question]`;
-    const prior = thread.turns.slice(0, -1).slice(-CONTEXT_TURNS);
+    const prior = includePrior ? thread.turns.slice(0, -1).slice(-CONTEXT_TURNS) : [];
     const lines = [header, ''];
 
     if (prior.length) {

package/packages/daemon/src/process.js

@@ -367,7 +367,7 @@ export class ProcessManager {
     this.daemon = daemon;
     this.handles = new Map(); // agentId -> { proc, logStream }
     this.peakContextUsage = new Map(); // agentId -> highest contextUsage seen
-    this.pendingMessages = new Map(); // agentId -> { message, timestamp }
+    this.pendingMessages = new Map(); // agentId -> [{ message, timestamp }, …] FIFO queue
     this._streamThrottle = new Map(); // agentId -> { timer, pending }
     this._rotatingAgents = new Set(); // agentIds currently being rotated (rotator wrote handoff)
     this._stalledAgents = new Set(); // agentIds already flagged as stalled (avoids duplicate broadcasts)
@@ -3222,7 +3222,13 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
   queueMessage(agentId, message) {
     const agent = this.daemon.registry.get(agentId);
     const wrapped = agent ? wrapWithRoleReminder(agent.role, message) : message;
-    this.pendingMessages.set(agentId, { message: wrapped, timestamp: Date.now() });
+    // Append to a FIFO queue rather than overwriting the slot. Two messages
+    // arriving while an agent is busy — a user chat and an InnerChat message,
+    // or two different agents reaching out — must BOTH survive. The old
+    // single-slot version silently dropped whichever arrived first.
+    const queue = this.pendingMessages.get(agentId) || [];
+    queue.push({ message: wrapped, timestamp: Date.now() });
+    this.pendingMessages.set(agentId, queue);
     if (this.daemon.rotator) {
       this.daemon.rotator.recordUserMessage(agentId);
     }
@@ -3230,9 +3236,13 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
   }
 
   consumePendingMessage(agentId) {
-    const pending = this.pendingMessages.get(agentId);
-    if (pending) this.pendingMessages.delete(agentId);
-    return pending || null;
+    const queue = this.pendingMessages.get(agentId);
+    if (!queue || queue.length === 0) return null;
+    this.pendingMessages.delete(agentId);
+    // Deliver everything queued in one turn, in arrival order, clearly
+    // separated so the agent can tell the messages apart.
+    const message = queue.map((q) => q.message).join('\n\n---\n\n');
+    return { message, timestamp: queue[0].timestamp, count: queue.length };
   }
 
   async killAll() {

package/packages/gui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/gui",
-  "version": "0.27.192",
+  "version": "0.27.194",
   "description": "GROOVE GUI — visual agent control plane",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",