pipcode 0.0.0-stage → 2.1.0

package/src/auto/step-loop.js

@@ -0,0 +1,56 @@
+// src/auto/step-loop.js — BOUCLE FERMÉE d'une tâche du Mode Auto (jusqu'à MAX_EXEC_TURNS tours, sans repasser par l'utilisateur) :
+//   AGIR (patch généré puis appliqué) → OBSERVER (erreur d'application, sortie de tsc / des tests) → ÉVALUER (vert ? même panne qu'au tour d'avant ?)
+//   → CORRIGER (la sortie réelle est réinjectée dans le prompt du tour suivant) → ARRÊT : tâche validée, ou PAUSE (question à l'utilisateur) /
+//   échec si le blocage ne se résout pas. Le patch d'un tour raté est ANNULÉ avant le suivant : chaque tour repart d'un dépôt propre.
+import { runQaLoop } from "./step-qa.js";
+import { applyTaskDiff, checkpointTask } from "./step-commit.js";
+import { markGreen } from "./step-green.js";
+import { failTask, stopReport } from "./stop-options.js";
+import { askExit } from "./ask-pause.js";
+import { canAsk } from "./ask-user.js";
+import { MAX_EXEC_TURNS } from "./constants.js";
+import { failureSignature, feedbackBlock, headTail } from "./observe.js";
+import { emitProgress } from "../core/progress-emit.js";
+import { cancelExit } from "./cancel.js";
+import { isRunAborted } from "../core/abort-signal.js";
+
+/** Événement de progression d'une tâche (affiché dans le chat) : début, terminée, non terminée. @param {StepCtx} ctx @param {"start" | "done" | "failed"} state */
+const taskEvent = (ctx, state) => emitProgress({ k: "task", state, id: ctx.task.id, title: ctx.task.title, n: ctx.idx + 1, total: ctx.state.tasks.length });
+
+/** Blocage non résolu : question posée à l'utilisateur (PAUSE) si une interface peut répondre, sinon échec classique. @param {StepCtx} ctx @param {string} observed @param {number} turn @returns {Promise<AutoResult>} */
+async function halt(ctx, observed, turn) {
+  const cause = headTail(observed, 300).replace(/\s+/g, " ");
+  if (canAsk(ctx.state)) return askExit(ctx, `La tâche « ${ctx.task.title} » reste bloquée après ${turn} tour(s) de correction automatique : ${cause} Indiquez comment la corriger, ou répondez « passer » pour l'ignorer.`);
+  const exit = await failTask(ctx, cause, turn);
+  taskEvent(ctx, "failed");
+  exit.stop = await stopReport(ctx, `Échec après ${turn} tour(s) de correction automatique : ${cause}`);
+  return exit;
+}
+
+/** @param {StepCtx} ctx @returns {Promise<AutoResult>} */
+export async function runExecLoop(ctx) {
+  let feedback = "";
+  let previous = "";
+  taskEvent(ctx, "start");
+  for (let turn = 1; turn <= MAX_EXEC_TURNS; turn++) {
+    if (isRunAborted()) return cancelExit(ctx); // Stop entre deux tours : PAUSE
+    const qa = await runQaLoop(ctx, feedback); // AGIR : le patch (garde-fous statiques inclus)
+    if (qa.exit) return qa.exit; // question du modèle (pause), panne du fournisseur, garde-fou épuisé
+    const result = /** @type {OrchestratorResult} */ (qa.result);
+    const tried = (qa.attempts ?? 0) + turn - 1; // tentatives déjà échouées (re-attaques des garde-fous + tours de correction)
+    const applied = await applyTaskDiff(ctx, result, tried, true); // AGIR : écriture
+    let observed = applied.error ?? ""; // OBSERVER : erreur d'application
+    if (applied.applied) {
+      const green = await markGreen(ctx, applied.applied, tried, true); // OBSERVER : sortie de tsc / tests
+      if ("exit" in green) return green.exit;
+      if ("green" in green) { taskEvent(ctx, "done"); return checkpointTask(ctx, result, tried, applied.applied); } // ÉVALUER : vert → ARRÊT
+      observed = green.error;
+    }
+    if (isRunAborted()) return cancelExit(ctx); // Stop pendant la vérification : patch déjà annulé, PAUSE (pas de correction à tenter)
+    if (turn === MAX_EXEC_TURNS || (previous !== "" && failureSignature(observed) === previous)) return halt(ctx, observed, turn); // dernier tour, ou même panne : inutile de recommencer
+    previous = failureSignature(observed);
+    feedback = feedbackBlock(turn, observed); // CORRIGER : réinjection dans le prompt du tour suivant
+  }
+  return halt(ctx, "boucle terminée sans résultat", MAX_EXEC_TURNS);
+}
+// MODULE_COMPLETE

package/src/auto/step-prep.js

@@ -0,0 +1,60 @@
+// src/auto/step-prep.js — Préparation d'une étape runAutoStep (porte + lecture + doctrine).
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadAutoState, saveAutoState, progressOf } from "./state.js";
+import { formatQuote } from "./quote-format.js";
+import { missionPathOf } from "./paths.js";
+import { redactError } from "./amnesia.js";
+
+// Charge state + gate consentement + done. Retourne { state } ou { result } (early exit).
+/** @param {string} projectPath @param {boolean} confirmed @returns {Promise<{ state?: AutoState, result?: AutoResult }>} */
+export async function stepGate(projectPath, confirmed) {
+  const state = await loadAutoState(projectPath);
+  if (!state) return { result: { isError: true, text: "Aucun plan Auto trouvé. Établissez d'abord le plan du Mode Auto." } };
+  if (state.status === "consent_pending") {
+    if (!confirmed) return { result: { needsConsent: true, quote: formatQuote(state.tasks, state.budget), status: "consent_pending" } };
+    state.status = "running";
+  }
+  if (state.status === "done") return { result: { done: true, progress: progressOf(state), status: "done" } };
+  return { state };
+}
+
+/** Trouve la prochaine tâche pending à/après cursor. @param {AutoState} state @param {string} projectPath @returns {Promise<{ idx?: number, task?: AutoTask, result?: AutoResult }>} */
+export async function findNextPending(state, projectPath) {
+  let idx = -1;
+  for (let i = state.cursor; i < state.tasks.length; i++) {
+    if (state.tasks[i].status === "pending") { idx = i; break; }
+  }
+  if (idx < 0) {
+    state.status = "done"; state.updatedAt = new Date().toISOString();
+    await saveAutoState(projectPath, state);
+    return { result: { done: true, progress: progressOf(state), status: "done" } };
+  }
+  return { idx, task: state.tasks[idx] };
+}
+
+/** Lit le fichier cible. @param {string} projectPath @param {AutoTask} task @param {AutoState} state @param {number} idx @returns {Promise<{ content?: string, result?: AutoResult }>} */
+export async function readTaskContent(projectPath, task, state, idx) {
+  if (task.isNew) return { content: "" };
+  try { return { content: await fs.readFile(path.join(projectPath, task.file), "utf8") }; }
+  catch (e) {
+    const ee = /** @type {Error} */ (e);
+    task.status = "failed"; task.error = redactError(`fichier introuvable : ${ee.message}`);
+    state.cursor = idx + 1; state.updatedAt = new Date().toISOString();
+    await saveAutoState(projectPath, state);
+    return { result: { failed: true, task, progress: progressOf(state), status: state.status } };
+  }
+}
+
+// Charge mission + doctrine complète (19 fiches). Retourne { mission, missionContext, doctrine } ou { result }.
+/** @param {AutoDeps} deps @param {PlugConfig} cfg @param {string} projectPath @returns {Promise<{ mission?: MissionPlan | null, missionContext?: string, doctrine?: string, result?: AutoResult }>} */
+export async function loadStepMission(deps, cfg, projectPath) {
+  const mission = await deps.readMissionContext(missionPathOf(projectPath));
+  const missionContext = deps.missionContextPrefix(mission);
+  let doctrine = "";
+  try { doctrine = await deps.loadAllDoctrine(cfg); }
+  catch (e) { const ee = /** @type {Error} */ (e); return { result: { isError: true, text: `🛑 Doctrine (19 fiches) indisponible ou signature invalide. ${ee.message}` } }; }
+  return { mission, missionContext, doctrine };
+}
+// MODULE_COMPLETE

package/src/auto/step-qa.js

@@ -0,0 +1,53 @@
+// src/auto/step-qa.js — Boucle de re-attaque QA bornée (MAX_QA_ATTEMPTS=3) de
+// runAutoStep. Alimente le sous-agent via amnésie (doctrine + lastDiff +
+// correction), retry transient orthogonal, checkMissionGuard. À l'épuisement :
+// échec persisté (garde-fou) + cause de boucle (violations N vs N-1) + rapport
+// d'arrêt avec les 2 options de restauration (.pipcode/cache/snapshots).
+
+import { buildAmnesiaContext, buildCorrectionSignal, redactError } from "./amnesia.js";
+import { withTransientRetry } from "./retry.js";
+import { MAX_QA_ATTEMPTS } from "./constants.js";
+import { failTask, stopReport, loopCause } from "./stop-options.js";
+import { answersBlock, canAsk } from "./ask-user.js";
+import { askExit } from "./ask-pause.js";
+import { cancelExit } from "./cancel.js";
+import { isRunAborted } from "../core/abort-signal.js";
+
+// Boucle QA : re-attaque bornée tant que le guard bloque. Retry transient orthogonal.
+/** @param {StepCtx} ctx @param {string} [feedback] sortie réelle du tour précédent (boucle auto-corrective) @returns {Promise<{ result?: OrchestratorResult, attempts?: number, lastGuard?: GuardResult | null, exit?: AutoResult }>} */
+export async function runQaLoop(ctx, feedback = "") {
+  const { deps, state, doctrine, missionContext, mission, task, fileContent, pcfg } = ctx;
+  let attempts = 0;
+  let lastGuard = null;
+  let prevGuard = null; // garde-fou : comparaison violations N vs N-1 (cause de boucle)
+  let result = /** @type {OrchestratorResult} */ (/** @type {unknown} */ (null));
+  while (attempts < MAX_QA_ATTEMPTS) {
+    const amn = buildAmnesiaContext(state, doctrine, missionContext + answersBlock(state)); // + réponses déjà données à ses questions
+    const correction = [feedback, lastGuard ? buildCorrectionSignal(lastGuard.violations) : ""].filter(Boolean).join("\n\n");
+    try {
+      result = await withTransientRetry(() => deps.orchestrateLLM(
+        { code: fileContent, file_path: task.file, missionContext: amn.missionContext, doctrine: amn.doctrine, lastDiff: amn.lastDiff, correction, canAsk: canAsk(state) },
+        pcfg
+      ), `task:${task.id}`);
+    } catch (e) {
+      if (isRunAborted()) return { exit: await cancelExit(ctx) }; // Stop : PAUSE, pas une panne
+      const ee = /** @type {Error} */ (e);
+      state.status = "failed"; // comportement historique : panne provider → run failed
+      const exit = await failTask(ctx, redactError(ee.message), attempts);
+      exit.stop = await stopReport(ctx, `Le sous-agent LLM a échoué (${redactError(ee.message)}).`);
+      return { exit };
+    }
+    if (result.asking) return { exit: await askExit(ctx, result.asking) }; // question : PAUSE (tâche en attente), ni garde-fou ni échec
+    const guard = deps.checkMissionGuard(result, mission);
+    if (!guard.blocked) break;
+    prevGuard = lastGuard; lastGuard = guard; attempts++;
+  }
+  if (attempts >= MAX_QA_ATTEMPTS && lastGuard && lastGuard.blocked) {
+    const exit = await failTask(ctx, lastGuard.message || "", attempts);
+    exit.violations = lastGuard.violations;
+    exit.stop = await stopReport(ctx, loopCause(prevGuard ? prevGuard.violations : null, lastGuard.violations));
+    return { exit };
+  }
+  return { result, attempts, lastGuard };
+}
+// MODULE_COMPLETE

package/src/auto/step.js

@@ -0,0 +1,30 @@
+// src/auto/step.js — Pilier 2 : runAutoStep (avance UNE tâche, orchestrateur).
+// step-prep (porte+lecture+doctrine) → snapshot state_pre_gen (garde-fou) →
+// step-loop (boucle fermée : patch, apply, gates, correction par la sortie réelle ≤ 3 tours) →
+// checkpoint. deps injecté (closure).
+
+import { stepGate, findNextPending, readTaskContent, loadStepMission } from "./step-prep.js";
+import { runExecLoop } from "./step-loop.js";
+import { takeSnapshot } from "./snapshot-take.js";
+import { SNAP_PRE } from "./snapshot-paths.js";
+import { missionPathOf } from "./paths.js";
+
+// Avance d'UNE tâche : porte → prochaine tâche → lecture → doctrine → QA → apply → checkpoint.
+/** @param {AutoStepArgs} arg @param {AutoDeps} deps @returns {Promise<AutoResult>} */
+export async function runAutoStep({ projectPath, confirmed, pcfg, cfg }, deps) {
+  const gated = await stepGate(projectPath, !!confirmed);
+  if (gated.result) return gated.result;
+  const state = /** @type {AutoState} */ (gated.state);
+  const found = await findNextPending(state, projectPath);
+  if (found.result) return found.result;
+  const idx = /** @type {number} */ (found.idx);
+  const task = /** @type {AutoTask} */ (found.task);
+  const read = await readTaskContent(projectPath, task, state, idx);
+  if (read.result) return read.result;
+  const loaded = await loadStepMission(deps, cfg, projectPath);
+  if (loaded.result) return loaded.result;
+  /** @type {StepCtx} */ const ctx = { deps, state, doctrine: /** @type {string} */ (loaded.doctrine), missionContext: /** @type {string} */ (loaded.missionContext), mission: /** @type {MissionPlan} */ (loaded.mission), task, fileContent: /** @type {string} */ (read.content), pcfg, idx, projectPath, missionPath: missionPathOf(projectPath) };
+  await takeSnapshot(projectPath, SNAP_PRE); // garde-fou : état AVANT génération (fail-safe)
+  return runExecLoop(ctx); // boucle fermée : agir → observer → évaluer → corriger (≤ 3 tours) → arrêt ou pause
+}
+// MODULE_COMPLETE

package/src/auto/stop-options.js

@@ -0,0 +1,34 @@
+// src/auto/stop-options.js — Garde-fou d'arrêt : échec de tâche persisté (compteur
+// d'échecs consécutifs, cap run-loop) + cause de boucle (violations identiques
+// N vs N-1). Le rapport d'arrêt 2 options vit dans stop-report.js (SRP).
+
+import { saveAutoState, progressOf } from "./state.js";
+import { redactError } from "./amnesia.js";
+
+// Le rapport d'arrêt 2 options vit dans stop-report.js (SRP) ; re-exporté ici
+// pour un point d'entrée unique du garde-fou.
+export { stopReport } from "./stop-report.js";
+
+// Cause de boucle : les violations sont-elles identiques à la tentative précédente ?
+/** @param {GuardViolation[] | null | undefined} prev @param {GuardViolation[] | null | undefined} cur @returns {string} */
+export function loopCause(prev, cur) {
+  /** @type {(v: GuardViolation[] | null | undefined) => string} */
+  const key = (v) => (Array.isArray(v) ? v.map((x) => String((x && (x.rule || x.kind)) || "")).sort().join(",") : "");
+  if (key(prev) && key(prev) === key(cur)) {
+    return `Boucle détectée : les mêmes violations reviennent à chaque re-attaque (${key(cur)}). Le modèle ignore le signal de correction — arrêt immédiat pour éviter une boucle infinie.`;
+  }
+  return "Échec après 3 re-attaques (violations persistantes malgré le signal de correction).";
+}
+
+// Marque la tâche failed, incrémente le compteur d'échecs consécutifs, persiste.
+/** @param {StepCtx} ctx @param {string} errText @param {number} attempts @returns {Promise<AutoResult>} */
+export async function failTask(ctx, errText, attempts) {
+  const { state, task, idx, projectPath } = ctx;
+  task.status = "failed"; task.attempts = attempts; task.error = redactError(errText);
+  state.cursor = idx + 1;
+  state.failureStreak = (state.failureStreak || 0) + 1;
+  state.updatedAt = new Date().toISOString();
+  await saveAutoState(projectPath, state);
+  return { failed: true, task, error: task.error || "", progress: progressOf(state), status: state.status };
+}
+// MODULE_COMPLETE

package/src/auto/stop-report.js

@@ -0,0 +1,17 @@
+// src/auto/stop-report.js — Rapport d'arrêt du garde-fou : cause + progression conservée + où retrouver les originaux (dossier de sauvegarde de l'exécution, s'il est fourni
+// par l'extension) + indice de délégation multi-agent (si l'agent hôte en a la capacité, c'est lui qui déploie).
+
+import path from "node:path";
+import { progressOf } from "./state.js";
+import { multiAgentHint } from "../mcp/client-info.js";
+
+// Rapport d'arrêt : aucune restauration automatique, l'état est préservé ; les originaux des fichiers modifiés restent dans la sauvegarde.
+/** @param {{ projectPath: string, state: AutoState }} ctx @param {string} cause @returns {Promise<string>} */
+export async function stopReport(ctx, cause) {
+  const saves = process.env.PLUGCTO_BACKUP_DIR;
+  const hint = multiAgentHint();
+  return `STOP — ${cause}\nProgression conservée : ${progressOf(ctx.state)}. Aucun retour en arrière automatique : l'état est préservé.` +
+    (saves && path.isAbsolute(saves) ? `\nOriginaux des fichiers modifiés : ${saves}` : "") +
+    (hint ? `\n\n${hint}` : "");
+}
+// MODULE_COMPLETE

package/src/auto/tasks.js

@@ -0,0 +1,44 @@
+// src/auto/tasks.js — Décomposition : normalisation des micro-tâches + collecte tailles.
+// normalizeTasks : valide les champs, rejette paths absolus/.., cap 40, isNew.
+// collectFileSizes : { [file]: bytes } pour le devis (0 pour les nouveaux fichiers).
+
+import fs from "node:fs/promises";
+import path from "node:path";
+
+// Normalise la sortie LLM en AutoTask[] : valide champs, anti path traversal, cap 40.
+/** @param {({ tasks?: Record<string, unknown>[] } | Record<string, unknown>[])} parsed @param {string[]} repoFiles @returns {AutoTask[]} */
+export function normalizeTasks(parsed, repoFiles) {
+  let arr = parsed;
+  if (arr && typeof arr === "object" && !Array.isArray(arr) && Array.isArray(arr.tasks)) arr = arr.tasks;
+  if (!Array.isArray(arr)) throw new Error("Décomposition : le LLM n'a pas retourné un tableau de tâches.");
+  const repo = new Set(repoFiles);
+  /** @type {AutoTask[]} */ const out = [];
+  let n = 0;
+  for (const raw of arr) {
+    if (!raw || typeof raw !== "object") continue;
+    n += 1;
+    const id = String(raw.id || `t${String(n).padStart(2, "0")}`);
+    const file = String(raw.file || "").trim();
+    const title = String(raw.title || "").trim();
+    const objective = String(raw.objective || "").trim();
+    const acceptance = String(raw.acceptance || "").trim();
+    if (!file || !title || !objective || !acceptance) continue; // tâche incomplète → écartée
+    if (path.isAbsolute(file) || file.includes("..")) continue; // anti path traversal hors projet
+    out.push({ id, title, file, objective, acceptance, status: "pending", attempts: 0, commit: null, error: null, isNew: !repo.has(file) });
+  }
+  if (out.length === 0) throw new Error("Décomposition : aucune micro-tâche valide produite.");
+  return out.slice(0, 40); // cap doctrine (prompt max 40).
+}
+
+// Collecte les tailles de fichiers (bytes) pour le devis. 0 pour les nouveaux fichiers.
+/** @param {string} projectPath @param {AutoTask[]} tasks @returns {Promise<Record<string, number>>} */
+export async function collectFileSizes(projectPath, tasks) {
+  /** @type {Record<string, number>} */ const sizes = {};
+  for (const t of tasks) {
+    if (t.isNew) { sizes[t.file] = 0; continue; }
+    try { const st = await fs.stat(path.join(projectPath, t.file)); sizes[t.file] = st.size; }
+    catch { sizes[t.file] = 0; }
+  }
+  return sizes;
+}
+// MODULE_COMPLETE

package/src/cli/apply-loop.js

@@ -0,0 +1,29 @@
+// src/cli/apply-loop.js — Boucle d'application du setup sur chaque cible IDE.
+// applySetup par cible, log ✓/✗, collecte des résultats (succès ou erreur).
+// Une erreur sur une cible n'interrompt pas les autres (best-effort).
+
+import { applySetup } from "./apply.js";
+
+/** @typedef {{ licenseKey: string, email: string }} CollectedConfig */
+/** @typedef {{ id: string, name: string, path: string, parentExists: boolean, configExists: boolean, schema?: "mcpServers" | "servers" | "context_servers" | "toml" }} IdeConfigEntry */
+/** @typedef {{ path: string, created?: boolean, wrote?: boolean, error?: string }} ApplyResult */
+
+// Applique le setup à chaque cible ; retourne le tableau des résultats (succès/erreur).
+/** @param {IdeConfigEntry[]} targets @param {CollectedConfig} collected @param {string} indexAbsPath @returns {Promise<ApplyResult[]>} */
+export async function applyToTargets(targets, collected, indexAbsPath) {
+  console.log("");
+  /** @type {ApplyResult[]} */ const results = [];
+  for (const t of targets) {
+    try {
+      const r = await applySetup(t.path, collected, indexAbsPath, t.schema || "mcpServers");
+      results.push(r);
+      console.log(`  ✓ ${t.name.padEnd(16)} → ${r.path} ${r.created ? "(créé)" : "(mis à jour)"}`);
+    } catch (err) {
+      const e = /** @type {Error} */ (err);
+      console.error(`  ✗ ${t.name.padEnd(16)} → ÉCHEC : ${e.message}`);
+      results.push({ path: t.path, error: e.message });
+    }
+  }
+  return results;
+}
+// MODULE_COMPLETE

package/src/cli/apply-toml.js

@@ -0,0 +1,26 @@
+// src/cli/apply-toml.js — Application du setup au config.toml de Codex (partagé
+// avec l'app ChatGPT desktop et l'extension IDE de Codex). Lecture → fusion
+// prudente de NOS tables seulement (toml-merge) → sauvegarde unique du fichier
+// d'origine → écriture atomique. Retourne { path, created, wrote }.
+
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import { buildServerEntry, SERVER_KEY } from "./server-entry.js";
+import { mergeToml, removeToml } from "./toml-merge.js";
+import { LEGACY_SERVER_KEYS } from "./legacy-entry.js";
+import { toEnvVars } from "../engine/collect.js";
+import { writeTextAtomic } from "../fs/atomic-text.js";
+import { backupOnce } from "../fs/backup-once.js";
+
+/** @typedef {{ licenseKey: string, email: string }} CollectedConfig */
+
+/** @param {string} filePath @param {CollectedConfig} collected @param {string} indexAbsPath @returns {Promise<{ path: string, created: boolean, wrote: boolean }>} */
+export async function applyTomlSetup(filePath, collected, indexAbsPath) {
+  const existed = existsSync(filePath);
+  const text = existed ? await fs.readFile(filePath, "utf8") : "";
+  const next = mergeToml(LEGACY_SERVER_KEYS.reduce((t, k) => removeToml(t, k).text, text), SERVER_KEY, buildServerEntry(indexAbsPath, toEnvVars(collected)));
+  await backupOnce(filePath);
+  await writeTextAtomic(filePath, next);
+  return { path: filePath, created: !existed, wrote: true };
+}
+// MODULE_COMPLETE

package/src/cli/apply.js

@@ -0,0 +1,45 @@
+// src/cli/apply.js — Application de la config collectée à un fichier IDE.
+// Lit → sauvegarde unique de l'original → merge idempotent → écriture atomique.
+// Retourne { path, created, wrote }. `schema` sélectionne la clé racine + la forme
+// de l'entrée (cf. mergeConfig) ; "toml" = config.toml de Codex (apply-toml.js).
+
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { loadConfig } from "../fs/load-config.js";
+import { writeConfigAtomic } from "../fs/atomic-write.js";
+import { backupOnce } from "../fs/backup-once.js";
+import { applyTomlSetup } from "./apply-toml.js";
+import { buildServerEntry, mergeConfig, SERVER_KEY } from "./server-entry.js";
+import { toEnvVars } from "../engine/collect.js";
+
+/** @typedef {{ licenseKey: string, email: string }} CollectedConfig */
+/** @typedef {{ path: string, created: boolean, wrote: boolean }} ApplySetupResult */
+/** @typedef {"mcpServers" | "servers" | "context_servers" | "toml"} IdeSchema */
+
+// Chemin absolu vers index.js (racine projet, à côté de bin/ et src/).
+const INDEX_JS = path.resolve(import.meta.dirname, "..", "..", "index.js");
+
+// Zed : settings.json contient presque toujours des commentaires — les réécrire en
+// JSON les détruirait. On refuse (jamais d'écrasement) et on guide l'utilisateur.
+const ZED_HINT = " Zed : ce fichier contient des commentaires, PipCode ne le réécrit pas pour ne pas les perdre. Ajoutez le serveur dans Zed (Paramètres → IA → Serveurs MCP).";
+
+/**
+ * @param {string} filePath
+ * @param {CollectedConfig} collected
+ * @param {string} [indexAbsPath]
+ * @param {IdeSchema} [schema]
+ * @returns {Promise<ApplySetupResult>}
+ */
+export async function applySetup(filePath, collected, indexAbsPath = INDEX_JS, schema = "mcpServers") {
+  if (schema === "toml") return applyTomlSetup(filePath, collected, indexAbsPath);
+  const existed = existsSync(filePath);
+  const config = await loadConfig(filePath).catch((err) => {
+    throw new Error(err.message + (schema === "context_servers" ? ZED_HINT : ""));
+  });
+  const entry = buildServerEntry(indexAbsPath, toEnvVars(collected));
+  const next = mergeConfig(config, entry, SERVER_KEY, schema);
+  await backupOnce(filePath);
+  await writeConfigAtomic(filePath, next);
+  return { path: filePath, created: !existed, wrote: true };
+}
+// MODULE_COMPLETE

package/src/cli/ask-prepare.js

@@ -0,0 +1,37 @@
+// src/cli/ask-prepare.js — Préparation d'un message du chat : règles du serveur ET lecture locale du projet EN PARALLÈLE (avant : l'une après l'autre), puis fiches métier du sujet.
+// Chaque étape est annoncée à l'interface (événement « stage ») : l'utilisateur voit tout de suite ce qui se passe. Aucune règle de contenu ici : assemblage seulement.
+import { ensureRules } from "../rules/rules-load.js";
+import { emitProgress } from "../core/progress-emit.js";
+import { buildProjectContext } from "../engine/project-context.js";
+import { parseOpenFiles } from "../engine/context-files.js";
+import { indexProject } from "../project-memory/memory-build.js";
+import { pendingBlock } from "../project-memory/qa-apply.js";
+import { projectInstructions } from "../engine/project-instructions.js";
+import { chatDoctrine } from "../engine/chat-doctrine.js";
+import { missionLine } from "../auto/mission-line.js";
+import { contextChars } from "../project-memory/window.js";
+import { isOllamaBase, ollamaPromptChars } from "../core/ollama.js";
+
+/** Lecture locale du projet : carte mise à jour, contexte, consignes (CLAUDE.md + mission en cours), questions en attente. @param {string} project @param {string} need @param {number} W @returns {Promise<{ ctx: string, instructions: string, pending: string }>} */
+async function readProject(project, need, W) {
+  await indexProject(project).catch((e) => console.error(`ℹ Carte du projet non mise à jour : ${e.message}`)); // mémoire alimentée à chaque message
+  const ctx = await buildProjectContext(project, parseOpenFiles(process.env.PLUGCTO_ASK_FILES), need, W);
+  const instructions = [await projectInstructions(project, W * 0.2), await missionLine(project)].filter(Boolean).join("\n\n");
+  return { ctx, instructions, pending: await pendingBlock(project) };
+}
+
+/** @param {AutoGateOk} g @param {AutoFlags} flags @returns {Promise<{ local: boolean, projectCtx: string, instructions: string, doctrine: string }>} */
+export async function prepareAsk(g, flags) {
+  const project = flags.project.trim();
+  const local = isOllamaBase(g.pcfg.primary.base); // Ollama : prompt réduit au strict utile
+  emitProgress({ k: "stage", s: "rules" });
+  // Règles du serveur (tous les comptes) : si le serveur est injoignable, le chat répond quand même et le signale sur stderr.
+  const rules = ensureRules(g.cfg).catch(() => console.error("ℹ Principes de réalisation indisponibles (serveur PipCode injoignable) : réponse sans eux."));
+  emitProgress({ k: "stage", s: "project" });
+  const [p] = await Promise.all([project ? readProject(project, flags.need, local ? ollamaPromptChars() : contextChars()) : { ctx: "", instructions: "", pending: "" }, rules]);
+  emitProgress({ k: "stage", s: "sheets" });
+  const doctrine = local ? "" : await chatDoctrine(flags.need, g.cfg);
+  emitProgress({ k: "stage", s: "model" });
+  return { local, projectCtx: [p.ctx, p.pending].filter(Boolean).join("\n\n"), instructions: p.instructions, doctrine };
+}
+// MODULE_COMPLETE

package/src/cli/auth-branches.js

@@ -0,0 +1,53 @@
+// src/cli/auth-branches.js — Branches d'authentification du flux interactif.
+// Trois voies : navigateur (callback local), email (lookup Worker puis saisie
+// manuelle de la clé Polar), essai (confirmation avant écrasement d'une licence
+// Pro existante — U1). Chaque branche retourne { licenseKey, email }.
+
+import { AUTH_CALLBACK_PORT } from "../net/auth-endpoints.js";
+
+/** @typedef {{ ask: (q: string) => Promise<string>, askDefault: (q: string, def: string | undefined) => Promise<string>, askRequired: (q: string) => Promise<string> }} Prompts */
+/** @typedef {{ licenseKey: string, email: string }} AuthResult */
+/** @typedef {{ key: string, email: string, source: "browser", error?: string }} AuthBrowserResult */
+/** @typedef {{ found: boolean, tier: string | null, email: string, source: "email", error?: string }} AuthEmailResult */
+
+/** @param {Prompts} _p @param {() => Promise<AuthBrowserResult>} browser @param {string} existingLicense @param {string} existingEmail @returns {Promise<AuthResult>} */
+export async function authBrowserBranch(_p, browser, existingLicense, existingEmail) {
+  console.log("  🌐 Ouverture du navigateur… (en attente du callback sur 127.0.0.1:" + AUTH_CALLBACK_PORT + ")");
+  const r = await browser();
+  if (r && r.key) return { licenseKey: r.key, email: r.email || "" };
+  // U1 : auth navigateur échouée — on conserve une licence Pro existante.
+  if (existingLicense) {
+    console.error("  ⚠️  Auth navigateur échouée (" + (r && r.error) + "). Conservation de votre licence existante.");
+    return { licenseKey: existingLicense, email: existingEmail };
+  }
+  console.error("  ⚠️  Auth navigateur échouée (" + (r && r.error) + "). Bascule en essai 5 jours.");
+  return { licenseKey: "", email: "" };
+}
+
+/** @param {Prompts} p @param {(email: string) => Promise<AuthEmailResult>} emailLookup @returns {Promise<AuthResult>} */
+export async function authEmailBranch(p, emailLookup) {
+  const email = await p.askRequired("  Entrez votre email : ");
+  const r = await emailLookup(email);
+  if (r && r.found) {
+    console.log("  ✅ Licence " + (r.tier ? r.tier.toUpperCase() : "") + " trouvée pour " + email + ".");
+    console.log("    Saisissez la clé de licence reçue par email (Polar.sh).");
+    const licenseKey = await p.askRequired("  Clé de licence : ");
+    return { licenseKey, email };
+  }
+  console.error("  ⚠️  Aucune licence trouvée pour cet email (" + (r && r.error) + "). Vous pouvez saisir une clé manuellement ou passer en essai.");
+  return { licenseKey: "", email };
+}
+
+// Essai [4] : confirmation explicite avant écrasement d'une licence Pro (U1).
+/** @param {Prompts} p @param {string} existingLicense @param {string} existingEmail @returns {Promise<AuthResult>} */
+export async function authTrialBranch(p, existingLicense, existingEmail) {
+  if (!existingLicense) return { licenseKey: "", email: "" };
+  console.log("  ⚠️  Vous avez une licence Pro existante. Le mode Essai (sans licence) l'écrasera.");
+  const confirm = await p.askDefault("  Confirmer le remplacement par un essai sans licence ? (o/N) : ", "N");
+  if (!/^(o|oui|y|yes)$/i.test(confirm)) {
+    console.log("  ✅ Licence existante conservée.");
+    return { licenseKey: existingLicense, email: existingEmail };
+  }
+  return { licenseKey: "", email: "" };
+}
+// MODULE_COMPLETE

package/src/cli/auth-interactive.js

@@ -0,0 +1,46 @@
+// src/cli/auth-interactive.js — Étape 1 du flux interactif : authentification.
+// Affiche le menu [1-4] (Navigateur / Email / Clé manuelle / Essai) et dispatche
+// vers la branche correspondante. Détecte une licence Pro existante (U1) pour
+// empêcher son écrasement accidentel.
+
+import { authBrowserBranch, authEmailBranch, authTrialBranch } from "./auth-branches.js";
+
+/** @typedef {{ ask: (q: string) => Promise<string>, askDefault: (q: string, def: string | undefined) => Promise<string>, askRequired: (q: string) => Promise<string> }} Prompts */
+/** @typedef {{ licenseKey: string, email: string }} AuthResult */
+/** @typedef {{ installedAt?: string, clientId?: string, licenseKey?: string, email?: string, trialExpiredNotified?: boolean }} SharedConfig */
+/** @typedef {{ key: string, email: string, source: "browser", error?: string }} AuthBrowserResult */
+/** @typedef {{ found: boolean, tier: string | null, email: string, source: "email", error?: string }} AuthEmailResult */
+/** @typedef {{ browser?: () => Promise<AuthBrowserResult>, emailLookup?: (email: string) => Promise<AuthEmailResult>, existingConfig?: SharedConfig }} CollectAuthOpts */
+
+// Extrait licence + email existants (U1 : anti-écrasement de licence Pro).
+/** @param {SharedConfig | undefined} existingConfig @returns {{ existingLicense: string, existingEmail: string }} */
+export function existingLicenseInfo(existingConfig) {
+  const existingLicense = (existingConfig && existingConfig.licenseKey) ? String(existingConfig.licenseKey) : "";
+  const existingEmail = (existingConfig && existingConfig.email) ? String(existingConfig.email) : "";
+  return { existingLicense, existingEmail };
+}
+
+/**
+ * @param {Prompts} p
+ * @param {CollectAuthOpts} opts
+ * @returns {Promise<AuthResult>}
+ */
+export async function collectAuth(p, { browser, emailLookup, existingConfig }) {
+  const { existingLicense, existingEmail } = existingLicenseInfo(existingConfig);
+  console.log("\n🔑 Configuration PipCode — auto-correction en direct (BYOK)\n");
+  if (existingLicense) {
+    console.log("  🔑 Licence existante détectée dans ~/.pipcode/config.json" + (existingEmail ? " (" + existingEmail + ")" : "") + ".");
+    console.log("    Elle sera conservée sauf si vous choisissez explicitement de la remplacer.\n");
+  }
+  console.log("  Authentification PipCode :");
+  console.log("    [1] Navigateur (connexion via navigateur)  ← défaut (Entrée)");
+  console.log("    [2] Email (recherche de licence par email)");
+  console.log("    [3] Clé de licence Polar.sh (saisie manuelle)");
+  console.log("    [4] Essai 5 jours (sans licence)");
+  const authChoice = await p.askDefault("  Choix [1-4] (Entrée = 1) : ", "1");
+  if (authChoice === "1") return authBrowserBranch(p, /** @type {() => Promise<AuthBrowserResult>} */ (browser), existingLicense, existingEmail);
+  if (authChoice === "2") return authEmailBranch(p, /** @type {(email: string) => Promise<AuthEmailResult>} */ (emailLookup));
+  if (authChoice === "3") return { licenseKey: await p.ask("  Entrez votre clé de licence Polar.sh : "), email: "" };
+  return authTrialBranch(p, existingLicense, existingEmail);
+}
+// MODULE_COMPLETE

package/src/cli/auto-ask.js

@@ -0,0 +1,33 @@
+// src/cli/auto-ask.js — Handler `auto ask` : conversation pure (ChatView v2).
+// Répond par UN appel LLM BYOK — aucun plan, aucun état, aucun fichier de code écrit (seule la mémoire du projet,
+// sous .pipcode/memoire, est alimentée). Gate héritée du dispatcher auto-cli.js : gratuit à vie (Lite inclus, zéro fiche
+// injectée sauf les règles de frugalité servies par le serveur), BYOK exigé.
+
+import { askLLM } from "../engine/ask-llm.js";
+import { formatAskHistory } from "../engine/ask-history.js";
+import { applyQa, stripTags } from "../project-memory/qa-apply.js";
+import { splitThinking, stepsBlock } from "../engine/steps-block.js";
+import { keepRecentLines } from "../core/ollama.js";
+import { prepareAsk } from "./ask-prepare.js";
+
+// Handler `auto ask --need "<question>" --project <chemin>`.
+/** @param {AutoGateOk} g @param {AutoFlags} flags @returns {Promise<void>} */
+export async function handleAutoAsk(g, flags) {
+  if (!flags.need.trim()) {
+    console.error('✗ --need "<question>" requis pour `auto ask`.');
+    process.exit(2);
+  }
+  const project = flags.project.trim();
+  try {
+    const { local, projectCtx, instructions, doctrine } = await prepareAsk(g, flags);
+    const raw = await askLLM({ primary: g.pcfg.primary }, flags.need, "", ((h) => (local ? keepRecentLines(h, 3000) : h))(formatAskHistory(process.env.PLUGCTO_ASK_HISTORY)), projectCtx, instructions, doctrine);
+    const { thinking, answer } = splitThinking(raw); // raisonnement du modèle : bloc repliable, jamais mêlé à la réponse ni aux balises
+    const shown = project ? await applyQa(project, flags.need, answer).catch((e) => { console.error(`ℹ Décisions non enregistrées : ${e.message}`); return stripTags(answer); }) : stripTags(answer);
+    console.log("\n" + shown + "\n");
+  } catch (err) {
+    const e = /** @type {NodeErr} */ (err);
+    console.error("\n  ✗ Conversation échouée :", e.message);
+    process.exit(1);
+  }
+}
+// MODULE_COMPLETE

package/src/cli/auto-audit.js

@@ -0,0 +1,16 @@
+// src/cli/auto-audit.js — Handler `auto audit` : rapport de diagnostic en lecture seule (aucun plan, aucun auto-state.json, aucune écriture).
+// Protocole serveur indisponible → code 5 sans appel modèle. Pas de process.exit après du réseau (crash Windows) : exitCode positionné.
+import { runAudit } from "../engine/audit-report.js";
+import { splitThinking } from "../engine/steps-block.js";
+
+/** @param {AutoGateOk} g @param {string} projectPath @returns {Promise<void>} */
+export async function handleAutoAudit(g, projectPath) {
+  try {
+    const { answer } = splitThinking(await runAudit({ primary: g.pcfg.primary }, g.cfg, projectPath));
+    console.log("\n" + answer.trim() + "\n");
+  } catch (err) {
+    console.error("\n  ✗ Audit échoué :", /** @type {Error} */ (err).message);
+    process.exitCode = /protocole|serveur|Audit approfondi|essai/i.test(/** @type {Error} */ (err).message) ? 5 : 1;
+  }
+}
+// MODULE_COMPLETE