@niroai/niro 0.16.0 → 0.18.0

package/src/commands/watch.js

@@ -10,6 +10,7 @@
  * Also exported as `startWatch(dir)` so `niro add repo` can transition into
  * watch mode automatically after initial sync.
  */
+const crypto = require("crypto");
 const path = require("path");
 const fs = require("fs");
 const api = require("../lib/api");
@@ -22,6 +23,9 @@ const folderSync = require("../lib/folderSync");
 const git = require("../lib/git");
 const tempProject = require("../lib/tempProject");
 const periodicClaim = require("../lib/periodicClaim");
+const localBuild = require("../lib/localBuild");
+const localEngine = require("../lib/localEngine");
+const { startLocalDocs } = require("../lib/docsUpload");
 const {
   SOURCE_EXTENSIONS, STRUCTURAL_EXTENSIONS, STRUCTURAL_FILENAMES,
   IGNORED_DIRS, isConfigName, chunk,
@@ -124,13 +128,22 @@ function recordBackstopSuccess(key) {
 
 async function watch(pathArg, opts = {}) {
   const creds = credentials.requireCreds();
+  if (pathArg && !require("../lib/release").cloud) {
+    // `niro watch <path>` syncs one folder to the cloud, which this release does not have.
+    console.error("`niro watch <path>` syncs a folder to Niro's cloud, which this release does not include. The background watcher (`niro service install`) keeps your local folders current.");
+    process.exitCode = 1;
+    return;
+  }
 
   if (!pathArg) {
     // Watch all registered local repos for the CURRENT backend (entries from
     // another stack are skipped — their gitIds are invalid here).
-    const all = watchState.allLocal(api.currentBaseUrl());
-    if (all.length === 0) {
-      console.error("No registered local repos found. Run `niro add repo` first.");
+    const { cloud: all, local, engineAnswered } = await daemonTargets({ run: opts.run });
+    // An engine that answered with no folder yet still gets a daemon: the folder list is read
+    // again every round (`followLocalFolders`), so the first `niro init` is picked up without a
+    // restart. Only a machine with neither an engine nor a cloud folder has nothing to do.
+    if (all.length === 0 && local.length === 0 && !engineAnswered) {
+      console.error("No folders to watch. Run `niro start` in a project folder first.");
       process.exitCode = 1;
       return;
     }
@@ -146,6 +159,10 @@ async function watch(pathArg, opts = {}) {
       watched.add(path.resolve(entry.folderPath));
       startWatch(entry.folderPath, opts).catch(err => handleEntryFailure(entry, err, watched));
     }
+    // Folders the local engine indexes and nothing registered for the cloud: a Niro Local
+    // machine has only these. Followed for as long as the daemon runs, not listed once: see
+    // followLocalFolders.
+    followLocalFolders(local, { ...opts, cloudFolders: watched });
     // Pick up folders added by `niro takeover` / `niro add repo` WITHOUT a daemon restart. Those commands
     // rewrite the state file, so watch it and start watching any NEW entry live. (A takeover that only
     // re-points an ALREADY-watched folder's gitId is handled per-event by handleFileEvent re-reading
@@ -154,7 +171,9 @@ async function watch(pathArg, opts = {}) {
     const reconcile = () => {
       if (reconcileTimer) clearTimeout(reconcileTimer);
       reconcileTimer = setTimeout(() => {
-        for (const entry of watchState.allLocal(api.currentBaseUrl())) {
+        // The same list as start-up (`hostedFolders`): without the cloud it is empty, so a hosted
+        // folder left in projects.json is not started here either when the file is rewritten.
+        for (const entry of hostedFolders()) {
           const resolved = path.resolve(entry.folderPath);
           if (!watched.has(resolved)) {
             watched.add(resolved);
@@ -178,7 +197,13 @@ async function watch(pathArg, opts = {}) {
     } catch (err) {
       console.error(color.yellow(`    Could not watch the state file for new folders: ${err.message}`));
     }
-    startPeriodicSweep();
+    startPeriodicSweep({ startupDelayMs: sweepStartupDelayMs() });
+    startLocalUploads();
+    // Documentation requests for folders built with `niro-local build --llm`. Its own timer and
+    // claim, kept in docsUpload.js because this file is already over 1,000 lines. Not started while
+    // LLM documentation is off (src/lib/release.js `llmDocs`): against an engine with it off every
+    // round would end refused, after a token refresh and a log line, every ten minutes.
+    if (require("../lib/release").llmDocs) startLocalDocs();
 
     // Keep process alive
     await new Promise(() => {});
@@ -189,6 +214,163 @@ async function watch(pathArg, opts = {}) {
   await startWatch(targetDir, opts);
 }
 
+/**
+ * What the no-path daemon watches: `cloud`, the registered folders for this backend, and
+ * `local`, every folder the local engine knows (`niro-local projects --json`) that is still
+ * on disk and not already among the cloud ones. A machine with no engine has no local folders.
+ *
+ * Before this the daemon exited when ~/.niro/projects.json was empty, so a Niro Local machine,
+ * which registers nothing there, had no daemon at all and "updates automatically" was false.
+ */
+/**
+ * How long `niro-local projects --json` may take before it is stopped. It answers in well under a
+ * second; a call that hangs would otherwise hold the daemon's round for ever, and no later round
+ * would run (VP-rel-watch N4). `NIRO_LOCAL_LIST_TIMEOUT_MS` changes it.
+ */
+const LIST_TIMEOUT_MS = 20_000;
+
+/**
+ * The folders registered for hosted Niro that the daemon syncs: the entries of ~/.niro/projects.json
+ * for this backend. None without the cloud (src/lib/release.js): a machine that once registered folders
+ * for the cloud keeps them in that file, and watching those would keep uploading their source to Niro.
+ * Start-up and the re-read after projects.json changes both take their list from here.
+ */
+function hostedFolders() {
+  return require("../lib/release").cloud ? watchState.allLocal(api.currentBaseUrl()) : [];
+}
+
+async function daemonTargets({ run = localEngine.run } = {}) {
+  const cloud = hostedFolders();
+  const taken = new Set(cloud.map((e) => path.resolve(e.folderPath)));
+  const local = [];
+  // Whether the engine answered at all, so the daemon can tell "no engine" from "an engine that
+  // holds no folder yet" (the second keeps the daemon up, waiting for the first folder).
+  let engineAnswered = false;
+  let problem = null;
+  try {
+    const timeoutMs = Number(process.env.NIRO_LOCAL_LIST_TIMEOUT_MS) > 0
+      ? Number(process.env.NIRO_LOCAL_LIST_TIMEOUT_MS) : LIST_TIMEOUT_MS;
+    const parsed = JSON.parse(await run(["projects", "--json"], undefined, { timeoutMs }));
+    engineAnswered = true;
+    for (const project of parsed.projects || []) {
+      for (const w of project.worktrees || []) {
+        const folder = w && typeof w.path === "string" ? path.resolve(w.path) : null;
+        if (!folder || taken.has(folder) || !fs.existsSync(folder)) continue;
+        taken.add(folder);
+        local.push(folder);
+      }
+    }
+  } catch (err) {
+    // No engine, or one that cannot answer: no local folders. The reason is passed back for the
+    // daemon's rounds, which say it once; the start-up caller only needs the yes or no.
+    problem = (err && err.message) || String(err);
+  }
+  return { cloud, local, engineAnswered, problem };
+}
+
+/**
+ * How often the daemon asks niro-local again which folders it indexes. Thirty seconds: one
+ * `niro-local projects --json` and two git calls per held repository, so a folder indexed by
+ * `niro init` or a `git worktree add` is followed within half a minute without a restart.
+ * `NIRO_LOCAL_RECONCILE_MS` changes it (read when the daemon starts; under one second is ignored).
+ */
+const LOCAL_RECONCILE_MS = 30_000;
+
+/** Said under a failed new-worktree build: that folder is not watched yet, so saving does nothing. */
+const WORKTREE_RETRY_HINT = () => `It is tried again in a few minutes. To see why now, run \`${require("../lib/release").rebuildCommand()}\` in that folder.`;
+
+/** The local folders being watched now: resolved folder -> handle with `stop()`. */
+const localWatches = new Map();
+
+/**
+ * Keep the daemon's local folders the same as niro-local's list, for as long as it runs.
+ *
+ * Until release finding 6 the list was read once, when the daemon started, so a folder indexed
+ * afterwards was never watched until the next reboot, a folder removed with `niro-local remove` was
+ * still built on every save (and each build failed in red), and a new git worktree of a held
+ * repository was never indexed. Now each round:
+ *   - a folder niro-local lists and nobody watches starts being watched;
+ *   - a watched folder it no longer lists, or that is gone from disk, stops being watched;
+ *   - a worktree of a held repository that is new since the repository was first seen is built
+ *     with `niro-local build` (`localWorktrees.js`), which makes its temporary copy; the next
+ *     round finds the copy in the list and watches it. A build that fails is tried twice more,
+ *     minutes apart, then given up with one line.
+ * A round where the engine cannot answer changes nothing, so a passing failure never stops a watch.
+ *
+ * `cloudFolders` are left to the cloud half. Returns `{ stop, round }`; `round` is for tests.
+ */
+function followLocalFolders(initial, {
+  run, intervalMs, log = console.log, cloudFolders = new Set(),
+  newWorktreeFolders = require("../lib/localWorktrees").newWorktreeFolders,
+} = {}) {
+  const every = usableReconcileMs(intervalMs) || usableReconcileMs(Number(process.env.NIRO_LOCAL_RECONCILE_MS))
+    || LOCAL_RECONCILE_MS;
+  let busy = false;
+  let failing = false;
+
+  const apply = async (folders, { first = false } = {}) => {
+    const wanted = new Set(folders.map((f) => path.resolve(f)).filter((f) => !cloudFolders.has(f)));
+    for (const folder of wanted) {
+      if (localWatches.has(folder)) continue;
+      if (!first) log(`    ${color.green("\u21bb")} Now watching new folder: ${folder}`);
+      await startLocalWatch(folder, { once: true, log });
+    }
+    for (const [folder, handle] of [...localWatches]) {
+      // A cloud folder that niro-local also indexes is watched through the cloud half
+      // (`startWatch` hands it to `startLocalWatch`), so it is in this map but never in `wanted`.
+      // It is not this round's to stop (VP-rel-watch N2: it lost its watch at the first round).
+      if (wanted.has(folder) || cloudFolders.has(folder)) continue;
+      handle.stop();
+      const why = fs.existsSync(folder) ? "niro-local no longer indexes it" : "it is gone from disk";
+      log(`    Stopped watching ${folder}: ${why}.`);
+    }
+    for (const folder of await newWorktreeFolders([...wanted], { log })) {
+      log(`    ${color.green("\u21bb")} New worktree of a repository niro-local indexes: building ${folder}`);
+      localBuild.noteChange(folder, { settleMs: 0, log, hint: WORKTREE_RETRY_HINT() });
+    }
+  };
+
+  const round = async () => {
+    if (busy) return;
+    busy = true;
+    try {
+      const { local, engineAnswered, problem } = await daemonTargets({ run });
+      if (engineAnswered) {
+        if (failing) log(`    niro-local answers again; following its folders.`);
+        failing = false;
+        await apply(local);
+      } else if (!failing) {
+        // Said once per run of failures, not every 30 s. Nothing is stopped meanwhile.
+        failing = true;
+        log(color.yellow(`    Could not ask niro-local for its folders (${problem}); watching the same folders and asking again every ${Math.round(every / 1000)} s.`));
+      }
+    } catch (err) {
+      log(color.yellow(`    Could not check niro-local's folders: ${err && err.message ? err.message : err}`));
+    } finally {
+      busy = false;
+    }
+  };
+
+  busy = true;
+  const started = apply(initial, { first: true })
+    .catch((err) => log(color.red(`    Could not watch niro-local's folders: ${err && err.message ? err.message : err}`)))
+    .finally(() => { busy = false; });
+  // Not unref'd: with no folder yet this timer is what keeps the daemon up, waiting for the first.
+  const timer = setInterval(round, every);
+  return {
+    started,
+    round,
+    stop: () => {
+      clearInterval(timer);
+      for (const handle of [...localWatches.values()]) handle.stop();
+    },
+  };
+}
+
+function usableReconcileMs(ms) {
+  return Number.isFinite(ms) && ms >= 1000 ? ms : undefined;
+}
+
 /**
  * How often the daemon sweeps for temporary projects that have gone from the server. Six hours, not
  * six seconds: its job is repairing pointers that go stale over days, not reacting to keystrokes.
@@ -201,6 +383,16 @@ const SWEEP_INTERVAL_MS = 6 * 60 * 60 * 1000;
  */
 const SWEEP_STARTUP_DELAY_MS = 60 * 1000;
 
+/**
+ * The first sweep's delay. `NIRO_SWEEP_STARTUP_DELAY_MS` (at least 1000) shortens it, so the end-to-end
+ * test of the daemon (test/watchHostedGuard.test.js) does not wait a minute; it changes only when the
+ * first sweep runs, since every run is still gated by the six-hour claim.
+ */
+function sweepStartupDelayMs() {
+  const ms = Number(process.env.NIRO_SWEEP_STARTUP_DELAY_MS);
+  return Number.isFinite(ms) && ms >= 1000 ? ms : SWEEP_STARTUP_DELAY_MS;
+}
+
 /**
  * Periodically run `niro cleanup-temp-projects`. Machine-wide, so it belongs HERE, in the no-path
  * branch, and not in startWatch — startWatch runs once per folder, and this must run once per machine.
@@ -239,6 +431,96 @@ function startPeriodicSweep({ intervalMs = SWEEP_INTERVAL_MS, startupDelayMs = S
   return { stop: () => { clearTimeout(first); clearInterval(timer); } };
 }
 
+/**
+ * How often the local engine's queues are emptied: its coverage-audit findings and its record
+ * of which MCP tools were asked for.
+ *
+ * Five minutes (Divya, 2026-11-05; it was half an hour). The engine holds back a session that is
+ * still in use and the audit queue dedups by content hash, so a run that finds nothing costs one
+ * licence request and nothing is sent twice.
+ */
+const LOCAL_UPLOAD_INTERVAL_MS = 5 * 60 * 1000;
+
+/** The same reasoning as the sweep's delay: let the daemon's startup burst settle first. */
+const LOCAL_UPLOAD_STARTUP_DELAY_MS = 2 * 60 * 1000;
+
+/**
+ * Periodically send what the local engine is holding.
+ *
+ * Until now both of these needed a person to type `niro audit-send` or `niro journal-send`,
+ * which means in practice they were never sent: a developer has no reason to run either and
+ * no way to know there is anything waiting.
+ *
+ * **Why on a timer rather than after each build.** The audit's findings come out of a build,
+ * so after-each-build looks like the obvious hook. But the watcher builds after every quiet
+ * period, which during a working session is every few minutes, and an upload per build is a
+ * request per save for a queue that is usually empty. The journal has no build to hang off at
+ * all. One timer, three jobs.
+ *
+ * **The third job, shared code (2026-11-11).** While the lease says `share_code: true`, the code
+ * of every indexed folder that is not excluded is sent, redacted here: the whole indexed set the
+ * first time, then only changed files (src/lib/shareCode.js, decision 01M75JHE64PYYNKR2G4JJ4JCZ3).
+ * The audit and the journal do not depend on that switch; this job does nothing without it.
+ *
+ * **Machine-wide, so it belongs in the no-path branch** beside the temporary-project sweep,
+ * and gated by periodicClaim for the same two reasons: PM2 restarting the daemon must not turn
+ * a half-hourly job into one that runs on every restart, and a `niro watch` left in a terminal
+ * must not upload at the same moment as the daemon.
+ *
+ * **It stays quiet on a machine with no engine.** A cloud-only developer has no niro-local, so
+ * each attempt fails to run it; that is never logged, and the next round tries again, so an
+ * engine installed later is sent from without restarting the daemon.
+ *
+ * Never throws: an upload failure must not touch the daemon's actual job.
+ */
+function startLocalUploads({
+  intervalMs = LOCAL_UPLOAD_INTERVAL_MS,
+  startupDelayMs = LOCAL_UPLOAD_STARTUP_DELAY_MS,
+  claimName = "localEngineUploads",
+  log = console.log,
+} = {}) {
+  let stopped = false;
+  const handle = { stop: () => {} };
+
+  const run = async () => {
+    if (stopped || !periodicClaim.claim(claimName, intervalMs)) return;
+    for (const job of [
+      { what: "audit findings", send: () => require("../lib/auditUpload").uploadPending() },
+      { what: "MCP journal", send: () => require("../lib/journalUpload").uploadPending() },
+      // Only while "Help improve Niro" is on; the rest of its rules are in shareCode.js.
+      { what: "shared code files", send: () => require("../lib/shareCode").shareRound() },
+    ]) {
+      try {
+        const result = await job.send();
+        const sent = result.submitted || result.sent || 0;
+        if (sent > 0) log(`    Sent ${sent} ${job.what} to Niro.`);
+      } catch (err) {
+        const message = (err && err.message) || String(err);
+        if (/cannot run /.test(message)) {
+          // No engine on this machine yet: nothing to send this round, and nothing worth saying.
+          // Tried again next round, so an engine installed after the daemon started is picked up
+          // without a restart (until 2026-11-06 the timer stopped here for good).
+          return;
+        }
+        // Said rather than swallowed: a queue that silently never drains is the failure this
+        // whole path exists to prevent. Once per interval, not once per item.
+        log(color.yellow(`    Could not send the ${job.what}: ${message}`));
+      }
+    }
+  };
+
+  const first = setTimeout(run, startupDelayMs);
+  const timer = setInterval(run, intervalMs);
+  if (first.unref) first.unref();
+  if (timer.unref) timer.unref();
+  handle.stop = () => {
+    stopped = true;
+    clearTimeout(first);
+    clearInterval(timer);
+  };
+  return handle;
+}
+
 /**
  * One watch entry failed to start (its startup delta sync threw). Contain the failure to that
  * entry — and when the cause is "the repo no longer exists on this backend" (a poison entry left
@@ -277,7 +559,139 @@ async function handleEntryFailure(entry, err, watched) {
     `Watch error for ${entry.folderPath}: ${err.message} — entry kept, will retry on next daemon start.`));
 }
 
+/**
+ * Watch a folder the local engine indexes: rebuild it when it goes quiet.
+ *
+ * Self-contained rather than branching through startWatch below, and the ~8 lines of
+ * fs.watch setup are duplicated on purpose. Two reasons, written down because a silent
+ * copy-paste is not allowed. First, the cloud half of this file carries protections that
+ * were each paid for by a real failure, and its fs.watch wiring is NOT covered by any test
+ * ("the fs.watch wiring is not driven here", test/watchDeleteSettle.test.js), so
+ * restructuring it to share with a new path would be an unguarded change to the riskiest
+ * code here. Second, phase 12 of the plan deletes the cloud half outright, so the
+ * duplication ends by deletion rather than by an abstraction that would then have one
+ * caller.
+ *
+ * What is NOT duplicated, because it is not needed: the per-file hashes, the gitignore
+ * check at upload time, the manifest scope and the heartbeat. The engine compares the whole
+ * folder against its own content hashes on every build, so it finds a change this watcher
+ * missed without being told. The one thing it cannot do is know that something happened,
+ * which is what this provides: a file event, or, for an event fs.watch dropped, a re-check of
+ * the folder's file sizes and times every few minutes (`localBuild.startRecheck`, rank 176; the
+ * cloud half's backstop re-hashes every file each minute, which a local build does not need).
+ */
+/** How often a folder is checked for changes when this Node cannot watch a folder tree (startLocalWatch). */
+const WATCHLESS_POLL_MS = 10_000;
+
+async function startLocalWatch(targetDir, opts = {}) {
+  const log = opts.log || console.log;
+  // One watch per folder, whichever path asks for it (the daemon's list and a cloud entry that
+  // turns out to be local can both name the same folder).
+  const existing = localWatches.get(path.resolve(targetDir));
+  if (existing) return existing;
+  let watcher = null;
+  const handle = {
+    stop: () => {
+      if (localWatches.get(path.resolve(targetDir)) === handle) localWatches.delete(path.resolve(targetDir));
+      if (watcher) watcher.close();
+      watcher = null;
+      localBuild.forget(targetDir);
+    },
+  };
+  localWatches.set(path.resolve(targetDir), handle);
+  log(`\n    ${color.cyan("Watching")} ${targetDir}`);
+  log(`    ${color.dim("indexed locally by niro-local")}`);
+
+  // Build once at startup. The folder may have changed while nothing was watching it, and
+  // that is the stale-graph case this exists to prevent; waiting for the next edit would
+  // leave it stale until one happened to arrive.
+  localBuild.noteChange(targetDir, { settleMs: 0, log });
+
+  // A Node that cannot watch a folder tree (Node 18 on Linux, Ubuntu 24.04's own package) throws here. It used to
+  // end the watch before the re-check below was started, with the folder still marked as watched, so nothing ever
+  // synced while PM2 showed the watcher online (2026-11-11). Then the re-check is the watcher, every 10 s.
+  let pollMs;
+  try {
+    watcher = fs.watch(targetDir, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
+      const relativePath = filename.replace(/\\/g, "/");
+      if (shouldIgnore(relativePath)) return;
+      // Straight to the folder's settle timer, with no per-file debounce in between: the
+      // settle timer already collapses a burst, and adding the per-file 2s on top would only
+      // delay every rebuild by two seconds for nothing.
+      localBuild.noteChange(targetDir, { log });
+    });
+  } catch (err) {
+    pollMs = WATCHLESS_POLL_MS;
+    log(color.yellow(`    Node ${process.version} cannot watch a folder tree here (${err.code || err.message}); checking ${targetDir} for changes every ${pollMs / 1000} s instead. Node 20 or later sees changes as they happen.`));
+  }
+
+  // A watch that errors (its folder deleted, too many open files) is stopped rather than left
+  // half alive; the daemon starts it again next round if niro-local still lists the folder.
+  if (watcher) watcher.on("error", (err) => {
+    // A folder deleted on purpose (`git worktree remove`) is not a fault: said plainly, not in red.
+    if (!fs.existsSync(targetDir)) log(`    Stopped watching ${targetDir}: it is gone from disk.`);
+    else log(color.red(`    Watcher error for ${targetDir}: ${err.message}`));
+    handle.stop();
+  });
+
+  // fs.watch drops events, so a few minutes apart the folder is listed again and rebuilt when it
+  // changed unseen (rank 176). Stopped by `forget` below. Without fs.watch it is the watcher (pollMs).
+  localBuild.startRecheck(targetDir, { intervalMs: pollMs, list: () => folderDigest(targetDir), log });
+
+  log(`    ${color.green("\u2713")} Watching for changes. Press Ctrl+C to stop.\n`);
+
+  // `once` is the daemon (and tests): it returns the handle and the daemon stops it. A Ctrl+C
+  // handler per folder there would add one listener per folder for nothing.
+  if (opts.once) return handle;
+
+  process.on("SIGINT", () => {
+    handle.stop();
+    log("\n    Watch stopped.");
+    process.exit(0);
+  });
+  await new Promise(() => {});
+}
+
+/**
+ * A digest of a locally indexed folder for the periodic re-check: every file the walk keeps (the same
+ * walk and filters as the cloud manifest, `buildMinimalManifest`), with its size and modification time.
+ * No file is read. Null when a folder under it cannot be listed: unknown is not "changed".
+ */
+function folderDigest(rootDir) {
+  const { files, failedDirs } = buildMinimalManifest(rootDir);
+  if (failedDirs.length > 0) return null;
+  const hash = crypto.createHash("sha1");
+  for (const relativePath of files.sort()) {
+    let stamp = "gone";
+    try {
+      const stat = fs.statSync(path.join(rootDir, relativePath));
+      stamp = `${stat.mtimeMs}:${stat.size}`;
+    } catch {
+      // Removed between the walk and the stat: a change like any other.
+    }
+    hash.update(`${relativePath}\t${stamp}\n`);
+  }
+  return hash.digest("hex");
+}
+
 async function startWatch(targetDir, opts = {}) {
+  // A locally indexed folder has no gitId and nothing to upload, so it is answered before
+  // the registration guard below, which would otherwise refuse it.
+  if (await localBuild.isLocallyIndexed(targetDir)) {
+    return startLocalWatch(targetDir, opts);
+  }
+
+  // Without the cloud (src/lib/release.js) nothing is synced to hosted Niro. Every sync of a folder
+  // starts here (daemon start-up, the re-read when projects.json changes, `niro watch <path>`), so this
+  // one check stops all of them: the delta sync below uploads whole files, unmasked. Before it, the
+  // re-read started syncing old hosted folders whenever projects.json was rewritten, including by the
+  // daemon's own sweep (2026-11-10).
+  if (!require("../lib/release").cloud) {
+    console.log(`    Not syncing ${targetDir}: the local engine does not index it, and this release does not sync folders to hosted Niro.`);
+    return;
+  }
+
   // Scope to the current backend: a folder registered against a different stack
   // has a gitId that is invalid here, so resume must refuse rather than 404 on
   // every sync. (The daemon's allLocal() already filters; this also guards the
@@ -976,7 +1390,7 @@ function buildMinimalManifest(rootDir, includePatterns, excludePatterns) {
 // gitignore/fail-closed guards without a live server or fs.watch loop. matchesPatterns is
 // exported for the same reason: it is the gate all three sync paths share, and a pattern that
 // cannot be compiled stops every one of them, so it is worth testing on its own.
-module.exports = { watch, startWatch, startPeriodicSweep, handleFileEvent, deltaSyncOnResume, handleEntryFailure,
+module.exports = { watch, daemonTargets, followLocalFolders, localWatches, LOCAL_RECONCILE_MS, startWatch, startLocalWatch, folderDigest, startPeriodicSweep, startLocalUploads, startLocalDocs, handleFileEvent, deltaSyncOnResume, handleEntryFailure,
   matchesPatterns,
   queueDelete, flushPendingDeletes, pendingDeletes, DELETE_SETTLE_MS, backstopTick, notHolding,
   unreadableRoots,