groove-dev 0.26.39 → 0.27.0

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

@@ -0,0 +1,370 @@
+// GROOVE — Persistent Agent Memory (Layer 7)
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Four file types, all in .groove/memory/:
+//   - project-constraints.md    Discovered project rules, do-not-touch, required patterns
+//   - handoff-chain/<role>.md   Cumulative rotation briefs (newest first, last 10 kept)
+//   - agent-discoveries.jsonl   Error→fix pairs (only successes stored)
+//   - agent-specializations.json Per-agent and per-project-role quality profiles
+//
+// Read by the introducer on every spawn so agent #50 knows what agent #1 learned.
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, appendFileSync, statSync } from 'fs';
+import { resolve } from 'path';
+import { createHash } from 'crypto';
+
+const MAX_CONSTRAINTS = 50;
+const MAX_HANDOFF_ROTATIONS = 10;
+const MAX_DISCOVERIES = 1000;
+const HANDOFF_BRIEF_MAX_CHARS = 4000;
+
+function hashText(text) {
+  return createHash('sha1').update(text.trim().toLowerCase()).digest('hex').slice(0, 12);
+}
+
+function safeName(role) {
+  return (role || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 40);
+}
+
+function truncate(text, max) {
+  if (!text || text.length <= max) return text || '';
+  return text.slice(0, max - 3) + '...';
+}
+
+export class MemoryStore {
+  constructor(grooveDir) {
+    this.memDir = resolve(grooveDir, 'memory');
+    this.constraintsPath = resolve(this.memDir, 'project-constraints.md');
+    this.handoffDir = resolve(this.memDir, 'handoff-chain');
+    this.discoveriesPath = resolve(this.memDir, 'agent-discoveries.jsonl');
+    this.specializationsPath = resolve(this.memDir, 'agent-specializations.json');
+    this._ensureDirs();
+  }
+
+  _ensureDirs() {
+    try {
+      mkdirSync(this.memDir, { recursive: true });
+      mkdirSync(this.handoffDir, { recursive: true });
+    } catch { /* best-effort */ }
+  }
+
+  // --- Project Constraints ---
+
+  listConstraints() {
+    if (!existsSync(this.constraintsPath)) return [];
+    try {
+      const content = readFileSync(this.constraintsPath, 'utf8');
+      const constraints = [];
+      const blocks = content.split(/\n(?=- )/); // each constraint starts with "- "
+      for (const block of blocks) {
+        const m = block.match(/^- \[([a-f0-9]+)\] \*([^*]+)\* (.+)$/s);
+        if (m) {
+          constraints.push({
+            hash: m[1],
+            category: m[2].trim(),
+            text: m[3].trim(),
+          });
+        }
+      }
+      return constraints;
+    } catch {
+      return [];
+    }
+  }
+
+  addConstraint({ text, category = 'general' }) {
+    if (!text || typeof text !== 'string') return { added: false, error: 'text required' };
+    const trimmed = text.trim();
+    if (trimmed.length < 3) return { added: false, error: 'text too short' };
+    if (trimmed.length > 500) return { added: false, error: 'text too long (max 500 chars)' };
+
+    const hash = hashText(trimmed);
+    const existing = this.listConstraints();
+    if (existing.some((c) => c.hash === hash)) {
+      return { added: false, hash, reason: 'duplicate' };
+    }
+
+    existing.push({ hash, category, text: trimmed });
+    // Keep most recent MAX_CONSTRAINTS
+    const pruned = existing.slice(-MAX_CONSTRAINTS);
+    this._writeConstraints(pruned);
+    return { added: true, hash };
+  }
+
+  removeConstraint(hash) {
+    const existing = this.listConstraints();
+    const filtered = existing.filter((c) => c.hash !== hash);
+    if (filtered.length === existing.length) return false;
+    this._writeConstraints(filtered);
+    return true;
+  }
+
+  _writeConstraints(constraints) {
+    const lines = [
+      '# Project Constraints',
+      `*Auto-managed by GROOVE memory (Layer 7). Last updated: ${new Date().toISOString()}*`,
+      '',
+    ];
+    for (const c of constraints) {
+      lines.push(`- [${c.hash}] *${c.category}* ${c.text}`);
+    }
+    lines.push('');
+    try {
+      writeFileSync(this.constraintsPath, lines.join('\n'));
+    } catch { /* best-effort */ }
+  }
+
+  getConstraintsMarkdown(maxChars = 4000) {
+    const constraints = this.listConstraints();
+    if (constraints.length === 0) return '';
+    const byCategory = {};
+    for (const c of constraints) {
+      byCategory[c.category] = byCategory[c.category] || [];
+      byCategory[c.category].push(c.text);
+    }
+    const lines = [];
+    for (const [cat, items] of Object.entries(byCategory)) {
+      lines.push(`**${cat}:**`);
+      for (const item of items) lines.push(`- ${item}`);
+      lines.push('');
+    }
+    return truncate(lines.join('\n').trim(), maxChars);
+  }
+
+  // --- Handoff Chain ---
+
+  _chainPath(role) {
+    return resolve(this.handoffDir, `${safeName(role)}.md`);
+  }
+
+  getHandoffChain(role) {
+    const path = this._chainPath(role);
+    if (!existsSync(path)) return [];
+    try {
+      const content = readFileSync(path, 'utf8');
+      const entries = [];
+      // Parse entries — each starts with "## Rotation N —"
+      // Body includes the header + all content up to (but not including) the
+      // trailing --- separator and the next entry.
+      const blocks = content.split(/\n(?=## Rotation )/);
+      for (const block of blocks) {
+        const headerMatch = block.match(/^## Rotation (\d+) —/);
+        if (!headerMatch) continue;
+        const body = block.replace(/\n---\s*$/, '').trim();
+        entries.push({
+          rotationN: parseInt(headerMatch[1], 10),
+          body,
+        });
+      }
+      return entries;
+    } catch {
+      return [];
+    }
+  }
+
+  appendHandoffBrief(role, entry) {
+    if (!role || !entry) return false;
+    const chain = this.getHandoffChain(role);
+    const nextN = (chain[0]?.rotationN || 0) + 1;
+
+    const block = [
+      `## Rotation ${nextN} — ${entry.timestamp || new Date().toISOString()} (${entry.agentId || '?'} → ${entry.newAgentId || '?'})`,
+      `**Reason:** ${entry.reason || 'unknown'}`,
+      entry.oldTokens != null ? `**Tokens carried:** ${entry.oldTokens.toLocaleString()}` : '',
+      entry.contextUsage != null ? `**Context at rotation:** ${Math.round(entry.contextUsage * 100)}%` : '',
+      '',
+      '**Brief summary:**',
+      truncate(entry.brief || '(no brief)', HANDOFF_BRIEF_MAX_CHARS),
+      '',
+    ].filter(Boolean).join('\n');
+
+    // Prepend new entry (newest first), keep last N
+    const newChain = [{ rotationN: nextN, body: block }, ...chain].slice(0, MAX_HANDOFF_ROTATIONS);
+
+    const lines = [
+      `# ${role[0].toUpperCase() + role.slice(1)} Handoff Chain`,
+      `*Cumulative rotation briefs. Newest first. Last ${MAX_HANDOFF_ROTATIONS} kept.*`,
+      '',
+    ];
+    for (const e of newChain) {
+      lines.push(e.body || '');
+      lines.push('---');
+      lines.push('');
+    }
+
+    try {
+      writeFileSync(this._chainPath(role), lines.join('\n'));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  getRecentHandoffMarkdown(role, count = 3, maxChars = 4000) {
+    const chain = this.getHandoffChain(role);
+    if (chain.length === 0) return '';
+    const recent = chain.slice(0, count);
+    const out = recent.map((e) => e.body || '').join('\n\n---\n\n');
+    return truncate(out, maxChars);
+  }
+
+  listHandoffRoles() {
+    if (!existsSync(this.handoffDir)) return [];
+    try {
+      return readdirSync(this.handoffDir)
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => f.replace(/\.md$/, ''));
+    } catch {
+      return [];
+    }
+  }
+
+  // --- Discoveries (error → fix pairs) ---
+
+  addDiscovery({ agentId, role, trigger, fix, outcome = 'success' }) {
+    if (!trigger || !fix) return { added: false, error: 'trigger and fix required' };
+    if (outcome !== 'success') return { added: false, reason: 'only successes stored' };
+
+    const entry = {
+      ts: new Date().toISOString(),
+      agentId: agentId || null,
+      role: role || 'unknown',
+      trigger: truncate(String(trigger).trim(), 300),
+      fix: truncate(String(fix).trim(), 500),
+      outcome,
+    };
+
+    // Dedup: same trigger+fix = skip
+    const existing = this.listDiscoveries({ limit: 200 });
+    const key = hashText(entry.trigger + '||' + entry.fix);
+    if (existing.some((d) => hashText(d.trigger + '||' + d.fix) === key)) {
+      return { added: false, reason: 'duplicate' };
+    }
+
+    try {
+      appendFileSync(this.discoveriesPath, JSON.stringify(entry) + '\n');
+      this._pruneDiscoveries();
+      return { added: true };
+    } catch (err) {
+      return { added: false, error: err.message };
+    }
+  }
+
+  listDiscoveries({ role, limit = 100 } = {}) {
+    if (!existsSync(this.discoveriesPath)) return [];
+    try {
+      const lines = readFileSync(this.discoveriesPath, 'utf8').split('\n').filter(Boolean);
+      const entries = [];
+      for (const line of lines) {
+        try {
+          const e = JSON.parse(line);
+          if (!role || e.role === role) entries.push(e);
+        } catch { /* skip malformed */ }
+      }
+      return entries.slice(-limit).reverse(); // newest first
+    } catch {
+      return [];
+    }
+  }
+
+  _pruneDiscoveries() {
+    if (!existsSync(this.discoveriesPath)) return;
+    try {
+      const stat = statSync(this.discoveriesPath);
+      // Only prune on larger files to avoid thrashing
+      if (stat.size < 50_000) return;
+      const lines = readFileSync(this.discoveriesPath, 'utf8').split('\n').filter(Boolean);
+      if (lines.length <= MAX_DISCOVERIES) return;
+      const kept = lines.slice(-MAX_DISCOVERIES);
+      writeFileSync(this.discoveriesPath, kept.join('\n') + '\n');
+    } catch { /* best-effort */ }
+  }
+
+  getDiscoveriesMarkdown(role, limit = 20, maxChars = 4000) {
+    const entries = this.listDiscoveries({ role, limit });
+    if (entries.length === 0) return '';
+    const lines = entries.map((d) => `- When \`${d.trigger}\` → fix: ${d.fix}`);
+    return truncate(lines.join('\n'), maxChars);
+  }
+
+  // --- Specializations ---
+
+  _loadSpecializations() {
+    if (!existsSync(this.specializationsPath)) {
+      return { perAgent: {}, perProjectRole: {} };
+    }
+    try {
+      const data = JSON.parse(readFileSync(this.specializationsPath, 'utf8'));
+      return {
+        perAgent: data.perAgent || {},
+        perProjectRole: data.perProjectRole || {},
+      };
+    } catch {
+      return { perAgent: {}, perProjectRole: {} };
+    }
+  }
+
+  _saveSpecializations(data) {
+    try {
+      writeFileSync(this.specializationsPath, JSON.stringify(data, null, 2));
+    } catch { /* best-effort */ }
+  }
+
+  updateSpecialization(agentId, { role, qualityScore, filesTouched, signals, threshold }) {
+    if (!agentId) return false;
+    const data = this._loadSpecializations();
+
+    const agentEntry = data.perAgent[agentId] || {
+      role: role || 'unknown',
+      sessionCount: 0,
+      avgQualityScore: 0,
+      qualityTotal: 0,
+      fileTouches: {},
+      signatureErrors: [],
+    };
+    agentEntry.sessionCount += 1;
+    if (typeof qualityScore === 'number') {
+      agentEntry.qualityTotal += qualityScore;
+      agentEntry.avgQualityScore = Math.round(agentEntry.qualityTotal / agentEntry.sessionCount);
+    }
+    if (Array.isArray(filesTouched)) {
+      for (const f of filesTouched) {
+        agentEntry.fileTouches[f] = (agentEntry.fileTouches[f] || 0) + 1;
+      }
+    }
+    if (role) agentEntry.role = role;
+    if (threshold != null) agentEntry.preferredThreshold = threshold;
+    data.perAgent[agentId] = agentEntry;
+
+    if (role) {
+      const roleEntry = data.perProjectRole[role] || {
+        sessionCount: 0,
+        avgQualityScore: 0,
+        qualityTotal: 0,
+        topFileChurn: {},
+      };
+      roleEntry.sessionCount += 1;
+      if (typeof qualityScore === 'number') {
+        roleEntry.qualityTotal += qualityScore;
+        roleEntry.avgQualityScore = Math.round(roleEntry.qualityTotal / roleEntry.sessionCount);
+      }
+      if (Array.isArray(filesTouched)) {
+        for (const f of filesTouched) {
+          roleEntry.topFileChurn[f] = (roleEntry.topFileChurn[f] || 0) + 1;
+        }
+      }
+      data.perProjectRole[role] = roleEntry;
+    }
+
+    this._saveSpecializations(data);
+    return true;
+  }
+
+  getSpecialization(agentId) {
+    return this._loadSpecializations().perAgent[agentId] || null;
+  }
+
+  getAllSpecializations() {
+    return this._loadSpecializations();
+  }
+}

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

@@ -54,7 +54,7 @@ Review: Is this within scope? Conflicts with other agents? Aligns with project?
 Respond in ONE line: APPROVED: <reason> or REJECTED: <reason>`;
 
     try {
-      const result = await this.daemon.journalist.callHeadless(prompt);
+      const result = await this.daemon.journalist.callHeadless(prompt, { trackAs: '__pm__' });
       const text = (result || '').trim();
       const approved = !text.toUpperCase().startsWith('REJECTED');
       const reason = text.replace(/^(APPROVED|REJECTED):?\s*/i, '').trim();

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

@@ -719,6 +719,25 @@ For normal file edits within your scope, proceed without review.
         // Process cross-scope handoff requests from this agent
         this._processHandoffs(agent);
       }
+
+      // Update Layer 7 specialization profile for this agent's session
+      if (this.daemon.memory && (finalStatus === 'completed' || finalStatus === 'crashed')) {
+        try {
+          const events = this.daemon.classifier?.agentWindows?.[agent.id] || [];
+          const signals = events.length >= 6
+            ? this.daemon.adaptive.extractSignals(events, agent.scope)
+            : null;
+          const score = signals ? this.daemon.adaptive.scoreSession(signals) : null;
+          const files = this.daemon.journalist?.getAgentFiles(agent) || [];
+          this.daemon.memory.updateSpecialization(agent.id, {
+            role: agent.role,
+            qualityScore: score,
+            filesTouched: files,
+            signals,
+            threshold: this.daemon.adaptive?.getThreshold(agent.provider, agent.role),
+          });
+        } catch { /* best-effort */ }
+      }
     });
 
     proc.on('error', (err) => {
@@ -1278,7 +1297,7 @@ For normal file edits within your scope, proceed without review.
     ].join('\n');
 
     try {
-      const response = await journalist.callHeadless(prompt);
+      const response = await journalist.callHeadless(prompt, { trackAs: '__negotiator__' });
       return response;
     } catch {
       // Fallback: return raw data for the agent to interpret

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

@@ -7,10 +7,11 @@ import { resolve } from 'path';
 
 const DEFAULT_THRESHOLD = 0.75;
 const CHECK_INTERVAL = 15_000;
-const QUALITY_THRESHOLD = 40;   // Score below this triggers quality rotation
-const MIN_EVENTS = 10;          // Minimum classifier events before scoring
+const QUALITY_THRESHOLD = 55;   // Score below this triggers quality rotation (tuned up from 40 — too hair-trigger)
+const MIN_EVENTS = 30;          // Minimum classifier events before scoring (tuned up from 10 — ~100 turns for stable signal)
 const MIN_AGE_SEC = 120;        // Minimum agent age before quality rotation
 const SCORE_HISTORY_MAX = 40;   // ~10 min at 15s intervals
+const ROTATION_COOLDOWN_MS = 5 * 60 * 1000; // 5 min between rotations per agent — prevents churn on persistent low quality
 
 export class Rotator extends EventEmitter {
   constructor(daemon) {
@@ -96,6 +97,18 @@ export class Rotator extends EventEmitter {
       : Infinity;
   }
 
+  // Check if this agent rotated recently. Prevents back-to-back rotation
+  // churn when quality score stays low post-rotation (e.g. genuinely hard task).
+  // Safety triggers bypass cooldown — pathological burn must be stopped.
+  _isInCooldown(agent) {
+    const last = [...this.rotationHistory]
+      .reverse()
+      .find((r) => r.newAgentId === agent.id || r.agentId === agent.id);
+    if (!last) return false;
+    const elapsed = Date.now() - new Date(last.timestamp).getTime();
+    return elapsed < ROTATION_COOLDOWN_MS;
+  }
+
   scoreLiveSession(agent) {
     const events = this.daemon.classifier.agentWindows[agent.id] || [];
     const ageSec = (Date.now() - new Date(agent.spawnedAt).getTime()) / 1000;
@@ -123,13 +136,89 @@ export class Rotator extends EventEmitter {
     return result;
   }
 
+  // Safety triggers — runaway agent detection. Scoped to `spawnedAt` so
+  // a rotation doesn't re-trigger on inherited cumulative tokens.
+  _checkSafetyTriggers(agent) {
+    const safety = this.daemon.config?.safety;
+    if (!safety || safety.autoRotate === false) return null;
+    if (!this.daemon.tokens || !agent.spawnedAt) return null;
+
+    const spawnedAtMs = new Date(agent.spawnedAt).getTime();
+    const ceiling = safety.tokenCeilingPerAgent;
+    if (ceiling > 0) {
+      const instanceTokens = this.daemon.tokens.getTokensInWindow(agent.id, spawnedAtMs);
+      if (instanceTokens >= ceiling) {
+        return {
+          reason: 'token_limit_exceeded',
+          instanceTokens,
+          ceiling,
+        };
+      }
+    }
+
+    const windowMs = (safety.velocityWindowSeconds || 300) * 1000;
+    const velocityThreshold = safety.velocityTokenThreshold;
+    if (velocityThreshold > 0) {
+      const velocity = this.daemon.tokens.getVelocity(agent.id, windowMs);
+      if (velocity >= velocityThreshold) {
+        return {
+          reason: 'runaway_velocity',
+          velocity,
+          windowMs,
+          threshold: velocityThreshold,
+        };
+      }
+    }
+
+    return null;
+  }
+
+  // Compute post-rotation velocity for rotations that are old enough to
+  // have meaningful data. Replaces hardcoded savings assumptions with
+  // measured deltas. Positive velocityDelta = rotation reduced burn rate.
+  _finalizeRotationMeasurements() {
+    if (!this.daemon.tokens?.getVelocity) return;
+    const now = Date.now();
+    let modified = false;
+    for (const record of this.rotationHistory) {
+      if (record.postRotationVelocity != null) continue;
+      if (record.preRotationVelocity == null) continue;
+      if (!record.newAgentId) continue;
+      const rotatedAt = new Date(record.timestamp).getTime();
+      if (now - rotatedAt < 600_000) continue; // need 10 min of post-data
+      const postVelocity = this.daemon.tokens.getVelocity(record.newAgentId, 600_000);
+      record.postRotationVelocity = postVelocity;
+      record.velocityDelta = record.preRotationVelocity - postVelocity;
+      modified = true;
+    }
+    if (modified) this._saveHistory();
+  }
+
   async check() {
+    this._finalizeRotationMeasurements();
+
     const agents = this.daemon.registry.getAll();
     const running = agents.filter((a) => a.status === 'running');
 
     for (const agent of running) {
       if (this.rotating.has(agent.id)) continue;
 
+      // Safety triggers — highest priority, pathological behavior.
+      // Bypasses cooldown: pathological burn must be stopped immediately.
+      const safety = this._checkSafetyTriggers(agent);
+      if (safety) {
+        const summary = safety.reason === 'token_limit_exceeded'
+          ? `${safety.instanceTokens} tokens >= ${safety.ceiling} ceiling`
+          : `${safety.velocity} tokens in ${safety.windowMs / 1000}s >= ${safety.threshold} threshold`;
+        console.log(`  Rotator: ${agent.name} ${safety.reason} (${summary}) — auto-rotating`);
+        await this.rotate(agent.id, safety);
+        continue;
+      }
+
+      // Cooldown check — skip threshold-based rotations if agent just rotated.
+      // Gives the new instance time to stabilize before another judgment.
+      if (this._isInCooldown(agent)) continue;
+
       const threshold = this.daemon.adaptive
         ? this.daemon.adaptive.getThreshold(agent.provider, agent.role)
         : DEFAULT_THRESHOLD;
@@ -143,11 +232,17 @@ export class Rotator extends EventEmitter {
         }
       }
 
-      // Quality-based rotation — detects degradation before tokens are wasted
+      // Quality-based rotation — detects degradation before tokens are wasted.
+      // Converged provider:role profiles have stable thresholds already, so
+      // skip quality rotation there unless score is catastrophically low.
       const quality = this.scoreLiveSession(agent);
       if (quality.hasEnoughData && quality.score < QUALITY_THRESHOLD) {
-        if (this._idleMs(agent) > 10_000) {
-          console.log(`  Rotator: ${agent.name} quality=${quality.score} — rotating (quality)`);
+        const profile = this.daemon.adaptive?.getProfile?.(agent.provider, agent.role);
+        const converged = profile?.converged;
+        // If converged, require a deeper score drop before rotating
+        const floor = converged ? QUALITY_THRESHOLD - 15 : QUALITY_THRESHOLD;
+        if (quality.score < floor && this._idleMs(agent) > 10_000) {
+          console.log(`  Rotator: ${agent.name} quality=${quality.score}${converged ? ' (converged profile)' : ''} — rotating (quality)`);
           await this.rotate(agent.id, {
             reason: 'quality_degradation',
             qualityScore: quality.score,
@@ -191,6 +286,13 @@ export class Rotator extends EventEmitter {
         brief = brief + '\n\n## User Instruction\n\n' + options.additionalPrompt;
       }
 
+      // Capture pre-rotation velocity (tokens/10min) so we can later measure
+      // whether the rotation actually improved token efficiency. Stored in
+      // history; finalized by _finalizeRotationMeasurements() on later ticks.
+      const preRotationVelocity = this.daemon.tokens?.getVelocity
+        ? this.daemon.tokens.getVelocity(agent.id, 600_000)
+        : null;
+
       const record = {
         agentId: agent.id,
         agentName: agent.name,
@@ -200,9 +302,22 @@ export class Rotator extends EventEmitter {
         contextUsage: agent.contextUsage,
         reason: options.reason || 'manual',
         qualityScore: options.qualityScore || null,
+        instanceTokens: options.instanceTokens || null,
+        velocity: options.velocity || null,
+        preRotationVelocity,
+        postRotationVelocity: null,
+        velocityDelta: null,
         timestamp: new Date().toISOString(),
       };
 
+      // Capture per-session signals for specialization tracking before we clear
+      const sessionSignals = classifierEvents.length > 0
+        ? this.daemon.adaptive.extractSignals(classifierEvents, agent.scope)
+        : null;
+      const sessionScore = sessionSignals
+        ? this.daemon.adaptive.scoreSession(sessionSignals)
+        : null;
+
       await processes.kill(agentId);
 
       const routingMode = this.daemon.router.getMode(agentId);
@@ -236,6 +351,35 @@ export class Rotator extends EventEmitter {
       }
       this._saveHistory();
 
+      // Append to persistent handoff chain (Layer 7 memory)
+      // so agent #50 knows what agent #1 struggled with.
+      if (this.daemon.memory) {
+        this.daemon.memory.appendHandoffBrief(agent.role, {
+          agentId: agent.id,
+          newAgentId: newAgent.id,
+          reason: record.reason,
+          oldTokens: agent.tokensUsed,
+          contextUsage: agent.contextUsage,
+          brief,
+          timestamp: record.timestamp,
+        });
+
+        // Update per-agent + per-role specialization profile
+        const files = Array.from(new Set(
+          classifierEvents
+            .map((e) => e.input || e.file || e.path)
+            .filter((f) => typeof f === 'string' && f.length > 0)
+            .slice(-20)
+        ));
+        this.daemon.memory.updateSpecialization(agent.id, {
+          role: agent.role,
+          qualityScore: sessionScore,
+          filesTouched: files,
+          signals: sessionSignals,
+          threshold: this.daemon.adaptive?.getThreshold(agent.provider, agent.role),
+        });
+      }
+
       if (this.daemon.timeline) {
         this.daemon.timeline.recordEvent('rotate', {
           agentId: newAgent.id, oldAgentId: agentId,
@@ -243,6 +387,8 @@ export class Rotator extends EventEmitter {
           tokensBefore: agent.tokensUsed,
           reason: record.reason,
           qualityScore: record.qualityScore,
+          instanceTokens: record.instanceTokens,
+          velocity: record.velocity,
         });
       }
 
@@ -332,6 +478,8 @@ export class Rotator extends EventEmitter {
     const qualityRotations = this.rotationHistory.filter((r) => r.reason === 'quality_degradation').length;
     const contextRotations = this.rotationHistory.filter((r) => r.reason === 'context_threshold').length;
     const naturalCompactions = this.rotationHistory.filter((r) => r.reason === 'natural_compaction').length;
+    const tokenLimitRotations = this.rotationHistory.filter((r) => r.reason === 'token_limit_exceeded').length;
+    const velocityRotations = this.rotationHistory.filter((r) => r.reason === 'runaway_velocity').length;
     return {
       enabled: this.enabled,
       totalRotations,
@@ -339,6 +487,8 @@ export class Rotator extends EventEmitter {
       qualityRotations,
       contextRotations,
       naturalCompactions,
+      tokenLimitRotations,
+      velocityRotations,
       rotating: Array.from(this.rotating),
       liveScores: this.liveScores,
       scoreHistory: this.scoreHistory,