groove-dev 0.27.185 → 0.27.186

package/node_modules/@groove-dev/gui/dist/index.html

@@ -6,7 +6,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link rel="icon" type="image/png" href="/favicon.png" />
     <title>Groove GUI</title>
-    <script type="module" crossorigin src="/assets/index-DEZwM4Hb.js"></script>
+    <script type="module" crossorigin src="/assets/index-DOOaCFRS.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-26L3JoZv.js">
     <link rel="modulepreload" crossorigin href="/assets/reactflow-DoBZjiHE.js">
     <link rel="modulepreload" crossorigin href="/assets/codemirror-BYKpdS2W.js">

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

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

package/node_modules/@groove-dev/gui/src/components/agents/agent-feed.jsx

@@ -12,6 +12,7 @@ import { useGrooveStore } from '../../stores/groove';
 import { cn } from '../../lib/cn';
 import { timeAgo } from '../../lib/format';
 import { api } from '../../lib/api';
+import { extractLogPaths, logLabel } from '../../lib/logpaths';
 import { ThinkingIndicator } from '../ui/thinking-indicator';
 import { TableTree } from '../ui/table-tree';
 
@@ -346,8 +347,14 @@ function UserMessage({ msg }) {
 function InnerChatMessage({ msg, agent }) {
   const [collapsed, setCollapsed] = useState(msg.text?.length > 400);
   const isLong = msg.text?.length > 400;
-  const { peer, direction, kind } = msg.innerchat || {};
-  const outbound = direction === 'out';
+  const info = msg.innerchat || {};
+  // `peer` is the current field; `fromAgent` is the pre-`tell` schema still
+  // sitting in persisted chatHistory. Fall back so old bubbles never render
+  // "undefined".
+  const peer = info.peer || info.fromAgent;
+  const peerName = peer?.name || 'another agent';
+  const outbound = info.direction === 'out';
+  const isAnswer = info.kind === 'answer' || info.kind === 'reply';
   const me = agent?.name || 'this agent';
 
   return (
@@ -356,10 +363,10 @@ function InnerChatMessage({ msg, agent }) {
         <ArrowLeftRight size={10} className="text-indigo flex-shrink-0" />
         <span className="text-2xs font-semibold text-indigo font-sans">InnerChat</span>
         <span className="text-2xs text-text-3 font-sans truncate">
-          {outbound ? `${me} → ${peer?.name}` : `${peer?.name} → ${me}`}
+          {outbound ? `${me} → ${peerName}` : `${peerName} → ${me}`}
         </span>
         <span className="text-2xs text-text-4 font-sans">
-          {kind === 'answer' ? 'answer' : outbound ? 'asked' : 'asks'}
+          {isAnswer ? 'answer' : outbound ? 'asked' : 'asks'}
         </span>
         <span className="text-[10px] text-text-4 font-sans ml-auto flex-shrink-0">{timeAgo(msg.timestamp)}</span>
       </div>
@@ -378,6 +385,30 @@ function InnerChatMessage({ msg, agent }) {
   );
 }
 
+// One-click "tail" chips for any log paths the agent mentioned — saves asking
+// "what's the log file?" and hand-copying it into a terminal.
+function LogChips({ text }) {
+  const runInTerminal = useGrooveStore((s) => s.runInTerminal);
+  const paths = useMemo(() => extractLogPaths(text), [text]);
+  if (paths.length === 0) return null;
+
+  return (
+    <div className="ml-3.5 mt-1.5 flex flex-wrap gap-1.5">
+      {paths.map((path) => (
+        <button
+          key={path}
+          onClick={() => runInTerminal(`tail -f ${path}`)}
+          title={`tail -f ${path}`}
+          className="inline-flex items-center gap-1.5 px-2 py-0.5 rounded-md bg-accent/10 hover:bg-accent/20 text-accent text-[11px] font-medium font-sans cursor-pointer transition-colors max-w-full"
+        >
+          <Terminal size={11} className="flex-shrink-0" />
+          <span className="truncate">tail {logLabel(path)}</span>
+        </button>
+      ))}
+    </div>
+  );
+}
+
 function AgentMessage({ msg, agent, answeredTo }) {
   const [collapsed, setCollapsed] = useState(msg.text?.length > 600);
   const isLong = msg.text?.length > 600;
@@ -399,6 +430,7 @@ function AgentMessage({ msg, agent, answeredTo }) {
       <div className={cn('pl-3.5 py-1 border-l', answeredTo ? 'border-indigo/50' : 'border-accent')}>
         <StructuredMessage text={collapsed ? msg.text.slice(0, 600) + '...' : msg.text} />
       </div>
+      <LogChips text={msg.text} />
       {collapsed && (
         <button
           onClick={() => setCollapsed(false)}

package/node_modules/@groove-dev/gui/src/components/editor/terminal.jsx

@@ -31,6 +31,7 @@ function TerminalInstance({ tabId, visible, registerKill, onSelectionChange }) {
   const mountedRef = useRef(false);
   const visibleRef = useRef(visible);
   const lastSizeRef = useRef({ cols: 0, rows: 0 });
+  const outputReadyRef = useRef(false);
 
   useEffect(() => {
     registerKill?.(tabId, () => {
@@ -41,6 +42,28 @@ function TerminalInstance({ tabId, visible, registerKill, onSelectionChange }) {
     });
   }, [tabId, registerKill]);
 
+  // Run a command dropped into the store by another component (e.g. a "tail
+  // log" chip in chat). Only the visible tab handles it, and we poll until this
+  // instance's PTY is ready — a freshly opened terminal spawns asynchronously,
+  // and keystrokes sent before it's ready are dropped.
+  const pendingCommand = useGrooveStore((s) => s.terminalPendingCommand);
+  useEffect(() => {
+    if (!pendingCommand || !visible) return;
+    let tries = 0;
+    let timer = null;
+    const send = () => {
+      const ws = useGrooveStore.getState().ws;
+      if (ws?.readyState === WebSocket.OPEN && termIdRef.current && outputReadyRef.current) {
+        ws.send(JSON.stringify({ type: 'terminal:input', id: termIdRef.current, data: pendingCommand.command + '\r' }));
+        useGrooveStore.getState().clearTerminalPendingCommand();
+        return;
+      }
+      if (tries++ < 40) timer = setTimeout(send, 150); // ~6s max, covers spawn
+    };
+    send();
+    return () => clearTimeout(timer);
+  }, [pendingCommand, visible]);
+
   useEffect(() => {
     if (!containerRef.current || mountedRef.current) return;
     mountedRef.current = true;
@@ -111,6 +134,7 @@ function TerminalInstance({ tabId, visible, registerKill, onSelectionChange }) {
             // Wipe xterm so garbled output from wrong-sized PTY is never visible
             term.reset();
             outputReady = true;
+            outputReadyRef.current = true;
             // Ask the shell to clear screen and redraw its prompt
             const w2 = useGrooveStore.getState().ws;
             if (w2?.readyState === WebSocket.OPEN && termIdRef.current) {
@@ -121,6 +145,7 @@ function TerminalInstance({ tabId, visible, registerKill, onSelectionChange }) {
           if (outputReady) term.write(msg.data);
         } else if (msg.type === 'terminal:exit' && msg.id === termIdRef.current) {
           outputReady = true;
+          outputReadyRef.current = false; // no live shell to accept commands
           term.write('\r\n\x1b[90m[session ended]\x1b[0m\r\n');
           termIdRef.current = null;
         }

package/node_modules/@groove-dev/gui/src/lib/logpaths.js

@@ -0,0 +1,45 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+// Pull tailable log targets out of an agent's message so the chat can offer a
+// one-click "tail" instead of the user asking "what's the log file?".
+//
+// Two signals, in priority order:
+//   1. An explicit `tail -f <path>` the agent already wrote — highest confidence.
+//   2. Any path-like token ending in .log.
+// Both are conservative: a bare word like "changelog" is not a path and won't
+// match, and results are de-duped by full path.
+
+const TAIL_RE = /tail\s+(?:-[a-zA-Z]+\s+)*([~/]?[\w./-]+)/g;
+const DOTLOG_RE = /(?:^|[\s'"`(=])([~/]?(?:[\w.-]+\/)*[\w.-]+\.log)\b/g;
+
+function clean(p) {
+  return p.replace(/^['"`]+/, '').replace(/['"`.,;:)]+$/, '');
+}
+
+export function extractLogPaths(text) {
+  if (!text || typeof text !== 'string') return [];
+  const out = [];
+  const seen = new Set();
+
+  const add = (raw) => {
+    const p = clean(raw);
+    // Require something path-shaped: a slash, a ~, or a .log extension. Guards
+    // against picking up plain words that followed "tail".
+    if (!p || p.length < 3) return;
+    if (!p.endsWith('.log') && !p.includes('/') && !p.startsWith('~')) return;
+    if (seen.has(p)) return;
+    seen.add(p);
+    out.push(p);
+  };
+
+  for (const m of text.matchAll(TAIL_RE)) add(m[1]);
+  for (const m of text.matchAll(DOTLOG_RE)) add(m[1]);
+
+  return out;
+}
+
+// A short label for the chip — the basename, which is what the user recognizes.
+export function logLabel(path) {
+  const base = path.replace(/\/+$/, '').split('/').pop() || path;
+  return base.length > 28 ? `…${base.slice(-27)}` : base;
+}

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

@@ -106,6 +106,17 @@ export const createUiSlice = (set, get) => ({
     set(updates);
     localStorage.setItem('groove:terminalVisible', String(v));
   },
+
+  // Cross-component channel for running a command in the terminal panel. The
+  // terminal id lives inside the active TerminalInstance, so components can't
+  // send to it directly — they drop a command here, the visible instance picks
+  // it up (waiting for its PTY to be ready) and clears it.
+  terminalPendingCommand: null,
+  runInTerminal(command) {
+    get().setTerminalVisible(true);
+    set({ terminalPendingCommand: { command, ts: Date.now() } });
+  },
+  clearTerminalPendingCommand() { set({ terminalPendingCommand: null }); },
   setTerminalHeight(h) {
     set({ terminalHeight: h });
     localStorage.setItem('groove:terminalHeight', String(h));

package/package.json

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

package/packages/daemon/src/api.js

@@ -1441,6 +1441,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
       'qcThreshold', 'maxAgents', 'defaultProvider', 'defaultWorkingDir',
       'onboardingDismissed', 'defaultModel', 'defaultChatProvider', 'defaultChatModel',
       'dataSharingDismissed', 'replayCeiling', 'velocityCeiling', 'journalistModelTier',
+      'resumeBudgetChars',
     ];
     for (const key of Object.keys(req.body)) {
       if (!ALLOWED_KEYS.includes(key)) {

package/packages/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/packages/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 = {