@yemi33/minions 0.1.2373 → 0.1.2375

package/dashboard/js/settings.js

@@ -446,6 +446,7 @@ async function openSettings() {
     '<div class="settings-pane-sub">Persistent CC worker pool and git worktree provisioning. Tune these only if you see worktree-create timeouts or slow CC cold-spawns.</div>' +
     '<div class="settings-stack" style="margin-bottom:12px">' +
       settingsToggle('CC Worker Pool', 'set-ccUseWorkerPool', (e.ccUseWorkerPool === undefined ? ((e.ccCli || e.defaultCli) === 'copilot') : !!e.ccUseWorkerPool), 'Route Command Center / doc-chat through a persistent copilot --acp worker per tab instead of spawning a fresh CLI per turn. Copilot-only (Agent Client Protocol transport); Claude does not implement ACP, so this toggle has no effect when CC runtime is Claude. Default ON for copilot (cold-spawn ~20s on Windows); forced OFF for non-copilot CC runtimes regardless of this toggle.') +
+      settingsToggle('Agent Worker Pool', 'set-agentUseWorkerPool', e.agentUseWorkerPool !== false, 'Route fleet Copilot dispatches through persistent copilot --acp workers. Default ON; runtimes without ACP support ignore this setting.') +
       // W-mq6f2fe0000557fa — opt-in: auto-kill orphan spawn-agent processes
       // holding a stuck worktree's cwd. Gated by safe-reap criteria (cmdline
       // matches spawn-agent.js + basename + age > agentTimeout * 2). Default
@@ -484,12 +485,6 @@ async function openSettings() {
         '</select>' +
       '</div>' +
       settingsField('Copilot fallback model', 'set-copilotFallbackModel', e.copilotFallbackModel || '', 'e.g. gpt-5.4', 'Copilot has no --fallback-model flag. On a MODEL_UNAVAILABLE (overloaded/503) retry, the engine OVERRIDES --model with this value (Copilot only).') +
-      '</div>' +
-      '<div class="settings-stack" style="margin-top:12px">' +
-        settingsField('Copilot: disable agent MCP servers', 'set-copilotAgentDisabledMcpServers',
-          Array.isArray(e.copilotAgentDisabledMcpServers) ? e.copilotAgentDisabledMcpServers.join(', ') : (e.copilotAgentDisabledMcpServers || ''),
-          'e.g. playwright, maestro, loop',
-          'Comma-separated MCP server names (from ~/.copilot/mcp-config.json) the engine disables for autonomous Copilot agent dispatches by filtering them out of the agent-only COPILOT_HOME. Copilot loads your user MCP config on every spawn regardless of --add-dir; list the noisy/auth-popping servers (e.g. playwright, maestro) to keep them out of agents. Empty = inherit all.') +
       '</div>';
 
   const paneClaude =
@@ -588,7 +583,7 @@ async function openSettings() {
     '</div>' +
     '<h4>Agent Memory</h4>' +
     '<div class="settings-stack">' +
-      settingsToggle('Shadow mode', 'set-memoryRetrievalShadowMode', e.memoryRetrievalShadowMode !== false, 'Measure retrieval without changing prompts') +
+      settingsToggle('Shadow mode', 'set-memoryRetrievalShadowMode', !!e.memoryRetrievalShadowMode, 'Measure retrieval without changing prompts') +
       settingsToggle('Capture task episodes', 'set-memoryEpisodicCapture', !!e.memoryEpisodicCapture, 'Store compact outcomes, never transcripts') +
     '</div>' +
     '<div class="settings-grid-2">' +
@@ -1128,6 +1123,7 @@ async function saveSettings() {
       autoFixHumanComments: document.getElementById('set-autoFixHumanComments').checked,
       autoCompletePrs: document.getElementById('set-autoCompletePrs').checked,
       ccUseWorkerPool: !!document.getElementById('set-ccUseWorkerPool')?.checked,
+      agentUseWorkerPool: !!document.getElementById('set-agentUseWorkerPool')?.checked,
       autoReapOrphanWorktreeHolders: !!document.getElementById('set-autoReapOrphanWorktreeHolders')?.checked,
       liveCheckoutAutoStash: !!document.getElementById('set-liveCheckoutAutoStash')?.checked,
       liveCheckoutAutoReset: !!document.getElementById('set-liveCheckoutAutoReset')?.checked,
@@ -1188,7 +1184,6 @@ async function saveSettings() {
       claudeBareMode: !!document.getElementById('set-claudeBareMode')?.checked,
       claudeFallbackModel: (document.getElementById('set-claudeFallbackModel')?.value ?? '').trim(),
       copilotFallbackModel: (document.getElementById('set-copilotFallbackModel')?.value ?? '').trim(),
-      copilotAgentDisabledMcpServers: (document.getElementById('set-copilotAgentDisabledMcpServers')?.value ?? '').trim(),
       copilotDisableBuiltinMcps: !!document.getElementById('set-copilotDisableBuiltinMcps')?.checked,
       copilotStreamMode: document.getElementById('set-copilotStreamMode')?.value || 'on',
       copilotReasoningSummaries: !!document.getElementById('set-copilotReasoningSummaries')?.checked,

package/dashboard.js

@@ -11374,17 +11374,6 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           else if (valid.includes(e.copilotStreamMode)) _setEngineConfig('copilotStreamMode', e.copilotStreamMode);
           else _clamped.push(`copilotStreamMode: "${e.copilotStreamMode}" not in [on, off] (kept previous value)`);
         }
-        // P-mcp-storm — MCP server names to disable for autonomous Copilot agents
-        // (--disable-mcp-server). Accept an array OR a comma/whitespace string;
-        // normalize to a deduped array of trimmed names. Empty clears (inherit all).
-        if (e.copilotAgentDisabledMcpServers !== undefined) {
-          const src = Array.isArray(e.copilotAgentDisabledMcpServers)
-            ? e.copilotAgentDisabledMcpServers
-            : String(e.copilotAgentDisabledMcpServers || '').split(/[\s,]+/);
-          const names = [...new Set(src.map(s => String(s == null ? '' : s).trim()).filter(Boolean))];
-          if (names.length) _setEngineConfig('copilotAgentDisabledMcpServers', names);
-          else _deleteEngineConfig('copilotAgentDisabledMcpServers');
-        }
         // W-mpmwxkrw000872ec — fontSize allowlist. Clamps invalid values
         // (rather than silently failing) so the dashboard bootstrap never
         // ends up with an unknown data-font-size attribute.
@@ -15099,18 +15088,6 @@ if (require.main === module) {
   // engine reads, port binding) is captured rather than dying silently.
   _installCrashHandlers();
 
-  // Deliberately do NOT set process.env.COPILOT_HOME here. Command Center,
-  // doc-chat, and the CC worker pool (`copilot --acp`) all spawn `copilot`
-  // as this process's children, so they should inherit the operator's real
-  // `~/.copilot` home (including their model preference in settings.json)
-  // exactly like an interactive `copilot` CLI session would — that's the
-  // documented CLI contract. An earlier revision forced these onto an
-  // isolated, MCP-filtered home to dodge MCP-server auth popups, but that
-  // broke CC's settings inheritance and reintroduced a staleness/reseed bug;
-  // reverted (W-mre75l6x00024f49). Per-dispatch agent isolation is unaffected
-  // — the engine process still seeds its own COPILOT_HOME at boot and
-  // re-stamps it per spawn via `_applyAgentCopilotHome` (engine.js).
-
   // Kick off first npm check on startup, then re-check every 4 hours.
   // Guarded here so that requiring dashboard as a module (unit tests, _withDashServer)
   // does not spawn npm child processes that keep the event loop alive past test teardown

package/docs/design-inbox-entries-schema.md

@@ -0,0 +1,106 @@
+# inbox_entries Table Schema
+
+## Overview
+The `inbox_entries` table is the persistent store for operator and agent inbox messages within the Minions orchestration engine. It provides a time-ordered, unread-tracking message queue decoupled from the runtime work-item/dispatch lifecycle.
+
+## Schema Specification
+
+### Column Definitions
+
+| Column | Type | Constraints | Purpose |
+|--------|------|-----------|---------|
+| `id` | TEXT | PRIMARY KEY | Unique message identifier; generated as `<recipient>-<timestamp>-<sender>-<seq>` format |
+| `recipient_session_id` | TEXT | NOT NULL | Session ID of the inbox owner (operator or agent); routes messages to specific actor |
+| `sender_id` | TEXT | NOT NULL | Identifier of the message originator; structured as `<agent-id>` or `'system'` or `'operator'` |
+| `sender_name` | TEXT | NOT NULL | Human-readable sender name for UI display; persisted at write-time for offline/archived reference |
+| `sender_type` | TEXT | NOT NULL | Enum: `'agent'`, `'system'`, `'operator'`; constrains allowed sender_id values |
+| `interaction_id` | TEXT | NOT NULL | Group ID linking related messages (e.g., work-item dispatch feedback, PR review batch); enables threading and deduplication |
+| `sequence` | INTEGER | NOT NULL, DEFAULT 0 | Per-interaction message counter; disambiguates bursts and enables ordering within same millisecond |
+| `summary` | TEXT | NOT NULL | Title/subject line; used for list views and user scanning; always present even if content is truncated |
+| `content` | TEXT | NOT NULL | Full message body; may contain Markdown, code blocks, or structured JSON sidecars (not yet parsed at table level) |
+| `unread` | INTEGER | NOT NULL, DEFAULT 1 | Boolean flag (0/1); toggled by reader, cleared on archive/delete; enables fast unread-count queries |
+| `sent_at` | INTEGER | NOT NULL | Unix timestamp (milliseconds) of message creation; primary sort key for time-ordered display |
+| `read_at` | INTEGER | Nullable | Unix timestamp (milliseconds) when recipient first read the message; null until marked read |
+| `notified_at` | INTEGER | Nullable | Unix timestamp (milliseconds) of last notification event sent to operator; null if no notification dispatched |
+
+### Constraints & Relationships
+
+- **PK constraint:** `id` is globally unique across all inboxes; collision risk is negligible given the composite structure (recipient + timestamp + sender + seq).
+- **FK (soft):** `recipient_session_id` does NOT enforce a referential constraint to `sessions` table (sessions may be archived). Queries SHOULD handle missing recipients gracefully.
+- **FK (soft):** `sender_id` is informational only; no validation that the sender exists in the `config.agents` or active sessions. Invalid senders are logged but do not block writes.
+- **No composite index on (recipient_session_id, sent_at):** See Performance section.
+
+## Architectural Rationale
+
+### Design Decisions
+
+1. **Separate inbox table vs. inline dispatch/work-item attachments.**
+   - Inboxes can outlive their source work items (e.g., a feedback message remains useful after the WI is done).
+   - Decoupling allows independent inbox lifecycle (archive, export, cleanup) without cascading work-item deletes.
+   - Supports rich async consolidation (team notes, KB articles) that don't belong to any single WI.
+
+2. **`unread` flag instead of soft-delete or status enum.**
+   - Fast count queries for badge (`SELECT COUNT(*) WHERE recipient_session_id = ? AND unread = 1`).
+   - Unread state is mutable; allows mark-as-read UX without data loss.
+   - Simplifies archive/export (no tombstone filtering needed).
+
+3. **`sender_type` as an explicit column.**
+   - Allows schema validation (e.g., "agent" senders must have valid IDs; "system" is always valid).
+   - Enables filtered views ("show only agent messages" or "system alerts only") without string parsing.
+
+4. **`interaction_id` for grouping.**
+   - Enables undo/redo on related messages (e.g., canceling all build-failure notifications from one dispatch).
+   - Supports consolidation: multiple small notifications can be collapsed into one summary message.
+
+5. **Persistent `sender_name` at write-time.**
+   - Operator may rename agents or disable them; storing the name ensures historical accuracy.
+   - UI doesn't need to perform runtime lookups on archived inboxes.
+
+6. **Unix timestamps (milliseconds) instead of ISO strings.**
+   - Enables range queries (`sent_at BETWEEN ? AND ?`) without parsing.
+   - Smaller column footprint; easier to sort.
+   - Downside: not human-readable; UI must convert to locale strings.
+
+### Entity Relationships
+
+- **inbox_entries ← dispatch WI feedback:** A failed dispatch may create multiple inbox entries (error summary, retry recommendation, logs snippet). Threaded via `interaction_id`.
+- **inbox_entries ← PR reviews:** Humans and auto-review agents post comments; summarized as inbox alerts to project owners via `interaction_id` per-PR.
+- **inbox_entries ← consolidation:** `engine/consolidation.js` reads inbox entries to extract `agent:` frontmatter and route findings into per-agent knowledge files.
+
+## Performance Considerations
+
+### Indexing Strategy
+
+**Current indexes (recommended):**
+- `idx_recipient_sent` on `(recipient_session_id, sent_at DESC)` — enables efficient "unread count" and "latest N messages" queries without table scans.
+- `idx_interaction` on `(interaction_id)` — enables grouping/dedup queries (e.g., "was this interaction already notified?").
+- PK `id` is implicit index.
+
+**Query patterns:**
+- **Unread count per session:** `SELECT COUNT(*) WHERE recipient_session_id = ? AND unread = 1` → must scan `idx_recipient_sent` to avoid full table.
+- **Latest messages:** `SELECT * WHERE recipient_session_id = ? ORDER BY sent_at DESC LIMIT 20` → seeks on `idx_recipient_sent` DESC.
+- **Thread view:** `SELECT * WHERE interaction_id = ? ORDER BY sent_at` → seeks on `idx_interaction`, then sorts in application or via secondary index.
+- **Cleanup:** `DELETE WHERE sent_at < ? AND unread = 0` → full table scan (acceptable; cleanup is infrequent, low-priority background task).
+
+**Missing indexes (future optimization):**
+- `idx_sender_id` — if queries like "messages from this agent" are common, consider adding.
+- `idx_unread` — if badge ("N unread") is a hot query, consider combining with recipient (`idx_recipient_unread` on `(recipient_session_id, unread)`).
+
+### Size Estimates & Cleanup
+
+- **Row size:** ~500–2000 bytes (summary + content; content can be verbose with logs/code snippets).
+- **Growth:** ~5–50 entries/day (depends on agent activity and verbose flagging).
+- **Retention:** No automatic cleanup; operators may archive/export and manually delete aged entries. Engine does NOT auto-prune.
+- **Recommended**: Implement a dashboard setting to soft-delete entries older than N days (default 30) with an undo/export option.
+
+## Migration & Backward Compatibility
+
+- **Migration 018 or later** creates `inbox_entries` as part of SQL state cutover. Legacy `inbox/` Markdown files are NOT imported; operators must re-send or manually recreate critical messages.
+- **No schema versioning needed** for now; table is immutable-append-only (reads/writes only).
+
+## Related Code
+
+- **Writes:** `engine/inbox-store.js` (primary mutator; uses `getDb()` and `emitStateEvent`).
+- **Reads:** `engine/queries.js#getInboxForSession()`, dashboard `/api/inbox`, `engine/consolidation.js`.
+- **UI:** `dashboard/pages/inbox.html`, `dashboard/js/inbox.js`.
+

package/docs/pr-review-fix-loop.md

@@ -11,6 +11,7 @@ How the engine manages the lifecycle of a PR from creation through review, fix,
 
 - `discoverFromPrs()` (engine.js) runs each tick (~10s)
 - Gates: `status === 'active'` + `reviewStatus === 'pending'` + not reviewed since last push + not dispatched + not on cooldown
+  - "Not reviewed since last push" is `!isPrReviewCurrent(pr)` — compares `pr.reviewedHeadSha` (the SHA the completed review verdict actually evaluated) against the live head, falling back to the legacy `lastPushedAt <= lastReviewedAt` timestamp comparison for PR records that predate `reviewedHeadSha`. The SHA-based check replaces a pure timestamp comparison, which could false-positive as "already reviewed" when a commit landed mid-review (`lastReviewedAt` is stamped at completion, i.e. *after* the mid-review push) — root cause of github:opg-microsoft/minions#821. Re-review (`reviewStatus === 'waiting'`) uses the mirrored `isPrFixedAfterReview(pr)` gate for the same reason. Both dispatch sites capture `reviewHeadSha: getPrCauseHead(pr)` into dispatch `meta` so the eventual verdict can stamp the exact SHA it evaluated.
 - Pre-dispatch: `checkLiveReviewStatus()` hits GitHub/ADO API to catch stale cached status
 - Routes to reviewer via `resolveAgent('review')`, dispatches with `review.md` playbook
 
@@ -144,8 +145,9 @@ A "branch unchanged" no-op report for a `BUILD_FAILURE`-cause fix used to be con
 | `buildErrorLog` | Poller | Actual CI error output for fix agents |
 | `_buildFixPushedAt` | Discovery (on dispatch) | Grace period timestamp |
 | `_buildFailNotified` | Discovery | Dedup for inbox alert |
-| `lastPushedAt` | Poller (new commit) | Tracks latest push for re-review logic |
-| `lastReviewedAt` | `updatePrAfterReview()` | Prevents re-dispatch if reviewed |
+| `lastPushedAt` | Poller (new commit) | Tracks latest push for re-review logic (legacy fallback signal) |
+| `lastReviewedAt` | `updatePrAfterReview()` | Legacy fallback for freshness gating on PR records that predate `reviewedHeadSha` |
+| `reviewedHeadSha` | `updatePrAfterReview()` | SHA the completed review verdict actually evaluated (captured at dispatch time via `meta.reviewHeadSha`, or falls back to the live head for legacy in-flight dispatches); primary review-freshness signal (`isPrReviewCurrent`/`isPrFixedAfterReview`) |
 | `minionsReview` | Post-completion hooks | `{ reviewer, reviewedAt, note, fixedAt }` |
 | `humanFeedback` | `pollPrHumanComments()` | `{ pendingFix, feedbackContent, lastProcessedCommentDate }` |
 | `_noOpFixes[cause]` | `recordPrNoOpFixAttempt()` | Per-cause record `{ count, paused, fingerprint, beforeHead, afterHead }` driving the issue #2969 pause loop |

package/docs/shared-lifecycle-module-map.md

@@ -321,8 +321,6 @@ means zero such files were found), **Proposed target module**.
 | `resolveCcModel` | 3935-3950 | Resolve the model for the Command Center / doc-chat. Priority: 1. `engine.ccModel` — CC-only override 2. `engine.defaultModel` — fleet default (CC inherits this when ccModel unset) 3. `undefined` — let the runtime adapte | yes | `engine/llm.js`, `engine/pre-dispatch-eval.js`, `test/unit/auto-recovery.test.js`, `test/unit.test.js`, `dashboard.js` | engine/shared.js (keep) |
 | `resolveAgentMaxBudget` | 3951-3973 | Resolve the per-spawn USD budget cap. Priority: 1. `agent.maxBudgetUsd` — per-agent override 2. `engine.maxBudgetUsd` — fleet default 3. `undefined` — no cap Uses nullish coalescing so a literal `0` is honored as a valid | yes | `test/unit.test.js`, `engine.js` | engine/shared.js (keep) |
 | `resolveAgentBareMode` | 3974-3991 | Resolve whether this agent should run in Claude `--bare` mode. Priority: 1. `agent.bareMode` — per-agent override (boolean) 2. `engine.claudeBareMode` — fleet default 3. `false` — hardcoded fallback Strict undefined/null | yes | `test/unit.test.js`, `engine.js` | engine/shared.js (keep) |
-| `_normalizeMcpServerList` | 3992-4005 | P-mcp-storm — Resolve the list of MCP server names to disable for spawned // Copilot agents. The engine FILTERS these out of the agent's seeded // COPILOT_HOME mcp-config (engine.js `_applyAgentCopilotHome`) — a server a | no | _internal-only (no callers found outside shared.js)_ | engine/shared.js (keep) |
-| `resolveCopilotAgentDisabledMcpServers` | 4006-4030 | Resolve copilot agent disabled mcp servers. | yes | `test/unit/agent-copilot-home.test.js` | engine/shared.js (keep) |
 | `applyLegacyCcModelMigration` | 4063-4082 | If `config.engine.ccModel` is set but `config.engine.defaultModel` is unset, mutate the in-memory `config.engine` so `defaultModel` mirrors `ccModel` and log a one-time deprecation notice. Does NOT write to disk. Returns | yes | `engine/cli.js`, `test/unit.test.js` | engine/shared.js (keep) |
 | `_resetLegacyCcModelMigrationFlag` | 4083-4113 | Test helper: reset the dedup flag so repeated tests can re-trigger the log. | yes | _internal-only (no callers found outside shared.js)_ | engine/shared.js (keep) |
 | `runtimeConfigWarnings` | 4114-4194 | Inspect runtime fleet config and return warning entries for misconfiguration. Warnings emitted: - Unknown CLI: any `cli` value (per-agent, ccCli, defaultCli) not in `registeredRuntimes`. Each unknown value produces one e | yes | `engine/preflight.js` | engine/process-utils.js (new) — process spawn/pid/tmp-dir lifecycle helpers |

package/docs/team-memory.md

@@ -12,7 +12,7 @@ Multiple agents work the same repository in parallel and across days. Without sh
 - Agents re-litigate decisions the team already made (drift, regressions).
 - Human-flagged warnings (e.g., "do not self-approve PRs") get ignored because they live outside the prompt.
 
-Team memory closes the loop. The engine always injects pinned context. By default it also injects recent team and personal notes; when structured retrieval is enabled outside shadow mode, it replaces those broad appendices with a bounded task-relevant memory pack. Playbooks still instruct agents to consult `knowledge/` and `notes/inbox/` on disk before going wider.
+Team memory closes the loop. The engine always injects pinned context. By default, structured retrieval replaces broad team and personal notes with a bounded task-relevant memory pack. Playbooks still instruct agents to consult `knowledge/` and `notes/inbox/` on disk before going wider.
 
 ## Structured memory and retrieval
 
@@ -20,11 +20,11 @@ Migration `017-agent-memory.js` backfills the existing Markdown sources into `me
 
 `engine/memory-retrieval.js` searches active records in global, current-project, and assigned-agent scopes. It reranks lexical matches by scope, trust, path match, recency, importance, and confidence, then packs the best records into a strict byte budget. Agent- or external-authored procedural records are never recalled as instructions. Every injected pack remains inside an `<UNTRUSTED-INPUT>` fence.
 
-Rollout is controlled by the default-off `memoryRetrieval` feature flag:
+Structured retrieval is controlled by the default-on `memoryRetrieval` feature flag:
 
 - **Flag off:** legacy prompt behavior.
-- **Flag on + `memoryRetrievalShadowMode: true` (default):** compute retrieval and telemetry, but keep legacy prompts.
-- **Flag on + shadow mode off:** inject `Relevant Memory` when retrieval finds evidence; otherwise fall back to legacy notes and personal memory.
+- **Flag on + shadow mode off (default):** inject `Relevant Memory` when retrieval finds evidence; otherwise fall back to legacy notes and personal memory.
+- **Flag on + `memoryRetrievalShadowMode: true`:** compute retrieval and telemetry, but keep legacy prompts.
 
 Settings expose top-k, candidate count, byte budget, shadow mode, and episodic capture. The Inbox page's **Memory search** control shows provenance and status and supports explicit pin, retract, and restore actions.
 

package/engine/db/migrations/019-inbox-entries.js

@@ -0,0 +1,37 @@
+// engine/db/migrations/019-inbox-entries.js
+//
+// Creates the `inbox_entries` table: persistent store for operator and agent
+// inbox messages, decoupled from the runtime work-item/dispatch lifecycle.
+//
+// Schema: columns, types, constraints, and indexing strategy documented in
+// docs/design-inbox-entries-schema.md
+
+module.exports = {
+  version: 19,
+  description: 'inbox_entries: operator/agent message queue with full schema + indexes',
+  up(db) {
+    db.exec(`
+      CREATE TABLE inbox_entries (
+        id                  TEXT PRIMARY KEY,
+        recipient_session_id TEXT NOT NULL,
+        sender_id           TEXT NOT NULL,
+        sender_name         TEXT NOT NULL,
+        sender_type         TEXT NOT NULL,
+        interaction_id      TEXT NOT NULL,
+        sequence            INTEGER NOT NULL DEFAULT 0,
+        summary             TEXT NOT NULL,
+        content             TEXT NOT NULL,
+        unread              INTEGER NOT NULL DEFAULT 1,
+        sent_at             INTEGER NOT NULL,
+        read_at             INTEGER,
+        notified_at         INTEGER
+      );
+
+      CREATE INDEX idx_inbox_recipient_sent 
+        ON inbox_entries(recipient_session_id, sent_at DESC);
+
+      CREATE INDEX idx_inbox_interaction 
+        ON inbox_entries(interaction_id);
+    `);
+  },
+};

package/engine/features.js

@@ -96,8 +96,8 @@ const FEATURES = {
     expires: '2026-12-01',
   },
   'memoryRetrieval': {
-    description: 'Select bounded task-relevant long-term memory with SQLite FTS5 instead of injecting only recent team and personal notes. Starts in shadow mode by default.',
-    default: false,
+    description: 'Select bounded task-relevant long-term memory with SQLite FTS5 instead of injecting broad team and personal notes.',
+    default: true,
     addedIn: '0.1.2233',
     expires: '2027-01-31',
   },

package/engine/inbox-store.js

@@ -0,0 +1,295 @@
+// engine/inbox-store.js — SQL-backed inbox_entries table handlers.
+//
+// Provides read/write helpers for the operator and agent inbox message queue.
+// Inboxes are decoupled from the runtime work-item/dispatch lifecycle and
+// support threading via interaction_id, unread tracking, and time-ordered display.
+//
+// Schema: docs/design-inbox-entries-schema.md
+
+const crypto = require('node:crypto');
+const { getDb, withTransaction } = require('./db');
+
+// Per CLAUDE.md's "State storage" mutator contract, every mutator wrapper
+// must call emitStateEvent() after a successful write so the dashboard's
+// MAX(events.id) cache-version advances — otherwise the dashboard keeps
+// serving stale cached inbox state until an unrelated event happens to
+// bump the counter. Best-effort: never let event emission fail a write.
+function _emitInboxEvent(payload) {
+  try {
+    require('./db-events').emitStateEvent('inbox', payload);
+  } catch { /* best-effort */ }
+}
+
+// In-process monotonic counter. Millisecond timestamps are too coarse to
+// disambiguate bursts of createInboxEntry() calls for the same
+// recipient+sender pair (e.g. rapid consolidation/notification writes), and
+// the caller-supplied `sequence` field is not guaranteed to be unique either
+// (it defaults to 0 and callers are not required to increment it). The
+// counter guarantees every id generated within this process is distinct even
+// when Date.now() does not advance between calls.
+let _inboxIdCounter = 0;
+
+// Generate a likely-unique inbox entry ID:
+// <recipient>-<timestamp>-<sender>-<seq>-<counter>-<random>
+// `sequence` is preserved for callers that pass a meaningful value; the
+// monotonic counter + random suffix are what actually make the id
+// collision-proof, independent of clock resolution or caller behavior.
+function _generateInboxId(recipientSessionId, senderId, sequence) {
+  const now = Date.now();
+  _inboxIdCounter = (_inboxIdCounter + 1) % 0x1000000;
+  const rand = crypto.randomBytes(4).toString('hex');
+  return `${recipientSessionId}-${now}-${senderId}-${sequence}-${_inboxIdCounter.toString(36)}-${rand}`;
+}
+
+// Read all inbox entries for a given recipient session, ordered by time descending.
+function _readInboxEntriesFromSql(db, { recipientSessionId } = {}) {
+  let query = 'SELECT * FROM inbox_entries';
+  const params = [];
+  if (recipientSessionId) {
+    query += ' WHERE recipient_session_id = ?';
+    params.push(recipientSessionId);
+  }
+  query += ' ORDER BY sent_at DESC';
+  return db.prepare(query).all(...params);
+}
+
+// Read unread count for a recipient.
+function getInboxUnreadCount(recipientSessionId) {
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+  const row = db.prepare('SELECT COUNT(*) AS count FROM inbox_entries WHERE recipient_session_id = ? AND unread = 1')
+    .get(recipientSessionId);
+  return row ? row.count : 0;
+}
+
+// Read all inbox entries for a recipient session.
+function getInboxForSession(recipientSessionId, { limit = null, offset = 0 } = {}) {
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+  let query = 'SELECT * FROM inbox_entries WHERE recipient_session_id = ? ORDER BY sent_at DESC';
+  const params = [recipientSessionId];
+  if (limit) {
+    query += ' LIMIT ? OFFSET ?';
+    params.push(limit, offset);
+  }
+  return db.prepare(query).all(...params);
+}
+
+// Read a single inbox entry by ID.
+function getInboxEntryById(id) {
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+  return db.prepare('SELECT * FROM inbox_entries WHERE id = ?').get(id);
+}
+
+// Create a new inbox entry. Returns the entry object.
+function createInboxEntry({
+  recipientSessionId,
+  senderId,
+  senderName,
+  senderType,
+  interactionId,
+  summary,
+  content,
+  sequence = 0,
+}) {
+  if (!recipientSessionId || !senderId || !senderName || !senderType || !interactionId || !summary || !content) {
+    throw new Error('inbox-store: missing required fields for createInboxEntry');
+  }
+  if (!['agent', 'system', 'operator'].includes(senderType)) {
+    throw new Error(`inbox-store: invalid senderType "${senderType}"`);
+  }
+
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+
+  const MAX_ID_COLLISION_RETRIES = 5;
+
+  return withTransaction(db, () => {
+    const now = Date.now();
+    const insert = db.prepare(`
+      INSERT INTO inbox_entries
+        (id, recipient_session_id, sender_id, sender_name, sender_type, interaction_id,
+         sequence, summary, content, unread, sent_at, read_at, notified_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, NULL, NULL)
+    `);
+
+    // _generateInboxId() is collision-proof in practice (monotonic
+    // per-process counter + random suffix), but retry-on-conflict is kept as
+    // defense-in-depth against an id collision from any other source (e.g. a
+    // pre-existing row imported/replayed from another process) rather than
+    // letting a rare UNIQUE-constraint failure crash the caller.
+    let id;
+    for (let attempt = 0; attempt < MAX_ID_COLLISION_RETRIES; attempt++) {
+      id = _generateInboxId(recipientSessionId, senderId, sequence);
+      try {
+        insert.run(id, recipientSessionId, senderId, senderName, senderType, interactionId, sequence, summary, content, now);
+        break;
+      } catch (e) {
+        const isUniqueViolation = e && (e.code === 'ERR_SQLITE_ERROR' || e.errcode === 1555 || /UNIQUE constraint failed/.test(e.message || ''));
+        if (!isUniqueViolation || attempt === MAX_ID_COLLISION_RETRIES - 1) throw e;
+        // Regenerate and retry — the monotonic counter guarantees the next
+        // attempt produces a different id.
+      }
+    }
+
+    _emitInboxEvent({ id, recipientSessionId, action: 'create' });
+    return getInboxEntryById(id);
+  });
+}
+
+// Mark one or more inbox entries as read.
+function markInboxEntriesAsRead(entryIds) {
+  if (!Array.isArray(entryIds) || !entryIds.length) return { wrote: false };
+
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    const now = Date.now();
+    const placeholders = entryIds.map(() => '?').join(',');
+    const query = `UPDATE inbox_entries SET unread = 0, read_at = ? WHERE id IN (${placeholders})`;
+    const stmt = db.prepare(query);
+    const result = stmt.run(now, ...entryIds);
+    if (result.changes > 0) _emitInboxEvent({ entryIds, action: 'mark_read' });
+    return { wrote: result.changes > 0 };
+  });
+}
+
+// Mark one or more inbox entries as unread.
+function markInboxEntriesAsUnread(entryIds) {
+  if (!Array.isArray(entryIds) || !entryIds.length) return { wrote: false };
+
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    const placeholders = entryIds.map(() => '?').join(',');
+    const query = `UPDATE inbox_entries SET unread = 1, read_at = NULL WHERE id IN (${placeholders})`;
+    const stmt = db.prepare(query);
+    const result = stmt.run(...entryIds);
+    if (result.changes > 0) _emitInboxEvent({ entryIds, action: 'mark_unread' });
+    return { wrote: result.changes > 0 };
+  });
+}
+
+// Mark all inbox entries for a recipient as read.
+function markAllInboxAsRead(recipientSessionId) {
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    const now = Date.now();
+    const result = db.prepare(
+      'UPDATE inbox_entries SET unread = 0, read_at = ? WHERE recipient_session_id = ? AND unread = 1'
+    ).run(now, recipientSessionId);
+    if (result.changes > 0) _emitInboxEvent({ recipientSessionId, action: 'mark_all_read' });
+    return { wrote: result.changes > 0 };
+  });
+}
+
+// Delete an inbox entry by ID.
+function deleteInboxEntry(id) {
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    const result = db.prepare('DELETE FROM inbox_entries WHERE id = ?').run(id);
+    if (result.changes > 0) _emitInboxEvent({ id, action: 'delete' });
+    return { wrote: result.changes > 0 };
+  });
+}
+
+// Delete multiple inbox entries by ID.
+function deleteInboxEntries(entryIds) {
+  if (!Array.isArray(entryIds) || !entryIds.length) return { wrote: false };
+
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    const placeholders = entryIds.map(() => '?').join(',');
+    const query = `DELETE FROM inbox_entries WHERE id IN (${placeholders})`;
+    const result = db.prepare(query).run(...entryIds);
+    if (result.changes > 0) _emitInboxEvent({ entryIds, action: 'delete_batch' });
+    return { wrote: result.changes > 0 };
+  });
+}
+
+// Delete all unread entries older than a given timestamp (in milliseconds).
+// Used for cleanup/archival.
+function deleteInboxEntriesOlderThan(timestampMs, { unreadOnly = false } = {}) {
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    let query = 'DELETE FROM inbox_entries WHERE sent_at < ?';
+    const params = [timestampMs];
+    if (unreadOnly) {
+      query += ' AND unread = 1';
+    }
+    const result = db.prepare(query).run(...params);
+    if (result.changes > 0) _emitInboxEvent({ timestampMs, unreadOnly, action: 'delete_older_than' });
+    return { wrote: result.changes > 0, deletedCount: result.changes };
+  });
+}
+
+// Retrieve inbox entries grouped by interaction_id.
+function getInboxByInteraction(interactionId) {
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+  return db.prepare('SELECT * FROM inbox_entries WHERE interaction_id = ? ORDER BY sent_at ASC')
+    .all(interactionId);
+}
+
+// Retrieve all unread entries for all recipients.
+function getAllUnreadInboxEntries() {
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+  return db.prepare('SELECT * FROM inbox_entries WHERE unread = 1 ORDER BY sent_at DESC').all();
+}
+
+// Update the notified_at timestamp for an entry (marks when a notification was sent).
+function markInboxEntryNotified(id) {
+  let db;
+  try { db = getDb(); }
+  catch (e) { throw new Error(`inbox-store: SQLite unavailable (${e.message})`); }
+
+  return withTransaction(db, () => {
+    const now = Date.now();
+    const result = db.prepare('UPDATE inbox_entries SET notified_at = ? WHERE id = ?').run(now, id);
+    if (result.changes > 0) _emitInboxEvent({ id, action: 'mark_notified' });
+    return { wrote: result.changes > 0 };
+  });
+}
+
+module.exports = {
+  // Read operations
+  getInboxUnreadCount,
+  getInboxForSession,
+  getInboxEntryById,
+  getInboxByInteraction,
+  getAllUnreadInboxEntries,
+
+  // Write operations
+  createInboxEntry,
+  markInboxEntriesAsRead,
+  markInboxEntriesAsUnread,
+  markAllInboxAsRead,
+  markInboxEntryNotified,
+  deleteInboxEntry,
+  deleteInboxEntries,
+  deleteInboxEntriesOlderThan,
+};

package/engine/shared.js

@@ -3485,25 +3485,8 @@ const ENGINE_DEFAULTS = {
   claudePreApproveWorkspaceMcps: true,
   copilotStreamMode: 'on',           // Copilot --stream <on|off>: 'on' streams assistant.message_delta events live; 'off' batches them
   copilotReasoningSummaries: false,  // Copilot --enable-reasoning-summaries (Anthropic-family models only)
-  ccUseWorkerPool: false,            // Sub-task C of W-mp2w003600196c51 (CC perf): when true AND CC runtime is copilot, _invokeCcStream routes through engine/cc-worker-pool.js (persistent `copilot --acp` per CC tab) instead of spawning a fresh CLI per turn. Off by default — opt-in feature flag. **Structurally copilot-only**: the pool spawns `copilot --acp` (Agent Client Protocol); Claude Code does not implement ACP, so resolveCcUseWorkerPool returns false on non-copilot CC runtimes even with explicit-true (W-mphlriic00095f69 — prevents silent runtime switch). Engine/agent dispatch path stays per-process regardless.
+  ccUseWorkerPool: true,             // Sub-task C of W-mp2w003600196c51 (CC perf): when true AND CC runtime is copilot, _invokeCcStream routes through engine/cc-worker-pool.js (persistent `copilot --acp` per CC tab) instead of spawning a fresh CLI per turn. On by default (PR #2492 cold-spawn measurements; matches engine/features.js's `ccUseWorkerPool` registry default) — opt out via `engine.ccUseWorkerPool: false`. **Structurally copilot-only**: the pool spawns `copilot --acp` (Agent Client Protocol); Claude Code does not implement ACP, so resolveCcUseWorkerPool returns false on non-copilot CC runtimes even with explicit-true (W-mphlriic00095f69 — prevents silent runtime switch). Engine/agent dispatch path stays per-process regardless.
   agentUseWorkerPool: false,         // P-9b3d5f61: mirrors ccUseWorkerPool's shape but for the fleet agent-dispatch path (engine/agent-worker-pool.js). Opt-in, default OFF — see resolveAgentUseWorkerPool in engine/shared.js for the full priority chain and rationale.
-  // PR #321 — "kill auth-popup storm". Copilot spawns and authenticates EVERY
-  // MCP server in `$COPILOT_HOME/mcp-config.json` on every process start, even
-  // when the corresponding tool is hidden from the model via
-  // `--disable-mcp-server`. If left unfiltered, every auth-requiring user MCP
-  // (azure-kusto/azmcp, DevBox, workiq, loop, teams, …) boots and pops a
-  // Microsoft sign-in window on EVERY agent spawn — at minions' continuous
-  // spawn cadence that is an infinite popup storm.
-  //
-  // The engine therefore points agents at a private COPILOT_HOME
-  // (`shared.resolveAgentCopilotHome`) whose mcp-config is a copy of the operator's
-  // `~/.copilot/mcp-config.json` MINUS the names in this list (see engine.js
-  // `_applyAgentCopilotHome`). Default [] = inherit ALL of the operator's MCP
-  // servers for agents (non-breaking). Add a name to disable it for agents only;
-  // the operator's interactive `~/.copilot` is never touched. Per-agent override
-  // `agent.copilotAgentDisabledMcpServers`. Resolved through
-  // `shared.resolveCopilotAgentDisabledMcpServers(agent, engine)`.
-  copilotAgentDisabledMcpServers: [],
   maxBudgetUsd: undefined,       // fleet USD ceiling for --max-budget-usd (per-agent override: agents.<id>.maxBudgetUsd). Honors 0 via ?? so a literal cap of $0 works
   disableModelDiscovery: false,  // skip runtime.listModels() REST calls fleet-wide (settings UI falls back to free-text)
   // Phase 8 (qa-runs.json + qa-sessions.json → SQL). When true, every QA
@@ -3605,7 +3588,7 @@ const ENGINE_DEFAULTS = {
   agentMemorySummaryEnabled: false, // opt-in: when true, eviction batches go through an LLM-compressed summary before being dropped. Default off to mirror the conservative gating on the existing reconcile pass (LLM cost + test stability). Operators flip via engine.agentMemorySummaryEnabled.
   agentMemorySummaryThreshold: 30, // batch window: when summary is enabled and a prune evicts entries, fold at least this many oldest sections into one summary. Means "summary every ~30 entries" in steady state (the original PRD intent).
   agentMemorySummaryDays: 30, // age trigger: when the oldest section is older than this and >= agentMemorySummaryThreshold entries exist, summarize the oldest window even if the file is under the entry cap.
-  memoryRetrievalShadowMode: true, // compute + measure FTS5 retrieval but preserve legacy prompt injection until explicitly disabled
+  memoryRetrievalShadowMode: false, // inject bounded FTS5-selected memory by default; true computes telemetry while preserving legacy prompt injection
   memoryRetrievalTopK: 8, // maximum structured memory records injected into one dispatch
   memoryRetrievalMaxBytes: 8 * 1024, // hard byte budget for the Relevant Memory prompt appendix
   memoryRetrievalCandidateLimit: 50, // bounded FTS5 candidate pool before deterministic re-ranking
@@ -3863,7 +3846,7 @@ function resolveCcUseWorkerPool(engine) {
   if (engine && (engine.ccUseWorkerPool === true || engine.ccUseWorkerPool === false)) {
     return engine.ccUseWorkerPool;
   }
-  return true; // CC runtime is copilot — default ON (cold-start savings)
+  return ENGINE_DEFAULTS.ccUseWorkerPool;
 }
 
 /**
@@ -3988,39 +3971,6 @@ function resolveAgentBareMode(agent, engine) {
   return false;
 }
 
-// P-mcp-storm — Resolve the list of MCP server names to disable for spawned
-// Copilot agents. The engine FILTERS these out of the agent's seeded
-// COPILOT_HOME mcp-config (engine.js `_applyAgentCopilotHome`) — a server absent
-// from the config can't be spawned, which is the only effective disable
-// (`--disable-mcp-server` does not stop the process). Chain: per-agent
-// `agent.copilotAgentDisabledMcpServers` → `engine.copilotAgentDisabledMcpServers`
-// → `[]` (inherit all). Tolerant of either an array OR a comma/whitespace-
-// separated string (Settings UI / `MINIONS_*` env deliver strings). Always
-// returns a deduped array of trimmed, non-empty strings. See ENGINE_DEFAULTS
-// for the full rationale.
-function _normalizeMcpServerList(v) {
-  if (v == null) return null;
-  const raw = Array.isArray(v) ? v : String(v).split(/[\s,]+/);
-  const out = [];
-  const seen = new Set();
-  for (const item of raw) {
-    const name = String(item == null ? '' : item).trim();
-    if (!name || seen.has(name)) continue;
-    seen.add(name);
-    out.push(name);
-  }
-  return out;
-}
-
-function resolveCopilotAgentDisabledMcpServers(agent, engine) {
-  const a = agent ? _normalizeMcpServerList(agent.copilotAgentDisabledMcpServers) : null;
-  if (a) return a;
-  const e = engine ? _normalizeMcpServerList(engine.copilotAgentDisabledMcpServers) : null;
-  if (e) return e;
-  return [];
-}
-
-
 // ─── Legacy ccModel → defaultModel Migration ─────────────────────────────────
 //
 // Pre-P-3b8e5f1d, `engine.ccModel` was the single fleet-wide model knob (it
@@ -6051,91 +6001,6 @@ function resolveAgentTempBaseDir(project, engine, minionsDir) {
   return path.join(anchor, '.agent-temp');
 }
 
-/**
- * Resolve the stable, repo-external COPILOT_HOME used to isolate spawned
- * Copilot agents from the operator's interactive `~/.copilot` MCP servers
- * (W-copilot-auth-popup-storm / PR #321 — "give copilot agents an MCP-free
- * COPILOT_HOME (kill auth-popup storm)"). Copilot spawns and authenticates
- * EVERY server in `$COPILOT_HOME/mcp-config.json` on every process start;
- * `--disable-mcp-server <name>` only hides that server's tools from the model,
- * it does NOT stop the server process from launching (verified live: agents
- * spawned azmcp.exe/workiq.exe despite those servers being in
- * `copilotAgentDisabledMcpServers`). The only effective lever is to point
- * agents at a COPILOT_HOME whose mcp-config has NO disabled-list servers — see
- * `ensureAgentCopilotHome` below, which the engine seeds at boot and re-stamps
- * per dispatch (`_applyAgentCopilotHome` in engine.js).
- *
- * `COPILOT_HOME` overrides `$HOME/.copilot`; copilot auth is unaffected (it
- * uses GH_TOKEN / the OS credential store, not files under the home), and the
- * operator's real `~/.copilot` — i.e. their interactive copilot — is
- * completely untouched.
- *
- * Placed OUTSIDE the repo so concurrent git branch switches in the working
- * tree can never delete or dirty it, on the MINIONS_DIR volume (copilot's
- * session-store can grow to GBs, so keep it off a possibly-full system
- * drive). Stable path so copilot session resume (`--resume`) stays
- * consistent across spawns. Falls back to the user home when no minionsDir
- * is given.
- *
- * Base selection is cross-platform (W-copilot-home-posix-root): on Windows
- * the MINIONS_DIR drive root (`C:\`, `D:\`, or a UNC share root) is
- * user-writable, so we anchor there. On POSIX the filesystem root (`/`) is
- * NOT user-writable — a home placed there can never be created (`mkdir`
- * EACCES), `ensureAgentCopilotHome` fail-opens and returns the uncreatable
- * path anyway, and every spawned `copilot --acp` / copilot agent then
- * inherits a `COPILOT_HOME` it can't use and exits code 1 silently. So when
- * the drive root is the bare POSIX root we fall back to the user home —
- * repo-external, writable, and on the user's own volume.
- */
-function resolveAgentCopilotHome(minionsDir) {
-  let base;
-  if (minionsDir) {
-    const root = path.parse(path.resolve(String(minionsDir))).root;
-    // The POSIX filesystem root ('/') is not user-writable; Windows drive/UNC
-    // roots are. Anchor at the user home in the unwritable-root case.
-    base = (root === '/' || root === path.sep) ? os.homedir() : root;
-  } else {
-    base = os.homedir();
-  }
-  return path.join(base, '.minions-agent-copilot-home');
-}
-
-// Seed the agent COPILOT_HOME's mcp-config (copy of `~/.copilot/mcp-config.json`
-// MINUS `engine.copilotAgentDisabledMcpServers`) and return the home path. This
-// is the source of truth for "what MCP servers may an agent-dispatch copilot
-// load." It is applied to the engine-process copilot spawn paths ONLY — agent
-// dispatches (`_applyAgentCopilotHome`) and the engine process's own internal
-// `llm.callLLM` calls — by setting `process.env.COPILOT_HOME` at engine boot
-// and re-stamping it per dispatch, so those copilot CHILDREN inherit the
-// filtered config. copilot SPAWNS every server in its config and
-// authenticates it (`--disable-mcp-server` only hides tools), so any
-// auth-requiring server pops a Microsoft window per spawn — filtering the
-// config is the only effective control. Idempotent: writes only when the
-// content changes (safe under concurrent callers). The operator's real
-// `~/.copilot` (interactive copilot, and now also Command Center / doc-chat /
-// the CC worker pool, per W-mre75l6x00024f49) is never touched. Fail-open.
-function ensureAgentCopilotHome(minionsDir, engine) {
-  const home = resolveAgentCopilotHome(minionsDir);
-  try {
-    fs.mkdirSync(home, { recursive: true });
-    const disabled = new Set(resolveCopilotAgentDisabledMcpServers(null, engine));
-    let servers = {};
-    try {
-      const userCfgPath = path.join(os.homedir(), '.copilot', 'mcp-config.json');
-      const userCfg = JSON.parse(fs.readFileSync(userCfgPath, 'utf8').replace(/^/, ''));
-      for (const [name, def] of Object.entries(userCfg.mcpServers || {})) {
-        if (!disabled.has(name)) servers[name] = def;
-      }
-    } catch { servers = {}; /* no/unreadable user config → no MCPs */ }
-    const desired = JSON.stringify({ mcpServers: servers }, null, 2);
-    const cfgFile = path.join(home, 'mcp-config.json');
-    let current = null;
-    try { current = fs.readFileSync(cfgFile, 'utf8'); } catch {}
-    if (current !== desired) fs.writeFileSync(cfgFile, desired);
-  } catch { /* fail-open: leave whatever home/config exists */ }
-  return home;
-}
-
 // ── Spawn cwd vs worktree placement (W-mp73x32w000l143d) ──────────────────────
 // Work types that don't need a git worktree — they read repo state but don't
 // produce code changes. Centralized here so engine.js spawnAgent and any
@@ -9056,7 +8921,6 @@ module.exports = {
   resolvePollFlag, // P-c4d8e1a3 — granular per-poller flag resolution
   resolveAgentCli, resolveCcCli, resolveCcUseWorkerPool, resolveAgentUseWorkerPool, resolveAgentAcpPoolSize, resolveAgentModel, resolveCcModel,
   resolveAgentMaxBudget, resolveAgentBareMode,
-  resolveCopilotAgentDisabledMcpServers,
   applyLegacyCcModelMigration, _resetLegacyCcModelMigrationFlag,
   runtimeConfigWarnings,
   projectWorkSourceWarnings,
@@ -9162,9 +9026,7 @@ module.exports = {
   parseWorktreePorcelain,
   assertWorktreeOutsideProject,
   resolveProjectRootDir,
-  resolveAgentCopilotHome,
   resolveAgentTempBaseDir,
-  ensureAgentCopilotHome,
   resolveSpawnPaths,
   validateWorkItemWorkdir,
   applyWorkdir,

package/engine.js

@@ -2100,32 +2100,6 @@ async function recoverPartialWorktree(rootDir, worktreePath, branchName, gitOpts
   }
 }
 
-// Seed a spawned agent's COPILOT_HOME mcp-config as a copy of the operator's
-// `~/.copilot/mcp-config.json` MINUS the servers in
-// `engine.copilotAgentDisabledMcpServers`, then point COPILOT_HOME at it.
-//
-// Why config-filtering and not `--disable-mcp-server`: copilot SPAWNS every
-// server in its config on startup and authenticates it; `--disable-mcp-server
-// <name>` only hides that server's TOOLS from the model, it does NOT stop the
-// server process (PR #321 — verified live: agents spawned azmcp.exe/workiq.exe
-// despite those servers being in `copilotAgentDisabledMcpServers`).
-//
-// Default disabled list `[]` => agents inherit ALL of the operator's MCP servers
-// (non-breaking; matches interactive copilot). Add a name to disable it for
-// agents. COPILOT_HOME is copilot-specific; claude/codex ignore it, so this is
-// set unconditionally (no runtime.name branching, per the adapter contract).
-// Copilot auth is unaffected (GH_TOKEN / OS credential store); the operator's
-// real ~/.copilot is untouched. Best-effort/fail-open: any failure leaves the
-// inherited COPILOT_HOME so a hiccup never blocks a dispatch.
-function _applyAgentCopilotHome(childEnv) {
-  // Re-seed (picks up Settings changes to the disabled list) + stamp the env.
-  // process.env.COPILOT_HOME is also set at engine boot (see below) so the
-  // child would inherit it anyway; this is belt-and-suspenders + keeps the
-  // seed fresh per dispatch. See shared.ensureAgentCopilotHome.
-  try { childEnv.COPILOT_HOME = shared.ensureAgentCopilotHome(MINIONS_DIR, getConfig()?.engine); }
-  catch { /* leave inherited COPILOT_HOME untouched */ }
-}
-
 // Point a spawned agent's TEMP/TMP/TMPDIR at a scratch dir on the worktree
 // volume instead of the (often full) system drive — see
 // shared.resolveAgentTempBaseDir. copilot/node/git + JVM-based MCP servers write
@@ -4598,16 +4572,6 @@ async function spawnAgent(dispatchItem, config) {
   // random localhost port (blank window). Belt-and-suspenders with dashboard.js's
   // stdout.isTTY gate.
   childEnv.MINIONS_NO_AUTO_OPEN = '1';
-  // MCP-free copilot config so agents never pop a per-spawn Microsoft auth
-  // window — see _applyAgentCopilotHome / shared.resolveAgentCopilotHome.
-  // P-1d8f0b93 — SKIPPED for pooled dispatches: the pooled ACP worker is a
-  // long-lived process shared across many dispatches, so it always uses the
-  // operator's REAL COPILOT_HOME (this is the isolation-removal half of the
-  // pooling feature — MCP-auth-popup risk becomes bounded by pool size
-  // instead of eliminated per-dispatch; documented tradeoff in the plan).
-  if (!useAgentPool) {
-    _applyAgentCopilotHome(childEnv);
-  }
   // Keep agent scratch off a (possibly full) system drive — anchors TEMP/TMP to
   // the worktree volume. See _applyAgentTempEnv / shared.resolveAgentTempBaseDir.
   _applyAgentTempEnv(childEnv, project);
@@ -5059,8 +5023,6 @@ async function spawnAgent(dispatchItem, config) {
       // W-mqef-dashboard-tty — same browser-popup suppression on steering resume
       // (see the initial spawn site). Agents must never auto-open a browser.
       childEnv.MINIONS_NO_AUTO_OPEN = '1';
-      // Same MCP-free copilot home on steering resume (see the initial spawn site).
-      _applyAgentCopilotHome(childEnv);
       // Same agent-scratch redirect on steering resume.
       _applyAgentTempEnv(childEnv, project);
       if (getRepoHost(project) === 'ado') {
@@ -11685,17 +11647,6 @@ function ensureGitHooksInstalled() {
 
 if (require.main === module) {
   try { ensureGitHooksInstalled(); } catch { /* best-effort */ }
-  // Every copilot this process spawns — agent dispatches AND internal
-  // `llm.callLLM` calls (consolidation, classification, meetings, …) — inherits
-  // this process's COPILOT_HOME, so point it at the seeded, MCP-filtered home.
-  // Without this, those `direct:true` copilot calls load the operator's full
-  // `~/.copilot` stack and pop a Microsoft auth window per call. This isolation
-  // is engine-process-only: the dashboard process deliberately does NOT set
-  // COPILOT_HOME at its own boot, so Command Center / doc-chat / the CC worker
-  // pool inherit the operator's real `~/.copilot` home instead (reverted in
-  // W-mre75l6x00024f49; see dashboard.js boot for rationale).
-  // See shared.ensureAgentCopilotHome. Fail-open.
-  try { process.env.COPILOT_HOME = shared.ensureAgentCopilotHome(MINIONS_DIR, getConfig()?.engine); } catch {}
   const { handleCommand } = require('./engine/cli');
   const [cmd, ...args] = process.argv.slice(2);
   handleCommand(cmd, args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2373",
+  "version": "0.1.2375",
   "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"