feat(loops): 6 trigger-based feedback loops with engine + CLI

Add FeedbackLoopEngine with 6 composable loops:

1. contextPressure — context 70%+ triggers auto-digest of old frames
2. editRecovery — edit failure triggers sm_edit fuzzy fallback
3. retrievalQuality — empty results >20% triggers strategy switch
4. traceErrorChain — same error 3x surfaces anchor + memory alert
5. harnessRegression — approval rate drop triggers regression alert
6. sessionDrift — depth >5 or stale frames triggers auto-checkpoint

Each loop has: trigger → detect → act → measure cycle with
configurable cooldown, event emission, history tracking, and stats.

Wire loop 5 into harness.ts (checks rolling 10-run window after
each metrics append). Add `stackmemory bench loops` to view
configuration and recent loop events.

Author: StackMemory Bot (CLI)

src/cli/commands/bench.ts

@@ -14,6 +14,10 @@ import {
   summarizeRuns,
 } from '../../orchestrators/multimodal/baselines.js';
 import type { HarnessRunMetrics } from '../../orchestrators/multimodal/baselines.js';
+import {
+  feedbackLoops,
+  DEFAULT_CONFIG,
+} from '../../core/monitoring/feedback-loops.js';
 
 function loadRunMetrics(projectRoot: string): HarnessRunMetrics[] {
   const metricsFile = join(
@@ -236,5 +240,68 @@ export function createBenchCommand(): Command {
       console.log('');
     });
 
+  // Sub-command: bench loops
+  bench
+    .command('loops')
+    .description('Show feedback loop configuration, status, and recent events')
+    .option('--json', 'Output as JSON', false)
+    .action((options) => {
+      const config = feedbackLoops.getConfig();
+      const stats = feedbackLoops.getStats();
+      const history = feedbackLoops.getHistory(undefined, 20);
+
+      if (options.json) {
+        console.log(JSON.stringify({ config, stats, history }, null, 2));
+        return;
+      }
+
+      console.log('\nFeedback Loops');
+      console.log('═'.repeat(60));
+
+      const loopDescriptions: Record<string, string> = {
+        contextPressure: 'Context 70%+ → auto-digest old frames',
+        editRecovery: 'Edit failure → sm_edit fuzzy fallback → telemetry',
+        retrievalQuality: 'Empty results > 20% → switch search strategy',
+        traceErrorChain: 'Same error 3x → surface anchor + memory',
+        harnessRegression: 'Approval rate drops → regression alert',
+        sessionDrift: 'Depth > 5 or stale frames → auto-checkpoint',
+      };
+
+      console.log('\nLoop Configuration:');
+      for (const [name, cfg] of Object.entries(config)) {
+        const icon = cfg.enabled ? ' ON' : 'OFF';
+        const desc = loopDescriptions[name] || name;
+        const cooldown =
+          cfg.cooldownSec > 0 ? ` (cooldown ${cfg.cooldownSec}s)` : '';
+        console.log(`  [${icon}] ${name.padEnd(22)} ${desc}${cooldown}`);
+      }
+
+      if (Object.keys(stats).length > 0) {
+        console.log('\nLoop Stats (this session):');
+        for (const [name, s] of Object.entries(stats)) {
+          const ago = s.lastFired
+            ? `${Math.round((Date.now() - s.lastFired) / 1000)}s ago`
+            : 'never';
+          console.log(
+            `  ${name.padEnd(22)} ${s.fires} fires, ${s.successes} ok, ${s.errors} err (last: ${ago})`
+          );
+        }
+      }
+
+      if (history.length > 0) {
+        console.log(`\nRecent Events (${history.length}):`);
+        for (const e of history.slice(-10)) {
+          const time = new Date(e.timestamp).toISOString().slice(11, 19);
+          console.log(
+            `  ${time} [${e.loop}] ${e.trigger} → ${e.action} (${e.outcome})`
+          );
+        }
+      } else {
+        console.log('\nNo loop events fired yet this session.');
+      }
+
+      console.log('');
+    });
+
   return bench;
 }

src/core/monitoring/__tests__/feedback-loops.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, vi } from 'vitest';
+import { FeedbackLoopEngine, DEFAULT_CONFIG } from '../feedback-loops.js';
+
+describe('FeedbackLoopEngine', () => {
+  it('fires enabled loops and respects cooldown', () => {
+    const engine = new FeedbackLoopEngine();
+    const listener = vi.fn();
+    engine.on('loop', listener);
+
+    // First fire succeeds
+    const e1 = engine.fire(
+      'editRecovery',
+      'PostToolUse',
+      { filePath: 'foo.ts', errorType: 'string_not_found' },
+      'fuzzy_fallback'
+    );
+    expect(e1).not.toBeNull();
+    expect(e1!.loop).toBe('editRecovery');
+    expect(listener).toHaveBeenCalledTimes(1);
+
+    // editRecovery has cooldown=0, so fires again immediately
+    const e2 = engine.fire(
+      'editRecovery',
+      'PostToolUse',
+      { filePath: 'bar.ts' },
+      'fuzzy_fallback'
+    );
+    expect(e2).not.toBeNull();
+
+    // contextPressure has cooldown=60s, second fire within cooldown skips
+    const e3 = engine.fire(
+      'contextPressure',
+      'context:high',
+      { percentage: 75 },
+      'auto_digest'
+    );
+    expect(e3).not.toBeNull();
+    const e4 = engine.fire(
+      'contextPressure',
+      'context:high',
+      { percentage: 78 },
+      'auto_digest'
+    );
+    expect(e4).toBeNull(); // cooldown
+  });
+
+  it('skips disabled loops', () => {
+    const engine = new FeedbackLoopEngine({
+      editRecovery: { enabled: false, cooldownSec: 0 },
+    });
+
+    const result = engine.fire(
+      'editRecovery',
+      'PostToolUse',
+      {},
+      'fuzzy_fallback'
+    );
+    expect(result).toBeNull();
+  });
+
+  it('tracks history and stats', () => {
+    const engine = new FeedbackLoopEngine();
+
+    engine.fire('editRecovery', 'test', {}, 'act1', 'success');
+    engine.fire('editRecovery', 'test', {}, 'act2', 'error');
+    engine.fire('traceErrorChain', 'test', {}, 'alert', 'success');
+
+    const history = engine.getHistory();
+    expect(history).toHaveLength(3);
+
+    const editHistory = engine.getHistory('editRecovery');
+    expect(editHistory).toHaveLength(2);
+
+    const stats = engine.getStats();
+    expect(stats['editRecovery'].fires).toBe(2);
+    expect(stats['editRecovery'].successes).toBe(1);
+    expect(stats['editRecovery'].errors).toBe(1);
+    expect(stats['traceErrorChain'].fires).toBe(1);
+  });
+
+  it('emits per-loop events', () => {
+    const engine = new FeedbackLoopEngine();
+    const editListener = vi.fn();
+    const traceListener = vi.fn();
+    engine.on('loop:editRecovery', editListener);
+    engine.on('loop:traceErrorChain', traceListener);
+
+    engine.fire('editRecovery', 'test', {}, 'act');
+    expect(editListener).toHaveBeenCalledTimes(1);
+    expect(traceListener).not.toHaveBeenCalled();
+  });
+
+  it('default config has all 6 loops', () => {
+    expect(Object.keys(DEFAULT_CONFIG)).toHaveLength(6);
+    for (const cfg of Object.values(DEFAULT_CONFIG)) {
+      expect(cfg).toHaveProperty('enabled');
+      expect(cfg).toHaveProperty('cooldownSec');
+    }
+  });
+});