@yemi33/minions 0.1.2370 → 0.1.2371

package/engine/shared.js

@@ -471,17 +471,6 @@ function log(level, msg, meta = {}) {
   // Console output remains immediate (also redacted)
   console.log(`[${logTs()}] [${level}] ${safeMsg}`);
 
-  // Capture the resolved log file path AT WRITE TIME (not flush time).
-  // Stops test pollution: a test sets MINIONS_TEST_DIR, calls log(), the test
-  // ends and clears MINIONS_TEST_DIR, then the buffer flushes — without
-  // capture-at-write-time the entry would land in the production log.json.
-  // Stripped before persisting (see _flushLogBuffer).
-  Object.defineProperty(entry, '_logPath', {
-    value: _currentLogPath(),
-    enumerable: false,
-    writable: true,
-    configurable: true,
-  });
   // Capture the SQL state.db path too — same write-time semantics so a
   // deferred buffer flush after the test ends still routes the entry to
   // the test's state.db (not the production one). Path resolution mirrors
@@ -534,22 +523,7 @@ function log(level, msg, meta = {}) {
  * Lazy resolution honors the *current* env at flush time, so even unbussed
  * dependents write to the test dir while the test owns it.
  */
-function _currentLogPath() {
-  if (process.env.MINIONS_TEST_DIR) {
-    return path.join(path.resolve(process.env.MINIONS_TEST_DIR), 'engine', 'log.json');
-  }
-  if (process.env.MINIONS_LOG_PATH) {
-    return path.resolve(process.env.MINIONS_LOG_PATH);
-  }
-  const root = process.env.MINIONS_HOME ? path.resolve(process.env.MINIONS_HOME) : path.resolve(__dirname, '..');
-  return path.join(root, 'engine', 'log.json');
-}
-
-// Resolve the SQL state.db path at write time — same isolation contract
-// as _currentLogPath. MINIONS_LOG_PATH only redirects the JSON sidecar;
-// the SQL store stays attached to MINIONS_TEST_DIR / MINIONS_HOME because
-// it shares the file with the rest of the engine state (dispatches,
-// work_items, pull_requests).
+// Resolve the SQL state.db path at write time.
 function _currentLogDbPath() {
   if (process.env.MINIONS_TEST_DIR) {
     return path.join(path.resolve(process.env.MINIONS_TEST_DIR), 'engine', 'state.db');
@@ -673,21 +647,15 @@ function _flushLogBuffer() {
   // has been cleared by the time we flush. Entries without captured paths
   // fall back to the current resolved values (eg. direct _logBuffer.push()
   // from tests).
-  const fallbackJsonPath = _currentLogPath();
   const fallbackDbPath = _currentLogDbPath();
-  const byJsonPath = new Map();
   const byDbPath = new Map();
   for (const raw of drained) {
-    const jsonTarget = raw._logPath || fallbackJsonPath;
     const dbTarget = raw._dbPath || fallbackDbPath;
     // SEC-09 defense-in-depth: redact again at flush time so any direct
     // `_logBuffer.push(entry)` callers (tests, future paths) can't leak secrets.
     const entry = redactSecrets(raw);
     // Strip the routing-only metadata before persisting.
-    delete entry._logPath;
     delete entry._dbPath;
-    if (!byJsonPath.has(jsonTarget)) byJsonPath.set(jsonTarget, []);
-    byJsonPath.get(jsonTarget).push(entry);
     if (!byDbPath.has(dbTarget)) byDbPath.set(dbTarget, []);
     byDbPath.get(dbTarget).push(entry);
   }
@@ -702,19 +670,6 @@ function _flushLogBuffer() {
     }
   } catch { /* logs-store unavailable (node<22.5) — JSON mirror still works */ }
 
-  // JSON mirror — kept for backward compat with test fixtures that
-  // safeJson(log.json) directly, and the legacy getEngineLog fallback.
-  // Phase 4.5 will retire this once readers move to readRecentLogs().
-  for (const [target, entries] of byJsonPath) {
-    try {
-      mutateJsonFileLocked(target, (logData) => {
-        if (!Array.isArray(logData)) logData = logData?.entries || [];
-        logData.push(...entries);
-        if (logData.length >= 2500) logData.splice(0, logData.length - 2000);
-        return logData;
-      }, { defaultValue: [] });
-    } catch { /* logging should never crash the caller */ }
-  }
 }
 
 /** Flush buffered log entries to disk. Call during graceful shutdown to drain the buffer. */
@@ -729,6 +684,11 @@ function flushLogs() {
 // ── File I/O ─────────────────────────────────────────────────────────────────
 
 function safeRead(p) {
+  const prdStore = require('./prd-store');
+  if (prdStore.parsePrdPath(p)) {
+    const prd = prdStore.readPrd(p);
+    return prd == null ? '' : JSON.stringify(prd, null, 2);
+  }
   try { return fs.readFileSync(p, 'utf8'); } catch { return ''; }
 }
 
@@ -738,10 +698,24 @@ function safeRead(p) {
 // the client-sent document body with '' when the file was deleted/moved
 // between panel open and send.
 function safeReadOrNull(p) {
+  const prdStore = require('./prd-store');
+  if (prdStore.parsePrdPath(p)) {
+    const prd = prdStore.readPrd(p);
+    return prd == null ? null : JSON.stringify(prd, null, 2);
+  }
   try { return fs.readFileSync(p, 'utf8'); } catch { return null; }
 }
 
 function safeReadDir(dir) {
+  const resolved = path.resolve(dir);
+  const prdRoot = path.resolve(MINIONS_DIR, 'prd');
+  const prdArchive = path.join(prdRoot, 'archive');
+  if (resolved === prdRoot || resolved === prdArchive) {
+    const archived = resolved === prdArchive;
+    return require('./prd-store').listPrdRows()
+      .filter(row => row.archived === archived)
+      .map(row => row.filename);
+  }
   try { return fs.readdirSync(dir); } catch { return []; }
 }
 
@@ -884,7 +858,7 @@ function isSourcePlanContentStale(plansDir, plan) {
 // Matching is by path suffix rather than full-prefix against MINIONS_DIR,
 // because tests using MINIONS_TEST_DIR re-resolve the dir but use the same
 // suffix pattern. Returns `{value}` on hit, `null` on miss; callers fall
-// through to the legacy disk read.
+// through to ordinary file-backed JSON handling.
 //
 // Per-project work-items / pull-requests need scope extraction from the
 // path. `<MINIONS_DIR>/projects/<name>/work-items.json` → scope `<name>`;
@@ -956,23 +930,15 @@ function _routeJsonReadToSql(p) {
       const store = require('./small-state-store');
       return { value: store.readDocSessions() };
     }
-    // Per-project work-items.json — match `/projects/<name>/work-items.json`.
-    // When SQL has no rows for the scope AND the JSON file is absent on
-    // disk, preserve the legacy "file missing → null" semantic. This guards
-    // the resurrection-bug regression (engine-helper-coverage.test.js):
-    // safeJson(path-to-removed-project) must return null, not `[]`.
+    // Per-project work-items.json — the path is now only a scope identifier.
     if ((m = norm.match(/\/projects\/([^/]+)\/work-items\.json$/))) {
       const store = require('./work-items-store');
-      const v = store.readWorkItemsForScope(m[1]);
-      if ((!Array.isArray(v) || v.length === 0) && !fs.existsSync(p)) return null;
-      return { value: v };
+      return { value: store.readWorkItemsForScope(m[1]) };
     }
     // Per-project pull-requests.json
     if ((m = norm.match(/\/projects\/([^/]+)\/pull-requests\.json$/))) {
       const store = require('./pull-requests-store');
-      const v = store.readPullRequestsForScope(m[1]);
-      if ((!Array.isArray(v) || v.length === 0) && !fs.existsSync(p)) return null;
-      return { value: v };
+      return { value: store.readPullRequestsForScope(m[1]) };
     }
     // Central work-items.json — `<MINIONS_DIR>/work-items.json`. Must not
     // collide with `/projects/<name>/work-items.json` (handled above).
@@ -1040,6 +1006,8 @@ function safeJson(p) {
   // bytes as the source of truth (so the read+write pair is atomic).
   const skipSqlRouting = arguments.length > 1 && arguments[1] && arguments[1].skipSqlRouting;
   if (!skipSqlRouting) {
+    const prdStore = require('./prd-store');
+    if (prdStore.parsePrdPath(p)) return prdStore.readPrd(p);
     const routed = _routeJsonReadToSql(p);
     if (routed) return routed.value;
   }
@@ -1137,6 +1105,10 @@ function safeJsonArr(p) { return safeJson(p) || []; }
  * @returns {*} Parsed JSON on success, otherwise `defaultValue`.
  */
 function safeJsonNoRestore(p, defaultValue = null) {
+  const prdStore = require('./prd-store');
+  if (prdStore.parsePrdPath(p)) return prdStore.readPrd(p) ?? defaultValue;
+  const routed = _routeJsonReadToSql(p);
+  if (routed) return routed.value ?? defaultValue;
   let raw;
   try {
     raw = fs.readFileSync(p, 'utf8');
@@ -1163,6 +1135,12 @@ function safeJsonNoRestore(p, defaultValue = null) {
 let _tmpCounter = 0;
 
 function safeWrite(p, data) {
+  const prdStore = require('./prd-store');
+  if (prdStore.parsePrdPath(p)) {
+    if (typeof data === 'string') data = JSON.parse(data);
+    prdStore.writePrd(p, data);
+    return;
+  }
   const dir = path.dirname(p);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
   const content = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
@@ -1824,18 +1802,27 @@ function withFileLock(lockPath, fn, {
 // Route table for small-state files migrated to SQL stores. Each entry
 // declares the SQL store function to invoke and the expected default JSON
 // shape (for the "ensure file exists" fallback below).
-const _SMALL_STATE_MUTATE_ROUTES = {
-  'cooldowns.json':       { fn: 'applyCooldownsMutation',       mirror: '_mirrorCooldownsJson',       defaultShape: 'object' },
-  'pending-rebases.json': { fn: 'applyPendingRebasesMutation',  mirror: '_mirrorPendingRebasesJson',  defaultShape: 'array'  },
-  'cc-sessions.json':     { fn: 'applyCcSessionsMutation',      mirror: '_mirrorCcSessionsJson',      defaultShape: 'array'  },
-  'doc-sessions.json':    { fn: 'applyDocSessionsMutation',     mirror: '_mirrorDocSessionsJson',     defaultShape: 'object' },
-  'pr-links.json':        { fn: 'applyPrLinksMutation',         mirror: '_mirrorPrLinksJson',         defaultShape: 'object' },
+const _STATE_MUTATE_ROUTES = {
+  'dispatch.json':         { module: './dispatch-store', fn: 'applyDispatchMutation' },
+  'metrics.json':          { module: './metrics-store', fn: 'applyMetricsMutation' },
+  'watches.json':          { module: './watches-store', fn: 'applyWatchesMutation' },
+  'schedule-runs.json':    { module: './small-state-store', fn: 'applyScheduleRunsMutation' },
+  'pipeline-runs.json':    { module: './small-state-store', fn: 'applyPipelineRunsMutation' },
+  'managed-processes.json': { module: './small-state-store', fn: 'applyManagedProcessesMutation' },
+  'worktree-pool.json':    { module: './small-state-store', fn: 'applyWorktreePoolMutation' },
+  'qa-runs.json':          { module: './small-state-store', fn: 'applyQaRunsMutation' },
+  'qa-sessions.json':      { module: './small-state-store', fn: 'applyQaSessionsMutation' },
+  'cooldowns.json':        { module: './small-state-store', fn: 'applyCooldownsMutation' },
+  'pending-rebases.json':  { module: './small-state-store', fn: 'applyPendingRebasesMutation' },
+  'cc-sessions.json':      { module: './small-state-store', fn: 'applyCcSessionsMutation' },
+  'doc-sessions.json':     { module: './small-state-store', fn: 'applyDocSessionsMutation' },
+  'pr-links.json':         { module: './small-state-store', fn: 'applyPrLinksMutation' },
 };
 
 function _tryRouteMutateToSql(filePath, mutateFn, onWrote) {
   const baseName = path.basename(filePath);
-  const smallRoute = _SMALL_STATE_MUTATE_ROUTES[baseName];
-  if (baseName !== 'work-items.json' && baseName !== 'pull-requests.json' && !smallRoute) return null;
+  const stateRoute = _STATE_MUTATE_ROUTES[baseName];
+  if (baseName !== 'work-items.json' && baseName !== 'pull-requests.json' && !stateRoute) return null;
   const fpNorm = String(filePath).replace(/\\/g, '/');
   const minionsNorm = String(MINIONS_DIR).replace(/\\/g, '/');
   const insideMinionsDir = fpNorm.startsWith(minionsNorm + '/') || fpNorm === minionsNorm + '/' + baseName;
@@ -1843,57 +1830,21 @@ function _tryRouteMutateToSql(filePath, mutateFn, onWrote) {
 
   // Small-state files live exclusively under <MINIONS_DIR>/engine/<baseName>.
   // Don't hijack writes to ad-hoc paths that happen to share the basename.
-  if (smallRoute) {
+  if (stateRoute) {
     if (!fpNorm.endsWith('/engine/' + baseName)) return null;
-    const store = require('./small-state-store');
-    // Pre-warm the SQLite DB BEFORE acquiring the file lock. On the very first
-    // call from a process (or after a test-isolation MINIONS_TEST_DIR swap),
-    // getDb() opens the DB file and runs migrations — which can take tens of
-    // milliseconds on a loaded box. When 5+ concurrent processes all hit this
-    // path simultaneously, whichever one wins the file lock holds it for the
-    // entire DB-init duration. The other 4 processes each have only a 5-second
-    // timeout window to acquire the lock; if DB init exceeds that, they throw
-    // "Lock timeout" and exit 1 (observed in CI after opg#552 backport which
-    // added a new test that increases system load during parallel runs).
-    // Pre-warming here means getDb() returns the cached _db instantly when
-    // called again inside the lock, so the lock is held only for the fast
-    // SQL transaction + mirror write — not for DB initialization.
+    const store = require(stateRoute.module);
     try {
       require('./db').getDb();
     } catch (e) {
       throw new Error(`small-state-store: SQLite unavailable — ${e.message}`);
     }
-    // Hold the JSON file lock across the SQL transaction AND the mirror
-    // write. The SQL transaction itself is cross-process serialized via
-    // BEGIN IMMEDIATE inside the SQL store, but the JSON mirror is a
-    // separate read-from-SQL → atomic-rename that can race across
-    // processes: an earlier mirror's stale snapshot can land AFTER a
-    // later mirror's complete snapshot and lose committed rows from the
-    // on-disk JSON file. Pre-Phase-9.4 this was masked by the JSON
-    // fallback (concurrent writers serialized through the same lock at
-    // the bottom of mutateJsonFileLocked); after the fallback removal,
-    // the bare mirror races. Locking around the SQL+mirror block puts
-    // those two operations back into one cross-process critical section.
-    const lockPath = `${filePath}.lock`;
-    return withFileLock(lockPath, () => {
-      const out = store[smallRoute.fn]((data) => {
-        const next = mutateFn(data);
-        if (onWrote) onWrote();
-        return next;
-      });
-      const result = out && Object.prototype.hasOwnProperty.call(out, 'result') ? out.result : undefined;
-      try { store[smallRoute.mirror](filePath); } catch { /* mirror best-effort */ }
-      if (!fs.existsSync(filePath)) {
-        try {
-          fs.mkdirSync(path.dirname(filePath), { recursive: true });
-          const fallback = smallRoute.defaultShape === 'array'
-            ? (Array.isArray(result) ? result : [])
-            : (result && typeof result === 'object' && !Array.isArray(result) ? result : {});
-          safeWrite(filePath, fallback);
-        } catch { /* best-effort */ }
-      }
-      return { routed: result };
+    const out = store[stateRoute.fn]((data) => {
+      const next = mutateFn(data);
+      if (onWrote) onWrote();
+      return next;
     });
+    const result = out && Object.prototype.hasOwnProperty.call(out, 'result') ? out.result : undefined;
+    return { routed: result };
   }
 
   let result;
@@ -1915,15 +1866,6 @@ function _tryRouteMutateToSql(filePath, mutateFn, onWrote) {
       return out;
     });
   }
-  // SQL-store mirror is gated on `wrote`; an empty-no-op mutator leaves the
-  // JSON file uncreated. The JSON path always wrote (including for empty
-  // arrays via ensureProjectStateFiles), so guarantee a JSON file exists.
-  if (!fs.existsSync(filePath)) {
-    try {
-      fs.mkdirSync(path.dirname(filePath), { recursive: true });
-      safeWrite(filePath, Array.isArray(result) ? result : []);
-    } catch { /* best-effort */ }
-  }
   return { routed: result };
 }
 
@@ -1938,12 +1880,11 @@ function mutateJsonFileLocked(filePath, mutateFn, {
   const lockPath = `${filePath}.lock`;
   const retries = lockRetries ?? ENGINE_DEFAULTS.lockRetries;
   const retryBackoffMs = lockRetryBackoffMs ?? ENGINE_DEFAULTS.lockRetryBackoffMs;
-  // Phase 9 SQL-routing: when targeting work-items.json or pull-requests.json
-  // under MINIONS_DIR, delegate to the SQL-store wrappers so SQL stays
-  // canonical. Without this, JSON-only edits leak past the SQL mirror and
-  // divergence-detection short-circuits leave SQL readers stale.
-  // `_skipSqlRouting: true` is the internal opt-out used by the SQL store's
-  // own SQLite-failure fallback to avoid recursion.
+  const prdStore = require('./prd-store');
+  if (!_skipSqlRouting && prdStore.parsePrdPath(filePath)) {
+    return prdStore.mutatePrd(filePath, mutateFn, { defaultValue });
+  }
+  // Route migrated path-shaped state APIs to SQL.
   if (!_skipSqlRouting) {
     const routed = _tryRouteMutateToSql(filePath, mutateFn, onWrote);
     if (routed) return routed.routed;
@@ -1980,17 +1921,6 @@ function mutateJsonFileLocked(filePath, mutateFn, {
         try { if (fileExists) fs.copyFileSync(filePath, backupPath); } catch { /* backup is best-effort */ }
       }
       safeWrite(filePath, finalData);
-      // Phase 10 step 2 — dual-write PRD content to SQL. The single chokepoint:
-      // every prd/*.json mutation through mutateJsonFileLocked mirrors into the
-      // prds/prd_items/prd_verify_prs tables. JSON stays canonical (nothing
-      // reads SQL yet); this keeps the mirror trustworthy for the read-flip.
-      // BEST-EFFORT: parsePrdPath fast-rejects non-PRD paths, and a SQLite
-      // failure must never break the JSON write. mirrorPrdToSql swallows
-      // internally; the require is guarded for the (engine-agnostic) load order.
-      try {
-        const prdStore = require('./prd-store');
-        if (prdStore.parsePrdPath(filePath)) prdStore.mirrorPrdToSql(filePath, finalData);
-      } catch { /* mirror is best-effort — never break the canonical JSON write */ }
       // Side-effect hook fired only when an actual write happened. Callers
       // use this to emit cache-invalidation signals (events table row) so
       // skip-write-unchanged paths (dedup, idempotent no-op POSTs) don't
@@ -3533,46 +3463,18 @@ const ENGINE_DEFAULTS = {
   // Engine-scoped per the CLAUDE.md rule against `runtime.name === ...` branches at call sites — the runtime check
   // lives inside the helper (engine/spawn-agent.js#preApproveWorkspaceMcps) which no-ops for non-Claude runtimes.
   claudePreApproveWorkspaceMcps: true,
-  // P-08b62d49 — propagate project-local-on-main harness dirs (uncommitted
-  // <repo>/.claude/skills, <repo>/.copilot/commands, etc.) into the worktree
-  // dispatch via additional `--add-dir` entries. Defaults TRUE so the
-  // worktree-uncommitted footgun described in docs/harness-propagation.md is
-  // closed by default. Set to false to fall back to the legacy
-  // "only committed assets are visible" behavior.
-  harnessPropagateProjectLocal: true,
-  // P-7c1a9e42 — cap on how many skill packs / command files
-  // engine/discover-project-skills.js reads per surface (root `.claude/skills`,
-  // each `<area>/.claude/skills`, etc.). Raised well above the module-level
-  // DEFAULTS.maxFilesPerSurface fallback (50) so large monorepo sub-projects (e.g.
-  // office/src/ocm/.claude/skills with ~80 packages) don't silently drop the
-  // most-relevant skills past the cap. engine/playbook.js threads this into the
-  // discovery `opts`; when no override is supplied the module falls back to its
-  // own DEFAULTS.maxFilesPerSurface. See docs/project-skills.md.
-  projectSkillMaxFilesPerSurface: 200,
-  // P-49e1c8b7 — hermetic harness opt-out. When TRUE the spawned agent runs
-  // with a known-empty harness surface around the worktree:
-  //   - `--add-dir` is exactly `[minionsDir]` (user-scope skill/command/MCP
-  //     roots from `runtime.getUserAssetDirs(...)` are dropped);
-  //   - project-local-on-main harness propagation (`harnessPropagateProjectLocal`)
-  //     is skipped — no `--project-harness-dir` flags emitted;
-  //   - Claude workspace `.mcp.json` pre-approval (`claudePreApproveWorkspaceMcps`)
-  //     is skipped.
-  // Independent of `copilotDisableBuiltinMcps` and `copilotSuppressAgentsMd` —
-  // those keep their existing semantics so operators can mix-and-match. Use
-  // per-agent override `agent.hermeticHarness` for targeted runs. Resolved
-  // through `shared.resolveAgentHermeticHarness(agent, engine)` (mirrors
-  // `resolveAgentBareMode`).
-  hermeticHarness: false,
-  copilotSuppressAgentsMd: true,     // Copilot --no-custom-instructions: stop AGENTS.md auto-load from fighting Minions playbook prompts
   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)
-  // P-mcp-storm — Copilot SPAWNS every server in its `mcp-config.json` on every
-  // process start and authenticates it. `--disable-mcp-server <name>` only hides
-  // a server's TOOLS from the model; it does NOT stop the server process (proven
-  // empirically — agents spawned azmcp/workiq even with the flag set), so any
-  // auth-requiring server pops a Microsoft sign-in window on EVERY agent spawn.
-  // The ONLY real lever is the CONFIG: a server absent from the config can't be
-  // spawned. The engine therefore points agents at a private COPILOT_HOME
+  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.
+  // 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
@@ -3581,7 +3483,6 @@ const ENGINE_DEFAULTS = {
   // `agent.copilotAgentDisabledMcpServers`. Resolved through
   // `shared.resolveCopilotAgentDisabledMcpServers(agent, engine)`.
   copilotAgentDisabledMcpServers: [],
-  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.
   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
@@ -4046,31 +3947,6 @@ function resolveCopilotAgentDisabledMcpServers(agent, engine) {
   return [];
 }
 
-/**
- * P-49e1c8b7 — Resolve whether this agent should run with a hermetic harness.
- * Priority (mirrors `resolveAgentBareMode`):
- *   1. `agent.hermeticHarness`    — per-agent override (boolean)
- *   2. `engine.hermeticHarness`   — fleet default
- *   3. `false`                    — hardcoded fallback
- *
- * Strict undefined/null check (not falsy) so a per-agent `false` correctly
- * overrides an engine `true`. Truthy/falsy non-bool values are coerced via
- * `!!` for config tolerance.
- *
- * When TRUE, engine.js (a) skips Claude workspace .mcp.json pre-approval,
- * (b) skips project-local-on-main `--project-harness-dir` propagation, and
- * (c) forwards `--hermetic-harness` to spawn-agent.js so `computeAddDirs`
- * returns `[minionsDir]` only (user-scope skill/command/MCP roots stripped).
- * Independent of `copilotDisableBuiltinMcps` and `copilotSuppressAgentsMd`.
- */
-function resolveAgentHermeticHarness(agent, engine) {
-  const a = agent ? agent.hermeticHarness : undefined;
-  if (a !== undefined && a !== null) return !!a;
-  const e = engine ? engine.hermeticHarness : undefined;
-  if (e !== undefined && e !== null) return !!e;
-  return false;
-}
-
 
 // ─── Legacy ccModel → defaultModel Migration ─────────────────────────────────
 //
@@ -4653,12 +4529,11 @@ const WATCH_ACTION_TYPE = {
  * propagate; the CLI shim in bin/minions.js guarantees `node:sqlite` is
  * loadable on every supported Node version.
  */
-function _smallStateMutator({ filePath, applyMutation, mirror, topic }) {
+function _smallStateMutator({ applyMutation, topic }) {
   return (mutator) => {
     const store = require('./small-state-store');
     const { wrote, result } = store[applyMutation]((obj) => mutator(obj) || obj);
     if (wrote) {
-      try { if (mirror && typeof store[mirror] === 'function') store[mirror](filePath); } catch { /* mirror best-effort */ }
       try { require('./db-events').emitStateEvent(topic); } catch { /* optional */ }
     }
     return result;
@@ -4666,84 +4541,51 @@ function _smallStateMutator({ filePath, applyMutation, mirror, topic }) {
 }
 
 const mutateScheduleRuns = _smallStateMutator({
-  filePath: path.join(MINIONS_DIR, 'engine', 'schedule-runs.json'),
   applyMutation: 'applyScheduleRunsMutation',
-  mirror: '_mirrorScheduleRunsJson',
   topic: 'schedule_runs',
   defaultValue: () => ({}),
 });
 
 const mutatePipelineRuns = _smallStateMutator({
-  filePath: path.join(MINIONS_DIR, 'engine', 'pipeline-runs.json'),
   applyMutation: 'applyPipelineRunsMutation',
-  mirror: '_mirrorPipelineRunsJson',
   topic: 'pipeline_runs',
   defaultValue: () => ({}),
 });
 
 const mutateManagedProcesses = _smallStateMutator({
-  filePath: path.join(MINIONS_DIR, 'engine', 'managed-processes.json'),
   applyMutation: 'applyManagedProcessesMutation',
-  mirror: '_mirrorManagedProcessesJson',
   topic: 'managed_processes',
   defaultValue: () => ({ specs: [] }),
 });
 
 const mutateWorktreePool = _smallStateMutator({
-  filePath: path.join(MINIONS_DIR, 'engine', 'worktree-pool.json'),
   applyMutation: 'applyWorktreePoolMutation',
-  mirror: '_mirrorWorktreePoolJson',
   topic: 'worktree_pool',
   defaultValue: () => ({ entries: [] }),
 });
 
-/**
- * Phase 8 — QA state mutators. Both qa-runs and qa-sessions are top-level
- * JSON arrays (mutator receives the array; mutates in place or returns a
- * replacement). The store diffs by `id`. Falls back to mutateJsonFileLocked
- * on SQLite failure so a node:sqlite-broken install keeps recording QA
- * state. The JSON mirror is gated by `engine.qaDualWriteJson` (default true)
- * — turn off once operators trust SQL as the source of truth.
- */
-function _qaDualWriteEnabled() {
-  try {
-    const cfg = safeJson(path.join(MINIONS_DIR, 'config.json')) || {};
-    const flag = cfg && cfg.engine && cfg.engine.qaDualWriteJson;
-    if (flag === false) return false;
-    return true;
-  } catch { return true; }
-}
-
-function _qaMutator({ filePath, applyMutation, mirror, topic }) {
+/** Route QA array mutations through their SQL stores. */
+function _qaMutator({ applyMutation, topic }) {
   return (mutator) => {
-    return withFileLock(filePath + '.lock', () => {
-      const store = require('./small-state-store');
-      const { wrote, result } = store[applyMutation]((arr) => {
-        if (!Array.isArray(arr)) arr = [];
-        return mutator(arr) || arr;
-      });
-      if (wrote) {
-        if (_qaDualWriteEnabled()) {
-          try { if (mirror && typeof store[mirror] === 'function') store[mirror](filePath); } catch { /* mirror best-effort */ }
-        }
-        try { require('./db-events').emitStateEvent(topic); } catch { /* optional */ }
-      }
-      return result;
-    }, { timeoutMs: 5000, retries: 3 });
+    const store = require('./small-state-store');
+    const { wrote, result } = store[applyMutation]((arr) => {
+      if (!Array.isArray(arr)) arr = [];
+      return mutator(arr) || arr;
+    });
+    if (wrote) {
+      try { require('./db-events').emitStateEvent(topic); } catch { /* optional */ }
+    }
+    return result;
   };
 }
 
 const mutateQaRuns = _qaMutator({
-  filePath: path.join(MINIONS_DIR, 'engine', 'qa-runs.json'),
   applyMutation: 'applyQaRunsMutation',
-  mirror: '_mirrorQaRunsJson',
   topic: 'qa_runs',
 });
 
 const mutateQaSessions = _qaMutator({
-  filePath: path.join(MINIONS_DIR, 'engine', 'qa-sessions.json'),
   applyMutation: 'applyQaSessionsMutation',
-  mirror: '_mirrorQaSessionsJson',
   topic: 'qa_sessions',
 });
 
@@ -4754,41 +4596,24 @@ const mutateQaSessions = _qaMutator({
  * diffs by id. SQL-canonical (Phase 9.4); SQLite failures propagate.
  */
 function mutateWatches(mutator) {
-  const watchesPath = path.join(MINIONS_DIR, 'engine', 'watches.json');
   const store = require('./watches-store');
   const { wrote, result } = store.applyWatchesMutation((arr) => {
     if (!Array.isArray(arr)) arr = [];
     return mutator(arr) || arr;
   });
   if (wrote) {
-    try { store._mirrorJsonFromSql(watchesPath); } catch { /* mirror best-effort */ }
     try { require('./db-events').emitStateEvent('watches'); } catch { /* optional */ }
   }
   return result;
 }
 
-/**
- * Route a metrics mutation through the SQL store with a JSON dual-write
- * mirror. Same shape as mutateWorkItems / mutatePullRequests: mutator
- * receives the full legacy-shape metrics object, mutates in place or
- * returns a replacement, and the store diffs by (kind, key) row.
- * SQL-canonical (Phase 9.4); SQLite failures propagate.
- */
+/** Route a metrics object mutation through the SQL store. */
 function mutateMetrics(mutator) {
-  const metricsPath = path.join(MINIONS_DIR, 'engine', 'metrics.json');
   const store = require('./metrics-store');
-  // W-mradg74d000rfd45 — the JSON mirror is now written INSIDE
-  // applyMetricsMutation's SQL transaction (before commit), not here
-  // after the fact. Mirroring post-commit left a cross-process window
-  // where a sibling process (dashboard vs. engine — separate Node
-  // processes, each with its own in-memory mirror-hash cache) could
-  // observe the newly committed SQL rows before the JSON file caught up
-  // and read stale/missing metrics off the sidecar. See
-  // metrics-store.js#applyMetricsMutation for the full rationale.
   const { wrote, result } = store.applyMetricsMutation((m) => {
     if (!m || typeof m !== 'object') m = {};
     return mutator(m) || m;
-  }, { mirrorPath: metricsPath });
+  });
   if (wrote) {
     try { require('./db-events').emitStateEvent('metrics'); } catch { /* optional */ }
   }
@@ -4981,132 +4806,6 @@ const FAILURE_CLASS = {
 // Structured completion protocol — fields agents must produce in ```completion blocks
 const COMPLETION_FIELDS = ['status', 'summary', 'files_changed', 'tests', 'pr', 'not_changed', 'failure_class', 'retryable', 'needs_rerun', 'verdict', 'artifacts', 'nonce', 'securityFlags'];
 
-// ── Harness transparency (P-a8f3c2d1) ──────────────────────────────────────
-// Canonical vocabulary for harness-usage observability. Both the agent
-// self-report (completionReport.harnessUsed) and the engine-side grounding
-// manifest (_harnessPropagated) speak this shape. Each kind declares the only
-// fields that survive normalization plus the single field that MUST be present
-// for an entry to be kept:
-//   skills:     { name, source, path }   (required: name)
-//   mcpServers: { name, scope }          (required: name)
-//   commands:   { name, scope }          (required: name)
-//   docs:       { path, why }            (required: path)
-const HARNESS_USED_KINDS = {
-  skills:     { fields: ['name', 'source', 'path'], required: 'name' },
-  mcpServers: { fields: ['name', 'scope'],          required: 'name' },
-  commands:   { fields: ['name', 'scope'],          required: 'name' },
-  docs:       { fields: ['path', 'why'],            required: 'path' },
-};
-const HARNESS_USED_MAX_ENTRIES = 50;    // per-kind array cap (anti-spam / anti-DoS)
-const HARNESS_USED_MAX_FIELD_LEN = 512; // per-field string clamp
-
-// normalizeHarnessUsed(raw) — validate/clamp an untrusted harnessUsed-shaped
-// object into the canonical { skills, mcpServers, commands, docs } form.
-// Drops malformed entries (non-objects, or missing the kind's required field),
-// keeps only whitelisted string fields (trimmed + clamped), and caps each array
-// at HARNESS_USED_MAX_ENTRIES. Returns null when nothing survives so callers can
-// treat "no harness data" as a single falsy case. When non-null, all four kind
-// keys are always present (empty arrays for kinds with no entries) for a stable
-// downstream shape.
-function normalizeHarnessUsed(raw) {
-  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
-  const out = {};
-  let any = false;
-  for (const [kind, spec] of Object.entries(HARNESS_USED_KINDS)) {
-    const arr = Array.isArray(raw[kind]) ? raw[kind] : [];
-    const normed = [];
-    for (const entry of arr) {
-      if (normed.length >= HARNESS_USED_MAX_ENTRIES) break;
-      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
-      const clean = {};
-      for (const field of spec.fields) {
-        const val = entry[field];
-        if (typeof val !== 'string') continue;
-        const trimmed = val.trim();
-        if (!trimmed) continue;
-        clean[field] = trimmed.slice(0, HARNESS_USED_MAX_FIELD_LEN);
-      }
-      if (!clean[spec.required]) continue; // required field missing/empty → drop
-      normed.push(clean);
-    }
-    out[kind] = normed;
-    if (normed.length) any = true;
-  }
-  return any ? out : null;
-}
-
-// groundHarnessUsed(harnessUsed, propagated) — Stage 2 grounding cross-check
-// (P-c6f5e8b3). Normalizes an agent's self-reported `harnessUsed` and annotates
-// every surviving entry with a strict-boolean `grounded` field by cross-checking
-// it against the engine-captured `_harnessPropagated` manifest persisted at
-// spawn time:
-//   { skills:[{name,source,path}], mcpServers:[{name,scope}],
-//     commands:[{name,scope}], addDirs:[...] }
-//
-// Grounding is intentionally NON-DESTRUCTIVE: a `grounded:false` entry is KEPT
-// and flagged — it may be a genuine out-of-band tool, a stale path, or a
-// hallucination, and a human (not the engine) adjudicates. Returns null when
-// the self-report normalizes to nothing (same falsy contract as
-// normalizeHarnessUsed) so callers treat "no harness data" as one case.
-//
-// Matching signals per entry (OR'd to grounded:true):
-//   - identity: the entry's `name` equals a propagated entry's name of the same
-//     kind, OR (skills/docs) the entry's `path` is lexically contained under a
-//     propagated skill root or `--add-dir`, OR basename(path) equals a
-//     propagated skill name.
-//   - scope: the entry's scope (skills use `source`) matches a propagated
-//     entry's scope of the same kind. The capture manifest records harness
-//     ROOTS (skill/command dirs, MCP config files) rather than individual
-//     affordances, so a per-affordance self-report often can't match by name;
-//     scope membership is the coarse-but-honest "the engine exposed this
-//     surface" signal the manifest can attest. `docs` carry no scope, so path
-//     containment is their only signal.
-function groundHarnessUsed(harnessUsed, propagated) {
-  const normalized = normalizeHarnessUsed(harnessUsed);
-  if (!normalized) return null;
-  const m = (propagated && typeof propagated === 'object' && !Array.isArray(propagated)) ? propagated : {};
-  const arr = (v) => (Array.isArray(v) ? v : []);
-  const lc = (v) => (typeof v === 'string' ? v.trim().toLowerCase() : '');
-  const normPath = (p) => String(p || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
-  const basename = (p) => normPath(p).split('/').filter(Boolean).pop() || '';
-
-  // Container paths an affordance may legitimately live under: every propagated
-  // skill root + every propagated `--add-dir`.
-  const containers = [
-    ...arr(m.skills).map(s => s && s.path).filter(Boolean),
-    ...arr(m.addDirs).filter(p => typeof p === 'string' && p),
-  ].map(normPath).filter(Boolean);
-  const isUnder = (p) => {
-    const np = normPath(p);
-    if (!np) return false;
-    return containers.some(c => np === c || np.startsWith(c + '/'));
-  };
-
-  const setOf = (list, key) => new Set(arr(list).map(e => e && lc(e[key])).filter(Boolean));
-  const skillNames = setOf(m.skills, 'name');
-  const skillSources = setOf(m.skills, 'source');
-  const cmdNames = setOf(m.commands, 'name');
-  const cmdScopes = setOf(m.commands, 'scope');
-  const mcpNames = setOf(m.mcpServers, 'name');
-  const mcpScopes = setOf(m.mcpServers, 'scope');
-
-  const groundSkill = (e) => !!(
-    (e.name && skillNames.has(lc(e.name)))
-    || (e.path && (isUnder(e.path) || skillNames.has(basename(e.path))))
-    || (e.source && skillSources.has(lc(e.source)))
-  );
-  const groundCommand = (e) => !!((e.name && cmdNames.has(lc(e.name))) || (e.scope && cmdScopes.has(lc(e.scope))));
-  const groundMcp = (e) => !!((e.name && mcpNames.has(lc(e.name))) || (e.scope && mcpScopes.has(lc(e.scope))));
-  const groundDoc = (e) => !!(e.path && isUnder(e.path));
-
-  return {
-    skills: normalized.skills.map(e => ({ ...e, grounded: groundSkill(e) })),
-    mcpServers: normalized.mcpServers.map(e => ({ ...e, grounded: groundMcp(e) })),
-    commands: normalized.commands.map(e => ({ ...e, grounded: groundCommand(e) })),
-    docs: normalized.docs.map(e => ({ ...e, grounded: groundDoc(e) })),
-  };
-}
-
 const DEFAULT_AGENT_METRICS = {
   tasksCompleted: 0, tasksErrored: 0,
   prsCreated: 0, prsApproved: 0, prsRejected: 0, prsMerged: 0,
@@ -5600,19 +5299,12 @@ function sameResolvedPath(a, b) {
 }
 
 function ensureProjectStateFiles(project) {
-  const files = [
-    { name: 'pull-requests.json', centralPath: projectPrPath(project) },
-    { name: 'work-items.json', centralPath: projectWorkItemsPath(project) },
-  ];
   const result = { created: [] };
-
   projectStateDirEnsure(project);
-  for (const file of files) {
-    if (!fs.existsSync(file.centralPath)) {
-      mutateJsonFileLocked(file.centralPath, data => Array.isArray(data) ? data : [], { defaultValue: [] });
-      result.created.push(file.name);
-    }
-  }
+  // SQL scopes need no empty sentinel rows. Touch both stores so migrations
+  // and schema validation still happen at project setup time.
+  require('./work-items-store').readWorkItemsForScope(project.name);
+  require('./pull-requests-store').readPullRequestsForScope(project.name);
   return result;
 }
 
@@ -6262,50 +5954,6 @@ function resolveProjectRootDir(localPath, minionsDir) {
   return fallback;
 }
 
-/**
- * Resolve a stable, repo-EXTERNAL COPILOT_HOME for spawned copilot agents.
- *
- * Copilot loads `$COPILOT_HOME/mcp-config.json` and SPAWNS every server in it on
- * every process start. `--disable-mcp-server <name>` only hides a server's tools
- * from the model — it does NOT stop the server PROCESS from launching, so any
- * server that does interactive auth (azure-kusto/azmcp, DevBox, workiq, loop, …)
- * still pops a Microsoft sign-in window on EVERY agent spawn. With minions
- * spawning agents continuously that is an unbounded popup storm.
- *
- * The only effective lever is to give agents a COPILOT_HOME whose mcp-config has
- * NO user servers (the engine seeds `{"mcpServers":{}}` there). Copilot auth is
- * unaffected — it uses GH_TOKEN / the OS credential store, not files under the
- * home — and the operator's real `~/.copilot` (interactive copilot) is 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 (surfaced in CC as "Load failed"). 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');
-}
-
 /**
  * Derive a scratch/temp base dir on the same volume agent work already lives on
  * — the configured worktree location (engine.worktreeRoot, default
@@ -6330,6 +5978,55 @@ 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
@@ -6503,13 +6200,7 @@ function resolveSpawnPaths(project, type, minionsDir, options) {
 // (project.localPath for read-only / live; worktree root for mutating).
 // When set, the engine lands the agent at <base>/<workdir> so monorepo
 // subpackage dispatches can use the runtime CLI's native cwd-rooted skill
-// discovery (`<workdir>/.claude/skills/<name>/SKILL.md`) without engine
-// awareness of which package is which. Cross-package skill aggregation is
-// explicitly out of scope (per PRD open_question) — when workdir is set,
-// the harness propagation block in engine.js also CLIPS its candidate
-// `--project-harness-dir` set to dirs that live under the workdir mirror
-// in `project.localPath`, so a `packages/foo` dispatch never sees
-// `packages/bar/.claude/skills/...`.
+// discovery without engine awareness of which package is which.
 //
 // Three pure helpers, all unit-tested in test/unit/work-item-workdir.test.js:
 //
@@ -6530,13 +6221,6 @@ function resolveSpawnPaths(project, type, minionsDir, options) {
 //      already rejects bare `..` / absolute strings). `base` MUST be
 //      absolute. Empty/null workdir returns the base unchanged.
 //
-//   3. filterProjectHarnessDirsForWorkdir(dirs, opts) — clips the
-//      candidate `--project-harness-dir` set to entries under the resolved
-//      cwd anchor in `project.localPath`, excluding entries under the
-//      worktree mirror (already discoverable via the agent's cwd). When
-//      `workdir` is null/empty the behavior matches P-08b62d49 unchanged
-//      (filter to project.localPath, exclude worktree).
-//
 // The private `_applyWorkdirOrThrow(base, workdir)` is the throw-on-error
 // adapter used inside resolveSpawnPaths so live/read-only callers don't
 // need to forward the `error` field.
@@ -6622,48 +6306,6 @@ function applyWorkdir(base, workdir) {
   return { cwd: joined };
 }
 
-function filterProjectHarnessDirsForWorkdir(dirs, opts) {
-  if (!Array.isArray(dirs) || dirs.length === 0) return [];
-  const projectLocalPath = opts && opts.projectLocalPath;
-  const worktreePath = opts && opts.worktreePath;
-  const workdir = opts && opts.workdir;
-  if (!projectLocalPath || !worktreePath) return [];
-
-  const projectLocalAbs = path.resolve(String(projectLocalPath));
-  const worktreeAbs = path.resolve(String(worktreePath));
-
-  // When workdir is set, the harness propagation anchors shift to the
-  // subpath mirror in BOTH the project root and the worktree root, so a
-  // `packages/foo` dispatch only sees `<projectLocal>/packages/foo/...`
-  // harness dirs (its actual cwd in the operator's main checkout) and
-  // excludes `<worktree>/packages/foo/...` (already discoverable via cwd).
-  let projectAnchor = projectLocalAbs;
-  let worktreeAnchor = worktreeAbs;
-  if (workdir && typeof workdir === 'string' && workdir) {
-    const pr = applyWorkdir(projectLocalAbs, workdir);
-    const wr = applyWorkdir(worktreeAbs, workdir);
-    // If either join fails containment, drop everything — better empty than wrong.
-    if (pr.error || wr.error) return [];
-    projectAnchor = pr.cwd;
-    worktreeAnchor = wr.cwd;
-  }
-
-  const seen = new Set();
-  const out = [];
-  for (const dir of dirs) {
-    if (typeof dir !== 'string' || !dir) continue;
-    const abs = path.resolve(dir);
-    if (seen.has(abs)) continue;
-    seen.add(abs);
-    const insideProject = abs === projectAnchor || abs.startsWith(projectAnchor + path.sep);
-    if (!insideProject) continue;
-    const insideWorktree = abs === worktreeAnchor || abs.startsWith(worktreeAnchor + path.sep);
-    if (insideWorktree) continue;
-    out.push(abs);
-  }
-  return out;
-}
-
 // ── HTTP Origin Allowlist & Security Headers ─────────────────────────────────
 // Pure helpers used by dashboard.js to gate mutating requests against an
 // explicit allowlist of local origins and to attach uniform security response
@@ -7710,18 +7352,12 @@ function getPrLinks() {
       mergePrLinkItems(links, pr.id, pr.prdItems || []);
     }
   } catch { /* SQL unavailable — skip primary source */ }
-  // Fallback: pr_links SQL store (was static pr-links.json file). Phase 9.1
-  // routes both reads and writes through small-state-store; the JSON file is
-  // kept as a dual-write mirror. SQL failures fall through to the JSON file.
+  // Static PR links are stored in SQLite.
   let static_ = null;
   try {
     const store = require('./small-state-store');
     static_ = store.readPrLinks();
   } catch { static_ = null; }
-  if (!static_ || Object.keys(static_).length === 0) {
-    try { static_ = JSON.parse(fs.readFileSync(PR_LINKS_PATH, 'utf8')); }
-    catch { static_ = null; }
-  }
   if (static_ && typeof static_ === 'object' && !Array.isArray(static_)) {
     for (const [k, v] of Object.entries(static_)) {
       const canonical = parseCanonicalPrId(k);
@@ -7920,6 +7556,32 @@ function _clearPrTombstonesForIdentity(identity) {
   return cleared;
 }
 
+/**
+ * W-mrezh0yb0007f733 — decide whether a poll should adopt the platform's real
+ * PR creation timestamp over the currently-stored `created` value. The platform
+ * (GitHub `created_at` / ADO `creationDate`) is the source of truth for when a
+ * PR was opened; the stored value may be missing, a legacy date-only stamp, or
+ * a link/attach-time `now()` default (the bug this fixes). Returns true when the
+ * stored value should be replaced.
+ *
+ * Rules (fail-safe — never trades a real timestamp for a worse one):
+ *   - platform absent/unparseable → false (keep whatever we have).
+ *   - stored absent/empty → true (nothing to lose; backfill).
+ *   - stored unparseable → true (replace garbage with the real instant).
+ *   - both parse → replace only when they denote a DIFFERENT instant, so two
+ *     equivalent representations (e.g. `…T00:00:00Z` vs `…T00:00:00.000Z`) don't
+ *     churn a rewrite every poll.
+ */
+function shouldAdoptPlatformCreated(storedCreated, platformCreated) {
+  if (!platformCreated) return false;
+  const p = Date.parse(platformCreated);
+  if (!Number.isFinite(p)) return false;
+  if (!storedCreated) return true;
+  const s = Date.parse(storedCreated);
+  if (!Number.isFinite(s)) return true;
+  return s !== p;
+}
+
 /**
  * Canonical PR-producing work contract helper.
  *
@@ -8238,19 +7900,10 @@ function mutateWorkItems(filePath, mutator) {
   if (insideMinionsDir) {
     const store = require('./work-items-store');
     const scope = store.scopeForFilePath(filePath);
-    // W-mr9vcxvy000cdb4e — the JSON mirror is now written INSIDE
-    // applyWorkItemsMutation's SQL transaction (before commit), not here
-    // after the fact. Mirroring post-commit left a cross-process window
-    // where a sibling process (dashboard vs. engine — separate Node
-    // processes, each with its own in-memory mirror-hash cache) could
-    // observe the new SQL row before the JSON file caught up and
-    // destructively rehydrate the scope from that stale file, dropping
-    // the just-created row (the "phantom work item" dispatch race). See
-    // work-items-store.js#applyWorkItemsMutation for the full rationale.
     const { wrote, result } = store.applyWorkItemsMutation(scope, (items) => {
       if (!Array.isArray(items)) items = [];
       return mutator(items) || items;
-    }, { mirrorPath: filePath });
+    });
     if (wrote) {
       try { require('./db-events').emitStateEvent('work_items'); } catch { /* optional */ }
       try { require('./queries').invalidateWorkItemsCache(); } catch { /* queries not loaded */ }
@@ -8302,20 +7955,10 @@ function mutatePullRequests(filePath, mutator) {
   if (insideMinionsDir) {
     const store = require('./pull-requests-store');
     const scope = store.scopeForFilePath(filePath);
-    // W-mrcg7j9k000ja233 (#759) — the JSON mirror is now written INSIDE
-    // applyPullRequestsMutation's SQL transaction (before commit), not here
-    // after the fact. Mirroring post-commit left a cross-process window
-    // where a sibling process (dashboard vs. engine — separate Node
-    // processes) could observe the new SQL row before the JSON file caught
-    // up and destructively rehydrate the scope from that stale file,
-    // dropping the just-written row. See
-    // pull-requests-store.js#applyPullRequestsMutation for the full
-    // rationale (mirrors the identical work-items-store.js fix,
-    // W-mr9vcxvy000cdb4e).
     const { wrote, result } = store.applyPullRequestsMutation(scope, (prs) => {
       if (!Array.isArray(prs)) prs = [];
       return mutator(prs) || prs;
-    }, { mirrorPath: filePath });
+    });
     if (wrote) {
       try { require('./db-events').emitStateEvent('pull_requests'); } catch { /* optional */ }
     }
@@ -9341,7 +8984,6 @@ module.exports = {
   resolveAgentCli, resolveCcCli, resolveCcUseWorkerPool, resolveAgentModel, resolveCcModel,
   resolveAgentMaxBudget, resolveAgentBareMode,
   resolveCopilotAgentDisabledMcpServers,
-  resolveAgentHermeticHarness,
   applyLegacyCcModelMigration, _resetLegacyCcModelMigrationFlag,
   runtimeConfigWarnings,
   projectWorkSourceWarnings,
@@ -9351,7 +8993,6 @@ module.exports = {
   WATCH_STALLED_DEFAULT_TICKS, WATCH_STUCK_STAGE_DEFAULT_TICKS,
   PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, AGENT_STATUS,
   FAILURE_CLASS, COMPLETION_FIELDS,
-  HARNESS_USED_KINDS, HARNESS_USED_MAX_ENTRIES, HARNESS_USED_MAX_FIELD_LEN, normalizeHarnessUsed, groundHarnessUsed,
   DEFAULT_AGENT_METRICS,
   DEFAULT_AGENTS,
   DEFAULT_CLAUDE,
@@ -9419,6 +9060,7 @@ module.exports = {
   normalizePrLinkItems, // exported for testing
   mergePrLinkItems, // exported for testing
   isContextOnlyPrRecord,
+  shouldAdoptPlatformCreated, // W-mrezh0yb0007f733 — platform creationDate authority
   upsertPullRequestRecord,
   collapseDuplicatePrRecords, // P-e9f0a2b4 — one-time repair helper
   isAutoManagedPrRecord, // W-mq5s5ttx000j7ab8-a — exported for engine + watch-plugin gate consolidation
@@ -9453,7 +9095,6 @@ module.exports = {
   resolveSpawnPaths,
   validateWorkItemWorkdir,
   applyWorkdir,
-  filterProjectHarnessDirsForWorkdir,
   READ_ONLY_ROOT_TASK_TYPES,
   isLiveCommandCenterPath,
   describeCcProtectedPaths,