@niroai/niro 0.9.0 → 0.10.0

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.

package/src/lib/moduleExcludeSuggestions.js

@@ -23,7 +23,7 @@ async function offerModuleExcludeSuggestions(gitId, opts = {}, alreadySupplied =
   }
   if (!Array.isArray(suggestions) || suggestions.length === 0) return;
 
-  console.log(`\n  ${color.cyan("Suggested module exclusions")} (modules that are usually noise):`);
+  console.log(`\n    ${color.cyan("Suggested module exclusions")} (modules that are usually noise):`);
   const accepted = [];
   for (const s of suggestions) {
     const count = s.module_count || s.moduleCount || 0;
@@ -33,24 +33,24 @@ async function offerModuleExcludeSuggestions(gitId, opts = {}, alreadySupplied =
       `    ${color.dim(s.pattern.padEnd(28))} ${String(count).padStart(3)} module${count === 1 ? "" : "s"}  ${color.dim(label)}`
     );
     if (samples.length > 0) {
-      console.log(`      ${color.dim("e.g. " + samples.join(", "))}`);
+      console.log(`        ${color.dim("e.g. " + samples.join(", "))}`);
     }
     const yes = await prompt.confirm(`    Apply ${color.cyan(s.pattern)}?`, true);
     if (yes) accepted.push(s.pattern);
   }
 
   if (accepted.length === 0) {
-    console.log(`  ${color.dim("No exclusions applied.")}`);
+    console.log(`    ${color.dim("No exclusions applied.")}`);
     return;
   }
 
   try {
     await agentApi.updateModuleExcludePatterns(gitId, accepted);
     console.log(
-      `  ${color.green("✓")} Applied ${accepted.length} exclusion${accepted.length === 1 ? "" : "s"}.`
+      `    ${color.green("✓")} Applied ${accepted.length} exclusion${accepted.length === 1 ? "" : "s"}.`
     );
   } catch (err) {
-    console.log(`  ${color.yellow("Warning:")} failed to save exclusions: ${err.message || err}`);
+    console.log(`    ${color.yellow("Warning:")} failed to save exclusions: ${err.message || err}`);
   }
 }
 

package/src/lib/nestedOutput.js

@@ -0,0 +1,49 @@
+/**
+ * Run something and shift everything it prints one rung deeper.
+ *
+ * `niro start` is a shell around commands that also run on their own. `niro init` printing at
+ * the top level is right when you typed `niro init`; inside the wizard the same lines belong
+ * UNDER "4/5 Onboarding and building the index", and printing them flush with the step markers
+ * is what made step 4 look like a different program had taken over.
+ *
+ * Wrapping the call is the only approach that does not require every helper it reaches
+ * (folderSync, onboardTarget, moduleExcludeSuggestions, watchDaemon, service) to know how deep
+ * it happens to be running. They keep printing at their own level; this adds the offset.
+ *
+ * Blank lines are left blank rather than padded with spaces, so nothing trails whitespace.
+ * process.stdout.write is untouched: the upload progress bar repaints one line with \r, and
+ * prefixing every repaint would smear it across the terminal.
+ */
+let current = 0;
+
+/** How deep the output is nested right now. prompt.js prefixes its questions with this. */
+function currentIndent() {
+  return current;
+}
+
+function withIndent(spaces, fn) {
+  const pad = " ".repeat(spaces);
+  const shift = (orig) => (...args) => {
+    const text = args.map((a) => (typeof a === "string" ? a : String(a))).join(" ");
+    // A line with nothing but spaces is emitted empty. Some callers print a whitespace-only
+    // string as a spacer, and padding it left a visible run of trailing whitespace.
+    orig(text.split("\n").map((l) => (l.trim() ? pad + l : "")).join("\n"));
+  };
+  const log = console.log;
+  const error = console.error;
+  const warn = console.warn;
+  current += spaces;
+  console.log = shift(log);
+  console.error = shift(error);
+  console.warn = shift(warn);
+  return Promise.resolve()
+    .then(fn)
+    .finally(() => {
+      current -= spaces;
+      console.log = log;
+      console.error = error;
+      console.warn = warn;
+    });
+}
+
+module.exports = { withIndent, currentIndent };

package/src/lib/onboardTarget.js

@@ -208,7 +208,7 @@ function ensureOnboardable(targetDir, opts = {}) {
 
   const reason = protectedRootReason(resolved);
   if (reason) {
-    console.error(color.red(`\n  ✗ Refusing to onboard ${reason} (${resolved}).`));
+    console.error(color.red(`\n    ✗ Refusing to onboard ${reason} (${resolved}).`));
     console.error("    That would upload source from every project underneath it, pin this folder");
     console.error("    with a .niro-project file, and watch the whole tree for changes.");
     console.error(`    Change into the project folder you meant, then run the command there.`);
@@ -223,17 +223,17 @@ function ensureOnboardable(targetDir, opts = {}) {
     // The protected-root rule above still applied, and still refuses.
     if (opts.alreadyRegistered) {
       console.log(color.dim(
-        `  No build file in ${resolved}, but it is already registered here — continuing.`
+        `    No build file in ${resolved}, but it is already registered here — continuing.`
       ));
       return true;
     }
     if (opts.force) {
       console.log(color.yellow(
-        `\n  ⚠ No project found in ${resolved}, but --force was passed. Onboarding it anyway.`
+        `\n    ⚠ No project found in ${resolved}, but --force was passed. Onboarding it anyway.`
       ));
       return true;
     }
-    console.error(color.red(`\n  ✗ No project found in ${resolved}.`));
+    console.error(color.red(`\n    ✗ No project found in ${resolved}.`));
     console.error("    Niro looks for a build file (package.json, pom.xml, go.mod, ...) in this");
     console.error(`    folder or just below it${truncated ? " (the scan stopped early — the tree is very large)" : ""}. None found.`);
     console.error("    Pass --force if you really mean to upload this folder.");
@@ -241,7 +241,7 @@ function ensureOnboardable(targetDir, opts = {}) {
   }
 
   console.log(
-    `  ${color.green("✓")} Found ${roots} project${roots === 1 ? "" : "s"} ` +
+    `    ${color.green("✓")} Found ${roots} project${roots === 1 ? "" : "s"} ` +
     `(${describeIndicators(indicators)}).`
   );
   return true;

package/src/lib/prompt.js

@@ -18,6 +18,9 @@ function rl() {
  * Also shared by the MCP setup/teardown wizards' own ask() helpers.
  */
 function formatPrompt(question, defaultValue) {
+  // Questions asked from inside a nested step sit at that step's depth. readline writes
+  // straight to stdout, so withIndent's console wrappers never see them.
+  question = " ".repeat(require("./nestedOutput").currentIndent()) + question;
   return defaultValue != null && defaultValue !== ""
     ? `${question} ${color.dim(`(default: ${defaultValue})`)}: `
     : `${question}: `;

package/src/lib/service.js

@@ -68,26 +68,30 @@ function install() {
   // Stop any existing instance so we can re-register cleanly
   spawnSync("pm2", ["delete", PROCESS_NAME], { shell: true, stdio: "pipe" });
 
-  // Start niro-watch under PM2
+  // PM2's own output is captured, not inherited. Inheriting it put ~55 lines into the middle
+  // of setup: a box-drawing process table, the entire generated systemd unit file, and the
+  // user's PATH twice. None of it is ours and none of it is actionable while it is working.
+  // It IS printed on failure, where it is the only diagnostic there is.
   const startResult = spawnSync(
     "pm2",
     ["start", niroBin, "--name", PROCESS_NAME, "--", "watch"],
-    { shell: true, stdio: "inherit" }
+    { shell: true, encoding: "utf8" }
   );
   if (startResult.status !== 0) {
+    console.error(color.dim(`${startResult.stdout || ""}${startResult.stderr || ""}`));
     throw new Error("pm2 start failed");
   }
 
   // Persist the process list so PM2 restores it after a manual `pm2 resurrect`
-  spawnSync("pm2", ["save"], { shell: true, stdio: "inherit" });
+  spawnSync("pm2", ["save"], { shell: true, encoding: "utf8" });
 
   // Wire into OS startup — pm2 startup detects systemd / launchd / etc.
   // It prints the exact privileged command we need to run.
   console.log(
-    `\n  ${color.bold("Setting up auto-start on login")} — PM2 will ask for your password to register`
+    `\n    ${color.bold("Setting up auto-start on login")} — PM2 will ask for your password to register`
   );
   console.log(
-    `  with the system startup manager (${getInitSystem()}). This only needs to happen once.\n`
+    `    with the system startup manager (${getInitSystem()}). This only needs to happen once.\n`
   );
 
   const startupProbe = spawnSync("pm2", ["startup"], {
@@ -97,21 +101,25 @@ function install() {
 
   const setupCmd = extractSetupCommand(startupProbe.stdout + startupProbe.stderr);
   if (setupCmd) {
-    console.log(`  Running: ${color.dim(setupCmd)}\n`);
+    console.log(`    Running: ${color.dim(setupCmd)}\n`);
+    // stdio is split: stdin stays connected so sudo can still prompt for the password, but
+    // PM2's forty lines of generated unit file are captured and only shown if it fails.
     const r = spawnSync(setupCmd, {
       shell: true,
-      stdio: "inherit",
+      stdio: ["inherit", "pipe", "pipe"],
+      encoding: "utf8",
     });
     if (r.status !== 0) {
+      console.error(color.dim(`${r.stdout || ""}${r.stderr || ""}`));
       console.log(
         color.yellow(
-          `  ⚠ Startup hook failed (exit ${r.status}). You can run it manually:\n    ${setupCmd}`
+          `    ⚠ Startup hook failed (exit ${r.status}). You can run it manually:\n    ${setupCmd}`
         )
       );
     }
   } else {
     // PM2 may print nothing if startup is already configured
-    console.log(`  ${color.green("✓")} Startup already configured.`);
+    console.log(`    ${color.green("✓")} Startup already configured.`);
   }
 
   return true;
@@ -127,7 +135,7 @@ function uninstall() {
   spawnSync("pm2", ["save"], { shell: true, stdio: "inherit" });
 
   console.log(
-    `\n  ${color.bold("Removing auto-start hook")} — PM2 may ask for your password.\n`
+    `\n    ${color.bold("Removing auto-start hook")} — PM2 may ask for your password.\n`
   );
   const unstartupResult = spawnSync("pm2", ["unstartup"], {
     shell: true,
@@ -137,7 +145,7 @@ function uninstall() {
     unstartupResult.stdout + unstartupResult.stderr
   );
   if (setupCmd) {
-    console.log(`  Running: ${color.dim(setupCmd)}\n`);
+    console.log(`    Running: ${color.dim(setupCmd)}\n`);
     spawnSync(setupCmd, { shell: true, stdio: "inherit" });
   }
 
@@ -149,7 +157,7 @@ function uninstall() {
  */
 function status() {
   if (!pm2Available()) {
-    console.log(color.yellow("  PM2 is not installed. Run: npm install -g pm2"));
+    console.log(color.yellow("    PM2 is not installed. Run: npm install -g pm2"));
     return;
   }
   spawnSync("pm2", ["show", PROCESS_NAME], { shell: true, stdio: "inherit" });