novahiz 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -5,6 +5,50 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.11.0] - 2026-10-22
+
+### Changed
+
+- **`npm install -g novahiz` is the whole install instruction** - the installer
+  now has two modes and two moments. `--core` is the local half: home, skills,
+  plugin, agent, commands, config, catalog. No network, no `sudo`, so it is safe
+  from a postinstall, a CI job or an agent with no terminal. `--extras` is the
+  network/system half (providers and toolchain, global MCP servers, docs index
+  seed, Obsidian vault, npm refresh) and is replayed at the first real `novahiz`
+  call. Without a flag the installer still does everything in one pass, so
+  `novahiz-install` keeps its historical behaviour.
+- **The first `novahiz` run finishes the setup** - npm 11.16+ blocks install
+  scripts unless `allowScripts` covers the package, and a global install has no
+  `package.json` to record that approval in. `bin/novahiz.mjs` therefore runs
+  `--core` when no manifest exists, then `--extras` in the same invocation, and
+  clears `extrasPending`. `NOVAHIZ_NO_EXTRAS=1` and `NOVAHIZ_AUTOINSTALL=0`
+  remain the opt-outs.
+- **Linux and macOS compatibility** - `which()` and `commandExists()` scan
+  `PATH` (plus `PATHEXT` on Windows) instead of spawning `which`/`where`, which
+  Debian minimal and Alpine do not ship. The opencode `shell` setting follows
+  `$SHELL` on macOS/Linux (zsh by default on macOS) instead of hardcoding
+  `bash`, and keeps the `pwsh`/`powershell` probe on Windows. CI gains an
+  `install` job that runs the core installer and the resulting CLI on ubuntu,
+  macos and windows.
+- **Nothing privileged is executed any more** - the core toolchain bootstrap no
+  longer spawns `sudo apt-get install` or `sh -c "curl … | sh"`. Both are
+  printed as the exact manual command (`manual core python - run: …`), so a CI
+  job or an agent can no longer hang on a password prompt. `brew` and `winget`
+  (structured argv, no privilege escalation) stay executable.
+
+### Removed
+
+- **Four redundant entry points** - `install/bootstrap.mjs`,
+  `install/install.sh`, `install/install.ps1` and `bin/veille-mensuelle.ps1`,
+  together with the `novahiz-bootstrap` bin and the `bootstrap` / `bootstrap:dry`
+  scripts. `novahiz-install` is the single installer; `npm run setup:core` and
+  `npm run setup:extras` cover the two modes.
+
+### Fixed
+
+- **`novahiz --version` printed the usage** - the `command === undefined` branch
+  ran before the `--version` flag check.
+
 ## [0.10.0] - 2026-10-22
 
 ### Fixed

package/README.md

@@ -4,7 +4,7 @@
 
 17 catégories, 94 skills, 13 gate rules, 8 MCP providers — tout déterministe, tout local, tout JSON.
 
-> **Version 0.9.0** — publiée sur npm (`npm install -g --allow-scripts=novahiz novahiz` installe et configure tout : core, plugin, agent, skills packs et Playwright MCP). `CHANGELOG.md` et `scripts/` sont dans le tarball.
+> **Version 0.11.0** — `npm install -g novahiz` pose le CLI, et le premier `novahiz` lancé termine l'installation (core puis extras). `CHANGELOG.md` et `scripts/` sont dans le tarball.
 
 ```
 ┌──────────────────────────────────────────────────────────────────────────┐
@@ -41,28 +41,33 @@
 
 ## Démarrage rapide
 
-### Option 1 — En une ligne (recommandé)
+### Option 1 — npm (recommandé)
 
 ```bash
-npm install -g --allow-scripts=novahiz novahiz
+npm install -g novahiz
+novahiz doctor
 ```
 
-Une commande, tout est en place : CLI, core (skills, plugin, agent, commands), skills packs et Playwright MCP.
+`npm install -g` pose le CLI. Le premier `novahiz` lancé termine le reste, en deux passes : le **core** (skills, plugin, agent, commands, config, catalogue — local, sans réseau ni sudo), puis les **extras** (providers et toolchain, MCP globaux dont Playwright, vault Obsidian, rafraîchissement npm). Une seule fois.
 
-**Pourquoi ce drapeau ?** npm 11.16+ ne considère plus les scripts de lifecycle (`postinstall`) comme autorisés tant qu'ils ne figurent pas dans `allowScripts`, et une installation globale n'a pas de `package.json` où l'inscrire : npm affiche alors `npm warn allow-scripts novahiz (...)`, et selon la version il saute le script — auquel cas `novahiz-install` n'a jamais tourné et rien n'est configuré. Le drapeau autorise explicitement ce paquet. Replis :
+**Pourquoi au premier lancement et pas dans le postinstall ?** npm 11.16+ ne lance un script de lifecycle que si le paquet y est explicitement autorisé, et une installation globale n'a pas de `package.json` où l'inscrire : npm avertit (`npm warn allow-scripts novahiz`) et saute le script. Le CLI fait donc le même travail à son premier appel, ce qui fonctionne quelle que soit la version de npm. Pour que tout se passe pendant le `npm install` :
 
 ```bash
-# valeur permanente : `npm install -g novahiz` marche ensuite sans drapeau
-npm config set allow-scripts=novahiz --location=user
-
-# paquet déjà installé sans configuration : une commande suffit
-novahiz-install --yes
+npm install -g --allow-scripts=novahiz novahiz
 ```
 
-npm antérieur à 11.16 exécute les scripts par défaut : `npm install -g novahiz` suffit. Et si le blocage a eu lieu quand même, le premier `novahiz` lancé termine l'installation lui-même (désactivable avec `NOVAHIZ_AUTOINSTALL=0`).
+Variantes :
+
+```bash
+NOVAHIZ_NO_EXTRAS=1 novahiz doctor     # core seulement, aucun accès réseau
+NOVAHIZ_AUTOINSTALL=0 novahiz doctor   # ni core ni extras
+novahiz-install --extras               # rejouer les extras plus tard
+```
 
 > Piège : `npm install -g --allow-scripts=novahiz` **sans** le nom du paquet installe le dossier courant et échoue avec `ENOENT: package.json`. Le nom du paquet est obligatoire : `npm install -g --allow-scripts=novahiz novahiz`.
 
+> Linux et macOS : les commandes système qui demandent `sudo` ou qui exécutent un script téléchargé ne sont jamais lancées. L'installeur affiche la ligne exacte (`sudo apt-get install -y python3`, `brew install uv`, …) et vous décidez. C'est ce qui rend l'installation utilisable sans terminal interactif.
+
 > Linux : le serveur Playwright MCP s'exécute sous WebKit (règle maison : Chromium interdit). WebKit exige ses dépendances système : si le navigateur ne démarre pas, `npx playwright install-deps webkit` (sudo requis sur Debian/Ubuntu).
 
 Puis vérifiez :

package/bin/novahiz.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
@@ -21,40 +21,66 @@ const here = dirname(fileURLToPath(import.meta.url));
 const root = join(here, "..");
 const underNodeModules = root.replace(/\\/g, "/").toLowerCase().includes("/node_modules/");
 const dist = join(root, "dist", "cli.js");
-const src = join(root, "src", "cli.ts");
+const src = join(root, "src", "cli.ts"); console.error("DEBUG", JSON.stringify({underNodeModules, root, auto: process.env.NOVAHIZ_AUTOINSTALL, noextras: process.env.NOVAHIZ_NO_EXTRAS}));
 
 // npm 11.16+ blocks install scripts unless `allowScripts` covers them, and a
 // global install (`npm install -g`) has no package.json to record that
 // approval in — so the postinstall can be skipped silently and the machine is
-// left half configured. Finishing the job here means the package works
-// whether or not npm let the lifecycle script through: the first real `novahiz`
-// run installs the core (skills, plugin, agent, MCP), then behaves normally.
-// Opt out with NOVAHIZ_AUTOINSTALL=0. Only a package installed from npm is
-// touched; a repo checkout keeps its explicit `novahiz-install`.
+// left half configured. The first real `novahiz` run therefore finishes the
+// job, in two passes:
+//   1. no install manifest -> install the core (skills, plugin, agent, config);
+//   2. manifest says extrasPending -> run the network/system extras once
+//      (providers, global MCP servers, Obsidian vault, npm refresh).
+// Opt out with NOVAHIZ_AUTOINSTALL=0 (both passes) or NOVAHIZ_NO_EXTRAS=1
+// (extras only). A repo checkout keeps its explicit `novahiz-install`.
+function readManifest(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
 if (underNodeModules && process.env.NOVAHIZ_AUTOINSTALL !== "0") {
   const args = process.argv.slice(2);
   const infoOnly = args.length > 0 && args.every((arg) => ["-v", "-V", "--version", "--help", "-h"].includes(arg));
   const home = process.env.NOVAHIZ_HOME ? resolve(process.env.NOVAHIZ_HOME) : join(homedir(), ".config", "novahiz");
-  if (!infoOnly && !existsSync(join(home, ".novahiz-install.json"))) {
-    process.stderr.write(
-      "novahiz: npm skipped the postinstall script (allow-scripts), so the setup has not run yet.\n" +
-        "novahiz: installing now — re-run it any time with `novahiz-install`.\n"
-    );
-    const setup = spawnSync(process.execPath, [join(root, "install", "install.mjs"), "--yes"], {
+  const manifestPath = join(home, ".novahiz-install.json");
+  const manifest = readManifest(manifestPath);
+  const installer = join(root, "install", "install.mjs");
+  const runInstaller = (mode, reason) => {
+    process.stderr.write(`novahiz: ${reason}\n`);
+    const setup = spawnSync(process.execPath, [installer, "--yes", mode], {
       stdio: "inherit",
       cwd: root,
       env: process.env
     });
     if (setup.status !== 0) {
-      process.stderr.write("novahiz: automatic setup did not complete; run `novahiz-install` to see why.\n");
+      process.stderr.write(`novahiz: setup (${mode}) did not complete; re-run it with \`novahiz-install ${mode}\`.\n`);
+    }
+    return setup.status === 0;
+  };
+  if (!infoOnly && manifest === null) {
+    const coreOk = runInstaller("--core", "first run - installing the core (the npm postinstall was skipped or did not finish).");
+    // Meme lancement, deux passes : le premier appel doit tout laisser pret, pas
+    // seulement le core. Les extras restent optionnels via NOVAHIZ_NO_EXTRAS=1.
+    if (coreOk && process.env.NOVAHIZ_NO_EXTRAS !== "1") {
+      runInstaller("--extras", "installing the extras (providers, global MCP servers, Obsidian vault). One time only; skip with NOVAHIZ_NO_EXTRAS=1.");
     }
+  } else if (!infoOnly && manifest?.extrasPending === true && process.env.NOVAHIZ_NO_EXTRAS !== "1") {
+    runInstaller("--extras", "finishing the setup installed earlier (providers, global MCP servers, Obsidian vault). One time only; skip with NOVAHIZ_NO_EXTRAS=1.");
   }
 }
 
 let target;
 if (underNodeModules) {
   if (!existsSync(dist)) {
-    process.stderr.write("novahiz: dist/cli.js is missing from the installed package. Reinstall: npm install novahiz\n");
+    process.stderr.write(
+      "novahiz: dist/cli.js is missing from this package copy.\n" +
+        "novahiz: npm blocked the `prepare` script (allow-scripts). Reinstall with:\n" +
+        "novahiz:   npm install -g --allow-scripts=novahiz novahiz\n"
+    );
     process.exit(1);
   }
   target = dist;

package/dist/cli.js

@@ -121,14 +121,16 @@ async function main(argv) {
         process.env.NOVAHIZ_HOME = resolve(expandHome(parsed.flags.home));
     }
     const command = parsed.positionals[0];
-    if (command === undefined || command === "help" || command === "--help" || command === "-h") {
-        usage();
-        return;
-    }
+    // `--version` sans commande tombe sur `command === undefined` et affichait
+    // l'aide : le test du drapeau doit passer avant celui de la commande.
     if (parsed.flags.version || parsed.flags.v) {
         printVersion();
         return;
     }
+    if (command === undefined || command === "help" || command === "--help" || command === "-h") {
+        usage();
+        return;
+    }
     switch (command) {
         case "init":
             return commandInit(parsed);

package/dist/commands/inspect.js

@@ -6,10 +6,10 @@ import { loadCatalog, loadInstalledSkills, persistCatalog, scanSkills, writeCata
 import { rankSkills } from "../relevance.js";
 import { buildMcpEntries, enabledProviders, installCommands, pendingInstallCommands, updateCommands } from "../providers.js";
 import { spawnSync } from "node:child_process";
-import { bootstrapFor, coreBootstrap, dependencyReport, missingPrerequisites, reloadPathFromRegistry, toolchainStatus } from "../deps.js";
+import { bootstrapFor, commandExists, coreBootstrap, dependencyReport, manualCoreBootstrap, missingPrerequisites, reloadPathFromRegistry, toolchainStatus } from "../deps.js";
 import { classify } from "../classify.js";
 import { isContinuation, isValidSessionId, readSessionClassification, writeSessionClassification } from "../session.js";
-import { runScript } from "../exec.js";
+import { bootstrapBinAllowed, runScript } from "../exec.js";
 import { activeTask, buildWorkPackets, getTask } from "../ledger.js";
 export function commandCheck() {
     const root = NovahizHome();
@@ -313,12 +313,27 @@ export function commandDeps(parsed) {
     // --core-only: the installer's path when the user declined providers —
     // system dependencies (toolchain + npm health) still install automatically.
     const coreOnly = flagOn(parsed, "core-only");
-    const corePlan = coreBootstrap().filter((entry) => report.toolchain.find((tool) => tool.id === entry.id)?.ok === false);
+    const corePlan = coreBootstrap()
+        .filter((entry) => report.toolchain.find((tool) => tool.id === entry.id)?.ok === false)
+        .map((entry) => ({
+        ...entry,
+        command: entry.argv.join(" "),
+        // Un bootstrap sudo ou un script telecharge execute par un shell n'est
+        // jamais lance : affiche, il reste une etape manuelle.
+        manual: manualCoreBootstrap(entry.argv) || !commandExists(entry.argv[0])
+    }));
     const npmPlan = report.npm.ok ? [] : [{ step: "npm", missing: report.npm.missing, note: report.npm.note }];
     const bootstrapPlan = missingPrerequisites(spec).map((entry) => {
         const bootstrap = bootstrapFor(entry.provider);
         return bootstrap && bootstrap.length > 0
-            ? { provider: entry.provider.id, step: "bootstrap", command: bootstrap.join(" ") }
+            ? {
+                provider: entry.provider.id,
+                step: "bootstrap",
+                command: bootstrap.join(" "),
+                // Hors allowlist de runScript (sudo, brew, winget, shell) : la
+                // commande est affichee, pas executee.
+                manual: !bootstrapBinAllowed(bootstrap[0])
+            }
             : { provider: entry.provider.id, step: "bootstrap", note: `missing ${entry.missing.join(", ")}` };
     });
     const installed = new Set(scanSkills(spec, []).map((skill) => skill.id));
@@ -347,6 +362,11 @@ export function commandDeps(parsed) {
     // through a plain spawn: runScript's catalog allowlist deliberately refuses
     // shells and package managers, and this argv never comes from the catalog.
     for (const entry of corePlan) {
+        if (entry.manual) {
+            process.stdout.write(`manual core ${entry.id} - run: ${entry.command}\n`);
+            results.push({ step: "core", tool: entry.id, command: entry.command, ok: false, manual: true });
+            continue;
+        }
         const result = spawnSync(entry.argv[0], entry.argv.slice(1), { encoding: "utf8", windowsHide: true });
         const ok = result.status === 0;
         process.stdout.write(`${ok ? "ok  " : "fail"} core ${entry.id}\n`);
@@ -394,6 +414,12 @@ export function commandDeps(parsed) {
             results.push({ provider: entry.provider.id, step: "bootstrap", ok: false, note: `missing ${entry.missing.join(", ")}` });
             continue;
         }
+        if (!bootstrapBinAllowed(bootstrap[0])) {
+            // sudo, brew, winget, shell : hors de l'allowlist, jamais executes.
+            process.stdout.write(`manual bootstrap ${entry.provider.id} - run: ${bootstrap.join(" ")}\n`);
+            results.push({ provider: entry.provider.id, step: "bootstrap", command: bootstrap.join(" "), ok: false, manual: true });
+            continue;
+        }
         const result = runScript(bootstrap);
         process.stdout.write(`${result.ok ? "ok  " : "fail"} bootstrap ${entry.provider.id}\n`);
         if (!result.ok && result.stderr)

package/dist/deps.js

@@ -2,10 +2,54 @@ import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { expandHome } from "./spec.js";
+// PATH scan plutot qu'un appel a `which`/`where` : ces binaires ne sont pas
+// garantis (Debian minimal, conteneurs, Alpine sans which) et un spawn par
+// verification ajoutait un echec silencieux. Meme semantique, sans dependance.
 export function commandExists(command) {
-    const probe = process.platform === "win32" ? "where" : "which";
-    const result = spawnSync(probe, [command], { encoding: "utf8", shell: false });
-    return result.status === 0;
+    const separator = process.platform === "win32" ? ";" : ":";
+    const dirs = String(process.env.PATH ?? process.env.Path ?? process.env.path ?? "")
+        .split(separator)
+        .filter(Boolean);
+    if (dirs.length === 0)
+        return false;
+    const hasExtension = /\.(exe|cmd|bat|com)$/i.test(command);
+    const extensions = process.platform === "win32" && !hasExtension
+        ? String(process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
+            .split(";")
+            .filter(Boolean)
+        : [""];
+    for (const dir of dirs) {
+        for (const extension of extensions) {
+            try {
+                if (existsSync(join(dir, command + extension)))
+                    return true;
+            }
+            catch {
+                // une entree de PATH invalide ne doit pas casser la detection
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Une commande de bootstrap du toolchain core doit-elle rester manuelle ?
+ *
+ * Deux familles ne sont jamais executees par l'installateur :
+ *  - `sudo` : demande un mot de passe sur le terminal. Un postinstall, un job
+ *    de CI ou un agent n'ont pas de TTY : le spawn attend indefiniment ou
+ *    echoue sans explication. L'installateur n'eleve jamais ses privileges.
+ *  - un shell (`sh -c`, `bash -c`) qui execute un script telecharge : c'est ce
+ *    que l'allowlist de exec.ts refuse pour les argv du catalogue, et un script
+ *    distant n'est pas verifiable avant execution.
+ * La commande exacte est affichee ; l'utilisateur decide de la lancer.
+ */
+export function manualCoreBootstrap(argv) {
+    const bin = (argv[0] ?? "")
+        .replace(/\\/g, "/")
+        .split("/")
+        .pop()
+        ?.toLowerCase() ?? "";
+    return ["sudo", "sh", "bash", "zsh", "dash", "curl", "wget"].includes(bin);
 }
 export function checkDependencies(spec) {
     return spec.providers.map((provider) => {

package/dist/exec.js

@@ -51,7 +51,7 @@ function normalizeBin(bin) {
     const base = bin.replace(/\\/g, "/").split("/").pop() ?? bin;
     return base.toLowerCase();
 }
-function bootstrapBinAllowed(bin) {
+export function bootstrapBinAllowed(bin) {
     const name = normalizeBin(bin);
     const withoutExt = name.replace(/\.(exe|cmd|bat)$/i, "");
     return SAFE_BOOTSTRAP_BINS.has(name) || SAFE_BOOTSTRAP_BINS.has(withoutExt);

package/docs/INSTALL.md

@@ -4,14 +4,32 @@ Novahiz needs Node.js 22.18 or later. There are no runtime dependencies.
 
 ## Quick install
 
-Clone the repository into the Novahiz home and run the installer:
+```
+npm install -g novahiz
+novahiz doctor
+```
+
+`npm install -g` puts the CLI on your PATH. The first real `novahiz` command finishes the setup, in two passes:
+
+1. **core** — local only: the Novahiz home, skills, plugin, agent, slash commands, config, catalog. No network, no `sudo`.
+2. **extras** — providers and toolchain, global MCP servers, the Obsidian vault, the npm refresh. This is the part that downloads and installs.
+
+npm 11.16 and later refuse to run a package's install scripts unless the package is explicitly allowed, and a global install has no `package.json` to record that approval in. The postinstall may therefore be skipped; the first-run pass covers it. To have the setup happen inside the npm install instead:
+
+```
+npm install -g --allow-scripts=novahiz novahiz
+```
+
+The two passes run the same code either way. Skip the extras with `NOVAHIZ_NO_EXTRAS=1`, skip both passes with `NOVAHIZ_AUTOINSTALL=0`.
+
+### From a checkout
 
 ```
 git clone https://github.com/novahiz/novahiz ~/.config/novahiz
 node ~/.config/novahiz/install/install.mjs
 ```
 
-On Windows, the same command works in PowerShell. If you cloned somewhere else, pass the target home:
+Without a flag the installer does everything in one interactive run, as it always has. On Windows the same command works in PowerShell. If you cloned somewhere else, pass the target home:
 
 ```
 node /path/to/novahiz/install/install.mjs --home ~/.config/novahiz
@@ -26,14 +44,19 @@ The installer runs `git`-free and never deletes your files. When run in a termin
 5. Builds the catalog with `sync`.
 6. Verifies provider dependencies, and installs them when you confirm or `--install-providers` is set.
 7. Installs the Novahiz agent into `~/.config/opencode/agent/novahiz.md` and the four slash commands into `~/.config/opencode/commands/`.
+8. Installs the global MCP servers and creates or verifies the Obsidian vault at `~/Documents/second-memory` — both are extras, so they run at the first CLI call when the install was core-only.
+
+Nothing privileged is ever executed. Commands that need `sudo`, or that pipe a downloaded script into a shell, are printed with the exact line to run; the installer does not ask for a password and does not execute them. This is what makes `--core` safe to run from a postinstall, a CI job, or an agent with no terminal.
 
 Restart opencode afterward. The plugin in `~/.config/opencode/plugins/novahiz-plugin.ts` is auto-discovered (confirmed by `opencode debug config`: `file:///…/plugins/novahiz-plugin.ts`, scope local), so it is not listed in `plugin[]` and you do not edit `opencode.jsonc` by hand. See [HARNESSES.md](HARNESSES.md) for the exact paths.
 
 ## Options
 
+- `--core` runs only the local half: home, skills, plugin, agent, commands, config, catalog. No network, no `sudo`. This is what the npm postinstall and the first-run pass use.
+- `--extras` runs only the network/system half: providers and toolchain, global MCP servers, docs index seed, Obsidian vault, npm refresh. Replay it any time with `novahiz-install --extras`.
 - `--home <path>` installs the core to a custom location.
 - `--scope project` targets `./.opencode` instead of the global config.
-- `--dry-run` prints the actions and writes nothing.
+- `--dry-run` prints the actions and writes nothing. The step list tells you which steps the current mode would skip.
 - `--no-skills` skips the skills copy.
 - `--force-skills` recopies a skill even when another scanned root already provides it.
 - `--install-providers` runs the provider dependency bootstrap and install commands.
@@ -42,6 +65,8 @@ Restart opencode afterward. The plugin in `~/.config/opencode/plugins/novahiz-pl
 - `--yes` skips every prompt. Use it in scripts and CI, where there is no terminal to answer.
 - `--interactive` forces the prompts even when the output is not a terminal.
 
+`--core` and `--extras` together mean "everything", which is also the behaviour when neither is given.
+
 ## What it touches
 
 The installer configures opencode — the only harness Novahiz supports — merging `skills/` into your opencode skills directory and writing the plugin, the agent, and the slash commands; `--yes` accepts the detected configuration. It skips a skill that already exists in `~/.agents/skills` or another root the catalog scans, because two copies of one skill make the catalog describe one version while the harness loads the other. Pass `--force-skills` to copy anyway. Any file it overwrites is copied first to `<file>.novahiz-bak`, and the list is stored in `.novahiz-install.json`. It never deletes a file it did not create. `node install/uninstall.mjs` restores the backups and removes what the installer created; `--only <dir>` scopes that to one directory, and `--purge` also removes the Novahiz home.

package/docs/PROVIDERS.md

@@ -51,7 +51,7 @@ MCP servers, with provenance from `catalog/providers.json`:
 
 `novahiz-scheduler` is the local scheduler (own cron parser, atomic JSON store, stdio MCP server) written in this repository under `mcp/clepsydre`. It has zero npm dependency and no install step: the `command` points straight at `index.mjs`. It replaced the former AGPL `mcp-cron` package and the `scheduler-mcp` venv clone — no third-party scheduler code is used or vendored.
 
-`security` (`security-mcp`) has been removed and must never be reinstalled — explicit user decision, 2026-10-05 ("jamais réinstallés"). The entry is gone from `catalog/providers.json`; `install.mjs` and `bootstrap.mjs` keep their MCP install list empty and purge any trace of `security-mcp` or `mcp-cron` (shim and global package) on every run; `providers.disabled` in `novahiz.config.json` keeps the id out of the registry. The `audit` category is served by `novahiz-scan` (house, clean-room).
+`security` (`security-mcp`) has been removed and must never be reinstalled — explicit user decision, 2026-10-05 ("jamais réinstallés"). The entry is gone from `catalog/providers.json`; `install.mjs` keeps its MCP install list empty and purges any trace of `security-mcp` or `mcp-cron` (shim and global package) on every run; `providers.disabled` in `novahiz.config.json` keeps the id out of the registry. The `audit` category is served by `novahiz-scan` (house, clean-room).
 
 `dart` requires the Dart SDK on `PATH` (`requires: ["dart"]`). Without it the MCP entry still registers, but the server fails to start; disable it or install the SDK.
 
@@ -139,7 +139,7 @@ Each provider declares its prerequisites in `requires` (the executable it needs)
 - `npx` based providers need `npx`, which ships with Node.
 - `dart` needs the Dart SDK on `PATH` (`dart --version`). Flutter installs ship it.
 
-`Novahiz deps` checks every prerequisite and reports what is missing. `Novahiz deps --install` prints the plan (bootstrap and install steps) and runs nothing; with `--yes` it first bootstraps a missing prerequisite through its official installer, then runs each provider's install command. The installer runs the check on every install and, when `providers.autoInstall` is true or `--install-providers` is passed, runs the installs with `--yes` too.
+`Novahiz deps` checks every prerequisite and reports what is missing. `Novahiz deps --install` prints the plan (bootstrap and install steps) and runs nothing; with `--yes` it first bootstraps a missing prerequisite when the command is a structured package-manager argv (`brew`, `winget`), then runs each provider's install command. Commands that need `sudo` or pipe a downloaded script into a shell are printed as `manual … - run: …` and never executed: the installer has no terminal to answer a password prompt. The installer runs the check on every install and, when `providers.autoInstall` is true or `--install-providers` is passed, runs the installs with `--yes` too.
 
 ## Troubleshooting
 
@@ -165,6 +165,6 @@ Confirm the tool count (8 `lodestone_*` tools) with the `tools/list` call above,
 - `Novahiz providers` lists providers, optionally by `--category` or a query.
 - `Novahiz providers --mcp-json` prints the MCP entry map.
 - `Novahiz providers --install [--yes]` plans the official install commands; `--yes` executes them.
-- `Novahiz deps [--install] [--yes]` checks prerequisites and plans or runs the bootstrap/install commands.
+- `Novahiz deps [--install] [--yes]` checks prerequisites and plans or runs the bootstrap/install commands (privileged or downloaded-script bootstraps are printed, never run).
 - MCP `novahiz_providers` and `novahiz_deps` expose the list and the dependency status over stdio.
 - `Novahiz report` lists the provider ids.