groove-dev 0.27.193 → 0.27.195

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

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

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

@@ -38,7 +38,11 @@ export async function deliverInstruction(daemon, agentId, message, opts = {}) {
     if (daemon.rotator) daemon.rotator.recordUserMessage(agentId);
   }
 
-  const wrappedMessage = wrapWithRoleReminder(agent.role, finalMessage);
+  // Prepend a fresh wall-clock anchor so the agent gauges progress by real time
+  // and the user's direction, not by how much context has piled up.
+  const clock = daemon.processes.sessionClock?.(agent);
+  const timedMessage = clock ? `${clock}\n\n${finalMessage}` : finalMessage;
+  const wrappedMessage = wrapWithRoleReminder(agent.role, timedMessage);
 
   // Agent loop path — send straight to the running loop.
   if (daemon.processes.hasAgentLoop(agentId)) {

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

@@ -362,12 +362,37 @@ export function wrapWithRoleReminder(role, message) {
   return message;
 }
 
+// A fresh wall-clock anchor, regenerated for every message an agent receives.
+// Agents have no innate sense of elapsed time — they infer "how far along are
+// we" from how much context has piled up, so 15 minutes of dense work (and the
+// session-feel that rotations add) reads as a long day and they start winding
+// down. This gives them the real time and duration each turn, plus an explicit
+// frame that the session is live and open-ended.
+export function sessionClockLine(startISO) {
+  const now = new Date();
+  const when = now.toLocaleString('en-US', {
+    weekday: 'short', month: 'short', day: 'numeric',
+    hour: 'numeric', minute: '2-digit', hour12: true,
+  });
+  let dur = '';
+  if (startISO) {
+    const mins = Math.max(0, Math.round((now - new Date(startISO)) / 60000));
+    const human = mins < 60 ? `${mins} min` : `${Math.floor(mins / 60)}h ${mins % 60}m`;
+    dur = ` You've been in this work session about ${human}.`;
+  }
+  return `[Clock — ${when}.${dur} This is a live session with the user present and engaged. `
+    + 'Judge how far along you are by the task and the user\'s direction, not by how much has '
+    + 'been built or a felt sense of time. Do not wind down, "call it a day," or trim scope on '
+    + 'your own — keep working until the user says to stop.]';
+}
+
 export class ProcessManager {
   constructor(daemon) {
     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.sessionStarts = new Map();   // agentName -> ISO start; keyed by name so it survives rotation
     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)
@@ -1184,6 +1209,12 @@ For normal file edits within your scope, proceed without review.
       }
     }
 
+    // Give the agent a wall-clock anchor on its very first turn. sessionClock
+    // records the session start (by name, so a later rotation keeps it).
+    if (!isOneShotProvider) {
+      spawnConfig.prompt = `${this.sessionClock(agent)}\n\n${spawnConfig.prompt}`;
+    }
+
     // Set up log capture (shared between CLI and agent loop paths)
     const logDir = resolve(this.daemon.grooveDir, 'logs');
     mkdirSync(logDir, { recursive: true });
@@ -3219,10 +3250,30 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
     return !!(handle?.loop);
   }
 
+  // The fresh clock line for an agent, anchored to when its work session first
+  // began. Keyed by name, so a rotation (new agent id, same name) keeps the
+  // original start rather than resetting the clock to "just now".
+  sessionClock(agent) {
+    if (!agent) return sessionClockLine(null);
+    const key = agent.name || agent.id;
+    let start = this.sessionStarts.get(key);
+    if (!start) {
+      start = agent.metadata?.sessionStartedAt || agent.spawnedAt || agent.createdAt || new Date().toISOString();
+      this.sessionStarts.set(key, start);
+    }
+    return sessionClockLine(start);
+  }
+
   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 +3281,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/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.193",
+  "version": "0.27.195",
   "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.193",
+  "version": "0.27.195",
   "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.193",
+  "version": "0.27.195",
   "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.193",
+  "version": "0.27.195",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/packages/daemon/src/deliver.js

@@ -38,7 +38,11 @@ export async function deliverInstruction(daemon, agentId, message, opts = {}) {
     if (daemon.rotator) daemon.rotator.recordUserMessage(agentId);
   }
 
-  const wrappedMessage = wrapWithRoleReminder(agent.role, finalMessage);
+  // Prepend a fresh wall-clock anchor so the agent gauges progress by real time
+  // and the user's direction, not by how much context has piled up.
+  const clock = daemon.processes.sessionClock?.(agent);
+  const timedMessage = clock ? `${clock}\n\n${finalMessage}` : finalMessage;
+  const wrappedMessage = wrapWithRoleReminder(agent.role, timedMessage);
 
   // Agent loop path — send straight to the running loop.
   if (daemon.processes.hasAgentLoop(agentId)) {

package/packages/daemon/src/process.js

@@ -362,12 +362,37 @@ export function wrapWithRoleReminder(role, message) {
   return message;
 }
 
+// A fresh wall-clock anchor, regenerated for every message an agent receives.
+// Agents have no innate sense of elapsed time — they infer "how far along are
+// we" from how much context has piled up, so 15 minutes of dense work (and the
+// session-feel that rotations add) reads as a long day and they start winding
+// down. This gives them the real time and duration each turn, plus an explicit
+// frame that the session is live and open-ended.
+export function sessionClockLine(startISO) {
+  const now = new Date();
+  const when = now.toLocaleString('en-US', {
+    weekday: 'short', month: 'short', day: 'numeric',
+    hour: 'numeric', minute: '2-digit', hour12: true,
+  });
+  let dur = '';
+  if (startISO) {
+    const mins = Math.max(0, Math.round((now - new Date(startISO)) / 60000));
+    const human = mins < 60 ? `${mins} min` : `${Math.floor(mins / 60)}h ${mins % 60}m`;
+    dur = ` You've been in this work session about ${human}.`;
+  }
+  return `[Clock — ${when}.${dur} This is a live session with the user present and engaged. `
+    + 'Judge how far along you are by the task and the user\'s direction, not by how much has '
+    + 'been built or a felt sense of time. Do not wind down, "call it a day," or trim scope on '
+    + 'your own — keep working until the user says to stop.]';
+}
+
 export class ProcessManager {
   constructor(daemon) {
     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.sessionStarts = new Map();   // agentName -> ISO start; keyed by name so it survives rotation
     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)
@@ -1184,6 +1209,12 @@ For normal file edits within your scope, proceed without review.
       }
     }
 
+    // Give the agent a wall-clock anchor on its very first turn. sessionClock
+    // records the session start (by name, so a later rotation keeps it).
+    if (!isOneShotProvider) {
+      spawnConfig.prompt = `${this.sessionClock(agent)}\n\n${spawnConfig.prompt}`;
+    }
+
     // Set up log capture (shared between CLI and agent loop paths)
     const logDir = resolve(this.daemon.grooveDir, 'logs');
     mkdirSync(logDir, { recursive: true });
@@ -3219,10 +3250,30 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
     return !!(handle?.loop);
   }
 
+  // The fresh clock line for an agent, anchored to when its work session first
+  // began. Keyed by name, so a rotation (new agent id, same name) keeps the
+  // original start rather than resetting the clock to "just now".
+  sessionClock(agent) {
+    if (!agent) return sessionClockLine(null);
+    const key = agent.name || agent.id;
+    let start = this.sessionStarts.get(key);
+    if (!start) {
+      start = agent.metadata?.sessionStartedAt || agent.spawnedAt || agent.createdAt || new Date().toISOString();
+      this.sessionStarts.set(key, start);
+    }
+    return sessionClockLine(start);
+  }
+
   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 +3281,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.193",
+  "version": "0.27.195",
   "description": "GROOVE GUI — visual agent control plane",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",