@yemi33/minions 0.1.2381 → 0.1.2383

package/engine/agent-worker-pool.js

@@ -18,6 +18,7 @@
  *       worker exists and the pool is already at its configured size.
  *       WorkerHandle: {
  *         dispatchId,
+ *         currentModel,                       // ACP-selected session model
  *         stream(promptText, opts) → Promise,  // ACP session/prompt turn
  *         cancel(),                            // ACP session/cancel
  *         release(),                           // return the worker to the
@@ -133,7 +134,8 @@ function _pump() {
     const req = _queue[0];
 
     const matchIdx = _free.findIndex((w) =>
-      w.mcpServersHash === req.mcpServersHash
+      w.runtime === req.runtime
+      && w.mcpServersHash === req.mcpServersHash
       && w.processContextHash === req.processContextHash
     );
     if (matchIdx >= 0) {
@@ -230,6 +232,7 @@ async function _spawnFreshWorker(req) {
 // queued request can spawn its replacement.
 async function _bootWorker(req) {
   const worker = new Worker({
+    runtime: req.runtime,
     id: `agent-pool-${_nextWorkerId++}`,
     model: req.model,
     effort: req.effort,
@@ -312,7 +315,7 @@ function _clearLeaseContext(dispatchId) {
 }
 
 async function acquireWorker({
-  dispatchId, cwd, model, effort, mcpServers, hermeticDirs, processEnv, sessionContext,
+  runtime, dispatchId, cwd, model, effort, mcpServers, hermeticDirs, processEnv, sessionContext,
 } = {}) {
   if (!dispatchId) throw new Error('agent-worker-pool.acquireWorker: dispatchId is required');
   if (_draining) throw new Error('agent-worker-pool: draining');
@@ -324,6 +327,7 @@ async function acquireWorker({
   }
 
   const mcpServersHash = hashMcpServers(mcpServers);
+  const runtimeAdapter = transport.resolveWorkerRuntime(runtime);
   const workerProcessEnv = processEnv && typeof processEnv === 'object'
     ? Object.freeze({ ...processEnv })
     : undefined;
@@ -332,6 +336,7 @@ async function acquireWorker({
     ? { ...sessionContext }
     : {};
   const req = {
+    runtime: runtimeAdapter,
     dispatchId, cwd, model, effort, mcpServers, mcpServersHash,
     processEnv: workerProcessEnv, processContextHash,
   };
@@ -365,12 +370,14 @@ async function acquireWorker({
     dispatchId,
     // P-1d8f0b93 — exposed so engine.js's PooledAgentProcess facade (the
     // spawnAgent integration) can write the same PID-file/log identity a
-    // cold-spawned child_process would, and stamp the ACP sessionId into the
-    // synthesized `result` event for parseOutput parity. Both are read-time
+    // cold-spawned child_process would, stamp the ACP sessionId into the
+    // synthesized `result` event, and expose the model selected by session/new.
+    // All are read-time
     // snapshots of the underlying worker's current values (a getter, not a
     // captured copy), since sessionId can rotate under a reused worker.
     get pid() { return (worker.proc && worker.proc.pid) || null; },
     get sessionId() { return worker.sessionId || null; },
+    get currentModel() { return worker.currentModel || null; },
     stream: async (promptText, opts = {}) => {
       try {
         return await worker.stream(promptText, {

package/engine/cc-worker-pool.js

@@ -151,8 +151,9 @@ function _trace(...parts) {
 
 // ── Public API ────────────────────────────────────────────────────────────
 
-async function getSession({ tabId, model, effort, mcpServers, systemPromptHash, cwd } = {}) {
+async function getSession({ runtime, tabId, model, effort, mcpServers, systemPromptHash, cwd } = {}) {
   if (!tabId) throw new Error('cc-worker-pool.getSession: tabId is required');
+  const runtimeAdapter = transport.resolveWorkerRuntime(runtime);
   const mcpServersHash = _hashMcpServers(mcpServers);
   let worker = _tabs.get(tabId);
   // Track which lifecycle path we took so the dashboard's [cc-timing] log can
@@ -195,7 +196,7 @@ async function getSession({ tabId, model, effort, mcpServers, systemPromptHash,
     if (worker.killed) {
       _tabs.delete(tabId);
       worker = null;
-    } else if (worker.mcpServersHash !== mcpServersHash) {
+    } else if (worker.runtime !== runtimeAdapter || worker.mcpServersHash !== mcpServersHash) {
       // mcpServers shape changed → must respawn the proc; the daemon
       // resolves MCP server config at process boot, not per session.
       _tabs.delete(tabId);
@@ -222,6 +223,7 @@ async function getSession({ tabId, model, effort, mcpServers, systemPromptHash,
 
   if (!worker) {
     worker = new Worker({
+      runtime: runtimeAdapter,
       id: tabId, model, effort, mcpServers, mcpServersHash, systemPromptHash, cwd,
       internals: _internals, trace: _trace,
     });

package/engine/claude-md-context.js

@@ -0,0 +1,195 @@
+/**
+ * engine/claude-md-context.js — CLAUDE.md propagation for non-Claude runtimes.
+ *
+ * W-mrdon0pe000l045a. CLAUDE.md auto-discovery is a Claude-Code-CLI-only
+ * convention (the claude binary reads CLAUDE.md itself at startup). Copilot and
+ * Codex have NO equivalent auto-load, so repo-authored CLAUDE.md files — which
+ * frequently carry load-bearing "must be kept in sync" rules and name blessed
+ * tooling — are structurally invisible to a Copilot/Codex-based fleet.
+ *
+ * This module discovers the *nearest applicable* CLAUDE.md files for a dispatch
+ * (bounded walk-UP from path hints toward the project root — NOT a full monorepo
+ * walk) and renders them into a prompt block. engine/playbook.js injects that
+ * block as a "Project instructions (CLAUDE.md)" context layer, gated on the
+ * runtime capability `claudeMdNativeDiscovery` (skip when true → Claude) and the
+ * `propagateClaudeMdForNonClaudeRuntimes` config flag.
+ *
+ * The whole point is to be CHEAP: it only stats CLAUDE.md at each ancestor
+ * directory of a small set of hint dirs (capped depth + capped file count), so
+ * it never walks a huge monorepo like office/src.
+ *
+ * This module is pure file discovery + string building — no engine state, no
+ * locking, no writes.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { truncateTextBytes, ENGINE_DEFAULTS } = require('./shared');
+
+const CLAUDE_MD_FILENAME = 'CLAUDE.md';
+// Cap the number of CLAUDE.md files collected across all hints — defense against
+// a dispatch with many path hints spread across a deep tree.
+const MAX_FILES = 8;
+// Cap the walk-up depth from any single hint dir — defense for pathological deep
+// Windows paths so a single hint can't spin the loop unbounded.
+const MAX_WALK_DEPTH = 24;
+// Byte cap for the whole injected block. Reuses the same budget the sibling
+// notes / agent-memory context layers use (maxNotesPromptBytes), so CLAUDE.md
+// propagation can never balloon a prompt on a large monorepo.
+const DEFAULT_MAX_BYTES = ENGINE_DEFAULTS.maxNotesPromptBytes;
+
+function _pathEq(a, b) {
+  if (process.platform === 'win32') return a.toLowerCase() === b.toLowerCase();
+  return a === b;
+}
+
+// Is `target` inside (or equal to) `root`?
+function _isWithin(root, target) {
+  const rel = path.relative(root, target);
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+/**
+ * Normalize a hint (a file OR directory, relative-to-root OR absolute) into an
+ * absolute directory contained within `root`. Returns null when the hint
+ * escapes the project root (path traversal guard). Non-existent hints are still
+ * resolved structurally (extension ⇒ file ⇒ parent dir; otherwise dir).
+ */
+function _hintToDir(root, hint) {
+  if (!hint || typeof hint !== 'string' || !hint.trim()) return null;
+  const cleaned = hint.trim();
+  let abs = path.isAbsolute(cleaned) ? cleaned : path.join(root, cleaned);
+  abs = path.resolve(abs);
+  if (!_isWithin(root, abs)) return null;
+  try {
+    const st = fs.statSync(abs);
+    if (st.isDirectory()) return abs;
+    return path.dirname(abs);
+  } catch {
+    // Doesn't exist on disk — infer file vs dir from a trailing extension.
+    return path.extname(abs) ? path.dirname(abs) : abs;
+  }
+}
+
+/**
+ * Discover CLAUDE.md files by walking UP from each hint directory to the project
+ * root, plus the project root itself as a guaranteed fallback. Returns entries
+ * ordered nearest-first (deepest directory first, project root last) so the
+ * caller renders "nearest wins" — the most specific instructions lead.
+ *
+ * @param {{ projectRoot: string, pathHints?: string[] }} opts
+ * @returns {{ absPath: string, relPath: string, depth: number }[]}
+ */
+function discoverClaudeMdFiles({ projectRoot, pathHints = [] } = {}) {
+  if (!projectRoot || typeof projectRoot !== 'string') return [];
+  const root = path.resolve(projectRoot);
+  try { if (!fs.statSync(root).isDirectory()) return []; } catch { return []; }
+
+  // Starting dirs: each valid hint dir, then the root itself (fallback so the
+  // project-root CLAUDE.md is always considered even with zero hints).
+  const startDirs = [];
+  for (const h of Array.isArray(pathHints) ? pathHints : []) {
+    const d = _hintToDir(root, h);
+    if (d) startDirs.push(d);
+  }
+  startDirs.push(root);
+
+  const found = new Map(); // absPath -> { depth, rel }
+  for (const start of startDirs) {
+    let dir = start;
+    let steps = 0;
+    while (steps <= MAX_WALK_DEPTH) {
+      const candidate = path.join(dir, CLAUDE_MD_FILENAME);
+      if (!found.has(candidate)) {
+        try {
+          if (fs.statSync(candidate).isFile()) {
+            const rel = path.relative(root, dir);
+            const depth = (rel === '' || rel === '.') ? 0 : rel.split(/[\\/]/).length;
+            found.set(candidate, { depth });
+          }
+        } catch { /* no CLAUDE.md at this level */ }
+      }
+      if (_pathEq(dir, root)) break;      // stop at project root (never above)
+      const parent = path.dirname(dir);
+      if (_pathEq(parent, dir)) break;    // filesystem-root guard
+      if (!_isWithin(root, parent)) break;
+      dir = parent;
+      steps++;
+    }
+  }
+
+  const entries = Array.from(found.entries()).map(([absPath, meta]) => ({
+    absPath,
+    relPath: (path.relative(root, absPath) || CLAUDE_MD_FILENAME).replace(/\\/g, '/'),
+    depth: meta.depth,
+  }));
+  // nearest-first: deepest dir first; stable tiebreak on relPath for determinism.
+  entries.sort((a, b) => (b.depth - a.depth) || a.relPath.localeCompare(b.relPath));
+  return entries.slice(0, MAX_FILES);
+}
+
+/**
+ * Build the CLAUDE.md propagation block (inner content, no outer header/fence —
+ * engine/playbook.js owns those). Reads each discovered file, labels it by its
+ * repo-relative path, and truncates to stay within `maxBytes` total. Returns
+ * `{ block, files }` where `block` is '' when nothing was found or all files
+ * were empty.
+ *
+ * @param {{ projectRoot: string, pathHints?: string[], maxBytes?: number }} opts
+ */
+function buildClaudeMdPropagationBlock({ projectRoot, pathHints = [], maxBytes = DEFAULT_MAX_BYTES } = {}) {
+  const files = discoverClaudeMdFiles({ projectRoot, pathHints });
+  if (files.length === 0) return { block: '', files: [] };
+
+  const cap = Math.max(256, Number(maxBytes) || DEFAULT_MAX_BYTES);
+  const parts = [];
+  const included = [];
+  let used = 0;
+
+  for (const f of files) {
+    let content;
+    try { content = fs.readFileSync(f.absPath, 'utf8'); } catch { continue; }
+    if (!content || !content.trim()) continue;
+
+    const heading = `\n\n### ${f.relPath}\n\n`;
+    const headingBytes = Buffer.byteLength(heading, 'utf8');
+    const remaining = cap - used - headingBytes;
+    if (remaining <= 0) break; // no room even for the next heading
+
+    const body = truncateTextBytes(content, remaining, '\n\n_...CLAUDE.md truncated (read the full file if needed)_');
+    parts.push(heading + body);
+    used += headingBytes + Buffer.byteLength(body, 'utf8');
+    included.push(f.relPath);
+    if (used >= cap) break;
+  }
+
+  if (parts.length === 0) return { block: '', files: [] };
+  return { block: parts.join('').replace(/^\n+/, ''), files: included };
+}
+
+/**
+ * Does the named runtime auto-discover CLAUDE.md natively? Reads the adapter's
+ * `capabilities.claudeMdNativeDiscovery`. Unknown runtimes return false ("does
+ * NOT auto-discover") so propagation is the safe additive default — an
+ * unrecognized runtime is far more likely to lack native CLAUDE.md loading than
+ * to have it.
+ */
+function runtimeAutoDiscoversClaudeMd(cliName) {
+  try {
+    const { resolveRuntime } = require('./runtimes');
+    const rt = resolveRuntime(cliName);
+    return !!(rt && rt.capabilities && rt.capabilities.claudeMdNativeDiscovery);
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  CLAUDE_MD_FILENAME,
+  MAX_FILES,
+  MAX_WALK_DEPTH,
+  DEFAULT_MAX_BYTES,
+  discoverClaudeMdFiles,
+  buildClaudeMdPropagationBlock,
+  runtimeAutoDiscoversClaudeMd,
+};

package/engine/cli.js

@@ -9,6 +9,7 @@ const shared = require('./shared');
 const { safeRead, safeJson, safeJsonArr, safeWrite, readWorkItems, readPullRequests, mutateControl, mutateWorkItems, ts, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, REVIEW_STATUS, DISPATCH_RESULT, FAILURE_CLASS } = shared;
 const queries = require('./queries');
 const agentWorkerPool = require('./agent-worker-pool');
+const { resolveCommentExecutionModel } = require('./execution-model');
 const { getConfig, getControl, getDispatch, getAgentStatus,
   MINIONS_DIR, ENGINE_DIR, AGENTS_DIR, PLANS_DIR, PRD_DIR, CONTROL_PATH } = queries;
 
@@ -2076,6 +2077,11 @@ const commands = {
       console.error('error: must supply either --body-file <path> or --body <text>');
       process.exit(2);
     }
+    const executionModel = resolveCommentExecutionModel({
+      dispatch: getDispatch(),
+      agentId,
+      workItemId,
+    });
 
     // ── Azure DevOps: <prNumber> --host ado --ado-org --ado-project --repo-id ──
     if (isAdo) {
@@ -2097,6 +2103,7 @@ const commands = {
       const adoComment = require('./ado-comment');
       adoComment.postAdoPrComment({
         orgBase, project, repositoryId, prNumber, body, agentId, kind, workItemId,
+        model: executionModel.model,
         resolved: flags.resolved === true,
       }).then((result) => {
         if (result && result.threadId) {
@@ -2135,7 +2142,7 @@ const commands = {
 
     try {
       const result = ghComment.postPrComment({
-        repo, prNumber, body, agentId, kind, workItemId,
+        repo, prNumber, body, agentId, kind, workItemId, model: executionModel.model,
       });
       if (result.output) console.log(result.output);
     } catch (e) {
@@ -2274,6 +2281,7 @@ module.exports = {
   _readDispatchPid: readDispatchPid,
   _normalizeSessionBranch: normalizeSessionBranch,
   _dispatchSessionBranch: dispatchSessionBranch,
+  _resolveCommentExecutionModel: resolveCommentExecutionModel, // exported for testing
   // W-mpcyvff6000pf828 (#2653) — heartbeat writer + factory exported for tests
   _writeHeartbeatNow: writeHeartbeatNow,
   _createHeartbeatInterval: createHeartbeatInterval,

package/engine/comment-format.js

@@ -48,14 +48,17 @@ function linkifyBrandTrailer(text) {
 // org/project/repoId).
 //
 // Marker format (single line, ASCII):
-//   <!-- minions:agent=<agentId> kind=<kind> wi=<workItemId> -->
+//   <!-- minions:agent=<agentId> kind=<kind> wi=<workItemId> model=<modelId> -->
 //
 // Validation (enforced before the marker is built):
 //   - agentId    /^[a-z][a-z0-9-]{0,30}$/
 //   - kind       /^[a-z][a-z0-9-]{0,30}$/
 //   - workItemId /^[A-Z]-[a-z0-9]+$/   (optional)
+//   - model       concrete runtime execution model (optional)
 //   - no field may contain `--` (would close the HTML comment early)
 
+const { normalizeExecutionModel } = require('./execution-model');
+
 const AGENT_ID_RE = /^[a-z][a-z0-9-]{0,30}$/;
 const KIND_RE = /^[a-z][a-z0-9-]{0,30}$/;
 const WORK_ITEM_ID_RE = /^[A-Z]-[a-z0-9]+$/;
@@ -63,7 +66,7 @@ const WORK_ITEM_ID_RE = /^[A-Z]-[a-z0-9]+$/;
 // Marker line (single-line HTML comment). Multiline flag so it matches at the
 // start of any line — required for round-trip detection of the builder output.
 const MINIONS_COMMENT_MARKER_RE =
-  /^<!--\s*minions:agent=([^\s]+)\s+kind=([^\s]+)(?:\s+wi=([^\s]+))?\s*-->/m;
+  /^<!--\s*minions:agent=([^\s]+)\s+kind=([^\s]+)(?:\s+wi=([^\s]+))?(?:\s+model=([^\s]+))?\s*-->/m;
 
 // Canonical-format sample marker for tests/fixtures that need a marked body but
 // don't care about the specific fields.
@@ -85,18 +88,44 @@ function _validateField(name, value, re) {
   }
 }
 
-function _validateMarkerInputs({ agentId, kind, workItemId }) {
+function _validateMarkerInputs({ agentId, kind, workItemId, model }) {
   _validateField('agentId', agentId, AGENT_ID_RE);
   _validateField('kind', kind, KIND_RE);
   if (workItemId !== undefined && workItemId !== null) {
     _validateField('workItemId', workItemId, WORK_ITEM_ID_RE);
   }
+  if (model !== undefined && model !== null && !normalizeExecutionModel(model)) {
+    throw new Error(`invalid model: ${JSON.stringify(model)}`);
+  }
+}
+
+function _encodeMarkerModel(model) {
+  const encoded = encodeURIComponent(model);
+  return encoded.includes('--') ? encoded.replace(/-/g, '%2D') : encoded;
 }
 
-function _buildMarker({ agentId, kind, workItemId }) {
-  _validateMarkerInputs({ agentId, kind, workItemId });
+function _buildMarker({ agentId, kind, workItemId, model }) {
+  _validateMarkerInputs({ agentId, kind, workItemId, model });
   const wi = (workItemId !== undefined && workItemId !== null) ? ` wi=${workItemId}` : '';
-  return `<!-- minions:agent=${agentId} kind=${kind}${wi} -->`;
+  const modelPart = model ? ` model=${_encodeMarkerModel(model)}` : '';
+  return `<!-- minions:agent=${agentId} kind=${kind}${wi}${modelPart} -->`;
+}
+
+const MODEL_SIGNOFF_RE =
+  /(\b(?:Review|Reviewed|Fixed|Verified|Rebased) by (?:Minions|\[Minions\]\([^)]+\)) \([^\r\n)]*? · )[^)\r\n]+(\))/g;
+
+function stampExecutionModel(text, model) {
+  const normalized = normalizeExecutionModel(model);
+  if (!normalized || typeof text !== 'string') return text;
+  return text.replace(MODEL_SIGNOFF_RE, (_match, prefix, suffix) => `${prefix}${normalized}${suffix}`);
+}
+
+function _stampLeadingMarkerModel(text, model) {
+  if (!model || typeof text !== 'string') return text;
+  return text.replace(MINIONS_COMMENT_MARKER_RE, (marker, agentId, kind, workItemId) => {
+    if (marker !== text.slice(0, marker.length)) return marker;
+    return _buildMarker({ agentId, kind, workItemId, model });
+  });
 }
 
 /**
@@ -106,41 +135,49 @@ function _buildMarker({ agentId, kind, workItemId }) {
  * Idempotency: if `body` already starts with a minions marker it is returned
  * with the brand transform applied but no second marker prepended.
  *
- * @param {{agentId:string, kind:string, workItemId?:string, body?:string}} args
+ * @param {{agentId:string, kind:string, workItemId?:string, model?:string, body?:string}} args
  * @returns {string} the final comment body
  */
-function buildMinionsCommentBody({ agentId, kind, workItemId, body }) {
+function buildMinionsCommentBody({ agentId, kind, workItemId, model, body }) {
   // Validate the inputs even when the body is pre-marked, so callers can't
   // silently bypass validation by pre-marking their body.
-  _validateMarkerInputs({ agentId, kind, workItemId });
+  _validateMarkerInputs({ agentId, kind, workItemId, model });
   let safeBody = body == null ? '' : String(body);
 
+  safeBody = stampExecutionModel(safeBody, model);
+
   // Brand-link safety net: deterministically hyperlink the first bare
   // "… by Minions" signature trailer (no-op when the agent already linked it).
   safeBody = linkifyBrandTrailer(safeBody);
 
-  if (_LEADING_MARKER_RE.test(safeBody)) return safeBody;
-  const marker = _buildMarker({ agentId, kind, workItemId });
+  if (_LEADING_MARKER_RE.test(safeBody)) return _stampLeadingMarkerModel(safeBody, model);
+  const marker = _buildMarker({ agentId, kind, workItemId, model });
   return `${marker}\n\n${safeBody}`;
 }
 
 /**
- * Inverse of the marker builder: parse `{agentId, kind, workItemId}` out of a
- * marked body, or null when no marker is present.
+ * Inverse of the marker builder: parse `{agentId, kind, workItemId, model?}`
+ * out of a marked body, or null when no marker is present.
  */
 function parseMinionsMarker(body) {
   if (typeof body !== 'string' || body.length === 0) return null;
   const m = body.match(MINIONS_COMMENT_MARKER_RE);
   if (!m) return null;
-  return {
+  const parsed = {
     agentId: m[1],
     kind: m[2],
     workItemId: m[3] === undefined ? undefined : m[3],
   };
+  if (m[4] !== undefined) {
+    try { parsed.model = decodeURIComponent(m[4]); }
+    catch { return null; }
+  }
+  return parsed;
 }
 
 module.exports = {
   linkifyBrandTrailer,
+  stampExecutionModel,
   MINIONS_BRAND_URL,
   // Neutral marker + body builder (consumed by gh-comment.js and ado-comment.js).
   buildMinionsCommentBody,

package/engine/consolidation.js

@@ -85,6 +85,34 @@ function _readNotesForAppendOrNull() {
   return fs.existsSync(NOTES_PATH) ? null : '';
 }
 
+// Resiliently write notes.md from inside a consolidation lock callback.
+// CRASH GUARD (#858): safeWrite -> renameSync throws EPERM on Windows when
+// notes.md is held open by another process (e.g. a leaked dashboard
+// /state/notes.md read stream). That throw used to propagate out of the
+// async consolidateWithLLM(...) chain / the regex-fallback timer callback with
+// NO surrounding try/catch, becoming an UNHANDLED PROMISE REJECTION (or an
+// uncaught timer exception) that killed the whole engine daemon. Supervisor
+// respawned it, but pooled Copilot ACP agents cannot reattach across restart,
+// so every in-flight agent was orphaned.
+//
+// This wraps safeWrite in shared._retryFsOp (extra exponential-backoff retries
+// on EPERM/EBUSY/EACCES on top of safeWrite's own short retry loop) AND a
+// try/catch, so a transient lock retries then DEFERS: returns false so the
+// caller leaves the inbox notes in place for the next tick instead of crashing.
+// Returns true on success, false if the write could not be completed.
+function _writeNotesOrDefer(content, label) {
+  try {
+    // Keep the in-lock retry budget small (safeWrite already retries EPERM ~5x
+    // internally): a few extra exponential-backoff attempts cover a slightly
+    // longer transient hold without stalling the consolidation lock.
+    shared._retryFsOp(() => safeWrite(NOTES_PATH, content), `write notes.md (${label})`, { attempts: 3, baseMs: 100 });
+    return true;
+  } catch (err) {
+    log('warn', `${label}: notes.md write failed after retries (${err?.code || ''} ${err?.message || err}) \u2014 deferring, inbox notes left for next cycle`);
+    return false;
+  }
+}
+
 // Per-agent memory files live under knowledge/agents/<agent>.md and are
 // injected into individual agent prompts (in addition to the broadcast
 // notes.md). See knowledge/agents/README.md for the convention.
@@ -971,7 +999,17 @@ function consolidateWithLLM(items, existingNotes, files, config) {
     fallbackDone = true;
     if (message) log('warn', message);
     if (err?.message) log('debug', `LLM error: ${err.message}`);
-    consolidateWithRegex(items, files, config);
+    // CRASH GUARD (#858): _fallback runs from a promise .catch AND from a
+    // setTimeout callback. An uncaught throw from consolidateWithRegex in the
+    // timer path is an uncaught exception that kills the daemon; in the .catch
+    // path it is an unhandled rejection. The notes.md write already defers on
+    // lock contention, but keep a top-level guard so no other regex-fallback
+    // failure can ever crash the engine — leave inbox notes for the next tick.
+    try {
+      consolidateWithRegex(items, files, config);
+    } catch (e) {
+      log('warn', `Regex consolidation fallback failed (${e?.code || ''} ${e?.message || e}) \u2014 inbox notes left for next cycle`);
+    }
   }
 
   const llmCall = callLLM(prompt, sysPrompt, {
@@ -1033,7 +1071,9 @@ function consolidateWithLLM(items, existingNotes, files, config) {
         // DATA-LOSS GUARD: cap size but archive the overflow instead of
         // silently discarding it (see _capNotesPreservingOverflow).
         const newContent = _capNotesPreservingOverflow(current + entry);
-        safeWrite(NOTES_PATH, newContent);
+        // CRASH GUARD (#858): defer (return false) on a transient write lock
+        // instead of throwing out of this async chain and crashing the daemon.
+        if (!_writeNotesOrDefer(newContent, 'LLM consolidation')) return false;
         return true;
       });
       if (!wrote) {
@@ -1169,7 +1209,10 @@ function consolidateWithRegex(items, files, config) {
     }
     // DATA-LOSS GUARD: cap size but archive the overflow (see LLM path).
     const newContent = _capNotesPreservingOverflow(current + entry);
-    safeWrite(NOTES_PATH, newContent);
+    // CRASH GUARD (#858): defer (return false) on a transient write lock
+    // instead of throwing out of this synchronous fallback (invoked from a
+    // timer callback and a promise .catch) and crashing the daemon.
+    if (!_writeNotesOrDefer(newContent, 'Regex consolidation')) return false;
     return true;
   });
   if (!wrote) {
@@ -1530,4 +1573,5 @@ module.exports = {
   buildCondensedKbBody,
   _alertContentHash,
   _alertHashExists,
+  _writeNotesOrDefer,
 };

package/engine/db/migrations/026-pre-dispatch-rejections.js

@@ -0,0 +1,55 @@
+function _parseObject(raw) {
+  try {
+    const value = JSON.parse(raw);
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  version: 26,
+  description: 'normalize exhausted pre-dispatch rejections out of execution failures',
+  up(db) {
+    const rows = db.prepare(`
+      SELECT rowid, data
+      FROM work_items
+      WHERE status = 'failed' AND archived = 0
+    `).all();
+    const update = db.prepare(`
+      UPDATE work_items
+      SET status = 'pending', data = ?, updated_at = ?
+      WHERE rowid = ? AND archived = 0
+    `);
+    const now = Date.now();
+    for (const row of rows) {
+      const item = _parseObject(row.data);
+      if (!item || item._failureClass !== 'pre-dispatch-eval-stuck') continue;
+      const evaluation = item._preDispatchEval && typeof item._preDispatchEval === 'object'
+        ? item._preDispatchEval
+        : {};
+      const evaluatedAt = evaluation.evaluatedAt || item.failedAt || new Date(now).toISOString();
+      const history = Array.isArray(evaluation.history) ? evaluation.history : [];
+      if (history.length === 0 && evaluation.reason) {
+        history.push({
+          reason: evaluation.reason,
+          evaluatedAt,
+          description: evaluation.description || '',
+        });
+      }
+      item.status = 'pending';
+      item._pendingReason = 'pre_dispatch_eval_rejected';
+      item._preDispatchEval = {
+        ...evaluation,
+        valid: false,
+        exhausted: true,
+        exhaustedAt: evaluation.exhaustedAt || evaluatedAt,
+        history,
+      };
+      delete item._failureClass;
+      delete item.failReason;
+      delete item.failedAt;
+      update.run(JSON.stringify(item), now, row.rowid);
+    }
+  },
+};