pipcode 0.0.0-stage → 2.1.0

package/src/cli/auto-cli.js

@@ -0,0 +1,46 @@
+// src/cli/auto-cli.js — Dispatcher du shell CLI Mode Auto (plan/run/resume/ask).
+// shell CLI sur le même cœur pur que le dispatch MCP. gate licence/session/BYOK →
+// re-gate Lite (chat gratuit ; plan/run/resume restent payants) →
+// appels minces aux handlers → consentement readline (BLOCK avant exécution).
+
+import { parseAutoFlags, resolveProjectPath } from "./auto-flags.js";
+import { gateAutoCli } from "./auto-gate.js";
+import { loadAutoShell } from "./auto-loader.js";
+import { LITE_BLOCK_TEXT } from "../core/tier.js";
+import { applyPreflight } from "./auto-preflight.js";
+import { handleAutoPlan } from "./auto-plan.js";
+import { handleAutoRun } from "./auto-run.js";
+import { handleAutoResume } from "./auto-resume.js";
+import { handleAutoAsk } from "./auto-ask.js";
+import { handleAutoAudit } from "./auto-audit.js";
+import { prepareRules } from "./auto-rules.js";
+import { listenForAbort } from "../core/abort-signal.js";
+
+// Handler principal du shell CLI Auto. Dispatche vers plan/run/resume/ask après gate.
+/** @param {string} action @param {string[]} argv @returns {Promise<void>} */
+export async function runAutoCli(action, argv) {
+  listenForAbort(); // « Stop » de l'interface (canal demandé seulement par l'extension)
+  const flags = parseAutoFlags(argv);
+  const projectPath = resolveProjectPath(flags);
+  const { auto, deps } = await loadAutoShell();
+  const g = await gateAutoCli(deps);
+  if (!g.ok) { console.error("\n  " + g.message); process.exit(1); }
+  const gate = /** @type {AutoGateOk} */ (g);
+  // Re-gate monétisation : le chat (`ask`) est gratuit à vie ; l'exécution
+  // autonome (plan/run/resume) reste débloquée en essai/Pro uniquement.
+  if (gate.tier === "lite" && (action === "plan" || action === "run" || action === "resume" || action === "audit")) {
+    console.error("\n  " + LITE_BLOCK_TEXT);
+    process.exit(1);
+  }
+  const ready = await applyPreflight(gate, flags, action); // capacités requises : arrêt AVANT tout appel modèle.
+  if (!ready) return; // arrêt pré-flight : message affiché, code de sortie positionné.
+  if (!(await prepareRules(gate.cfg, action))) return; // règles métier du serveur : sinon arrêt AVANT tout appel modèle.
+  if (action === "plan") return handleAutoPlan(auto, flags, projectPath, ready);
+  if (action === "run") return handleAutoRun(auto, flags, projectPath, ready);
+  if (action === "resume") return handleAutoResume(auto, flags, projectPath, ready);
+  if (action === "ask") return handleAutoAsk(ready, flags);
+  if (action === "audit") return handleAutoAudit(ready, projectPath);
+  console.error(`Sous-action auto inconnue : "${action}". Essayez : plan | run | resume | ask | audit`);
+  process.exit(2);
+}
+// MODULE_COMPLETE

package/src/cli/auto-consent.js

@@ -0,0 +1,22 @@
+// src/cli/auto-consent.js — Gate de consentement du Mode Auto (Pilier 1).
+// BLOCK avant exécution. --yes confirme sans prompt ; non-TTY sans --yes = exit(2).
+// TTY : prompt Y/n (Entrée = oui).
+
+import readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+
+// Retourne true si l'utilisateur a confirmé l'exécution (Y/n, Entrée = oui).
+/** @param {AutoFlags} flags @returns {Promise<boolean>} */
+export async function confirmConsent(flags) {
+  if (flags.yes) return true;
+  if (!stdin.isTTY) {
+    console.error("\n  ✗ Consentement requis (non-TTY). Passez --yes pour confirmer le plan.");
+    process.exit(2);
+  }
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    const ans = (await rl.question("\n  ▶ Lancer l'exécution Auto de ces tâches ? [Y/n] : ")).trim().toLowerCase();
+    return (ans === "y" || ans === "yes" || ans === "");
+  } finally { rl.close(); }
+}
+// MODULE_COMPLETE

package/src/cli/auto-flags.js

@@ -0,0 +1,39 @@
+// src/cli/auto-flags.js — Parsing des flags CLI du Mode Auto.
+// --need "…" --project ./p --max-steps N --yes|-y (accepte --need="…" --project=./p).
+
+import path from "node:path";
+
+// Analyse les flags CLI et retourne les valeurs parsées (défauts : maxSteps 50, yes false).
+/** @param {string[]} argv @returns {AutoFlags} */
+export function parseAutoFlags(argv) {
+  /** @type {AutoFlags} */ const flags = { need: "", project: "", maxSteps: 50, yes: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--yes" || a === "-y") flags.yes = true;
+    else if (a === "--need") flags.need = argv[++i] || "";
+    else if (a === "--adjust") flags.adjust = argv[++i] || "";
+    else if (a === "--project") flags.project = argv[++i] || "";
+    else if (a === "--max-steps") flags.maxSteps = Math.max(1, parseInt(argv[++i], 10) || 50);
+    else if (a === "--require") flags.require = argv[++i] || "";
+    else if (a.startsWith("--require=")) flags.require = a.slice(10);
+    else if (a === "--answer") flags.answer = argv[++i] || "";
+    else if (a.startsWith("--answer=")) flags.answer = a.slice(9);
+    else if (a === "--task") flags.task = argv[++i] || "";
+    else if (a.startsWith("--task=")) flags.task = a.slice(7);
+    else if (a.startsWith("--need=")) flags.need = a.slice(7);
+    else if (a.startsWith("--project=")) flags.project = a.slice(10);
+    else if (a.startsWith("--max-steps=")) flags.maxSteps = Math.max(1, parseInt(a.slice(12), 10) || 50);
+  }
+  return flags;
+}
+
+// Résout le chemin projet et valide la présence de --project (exit(2) si absent).
+/** @param {AutoFlags} flags @returns {string} */
+export function resolveProjectPath(flags) {
+  if (!flags.project.trim()) {
+    console.error("✗ --project <chemin> requis (le Mode Auto exige un dépôt git).");
+    process.exit(2);
+  }
+  return path.resolve(flags.project);
+}
+// MODULE_COMPLETE

package/src/cli/auto-gate-session.js

@@ -0,0 +1,27 @@
+// src/cli/auto-gate-session.js — Session Pro du gate Auto CLI + résilience.
+// ensureSession échoue : 402/403/429/no_license → blocage (purge gérée par les
+// gates MCP) ; échec RÉSEAU seulement → retombe sur l'essai serveur /v1/trial
+// (Polar injoinable + essai actif → trial). Jamais de grant local (Zero Trust §3).
+
+import { PRO_UPGRADE_URL } from "../core/constants.js";
+
+/** @param {(cfg: PlugConfig) => Promise<LicenseSession>} ensureSession @param {PlugConfig} cfg @param {(cfg: PlugConfig) => Promise<SessionResolution>} resolveTrial @returns {Promise<{ ok: true, tier: string } | { ok: false, message: string }>} */
+export async function proSessionGate(ensureSession, cfg, resolveTrial) {
+  try {
+    await ensureSession(cfg);
+    return { ok: true, tier: "pro" };
+  } catch (err) {
+    const e = /** @type {NodeErr} */ (err);
+    if (e && e.code === "no_license") {
+      return { ok: false, message: `🔒 Licence requise. Débloquez la version Pro ($14.99 USD à vie, Polar.sh) : ${PRO_UPGRADE_URL}` };
+    }
+    if (e && (e.status === 402 || e.status === 403 || e.status === 429)) {
+      return { ok: false, message: e.message || `Session refusée par le serveur (HTTP ${e.status}).` };
+    }
+    // Serveur injoinable : l'essai serveur peut rester actif (résilience).
+    const t = await resolveTrial(cfg);
+    if (t.tier === "trial") return { ok: true, tier: "trial" };
+    return { ok: false, message: `Serveur de licence indisponible. ${(e && e.message) || "Erreur inconnue."}` };
+  }
+}
+// MODULE_COMPLETE

package/src/cli/auto-gate.js

@@ -0,0 +1,34 @@
+// src/cli/auto-gate.js — Gate licence/session/BYOK du shell CLI Mode Auto.
+// Réplique CLI de gateAuto (index.js). L'essai est TRANCHÉ PAR LE SERVEUR
+// (jeton signé /v1/trial, jamais l'horloge locale — Zero Trust §3) ; Pro exige
+// ensureSession (Ed25519). Sans licence : essai serveur → trial ; refusé (402)
+// OU serveur injoinable → tier "lite" ok — seul `auto ask` passe, le dispatcher
+// (auto-cli.js) re-gate plan/run/resume et le serveur re-gate les fiches Pro
+// (zéro risque monétaire). BYOK exigé dans tous les cas.
+
+import { proSessionGate } from "./auto-gate-session.js";
+
+// Gate partagée tier + session + BYOK. Retourne {ok, cfg, pcfg, tier} ou {ok:false, message}.
+/** @param {GateAutoDeps} deps @returns {Promise<GateAutoResult>} */
+export async function gateAutoCli({ loadConfig, ensureSession, readProviderConfig, resolveTrial }) {
+  const cfg = await loadConfig();
+  const hasLicense = !!(process.env.PLUGCTO_LICENSE_KEY || cfg.licenseKey);
+  let tier = "trial";
+  if (!hasLicense) {
+    // Sans licence : essai serveur (jeton /v1/trial) → trial ; sinon Lite (refus
+    // 402 OU échec réseau) → ok tier "lite" : le chat gratuit reste ouvert, les
+    // fiches Pro restent gates côté serveur (autorité monétaire).
+    const t = await resolveTrial(cfg);
+    tier = t.tier === "trial" ? "trial" : "lite";
+  } else {
+    const gated = await proSessionGate(ensureSession, cfg, resolveTrial);
+    if (!gated.ok) return { ok: false, message: gated.message };
+    tier = gated.tier;
+  }
+  const pcfg = readProviderConfig();
+  if (!pcfg.primary) {
+    return { ok: false, message: `🔑 Aucune clé API provider configurée (BYOK). Lancez \`npx pipcode setup\` pour saisir votre clé unique (OpenRouter / OpenAI / Anthropic / Gemini / Ollama / Local / Proxy).` };
+  }
+  return { ok: true, cfg, pcfg: /** @type {{ primary: ProviderPrimary }} */ (pcfg), tier };
+}
+// MODULE_COMPLETE

package/src/cli/auto-loader.js

@@ -0,0 +1,17 @@
+// src/cli/auto-loader.js — Chargement paresseux du cœur Auto + helpers index.js.
+// Les tests de setup.js ne chargent ni le graphe de gates ni le cœur Auto (aucune
+// régression de la suite existante). auto.js définit son propre AutoDeps ;
+// createAutoDeps() (index.js) y est compatible au runtime mais leurs typedefs JSDoc
+// diffèrent — on cast l'usine vers une signature acceptant unknown + AutoShell typé
+// localement (évite de propager les inférences de auto.js non annoté à zéro).
+
+// Charge le cœur Auto + les helpers de gate. Retourne l'orchestrateur + les deps.
+/** @returns {Promise<{ auto: AutoShell, deps: GateAutoDeps }>} */
+export async function loadAutoShell() {
+  const { createAutoOrchestrator } = await import("../../auto.js");
+  const { createAutoDeps, loadConfig, ensureSession, readProviderConfig, resolveTrialOrLite } = await import("../../index.js");
+  const mkAuto = /** @type {(deps: unknown) => AutoShell} */ (/** @type {unknown} */ (createAutoOrchestrator));
+  const auto = mkAuto(createAutoDeps());
+  return { auto, deps: { loadConfig, ensureSession, readProviderConfig, resolveTrial: resolveTrialOrLite } };
+}
+// MODULE_COMPLETE

package/src/cli/auto-plan.js

@@ -0,0 +1,36 @@
+// src/cli/auto-plan.js — Handler `auto plan` : génère le roadmap + devis (dry-run).
+// Pilier 1 : 1 appel LLM de décomposition. L'exécution reste bloquée (consentement).
+// `--task audit` : besoin = libellé public, protocole serveur transmis à la seule
+// décomposition (jamais affiché ni persisté). Erreurs de tâche : code de sortie
+// positionné + retour (pas de process.exit après du réseau : crash Windows).
+
+import { resolveTask } from "./auto-task.js";
+
+// @param auto — orchestrateur Auto. @param flags — flags CLI. @param projectPath — résolu.
+/** @param {AutoShell} auto @param {AutoFlags} flags @param {string} projectPath @param {AutoGateOk} g @returns {Promise<void>} */
+export async function handleAutoPlan(auto, flags, projectPath, g) {
+  let task;
+  try { task = await resolveTask(flags, g.cfg); }
+  catch (err) {
+    console.error("\n  ✗ " + /** @type {Error} */ (err).message);
+    process.exitCode = /** @type {{ exitCode?: number }} */ (err).exitCode || 1;
+    return;
+  }
+  if (!task.need.trim()) {
+    console.error('✗ --need "<cahier des charges>" requis pour `auto plan`.');
+    process.exit(2);
+  }
+  try {
+    const r = await auto.buildAutoPlan({ need: task.need, instructions: task.instructions, adjust: flags.adjust, projectPath, pcfg: g.pcfg, cfg: g.cfg });
+    if (r.isError) { console.error("\n  " + r.text); process.exit(1); }
+    console.log("\n" + r.quote);
+    const tasks = /** @type {AutoTask[]} */ (r.tasks);
+    console.log(`\n  runId: ${r.runId} • ${tasks.length} tâches • status: ${r.status}`);
+    console.log(`  Pour lancer : npx pipcode auto run --project "${flags.project}"`);
+  } catch (err) {
+    const e = /** @type {NodeErr} */ (err);
+    console.error("\n  ✗ Plan Auto échoué :", e.message);
+    process.exit(1);
+  }
+}
+// MODULE_COMPLETE

package/src/cli/auto-preflight.js

@@ -0,0 +1,35 @@
+// src/cli/auto-preflight.js — Branchement du pré-flight de capacités dans le CLI
+// `auto` : `--require vision,tools,media_generation` (ou PLUGCTO_REQUIRE).
+// Appelé APRÈS les gates licence/BYOK et AVANT tout appel du modèle. Aucune
+// capacité requise → no-op total (0 requête). Arrêt = code de sortie 4 + message
+// exact, retour null (l'appelant s'arrête : PAS de process.exit — sous Windows il
+// fait planter Node juste après une requête réseau). Modèle 1 incapable mais
+// Modèle 2 confirmé : `ask` est confié au Modèle 2 ; plan/run/resume demandent le
+// mode Solo Modèle 2.
+
+import { parseCaps } from "../engine/cap-types.js";
+import { runPreflight } from "../engine/preflight.js";
+import { readSecondaryProvider } from "../core/llm-config-secondary.js";
+
+/** @param {number} code @returns {void} */
+const defaultSetExit = (code) => { process.exitCode = code; };
+
+/** @param {AutoGateOk} gate @param {AutoFlags} flags @param {string} action @param {{ env?: Record<string, string | undefined>, setExit?: (code: number) => void }} [deps] @returns {Promise<AutoGateOk | null>} */
+export async function applyPreflight(gate, flags, action, { env = process.env, setExit = defaultSetExit } = {}) {
+  /** @type {Capability[]} */ let required = [];
+  try { required = parseCaps(flags.require || env.PLUGCTO_REQUIRE); }
+  catch (e) { console.error("\n  ✗ " + /** @type {Error} */ (e).message); setExit(2); return null; }
+  if (required.length === 0) return gate;
+  const { secondary } = readSecondaryProvider(env);
+  const r = await runPreflight({ required, primary: gate.pcfg.primary, secondary });
+  if (!r.ok) { console.error("\n  ✗ " + r.message); setExit(4); return null; }
+  if (r.runner === "primary") return gate;
+  if (action !== "ask" || !secondary) {
+    console.error(`\n  ✗ ${r.notice} Relancez en mode Solo Modèle 2 pour une tâche d'exécution.`);
+    setExit(4);
+    return null;
+  }
+  console.error("\n  ℹ " + r.notice);
+  return { ...gate, pcfg: { primary: secondary } };
+}
+// MODULE_COMPLETE

package/src/cli/auto-quote.js

@@ -0,0 +1,28 @@
+// src/cli/auto-quote.js — Résolution du devis Auto avant exécution (Pilier 1).
+// Si un besoin est fourni ou aucun plan n'existe → (re)construit le devis (dry-run,
+// 1 appel LLM). Sinon récupère le devis du plan existant (confirmed:false, 1 step).
+// `--task audit` : même résolution que `auto plan` (libellé public + instructions serveur),
+// pour que le plan reconstruit à l'exécution soit IDENTIQUE à celui que l'utilisateur a approuvé.
+
+import { resolveTask } from "./auto-task.js";
+
+// Retourne le texte du devis. Exit(1) si plan/probe en erreur, exit(2) si besoin absent sans plan.
+/** @param {AutoShell} auto @param {AutoFlags} flags @param {string} projectPath @param {AutoGateOk} g @returns {Promise<string>} */
+export async function resolveAutoQuote(auto, flags, projectPath, g) {
+  const existing = await auto.loadAutoState(projectPath);
+  const task = await resolveTask(flags, g.cfg);
+  if (task.need.trim() || !existing) {
+    if (!task.need.trim()) {
+      console.error("✗ Aucun plan Auto trouvé. Lancez d'abord `auto plan --need \"…\" --project …`.");
+      process.exit(2);
+    }
+    const plan = await auto.buildAutoPlan({ need: task.need, instructions: task.instructions, projectPath, pcfg: g.pcfg, cfg: g.cfg });
+    if (plan.isError) { console.error("\n  " + plan.text); process.exit(1); }
+    return /** @type {string} */ (plan.quote);
+  }
+  // Plan existant : on récupère le devis sans exécuter (confirmed:false, maxSteps 1).
+  const probe = await auto.runAutoRun({ projectPath, confirmed: false, maxSteps: 1, pcfg: g.pcfg, cfg: g.cfg });
+  if (probe.isError) { console.error("\n  " + probe.text); process.exit(1); }
+  return /** @type {string} */ (probe.quote);
+}
+// MODULE_COMPLETE

package/src/cli/auto-report.js

@@ -0,0 +1,36 @@
+// src/cli/auto-report.js — Rendu du résultat d'une opération Auto (run/resume).
+// Trois issues : terminé (done), tâche échouée (last.failed → exit 1), ou
+// progression partielle (continue → relancer). `continueVerb` différencie
+// "Auto Mode" (run) de "Reprise Auto" (resume).
+
+import { ASK_PREFIX } from "../auto/ask-protocol.js";
+import { CANCEL_EXIT_CODE } from "../auto/cancel.js";
+import { guardQuestion } from "../auto/ask-guard.js";
+
+// Affiche l'issue de l'opération. Échec → exit(1) ; done/continue → retour au caller.
+/** @param {AutoOpResult} r @param {AutoFlags} flags @param {string} continueVerb @returns {void} */
+export function reportAutoOutcome(r, flags, continueVerb) {
+  const ask = r.asking ? r : r.last?.asking ? r.last : null;
+  if (ask) { // pause « ASK_USER » : ni terminé ni échoué — la question est posée, l'exécution reprend avec `auto resume --answer`
+    const question = guardQuestion(ask.question ?? null, "") ?? ask.question; // une question enregistrée AVANT le garde-fou (plan resté en pause) est filtrée aussi à la reprise
+    console.log(`\n  ❓ ${question}`);
+    console.log(`${ASK_PREFIX}${JSON.stringify({ question })}`);
+    process.exit(3);
+  }
+  if (r.cancelled || r.last?.cancelled) { // Stop : ni terminé ni échoué — plan en PAUSE, reprise possible
+    console.log(`\n  🛑 Exécution interrompue par l'utilisateur. Le plan est en pause (reprise : auto resume).`);
+    process.exit(CANCEL_EXIT_CODE);
+  }
+  if (r.done || r.status === "done") {
+    console.log(`\n  ✅ Auto Mode terminé : ${r.progress} tâches validées.`);
+    if (r.summary) console.log(`  ${r.summary}`);
+    return;
+  }
+  if (r.last && r.last.failed) {
+    console.error(`\n  ⚠️ Tâche échouée : ${r.last.task && r.last.task.id} — ${(r.last.task && r.last.task.error) || r.last.error}`);
+    console.error(`  Progression : ${r.progress}. Corrigez ou reprenez : npx pipcode auto resume --project "${flags.project}"`);
+    process.exit(1);
+  }
+  console.log(`\n  ⏵ ${continueVerb} : ${r.progress} tâches validées (status: ${r.status}). Relancez pour continuer.`);
+}
+// MODULE_COMPLETE

package/src/cli/auto-resume.js

@@ -0,0 +1,28 @@
+// src/cli/auto-resume.js — Handler `auto resume` : reprise après crash/arrêt.
+// Pilier 2 (séquenceur résilient). Si le plan attend un consentement → exit(2).
+
+import { reportAutoOutcome } from "./auto-report.js";
+
+// Handler de `auto resume`. Reprise → issue. needsConsent → exit(2) (lancer `run`).
+/** @param {AutoShell} auto @param {AutoFlags} flags @param {string} projectPath @param {AutoGateOk} g @returns {Promise<void>} */
+export async function handleAutoResume(auto, flags, projectPath, g) {
+  try {
+    const r = await auto.resumeAuto({ projectPath, maxSteps: flags.maxSteps, pcfg: g.pcfg, cfg: g.cfg, answer: flags.answer });
+    if (r.isError) { console.error("\n  " + r.text); process.exit(1); }
+    if (r.needsConsent && flags.yes) { // « Reprendre » cliqué = consentement explicite (devis déjà vu et approuvé) : le plan est lancé au lieu de rester en attente
+      reportAutoOutcome(await auto.runAutoRun({ projectPath, confirmed: true, maxSteps: flags.maxSteps, pcfg: g.pcfg, cfg: g.cfg }), flags, "Reprise Auto");
+      return;
+    }
+    if (r.needsConsent) {
+      console.log("\n" + r.quote);
+      console.error("\n  ✗ Le plan attend un consentement. Lancez `npx pipcode auto run --project …` pour confirmer.");
+      process.exit(2);
+    }
+    reportAutoOutcome(r, flags, "Reprise Auto");
+  } catch (err) {
+    const e = /** @type {NodeErr} */ (err);
+    console.error("\n  ✗ Reprise Auto échouée :", e.message);
+    process.exit(1);
+  }
+}
+// MODULE_COMPLETE

package/src/cli/auto-rules.js

@@ -0,0 +1,20 @@
+// src/cli/auto-rules.js — Règles métier requises par plan/run/resume : chargées depuis le serveur PipCode
+// AVANT tout appel modèle (0 token si indisponibles). `ask` n'en a pas besoin (conversation pure).
+
+import { ensureRules } from "../rules/rules-load.js";
+
+export const RULES_EXIT_CODE = 5;
+
+/** @param {PlugConfig} cfg @param {string} action @returns {Promise<boolean>} true = on continue */
+export async function prepareRules(cfg, action) {
+  if (action !== "plan" && action !== "run" && action !== "resume") return true;
+  try {
+    await ensureRules(cfg);
+    return true;
+  } catch (e) {
+    console.error("\n  ✗ " + /** @type {Error} */ (e).message);
+    process.exitCode = RULES_EXIT_CODE;
+    return false;
+  }
+}
+// MODULE_COMPLETE

package/src/cli/auto-run.js

@@ -0,0 +1,26 @@
+// src/cli/auto-run.js — Handler `auto run` : exécute le plan Auto après consentement.
+// Pilier 1 (devis) → consentement Y/n (BLOCK) → Pilier 2 (séquenceur résilient).
+
+import { resolveAutoQuote } from "./auto-quote.js";
+import { confirmConsent } from "./auto-consent.js";
+import { reportAutoOutcome } from "./auto-report.js";
+
+// Handler principal de `auto run`. Devis → consentement → exécution → rendu issue.
+/** @param {AutoShell} auto @param {AutoFlags} flags @param {string} projectPath @param {AutoGateOk} g @returns {Promise<void>} */
+export async function handleAutoRun(auto, flags, projectPath, g) {
+  try {
+    const quote = await resolveAutoQuote(auto, flags, projectPath, g);
+    console.log("\n" + quote);
+    // Gate de consentement (Pilier 1) : BLOCK avant exécution.
+    const confirmed = await confirmConsent(flags);
+    if (!confirmed) { console.log("\n  ⏸ Exécution annulée (plan non confirmé)."); return; }
+    const r = await auto.runAutoRun({ projectPath, confirmed: true, maxSteps: flags.maxSteps, pcfg: g.pcfg, cfg: g.cfg });
+    if (r.isError) { console.error("\n  " + r.text); process.exit(1); }
+    reportAutoOutcome(r, flags, "Auto Mode");
+  } catch (err) {
+    const e = /** @type {NodeErr} */ (err);
+    console.error("\n  ✗ Exécution Auto échouée :", e.message);
+    process.exit(1);
+  }
+}
+// MODULE_COMPLETE

package/src/cli/auto-task.js

@@ -0,0 +1,26 @@
+// src/cli/auto-task.js — Besoin effectif de `auto plan` : sans tâche, le --need de
+// l'utilisateur ; avec `--task audit` (ou PLUGCTO_TASK), un LIBELLÉ PUBLIC comme
+// besoin (c'est lui qui est affiché et persisté) et les instructions CONFIDENTIELLES
+// récupérées auprès du serveur, transmises à la seule décomposition. Tâche inconnue
+// → erreur exit 2 ; protocole indisponible → erreur exit 5 (message honnête).
+
+import { AUDIT_LABEL, loadAuditInstructions } from "../engine/audit-task.js";
+
+/** @typedef {Error & { exitCode?: number }} TaskError */
+
+/** @param {string} message @param {number} exitCode @returns {TaskError} */
+function fail(message, exitCode) {
+  const e = /** @type {TaskError} */ (new Error(message));
+  e.exitCode = exitCode;
+  return e;
+}
+
+/** @param {AutoFlags} flags @param {PlugConfig} cfg @param {{ env?: Record<string, string | undefined>, load?: typeof loadAuditInstructions }} [deps] @returns {Promise<{ need: string, instructions: string }>} */
+export async function resolveTask(flags, cfg, { env = process.env, load = loadAuditInstructions } = {}) {
+  const task = String(flags.task || env.PLUGCTO_TASK || "").trim().toLowerCase();
+  if (!task) return { need: flags.need, instructions: "" };
+  if (task !== "audit") throw fail(`Tâche inconnue « ${task} » (valeur acceptée : audit).`, 2);
+  try { return { need: AUDIT_LABEL, instructions: await load(cfg) }; }
+  catch (e) { throw fail(/** @type {Error} */ (e).message, 5); }
+}
+// MODULE_COMPLETE

package/src/cli/banner.js

@@ -0,0 +1,20 @@
+// src/cli/banner.js — Bannière de démarrage + liste des candidats IDE détectés.
+// Affiche l'en-tête PipCode, le système détecté et chaque candidat avec son
+// drapeau de détection (✓ installé / non installé).
+
+/** @typedef {{ id: string, name: string, path: string, parentExists: boolean, configExists: boolean, schema?: "mcpServers" | "servers" | "context_servers" | "toml" }} IdeConfigEntry */
+
+// Affiche l'en-tête + la liste des candidats IDE (détectés ou non).
+/** @param {string} osName @param {IdeConfigEntry[]} candidates */
+export function printBanner(osName, candidates) {
+  console.log("╔══════════════════════════════════════════════════════════╗");
+  console.log("║       PipCode — auto-configuration MCP (Zero-Click, BYOK)   ║");
+  console.log("╚══════════════════════════════════════════════════════════╝");
+  console.log(`\n  Système détecté : ${osName}`);
+  console.log("  IDE candidats :");
+  candidates.forEach((c) => {
+    const tag = c.parentExists ? "✓ détecté" : "  non installé";
+    console.log(`    • ${c.name.padEnd(16)} ${tag}  ${c.path}`);
+  });
+}
+// MODULE_COMPLETE

package/src/cli/centralize.js

@@ -0,0 +1,23 @@
+// src/cli/centralize.js — Centralisation best-effort du token + email dans
+// ~/.pipcode/config.json (partagé CLI / agents / extension VS Code).
+// Un échec d'écriture n'empêche pas l'inscription MCP (la licence reste dans l'env).
+
+import { writeSharedConfig } from "../fs/config-write.js";
+
+/** @typedef {{ licenseKey: string, email: string }} CollectedConfig */
+
+// Écrit le token + email validés dans la config partagée. Best-effort (log seulement).
+/** @param {CollectedConfig} collected @returns {Promise<void>} */
+export async function centralizeConfig(collected) {
+  try {
+    const sc = await writeSharedConfig({ licenseKey: collected.licenseKey, email: collected.email });
+    if (collected.licenseKey) {
+      console.log(`  🔑 Licence centralisée dans ${sc.path} (partagée CLI / agents / extension).`);
+    }
+  } catch (err) {
+    const e = /** @type {Error} */ (err);
+    if (collected.licenseKey) throw new Error(`Licence NON enregistrée : impossible d'écrire la config partagée (${e.message})`); // la licence ne vit que là : échec franc plutôt qu'un client sans licence
+    console.error(`  ⚠️  Impossible de centraliser la config partagée : ${e.message}`);
+  }
+}
+// MODULE_COMPLETE

package/src/cli/collect-step.js

@@ -0,0 +1,25 @@
+// src/cli/collect-step.js — Étape collecte du setup (TTY interactive / non-TTY env).
+// TTY : readline + collectInteractive (config existante lue ; licence et e-mail seulement). Non-TTY : collectFromEnv (licence optionnelle : sans clé, 5 jours d'essai).
+
+import readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { collectInteractive } from "./interactive.js";
+import { collectFromEnv } from "../engine/collect.js";
+import { readSharedConfig } from "../fs/config-read.js";
+
+/** @typedef {{ licenseKey: string, email: string }} CollectedConfig */
+
+// Collecte : interactive si TTY, sinon env vars (CI/tests). Aucune clé d'IA n'est demandée ni exigée.
+/** @param {boolean} isTTY @returns {Promise<CollectedConfig>} */
+export async function collectForSetup(isTTY) {
+  if (isTTY) {
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    try {
+      const existingConfig = await readSharedConfig().catch(() => ({}));
+      return await collectInteractive(rl, { existingConfig });
+    } finally { rl.close(); }
+  }
+  console.log("\n  (Mode non-interactif : lecture des variables d'environnement.)");
+  return collectFromEnv();
+}
+// MODULE_COMPLETE

package/src/cli/config-pairs.js

@@ -0,0 +1,46 @@
+// src/cli/config-pairs.js — Traduction PURE des réponses de `config` en paires
+// .env : inférence du provider cloud depuis le format de la clé (zéro question
+// supplémentaire), bascule Ollama quand la clé BYOK est laissée vide. La clé
+// de licence réutilise la règle de validation de setup-args.js (zéro doublon).
+
+import { KEY_RE } from "./setup-args.js";
+
+/** @typedef {Record<string, string>} EnvPairs */
+
+// Clé API cloud : préfixes des 3 clouds nommés + forme générique (8-256,
+// alphanum/._- : couvre sk-, sk-ant-, sk-or-, AIza…). Espace = rejet.
+const API_KEY_RE = /^[A-Za-z0-9._-]{8,256}$/;
+
+// Inférence du provider : sk-ant- (Anthropic) AVANT le préfixe générique sk-.
+/** @param {string} apiKey @returns {string} */
+export function inferProvider(apiKey) {
+  if (apiKey.startsWith("sk-ant-")) return "anthropic";
+  if (apiKey.startsWith("AIza")) return "gemini";
+  return "openai";
+}
+
+/**
+ * Réponses des 2 questions → paires .env canoniques. Entrée vide = choix
+ * explicite : pas de licence (essai 5 jours puis Lite) / mode local Ollama.
+ * Validation Zero Trust aux frontières : formats malformés rejetés proprement.
+ * @param {string} licenseKey @param {string} apiKey @returns {EnvPairs}
+ */
+export function answersToPairs(licenseKey, apiKey) {
+  const license = licenseKey.trim();
+  const key = apiKey.trim();
+  if (license && !KEY_RE.test(license)) {
+    throw new Error("Clé de licence malformée (8-128 caractères alphanumériques, tirets ou underscores). Rien saisir = essai 5 jours.");
+  }
+  if (key && !API_KEY_RE.test(key)) {
+    throw new Error("Clé API malformée (espaces ou caractères inattendus). Rien saisir = Mode Local / Ollama.");
+  }
+  /** @type {EnvPairs} */ const pairs = {};
+  if (license) pairs.PLUGCTO_LICENSE_KEY = license;
+  if (!key) pairs.PLUGCTO_PROVIDER_PRIMARY = "ollama";
+  else {
+    pairs.PLUGCTO_PROVIDER_PRIMARY = inferProvider(key);
+    pairs.PLUGCTO_PROVIDER_PRIMARY_KEY = key;
+  }
+  return pairs;
+}
+// MODULE_COMPLETE

package/src/cli/config.js

@@ -0,0 +1,51 @@
+// src/cli/config.js — `npx pipcode config` : saisie interactive des 2 clés
+// (licence Polar.sh, BYOK cloud) → .env local à la racine du projet, hors Git.
+// Zéro-IA : les clés ne transitent par AUCUN prompt LLM ni appel réseau au
+// moment de la saisie ; elles ne servent ensuite qu'aux en-têtes HTTP vers le
+// provider choisi. Confirmation sans écho : jamais de clé affichée.
+
+import readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { makePrompts } from "./prompts.js";
+import { answersToPairs } from "./config-pairs.js";
+import { rebuildEnvText } from "./env-rebuild.js";
+import { localEnvPath, readLocalEnvText, writeEnvText } from "./env-file.js";
+import { ensureEnvIgnored } from "./gitignore-env.js";
+
+/** @typedef {Record<string, string>} EnvPairs */
+
+// Résumé final : libellés uniquement, JAMAIS la moindre valeur de clé.
+/** @param {EnvPairs} pairs @param {string} envPath */
+function printSummary(pairs, envPath) {
+  const local = pairs.PLUGCTO_PROVIDER_PRIMARY === "ollama";
+  const licence = pairs.PLUGCTO_LICENSE_KEY ? "Pro (clé Polar.sh enregistrée)" : "Essai gratuit 5 jours puis Lite";
+  const engine = local ? "Mode Local / Ollama (aucune clé cloud)" : `${pairs.PLUGCTO_PROVIDER_PRIMARY} (clé cloud enregistrée)`;
+  console.log(`\n  ✅ Enregistré (localement, hors Git) : ${envPath}`);
+  console.log(`     Licence : ${licence}`);
+  console.log(`     Moteur IA : ${engine}`);
+  console.log("\n  Prochaine étape : npx pipcode setup (installation/configuration des IDE).");
+}
+
+// Commande interactive : 2 questions readline → paires validées → .env fusionné
+// (lignes tierces préservées) → .gitignore garanti → résumé sans écho.
+/** @param {string} [cwd] @returns {Promise<void>} */
+export async function runConfigCli(cwd = process.cwd()) {
+  if (!stdin.isTTY) {
+    throw new Error("Commande interactive : lancez `npx pipcode config` dans un terminal. Sans terminal : variables d'environnement ou `npx pipcode setup --key <CLÉ>`.");
+  }
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    const p = makePrompts(rl);
+    console.log("PipCode — configuration locale des clés (stockées dans .env, jamais committées).");
+    const licenseKey = await p.ask("Clé de licence Polar.sh (Entrée = Essai gratuit 5 jours / Lite) : ");
+    const apiKey = await p.ask("Clé API Cloud BYOK (Gemini, OpenAI, Anthropic - Entrée = Mode Local / Ollama) : ");
+    const pairs = answersToPairs(licenseKey, apiKey);
+    const existing = (await readLocalEnvText(cwd)) ?? "";
+    await writeEnvText(cwd, rebuildEnvText(existing, pairs));
+    await ensureEnvIgnored(cwd);
+    printSummary(pairs, localEnvPath(cwd));
+  } finally {
+    rl.close();
+  }
+}
+// MODULE_COMPLETE

package/src/cli/detect-os.js

@@ -0,0 +1,11 @@
+// src/cli/detect-os.js — Détection de plateforme (leaf pur, zéro import).
+// Mappe process.platform vers un identifiant OS stable utilisé par les modules
+// fs (permissions icacls vs chmod) et cli (localisation des config IDE).
+
+/** @param {string} [platform] @returns {"macos" | "windows" | "linux"} */
+export function detectOS(platform = process.platform) {
+  if (platform === "darwin") return "macos";
+  if (platform === "win32") return "windows";
+  return "linux";
+}
+// MODULE_COMPLETE