groove-dev 0.27.134 → 0.27.136

package/moe-training/client/domain-tagger.js

@@ -2,7 +2,7 @@
 
 import { EMBEDDING_SERVICE_URL } from '../shared/constants.js';
 
-const DEFAULT_MODEL = 'BAAI/bge-small-en-v1.5';
+const DEFAULT_MODEL = 'BAAI/bge-base-en-v1.5';
 const DEFAULT_TOP_K = 3;
 
 // ~40 domains covering broad technical territory.

package/moe-training/scripts/retag-delegate-yield.js

@@ -0,0 +1,303 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Retroactive tagger: scans planner/fullstack session envelopes and re-tags
+// delegation dispatches as "delegate" steps and artifact handoffs as "yield" steps.
+//
+// Usage:
+//   node retag-delegate-yield.js <input.jsonl> [output.jsonl]
+//
+// If output is omitted, writes to stdout. Input can also be piped via stdin.
+// Only modifies planner/fullstack trajectory envelopes — SESSION_CLOSE and
+// USER_FEEDBACK envelopes pass through unchanged.
+
+import { createReadStream, createWriteStream, existsSync } from 'fs';
+import { createInterface } from 'readline';
+
+// --- Pattern A: Delegation detection ---
+// A thought step reasoning about needing a specialist, followed by an action
+// that dispatches to another agent. The dispatch action+observation get replaced
+// with a single delegate step.
+
+const DELEGATION_THOUGHT_RE = /\b(specialist|dispatch|delegate|hand off|route to|needs? a .*(backend|frontend|fullstack|database|devops|planner)|re-route|different agent|another agent|pass this to)\b/i;
+
+const DELEGATION_ACTION_RE = /\b(dispatch|spawn|agent|delegate|hand off|route|assign)\b/i;
+
+const AGENT_ID_RE = /\b(backend|frontend|fullstack|planner|devops|database|chat|advisor|qc)[-_]?\d+\b/gi;
+
+function isDelegationThought(step) {
+  if (step.type !== 'thought') return false;
+  return DELEGATION_THOUGHT_RE.test(step.content || '');
+}
+
+function isDelegationAction(step) {
+  if (step.type !== 'action') return false;
+  const tool = (step.tool || '').toLowerCase();
+  const content = (step.content || '').toLowerCase();
+  if (tool === 'agent' || tool === 'dispatch') return true;
+  if (DELEGATION_ACTION_RE.test(content)) return true;
+  return false;
+}
+
+function extractDelegateTask(actionStep, observationStep) {
+  let task = '';
+  const content = actionStep.content || '';
+  const args = actionStep.arguments || {};
+
+  // Try to extract the task from arguments (e.g. Agent tool input)
+  if (args.prompt) {
+    task = args.prompt;
+  } else if (args.message) {
+    task = args.message;
+  } else if (args.task) {
+    task = args.task;
+  }
+
+  // Fall back to parsing the content after "Dispatch to X:" or similar
+  if (!task) {
+    const match = content.match(/(?:dispatch(?:ed)? to \S+:\s*|:\s*)(.*)/i);
+    task = match ? match[1] : content;
+  }
+
+  // Strip agent ID references — the router picks the target, not the delegator
+  task = task.replace(AGENT_ID_RE, '').replace(/\s{2,}/g, ' ').trim();
+
+  return task;
+}
+
+// --- Pattern B: Yield detection ---
+// An action(Write/Edit) producing a file, followed by observation(success),
+// followed by a resolution whose content suggests artifact handoff to another agent.
+
+const WRITE_TOOLS = new Set(['write', 'edit', 'create', 'save']);
+
+const YIELD_RESOLUTION_RE = /\b(next agent|can now|build on this|picks? up|hand(?:ed|s|ing)? off|artifact|ready for|phase complete|my part is done|produced|output for)\b/i;
+
+function isWriteAction(step) {
+  if (step.type !== 'action') return false;
+  const tool = (step.tool || '').toLowerCase();
+  return WRITE_TOOLS.has(tool);
+}
+
+function isSuccessObservation(step) {
+  if (step.type !== 'observation') return false;
+  const c = (step.content || '').toLowerCase();
+  if (step.is_error) return false;
+  return !c.includes('error') || c.includes('0 error');
+}
+
+function isYieldResolution(step) {
+  if (step.type !== 'resolution') return false;
+  return YIELD_RESOLUTION_RE.test(step.content || '');
+}
+
+function extractFilePath(writeStep) {
+  const args = writeStep.arguments || {};
+  if (args.file_path) return args.file_path;
+  if (args.path) return args.path;
+
+  // Try to parse path from content
+  const content = writeStep.content || '';
+  const match = content.match(/(?:Writing|Wrote|Created?|Saving?|Edit(?:ing|ed)?)\s+(\S+\.\w+)/i);
+  return match ? match[1] : null;
+}
+
+function buildYieldSummary(resolutionStep, maxTokens = 20) {
+  const content = (resolutionStep.content || '').trim();
+  // Take first sentence, cap at ~80 chars for ~20 tokens
+  const firstSentence = content.split(/[.!?\n]/)[0].trim();
+  return firstSentence.slice(0, 80);
+}
+
+// --- Main retagging logic ---
+
+function retagTrajectory(steps) {
+  if (!Array.isArray(steps) || steps.length < 2) return { steps, delegateCount: 0, yieldCount: 0 };
+
+  const result = [];
+  let delegateCount = 0;
+  let yieldCount = 0;
+  let i = 0;
+
+  while (i < steps.length) {
+    // Pattern A: thought(delegation) → action(dispatch) → observation → ...
+    // Replace action+observation with a single delegate step
+    if (i + 2 < steps.length &&
+        isDelegationThought(steps[i]) &&
+        isDelegationAction(steps[i + 1])) {
+
+      // Keep the thought
+      result.push({ ...steps[i] });
+
+      const actionStep = steps[i + 1];
+      const nextStep = steps[i + 2];
+      const obsStep = nextStep.type === 'observation' ? nextStep : null;
+
+      const task = extractDelegateTask(actionStep, obsStep);
+
+      if (task) {
+        result.push({
+          step: actionStep.step,
+          type: 'delegate',
+          content: task,
+          timestamp: actionStep.timestamp,
+          token_count: Math.max(1, Math.ceil(task.length / 4)),
+        });
+        delegateCount++;
+
+        // Skip the action and observation
+        i += obsStep ? 3 : 2;
+
+        // If the next step is a resolution that just confirms dispatch, skip it too
+        if (i < steps.length && steps[i].type === 'resolution') {
+          const rc = (steps[i].content || '').toLowerCase();
+          if (rc.includes('dispatch') || rc.includes('delegat') || rc.includes('handed off') || rc.length < 50) {
+            i++;
+          }
+        }
+        continue;
+      }
+    }
+
+    // Pattern B: action(Write/Edit) → observation(success) → resolution(handoff)
+    // Replace resolution with yield
+    if (i + 2 < steps.length &&
+        isWriteAction(steps[i]) &&
+        isSuccessObservation(steps[i + 1]) &&
+        isYieldResolution(steps[i + 2])) {
+
+      // Keep the action and observation as-is
+      result.push({ ...steps[i] });
+      result.push({ ...steps[i + 1] });
+
+      const writeStep = steps[i];
+      const resStep = steps[i + 2];
+      const path = extractFilePath(writeStep);
+      const summary = buildYieldSummary(resStep);
+
+      const yieldStep = {
+        step: resStep.step,
+        type: 'yield',
+        content: summary,
+        timestamp: resStep.timestamp,
+        token_count: Math.max(1, Math.ceil(summary.length / 4)),
+      };
+      if (path) yieldStep.path = path;
+
+      result.push(yieldStep);
+      yieldCount++;
+      i += 3;
+      continue;
+    }
+
+    // No pattern match — pass through unchanged
+    result.push({ ...steps[i] });
+    i++;
+  }
+
+  return { steps: result, delegateCount, yieldCount };
+}
+
+// --- Process envelopes ---
+
+async function processStream(input, output) {
+  const rl = createInterface({ input, crlfDelay: Infinity });
+
+  let totalEnvelopes = 0;
+  let modifiedEnvelopes = 0;
+  let totalDelegates = 0;
+  let totalYields = 0;
+  let skippedRoles = 0;
+
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    let envelope;
+    try {
+      envelope = JSON.parse(trimmed);
+    } catch {
+      output.write(trimmed + '\n');
+      continue;
+    }
+
+    totalEnvelopes++;
+
+    // Pass through non-trajectory envelopes unchanged
+    if (envelope.type === 'SESSION_CLOSE' || envelope.type === 'USER_FEEDBACK') {
+      output.write(JSON.stringify(envelope) + '\n');
+      continue;
+    }
+
+    // Only retag planner and fullstack sessions (where delegation/yield patterns occur)
+    const role = envelope.metadata?.agent_role;
+    if (!role || !['planner', 'fullstack', 'advisor'].includes(role)) {
+      skippedRoles++;
+      output.write(JSON.stringify(envelope) + '\n');
+      continue;
+    }
+
+    const steps = envelope.trajectory_log;
+    if (!Array.isArray(steps) || steps.length < 2) {
+      output.write(JSON.stringify(envelope) + '\n');
+      continue;
+    }
+
+    const { steps: retagged, delegateCount, yieldCount } = retagTrajectory(steps);
+
+    if (delegateCount > 0 || yieldCount > 0) {
+      modifiedEnvelopes++;
+      totalDelegates += delegateCount;
+      totalYields += yieldCount;
+      envelope.trajectory_log = retagged;
+    }
+
+    output.write(JSON.stringify(envelope) + '\n');
+  }
+
+  return { totalEnvelopes, modifiedEnvelopes, totalDelegates, totalYields, skippedRoles };
+}
+
+// --- Entry point ---
+
+async function main() {
+  const args = process.argv.slice(2);
+  const inputPath = args[0];
+  const outputPath = args[1];
+
+  let input;
+  if (inputPath && inputPath !== '-') {
+    if (!existsSync(inputPath)) {
+      console.error(`Error: input file not found: ${inputPath}`);
+      process.exit(1);
+    }
+    input = createReadStream(inputPath, 'utf8');
+  } else {
+    input = process.stdin;
+  }
+
+  let output;
+  if (outputPath) {
+    output = createWriteStream(outputPath, 'utf8');
+  } else {
+    output = process.stdout;
+  }
+
+  const stats = await processStream(input, output);
+
+  if (output !== process.stdout) {
+    output.end();
+  }
+
+  // Print stats to stderr so they don't mix with JSONL output
+  console.error(`\n--- Retag Summary ---`);
+  console.error(`Envelopes processed: ${stats.totalEnvelopes}`);
+  console.error(`Envelopes modified:  ${stats.modifiedEnvelopes}`);
+  console.error(`Delegate steps added: ${stats.totalDelegates}`);
+  console.error(`Yield steps added:    ${stats.totalYields}`);
+  console.error(`Skipped (wrong role): ${stats.skippedRoles}`);
+}
+
+main().catch((err) => {
+  console.error(`Fatal: ${err.message}`);
+  process.exit(1);
+});

package/moe-training/test/shared/envelope-schema.test.js

@@ -475,7 +475,7 @@ describe('envelope-schema', () => {
   it('accepts valid session_embedding object', () => {
     const env = validEnvelope();
     env.metadata.session_embedding = {
-      model: 'BAAI/bge-small-en-v1.5',
+      model: 'BAAI/bge-base-en-v1.5',
       vector: [0.0234, -0.0891, 0.1247, 0.0562],
       source_text: 'Write a Python decorator that caches function results',
     };
@@ -486,7 +486,7 @@ describe('envelope-schema', () => {
   it('rejects session_embedding with empty vector', () => {
     const env = validEnvelope();
     env.metadata.session_embedding = {
-      model: 'BAAI/bge-small-en-v1.5',
+      model: 'BAAI/bge-base-en-v1.5',
       vector: [],
       source_text: 'test',
     };
@@ -498,7 +498,7 @@ describe('envelope-schema', () => {
   it('rejects session_embedding with non-numeric vector values', () => {
     const env = validEnvelope();
     env.metadata.session_embedding = {
-      model: 'BAAI/bge-small-en-v1.5',
+      model: 'BAAI/bge-base-en-v1.5',
       vector: [0.1, 'bad', 0.3],
       source_text: 'test',
     };

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.134",
+  "version": "0.27.136",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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

@@ -137,6 +137,20 @@ export class AdaptiveThresholds {
     const filesWritten = signals.filesWritten || 0;
     score += Math.min(filesWritten * 2, 10); // Cap at +10
 
+    // Output length decay: assistant responses shrinking dramatically
+    if (signals.outputLengthDecay) score -= 10;
+
+    // Tool output volume: bloated context from large tool results
+    const toolVol = signals.toolOutputVolume || 0;
+    if (toolVol === 2) score -= 10;
+    else if (toolVol === 1) score -= 5;
+
+    // Turn latency trend: agent slowing down significantly
+    if (signals.turnLatencyTrend) score -= 5;
+
+    // Bash repetition: agent stuck running identical commands
+    if (signals.bashRepetition) score -= 8;
+
     // Clamp to 0-100
     return Math.max(0, Math.min(100, score));
   }
@@ -165,20 +179,43 @@ export class AdaptiveThresholds {
       filesWritten: 0,
       fileChurn: 0,         // same file written 3+ times → possible circular refactoring
       errorTrend: 0,        // errors increasing in recent window → degradation signal
+      outputLengthDecay: 0, // last 5 assistant turns avg <50% of first 5 → declining output
+      toolOutputVolume: 0,  // cumulative tool result chars (>300KB = bloated context)
+      turnLatencyTrend: 0,  // avg gap in last 10 entries >2x first 10 → slowing down
+      bashRepetition: 0,    // 3+ identical consecutive Bash commands → stuck in loop
     };
 
     const writtenFiles = new Set();
     const fileWriteCounts = {};
     const writeEditOps = [];
+    const assistantOutputLengths = [];
+    let toolOutputBytes = 0;
+    const entryTimestamps = [];
+    const bashCommands = [];
 
     for (const entry of entries) {
+      if (entry.timestamp) entryTimestamps.push(new Date(entry.timestamp).getTime());
+
       if (entry.type === 'error') {
         signals.errorCount++;
       }
 
+      // Track assistant output lengths for decay detection
+      if (entry.type === 'thinking' && entry.text) {
+        assistantOutputLengths.push(entry.text.length);
+      }
+
       if (entry.type === 'tool') {
         signals.toolCalls++;
 
+        // Track tool result output volume
+        if (entry.output) toolOutputBytes += entry.output.length;
+
+        // Track Bash commands for repetition detection
+        if (entry.tool === 'Bash' && entry.input) {
+          bashCommands.push(entry.input);
+        }
+
         if (entry.tool === 'Write' || entry.tool === 'Edit') {
           if (entry.input) {
             writtenFiles.add(entry.input);
@@ -245,6 +282,46 @@ export class AdaptiveThresholds {
       signals.errorTrend = secondHalfErrors - firstHalfErrors;
     }
 
+    // Output length decay: if last 5 assistant outputs avg <50% of first 5
+    if (assistantOutputLengths.length >= 10) {
+      const first5 = assistantOutputLengths.slice(0, 5);
+      const last5 = assistantOutputLengths.slice(-5);
+      const firstAvg = first5.reduce((a, b) => a + b, 0) / 5;
+      const lastAvg = last5.reduce((a, b) => a + b, 0) / 5;
+      if (firstAvg > 0 && lastAvg < firstAvg * 0.5) signals.outputLengthDecay = 1;
+    }
+
+    // Tool output volume: cumulative tool result size
+    if (toolOutputBytes > 600_000) signals.toolOutputVolume = 2;
+    else if (toolOutputBytes > 300_000) signals.toolOutputVolume = 1;
+
+    // Turn latency trend: avg gap in last 10 entries >2x first 10
+    if (entryTimestamps.length >= 20) {
+      const gaps = (ts) => {
+        const g = [];
+        for (let i = 1; i < ts.length; i++) g.push(ts[i] - ts[i - 1]);
+        return g;
+      };
+      const firstGaps = gaps(entryTimestamps.slice(0, 11));
+      const lastGaps = gaps(entryTimestamps.slice(-11));
+      const avgFirst = firstGaps.reduce((a, b) => a + b, 0) / firstGaps.length;
+      const avgLast = lastGaps.reduce((a, b) => a + b, 0) / lastGaps.length;
+      if (avgFirst > 0 && avgLast > avgFirst * 2) signals.turnLatencyTrend = 1;
+    }
+
+    // Bash repetition: 3+ identical consecutive Bash commands
+    let maxConsecutive = 0;
+    let streak = 1;
+    for (let i = 1; i < bashCommands.length; i++) {
+      if (bashCommands[i] === bashCommands[i - 1]) {
+        streak++;
+        if (streak > maxConsecutive) maxConsecutive = streak;
+      } else {
+        streak = 1;
+      }
+    }
+    if (maxConsecutive >= 3) signals.bashRepetition = 1;
+
     return signals;
   }
 

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

@@ -124,6 +124,38 @@ export function createApi(app, daemon) {
     res.json({ status: 'ok', uptime: process.uptime() });
   });
 
+  // Debug: test fetch to llama-server from daemon runtime
+  app.get('/api/lab/debug-fetch', async (req, res) => {
+    const target = req.query.url || 'http://localhost:8081/v1/chat/completions';
+    const log = [];
+    try {
+      log.push(`fetch → ${target}`);
+      log.push(`node ${process.version}, electron ${process.versions.electron || 'N/A'}`);
+      const start = Date.now();
+      const r = await fetch(target, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ model: 'Qwen3-0.6B-Q8_0.gguf', messages: [{ role: 'user', content: 'Say ok' }], stream: true, max_tokens: 10 }),
+        signal: AbortSignal.timeout(10000),
+      });
+      log.push(`status=${r.status} in ${Date.now() - start}ms`);
+      const reader = r.body.getReader();
+      let chunks = 0;
+      while (chunks < 5) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks++;
+        log.push(`chunk ${chunks}: ${new TextDecoder().decode(value).slice(0, 120)}`);
+      }
+      reader.cancel();
+      log.push(`total chunks read: ${chunks}`);
+      res.json({ ok: true, log });
+    } catch (err) {
+      log.push(`ERROR: ${err.message}`);
+      res.json({ ok: false, log, error: err.message });
+    }
+  });
+
   // List all agents
   app.get('/api/agents', (req, res) => {
     res.json(daemon.registry.getAll());
@@ -6703,11 +6735,9 @@ Keep responses concise. Help them think, don't lecture them about the system the
       let closed = false;
       req.on('close', () => { closed = true; });
 
-      const stream = daemon.modelLab.streamInference(params);
-      for await (const event of stream) {
-        if (closed) break;
-        res.write(`data: ${JSON.stringify(event)}\n\n`);
-      }
+      await daemon.modelLab.streamInference(params, (event) => {
+        if (!closed) res.write(`data: ${JSON.stringify(event)}\n\n`);
+      });
 
       if (!closed) {
         res.write('data: [DONE]\n\n');

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

@@ -460,7 +460,7 @@ export class Journalist {
       '(What was completed. Name files, functions, and line numbers.)',
       '',
       'Be specific. Name files, functions, and line numbers. Do not summarize vaguely.',
-      'Keep your response under 2000 characters.',
+      'Keep your response under 1500 characters.',
       '',
       '---',
       '',
@@ -469,7 +469,7 @@ export class Journalist {
     ];
 
     let totalChars = 0;
-    const cap = 30_000;
+    const cap = 15_000;
     for (const entry of entries.slice(-200)) {
       const line = this.formatEntry(entry);
       if (totalChars + line.length > cap) break;
@@ -853,15 +853,15 @@ export class Journalist {
     const agentLog = filteredLogs[agent.id];
     const entries = agentLog?.entries || [];
 
-    // Layer 7 memory: discoveries, constraints, specializations
-    const discoveries = this.daemon.memory?.getDiscoveriesMarkdown(agent.role, 10, 2000) || '';
+    // Layer 7 memory: discoveries (inline, not pointer — agents lose context with pointers), constraints, specializations
+    const discoveries = this.daemon.memory?.getDiscoveriesMarkdown(agent.role, 10, 1500) || '';
     const constraints = this.daemon.memory?.getConstraintsMarkdown(2000) || '';
     const specialization = this.daemon.memory?.getSpecialization(agent.id);
     const specLine = specialization?.avgQualityScore != null
       ? `- Quality profile: ${specialization.avgQualityScore}/100 across ${specialization.sessionCount} sessions`
       : '';
 
-    const recentChain = this.daemon.memory?.getRecentHandoffMarkdown(agent.role, 3, 3000, agent.workingDir, agent.teamId) || '';
+    const recentChain = this.daemon.memory?.getRecentHandoffMarkdown(agent.role, 1, 1500, agent.workingDir, agent.teamId) || '';
 
     const agentFeedback = this.getUserFeedback(agent.id).slice(-5);
     const conversationSummary = agentFeedback.length > 0
@@ -871,7 +871,7 @@ export class Journalist {
     const recentTools = entries
       .filter((e) => e.type === 'tool' || e.type === 'error')
       .slice(-5)
-      .map((e) => `- ${e.type === 'error' ? 'ERROR ' : ''}${e.tool}: ${(e.input || e.text || '').slice(0, 80)}`)
+      .map((e) => `- ${e.type === 'error' ? 'ERROR ' : ''}${e.tool}: ${(e.input || e.text || '').slice(0, 200)}`)
       .join('\n');
 
     // Try AI-synthesized session summary
@@ -908,7 +908,7 @@ export class Journalist {
       const fallbackRecentTools = entries
         .filter((e) => e.type === 'tool' || e.type === 'error')
         .slice(-5)
-        .map((e) => `- ${e.type === 'error' ? 'ERROR ' : ''}${e.tool}: ${(e.input || '').slice(0, 80)}`)
+        .map((e) => `- ${e.type === 'error' ? 'ERROR ' : ''}${e.tool}: ${(e.input || '').slice(0, 200)}`)
         .join('\n');
 
       const fallbackParts = [];
@@ -919,7 +919,13 @@ export class Journalist {
       sessionSummary = fallbackParts.join('\n\n');
     }
 
-    return [
+    // For quality_degradation rotations, drop user messages (already in session summary)
+    const includeUserMessages = options.reason !== 'quality_degradation';
+
+    // Cap Original Task to 1000 chars — task descriptions for debugging can be long
+    const originalTask = agent.prompt ? agent.prompt.slice(0, 1000) + (agent.prompt.length > 1000 ? '…' : '') : '';
+
+    let brief = [
       `# Handoff Brief — ${agent.name} (${agent.role})`,
       ``,
       `Role: ${agent.role} | Scope: ${agent.scope?.join(', ') || 'unrestricted'} | Provider: ${agent.provider}`,
@@ -927,17 +933,27 @@ export class Journalist {
       `Rotation: ${options.reason || 'manual'}${options.qualityScore ? ` (quality: ${options.qualityScore}/100)` : ''} | Tokens: ${agent.tokensUsed}`,
       specLine,
       ``,
-      discoveries ? `## Known Issues & Fixes\n\n${discoveries}\n` : '',
+      // Priority order: session summary (contains unresolved errors) first,
+      // then constraints, then discoveries, then tools — so the most critical
+      // debugging context survives even if the brief hits the hard cap.
+      sessionSummary ? `## Session Summary\n\n${sessionSummary}\n` : '',
       constraints ? `## Project Constraints (must follow)\n\n${constraints}\n` : '',
+      discoveries ? `## Known Issues & Fixes\n\n${discoveries}\n` : '',
       recentTools ? `## Last 5 Tool Calls\n\n${recentTools}\n` : '',
-      sessionSummary ? `## Session Summary\n\n${sessionSummary}\n` : '',
-      conversationSummary ? `## Recent User Messages\n\n${conversationSummary}\n` : '',
+      includeUserMessages && conversationSummary ? `## Recent User Messages\n\n${conversationSummary}\n` : '',
       recentChain ? `## Rotation History\n\n${recentChain}\n` : '',
-      agent.prompt ? `## Original Task\n\n${agent.prompt}\n` : '',
+      originalTask ? `## Original Task\n\n${originalTask}\n` : '',
       ``,
       agent.role === 'planner' ? 'CRITICAL: You are a PLANNING ONLY agent. Do NOT implement code. Route all work to your team via .groove/recommended-team.json.\n' : '',
       `Continue seamlessly — finish the work and deliver the output.`,
     ].filter(Boolean).join('\n');
+
+    // Hard cap: 8000 chars — enough for debugging context without overwhelming the new agent
+    if (brief.length > 8000) {
+      brief = brief.slice(0, 7950) + '\n\n[Brief truncated — see session logs for full context]';
+    }
+
+    return brief;
   }
 
   // --- Workspace Grouping ---