theforge-cli 0.2.4 → 0.2.6

package/dist/index.js

@@ -2664,6 +2664,19 @@ var FORGE_REPOS = [
     kind: "node",
     verify: ["npx", "--no-install", "ng", "version"],
     nextSteps: ["npm start"]
+  },
+  {
+    // lf-0031 (gap G7): o repositório existe e é clonável, mas ainda não tem
+    // rota de instalação — sem setup.sh/forge_bootstrap.py na fonte e sem
+    // dist no PyPI (verificado). Sem `nativeInstall`: o fluxo git reporta
+    // `noSetupSteps` honestamente; o registry recusa com "sem dist no
+    // catálogo". Nenhum caminho finge uma instalação que não existe.
+    name: "data-sentinel-forge",
+    url: "https://github.com/EdgarSocrates98/data-sentinel-forge",
+    description: "Diagn\xF3stico de runtime (logs/plans Spark, doctor-bundles)",
+    kind: "python",
+    verify: ["data-sentinel", "--help"],
+    nextSteps: ["data-sentinel --help"]
   }
 ];
 
@@ -10787,6 +10800,9 @@ var S = {
   recoveredRun: "Execu\xE7\xE3o anterior interrompida recuperada do estado persistido",
   breakingTitle: "An\xE1lise de breaking changes",
   rollbackScopeNote: "Rollback cobre apenas efeitos revers\xEDveis documentados",
+  integrationsTitle: "Integra\xE7\xF5es opcionais",
+  integrationsOffer: "Integra\xE7\xF5es opcionais \u2014 marque para instalar (nada entra sem sua sele\xE7\xE3o)",
+  integrationNoInstallRoute: "sem dist no cat\xE1logo registry \u2014 instale via git (`--method git`) ou pelo m\xE9todo do reposit\xF3rio",
   usage: `forge-cli \u2014 instalador do ecossistema Forge
 
 Uso:
@@ -15272,6 +15288,8 @@ async function checkEnvironment() {
   return env;
 }
 function emitJson(data, exitCode = 0) {
+  const handle = process.stdout._handle;
+  handle?.setBlocking?.(true);
   process.stdout.write(`${JSON.stringify(data, null, 2)}
 `);
   process.exit(exitCode);
@@ -19705,7 +19723,7 @@ function errMsg(error) {
 }
 
 // src/doctor2/domains.ts
-import { existsSync as existsSync24, readdirSync as readdirSync11, rmSync as rmSync6, statSync as statSync4, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync11, rmSync as rmSync6, statSync as statSync4, writeFileSync as writeFileSync6 } from "fs";
 import os4 from "os";
 import path34 from "path";
 
@@ -20186,6 +20204,303 @@ function analyzeBumps(current, candidates) {
   }).sort((a3, b) => a3.to.localeCompare(b.to, void 0, { numeric: true }));
 }
 
+// src/integrations.ts
+import { existsSync as existsSync24 } from "fs";
+var OPTIONAL_INTEGRATIONS = {
+  "the-forge": [
+    {
+      name: "spark-forge-aws",
+      reason: "an\xE1lise est\xE1tica/runtime PySpark \u2014 delegate do orquestrador",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "spark-forge-azure",
+      reason: "an\xE1lise PySpark em Azure \u2014 delegate do orquestrador",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "api-forge",
+      reason: "constru\xE7\xE3o/contratos de API \u2014 delegate do orquestrador",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "platform-forge",
+      reason: "postura de plataforma \u2014 delegate do orquestrador",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "forge-doctor-data",
+      reason: "verifica\xE7\xE3o independente de dados \u2014 delegate do orquestrador",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "forge-doctor-api",
+      reason: "verifica\xE7\xE3o independente de API \u2014 delegate do orquestrador",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "data-sentinel-forge",
+      reason: "diagn\xF3stico de runtime (logs/plans) \u2014 sem adapter the-forge e sem rota de install: gap documentado, nunca obrigat\xF3rio",
+      adapter: false,
+      installable: false
+    }
+  ],
+  "spark-forge-aws": [
+    {
+      name: "forge-doctor-data",
+      reason: "verificador independente das an\xE1lises produzidas",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "platform-forge",
+      reason: "estado da plataforma onde o job roda",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "spark-forge-azure",
+      reason: "fallback declarado (mesma fam\xEDlia spark)",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "api-forge",
+      reason: "contratos de API adjacentes ao pipeline",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "data-sentinel-forge",
+      reason: "diagn\xF3stico de runtime \u2014 sem adapter e sem rota de install: gap documentado, nunca obrigat\xF3rio",
+      adapter: false,
+      installable: false
+    }
+  ],
+  "spark-forge-azure": [
+    {
+      name: "forge-doctor-data",
+      reason: "verificador independente das an\xE1lises produzidas",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "platform-forge",
+      reason: "estado da plataforma onde o job roda",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "spark-forge-aws",
+      reason: "fallback declarado (mesma fam\xEDlia spark)",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "data-sentinel-forge",
+      reason: "diagn\xF3stico de runtime \u2014 sem adapter e sem rota de install: gap documentado, nunca obrigat\xF3rio",
+      adapter: false,
+      installable: false
+    }
+  ],
+  "api-forge": [
+    {
+      name: "forge-doctor-api",
+      reason: "verificador independente (producer\u2260verifier)",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "platform-forge",
+      reason: "governan\xE7a/estado da plataforma consumidora",
+      adapter: true,
+      installable: true
+    }
+  ],
+  "platform-forge": [
+    {
+      name: "api-forge",
+      reason: "comp\xF5e governan\xE7a de APIs da plataforma",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "forge-doctor-data",
+      reason: "verificador independente declarado",
+      adapter: true,
+      installable: true
+    }
+  ],
+  "forge-doctor-api": [
+    {
+      name: "api-forge",
+      reason: "produtor dos artefatos que ele verifica",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "forge-doctor-data",
+      reason: "fallback declarado entre verificadores",
+      adapter: true,
+      installable: true
+    }
+  ],
+  "forge-doctor-data": [
+    {
+      name: "spark-forge-aws",
+      reason: "produtor das an\xE1lises que ele verifica",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "spark-forge-azure",
+      reason: "produtor das an\xE1lises que ele verifica",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "platform-forge",
+      reason: "estado da plataforma verificada",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "forge-doctor-api",
+      reason: "fallback declarado entre verificadores",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "data-sentinel-forge",
+      reason: "importa doctor-bundles para diagn\xF3stico de runtime \u2014 sem adapter e sem rota de install: gap documentado",
+      adapter: false,
+      installable: false
+    }
+  ],
+  "forge-portal": [
+    {
+      name: "the-forge",
+      reason: "control plane que o portal renderiza",
+      adapter: true,
+      installable: true
+    }
+  ],
+  "data-sentinel-forge": [
+    {
+      name: "forge-doctor-data",
+      reason: "consome doctor-bundles para diagn\xF3stico independente",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "spark-forge-aws",
+      reason: "fonte de evid\xEAncia Spark para diagn\xF3stico",
+      adapter: true,
+      installable: true
+    },
+    {
+      name: "spark-forge-azure",
+      reason: "fonte de evid\xEAncia Spark para diagn\xF3stico",
+      adapter: true,
+      installable: true
+    }
+  ]
+};
+function integrationsOf(forge) {
+  return OPTIONAL_INTEGRATIONS[forge] ?? [];
+}
+function detectLocal(integration, deps) {
+  const { name } = integration;
+  const evidence = [];
+  const receipt = loadForgeState(deps.home).forges[name];
+  if (receipt) {
+    evidence.push(`receipt=${receipt.method}@${receipt.venv ?? receipt.bin ?? "?"}`);
+    if (receipt.version) evidence.push(`version=${receipt.version}`);
+    const localMissing = receipt.method === "local" && (typeof receipt.source_dir !== "string" || !existsSync24(receipt.source_dir));
+    if (localMissing) {
+      evidence.push(`source_dir=${receipt.source_dir ?? "?"} (AUSENTE)`);
+      return { integration, state: "degraded", evidence };
+    }
+    if (receipt.verify?.ok === false) {
+      evidence.push(`verify=${receipt.verify.command.join(" ") || "?"} falhou`);
+      return { integration, state: "degraded", evidence };
+    }
+    evidence.push(`verify=${receipt.verify?.ok ? "ok" : "n\xE3o executado"}`);
+    return { integration, state: receipt.verify?.ok ? "verified" : "installed", evidence };
+  }
+  const dir = resolveInside(deps.root, name);
+  if (dir && existsSync24(dir)) {
+    evidence.push(`checkout=${dir}${hasGitRepo(dir) ? " (git)" : " (sem .git)"}`);
+    return { integration, state: "checkout", evidence };
+  }
+  evidence.push("sem receipt, checkout ou bin\xE1rio gerenciado detectado");
+  return { integration, state: "absent", evidence };
+}
+async function detect(integration, deps) {
+  const local = detectLocal(integration, deps);
+  if (local.state !== "absent" || !deps.which) return local;
+  const bin = deps.bin?.(integration.name);
+  if (!bin) return local;
+  const found = await deps.which(bin);
+  if (!found) return local;
+  return {
+    integration,
+    state: "installed",
+    evidence: [`bin=${found} (PATH, n\xE3o-gerenciado)`]
+  };
+}
+async function classifyIntegrations(forge, deps) {
+  const out = [];
+  for (const integration of integrationsOf(forge)) {
+    out.push(await detect(integration, deps));
+  }
+  return out;
+}
+function classifyIntegrationsSync(forge, deps) {
+  return integrationsOf(forge).map((i3) => detectLocal(i3, deps));
+}
+function pendingIntegrations(statuses) {
+  return statuses.filter((s) => s.state === "absent" || s.state === "checkout");
+}
+function installableNames(statuses) {
+  return statuses.filter((s) => s.integration.installable).map((s) => s.integration.name);
+}
+async function defaultWhich(bin) {
+  const isWin = process.platform === "win32";
+  try {
+    const res = await execa(isWin ? "where" : "sh", isWin ? [bin] : ["-c", `command -v ${bin}`], {
+      reject: false
+    });
+    const first = (res.stdout ?? "").split("\n")[0]?.trim();
+    return res.exitCode === 0 && first ? first : null;
+  } catch {
+    return null;
+  }
+}
+async function askOptionalIntegrations(statuses, ask) {
+  const pending = pendingIntegrations(statuses);
+  const chosen = await ask(
+    pending.map((s) => ({
+      value: s.integration.name,
+      label: s.integration.name,
+      hint: s.integration.reason
+    }))
+  ) ?? [];
+  const installable = new Set(installableNames(pending));
+  return {
+    offered: pending,
+    consented: chosen,
+    installable: chosen.filter((n4) => installable.has(n4)),
+    notInstallable: chosen.filter((n4) => !installable.has(n4))
+  };
+}
+
 // src/doctor2/domains.ts
 function systemChecks(ctx) {
   const checks = [];
@@ -20277,7 +20592,7 @@ function systemChecks(ctx) {
   const dirEvidence = [];
   let dirFailed = 0;
   for (const { label, dir: d } of required) {
-    if (!existsSync24(d)) {
+    if (!existsSync25(d)) {
       dirFailed += 1;
       dirEvidence.push(`${label}=${d}: ausente`);
       continue;
@@ -20348,7 +20663,7 @@ function backupScan(ctx) {
   scan(
     path34.join(ctx.home, ".forge-cli", "backups"),
     "host-backup",
-    (full) => existsSync24(path34.join(full, "manifest.json"))
+    (full) => existsSync25(path34.join(full, "manifest.json"))
   );
   for (const repo of ctx.catalog) {
     const dir = resolveInside(ctx.root, repo.name);
@@ -20361,7 +20676,7 @@ function backupScan(ctx) {
 function installationChecks(ctx) {
   const checks = [];
   const forgeDir = artifactsRoot(ctx.root);
-  const forgeDirPresent = existsSync24(forgeDir);
+  const forgeDirPresent = existsSync25(forgeDir);
   const stateFile = stateFileFor(ctx.root);
   checks.push(
     mkCheck(
@@ -20374,7 +20689,7 @@ function installationChecks(ctx) {
         diagnosis: "diret\xF3rio de estado .forge-cli presente",
         evidence: [
           `${forgeDir} presente`,
-          existsSync24(stateFile) ? "state.json presente" : "state.json ausente"
+          existsSync25(stateFile) ? "state.json presente" : "state.json ausente"
         ],
         reversible: null
       } : {
@@ -20390,7 +20705,7 @@ function installationChecks(ctx) {
     )
   );
   const forgeJson = path34.join(ctx.root, "forge.json");
-  if (!existsSync24(forgeJson)) {
+  if (!existsSync25(forgeJson)) {
     checks.push(
       mkCheck(ctx.now, {
         id: "installation.forge-json.present",
@@ -20440,9 +20755,9 @@ function installationChecks(ctx) {
     }
   }
   const lockFile = path34.join(forgeDir, "env.lock.json");
-  const lockParsed = existsSync24(lockFile) ? readJson(lockFile) : null;
+  const lockParsed = existsSync25(lockFile) ? readJson(lockFile) : null;
   const lockObj = lockParsed?.ok && lockParsed.value !== null && typeof lockParsed.value === "object" ? lockParsed.value : null;
-  if (!forgeDirPresent || !existsSync24(lockFile)) {
+  if (!forgeDirPresent || !existsSync25(lockFile)) {
     checks.push(
       mkCheck(ctx.now, {
         id: "installation.lockfile.present",
@@ -20487,7 +20802,7 @@ function installationChecks(ctx) {
     );
   }
   const trackedForges = lockObj ? Object.keys(lockObj.forges ?? {}) : [];
-  if (!existsSync24(lockFile) || !lockObj || !trackedForges.length) {
+  if (!existsSync25(lockFile) || !lockObj || !trackedForges.length) {
     checks.push(
       mkCheck(ctx.now, {
         id: "installation.lockfile.drift",
@@ -20496,7 +20811,7 @@ function installationChecks(ctx) {
         severity: "info",
         diagnosis: "deriva do lockfile n\xE3o verific\xE1vel",
         evidence: [
-          !existsSync24(lockFile) ? "sem lockfile para recomputar (.forge-cli/env.lock.json ausente)" : !lockObj ? "lockfile ileg\xEDvel \u2014 digest n\xE3o pode ser recomputado" : "lockfile n\xE3o cobre nenhuma Forja \u2014 nada para recomputar"
+          !existsSync25(lockFile) ? "sem lockfile para recomputar (.forge-cli/env.lock.json ausente)" : !lockObj ? "lockfile ileg\xEDvel \u2014 digest n\xE3o pode ser recomputado" : "lockfile n\xE3o cobre nenhuma Forja \u2014 nada para recomputar"
         ],
         reversible: null
       })
@@ -20525,10 +20840,10 @@ function installationChecks(ctx) {
       mkCheck(ctx.now, {
         id: "installation.ledger.readable",
         domain: "installation",
-        result: existsSync24(ledgerDir) ? "warn" : "skip",
-        severity: existsSync24(ledgerDir) ? "medium" : "info",
-        diagnosis: existsSync24(ledgerDir) ? "ledger de instala\xE7\xF5es existe mas n\xE3o p\xF4de ser lido" : "sem ledger de instala\xE7\xF5es (~/.forge/installations ausente)",
-        evidence: [`${ledgerDir} ${existsSync24(ledgerDir) ? "ileg\xEDvel" : "ausente"}`],
+        result: existsSync25(ledgerDir) ? "warn" : "skip",
+        severity: existsSync25(ledgerDir) ? "medium" : "info",
+        diagnosis: existsSync25(ledgerDir) ? "ledger de instala\xE7\xF5es existe mas n\xE3o p\xF4de ser lido" : "sem ledger de instala\xE7\xF5es (~/.forge/installations ausente)",
+        evidence: [`${ledgerDir} ${existsSync25(ledgerDir) ? "ileg\xEDvel" : "ausente"}`],
         reversible: null
       })
     );
@@ -20610,11 +20925,11 @@ function installationChecks(ctx) {
   } else {
     const lines = localEntries.map(([name, r2]) => {
       const src = typeof r2.source_dir === "string" ? r2.source_dir : "?";
-      const srcOk = typeof r2.source_dir === "string" && existsSync24(r2.source_dir);
+      const srcOk = typeof r2.source_dir === "string" && existsSync25(r2.source_dir);
       return `${name}: is_git=${r2.is_git === true} trust=${r2.source_trust ?? "?"} manifest_valid=${r2.manifest_valid === true} integrity=${r2.integrity ?? "?"} env=${r2.execution_environment?.platform ?? "?"} dir=${src}${srcOk ? "" : " (AUSENTE)"}`;
     });
     const missing = localEntries.filter(
-      ([, r2]) => typeof r2.source_dir !== "string" || !existsSync24(r2.source_dir)
+      ([, r2]) => typeof r2.source_dir !== "string" || !existsSync25(r2.source_dir)
     );
     checks.push(
       mkCheck(ctx.now, {
@@ -20688,6 +21003,58 @@ function installationChecks(ctx) {
       }
     )
   );
+  const forgeState = loadForgeState(ctx.home).forges;
+  for (const repo of [...ctx.catalog].sort((a3, b) => a3.name.localeCompare(b.name))) {
+    const dir = resolveInside(ctx.root, repo.name);
+    const consumerPresent = !!dir && hasGitRepo(dir) || !!forgeState[repo.name];
+    if (!consumerPresent) continue;
+    const statuses = classifyIntegrationsSync(repo.name, { root: ctx.root, home: ctx.home });
+    if (!statuses.length) continue;
+    const lines = statuses.map((s) => {
+      const sdir = resolveInside(ctx.root, s.integration.name);
+      let contract = "contract=n\xE3o sondado";
+      if (sdir && existsSync25(sdir)) {
+        const manifest = path34.join(sdir, "forge.json");
+        contract = !existsSync25(manifest) ? "contract=sem forge.json" : readJson(manifest).ok ? "contract=forge.json v\xE1lido" : "contract=forge.json inv\xE1lido";
+      } else if (s.state === "verified" || s.state === "installed") {
+        contract = "contract=manifesto dentro da venv (n\xE3o sondado)";
+      }
+      return `${s.integration.name}: state=${s.state} capability=${s.integration.adapter ? "deriv\xE1vel (adapter declarado)" : "n\xE3o declarada"} adapter=${s.integration.adapter ? "the-forge" : "ausente"} ${contract} [${s.evidence.join(" \xB7 ")}]`;
+    });
+    const degraded = statuses.filter((s) => s.state === "degraded").length;
+    const present = statuses.filter((s) => s.state !== "absent").length;
+    checks.push(
+      mkCheck(
+        ctx.now,
+        degraded ? {
+          id: `installation.integrations.${repo.name}`,
+          domain: "installation",
+          result: "warn",
+          severity: "low",
+          diagnosis: `${degraded} integra\xE7\xE3o(\xF5es) opcional(is) degradada(s)`,
+          evidence: boundEntries(ctx, lines).shown,
+          correctiveAction: "reinstall or verify degraded optional specialists",
+          reversible: true
+        } : present ? {
+          id: `installation.integrations.${repo.name}`,
+          domain: "installation",
+          result: "pass",
+          severity: "info",
+          diagnosis: `${present} integra\xE7\xE3o(\xF5es) opcional(is) presente(s) e saud\xE1vel(is)`,
+          evidence: boundEntries(ctx, lines).shown,
+          reversible: null
+        } : {
+          id: `installation.integrations.${repo.name}`,
+          domain: "installation",
+          result: "skip",
+          severity: "info",
+          diagnosis: "integra\xE7\xF5es opcionais ausentes \u2014 nada exigido, nunca falha a Forja principal",
+          evidence: boundEntries(ctx, lines).shown,
+          reversible: null
+        }
+      )
+    );
+  }
   return checks;
 }
 function environmentChecks(ctx) {
@@ -20695,7 +21062,7 @@ function environmentChecks(ctx) {
   const targets = [{ label: "<workspace>", dir: ctx.root }];
   for (const repo of ctx.catalog) {
     const dir = resolveInside(ctx.root, repo.name);
-    if (dir && existsSync24(dir)) targets.push({ label: repo.name, dir, envKeys: repo.envKeys });
+    if (dir && existsSync25(dir)) targets.push({ label: repo.name, dir, envKeys: repo.envKeys });
   }
   const inspected = targets.map((t2) => ({
     ...t2,
@@ -20917,7 +21284,7 @@ function operationsChecks(ctx) {
   checks.push(
     mkCheck(
       ctx.now,
-      !existsSync24(reportsDir) ? {
+      !existsSync25(reportsDir) ? {
         id: "operations.receipts.recent",
         domain: "operations",
         result: "skip",
@@ -20953,7 +21320,7 @@ function operationsChecks(ctx) {
     if (entry2.status === "error") failures.set(name, (failures.get(name) ?? 0) + 1);
   }
   const recurring = [...failures.entries()].filter(([, n4]) => n4 >= 2);
-  const scannedAnything = existsSync24(reportsDir) || ctx.state !== null;
+  const scannedAnything = existsSync25(reportsDir) || ctx.state !== null;
   if (!scannedAnything) {
     checks.push(
       mkCheck(ctx.now, {
@@ -21229,7 +21596,7 @@ async function runDoctor2(root, opts = {}) {
 }
 
 // src/heal/fixes.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync8, readdirSync as readdirSync12, readFileSync as readFileSync19, statSync as statSync5 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync8, readdirSync as readdirSync12, readFileSync as readFileSync19, statSync as statSync5 } from "fs";
 import path36 from "path";
 var rel = (root, abs) => path36.relative(root, abs) || ".";
 function stampOf(iso) {
@@ -21248,7 +21615,7 @@ var forgeDirRepair = {
     return ["", ...FORGE_DIR_SUBDIRS].map((sub) => {
       const dir = sub ? path36.join(base, sub) : base;
       return {
-        description: `create directory ${rel(ctx.root, dir)}${existsSync25(dir) ? " (already present)" : ""}`,
+        description: `create directory ${rel(ctx.root, dir)}${existsSync26(dir) ? " (already present)" : ""}`,
         touches: [rel(ctx.root, dir)]
       };
     });
@@ -21259,7 +21626,7 @@ var forgeDirRepair = {
     const created = [];
     for (const sub of ["", ...FORGE_DIR_SUBDIRS]) {
       const dir = sub ? path36.join(base, sub) : base;
-      if (existsSync25(dir)) continue;
+      if (existsSync26(dir)) continue;
       mkdirSync8(dir, { recursive: true });
       created.push(rel(ctx.root, dir));
     }
@@ -21283,7 +21650,7 @@ function envPathOf(root) {
 }
 function presentKeys(root) {
   const file = envPathOf(root);
-  if (!existsSync25(file)) return /* @__PURE__ */ new Set();
+  if (!existsSync26(file)) return /* @__PURE__ */ new Set();
   return new Set(parseEnv(readFileSync19(file, "utf8")).entries.map((e) => e.key));
 }
 function missingEnvKeys(root, check) {
@@ -21319,7 +21686,7 @@ var envMissingKeyRepair = {
     const root = ctx.root;
     const toAppend = keysToAppend(root, ctx.check);
     const steps = [];
-    if (existsSync25(envPathOf(root))) {
+    if (existsSync26(envPathOf(root))) {
       steps.push({
         description: `backup .env to ${rel(root, path36.join(artifactsRoot(root), "backups"))}/env-<ts>/.env`,
         touches: [".env", `${rel(root, artifactsRoot(root))}/backups/`]
@@ -21338,7 +21705,7 @@ var envMissingKeyRepair = {
     const root = ctx.root;
     if (ctx.dryRun) return "dry-run \u2014 not applied";
     const file = envPathOf(root);
-    const exists = existsSync25(file);
+    const exists = existsSync26(file);
     const current = exists ? readFileSync19(file, "utf8") : "";
     const env = parseEnv(current);
     const present = new Set(env.entries.map((e) => e.key));
@@ -21356,7 +21723,7 @@ var envMissingKeyRepair = {
   },
   async verify(ctx) {
     const file = envPathOf(ctx.root);
-    if (!existsSync25(file)) return false;
+    if (!existsSync26(file)) return false;
     const present = new Set(parseEnv(readFileSync19(file, "utf8")).entries.map((e) => e.key));
     return missingEnvKeys(ctx.root, ctx.check).every((k) => present.has(k));
   }
@@ -21394,7 +21761,7 @@ var ENV_BACKUP_RE = /^env-\d{8}-\d{6}$/;
 var REPO_BACKUP_RE = /^([a-z0-9][a-z0-9._-]*)-\d{10,}$/i;
 function listBackups(root) {
   const base = path36.join(artifactsRoot(root), "backups");
-  if (!existsSync25(base)) return [];
+  if (!existsSync26(base)) return [];
   const out = [];
   for (const entry2 of readdirSync12(base, { withFileTypes: true })) {
     if (!entry2.isDirectory()) continue;
@@ -21423,7 +21790,7 @@ function pickBackupFile(ctx) {
     if (inside.startsWith("..") || path36.isAbsolute(inside)) {
       throw new Error(`selected backup escapes .forge-cli/backups: ${ctx.backup}`);
     }
-    if (!existsSync25(abs) || !statSync5(abs).isFile()) {
+    if (!existsSync26(abs) || !statSync5(abs).isFile()) {
       throw new Error(`selected backup not found: ${ctx.backup}`);
     }
     const dirName = inside.split(path36.sep)[0] ?? "";
@@ -21491,7 +21858,7 @@ var backupRestoreRepair = {
     try {
       const picked = pickBackupFile(ctx);
       const dest = path36.resolve(ctx.root, picked.dest);
-      return existsSync25(dest) && readFileSync19(dest, "utf8") === readFileSync19(picked.src, "utf8");
+      return existsSync26(dest) && readFileSync19(dest, "utf8") === readFileSync19(picked.src, "utf8");
     } catch {
       return false;
     }
@@ -21746,7 +22113,7 @@ async function runDoctor2Command(cli) {
 
 // src/cmd/registry.ts
 import path38 from "path";
-import { existsSync as existsSync26, mkdirSync as mkdirSync10 } from "fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync10 } from "fs";
 
 // src/registry/catalog.ts
 var REGISTRY_PACKAGES = [
@@ -22160,7 +22527,14 @@ async function runRegistryInstall(cli, names, deps = {}) {
       ...receipt.native ? { native: receipt.native } : {}
     });
   }
-  const doc = { method: "pypi", results, warnings };
+  const integrationStatuses = deps.skipIntegrations ? [] : await collectIntegrationStatuses(results, home, cli, deps.which);
+  const pending = pendingIntegrations(integrationStatuses);
+  const doc = {
+    method: "pypi",
+    results,
+    warnings,
+    ...pending.length ? { optional_integrations: pending.map(integrationJson) } : {}
+  };
   reportTo2(doc);
   if (cli.reportPath !== void 0) {
     log.info(`${S.reportSaved}: ${theme.dim(path38.resolve(cli.reportPath))}`);
@@ -22182,8 +22556,62 @@ async function runRegistryInstall(cli, names, deps = {}) {
     "Launchers em ~/.forge-cli/bin (no PATH do forge-cli); sem shim, invoque o caminho da venv"
   );
   outro(`${icons.ok} instala\xE7\xE3o registry-first conclu\xEDda`);
+  if (pending.length && !deps.skipIntegrations) {
+    const canAsk = !quiet2 && !cli.yes && process.stdout.isTTY && process.stdin.isTTY;
+    if (canAsk) {
+      const offer = await askOptionalIntegrations(pending, async (options) => {
+        const picked = await multiselect({
+          message: S.integrationsOffer,
+          options,
+          required: false
+        });
+        if (isCancel(picked)) exitCancelled();
+        return picked;
+      });
+      for (const n4 of offer.notInstallable) {
+        log.warn(`${n4}: ${S.integrationNoInstallRoute}`);
+      }
+      if (offer.installable.length) {
+        await runRegistryInstall(cli, offer.installable, { ...deps, skipIntegrations: true });
+      }
+    } else if (!quiet2) {
+      note(
+        pending.map(
+          (s) => `${s.integration.name} \u2014 ${s.integration.reason}${s.integration.installable ? "" : ` (${S.integrationNoInstallRoute})`}`
+        ).join("\n"),
+        S.integrationsTitle
+      );
+    }
+  }
   return results;
 }
+function integrationJson(s) {
+  return {
+    name: s.integration.name,
+    state: s.state,
+    adapter: s.integration.adapter,
+    installable: s.integration.installable,
+    reason: s.integration.reason,
+    evidence: s.evidence
+  };
+}
+async function collectIntegrationStatuses(results, home, cli, which) {
+  const root = resolveTargetDir(cli.dir);
+  const bin = (n4) => FORGE_REPOS.find((r2) => r2.name === n4)?.verify?.[0];
+  const statuses = [];
+  for (const r2 of results) {
+    if (!r2.ok) continue;
+    statuses.push(
+      ...await classifyIntegrations(r2.forge, {
+        root,
+        home,
+        which: which ?? defaultWhich,
+        bin
+      })
+    );
+  }
+  return statuses;
+}
 async function runRegistryLock(cli, names, deps = {}) {
   const home = deps.home ?? cliHome();
   const quiet2 = registryQuiet(cli);
@@ -22304,7 +22732,7 @@ function runRegistryList(cli, deps = {}) {
   }
   const rows = REGISTRY_PACKAGES.filter((e) => !wanted || wanted.has(e.name)).map((e) => {
     const inst = state.forges[e.name];
-    const binOk = inst ? typeof inst.bin === "string" && existsSync26(inst.bin) : null;
+    const binOk = inst ? typeof inst.bin === "string" && existsSync27(inst.bin) : null;
     const consistency = installConsistency(home, e.name);
     const relevant = consistency.status !== "not-installed";
     return {
@@ -22333,7 +22761,7 @@ function runRegistryList(cli, deps = {}) {
     installed: inst.version ?? null,
     method: inst.method ?? null,
     verifyOk: inst.verify?.ok ?? null,
-    binPresent: typeof inst.bin === "string" ? existsSync26(inst.bin) : null,
+    binPresent: typeof inst.bin === "string" ? existsSync27(inst.bin) : null,
     bin: inst.bin ?? null,
     consistent: null,
     consistency: null,
@@ -23101,7 +23529,7 @@ async function runRegistryPin(cli, names, pin, deps = {}) {
 
 // src/source/detect.ts
 import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync27, lstatSync as lstatSync3, readFileSync as readFileSync20, statSync as statSync6 } from "fs";
+import { existsSync as existsSync28, lstatSync as lstatSync3, readFileSync as readFileSync20, statSync as statSync6 } from "fs";
 import path39 from "path";
 var MANIFEST_MAX_BYTES = 64 * 1024;
 var CHECKSUM_MAX_ENTRIES = 1e4;
@@ -23124,7 +23552,7 @@ var PROJECT_MARKERS = [
 var CHECKSUM_FILES = ["SHA256SUMS", "checksums.sha256", ".forge-checksums.json"];
 function readManifestStrict(dir) {
   const file = path39.join(dir, "forge.json");
-  if (!existsSync27(file)) return { ok: false, reason: "absent", detail: "forge.json ausente" };
+  if (!existsSync28(file)) return { ok: false, reason: "absent", detail: "forge.json ausente" };
   let raw;
   try {
     if (!statSync6(file).isFile() || statSync6(file).size > MANIFEST_MAX_BYTES) {
@@ -23199,7 +23627,7 @@ function scanStructure(dir) {
       return false;
     }
   });
-  const markers = PROJECT_MARKERS.filter((f) => existsSync27(path39.join(dir, f)));
+  const markers = PROJECT_MARKERS.filter((f) => existsSync28(path39.join(dir, f)));
   return { setup_scripts: [...setup], project_markers: [...markers] };
 }
 function verifyChecksums(dir, reasons) {
@@ -23421,7 +23849,7 @@ function detectSource(input, cwd = process.cwd()) {
   const structure = scanStructure(dir);
   const expected = structure.setup_scripts.length > 0 && structure.project_markers.length > 0;
   if (gitKind === null) {
-    if (!existsSync27(path39.join(dir, "forge.json"))) {
+    if (!existsSync28(path39.join(dir, "forge.json"))) {
       reasons.push("forge.json=ausente");
       return verdict(
         "UNKNOWN_DIRECTORY",
@@ -23504,7 +23932,7 @@ function looksLikePathArg(arg, cwd = process.cwd()) {
 import path41 from "path";
 
 // src/source/install.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync11, readdirSync as readdirSync13, rmSync as rmSync7, statSync as statSync7 } from "fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync11, readdirSync as readdirSync13, rmSync as rmSync7, statSync as statSync7 } from "fs";
 import { copyFile as copyFile3 } from "fs/promises";
 import path40 from "path";
 var fail = (failure, detection) => ({
@@ -23592,7 +24020,7 @@ function selectSetup(det, platform2, python, winShells) {
   if (script) return script;
   const bootstrap = path40.join("scripts", "forge_bootstrap.py");
   const argv = localPythonOf(python)?.argv;
-  if (argv?.length && existsSync28(path40.join(det.path, bootstrap))) {
+  if (argv?.length && existsSync29(path40.join(det.path, bootstrap))) {
     return {
       file: bootstrap,
       command: argv[0],
@@ -23618,14 +24046,14 @@ function pythonFloorFailure(det, python) {
 }
 async function provisionEnvironment(dir, forgeId) {
   const envKeys = FORGE_REPOS.find((r2) => r2.name === forgeId)?.envKeys;
-  if (envKeys?.length || existsSync28(path40.join(dir, ".env")) || existsSync28(path40.join(dir, ".env.example"))) {
+  if (envKeys?.length || existsSync29(path40.join(dir, ".env")) || existsSync29(path40.join(dir, ".env.example"))) {
     await ensureEnvFile(dir, envKeys);
   }
   await copyConfigExamples(dir);
 }
 function sourceVenv(det, platform2) {
   const venv = path40.join(det.path, ".venv");
-  return existsSync28(venvBin(venv, platform2)) ? venv : void 0;
+  return existsSync29(venvBin(venv, platform2)) ? venv : void 0;
 }
 async function persistLocalReceipt(home, receipt, opts) {
   const envelope = resolveInside(forgesRoot(home), receipt.forge);
@@ -23650,7 +24078,7 @@ function buildReceipt(det, deps, script, managed, sourceFiles, prior) {
   const venv = sourceVenv(det, platform2);
   const cliName = manifest?.cli;
   const binCandidate = venv && cliName ? path40.join(venvBin(venv, platform2), cliName) : void 0;
-  const bin = binCandidate && existsSync28(binCandidate) ? binCandidate : cliName;
+  const bin = binCandidate && existsSync29(binCandidate) ? binCandidate : cliName;
   const py = localPythonOf(deps.python);
   return {
     forge: det.forge_id,
@@ -23805,7 +24233,7 @@ async function localInstall(dir, deps) {
   await runVerify(receipt, det, deps, run);
   try {
     await persistLocalReceipt(deps.home, receipt, deps.lifecycleLock);
-    if (receipt.bin && existsSync28(receipt.bin)) {
+    if (receipt.bin && existsSync29(receipt.bin)) {
       try {
         receipt.shim = emitForgeShim(deps.home, receipt.bin, platform2);
       } catch (shimError) {
@@ -23855,7 +24283,7 @@ async function localUpdate(dir, deps) {
   if (gate) return fail(gate, det);
   const targetDir = prior.source_dir;
   if (path40.resolve(targetDir) !== det.path) {
-    if (!existsSync28(targetDir)) {
+    if (!existsSync29(targetDir)) {
       return fail(
         {
           code: "FORGE-SOURCE-NOT-FOUND",
@@ -23877,7 +24305,7 @@ async function localUpdate(dir, deps) {
     for (const rel2 of prior.source_files) {
       if (keep.has(rel2)) continue;
       const target = safeJoinInside(targetDir, rel2);
-      if (target && existsSync28(target)) rmSync7(target, { force: true });
+      if (target && existsSync29(target)) rmSync7(target, { force: true });
     }
   }
   return runUpdateAt(targetDir, prior, deps, run);
@@ -23920,7 +24348,7 @@ async function runUpdateAt(dir, prior, deps, run) {
   }
   const managed = [
     .../* @__PURE__ */ new Set([
-      ...prior.managed_artifacts.filter((a3) => existsSync28(path40.join(det.path, a3))),
+      ...prior.managed_artifacts.filter((a3) => existsSync29(path40.join(det.path, a3))),
       ...[...topLevelEntries(det.path)].filter((e) => !before.has(e))
     ])
   ].sort();
@@ -23972,7 +24400,7 @@ async function localRepair(name, deps) {
     });
   }
   const dir = prior.source_dir;
-  if (!dir || !existsSync28(dir)) {
+  if (!dir || !existsSync29(dir)) {
     return fail({
       code: "FORGE-SOURCE-NOT-FOUND",
       cause: `${name}: fonte local ausente (${dir ?? "desconhecida"})`,
@@ -23987,7 +24415,7 @@ async function localRepair(name, deps) {
   if (floorFailure) return fail(floorFailure, det);
   for (const rel2 of prior.managed_artifacts) {
     const target = safeJoinInside(dir, rel2);
-    if (target && existsSync28(target)) rmSync7(target, { recursive: true, force: true });
+    if (target && existsSync29(target)) rmSync7(target, { recursive: true, force: true });
   }
   const before = topLevelEntries(dir);
   const envFailure = await provisionOrRefuse(dir, det.forge_id);
@@ -24022,7 +24450,7 @@ async function localRepair(name, deps) {
   }
   const managed = [
     .../* @__PURE__ */ new Set([
-      ...prior.managed_artifacts.filter((a3) => existsSync28(path40.join(dir, a3))),
+      ...prior.managed_artifacts.filter((a3) => existsSync29(path40.join(dir, a3))),
       ...[...topLevelEntries(dir)].filter((e) => !before.has(e))
     ])
   ].sort();
@@ -24078,7 +24506,7 @@ async function localUninstall(name, deps) {
   const dir = prior.source_dir;
   const removed = [];
   let backup;
-  if (dir && existsSync28(dir)) {
+  if (dir && existsSync29(dir)) {
     const filesToBackup = prior.managed_artifacts.filter((rel2) => {
       const target = safeJoinInside(dir, rel2);
       try {
@@ -24103,7 +24531,7 @@ async function localUninstall(name, deps) {
     }
     for (const rel2 of prior.managed_artifacts) {
       const target = safeJoinInside(dir, rel2);
-      if (target && existsSync28(target)) {
+      if (target && existsSync29(target)) {
         rmSync7(target, { recursive: true, force: true });
         removed.push(rel2);
       }
@@ -24116,7 +24544,7 @@ async function localUninstall(name, deps) {
   try {
     removeForgeShim(deps.home, prior.shim ?? prior.bin, deps.platform ?? process.platform);
     const envelope = resolveInside(forgesRoot(deps.home), name);
-    if (envelope && existsSync28(envelope)) rmSync7(envelope, { recursive: true, force: true });
+    if (envelope && existsSync29(envelope)) rmSync7(envelope, { recursive: true, force: true });
     const cur = loadForgeState(deps.home);
     if (Object.hasOwn(cur.forges, name)) {
       delete cur.forges[name];
@@ -24481,15 +24909,15 @@ async function runLocalLifecycleCommand(cli, op, names) {
 }
 
 // src/lifecycle.ts
-import { copyFileSync as copyFileSync3, existsSync as existsSync29, mkdirSync as mkdirSync13, readdirSync as readdirSync14, rmSync as rmSync8 } from "fs";
+import { copyFileSync as copyFileSync3, existsSync as existsSync30, mkdirSync as mkdirSync13, readdirSync as readdirSync14, rmSync as rmSync8 } from "fs";
 import path42 from "path";
 function configFilesToBackup(repoDir) {
   const out = /* @__PURE__ */ new Set();
-  if (existsSync29(path42.join(repoDir, ".env"))) out.add(".env");
+  if (existsSync30(path42.join(repoDir, ".env"))) out.add(".env");
   for (const file of readdirSync14(repoDir)) {
     if (file === ".env.example" || !file.includes(".example.")) continue;
     const real = file.replace(".example.", ".");
-    if (existsSync29(path42.join(repoDir, real))) out.add(real);
+    if (existsSync30(path42.join(repoDir, real))) out.add(real);
   }
   return [...out];
 }
@@ -24498,7 +24926,7 @@ async function planUninstall(targetDir, repo) {
   if (!dir)
     return { kind: "refused", dir: path42.join(targetDir, repo.name), reason: "invalid-name" };
   if (isLinkOrJunction(dir)) return { kind: "refused", dir, reason: "symlink" };
-  if (!existsSync29(dir)) return { kind: "absent", dir };
+  if (!existsSync30(dir)) return { kind: "absent", dir };
   if (!hasGitRepo(dir)) return { kind: "refused", dir, reason: "non-git" };
   const remote = await commandOutput("git", ["-C", dir, "remote", "get-url", "origin"]);
   if (remote && remote !== "ok" && !sameRemote(remote, repo.url)) {
@@ -24849,11 +25277,11 @@ async function runUninstallCommand(cli) {
 }
 
 // src/config.ts
-import { existsSync as existsSync30, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync21 } from "fs";
 import path44 from "path";
 function loadConfig(targetDir) {
   const file = path44.join(targetDir, "forge-cli.config.json");
-  if (!existsSync30(file)) return null;
+  if (!existsSync31(file)) return null;
   let parsed;
   try {
     parsed = JSON.parse(readFileSync21(file, "utf8"));
@@ -24899,12 +25327,12 @@ function loadConfig(targetDir) {
 }
 
 // src/plan.ts
-import { existsSync as existsSync31, readdirSync as readdirSync15 } from "fs";
+import { existsSync as existsSync32, readdirSync as readdirSync15 } from "fs";
 import path45 from "path";
 function planLines(repo, targetDir) {
   const repoDir = path45.join(targetDir, repo.name);
   const lines = [];
-  if (!existsSync31(repoDir)) {
+  if (!existsSync32(repoDir)) {
     lines.push(`${S.planSync}: git clone (${S.planDetectAfter})`);
     for (const step of [
       S.phaseEnv,
@@ -24947,7 +25375,7 @@ async function executionSummary(repo, targetDir, native, platform2 = process.pla
   const trust = repo.origin === "custom" ? "custom" : "builtin";
   const commands = [];
   let revision;
-  if (!existsSync31(repoDir) || !hasGitRepo(repoDir)) {
+  if (!existsSync32(repoDir) || !hasGitRepo(repoDir)) {
     commands.push(`git clone -- ${repo.url}`, S.planScriptsAfterClone);
   } else {
     revision = (await currentHead(repoDir))?.slice(0, 7);
@@ -25181,11 +25609,59 @@ ${planLines(repo, targetDir).map((line) => `  ${theme.dim(line)}`).join("\n")}`
   log.info(`${S.logSaved}: ${theme.dim(runLog.file)}`);
   const hasErrors = results.some((r2) => r2.status === "error");
   outro(`${icons.rocket} ${hasErrors ? S.outroWithErrors : S.outroOk}`);
+  if (!hasErrors && (resolved.command === "install" || resolved.command === "clone")) {
+    await offerOptionalIntegrations(cli, results, catalog, targetDir, opts, runLog, interactive);
+  }
   if (hasErrors) process.exitCode = 1;
 }
+async function offerOptionalIntegrations(cli, results, catalog, targetDir, opts, runLog, interactive) {
+  const present = new Set(results.filter((r2) => r2.status !== "error").map((r2) => r2.repo.name));
+  const statuses = [];
+  for (const r2 of results) {
+    if (!present.has(r2.repo.name)) continue;
+    statuses.push(
+      ...await classifyIntegrations(r2.repo.name, {
+        root: targetDir,
+        home: cliHome(),
+        which: defaultWhich,
+        bin: (n4) => catalog.find((c5) => c5.name === n4)?.verify?.[0]
+      })
+    );
+  }
+  const pending = pendingIntegrations(statuses);
+  if (!pending.length) return;
+  if (interactive && !cli.yes) {
+    const offer = await askOptionalIntegrations(pending, async (options) => {
+      const picked = await multiselect({
+        message: S.integrationsOffer,
+        options,
+        required: false
+      });
+      if (isCancel(picked)) {
+        cancel(S.cancelled);
+        return null;
+      }
+      return picked;
+    });
+    const selected = catalog.filter((c5) => offer.consented.includes(c5.name));
+    const unrouted = offer.consented.filter((n4) => !catalog.some((c5) => c5.name === n4));
+    for (const n4 of unrouted) log.warn(`${n4}: ${S.integrationNoInstallRoute}`);
+    if (selected.length) {
+      const more = await processBatch(selected, targetDir, opts, runLog.write, 0, selected.length);
+      renderReport(more);
+    }
+  } else {
+    note(
+      pending.map(
+        (s) => `${s.integration.name} \u2014 ${s.integration.reason}${catalog.some((c5) => c5.name === s.integration.name) ? "" : ` (${S.integrationNoInstallRoute})`}`
+      ).join("\n"),
+      S.integrationsTitle
+    );
+  }
+}
 
 // src/cmd/env.ts
-import { copyFileSync as copyFileSync4, existsSync as existsSync34, readFileSync as readFileSync23, readdirSync as readdirSync17 } from "fs";
+import { copyFileSync as copyFileSync4, existsSync as existsSync35, readFileSync as readFileSync23, readdirSync as readdirSync17 } from "fs";
 import path48 from "path";
 
 // src/env/discover.ts
@@ -25193,7 +25669,7 @@ import { accessSync as accessSync3, constants as constants6 } from "fs";
 import os7 from "os";
 
 // src/env/paths.ts
-import { accessSync as accessSync2, constants as constants5, existsSync as existsSync32 } from "fs";
+import { accessSync as accessSync2, constants as constants5, existsSync as existsSync33 } from "fs";
 import os6 from "os";
 import path46 from "path";
 function resolveDeps2(deps) {
@@ -25202,7 +25678,7 @@ function resolveDeps2(deps) {
     osHome: deps.osHome ?? os6.homedir(),
     cwd: deps.cwd ?? process.cwd(),
     tmpDir: deps.tmpDir ?? os6.tmpdir(),
-    exists: deps.exists ?? existsSync32,
+    exists: deps.exists ?? existsSync33,
     writable: deps.writable ?? ((dir) => {
       try {
         accessSync2(dir, constants5.W_OK);
@@ -25416,7 +25892,32 @@ function targetFindings(targets) {
 async function discoverEnvironment(deps = {}) {
   const platform2 = deps.platform ?? process.platform;
   const home = deps.home ?? cliHome();
-  const shells = await discoverShells(deps);
+  const [shells, gitProbe, pyDiscovery] = await Promise.all([
+    discoverShells(deps),
+    deps.gitProbe ? deps.gitProbe() : commandOutput("git", ["--version"]).then((output) => ({ output, timedOut: false })),
+    // Pipeline lf-0017 completo — `run`/`exists`/`env`/`platform` são os
+    // MESMOS da sonda de shells: um fake único controla a descoberta toda.
+    // `pythonProbe` legado (testes pré-lf-0017) vira descoberta sintética.
+    deps.pythonDiscovery ? deps.pythonDiscovery({
+      platform: platform2,
+      env: deps.env,
+      run: deps.run,
+      exists: deps.exists,
+      osHome: deps.osHome,
+      cwd: deps.cwd,
+      targetDir: deps.workspace,
+      explicit: deps.pythonExplicit
+    }) : deps.pythonProbe ? legacyPythonDiscovery(platform2, deps.pythonProbe) : discoverPythons({
+      platform: platform2,
+      env: deps.env,
+      run: deps.run,
+      exists: deps.exists,
+      osHome: deps.osHome,
+      cwd: deps.cwd,
+      targetDir: deps.workspace,
+      explicit: deps.pythonExplicit
+    })
+  ]);
   const route = routeOf(platform2, shells);
   const targets = resolveWriteTargets({
     env: deps.env,
@@ -25432,31 +25933,11 @@ async function discoverEnvironment(deps = {}) {
       workspaceDir: deps.workspace ?? deps.explicit?.workspaceDir
     }
   });
-  const gitProbe = deps.gitProbe ? await deps.gitProbe() : { output: await commandOutput("git", ["--version"]), timedOut: false };
   const git = {
     present: gitProbe !== null && !gitProbe.timedOut && gitProbe.output !== null,
     version: gitProbe?.output ?? null,
     executable: gitProbe?.output ? "git" : null
   };
-  const pyDiscovery = deps.pythonDiscovery ? await deps.pythonDiscovery({
-    platform: platform2,
-    env: deps.env,
-    run: deps.run,
-    exists: deps.exists,
-    osHome: deps.osHome,
-    cwd: deps.cwd,
-    targetDir: deps.workspace,
-    explicit: deps.pythonExplicit
-  }) : deps.pythonProbe ? await legacyPythonDiscovery(platform2, deps.pythonProbe) : await discoverPythons({
-    platform: platform2,
-    env: deps.env,
-    run: deps.run,
-    exists: deps.exists,
-    osHome: deps.osHome,
-    cwd: deps.cwd,
-    targetDir: deps.workspace,
-    explicit: deps.pythonExplicit
-  });
   const pySelected = pyDiscovery.selected;
   const pyInfo = pySelected ? {
     exe: pySelected.argv[0],
@@ -25719,7 +26200,7 @@ function envDoctor(repoDir, envKeys) {
 
 // src/envintel/migrate.ts
 import { randomBytes } from "crypto";
-import { existsSync as existsSync33, mkdirSync as mkdirSync14, readdirSync as readdirSync16, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync14, readdirSync as readdirSync16, readFileSync as readFileSync22 } from "fs";
 import path47 from "path";
 function timestamp2(d = /* @__PURE__ */ new Date()) {
   const p = (n4) => String(n4).padStart(2, "0");
@@ -25735,11 +26216,11 @@ function addValue(spec, exampleEmpty) {
 function planMigration(repoDir, targetSchema) {
   const schema = targetSchema ?? deriveSchema(repoDir);
   const envPath = path47.join(repoDir, ".env");
-  const env = existsSync33(envPath) ? parseEnv(readFileSync22(envPath, "utf8")) : null;
+  const env = existsSync34(envPath) ? parseEnv(readFileSync22(envPath, "utf8")) : null;
   const present = new Set(env?.entries.map((e) => e.key) ?? []);
   const examplePath = path47.join(repoDir, ".env.example");
   const exampleEmpty = /* @__PURE__ */ new Set();
-  if (existsSync33(examplePath)) {
+  if (existsSync34(examplePath)) {
     for (const e of parseEnv(readFileSync22(examplePath, "utf8")).entries) {
       if (e.value === "") exampleEmpty.add(e.key);
     }
@@ -25779,7 +26260,7 @@ function backupEnv(repoDir, content) {
 }
 function applyMigration(repoDir, plan, opts = {}) {
   const envPath = path47.join(repoDir, ".env");
-  const exists = existsSync33(envPath);
+  const exists = existsSync34(envPath);
   const current = exists ? readFileSync22(envPath, "utf8") : "";
   const env = parseEnv(current);
   const present = new Set(env.entries.map((e) => e.key));
@@ -25811,14 +26292,14 @@ function applyMigration(repoDir, plan, opts = {}) {
 }
 function latestEnvBackup(repoDir) {
   const root = path47.join(artifactsRoot(repoDir), "backups");
-  if (!existsSync33(root)) return null;
+  if (!existsSync34(root)) return null;
   const candidates = readdirSync16(root, { withFileTypes: true }).filter((d) => d.isDirectory() && /^env-\d{8}-\d{6}$/.test(d.name)).map((d) => d.name).sort();
   const last = candidates.at(-1);
   return last ? path47.join(root, last) : null;
 }
 function rollbackEnv(repoDir, backupDir) {
   const src = path47.join(backupDir, ".env");
-  if (!existsSync33(src)) return false;
+  if (!existsSync34(src)) return false;
   writeFileAtomic(path47.join(repoDir, ".env"), readFileSync22(src, "utf8"));
   return true;
 }
@@ -25839,7 +26320,7 @@ function envCandidates(dir) {
   try {
     return readdirSync17(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).filter((name) => {
       const r2 = resolveInside(dir, name);
-      return r2 !== null && (existsSync34(path48.join(r2, ".env")) || existsSync34(path48.join(r2, ".env.example")));
+      return r2 !== null && (existsSync35(path48.join(r2, ".env")) || existsSync35(path48.join(r2, ".env.example")));
     }).sort();
   } catch {
     return [];
@@ -25916,7 +26397,7 @@ async function runEnvCommand(cli, args) {
     envKeys = catalogFor(targetDir).find((r2) => r2.name === name)?.envKeys;
   } else {
     const cwd = process.cwd();
-    if (existsSync34(path48.join(cwd, ".env")) || existsSync34(path48.join(cwd, ".env.example"))) {
+    if (existsSync35(path48.join(cwd, ".env")) || existsSync35(path48.join(cwd, ".env.example"))) {
       repoDir = cwd;
     }
   }
@@ -25968,7 +26449,7 @@ async function runEnvCommand(cli, args) {
     note(lines.join("\n"), `${S.envDoctorTitle} \u2014 ${repo}`);
     return res2.checks.some((c5) => c5.result === "fail") ? 1 : 0;
   }
-  if (!existsSync34(repoDir)) {
+  if (!existsSync35(repoDir)) {
     log.error(`${repo}: ${S.statusNotInstalled}`);
     return 2;
   }
@@ -25984,7 +26465,7 @@ async function runEnvCommand(cli, args) {
       log.error(S.envWizardNonInteractive);
       return 2;
     }
-    const env = parseEnv(existsSync34(envPath) ? readFileSync23(envPath, "utf8") : "");
+    const env = parseEnv(existsSync35(envPath) ? readFileSync23(envPath, "utf8") : "");
     const current = new Map(env.entries.map((e) => [e.key, e]));
     const updates = /* @__PURE__ */ new Map();
     for (const spec of schema.vars) {
@@ -26027,7 +26508,7 @@ async function runEnvCommand(cli, args) {
     }
     for (const [k, v] of updates) lines.push(formatEntry(k, v));
     const out = serializeEnv({ ...env, lines });
-    if (existsSync34(envPath)) copyFileSync4(envPath, `${envPath}.bak`);
+    if (existsSync35(envPath)) copyFileSync4(envPath, `${envPath}.bak`);
     writeFileAtomic(envPath, out.endsWith("\n") ? out : `${out}
 `);
     log.success(`${icons.ok} ${S.envWizardDone} ${theme.dim(`(${envPath}.bak)`)}`);
@@ -26055,7 +26536,7 @@ async function runEnvCommand(cli, args) {
     return 0;
   }
   if (verb === "init") {
-    if (existsSync34(envPath)) {
+    if (existsSync35(envPath)) {
       if (json) console.log(JSON.stringify({ command: "env init", repo, created: false }));
       else log.info(S.envInitExists);
       return 0;
@@ -26170,11 +26651,11 @@ async function runEnvCommand(cli, args) {
 
 // src/cmd/hosts.ts
 import path50 from "path";
-import { existsSync as existsSync36, readdirSync as readdirSync18 } from "fs";
+import { existsSync as existsSync37, readdirSync as readdirSync18 } from "fs";
 
 // src/mcp/handshake.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync35 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 import path49 from "path";
 import { createInterface as createInterface2 } from "readline";
 var PROTOCOL_VERSION = "2024-11-05";
@@ -26265,7 +26746,7 @@ function probeMcpServer(argv, opts = {}) {
     const stepMs = opts.timeoutMs ?? STEP_MS;
     const levels = [];
     if (path49.isAbsolute(argv[0])) {
-      if (!existsSync35(argv[0])) {
+      if (!existsSync36(argv[0])) {
         resolve(err("bin-missing", `bin\xE1rio MCP ausente: ${argv[0]}`));
         return;
       }
@@ -26695,7 +27176,7 @@ async function runMcpCommand(cli, args, home = cliHome()) {
   const candidates = names.length > 0 ? names : [
     .../* @__PURE__ */ new Set([
       ...Object.keys(loadForgeState(home).forges),
-      ...existsSync36(targetDir) ? readdirSync18(targetDir, { withFileTypes: true }).filter((d) => d.isDirectory() && isSafeRepoName(d.name)).map((d) => d.name) : []
+      ...existsSync37(targetDir) ? readdirSync18(targetDir, { withFileTypes: true }).filter((d) => d.isDirectory() && isSafeRepoName(d.name)).map((d) => d.name) : []
     ])
   ].sort();
   if (candidates.length === 0) {
@@ -26716,7 +27197,7 @@ async function runMcpCommand(cli, args, home = cliHome()) {
       results.push({ forge: name, ok: false, detail: "sem mcp_command" });
       continue;
     }
-    const binPresent = path50.isAbsolute(argv[0]) ? existsSync36(argv[0]) : true;
+    const binPresent = path50.isAbsolute(argv[0]) ? existsSync37(argv[0]) : true;
     const item = {
       forge: name,
       forge_id: forge.forge_id,
@@ -26764,7 +27245,7 @@ async function runMcpCommand(cli, args, home = cliHome()) {
 }
 
 // src/discovery.ts
-import { existsSync as existsSync37, readdirSync as readdirSync19, readFileSync as readFileSync24, statSync as statSync8 } from "fs";
+import { existsSync as existsSync38, readdirSync as readdirSync19, readFileSync as readFileSync24, statSync as statSync8 } from "fs";
 import os8 from "os";
 import path51 from "path";
 var DEFAULT_LIMITS = {
@@ -27054,10 +27535,10 @@ function registryState(entry2) {
 function discoverForge(name, dir, state) {
   const sources = [];
   const git = !!dir && hasGitRepo(dir);
-  const manifest = dir && existsSync37(dir) ? readForgeManifest(dir) : null;
+  const manifest = dir && existsSync38(dir) ? readForgeManifest(dir) : null;
   const entry2 = state?.repos[name];
   if (entry2 && entry2.phase !== "not-installed") {
-    const dirExists = !!dir && existsSync37(dir);
+    const dirExists = !!dir && existsSync38(dir);
     sources.push({
       origin: "manifest",
       // registro diz instalada mas o checkout sumiu → evidência falhando
@@ -27117,7 +27598,7 @@ async function discoverEnvironment2(targetDir, opts) {
     const dir = resolveInside(root, dirName);
     if (!dir) continue;
     const git = hasGitRepo(dir);
-    const manifest = existsSync37(path51.join(dir, "forge.json"));
+    const manifest = existsSync38(path51.join(dir, "forge.json"));
     if (!git && !manifest) continue;
     presence.push({ name: dirName, path: dirName, git, manifest });
     if (!catalogNames.has(dirName) && manifest) {
@@ -27786,7 +28267,7 @@ async function answerRepair(targetDir, repos, opts = {}) {
 }
 
 // src/intel/context.ts
-import { existsSync as existsSync38, readdirSync as readdirSync20, readFileSync as readFileSync25, statSync as statSync9 } from "fs";
+import { existsSync as existsSync39, readdirSync as readdirSync20, readFileSync as readFileSync25, statSync as statSync9 } from "fs";
 import path52 from "path";
 
 // src/planner.ts
@@ -27904,7 +28385,7 @@ function safeConfig(targetDir) {
 function readManifestObject(repoDir) {
   const file = path52.join(repoDir, "forge.json");
   try {
-    if (!existsSync38(file) || statSync9(file).size > MAX_MANIFEST_BYTES) return null;
+    if (!existsSync39(file) || statSync9(file).size > MAX_MANIFEST_BYTES) return null;
     const raw = JSON.parse(readFileSync25(file, "utf8"));
     return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
   } catch {
@@ -28074,7 +28555,7 @@ async function buildForgeContext(targetDir, repos, opts = {}) {
 }
 
 // src/intel/predict.ts
-import { existsSync as existsSync39, readFileSync as readFileSync26, statSync as statSync10 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync26, statSync as statSync10 } from "fs";
 import path53 from "path";
 var MAX_MANIFEST_BYTES2 = 64 * 1024;
 var SEMVERISH = /^v?\d+\.\d+\.\d+/;
@@ -28087,7 +28568,7 @@ var mk2 = (id, kind, subject, certainty, version, evidence, explanation) => ({ i
 function readManifest(repoDir) {
   const file = path53.join(repoDir, "forge.json");
   try {
-    if (!existsSync39(file) || statSync10(file).size > MAX_MANIFEST_BYTES2) return null;
+    if (!existsSync40(file) || statSync10(file).size > MAX_MANIFEST_BYTES2) return null;
     const raw = JSON.parse(readFileSync26(file, "utf8"));
     return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
   } catch {
@@ -28404,7 +28885,7 @@ async function predictCompatibility(targetDir, repos, opts = {}) {
   const allClaims = [];
   for (const repo of sorted) {
     const dir = resolveInside(targetDir, repo.name);
-    if (!dir || !existsSync39(dir)) continue;
+    if (!dir || !existsSync40(dir)) continue;
     const m3 = readManifest(dir);
     manifests.set(repo.name, m3);
     if (m3) out.push(...schemaChange(repo.name, m3));
@@ -28416,7 +28897,7 @@ async function predictCompatibility(targetDir, repos, opts = {}) {
   out.push(...envVarFindings("<workspace>", targetDir));
   for (const repo of sorted) {
     const dir = resolveInside(targetDir, repo.name);
-    if (!dir || !existsSync39(dir)) continue;
+    if (!dir || !existsSync40(dir)) continue;
     out.push(...envVarFindings(repo.name, dir, repo.envKeys));
   }
   out.push(...installConflict(allClaims));
@@ -28429,7 +28910,7 @@ import path55 from "path";
 
 // src/ai/cache.ts
 import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync40, mkdirSync as mkdirSync15, readFileSync as readFileSync27, readdirSync as readdirSync21, rmSync as rmSync9 } from "fs";
+import { existsSync as existsSync41, mkdirSync as mkdirSync15, readFileSync as readFileSync27, readdirSync as readdirSync21, rmSync as rmSync9 } from "fs";
 import path54 from "path";
 
 // src/ai/types.ts
@@ -28533,7 +29014,7 @@ function entryFile(rootDir, key) {
 function aiCacheGet(rootDir, key, opts) {
   if (opts.ttlMs <= 0) return null;
   const file = entryFile(rootDir, key);
-  if (!file || !existsSync40(file)) return null;
+  if (!file || !existsSync41(file)) return null;
   try {
     const entry2 = JSON.parse(readFileSync27(file, "utf8"));
     const now = opts.now ?? Date.now();
@@ -28733,7 +29214,7 @@ async function runAiBridge(req, cfg, deps) {
 }
 
 // src/portability/bundle.ts
-import { existsSync as existsSync41, mkdirSync as mkdirSync17, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync42, mkdirSync as mkdirSync17, readFileSync as readFileSync28 } from "fs";
 import path56 from "path";
 
 // src/portability/manifest.ts
@@ -28845,7 +29326,7 @@ function collectPins(targetDir, repos) {
   const pins = /* @__PURE__ */ new Map();
   for (const repo of repos) {
     const repoDir = path56.join(targetDir, repo.name);
-    const version = existsSync41(repoDir) ? pinVersion(repoDir) : void 0;
+    const version = existsSync42(repoDir) ? pinVersion(repoDir) : void 0;
     const head = state?.repos[repo.name]?.head;
     const ref = state?.pins?.[repo.name] ?? head;
     pins.set(repo.name, {
@@ -28872,7 +29353,7 @@ async function exportBundle(targetDir, repos, dest, opts) {
   const schemaByRepo = /* @__PURE__ */ new Map();
   for (const repo of repos) {
     const repoDir = path56.join(targetDir, repo.name);
-    const schema = existsSync41(repoDir) ? deriveSchema(repoDir, repo.envKeys) : { vars: [] };
+    const schema = existsSync42(repoDir) ? deriveSchema(repoDir, repo.envKeys) : { vars: [] };
     schemaByRepo.set(repo.name, schema);
     for (const v of schema.vars) {
       if (v.secret && whitelist.includes(v.key)) refused.add(v.key);
@@ -28914,7 +29395,7 @@ async function exportBundle(targetDir, repos, dest, opts) {
     const values = {};
     for (const repo of repos) {
       const envFile = path56.join(targetDir, repo.name, ".env");
-      if (!existsSync41(envFile)) continue;
+      if (!existsSync42(envFile)) continue;
       const entries = parseEnv(readFileSync28(envFile, "utf8")).entries;
       const found = {};
       for (const key of whitelist) {
@@ -29004,7 +29485,7 @@ function importBundle(src, opts) {
 }
 
 // src/intel/learning.ts
-import { existsSync as existsSync42, mkdirSync as mkdirSync18, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync43, mkdirSync as mkdirSync18, readFileSync as readFileSync29 } from "fs";
 import path57 from "path";
 var LEARNING_SCHEMA = "forge-cli/LearningStore/v1";
 function learningFile(targetDir) {
@@ -29012,7 +29493,7 @@ function learningFile(targetDir) {
 }
 function readStore(targetDir) {
   const file = learningFile(targetDir);
-  if (!existsSync42(file)) return { schema: LEARNING_SCHEMA, enabled: false, observations: [] };
+  if (!existsSync43(file)) return { schema: LEARNING_SCHEMA, enabled: false, observations: [] };
   try {
     const parsed = JSON.parse(readFileSync29(file, "utf8"));
     if (parsed?.schema !== LEARNING_SCHEMA || !Array.isArray(parsed.observations)) {
@@ -29272,7 +29753,7 @@ async function runLearningCommand(cli) {
 }
 
 // src/wizard.ts
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 import path58 from "path";
 var STEP_LABELS = [
   S.wizardStepDetect,
@@ -29313,7 +29794,7 @@ function renderOperationPlan(plan) {
 }
 function planActionsFor(repo, targetDir, steps) {
   const repoDir = path58.join(targetDir, repo.name);
-  const cloned = existsSync43(repoDir) && hasGitRepo(repoDir);
+  const cloned = existsSync44(repoDir) && hasGitRepo(repoDir);
   const actions = [
     {
       kind: "clone",