groove-dev 0.27.184 → 0.27.186

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

@@ -10,6 +10,12 @@ import { agentLogPath } from './process.js';
 const DEFAULT_INTERVAL = 300_000; // 5 minutes (safety-net fallback; event-driven triggers handle the normal case)
 const MAX_LOG_CHARS = 100_000; // ~25k tokens budget for synthesis input (captures 80-90% of recent activity)
 const DEBOUNCE_MS = 10_000; // requestSynthesis debounce window
+// Conversation carried across a rotation (~37K tokens at 150K chars). This is
+// deliberately generous: a rotation is the one lossy step in an infinite
+// session, and re-reading the recent dialogue once per rotation is far cheaper
+// than the degradation from an agent that forgot its own history. Tune via
+// config resumeBudgetChars (lower for cost-sensitive fleets).
+const DEFAULT_RESUME_BUDGET_CHARS = 150_000;
 
 export class Journalist {
   constructor(daemon) {
@@ -1061,7 +1067,51 @@ export class Journalist {
    *
    * Budget: keeps recent turns verbatim, summarizes oldest if over maxChars.
    */
-  extractConversationThread(agent, { maxChars = 60000 } = {}) {
+  extractConversationThread(agent, { maxChars } = {}) {
+    // Budget is configurable (resumeBudgetChars): this is the "how much memory
+    // survives a rotation" dial. Bigger costs more tokens per rotation but
+    // preserves more of the session; a rotation is lossy exactly here.
+    if (!maxChars) maxChars = this.daemon.config?.resumeBudgetChars ?? DEFAULT_RESUME_BUDGET_CHARS;
+    const merged = this._parseConversationTurns(agent);
+    if (!merged || merged.length === 0) return null;
+
+    // Build the thread — keep recent turns verbatim, truncate old ones if over budget
+    let thread = '';
+    const formatted = merged.map((t) => {
+      const label = t.role === 'user' ? 'USER' : 'CLAUDE';
+      return `[${label}]:\n${t.text}`;
+    });
+
+    // Start from the end (most recent) and work backwards to fill budget
+    const recentFirst = [...formatted].reverse();
+    const kept = [];
+    let totalLen = 0;
+
+    for (const entry of recentFirst) {
+      if (totalLen + entry.length > maxChars) {
+        // Truncate this entry to fit remaining budget
+        const remaining = maxChars - totalLen;
+        if (remaining > 200) {
+          kept.push(entry.slice(0, remaining) + '\n[...truncated]');
+        }
+        break;
+      }
+      kept.push(entry);
+      totalLen += entry.length;
+    }
+
+    // Reverse back to chronological order
+    kept.reverse();
+    thread = kept.join('\n\n---\n\n');
+
+    return thread;
+  }
+
+  /**
+   * Parse the full user↔assistant turn list from an agent's stream-json log.
+   * Returns merged turns in chronological order, or null if no log/turns.
+   */
+  _parseConversationTurns(agent) {
     const logPath = agentLogPath(this.daemon.grooveDir, agent);
     if (!existsSync(logPath)) return null;
 
@@ -1121,37 +1171,23 @@ export class Journalist {
         merged.push({ ...turn });
       }
     }
+    return merged;
+  }
 
-    // Build the thread — keep recent turns verbatim, truncate old ones if over budget
-    let thread = '';
-    const formatted = merged.map((t) => {
-      const label = t.role === 'user' ? 'USER' : 'CLAUDE';
-      return `[${label}]:\n${t.text}`;
-    });
-
-    // Start from the end (most recent) and work backwards to fill budget
-    const recentFirst = [...formatted].reverse();
-    const kept = [];
-    let totalLen = 0;
-
-    for (const entry of recentFirst) {
-      if (totalLen + entry.length > maxChars) {
-        // Truncate this entry to fit remaining budget
-        const remaining = maxChars - totalLen;
-        if (remaining > 200) {
-          kept.push(entry.slice(0, remaining) + '\n[...truncated]');
-        }
-        break;
-      }
-      kept.push(entry);
-      totalLen += entry.length;
-    }
-
-    // Reverse back to chronological order
-    kept.reverse();
-    thread = kept.join('\n\n---\n\n');
-
-    return thread;
+  /**
+   * The agent's ORIGINAL task, from the first substantial user message in the
+   * FULL log — never from the truncated resume window. When weeks of dialogue
+   * exceed the resume budget, the window holds only recent work; anchoring the
+   * task there makes the agent's identity drift onto whatever happened last.
+   * The name-keyed log spans all rotations, so the true origin is always here.
+   */
+  extractOriginalTask(agent) {
+    const merged = this._parseConversationTurns(agent);
+    if (!merged) return '';
+    const first = merged.find((t) => t.role === 'user' && t.text.trim().length >= 10);
+    if (!first) return '';
+    const text = first.text.trim();
+    return text.length > 500 ? text.slice(0, 500) + '...' : text;
   }
 
   /**
@@ -1159,15 +1195,17 @@ export class Journalist {
    * thread so a fresh agent picks up where the previous session left off.
    */
   buildConversationResumePrompt(agent, userMessage, { isRotation = false, reason } = {}) {
-    const thread = this.extractConversationThread(agent);
+    const budget = this.daemon.config?.resumeBudgetChars ?? DEFAULT_RESUME_BUDGET_CHARS;
+    const thread = this.extractConversationThread(agent, { maxChars: budget });
     if (!thread) return null;
 
     const constraints = this.daemon.memory?.getConstraintsMarkdown(2000) || '';
     const discoveries = this.daemon.memory?.getDiscoveriesMarkdown(agent.role, 5, 1000, agent.scope, agent.teamId) || '';
 
-    // Extract the user's original task from the conversation — the first substantial
-    // user message is almost always the task assignment. This anchors the new agent.
-    const originalTask = this._extractOriginalTask(thread);
+    // Anchor the agent to its ORIGINAL task from the full log — the truncated
+    // thread's first message may be mid-project (or another agent's task) once
+    // history outgrows the budget. Fall back to the window only if the log parse fails.
+    const originalTask = this.extractOriginalTask(agent) || this._extractOriginalTask(thread);
 
     // Rotation and idle-resume need very different framing. During rotation the agent
     // has no new user message — it must continue the exact in-progress task without
@@ -1181,6 +1219,7 @@ export class Journalist {
       originalTask ? `Your task: ${originalTask}` : '',
       ``,
       `Rules:`,
+      `- NEVER mention the rotation, context refresh, restart, or any session discontinuity to the user — from the user's perspective you are one continuous agent and this refresh must be invisible`,
       `- Continue ONLY the task described in the conversation below`,
       `- Do NOT explore the codebase looking for other things to fix or improve`,
       `- Do NOT start new work that was not part of the original task`,
@@ -1210,14 +1249,16 @@ export class Journalist {
       isIdleResume ? `## New Message From User\n\n${userMessage}` : '',
       ``,
       isRotation
-        ? `Continue the in-progress task from the conversation above. Stay focused on that task only. Do not ask the user to repeat anything. If the task was already completed, state that and wait for new instructions.`
-        : `Continue seamlessly from the conversation above. You have the full context of what was discussed, what was tried, what worked and what didn't. Do not ask the user to repeat anything.`,
+        ? `Continue the in-progress task from the conversation above. Stay focused on that task only. Do not ask the user to repeat anything, and never reference this context refresh — continue as if the conversation above simply never stopped. If the task was already completed, state that and wait for new instructions.`
+        : `Continue seamlessly from the conversation above. You have the full context of what was discussed, what was tried, what worked and what didn't. Do not ask the user to repeat anything, and never mention the interruption or that you are resuming — to the user this is one continuous conversation.`,
     ].filter(Boolean).join('\n');
 
-    // Hard cap at 80K chars (~20K tokens) to leave plenty of room in context window
-    if (prompt.length > 80000) {
+    // Cap scales with the configured budget (framing adds constraints/discoveries
+    // on top of the thread) to leave room in the context window
+    const promptCap = budget + 20_000;
+    if (prompt.length > promptCap) {
       // Re-extract with smaller budget and rebuild
-      const smallerThread = this.extractConversationThread(agent, { maxChars: 40000 });
+      const smallerThread = this.extractConversationThread(agent, { maxChars: Math.floor(budget * 2 / 3) });
       if (smallerThread) {
         prompt = [
           `# Session Context Resume`,
@@ -1238,8 +1279,8 @@ export class Journalist {
           isIdleResume ? `## New Message From User\n\n${userMessage}` : '',
           ``,
           isRotation
-            ? `Continue the in-progress task only. Do not explore or start new work. If done, state that and wait.`
-            : `Continue seamlessly. Do not ask the user to repeat anything.`,
+            ? `Continue the in-progress task only. Do not explore or start new work. Never mention this context refresh to the user. If done, state that and wait.`
+            : `Continue seamlessly. Do not ask the user to repeat anything, and never mention the interruption — to the user this is one continuous conversation.`,
         ].filter(Boolean).join('\n');
       }
     }

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

@@ -10,7 +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';
+import { innerChatInstructions, watchInstructions } from './innerchat-docs.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SLIDES_ENGINE_SRC = resolve(__dirname, '../templates/groove-slides.cjs');
@@ -562,12 +562,17 @@ export class ProcessManager {
       const pending = this.consumePendingMessage(agent.id);
       if (pending) {
         const agentData = registry.get(agent.id);
-        if (agentData?.sessionId) {
-          this.resume(agent.id, pending.message).catch((err) => {
-            console.error(`[Groove] Auto-resume with queued message failed for ${agent.name}: ${err.message}`);
-          });
-          return;
-        }
+        // Deliver the queued message: resume if there's a session, otherwise
+        // rotate (fresh session + handoff brief). Previously a missing sessionId
+        // meant the already-consumed message was silently dropped — an
+        // InnerChat message to a busy agent would vanish and never fire it.
+        const deliver = agentData?.sessionId
+          ? this.resume(agent.id, pending.message)
+          : this.daemon.rotator.rotate(agent.id, { additionalPrompt: pending.message });
+        deliver.catch((err) => {
+          console.error(`[Groove] Delivering queued message to ${agent.name} failed: ${err.message}`);
+        });
+        return;
       }
     }
 
@@ -1165,11 +1170,15 @@ For normal file edits within your scope, proceed without review.
     // 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';
+      const capabilities = [
+        ...innerChatInstructions(port, agent.name),
+        '',
+        ...watchInstructions(port, agent.name),
+      ].join('\n') + '\n\n';
       if (spawnConfig.prompt.startsWith('# Handoff Brief')) {
-        spawnConfig.prompt += '\n\n' + innerChatPrompt.trim();
+        spawnConfig.prompt += '\n\n' + capabilities.trim();
       } else {
-        spawnConfig.prompt = innerChatPrompt + spawnConfig.prompt;
+        spawnConfig.prompt = capabilities + spawnConfig.prompt;
       }
     }
 

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

@@ -18,7 +18,12 @@ const SCORE_HISTORY_MAX = 40;   // ~10 min at 15s intervals
 const COOLDOWN_MS = 5 * 60 * 1000;   // 5 minutes between rotations per agent
 const QUALITY_COOLDOWN_MS = 2 * 60 * 1000; // 2 minutes for quality degradation rotations
 const TOKEN_CEILING = 5_000_000;     // 5M tokens per agent (non-self-managing only)
-const REPLAY_CEILING = 0.50;         // Self-managing providers: rotate idle agents above this context usage
+// Self-managing providers: rotate idle agents above this context usage.
+// 0.80 favors context retention over cache-read cost — the conversation-resume
+// window is a slice of the full session, so every rotation is lossy; for
+// complex long-lived work that loss compounds faster than token savings pay off.
+// Lower via config (replayCeiling) for cost-sensitive fleets; 0 disables.
+const REPLAY_CEILING = 0.80;
 const VELOCITY_CEILING = 250_000;    // New (non-cache) tokens per window before force rotation
 const VELOCITY_WINDOW_MS = 5 * 60_000;
 const ROLE_MULTIPLIERS = {

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

@@ -2,15 +2,51 @@
 
 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`.
+// Agents know each other by name, not id. Exact matches win first so
+// `fullstack-1` never resolves to `fullstack-14`; only if nothing matches
+// exactly do we accept a single unambiguous partial, since agents routinely
+// half-remember a teammate's name. An ambiguous partial resolves to nothing
+// and the caller gets the candidate list instead of a wrong recipient.
 function resolveAgent(daemon, ref) {
   if (!ref || typeof ref !== 'string') return null;
   const all = daemon.registry.getAll();
-  return all.find((a) => a.id === ref)
+  const needle = ref.trim().toLowerCase();
+
+  const exact = all.find((a) => a.id === ref)
     || all.find((a) => a.name === ref)
-    || all.find((a) => a.name.toLowerCase() === ref.toLowerCase())
-    || null;
+    || all.find((a) => a.name.toLowerCase() === needle);
+  if (exact) return exact;
+
+  const partial = all.filter((a) => a.name.toLowerCase().includes(needle)
+    || needle.includes(a.name.toLowerCase()));
+  return partial.length === 1 ? partial[0] : null;
+}
+
+// Resolve the from/to pair from a request body, or write the appropriate
+// 400/404 and return null so the caller bails.
+function resolveParties(daemon, req, res) {
+  const { from, to, message } = req.body || {};
+
+  const fromAgent = resolveAgent(daemon, from);
+  if (!fromAgent) { res.status(404).json({ error: `Unknown calling agent: ${from}` }); return null; }
+
+  const toAgent = resolveAgent(daemon, to);
+  if (!toAgent) {
+    const others = daemon.registry.getAll().filter((a) => a.id !== fromAgent.id);
+    const needle = String(to || '').trim().toLowerCase();
+    const close = others.filter((a) => a.name.toLowerCase().includes(needle)).map((a) => a.name);
+    if (close.length > 1) {
+      res.status(404).json({ error: `"${to}" matches more than one agent — use the full name.`, didYouMean: close });
+    } else {
+      res.status(404).json({ error: `No agent named "${to}".`, availableAgents: others.map((a) => a.name) });
+    }
+    return null;
+  }
+
+  if (!message || typeof message !== 'string' || !message.trim()) {
+    res.status(400).json({ error: 'message is required' }); return null;
+  }
+  return { fromAgent, toAgent, message: message.trim() };
 }
 
 export function registerInnerChatRoutes(app, daemon) {
@@ -18,39 +54,25 @@ export function registerInnerChatRoutes(app, daemon) {
    * 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.
+   * it, and the response body is the other agent's reply. Best for tight
+   * interface negotiation, where the finite exchange budget keeps both sides
+   * writing decision-dense messages.
    */
   app.post('/api/innerchat/ask', async (req, res) => {
     try {
-      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' });
-      }
+      const parties = resolveParties(daemon, req, res);
+      if (!parties) return;
 
       // 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 });
+      const result = await daemon.innerchat.ask(parties.fromAgent.id, parties.toAgent.id, parties.message, {
+        timeoutMs: req.body?.timeoutMs,
+      });
 
       res.json({
-        from: toAgent.name,
+        from: parties.toAgent.name,
         reply: result.reply,
         threadId: result.threadId,
         exchangesUsed: result.exchanges,
@@ -63,6 +85,36 @@ export function registerInnerChatRoutes(app, daemon) {
     }
   });
 
+  /**
+   * Send a message WITHOUT blocking — returns as soon as it's delivered. If the
+   * target replies, the reply is routed back to the sender asynchronously
+   * (resuming it if its turn ended). Best for handing off to a heads-down agent
+   * where waiting out a timeout would waste the turn.
+   */
+  app.post('/api/innerchat/tell', async (req, res) => {
+    try {
+      const parties = resolveParties(daemon, req, res);
+      if (!parties) return;
+
+      const result = await daemon.innerchat.tell(parties.fromAgent.id, parties.toAgent.id, parties.message, {
+        threadId: req.body?.threadId,
+      });
+
+      res.json({
+        ok: true,
+        to: parties.toAgent.name,
+        delivered: result.delivered,
+        threadId: result.threadId,
+        exchangesUsed: result.exchanges,
+        exchangesRemaining: result.remaining,
+        maxExchanges: MAX_EXCHANGES,
+        note: `Message delivered. ${parties.toAgent.name}'s reply, if any, will be routed back to you — you can end your turn.`,
+      });
+    } catch (err) {
+      res.status(409).json({ error: err.message });
+    }
+  });
+
   app.get('/api/innerchat/threads', (req, res) => {
     const { agentId } = req.query;
     res.json({ threads: daemon.innerchat.getThreads(agentId || null) });

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

@@ -0,0 +1,42 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+// Agents identify themselves by name; resolve to the live record.
+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.trim().toLowerCase())
+    || null;
+}
+
+export function registerWatchRoutes(app, daemon) {
+  // Register a watch and return immediately — the agent's turn ends, and the
+  // wake comes later when the watched thing finishes. This does NOT block.
+  app.post('/api/watch', (req, res) => {
+    try {
+      const { agent, command, until, label, timeoutMs, intervalMs } = req.body || {};
+      const who = resolveAgent(daemon, agent);
+      if (!who) return res.status(404).json({ error: `Unknown agent: ${agent}` });
+
+      const watch = daemon.watcher.create(who.id, { command, until, label, timeoutMs, intervalMs });
+      res.json({
+        ok: true,
+        watchId: watch.id,
+        message: `Watching "${watch.label}". You'll be resumed with the result when it ${watch.mode === 'command' ? 'finishes' : 'condition is met'}. You can end your turn now.`,
+      });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/watch', (req, res) => {
+    res.json({ watches: daemon.watcher.list(req.query.agentId || null) });
+  });
+
+  app.delete('/api/watch/:id', (req, res) => {
+    const ok = daemon.watcher.cancel(req.params.id);
+    if (!ok) return res.status(404).json({ error: 'Watch not found' });
+    res.json({ ok: true });
+  });
+}