create-byan-agent 2.54.0 → 2.58.1

package/install/lib/home-credentials.js

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * HOME CREDENTIALS — the write side of the per-user install memory.
+ *
+ * The byan MCP server already RESOLVES its config from
+ * ~/.byan/credentials.json (env -> file -> default, see
+ * _byan/mcp/byan-mcp-server/lib/resolve-config.js). This module is the
+ * installer-side counterpart: read what a previous install stored, merge in
+ * what the user provides once, and never ask again on the next machine-wide
+ * install. os.homedir() covers Linux/macOS/Windows.
+ *
+ * Guarantees: reading never throws (missing/garbage file -> {}), writing is a
+ * merge (unknown keys already in the file are preserved), the file lands with
+ * mode 0600 (it holds tokens), and no value is ever logged by this module.
+ */
+
+const fs = require('fs-extra');
+const os = require('os');
+const path = require('path');
+
+// Same key set the MCP server resolver understands — one vocabulary, two sides.
+const KNOWN_KEYS = Object.freeze([
+  'BYAN_API_URL',
+  'BYAN_API_TOKEN',
+  'LEANTIME_API_URL',
+  'LEANTIME_API_TOKEN',
+  'GOOGLE_APPLICATION_CREDENTIALS',
+  'GDOC_TEMPLATE_ID',
+  'GDOC_LOGO_PNG_URL',
+]);
+
+function credentialsPath(homeDir = os.homedir()) {
+  return path.join(homeDir, '.byan', 'credentials.json');
+}
+
+/** Read the stored credentials. Missing or invalid file -> {}. */
+function readCredentials({ homeDir = os.homedir() } = {}) {
+  try {
+    const parsed = fs.readJSONSync(credentialsPath(homeDir));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Merge-write: existing keys are kept unless the patch overrides them with a
+ * non-empty value. Empty/undefined patch values never erase a stored secret.
+ * Returns the merged object actually written.
+ */
+function writeCredentials(patch, { homeDir = os.homedir() } = {}) {
+  const current = readCredentials({ homeDir });
+  const merged = { ...current };
+  for (const [key, value] of Object.entries(patch || {})) {
+    // Only known keys are written from a patch. The patch can reach here from
+    // an HTTP body (the web wizard) ; an unknown key would be junk in the
+    // secret store. Keys already present in the file are preserved (the spread
+    // above), unknown ones just cannot be ADDED by a patch.
+    if (!KNOWN_KEYS.includes(key)) continue;
+    if (typeof value === 'string' && value.trim() !== '') merged[key] = value;
+  }
+  const file = credentialsPath(homeDir);
+  fs.ensureDirSync(path.dirname(file));
+  try {
+    fs.chmodSync(path.dirname(file), 0o700); // the dir holds only secrets
+  } catch {
+    // best-effort (Windows ACLs) — the 0600 file mode below is the real guard
+  }
+  fs.writeJSONSync(file, merged, { spaces: 2, mode: 0o600 });
+  try {
+    fs.chmodSync(file, 0o600); // writeJSON mode applies on create only; enforce on rewrite
+  } catch {
+    // chmod best-effort (e.g. Windows ACLs) — the write itself succeeded
+  }
+  return merged;
+}
+
+/** The keys among KNOWN_KEYS that are present and non-empty in the store. */
+function storedKeys({ homeDir = os.homedir() } = {}) {
+  const current = readCredentials({ homeDir });
+  return KNOWN_KEYS.filter((k) => typeof current[k] === 'string' && current[k].trim() !== '');
+}
+
+module.exports = {
+  KNOWN_KEYS,
+  credentialsPath,
+  readCredentials,
+  writeCredentials,
+  storedKeys,
+};

package/install/lib/install-engine.js

@@ -0,0 +1,297 @@
+'use strict';
+
+/**
+ * INSTALL ENGINE — the single real installation engine, one engine for two
+ * faces (terminal CLI and local web wizard).
+ *
+ * Why this module exists (field record, 2026-07-21): the whole install logic
+ * lived inline in a 2103-line interactive bin, so the web installer could not
+ * call it and shipped a SIMULATION instead (9 broadcast steps around sleep()
+ * calls). Three install/update gaps were fixed in three days because the logic
+ * had no single owner. This engine is that owner.
+ *
+ * Contract:
+ *   - options in, real actions out. No prompt in here, ever: consent-needing
+ *     choices arrive AS options (the faces collect them).
+ *   - progress is honest by construction: onStep fires once per step and each
+ *     step body performs the real action it names. No step, no broadcast.
+ *   - side steps that must not kill an install (rtk, skills sync, credentials)
+ *     record ok:false instead of throwing; core steps (copy, config) throw.
+ *
+ * Defaults are the zero-question install: Claude + Codex when detected, every
+ * agent, creator soul, rtk installed when missing.
+ */
+
+const fs = require('fs-extra');
+const os = require('os');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+const yaml = require('js-yaml');
+
+const { setupClaudeNative } = require('./claude-native-setup');
+const { setupCodexNative } = require('./codex-native-setup');
+const { offerGlobalSkillsSync } = require('./global-skills-sync');
+const homeCreds = require('./home-credentials');
+
+// Gen3 by-type dirs copied from templates/_byan (same list as the legacy bin).
+const BYAN_DIRS = ['agent', 'workflow', 'connaissance', 'command', 'worker', 'memoire',
+  'core', 'bmb', 'bmm', 'tea', 'cis', '_config', 'data'];
+
+function defaultTemplateDir() {
+  const p = path.join(__dirname, '..', 'templates');
+  return fs.existsSync(p) ? p : null;
+}
+
+function commandExists(cmd) {
+  try {
+    execSync(`command -v ${cmd}`, { stdio: 'ignore', shell: '/bin/sh' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Detection: platforms on this machine + stored credentials. Facts only. */
+function detectEnvironment({ homeDir = os.homedir() } = {}) {
+  return {
+    claude: fs.existsSync(path.join(homeDir, '.claude')) || commandExists('claude'),
+    codex: fs.existsSync(path.join(homeDir, '.codex')) || commandExists('codex'),
+    rtk: commandExists('rtk'),
+    storedCredentialKeys: homeCreds.storedKeys({ homeDir }),
+  };
+}
+
+/**
+ * The Claude Code launch command for the end of install. The byan-channel is a
+ * Claude Code research-preview feature behind an explicit flag; when the
+ * installed CLI does not know the flag, the plain `claude` command is the
+ * fallback. We only BUILD the command here — executing it is the caller's move.
+ */
+function claudeLaunchCommand() {
+  if (!commandExists('claude')) return null;
+  let helpText = '';
+  try {
+    helpText = execSync('claude --help', { encoding: 'utf8', timeout: 8000 });
+  } catch {
+    return { command: 'claude', channel: false };
+  }
+  const supportsChannel = helpText.includes('dangerously-load-development-channels');
+  return supportsChannel
+    ? { command: 'claude --dangerously-load-development-channels server:byan-channel', channel: true }
+    : { command: 'claude', channel: false };
+}
+
+/**
+ * Run the full installation.
+ *
+ * @param {object} options
+ * @param {string}  options.projectRoot   target directory (created if absent)
+ * @param {string}  [options.projectName] defaults to basename(projectRoot)
+ * @param {object}  [options.platforms]   {claude, codex} — defaults to detection
+ * @param {string}  [options.templateDir]
+ * @param {string}  [options.userName='Developer']
+ * @param {string}  [options.language='Francais']
+ * @param {boolean} [options.rtk=true]        install rtk when missing
+ * @param {object}  [options.credentials]     values to persist in ~/.byan/credentials.json
+ * @param {string}  [options.homeDir]
+ * @param {object}  [hooks]
+ * @param {(step:{index:number,total:number,id:string,label:string})=>void} [hooks.onStep]
+ * @param {(line:string)=>void} [hooks.log]
+ * @param {(q:string)=>Promise<boolean>} [hooks.ask]  consent collector for the
+ *        global-skills offer (absent -> notice only, nothing written in home)
+ * @param {Function} [hooks.claudeSetup] [hooks.codexSetup] [hooks.rtkInstall]  test injection
+ * @returns {Promise<{ok:boolean, steps:Array, verify:{passed:number,total:number,failed:string[]}, launch:{command:string,channel:boolean}|null}>}
+ */
+async function runInstall(options = {}, hooks = {}) {
+  const {
+    projectRoot,
+    projectName = path.basename(options.projectRoot || ''),
+    templateDir = defaultTemplateDir(),
+    userName = 'Developer',
+    language = 'Francais',
+    rtk = true,
+    credentials = null,
+    homeDir = os.homedir(),
+  } = options;
+  const onStep = hooks.onStep || (() => {});
+  const log = hooks.log || (() => {});
+  const claudeSetup = hooks.claudeSetup || setupClaudeNative;
+  const codexSetup = hooks.codexSetup || setupCodexNative;
+
+  if (!projectRoot) throw new Error('projectRoot est requis');
+  if (!templateDir || !fs.existsSync(path.join(templateDir, '_byan'))) {
+    throw new Error(`templates introuvables (${templateDir || 'aucun chemin'})`);
+  }
+
+  // Detection is injectable so tests do not depend on what THIS machine has.
+  const detected = hooks.detect ? hooks.detect() : detectEnvironment({ homeDir });
+  const platforms = options.platforms || { claude: detected.claude, codex: detected.codex };
+  const byanDir = path.join(projectRoot, '_byan');
+  const results = [];
+
+  // Step plan is computed FIRST so index/total are stable and honest.
+  const plan = [
+    { id: 'detect', label: 'Detection de l\'environnement' },
+    { id: 'copy-byan', label: 'Copie de la plateforme _byan/' },
+    { id: 'config', label: 'Ecriture de la configuration du projet' },
+  ];
+  if (platforms.claude) plan.push({ id: 'claude', label: 'Installation Claude Code (.claude + serveur MCP + .mcp.json)' });
+  if (platforms.codex) plan.push({ id: 'codex', label: 'Installation Codex (~/.codex)' });
+  if (credentials && Object.keys(credentials).length) plan.push({ id: 'credentials', label: 'Memorisation de la configuration (~/.byan/credentials.json)' });
+  if (platforms.claude) plan.push({ id: 'skills-sync', label: 'Controle des copies globales de skills' });
+  if (rtk) plan.push({ id: 'rtk', label: 'Verification / installation de rtk' });
+  plan.push({ id: 'verify', label: 'Verification finale' });
+
+  let index = 0;
+  const step = async (id, label, fn, { critical = true } = {}) => {
+    index += 1;
+    onStep({ index, total: plan.length, id, label });
+    try {
+      const detail = await fn();
+      results.push({ id, ok: true, detail: detail || '' });
+    } catch (err) {
+      results.push({ id, ok: false, detail: err.message });
+      if (critical) throw err;
+      log(`[!] etape ${id} en echec (non bloquant) : ${err.message}`);
+    }
+  };
+
+  await step('detect', plan[0].label, async () => {
+    log(`Claude: ${detected.claude ? 'present' : 'absent'} ; Codex: ${detected.codex ? 'present' : 'absent'} ; rtk: ${detected.rtk ? 'present' : 'absent'}`);
+    if (detected.storedCredentialKeys.length) {
+      log(`Configuration memorisee reutilisee (${detected.storedCredentialKeys.length} cle(s), rien a re-saisir)`);
+    }
+    return `claude=${detected.claude} codex=${detected.codex} rtk=${detected.rtk}`;
+  });
+
+  await step('copy-byan', 'Copie de la plateforme _byan/', async () => {
+    const src = path.join(templateDir, '_byan');
+    await fs.ensureDir(byanDir);
+    let copied = 0;
+    for (const dir of BYAN_DIRS) {
+      const s = path.join(src, dir);
+      if (await fs.pathExists(s)) {
+        await fs.copy(s, path.join(byanDir, dir), { overwrite: true });
+        copied += 1;
+      }
+    }
+    for (const file of await fs.readdir(src)) {
+      const full = path.join(src, file);
+      if ((await fs.stat(full)).isFile()) await fs.copy(full, path.join(byanDir, file), { overwrite: true });
+    }
+    return `${copied} dossiers copies`;
+  });
+
+  await step('config', 'Ecriture de la configuration du projet', async () => {
+    const bmbDir = path.join(byanDir, 'bmb');
+    await fs.ensureDir(bmbDir);
+    const configContent = {
+      bmb_creations_output_folder: '{project-root}/_byan-output/bmb-creations',
+      user_name: userName,
+      communication_language: language,
+      document_output_language: language,
+      output_folder: '{project-root}/_byan-output',
+      project_name: projectName,
+      platform: Object.entries(platforms).filter(([, v]) => v).map(([k]) => k).join(',') || 'none',
+      install_mode: 'engine-auto',
+      byan_version: readOwnVersion(),
+    };
+    await fs.writeFile(path.join(bmbDir, 'config.yaml'), yaml.dump(configContent), 'utf8');
+    return 'config.yaml ecrit';
+  });
+
+  if (platforms.claude) {
+    await step('claude', 'Installation Claude Code', async () => {
+      const claudeSource = path.join(templateDir, '.claude');
+      if (await fs.pathExists(claudeSource)) {
+        await fs.ensureDir(path.join(projectRoot, '.claude', 'rules'));
+        await fs.copy(claudeSource, path.join(projectRoot, '.claude'), { overwrite: true });
+      }
+      await claudeSetup(projectRoot);
+      return '.claude copie + configuration native (hooks, skills, .mcp.json, dependances MCP)';
+    });
+  }
+
+  if (platforms.codex) {
+    await step('codex', 'Installation Codex', async () => {
+      await codexSetup(projectRoot, { templateDir, force: true });
+      return 'squelettes .codex + config';
+    }, { critical: false });
+  }
+
+  if (credentials && Object.keys(credentials).length) {
+    await step('credentials', 'Memorisation de la configuration', async () => {
+      const merged = homeCreds.writeCredentials(credentials, { homeDir });
+      return `${Object.keys(merged).length} cle(s) en memoire dans ${homeCreds.credentialsPath(homeDir)}`;
+    }, { critical: false });
+  }
+
+  if (platforms.claude) {
+    await step('skills-sync', 'Controle des copies globales de skills', async () => {
+      const r = await offerGlobalSkillsSync(projectRoot, templateDir, { ask: hooks.ask || null, homeDir, log });
+      return r.diverged.length === 0 ? 'copies globales fideles' : `${r.diverged.length} divergente(s), ${r.synced.length} synchronisee(s)`;
+    }, { critical: false });
+  }
+
+  if (rtk) {
+    await step('rtk', 'Verification / installation de rtk', async () => {
+      if (detected.rtk) return 'rtk deja present';
+      const rtkInstall = hooks.rtkInstall || (() => {
+        // The official rtk setup script shipped with this package. Non-TTY
+        // safe: it runs unattended; a failure is reported, never fatal.
+        const script = path.join(__dirname, '..', 'setup-rtk.js');
+        const r = spawnSync(process.execPath, [script], { encoding: 'utf8', timeout: 300000 });
+        if (r.status !== 0) throw new Error(`setup-rtk sortie ${r.status}: ${(r.stderr || '').slice(0, 200)}`);
+        return 'rtk installe';
+      });
+      return rtkInstall();
+    }, { critical: false });
+  }
+
+  let verify = { passed: 0, total: 0, failed: [] };
+  await step('verify', 'Verification finale', async () => {
+    const checks = [
+      { name: 'Dossier agents', p: path.join(byanDir, 'agent') },
+      { name: 'Agent BYAN', p: path.join(byanDir, 'agent', 'byan', 'byan.md') },
+      { name: 'Workflows', p: path.join(byanDir, 'workflow') },
+      { name: 'Config', p: path.join(byanDir, 'bmb', 'config.yaml') },
+    ];
+    if (platforms.claude) {
+      checks.push(
+        { name: 'CLAUDE.md', p: path.join(projectRoot, '.claude', 'CLAUDE.md') },
+        { name: 'Regles Claude', p: path.join(projectRoot, '.claude', 'rules') },
+        { name: 'Skill byan-byan', p: path.join(projectRoot, '.claude', 'skills', 'byan-byan', 'SKILL.md') },
+        { name: 'Workflow auto-dispatch', p: path.join(projectRoot, '.claude', 'workflows', 'byan-auto-dispatch.js') },
+      );
+    }
+    const failed = [];
+    for (const c of checks) {
+      if (!await fs.pathExists(c.p)) failed.push(c.name);
+    }
+    verify = { passed: checks.length - failed.length, total: checks.length, failed };
+    if (failed.length) throw new Error(`verification incomplete : ${failed.join(', ')}`);
+    return `${verify.passed}/${verify.total} controles OK`;
+  });
+
+  return {
+    ok: results.every((r) => r.ok || !['detect', 'copy-byan', 'config', 'claude', 'verify'].includes(r.id)),
+    steps: results,
+    verify,
+    launch: claudeLaunchCommand(),
+  };
+}
+
+function readOwnVersion() {
+  try {
+    return fs.readJSONSync(path.join(__dirname, '..', '..', 'package.json')).version;
+  } catch {
+    return 'unknown';
+  }
+}
+
+module.exports = {
+  runInstall,
+  detectEnvironment,
+  claudeLaunchCommand,
+  BYAN_DIRS,
+};

package/install/lib/install-mode.js

@@ -0,0 +1,37 @@
+'use strict';
+
+// Since 2.57.0 the default install experience is the graphical web wizard
+// (create-byan-agent, which starts the local server and opens the browser).
+// Two terminal escape hatches stay reachable by flag:
+//   --cli    -> the zero-question automatic terminal install (installAuto)
+//   --legacy -> the original question-by-question interview (install)
+// --legacy wins over --cli when both are passed: it is the more explicit,
+// older path, so an operator who typed it means it.
+function chooseInstallMode(options = {}) {
+  if (options && options.legacy) return 'legacy';
+  if (options && options.cli) return 'cli';
+  return 'web';
+}
+
+// Global-skills consent for the AUTOMATIC terminal install (installAuto).
+//
+// Field bug (2026-07-21): the auto install froze at "[6/8] Controle des copies
+// globales de skills". Root cause — the engine's skills-sync step was handed an
+// inquirer prompt as its `ask`, but installAuto keeps an ora progress spinner
+// spinning during every step. The prompt was drawn UNDER the live spinner:
+// invisible, waiting on input the user could not see -> apparent infinite load.
+//
+// The fix is a rule, not spinner choreography: the automatic install NEVER opens
+// an interactive prompt. Two non-interactive behaviours only:
+//   - default        -> null : the engine notices the divergence and prints the
+//                        exact sync command, writes nothing in ~/.claude, does
+//                        not block (keeps the "no silent home write" red line).
+//   - --sync-skills  -> an unattended auto-approve (resolves true, no inquirer):
+//                        the flag itself is the explicit consent, so the engine
+//                        syncs the stale global copies without a prompt.
+function skillsSyncConsent(options = {}) {
+  if (options && options.syncSkills) return async () => true;
+  return null;
+}
+
+module.exports = { chooseInstallMode, skillsSyncConsent };

package/install/lib/yanstaller/updater.js

@@ -12,6 +12,7 @@ const path = require('path');
 const { compareVersions, getLatestVersion } = require('../utils/version-compare');
 const { diffFiles } = require('../utils/file-differ');
 const { readManifest, writeManifest, generateManifest, detectUserModifications } = require('../utils/manifest');
+const { setupClaudeNative } = require('../claude-native-setup');
 const backuper = require('./backuper');
 const logger = require('../utils/logger');
 
@@ -137,11 +138,15 @@ async function update(projectRoot, options = {}) {
       backupPath: null,
       filesUpdated: 0,
       filesAdded: 0,
-      filesSkipped: 0
+      filesSkipped: 0,
+      claudeRefreshed: false,
+      claudeBackupPath: null
     };
   }
 
-  const templateDir = getTemplateDir();
+  // templateDir is injectable so the flow is testable without touching the
+  // packaged templates (and so a caller can point at a staged template set).
+  const templateDir = options.templateDir || getTemplateDir();
   if (!templateDir) {
     throw new Error('Template directory not found. Is the package installed correctly?');
   }
@@ -170,6 +175,10 @@ async function update(projectRoot, options = {}) {
   let filesUpdated = 0;
   let filesAdded = 0;
   let filesSkipped = 0;
+  let claudeRefreshed = false;
+  let claudeBackupPath = null;
+  let globalSkillsDiverged = [];
+  const installedClaude = path.join(projectRoot, '.claude');
 
   try {
     // Apply updated files (skip user-modified unless forced)
@@ -195,6 +204,38 @@ async function update(projectRoot, options = {}) {
       filesAdded++;
     }
 
+    // --- .claude refresh -------------------------------------------------
+    // The update must deploy what the full install deploys. Historically it
+    // only diffed _byan/, so everything living under .claude/ (skills with the
+    // auto-dispatch rail, native workflows, hooks, settings, and the .mcp.json
+    // regenerated by the native setup) was NEVER refreshed by `update` — an
+    // up-to-date _byan/ next to a months-old .claude/. Same contract as the
+    // full install (copy with overwrite), with a dedicated backup first. The
+    // backup uses its own `.claude.backup-` prefix : reusing the `_byan.backup-`
+    // prefix would make pruneBackups/rollback treat it as a _byan backup.
+    const templateClaude = path.join(templateDir, '.claude');
+    if (await fs.pathExists(templateClaude) && await fs.pathExists(installedClaude)) {
+      claudeBackupPath = path.join(projectRoot, `.claude.backup-${Date.now()}`);
+      await fs.copy(installedClaude, claudeBackupPath);
+      await fs.copy(templateClaude, installedClaude, { overwrite: true });
+      // Same native pass as the full install : regenerates .mcp.json, installs
+      // the MCP server dependencies, wires git hooks. Injectable for tests.
+      const nativeSetup = options.nativeSetup || setupClaudeNative;
+      await nativeSetup(projectRoot);
+      claudeRefreshed = true;
+      logger.debug(`.claude refreshed from templates (backup: ${claudeBackupPath})`);
+
+      // Stale global copies check (notice-only on the update path : no TTY
+      // conversation here, and the home is never written without consent).
+      // The CLI surfaces the diverged names + the exact sync command.
+      try {
+        const { checkGlobalSkills } = require('../global-skills-sync');
+        globalSkillsDiverged = (await checkGlobalSkills(projectRoot, templateDir)).diverged;
+      } catch {
+        // the check must never fail an update
+      }
+    }
+
     // Regenerate manifest with new state
     const newManifest = await generateManifest(installedByan, latest);
     await writeManifest(projectRoot, newManifest);
@@ -206,6 +247,11 @@ async function update(projectRoot, options = {}) {
     // Rollback on failure
     logger.error(`Update failed, restoring backup: ${error.message}`);
     await backuper.restore(backupResult.backupPath, installedByan);
+    if (claudeBackupPath && await fs.pathExists(claudeBackupPath)) {
+      await fs.remove(installedClaude);
+      await fs.copy(claudeBackupPath, installedClaude);
+      logger.error('.claude restored from its pre-update backup');
+    }
     throw error;
   }
 
@@ -216,7 +262,10 @@ async function update(projectRoot, options = {}) {
     backupPath: backupResult.backupPath,
     filesUpdated,
     filesAdded,
-    filesSkipped
+    filesSkipped,
+    claudeRefreshed,
+    claudeBackupPath,
+    globalSkillsDiverged
   };
 }
 

package/install/src/webui/api.js

@@ -53,6 +53,18 @@ function json(res, statusCode, data) {
   res.end(JSON.stringify(data));
 }
 
+// Confine an HTTP-supplied install/update directory to the server's launch
+// directory. A relative value resolves inside base; base itself, or any path
+// that escapes it (../, absolute elsewhere), collapses back to base. The
+// installer targets the project the wizard was launched in — nothing else.
+function confineToBase(candidate, base) {
+  if (!candidate || typeof candidate !== 'string') return base;
+  const resolved = path.resolve(base, candidate);
+  const rel = path.relative(base, resolved);
+  const escapes = rel === '' ? false : (rel.startsWith('..') || path.isAbsolute(rel));
+  return escapes ? base : resolved;
+}
+
 function readPackageVersion() {
   try {
     const pkg = JSON.parse(
@@ -141,39 +153,54 @@ const routes = {
     });
   },
 
+  // Runs the REAL install engine (install/lib/install-engine.js) — the same
+  // one the CLI uses. Every progress broadcast maps 1:1 to a real action; the
+  // previous handler here simulated 9 steps around sleep() calls and only
+  // created directories, which is exactly the dishonest-progress trap the
+  // engine forbids. `server.installEngine` is injectable for tests.
   'POST install': async (req, res, server) => {
     json(res, 200, { status: 'started' });
 
     const config = req.body || {};
-    const projectRoot = server.projectRoot;
-    const steps = [
-      'Detecting environment',
-      'Validating prerequisites',
-      'Creating directory structure',
-      'Installing core module',
-      'Installing selected modules',
-      'Configuring platforms',
-      'Generating agent stubs',
-      'Writing configuration',
-      'Validating installation'
-    ];
+    // projectDir comes from the HTTP body — it must NOT be an arbitrary path
+    // sink (the engine writes files and spawns processes). Confine it to the
+    // directory the server was launched in: the wizard installs "here", the
+    // exact intent of `create-byan-agent web` run in a project.
+    const projectRoot = confineToBase(config.projectDir, server.projectRoot);
 
     try {
-      for (let i = 0; i < steps.length; i++) {
-        server.broadcastProgress(i + 1, steps.length, steps[i]);
-        server.broadcastLog('info', steps[i] + '...');
-        await sleep(300);
-      }
-
-      ensureDirectoryStructure(projectRoot);
-      writeBaseConfig(projectRoot, config);
+      const installEngine = server.installEngine || require('../../lib/install-engine');
+      // The wizard form sends platforms as an array (['claude','codex']); the
+      // engine takes an object. An empty selection means "let the engine detect".
+      const platformList = Array.isArray(config.platforms) ? config.platforms : null;
+      const platforms = platformList && platformList.length
+        ? { claude: platformList.includes('claude'), codex: platformList.includes('codex') }
+        : (config.platforms && !Array.isArray(config.platforms) ? config.platforms : undefined);
+      const result = await installEngine.runInstall({
+        projectRoot,
+        projectName: config.projectName || undefined,
+        platforms,
+        userName: config.userName || undefined,
+        language: config.language || undefined,
+        rtk: config.rtk !== false,
+        credentials: config.credentials || null,
+      }, {
+        onStep: ({ index, total, label }) => {
+          server.broadcastProgress(index, total, label);
+          server.broadcastLog('info', label);
+        },
+        log: (line) => server.broadcastLog('info', line),
+        // No consent prompt over HTTP: the global-skills offer degrades to a
+        // notice with the exact command (same non-interactive contract as CI).
+        ask: null,
+      });
 
-      server.broadcastProgress(steps.length, steps.length, 'Complete');
-      server.broadcastComplete(true, {
-        message: 'BYAN installed successfully',
+      server.broadcastComplete(result.ok, {
+        message: result.ok ? 'Installation BYAN terminee' : 'Installation terminee avec des etapes en echec',
         projectRoot,
-        mode: config.mode || 'auto',
-        platforms: config.platforms || detectPlatforms(projectRoot)
+        verify: result.verify,
+        steps: result.steps,
+        launch: result.launch,
       });
     } catch (err) {
       server.broadcastLog('error', err.message);
@@ -181,34 +208,29 @@ const routes = {
     }
   },
 
+  // Runs the REAL updater (yanstaller.update, which since 2.54.1 refreshes
+  // _byan AND .claude + native setup). The previous handler simulated 6 steps,
+  // called update with a wrong argument, swallowed its failure and broadcast
+  // success regardless — the result is now the truth, including failures.
   'POST update': async (req, res, server) => {
     json(res, 200, { status: 'started' });
-
-    const steps = [
-      'Checking current version',
-      'Creating backup',
-      'Downloading update',
-      'Applying changes',
-      'Merging configuration',
-      'Validating update'
-    ];
+    const projectRoot = confineToBase(req.body && req.body.projectDir, server.projectRoot);
 
     try {
-      for (let i = 0; i < steps.length; i++) {
-        server.broadcastProgress(i + 1, steps.length, steps[i]);
-        server.broadcastLog('info', steps[i] + '...');
-        await sleep(400);
-      }
-
-      if (yanstaller && yanstaller.update) {
-        try {
-          await yanstaller.update('latest');
-        } catch (err) {
-          server.broadcastLog('warn', `Update module: ${err.message}`);
-        }
+      if (!yanstaller || !yanstaller.update) {
+        throw new Error('Module de mise a jour indisponible dans ce paquet');
       }
-
-      server.broadcastComplete(true, { message: 'BYAN updated successfully' });
+      server.broadcastProgress(1, 2, 'Mise a jour en cours (_byan + .claude + configuration native)');
+      const result = await (server.updater || yanstaller.update)(projectRoot, {});
+      server.broadcastProgress(2, 2, 'Terminee');
+      server.broadcastComplete(true, {
+        message: `Mise a jour ${result.previousVersion} -> ${result.newVersion}`,
+        filesUpdated: result.filesUpdated,
+        filesAdded: result.filesAdded,
+        filesSkipped: result.filesSkipped,
+        claudeRefreshed: result.claudeRefreshed === true,
+        globalSkillsDiverged: result.globalSkillsDiverged || [],
+      });
     } catch (err) {
       server.broadcastLog('error', err.message);
       server.broadcastComplete(false, { message: err.message });