groove-dev 0.27.85 → 0.27.87

package/CLAUDE.md

@@ -263,3 +263,13 @@ Audit-driven release. Multi-agent orchestration system with 7 coordination layer
 - Dashboard: routing donut, cache panel, context health gauges
 - Monitor/QC agent mode (stay active, loop)
 - Distribution: demo video, HN launch, Twitter content
+
+<!-- GROOVE:START -->
+## GROOVE Orchestration (auto-injected)
+Active agents: 1
+| Name | Role | Scope |
+|------|------|-------|
+| backend-9 | backend | packages/cli/src/commands/connect.js, packages/cli/src/commands/disconnect.js, packages/cli/src/commands/remotes.js, packages/cli/bin/groove.js |
+See AGENTS_REGISTRY.md for full agent state.
+**Memory policy:** GROOVE manages project memory automatically. Do not read or write MEMORY.md or .groove/memory/ files directly.
+<!-- GROOVE:END -->

package/moe-training/client/scrubber.js

@@ -95,8 +95,8 @@ export class PIIScrubber {
       },
       {
         name: 'home_path',
-        regex: /(?:\/Users\/[^\s]+|\/home\/[^\s]+|C:\\Users\\[^\s]+)/g,
-        replacement: '[FILE_PATH]',
+        regex: /(?:\/Users\/[^\/\s]+|\/home\/[^\/\s]+|C:\\Users\\[^\\\s]+)([\/\\][^\s]*)?/g,
+        replacement: null,
       },
       {
         name: 'base64_secret',
@@ -116,6 +116,8 @@ export class PIIScrubber {
           const digits = (g1 + g2 + g3 + g4);
           return luhnCheck(digits) ? '[CREDIT_CARD]' : match;
         });
+      } else if (pattern.name === 'home_path') {
+        result = result.replace(pattern.regex, (_match, relPath) => '~' + (relPath || ''));
       } else {
         result = result.replace(pattern.regex, pattern.replacement);
       }

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

@@ -1,8 +1,12 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
+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;
+
 export class StepClassifier {
   constructor() {
     this.hasAgentActed = false;
+    this._lastStepType = null;
   }
 
   classifyUserMessage(text) {
@@ -31,6 +35,19 @@ export class StepClassifier {
     if (step.type === 'action') {
       this.hasAgentActed = true;
     }
+
+    const content = step.content || '';
+
+    if ((step.type === 'action' || step.type === 'observation') && ERROR_SIGNAL_RE.test(content)) {
+      step.type = 'error';
+    }
+
+    if (step.type === 'thought' && this._lastStepType === 'correction' && FIX_SIGNAL_RE.test(content)) {
+      step.correction_context = true;
+    }
+
+    this._lastStepType = step.type;
+    return step;
   }
 
   static detectErrorRecovery(steps) {

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

@@ -10,6 +10,8 @@ import { SessionAttestation } from './session-attestation.js';
 import { TransmissionQueue } from './transmission-queue.js';
 import { CHUNK_TIMEOUT_MS, CENTRAL_COMMAND_URL } from '../shared/constants.js';
 
+const OFFLINE_RETRY_INTERVAL_MS = 60_000;
+
 export class TrajectoryCapture {
   constructor(options = {}) {
     this._centralCommandUrl = options.centralCommandUrl || CENTRAL_COMMAND_URL;
@@ -18,6 +20,7 @@ export class TrajectoryCapture {
     this._scrubber = null;
     this._attestation = null;
     this._transmissionQueue = null;
+    this._offlineRetryTimer = null;
     this._contexts = new Map();
   }
 
@@ -31,6 +34,9 @@ export class TrajectoryCapture {
     this._attestation = new SessionAttestation(this._centralCommandUrl);
     this._transmissionQueue = new TransmissionQueue(this._centralCommandUrl);
     this._transmissionQueue.start();
+    this._offlineRetryTimer = setInterval(() => {
+      this._retryOfflineQueue();
+    }, OFFLINE_RETRY_INTERVAL_MS);
   }
 
   async onAgentSpawn(agentId, provider, model, role, teamSize) {
@@ -103,6 +109,12 @@ export class TrajectoryCapture {
       this._processStep(agentId, ctx, event);
     }
 
+    if ((!ctx.metadata.model_engine || ctx.metadata.model_engine === 'auto') &&
+        typeof ctx.parser.extractModel === 'function') {
+      const resolved = ctx.parser.extractModel(jsonEvent);
+      if (resolved) ctx.metadata.model_engine = resolved;
+    }
+
     const tokens = ctx.parser.extractTokens(jsonEvent);
     if (tokens) {
       ctx.totalTokens += (tokens.input || 0) + (tokens.output || 0);
@@ -139,6 +151,7 @@ export class TrajectoryCapture {
   }
 
   async shutdown() {
+    if (this._offlineRetryTimer) clearInterval(this._offlineRetryTimer);
     for (const agentId of this._contexts.keys()) {
       await this._closeAgent(agentId, 'SHUTDOWN');
     }
@@ -148,20 +161,25 @@ export class TrajectoryCapture {
   }
 
   _processStep(agentId, ctx, event) {
-    ctx.classifier.onStep(event);
+    const classified = ctx.classifier.onStep(event);
+    const ev = classified || event;
 
-    if (event.content && typeof event.content === 'string') {
-      event.content = this._scrubber.scrub(event.content);
+    if (ev.content && typeof ev.content === 'string') {
+      ev.content = this._scrubber.scrub(ev.content);
+    }
+
+    if (ev.arguments && typeof ev.arguments === 'object') {
+      ev.arguments = this._scrubObject(ev.arguments);
     }
 
     const step = {
       step: ++ctx.stepCount,
-      type: event.type,
+      type: ev.type,
       timestamp: Date.now() / 1000,
-      ...event,
+      ...ev,
     };
 
-    if (event.type === 'error') ctx.errorsEncountered++;
+    if (ev.type === 'error') ctx.errorsEncountered++;
     ctx.allSteps.push(step);
 
     const envelope = ctx.builder.addStep(step);
@@ -171,9 +189,29 @@ export class TrajectoryCapture {
     }
   }
 
+  _computeQuality(ctx) {
+    let score = 50;
+    const types = new Set();
+    let hasCorrection = false;
+
+    for (const step of ctx.allSteps) {
+      if (step.type) types.add(step.type);
+      if (step.type === 'correction') hasCorrection = true;
+    }
+
+    if (hasCorrection) score += 10;
+    if (ctx.coordinationEvents > 0) score += 10;
+    if (ctx.errorsRecovered > 0) score += 10;
+    if (ctx.stepCount >= 20) score += 10;
+    if (types.size >= 3) score += 10;
+
+    return Math.min(score, 100);
+  }
+
   _flushContext(agentId) {
     const ctx = this._contexts.get(agentId);
     if (!ctx) return;
+    ctx.metadata.session_quality = this._computeQuality(ctx);
     const envelope = ctx.builder.flush();
     if (envelope) {
       this._signAndTransmit(ctx.sessionId, envelope);
@@ -192,8 +230,11 @@ export class TrajectoryCapture {
     const hasRecovery = StepClassifier.detectErrorRecovery(ctx.allSteps);
     if (hasRecovery) ctx.errorsRecovered++;
 
+    ctx.metadata.session_quality = this._computeQuality(ctx);
+
     const closeEnvelope = ctx.builder.buildSessionClose({
       status,
+      session_quality: ctx.metadata.session_quality,
       user_interventions: StepClassifier.countUserInterventions(ctx.allSteps),
       total_steps: ctx.stepCount,
       total_chunks: ctx.chunkCount,
@@ -207,6 +248,12 @@ export class TrajectoryCapture {
 
     this._signAndTransmit(ctx.sessionId, closeEnvelope);
 
+    try {
+      await this._transmissionQueue.waitForDrain();
+    } catch {
+      // drain timeout
+    }
+
     try {
       await this._attestation.closeSession(ctx.sessionId);
     } catch {
@@ -216,6 +263,33 @@ export class TrajectoryCapture {
     this._contexts.delete(agentId);
   }
 
+  async _retryOfflineQueue() {
+    if (!this._enabled || !this._transmissionQueue || this._transmissionQueue.offlineQueueSize === 0) return;
+    try {
+      const res = await fetch(`${this._centralCommandUrl}/health`, {
+        signal: AbortSignal.timeout(5_000),
+      });
+      if (res.ok) {
+        this._transmissionQueue.replayOfflineQueue(this._attestation);
+      }
+    } catch {
+      // still unreachable
+    }
+  }
+
+  _scrubObject(obj) {
+    if (typeof obj === 'string') return this._scrubber.scrub(obj);
+    if (Array.isArray(obj)) return obj.map((v) => this._scrubObject(v));
+    if (obj && typeof obj === 'object') {
+      const out = {};
+      for (const [k, v] of Object.entries(obj)) {
+        out[k] = this._scrubObject(v);
+      }
+      return out;
+    }
+    return obj;
+  }
+
   _signAndTransmit(sessionId, envelope) {
     try {
       const signed = this._attestation.signEnvelope(sessionId, envelope);

package/moe-training/client/transmission-queue.js

@@ -16,6 +16,10 @@ export class TransmissionQueue {
     }
   }
 
+  get offlineQueueSize() {
+    return this._offlineQueue.length;
+  }
+
   enqueue(signedEnvelope) {
     if (this._queue.length >= this._maxSize) return;
     if (signedEnvelope?.attestation?.session_hmac === 'OFFLINE') {
@@ -46,6 +50,13 @@ export class TransmissionQueue {
     this._kick();
   }
 
+  async waitForDrain() {
+    while (this._queue.length > 0 || this._drainPromise) {
+      if (this._drainPromise) await this._drainPromise;
+      else await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+
   async stop() {
     this._running = false;
     if (this._drainPromise) {

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

@@ -73,9 +73,9 @@ describe('PIIScrubber', () => {
     assert.equal(scrubber.scrub(input), 'hash: [API_KEY]');
   });
 
-  it('scrubs home directory paths', () => {
+  it('scrubs home directory paths preserving relative path', () => {
     const input = 'file at /Users/john/Documents/secret.txt';
-    assert.equal(scrubber.scrub(input), 'file at [FILE_PATH]');
+    assert.equal(scrubber.scrub(input), 'file at ~/Documents/secret.txt');
   });
 
   it('scrubs URL-encoded emails', () => {
@@ -95,10 +95,10 @@ describe('PIIScrubber', () => {
     assert.ok(!result.includes('eyJhbGciOi'));
   });
 
-  it('scrubs file paths without trailing slash', () => {
+  it('scrubs file paths preserving relative path', () => {
     const input = 'reading /home/alice/project/secret.key now';
     const result = scrubber.scrub(input);
-    assert.ok(result.includes('[FILE_PATH]'));
+    assert.equal(result, 'reading ~/project/secret.key now');
     assert.ok(!result.includes('/home/alice'));
   });
 
@@ -121,6 +121,16 @@ describe('PIIScrubber', () => {
     assert.equal(scrubber.scrub(''), '');
   });
 
+  it('scrubs Windows home paths preserving relative path', () => {
+    const input = 'file at C:\\Users\\bob\\Desktop\\project\\app.js';
+    assert.equal(scrubber.scrub(input), 'file at ~\\Desktop\\project\\app.js');
+  });
+
+  it('scrubs home path with no trailing path', () => {
+    const input = 'cd /Users/john';
+    assert.equal(scrubber.scrub(input), 'cd ~');
+  });
+
   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

@@ -85,4 +85,51 @@ describe('StepClassifier', () => {
     ];
     assert.equal(StepClassifier.countUserInterventions(steps), 0);
   });
+
+  it('reclassifies action with error content to error', () => {
+    const classifier = new StepClassifier();
+    const step = { type: 'action', content: 'Command failed with exit code 1' };
+    const result = classifier.onStep(step);
+    assert.equal(result.type, 'error');
+  });
+
+  it('reclassifies observation with error content to error', () => {
+    const classifier = new StepClassifier();
+    const step = { type: 'observation', content: 'TypeError: cannot read properties of undefined' };
+    const result = classifier.onStep(step);
+    assert.equal(result.type, 'error');
+  });
+
+  it('does not reclassify thought with error content', () => {
+    const classifier = new StepClassifier();
+    const step = { type: 'thought', content: 'I see the Error and will fix it' };
+    const result = classifier.onStep(step);
+    assert.equal(result.type, 'thought');
+  });
+
+  it('marks thought after correction as correction_context', () => {
+    const classifier = new StepClassifier();
+    classifier.onStep({ type: 'action' });
+    classifier.onStep({ type: 'correction', content: 'no, fix the bug' });
+    const step = { type: 'thought', content: 'I see the issue, let me fix it' };
+    const result = classifier.onStep(step);
+    assert.equal(result.type, 'thought');
+    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' });
+    const step = { type: 'thought', content: 'let me fix this' };
+    const result = classifier.onStep(step);
+    assert.equal(result.correction_context, undefined);
+  });
+
+  it('returns the step from onStep', () => {
+    const classifier = new StepClassifier();
+    const step = { type: 'action', content: 'hello' };
+    const result = classifier.onStep(step);
+    assert.ok(result);
+    assert.equal(result.type, 'action');
+  });
 });

package/moe-training/test/client/transmission-queue.test.js

@@ -0,0 +1,33 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { TransmissionQueue } from '../../client/transmission-queue.js';
+
+describe('TransmissionQueue', () => {
+  it('waitForDrain resolves immediately when queue is empty', async () => {
+    const queue = new TransmissionQueue('http://localhost:9999');
+    await queue.waitForDrain();
+    assert.ok(true);
+  });
+
+  it('waitForDrain waits for active drain to complete', async () => {
+    const queue = new TransmissionQueue('http://localhost:9999');
+    queue._queue.push({ session_id: 'test' });
+    const drain = Promise.resolve().then(() => {
+      queue._queue.length = 0;
+    });
+    queue._drainPromise = drain.finally(() => {
+      queue._drainPromise = null;
+    });
+    await queue.waitForDrain();
+    assert.equal(queue._queue.length, 0);
+  });
+
+  it('offlineQueueSize tracks offline envelopes', () => {
+    const queue = new TransmissionQueue('http://localhost:9999');
+    assert.equal(queue.offlineQueueSize, 0);
+    queue.enqueue({ session_id: 'test', attestation: { session_hmac: 'OFFLINE' } });
+    assert.equal(queue.offlineQueueSize, 1);
+  });
+});

package/node_modules/@groove-dev/cli/bin/groove.js

@@ -18,6 +18,7 @@ import { providers, setKey } from '../src/commands/providers.js';
 import { configShow, configSet } from '../src/commands/config.js';
 import { connect } from '../src/commands/connect.js';
 import { disconnect } from '../src/commands/disconnect.js';
+import { remotes } from '../src/commands/remotes.js';
 import { audit } from '../src/commands/audit.js';
 import { federationPair, federationUnpair, federationList, federationStatus } from '../src/commands/federation.js';
 import { createRequire } from 'node:module';
@@ -108,13 +109,21 @@ program
   .description('Connect to a remote GROOVE daemon via SSH tunnel')
   .option('-i, --identity <keyfile>', 'SSH private key file')
   .option('--no-browser', 'Don\'t open browser automatically')
+  .option('-p, --port <port>', 'SSH port', '22')
+  .option('--project-dir <path>', 'Remote working directory')
+  .option('--auto-connect', 'Save with autoConnect (reconnect on daemon start)')
   .action(connect);
 
 program
-  .command('disconnect')
+  .command('disconnect [target]')
   .description('Disconnect from remote GROOVE daemon')
   .action(disconnect);
 
+program
+  .command('remotes')
+  .description('List saved remote connections')
+  .action(remotes);
+
 // Audit
 program
   .command('audit')

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.85",
+  "version": "0.27.87",
   "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",