groove-dev 0.27.139 → 0.27.141

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.139",
+  "version": "0.27.141",
   "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/integrations-registry.json

@@ -432,10 +432,10 @@
     "icon": "elevenlabs",
     "tags": ["voice", "tts", "audio", "speech"],
     "roles": ["creative", "cmo", "support"],
-    "npmPackage": "elevenlabs-mcp",
+    "npmPackage": "@angelogiacco/elevenlabs-mcp-server",
     "transport": "stdio",
     "command": "npx",
-    "args": ["-y", "elevenlabs-mcp"],
+    "args": ["-y", "@angelogiacco/elevenlabs-mcp-server"],
     "authType": "api-key",
     "envKeys": [
       { "key": "ELEVENLABS_API_KEY", "label": "API Key", "required": true }
@@ -491,10 +491,10 @@
     "icon": "hubspot",
     "tags": ["crm", "sales", "contacts", "marketing"],
     "roles": ["cmo", "analyst", "support"],
-    "npmPackage": "hubspot-mcp",
+    "npmPackage": "@hubspot/mcp-server",
     "transport": "stdio",
     "command": "npx",
-    "args": ["-y", "hubspot-mcp"],
+    "args": ["-y", "@hubspot/mcp-server"],
     "authType": "api-key",
     "envKeys": [
       { "key": "HUBSPOT_ACCESS_TOKEN", "label": "Private App Token", "required": true }
@@ -701,10 +701,10 @@
     "icon": "mixpanel",
     "tags": ["analytics", "events", "funnels", "users"],
     "roles": ["analyst", "cmo", "cfo"],
-    "npmPackage": "mixpanel-mcp",
+    "npmPackage": "@mercuryml/mcp-mixpanel",
     "transport": "stdio",
     "command": "npx",
-    "args": ["-y", "mixpanel-mcp"],
+    "args": ["-y", "@mercuryml/mcp-mixpanel"],
     "authType": "api-key",
     "envKeys": [
       { "key": "MIXPANEL_API_SECRET", "label": "API Secret", "required": true }
@@ -761,10 +761,10 @@
     "icon": "airtable",
     "tags": ["database", "spreadsheet", "content", "crm"],
     "roles": ["ea", "cmo", "analyst"],
-    "npmPackage": "airtable-mcp",
+    "npmPackage": "airtable-mcp-server",
     "transport": "stdio",
     "command": "npx",
-    "args": ["-y", "airtable-mcp"],
+    "args": ["-y", "airtable-mcp-server"],
     "authType": "api-key",
     "envKeys": [
       { "key": "AIRTABLE_API_KEY", "label": "Personal Access Token", "required": true }
@@ -823,10 +823,10 @@
     "icon": "intercom",
     "tags": ["chat", "support", "messaging", "customers"],
     "roles": ["support", "cmo"],
-    "npmPackage": "intercom-mcp",
+    "npmPackage": "@pipeworx/mcp-intercom",
     "transport": "stdio",
     "command": "npx",
-    "args": ["-y", "intercom-mcp"],
+    "args": ["-y", "@pipeworx/mcp-intercom"],
     "authType": "api-key",
     "envKeys": [
       { "key": "INTERCOM_ACCESS_TOKEN", "label": "Access Token", "required": true }
@@ -853,10 +853,10 @@
     "icon": "twilio",
     "tags": ["sms", "voice", "phone", "whatsapp"],
     "roles": ["ea", "support", "cmo"],
-    "npmPackage": "twilio-mcp",
+    "npmPackage": "@twilio-alpha/mcp",
     "transport": "stdio",
     "command": "npx",
-    "args": ["-y", "twilio-mcp"],
+    "args": ["-y", "@twilio-alpha/mcp"],
     "authType": "api-key",
     "envKeys": [
       { "key": "TWILIO_ACCOUNT_SID", "label": "Account SID", "placeholder": "AC...", "required": true },
@@ -939,37 +939,5 @@
     "rating": 0,
     "ratingCount": 0,
     "verified": "community"
-  },
-  {
-    "id": "plaid",
-    "name": "Plaid",
-    "description": "Bank connections and financial data",
-    "category": "finance",
-    "icon": "plaid",
-    "tags": ["banking", "transactions", "finance", "accounts"],
-    "roles": ["cfo", "analyst"],
-    "npmPackage": "plaid-mcp",
-    "transport": "stdio",
-    "command": "npx",
-    "args": ["-y", "plaid-mcp"],
-    "authType": "api-key",
-    "envKeys": [
-      { "key": "PLAID_CLIENT_ID", "label": "Client ID", "required": true },
-      { "key": "PLAID_SECRET", "label": "Secret", "required": true },
-      { "key": "PLAID_ENV", "label": "Environment", "placeholder": "sandbox", "required": false }
-    ],
-    "setupUrl": "https://dashboard.plaid.com/team/keys",
-    "setupSteps": [
-      "Click the link below to open Plaid team keys",
-      "Copy your Client ID and Secret",
-      "Use 'sandbox' environment for testing"
-    ],
-    "requiresApproval": [],
-    "agentInstructions": "## Plaid Integration\n\nYou have Plaid connected via GROOVE.\n\n### API\n`POST http://localhost:31415/api/integrations/plaid/exec`\nBody: `{\"tool\": \"<tool>\", \"params\": {...}}`\n\n### Common Tools\n- `get_accounts` — params: {access_token}\n- `get_transactions` — params: {access_token, start_date, end_date}\n- `get_balance` — params: {access_token}\n\n### Rules\n- Use sandbox environment for testing\n- Never expose access_tokens in output",
-    "featured": false,
-    "downloads": 0,
-    "rating": 0,
-    "ratingCount": 0,
-    "verified": "community"
   }
 ]

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

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

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

@@ -18,6 +18,7 @@ import { supportsSignalFlag, compareSemver, parseSemver } from './providers/groo
 import { ConsentManager } from '../../../moe-training/client/index.js';
 import { validateAgentConfig, validateReasoningEffort, validateVerbosity, validateTeamMode, validateLabRuntimeConfig, validateLabInferenceParams, validateLabPresetConfig } from './validate.js';
 import { ROLE_INTEGRATIONS, wrapWithRoleReminder } from './process.js';
+import { Keeper, KEEPER_COMMANDS } from './keeper.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
@@ -487,6 +488,148 @@ export function createApi(app, daemon) {
     res.json(spec);
   });
 
+  // ── Keeper (tagged memory) ──────────────────────────────────
+
+  app.get('/api/keeper', (req, res) => {
+    res.json({ items: daemon.keeper.list() });
+  });
+
+  app.get('/api/keeper/tree', (req, res) => {
+    res.json({ tree: daemon.keeper.tree() });
+  });
+
+  app.get('/api/keeper/search', (req, res) => {
+    const q = req.query.q || '';
+    res.json({ results: daemon.keeper.search(q) });
+  });
+
+  app.get('/api/keeper/commands', (_req, res) => {
+    res.json({ commands: KEEPER_COMMANDS });
+  });
+
+  app.get('/api/keeper/:tag(*)', (req, res) => {
+    const item = daemon.keeper.get(req.params.tag);
+    if (!item) return res.status(404).json({ error: `Memory #${req.params.tag} not found` });
+    res.json(item);
+  });
+
+  app.post('/api/keeper', (req, res) => {
+    try {
+      const { tag, content } = req.body || {};
+      const item = daemon.keeper.save(tag, content);
+      daemon.audit.log('keeper.save', { tag: item.tag });
+      daemon.broadcast({ type: 'keeper:saved', item });
+      res.status(201).json(item);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/keeper/append', (req, res) => {
+    try {
+      const { tag, content } = req.body || {};
+      const item = daemon.keeper.append(tag, content);
+      daemon.audit.log('keeper.append', { tag: item.tag });
+      daemon.broadcast({ type: 'keeper:updated', item });
+      res.json(item);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/keeper/pull', (req, res) => {
+    try {
+      const { tags } = req.body || {};
+      if (!Array.isArray(tags) || tags.length === 0) {
+        return res.status(400).json({ error: 'Tags array is required' });
+      }
+      const brief = daemon.keeper.pull(tags);
+      if (!brief) return res.status(404).json({ error: 'No memories found for the given tags' });
+      res.json({ brief, tags });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.patch('/api/keeper/:tag(*)', (req, res) => {
+    try {
+      const { content } = req.body || {};
+      const item = daemon.keeper.update(req.params.tag, content);
+      daemon.audit.log('keeper.update', { tag: item.tag });
+      daemon.broadcast({ type: 'keeper:updated', item });
+      res.json(item);
+    } catch (err) {
+      res.status(err.message.includes('does not exist') ? 404 : 400).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/keeper/link/:tag(*)', (req, res) => {
+    try {
+      const { docPath } = req.body || {};
+      daemon.keeper.unlink(req.params.tag, docPath);
+      daemon.audit.log('keeper.unlink', { tag: req.params.tag, docPath });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/keeper/:tag(*)', (req, res) => {
+    try {
+      const removed = daemon.keeper.delete(req.params.tag);
+      if (!removed) return res.status(404).json({ error: `Memory #${req.params.tag} not found` });
+      daemon.audit.log('keeper.delete', { tag: req.params.tag });
+      daemon.broadcast({ type: 'keeper:deleted', tag: req.params.tag });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/keeper/doc', async (req, res) => {
+    try {
+      const { tag, chatHistory, agentId } = req.body || {};
+      if (!tag) return res.status(400).json({ error: 'Tag is required' });
+      if (!chatHistory || !Array.isArray(chatHistory) || chatHistory.length === 0) {
+        return res.status(400).json({ error: 'Chat history is required' });
+      }
+      const transcript = chatHistory
+        .map(m => `**${m.from === 'user' ? 'User' : 'Agent'}:** ${m.text}`)
+        .join('\n\n');
+      const prompt = `You are a technical writer. Below is a conversation exploring an idea or feature. Write a comprehensive document that captures:\n\n1. The core idea and motivation\n2. Key decisions made during the discussion\n3. Architecture / design choices\n4. Implementation plan (if discussed)\n5. Open questions or next steps\n\nWrite in clear, structured markdown with headers. Be thorough — this document will be the reference for future work on this topic. Do not include a meta-summary about the conversation itself.\n\n---\n\nConversation:\n\n${transcript.slice(0, 40000)}`;
+      let doc;
+      if (daemon.journalist && typeof daemon.journalist.callHeadless === 'function') {
+        doc = await daemon.journalist.callHeadless(prompt, { trackAs: '__keeper_doc__' });
+      } else {
+        doc = `# ${tag}\n\n*Auto-generated document from conversation*\n\n${transcript.slice(0, 5000)}`;
+      }
+      const item = daemon.keeper.saveDoc(tag, doc);
+      daemon.audit.log('keeper.doc', { tag: item.tag, agentId });
+      daemon.broadcast({ type: 'keeper:saved', item });
+      res.status(201).json({ ...item, content: doc });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/keeper/link', (req, res) => {
+    try {
+      const { tag, docPath } = req.body || {};
+      const item = daemon.keeper.link(tag, docPath);
+      daemon.audit.log('keeper.link', { tag: item.tag, docPath });
+      daemon.broadcast({ type: 'keeper:updated', item });
+      res.json(item);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.post('/api/keeper/parse', (req, res) => {
+    const { text } = req.body || {};
+    const parsed = Keeper.parseCommand(text || '');
+    res.json({ parsed });
+  });
+
   // Token usage
   app.get('/api/tokens', (req, res) => {
     res.json(daemon.tokens.getAll());
@@ -3088,8 +3231,11 @@ Keep responses concise. Help them think, don't lecture them about the system the
       const raw = readdirSync(fullPath, { withFileTypes: true });
       const entries = [];
 
+      const HIDDEN_DIRS = new Set(['.git', 'node_modules', '.groove', '.next', '.nuxt', '__pycache__', '.venv', 'dist', '.cache']);
+      const HIDDEN_FILES = new Set(['.DS_Store']);
+
       const dirs = raw.filter((e) => {
-        if (e.name === '.DS_Store') return false;
+        if (HIDDEN_FILES.has(e.name) || HIDDEN_DIRS.has(e.name)) return false;
         if (e.isDirectory()) return true;
         if (e.isSymbolicLink()) {
           try { return statSync(resolve(fullPath, e.name)).isDirectory(); }
@@ -3098,7 +3244,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
         return false;
       }).sort((a, b) => a.name.localeCompare(b.name));
       const files = raw.filter((e) => {
-        if (e.name === '.DS_Store') return false;
+        if (HIDDEN_FILES.has(e.name)) return false;
         if (e.isFile()) return true;
         if (e.isSymbolicLink()) {
           try { return statSync(resolve(fullPath, e.name)).isFile(); }
@@ -6843,30 +6989,93 @@ Keep responses concise. Help them think, don't lecture them about the system the
   app.post('/api/lab/inference', async (req, res) => {
     try {
       const params = validateLabInferenceParams(req.body);
+      const rt = daemon.modelLab.getRuntime(params.runtimeId);
+      if (!rt) throw new Error('Runtime not found');
 
+      const url = new URL(`${rt.endpoint}/v1/chat/completions`);
+      const reqHeaders = { 'Content-Type': 'application/json' };
+      if (rt.apiKey) reqHeaders['Authorization'] = `Bearer ${rt.apiKey}`;
+
+      const body = {
+        model: params.model,
+        messages: params.messages,
+        stream: true,
+      };
+      const pb = params.parameters || {};
+      if (pb.temperature !== undefined) body.temperature = pb.temperature;
+      if (pb.top_p !== undefined) body.top_p = pb.top_p;
+      if (pb.top_k !== undefined) body.top_k = pb.top_k;
+      if (pb.repeat_penalty !== undefined) body.repeat_penalty = pb.repeat_penalty;
+      if (pb.max_tokens !== undefined) body.max_tokens = pb.max_tokens;
+      if (pb.stop !== undefined) body.stop = pb.stop;
+      if (pb.frequency_penalty !== undefined) body.frequency_penalty = pb.frequency_penalty;
+      if (pb.presence_penalty !== undefined) body.presence_penalty = pb.presence_penalty;
+
+      const payload = JSON.stringify(body);
+
+      // Use Node http module directly — Electron's fetch has stream issues
+      const { request: httpRequest } = await import('http');
+      const upstream = await new Promise((resolve, reject) => {
+        const r = httpRequest({
+          hostname: url.hostname,
+          port: url.port,
+          path: url.pathname,
+          method: 'POST',
+          headers: { ...reqHeaders, 'Content-Length': Buffer.byteLength(payload) },
+          timeout: 300000,
+        }, resolve);
+        r.on('error', reject);
+        r.on('timeout', () => { r.destroy(); reject(new Error('Upstream timeout')); });
+        r.write(payload);
+        r.end();
+      });
+
+      if (upstream.statusCode !== 200) {
+        let errMsg = `HTTP ${upstream.statusCode}`;
+        try {
+          const chunks = [];
+          for await (const c of upstream) chunks.push(c);
+          const data = JSON.parse(Buffer.concat(chunks).toString());
+          errMsg = data.error?.message || errMsg;
+        } catch { /* ignore */ }
+        throw new Error(errMsg);
+      }
+
+      // Pipe raw OpenAI-compatible SSE straight to client
       res.setHeader('Content-Type', 'text/event-stream');
       res.setHeader('Cache-Control', 'no-cache');
       res.setHeader('Connection', 'keep-alive');
       res.setHeader('X-Accel-Buffering', 'no');
-      res.flushHeaders();
-
-      let closed = false;
-      req.on('close', () => { closed = true; });
-
-      await daemon.modelLab.streamInference(params, (event) => {
-        if (!closed) res.write(`data: ${JSON.stringify(event)}\n\n`);
-      });
-
-      if (!closed) {
-        res.write('data: [DONE]\n\n');
-        res.end();
+      upstream.pipe(res);
+
+      // Collect content for session persistence
+      if (params.sessionId) {
+        let full = '';
+        upstream.on('data', (chunk) => {
+          const text = chunk.toString('utf8');
+          for (const line of text.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('data: ')) continue;
+            const d = trimmed.slice(6);
+            if (d === '[DONE]') continue;
+            try {
+              const p = JSON.parse(d);
+              const c = p.choices?.[0]?.delta?.content;
+              if (c) full += c;
+            } catch { /* skip */ }
+          }
+        });
+        upstream.on('end', () => {
+          if (full) daemon.modelLab._appendToSession(params.sessionId, params.messages, { role: 'assistant', content: full });
+        });
       }
+
+      req.on('close', () => { upstream.destroy(); });
     } catch (err) {
       if (!res.headersSent) {
         res.status(400).json({ error: err.message });
       } else {
-        res.write(`data: ${JSON.stringify({ type: 'error', error: err.message })}\n\n`);
-        res.end();
+        try { res.end(); } catch { /* ignore */ }
       }
     }
   });

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

@@ -34,6 +34,7 @@ import { Scheduler } from './scheduler.js';
 import { FileWatcher } from './filewatcher.js';
 import { TimelineTracker } from './timeline.js';
 import { MemoryStore } from './memory.js';
+import { Keeper } from './keeper.js';
 import { TerminalManager } from './terminal-pty.js';
 import { GatewayManager } from './gateways/manager.js';
 import { McpManager } from './mcp-manager.js';
@@ -124,6 +125,7 @@ export class Daemon {
     this.locks = new LockManager(this.grooveDir);
     this.tokens = new TokenTracker(this.grooveDir);
     this.memory = new MemoryStore(this.grooveDir);
+    this.keeper = new Keeper(this.grooveDir);
     this.timeline = new TimelineTracker(this);
     this.processes = new ProcessManager(this);
     this.introducer = new Introducer(this);

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

@@ -127,6 +127,16 @@ export class IntegrationStore {
     if (this._isInstalled(integrationId)) throw new Error(`Integration already installed: ${integrationId}`);
 
     if (entry.npmPackage) {
+      // Pre-validate: check the package exists on npm before attempting install
+      try {
+        execFileSync('npm', ['view', entry.npmPackage, 'version'], {
+          stdio: 'pipe',
+          timeout: 10_000,
+        });
+      } catch {
+        throw new Error(`Package ${entry.npmPackage} is not available on npm. Use the agent-assisted install flow instead.`);
+      }
+
       try {
         execFileSync('npm', ['install', '--legacy-peer-deps', entry.npmPackage], {
           cwd: this.integrationsDir,

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

@@ -462,7 +462,23 @@ export class Introducer {
       memorySection = '';
     }
 
-    return lines.join('\n') + memorySection;
+    // --- Keeper: tagged memory injection via [pull] ---
+    let keeperSection = '';
+    try {
+      if (this.daemon.keeper && newAgent.keeperTags && Array.isArray(newAgent.keeperTags) && newAgent.keeperTags.length > 0) {
+        const brief = this.daemon.keeper.pull(newAgent.keeperTags);
+        if (brief) {
+          keeperSection = `\n## Keeper Context (user-tagged memories)\n\n${brief}\n`;
+          if (keeperSection.length > 5000) {
+            keeperSection = keeperSection.slice(0, 4997) + '...';
+          }
+        }
+      }
+    } catch {
+      keeperSection = '';
+    }
+
+    return lines.join('\n') + memorySection + keeperSection;
   }
 
   _loadClaudeMd(workingDir) {

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

@@ -994,6 +994,175 @@ export class Journalist {
     return brief;
   }
 
+  // --- Conversation Thread Extraction (for idle resume) ---
+
+  /**
+   * Extract the actual user↔assistant conversation from stream-json logs.
+   * Returns the dialogue in chronological order — user messages interleaved
+   * with Claude's text responses. This preserves the "why" context that
+   * handoff briefs lose through summarization.
+   *
+   * Budget: keeps recent turns verbatim, summarizes oldest if over maxChars.
+   */
+  extractConversationThread(agent, { maxChars = 60000 } = {}) {
+    const logPath = resolve(this.daemon.grooveDir, 'logs', `${agent.name}.log`);
+    if (!existsSync(logPath)) return null;
+
+    let content;
+    try {
+      content = readFileSync(logPath, 'utf8');
+    } catch { return null; }
+
+    const lines = content.split('\n');
+    const turns = []; // { role: 'user'|'assistant', text, timestamp }
+
+    for (const line of lines) {
+      if (!line.trim() || line.startsWith('[')) continue;
+      try {
+        const data = JSON.parse(line);
+
+        // User messages
+        if (data.type === 'user' && data.message?.content) {
+          const msgContent = data.message.content;
+          let text = '';
+          if (typeof msgContent === 'string') {
+            text = msgContent;
+          } else if (Array.isArray(msgContent)) {
+            // Extract text blocks, skip tool_result blocks (noise)
+            text = msgContent
+              .filter((b) => b.type === 'text' && b.text)
+              .map((b) => b.text)
+              .join('\n');
+          }
+          if (text.trim().length > 5) {
+            turns.push({ role: 'user', text: text.trim(), timestamp: data.timestamp });
+          }
+        }
+
+        // Assistant text responses (what Claude said — the reasoning/explanations)
+        if (data.type === 'assistant' && data.message?.content) {
+          const blocks = Array.isArray(data.message.content) ? data.message.content : [];
+          const textParts = blocks
+            .filter((b) => b.type === 'text' && b.text && b.text.trim().length > 20)
+            .map((b) => b.text.trim());
+          if (textParts.length > 0) {
+            turns.push({ role: 'assistant', text: textParts.join('\n'), timestamp: data.timestamp });
+          }
+        }
+      } catch { /* skip non-JSON */ }
+    }
+
+    if (turns.length === 0) return null;
+
+    // Deduplicate consecutive same-role turns (merge them)
+    const merged = [];
+    for (const turn of turns) {
+      const last = merged[merged.length - 1];
+      if (last && last.role === turn.role) {
+        last.text += '\n' + turn.text;
+      } else {
+        merged.push({ ...turn });
+      }
+    }
+
+    // Build the thread — keep recent turns verbatim, truncate old ones if over budget
+    let thread = '';
+    const formatted = merged.map((t) => {
+      const label = t.role === 'user' ? 'USER' : 'CLAUDE';
+      return `[${label}]:\n${t.text}`;
+    });
+
+    // Start from the end (most recent) and work backwards to fill budget
+    const recentFirst = [...formatted].reverse();
+    const kept = [];
+    let totalLen = 0;
+
+    for (const entry of recentFirst) {
+      if (totalLen + entry.length > maxChars) {
+        // Truncate this entry to fit remaining budget
+        const remaining = maxChars - totalLen;
+        if (remaining > 200) {
+          kept.push(entry.slice(0, remaining) + '\n[...truncated]');
+        }
+        break;
+      }
+      kept.push(entry);
+      totalLen += entry.length;
+    }
+
+    // Reverse back to chronological order
+    kept.reverse();
+    thread = kept.join('\n\n---\n\n');
+
+    return thread;
+  }
+
+  /**
+   * Build a full context-resume prompt that preserves the conversation
+   * thread so a fresh agent picks up where the previous session left off.
+   */
+  buildConversationResumePrompt(agent, userMessage) {
+    const thread = this.extractConversationThread(agent);
+    if (!thread) return null;
+
+    const constraints = this.daemon.memory?.getConstraintsMarkdown(2000) || '';
+    const discoveries = this.daemon.memory?.getDiscoveriesMarkdown(agent.role, 5, 1000) || '';
+
+    let prompt = [
+      `# Session Context Resume`,
+      ``,
+      `You are continuing a session that went idle. Below is the full conversation`,
+      `from your previous session — your actual exchanges with the user. Pick up`,
+      `exactly where you left off. The user's new message follows at the end.`,
+      ``,
+      `Role: ${agent.role} | Provider: ${agent.provider} | Scope: ${agent.scope?.join(', ') || 'unrestricted'}`,
+      agent.workingDir ? `Working directory: ${agent.workingDir}` : '',
+      ``,
+      constraints ? `## Project Constraints\n\n${constraints}\n` : '',
+      discoveries ? `## Known Issues & Fixes\n\n${discoveries}\n` : '',
+      `## Previous Conversation\n\n${thread}`,
+      ``,
+      `---`,
+      ``,
+      `## New Message From User`,
+      ``,
+      userMessage,
+      ``,
+      `Continue seamlessly from the conversation above. You have the full context of what was discussed, what was tried, what worked and what didn't. Do not ask the user to repeat anything.`,
+    ].filter(Boolean).join('\n');
+
+    // Hard cap at 80K chars (~20K tokens) to leave plenty of room in context window
+    if (prompt.length > 80000) {
+      // Re-extract with smaller budget and rebuild
+      const smallerThread = this.extractConversationThread(agent, { maxChars: 40000 });
+      if (smallerThread) {
+        prompt = [
+          `# Session Context Resume`,
+          ``,
+          `You are continuing a session that went idle. Below is the conversation`,
+          `from your previous session (older turns summarized to fit). Pick up`,
+          `exactly where you left off.`,
+          ``,
+          `Role: ${agent.role} | Scope: ${agent.scope?.join(', ') || 'unrestricted'}`,
+          agent.workingDir ? `Working directory: ${agent.workingDir}` : '',
+          ``,
+          constraints ? `## Project Constraints\n\n${constraints}\n` : '',
+          `## Previous Conversation\n\n${smallerThread}`,
+          ``,
+          `---`,
+          ``,
+          `## New Message From User`,
+          ``,
+          userMessage,
+          ``,
+          `Continue seamlessly. Do not ask the user to repeat anything.`,
+        ].filter(Boolean).join('\n');
+      }
+    }
+
+    return prompt;
+  }
+
   // --- Workspace Grouping ---
 
   /**