groove-dev 0.27.186 → 0.27.188

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

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

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

@@ -638,6 +638,12 @@ export class Daemon {
           }
         }
 
+        // Reconnect to watches whose detached jobs survived this restart, so a
+        // "notify me when the training finishes" watch still fires afterward.
+        try { this.watcher.restore(); } catch (err) {
+          console.error('[startup] Failed to restore watches:', err.message);
+        }
+
         // Restore auth token from stored config so subscription polling works after restart
         const storedToken = this.skills.getToken();
         if (storedToken) {

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

@@ -70,27 +70,48 @@ export function innerChatInstructions(port = 31415, agentName = 'YOUR_NAME') {
 export function watchInstructions(port = 31415, agentName = 'YOUR_NAME') {
   const nameHint = agentName === 'YOUR_NAME' ? ' ($GROOVE_AGENT_NAME)' : '';
   return [
-    '## Getting Notified When Something Finishes (Watch)',
+    '## Running Long Jobs & Getting Notified (Watch)',
     '',
-    'Your process ends when your turn ends, so a test suite or long job you kicked',
-    'off has nothing to notify you — telling the user "I\'ll report back when it lands"',
-    'does not work on its own; the session is gone. Instead, set a Watch. The daemon',
-    'outlives your turn and RESUMES you with the result when it finishes:',
+    '> **A job you start yourself dies when your turn ends.** Anything you launch in Bash —',
+    "> even backgrounded with `&`, `nohup`, or `disown` — is a child of your session process.",
+    '> When your turn ends or your context rotates, that process is torn down and the job dies',
+    '> with it. Do NOT start a long-running job (training, build, server, benchmark) directly',
+    "> in Bash and expect it to keep running. It won't.",
+    '',
+    'Instead, hand the command to a Watch. The DAEMON runs it fully detached — independent of',
+    'your turn, surviving turn-end, context rotation, and even a daemon restart — and RESUMES',
+    'you with the exit code and output when it finishes:',
     '',
     '```bash',
     `curl -s http://localhost:${port}/api/watch -X POST -H 'Content-Type: application/json' \\`,
-    `  -d '{"agent":"${agentName}","label":"test suite","command":"npm test"}'`,
+    `  -d '{"agent":"${agentName}","label":"model training","command":"python train.py"}'`,
     '```',
     '',
-    'This returns immediately with a `watchId`. **End your turn** — you will be woken',
-    'with the exit code and output tail when the command finishes.',
+    'This returns immediately with a `watchId`. **End your turn** — the job keeps running under',
+    'the daemon and you will be woken with the result when it completes.',
     '',
-    '- Prefer `command` (let the daemon run it) over launching it yourself — that way',
-    '  it captures the real exit code and output.',
-    '- For something ALREADY running, poll instead with `until` (fires when the check',
-    `  exits 0): \`-d '{"agent":"${agentName}","label":"server up","until":"curl -sf localhost:3000/health"}'\`.`,
+    '- Use `command` for anything that must outlive your turn. Let the daemon run it — do not',
+    '  launch it yourself and then watch it; a self-launched job is already doomed.',
+    '- Use `until` ONLY for something the daemon or another durable process is already running',
+    `  (not a Bash job you started): \`-d '{"agent":"${agentName}","label":"server up","until":"curl -sf localhost:3000/health"}'\`.`,
     `- \`agent\` must be your own name${nameHint}.`,
-    '- Watches time out (default 30 min). One clear task per watch; do not watch trivial commands you could just run.',
+    '- Watches time out (default 30 min, up to 24h — pass `timeoutMs` for long trainings).',
     '- Do not poll or sleep-loop waiting yourself — set the watch and end the turn. That is the whole point.',
   ];
 }
+
+// Log-path convention. The GUI turns log paths in a message into a one-click
+// "tail" button; a bare or relative filename can't be located reliably (there
+// may be several with the same name in different directories), so agents must
+// give the absolute path.
+export function logFileInstructions() {
+  return [
+    '## Mentioning Log Files',
+    '',
+    'When you start a process that writes to a log the user may want to watch, state the',
+    "log's ABSOLUTE path — e.g. `Logging to /home/you/project/runs/train.log` — not a bare",
+    'or relative filename. The GUI turns that path into a one-click "tail" button for the',
+    'user; a bare name like `train.log` cannot be located reliably (several files may share',
+    'it), so always resolve it to a full path first (`realpath` / `readlink -f` if unsure).',
+  ];
+}

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

@@ -4,7 +4,7 @@
 import { writeFileSync, readFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { resolve, dirname, basename } from 'path';
 import { escapeMd } from './validate.js';
-import { innerChatInstructions, watchInstructions } from './innerchat-docs.js';
+import { innerChatInstructions, watchInstructions, logFileInstructions } from './innerchat-docs.js';
 
 const GROOVE_SECTION_START = '<!-- GROOVE:START -->';
 const GROOVE_SECTION_END = '<!-- GROOVE:END -->';
@@ -561,7 +561,7 @@ export class Introducer {
   // compaction — the spawn prompt alone can scroll out of a long session.
   _innerChatSection() {
     const port = this.daemon.port || 31415;
-    return [...innerChatInstructions(port), '', ...watchInstructions(port)];
+    return [...innerChatInstructions(port), '', ...watchInstructions(port), '', ...logFileInstructions()];
   }
 
   writeRegistryFile(projectDir) {

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, watchInstructions } from './innerchat-docs.js';
+import { innerChatInstructions, watchInstructions, logFileInstructions } from './innerchat-docs.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SLIDES_ENGINE_SRC = resolve(__dirname, '../templates/groove-slides.cjs');
@@ -1174,6 +1174,8 @@ For normal file edits within your scope, proceed without review.
         ...innerChatInstructions(port, agent.name),
         '',
         ...watchInstructions(port, agent.name),
+        '',
+        ...logFileInstructions(),
       ].join('\n') + '\n\n';
       if (spawnConfig.prompt.startsWith('# Handoff Brief')) {
         spawnConfig.prompt += '\n\n' + capabilities.trim();
@@ -2626,6 +2628,9 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
     // Let the aborted process finish tearing down before re-spawning; resume()
     // kills the current handle and re-registers under a new agent id.
     setTimeout(() => {
+      // The user may have paused/killed during this 500ms window — stop()/kill()
+      // clear the pending message to cancel exactly this in-flight retry.
+      if (!this._pendingUserMessage.has(agentId)) return;
       this.resume(agentId, pending.message).catch((err) => {
         this.daemon.broadcast({
           type: 'agent:output',
@@ -3058,6 +3063,13 @@ After fixing all issues, run tests (npm test) and build (npm run build) to verif
     const handle = this.handles.get(agentId);
     if (!handle) return;
 
+    // A user pause aborts the current turn, which the CLI reports as a dropped
+    // turn (isError, apiDurationMs === 0). Clear the pending message FIRST so
+    // _retryDroppedTurn no-ops — otherwise the stop is auto-retried and the
+    // agent resumes, forcing the user to click Pause twice.
+    this._pendingUserMessage.delete(agentId);
+    this._retryAttemptCarry.delete(agentId);
+
     const { proc, loop } = handle;
 
     if (loop) {

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

@@ -230,6 +230,21 @@ export class Teams {
           originalWorkingDir: team.workingDir,
         };
         writeFileSync(resolve(archivePath, 'metadata.json'), JSON.stringify(metadata, null, 2));
+      } else if (
+        team.workingDir &&
+        team.workingDir !== this.daemon.projectDir &&
+        existsSync(team.workingDir) &&
+        this._dirHasExternalOccupants(team.workingDir)
+      ) {
+        // A moved agent still lives here — archive metadata only, leave the
+        // directory in place so that agent keeps working.
+        console.log(`[Groove:Teams] Archiving ${team.name} metadata only: agents from other teams still use its directory`);
+        mkdirSync(archivePath, { recursive: true });
+        writeFileSync(resolve(archivePath, 'metadata.json'), JSON.stringify({
+          originalName: team.name, originalId: team.id, mode: team.mode || 'sandbox',
+          deletedAt: new Date().toISOString(), agentCount: agents.length,
+          originalWorkingDir: team.workingDir, directoryRetained: true,
+        }, null, 2));
       } else if (
         team.workingDir &&
         team.workingDir !== this.daemon.projectDir &&
@@ -281,10 +296,16 @@ export class Teams {
       team.workingDir !== this.daemon.projectDir &&
       existsSync(team.workingDir)
     ) {
-      try {
-        rmSync(team.workingDir, { recursive: true, force: true });
-      } catch (err) {
-        console.log(`[Groove:Teams] Failed to delete directory: ${err.message}`);
+      if (this._dirHasExternalOccupants(team.workingDir)) {
+        // An agent moved to another team still lives here — keep the directory
+        // so it doesn't lose its working dir. The team record is still removed.
+        console.log(`[Groove:Teams] Keeping ${team.workingDir}: agents from other teams still use it`);
+      } else {
+        try {
+          rmSync(team.workingDir, { recursive: true, force: true });
+        } catch (err) {
+          console.log(`[Groove:Teams] Failed to delete directory: ${err.message}`);
+        }
       }
     }
 
@@ -292,6 +313,17 @@ export class Teams {
     return true;
   }
 
+  // True if an agent OUTSIDE this team still lives in the given directory —
+  // i.e. an agent that was moved to another team but kept its working dir here.
+  // Destroying the directory would break it, so callers skip the removal.
+  // Call after _killAndRemoveAgents so this team's own agents are already gone.
+  _dirHasExternalOccupants(dir) {
+    if (!dir) return false;
+    const prefix = `${dir}/`;
+    return this.daemon.registry.getAll().some((a) =>
+      a.workingDir && (a.workingDir === dir || a.workingDir.startsWith(prefix)));
+  }
+
   _killAndRemoveAgents(teamId) {
     const agents = this.daemon.registry.getAll().filter((a) => a.teamId === teamId);
     for (const agent of agents) {