@yemi33/minions 0.1.2369 → 0.1.2371

package/engine/prd-store.js

@@ -1,17 +1,9 @@
 // engine/prd-store.js
 //
-// Phase 10 step 2: SQL mirror for PRD state. PRD content writes go to the
-// canonical prd/*.json file AND are mirrored into the plans/prds/prd_items/
-// prd_verify_prs tables created by migration 015. JSON stays canonical and is
-// still the only thing read in this step — the SQL side is a passive mirror so
-// the read-flip (step 3) has a trustworthy source.
-//
-// All entry points are BEST-EFFORT: a SQLite failure (Node < 22.5, locked DB,
-// schema not yet migrated) must never break a PRD JSON write. Callers wrap via
-// the thin `mirror*`/`remove*` helpers which swallow and return {ok:false}.
+// SQL-authoritative PRD state. Paths are retained as stable identifiers for
+// existing callers, but no runtime PRD JSON is read or written here.
 
 const path = require('path');
-const fs = require('fs');
 
 function _toMs(v) {
   if (v == null) return null;
@@ -75,7 +67,7 @@ function _upsertPrd(db, filename, archived, prd, now) {
       JSON.stringify(prd), now, prdId,
     );
     // NOTE: prd_items are NOT bulk-deleted here — they are upserted by their
-    // stable (prd_id, feature_id) key below so prd_items.id survives a re-mirror
+    // stable (prd_id, feature_id) key below so prd_items.id survives an update
     // (work_items.prd_item_id is an FK to it). prd_verify_prs carries no FK, so
     // a cheap delete+reinsert is fine.
     db.prepare('DELETE FROM prd_verify_prs WHERE prd_id=?').run(prdId);
@@ -96,8 +88,8 @@ function _upsertPrd(db, filename, archived, prd, now) {
 
   // Upsert prd_items by their STABLE natural key (prd_id, feature_id) instead of
   // delete-all-then-reinsert, so the surrogate prd_items.id is durable across
-  // re-mirrors. work_items.prd_item_id is an FK to this id; churning it (via
-  // AUTOINCREMENT on every mirror) dangled every stamped row — the Phase-10
+  // updates. work_items.prd_item_id is an FK to this id; churning it (via
+  // AUTOINCREMENT on every write) dangled every stamped row — the Phase-10
   // step-4 join-flip blocker. feature_id-less legacy items can't be keyed (NULL
   // != NULL under UNIQUE), so they are swept + reinserted each time; they are
   // never FK targets, so their churn is harmless.
@@ -128,15 +120,19 @@ function _upsertPrd(db, filename, archived, prd, now) {
   `);
   const selItemId = db.prepare('SELECT id FROM prd_items WHERE prd_id=? AND feature_id=?');
   // Stamp the materialized work item(s) → prd_items.id. The two backref paths
-  // mirror the migration-015 backfill: an explicit feature.workItemId (set by
+  // match the migration-015 backfill: an explicit feature.workItemId (set by
   // lifecycle.stampPrdItemWorkItemId), and the sourcePlan(=PRD filename) +
-  // feature-id equality the legacy JSON model joined on. Self-heals on every
-  // mirror, so a WI materialized after this PRD was first seen still gets its FK.
+  // feature-id equality the legacy model joined on. Every update self-heals a
+  // WI materialized after the PRD was first written.
+  // Live PRDs take precedence over same-basename archived rows. Archived
+  // imports may fill an empty FK but must never steal one already stamped by
+  // the live PRD.
+  const fkPredicate = archived ? 'prd_item_id IS NULL' : '(prd_item_id IS NULL OR prd_item_id<>?)';
   const stampWiById = db.prepare(
-    'UPDATE work_items SET prd_item_id=? WHERE id=? AND (prd_item_id IS NULL OR prd_item_id<>?)'
+    `UPDATE work_items SET prd_item_id=? WHERE id=? AND ${fkPredicate}`
   );
   const stampWiBySourcePlan = db.prepare(
-    `UPDATE work_items SET prd_item_id=? WHERE json_extract(data,'$.sourcePlan')=? AND json_extract(data,'$.id')=? AND (prd_item_id IS NULL OR prd_item_id<>?)`
+    `UPDATE work_items SET prd_item_id=? WHERE json_extract(data,'$.sourcePlan')=? AND json_extract(data,'$.id')=? AND ${fkPredicate}`
   );
   for (const ft of features) {
     if (!ft || typeof ft !== 'object') continue;
@@ -158,9 +154,15 @@ function _upsertPrd(db, filename, archived, prd, now) {
     try { prdItemId = selItemId.get(prdId, featureId)?.id; } catch { /* ignore */ }
     if (!prdItemId) continue;
     if (explicitWi) {
-      try { stampWiById.run(prdItemId, String(explicitWi), prdItemId); } catch { /* best-effort */ }
+      try {
+        if (archived) stampWiById.run(prdItemId, String(explicitWi));
+        else stampWiById.run(prdItemId, String(explicitWi), prdItemId);
+      } catch { /* best-effort */ }
     }
-    try { stampWiBySourcePlan.run(prdItemId, filename, featureId, prdItemId); } catch { /* best-effort */ }
+    try {
+      if (archived) stampWiBySourcePlan.run(prdItemId, filename, featureId);
+      else stampWiBySourcePlan.run(prdItemId, filename, featureId, prdItemId);
+    } catch { /* best-effort */ }
   }
 
   const insVp = db.prepare(`
@@ -179,127 +181,101 @@ function _upsertPrd(db, filename, archived, prd, now) {
   return prdId;
 }
 
-// Mirror a PRD object to SQL for the given prd/*.json path. Best-effort.
-function mirrorPrdToSql(filePath, prd) {
+function writePrd(filePath, prd) {
   const parsed = parsePrdPath(filePath);
-  if (!parsed || !prd || typeof prd !== 'object' || Array.isArray(prd)) return { ok: false, reason: 'not-a-prd' };
-  try {
-    const { getDb, withTransaction } = require('./db');
-    const db = getDb();
-    withTransaction(db, () => _upsertPrd(db, parsed.filename, parsed.archived, prd, Date.now()));
-    try { require('./db-events').emitStateEvent('prds', { filename: parsed.filename, archived: parsed.archived }); } catch { /* event optional */ }
-    return { ok: true };
-  } catch (e) {
-    return { ok: false, reason: e && e.message };
+  if (!parsed || !prd || typeof prd !== 'object' || Array.isArray(prd)) {
+    throw new TypeError('prd-store.writePrd requires a PRD path and object');
   }
+  const { getDb, withTransaction } = require('./db');
+  const db = getDb();
+  const prdId = withTransaction(db, () => _upsertPrd(db, parsed.filename, parsed.archived, prd, Date.now()));
+  require('./db-events').emitStateEvent('prds', { filename: parsed.filename, archived: parsed.archived });
+  return { ok: true, id: prdId, plan: prd };
 }
 
-// Remove a PRD (and its items/verify rows) from SQL for the given path. Best-effort.
-function removePrdFromSql(filePath) {
+function mutatePrd(filePath, mutator, { defaultValue = {} } = {}) {
   const parsed = parsePrdPath(filePath);
-  if (!parsed) return { ok: false, reason: 'not-a-prd' };
-  try {
-    const { getDb, withTransaction } = require('./db');
-    const db = getDb();
-    withTransaction(db, () => {
-      const row = db.prepare('SELECT id FROM prds WHERE filename=? AND archived=?').get(parsed.filename, parsed.archived);
-      if (!row) return;
-      db.prepare('DELETE FROM prd_items WHERE prd_id=?').run(row.id);
-      db.prepare('DELETE FROM prd_verify_prs WHERE prd_id=?').run(row.id);
-      db.prepare('DELETE FROM prds WHERE id=?').run(row.id);
-    });
-    try { require('./db-events').emitStateEvent('prds', { filename: parsed.filename, archived: parsed.archived, removed: true }); } catch { /* optional */ }
-    return { ok: true };
-  } catch (e) {
-    return { ok: false, reason: e && e.message };
+  if (!parsed || typeof mutator !== 'function') {
+    throw new TypeError('prd-store.mutatePrd requires a PRD path and mutator');
   }
+  const { getDb, withTransaction } = require('./db');
+  const db = getDb();
+  const result = withTransaction(db, () => {
+    const row = db.prepare('SELECT data FROM prds WHERE filename=? AND archived=?').get(parsed.filename, parsed.archived);
+    let current = row ? JSON.parse(row.data) : structuredClone(defaultValue);
+    if (!current || typeof current !== 'object' || Array.isArray(current)) current = structuredClone(defaultValue);
+    const next = mutator(current);
+    const finalData = next === undefined ? current : next;
+    if (!finalData || typeof finalData !== 'object' || Array.isArray(finalData)) {
+      throw new TypeError('PRD mutator must return an object or mutate in place');
+    }
+    _upsertPrd(db, parsed.filename, parsed.archived, finalData, Date.now());
+    return finalData;
+  });
+  require('./db-events').emitStateEvent('prds', { filename: parsed.filename, archived: parsed.archived });
+  return result;
 }
 
-// Read one PRD back from SQL as the original object (the `data` blob). Used by
-// the divergence test now and the read-flip in step 3.
-function readPrdFromSql(filePath) {
+function deletePrd(filePath) {
   const parsed = parsePrdPath(filePath);
-  if (!parsed) return null;
-  try {
-    const { getDb } = require('./db');
-    const row = getDb().prepare('SELECT data FROM prds WHERE filename=? AND archived=?').get(parsed.filename, parsed.archived);
-    return row ? JSON.parse(row.data) : null;
-  } catch { return null; }
+  if (!parsed) throw new TypeError('prd-store.deletePrd requires a PRD path');
+  const { getDb, withTransaction } = require('./db');
+  const db = getDb();
+  const removed = withTransaction(db, () => {
+    const row = db.prepare('SELECT id FROM prds WHERE filename=? AND archived=?').get(parsed.filename, parsed.archived);
+    if (!row) return false;
+    db.prepare('DELETE FROM prd_items WHERE prd_id=?').run(row.id);
+    db.prepare('DELETE FROM prd_verify_prs WHERE prd_id=?').run(row.id);
+    db.prepare('DELETE FROM prds WHERE id=?').run(row.id);
+    return true;
+  });
+  if (removed) require('./db-events').emitStateEvent('prds', { filename: parsed.filename, archived: parsed.archived, removed: true });
+  return removed;
 }
 
-// Per-process mtime cache so reconciliation re-mirrors only files that actually
-// changed on disk since this process last saw them (empty after restart → the
-// first read re-mirrors everything once). Keyed `${archived} ${filename}`.
-const _reconcileMtimes = new Map();
-
-function _prdDirsFor(minionsDir) {
-  return [
-    { dir: path.join(minionsDir, 'prd'), archived: 0 },
-    { dir: path.join(minionsDir, 'prd', 'archive'), archived: 1 },
-  ];
+function readPrd(filePath) {
+  const parsed = parsePrdPath(filePath);
+  if (!parsed) return null;
+  const row = require('./db').getDb()
+    .prepare('SELECT data FROM prds WHERE filename=? AND archived=?')
+    .get(parsed.filename, parsed.archived);
+  return row ? JSON.parse(row.data) : null;
 }
 
-// Reconcile the SQL mirror from the prd/ + prd/archive/ directories: re-mirror
-// files that are new or changed on disk (catches PRDs written OUTSIDE the
-// mutateJsonFileLocked chokepoint — e.g. the plan-to-prd agent writing the JSON
-// directly, or an archive file-move), and drop SQL rows whose backing file is
-// gone. Best-effort; safe to call on every read. Returns a small stats object.
-function reconcilePrdsFromDisk() {
-  let minionsDir;
-  try { minionsDir = require('./shared').MINIONS_DIR; } catch { return { ok: false }; }
-  if (!minionsDir) return { ok: false };
-  let db;
-  try { db = require('./db').getDb(); } catch { return { ok: false }; }
-
-  let mirrored = 0, removed = 0;
-  const seen = new Set(); // `${archived} ${filename}` present on disk
-  for (const { dir, archived } of _prdDirsFor(minionsDir)) {
-    let files;
-    try { files = fs.readdirSync(dir).filter(f => f.endsWith('.json')); } catch { continue; }
-    for (const f of files) {
-      const key = `${archived} ${f}`;
-      seen.add(key);
-      const full = path.join(dir, f);
-      let mtime;
-      try { mtime = Math.round(fs.statSync(full).mtimeMs); } catch { continue; }
-      if (_reconcileMtimes.get(key) === mtime) continue; // unchanged since last seen
-      const prd = require('./shared').safeJsonNoRestore(full);
-      if (!prd) continue;
-      try {
-        const { withTransaction } = require('./db');
-        withTransaction(db, () => _upsertPrd(db, f, archived, prd, Date.now()));
-        _reconcileMtimes.set(key, mtime);
-        mirrored += 1;
-      } catch { /* best-effort */ }
-    }
+// Atomically restore a legacy physically-archived PRD (archived=1 row) into
+// the live bucket (archived=0). Unlike a caller doing readPrd(archivePath)
+// then writePrd(livePath, snapshot), the archived row's data is read FRESH
+// inside the SAME transaction that upserts the live row and deletes the
+// archived one — so a concurrent engine write to the archived row (e.g.
+// lifecycle updating completion/verify state between an operator's unarchive
+// request and this write) can never be silently clobbered by a stale
+// in-memory snapshot (W-mrenu075000a94c9). Returns the restored PRD data, or
+// null if no archived row exists for `filename`.
+function restorePrdFromArchive(filename) {
+  if (!filename || typeof filename !== 'string') {
+    throw new TypeError('prd-store.restorePrdFromArchive requires a filename');
   }
-  // Drop rows whose backing file disappeared (delete/move not caught by a hook).
-  try {
-    const rows = db.prepare('SELECT id, filename, archived FROM prds').all();
-    for (const r of rows) {
-      const key = `${r.archived} ${r.filename}`;
-      if (seen.has(key)) continue;
-      try {
-        require('./db').withTransaction(db, () => {
-          db.prepare('DELETE FROM prd_items WHERE prd_id=?').run(r.id);
-          db.prepare('DELETE FROM prd_verify_prs WHERE prd_id=?').run(r.id);
-          db.prepare('DELETE FROM prds WHERE id=?').run(r.id);
-        });
-        _reconcileMtimes.delete(key);
-        removed += 1;
-      } catch { /* best-effort */ }
-    }
-  } catch { /* best-effort */ }
-  return { ok: true, mirrored, removed };
+  const { getDb, withTransaction } = require('./db');
+  const db = getDb();
+  const restored = withTransaction(db, () => {
+    const row = db.prepare('SELECT id, data FROM prds WHERE filename=? AND archived=1').get(filename);
+    if (!row) return null;
+    const prd = JSON.parse(row.data);
+    _upsertPrd(db, filename, 0, prd, Date.now());
+    db.prepare('DELETE FROM prd_items WHERE prd_id=?').run(row.id);
+    db.prepare('DELETE FROM prd_verify_prs WHERE prd_id=?').run(row.id);
+    db.prepare('DELETE FROM prds WHERE id=?').run(row.id);
+    return prd;
+  });
+  if (restored) {
+    require('./db-events').emitStateEvent('prds', { filename, archived: 0, restored: true });
+  }
+  return restored;
 }
 
-// Idempotent boot sweep: populate work_items.prd_item_id for rows that predate
-// the dual-write stamp (everything materialized before #546), or that a JSON
-// re-hydrate transiently zeroed. The per-mirror stamp in _upsertPrd only fires
-// for PRDs that are re-mirrored, and reconcile is mtime-gated — so a PRD that
-// never changes again never re-stamps its historical WIs. This catch-up is
-// set-based (two SQL UPDATEs, no per-row loop), only touches NULL FKs, and
-// prefers the live (archived=0) prd_item when a basename exists in both buckets.
+// Idempotent boot sweep for work items that predate PRD FK stamping.
+// This is set-based, only touches NULL FKs, and prefers live PRDs when a
+// basename exists in both live and archived buckets.
 // Safe to run on every boot — a no-op once every matchable WI is linked.
 // Returns { ok, byWorkItemId, bySourcePlan } counts.
 function backfillWorkItemPrdItemIds() {
@@ -344,27 +320,25 @@ function backfillWorkItemPrdItemIds() {
 // data blob. Sorted by (archived, filename) for deterministic consumer order
 // (matches the disk-scan order once the caller also sorts). Read-flip source.
 function listPrdRows() {
-  try {
-    const db = require('./db').getDb();
-    const rows = db.prepare('SELECT filename, archived, data FROM prds ORDER BY archived, filename').all();
-    const out = [];
-    for (const r of rows) {
-      let plan;
-      try { plan = JSON.parse(r.data); } catch { continue; }
-      out.push({ filename: r.filename, archived: !!r.archived, plan });
-    }
-    return out;
-  } catch { return []; }
+  const db = require('./db').getDb();
+  const rows = db.prepare('SELECT filename, archived, data, updated_at FROM prds ORDER BY archived, filename').all();
+  const out = [];
+  for (const r of rows) {
+    let plan;
+    try { plan = JSON.parse(r.data); } catch { continue; }
+    out.push({ filename: r.filename, archived: !!r.archived, plan, updatedAt: Number(r.updated_at) || 0 });
+  }
+  return out;
 }
 
 module.exports = {
   parsePrdPath,
-  mirrorPrdToSql,
-  removePrdFromSql,
-  readPrdFromSql,
-  reconcilePrdsFromDisk,
+  writePrd,
+  mutatePrd,
+  deletePrd,
+  readPrd,
+  restorePrdFromArchive,
   backfillWorkItemPrdItemIds,
   listPrdRows,
-  _reconcileMtimes, // exported for tests (reset between cases)
   _upsertPrd, // exported for tests
 };

package/engine/preflight.js

@@ -343,7 +343,6 @@ const _FEATURE_FLAG_DEFAULTS = {
   claudeBareMode: false,
   claudeFallbackModel: undefined,
   copilotDisableBuiltinMcps: true,
-  copilotSuppressAgentsMd: true,
   copilotStreamMode: 'on',
   copilotReasoningSummaries: false,
   maxBudgetUsd: undefined,
@@ -716,23 +715,10 @@ function doctor(minionsHome) {
 }
 
 /**
- * Harness propagation diagnostic for `minions doctor --harness` (plan item #1
- * of `seamless-user-repo-harness-invocation`, PRD `P-a3f9b2c1`). Iterates
- * every registered runtime and prints every dir / file the engine would
- * surface to a spawned agent today, grouped by scope label
- * (`user` / `project:<name>` / `personal` / `minions`). Missing on-disk paths
- * are flagged with `⚠` but do not fail the command — they're listed so the
- * operator can decide whether to create / populate the dir or leave it as-is
- * for this host.
+ * Read-only inventory for `minions doctor --harness`.
  *
- * The diagnostic is intentionally read-only and side-effect-free: no mutation
- * of config, cache files, or worktrees. Exits non-zero only on a true
- * runtime/config error (e.g. registry refuses to resolve a registered
- * runtime). See `docs/harness-propagation.md` for the full contract.
- *
- * Pure-ish: `homeDir` and `existsFn` are injectable for tests so a temp
- * sandbox can assert the "missing path" branch without touching the real
- * `~/.claude` / `~/.copilot` dirs.
+ * Reports native locations declared by each adapter without changing runtime
+ * discovery. Missing paths are warnings; runtime/config errors fail the command.
  */
 function _resolveProjectsForHarness(minionsHome) {
   const configPath = path.join(minionsHome, 'config.json');
@@ -867,21 +853,6 @@ function _runtimeHarnessRows(runtime, { homeDir, projects, existsFn }) {
   return rows;
 }
 
-function _computeAddDirSnapshot(runtime, { minionsHome, homeDir, existsFn }) {
-  let computeAddDirs;
-  try { ({ computeAddDirs } = require('./spawn-agent')); }
-  catch { return null; }
-  if (typeof computeAddDirs !== 'function') return null;
-  let dirs = [];
-  try { dirs = computeAddDirs({ runtime, minionsDir: minionsHome, homeDir, exists: existsFn }) || []; }
-  catch { return null; }
-  return dirs.map(d => {
-    let scope = 'user';
-    if (path.resolve(d) === path.resolve(minionsHome)) scope = 'minions';
-    return { path: d, scope, exists: existsFn(d) };
-  });
-}
-
 function runHarnessDoctor(minionsHome, opts = {}) {
   const homeDir = opts.homeDir || os.homedir();
   const existsFn = opts.existsFn || fs.existsSync;
@@ -890,15 +861,14 @@ function runHarnessDoctor(minionsHome, opts = {}) {
   let registry;
   try { registry = require('./runtimes'); }
   catch (e) {
-    out(`Minions Harness Propagation`);
+    out(`Minions Runtime Harness Inventory`);
     out(`  Could not load runtime registry: ${e.message}`);
     return false;
   }
   const runtimeNames = registry.listRuntimes();
   const { config, projects } = _resolveProjectsForHarness(minionsHome);
-  const defaultCli = (config && config.engine && config.engine.defaultCli) || 'copilot';
-
-  out('Minions Harness Propagation');
+  out('Minions Runtime Harness Inventory');
+  out('  Minions does not propagate these paths; each CLI discovers its native harness from cwd and user config.');
   if (projects.length === 0) {
     out('  (no real projects configured — project-scope rows will be empty)');
   } else {
@@ -918,7 +888,7 @@ function runHarnessDoctor(minionsHome, opts = {}) {
     }
     const rows = _runtimeHarnessRows(runtime, { homeDir, projects, existsFn });
 
-    out('    User asset dirs (--add-dir to agents):');
+    out('    User asset dirs (adapter inventory only):');
     if (rows.userAssetDirs.length === 0) out('      (adapter does not expose getUserAssetDirs)');
     for (const r of rows.userAssetDirs) out(_formatHarnessLine(r.path, r.scope, r.exists));
 
@@ -950,22 +920,6 @@ function runHarnessDoctor(minionsHome, opts = {}) {
     for (const r of rows.mcpConfigProject) out(_formatHarnessLine(r.path, r.scope, r.exists));
   }
 
-  out('');
-  out(`  Worktree --add-dir snapshot (engine fleet default: ${defaultCli}):`);
-  let defaultRuntime = null;
-  try { defaultRuntime = registry.resolveRuntime(defaultCli); }
-  catch { /* preflight handles unknown-runtime errors; here we just skip */ }
-  if (!defaultRuntime) {
-    out('    (cannot resolve fleet-default runtime — see `minions doctor` for details)');
-  } else {
-    const snapshot = _computeAddDirSnapshot(defaultRuntime, { minionsHome, homeDir, existsFn });
-    if (!snapshot || snapshot.length === 0) {
-      out('    (no dirs attached — engine/spawn-agent.js unavailable or adapter has no asset dirs)');
-    } else {
-      for (const r of snapshot) out(_formatHarnessLine(r.path, r.scope, r.exists));
-    }
-  }
-
   out('');
   out('  All harness paths surveyed. Missing on-disk paths are warnings, not failures —');
   out('  they\'re listed so you can decide whether to create the dir, populate it, or');
@@ -991,8 +945,7 @@ module.exports = {
   _fetchCliHelpText,
   _checkBypassFlagSupported,
   _bypassFlagResults,
-  // Exposed for harness-propagation doctor unit tests (P-a3f9b2c1).
+  // Exposed for runtime harness inventory unit tests.
   _runtimeHarnessRows,
-  _computeAddDirSnapshot,
   _formatHarnessLine,
 };

package/engine/projects.js

@@ -100,7 +100,6 @@ function _collectProjectlessCentralDispatchItemIds(removedProject, projects) {
 function _requeueProjectlessCentralWorkItems(itemIds) {
   if (!itemIds || itemIds.size === 0) return 0;
   const wiPath = path.join(MINIONS_DIR, 'work-items.json');
-  if (!fs.existsSync(wiPath)) return 0;
   let requeued = 0;
   shared.mutateWorkItems(wiPath, items => {
     if (!Array.isArray(items)) return items;
@@ -236,16 +235,15 @@ function removeProject(target, options = {}) {
   //    from re-triggering plan completion (mirror of f28162b0 fix).
   const plansDir = path.join(MINIONS_DIR, 'plans');
   const plansArchive = path.join(plansDir, 'archive');
-  const prdDir = path.join(MINIONS_DIR, 'prd');
   const escName = project.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const projectLineRe = new RegExp('^[*_>\\s]{0,4}\\*{0,2}_{0,2}Project:?\\*{0,2}_{0,2}\\s*' + escName + '\\b', 'im');
   const archivedSourcePlans = new Set();
   try {
-    if (fs.existsSync(prdDir)) {
+    {
       const { archivePlan } = require('./lifecycle');
-      for (const f of fs.readdirSync(prdDir).filter(f => f.endsWith('.json'))) {
+      for (const { filename: f, plan: prd, archived } of require('./prd-store').listPrdRows()) {
+        if (archived) continue;
         try {
-          const prd = JSON.parse(fs.readFileSync(path.join(prdDir, f), 'utf8'));
           if (!_projectRefMatches(prd?.project, project, projects)) continue;
           archivePlan(f, prd, [project], config);
           summary.archivedPlans.push('prd/' + f);
@@ -361,49 +359,44 @@ function removeProject(target, options = {}) {
       });
     } catch (e) { summary.warnings.push('orphan-tag dispatch: ' + e.message); }
 
-    // (b) MINIONS_DIR/pull-requests.json — central PR registry. PRs in this
-    //     file lack an explicit project field; match by canonical scope
+    // (b) Central PR registry. PRs in this scope lack an explicit project field; match by canonical scope
     //     (e.g. `github:owner/repo`) against the removed project's PR scope.
     const centralPrPath = shared.centralPullRequestsPath();
-    if (fs.existsSync(centralPrPath)) {
-      try {
-        const projectScope = shared.getProjectPrScope(project);
-        if (projectScope) {
-          shared.mutatePullRequests(centralPrPath, (prs) => {
-            for (const pr of prs) {
-              if (!pr || pr._orphaned_at) continue;
-              const canonical = shared.parseCanonicalPrId(pr.id);
-              if (canonical?.scope !== projectScope) continue;
-              pr._orphaned_at = orphanedAt;
-              pr._orphaned_project = orphanedProject;
-              summary.orphanedRefs.pullRequests++;
-            }
-            return prs;
-          });
-        }
-      } catch (e) { summary.warnings.push('orphan-tag pull-requests: ' + e.message); }
-    }
+    try {
+      const projectScope = shared.getProjectPrScope(project);
+      if (projectScope) {
+        shared.mutatePullRequests(centralPrPath, (prs) => {
+          for (const pr of prs) {
+            if (!pr || pr._orphaned_at) continue;
+            const canonical = shared.parseCanonicalPrId(pr.id);
+            if (canonical?.scope !== projectScope) continue;
+            pr._orphaned_at = orphanedAt;
+            pr._orphaned_project = orphanedProject;
+            summary.orphanedRefs.pullRequests++;
+          }
+          return prs;
+        });
+      }
+    } catch (e) { summary.warnings.push('orphan-tag pull-requests: ' + e.message); }
 
-    // (c) MINIONS_DIR/work-items.json — central WI list. Pending/queued WIs
+    // (c) Central WI scope. Pending/queued WIs
     //     were already CANCELLED by cancelPendingWorkItems in step 1; tag
     //     the remaining matchers (dispatched / done / failed / etc.) so
     //     downstream consumers can filter them.
     const centralWiPath = path.join(MINIONS_DIR, 'work-items.json');
-    if (fs.existsSync(centralWiPath)) {
-      try {
-        shared.mutateWorkItems(centralWiPath, (items) => {
-          for (const w of items) {
-            if (!w || w._orphaned_at) continue;
-            if (w.status === shared.WI_STATUS.CANCELLED) continue;
-            if (!_workItemMatchesProject(w, project, projects)) continue;
-            w._orphaned_at = orphanedAt;
-            w._orphaned_project = orphanedProject;
-            summary.orphanedRefs.workItems++;
-          }
-          return items;
-        });
-      } catch (e) { summary.warnings.push('orphan-tag work-items: ' + e.message); }
-    }
+    try {
+      shared.mutateWorkItems(centralWiPath, (items) => {
+        for (const w of items) {
+          if (!w || w._orphaned_at) continue;
+          if (w.status === shared.WI_STATUS.CANCELLED) continue;
+          if (!_workItemMatchesProject(w, project, projects)) continue;
+          w._orphaned_at = orphanedAt;
+          w._orphaned_project = orphanedProject;
+          summary.orphanedRefs.workItems++;
+        }
+        return items;
+      });
+    } catch (e) { summary.warnings.push('orphan-tag work-items: ' + e.message); }
   } catch (e) { summary.warnings.push('orphan-sweep: ' + e.message); }
 
   // 8. Move (or purge) projects/<name>/ — preserves PR/work-item history by