groove-dev 0.26.38 → 0.27.0

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

@@ -75,6 +75,10 @@ export function validateAgentConfig(config) {
     integrations = config.integrations.filter((s) => typeof s === 'string' && s.length > 0 && s.length <= 100);
   }
 
+  // Validate integration approval mode
+  const validApprovalModes = ['auto', 'manual'];
+  const integrationApproval = validApprovalModes.includes(config.integrationApproval) ? config.integrationApproval : 'manual';
+
   // Return sanitized config (only known fields)
   return {
     role: config.role,
@@ -88,6 +92,7 @@ export function validateAgentConfig(config) {
     permission,
     skills,
     integrations,
+    integrationApproval,
   };
 }
 
@@ -122,19 +127,6 @@ export function validateTeamName(name) {
   // Allow spaces and special chars in display name, sanitize for filesystem separately
 }
 
-export function sanitizeForFilename(name) {
-  const sanitized = name
-    .replace(/[^a-zA-Z0-9_-]/g, '_')
-    .replace(/_+/g, '_')
-    .toLowerCase()
-    .slice(0, 50);
-
-  if (!sanitized || /^_+$/.test(sanitized)) {
-    throw new Error('Team name must contain alphanumeric characters');
-  }
-  return sanitized;
-}
-
 const VALID_GATEWAY_TYPES = ['telegram', 'discord', 'slack'];
 const VALID_NOTIFICATION_PRESETS = ['critical', 'lifecycle', 'all', 'custom'];
 

package/node_modules/@groove-dev/daemon/templates/groove-slides.cjs

@@ -0,0 +1,306 @@
+// GROOVE — Slide Deck Layout Engine
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// This file is written into every `slides` role agent's working directory at spawn time.
+// Do not modify it — Groove overwrites it on every spawn. Theme / style / visual
+// components come from a marketplace skill. Layout, measurement, and validation are
+// core and baked in here so decks never ship broken regardless of which skill (if any)
+// is attached.
+//
+// Usage in convert-slides.js:
+//
+//   const pptxgen = require('pptxgenjs');
+//   const {
+//     LAYOUT, estimateTextHeight, fitFontSize,
+//     checkCollisions, checkBounds, checkTextWrap, hardGate, tracker,
+//   } = require('./groove-slides.js');
+//
+//   const pres = new pptxgen();
+//   pres.layout = 'LAYOUT_16x9';
+//
+//   function renderMetricsSlide(data) {
+//     const slide = pres.addSlide();
+//     const { track, placed } = tracker();
+//
+//     let Y = LAYOUT.CONTENT_START;
+//
+//     // Title — box height budgeted first, then font size fit to it
+//     const titleBoxH = 1.1;
+//     const titleSize = fitFontSize(data.title, 42, 24, LAYOUT.SAFE_W, titleBoxH, { bold: true });
+//     slide.addText(data.title, track('title', {
+//       x: LAYOUT.SAFE_X, y: Y, w: LAYOUT.SAFE_W, h: titleBoxH,
+//       text: data.title, fontSize: titleSize, bold: true,
+//     }));
+//     Y += titleBoxH + LAYOUT.GAP_STD;
+//     // ... more placements ...
+//     return { name: 'metrics', elements: placed };
+//   }
+//
+//   const allSlides = [renderMetricsSlide(data.slides[0]), ...];
+//   hardGate(allSlides.map((s) => [s.name, s.elements])); // exits 1 on any issue
+//   await pres.writeFile({ fileName: 'deck.pptx' });
+//
+// Rules (enforced by hardGate — no bypasses):
+//   1. Every text and shape you place MUST be pushed to `placed[]` via `track()`.
+//   2. NEVER add `skipCollision`, `skipBounds`, `skipWrap`, or any other bypass flag.
+//      If a legitimate design element overflows the safe area (e.g., an orb bleeding
+//      off-slide), use addImage() WITHOUT tracking it. The gate only validates what
+//      you declare placed.
+//   3. DO NOT use `shrinkText: true`. PowerPoint honors it; Google Slides and
+//      LibreOffice PDF export largely do not — text renders at its declared size
+//      and overflows. Always use `fitFontSize()` to compute a real font size that
+//      fits the box.
+//   4. Y advances MUST come from `estimateTextHeight()` or an explicit box budget,
+//      never a hardcoded magic number like `Y += 0.95`.
+//   5. Every call to `hardGate()` is a build gate. Do not wrap it in try/catch.
+//      A failing gate is a build failure — fix the slide generator, don't silence
+//      the check.
+
+// ─── Layout constants ───────────────────────────────────────────────────────
+
+const LAYOUT = Object.freeze({
+  // 16:9 canvas
+  SLIDE_W: 10,
+  SLIDE_H: 5.625,
+
+  // Safe margins
+  SAFE_X: 0.6,
+  SAFE_R: 9.4,
+  SAFE_W: 8.8,
+  SAFE_TOP: 0.25,         // top of brand zone
+  SAFE_BOT: 5.125,        // below this = clipped
+  CONTENT_START: 0.65,    // below branding — first Y for content
+  CONTENT_H: 4.475,       // SAFE_BOT - CONTENT_START
+
+  // Branding reserved zone (do not place content here)
+  BRAND_Y: 0.25,
+  BRAND_H: 0.3,
+
+  // Gaps between elements
+  GAP_TIGHT: 0.1,
+  GAP_STD: 0.25,
+  GAP_SECTION: 0.4,
+  GAP_DRAMATIC: 0.8,
+
+  // Inset for text beside an accent border / inside a column
+  TEXT_INSET: 0.2,
+});
+
+// ─── Measurement ────────────────────────────────────────────────────────────
+
+/**
+ * Estimate the rendered height of a text box in inches.
+ * Handles word-wrap, explicit newlines, and bold/serif width adjustments.
+ *
+ * @param {string}  text
+ * @param {number}  fontSize   points
+ * @param {number}  boxWidth   inches
+ * @param {object}  [opts]
+ * @param {boolean} [opts.bold=false]
+ * @param {number}  [opts.margin=0.1]  side margin pptxgenjs applies inside a text box
+ * @returns {number} height in inches
+ */
+function estimateTextHeight(text, fontSize, boxWidth, opts = {}) {
+  if (typeof text !== 'string' || text.length === 0) return fontSize / 72;
+
+  const bold = opts.bold === true;
+  const margin = typeof opts.margin === 'number' ? opts.margin : 0.1;
+
+  // Average glyph width as a fraction of font size (pt → in)
+  // Bold text is ~8% wider in typical sans-serif.
+  const charWidthFactor = bold ? 0.0075 : 0.0070;
+  const avgCharWidth = fontSize * charWidthFactor;
+
+  const effectiveWidth = Math.max(boxWidth - margin * 2, 0.1);
+  const charsPerLine = Math.max(1, Math.floor(effectiveWidth / avgCharWidth));
+
+  // Count wrapped lines — words don't break mid-word.
+  // Also respect explicit newlines.
+  const paragraphs = text.split('\n');
+  let lines = 0;
+  for (const p of paragraphs) {
+    if (p.length === 0) { lines += 1; continue; }
+    const words = p.split(/\s+/).filter(Boolean);
+    if (words.length === 0) { lines += 1; continue; }
+    let lineLen = 0;
+    let paraLines = 1;
+    for (const w of words) {
+      const addLen = (lineLen > 0 ? 1 : 0) + w.length;
+      if (lineLen + addLen > charsPerLine && lineLen > 0) {
+        paraLines += 1;
+        lineLen = w.length;
+      } else {
+        lineLen += addLen;
+      }
+    }
+    lines += paraLines;
+  }
+
+  // line-height ≈ 1.3 × fontSize
+  const lineHeight = (fontSize * 1.3) / 72;
+  return Math.max(lines * lineHeight, fontSize / 72);
+}
+
+/**
+ * Find the largest font size in [minSize, maxSize] (integer points) that fits
+ * `text` in a box of `boxW` × `boxH` inches. Returns `minSize` if even that
+ * doesn't fit — caller should allocate more space or shorten the text.
+ *
+ * Use this instead of pptxgenjs `shrinkText: true`, which is inconsistently
+ * respected by Google Slides / LibreOffice PDF export.
+ */
+function fitFontSize(text, maxSize, minSize, boxW, boxH, opts = {}) {
+  if (maxSize < minSize) return minSize;
+  for (let size = Math.floor(maxSize); size >= Math.floor(minSize); size -= 1) {
+    const needed = estimateTextHeight(text, size, boxW, opts);
+    if (needed <= boxH) return size;
+  }
+  return Math.floor(minSize);
+}
+
+// ─── Validation gates ──────────────────────────────────────────────────────
+
+function _fmt(n) { return Number(n).toFixed(2); }
+
+function checkCollisions(elements) {
+  const issues = [];
+  for (let i = 0; i < elements.length; i += 1) {
+    for (let j = i + 1; j < elements.length; j += 1) {
+      const a = elements[i];
+      const b = elements[j];
+      const overlapX = a.x < b.x + b.w && a.x + a.w > b.x;
+      const overlapY = a.y < b.y + b.h && a.y + a.h > b.y;
+      if (overlapX && overlapY) {
+        issues.push(
+          `OVERLAP: "${a.name}" (${_fmt(a.x)},${_fmt(a.y)}→${_fmt(a.x + a.w)},${_fmt(a.y + a.h)}) ` +
+          `↔ "${b.name}" (${_fmt(b.x)},${_fmt(b.y)}→${_fmt(b.x + b.w)},${_fmt(b.y + b.h)})`,
+        );
+      }
+    }
+  }
+  return issues;
+}
+
+function checkBounds(elements, opts = {}) {
+  const safeTop = typeof opts.safeTop === 'number' ? opts.safeTop : LAYOUT.SAFE_TOP;
+  const safeBot = typeof opts.safeBot === 'number' ? opts.safeBot : LAYOUT.SAFE_BOT;
+  const safeL = typeof opts.safeL === 'number' ? opts.safeL : 0;
+  const safeR = typeof opts.safeR === 'number' ? opts.safeR : LAYOUT.SLIDE_W;
+  const issues = [];
+  for (const el of elements) {
+    if (el.y < safeTop) {
+      issues.push(`TOP-OVERFLOW: "${el.name}" starts y=${_fmt(el.y)} (safe top ${_fmt(safeTop)})`);
+    }
+    if (el.y + el.h > safeBot) {
+      issues.push(`BOTTOM-OVERFLOW: "${el.name}" ends y=${_fmt(el.y + el.h)} (safe bottom ${_fmt(safeBot)}) — CLIPPED`);
+    }
+    if (el.x < safeL) {
+      issues.push(`LEFT-OVERFLOW: "${el.name}" starts x=${_fmt(el.x)} (safe left ${_fmt(safeL)})`);
+    }
+    if (el.x + el.w > safeR) {
+      issues.push(`RIGHT-OVERFLOW: "${el.name}" ends x=${_fmt(el.x + el.w)} (safe right ${_fmt(safeR)})`);
+    }
+  }
+  return issues;
+}
+
+function checkTextWrap(elements, opts = {}) {
+  const slack = typeof opts.slack === 'number' ? opts.slack : 1.05;
+  const issues = [];
+  for (const el of elements) {
+    if (typeof el.text !== 'string' || typeof el.fontSize !== 'number') continue;
+    const needed = estimateTextHeight(el.text, el.fontSize, el.w, {
+      bold: el.bold === true,
+      margin: typeof el.margin === 'number' ? el.margin : 0.1,
+    });
+    if (needed > el.h * slack) {
+      issues.push(
+        `TEXT-WRAP: "${el.name}" needs ~${_fmt(needed)}" at ${el.fontSize}pt but got ${_fmt(el.h)}" — ` +
+        `use fitFontSize() to shrink, or increase box height.`,
+      );
+    }
+  }
+  return issues;
+}
+
+/**
+ * Run every gate over every slide's placed elements. Exits the process with
+ * code 1 on any issue — this is intentional. Do not wrap in try/catch.
+ *
+ * @param {Array<[string, Array<object>]>} allSlideElements
+ *   Pairs of [slideName, placedElements[]]. Each element must carry at least
+ *   { name, x, y, w, h }. Text elements must also carry { text, fontSize }
+ *   to participate in the wrap check.
+ */
+function hardGate(allSlideElements, opts = {}) {
+  const issues = [];
+  for (const [slideName, elements] of allSlideElements) {
+    const slideIssues = [
+      ...checkCollisions(elements),
+      ...checkBounds(elements, opts),
+      ...checkTextWrap(elements, opts),
+    ];
+    for (const msg of slideIssues) issues.push(`[${slideName}] ${msg}`);
+  }
+  if (issues.length === 0) {
+    console.log(`✓ Layout gate passed — ${allSlideElements.length} slide(s), zero issues.`);
+    return;
+  }
+  console.error(`\n✗ Layout gate FAILED — ${issues.length} issue(s):\n`);
+  for (const msg of issues) console.error('  ' + msg);
+  console.error('\nFix the slide generator(s) above. Do not add skip flags — the gate has no bypasses.');
+  console.error('For text overflow: use fitFontSize() to compute a real font size, or allocate more box height.');
+  process.exit(1);
+}
+
+// ─── Tracker helper ────────────────────────────────────────────────────────
+
+/**
+ * Convenience factory for tracking placed elements.
+ *
+ *   const { track, placed } = tracker();
+ *   slide.addText(data.title, track('title', { x, y, w, h, text, fontSize, bold }));
+ *   return { name: 'my-slide', elements: placed };
+ *
+ * `track()` returns the same options object so you can inline it into
+ * `slide.addText()` / `slide.addShape()` calls.
+ */
+function tracker() {
+  const placed = [];
+  function track(name, opts) {
+    if (typeof name !== 'string' || !name) {
+      throw new Error('tracker.track(name, opts): name must be a non-empty string');
+    }
+    if (!opts || typeof opts !== 'object') {
+      throw new Error(`tracker.track("${name}", opts): opts is required`);
+    }
+    for (const key of ['x', 'y', 'w', 'h']) {
+      if (typeof opts[key] !== 'number' || !Number.isFinite(opts[key])) {
+        throw new Error(`tracker.track("${name}"): opts.${key} must be a finite number`);
+      }
+    }
+    // Reject bypass flags — the gate has no exemptions.
+    for (const flag of ['skipCollision', 'skipBounds', 'skipWrap']) {
+      if (opts[flag]) {
+        throw new Error(
+          `tracker.track("${name}"): "${flag}" is not a supported option. The layout gate has no bypasses. ` +
+          `Fix the placement or don't track it.`,
+        );
+      }
+    }
+    placed.push({ name, ...opts });
+    return opts;
+  }
+  return { track, placed };
+}
+
+module.exports = {
+  LAYOUT,
+  estimateTextHeight,
+  fitFontSize,
+  checkCollisions,
+  checkBounds,
+  checkTextWrap,
+  hardGate,
+  tracker,
+};

package/node_modules/@groove-dev/daemon/test/classifier.test.js

@@ -82,13 +82,11 @@ describe('TaskClassifier', () => {
   });
 
   it('should maintain sliding window', () => {
-    // Add 60 events — should only keep last 50 (window size)
-    for (let i = 0; i < 60; i++) {
+    const cap = classifier.windowSize;
+    for (let i = 0; i < cap + 10; i++) {
       classifier.addEvent('agent-1', { type: 'tool', tool: 'Read', input: `file${i}.js` });
     }
-
-    // Window should be 50
-    assert.equal(classifier.agentWindows['agent-1'].length, 50);
+    assert.equal(classifier.agentWindows['agent-1'].length, cap);
   });
 
   it('should clear agent window', () => {

package/node_modules/@groove-dev/daemon/test/lockmanager.test.js

@@ -83,4 +83,68 @@ describe('LockManager', () => {
     assert.equal(locks.check('agent-1', 'src/components/App.jsx').conflict, true);
     assert.equal(locks.check('agent-2', 'src/api/auth.js').conflict, true);
   });
+
+  describe('coordination operations', () => {
+    it('declares an operation with no conflict', () => {
+      const result = locks.declareOperation('agent-1', 'npm install', ['package.json']);
+      assert.equal(result.conflict, false);
+      const ops = locks.getOperations();
+      assert.equal(ops['agent-1'].name, 'npm install');
+    });
+
+    it('detects conflict when another agent holds a resource', () => {
+      locks.declareOperation('agent-1', 'npm install', ['package.json']);
+      const result = locks.declareOperation('agent-2', 'edit manifest', ['package.json']);
+      assert.equal(result.conflict, true);
+      assert.equal(result.owner, 'agent-1');
+      assert.equal(result.resource, 'package.json');
+      assert.equal(result.operation, 'npm install');
+    });
+
+    it('allows non-overlapping resource claims', () => {
+      locks.declareOperation('agent-1', 'npm install', ['package.json']);
+      const result = locks.declareOperation('agent-2', 'restart server', ['server:3000']);
+      assert.equal(result.conflict, false);
+    });
+
+    it('same agent can update its own declaration', () => {
+      locks.declareOperation('agent-1', 'edit', ['file-a']);
+      // Same agent can re-declare without conflict
+      const result = locks.declareOperation('agent-1', 'edit', ['file-a', 'file-b']);
+      assert.equal(result.conflict, false);
+    });
+
+    it('completeOperation releases the claim', () => {
+      locks.declareOperation('agent-1', 'npm install', ['package.json']);
+      locks.completeOperation('agent-1');
+
+      const result = locks.declareOperation('agent-2', 'edit', ['package.json']);
+      assert.equal(result.conflict, false);
+    });
+
+    it('operations auto-expire after TTL', () => {
+      locks.declareOperation('agent-1', 'stale op', ['resource-x'], 1);
+      // Wait past TTL
+      const start = Date.now();
+      while (Date.now() - start < 5) { /* spin briefly */ }
+
+      const result = locks.declareOperation('agent-2', 'takeover', ['resource-x']);
+      assert.equal(result.conflict, false);
+    });
+
+    it('rejects malformed declarations', () => {
+      assert.equal(locks.declareOperation(null, 'op', ['r']).conflict, false);
+      assert.equal(locks.declareOperation('a', null, ['r']).conflict, false);
+      assert.equal(locks.declareOperation('a', 'op', []).conflict, false);
+      // All return error flag
+      assert.ok(locks.declareOperation('a', 'op', []).error);
+    });
+
+    it('release() also clears pending operations', () => {
+      locks.declareOperation('agent-1', 'op', ['r']);
+      locks.release('agent-1');
+      const result = locks.declareOperation('agent-2', 'op2', ['r']);
+      assert.equal(result.conflict, false);
+    });
+  });
 });

package/node_modules/@groove-dev/daemon/test/memory.test.js

@@ -0,0 +1,252 @@
+// GROOVE — MemoryStore Tests (Layer 7)
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { MemoryStore } from '../src/memory.js';
+import { mkdtempSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('MemoryStore', () => {
+  let memory;
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'groove-memory-test-'));
+    memory = new MemoryStore(tmpDir);
+  });
+
+  describe('constraints', () => {
+    it('starts with no constraints', () => {
+      assert.deepEqual(memory.listConstraints(), []);
+      assert.equal(memory.getConstraintsMarkdown(), '');
+    });
+
+    it('adds a constraint and returns a hash', () => {
+      const result = memory.addConstraint({ text: 'Never touch packages/daemon/index.js', category: 'hard' });
+      assert.equal(result.added, true);
+      assert.ok(result.hash);
+
+      const list = memory.listConstraints();
+      assert.equal(list.length, 1);
+      assert.equal(list[0].category, 'hard');
+      assert.match(list[0].text, /Never touch/);
+    });
+
+    it('dedups identical constraints', () => {
+      memory.addConstraint({ text: 'ESM only', category: 'pattern' });
+      const result = memory.addConstraint({ text: 'ESM only', category: 'pattern' });
+      assert.equal(result.added, false);
+      assert.equal(result.reason, 'duplicate');
+      assert.equal(memory.listConstraints().length, 1);
+    });
+
+    it('rejects empty and oversized text', () => {
+      assert.equal(memory.addConstraint({ text: '' }).added, false);
+      assert.equal(memory.addConstraint({ text: 'ab' }).added, false);
+      assert.equal(memory.addConstraint({ text: 'x'.repeat(600) }).added, false);
+    });
+
+    it('removes constraints by hash', () => {
+      const r = memory.addConstraint({ text: 'remove me', category: 'test' });
+      assert.equal(memory.removeConstraint(r.hash), true);
+      assert.equal(memory.listConstraints().length, 0);
+      // Removing non-existent hash returns false
+      assert.equal(memory.removeConstraint('nonexistent'), false);
+    });
+
+    it('getConstraintsMarkdown groups by category', () => {
+      memory.addConstraint({ text: 'rule-a', category: 'hard' });
+      memory.addConstraint({ text: 'rule-b', category: 'hard' });
+      memory.addConstraint({ text: 'pattern-x', category: 'pattern' });
+      const md = memory.getConstraintsMarkdown();
+      assert.match(md, /\*\*hard:\*\*/);
+      assert.match(md, /\*\*pattern:\*\*/);
+      assert.match(md, /rule-a/);
+      assert.match(md, /pattern-x/);
+    });
+
+    it('survives restart', () => {
+      memory.addConstraint({ text: 'persists across restart', category: 'test' });
+      const memory2 = new MemoryStore(tmpDir);
+      assert.equal(memory2.listConstraints().length, 1);
+      assert.match(memory2.listConstraints()[0].text, /persists/);
+    });
+  });
+
+  describe('handoff chain', () => {
+    it('starts with no chain', () => {
+      assert.deepEqual(memory.getHandoffChain('backend'), []);
+      assert.equal(memory.getRecentHandoffMarkdown('backend'), '');
+    });
+
+    it('appends a rotation entry', () => {
+      const ok = memory.appendHandoffBrief('backend', {
+        agentId: 'bk-1',
+        newAgentId: 'bk-2',
+        reason: 'context_threshold',
+        oldTokens: 5_000_000,
+        contextUsage: 0.82,
+        brief: 'Finished auth refactor, started on payment flow',
+        timestamp: '2026-04-12T14:00:00Z',
+      });
+      assert.equal(ok, true);
+
+      const chain = memory.getHandoffChain('backend');
+      assert.equal(chain.length, 1);
+      assert.equal(chain[0].rotationN, 1);
+      assert.match(chain[0].body, /Rotation 1/);
+      assert.match(chain[0].body, /context_threshold/);
+    });
+
+    it('increments rotation numbers and keeps newest first', () => {
+      memory.appendHandoffBrief('backend', { brief: 'first' });
+      memory.appendHandoffBrief('backend', { brief: 'second' });
+      memory.appendHandoffBrief('backend', { brief: 'third' });
+
+      const chain = memory.getHandoffChain('backend');
+      assert.equal(chain.length, 3);
+      assert.equal(chain[0].rotationN, 3);
+      assert.equal(chain[2].rotationN, 1);
+    });
+
+    it('caps chain at MAX_HANDOFF_ROTATIONS (10)', () => {
+      for (let i = 0; i < 15; i++) {
+        memory.appendHandoffBrief('backend', { brief: `rotation-${i}` });
+      }
+      const chain = memory.getHandoffChain('backend');
+      assert.equal(chain.length, 10);
+      assert.equal(chain[0].rotationN, 15);
+    });
+
+    it('separate chains per role', () => {
+      memory.appendHandoffBrief('backend', { brief: 'backend work' });
+      memory.appendHandoffBrief('frontend', { brief: 'frontend work' });
+      assert.equal(memory.getHandoffChain('backend').length, 1);
+      assert.equal(memory.getHandoffChain('frontend').length, 1);
+      assert.deepEqual(memory.listHandoffRoles().sort(), ['backend', 'frontend']);
+    });
+
+    it('getRecentHandoffMarkdown returns N newest', () => {
+      for (let i = 0; i < 5; i++) {
+        memory.appendHandoffBrief('backend', { brief: `brief-${i}` });
+      }
+      const md = memory.getRecentHandoffMarkdown('backend', 3);
+      assert.match(md, /brief-4/);
+      assert.match(md, /brief-3/);
+      assert.match(md, /brief-2/);
+      assert.ok(!md.includes('brief-1'));
+    });
+
+    it('sanitizes role names for filesystem safety', () => {
+      const ok = memory.appendHandoffBrief('../evil/role', { brief: 'test' });
+      assert.equal(ok, true);
+      // File should be created with safe name, no path traversal
+      assert.ok(existsSync(tmpDir));
+    });
+  });
+
+  describe('discoveries', () => {
+    it('starts with no discoveries', () => {
+      assert.deepEqual(memory.listDiscoveries(), []);
+      assert.equal(memory.getDiscoveriesMarkdown(), '');
+    });
+
+    it('adds a success discovery', () => {
+      const result = memory.addDiscovery({
+        agentId: 'bk-1',
+        role: 'backend',
+        trigger: 'Cannot find module gray-matter',
+        fix: 'npm install gray-matter',
+        outcome: 'success',
+      });
+      assert.equal(result.added, true);
+
+      const list = memory.listDiscoveries();
+      assert.equal(list.length, 1);
+      assert.equal(list[0].role, 'backend');
+    });
+
+    it('rejects non-success outcomes', () => {
+      const result = memory.addDiscovery({
+        trigger: 'err',
+        fix: 'did not work',
+        outcome: 'failed',
+      });
+      assert.equal(result.added, false);
+    });
+
+    it('rejects incomplete records', () => {
+      assert.equal(memory.addDiscovery({ trigger: 'x' }).added, false);
+      assert.equal(memory.addDiscovery({ fix: 'y' }).added, false);
+    });
+
+    it('dedups identical trigger+fix pairs', () => {
+      memory.addDiscovery({ trigger: 'error X', fix: 'fix X' });
+      const result = memory.addDiscovery({ trigger: 'error X', fix: 'fix X' });
+      assert.equal(result.added, false);
+      assert.equal(result.reason, 'duplicate');
+    });
+
+    it('filters by role', () => {
+      memory.addDiscovery({ role: 'backend', trigger: 'a', fix: 'fa' });
+      memory.addDiscovery({ role: 'frontend', trigger: 'b', fix: 'fb' });
+      memory.addDiscovery({ role: 'backend', trigger: 'c', fix: 'fc' });
+
+      assert.equal(memory.listDiscoveries({ role: 'backend' }).length, 2);
+      assert.equal(memory.listDiscoveries({ role: 'frontend' }).length, 1);
+      assert.equal(memory.listDiscoveries().length, 3);
+    });
+
+    it('getDiscoveriesMarkdown formats for agent consumption', () => {
+      memory.addDiscovery({ role: 'backend', trigger: 'X error', fix: 'do Y' });
+      const md = memory.getDiscoveriesMarkdown('backend');
+      assert.match(md, /X error/);
+      assert.match(md, /do Y/);
+    });
+  });
+
+  describe('specializations', () => {
+    it('starts empty', () => {
+      const all = memory.getAllSpecializations();
+      assert.deepEqual(all.perAgent, {});
+      assert.deepEqual(all.perProjectRole, {});
+    });
+
+    it('updates an agent profile', () => {
+      memory.updateSpecialization('bk-1', {
+        role: 'backend',
+        qualityScore: 80,
+        filesTouched: ['src/a.js', 'src/b.js'],
+      });
+      const spec = memory.getSpecialization('bk-1');
+      assert.ok(spec);
+      assert.equal(spec.role, 'backend');
+      assert.equal(spec.avgQualityScore, 80);
+      assert.equal(spec.sessionCount, 1);
+      assert.equal(spec.fileTouches['src/a.js'], 1);
+    });
+
+    it('averages quality score across sessions', () => {
+      memory.updateSpecialization('bk-1', { role: 'backend', qualityScore: 70 });
+      memory.updateSpecialization('bk-1', { role: 'backend', qualityScore: 90 });
+      assert.equal(memory.getSpecialization('bk-1').avgQualityScore, 80);
+      assert.equal(memory.getSpecialization('bk-1').sessionCount, 2);
+    });
+
+    it('aggregates per-role stats', () => {
+      memory.updateSpecialization('bk-1', { role: 'backend', qualityScore: 80 });
+      memory.updateSpecialization('bk-2', { role: 'backend', qualityScore: 60 });
+      const all = memory.getAllSpecializations();
+      assert.equal(all.perProjectRole.backend.sessionCount, 2);
+      assert.equal(all.perProjectRole.backend.avgQualityScore, 70);
+    });
+
+    it('survives restart', () => {
+      memory.updateSpecialization('bk-1', { role: 'backend', qualityScore: 75 });
+      const memory2 = new MemoryStore(tmpDir);
+      assert.equal(memory2.getSpecialization('bk-1').avgQualityScore, 75);
+    });
+  });
+});