pipcode 0.0.0-stage → 2.1.1

package/src/rules/rules-validate-scan.js

@@ -0,0 +1,45 @@
+// src/rules/rules-validate-scan.js — Zero Trust sur les règles du scan de patch reçues du serveur (lot Pro) :
+// listes de chaînes bornées, expressions compilables, textes présents. La signature prouve l'origine, ceci
+// prouve la FORME. Toute anomalie lève une erreur typée ; rien n'est « réparé » en silence.
+
+const isObj = (/** @type {unknown} */ v) => !!v && typeof v === "object" && !Array.isArray(v);
+const isStr = (/** @type {unknown} */ v) => typeof v === "string" && v.length > 0 && v.length <= 2000;
+const strs = (/** @type {unknown} */ v) => Array.isArray(v) && v.length <= 200 && v.every(isStr);
+/** @param {string} m @returns {Error} */
+const bad = (m) => new Error(`Règles PipCode invalides (scan : ${m}).`);
+
+/** @param {unknown} src @param {string} what */
+function regex(src, what) {
+  if (!isStr(src)) throw bad(what);
+  try { new RegExp(/** @type {string} */ (src)); } catch { throw bad(`${what} non compilable`); }
+}
+/** @param {unknown} m @param {string} what */
+function msg(m, what) {
+  const part = (/** @type {unknown} */ v) => isStr(v) || (isObj(v) && isStr(/** @type {Record<string, unknown>} */ (v).js) && isStr(/** @type {Record<string, unknown>} */ (v).py));
+  const o = /** @type {Record<string, unknown>} */ (m);
+  if (!isObj(m) || !part(o.rule) || !part(o.alt)) throw bad(`message ${what}`);
+}
+
+/** @param {unknown} scan @returns {ScanRules} */
+export function parseScan(scan) {
+  const s = /** @type {Record<string, Record<string, unknown>>} */ (scan);
+  if (!isObj(scan) || !isObj(s.ast) || !isObj(s.graph) || !isObj(s.cheat) || !isObj(s.design)) throw bad("sections");
+  const { ast, graph, cheat, design } = s;
+  const callees = /** @type {Record<string, Record<string, unknown>>} */ (ast.callees);
+  if (!isObj(callees) || !isObj(callees.js) || !isObj(callees.py)) throw bad("callees");
+  for (const k of ["dangerous", "shell", "xssWrites", "xssCalls", "stringEval"]) if (!strs(callees.js[k])) throw bad(`callees.js.${k}`);
+  if (!strs(callees.py.dangerous) || !strs(ast.xssWriteAll) || !strs(ast.jsxSinks)) throw bad("listes ast");
+  for (const r of /** @type {string[]} */ (ast.xssWriteAll)) regex(r, "xssWriteAll");
+  regex(ast.secretNames, "secretNames");
+  if (!Number.isInteger(ast.minString) || /** @type {number} */ (ast.minString) < 1 || /** @type {number} */ (ast.minString) > 64) throw bad("minString");
+  const msgs = /** @type {Record<string, unknown>} */ (ast.msgs);
+  for (const k of ["dangerous", "shell", "stringEval", "xssCall", "xssWrite", "secret", "jsx"]) msg(msgs?.[k], `ast.${k}`);
+  msg(graph.cycle, "graph.cycle"); msg(graph.orphan, "graph.orphan");
+  for (const k of ["testFile", "tauto", "assert", "emptyCatch", "skip", "commented", "callAssign", "stub"]) regex(cheat[k], `cheat.${k}`);
+  const rules = /** @type {{ rule?: unknown, alt?: unknown }[]} */ (cheat.rules);
+  if (!Number.isInteger(cheat.commentedMin) || !Array.isArray(rules) || rules.length !== 5 || !rules.every((r) => isObj(r) && isStr(r.rule) && isStr(r.alt))) throw bad("cheat.rules");
+  const shell = /** @type {{ rule?: unknown, patterns?: unknown }[]} */ (design.shellInUi);
+  if (!Array.isArray(shell) || !shell.every((v) => isObj(v) && isStr(v.rule) && strs(v.patterns)) || !isStr(design.shellAlt) || !isStr(design.charterAlt)) throw bad("design");
+  return /** @type {ScanRules} */ (scan);
+}
+// MODULE_COMPLETE

package/src/rules/rules-validate.js

@@ -0,0 +1,53 @@
+// src/rules/rules-validate.js — Zero Trust sur les règles reçues du serveur : la signature Ed25519 prouve
+// l'origine, cette validation prouve la FORME (objets simples, chaînes bornées) avant tout usage par le
+// moteur. Toute anomalie lève une erreur typée ; rien n'est « réparé » en silence.
+
+import { parseScan } from "./rules-validate-scan.js";
+import { parsePricing } from "./rules-validate-pricing.js";
+
+export const SKILL_PLACEHOLDER = "{{SKILL_CONTENT}}";
+const MAX_TEXT = 200_000;
+const isObj = (/** @type {unknown} */ v) => !!v && typeof v === "object" && !Array.isArray(v);
+const isStrArr = (/** @type {unknown} */ v) => Array.isArray(v) && v.every((s) => typeof s === "string");
+const isText = (/** @type {unknown} */ v) => typeof v === "string" && v.length > 0 && v.length <= MAX_TEXT;
+
+/** @param {string} m @returns {Error} */
+const bad = (m) => new Error(`Règles PipCode invalides (${m}).`);
+
+/** @param {string} text @returns {Record<string, unknown>} */
+function parseObject(text) {
+  if (typeof text !== "string" || text.length > 1_000_000) throw bad("taille");
+  /** @type {unknown} */ let o;
+  try { o = JSON.parse(text); } catch { throw bad("JSON illisible"); }
+  if (!isObj(o) || /** @type {Record<string, unknown>} */ (o).v !== 1) throw bad("version");
+  return /** @type {Record<string, unknown>} */ (o);
+}
+
+/** Lot « base » (accessible à tous) → champs du registre. @param {string} text */
+export function parseBaseRules(text) {
+  const o = parseObject(text);
+  const prompts = /** @type {Record<string, unknown>} */ (o.prompts);
+  if (!isObj(o.domains) || !isObj(o.patterns) || !isObj(o.glossary) || !isObj(prompts)) throw bad("lot base incomplet");
+  const plan = /** @type {Record<string, unknown>} */ (o.plan);
+  const imp = /** @type {Record<string, unknown>} */ (plan?.impact);
+  if (!isObj(plan) || !isStrArr(plan.steps) || !isObj(imp) || !["base", "perDomain", "perRole", "perRule", "perFiche", "filesPerDomain", "filesBase"].every((k) => Number.isFinite(imp[k]))) throw bad("plan (étapes, impact)");
+  if (!isText(prompts.analysis) || !isText(prompts.mission) || !isText(prompts.master)) throw bad("prompts de base");
+  if (/** @type {string} */ (prompts.master).split(SKILL_PLACEHOLDER).length !== 2) throw bad("prompt maître : emplacement de fiche");
+  for (const d of Object.values(/** @type {Record<string, unknown>} */ (o.domains))) {
+    const x = /** @type {Record<string, unknown>} */ (d);
+    if (!isObj(x) || typeof x.label !== "string" || !isStrArr(x.keywords) || !isStrArr(x.roles) || !isStrArr(x.fiches)) throw bad("domaine");
+  }
+  return { domains: /** @type {Record<string, BusinessDomain>} */ (o.domains), patterns: /** @type {EngineRules["patterns"]} */ (o.patterns), glossary: /** @type {EngineRules["glossary"]} */ (o.glossary), analysis: /** @type {string} */ (prompts.analysis), mission: /** @type {string} */ (prompts.mission), master: /** @type {string} */ (prompts.master), plan: /** @type {EngineRules["plan"]} */ (plan), pricing: parsePricing(o.pricing) };
+}
+
+/** Lot « pro » (essai / Pro) → UX + prompt de patch. @param {string} text */
+export function parseProRules(text) {
+  const o = parseObject(text);
+  const ux = /** @type {Record<string, unknown>} */ (o.ux);
+  const prompts = /** @type {Record<string, unknown>} */ (o.prompts);
+  const prefix = /** @type {Record<string, unknown>} */ (o.prefix);
+  if (!isObj(ux) || !isObj(ux.design) || !isStrArr(ux.universal) || !isObj(prompts) || !isText(prompts.patch) || !isText(prompts.decomp) || !isText(prompts.control)) throw bad("lot pro incomplet");
+  if (!isObj(prefix) || !Object.values(prefix).every((s) => typeof s === "string" && s.length <= 400)) throw bad("préfixe de mission");
+  return { ux: /** @type {EngineRules["ux"]} */ (ux), patch: /** @type {string} */ (prompts.patch), decomp: /** @type {string} */ (prompts.decomp), control: /** @type {string} */ (prompts.control), prefix: /** @type {Record<string, string>} */ (prefix), scan: parseScan(o.scan) };
+}
+// MODULE_COMPLETE

package/src/teardown/consent.js

@@ -0,0 +1,31 @@
+// src/teardown/consent.js — Consentement interactif avant suppression (Phase 6).
+// Requis en interactif. Implicite en non-interactif : le hook npm postuninstall
+// et la CI n'ont pas de TTY pour répondre à une invite (le teardown ne touche
+// que des artefacts appartenant à PipCode — inversion de l'empreinte setup).
+
+import readline from "node:readline/promises";
+
+/** @typedef {{ yes: boolean, dryRun: boolean }} ConsentFlags */
+
+/** @param {ConsentFlags} flags @param {() => Promise<boolean>} [ask] @returns {Promise<boolean>} */
+export async function requestConsent(flags, ask = askInteractively) {
+  if (flags.yes || flags.dryRun) return true;
+  if (!process.stdin.isTTY) {
+    console.log("  ℹ️  Contexte non interactif (hook de désinstallation / CI) : consentement implicite.");
+    return true;
+  }
+  return ask();
+}
+
+// Invite interactive y/N (accepte oui/yes/o/y ; tout le reste = refus, fail-safe).
+/** @returns {Promise<boolean>} */
+async function askInteractively() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question("  ⚠️  Supprimer les artefacts PipCode listés ci-dessus ? [y/N] ")).trim().toLowerCase();
+    return answer === "y" || answer === "yes" || answer === "o" || answer === "oui";
+  } finally {
+    rl.close();
+  }
+}
+// MODULE_COMPLETE

package/src/teardown/flags.js

@@ -0,0 +1,39 @@
+// src/teardown/flags.js — Parsing des options de désinstallation (Phase 6).
+// --yes (hooks npm/CI), --dry-run (plan sans écriture), --keep-config (épargne
+// la config partagée), --ide-only / --config-only (périmètre), --help.
+
+// Aide CLI du teardown (affichée par --help).
+export const TEARDOWN_HELP = [
+  "Usage : npx pipcode teardown [options]",
+  "",
+  "Désinstallation propre de PipCode : retire l'entrée MCP PipCode de chaque",
+  "config IDE détectée (sans altérer les autres clés) et supprime la config",
+  "partagée ~/.pipcode/config.json (dossier retiré seulement s'il devient vide).",
+  "",
+  "Options :",
+  "  --yes, -y        Supprime sans invite (hooks npm / CI)",
+  "  --dry-run        Affiche le plan sans rien écrire",
+  "  --keep-config    Conserve la config partagée (licences / clés BYOK)",
+  "  --ide-only       Ne touche que les entrées MCP des configs IDE",
+  "  --config-only    Ne touche que la config partagée ~/.pipcode",
+  "  --help, -h       Affiche cette aide",
+].join("\n");
+
+/** @param {string[]} argv @returns {TeardownFlags} */
+export function parseTeardownFlags(argv) {
+  /** @type {TeardownFlags} */
+  const flags = { yes: false, dryRun: false, keepConfig: false, configOnly: false, ideOnly: false, help: false };
+  for (const a of argv) {
+    if (a === "--yes" || a === "-y") flags.yes = true;
+    else if (a === "--dry-run") flags.dryRun = true;
+    else if (a === "--keep-config") flags.keepConfig = true;
+    else if (a === "--config-only") flags.configOnly = true;
+    else if (a === "--ide-only") flags.ideOnly = true;
+    else if (a === "--help" || a === "-h") flags.help = true;
+    else throw new Error(`Option inconnue : "${a}". Essayez : npx pipcode teardown --help`);
+  }
+  if (flags.ideOnly && flags.configOnly) throw new Error("--ide-only et --config-only sont contradictoires.");
+  if (flags.configOnly && flags.keepConfig) throw new Error("--config-only et --keep-config sont contradictoires.");
+  return flags;
+}
+// MODULE_COMPLETE

package/src/teardown/main.js

@@ -0,0 +1,41 @@
+// src/teardown/main.js — Orchestration du teardown (Phase 6) : flags → plan
+// (dry-run affiché) → consentement → exécution best-effort → bilan.
+
+import os from "node:os";
+import { detectOS } from "../cli/detect-os.js";
+import { resolvePlugctoRoot } from "../fs/home-root.js";
+import { parseTeardownFlags, TEARDOWN_HELP } from "./flags.js";
+import { buildTeardownPlan } from "./plan.js";
+import { requestConsent } from "./consent.js";
+import { removeIdeEntry } from "./remove-entry.js";
+import { removeSharedConfig } from "./remove-file.js";
+import { printPlan, printResults } from "./report.js";
+
+/** @param {TeardownCtx} [ctx] @returns {Promise<TeardownSummary>} */
+export async function runTeardown(ctx = {}) {
+  const env = ctx.env || process.env;
+  const home = ctx.home || os.homedir();
+  const flags = parseTeardownFlags(ctx.argv || process.argv.slice(2));
+  if (flags.help) { console.log(TEARDOWN_HELP); return { removed: 0, absent: 0, errors: 0, dryRun: true }; }
+  const configDir = resolvePlugctoRoot(env); // même racine résiliente que le setup
+  const plan = buildTeardownPlan(flags, { configDir, osName: ctx.osName || detectOS(), env, home });
+  console.log("\n🧹 Teardown PipCode — artefacts détectés :");
+  printPlan(plan);
+  if (flags.dryRun || !plan.length) {
+    console.log(flags.dryRun ? "\n  (dry-run : aucun changement effectué)" : "\n  ✅ Rien à désinstaller.");
+    return { removed: 0, absent: 0, errors: 0, dryRun: flags.dryRun };
+  }
+  if (!(await requestConsent(flags))) {
+    console.log("  ✅ Annulé — aucun changement effectué.");
+    return { removed: 0, absent: 0, errors: 0, dryRun: false };
+  }
+  const results = [];
+  for (const a of plan) {
+    const r = a.kind === "ide-entry"
+      ? await removeIdeEntry(a.path, a.schema || "mcpServers")
+      : await removeSharedConfig(a.path);
+    results.push({ ...r, path: a.path, label: a.label });
+  }
+  return printResults(results);
+}
+// MODULE_COMPLETE

package/src/teardown/plan.js

@@ -0,0 +1,31 @@
+// src/teardown/plan.js — Inventaire des artefacts installés par setup (Phase 6).
+// Inversion exacte de l'empreinte : entrée MCP `pipcode` dans les configs IDE
+// (ideConfigPaths = source unique de vérité, aucun chemin codé en dur) +
+// config partagée ~/.pipcode/config.json. Les configs IDE inexistantes sont
+// exclues du plan (rien à retirer).
+
+import path from "node:path";
+import { ideConfigPaths } from "../cli/ide-paths.js";
+import { sharedConfigPath } from "../fs/config-path.js";
+
+/**
+ * @param {TeardownFlags} flags
+ * @param {{ configDir: string, osName?: string, env?: Record<string, string | undefined>, home?: string }} ctx
+ * @returns {TeardownAction[]}
+ */
+export function buildTeardownPlan(flags, ctx) {
+  /** @type {TeardownAction[]} */
+  const actions = [];
+  if (!flags.configOnly) {
+    for (const e of ideConfigPaths(ctx.osName, ctx.env, ctx.home)) {
+      if (e.configExists) {
+        actions.push({ kind: "ide-entry", path: e.path, label: e.name, schema: e.schema || "mcpServers" });
+      }
+    }
+  }
+  if (!flags.ideOnly && !flags.keepConfig) {
+    actions.push({ kind: "config", path: sharedConfigPath(ctx.configDir), label: "Config partagée " + path.join(ctx.configDir, "config.json") });
+  }
+  return actions;
+}
+// MODULE_COMPLETE

package/src/teardown/remove-entry.js

@@ -0,0 +1,39 @@
+// src/teardown/remove-entry.js — Retrait chirurgical de l'entrée MCP `pipcode`
+// d'une config IDE (Phase 6). Préserve toutes les autres clés du fichier. Si le
+// fichier ne contient plus RIEN après retrait (fichier créé par setup), il est
+// supprimé : inversion exacte d'applySetup (merge → unmerge, created → delete).
+
+import fs from "node:fs/promises";
+import { loadConfig } from "../fs/load-config.js";
+import { writeConfigAtomic } from "../fs/atomic-write.js";
+import { SERVER_KEY } from "../cli/server-entry.js";
+import { LEGACY_SERVER_KEYS } from "../cli/legacy-entry.js";
+import { removeTomlEntry } from "./remove-toml.js";
+
+/** @typedef {Error & { code?: string }} NodeErr */
+
+/** @param {string} filePath @param {"mcpServers" | "servers" | "context_servers" | "toml"} [schema] @returns {Promise<RemoveResult>} */
+export async function removeIdeEntry(filePath, schema = "mcpServers") {
+  if (schema === "toml") return removeTomlEntry(filePath);
+  try {
+    const config = await loadConfig(filePath);
+    const root = config[schema];
+    const bucket = /** @type {Record<string, unknown> | undefined} */ (root);
+    const keys = bucket && typeof bucket === "object" ? [SERVER_KEY, ...LEGACY_SERVER_KEYS].filter((k) => k in bucket) : [];
+    if (!bucket || keys.length === 0) return { status: "absent" }; // fichier inexistant, sans notre entrée (nom actuel ou ancien), ou schéma inattendu
+    for (const k of keys) delete bucket[k];
+    // Fichier « créé par setup » = config réduite à une racine de schéma vide
+    // (ex. { mcpServers: {} }) → suppression du fichier (inversion de created).
+    const onlyEmptySchemaRoot = Object.keys(config).length === 1 && Object.keys(bucket).length === 0;
+    if (onlyEmptySchemaRoot) {
+      await fs.rm(filePath, { force: true });
+      return { status: "file-removed" };
+    }
+    await writeConfigAtomic(filePath, config);
+    return { status: "removed" };
+  } catch (err) {
+    const e = /** @type {NodeErr} */ (err);
+    return { status: "error", error: e.message }; // best-effort : ne bloque pas les autres fichiers
+  }
+}
+// MODULE_COMPLETE

package/src/teardown/remove-file.js

@@ -0,0 +1,37 @@
+// src/teardown/remove-file.js — Suppression sécurisée de la config partagée
+// ~/.pipcode/config.json (Phase 6). Zero Trust : le fichier n'est supprimé que
+// s'il ressemble à une config PipCode (champs licenseKey/email/primary) — un
+// fichier illisible ou étranger est conservé. Le dossier parent est retiré
+// uniquement s'il devient vide (rmdir non-récursif : jamais rm -rf).
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { warnIfBlocked } from "../fs/os-errors.js";
+
+/** @typedef {Error & { code?: string }} NodeErr */
+
+/** @param {string} configPath @returns {Promise<RemoveResult>} */
+export async function removeSharedConfig(configPath) {
+  try {
+    let raw;
+    try {
+      raw = await fs.readFile(configPath, "utf8");
+    } catch (err) {
+      const e = /** @type {NodeErr} */ (err);
+      if (e && e.code === "ENOENT") return { status: "absent" };
+      throw err;
+    }
+    let cfg;
+    try { cfg = JSON.parse(raw); } catch { return { status: "kept-foreign" }; } // illisible : non vérifiable, conservé
+    if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) return { status: "kept-foreign" };
+    if (!("licenseKey" in cfg) && !("email" in cfg) && !("primary" in cfg)) return { status: "kept-foreign" };
+    await fs.rm(configPath, { force: true });
+    try { await fs.rmdir(path.dirname(configPath)); } catch { /* dossier non vide : conservé */ }
+    return { status: "removed" };
+  } catch (err) {
+    const e = /** @type {NodeErr} */ (err);
+    warnIfBlocked(`suppression de ${configPath}`, err); // AV/droits : averti proprement, pas de crash
+    return { status: "error", error: e.message }; // best-effort : listé au bilan
+  }
+}
+// MODULE_COMPLETE

package/src/teardown/remove-toml.js

@@ -0,0 +1,33 @@
+// src/teardown/remove-toml.js — Retrait chirurgical de nos tables MCP `pipcode`
+// du config.toml de Codex (inversion de apply-toml.js). Tout le reste du fichier
+// est conservé ; si plus rien ne reste (fichier créé par setup), il est supprimé.
+// Fichier que toml-merge refuse de traiter (chaînes multilignes) → status "error"
+// honnête, jamais de réécriture à l'aveugle. Best-effort : ne bloque pas les autres.
+
+import fs from "node:fs/promises";
+import { SERVER_KEY } from "../cli/server-entry.js";
+import { LEGACY_SERVER_KEYS } from "../cli/legacy-entry.js";
+import { removeToml } from "../cli/toml-merge.js";
+import { writeTextAtomic } from "../fs/atomic-text.js";
+
+/** @typedef {Error & { code?: string }} NodeErr */
+
+/** @param {string} filePath @returns {Promise<RemoveResult>} */
+export async function removeTomlEntry(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const steps = [SERVER_KEY, ...LEGACY_SERVER_KEYS].reduce((acc, k) => { const r = removeToml(acc.text, k); return { text: r.text, changed: acc.changed || r.changed }; }, { text: raw, changed: false }); // nom actuel puis anciens noms
+    const { text, changed } = steps;
+    if (!changed) return { status: "absent" };
+    if (!text.trim()) {
+      await fs.rm(filePath, { force: true });
+      return { status: "file-removed" };
+    }
+    await writeTextAtomic(filePath, text);
+    return { status: "removed" };
+  } catch (err) {
+    const e = /** @type {NodeErr} */ (err);
+    return e.code === "ENOENT" ? { status: "absent" } : { status: "error", error: e.message };
+  }
+}
+// MODULE_COMPLETE

package/src/teardown/report.js

@@ -0,0 +1,34 @@
+// src/teardown/report.js — Rendu du plan (dry-run) et du bilan de suppression
+// (Phase 6). Best-effort : chaque échec est listé sans interrompre les autres.
+
+const STATUS_LABEL = {
+  removed: "entrée PipCode retirée (fichier conservé)",
+  "file-removed": "fichier vidé puis supprimé (créé par setup, vide après retrait)",
+  absent: "déjà absent",
+  "kept-foreign": "conservé (contenu non PipCode — rien supprimé)",
+  error: "échec (non bloquant)",
+};
+
+/** @param {TeardownAction[]} plan @returns {void} */
+export function printPlan(plan) {
+  if (!plan.length) { console.log("  (aucun artefact détecté)"); return; }
+  for (const a of plan) {
+    const detail = a.kind === "config" ? "suppression (dossier retiré seulement si vide)" : "retrait de l'entrée PipCode uniquement";
+    console.log(`  • ${a.label} → ${a.path} (${detail})`);
+  }
+}
+
+/** @param {TeardownResult[]} results @returns {TeardownSummary} */
+export function printResults(results) {
+  let removed = 0, absent = 0, errors = 0;
+  for (const r of results) {
+    const icon = r.status === "error" ? "⚠️ " : "✓";
+    console.log(`  ${icon} ${r.label} : ${STATUS_LABEL[r.status]}${r.error ? " — " + r.error : ""}`);
+    if (r.status === "removed" || r.status === "file-removed") removed++;
+    else if (r.status === "absent" || r.status === "kept-foreign") absent++;
+    else errors++;
+  }
+  console.log(`\n  Bilan : ${removed} retiré(s), ${absent} déjà absent(s)/conservé(s), ${errors} échec(s).`);
+  return { removed, absent, errors, dryRun: false };
+}
+// MODULE_COMPLETE

package/src/types/ast.d.ts

@@ -0,0 +1,40 @@
+// src/types/ast.d.ts — Contrats du scanner AST (Tree-sitter WASM, v1.1).
+
+// Node Tree-sitter (subset strict utilisé par le scanner).
+interface AstNode {
+  type: string; text: string;
+  firstChild: AstNode | null; lastChild: AstNode | null;
+  firstNamedChild: AstNode | null; nextSibling: AstNode | null;
+  childCount: number; rootNode: AstNode;
+  child(index: number): AstNode | null;
+}
+
+// Parser initialisé avec une grammaire.
+interface AstParser {
+  setLanguage(l: unknown): void;
+  parse(s: string): { rootNode: AstNode | null } | null;
+}
+
+// Runtime WASM chargé (Parser + grammaires par clé de langage).
+interface AstRuntime {
+  Parser: new () => AstParser;
+  langs: Record<string, unknown>;
+}
+
+// Contexte de règles AST calculé par langage (js|ts|tsx|py).
+interface AstContext {
+  isPy: boolean; isJsx: boolean; callType: string;
+  dangerousCallees: Set<string>;
+  shellCallees: Set<string> | null;
+  xssMemberWrites: Set<string> | null;
+  xssMemberCalls: Set<string> | null;
+  stringEvalCallees: Set<string> | null;
+  xssWriteAll: RegExp[]; secretRe: RegExp; minString: number; jsxSinks: Set<string>;
+  msgs: ScanRules["ast"]["msgs"];
+}
+
+// Section fichier d'un patch Unified Diff (découpage patch-file-sections.js).
+interface Section {
+  file: string; added: string[]; removed: string[]; isNew: boolean;
+}
+// MODULE_COMPLETE

package/src/types/auto-ask.d.ts

@@ -0,0 +1,6 @@
+// src/types/auto-ask.d.ts — Pause « ASK_USER » du Mode Auto (fusion de déclarations, ambient global) : le plan attend la réponse de l'utilisateur
+// (ce n'est pas un échec) ; `answer` = réponse transmise à la reprise.
+
+interface AutoResult { asking?: boolean; question?: string; cancelled?: boolean; }
+interface ResumeArgs { answer?: string; }
+// MODULE_COMPLETE

package/src/types/auto-orch.d.ts

@@ -0,0 +1,59 @@
+// src/types/auto-orch.d.ts — Types de l'orchestrateur Auto (args, résultat, deps).
+// Ambient global (aucun import/export). Référence PlugConfig/ProviderPrimary/
+// CallLLMArgs/OrchestratorArgs/OrchestratorResult/MissionPlan/AmnesiaContext/AutoState.
+
+/** Args de buildAutoPlan (need + projet + pcfg + cfg). */
+interface AutoPlanArgs { need: string; /** Ajustements demandés sur le plan précédent. */ adjust?: string; projectPath: string; pcfg: { primary: ProviderPrimary }; cfg: PlugConfig; /** Instructions confidentielles (serveur) : transmises à la décomposition, JAMAIS persistées. */ instructions?: string; }
+
+/** Args de runAutoStep (projet + consentement + pcfg + cfg). */
+interface AutoStepArgs { projectPath: string; confirmed?: boolean; pcfg: { primary: ProviderPrimary }; cfg: PlugConfig; }
+
+/** Args de runAutoRun (projet + consentement + maxSteps + pcfg + cfg). */
+interface AutoRunArgs { projectPath: string; confirmed?: boolean; maxSteps?: number; pcfg: { primary: ProviderPrimary }; cfg: PlugConfig; }
+
+/** Args de resumeAuto (projet + maxSteps + pcfg + cfg). */
+interface ResumeArgs { projectPath: string; maxSteps?: number; pcfg: { primary: ProviderPrimary }; cfg: PlugConfig; }
+
+/** Résultat lâche d'une opération Auto (branches isError/done/failed/needsConsent). */
+interface AutoResult {
+  isError?: boolean; text?: string; runId?: string; tasks?: AutoTask[];
+  budget?: AutoBudget | AutoBudgetResult; quote?: string; consent?: boolean; status?: string;
+  needsConsent?: boolean; done?: boolean; failed?: boolean; task?: AutoTask;
+  error?: string; violations?: GuardViolation[]; progress?: string; summary?: string;
+  diff?: string; commit?: string; steps?: AutoResult[]; last?: AutoResult;
+}
+
+/** Dépendances injectées par index.js (anti-import circulaire). */
+interface AutoDeps {
+  callLLM: (args: CallLLMArgs) => Promise<string>;
+  readProviderConfig?: unknown;
+  orchestrateLLM: (args: OrchestratorArgs, pcfg: { primary: ProviderPrimary }) => Promise<OrchestratorResult>;
+  readMissionContext: (missionPath: string) => Promise<MissionPlan | null>;
+  extractMission: (need: string, pcfg: { primary: ProviderPrimary } | null) => Promise<MissionPlan>;
+  writeMission: (mission: MissionPlan, missionPath: string) => Promise<void>;
+  missionContextPrefix: (mission: MissionPlan | null) => string;
+  loadAllDoctrine: (cfg: PlugConfig) => Promise<string>;
+  checkMissionGuard: (result: OrchestratorResult | null, mission: MissionPlan | null) => GuardResult;
+  parseJsonLoose: (raw: string, opts?: { arrays?: boolean; recover?: boolean }) => unknown;
+  logIteration: (missionPath: string, line: string) => Promise<void>;
+  patchMaxTokens: (bytes: number) => number;
+  ANALYSIS_MAX_TOKENS: number;
+}
+
+/** Contexte partagé des sous-fonctions de runAutoStep (évite la prolifération de params). */
+interface StepCtx { deps: AutoDeps; state: AutoState; doctrine: string; missionContext: string; mission: MissionPlan; task: AutoTask; fileContent: string; pcfg: { primary: ProviderPrimary }; idx: number; projectPath: string; missionPath: string; }
+
+/** Interface de l'orchestrateur Auto (retour de createAutoOrchestrator). */
+interface AutoOrchestrator {
+  buildAutoPlan: (arg: AutoPlanArgs) => Promise<AutoResult>;
+  runAutoStep: (arg: AutoStepArgs) => Promise<AutoResult>;
+  runAutoRun: (arg: AutoRunArgs) => Promise<AutoResult>;
+  resumeAuto: (arg: ResumeArgs) => Promise<AutoResult>;
+  applyDiffSafe: (arg: ApplyDiffArgs) => Promise<{ commit: string; touched: string[] }>;
+  estimateRunBudget: (tasks: AutoTask[], mission: MissionPlan, fileSizes: Record<string, number>, pcfg: { primary: ProviderPrimary }) => AutoBudgetResult;
+  buildAmnesiaContext: (state: AutoState | null, doctrine: string, missionContext: string) => AmnesiaContext;
+  buildCorrectionSignal: (violations: GuardViolation[] | null | undefined) => string;
+  loadAutoState: (projectPath: string) => Promise<AutoState | null>;
+  saveAutoState: (projectPath: string, state: AutoState) => Promise<void>;
+}
+// MODULE_COMPLETE

package/src/types/auto.d.ts

@@ -0,0 +1,45 @@
+// src/types/auto.d.ts — Types primitifs du Mode Auto (pricing, git, guard, budget).
+// Ambient global (aucun import/export) : utilisables via JSDoc sans import.
+
+/** Paire de prix modèle (USD pour 1 000 000 de tokens, in/out). */
+interface PricePair { in: number; out: number; }
+
+/** Table publique de prix modèles (provider → modèle → prix). */
+type PricingTable = Record<string, Record<string, PricePair>>;
+
+/** Config retry/backoff (maxRetries, baseMs). */
+interface RetryConfig { maxRetries: number; baseMs: number; }
+
+/** Erreur git enrichie (stderr capturé). */
+interface GitError extends Error { stderr?: string; }
+
+/** Violation émise par un Hook déterministe (re-attaque QA). */
+interface GuardViolation { kind?: string; rule?: string; alternative?: string; }
+
+/** Résultat du gate mission : bloqué (violations) ou autorisé. */
+interface GuardResult {
+  blocked: boolean;
+  message?: string | null;
+  violations?: GuardViolation[];
+}
+
+/** Devis budgétaire agrégé (tokens + coût estimé). */
+interface BudgetQuote { tokensEst: number; costUsdEst: number; }
+
+/** Devis budgétaire détaillé (per-task) — champs relais additifs (optionnels). */
+interface AutoBudgetResult {
+  tokensEst: number;
+  costUsdEst: number;
+  perTask: Array<{ id: string; file: string; tokens: number; relayTokens?: number }>;
+  relaysEst?: number;
+  relayTokensEst?: number;
+}
+
+/** Args d'applyDiffSafe (projet, fichier, diff, deps injectés). */
+interface ApplyDiffArgs {
+  projectPath: string;
+  file: string;
+  diff: string;
+  deps: AutoDeps;
+}
+// MODULE_COMPLETE

package/src/types/capability.d.ts

@@ -0,0 +1,12 @@
+// src/types/capability.d.ts — Types globaux du pré-flight de capacités (cap-*.js,
+// preflight.js) : capacité requise, verdict par capacité, rapport d'un modèle.
+
+type Capability = "vision" | "tools" | "media_generation";
+/** Verdict d'une capacité : true/false CONNU, null = non confirmé. `source` = d'où ça vient. */
+interface CapVerdict { cap: Capability; value: boolean | null; source: string; }
+/** Rapport d'évaluation d'UN modèle (même forme pour Modèle 1 et Modèle 2). */
+interface CapReport { ok: boolean; detail: CapVerdict[]; probed: boolean; }
+/** Modèle à évaluer : sous-ensemble de ProviderPrimary (provider, base, key, model). */
+interface CapModel { provider: ProviderName; base: string; key: string; model: string; }
+/** Métadonnées niveau 1 (0 token) : capacités connues + libellé de la source. */
+interface CapMeta { caps: Partial<Record<Capability, boolean>>; source: string; }

package/src/types/cli-auto-gate.d.ts

@@ -0,0 +1,45 @@
+// src/types/cli-auto-gate.d.ts — Types du gate Mode Auto CLI (flags + dépendances).
+// Ambient global (aucun import/export) : utilisables via JSDoc sans import.
+
+/** Erreur Node enrichie (code errno + status HTTP pour les erreurs Worker). */
+interface NodeErr extends Error {
+  code?: string;
+  status?: number;
+}
+
+/** Flags CLI parsés par parseAutoFlags (--need / --project / --max-steps / --yes / --require). */
+interface AutoFlags {
+  need: string;
+  /** Remarques de l'utilisateur sur le plan proposé (--adjust). */
+  adjust?: string;
+  project: string;
+  maxSteps: number;
+  yes: boolean;
+  /** Réponse de l'utilisateur à une question en pause (`auto resume --answer`). */
+  answer?: string;
+  /** Capacités requises (pré-flight) : "vision,tools,media_generation". */
+  require?: string;
+  /** Tâche à instructions serveur (`auto plan --task audit`) ; ignorée par run/resume/ask. */
+  task?: string;
+}
+
+/** Résolution de session/essai des gates : tier + failure MCP éventuelle. */
+interface SessionResolution {
+  session: LicenseSession | null;
+  tier: "pro" | "trial" | "lite";
+  failure?: McpTextContent[];
+}
+
+/** Dépendances injectées à gateAutoCli (helpers d'index.js chargés paresseusement). */
+interface GateAutoDeps {
+  loadConfig: () => Promise<PlugConfig>;
+  ensureSession: (cfg: PlugConfig) => Promise<LicenseSession>;
+  readProviderConfig: () => { primary: ProviderPrimary | null };
+  resolveTrial: (cfg: PlugConfig) => Promise<SessionResolution>;
+}
+
+/** Résultat du gate Auto CLI : autorisé (cfg/pcfg/tier) ou bloqué (message). */
+type GateAutoResult =
+  | { ok: true; cfg: PlugConfig; pcfg: { primary: ProviderPrimary }; tier: string }
+  | { ok: false; message: string };
+// MODULE_COMPLETE