groove-dev 0.27.106 → 0.27.108

package/moe-training/client/envelope-builder.js

@@ -31,12 +31,17 @@ export class EnvelopeBuilder {
     return this._buildEnvelope();
   }
 
+  updateMetadata(updates) {
+    Object.assign(this._metadata, updates);
+  }
+
   buildSessionClose(outcome) {
     return {
       envelope_id: `env_${randomUUID()}`,
       session_id: this._sessionId,
       type: 'SESSION_CLOSE',
       attestation: { session_hmac: '', sequence: 0, app_version_hash: '' },
+      metadata: { ...this._metadata },
       outcome,
     };
   }

package/moe-training/client/scrubber.js

@@ -65,7 +65,7 @@ export class PIIScrubber {
       },
       {
         name: 'ipv6',
-        regex: /(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|::(?:[fF]{4}:)?(?:\d{1,3}\.){3}\d{1,3}|::1?\b/g,
+        regex: /(?<![\w.#-])(?:(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|::(?:[fF]{4}:)?(?:\d{1,3}\.){3}\d{1,3}|::1\b)/g,
         replacement: '[IP]',
       },
       {
@@ -100,7 +100,7 @@ export class PIIScrubber {
       },
       {
         name: 'base64_secret',
-        regex: /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{40,}={0,2}(?![A-Za-z0-9+/])/g,
+        regex: /(?<![A-Za-z0-9+])[A-Za-z0-9+]{40,}={0,2}(?![A-Za-z0-9+])/g,
         replacement: '[API_KEY]',
       },
     ];

package/moe-training/client/step-classifier.js

@@ -3,23 +3,39 @@
 const ERROR_SIGNAL_RE = /\b(?:error|Error|ERROR|exception|Exception|EXCEPTION|failed|FAILED|exit code [1-9]|ENOENT|EACCES|EPERM|TypeError|ReferenceError|SyntaxError|Cannot find|Module not found|Command failed|non-zero exit)\b/;
 const FIX_SIGNAL_RE = /\b(?:fix|correcting|I see the issue|let me fix|the (?:issue|problem|bug) (?:is|was)|instead I should|my mistake)\b/i;
 
+const CORRECTION_RE = /\b(?:no[,. ](?:that|not|don't|wrong)|that'?s (?:not|wrong|incorrect)|don'?t do that|stop (?:doing|that)|instead (?:of|do)|undo|revert|go back|try (?:again|differently)|you (?:broke|missed|forgot))\b/i;
+const APPROVAL_RE = /\b(?:looks? good|lgtm|approved?|go ahead|ship it|that'?s (?:right|correct|perfect)|perfect|exactly right|nice work|well done|great job)\b/i;
+const CLARIFICATION_RE = /\b(?:what (?:about|I (?:mean|want))|I meant|to (?:be clear|clarify)|let me (?:rephrase|explain)|clarif(?:y|ication)|more specifically)\b/i;
+
 export class StepClassifier {
   constructor() {
     this.hasAgentActed = false;
     this._lastStepType = null;
   }
 
-  classifyUserMessage(text) {
+  classifyUserMessage(text, source = 'user') {
     if (!this.hasAgentActed) {
-      return null;
+      return {
+        type: 'instruction',
+        content: text,
+        source,
+      };
     }
     return {
-      type: 'correction',
+      type: StepClassifier.classifyIntent(text),
       content: text,
-      source: 'user',
+      source,
     };
   }
 
+  static classifyIntent(text) {
+    if (!text || typeof text !== 'string') return 'instruction';
+    if (CORRECTION_RE.test(text)) return 'correction';
+    if (APPROVAL_RE.test(text)) return 'approval';
+    if (CLARIFICATION_RE.test(text)) return 'clarification';
+    return 'instruction';
+  }
+
   classifyCoordinationEvent(event) {
     return {
       type: 'coordination',
@@ -42,7 +58,7 @@ export class StepClassifier {
       step.type = 'error';
     }
 
-    if (step.type === 'thought' && this._lastStepType === 'correction' && FIX_SIGNAL_RE.test(content)) {
+    if (step.type === 'thought' && (this._lastStepType === 'correction' || this._lastStepType === 'instruction') && FIX_SIGNAL_RE.test(content)) {
       step.correction_context = true;
     }
 
@@ -63,6 +79,6 @@ export class StepClassifier {
   }
 
   static countUserInterventions(steps) {
-    return steps.filter((s) => s.type === 'correction').length;
+    return steps.filter((s) => s.type === 'correction' || s.type === 'clarification').length;
   }
 }

package/moe-training/client/trajectory-capture.js

@@ -18,6 +18,7 @@ import {
   TRAINING_MIN_TOKENS,
   TRAINING_MIN_DURATION,
   TRAINING_EXCLUSION_REASONS,
+  USER_MESSAGE_MAX_CHARS,
 } from '../shared/constants.js';
 
 const OFFLINE_RETRY_INTERVAL_MS = 60_000;
@@ -131,15 +132,20 @@ export class TrajectoryCapture {
 
   }
 
-  onUserMessage(agentId, text) {
+  onUserMessage(agentId, text, source = 'user') {
     if (!this._enabled) return;
     const ctx = this._contexts.get(agentId);
     if (!ctx) return;
 
-    ctx.revisionRounds++;
+    const capped = (typeof text === 'string' && text.length > USER_MESSAGE_MAX_CHARS)
+      ? text.slice(0, USER_MESSAGE_MAX_CHARS)
+      : text;
 
-    const classified = ctx.classifier.classifyUserMessage(text);
-    if (!classified) return;
+    const classified = ctx.classifier.classifyUserMessage(capped, source);
+
+    if (classified.type === 'correction' || classified.type === 'clarification') {
+      ctx.revisionRounds++;
+    }
 
     this._processStep(agentId, ctx, classified);
   }
@@ -301,6 +307,11 @@ export class TrajectoryCapture {
     const { tier, reason: tierReason } = this._computeQualityTier(ctx, status, userInterventions);
     const { eligible, exclusionReason } = this._computeTrainingEligibility(ctx, durationSeconds);
 
+    ctx.builder.updateMetadata({
+      domain_tags: ctx.metadata.domain_tags,
+      session_quality: ctx.metadata.session_quality,
+    });
+
     const closeEnvelope = ctx.builder.buildSessionClose({
       status,
       session_quality: ctx.metadata.session_quality,

package/moe-training/shared/constants.js

@@ -36,4 +36,6 @@ export const TRAINING_MIN_TOKENS = 500;
 export const TRAINING_MIN_DURATION = 10;
 export const TRAINING_EXCLUSION_REASONS = ['too_few_steps', 'no_actions', 'no_observations', 'insufficient_tokens', 'too_short'];
 
+export const USER_MESSAGE_MAX_CHARS = 2000;
+
 export const CENTRAL_COMMAND_URL = process.env.GROOVE_CENTRAL_URL || 'https://api.groovedev.ai';

package/moe-training/shared/envelope-schema.js

@@ -2,7 +2,7 @@
 
 import { SUPPORTED_PROVIDERS, MODEL_TIERS, TRAINING_EXCLUSION_REASONS } from './constants.js';
 
-export const STEP_TYPES = ['thought', 'action', 'observation', 'correction', 'resolution', 'error', 'coordination', 'edit'];
+export const STEP_TYPES = ['thought', 'action', 'observation', 'correction', 'resolution', 'error', 'coordination', 'edit', 'instruction', 'clarification', 'approval'];
 const VALID_QUALITY_TIERS = ['TIER_A', 'TIER_B', 'TIER_C'];
 const VALID_FEEDBACK_SIGNALS = ['accepted', 'modified', 'rejected', 'iterated'];
 

package/moe-training/test/client/envelope-builder.test.js

@@ -117,6 +117,38 @@ describe('EnvelopeBuilder', () => {
     assert.equal(close.outcome.training_exclusion_reason, null);
   });
 
+  it('updateMetadata syncs late-computed fields to builder', () => {
+    const builder = new EnvelopeBuilder('sess_1', 'user_1', metadata);
+    const domainTags = {
+      primary: { domain: 'react_frontend', confidence: 0.3 },
+      secondary: { domain: 'typescript_node', confidence: 0.25 },
+      tertiary: { domain: 'python', confidence: 0 },
+    };
+    builder.updateMetadata({ domain_tags: domainTags, session_quality: 85 });
+
+    builder.addStep({ step: 1, type: 'thought', timestamp: 123 });
+    const envelope = builder.flush();
+    assert.deepEqual(envelope.metadata.domain_tags, domainTags);
+    assert.equal(envelope.metadata.session_quality, 85);
+  });
+
+  it('SESSION_CLOSE includes metadata with domain_tags', () => {
+    const builder = new EnvelopeBuilder('sess_1', 'user_1', metadata);
+    const domainTags = {
+      primary: { domain: 'react_frontend', confidence: 0.3 },
+      secondary: { domain: 'typescript_node', confidence: 0.25 },
+      tertiary: { domain: 'python', confidence: 0 },
+    };
+    builder.updateMetadata({ domain_tags: domainTags });
+
+    const close = builder.buildSessionClose({
+      status: 'SUCCESS', total_steps: 10, total_chunks: 1,
+    });
+    assert.ok(close.metadata, 'SESSION_CLOSE must include metadata');
+    assert.deepEqual(close.metadata.domain_tags, domainTags);
+    assert.equal(close.metadata.agent_role, 'backend');
+  });
+
   it('chunk sequence increments correctly', () => {
     const builder = new EnvelopeBuilder('sess_1', 'user_1', metadata);
     let first = null;

package/moe-training/test/client/scrubber.test.js

@@ -131,6 +131,43 @@ describe('PIIScrubber', () => {
     assert.equal(scrubber.scrub(input), 'cd ~');
   });
 
+  it('does not scrub CSS pseudo-elements as IPv6', () => {
+    const input = '.hero-icon::before { content: ""; }';
+    assert.equal(scrubber.scrub(input), input);
+  });
+
+  it('does not scrub CSS pseudo-elements with hex-like class names', () => {
+    assert.equal(scrubber.scrub('.page::before { content: ""; }'), '.page::before { content: ""; }');
+    assert.equal(scrubber.scrub('.page::-webkit-scrollbar { width: 8px; }'), '.page::-webkit-scrollbar { width: 8px; }');
+    assert.equal(scrubber.scrub('.cafe::after { display: block; }'), '.cafe::after { display: block; }');
+    assert.equal(scrubber.scrub('::placeholder { color: gray; }'), '::placeholder { color: gray; }');
+  });
+
+  it('still scrubs IPv6 loopback ::1', () => {
+    const input = 'listening on ::1 port 3000';
+    assert.equal(scrubber.scrub(input), 'listening on [IP] port 3000');
+  });
+
+  it('scrubs compressed IPv6 addresses completely', () => {
+    assert.equal(scrubber.scrub('addr fe80::1 here'), 'addr [IP] here');
+    assert.equal(scrubber.scrub('addr fe80:: here'), 'addr [IP] here');
+    assert.equal(scrubber.scrub('addr 2001:db8::1 here'), 'addr [IP] here');
+  });
+
+  it('does not scrub file paths as base64 secrets', () => {
+    const input = '/home/user/project/groove/packages/gui/src/views/settings.jsx';
+    const result = scrubber.scrub(input);
+    assert.ok(!result.includes('[API_KEY]'), `expected no [API_KEY] in: ${result}`);
+  });
+
+  it('still scrubs real base64 secrets without slashes', () => {
+    const b64 = 'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODk';
+    const input = `key: ${b64} end`;
+    const result = scrubber.scrub(input);
+    assert.ok(result.includes('[API_KEY]'), `expected [API_KEY] in: ${result}`);
+    assert.ok(!result.includes(b64));
+  });
+
   it('patterns do not interfere with each other', () => {
     const input = 'user@example.com called 555-123-4567 from 192.168.1.1';
     const result = scrubber.scrub(input);

package/moe-training/test/client/step-classifier.test.js

@@ -5,18 +5,54 @@ import assert from 'node:assert/strict';
 import { StepClassifier } from '../../client/step-classifier.js';
 
 describe('StepClassifier', () => {
-  it('user message before any action is not a correction', () => {
+  it('user message before any action is classified as instruction', () => {
     const classifier = new StepClassifier();
     const result = classifier.classifyUserMessage('fix the bug');
-    assert.equal(result, null);
+    assert.equal(result.type, 'instruction');
+    assert.equal(result.content, 'fix the bug');
+    assert.equal(result.source, 'user');
   });
 
-  it('user message after action is a correction', () => {
+  it('user correction after action is classified as correction', () => {
     const classifier = new StepClassifier();
     classifier.onStep({ type: 'action' });
-    const result = classifier.classifyUserMessage('no, use exponential backoff');
+    const result = classifier.classifyUserMessage('no, that\'s wrong, use exponential backoff');
     assert.equal(result.type, 'correction');
-    assert.equal(result.content, 'no, use exponential backoff');
+    assert.equal(result.content, 'no, that\'s wrong, use exponential backoff');
+    assert.equal(result.source, 'user');
+  });
+
+  it('user approval after action is classified as approval', () => {
+    const classifier = new StepClassifier();
+    classifier.onStep({ type: 'action' });
+    const result = classifier.classifyUserMessage('looks good, ship it');
+    assert.equal(result.type, 'approval');
+  });
+
+  it('user clarification after action is classified as clarification', () => {
+    const classifier = new StepClassifier();
+    classifier.onStep({ type: 'action' });
+    const result = classifier.classifyUserMessage('to clarify, I meant the sidebar component');
+    assert.equal(result.type, 'clarification');
+  });
+
+  it('new instruction after action defaults to instruction', () => {
+    const classifier = new StepClassifier();
+    classifier.onStep({ type: 'action' });
+    const result = classifier.classifyUserMessage('now add pagination to the list view');
+    assert.equal(result.type, 'instruction');
+  });
+
+  it('passes source through from caller', () => {
+    const classifier = new StepClassifier();
+    const result = classifier.classifyUserMessage('deploy the backend', 'planner');
+    assert.equal(result.source, 'planner');
+    assert.equal(result.type, 'instruction');
+  });
+
+  it('defaults source to user', () => {
+    const classifier = new StepClassifier();
+    const result = classifier.classifyUserMessage('do the thing');
     assert.equal(result.source, 'user');
   });
 
@@ -66,17 +102,27 @@ describe('StepClassifier', () => {
     assert.equal(StepClassifier.detectErrorRecovery(steps), false);
   });
 
-  it('counts user interventions', () => {
+  it('counts corrections and clarifications as interventions', () => {
     const steps = [
       { type: 'thought' },
       { type: 'correction' },
       { type: 'action' },
-      { type: 'correction' },
+      { type: 'clarification' },
       { type: 'resolution' },
     ];
     assert.equal(StepClassifier.countUserInterventions(steps), 2);
   });
 
+  it('does not count instruction or approval as interventions', () => {
+    const steps = [
+      { type: 'instruction' },
+      { type: 'action' },
+      { type: 'approval' },
+      { type: 'resolution' },
+    ];
+    assert.equal(StepClassifier.countUserInterventions(steps), 0);
+  });
+
   it('counts zero interventions when none present', () => {
     const steps = [
       { type: 'thought' },
@@ -117,6 +163,14 @@ describe('StepClassifier', () => {
     assert.equal(result.correction_context, true);
   });
 
+  it('marks thought after instruction as correction_context when fix signal present', () => {
+    const classifier = new StepClassifier();
+    classifier.onStep({ type: 'instruction', content: 'fix the login page' });
+    const step = { type: 'thought', content: 'I see the issue, let me fix the validation' };
+    const result = classifier.onStep(step);
+    assert.equal(result.correction_context, true);
+  });
+
   it('does not mark thought as correction_context without prior correction', () => {
     const classifier = new StepClassifier();
     classifier.onStep({ type: 'action', content: 'running test' });
@@ -175,3 +229,38 @@ describe('StepClassifier', () => {
     assert.equal(result.type, 'error');
   });
 });
+
+describe('StepClassifier.classifyIntent', () => {
+  it('classifies corrections', () => {
+    assert.equal(StepClassifier.classifyIntent("no, that's wrong"), 'correction');
+    assert.equal(StepClassifier.classifyIntent("that's not what I wanted"), 'correction');
+    assert.equal(StepClassifier.classifyIntent('undo that change'), 'correction');
+    assert.equal(StepClassifier.classifyIntent('revert the last edit'), 'correction');
+    assert.equal(StepClassifier.classifyIntent('you missed the edge case'), 'correction');
+  });
+
+  it('classifies approvals', () => {
+    assert.equal(StepClassifier.classifyIntent('looks good'), 'approval');
+    assert.equal(StepClassifier.classifyIntent('lgtm, ship it'), 'approval');
+    assert.equal(StepClassifier.classifyIntent("that's correct"), 'approval');
+    assert.equal(StepClassifier.classifyIntent('go ahead with that approach'), 'approval');
+  });
+
+  it('classifies clarifications', () => {
+    assert.equal(StepClassifier.classifyIntent('to clarify, I meant the sidebar'), 'clarification');
+    assert.equal(StepClassifier.classifyIntent('what I want is the mobile layout'), 'clarification');
+    assert.equal(StepClassifier.classifyIntent('let me rephrase — update the header'), 'clarification');
+  });
+
+  it('defaults to instruction for new directions', () => {
+    assert.equal(StepClassifier.classifyIntent('now add pagination to the list'), 'instruction');
+    assert.equal(StepClassifier.classifyIntent('also update the README'), 'instruction');
+    assert.equal(StepClassifier.classifyIntent('can you refactor the auth module'), 'instruction');
+  });
+
+  it('returns instruction for null/empty input', () => {
+    assert.equal(StepClassifier.classifyIntent(null), 'instruction');
+    assert.equal(StepClassifier.classifyIntent(''), 'instruction');
+    assert.equal(StepClassifier.classifyIntent(undefined), 'instruction');
+  });
+});

package/moe-training/test/client/trajectory-capture.test.js

@@ -29,12 +29,17 @@ function makeCtx(overrides = {}) {
       session_quality: overrides.quality ?? 80,
     },
     builder: {
-      buildSessionClose: (outcome) => ({
-        envelope_id: 'env_test_close',
-        session_id: 'sess_test_1',
-        type: 'SESSION_CLOSE',
-        outcome,
-      }),
+      _metadata: {},
+      updateMetadata(updates) { Object.assign(this._metadata, updates); },
+      buildSessionClose: function (outcome) {
+        return {
+          envelope_id: 'env_test_close',
+          session_id: 'sess_test_1',
+          type: 'SESSION_CLOSE',
+          metadata: { ...this._metadata },
+          outcome,
+        };
+      },
     },
   };
 }
@@ -439,6 +444,48 @@ describe('TrajectoryCapture — _computeQuality', () => {
   });
 });
 
+describe('TrajectoryCapture — domain_tags in SESSION_CLOSE', () => {
+  it('domain_tags set on ctx.metadata flow into SESSION_CLOSE via updateMetadata', () => {
+    const tc = makeTc();
+    const captured = [];
+    tc._signAndTransmit = (_sid, envelope) => { captured.push(envelope); };
+
+    const ctx = makeCtx();
+    ctx.metadata.domain_tags = {
+      primary: { domain: 'react_frontend', confidence: 0.3 },
+      secondary: { domain: 'typescript_node', confidence: 0.25 },
+      tertiary: { domain: 'python', confidence: 0 },
+    };
+
+    ctx.builder.updateMetadata({
+      domain_tags: ctx.metadata.domain_tags,
+      session_quality: ctx.metadata.session_quality,
+    });
+    const close = ctx.builder.buildSessionClose({
+      status: 'SUCCESS', total_steps: 10, total_chunks: 1,
+    });
+
+    assert.ok(close.metadata, 'SESSION_CLOSE must have metadata');
+    assert.deepEqual(close.metadata.domain_tags, ctx.metadata.domain_tags);
+  });
+
+  it('SESSION_CLOSE metadata is absent domain_tags when tagger returns null', () => {
+    const ctx = makeCtx();
+    ctx.metadata.domain_tags = null;
+
+    ctx.builder.updateMetadata({
+      domain_tags: null,
+      session_quality: ctx.metadata.session_quality,
+    });
+    const close = ctx.builder.buildSessionClose({
+      status: 'SUCCESS', total_steps: 5, total_chunks: 1,
+    });
+
+    assert.ok(close.metadata, 'SESSION_CLOSE must have metadata');
+    assert.equal(close.metadata.domain_tags, null);
+  });
+});
+
 describe('TrajectoryCapture — onParsedOutput', () => {
   function makeEnabledTc() {
     const tc = makeTc();

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

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

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

@@ -62,12 +62,12 @@ async function _executeApprovalRetry(daemon, approval) {
       return;
     }
     if (rp.agentId) {
-      await daemon.processes.sendMessage(rp.agentId, `Your ${rp.type === 'integration_exec' ? 'integration action' : 'upload'} was approved and executed successfully. Result: ${resultText}`);
+      await daemon.processes.sendMessage(rp.agentId, `Your ${rp.type === 'integration_exec' ? 'integration action' : 'upload'} was approved and executed successfully. Result: ${resultText}`, 'system');
     }
   } catch (err) {
     console.log(`[Groove] Auto-retry for approval ${approval.id} failed: ${err.message}`);
     if (rp.agentId) {
-      daemon.processes.sendMessage(rp.agentId, `Your ${rp.type === 'integration_exec' ? 'integration action' : 'upload'} was approved but execution failed: ${err.message}`).catch(() => {});
+      daemon.processes.sendMessage(rp.agentId, `Your ${rp.type === 'integration_exec' ? 'integration action' : 'upload'} was approved but execution failed: ${err.message}`, 'system').catch(() => {});
     }
   }
 }
@@ -740,9 +740,10 @@ export function createApi(app, daemon) {
           };
 
           const proc = spawn('codex', ['login'], {
-            stdio: ['ignore', 'pipe', 'pipe'],
+            stdio: ['pipe', 'pipe', 'pipe'],
             shell: true,
           });
+          proc.stdin.on('error', () => {});
           let stdout = '';
           let stderr = '';
           proc.stdout.on('data', (d) => { stdout += d.toString(); });
@@ -751,8 +752,8 @@ export function createApi(app, daemon) {
           const timeout = setTimeout(() => {
             const urlMatch = (stdout + stderr).match(/https:\/\/\S+/);
             respond(urlMatch
-              ? { status: 'pending', url: urlMatch[0] }
-              : { status: 'pending', message: 'Login started — check your browser' });
+              ? { status: 'pending', url: urlMatch[0], browserOpened: true }
+              : { status: 'pending', message: 'Login started — check your browser', browserOpened: true });
           }, 5000);
 
           proc.on('close', (code) => {
@@ -4210,6 +4211,33 @@ Keep responses concise. Help them think, don't lecture them about the system the
     res.json(daemon.federation.getStatus());
   });
 
+  app.get('/api/federation/test', async (req, res) => {
+    const target = req.query.target;
+    if (!target) return res.status(400).json({ error: 'target required' });
+    const host = target.split(':')[0];
+    const privatePatterns = [
+      /^127\./, /^10\./, /^192\.168\./, /^172\.(1[6-9]|2\d|3[01])\./,
+      /^0\./, /^169\.254\./, /^localhost$/i, /^::1$/, /^\[::1\]$/,
+      /^0\.0\.0\.0$/, /^fc/i, /^fd/i, /^fe80/i,
+    ];
+    if (privatePatterns.some(p => p.test(host))) {
+      return res.status(400).json({ error: 'Private/local addresses are not allowed' });
+    }
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+      const resp = await fetch(`http://${target}/api/health`, { signal: controller.signal });
+      clearTimeout(timeout);
+      if (resp.ok) {
+        const data = await resp.json();
+        return res.json({ reachable: true, version: data.version, peerId: data.daemonId, agents: data.agents });
+      }
+      res.json({ reachable: false });
+    } catch {
+      res.json({ reachable: false });
+    }
+  });
+
   // List peers
   app.get('/api/federation/peers', (req, res) => {
     res.json(daemon.federation.getPeers());
@@ -4665,7 +4693,13 @@ Keep responses concise. Help them think, don't lecture them about the system the
       const hasKey = daemon.credentials.hasKey(p.id);
       let authStatus = 'not-configured';
       if (p.authType === 'subscription') {
-        authStatus = p.installed ? 'authenticated' : 'not-configured';
+        if (!p.installed) {
+          authStatus = 'not-configured';
+        } else {
+          const provObj = getProvider(p.id);
+          const authResult = provObj?.constructor?.isAuthenticated?.();
+          authStatus = authResult?.authenticated ? 'authenticated' : 'not-configured';
+        }
       } else if (p.authType === 'api-key') {
         authStatus = hasKey ? 'key-set' : 'not-configured';
         if (p.authStatus?.authenticated) authStatus = 'authenticated';

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

@@ -1434,7 +1434,7 @@ For normal file edits within your scope, proceed without review.
           if (existing && (existing.status === 'running' || existing.status === 'starting')) {
             // Agent already active — reuse it instead of spawning a duplicate
             if (config.prompt) {
-              this.sendMessage(existing.id, config.prompt).catch((err) => {
+              this.sendMessage(existing.id, config.prompt, 'planner').catch((err) => {
                 console.error(`[Groove] Phase 2 reuse message failed for ${existing.name}: ${err.message}`);
               });
             }
@@ -1527,7 +1527,7 @@ For normal file edits within your scope, proceed without review.
     const message = `Your teammate ${completedAgent.name} (${completedAgent.role}) just finished their work.${fileList}${result ? `\n\nTheir summary:\n${result.slice(0, 2000)}` : ''}\n\nPlease audit their changes: verify correctness, check for bugs, run tests if available, and report any issues.`;
 
     // Send message to the QC agent via the instruct flow
-    this.sendMessage(qc.id, message).catch((err) => {
+    this.sendMessage(qc.id, message, 'system').catch((err) => {
       console.error(`[Groove] QC auto-trigger failed: ${err.message}`);
     });
 
@@ -1651,7 +1651,7 @@ For normal file edits within your scope, proceed without review.
       if (target.status === 'running') {
         let sent = false;
         if (this.hasAgentLoop(target.id)) {
-          this.sendMessage(target.id, message).catch(() => {});
+          this.sendMessage(target.id, message, 'agent').catch(() => {});
           sent = true;
         }
         if (!sent && this.daemon.journalist) {
@@ -2189,7 +2189,7 @@ For normal file edits within your scope, proceed without review.
    * Send a message to a running agent loop.
    * Returns true if the message was sent, false if the agent doesn't have an active loop.
    */
-  async sendMessage(agentId, message) {
+  async sendMessage(agentId, message, source = 'user') {
     const handle = this.handles.get(agentId);
     if (!handle?.loop) return false;
 
@@ -2200,7 +2200,7 @@ For normal file edits within your scope, proceed without review.
     const wrapped = agent ? wrapWithRoleReminder(agent.role, message) : message;
 
     if (this.daemon.trajectoryCapture) {
-      try { this.daemon.trajectoryCapture.onUserMessage(agentId, message); } catch (e) { /* fail silent */ }
+      try { this.daemon.trajectoryCapture.onUserMessage(agentId, message, source); } catch (e) { /* fail silent */ }
     }
 
     loop.sendMessage(wrapped).catch(() => {});