@yemi33/minions 0.1.1046 → 0.1.1048

package/CHANGELOG.md

@@ -1,11 +1,13 @@
 # Changelog
 
-## 0.1.1046 (2026-04-16)
+## 0.1.1048 (2026-04-17)
 
 ### Fixes
+- stamp live-output.log stub before spawn (#1198)
 -  harden settings save and migrate pr poll config
 
 ### Other
+- Harden prompt context handling
 - Harden loop watch conversion
 - Add watches sidebar activity badge
 - test(cli): add unit tests for handleCommand, start, stop, kill, spawn (#1191)

package/dashboard.js

@@ -533,9 +533,9 @@ setInterval(() => {
 
 // ── Command Center: session state + helpers ─────────────────────────────────
 
-// Sessions never expire by time — user controls lifecycle via tabs (new tab = new session, /clear = reset).
-// Only invalidated by: system prompt change, explicit clear, or tab close.
-const CC_SESSION_MAX_TURNS = Infinity;
+// Bound resumed session growth so stale conversations do not accumulate unbounded context.
+const CC_SESSION_MAX_TURNS = shared.ENGINE_DEFAULTS.ccMaxTurns;
+const CC_SESSION_TTL_MS = shared.ENGINE_DEFAULTS.ccSessionTtlMs;
 let ccSession = { sessionId: null, createdAt: null, lastActiveAt: null, turnCount: 0 };
 const ccInFlightTabs = new Map(); // tabId → timestamp — per-tab in-flight tracking for parallel CC requests
 const ccInFlightAborts = new Map(); // tabId → abortFn — lets a new request kill the stale LLM
@@ -568,15 +568,14 @@ function ccSessionValid() {
     ccSession = { sessionId: null, createdAt: null, lastActiveAt: null, turnCount: 0 };
     return false;
   }
+  if (_sessionExpired(ccSession.lastActiveAt || ccSession.createdAt, CC_SESSION_TTL_MS)) {
+    console.log('[CC] Session expired by TTL — starting fresh');
+    ccSession = { sessionId: null, createdAt: null, lastActiveAt: null, turnCount: 0 };
+    return false;
+  }
   return ccSession.turnCount < CC_SESSION_MAX_TURNS;
 }
 
-// Load persisted CC session on startup
-try {
-  const saved = safeJson(path.join(ENGINE_DIR, 'cc-session.json'));
-  if (saved && saved.sessionId) ccSession = saved;
-} catch { /* optional */ }
-
 // Static system prompt — baked into session on creation, never changes
 // Load CC system prompt from file — editable without touching engine code
 const CC_STATIC_SYSTEM_PROMPT = (() => {
@@ -592,6 +591,34 @@ const CC_STATIC_SYSTEM_PROMPT = (() => {
 // Hash the system prompt so we can detect changes and invalidate stale sessions
 const _ccPromptHash = require('crypto').createHash('md5').update(CC_STATIC_SYSTEM_PROMPT).digest('hex').slice(0, 8);
 
+function _sessionExpired(lastActiveAt, ttlMs) {
+  if (!lastActiveAt || !ttlMs) return false;
+  const at = new Date(lastActiveAt).getTime();
+  if (!Number.isFinite(at)) return true;
+  return Date.now() - at > ttlMs;
+}
+
+function _filterCcTabSessions(sessions) {
+  return (Array.isArray(sessions) ? sessions : []).filter(s =>
+    s && s.id && s.sessionId &&
+    (s.turnCount || 0) < CC_SESSION_MAX_TURNS &&
+    !_sessionExpired(s.lastActiveAt || s.createdAt, CC_SESSION_TTL_MS) &&
+    (!s._promptHash || s._promptHash === _ccPromptHash)
+  );
+}
+
+function _readCcTabSessions({ prune = true } = {}) {
+  const sessions = _filterCcTabSessions(shared.safeJsonArr(CC_SESSIONS_PATH));
+  if (prune) safeWrite(CC_SESSIONS_PATH, sessions);
+  return sessions;
+}
+
+// Load persisted CC session on startup
+try {
+  const saved = safeJson(path.join(ENGINE_DIR, 'cc-session.json'));
+  if (saved && saved.sessionId && !_sessionExpired(saved.lastActiveAt || saved.createdAt, CC_SESSION_TTL_MS)) ccSession = saved;
+} catch { /* optional */ }
+
 let _preambleCache = null;
 let _preambleCacheTs = 0;
 const PREAMBLE_TTL = 30000; // 30s — longer TTL since preamble is lightweight orientation, not real-time data
@@ -998,17 +1025,16 @@ async function executeCCActions(actions) {
 // Session store for doc modals — keyed by filePath or title, persisted to disk
 const CC_SESSIONS_PATH = path.join(ENGINE_DIR, 'cc-sessions.json');
 const DOC_SESSIONS_PATH = path.join(ENGINE_DIR, 'doc-sessions.json');
-const DOC_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 604800000 — 7 days
+const DOC_SESSION_TTL_MS = shared.ENGINE_DEFAULTS.docSessionTtlMs;
 const docSessions = new Map(); // key → { sessionId, lastActiveAt, turnCount }
 
 // Load persisted doc sessions on startup
 try {
   const saved = safeJson(DOC_SESSIONS_PATH);
   if (saved && typeof saved === 'object') {
-    const now = Date.now();
     for (const [key, s] of Object.entries(saved)) {
       if (s.turnCount >= CC_SESSION_MAX_TURNS) continue;
-      if (s.lastActiveAt && now - new Date(s.lastActiveAt).getTime() > DOC_SESSION_TTL_MS) continue;
+      if (_sessionExpired(s.lastActiveAt || s.createdAt, DOC_SESSION_TTL_MS)) continue;
       docSessions.set(key, s);
     }
   }
@@ -1052,7 +1078,7 @@ function resolveSession(store, key) {
     persistDocSessions();
     return null;
   }
-  if (s.lastActiveAt && Date.now() - new Date(s.lastActiveAt).getTime() > DOC_SESSION_TTL_MS) {
+  if (_sessionExpired(s.lastActiveAt || s.createdAt, DOC_SESSION_TTL_MS)) {
     docSessions.delete(key);
     persistDocSessions();
     return null;
@@ -3819,14 +3845,14 @@ What would you like to discuss or change? When you're happy, say "approve" and I
   }
 
   async function handleCCSessionsList(req, res) {
-    const sessions = shared.safeJsonArr(CC_SESSIONS_PATH);
+    const sessions = _readCcTabSessions();
     return jsonReply(res, 200, { sessions });
   }
 
   async function handleCCSessionDelete(req, res, match) {
     const id = match?.[1];
     if (!id) return jsonReply(res, 400, { error: 'id required' });
-    const sessions = shared.safeJsonArr(CC_SESSIONS_PATH);
+    const sessions = _readCcTabSessions();
     const filtered = sessions.filter(s => s.id !== id);
     safeWrite(CC_SESSIONS_PATH, filtered);
     return jsonReply(res, 200, { ok: true });
@@ -3885,7 +3911,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         }
 
         const parsed = parseCCActions(result.text);
-        const toolUses = _extractToolUsesFromRaw(result.raw);
+        const toolUses = Array.isArray(result.toolUses) ? result.toolUses : _extractToolUsesFromRaw(result.raw);
         // Safety net: detect /loop invocation and convert to create-watch
         const _loopWatch = _detectLoopInvocation(parsed.text, parsed.actions, toolUses);
         if (_loopWatch) {
@@ -3981,9 +4007,12 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         let sessionReset = false;
         // If system prompt changed since this session was created, force a fresh session
         if (tabSessionId) {
-          const sessions = shared.safeJsonArr(CC_SESSIONS_PATH);
+          const sessions = _readCcTabSessions();
           const tabEntry = sessions.find(s => s.id === (body.tabId || 'default'));
-          if (tabEntry && tabEntry._promptHash && tabEntry._promptHash !== _ccPromptHash) {
+          if (!tabEntry) {
+            tabSessionId = null;
+            sessionReset = true;
+          } else if (tabEntry._promptHash && tabEntry._promptHash !== _ccPromptHash) {
             tabSessionId = null;
             sessionReset = true;
           }
@@ -4065,7 +4094,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         const _persistTabId = body.tabId;
         if (_persistTabId && responseSessionId) {
           try {
-            const sessions = shared.safeJsonArr(CC_SESSIONS_PATH);
+            const sessions = _readCcTabSessions();
             const existing = sessions.find(s => s.id === _persistTabId);
             const preview = (body.message || '').slice(0, 80);
             if (existing) {

package/engine/cleanup.js

@@ -369,6 +369,22 @@ function runCleanup(config, verbose = false) {
     } catch (e) { log('warn', 'prune output archives: ' + e.message); }
   }
 
+  // 6b. Prune notes/archive — keep the most recent bounded set
+  cleaned.notesArchive = 0;
+  try {
+    const archiveDir = path.join(MINIONS_DIR, 'notes', 'archive');
+    if (fs.existsSync(archiveDir)) {
+      const archiveFiles = fs.readdirSync(archiveDir)
+        .map(name => ({ name, mtime: fs.statSync(path.join(archiveDir, name)).mtimeMs }))
+        .sort((a, b) => b.mtime - a.mtime);
+      if (archiveFiles.length > ENGINE_DEFAULTS.notesArchiveMaxFiles) {
+        for (const old of archiveFiles.slice(ENGINE_DEFAULTS.notesArchiveMaxFiles)) {
+          try { fs.unlinkSync(path.join(archiveDir, old.name)); cleaned.notesArchive++; } catch { /* cleanup */ }
+        }
+      }
+    }
+  } catch (e) { log('warn', 'prune notes archive: ' + e.message); }
+
   // 7. Prune orphaned dispatch entries — items whose source work item no longer exists
   cleaned.orphanedDispatches = 0;
   try {
@@ -708,8 +724,8 @@ function runCleanup(config, verbose = false) {
   // 14. Scrub stale temp agent keys from metrics.json
   try { scrubStaleMetrics(); } catch { /* best-effort cleanup */ }
 
-  if (cleaned.ccSessions + cleaned.docSessions + cleaned.cooldowns + cleaned.pidFiles + cleaned.pendingContextsTrimmed > 0) {
-    log('info', `Cleanup (resources): ${cleaned.ccSessions} cc-sessions, ${cleaned.docSessions} doc-sessions, ${cleaned.cooldowns} cooldowns, ${cleaned.pendingContextsTrimmed} pendingCtx trimmed, ${cleaned.pidFiles} PID files`);
+  if (cleaned.ccSessions + cleaned.docSessions + cleaned.cooldowns + cleaned.pidFiles + cleaned.pendingContextsTrimmed + cleaned.notesArchive > 0) {
+    log('info', `Cleanup (resources): ${cleaned.ccSessions} cc-sessions, ${cleaned.docSessions} doc-sessions, ${cleaned.cooldowns} cooldowns, ${cleaned.pendingContextsTrimmed} pendingCtx trimmed, ${cleaned.notesArchive} archived notes, ${cleaned.pidFiles} PID files`);
   }
 
   return cleaned;

package/engine/llm.js

@@ -5,7 +5,7 @@
 
 const path = require('path');
 const shared = require('./shared');
-const { safeWrite, safeUnlink, uid, ts, runFile, cleanChildEnv, parseStreamJsonOutput, mutateJsonFileLocked } = shared;
+const { safeWrite, safeUnlink, uid, ts, runFile, cleanChildEnv, parseStreamJsonOutput, mutateJsonFileLocked, appendTextTail, ENGINE_DEFAULTS } = shared;
 
 const MINIONS_DIR = shared.MINIONS_DIR;
 const ENGINE_DIR = path.join(MINIONS_DIR, 'engine');
@@ -127,6 +127,93 @@ function _spawnProcess(promptText, sysPromptText, { direct, label, model, maxTur
   return { proc, cleanupFiles };
 }
 
+function _createStreamAccumulator({
+  maxRawBytes,
+  maxStderrBytes,
+  maxLineBufferBytes,
+  maxTextLength = 0,
+  onChunk = null,
+  onToolUse = null,
+}) {
+  let stdout = '';
+  let stderr = '';
+  let lineBuf = '';
+  let text = '';
+  let usage = null;
+  let sessionId = null;
+  let lastTextSent = '';
+  const toolUses = [];
+
+  function captureResult(obj) {
+    if (!obj || typeof obj !== 'object') return;
+    if (obj.session_id) sessionId = obj.session_id;
+    if (obj.type === 'result') {
+      if (typeof obj.result === 'string') {
+        text = maxTextLength ? obj.result.slice(0, maxTextLength) : obj.result;
+      }
+      if (obj.total_cost_usd || obj.usage) {
+        usage = {
+          costUsd: obj.total_cost_usd || 0,
+          inputTokens: obj.usage?.input_tokens || 0,
+          outputTokens: obj.usage?.output_tokens || 0,
+          cacheRead: obj.usage?.cache_read_input_tokens || obj.usage?.cacheReadInputTokens || 0,
+          cacheCreation: obj.usage?.cache_creation_input_tokens || obj.usage?.cacheCreationInputTokens || 0,
+          durationMs: obj.duration_ms || 0,
+          numTurns: obj.num_turns || 0,
+        };
+      }
+    }
+    if (obj.type === 'assistant' && Array.isArray(obj.message?.content)) {
+      for (const block of obj.message.content) {
+        if (block?.type === 'text' && block.text) {
+          text = maxTextLength ? block.text.slice(0, maxTextLength) : block.text;
+          if (onChunk && block.text !== lastTextSent) {
+            lastTextSent = block.text;
+            onChunk(block.text);
+          }
+        } else if (block?.type === 'tool_use' && block.name) {
+          const toolUse = { name: block.name, input: block.input || {} };
+          toolUses.push(toolUse);
+          if (onToolUse) onToolUse(toolUse.name, toolUse.input);
+        }
+      }
+    }
+  }
+
+  function ingestStdout(chunk) {
+    const str = chunk == null ? '' : chunk.toString();
+    stdout = appendTextTail(stdout, str, maxRawBytes, '...(truncated stdout)\n');
+    lineBuf = appendTextTail(lineBuf, str, maxLineBufferBytes, '');
+    const lines = lineBuf.split('\n');
+    lineBuf = lines.pop() || '';
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || !trimmed.startsWith('{')) continue;
+      try { captureResult(JSON.parse(trimmed)); } catch { /* incomplete JSON or non-JSON line */ }
+    }
+  }
+
+  function ingestStderr(chunk) {
+    stderr = appendTextTail(stderr, chunk == null ? '' : chunk.toString(), maxStderrBytes, '...(truncated stderr)\n');
+  }
+
+  function finalize() {
+    const trimmed = lineBuf.trim();
+    if (trimmed.startsWith('{')) {
+      try { captureResult(JSON.parse(trimmed)); } catch { /* incomplete trailing JSON */ }
+    }
+    if (!text || !usage || !sessionId) {
+      const parsedTail = parseStreamJsonOutput(stdout, maxTextLength ? { maxTextLength } : {});
+      if (!text && parsedTail.text) text = parsedTail.text;
+      if (!usage && parsedTail.usage) usage = parsedTail.usage;
+      if (!sessionId && parsedTail.sessionId) sessionId = parsedTail.sessionId;
+    }
+    return { text, usage, sessionId, raw: stdout, stderr, toolUses };
+  }
+
+  return { ingestStdout, ingestStderr, finalize };
+}
+
 // ── Core LLM Call ───────────────────────────────────────────────────────────
 
 function callLLM(promptText, sysPromptText, { timeout = 120000, label = 'llm', model = 'sonnet', maxTurns = 1, allowedTools = '', sessionId = null, effort = null, direct = false } = {}) {
@@ -134,29 +221,32 @@ function callLLM(promptText, sysPromptText, { timeout = 120000, label = 'llm', m
   const promise = new Promise((resolve) => {
     const _startMs = Date.now();
     const { proc, cleanupFiles } = _spawnProcess(promptText, sysPromptText, { direct, label, model, maxTurns, allowedTools, effort, sessionId });
+    const acc = _createStreamAccumulator({
+      maxRawBytes: ENGINE_DEFAULTS.maxLlmRawBytes,
+      maxStderrBytes: ENGINE_DEFAULTS.maxLlmStderrBytes,
+      maxLineBufferBytes: ENGINE_DEFAULTS.maxLlmLineBufferBytes,
+    });
 
     _abort = () => { shared.killImmediate(proc); };
 
-    let stdout = '';
-    let stderr = '';
-    proc.stdout.on('data', d => { stdout += d.toString(); });
-    proc.stderr.on('data', d => { stderr += d.toString(); });
+    proc.stdout.on('data', d => { acc.ingestStdout(d); });
+    proc.stderr.on('data', d => { acc.ingestStderr(d); });
 
     const timer = setTimeout(() => { shared.killImmediate(proc); }, timeout);
 
     proc.on('close', (code) => {
       clearTimeout(timer);
       for (const f of cleanupFiles) safeUnlink(f);
-      const parsed = parseStreamJsonOutput(stdout);
+      const parsed = acc.finalize();
       const durationMs = Date.now() - _startMs;
       const usage = parsed.usage ? { ...parsed.usage, durationMs } : { durationMs };
-      resolve({ text: parsed.text || '', usage, sessionId: parsed.sessionId || null, code, stderr, raw: stdout });
+      resolve({ text: parsed.text || '', usage, sessionId: parsed.sessionId || null, code, stderr: parsed.stderr, raw: parsed.raw, toolUses: parsed.toolUses });
     });
 
     proc.on('error', (err) => {
       clearTimeout(timer);
       for (const f of cleanupFiles) safeUnlink(f);
-      resolve({ text: '', usage: null, sessionId: null, code: 1, stderr: err.message, raw: '' });
+      resolve({ text: '', usage: null, sessionId: null, code: 1, stderr: err.message, raw: '', toolUses: [] });
     });
   });
   promise.abort = () => { if (_abort) _abort(); };
@@ -190,56 +280,34 @@ function callLLMStreaming(promptText, sysPromptText, { timeout = 120000, label =
   const promise = new Promise((resolve) => {
     const _startMs = Date.now();
     const { proc, cleanupFiles } = _spawnProcess(promptText, sysPromptText, { direct, label, model, maxTurns, allowedTools, effort, sessionId });
+    const acc = _createStreamAccumulator({
+      maxRawBytes: ENGINE_DEFAULTS.maxLlmRawBytes,
+      maxStderrBytes: ENGINE_DEFAULTS.maxLlmStderrBytes,
+      maxLineBufferBytes: ENGINE_DEFAULTS.maxLlmLineBufferBytes,
+      onChunk,
+      onToolUse,
+    });
 
     _abort = () => { shared.killImmediate(proc); };
 
-    let stdout = '';
-    let stderr = '';
-    let lineBuf = '';
-
-    let lastTextSent = '';
-    proc.stdout.on('data', d => {
-      const chunk = d.toString();
-      stdout += chunk;
-      lineBuf += chunk;
-      // Parse complete lines for streaming text
-      const lines = lineBuf.split('\n');
-      lineBuf = lines.pop(); // keep incomplete line in buffer
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed || !trimmed.startsWith('{')) continue;
-        try {
-          const obj = JSON.parse(trimmed);
-          if (obj.type === 'assistant' && obj.message?.content) {
-            for (const block of obj.message.content) {
-              if (block.type === 'text' && block.text && block.text !== lastTextSent) {
-                lastTextSent = block.text;
-                onChunk(block.text);
-              } else if (block.type === 'tool_use' && block.name && onToolUse) {
-                onToolUse(block.name, block.input);
-              }
-            }
-          }
-        } catch { /* incomplete JSON or non-JSON line */ }
-      }
-    });
-    proc.stderr.on('data', d => { stderr += d.toString(); });
+    proc.stdout.on('data', d => { acc.ingestStdout(d); });
+    proc.stderr.on('data', d => { acc.ingestStderr(d); });
 
     const timer = setTimeout(() => { shared.killImmediate(proc); }, timeout);
 
     proc.on('close', (code) => {
       clearTimeout(timer);
       for (const f of cleanupFiles) safeUnlink(f);
-      const parsed = parseStreamJsonOutput(stdout);
+      const parsed = acc.finalize();
       const durationMs = Date.now() - _startMs;
       const usage = parsed.usage ? { ...parsed.usage, durationMs } : { durationMs };
-      resolve({ text: parsed.text || '', usage, sessionId: parsed.sessionId || null, code, stderr, raw: stdout });
+      resolve({ text: parsed.text || '', usage, sessionId: parsed.sessionId || null, code, stderr: parsed.stderr, raw: parsed.raw, toolUses: parsed.toolUses });
     });
 
     proc.on('error', (err) => {
       clearTimeout(timer);
       for (const f of cleanupFiles) safeUnlink(f);
-      resolve({ text: '', usage: null, sessionId: null, code: 1, stderr: err.message, raw: '' });
+      resolve({ text: '', usage: null, sessionId: null, code: 1, stderr: err.message, raw: '', toolUses: [] });
     });
   });
   promise.abort = () => { if (_abort) _abort(); };
@@ -252,4 +320,3 @@ module.exports = {
   trackEngineUsage,
   isResumeSessionStillValid,
 };
-

package/engine/meeting.js

@@ -18,6 +18,20 @@ const EMPTY_OUTPUT_PATTERNS = ['(no output)', '(no findings)', '(no response)'];
 
 const MEETINGS_DIR = path.join(__dirname, '..', 'meetings');
 
+function truncateMeetingContext(text, maxBytes, label) {
+  return shared.truncateTextBytes(text, maxBytes, `\n\n_...${label} truncated — review the meeting transcript if needed._`);
+}
+
+function formatMeetingContributions(entries, agents, emptyText, label, maxBytes) {
+  const pairs = Object.entries(typeof entries === 'object' && entries ? entries : {});
+  if (pairs.length === 0) return emptyText;
+  const perEntryBytes = Math.max(1024, Math.floor(maxBytes / Math.max(1, pairs.length)));
+  const combined = pairs.map(([agent, value]) =>
+    `### ${agents[agent]?.name || agent}\n\n${truncateMeetingContext(value?.content || emptyText, perEntryBytes, `${label} entry`)}`
+  ).join('\n\n---\n\n');
+  return truncateMeetingContext(combined, maxBytes, label);
+}
+
 function getMeetings() {
   if (!fs.existsSync(MEETINGS_DIR)) return [];
   return fs.readdirSync(MEETINGS_DIR)
@@ -100,13 +114,25 @@ function discoverMeetingWork(config) {
       const key = `${concludePrefix}${concluder}`;
       if (activeKeys.has(key)) continue;
 
-      const humanNotes = (Array.isArray(meeting.humanNotes) ? meeting.humanNotes : []).map(n => '- ' + n).join('\n');
-      const allFindings = Object.entries(typeof meeting.findings === 'object' && meeting.findings ? meeting.findings : {}).map(([agent, f]) =>
-        `### ${agents[agent]?.name || agent}\n\n${f.content || '(no findings)'}`
-      ).join('\n\n---\n\n');
-      const allDebate = Object.entries(typeof meeting.debate === 'object' && meeting.debate ? meeting.debate : {}).map(([agent, d]) =>
-        `### ${agents[agent]?.name || agent}\n\n${d.content || '(no response)'}`
-      ).join('\n\n---\n\n');
+      const humanNotes = truncateMeetingContext(
+        (Array.isArray(meeting.humanNotes) ? meeting.humanNotes : []).map(n => '- ' + n).join('\n'),
+        ENGINE_DEFAULTS.maxMeetingHumanNotesBytes,
+        'human meeting notes'
+      );
+      const allFindings = formatMeetingContributions(
+        meeting.findings,
+        agents,
+        '(no findings)',
+        'meeting findings',
+        ENGINE_DEFAULTS.maxMeetingPromptBytes
+      );
+      const allDebate = formatMeetingContributions(
+        meeting.debate,
+        agents,
+        '(no response)',
+        'meeting debate',
+        ENGINE_DEFAULTS.maxMeetingPromptBytes
+      );
 
       const vars = {
         agent_name: agents[concluder]?.name || concluder,
@@ -149,7 +175,11 @@ function discoverMeetingWork(config) {
       const key = `meeting-${meeting.id}-r${round}-${agentId}`;
       if (activeKeys.has(key)) continue;
 
-      const humanNotes = (meeting.humanNotes || []).map(n => '- ' + n).join('\n');
+      const humanNotes = truncateMeetingContext(
+        (meeting.humanNotes || []).map(n => '- ' + n).join('\n'),
+        ENGINE_DEFAULTS.maxMeetingHumanNotesBytes,
+        'human meeting notes'
+      );
       const vars = {
         agent_name: agents[agentId]?.name || agentId,
         agent_role: agents[agentId]?.role || 'Agent',
@@ -160,9 +190,13 @@ function discoverMeetingWork(config) {
       };
 
       if (roundName === 'debating') {
-        vars.all_findings = Object.entries(meeting.findings || {}).map(([agent, f]) =>
-          `### ${agents[agent]?.name || agent}\n\n${f.content || '(no findings)'}`
-        ).join('\n\n---\n\n');
+        vars.all_findings = formatMeetingContributions(
+          meeting.findings,
+          agents,
+          '(no findings)',
+          'meeting findings',
+          ENGINE_DEFAULTS.maxMeetingPromptBytes
+        );
       }
 
       const playbookName = roundName === 'investigating' ? 'meeting-investigate' : 'meeting-debate';

package/engine/pipeline.js

@@ -15,6 +15,10 @@ const { parseCronExpr, shouldRunNow } = require('./scheduler');
 const PIPELINES_DIR = path.join(__dirname, '..', 'pipelines');
 const PIPELINE_RUNS_PATH = path.join(__dirname, 'pipeline-runs.json');
 
+function truncatePipelineContext(text, maxBytes, label) {
+  return shared.truncateTextBytes(text, maxBytes, `\n\n_...${label} truncated — inspect the upstream artifacts if needed._`);
+}
+
 // ── Pipeline CRUD ────────────────────────────────────────────────────────────
 
 function getPipelines() {
@@ -433,7 +437,11 @@ async function executePlanStage(stage, stageState, run, config) {
     try {
       const mtg = safeJson(path.join(__dirname, '..', 'meetings', mid + '.json'));
       if (mtg) {
-        const transcript = (mtg.transcript || []).map(formatTranscriptEntry).join('\n\n---\n\n');
+        const transcript = truncatePipelineContext(
+          (mtg.transcript || []).map(formatTranscriptEntry).join('\n\n---\n\n'),
+          ENGINE_DEFAULTS.maxPipelineMeetingContextBytes,
+          `meeting transcript for ${mtg.title || mid}`
+        );
         meetingContext += '# Meeting: ' + (mtg.title || mid) + '\n\n**Agenda:** ' + (mtg.agenda || '') + '\n\n' + transcript + '\n\n';
       }
     } catch (e) { log('warn', `Pipeline plan: failed to read meeting ${mid}: ${e.message}`); }
@@ -443,10 +451,15 @@ async function executePlanStage(stage, stageState, run, config) {
     for (const depId of stage.dependsOn) {
       const depStage = run.stages[depId];
       if (depStage?.output && !depStage.artifacts?.meetings?.length) {
-        meetingContext += '## From: ' + depId + '\n\n' + depStage.output + '\n\n';
+        meetingContext += '## From: ' + depId + '\n\n' + truncatePipelineContext(
+          depStage.output,
+          ENGINE_DEFAULTS.maxPipelineMeetingContextBytes,
+          `pipeline stage output from ${depId}`
+        ) + '\n\n';
       }
     }
   }
+  meetingContext = truncatePipelineContext(meetingContext, ENGINE_DEFAULTS.maxPipelineMeetingContextBytes, 'pipeline meeting context');
 
   // Use LLM to generate a structured plan (same approach as dashboard "Create Plan from Meeting" button)
   let content = '';

package/engine/playbook.js

@@ -9,7 +9,7 @@ const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
 
-const { safeJson, safeRead, getProjects, log, ts, dateStamp, WI_STATUS, WORK_TYPE, PR_STATUS, DISPATCH_RESULT } = shared;
+const { safeJson, safeRead, getProjects, log, ts, dateStamp, truncateTextBytes, ENGINE_DEFAULTS, WI_STATUS, WORK_TYPE, PR_STATUS, DISPATCH_RESULT } = shared;
 const { getConfig, getDispatch, getNotes, getAgentCharter, getPrs, AGENTS_DIR } = queries;
 
 const MINIONS_DIR = path.resolve(__dirname, '..');
@@ -119,6 +119,10 @@ function resolveTaskContext(item, config) {
   }));
   const resolved = { additionalContext: '', referencedFiles: [] };
 
+  function truncateReferencedContext(content, maxBytes, label) {
+    return truncateTextBytes(content, maxBytes, `\n\n_...${label} truncated — read the full file if needed._`);
+  }
+
 
   // Match agent references: "ripley's plan", "dallas's pr", "lambert's output", etc.
   for (const agent of agentNames) {
@@ -144,7 +148,7 @@ function resolveTaskContext(item, config) {
           const planPath = path.join(MINIONS_DIR, 'plans', planFile);
           try {
             const content = safeRead(planPath);
-            resolved.additionalContext += `\n\n## Referenced Plan: ${planFile} (created by ${agent.name})\n\n${content}`;
+            resolved.additionalContext += `\n\n## Referenced Plan: ${planFile} (created by ${agent.name})\n\n${truncateReferencedContext(content, ENGINE_DEFAULTS.maxReferencedPlanBytes, 'referenced plan')}`;
             resolved.referencedFiles.push(planPath);
             log('info', `Context resolution: found plan "${planFile}" by ${agent.name} for work item ${item.id}`);
           } catch (e) { log('warn', 'resolve plan context: ' + e.message); }
@@ -155,7 +159,7 @@ function resolveTaskContext(item, config) {
             const planPath = path.join(MINIONS_DIR, 'plans', match);
             try {
               const content = safeRead(planPath);
-              resolved.additionalContext += `\n\n## Referenced Plan: ${match}\n\n${content}`;
+              resolved.additionalContext += `\n\n## Referenced Plan: ${match}\n\n${truncateReferencedContext(content, ENGINE_DEFAULTS.maxReferencedPlanBytes, 'referenced plan')}`;
               resolved.referencedFiles.push(planPath);
               log('info', `Context resolution: found plan "${match}" (name match) for work item ${item.id}`);
             } catch (e) { log('warn', 'resolve plan fallback context: ' + e.message); }
@@ -178,7 +182,7 @@ function resolveTaskContext(item, config) {
           .sort().reverse();
         if (files.length > 0) {
           const content = safeRead(path.join(inboxDir, files[0]));
-          resolved.additionalContext += `\n\n## Referenced Notes by ${agent.name}: ${files[0]}\n\n${content.slice(0, 5000)}`;
+          resolved.additionalContext += `\n\n## Referenced Notes by ${agent.name}: ${files[0]}\n\n${truncateReferencedContext(content, ENGINE_DEFAULTS.maxReferencedNotesBytes, 'referenced notes')}`;
           resolved.referencedFiles.push(path.join(inboxDir, files[0]));
           log('info', `Context resolution: found notes "${files[0]}" by ${agent.name} for work item ${item.id}`);
         }
@@ -197,13 +201,20 @@ function resolveTaskContext(item, config) {
       if (plans.length > 0) {
         const planPath = path.join(MINIONS_DIR, 'plans', plans[0]);
         const content = safeRead(planPath);
-        resolved.additionalContext += `\n\n## Referenced Plan (latest): ${plans[0]}\n\n${content}`;
+        resolved.additionalContext += `\n\n## Referenced Plan (latest): ${plans[0]}\n\n${truncateReferencedContext(content, ENGINE_DEFAULTS.maxReferencedPlanBytes, 'referenced plan')}`;
         resolved.referencedFiles.push(planPath);
         log('info', `Context resolution: using latest plan "${plans[0]}" for work item ${item.id}`);
       }
     } catch (e) { log('warn', 'resolve latest plan context: ' + e.message); }
   }
 
+  if (resolved.additionalContext) {
+    resolved.additionalContext = truncateTextBytes(
+      resolved.additionalContext,
+      ENGINE_DEFAULTS.maxResolvedTaskContextBytes,
+      '\n\n_...additional referenced context truncated — read the referenced files if needed._'
+    );
+  }
   return resolved;
 }
 
@@ -316,14 +327,16 @@ function renderPlaybook(type, vars) {
     content += '\n\n---\n\n## Pinned Context (CRITICAL — READ FIRST)\n\n' + pinnedContent;
   }
 
-  // Inject team notes (single injection point — not in buildAgentContext) — capped at 8KB
+  // Inject team notes (single injection point — not in buildAgentContext) — capped via ENGINE_DEFAULTS
   let notes = getNotes();
   if (notes) {
-    if (notes.length > 8192) {
+    if (Buffer.byteLength(notes, 'utf8') > ENGINE_DEFAULTS.maxNotesPromptBytes) {
       const sections = notes.split(/(?=^### )/m);
-      const recent = sections.slice(-10).join('');
-      notes = recent.length > 8192 ? recent.slice(0, 8192) + '\n\n_...notes truncated_' : recent;
-      notes += '\n\n_' + Math.max(0, sections.length - 10) + ' older entries in `notes.md` — Read if needed._';
+      const recent = sections.slice(-10).join('') || notes;
+      const olderCount = Math.max(0, sections.length - 10);
+      const footer = olderCount > 0 ? `\n\n_${olderCount} older entries in \`notes.md\` — Read if needed._` : '';
+      const budget = Math.max(0, ENGINE_DEFAULTS.maxNotesPromptBytes - Buffer.byteLength(footer, 'utf8'));
+      notes = truncateTextBytes(recent, budget, '\n\n_...notes truncated_') + footer;
     }
     content += '\n\n---\n\n## Team Notes (MUST READ)\n\n' + notes;
   }

package/engine/shared.js

@@ -391,6 +391,44 @@ function uniquePath(filePath) {
   return `${base}-${Date.now()}${ext}`;
 }
 
+function truncateTextBytes(text, maxBytes, suffix = '') {
+  const value = text == null ? '' : String(text);
+  if (!maxBytes || maxBytes <= 0) return '';
+  if (Buffer.byteLength(value, 'utf8') <= maxBytes) return value;
+  const suffixText = suffix == null ? '' : String(suffix);
+  const suffixBytes = Buffer.byteLength(suffixText, 'utf8');
+  const targetBytes = Math.max(0, maxBytes - suffixBytes);
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(value.slice(0, mid), 'utf8') <= targetBytes) low = mid;
+    else high = mid - 1;
+  }
+  return value.slice(0, low) + suffixText;
+}
+
+function tailTextBytes(text, maxBytes, prefix = '') {
+  const value = text == null ? '' : String(text);
+  if (!maxBytes || maxBytes <= 0) return '';
+  if (Buffer.byteLength(value, 'utf8') <= maxBytes) return value;
+  const prefixText = prefix == null ? '' : String(prefix);
+  const prefixBytes = Buffer.byteLength(prefixText, 'utf8');
+  const targetBytes = Math.max(0, maxBytes - prefixBytes);
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    if (Buffer.byteLength(value.slice(mid), 'utf8') <= targetBytes) high = mid;
+    else low = mid + 1;
+  }
+  return prefixText + value.slice(low);
+}
+
+function appendTextTail(existing, addition, maxBytes, prefix = '') {
+  return tailTextBytes((existing || '') + (addition || ''), maxBytes, prefix);
+}
+
 // ── Inbox Helpers ───────────────────────────────────────────────────────────
 
 /**
@@ -687,6 +725,19 @@ const ENGINE_DEFAULTS = {
   maxDispatchPromptBytes: 1024 * 1024, // 1 MB — dispatch items with prompts larger than this sidecar to engine/contexts/ to prevent dispatch.json OOM (#1167)
   maxStateFileBytes: 100 * 1024 * 1024, // 100 MB — fail startup with a clear error when dispatch.json / cooldowns.json exceed this, rather than silently OOMing on JSON.parse (#1167)
   ccMaxTurns: 50, // max tool-use turns for CC/doc-chat before CLI stops
+  ccSessionTtlMs: 2 * 60 * 60 * 1000, // 2h — expire stale resumed CC sessions to cap context growth
+  docSessionTtlMs: 7 * 24 * 60 * 60 * 1000, // 7d — longer-lived doc sessions, still bounded
+  maxLlmRawBytes: 256 * 1024, // keep only a bounded stdout tail from direct Claude calls
+  maxLlmStderrBytes: 64 * 1024, // keep only a bounded stderr tail from direct Claude calls
+  maxLlmLineBufferBytes: 128 * 1024, // cap the incremental JSON line buffer to avoid malformed-stream OOMs
+  maxReferencedPlanBytes: 12 * 1024, // cap full plan injection when implicit task context references prior plans
+  maxReferencedNotesBytes: 5 * 1024, // cap referenced inbox note excerpts injected via task context resolution
+  maxResolvedTaskContextBytes: 20 * 1024, // bound the total implicit context injected from referenced plans/notes
+  maxNotesPromptBytes: 8 * 1024, // cap Team Notes injected into every playbook prompt
+  maxMeetingPromptBytes: 16 * 1024, // cap meeting findings/debate context injected into prompts
+  maxMeetingHumanNotesBytes: 2 * 1024, // cap human note bullet lists injected into meeting prompts
+  maxPipelineMeetingContextBytes: 16 * 1024, // cap aggregated meeting/dependency context for pipeline plan generation
+  notesArchiveMaxFiles: 2000, // keep notes/archive bounded during periodic cleanup
   // Teams integration — config.teams shape: { enabled, appId, appPassword, certPath, privateKeyPath, tenantId, notifyEvents, ccMirror, inboxPollInterval }
   // Auth modes: (1) appId + appPassword (client secret), or (2) appId + certPath + privateKeyPath + tenantId (certificate)
   teams: {
@@ -1527,6 +1578,9 @@ module.exports = {
   mutatePullRequests,
   uid,
   uniquePath,
+  truncateTextBytes,
+  tailTextBytes,
+  appendTextTail,
   writeToInbox, parseNoteId,
   exec,
   execAsync,

package/engine/timeout.js

@@ -308,16 +308,27 @@ function checkTimeouts(config) {
     const procInfo = activeProcesses.get(item.id);
     if (procInfo?._steeringAt && Date.now() - procInfo._steeringAt < 60000) continue;
 
+    // Capture live-output.log file state for orphan/hung diagnostics (#W-mo248lkjwgsu).
+    // Three distinguishable failure modes:
+    //   logExists=false           → spawn call itself threw, no log ever written
+    //   logExists=true, size~stub → process died at startup (stub-only content)
+    //   logExists=true, size>stub → genuine hang (process alive, wrote output, then stopped)
+    let _logState = 'logExists=false logSize=0';
+    try {
+      const lst = fs.statSync(liveLogPath);
+      _logState = `logExists=true logSize=${lst.size}`;
+    } catch { /* ENOENT — keep default */ }
+
     if (!hasProcess && silentMs > effectiveTimeout && (Date.now() > engineRestartGraceUntil || engineRestartGraceExempt?.has(item.id))) {
       // No tracked process AND no recent output past effective timeout AND (grace period expired OR confirmed-dead at restart) → orphaned
-      log('warn', `Orphan detected: ${item.agent} (${item.id}) — no process tracked, silent for ${silentSec}s${isBlocking ? ' (blocking timeout exceeded)' : ''}`);
+      log('warn', `Orphan detected: ${item.agent} (${item.id}) — no process tracked, silent for ${silentSec}s${isBlocking ? ' (blocking timeout exceeded)' : ''} [${_logState}]`);
       dispatch().updateAgentStatus(item.id, AGENT_STATUS.TIMED_OUT, `Orphaned — no process, silent for ${silentSec}s`);
       // Clear session so retry starts fresh
       try { shared.safeUnlink(path.join(AGENTS_DIR, item.agent, 'session.json')); } catch {}
       deadItems.push({ item, reason: `Orphaned — no process, silent for ${silentSec}s` });
     } else if (hasProcess && silentMs > effectiveTimeout) {
       // Has process but no output past effective timeout → hung
-      log('warn', `Hung agent: ${item.agent} (${item.id}) — process exists but no output for ${silentSec}s${isBlocking ? ' (blocking timeout exceeded)' : ''}`);
+      log('warn', `Hung agent: ${item.agent} (${item.id}) — process exists but no output for ${silentSec}s${isBlocking ? ' (blocking timeout exceeded)' : ''} [${_logState}]`);
       dispatch().updateAgentStatus(item.id, AGENT_STATUS.TIMED_OUT, `Hung — no output for ${silentSec}s`);
       const procInfo = activeProcesses.get(item.id);
       if (procInfo) {

package/engine.js

@@ -871,25 +871,16 @@ async function spawnAgent(dispatchItem, config) {
   const spawnScript = path.join(ENGINE_DIR, 'spawn-agent.js');
   const spawnArgs = [spawnScript, promptPath, sysPromptPath, ...args];
 
-  const proc = runFile(process.execPath, spawnArgs, {
-    cwd,
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env: childEnv,
-  });
-
-  const MAX_OUTPUT = 1024 * 1024; // 1MB
-  let stdout = '';
-  let stderr = '';
-  let lastOutputAt = Date.now();
-  let heartbeatTimer = null;
-  let _trustCheckDone = false;
-  const _spawnTime = Date.now();
-
-  // Live output file — written as data arrives so dashboard can tail it
+  // Live output file — stamped BEFORE child process is spawned (#W-mo248lkjwgsu).
+  // Writing the stub pre-spawn lets the orphan detector distinguish three failure modes
+  // that otherwise look identical:
+  //   1. No log file          → spawn call itself threw before reaching this line
+  //   2. Log has stub only    → process started but died before its first write
+  //   3. Log has stub + ...   → process alive but hung (the only case that warrants orphan kill+retry)
   const liveOutputPath = path.join(AGENTS_DIR, agentId, 'live-output.log');
 
   // Rotate previous live output to preserve session history (fixes #543: orphan recovery overwrites)
-  // Only rotate if the existing file has meaningful content (beyond just the header)
+  // Only rotate if the existing file has meaningful content (beyond just the header stub)
   const LIVE_OUTPUT_SPARSE_THRESHOLD = 500; // bytes — header + init JSON is typically < 500
   try {
     if (fs.existsSync(liveOutputPath)) {
@@ -901,7 +892,37 @@ async function spawnAgent(dispatchItem, config) {
     }
   } catch { /* rotation is best-effort — overwrite still happens below */ }
 
-  safeWrite(liveOutputPath, `# Live output for ${agentId} — ${id}\n# Started: ${startedAt}\n# Task: ${dispatchItem.task}\n\n`);
+  // Stamp the log synchronously before spawn. If the synchronous write throws,
+  // we still attempt to spawn (log-file stamp failure must not block the agent),
+  // but we note it so the diagnostic trail isn't silent either.
+  try {
+    safeWrite(liveOutputPath, `# Live output for ${agentId} — ${id}\n# Started: ${startedAt}\n# Task: ${dispatchItem.task}\n[${new Date().toISOString()}] spawn: agent=${agentId} item=${id}\n\n`);
+  } catch (stubErr) {
+    log('warn', `Failed to stamp live-output stub for ${agentId} (${id}): ${stubErr.message}`);
+  }
+
+  let proc;
+  try {
+    proc = runFile(process.execPath, spawnArgs, {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: childEnv,
+    });
+  } catch (spawnErr) {
+    // Synchronous spawn failure — record it to the (already-stamped) log so the
+    // orphan detector's "logSize > stub-only" check can tell this apart from a
+    // hung process. Then rethrow so the dispatch loop handles it normally.
+    try { fs.appendFileSync(liveOutputPath, `[${new Date().toISOString()}] spawn-failed: ${spawnErr.message}\n[process-exit] spawn-failed\n`); } catch { /* cleanup-only best effort */ }
+    throw spawnErr;
+  }
+
+  const MAX_OUTPUT = 1024 * 1024; // 1MB
+  let stdout = '';
+  let stderr = '';
+  let lastOutputAt = Date.now();
+  let heartbeatTimer = null;
+  let _trustCheckDone = false;
+  const _spawnTime = Date.now();
 
   // Keep live log active even when the agent produces no stdout/stderr for long stretches.
   // This makes "silent but running" states visible in the dashboard tail view.
@@ -2491,9 +2512,10 @@ function normalizeAc(ac) {
 function buildWorkItemDispatchVars(item, vars, config, options = {}) {
   const { worktreePath, includeNotes = true, workType } = options;
 
-  // Notes content (uses queries.getNotes instead of inline fs.readFileSync)
+  // Team notes are injected once in renderPlaybook(). Keep notes_content as a
+  // lightweight pointer so prompts do not duplicate the full notes.md blob.
   if (includeNotes) {
-    vars.notes_content = getNotes() || '';
+    vars.notes_content = 'See the **Team Notes** section above for the latest shared team context.';
   }
 
   // References
@@ -2540,7 +2562,7 @@ function buildWorkItemDispatchVars(item, vars, config, options = {}) {
   if (workType === WORK_TYPE.ASK) {
     vars.question = item.title + (item.description ? '\n\n' + item.description : '');
     vars.task_id = item.id;
-    vars.notes_content = getNotes() || '';
+    vars.notes_content = 'See the **Team Notes** section above for the latest shared team context.';
   }
 
   // Resolve implicit context references (e.g., "ripley's plan", "the latest plan")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1046",
+  "version": "0.1.1048",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"