groove-dev 0.27.107 → 0.27.108

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

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

package/node_modules/@groove-dev/gui/src/components/layout/command-palette.jsx

@@ -4,7 +4,7 @@ import { useGrooveStore } from '../../stores/groove';
 import {
   Network, Code2, ChartSpline, Puzzle, Users, Plus,
   RotateCw, Skull, MessageSquare, Terminal, Newspaper,
-  Search, Radio, ExternalLink, FolderOpen, Globe,
+  Search, Radio, ExternalLink, FolderOpen, Globe, Shield,
 } from 'lucide-react';
 import { cn } from '../../lib/cn';
 import { AnimatePresence, motion } from 'framer-motion';
@@ -16,6 +16,7 @@ const STATIC_COMMANDS = [
   { id: 'nav:marketplace', label: 'Go to Marketplace', icon: Puzzle,     category: 'Navigation', action: (s) => { s.setActiveView('marketplace'); } },
   { id: 'nav:teams',       label: 'Go to Teams',       icon: Users,      category: 'Navigation', action: (s) => { s.setActiveView('teams'); } },
   { id: 'nav:federation', label: 'Go to Federation',  icon: Globe,      category: 'Navigation', action: (s) => { s.setActiveView('federation'); } },
+  { id: 'action:whitelist', label: 'Add to Federation Whitelist', icon: Shield, category: 'Federation', action: (s) => { s.setActiveView('federation'); } },
   { id: 'action:spawn',    label: 'Spawn Agent',       icon: Plus,       category: 'Actions',    action: (s) => { s.openDetail({ type: 'spawn' }); } },
   { id: 'action:terminal', label: 'Toggle Terminal',   icon: Terminal,   category: 'Actions',    action: (s) => { s.setTerminalVisible(!s.terminalVisible); }, shortcut: 'Cmd+J' },
   { id: 'action:journalist', label: 'Toggle Journalist', icon: Newspaper, category: 'Actions',  action: (s) => {

package/node_modules/@groove-dev/gui/src/components/layout/status-bar.jsx

@@ -1,5 +1,5 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
-import { Terminal, BookOpen, Radio, Plug, Globe, ArrowUpCircle, X, Unplug } from 'lucide-react';
+import { Terminal, BookOpen, Radio, Plug, Globe, ArrowUpCircle, X, Unplug, Shield } from 'lucide-react';
 import { cn } from '../../lib/cn';
 import { StatusDot } from '../ui/status-dot';
 import { Badge } from '../ui/badge';
@@ -22,7 +22,6 @@ export function StatusBar({
   const updateReady = useGrooveStore((s) => s.updateReady);
   const updateProgress = useGrooveStore((s) => s.updateProgress);
   const setUpdateModalOpen = useGrooveStore((s) => s.setUpdateModalOpen);
-  const subscription = useGrooveStore((s) => s.subscription);
   const navigate = useGrooveStore((s) => s.setActiveView);
   const activeTunnel = savedTunnels.find((t) => t.active);
   const electron = isElectron();
@@ -71,6 +70,13 @@ export function StatusBar({
                 <span className="text-text-4">{activeTunnel.latencyMs}ms</span>
               )}
             </button>
+            <button
+              onClick={() => useGrooveStore.getState().addToWhitelist(activeTunnel.host)}
+              className="p-0.5 text-text-4 hover:text-accent cursor-pointer transition-colors rounded"
+              title="Add to Federation Whitelist"
+            >
+              <Shield size={10} />
+            </button>
             <button
               onClick={() => useGrooveStore.getState().disconnectTunnel(activeTunnel.id)}
               className="p-0.5 text-text-4 hover:text-danger cursor-pointer transition-colors rounded"
@@ -98,7 +104,7 @@ export function StatusBar({
             <span>Connect</span>
           </button>
         )}
-        {subscription?.active && (subscription.plan === 'pro' || subscription.plan === 'team') && (
+        {connected && (
           <button
             onClick={() => navigate('federation')}
             className="flex items-center gap-1.5 text-text-4 hover:text-text-1 cursor-pointer transition-colors"

package/node_modules/@groove-dev/gui/src/components/settings/federation-panel.jsx

@@ -22,7 +22,7 @@ function statusBadge(status) {
   }
 }
 
-function WhitelistTab() {
+export function WhitelistTab() {
   const whitelist = useGrooveStore((s) => s.federation.whitelist);
   const addToWhitelist = useGrooveStore((s) => s.addToWhitelist);
   const removeFromWhitelist = useGrooveStore((s) => s.removeFromWhitelist);
@@ -198,7 +198,7 @@ function WhitelistTab() {
   );
 }
 
-function AmbassadorsTab() {
+export function AmbassadorsTab() {
   const ambassadors = useGrooveStore((s) => s.federation.ambassadors);
 
   return (

package/node_modules/@groove-dev/gui/src/components/settings/federation-peers.jsx

@@ -22,6 +22,8 @@ export function FederationPeers({ onOpenWizard }) {
   const connections = useGrooveStore((s) => s.federation.connections);
   const peers = useGrooveStore((s) => s.federation.peers);
   const sendPouch = useGrooveStore((s) => s.sendPouch);
+  const disconnectPeer = useGrooveStore((s) => s.disconnectPeer);
+  const addToast = useGrooveStore((s) => s.addToast);
   const [sendingTo, setSendingTo] = useState(null);
 
   const allPeers = peers.length > 0 ? peers : connections;
@@ -97,7 +99,12 @@ export function FederationPeers({ onOpenWizard }) {
                 </div>
 
                 <div className="flex items-center gap-1.5 mt-3 pt-2.5 border-t border-border-subtle">
-                  <Button size="sm" variant="ghost" className="h-6 text-2xs gap-1 text-text-2">
+                  <Button
+                    size="sm"
+                    variant="ghost"
+                    className="h-6 text-2xs gap-1 text-text-2"
+                    onClick={() => addToast('info', name, `ID: ${id}\nIP: ${ip}${peer.port ? `:${peer.port}` : ''}\nLatency: ${latency != null ? `${latency}ms` : 'N/A'}\nState: ${state}`)}
+                  >
                     <Eye size={10} />
                     Details
                   </Button>
@@ -111,7 +118,12 @@ export function FederationPeers({ onOpenWizard }) {
                     <Send size={10} />
                     Send Pouch
                   </Button>
-                  <Button size="sm" variant="ghost" className="h-6 text-2xs gap-1 text-danger/70 hover:text-danger ml-auto">
+                  <Button
+                    size="sm"
+                    variant="ghost"
+                    className="h-6 text-2xs gap-1 text-danger/70 hover:text-danger ml-auto"
+                    onClick={() => disconnectPeer(id)}
+                  >
                     <Unplug size={10} />
                     Disconnect
                   </Button>

package/node_modules/@groove-dev/gui/src/components/settings/quick-connect.jsx

@@ -25,6 +25,15 @@ export function QuickConnect() {
     setConnectingId(id);
     try {
       await useGrooveStore.getState().connectTunnel(id);
+      const tunnel = savedTunnels.find((t) => t.id === id);
+      if (tunnel?.host) {
+        addToast('info', `Add ${tunnel.host} to Federation Whitelist?`, '', {
+          action: {
+            label: 'Add',
+            onClick: () => useGrooveStore.getState().addToWhitelist(tunnel.host),
+          },
+        });
+      }
       toggle();
     } catch (err) {
       let detail = err?.message || 'Unknown error';

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

@@ -2660,6 +2660,16 @@ export const useGrooveStore = create((set, get) => ({
     }
   },
 
+  async disconnectPeer(peerId) {
+    try {
+      await api.delete(`/federation/peers/${encodeURIComponent(peerId)}`);
+      get().addToast('info', 'Peer disconnected');
+      get().fetchFederationStatus();
+    } catch (err) {
+      get().addToast('error', 'Disconnect failed', err.message);
+    }
+  },
+
   // ── Training Data ─────────────────────────────────────────
 
   async setTrainingOptIn(enabled) {

package/node_modules/@groove-dev/gui/src/views/federation.jsx

@@ -1,37 +1,78 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
-import { useEffect } from 'react';
+import { useEffect, useState } from 'react';
 import { useGrooveStore } from '../stores/groove';
-import { FederationPanel } from '../components/settings/federation-panel';
-import { ProGate } from '../components/pro/pro-gate';
+import { FederationPeers } from '../components/settings/federation-peers';
+import { FederationActivity } from '../components/settings/federation-activity';
+import { FederationWizard } from '../components/settings/federation-wizard';
+import { WhitelistTab, AmbassadorsTab } from '../components/settings/federation-panel';
+import { Button } from '../components/ui/button';
 import { ScrollArea } from '../components/ui/scroll-area';
-import { Globe } from 'lucide-react';
+import { Globe, Plus } from 'lucide-react';
 
 export default function FederationView() {
   const fetchFederationStatus = useGrooveStore((s) => s.fetchFederationStatus);
+  const fetchPouchLog = useGrooveStore((s) => s.fetchPouchLog);
+  const peers = useGrooveStore((s) => s.federation.peers);
+  const connections = useGrooveStore((s) => s.federation.connections);
+  const whitelist = useGrooveStore((s) => s.federation.whitelist);
+  const [wizardOpen, setWizardOpen] = useState(false);
+
+  const peerCount = (peers.length > 0 ? peers : connections).length;
 
   useEffect(() => {
     fetchFederationStatus();
+    fetchPouchLog();
   }, []);
 
   return (
     <div className="flex flex-col h-full bg-surface-0">
-      <div className="flex items-center gap-3 px-6 py-4 border-b border-border">
-        <div className="w-8 h-8 rounded-md bg-accent/10 flex items-center justify-center">
-          <Globe size={16} className="text-accent" />
-        </div>
-        <div>
-          <h1 className="text-sm font-semibold text-text-0 font-sans">Federation</h1>
-          <p className="text-2xs text-text-3 font-sans">Connect to remote Groove daemons</p>
+      {/* Hero strip */}
+      <div className="flex items-center justify-between px-6 py-4 border-b border-border">
+        <div className="flex items-center gap-3">
+          <div className="w-8 h-8 rounded-md bg-accent/10 flex items-center justify-center">
+            <Globe size={16} className="text-accent" />
+          </div>
+          <div>
+            <h1 className="text-sm font-semibold text-text-0 font-sans">Federation</h1>
+            <p className="text-2xs text-text-3 font-sans">
+              {peerCount} peer{peerCount !== 1 ? 's' : ''} &middot; {whitelist.length} whitelisted
+            </p>
+          </div>
         </div>
+        <Button size="sm" variant="primary" onClick={() => setWizardOpen(true)} className="h-8 text-xs gap-1.5">
+          <Plus size={12} />
+          Add Peer
+        </Button>
       </div>
 
+      {/* Content */}
       <ScrollArea className="flex-1">
-        <div className="max-w-2xl mx-auto px-6 py-5">
-          <ProGate feature="Federation" featureKey="federation" description="Daemon-to-daemon federation over Tailscale mesh for multi-machine agent coordination">
-            <FederationPanel />
-          </ProGate>
+        <div className="p-6">
+          <div className="grid grid-cols-1 lg:grid-cols-3 gap-4">
+            {/* Left: Peers + Activity (stacked) */}
+            <div className="lg:col-span-2 space-y-4">
+              <div className="rounded-lg border border-border-subtle bg-surface-1 p-4">
+                <FederationPeers onOpenWizard={() => setWizardOpen(true)} />
+              </div>
+              <div className="rounded-lg border border-border-subtle bg-surface-1 p-4">
+                <FederationActivity />
+              </div>
+            </div>
+
+            {/* Right: Whitelist + Ambassadors (stacked) */}
+            <div className="space-y-4">
+              <div className="rounded-lg border border-border-subtle bg-surface-1 p-4">
+                <WhitelistTab />
+              </div>
+              <div className="rounded-lg border border-border-subtle bg-surface-1 p-4">
+                <AmbassadorsTab />
+              </div>
+            </div>
+          </div>
         </div>
       </ScrollArea>
+
+      <FederationWizard open={wizardOpen} onOpenChange={setWizardOpen} />
     </div>
   );
 }

package/node_modules/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/node_modules/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]',
       },
       {

package/node_modules/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/node_modules/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/node_modules/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/node_modules/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/node_modules/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/node_modules/moe-training/test/client/scrubber.test.js

@@ -136,11 +136,24 @@ describe('PIIScrubber', () => {
     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);

package/node_modules/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');
+  });
+});