@yemi33/minions 0.1.2370 → 0.1.2372

package/engine/spawn-agent.js

@@ -22,7 +22,6 @@
  *   --verbose / --no-verbose    → opts.verbose
  *   --stream <on|off>           → opts.stream                (Copilot)
  *   --disable-builtin-mcps      → opts.disableBuiltinMcps    (Copilot)
- *   --no-custom-instructions    → opts.suppressAgentsMd      (Copilot)
  *   --enable-reasoning-summaries→ opts.reasoningSummaries    (Copilot)
  *
  * Legacy --permission-mode <X> is dropped: the new Claude adapter emits
@@ -55,15 +54,6 @@ function parseSpawnArgs(argv) {
   let runtimeName = 'claude';
   const opts = {};
   const passthrough = [];
-  // P-08b62d49 — accumulating array of project-local-on-main harness dirs that
-  // engine.js wants `computeAddDirs` to surface as additional `--add-dir`
-  // entries. Multiple `--project-harness-dir <path>` flags accumulate in
-  // declaration order; the dedup/exists filter happens inside `computeAddDirs`.
-  const projectHarnessDirs = [];
-  // P-49e1c8b7 — hermetic harness opt-out (boolean). Set by engine.js when
-  // shared.resolveAgentHermeticHarness(agent, engine) is true; propagates to
-  // computeAddDirs which then returns [minionsDir] only.
-  let hermetic = false;
 
   for (let i = 2; i < args.length; i++) {
     const a = args[i];
@@ -105,7 +95,7 @@ function parseSpawnArgs(argv) {
     }
   }
 
-  return { promptFile, sysPromptFile, runtimeName, opts, passthrough, projectHarnessDirs, hermetic };
+  return { promptFile, sysPromptFile, runtimeName, opts, passthrough };
 }
 
 /**
@@ -121,9 +111,8 @@ function parseSpawnArgs(argv) {
  *     usingNodeShim,                  // true → runtime returned a non-native binary (Claude cli.js)
  *   }
  */
-function buildSpawnInvocation({ runtime, resolved, promptText, sysPromptText, opts, passthrough, addDirs }) {
+function buildSpawnInvocation({ runtime, resolved, promptText, sysPromptText, opts, passthrough }) {
   const adapterOpts = { ...opts };
-  if (Array.isArray(addDirs) && addDirs.length) adapterOpts.addDirs = addDirs;
   const finalPrompt = runtime.buildPrompt(promptText, sysPromptText, adapterOpts);
   const deliveryMode = typeof runtime.getPromptDeliveryMode === 'function'
     ? runtime.getPromptDeliveryMode(adapterOpts)
@@ -317,67 +306,6 @@ function createParentPipeForwarder(stream, outputPath, prefix = '') {
   };
 }
 
-/**
- * Build the `--add-dir` list passed to the runtime CLI. Pure: takes
- * `{ runtime, minionsDir, homeDir, projectHarnessDirs, hermetic, exists }`
- * and returns an ordered, deduped array of dirs the agent should be able to
- * read from outside its worktree.
- *
- * Order:
- *   1. minionsDir (always first, so playbooks/system-prompt are reachable).
- *   2. Every existing dir from `runtime.getUserAssetDirs({ homeDir })` —
- *      user-scope skill/command/MCP roots (`~/.claude`, `~/.copilot`,
- *      `~/.agents`, …) so worktree-bound agents inherit user-installed
- *      harnesses.
- *   3. P-08b62d49 — Every existing dir in `projectHarnessDirs` (engine.js
- *      passes the union of `queries.getProjectHarnesses(project).{skills,
- *      commands}` dirs that live in `project.localPath` but NOT under the
- *      worktree, so uncommitted `<repo>/.claude/skills/…` etc. on the main
- *      checkout are reachable from worktree dispatches). See
- *      `docs/harness-propagation.md` → "The worktree-uncommitted footgun".
- *
- * Non-existent dirs are dropped at every layer — Claude CLI rejects unknown
- * `--add-dir` entries. The dedup compares resolved paths so we never emit a
- * dir twice (e.g. when a runtime asset dir IS the minions repo in unusual
- * setups, or when a project-harness dir duplicates a user-asset dir).
- *
- * P-49e1c8b7 — When `hermetic === true`, the result is exactly `[minionsDir]`:
- * both the runtime adapter's user-asset dirs AND `projectHarnessDirs` are
- * dropped so the spawned agent runs with a known-empty harness surface.
- * Engine.js sets this via `shared.resolveAgentHermeticHarness(agent, engine)`
- * and forwards `--hermetic-harness` to spawn-agent so the flag survives the
- * subprocess hop.
- *
- * `exists` is injectable for tests; defaults to `fs.existsSync`.
- */
-function computeAddDirs({ runtime, minionsDir, homeDir, projectHarnessDirs, hermetic, exists = fs.existsSync } = {}) {
-  if (hermetic) return [minionsDir];
-  const out = [minionsDir];
-  const seen = new Set([path.resolve(minionsDir)]);
-  const assetDirs = typeof runtime?.getUserAssetDirs === 'function'
-    ? runtime.getUserAssetDirs({ homeDir })
-    : [];
-  for (const d of assetDirs) {
-    if (!d) continue;
-    const resolved = path.resolve(d);
-    if (seen.has(resolved)) continue;
-    if (!exists(d)) continue;
-    out.push(d);
-    seen.add(resolved);
-  }
-  if (Array.isArray(projectHarnessDirs)) {
-    for (const d of projectHarnessDirs) {
-      if (!d) continue;
-      const resolved = path.resolve(d);
-      if (seen.has(resolved)) continue;
-      if (!exists(d)) continue;
-      out.push(d);
-      seen.add(resolved);
-    }
-  }
-  return out;
-}
-
 /**
  * P-7d31a06b — Pre-approve a worktree's `.mcp.json` servers in `~/.claude.json`
  * so Claude Code's first invocation in a fresh worktree cwd doesn't show the
@@ -498,7 +426,7 @@ function main() {
     console.error('Usage: node spawn-agent.js <prompt-file> <sysprompt-file> [--runtime <name>] [args...]');
     process.exit(1);
   }
-  const { promptFile, sysPromptFile, runtimeName, opts, passthrough, projectHarnessDirs, hermetic } = parsed;
+  const { promptFile, sysPromptFile, runtimeName, opts, passthrough } = parsed;
 
   const env = cleanChildEnv();
   injectAdoTokenEnvForRepoHost(env);
@@ -532,25 +460,6 @@ function main() {
     opts.sysPromptFile = sysTmpPath;
   }
 
-  // Skill discovery dirs — agents run with CWD set to an external repo
-  // worktree, so runtime-native global assets would otherwise be invisible.
-  // The adapter owns both where those assets live and how to surface them.
-  // P-08b62d49: engine.js also forwards uncommitted project-local harness
-  // dirs from the operator's main checkout via `--project-harness-dir <path>`
-  // (one per dir, accumulated in `projectHarnessDirs`) so worktree-bound
-  // agents inherit them too. See docs/harness-propagation.md.
-  // P-49e1c8b7: when engine.js passes `--hermetic-harness`, computeAddDirs
-  // returns [minionsDir] only — both user-asset dirs and project harness
-  // dirs are dropped for a known-empty harness surface.
-  const minionsDir = path.resolve(__dirname, '..');
-  const addDirs = computeAddDirs({
-    runtime,
-    minionsDir,
-    homeDir: os.homedir(),
-    projectHarnessDirs,
-    hermetic,
-  });
-
   let resolved;
   try { resolved = runtime.resolveBinary({ env }); }
   catch (err) {
@@ -565,7 +474,7 @@ function main() {
   const invocation = buildSpawnInvocation({
     runtime, resolved,
     promptText, sysPromptText,
-    opts, passthrough, addDirs,
+    opts, passthrough,
   });
 
   // Debug log (async — not on critical path). Lives inside the per-dispatch
@@ -805,6 +714,6 @@ function main() {
   });
 }
 
-module.exports = { parseSpawnArgs, buildSpawnInvocation, normalizeRuntimeExit, shouldInjectAdoTokenEnv, injectAdoTokenEnv, injectAdoTokenEnvForRepoHost, writeProcessExitSentinel, computeAddDirs, preApproveWorkspaceMcps, createParentPipeForwarder, assertStaleHeadOk };
+module.exports = { parseSpawnArgs, buildSpawnInvocation, normalizeRuntimeExit, shouldInjectAdoTokenEnv, injectAdoTokenEnv, injectAdoTokenEnvForRepoHost, writeProcessExitSentinel, preApproveWorkspaceMcps, createParentPipeForwarder, assertStaleHeadOk };
 
 if (require.main === module) main();

package/engine/state-operations.js

@@ -0,0 +1,166 @@
+// Explicit operational tooling for the SQL-only runtime state store.
+
+const fs = require('fs');
+const path = require('path');
+const { getDb } = require('./db');
+
+function _quoteSqlString(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+function checkState() {
+  const db = getDb();
+  const schemaVersion = Number(db.prepare('SELECT COALESCE(MAX(version), 0) AS version FROM schema_version').get().version) || 0;
+  const quickCheck = db.prepare('PRAGMA quick_check').all().map(row => Object.values(row)[0]);
+  const foreignKeyViolations = db.prepare('PRAGMA foreign_key_check').all();
+  const invariants = {
+    orphanPrdItems: Number(db.prepare('SELECT COUNT(*) AS n FROM prd_items pi LEFT JOIN prds p ON p.id=pi.prd_id WHERE p.id IS NULL').get().n) || 0,
+    orphanVerifyPrs: Number(db.prepare('SELECT COUNT(*) AS n FROM prd_verify_prs vp LEFT JOIN prds p ON p.id=vp.prd_id WHERE p.id IS NULL').get().n) || 0,
+    brokenWorkItemPrdLinks: Number(db.prepare('SELECT COUNT(*) AS n FROM work_items wi LEFT JOIN prd_items pi ON pi.id=wi.prd_item_id WHERE wi.prd_item_id IS NOT NULL AND pi.id IS NULL').get().n) || 0,
+  };
+  const ok = quickCheck.length === 1
+    && quickCheck[0] === 'ok'
+    && foreignKeyViolations.length === 0
+    && Object.values(invariants).every(count => count === 0);
+  return { ok, schemaVersion, quickCheck, foreignKeyViolations, invariants };
+}
+
+function backupState(targetPath) {
+  if (!targetPath) throw new Error('state backup requires an output path');
+  const resolved = path.resolve(targetPath);
+  fs.mkdirSync(path.dirname(resolved), { recursive: true });
+  if (fs.existsSync(resolved)) throw new Error(`backup target already exists: ${resolved}`);
+  const db = getDb();
+  db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+  db.exec(`VACUUM INTO ${_quoteSqlString(resolved)}`);
+  return { ok: true, path: resolved, bytes: fs.statSync(resolved).size };
+}
+
+function exportState(targetPath) {
+  if (!targetPath) throw new Error('state export requires an output path');
+  const resolved = path.resolve(targetPath);
+  fs.mkdirSync(path.dirname(resolved), { recursive: true });
+  const db = getDb();
+  const tables = db.prepare(`
+    SELECT name FROM sqlite_master
+    WHERE type='table' AND name NOT LIKE 'sqlite_%'
+    ORDER BY name
+  `).all().map(row => row.name);
+  const data = {
+    format: 'minions-sql-diagnostic-export-v1',
+    exportedAt: new Date().toISOString(),
+    integrity: checkState(),
+    tables: {},
+  };
+  for (const table of tables) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(table)) throw new Error(`unsafe table name: ${table}`);
+    data.tables[table] = db.prepare(`SELECT * FROM "${table}"`).all();
+  }
+  const tmp = `${resolved}.tmp.${process.pid}`;
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2));
+  fs.renameSync(tmp, resolved);
+  return { ok: true, path: resolved, tables: tables.length, bytes: fs.statSync(resolved).size };
+}
+
+function _readJson(filePath, expected) {
+  if (!fs.existsSync(filePath)) return null;
+  const value = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  if (expected === 'array' && !Array.isArray(value)) throw new Error(`expected array in ${filePath}`);
+  if (expected === 'object' && (!value || typeof value !== 'object' || Array.isArray(value))) {
+    throw new Error(`expected object in ${filePath}`);
+  }
+  return value;
+}
+
+function importLegacyJson(sourceRoot) {
+  if (!sourceRoot) throw new Error('state import-legacy-json requires a source directory');
+  const root = path.resolve(sourceRoot);
+  if (!fs.statSync(root).isDirectory()) throw new Error(`legacy source is not a directory: ${root}`);
+  const imported = {};
+  const replace = (modulePath, fn, value) => {
+    if (value == null) return;
+    require(modulePath)[fn](() => value);
+    imported[fn] = (imported[fn] || 0) + 1;
+  };
+
+  replace('./dispatch-store', 'applyDispatchMutation', _readJson(path.join(root, 'engine', 'dispatch.json'), 'object'));
+  replace('./metrics-store', 'applyMetricsMutation', _readJson(path.join(root, 'engine', 'metrics.json'), 'object'));
+  replace('./watches-store', 'applyWatchesMutation', _readJson(path.join(root, 'engine', 'watches.json'), 'array'));
+
+  const small = [
+    ['schedule-runs.json', 'applyScheduleRunsMutation', 'object'],
+    ['pipeline-runs.json', 'applyPipelineRunsMutation', 'object'],
+    ['managed-processes.json', 'applyManagedProcessesMutation', 'object'],
+    ['worktree-pool.json', 'applyWorktreePoolMutation', 'object'],
+    ['qa-runs.json', 'applyQaRunsMutation', 'array'],
+    ['qa-sessions.json', 'applyQaSessionsMutation', 'array'],
+    ['pr-links.json', 'applyPrLinksMutation', 'object'],
+    ['cooldowns.json', 'applyCooldownsMutation', 'object'],
+    ['pending-rebases.json', 'applyPendingRebasesMutation', 'array'],
+    ['cc-sessions.json', 'applyCcSessionsMutation', 'array'],
+    ['doc-sessions.json', 'applyDocSessionsMutation', 'object'],
+  ];
+  for (const [filename, fn, shape] of small) {
+    replace('./small-state-store', fn, _readJson(path.join(root, 'engine', filename), shape));
+  }
+
+  const workItemsStore = require('./work-items-store');
+  const pullRequestsStore = require('./pull-requests-store');
+  const importScope = (scope, dir) => {
+    const workItems = _readJson(path.join(dir, 'work-items.json'), 'array');
+    if (workItems) {
+      workItemsStore.applyWorkItemsMutation(scope, () => workItems);
+      imported.workItemScopes = (imported.workItemScopes || 0) + 1;
+    }
+    const pullRequests = _readJson(path.join(dir, 'pull-requests.json'), 'array');
+    if (pullRequests) {
+      pullRequestsStore.applyPullRequestsMutation(scope, () => pullRequests);
+      imported.pullRequestScopes = (imported.pullRequestScopes || 0) + 1;
+    }
+  };
+  importScope('central', root);
+  try {
+    for (const entry of fs.readdirSync(path.join(root, 'projects'), { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name !== '.archived') {
+        importScope(entry.name, path.join(root, 'projects', entry.name));
+      }
+    }
+  } catch { /* projects are optional */ }
+
+  const prdStore = require('./prd-store');
+  for (const [dir, archived] of [[path.join(root, 'prd'), false], [path.join(root, 'prd', 'archive'), true]]) {
+    let files = [];
+    try { files = fs.readdirSync(dir).filter(name => name.endsWith('.json')); } catch { continue; }
+    for (const filename of files) {
+      const prd = _readJson(path.join(dir, filename), 'object');
+      const target = archived
+        ? path.join(require('./shared').MINIONS_DIR, 'prd', 'archive', filename)
+        : path.join(require('./shared').MINIONS_DIR, 'prd', filename);
+      prdStore.writePrd(target, prd);
+      imported.prds = (imported.prds || 0) + 1;
+    }
+  }
+
+  const logs = _readJson(path.join(root, 'engine', 'log.json'), 'array');
+  if (logs) {
+    const db = getDb();
+    const { withTransaction } = require('./db');
+    withTransaction(db, () => {
+      db.exec('DELETE FROM logs');
+      const insert = db.prepare('INSERT INTO logs (ts_ms, level, message, meta) VALUES (?, ?, ?, ?)');
+      for (const entry of logs) {
+        const timestamp = Date.parse(entry.timestamp);
+        const meta = { ...entry };
+        delete meta.timestamp;
+        delete meta.level;
+        delete meta.message;
+        const { level, message } = entry;
+        insert.run(Number.isFinite(timestamp) ? timestamp : Date.now(), level || 'info', String(message || ''), Object.keys(meta).length ? JSON.stringify(meta) : null);
+      }
+    });
+    imported.logs = logs.length;
+  }
+  return { ok: true, source: root, imported, integrity: checkState() };
+}
+
+module.exports = { checkState, backupState, exportState, importLegacyJson };

package/engine/supervisor.js

@@ -339,7 +339,6 @@ function openAppendFd(name) {
 }
 
 function _sqliteSpawnFlags() {
-  if (process.env.MINIONS_FORCE_JSON === '1') return [];
   const major = parseInt(String(process.versions.node).split('.')[0], 10);
   if (!Number.isFinite(major) || major < 22 || major >= 24) return [];
   const nodeOpts = String(process.env.NODE_OPTIONS || '');

package/engine/watch-actions.js

@@ -687,7 +687,6 @@ registerActionType(WATCH_ACTION_TYPE.CANCEL_WORK_ITEM, {
 
     let cancelled = false;
     for (const wiPath of candidates) {
-      if (!fs.existsSync(wiPath)) continue;
       mutateWorkItems(wiPath, (items) => {
         const it = items.find(i => i && i.id === targetId);
         if (!it) return items;
@@ -743,7 +742,7 @@ registerActionType(WATCH_ACTION_TYPE.ARCHIVE_PLAN, {
     const planFile = String(p.planFile || ctx.planFile || '').trim();
     if (!planFile) return { ok: false, summary: 'archive-plan: planFile is required' };
     const prdPath = path.join(shared.MINIONS_DIR, 'prd', planFile);
-    if (!fs.existsSync(prdPath)) return { ok: false, summary: `archive-plan: ${planFile} not found` };
+    if (!shared.safeJsonNoRestore(prdPath)) return { ok: false, summary: `archive-plan: ${planFile} not found` };
     let updated = false;
     mutateJsonFileLocked(prdPath, (data) => {
       if (!data || typeof data !== 'object' || Array.isArray(data)) data = {};
@@ -770,7 +769,7 @@ registerActionType(WATCH_ACTION_TYPE.RESUME_PLAN, {
     const planFile = String(p.planFile || ctx.planFile || '').trim();
     if (!planFile) return { ok: false, summary: 'resume-plan: planFile is required' };
     const prdPath = path.join(shared.MINIONS_DIR, 'prd', planFile);
-    if (!fs.existsSync(prdPath)) return { ok: false, summary: `resume-plan: ${planFile} not found` };
+    if (!shared.safeJsonNoRestore(prdPath)) return { ok: false, summary: `resume-plan: ${planFile} not found` };
     let updated = false;
     mutateJsonFileLocked(prdPath, (data) => {
       if (!data || typeof data !== 'object' || Array.isArray(data)) data = {};

package/engine/watches-store.js

@@ -1,16 +1,10 @@
 // engine/watches-store.js — SQL-backed implementation of engine/watches.json.
 //
-// Mirrors the Phase 2/3 work_items / pull_requests stores: a single
-// table (no per-scope split — watches.json is a flat array, not
-// per-project), diff-then-apply mutator, JSON dual-write mirror with
-// (mtime, size) fingerprint for external-edit detection.
+// A single SQL table (no per-scope split), with a diff-then-apply mutator.
 //
 //   readWatches()           -> [watch, watch, ...]
 //   applyWatchesMutation(fn) -> diff-then-apply, returns { wrote, result }
 
-const fs = require('fs');
-const path = require('path');
-
 function _toMs(v) {
   if (v == null) return null;
   if (typeof v === 'number') return Number.isFinite(v) ? v : null;
@@ -18,99 +12,12 @@ function _toMs(v) {
   return Number.isFinite(parsed) ? parsed : null;
 }
 
-function _watchesFilePath() {
-  const shared = require('./shared');
-  return path.join(shared.MINIONS_DIR, 'engine', 'watches.json');
-}
-
 function _parseRow(row) {
   if (!row || !row.data) return null;
   try { return JSON.parse(row.data); }
   catch { return null; }
 }
 
-function _readJsonArrayFallback() {
-  const fp = _watchesFilePath();
-  let raw;
-  try { raw = fs.readFileSync(fp, 'utf8'); }
-  catch { return []; }
-  try {
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch (e) {
-    try {
-      // eslint-disable-next-line no-console
-      console.warn(`[watches-store] corrupt JSON in ${fp}: ${e.message}`);
-    } catch { /* console may be wrapped */ }
-    return [];
-  }
-}
-
-// Content-hash fingerprint — (mtime, size) is too coarse: same-size
-// content swaps (e.g. last_checked timestamps that always have the same
-// byte length) inside the same ms tick collide on both axes. Hashing the
-// bytes is the unambiguous signal. SHA-1 on a few-KB file is sub-ms.
-let _lastMirrorHash = null;
-
-const crypto = require('crypto');
-
-function _fileContentHash(filePath) {
-  try {
-    const buf = fs.readFileSync(filePath);
-    return crypto.createHash('sha1').update(buf).digest('hex');
-  }
-  catch { return null; }
-}
-
-function _hydrateFromJson(db) {
-  const items = _readJsonArrayFallback();
-  db.prepare('DELETE FROM watches').run();
-  if (items.length === 0) return;
-  const now = Date.now();
-  const ins = db.prepare(`
-    INSERT INTO watches (id, target, target_type, condition, status, owner, created_at, last_checked, last_triggered, data, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(id) DO NOTHING
-  `);
-  for (const w of items) {
-    if (!w || !w.id) continue;
-    ins.run(
-      String(w.id),
-      typeof w.target === 'string' ? w.target : (w.target == null ? null : JSON.stringify(w.target)),
-      w.targetType || null,
-      w.condition || null,
-      String(w.status || 'active'),
-      w.owner || null,
-      _toMs(w.created_at),
-      _toMs(w.last_checked),
-      _toMs(w.last_triggered),
-      JSON.stringify(w),
-      now,
-    );
-  }
-}
-
-function _resyncIfJsonDiverged(db) {
-  const jsonPath = _watchesFilePath();
-  const currentHash = _fileContentHash(jsonPath);
-  if (currentHash == null) return;
-  if (_lastMirrorHash != null && currentHash === _lastMirrorHash) return;
-  if (_lastMirrorHash == null) {
-    const sqlHas = db.prepare('SELECT 1 FROM watches LIMIT 1').get();
-    if (sqlHas) {
-      _lastMirrorHash = currentHash;
-      return;
-    }
-  }
-  _hydrateFromJson(db);
-  _lastMirrorHash = currentHash;
-}
-
-// Read all watch rows from SQL only. No JSON fallback — used by the
-// mirror writer to avoid resurrecting deleted rows: after the mutation
-// deletes a watch from SQL but BEFORE the mirror lands, the JSON still
-// holds the pre-mutation content, so a fallback read would round-trip
-// the deleted row right back into JSON.
 function _readWatchesFromSqlOnly(db) {
   const rows = db.prepare('SELECT data FROM watches ORDER BY rowid').all();
   const out = [];
@@ -123,22 +30,7 @@ function _readWatchesFromSqlOnly(db) {
 
 function readWatches() {
   const { getDb } = require('./db');
-  let db;
-  try { db = getDb(); }
-  catch { return _readJsonArrayFallback(); }
-
-  _resyncIfJsonDiverged(db);
-
-  const out = _readWatchesFromSqlOnly(db);
-  if (out.length === 0) {
-    // SQL is empty for first-time hydrate: trust the JSON if it has
-    // content. After hydrate ran, SQL is empty iff the user really has
-    // no watches.
-    const fallback = _readJsonArrayFallback();
-    if (fallback.length > 0) return fallback;
-    return [];
-  }
-  return out;
+  return _readWatchesFromSqlOnly(getDb());
 }
 
 function _indexById(arr) {
@@ -216,7 +108,6 @@ function applyWatchesMutation(mutator) {
   }
 
   return withTransaction(db, () => {
-    _resyncIfJsonDiverged(db);
     const before = readWatches();
     const beforeSnapshot = JSON.parse(JSON.stringify(before));
     const next = mutator(before);
@@ -229,24 +120,7 @@ function applyWatchesMutation(mutator) {
   });
 }
 
-function _mirrorJsonFromSql(filePath) {
-  try {
-    const shared = require('./shared');
-    const { getDb } = require('./db');
-    // Read SQL directly — bypass the JSON fallback so a deletion that
-    // leaves SQL empty doesn't resurrect from the stale JSON content.
-    const items = _readWatchesFromSqlOnly(getDb());
-    const target = filePath || _watchesFilePath();
-    shared.safeWrite(target, items);
-    const h = _fileContentHash(target);
-    if (h != null) _lastMirrorHash = h;
-  } catch {
-    // Mirror failures are non-fatal — SQL has already committed.
-  }
-}
-
 module.exports = {
   readWatches,
   applyWatchesMutation,
-  _mirrorJsonFromSql,
 };