@niroai/niro 0.8.0 → 0.10.0

package/src/commands/takeover.js

@@ -22,6 +22,7 @@ const git = require("../lib/git");
 const prompt = require("../lib/prompt");
 const watchState = require("../lib/watchState");
 const resolveCtxLib = require("../lib/resolveContext");
+const spinner = require("../lib/spinner");
 
 const ok = (s) => color.green(s);
 const warn = (s) => color.yellow(s);
@@ -72,9 +73,9 @@ async function takeover(pathArg, opts = {}) {
       const list = ctx.projects.map((p) => `  ${p.project_id} (${p.alias})`).join("\n");
       throw new Error(`Multiple projects match this repo — pass --project:\n${list}`);
     }
-    console.log("\n  Multiple projects match this repo:");
+    console.log("\n    Multiple projects match this repo:");
     ctx.projects.forEach((p, i) => console.log(`    ${i + 1}. ${p.alias || "(no alias)"} ${color.dim(p.project_id)}`));
-    const answer = await prompt.ask(`  Take over which one? [1-${ctx.projects.length}]`, "1");
+    const answer = await prompt.ask(`    Take over which one? [1-${ctx.projects.length}]`, "1");
     const idx = parseInt(answer, 10) - 1;
     if (isNaN(idx) || idx < 0 || idx >= ctx.projects.length) {
       throw new Error(`Invalid choice: ${answer}`);
@@ -120,11 +121,11 @@ async function takeover(pathArg, opts = {}) {
     && path.resolve(e.folderPath) !== here);
   if (holder) {
     const onBranch = holder.branch ? ` on branch \`${holder.branch}\`` : "";
-    console.log(warn("\n  Niro keeps ONE temporary project per project, and this project's is already"));
-    console.log(warn("  held by another folder:"));
+    console.log(warn("\n    Niro keeps ONE temporary project per project, and this project's is already"));
+    console.log(warn("    held by another folder:"));
     console.log(`    ${holder.folderPath}${onBranch}`);
-    console.log(color.dim("  Moving it here stops Niro reflecting that folder: it falls back to the original"));
-    console.log(color.dim("  project until `niro new-temp-project` is run there again."));
+    console.log(color.dim("    Moving it here stops Niro reflecting that folder: it falls back to the original"));
+    console.log(color.dim("    project until `niro new-temp-project` is run there again."));
     if (prompt.isNonInteractive()) {
       // Refuse rather than hang, and rather than proceed. Proceeding is what caused the problem; hanging
       // would break any agent or script that runs this unattended. The way forward is two explicit
@@ -135,20 +136,18 @@ async function takeover(pathArg, opts = {}) {
         + holder.folderPath + (holder.branch ? ` on branch ${holder.branch}` : "")
         + ". Run `niro discard-temp-project` in that folder first, then re-run this here.");
     }
-    if (!(await prompt.confirm("  Move the temporary project to this folder?", false))) {
+    if (!(await prompt.confirm("    Move the temporary project to this folder?", false))) {
       throw new Error("Cancelled — the temporary project stays where it is.");
     }
   }
 
-  console.log(`\n  Creating a temporary private project of ${color.bold(source.alias || source.project_id)}...`);
-  console.log(color.dim("  Your original project is not changed."));
+  console.log(`\n    Creating a temporary private project of ${color.bold(source.alias || source.project_id)}...`);
+  console.log(color.dim("    Your original project is not changed."));
 
   // 2. Create-or-extend server-side (ADR-016). If you already have a temporary project of this project,
   // the backend EXTENDS it — adds this repo to the same copy — instead of minting a second one, so
   // cross-repo answers stay coherent. Either way this folder's repo becomes AGENT_UPLOAD.
-  const outcome = await api.post(
-    `/api/projects/${encodeURIComponent(source.project_id)}/clone`,
-    { local_git_ids: [source.git_id], branch });
+  const outcome = await requestClone(source.project_id, source.git_id, branch);
   const newProjectId = outcome.new_project_id || outcome.newProjectId;
   const gitIdMap = outcome.git_id_map || outcome.gitIdMap || {};
   const newGitId = gitIdMap[source.git_id];
@@ -164,16 +163,16 @@ async function takeover(pathArg, opts = {}) {
   // route; its absence means a version mismatch the user must hear about NOW, not discover via wrong answers.
   const serverRoutes = outcome.routing_supported === true || outcome.routingSupported === true;
   if (!serverRoutes) {
-    console.log(warn("\n  ⚠ Your backend did NOT confirm automatic routing (pre-ADR-018 server?)."));
+    console.log(warn("\n    ⚠ Your backend did NOT confirm automatic routing (pre-ADR-018 server?)."));
     console.log(warn("    This CLI no longer re-pins .niro-project, so against this backend Niro's answers"));
     console.log(warn("    will KEEP coming from the original project — NOT this temporary project."));
     console.log(warn("    Fix: upgrade the backend (ai-assistant + ai-orchestrator), or use the previous CLI."));
   }
   if (wasExtended) {
-    console.log(`  ${step("●")}  Added this repo to your temporary project: ${color.bold(outcome.alias || newProjectId)} ` +
+    console.log(`    ${step("●")}  Added this repo to your temporary project: ${color.bold(outcome.alias || newProjectId)} ` +
         color.dim("(existing copy extended — your other repos are untouched)"));
   } else {
-    console.log(`  ${step("●")}  Temporary project created: ${color.bold(outcome.alias || newProjectId)} ` +
+    console.log(`    ${step("●")}  Temporary project created: ${color.bold(outcome.alias || newProjectId)} ` +
         color.dim(`(${outcome.nodes_copied ?? "?"} nodes copied, no re-index needed)`));
   }
 
@@ -191,7 +190,7 @@ async function takeover(pathArg, opts = {}) {
     folderSync.warnOversizeFiles(manifest, filterResult, (m) => console.log(warn(m)));
     const sizes = {};
     for (const m of manifest) sizes[m.path] = m.size_bytes;
-    console.log(`  ${step("●")}  Uploading working tree: ${includedPaths.length} files ` +
+    console.log(`    ${step("●")}  Uploading working tree: ${includedPaths.length} files ` +
         `(branch ${color.cyan(branch || "detached HEAD")})...`);
     // Capture the uploaded hashes: takeover registers its watchState entry AFTER this upload (below), so
     // doInitialSync's own watchState.update no-ops (no entry yet). Seeding these into the final set means
@@ -204,9 +203,9 @@ async function takeover(pathArg, opts = {}) {
       await api.post(`/api/graph/${encodeURIComponent(newProjectId)}/build`, {}, {
         query: { force_full_rebuild: "false" },
       });
-      console.log(`  ${step("●")}  Incremental index of your working tree triggered.`);
+      console.log(`    ${step("●")}  Incremental index of your working tree triggered.`);
     } catch (buildErr) {
-      console.log(warn(`  ⚠ Could not trigger the index build automatically (${buildErr.message}). ` +
+      console.log(warn(`    ⚠ Could not trigger the index build automatically (${buildErr.message}). ` +
           "Run `niro build` to index your uploaded tree."));
     }
 
@@ -266,11 +265,94 @@ async function takeover(pathArg, opts = {}) {
     }
   }
 
-  console.log(`\n  ${ok("✓")} Niro now answers from your temporary project whenever you are on this branch`);
+  console.log(`\n    ${ok("✓")} Niro now answers from your temporary project whenever you are on this branch`);
   console.log(color.dim("    (routing is automatic per branch — your .niro-project file was NOT changed)."));
-  console.log(`  ${ok("✓")} Local edits stream in live while ${color.bold("niro watch")} is running.`);
-  console.log(color.dim("\n  When your branch is merged: `niro discard-temp-project` deletes the temporary project;"));
-  console.log(color.dim("  routing falls back to the original project by itself."));
+  console.log(`    ${ok("✓")} Local edits stream in live while ${color.bold("niro watch")} is running.`);
+  console.log(color.dim("\n    When your branch is merged: `niro discard-temp-project` deletes the temporary project;"));
+  console.log(color.dim("    routing falls back to the original project by itself."));
 }
 
-module.exports = { takeover };
+
+/**
+ * Ask the server for a working copy, and wait for it without holding the request open.
+ *
+ * WHY. The copy takes 44 to 60 seconds. It used to run inside the POST, and the gateway in front of
+ * the server gives up at 60, so three requests at once on 2026-08-26 all came back as HTML 504 pages.
+ * A 504 also says nothing about whether the work finished: the real error underneath, a duplicate key
+ * from a migration that had not been run, went unread for an afternoon because of it.
+ *
+ * WORKS AGAINST BOTH SERVERS, and that is why it branches on the RESPONSE rather than on a version.
+ * A server that understands `async` returns 202 and a job id to poll. An older one ignores the unknown
+ * field and returns the outcome inline exactly as before, which is the shape this already handled. So
+ * there is no capability check to keep in step, and no flag day.
+ */
+async function requestClone(projectId, gitId, branch, opts = {}) {
+  const started = await api.post(
+    `/api/projects/${encodeURIComponent(projectId)}/clone`,
+    { local_git_ids: [gitId], branch, async: true });
+
+  const jobId = started && (started.job_id || started.jobId);
+  if (!jobId) {
+    return started; // older server: it did the work inline and this IS the outcome
+  }
+
+  // Poll until it finishes. The interval is deliberately not tight: nothing is waiting on the answer
+  // faster than a person reads, and a shorter one only adds load to the server doing the copy.
+  // A seam, not a knob: tests pass a small value so they do not sit through real polls.
+  const POLL_MS = opts.pollMs || 2000;
+  const GIVE_UP_MS = opts.giveUpMs || 15 * 60 * 1000;
+  const startedAt = Date.now();
+  const deadline = startedAt + GIVE_UP_MS;
+  const sp = spinner.start("Building your temporary project...");
+  try {
+    for (;;) {
+      await sleep(POLL_MS);
+      let job;
+      try {
+        job = await api.get(`/api/projects/clone/job/${encodeURIComponent(jobId)}`);
+      } catch (e) {
+        // A blip while polling is not a failed clone. The copy is running on the server regardless of
+        // whether this one request reached it, so keep waiting rather than reporting a failure that
+        // has not happened. A 404 is different: the job is gone, and waiting cannot bring it back.
+        // Waiting cannot fix an expired token or a revoked account, and 15 minutes of silent retrying
+        // before finally reporting it is worse than saying so at once.
+        if (e && (e.status === 401 || e.status === 403)) {
+          throw e;
+        }
+        if (e && e.status === 404) {
+          throw new Error(
+            `The server has no record of clone job ${jobId}. It may have expired, or the server was `
+            + "restarted mid-copy. Run `niro new-temp-project` again.");
+        }
+        if (Date.now() > deadline) throw e;
+        continue;
+      }
+      const state = job && job.state;
+      if (state === "SUCCEEDED") {
+        sp.stop();
+        return job.outcome;
+      }
+      if (state === "FAILED") {
+        sp.stop();
+        throw new Error(job.error || "The server could not create the temporary project.");
+      }
+      if (Date.now() > deadline) {
+        sp.stop();
+        throw new Error(
+          `Still building after ${Math.round(GIVE_UP_MS / 60000)} minutes. The server may still finish; `
+          + `check with \`niro status\` before running this again.`);
+      }
+      // Deliberately NOT re-labelled with the elapsed time. Without a TTY the spinner prints a fresh
+      // line every time the label CHANGES, so putting the seconds in it produced one line per poll:
+      // measured at 10 lines in 11 seconds. The spinner already shows elapsed time where it can.
+    }
+  } finally {
+    sp.stop();
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+module.exports = { takeover, requestClone};

package/src/commands/watch.js

@@ -157,7 +157,7 @@ async function watch(pathArg, opts = {}) {
           const resolved = path.resolve(entry.folderPath);
           if (!watched.has(resolved)) {
             watched.add(resolved);
-            console.log(`  ${color.green("↻")} Now watching new folder: ${entry.folderPath}`);
+            console.log(`    ${color.green("↻")} Now watching new folder: ${entry.folderPath}`);
             startWatch(entry.folderPath, opts).catch(err => handleEntryFailure(entry, err, watched));
           }
         }
@@ -173,9 +173,9 @@ async function watch(pathArg, opts = {}) {
       fs.watch(stateDir, { persistent: false }, (_evt, filename) => {
         if (!filename || filename === stateName) reconcile();
       }).on("error", (err) =>
-        console.error(color.yellow(`  State-file watcher error (recovered): ${err.message}`)));
+        console.error(color.yellow(`    State-file watcher error (recovered): ${err.message}`)));
     } catch (err) {
-      console.error(color.yellow(`  Could not watch the state file for new folders: ${err.message}`));
+      console.error(color.yellow(`    Could not watch the state file for new folders: ${err.message}`));
     }
     // Keep process alive
     await new Promise(() => {});
@@ -203,7 +203,7 @@ async function handleEntryFailure(entry, err, watched) {
         const removed = watchState.remove(entry.folderPath, entry.gitId);
         if (!removed) {
           console.error(color.yellow(
-            `  Self-heal skipped for ${entry.folderPath}: it was re-pointed to a new repo mid-check — kept.`));
+            `    Self-heal skipped for ${entry.folderPath}: it was re-pointed to a new repo mid-check — kept.`));
           return;
         }
         // CRITICAL: also drop the folder from the daemon's live `watched` set. Otherwise, when the same
@@ -212,7 +212,7 @@ async function handleEntryFailure(entry, err, watched) {
         // silently stop syncing until a full daemon restart. Pruning here lets the reconcile re-adopt it.
         if (watched) watched.delete(path.resolve(entry.folderPath));
         console.error(color.yellow(
-          `  Self-healed: ${entry.folderPath} pointed at a repo that no longer exists on this ` +
+          `    Self-healed: ${entry.folderPath} pointed at a repo that no longer exists on this ` +
           `backend (${entry.gitId}) — entry removed; other folders unaffected.`));
         return;
       }
@@ -238,8 +238,8 @@ async function startWatch(targetDir, opts = {}) {
 
   const { gitId } = state;
 
-  console.log(`\n  ${color.cyan("Watching")} ${targetDir}`);
-  console.log(`  gitId: ${color.dim(gitId)}`);
+  console.log(`\n    ${color.cyan("Watching")} ${targetDir}`);
+  console.log(`    gitId: ${color.dim(gitId)}`);
 
   // Delta sync on startup. A repo-not-found error must still propagate so the caller's handleEntryFailure
   // can self-heal a poison entry. But a TRANSIENT failure (network blip at daemon start) must NOT prevent
@@ -251,7 +251,7 @@ async function startWatch(targetDir, opts = {}) {
   } catch (err) {
     if (agentApi.isRepoNotFound(err)) throw err; // poison entry — let handleEntryFailure remove it
     console.error(color.yellow(
-      `  Initial sync failed for ${targetDir} (${err.message}) — watching anyway; the backstop will retry.`));
+      `    Initial sync failed for ${targetDir} (${err.message}) — watching anyway; the backstop will retry.`));
   }
 
   // Start heartbeat. Re-read fresh state each tick exactly like the backstop below: a `niro
@@ -294,16 +294,16 @@ async function startWatch(targetDir, opts = {}) {
       // A rejection here would be an unhandled promise rejection = process death in
       // modern Node. One file's failure must never take the daemon down.
       handleFileEvent(gitId, targetDir, relativePath, state).catch(err =>
-        console.error(color.red(`  Watch event failed for ${relativePath}: ${err.message}`)));
+        console.error(color.red(`    Watch event failed for ${relativePath}: ${err.message}`)));
     }, DEBOUNCE_MS));
   });
 
   // fs.watch emits 'error' events (EMFILE, watched dir removed, …); with no listener
   // an EventEmitter 'error' THROWS and kills the process.
   watcher.on("error", (err) =>
-    console.error(color.red(`  Watcher error for ${targetDir}: ${err.message}`)));
+    console.error(color.red(`    Watcher error for ${targetDir}: ${err.message}`)));
 
-  console.log(`  ${color.green("✓")} Watching for changes. Press Ctrl+C to stop.\n`);
+  console.log(`    ${color.green("✓")} Watching for changes. Press Ctrl+C to stop.\n`);
 
   // Graceful shutdown
   process.on("SIGINT", () => {
@@ -311,7 +311,7 @@ async function startWatch(targetDir, opts = {}) {
     clearInterval(rescanTimer);
     watcher.close();
     for (const t of debounceTimers.values()) clearTimeout(t);
-    console.log("\n  Watch stopped.");
+    console.log("\n    Watch stopped.");
     process.exit(0);
   });
 
@@ -366,7 +366,7 @@ async function deltaSyncOnResume(gitId, targetDir, state, opts = {}) {
       return { notHolder: true };
     }
     if (notHolding.delete(inFlightKey)) {
-      console.log(color.green(`  ${targetDir} holds the temporary project again — resuming uploads.`));
+      console.log(color.green(`    ${targetDir} holds the temporary project again — resuming uploads.`));
     }
   }
   const storedHashes = state.fileHashes || {};
@@ -387,14 +387,14 @@ async function deltaSyncOnResume(gitId, targetDir, state, opts = {}) {
     if (!unreadableRoots.has(path.resolve(targetDir))) {
       unreadableRoots.add(path.resolve(targetDir));
       console.error(color.red(
-        `  Cannot read ${targetDir} — skipping this sync entirely rather than reporting every file ` +
+        `    Cannot read ${targetDir} — skipping this sync entirely rather than reporting every file ` +
         `deleted. Check the folder still exists and is readable. ` +
         `This will not be repeated until it can be read again.`));
     }
     return;
   }
   if (unreadableRoots.delete(path.resolve(targetDir))) {
-    console.log(color.green(`  ${targetDir} is readable again — syncing resumed.`));
+    console.log(color.green(`    ${targetDir} is readable again — syncing resumed.`));
   }
 
   const unreadable = [];
@@ -423,7 +423,7 @@ async function deltaSyncOnResume(gitId, targetDir, state, opts = {}) {
 
   if (unreadable.length > 0) {
     console.warn(color.yellow(
-      `  ${unreadable.length} file(s) could not be read this pass — keeping them as-is rather than ` +
+      `    ${unreadable.length} file(s) could not be read this pass — keeping them as-is rather than ` +
       `reporting them deleted. Sample: ${unreadable.slice(0, 5).join(", ")}`));
   }
 
@@ -446,13 +446,13 @@ async function deltaSyncOnResume(gitId, targetDir, state, opts = {}) {
 
   if (unreadableDirs.length > 0) {
     console.warn(color.yellow(
-      `  ${failedDirs.length} directory(ies) could not be read this pass, so ${unreadableDirs.length} ` +
+      `    ${failedDirs.length} directory(ies) could not be read this pass, so ${unreadableDirs.length} ` +
       `file(s) under them are being left alone rather than reported deleted. ` +
       `Sample: ${failedDirs.slice(0, 3).join(", ")}`));
   }
 
   if (changed.length === 0 && deleted.length === 0) {
-    if (!quiet) console.log(`  No changes since last sync.`);
+    if (!quiet) console.log(`    No changes since last sync.`);
     watchState.mergeFileHashes(targetDir, { set: currentHashes, expectedGitId: gitId });
     // Nothing to send, so the server was never contacted and this pass is not evidence it is healthy.
     // This is the MAJORITY of backstop ticks: treated as a success it cleared the failure count on the
@@ -461,7 +461,7 @@ async function deltaSyncOnResume(gitId, targetDir, state, opts = {}) {
   }
 
   // A quiet backstop run only speaks up when it actually found something fs.watch missed.
-  console.log(`  ${quiet ? color.yellow("↻ backstop: ") : ""}Delta: ${changed.length} changed, ${deleted.length} deleted — syncing...`);
+  console.log(`    ${quiet ? color.yellow("↻ backstop: ") : ""}Delta: ${changed.length} changed, ${deleted.length} deleted — syncing...`);
 
   // Honor .gitignore (+ fail-closed-for-config) on the changed set BEFORE upload,
   // using the same helper as init/add-repo. A gitignored secret edited after
@@ -525,12 +525,12 @@ async function deltaSyncOnResume(gitId, targetDir, state, opts = {}) {
       // only never throws, so without this the caller saw a clean resolve while every single delete was
       // being refused, cleared the backoff, and retried the whole set 60 seconds later. Forever.
       failures++;
-      console.warn(color.yellow(`  Warning: failed to delete ${rp}: ${err.message}`));
+      console.warn(color.yellow(`    Warning: failed to delete ${rp}: ${err.message}`));
     }
   }
   if (reappeared.length > 0) {
     console.warn(color.yellow(
-      `  ${reappeared.length} file(s) were back on disk by the time the delete ran — not deleted. ` +
+      `    ${reappeared.length} file(s) were back on disk by the time the delete ran — not deleted. ` +
       `Sample: ${reappeared.slice(0, 5).join(", ")}`));
     // Deliberately NOT re-hashed into the baseline. The file may have come back with DIFFERENT bytes
     // (a branch switch or stash pop mid-upload), and it was in `deleted` rather than `changed`, so it
@@ -550,9 +550,9 @@ async function deltaSyncOnResume(gitId, targetDir, state, opts = {}) {
     patch: { lastSyncedAt: new Date().toISOString() },
     expectedGitId: gitId,
   })) {
-    console.log(color.dim("  Folder was re-pointed during this sync — its results were not recorded."));
+    console.log(color.dim("    Folder was re-pointed during this sync — its results were not recorded."));
   }
-  console.log(`  ${color.green("✓")} Delta sync complete.`);
+  console.log(`    ${color.green("✓")} Delta sync complete.`);
   return { failures };
   } finally {
     syncInFlight.delete(inFlightKey);
@@ -573,7 +573,7 @@ function queueDelete(targetDir, relativePath, settleMs = DELETE_SETTLE_MS) {
   if (entry.timer) clearTimeout(entry.timer);
   entry.timer = setTimeout(() => {
     flushPendingDeletes(targetDir).catch(err =>
-      console.error(color.red(`  Delete flush failed for ${targetDir}: ${err.message}`)));
+      console.error(color.red(`    Delete flush failed for ${targetDir}: ${err.message}`)));
   }, settleMs);
   if (entry.timer.unref) entry.timer.unref(); // must never hold the daemon open
 }
@@ -609,7 +609,7 @@ async function flushPendingDeletes(targetDir) {
 
   if (returned.length > 0) {
     console.log(color.dim(
-      `  ${returned.length} file(s) reappeared while settling — not deleted` +
+      `    ${returned.length} file(s) reappeared while settling — not deleted` +
       (returned.length <= 3 ? `: ${returned.join(", ")}` : "")));
   }
 
@@ -621,11 +621,11 @@ async function flushPendingDeletes(targetDir) {
         patch: { lastSyncedAt: new Date().toISOString() },
         expectedGitId: fresh.gitId,
       });
-      console.log(`  ${color.yellow("−")} ${rp}`);
+      console.log(`    ${color.yellow("−")} ${rp}`);
     } catch (err) {
       // Keep the baseline entry so a later pass retries. Dropping it here is how a refused delete
       // became permanent (see fb3ff0a).
-      console.error(color.red(`  Failed to delete ${rp}: ${err.message}`));
+      console.error(color.red(`    Failed to delete ${rp}: ${err.message}`));
     }
   }
 }
@@ -661,18 +661,18 @@ function backstopTick(targetDir) {
         if (result.failures > 0) {
           const delayMs = recordBackstopFailure(backoffKey, Date.now());
           console.error(color.red(
-            `  ${result.failures} file operation(s) failed for ${targetDir} — retrying in ` +
+            `    ${result.failures} file operation(s) failed for ${targetDir} — retrying in ` +
             `${Math.round(delayMs / 60_000)} min.`));
           return;
         }
         if (recordBackstopSuccess(backoffKey)) {
-          console.log(color.green(`  Sync recovered for ${targetDir}.`));
+          console.log(color.green(`    Sync recovered for ${targetDir}.`));
         }
       })
       .catch(err => {
         const delayMs = recordBackstopFailure(backoffKey, Date.now());
         console.error(color.red(
-          `  Backstop re-scan failed for ${targetDir}: ${err.message} — retrying in ` +
+          `    Backstop re-scan failed for ${targetDir}: ${err.message} — retrying in ` +
           `${Math.round(delayMs / 60_000)} min.`));
       });
 }
@@ -714,19 +714,19 @@ async function handleFileEvent(gitId, targetDir, relativePath, state) {
           // A daemon has no TTY — never block on (or crash in) a prompt. Leave the
           // directory unsynced and tell the user how to include it.
           console.log(color.yellow(
-            `  New directory '${relativePath}' detected — not synced. ` +
+            `    New directory '${relativePath}' detected — not synced. ` +
             `Run \`niro watch\` interactively (or \`niro edit\`) to include it.`));
           return;
         }
         const add = await prompt.confirm(
-          `\n  New directory '${relativePath}' detected. Add to sync?`,
+          `\n    New directory '${relativePath}' detected. Add to sync?`,
           false
         );
         if (add) {
           const newPattern = relativePath + "/**";
           state.includePatterns.push(newPattern);
           watchState.update(targetDir, { includePatterns: state.includePatterns });
-          console.log(`  Added include pattern: ${color.cyan(newPattern)}`);
+          console.log(`    Added include pattern: ${color.cyan(newPattern)}`);
         } else {
           state.excludePatterns.push(relativePath + "/**");
           watchState.update(targetDir, { excludePatterns: state.excludePatterns });
@@ -784,9 +784,9 @@ async function handleFileEvent(gitId, targetDir, relativePath, state) {
       patch: { lastSyncedAt: new Date().toISOString() },
       expectedGitId: gitId,
     });
-    console.log(`  ${color.green("+")} ${relativePath}`);
+    console.log(`    ${color.green("+")} ${relativePath}`);
   } catch (err) {
-    console.error(color.red(`  Failed to sync ${relativePath}: ${err.message}`));
+    console.error(color.red(`    Failed to sync ${relativePath}: ${err.message}`));
   }
 }
 

package/src/index.js

@@ -31,13 +31,21 @@ function main() {
     if (!program.opts().apiUrl) return;
     if (actionCommand.name() === "login") return;
     console.error("`--api-url` only applies to `niro login`.");
-    console.error("  It was ignored by the upload path, so using it here would read from one");
-    console.error("  backend and write to another. Pick the backend once instead:");
+    console.error("    It was ignored by the upload path, so using it here would read from one");
+    console.error("    backend and write to another. Pick the backend once instead:");
     console.error("    niro login --api-url <url>        log in to that backend");
     console.error("    NIRO_API_URL=<url> niro <cmd>     or set it for every command");
     process.exit(1);
   });
 
+  program
+    .command("start [path]")
+    .description("First-time setup, end to end: sign in, onboard this folder, connect your AI assistant.")
+    .action((pathArg) => run(async () => {
+      const startCmd = require("./commands/start");
+      await startCmd.start(pathArg, {});
+    }));
+
   program
     .command("login")
     .description("Log in to Niro. Default: device authorization in your browser. (--api-key or --password for alternatives.)")
@@ -134,6 +142,44 @@ function main() {
       await cmd.addProject({ ...opts });
     }));
 
+  // `niro ab` subcommand group
+  const ab = program
+    .command("ab")
+    .description("Measure what Niro changes: run it off for half your sessions, then compare.");
+
+  ab
+    .command("status", { isDefault: true })
+    .description("Is a measurement window open, and until when?")
+    .action(() => run(async () => {
+      await require("./commands/ab").status();
+    }));
+
+  ab
+    .command("enable")
+    .description("Start a measurement window. Account-wide; asks first.")
+    .option("--days <n>", "window length in days (default: 14)")
+    .option("--name <name>", "label for this run")
+    .option("-y, --yes", "skip the confirmation (for scripts)")
+    .action((opts) => run(async () => {
+      await require("./commands/ab").enable({ ...opts });
+    }));
+
+  ab
+    .command("disable")
+    .description("Stop the current window early. Every session uses Niro again.")
+    .action(() => run(async () => {
+      await require("./commands/ab").disable();
+    }));
+
+  ab
+    .command("report")
+    .description("Show the with-Niro and without-Niro comparison.")
+    .option("--run-id <id>", "a specific past run (default: the latest)")
+    .option("--json", "emit machine-readable JSON")
+    .action((opts) => run(async () => {
+      await require("./commands/ab").report({ ...opts });
+    }));
+
   program
     .command("info [path]")
     .description("Show what Niro knows about this folder: git info + which project(s) it maps to and their status.")
@@ -300,6 +346,14 @@ function main() {
     .option("--off", "Stop showing the end-of-task line.")
     .action((opts) => { require("./commands/mcp").receipt(opts); });
 
+  // Bare `niro` used to print an 18-command help listing, which is the worst possible
+  // first screen for someone who does not yet know what any of them do. With no stored
+  // credentials that person is, by definition, new: send them to the wizard instead.
+  // Once they have credentials the help listing is what they asked for, so it stays.
+  if (process.argv.length <= 2 && !require("./commands/start").hasCredentials()) {
+    process.argv.push("start");
+  }
+
   program.parseAsync(process.argv).catch((err) => {
     console.error(err && err.message ? err.message : err);
     process.exit(1);
@@ -319,7 +373,7 @@ function run(fn) {
         process.exit(1);
       }
       console.error(err && err.stack ? err.stack.split("\n")[0] : String(err));
-      if (err && err.status) console.error(`  (HTTP ${err.status})`);
+      if (err && err.status) console.error(`    (HTTP ${err.status})`);
       process.exit(1);
     });
 }

package/src/lib/folderSync.js

@@ -165,6 +165,11 @@ const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
  * candidate that git ignores. Pass { honorGitignore: false } to skip the git
  * pass (used by tests that assert the raw walk).
  */
+/** Current nesting depth as spaces. \r-repainted lines bypass withIndent's console wrappers. */
+function nestPad() {
+  return " ".repeat(require("./nestedOutput").currentIndent());
+}
+
 function buildManifest(rootDir, opts = {}) {
   const manifest = [];
   walkDir(rootDir, rootDir, manifest);
@@ -244,7 +249,7 @@ function gitignoreDrops(rootDir, relPaths) {
   const { ok, ignored } = git.checkIgnored(repoRoot, repoRelPaths);
   if (!ok) {
     console.log(color.yellow(
-      "  ⚠ WARNING: could not run `git check-ignore`, so .gitignore can't be " +
+      "    ⚠ WARNING: could not run `git check-ignore`, so .gitignore can't be " +
       "honored — dropping config/env files from this upload to avoid leaking " +
       "secrets (source files are still uploaded)."
     ));
@@ -358,10 +363,10 @@ async function aggregateGuard(targetDir, includedPaths, sizes) {
   const msg = `Large upload — ${reasons.join("; ")}.`;
 
   if (prompt.isNonInteractive()) {
-    console.log(color.yellow(`  ⚠ WARNING: ${msg} Proceeding (non-interactive).`));
+    console.log(color.yellow(`    ⚠ WARNING: ${msg} Proceeding (non-interactive).`));
     return;
   }
-  const proceed = await prompt.confirm(`  ⚠ ${msg} Continue?`, false);
+  const proceed = await prompt.confirm(`    ⚠ ${msg} Continue?`, false);
   if (!proceed) {
     throw new Error("Upload cancelled by user.");
   }
@@ -404,14 +409,14 @@ async function uploadBatchWithRetry(gitId, sessionId, fileBatch) {
  */
 async function doInitialSync(gitId, targetDir, includedPaths, { sizes } = {}) {
   if (!includedPaths || includedPaths.length === 0) {
-    console.log(`  ${color.yellow("No files to sync.")} Check your include/exclude patterns.`);
+    console.log(`    ${color.yellow("No files to sync.")} Check your include/exclude patterns.`);
     return;
   }
 
   await aggregateGuard(targetDir, includedPaths, sizes);
 
   const total = includedPaths.length;
-  console.log(`\n  Starting initial sync (${total} files)...`);
+  console.log(`\n    Starting initial sync (${total} files)...`);
   const sessionId = await agentApi.startSync(gitId);
 
   const batches = chunk(includedPaths, BATCH_SIZE);
@@ -442,7 +447,7 @@ async function doInitialSync(gitId, targetDir, includedPaths, { sizes } = {}) {
       uploaded += fileBatch.length;
       // Denominator excludes files that disappeared, so progress can still reach 100%.
       const pct = Math.round((uploaded / Math.max(1, total - dropped)) * 100);
-      process.stdout.write(`\r  Uploading... ${pct}% (${uploaded}/${total - dropped})`);
+      process.stdout.write(`\r${nestPad()}    Uploading... ${pct}% (${uploaded}/${total - dropped})`);
     }
   }
 
@@ -454,7 +459,7 @@ async function doInitialSync(gitId, targetDir, includedPaths, { sizes } = {}) {
 
   // Never drop files silently — surface the count (no names/content).
   if (!firstError && dropped > 0) {
-    console.log(color.yellow(`  ⚠ ${dropped} file(s) disappeared during upload and were skipped.`));
+    console.log(color.yellow(`    ⚠ ${dropped} file(s) disappeared during upload and were skipped.`));
   }
 
   if (firstError) {
@@ -476,7 +481,7 @@ async function doInitialSync(gitId, targetDir, includedPaths, { sizes } = {}) {
   }
   watchState.update(targetDir, { fileHashes: hashes, lastSyncedAt: new Date().toISOString() });
 
-  console.log(`  ${color.green("✓")} Initial sync complete.`);
+  console.log(`    ${color.green("✓")} Initial sync complete.`);
   // Return the computed hashes so a caller that registers its watchState entry AFTER the upload (takeover)
   // can seed fileHashes directly — watchState.update above no-ops when no entry exists yet, so without this
   // the daemon would re-upload the whole tree on its first pass.