theforge-cli 0.2.1 → 0.2.3

package/dist/index.js

@@ -95,7 +95,7 @@ var require_windows = __commonJS({
     module.exports = isexe;
     isexe.sync = sync;
     var fs2 = __require("fs");
-    function checkPathExt(path52, options) {
+    function checkPathExt(path53, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -106,25 +106,25 @@ var require_windows = __commonJS({
       }
       for (var i3 = 0; i3 < pathext.length; i3++) {
         var p = pathext[i3].toLowerCase();
-        if (p && path52.substr(-p.length).toLowerCase() === p) {
+        if (p && path53.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path52, options) {
+    function checkStat(stat, path53, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path52, options);
+      return checkPathExt(path53, options);
     }
-    function isexe(path52, options, cb) {
-      fs2.stat(path52, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path52, options));
+    function isexe(path53, options, cb) {
+      fs2.stat(path53, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path53, options));
       });
     }
-    function sync(path52, options) {
-      return checkStat(fs2.statSync(path52), path52, options);
+    function sync(path53, options) {
+      return checkStat(fs2.statSync(path53), path53, options);
     }
   }
 });
@@ -136,13 +136,13 @@ var require_mode = __commonJS({
     module.exports = isexe;
     isexe.sync = sync;
     var fs2 = __require("fs");
-    function isexe(path52, options, cb) {
-      fs2.stat(path52, function(er, stat) {
+    function isexe(path53, options, cb) {
+      fs2.stat(path53, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path52, options) {
-      return checkStat(fs2.statSync(path52), options);
+    function sync(path53, options) {
+      return checkStat(fs2.statSync(path53), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -176,7 +176,7 @@ var require_isexe = __commonJS({
     }
     module.exports = isexe;
     isexe.sync = sync;
-    function isexe(path52, options, cb) {
+    function isexe(path53, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -186,7 +186,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve, reject) {
-          isexe(path52, options || {}, function(er, is) {
+          isexe(path53, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -195,7 +195,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path52, options || {}, function(er, is) {
+      core(path53, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -205,9 +205,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path52, options) {
+    function sync(path53, options) {
       try {
-        return core.sync(path52, options || {});
+        return core.sync(path53, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -224,7 +224,7 @@ var require_which = __commonJS({
   "node_modules/which/which.js"(exports, module) {
     "use strict";
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path52 = __require("path");
+    var path53 = __require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -262,7 +262,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i3];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path52.join(pathPart, cmd);
+        const pCmd = path53.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve(subStep(p, i3, 0));
       });
@@ -289,7 +289,7 @@ var require_which = __commonJS({
       for (let i3 = 0; i3 < pathEnv.length; i3++) {
         const ppRaw = pathEnv[i3];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path52.join(pathPart, cmd);
+        const pCmd = path53.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         for (let j = 0; j < pathExt.length; j++) {
           const cur = p + pathExt[j];
@@ -337,7 +337,7 @@ var require_path_key = __commonJS({
 var require_resolveCommand = __commonJS({
   "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
     "use strict";
-    var path52 = __require("path");
+    var path53 = __require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -355,7 +355,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path52.delimiter : void 0
+          pathExt: withoutPathExt ? path53.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -364,7 +364,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path52.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path53.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -418,8 +418,8 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path52, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path52.split("/").pop();
+      const [path53, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path53.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -454,7 +454,7 @@ var require_readShebang = __commonJS({
 var require_parse = __commonJS({
   "node_modules/cross-spawn/lib/parse.js"(exports, module) {
     "use strict";
-    var path52 = __require("path");
+    var path53 = __require("path");
     var resolveCommand2 = require_resolveCommand();
     var escape = require_escape();
     var readShebang = require_readShebang();
@@ -479,7 +479,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path52.normalize(parsed.command);
+        parsed.command = path53.normalize(parsed.command);
         parsed.command = escape.command(parsed.command);
         parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -7069,13 +7069,13 @@ var logOutputSync = ({ serializedResult, fdNumber, state, verboseInfo, encoding,
   }
 };
 var writeToFiles = (serializedResult, stdioItems, outputFiles) => {
-  for (const { path: path52, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
-    const pathString = typeof path52 === "string" ? path52 : path52.toString();
+  for (const { path: path53, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
+    const pathString = typeof path53 === "string" ? path53 : path53.toString();
     if (append || outputFiles.has(pathString)) {
-      appendFileSync2(path52, serializedResult);
+      appendFileSync2(path53, serializedResult);
     } else {
       outputFiles.add(pathString);
-      writeFileSync2(path52, serializedResult);
+      writeFileSync2(path53, serializedResult);
     }
   }
 };
@@ -10380,7 +10380,7 @@ function isNonInteractive(cli) {
   return cli.all || (cli.only?.length ?? 0) > 0 || cli.retryFailed;
 }
 var COMMAND_USAGE = {
-  install: "\ninstall <forjas> \u2014 git clone + setup (default) ou PyPI+venv (--method registry).\n  --plan s\xF3 mostra o plano; --ref/--version fixa UMA Forja; --all/--only selecionam.",
+  install: "\ninstall <forjas> \u2014 PyPI+venv (default) ou git clone + setup (--method git).\n  --plan s\xF3 mostra o plano; --ref/--version fixa UMA Forja; --all/--only selecionam.",
   update: "\nupdate [forjas] \u2014 pull + setup. --check s\xF3 verifica; --method registry usa o receipt.\n  Sem nomes no interativo: oferece as Forjas presentes; --yes exige sele\xE7\xE3o.",
   registry: "\nregistry [list|install|lock] \u2014 cat\xE1logo PyPI + receipts.\n  registry install <f> --offline --lock <arquivo>: instala\xE7\xE3o travada (--no-index).\n  registry lock <f> [--out <arq|dir>]: gera <forja>.offline-lock.json (online, pip>=23).",
   mcp: "\nmcp [forja\u2026] \u2014 argv MCP por Forja (clone ou venv registry).\n  --verify: handshake real \u2014 n\xEDveis INSTALLED\u2192EXECUTABLE\u2192INITIALIZED\u2192\n  TOOLS_DISCOVERED\u2192SAFE_TOOL_CALLED\u2192HOST_VERIFIED. tools/call s\xF3 na allowlist do cat\xE1logo.",
@@ -14528,26 +14528,26 @@ var ContractValidator = class {
     }
     return this.validate(declared, document);
   }
-  check(value, schema, path52, errs) {
+  check(value, schema, path53, errs) {
     if (typeof schema.$ref === "string") {
       const target = schema.$ref;
       if (!target.startsWith("forge/")) {
-        errs.push({ code: "CONTRACT-REF", message: `external ref refused: ${target}`, path: path52 });
+        errs.push({ code: "CONTRACT-REF", message: `external ref refused: ${target}`, path: path53 });
         return;
       }
       const resolved = this.schemas[target];
       if (!resolved) {
-        errs.push({ code: "CONTRACT-UNKNOWN", message: `unknown contract: ${target}`, path: path52 });
+        errs.push({ code: "CONTRACT-UNKNOWN", message: `unknown contract: ${target}`, path: path53 });
         return;
       }
-      this.check(value, resolved, path52, errs);
+      this.check(value, resolved, path53, errs);
       return;
     }
     if ("const" in schema && value !== schema.const) {
       errs.push({
         code: "CONTRACT-CONST",
         message: `expected ${JSON.stringify(schema.const)}`,
-        path: path52
+        path: path53
       });
       return;
     }
@@ -14555,7 +14555,7 @@ var ContractValidator = class {
       errs.push({
         code: "CONTRACT-TYPE",
         message: `expected type ${JSON.stringify(schema.type)}`,
-        path: path52
+        path: path53
       });
       return;
     }
@@ -14563,27 +14563,27 @@ var ContractValidator = class {
       errs.push({
         code: "CONTRACT-ENUM",
         message: `value not in ${JSON.stringify(schema.enum)}`,
-        path: path52
+        path: path53
       });
       return;
     }
     if (typeof value === "string") {
       if (typeof schema.pattern === "string" && !new RegExp(schema.pattern).test(value)) {
-        errs.push({ code: "CONTRACT-PATTERN", message: `does not match ${schema.pattern}`, path: path52 });
+        errs.push({ code: "CONTRACT-PATTERN", message: `does not match ${schema.pattern}`, path: path53 });
       }
       if (typeof schema.minLength === "number" && value.length < schema.minLength) {
-        errs.push({ code: "CONTRACT-LENGTH", message: "string too short", path: path52 });
+        errs.push({ code: "CONTRACT-LENGTH", message: "string too short", path: path53 });
       }
       if (typeof schema.maxLength === "number" && value.length > schema.maxLength) {
-        errs.push({ code: "CONTRACT-LENGTH", message: "string too long", path: path52 });
+        errs.push({ code: "CONTRACT-LENGTH", message: "string too long", path: path53 });
       }
     }
     if (typeof value === "number") {
       if (typeof schema.min === "number" && value < schema.min) {
-        errs.push({ code: "CONTRACT-RANGE", message: `< ${schema.min}`, path: path52 });
+        errs.push({ code: "CONTRACT-RANGE", message: `< ${schema.min}`, path: path53 });
       }
       if (typeof schema.max === "number" && value > schema.max) {
-        errs.push({ code: "CONTRACT-RANGE", message: `> ${schema.max}`, path: path52 });
+        errs.push({ code: "CONTRACT-RANGE", message: `> ${schema.max}`, path: path53 });
       }
     }
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
@@ -14593,7 +14593,7 @@ var ContractValidator = class {
           errs.push({
             code: "CONTRACT-REQUIRED",
             message: `missing '${req}'`,
-            path: `${path52}/${req}`
+            path: `${path53}/${req}`
           });
         }
       }
@@ -14601,25 +14601,25 @@ var ContractValidator = class {
       const additional = schema.additionalProperties;
       for (const [key, val] of Object.entries(obj)) {
         if (key in props) {
-          this.check(val, props[key], `${path52}/${key}`, errs);
+          this.check(val, props[key], `${path53}/${key}`, errs);
         } else if (additional === false) {
           errs.push({
             code: "CONTRACT-UNKNOWN-FIELD",
             message: `unexpected '${key}'`,
-            path: `${path52}/${key}`
+            path: `${path53}/${key}`
           });
         } else if (typeof additional === "object" && additional !== null) {
-          this.check(val, additional, `${path52}/${key}`, errs);
+          this.check(val, additional, `${path53}/${key}`, errs);
         }
       }
     }
     if (Array.isArray(value)) {
       if (typeof schema.minItems === "number" && value.length < schema.minItems) {
-        errs.push({ code: "CONTRACT-SIZE", message: "too few items", path: path52 });
+        errs.push({ code: "CONTRACT-SIZE", message: "too few items", path: path53 });
       }
       const itemSchema = schema.items;
       if (typeof itemSchema === "object" && itemSchema !== null) {
-        value.forEach((item, i3) => this.check(item, itemSchema, `${path52}/${i3}`, errs));
+        value.forEach((item, i3) => this.check(item, itemSchema, `${path53}/${i3}`, errs));
       }
     }
   }
@@ -15609,22 +15609,22 @@ async function uninstall(opts = {}) {
 }
 
 // src/cmd/query.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 
 // src/registry/install.ts
 import { createHash as createHash2 } from "crypto";
 import {
-  chmodSync as chmodSync2,
-  existsSync as existsSync12,
-  mkdirSync as mkdirSync4,
+  chmodSync as chmodSync3,
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync6,
   readFileSync as readFileSync11,
   renameSync as renameSync2,
-  rmSync as rmSync3,
+  rmSync as rmSync4,
   statSync as statSync3,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
-import path20 from "path";
+import path21 from "path";
 
 // src/registry/lock.ts
 import { createHash } from "crypto";
@@ -15919,9 +15919,58 @@ async function lockTransitiveCheck(lock, wheels, run, pythonExe) {
   return null;
 }
 
-// src/registry/pypi.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync10 } from "fs";
+// src/registry/shims.ts
+import { chmodSync as chmodSync2, existsSync as existsSync12, mkdirSync as mkdirSync3, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
 import path19 from "path";
+function shimsDir(home) {
+  return path19.join(home, ".forge-cli", "bin");
+}
+function shimName(bin, platform2) {
+  const base = path19.basename(bin).replace(/\.(exe|cmd|bat)$/i, "");
+  return platform2 === "win32" ? `${base}.cmd` : base;
+}
+function shQuote(bin) {
+  if (bin.includes("\n") || bin.includes("\r")) {
+    throw new Error(`bin com newline n\xE3o pode virar shim: ${JSON.stringify(bin)}`);
+  }
+  return bin.replace(/(["\\$`])/g, "\\$1");
+}
+function emitForgeShim(home, bin, platform2) {
+  const dir = shimsDir(home);
+  const target = resolveInside(dir, shimName(bin, platform2));
+  if (!target || !isSafeRepoName(path19.basename(target).replace(/\.cmd$/i, ""))) {
+    throw new Error(`nome de shim inseguro: ${path19.basename(bin)}`);
+  }
+  mkdirSync3(dir, { recursive: true });
+  if (platform2 === "win32") {
+    if (bin.includes('"') || bin.includes("\n") || bin.includes("\r")) {
+      throw new Error(`bin n\xE3o express\xE1vel em .cmd: ${JSON.stringify(bin)}`);
+    }
+    writeFileSync4(target, `@echo off\r
+"${bin}" %*\r
+`, "utf8");
+  } else {
+    writeFileSync4(target, `#!/bin/sh
+exec "${shQuote(bin)}" "$@"
+`, {
+      encoding: "utf8",
+      mode: 493
+    });
+    chmodSync2(target, 493);
+  }
+  return target;
+}
+function removeForgeShim(home, bin, platform2) {
+  if (!bin) return false;
+  const target = resolveInside(shimsDir(home), shimName(bin, platform2));
+  if (!target || !existsSync12(target)) return false;
+  rmSync3(target, { force: true });
+  return true;
+}
+
+// src/registry/pypi.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync10 } from "fs";
+import path20 from "path";
 
 // src/registry/versions.ts
 var VERSION_RE = /^(\d+(?:\.\d+)*)(?:(a|b|rc)(\d+))?(?:\.post(\d+))?(?:\.dev(\d+))?$/i;
@@ -16051,7 +16100,7 @@ function latestStable(versions) {
 var PYPI_JSON = "https://pypi.org/pypi";
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 function pypiCacheFile(cacheDir, dist) {
-  return path19.join(cacheDir, `${dist}.json`);
+  return path20.join(cacheDir, `${dist}.json`);
 }
 function asString(v) {
   return typeof v === "string" && v.length ? v : void 0;
@@ -16090,7 +16139,7 @@ function readCache(cacheDir, dist) {
 }
 function writeCache(cacheDir, dist, payload) {
   try {
-    mkdirSync3(cacheDir, { recursive: true });
+    mkdirSync4(cacheDir, { recursive: true });
     writeFileAtomic(
       pypiCacheFile(cacheDir, dist),
       JSON.stringify({ fetchedAt: Date.now(), payload })
@@ -16247,20 +16296,20 @@ async function resolveRelease(dist, opts) {
 
 // src/registry/install.ts
 function forgesRoot(home) {
-  return path20.join(home, ".forge-cli", "forges");
+  return path21.join(home, ".forge-cli", "forges");
 }
 function forgeStatePath(home) {
-  return path20.join(forgesRoot(home), "state.json");
+  return path21.join(forgesRoot(home), "state.json");
 }
 function forgeVenv(home, name) {
-  return path20.join(forgesRoot(home), name, "venv");
+  return path21.join(forgesRoot(home), name, "venv");
 }
 function receiptPath(home, name) {
-  return path20.join(forgesRoot(home), name, "install.json");
+  return path21.join(forgesRoot(home), name, "install.json");
 }
 function loadForgeState(home) {
   const file = forgeStatePath(home);
-  if (!existsSync12(file)) return { forges: {} };
+  if (!existsSync13(file)) return { forges: {} };
   try {
     const raw = JSON.parse(readFileSync11(file, "utf8"));
     if (typeof raw.forges !== "object" || !raw.forges || Array.isArray(raw.forges)) {
@@ -16279,7 +16328,7 @@ function ghostEntry(name, receipt) {
   return {
     name,
     dist: receipt.dist,
-    bin: path20.basename(receipt.bin).replace(/\.exe$/i, ""),
+    bin: path21.basename(receipt.bin).replace(/\.exe$/i, ""),
     minPython: receipt.python.split(".").slice(0, 2).join("."),
     origin: "official",
     // Extras instalados junto — reinstall/update/rollback do ghost pedem o
@@ -16288,22 +16337,22 @@ function ghostEntry(name, receipt) {
   };
 }
 function quarantineCorruptState(file) {
-  if (!existsSync12(file)) return;
+  if (!existsSync13(file)) return;
   try {
     JSON.parse(readFileSync11(file, "utf8"));
   } catch {
     try {
-      writeFileSync4(`${file}.corrupt`, readFileSync11(file), { flag: "wx" });
+      writeFileSync5(`${file}.corrupt`, readFileSync11(file), { flag: "wx" });
     } catch {
     }
   }
 }
 function saveForgeState(home, state) {
-  mkdirSync4(forgesRoot(home), { recursive: true });
+  mkdirSync5(forgesRoot(home), { recursive: true });
   if (process.platform !== "win32") {
     try {
-      chmodSync2(forgesRoot(home), 448);
-      chmodSync2(path20.dirname(forgesRoot(home)), 448);
+      chmodSync3(forgesRoot(home), 448);
+      chmodSync3(path21.dirname(forgesRoot(home)), 448);
     } catch {
     }
   }
@@ -16313,7 +16362,7 @@ function saveForgeState(home, state) {
 `);
 }
 function wheelCacheDir(cacheDir, dist) {
-  return path20.join(path20.dirname(cacheDir), "wheels", dist);
+  return path21.join(path21.dirname(cacheDir), "wheels", dist);
 }
 function entryExtras(entry2) {
   return [...new Set(entry2.extras ?? [])].sort();
@@ -16326,13 +16375,13 @@ function pipSpec(entry2, version) {
   return `${entry2.dist}${extrasSuffix(entry2)}==${version}`;
 }
 function venvBin(venvDir, platform2 = process.platform) {
-  return platform2 === "win32" ? path20.join(venvDir, "Scripts") : path20.join(venvDir, "bin");
+  return platform2 === "win32" ? path21.join(venvDir, "Scripts") : path21.join(venvDir, "bin");
 }
 function venvPython(venvDir, platform2 = process.platform) {
-  return path20.join(venvBin(venvDir, platform2), platform2 === "win32" ? "python.exe" : "python");
+  return path21.join(venvBin(venvDir, platform2), platform2 === "win32" ? "python.exe" : "python");
 }
 function forgeLockDir(home) {
-  return path20.join(forgesRoot(home), ".forge-lifecycle.lock");
+  return path21.join(forgesRoot(home), ".forge-lifecycle.lock");
 }
 function pidAliveDefault(pid) {
   try {
@@ -16349,12 +16398,12 @@ async function acquireForgeLock(home, opts = {}) {
   const now = opts.now ?? Date.now;
   const alive = opts.pidAlive ?? pidAliveDefault;
   const dir = forgeLockDir(home);
-  const info = path20.join(dir, "info.json");
+  const info = path21.join(dir, "info.json");
   const deadline = now() + timeoutMs;
   for (; ; ) {
     try {
-      mkdirSync4(forgesRoot(home), { recursive: true });
-      mkdirSync4(dir);
+      mkdirSync5(forgesRoot(home), { recursive: true });
+      mkdirSync5(dir);
     } catch (error) {
       if (error.code !== "EEXIST") {
         return { ok: false, reason: "error", detail: `lifecycle lock: ${String(error)}` };
@@ -16375,7 +16424,7 @@ async function acquireForgeLock(home, opts = {}) {
       })();
       if (stale || broken) {
         try {
-          rmSync3(dir, { recursive: true, force: true });
+          rmSync4(dir, { recursive: true, force: true });
         } catch {
         }
         continue;
@@ -16391,7 +16440,7 @@ async function acquireForgeLock(home, opts = {}) {
       continue;
     }
     try {
-      writeFileSync4(info, JSON.stringify({ pid: process.pid, at: new Date(now()).toISOString() }));
+      writeFileSync5(info, JSON.stringify({ pid: process.pid, at: new Date(now()).toISOString() }));
     } catch {
     }
     return {
@@ -16400,7 +16449,7 @@ async function acquireForgeLock(home, opts = {}) {
         dir,
         release: () => {
           try {
-            rmSync3(dir, { recursive: true, force: true });
+            rmSync4(dir, { recursive: true, force: true });
           } catch {
           }
         }
@@ -16414,7 +16463,7 @@ function installConsistency(home, name) {
   const dir = resolveInside(forgesRoot(home), name);
   const venv = forgeVenv(home, name);
   if (!entry2) {
-    const leftover = dir !== null && existsSync12(dir) || existsSync12(venv);
+    const leftover = dir !== null && existsSync13(dir) || existsSync13(venv);
     return leftover ? {
       ok: false,
       status: "orphaned",
@@ -16422,7 +16471,7 @@ function installConsistency(home, name) {
     } : { ok: false, status: "not-installed", detail: `${name}: n\xE3o instalado via registry` };
   }
   const rfile = receiptPath(home, name);
-  if (!existsSync12(rfile)) {
+  if (!existsSync13(rfile)) {
     return {
       ok: false,
       status: "missing-receipt",
@@ -16455,7 +16504,7 @@ function installConsistency(home, name) {
       detail: `${name}: state=${entry2.version} mas receipt=${receipt.version} \u2014 escrita interrompida no meio; ${REPAIR_HINT}`
     };
   }
-  if (!existsSync12(entry2.venv ?? venv)) {
+  if (!existsSync13(entry2.venv ?? venv)) {
     return {
       ok: false,
       status: "missing-venv",
@@ -16511,16 +16560,16 @@ function selectInterpreter(entry2, resolved, pythons) {
   return { python: candidates[0] };
 }
 function checkDistHashes(distFiles, wheels) {
-  const have = existsSync12(wheels) ? readdirSync6(wheels) : [];
+  const have = existsSync13(wheels) ? readdirSync6(wheels) : [];
   let verifiedHash;
   let verifiedFile;
   for (const f of distFiles) {
     if (!have.includes(f.filename) || !f.sha256) continue;
-    const digest = createHash2("sha256").update(readFileSync11(path20.join(wheels, f.filename))).digest("hex");
+    const digest = createHash2("sha256").update(readFileSync11(path21.join(wheels, f.filename))).digest("hex");
     if (digest !== f.sha256) {
-      const culprit = path20.join(wheels, f.filename);
+      const culprit = path21.join(wheels, f.filename);
       try {
-        rmSync3(`${culprit}.rejected`, { force: true });
+        rmSync4(`${culprit}.rejected`, { force: true });
         renameSync2(culprit, `${culprit}.rejected`);
       } catch {
       }
@@ -16557,7 +16606,7 @@ async function registryInstall(entry2, pin, deps) {
     }
     return { stage: "incomplete", detail: c5.detail };
   };
-  if (!deps.clean && existsSync12(venvDir)) return consistencyGate();
+  if (!deps.clean && existsSync13(venvDir)) return consistencyGate();
   const resolved = await resolveRelease(entry2.dist, {
     pin,
     offline: deps.offline,
@@ -16615,20 +16664,20 @@ async function registryInstall(entry2, pin, deps) {
     return { stage: "busy", detail: `${entry2.name}: ${lockRes.detail}` };
   }
   try {
-    if (!deps.clean && existsSync12(venvDir)) return consistencyGate();
-    const forgeDir = path20.join(forgesRoot(deps.home), entry2.name);
+    if (!deps.clean && existsSync13(venvDir)) return consistencyGate();
+    const forgeDir = path21.join(forgesRoot(deps.home), entry2.name);
     let backupDir = null;
-    if (deps.clean && existsSync12(forgeDir)) {
+    if (deps.clean && existsSync13(forgeDir)) {
       backupDir = `${forgeDir}.restore-${process.pid}`;
       renameSync2(forgeDir, backupDir);
     }
     const cleanup = () => {
-      rmSync3(venvDir, { recursive: true, force: true });
-      if (existsSync12(forgeDir) && !readdirSync6(forgeDir).length) {
-        rmSync3(forgeDir, { recursive: true, force: true });
+      rmSync4(venvDir, { recursive: true, force: true });
+      if (existsSync13(forgeDir) && !readdirSync6(forgeDir).length) {
+        rmSync4(forgeDir, { recursive: true, force: true });
       }
       if (backupDir) {
-        rmSync3(forgeDir, { recursive: true, force: true });
+        rmSync4(forgeDir, { recursive: true, force: true });
         renameSync2(backupDir, forgeDir);
         backupDir = null;
       }
@@ -16643,7 +16692,7 @@ async function registryInstall(entry2, pin, deps) {
     }
     const vpy = venvPython(venvDir, platform2);
     const spec = pipSpec(entry2, resolved.version);
-    mkdirSync4(wheels, { recursive: true });
+    mkdirSync5(wheels, { recursive: true });
     const distFiles = distArtifactFiles(resolved.files, entry2.dist);
     let verifiedHash;
     let verifiedFile;
@@ -16671,7 +16720,7 @@ async function registryInstall(entry2, pin, deps) {
         return { stage: "lock", error: depErr };
       }
     } else if (deps.offline) {
-      const have = existsSync12(wheels) ? readdirSync6(wheels) : [];
+      const have = existsSync13(wheels) ? readdirSync6(wheels) : [];
       if (!distFiles.length || !distFiles.some((f) => have.includes(f.filename))) {
         cleanup();
         return {
@@ -16739,11 +16788,11 @@ async function registryInstall(entry2, pin, deps) {
       ...lock ? (
         // Lock já enumera o fecho inteiro — inclusive as deps dos extras
         // declarados — então os artefatos entram por caminho puro.
-        lock.artifacts.map((a3) => path20.join(wheels, a3.filename))
+        lock.artifacts.map((a3) => path21.join(wheels, a3.filename))
       ) : (
         // `[extras]` no caminho do artefato: pip instala a wheel verificada
         // E resolve as deps do extra no índice/--find-links (PEP 508).
-        [`${path20.join(wheels, verifiedFile)}${extrasSuffix(entry2)}`]
+        [`${path21.join(wheels, verifiedFile)}${extrasSuffix(entry2)}`]
       )
     ];
     const pip = await run(vpy, pipArgs);
@@ -16756,7 +16805,7 @@ async function registryInstall(entry2, pin, deps) {
     }
     const commitBackup = backupDir;
     backupDir = null;
-    const binPath = path20.join(
+    const binPath = path21.join(
       venvBin(venvDir, platform2),
       platform2 === "win32" ? `${entry2.bin}.exe` : entry2.bin
     );
@@ -16793,15 +16842,24 @@ async function registryInstall(entry2, pin, deps) {
     };
     deps.receiptPatch?.(receipt);
     try {
-      mkdirSync4(path20.dirname(receiptPath(deps.home, entry2.name)), { recursive: true });
+      mkdirSync5(path21.dirname(receiptPath(deps.home, entry2.name)), { recursive: true });
       writeFileAtomic(receiptPath(deps.home, entry2.name), `${JSON.stringify(receipt, null, 2)}
 `);
       const state = loadForgeState(deps.home);
       state.forges[entry2.name] = receipt;
       saveForgeState(deps.home, state);
+      try {
+        receipt.shim = emitForgeShim(deps.home, binPath, platform2);
+      } catch (shimError) {
+        receipt.shimRefused = shimError instanceof Error ? shimError.message : String(shimError);
+      }
+      writeFileAtomic(receiptPath(deps.home, entry2.name), `${JSON.stringify(receipt, null, 2)}
+`);
+      state.forges[entry2.name] = receipt;
+      saveForgeState(deps.home, state);
     } catch (error) {
       if (commitBackup) {
-        rmSync3(forgeDir, { recursive: true, force: true });
+        rmSync4(forgeDir, { recursive: true, force: true });
         try {
           renameSync2(commitBackup, forgeDir);
         } catch {
@@ -16814,7 +16872,7 @@ async function registryInstall(entry2, pin, deps) {
         detail: `${entry2.name}: pip instalou mas o receipt/state falhou (${why}) \u2014 instala\xE7\xE3o INCOMPLETA (${consistency.status}): ${consistency.detail || "reexecute install"}`
       };
     }
-    if (commitBackup) rmSync3(commitBackup, { recursive: true, force: true });
+    if (commitBackup) rmSync4(commitBackup, { recursive: true, force: true });
     if (verify.exitCode !== 0) {
       return { stage: "verify", detail: `${entry2.bin} --help saiu com c\xF3digo ${verify.exitCode}` };
     }
@@ -16827,22 +16885,27 @@ function registryUninstall(target, deps) {
   const dir = resolveInside(forgesRoot(deps.home), target.name);
   if (!dir)
     return { removed: false, receiptRemoved: false, cacheRemoved: false, refused: "unsafe-name" };
-  const removed = existsSync12(dir);
-  if (removed) rmSync3(dir, { recursive: true, force: true });
-  const wheels = target.dist && isSafeRepoName(target.dist) ? resolveInside(path20.join(deps.home, ".forge-cli", "cache", "wheels"), target.dist) : null;
-  const cacheRemoved = wheels !== null && existsSync12(wheels);
-  if (wheels) rmSync3(wheels, { recursive: true, force: true });
+  const removed = existsSync13(dir);
+  if (removed) rmSync4(dir, { recursive: true, force: true });
+  const wheels = target.dist && isSafeRepoName(target.dist) ? resolveInside(path21.join(deps.home, ".forge-cli", "cache", "wheels"), target.dist) : null;
+  const cacheRemoved = wheels !== null && existsSync13(wheels);
+  if (wheels) rmSync4(wheels, { recursive: true, force: true });
   const state = loadForgeState(deps.home);
   const hadReceipt = Object.hasOwn(state.forges, target.name);
+  const shimRemoved = removeForgeShim(
+    deps.home,
+    hadReceipt ? state.forges[target.name].shim ?? state.forges[target.name].bin : void 0,
+    deps.platform ?? process.platform
+  );
   if (hadReceipt) delete state.forges[target.name];
   saveForgeState(deps.home, state);
-  return { removed, receiptRemoved: hadReceipt, cacheRemoved };
+  return { removed, receiptRemoved: hadReceipt, cacheRemoved, shimRemoved };
 }
 
 // src/compat.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync13, readFileSync as readFileSync12 } from "fs";
-import path21 from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
+import path22 from "path";
 var ECOSYSTEM_SCHEMA = "forge/EcosystemCompatibility/v1";
 function isRecord(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -16929,7 +16992,7 @@ function manifestProblems(doc) {
   return problems;
 }
 function loadCompatManifest(manifestPath) {
-  if (!existsSync13(manifestPath)) return null;
+  if (!existsSync14(manifestPath)) return null;
   let raw;
   try {
     raw = readFileSync12(manifestPath, "utf-8");
@@ -16954,7 +17017,7 @@ function loadCompatManifest(manifestPath) {
   };
 }
 function defaultManifestPath(workspaceDir) {
-  return path21.join(workspaceDir, "the-forge", "ecosystem-compatibility.json");
+  return path22.join(workspaceDir, "the-forge", "ecosystem-compatibility.json");
 }
 function compatVerdict(manifest, component, version) {
   const entry2 = manifest.components.find((c5) => c5.component === component);
@@ -16962,8 +17025,8 @@ function compatVerdict(manifest, component, version) {
   return entry2.version === version ? "certified" : "incompatible";
 }
 function readDeclaredVersion(repoDir) {
-  const pkg = path21.join(repoDir, "package.json");
-  if (existsSync13(pkg)) {
+  const pkg = path22.join(repoDir, "package.json");
+  if (existsSync14(pkg)) {
     try {
       const parsed = JSON.parse(readFileSync12(pkg, "utf-8"));
       if (isRecord(parsed) && typeof parsed.version === "string" && parsed.version) {
@@ -16972,8 +17035,8 @@ function readDeclaredVersion(repoDir) {
     } catch {
     }
   }
-  const pyproject = path21.join(repoDir, "pyproject.toml");
-  if (existsSync13(pyproject)) {
+  const pyproject = path22.join(repoDir, "pyproject.toml");
+  if (existsSync14(pyproject)) {
     try {
       const table = /^\[project\][^\n]*\n((?:(?!\[)[^\n]*(?:\n|$))*)/m.exec(
         readFileSync12(pyproject, "utf-8")
@@ -17015,7 +17078,7 @@ function mergeRegistryPhase(infos, registry) {
     const reg = Object.hasOwn(registry, i3.name) ? registry[i3.name] : void 0;
     if (!reg || typeof reg !== "object") continue;
     const tag2 = `pypi ${reg.dist ?? "?"}==${reg.version ?? "?"}`;
-    const binMissing = typeof reg.bin !== "string" || !existsSync14(reg.bin);
+    const binMissing = typeof reg.bin !== "string" || !existsSync15(reg.bin);
     if (binMissing) {
       if (i3.phase === "not-installed" || i3.phase === "installed") i3.phase = "drifted";
       i3.describe = [i3.describe, `${tag2} (bin ausente)`].filter(Boolean).join(" + ");
@@ -17154,15 +17217,15 @@ async function runVersionsCommand(cli, names) {
 
 // src/doctor2/index.ts
 import os4 from "os";
-import path32 from "path";
+import path33 from "path";
 
 // src/hosts/claude.ts
-import path23 from "path";
+import path24 from "path";
 
 // src/hosts/types.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync13, readdirSync as readdirSync7, rmSync as rmSync4 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync13, readdirSync as readdirSync7, rmSync as rmSync5 } from "fs";
 import os2 from "os";
-import path22 from "path";
+import path23 from "path";
 var defaultProbe = {
   output: (command, args) => commandOutput(command, args),
   detailed: async (command, args) => {
@@ -17181,7 +17244,7 @@ function parseVersionOutput(out) {
   return first && first !== "ok" ? first : null;
 }
 function existingConfigPaths(home, rels) {
-  return rels.map((rel2) => path22.join(home, rel2)).filter((p) => existsSync15(p));
+  return rels.map((rel2) => path23.join(home, rel2)).filter((p) => existsSync16(p));
 }
 async function detectHost(home, spec) {
   const runProbe = async (argv) => spec.probe.detailed ? spec.probe.detailed(argv[0], argv.slice(1)) : { out: await spec.probe.output(argv[0], argv.slice(1)), timedOut: false };
@@ -17237,7 +17300,7 @@ async function detectHost(home, spec) {
   };
 }
 function readJsonObject(file) {
-  if (!existsSync15(file)) return null;
+  if (!existsSync16(file)) return null;
   try {
     const parsed = JSON.parse(readFileSync13(file, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : "invalid";
@@ -17275,22 +17338,22 @@ function backupTimestamp(d = /* @__PURE__ */ new Date()) {
   return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}${p(d.getMilliseconds(), 3)}`;
 }
 function backupsRoot(home) {
-  return path22.join(artifactsRoot(home), "backups");
+  return path23.join(artifactsRoot(home), "backups");
 }
 function backupDirFor(home, hostId) {
-  return path22.join(backupsRoot(home), `hosts-${hostId}-${backupTimestamp()}`);
+  return path23.join(backupsRoot(home), `hosts-${hostId}-${backupTimestamp()}`);
 }
 function backupTargets(dir, hostId, targets) {
-  mkdirSync5(dir, { recursive: true });
+  mkdirSync6(dir, { recursive: true });
   const files = targets.map((target) => {
-    const name = path22.basename(target);
-    const absent = !existsSync15(target);
-    if (absent) writeFileAtomic(path22.join(dir, `${name}.absent`), "");
-    else copyFileSync2(target, path22.join(dir, name));
+    const name = path23.basename(target);
+    const absent = !existsSync16(target);
+    if (absent) writeFileAtomic(path23.join(dir, `${name}.absent`), "");
+    else copyFileSync2(target, path23.join(dir, name));
     return { backup: name, target, absent };
   });
   writeFileAtomic(
-    path22.join(dir, "manifest.json"),
+    path23.join(dir, "manifest.json"),
     `${JSON.stringify({ host: hostId, files }, null, 2)}
 `
   );
@@ -17303,18 +17366,18 @@ function latestBackupDir(home, hostId) {
     return null;
   }
   const hit = names.filter((n4) => n4.startsWith(`hosts-${hostId}-`)).sort().reverse()[0];
-  return hit ? path22.join(backupsRoot(home), hit) : null;
+  return hit ? path23.join(backupsRoot(home), hit) : null;
 }
 function restoreBackupDir(dir) {
-  const manifest = JSON.parse(readFileSync13(path22.join(dir, "manifest.json"), "utf8"));
+  const manifest = JSON.parse(readFileSync13(path23.join(dir, "manifest.json"), "utf8"));
   const restored = [];
   const removed = [];
   for (const entry2 of manifest.files ?? []) {
     if (entry2.absent) {
-      rmSync4(entry2.target, { force: true });
+      rmSync5(entry2.target, { force: true });
       removed.push(entry2.target);
     } else {
-      writeFileAtomic(entry2.target, readFileSync13(path22.join(dir, entry2.backup), "utf8"));
+      writeFileAtomic(entry2.target, readFileSync13(path23.join(dir, entry2.backup), "utf8"));
       restored.push(entry2.target);
     }
   }
@@ -17363,7 +17426,7 @@ async function applyHostPlan(home, plan, resolveWrite, opts = {}) {
   );
   for (const w of writes) {
     try {
-      mkdirSync5(path22.dirname(w.target), { recursive: true });
+      mkdirSync6(path23.dirname(w.target), { recursive: true });
       writeFileAtomic(w.target, w.content);
       applied.push(w.target);
     } catch (error) {
@@ -17410,9 +17473,9 @@ async function rollbackHostPlan(home, plan, backup) {
 
 // src/hosts/claude.ts
 var CONFIG_FILE = ".claude.json";
-var CONFIG_REL = [CONFIG_FILE, ".claude", path23.join(".claude", "settings.json")];
+var CONFIG_REL = [CONFIG_FILE, ".claude", path24.join(".claude", "settings.json")];
 function targetFor(home) {
-  return path23.join(home, CONFIG_FILE);
+  return path24.join(home, CONFIG_FILE);
 }
 function createClaudeAdapter(probe = defaultProbe) {
   return {
@@ -17480,12 +17543,12 @@ function createClaudeAdapter(probe = defaultProbe) {
 var claudeAdapter = createClaudeAdapter();
 
 // src/hosts/codex.ts
-import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
-import path24 from "path";
-var CONFIG_FILE2 = path24.join(".codex", "config.toml");
+import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
+import path25 from "path";
+var CONFIG_FILE2 = path25.join(".codex", "config.toml");
 var CONFIG_REL2 = [CONFIG_FILE2, ".codex"];
 function targetFor2(home) {
-  return path24.join(home, CONFIG_FILE2);
+  return path25.join(home, CONFIG_FILE2);
 }
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -17551,7 +17614,7 @@ function createCodexAdapter(probe = defaultProbe) {
         authArgv: ["codex", "login", "status"],
         hasIntegration: (dir) => {
           const file = targetFor2(dir);
-          return existsSync16(file) && hasAnyCodexMcpSection(readFileSync14(file, "utf8"));
+          return existsSync17(file) && hasAnyCodexMcpSection(readFileSync14(file, "utf8"));
         }
       });
     },
@@ -17560,7 +17623,7 @@ function createCodexAdapter(probe = defaultProbe) {
       if (!argv?.length) return null;
       const h3 = hostHome(home);
       const target = targetFor2(h3);
-      const existing = existsSync16(target) ? readFileSync14(target, "utf8") : null;
+      const existing = existsSync17(target) ? readFileSync14(target, "utf8") : null;
       if (existing !== null && hasCodexMcpSection(existing, forge.forge_id)) {
         return {
           host: "codex",
@@ -17591,7 +17654,7 @@ function createCodexAdapter(probe = defaultProbe) {
       plan,
       (action) => {
         if (!action.target || !action.argv?.length) return "skip";
-        const existing = existsSync16(action.target) ? readFileSync14(action.target, "utf8") : null;
+        const existing = existsSync17(action.target) ? readFileSync14(action.target, "utf8") : null;
         if (existing !== null && hasCodexMcpSection(existing, plan.forge_id)) {
           return "duplicate";
         }
@@ -17608,7 +17671,7 @@ ${block2}
     validateIntegration: async (forge_id, home) => {
       const file = targetFor2(hostHome(home));
       const checks = [];
-      if (!existsSync16(file)) {
+      if (!existsSync17(file)) {
         checks.push({ id: "config-file", result: "fail", detail: "absent" });
         checks.push({ id: "mcp-section", result: "fail", detail: forge_id });
         return { ok: false, checks };
@@ -17635,12 +17698,12 @@ ${block2}
 var codexAdapter = createCodexAdapter();
 
 // src/hosts/copilot.ts
-import path25 from "path";
-import { existsSync as existsSync17 } from "fs";
-var CONFIG_FILE3 = path25.join(".copilot", "mcp-config.json");
-var CONFIG_REL3 = [".copilot", CONFIG_FILE3, path25.join(".config", "gh")];
+import path26 from "path";
+import { existsSync as existsSync18 } from "fs";
+var CONFIG_FILE3 = path26.join(".copilot", "mcp-config.json");
+var CONFIG_REL3 = [".copilot", CONFIG_FILE3, path26.join(".config", "gh")];
 function targetFor3(home) {
-  return path25.join(home, CONFIG_FILE3);
+  return path26.join(home, CONFIG_FILE3);
 }
 function createCopilotAdapter(probe = defaultProbe) {
   return {
@@ -17664,7 +17727,7 @@ function createCopilotAdapter(probe = defaultProbe) {
       if (!argv?.length) return null;
       const h3 = hostHome(home);
       const target = targetFor3(h3);
-      if (!existsSync17(target)) return null;
+      if (!existsSync18(target)) return null;
       if (hasMcpEntry(target, forge.forge_id)) {
         return {
           host: "copilot",
@@ -17710,11 +17773,11 @@ function createCopilotAdapter(probe = defaultProbe) {
 var copilotAdapter = createCopilotAdapter();
 
 // src/hosts/cursor.ts
-import path26 from "path";
-var CONFIG_FILE4 = path26.join(".cursor", "mcp.json");
+import path27 from "path";
+var CONFIG_FILE4 = path27.join(".cursor", "mcp.json");
 var CONFIG_REL4 = [CONFIG_FILE4, ".cursor"];
 function targetFor4(home) {
-  return path26.join(home, CONFIG_FILE4);
+  return path27.join(home, CONFIG_FILE4);
 }
 function createCursorAdapter(probe = defaultProbe) {
   return {
@@ -17780,8 +17843,8 @@ function createCursorAdapter(probe = defaultProbe) {
 var cursorAdapter = createCursorAdapter();
 
 // src/hosts/devin.ts
-import path27 from "path";
-var CONFIG_REL5 = [".devin", path27.join(".config", "devin")];
+import path28 from "path";
+var CONFIG_REL5 = [".devin", path28.join(".config", "devin")];
 function createDevinAdapter(probe = defaultProbe) {
   return {
     id: "devin",
@@ -17862,13 +17925,13 @@ function errMsg(error) {
 }
 
 // src/doctor2/domains.ts
-import { existsSync as existsSync21, readdirSync as readdirSync10, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync22, readdirSync as readdirSync10, rmSync as rmSync6, statSync as statSync4, writeFileSync as writeFileSync6 } from "fs";
 import os3 from "os";
-import path31 from "path";
+import path32 from "path";
 
 // src/envintel/validate.ts
-import { existsSync as existsSync19, readFileSync as readFileSync17 } from "fs";
-import path29 from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync17 } from "fs";
+import path30 from "path";
 
 // src/envintel/parse.ts
 var ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -17957,8 +18020,8 @@ function formatEntry(key, value) {
 }
 
 // src/envintel/schema.ts
-import { existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
-import path28 from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync16 } from "fs";
+import path29 from "path";
 var SECRET_RE = /KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL/;
 var KIND_RULES = [
   { kind: "port", re: /(^|_)PORT($|_)/ },
@@ -18005,8 +18068,8 @@ function validPattern(p) {
   }
 }
 function readSchemaFile(repoDir) {
-  const file = path28.join(repoDir, "forge.env.schema.json");
-  if (!existsSync18(file)) return [];
+  const file = path29.join(repoDir, "forge.env.schema.json");
+  if (!existsSync19(file)) return [];
   try {
     const parsed = JSON.parse(readFileSync16(file, "utf8"));
     const list = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.vars) ? parsed.vars : parsed && typeof parsed === "object" ? Object.entries(parsed).map(([key, v]) => ({
@@ -18020,8 +18083,8 @@ function readSchemaFile(repoDir) {
 }
 function deriveSchema(repoDir, envKeys) {
   const specs = /* @__PURE__ */ new Map();
-  const exampleFile = path28.join(repoDir, ".env.example");
-  if (existsSync18(exampleFile)) {
+  const exampleFile = path29.join(repoDir, ".env.example");
+  if (existsSync19(exampleFile)) {
     for (const entry2 of parseEnv(readFileSync16(exampleFile, "utf8")).entries) {
       if (specs.has(entry2.key)) continue;
       const kind = inferKind(entry2.key, entry2.value || void 0);
@@ -18085,8 +18148,8 @@ function checkValue(spec, value, opts = {}) {
     case "path": {
       if (!value.trim()) return false;
       if (!opts.checkPaths) return true;
-      const p = path29.isAbsolute(value) ? value : path29.resolve(opts.baseDir ?? ".", value);
-      return existsSync19(p);
+      const p = path30.isAbsolute(value) ? value : path30.resolve(opts.baseDir ?? ".", value);
+      return existsSync20(p);
     }
     case "bool":
       return /^(true|false|0|1|yes|no)$/i.test(value.trim());
@@ -18137,9 +18200,9 @@ function analyzeKey(key, spec, entries, opts) {
 }
 function analyzeEnv(repoDir, envKeys, opts = {}) {
   const schema = deriveSchema(repoDir, envKeys);
-  const envPath = path29.join(repoDir, ".env");
+  const envPath = path30.join(repoDir, ".env");
   const specByKey = new Map(schema.vars.map((v) => [v.key, v]));
-  const envFile = existsSync19(envPath) ? parseEnv(readFileSync17(envPath, "utf8")) : null;
+  const envFile = existsSync20(envPath) ? parseEnv(readFileSync17(envPath, "utf8")) : null;
   const findings = [];
   const vars = [];
   const byKey = /* @__PURE__ */ new Map();
@@ -18220,9 +18283,9 @@ function inspectEnv(repoDir, envKeys) {
 }
 
 // src/maintenance.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync6, readFileSync as readFileSync18, readdirSync as readdirSync9 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync7, readFileSync as readFileSync18, readdirSync as readdirSync9 } from "fs";
 import { createHash as createHash4 } from "crypto";
-import path30 from "path";
+import path31 from "path";
 function envLockDigest(repoDir) {
   const names = [
     ".env.example",
@@ -18234,8 +18297,8 @@ function envLockDigest(repoDir) {
   const files = [];
   const hash = createHash4("sha256");
   for (const name of names) {
-    const file = path30.join(repoDir, name);
-    if (!existsSync20(file)) continue;
+    const file = path31.join(repoDir, name);
+    if (!existsSync21(file)) continue;
     files.push(name);
     const content = readFileSync18(file);
     hash.update(name).update("\0").update(content).update("\0");
@@ -18249,8 +18312,8 @@ function buildEnvLock(targetDir, repos) {
     forges: {}
   };
   for (const repo of repos) {
-    const dir = path30.join(targetDir, repo.name);
-    if (!existsSync20(dir)) continue;
+    const dir = path31.join(targetDir, repo.name);
+    if (!existsSync21(dir)) continue;
     const { files, digest } = envLockDigest(dir);
     const head = loadState(targetDir)?.repos[repo.name]?.head;
     lock.forges[repo.name] = { env_files: files, digest, ...head ? { head } : {} };
@@ -18259,14 +18322,14 @@ function buildEnvLock(targetDir, repos) {
 }
 function writeEnvLock(targetDir, repos) {
   const lock = buildEnvLock(targetDir, repos);
-  const file = path30.join(artifactsRoot(targetDir), "env.lock.json");
-  mkdirSync6(path30.dirname(file), { recursive: true });
+  const file = path31.join(artifactsRoot(targetDir), "env.lock.json");
+  mkdirSync7(path31.dirname(file), { recursive: true });
   writeFileAtomic(file, JSON.stringify(lock, null, 2));
   return lock;
 }
 function checkEnvLock(targetDir, repos) {
-  const file = path30.join(artifactsRoot(targetDir), "env.lock.json");
-  if (!existsSync20(file)) return repos.map((r2) => ({ forge: r2.name, state: "untracked" }));
+  const file = path31.join(artifactsRoot(targetDir), "env.lock.json");
+  if (!existsSync21(file)) return repos.map((r2) => ({ forge: r2.name, state: "untracked" }));
   let lock;
   try {
     lock = JSON.parse(readFileSync18(file, "utf8"));
@@ -18276,8 +18339,8 @@ function checkEnvLock(targetDir, repos) {
   return repos.map((repo) => {
     const entry2 = lock.forges?.[repo.name];
     if (!entry2) return { forge: repo.name, state: "untracked" };
-    const dir = path30.join(targetDir, repo.name);
-    if (!existsSync20(dir)) return { forge: repo.name, state: "absent" };
+    const dir = path31.join(targetDir, repo.name);
+    if (!existsSync21(dir)) return { forge: repo.name, state: "absent" };
     const { digest } = envLockDigest(dir);
     return { forge: repo.name, state: digest === entry2.digest ? "match" : "drifted" };
   });
@@ -18298,7 +18361,7 @@ function buildProfile(targetDir) {
 }
 function exportProfile(targetDir, dest) {
   const profile = buildProfile(targetDir);
-  mkdirSync6(path30.dirname(path30.resolve(dest)), { recursive: true });
+  mkdirSync7(path31.dirname(path31.resolve(dest)), { recursive: true });
   writeFileAtomic(dest, JSON.stringify(profile, null, 2));
   return profile;
 }
@@ -18399,16 +18462,16 @@ function systemChecks(ctx) {
     readEvidence = `read=falha (${errMsg(error)})`;
   }
   if (readable2) {
-    const probe = path31.join(dir, `.forge-doctor2-probe-${process.pid}`);
+    const probe = path32.join(dir, `.forge-doctor2-probe-${process.pid}`);
     try {
-      writeFileSync5(probe, "probe\n", "utf8");
-      rmSync5(probe, { force: true });
+      writeFileSync6(probe, "probe\n", "utf8");
+      rmSync6(probe, { force: true });
       writable2 = true;
       writeEvidence = "write=ok";
     } catch (error) {
       writeEvidence = `write=falha (${errMsg(error)})`;
       try {
-        rmSync5(probe, { force: true });
+        rmSync6(probe, { force: true });
       } catch {
       }
     }
@@ -18434,7 +18497,7 @@ function systemChecks(ctx) {
   const dirEvidence = [];
   let dirFailed = 0;
   for (const { label, dir: d } of required) {
-    if (!existsSync21(d)) {
+    if (!existsSync22(d)) {
       dirFailed += 1;
       dirEvidence.push(`${label}=${d}: ausente`);
       continue;
@@ -18492,7 +18555,7 @@ function backupScan(ctx) {
         over = true;
         break;
       }
-      const full = path31.join(dir, name);
+      const full = path32.join(dir, name);
       try {
         if (!statSync4(full).isDirectory()) continue;
       } catch {
@@ -18501,16 +18564,16 @@ function backupScan(ctx) {
       if (restorableIf(full)) restorable.push(`${kind}: ${full}`);
     }
   };
-  scan(path31.join(artifactsRoot(ctx.root), "backups"), "workspace-backup", dirHasFiles);
+  scan(path32.join(artifactsRoot(ctx.root), "backups"), "workspace-backup", dirHasFiles);
   scan(
-    path31.join(ctx.home, ".forge-cli", "backups"),
+    path32.join(ctx.home, ".forge-cli", "backups"),
     "host-backup",
-    (full) => existsSync21(path31.join(full, "manifest.json"))
+    (full) => existsSync22(path32.join(full, "manifest.json"))
   );
   for (const repo of ctx.catalog) {
     const dir = resolveInside(ctx.root, repo.name);
     if (!dir || over) continue;
-    scan(path31.join(dir, ".forge-cli", "backups"), `env-backup(${repo.name})`, dirHasFiles);
+    scan(path32.join(dir, ".forge-cli", "backups"), `env-backup(${repo.name})`, dirHasFiles);
   }
   if (over) ctx.truncated.value = true;
   return { restorable, scanned };
@@ -18518,7 +18581,7 @@ function backupScan(ctx) {
 function installationChecks(ctx) {
   const checks = [];
   const forgeDir = artifactsRoot(ctx.root);
-  const forgeDirPresent = existsSync21(forgeDir);
+  const forgeDirPresent = existsSync22(forgeDir);
   const stateFile = stateFileFor(ctx.root);
   checks.push(
     mkCheck(
@@ -18531,7 +18594,7 @@ function installationChecks(ctx) {
         diagnosis: "diret\xF3rio de estado .forge-cli presente",
         evidence: [
           `${forgeDir} presente`,
-          existsSync21(stateFile) ? "state.json presente" : "state.json ausente"
+          existsSync22(stateFile) ? "state.json presente" : "state.json ausente"
         ],
         reversible: null
       } : {
@@ -18546,8 +18609,8 @@ function installationChecks(ctx) {
       }
     )
   );
-  const forgeJson = path31.join(ctx.root, "forge.json");
-  if (!existsSync21(forgeJson)) {
+  const forgeJson = path32.join(ctx.root, "forge.json");
+  if (!existsSync22(forgeJson)) {
     checks.push(
       mkCheck(ctx.now, {
         id: "installation.forge-json.present",
@@ -18596,10 +18659,10 @@ function installationChecks(ctx) {
       );
     }
   }
-  const lockFile = path31.join(forgeDir, "env.lock.json");
-  const lockParsed = existsSync21(lockFile) ? readJson(lockFile) : null;
+  const lockFile = path32.join(forgeDir, "env.lock.json");
+  const lockParsed = existsSync22(lockFile) ? readJson(lockFile) : null;
   const lockObj = lockParsed?.ok && lockParsed.value !== null && typeof lockParsed.value === "object" ? lockParsed.value : null;
-  if (!forgeDirPresent || !existsSync21(lockFile)) {
+  if (!forgeDirPresent || !existsSync22(lockFile)) {
     checks.push(
       mkCheck(ctx.now, {
         id: "installation.lockfile.present",
@@ -18644,7 +18707,7 @@ function installationChecks(ctx) {
     );
   }
   const trackedForges = lockObj ? Object.keys(lockObj.forges ?? {}) : [];
-  if (!existsSync21(lockFile) || !lockObj || !trackedForges.length) {
+  if (!existsSync22(lockFile) || !lockObj || !trackedForges.length) {
     checks.push(
       mkCheck(ctx.now, {
         id: "installation.lockfile.drift",
@@ -18653,7 +18716,7 @@ function installationChecks(ctx) {
         severity: "info",
         diagnosis: "deriva do lockfile n\xE3o verific\xE1vel",
         evidence: [
-          !existsSync21(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"
+          !existsSync22(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
       })
@@ -18675,17 +18738,17 @@ function installationChecks(ctx) {
       })
     );
   }
-  const ledgerDir = path31.join(ctx.home, ".forge", "installations");
+  const ledgerDir = path32.join(ctx.home, ".forge", "installations");
   const ledgerNames = listDir(ledgerDir);
   if (ledgerNames === null) {
     checks.push(
       mkCheck(ctx.now, {
         id: "installation.ledger.readable",
         domain: "installation",
-        result: existsSync21(ledgerDir) ? "warn" : "skip",
-        severity: existsSync21(ledgerDir) ? "medium" : "info",
-        diagnosis: existsSync21(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} ${existsSync21(ledgerDir) ? "ileg\xEDvel" : "ausente"}`],
+        result: existsSync22(ledgerDir) ? "warn" : "skip",
+        severity: existsSync22(ledgerDir) ? "medium" : "info",
+        diagnosis: existsSync22(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} ${existsSync22(ledgerDir) ? "ileg\xEDvel" : "ausente"}`],
         reversible: null
       })
     );
@@ -18813,7 +18876,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 && existsSync21(dir)) targets.push({ label: repo.name, dir, envKeys: repo.envKeys });
+    if (dir && existsSync22(dir)) targets.push({ label: repo.name, dir, envKeys: repo.envKeys });
   }
   const inspected = targets.map((t2) => ({
     ...t2,
@@ -19026,16 +19089,16 @@ async function hostsChecks(ctx) {
 }
 function operationsChecks(ctx) {
   const checks = [];
-  const reportsDir = path31.join(artifactsRoot(ctx.root), "reports");
+  const reportsDir = path32.join(artifactsRoot(ctx.root), "reports");
   const allReports = (listDir(reportsDir) ?? []).filter((n4) => n4.endsWith(".json"));
   const capped = allReports.length > ctx.maxReceipts;
   if (capped) ctx.truncated.value = true;
   const scannedNames = [...allReports].sort().reverse().slice(0, ctx.maxReceipts);
-  const parsedReports = scannedNames.map((n4) => readJson(path31.join(reportsDir, n4))).filter((r2) => r2.ok).map((r2) => r2.value);
+  const parsedReports = scannedNames.map((n4) => readJson(path32.join(reportsDir, n4))).filter((r2) => r2.ok).map((r2) => r2.value);
   checks.push(
     mkCheck(
       ctx.now,
-      !existsSync21(reportsDir) ? {
+      !existsSync22(reportsDir) ? {
         id: "operations.receipts.recent",
         domain: "operations",
         result: "skip",
@@ -19071,7 +19134,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 = existsSync21(reportsDir) || ctx.state !== null;
+  const scannedAnything = existsSync22(reportsDir) || ctx.state !== null;
   if (!scannedAnything) {
     checks.push(
       mkCheck(ctx.now, {
@@ -19107,7 +19170,7 @@ function operationsChecks(ctx) {
   );
   const recFiles = boundEntries(ctx, allRecFiles).shown;
   const recEvidence = recFiles.map((f) => {
-    const parsed = readJson(path31.join(artifactsRoot(ctx.root), f));
+    const parsed = readJson(path32.join(artifactsRoot(ctx.root), f));
     return `recovery file: ${f}${parsed.ok ? "" : " (ileg\xEDvel)"}`;
   });
   checks.push(
@@ -19287,7 +19350,7 @@ function defaultCatalog(root) {
 }
 async function runDoctor2(root, opts = {}) {
   const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  const resolved = path32.resolve(root);
+  const resolved = path33.resolve(root);
   const ctx = {
     root: resolved,
     home: opts.home ?? os4.homedir(),
@@ -19347,9 +19410,9 @@ async function runDoctor2(root, opts = {}) {
 }
 
 // src/heal/fixes.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync7, readdirSync as readdirSync11, readFileSync as readFileSync19, statSync as statSync5 } from "fs";
-import path33 from "path";
-var rel = (root, abs) => path33.relative(root, abs) || ".";
+import { existsSync as existsSync23, mkdirSync as mkdirSync8, readdirSync as readdirSync11, readFileSync as readFileSync19, statSync as statSync5 } from "fs";
+import path34 from "path";
+var rel = (root, abs) => path34.relative(root, abs) || ".";
 function stampOf(iso) {
   const m3 = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})/.exec(iso);
   return m3 ? `${m3[1]}${m3[2]}${m3[3]}-${m3[4]}${m3[5]}${m3[6]}` : iso.replace(/[^\d]/g, "").slice(0, 14);
@@ -19364,9 +19427,9 @@ var forgeDirRepair = {
   plan(ctx) {
     const base = artifactsRoot(ctx.root);
     return ["", ...FORGE_DIR_SUBDIRS].map((sub) => {
-      const dir = sub ? path33.join(base, sub) : base;
+      const dir = sub ? path34.join(base, sub) : base;
       return {
-        description: `create directory ${rel(ctx.root, dir)}${existsSync22(dir) ? " (already present)" : ""}`,
+        description: `create directory ${rel(ctx.root, dir)}${existsSync23(dir) ? " (already present)" : ""}`,
         touches: [rel(ctx.root, dir)]
       };
     });
@@ -19376,9 +19439,9 @@ var forgeDirRepair = {
     const base = artifactsRoot(ctx.root);
     const created = [];
     for (const sub of ["", ...FORGE_DIR_SUBDIRS]) {
-      const dir = sub ? path33.join(base, sub) : base;
-      if (existsSync22(dir)) continue;
-      mkdirSync7(dir, { recursive: true });
+      const dir = sub ? path34.join(base, sub) : base;
+      if (existsSync23(dir)) continue;
+      mkdirSync8(dir, { recursive: true });
       created.push(rel(ctx.root, dir));
     }
     return created.length ? `created ${created.length} directorie(s): ${created.join(", ")}` : "all directories already present";
@@ -19386,7 +19449,7 @@ var forgeDirRepair = {
   async verify(ctx) {
     const base = artifactsRoot(ctx.root);
     return ["", ...FORGE_DIR_SUBDIRS].every((sub) => {
-      const dir = sub ? path33.join(base, sub) : base;
+      const dir = sub ? path34.join(base, sub) : base;
       try {
         return statSync5(dir).isDirectory();
       } catch {
@@ -19397,11 +19460,11 @@ var forgeDirRepair = {
 };
 var EVIDENCE_KEY_RE = /^[A-Z_][A-Z0-9_]*$/;
 function envPathOf(root) {
-  return path33.join(root, ".env");
+  return path34.join(root, ".env");
 }
 function presentKeys(root) {
   const file = envPathOf(root);
-  if (!existsSync22(file)) return /* @__PURE__ */ new Set();
+  if (!existsSync23(file)) return /* @__PURE__ */ new Set();
   return new Set(parseEnv(readFileSync19(file, "utf8")).entries.map((e) => e.key));
 }
 function missingEnvKeys(root, check) {
@@ -19422,9 +19485,9 @@ function keysToAppend(root, check) {
 }
 function backupEnvFile(ctx, current) {
   const stamp = stampOf(ctx.now?.() ?? (/* @__PURE__ */ new Date()).toISOString());
-  const dir = path33.join(artifactsRoot(ctx.root), "backups", `env-${stamp}`);
-  mkdirSync7(dir, { recursive: true });
-  writeFileAtomic(path33.join(dir, ".env"), current);
+  const dir = path34.join(artifactsRoot(ctx.root), "backups", `env-${stamp}`);
+  mkdirSync8(dir, { recursive: true });
+  writeFileAtomic(path34.join(dir, ".env"), current);
   return dir;
 }
 var envMissingKeyRepair = {
@@ -19437,9 +19500,9 @@ var envMissingKeyRepair = {
     const root = ctx.root;
     const toAppend = keysToAppend(root, ctx.check);
     const steps = [];
-    if (existsSync22(envPathOf(root))) {
+    if (existsSync23(envPathOf(root))) {
       steps.push({
-        description: `backup .env to ${rel(root, path33.join(artifactsRoot(root), "backups"))}/env-<ts>/.env`,
+        description: `backup .env to ${rel(root, path34.join(artifactsRoot(root), "backups"))}/env-<ts>/.env`,
         touches: [".env", `${rel(root, artifactsRoot(root))}/backups/`]
       });
     }
@@ -19456,7 +19519,7 @@ var envMissingKeyRepair = {
     const root = ctx.root;
     if (ctx.dryRun) return "dry-run \u2014 not applied";
     const file = envPathOf(root);
-    const exists = existsSync22(file);
+    const exists = existsSync23(file);
     const current = exists ? readFileSync19(file, "utf8") : "";
     const env = parseEnv(current);
     const present = new Set(env.entries.map((e) => e.key));
@@ -19474,7 +19537,7 @@ var envMissingKeyRepair = {
   },
   async verify(ctx) {
     const file = envPathOf(ctx.root);
-    if (!existsSync22(file)) return false;
+    if (!existsSync23(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));
   }
@@ -19491,7 +19554,7 @@ var lockfileDriftRepair = {
     return [
       {
         description: `run \`${LOCKFILE_REGEN_COMMAND}\` to regenerate .forge-cli/env.lock.json`,
-        touches: [path33.join(".forge-cli", "env.lock.json")]
+        touches: [path34.join(".forge-cli", "env.lock.json")]
       },
       {
         description: `run \`${LOCKFILE_CHECK_COMMAND}\` to confirm the drift cleared`,
@@ -19511,12 +19574,12 @@ var lockfileDriftRepair = {
 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 = path33.join(artifactsRoot(root), "backups");
-  if (!existsSync22(base)) return [];
+  const base = path34.join(artifactsRoot(root), "backups");
+  if (!existsSync23(base)) return [];
   const out = [];
   for (const entry2 of readdirSync11(base, { withFileTypes: true })) {
     if (!entry2.isDirectory()) continue;
-    const dir = path33.join(base, entry2.name);
+    const dir = path34.join(base, entry2.name);
     try {
       const files = readdirSync11(dir, { withFileTypes: true }).filter((f) => f.isFile()).map((f) => f.name).sort();
       if (!files.length) continue;
@@ -19534,18 +19597,18 @@ function restoreTargetFor(backupDirName, fileName) {
   return fileName;
 }
 function pickBackupFile(ctx) {
-  const backupsBase = path33.join(artifactsRoot(ctx.root), "backups");
+  const backupsBase = path34.join(artifactsRoot(ctx.root), "backups");
   if (ctx.backup) {
-    const abs = path33.resolve(ctx.root, ctx.backup);
-    const inside = path33.relative(backupsBase, abs);
-    if (inside.startsWith("..") || path33.isAbsolute(inside)) {
+    const abs = path34.resolve(ctx.root, ctx.backup);
+    const inside = path34.relative(backupsBase, abs);
+    if (inside.startsWith("..") || path34.isAbsolute(inside)) {
       throw new Error(`selected backup escapes .forge-cli/backups: ${ctx.backup}`);
     }
-    if (!existsSync22(abs) || !statSync5(abs).isFile()) {
+    if (!existsSync23(abs) || !statSync5(abs).isFile()) {
       throw new Error(`selected backup not found: ${ctx.backup}`);
     }
-    const dirName = inside.split(path33.sep)[0] ?? "";
-    const fileName2 = path33.basename(abs);
+    const dirName = inside.split(path34.sep)[0] ?? "";
+    const fileName2 = path34.basename(abs);
     return { src: abs, rel: inside, dest: restoreTargetFor(dirName, fileName2) };
   }
   const candidates = listBackups(ctx.root);
@@ -19554,7 +19617,7 @@ function pickBackupFile(ctx) {
   if (!cand) throw new Error("no backups available under .forge-cli/backups");
   const fileName = cand.files.includes(".env") ? ".env" : cand.files[0];
   return {
-    src: path33.join(cand.dir, fileName),
+    src: path34.join(cand.dir, fileName),
     rel: `${cand.name}/${fileName}`,
     dest: restoreTargetFor(cand.name, fileName)
   };
@@ -19570,7 +19633,7 @@ var backupRestoreRepair = {
     if (!candidates.length) {
       return [
         {
-          description: `no backups found under ${rel(ctx.root, path33.join(artifactsRoot(ctx.root), "backups"))}/`,
+          description: `no backups found under ${rel(ctx.root, path34.join(artifactsRoot(ctx.root), "backups"))}/`,
           touches: []
         }
       ];
@@ -19596,20 +19659,20 @@ var backupRestoreRepair = {
   async apply(ctx) {
     if (ctx.dryRun) return "dry-run \u2014 not applied";
     const picked = pickBackupFile(ctx);
-    const dest = path33.resolve(ctx.root, picked.dest);
-    const relDest = path33.relative(ctx.root, dest);
-    if (relDest.startsWith("..") || path33.isAbsolute(relDest)) {
+    const dest = path34.resolve(ctx.root, picked.dest);
+    const relDest = path34.relative(ctx.root, dest);
+    if (relDest.startsWith("..") || path34.isAbsolute(relDest)) {
       throw new Error(`restore target escapes root: ${picked.dest}`);
     }
-    mkdirSync7(path33.dirname(dest), { recursive: true });
+    mkdirSync8(path34.dirname(dest), { recursive: true });
     writeFileAtomic(dest, readFileSync19(picked.src, "utf8"));
     return `restored ${picked.rel} \u2192 ${relDest}`;
   },
   async verify(ctx) {
     try {
       const picked = pickBackupFile(ctx);
-      const dest = path33.resolve(ctx.root, picked.dest);
-      return existsSync22(dest) && readFileSync19(dest, "utf8") === readFileSync19(picked.src, "utf8");
+      const dest = path34.resolve(ctx.root, picked.dest);
+      return existsSync23(dest) && readFileSync19(dest, "utf8") === readFileSync19(picked.src, "utf8");
     } catch {
       return false;
     }
@@ -19639,11 +19702,11 @@ function classifyFindings(checks) {
 }
 
 // src/heal/flow.ts
-import { mkdirSync as mkdirSync8 } from "fs";
-import path34 from "path";
+import { mkdirSync as mkdirSync9 } from "fs";
+import path35 from "path";
 function healReceiptPath(root, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path34.join(artifactsRoot(root), "receipts", `heal-${stamp}.json`);
+  return path35.join(artifactsRoot(root), "receipts", `heal-${stamp}.json`);
 }
 async function planRepairs(checks, opts) {
   const classified = classifyFindings(checks);
@@ -19778,7 +19841,7 @@ async function runHealFlow(checks, opts) {
   };
   if (!dryRun) {
     const file = healReceiptPath(opts.root, generatedAt);
-    mkdirSync8(path34.dirname(file), { recursive: true });
+    mkdirSync9(path35.dirname(file), { recursive: true });
     writeFileAtomic(file, redactSecrets(JSON.stringify(receipt, null, 2)));
   }
   return receipt;
@@ -19863,8 +19926,8 @@ async function runDoctor2Command(cli) {
 }
 
 // src/cmd/registry.ts
-import path35 from "path";
-import { existsSync as existsSync23, mkdirSync as mkdirSync9 } from "fs";
+import path36 from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync10 } from "fs";
 
 // src/registry/catalog.ts
 var REGISTRY_PACKAGES = [
@@ -19998,7 +20061,7 @@ function describeInstallError(e) {
   return `${e.stage}: ${e.detail}`;
 }
 function registryCacheDir(home = cliHome()) {
-  return path35.join(home, ".forge-cli", "cache", "pypi");
+  return path36.join(home, ".forge-cli", "cache", "pypi");
 }
 var REGISTRY_IGNORED_FLAGS = [
   ["dir", "--dir"],
@@ -20092,8 +20155,8 @@ async function persistReceipt(home, receipt) {
   }
 }
 function writeRegistryReport(reportPath, doc) {
-  const file = path35.resolve(reportPath);
-  mkdirSync9(path35.dirname(file), { recursive: true });
+  const file = path36.resolve(reportPath);
+  mkdirSync10(path36.dirname(file), { recursive: true });
   writeFileAtomic(file, redactSecrets(JSON.stringify(doc, null, 2)));
 }
 async function runRegistryInstall(cli, names, deps = {}) {
@@ -20272,7 +20335,7 @@ async function runRegistryInstall(cli, names, deps = {}) {
   const doc = { method: "pypi", results, warnings };
   reportTo(doc);
   if (cli.reportPath !== void 0) {
-    log.info(`${S.reportSaved}: ${theme.dim(path35.resolve(cli.reportPath))}`);
+    log.info(`${S.reportSaved}: ${theme.dim(path36.resolve(cli.reportPath))}`);
   }
   if (quiet) {
     emitJson(doc, results.every((r2) => r2.ok) ? 0 : 1);
@@ -20283,9 +20346,13 @@ async function runRegistryInstall(cli, names, deps = {}) {
   if (results.some((r2) => !r2.ok)) process.exit(1);
   const bins = results.map((r2) => {
     const inst = loadForgeState(home).forges[r2.forge];
-    return inst ? `${r2.forge} \u2192 ${inst.bin}` : "";
+    if (!inst) return "";
+    return inst.shim ? `${r2.forge} \u2192 ${path36.basename(inst.shim)} (em ${path36.dirname(inst.shim)})` : `${r2.forge} \u2192 ${inst.bin}`;
   });
-  note(bins.filter(Boolean).join("\n"), "Para usar, adicione ao PATH ou invoque o caminho");
+  note(
+    bins.filter(Boolean).join("\n"),
+    "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`);
   return results;
 }
@@ -20347,7 +20414,7 @@ async function runRegistryLock(cli, names, deps = {}) {
       results.push({ forge: e.name, ok: false, detail: describeResolveError(picked.error) });
       continue;
     }
-    const out = cli.out ? entries.length === 1 ? path35.resolve(cli.out) : path35.join(path35.resolve(cli.out), `${e.name}.offline-lock.json`) : path35.resolve(`${e.name}.offline-lock.json`);
+    const out = cli.out ? entries.length === 1 ? path36.resolve(cli.out) : path36.join(path36.resolve(cli.out), `${e.name}.offline-lock.json`) : path36.resolve(`${e.name}.offline-lock.json`);
     if (isPlan) {
       results.push({
         forge: e.name,
@@ -20366,7 +20433,7 @@ async function runRegistryLock(cli, names, deps = {}) {
       results.push({ forge: e.name, ok: false, detail: `${lock.kind}: ${lock.detail}` });
       continue;
     }
-    mkdirSync9(path35.dirname(out), { recursive: true });
+    mkdirSync10(path36.dirname(out), { recursive: true });
     writeFileAtomic(out, `${JSON.stringify(lock, null, 2)}
 `);
     locks.push({ forge: e.name, lock, file: out });
@@ -20407,7 +20474,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" && existsSync23(inst.bin) : null;
+    const binOk = inst ? typeof inst.bin === "string" && existsSync24(inst.bin) : null;
     const consistency = installConsistency(home, e.name);
     const relevant = consistency.status !== "not-installed";
     return {
@@ -21132,24 +21199,24 @@ async function runRegistryPin(cli, names, pin, deps = {}) {
 }
 
 // src/lifecycle.ts
-import { copyFileSync as copyFileSync3, existsSync as existsSync24, mkdirSync as mkdirSync10, readdirSync as readdirSync12, rmSync as rmSync6 } from "fs";
-import path36 from "path";
+import { copyFileSync as copyFileSync3, existsSync as existsSync25, mkdirSync as mkdirSync11, readdirSync as readdirSync12, rmSync as rmSync7 } from "fs";
+import path37 from "path";
 function configFilesToBackup(repoDir) {
   const out = /* @__PURE__ */ new Set();
-  if (existsSync24(path36.join(repoDir, ".env"))) out.add(".env");
+  if (existsSync25(path37.join(repoDir, ".env"))) out.add(".env");
   for (const file of readdirSync12(repoDir)) {
     if (file === ".env.example" || !file.includes(".example.")) continue;
     const real = file.replace(".example.", ".");
-    if (existsSync24(path36.join(repoDir, real))) out.add(real);
+    if (existsSync25(path37.join(repoDir, real))) out.add(real);
   }
   return [...out];
 }
 async function planUninstall(targetDir, repo) {
   const dir = resolveInside(targetDir, repo.name);
   if (!dir)
-    return { kind: "refused", dir: path36.join(targetDir, repo.name), reason: "invalid-name" };
+    return { kind: "refused", dir: path37.join(targetDir, repo.name), reason: "invalid-name" };
   if (isLinkOrJunction(dir)) return { kind: "refused", dir, reason: "symlink" };
-  if (!existsSync24(dir)) return { kind: "absent", dir };
+  if (!existsSync25(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)) {
@@ -21163,14 +21230,14 @@ function executeUninstall(targetDir, repo, plan) {
   if (!expected || expected !== plan.dir) throw new Error("plano de remo\xE7\xE3o inconsistente");
   let backupDir = null;
   if (plan.backups.length) {
-    backupDir = path36.join(artifactsRoot(targetDir), "backups", `${repo.name}-${Date.now()}`);
+    backupDir = path37.join(artifactsRoot(targetDir), "backups", `${repo.name}-${Date.now()}`);
     for (const file of plan.backups) {
-      const dest = path36.join(backupDir, file);
-      mkdirSync10(path36.dirname(dest), { recursive: true });
-      copyFileSync3(path36.join(plan.dir, file), dest);
+      const dest = path37.join(backupDir, file);
+      mkdirSync11(path37.dirname(dest), { recursive: true });
+      copyFileSync3(path37.join(plan.dir, file), dest);
     }
   }
-  rmSync6(plan.dir, { recursive: true, force: true });
+  rmSync7(plan.dir, { recursive: true, force: true });
   forgetRepo(targetDir, repo.name);
   return backupDir;
 }
@@ -21199,13 +21266,13 @@ async function rollbackRepo(targetDir, repo) {
 }
 
 // src/self.ts
-import path37 from "path";
+import path38 from "path";
 function norm(p) {
-  return path37.resolve(p).replace(/\\/g, "/").toLowerCase();
+  return path38.resolve(p).replace(/\\/g, "/").toLowerCase();
 }
 function detectInstallMethod(scriptPath, home) {
   const script = norm(scriptPath);
-  if (script.startsWith(`${norm(path37.join(home, ".forge-cli", "bin"))}/`)) return "shim";
+  if (script.startsWith(`${norm(path38.join(home, ".forge-cli", "bin"))}/`)) return "shim";
   if (script.includes("/node_modules/")) return "npm-global";
   return "source";
 }
@@ -21500,11 +21567,11 @@ async function runUninstallCommand(cli) {
 }
 
 // src/config.ts
-import { existsSync as existsSync25, readFileSync as readFileSync20 } from "fs";
-import path38 from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync20 } from "fs";
+import path39 from "path";
 function loadConfig(targetDir) {
-  const file = path38.join(targetDir, "forge-cli.config.json");
-  if (!existsSync25(file)) return null;
+  const file = path39.join(targetDir, "forge-cli.config.json");
+  if (!existsSync26(file)) return null;
   let parsed;
   try {
     parsed = JSON.parse(readFileSync20(file, "utf8"));
@@ -21550,12 +21617,12 @@ function loadConfig(targetDir) {
 }
 
 // src/plan.ts
-import { existsSync as existsSync26, readdirSync as readdirSync13 } from "fs";
-import path39 from "path";
+import { existsSync as existsSync27, readdirSync as readdirSync13 } from "fs";
+import path40 from "path";
 function planLines(repo, targetDir) {
-  const repoDir = path39.join(targetDir, repo.name);
+  const repoDir = path40.join(targetDir, repo.name);
   const lines = [];
-  if (!existsSync26(repoDir)) {
+  if (!existsSync27(repoDir)) {
     lines.push(`${S.planSync}: git clone (${S.planDetectAfter})`);
     for (const step of [
       S.phaseEnv,
@@ -21594,11 +21661,11 @@ function planLines(repo, targetDir) {
   return lines;
 }
 async function executionSummary(repo, targetDir, native, platform2 = process.platform) {
-  const repoDir = path39.join(targetDir, repo.name);
+  const repoDir = path40.join(targetDir, repo.name);
   const trust = repo.origin === "custom" ? "custom" : "builtin";
   const commands = [];
   let revision;
-  if (!existsSync26(repoDir) || !hasGitRepo(repoDir)) {
+  if (!existsSync27(repoDir) || !hasGitRepo(repoDir)) {
     commands.push(`git clone -- ${repo.url}`, S.planScriptsAfterClone);
   } else {
     revision = (await currentHead(repoDir))?.slice(0, 7);
@@ -21833,8 +21900,8 @@ ${planLines(repo, targetDir).map((line) => `  ${theme.dim(line)}`).join("\n")}`
 }
 
 // src/cmd/env.ts
-import { copyFileSync as copyFileSync4, existsSync as existsSync28, readFileSync as readFileSync22, readdirSync as readdirSync15 } from "fs";
-import path41 from "path";
+import { copyFileSync as copyFileSync4, existsSync as existsSync29, readFileSync as readFileSync22, readdirSync as readdirSync15 } from "fs";
+import path42 from "path";
 
 // src/envintel/doctor.ts
 function envDoctor(repoDir, envKeys) {
@@ -21883,8 +21950,8 @@ function envDoctor(repoDir, envKeys) {
 
 // src/envintel/migrate.ts
 import { randomBytes } from "crypto";
-import { existsSync as existsSync27, mkdirSync as mkdirSync11, readdirSync as readdirSync14, readFileSync as readFileSync21 } from "fs";
-import path40 from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync12, readdirSync as readdirSync14, readFileSync as readFileSync21 } from "fs";
+import path41 from "path";
 function timestamp2(d = /* @__PURE__ */ new Date()) {
   const p = (n4) => String(n4).padStart(2, "0");
   return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
@@ -21898,12 +21965,12 @@ function addValue(spec, exampleEmpty) {
 }
 function planMigration(repoDir, targetSchema) {
   const schema = targetSchema ?? deriveSchema(repoDir);
-  const envPath = path40.join(repoDir, ".env");
-  const env = existsSync27(envPath) ? parseEnv(readFileSync21(envPath, "utf8")) : null;
+  const envPath = path41.join(repoDir, ".env");
+  const env = existsSync28(envPath) ? parseEnv(readFileSync21(envPath, "utf8")) : null;
   const present = new Set(env?.entries.map((e) => e.key) ?? []);
-  const examplePath = path40.join(repoDir, ".env.example");
+  const examplePath = path41.join(repoDir, ".env.example");
   const exampleEmpty = /* @__PURE__ */ new Set();
-  if (existsSync27(examplePath)) {
+  if (existsSync28(examplePath)) {
     for (const e of parseEnv(readFileSync21(examplePath, "utf8")).entries) {
       if (e.value === "") exampleEmpty.add(e.key);
     }
@@ -21932,18 +21999,18 @@ function planMigration(repoDir, targetSchema) {
   return { actions, removesRequireApproval: true };
 }
 function backupDirFor2(repoDir, ts) {
-  return path40.join(artifactsRoot(repoDir), "backups", `env-${ts}`);
+  return path41.join(artifactsRoot(repoDir), "backups", `env-${ts}`);
 }
 function backupEnv(repoDir, content) {
   const dir = backupDirFor2(repoDir, timestamp2());
-  mkdirSync11(dir, { recursive: true });
-  const file = path40.join(dir, ".env");
+  mkdirSync12(dir, { recursive: true });
+  const file = path41.join(dir, ".env");
   writeFileAtomic(file, content);
   return dir;
 }
 function applyMigration(repoDir, plan, opts = {}) {
-  const envPath = path40.join(repoDir, ".env");
-  const exists = existsSync27(envPath);
+  const envPath = path41.join(repoDir, ".env");
+  const exists = existsSync28(envPath);
   const current = exists ? readFileSync21(envPath, "utf8") : "";
   const env = parseEnv(current);
   const present = new Set(env.entries.map((e) => e.key));
@@ -21974,16 +22041,16 @@ function applyMigration(repoDir, plan, opts = {}) {
   };
 }
 function latestEnvBackup(repoDir) {
-  const root = path40.join(artifactsRoot(repoDir), "backups");
-  if (!existsSync27(root)) return null;
+  const root = path41.join(artifactsRoot(repoDir), "backups");
+  if (!existsSync28(root)) return null;
   const candidates = readdirSync14(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 ? path40.join(root, last) : null;
+  return last ? path41.join(root, last) : null;
 }
 function rollbackEnv(repoDir, backupDir) {
-  const src = path40.join(backupDir, ".env");
-  if (!existsSync27(src)) return false;
-  writeFileAtomic(path40.join(repoDir, ".env"), readFileSync21(src, "utf8"));
+  const src = path41.join(backupDir, ".env");
+  if (!existsSync28(src)) return false;
+  writeFileAtomic(path41.join(repoDir, ".env"), readFileSync21(src, "utf8"));
   return true;
 }
 
@@ -21993,7 +22060,7 @@ function envCandidates(dir) {
   try {
     return readdirSync15(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).filter((name) => {
       const r2 = resolveInside(dir, name);
-      return r2 !== null && (existsSync28(path41.join(r2, ".env")) || existsSync28(path41.join(r2, ".env.example")));
+      return r2 !== null && (existsSync29(path42.join(r2, ".env")) || existsSync29(path42.join(r2, ".env.example")));
     }).sort();
   } catch {
     return [];
@@ -22040,7 +22107,7 @@ async function runEnvCommand(cli, args) {
     envKeys = catalogFor(targetDir).find((r2) => r2.name === name)?.envKeys;
   } else {
     const cwd = process.cwd();
-    if (existsSync28(path41.join(cwd, ".env")) || existsSync28(path41.join(cwd, ".env.example"))) {
+    if (existsSync29(path42.join(cwd, ".env")) || existsSync29(path42.join(cwd, ".env.example"))) {
       repoDir = cwd;
     }
   }
@@ -22050,7 +22117,7 @@ async function runEnvCommand(cli, args) {
     if (found.length) note(found.join("\n"), S.envTitle);
     return 2;
   }
-  const repo = name ?? path41.basename(repoDir);
+  const repo = name ?? path42.basename(repoDir);
   if (verb === "inspect") {
     const res2 = inspectEnv(repoDir, envKeys);
     if (json) {
@@ -22092,13 +22159,13 @@ async function runEnvCommand(cli, args) {
     note(lines.join("\n"), `${S.envDoctorTitle} \u2014 ${repo}`);
     return res2.checks.some((c5) => c5.result === "fail") ? 1 : 0;
   }
-  if (!existsSync28(repoDir)) {
+  if (!existsSync29(repoDir)) {
     log.error(`${repo}: ${S.statusNotInstalled}`);
     return 2;
   }
   const schema = deriveSchema(repoDir, envKeys);
   const secretKeys = new Set(schema.vars.filter((v) => v.secret).map((v) => v.key));
-  const envPath = path41.join(repoDir, ".env");
+  const envPath = path42.join(repoDir, ".env");
   if (verb === "wizard") {
     if (dryRun) {
       log.error(S.errPlanUnsupported);
@@ -22108,7 +22175,7 @@ async function runEnvCommand(cli, args) {
       log.error(S.envWizardNonInteractive);
       return 2;
     }
-    const env = parseEnv(existsSync28(envPath) ? readFileSync22(envPath, "utf8") : "");
+    const env = parseEnv(existsSync29(envPath) ? readFileSync22(envPath, "utf8") : "");
     const current = new Map(env.entries.map((e) => [e.key, e]));
     const updates = /* @__PURE__ */ new Map();
     for (const spec of schema.vars) {
@@ -22151,7 +22218,7 @@ async function runEnvCommand(cli, args) {
     }
     for (const [k, v] of updates) lines.push(formatEntry(k, v));
     const out = serializeEnv({ ...env, lines });
-    if (existsSync28(envPath)) copyFileSync4(envPath, `${envPath}.bak`);
+    if (existsSync29(envPath)) copyFileSync4(envPath, `${envPath}.bak`);
     writeFileAtomic(envPath, out.endsWith("\n") ? out : `${out}
 `);
     log.success(`${icons.ok} ${S.envWizardDone} ${theme.dim(`(${envPath}.bak)`)}`);
@@ -22179,7 +22246,7 @@ async function runEnvCommand(cli, args) {
     return 0;
   }
   if (verb === "init") {
-    if (existsSync28(envPath)) {
+    if (existsSync29(envPath)) {
       if (json) console.log(JSON.stringify({ command: "env init", repo, created: false }));
       else log.info(S.envInitExists);
       return 0;
@@ -22293,13 +22360,13 @@ async function runEnvCommand(cli, args) {
 }
 
 // src/cmd/hosts.ts
-import path43 from "path";
-import { existsSync as existsSync30, readdirSync as readdirSync16 } from "fs";
+import path44 from "path";
+import { existsSync as existsSync31, readdirSync as readdirSync16 } from "fs";
 
 // src/mcp/handshake.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync29 } from "fs";
-import path42 from "path";
+import { existsSync as existsSync30 } from "fs";
+import path43 from "path";
 import { createInterface as createInterface2 } from "readline";
 var PROTOCOL_VERSION = "2024-11-05";
 var STEP_MS = 8e3;
@@ -22388,8 +22455,8 @@ function probeMcpServer(argv, opts = {}) {
     }
     const stepMs = opts.timeoutMs ?? STEP_MS;
     const levels = [];
-    if (path42.isAbsolute(argv[0])) {
-      if (!existsSync29(argv[0])) {
+    if (path43.isAbsolute(argv[0])) {
+      if (!existsSync30(argv[0])) {
         resolve(err("bin-missing", `bin\xE1rio MCP ausente: ${argv[0]}`));
         return;
       }
@@ -22678,12 +22745,12 @@ function forgeDescriptor(targetDir, name, home = cliHome()) {
   const receipt = loadForgeState(home).forges[name];
   const entry2 = registryEntry(name);
   if (receipt?.bin && entry2?.mcp?.length) {
-    const binDir = path43.dirname(receipt.bin);
+    const binDir = path44.dirname(receipt.bin);
     const mcp_command = entry2.mcp.map((tok) => {
       if (tok === "{bin}") return receipt.bin;
       if (tok.startsWith("{binDir}/")) {
         const script = tok.slice("{binDir}/".length);
-        return path43.join(binDir, process.platform === "win32" ? `${script}.exe` : script);
+        return path44.join(binDir, process.platform === "win32" ? `${script}.exe` : script);
       }
       return tok;
     });
@@ -22818,7 +22885,7 @@ async function runMcpCommand(cli, args, home = cliHome()) {
   const candidates = names.length > 0 ? names : [
     .../* @__PURE__ */ new Set([
       ...Object.keys(loadForgeState(home).forges),
-      ...existsSync30(targetDir) ? readdirSync16(targetDir, { withFileTypes: true }).filter((d) => d.isDirectory() && isSafeRepoName(d.name)).map((d) => d.name) : []
+      ...existsSync31(targetDir) ? readdirSync16(targetDir, { withFileTypes: true }).filter((d) => d.isDirectory() && isSafeRepoName(d.name)).map((d) => d.name) : []
     ])
   ].sort();
   if (candidates.length === 0) {
@@ -22839,7 +22906,7 @@ async function runMcpCommand(cli, args, home = cliHome()) {
       results.push({ forge: name, ok: false, detail: "sem mcp_command" });
       continue;
     }
-    const binPresent = path43.isAbsolute(argv[0]) ? existsSync30(argv[0]) : true;
+    const binPresent = path44.isAbsolute(argv[0]) ? existsSync31(argv[0]) : true;
     const item = {
       forge: name,
       forge_id: forge.forge_id,
@@ -22848,7 +22915,7 @@ async function runMcpCommand(cli, args, home = cliHome()) {
       ok: binPresent
     };
     if (!binPresent) item.detail = "bin\xE1rio MCP ausente na venv";
-    if (verify && binPresent && path43.isAbsolute(argv[0])) {
+    if (verify && binPresent && path44.isAbsolute(argv[0])) {
       const safeTools = registryEntry(name)?.mcp_safe_tools;
       const probe = await probeMcpServer(argv, { safeTools });
       let levels = probe.levels;
@@ -22887,9 +22954,9 @@ async function runMcpCommand(cli, args, home = cliHome()) {
 }
 
 // src/discovery.ts
-import { existsSync as existsSync31, readdirSync as readdirSync17, readFileSync as readFileSync23, statSync as statSync6 } from "fs";
+import { existsSync as existsSync32, readdirSync as readdirSync17, readFileSync as readFileSync23, statSync as statSync6 } from "fs";
 import os5 from "os";
-import path44 from "path";
+import path45 from "path";
 var DEFAULT_LIMITS = {
   maxDepth: 3,
   maxEntriesPerDir: 500,
@@ -23054,7 +23121,7 @@ function walkWorkspace(root, limits, budgetLeft) {
         return { markers, envFiles, topDirs, signals: signals2, truncated };
       }
       const lower = entry2.name.toLowerCase();
-      const full = path44.join(dir, entry2.name);
+      const full = path45.join(dir, entry2.name);
       const relPath = rel2 ? `${rel2}/${entry2.name}` : entry2.name;
       if (entry2.isDirectory()) {
         if (skip.has(lower) || isLinkOrJunction(full)) continue;
@@ -23177,10 +23244,10 @@ function registryState(entry2) {
 function discoverForge(name, dir, state) {
   const sources = [];
   const git = !!dir && hasGitRepo(dir);
-  const manifest = dir && existsSync31(dir) ? readForgeManifest(dir) : null;
+  const manifest = dir && existsSync32(dir) ? readForgeManifest(dir) : null;
   const entry2 = state?.repos[name];
   if (entry2 && entry2.phase !== "not-installed") {
-    const dirExists = !!dir && existsSync31(dir);
+    const dirExists = !!dir && existsSync32(dir);
     sources.push({
       origin: "manifest",
       // registro diz instalada mas o checkout sumiu → evidência falhando
@@ -23223,7 +23290,7 @@ async function discoverEnvironment(targetDir, opts) {
   const start = now();
   const limits = { ...DEFAULT_LIMITS, ...opts?.limits };
   const budgetLeft = () => limits.timeoutMs - (now() - start);
-  const root = path44.resolve(targetDir);
+  const root = path45.resolve(targetDir);
   const walk = walkWorkspace(root, limits, budgetLeft);
   const tools = await probeTools(process.platform, budgetLeft);
   const hosts = await probeHosts(budgetLeft);
@@ -23240,7 +23307,7 @@ async function discoverEnvironment(targetDir, opts) {
     const dir = resolveInside(root, dirName);
     if (!dir) continue;
     const git = hasGitRepo(dir);
-    const manifest = existsSync31(path44.join(dir, "forge.json"));
+    const manifest = existsSync32(path45.join(dir, "forge.json"));
     if (!git && !manifest) continue;
     presence.push({ name: dirName, path: dirName, git, manifest });
     if (!catalogNames.has(dirName) && manifest) {
@@ -23909,8 +23976,8 @@ async function answerRepair(targetDir, repos, opts = {}) {
 }
 
 // src/intel/context.ts
-import { existsSync as existsSync32, readdirSync as readdirSync18, readFileSync as readFileSync24, statSync as statSync7 } from "fs";
-import path45 from "path";
+import { existsSync as existsSync33, readdirSync as readdirSync18, readFileSync as readFileSync24, statSync as statSync7 } from "fs";
+import path46 from "path";
 
 // src/planner.ts
 import { createHash as createHash5 } from "crypto";
@@ -24008,7 +24075,7 @@ function safeScalar(value) {
   return redactSecrets(value) === value ? value : null;
 }
 function safeConfig(targetDir) {
-  const file = path45.join(targetDir, "forge-cli.config.json");
+  const file = path46.join(targetDir, "forge-cli.config.json");
   let raw;
   try {
     raw = JSON.parse(readFileSync24(file, "utf8"));
@@ -24025,9 +24092,9 @@ function safeConfig(targetDir) {
   return out;
 }
 function readManifestObject(repoDir) {
-  const file = path45.join(repoDir, "forge.json");
+  const file = path46.join(repoDir, "forge.json");
   try {
-    if (!existsSync32(file) || statSync7(file).size > MAX_MANIFEST_BYTES) return null;
+    if (!existsSync33(file) || statSync7(file).size > MAX_MANIFEST_BYTES) return null;
     const raw = JSON.parse(readFileSync24(file, "utf8"));
     return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
   } catch {
@@ -24061,7 +24128,7 @@ function manifestCapabilities(repoDir, repoName, out) {
   }
 }
 function activePlans(targetDir, nowIso) {
-  const dir = path45.join(artifactsRoot(targetDir), "plans");
+  const dir = path46.join(artifactsRoot(targetDir), "plans");
   let names;
   try {
     names = readdirSync18(dir).filter((n4) => n4.endsWith(".json")).sort();
@@ -24072,7 +24139,7 @@ function activePlans(targetDir, nowIso) {
   const out = [];
   for (const name of names.slice(0, MAX_PLAN_FILES)) {
     try {
-      const doc = JSON.parse(readFileSync24(path45.join(dir, name), "utf8"));
+      const doc = JSON.parse(readFileSync24(path46.join(dir, name), "utf8"));
       if (!doc || typeof doc !== "object" || Array.isArray(doc)) continue;
       const plan = doc;
       if (typeof plan.plan_id !== "string" || !plan.plan_id) continue;
@@ -24143,7 +24210,7 @@ async function buildForgeContext(targetDir, repos, opts = {}) {
   const byName = new Map(report.forges.map((f) => [f.name, f]));
   const capabilities = {};
   const forjas = [...repos].sort((a3, b) => cmp2(a3.name, b.name)).map((repo) => {
-    const dir = path45.join(targetDir, repo.name);
+    const dir = path46.join(targetDir, repo.name);
     manifestCapabilities(dir, repo.name, capabilities);
     const discovered = byName.get(repo.name);
     return {
@@ -24197,8 +24264,8 @@ async function buildForgeContext(targetDir, repos, opts = {}) {
 }
 
 // src/intel/predict.ts
-import { existsSync as existsSync33, readFileSync as readFileSync25, statSync as statSync8 } from "fs";
-import path46 from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync25, statSync as statSync8 } from "fs";
+import path47 from "path";
 var MAX_MANIFEST_BYTES2 = 64 * 1024;
 var SEMVERISH = /^v?\d+\.\d+\.\d+/;
 var ev2 = (source, fact) => ({
@@ -24208,9 +24275,9 @@ var ev2 = (source, fact) => ({
 var cmp3 = (a3, b) => a3 < b ? -1 : a3 > b ? 1 : 0;
 var mk2 = (id, kind, subject, certainty, version, evidence, explanation) => ({ id, kind, subject, certainty, version, evidence, explanation });
 function readManifest(repoDir) {
-  const file = path46.join(repoDir, "forge.json");
+  const file = path47.join(repoDir, "forge.json");
   try {
-    if (!existsSync33(file) || statSync8(file).size > MAX_MANIFEST_BYTES2) return null;
+    if (!existsSync34(file) || statSync8(file).size > MAX_MANIFEST_BYTES2) return null;
     const raw = JSON.parse(readFileSync25(file, "utf8"));
     return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
   } catch {
@@ -24260,7 +24327,7 @@ function declaredRefs(targetDir, repoName, m3) {
   }
   try {
     const lock = JSON.parse(
-      readFileSync25(path46.join(artifactsRoot(targetDir), "env.lock.json"), "utf8")
+      readFileSync25(path47.join(artifactsRoot(targetDir), "env.lock.json"), "utf8")
     );
     const head = lock?.forges?.[repoName]?.head;
     if (typeof head === "string" && SEMVERISH.test(head)) {
@@ -24527,7 +24594,7 @@ async function predictCompatibility(targetDir, repos, opts = {}) {
   const allClaims = [];
   for (const repo of sorted) {
     const dir = resolveInside(targetDir, repo.name);
-    if (!dir || !existsSync33(dir)) continue;
+    if (!dir || !existsSync34(dir)) continue;
     const m3 = readManifest(dir);
     manifests.set(repo.name, m3);
     if (m3) out.push(...schemaChange(repo.name, m3));
@@ -24539,7 +24606,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 || !existsSync33(dir)) continue;
+    if (!dir || !existsSync34(dir)) continue;
     out.push(...envVarFindings(repo.name, dir, repo.envKeys));
   }
   out.push(...installConflict(allClaims));
@@ -24547,13 +24614,13 @@ async function predictCompatibility(targetDir, repos, opts = {}) {
 }
 
 // src/ai/bridge.ts
-import { mkdirSync as mkdirSync13 } from "fs";
-import path48 from "path";
+import { mkdirSync as mkdirSync14 } from "fs";
+import path49 from "path";
 
 // src/ai/cache.ts
 import { createHash as createHash6 } from "crypto";
-import { existsSync as existsSync34, mkdirSync as mkdirSync12, readFileSync as readFileSync26, readdirSync as readdirSync19, rmSync as rmSync7 } from "fs";
-import path47 from "path";
+import { existsSync as existsSync35, mkdirSync as mkdirSync13, readFileSync as readFileSync26, readdirSync as readdirSync19, rmSync as rmSync8 } from "fs";
+import path48 from "path";
 
 // src/ai/types.ts
 var AI_PROPOSAL_SCHEMA = "forge/AiProposal/v1";
@@ -24636,7 +24703,7 @@ function validateProposal(proposal, catalog) {
 var AI_CACHE_MAX_ENTRIES = 32;
 var KEY_RE = /^[a-f0-9]{64}$/;
 function aiCacheDir(rootDir) {
-  return path47.join(artifactsRoot(rootDir), "ai", "cache");
+  return path48.join(artifactsRoot(rootDir), "ai", "cache");
 }
 function canonical(value) {
   if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
@@ -24651,12 +24718,12 @@ function aiCacheKey(payload) {
 }
 function entryFile(rootDir, key) {
   if (!KEY_RE.test(key)) return null;
-  return path47.join(aiCacheDir(rootDir), `${key}.json`);
+  return path48.join(aiCacheDir(rootDir), `${key}.json`);
 }
 function aiCacheGet(rootDir, key, opts) {
   if (opts.ttlMs <= 0) return null;
   const file = entryFile(rootDir, key);
-  if (!file || !existsSync34(file)) return null;
+  if (!file || !existsSync35(file)) return null;
   try {
     const entry2 = JSON.parse(readFileSync26(file, "utf8"));
     const now = opts.now ?? Date.now();
@@ -24672,7 +24739,7 @@ function aiCacheSet(rootDir, key, proposal, opts = {}) {
   const file = entryFile(rootDir, key);
   if (!file) return;
   const dir = aiCacheDir(rootDir);
-  mkdirSync12(dir, { recursive: true });
+  mkdirSync13(dir, { recursive: true });
   const entry2 = { at: opts.now ?? Date.now(), proposal };
   writeFileAtomic(file, JSON.stringify(entry2));
   evictOldest(dir, opts.maxEntries ?? AI_CACHE_MAX_ENTRIES);
@@ -24681,14 +24748,14 @@ function evictOldest(dir, maxEntries) {
   if (maxEntries < 1) return;
   let files;
   try {
-    files = readdirSync19(dir).filter((f) => KEY_RE.test(path47.basename(f, ".json")));
+    files = readdirSync19(dir).filter((f) => KEY_RE.test(path48.basename(f, ".json")));
   } catch {
     return;
   }
   if (files.length <= maxEntries) return;
-  const aged = files.map((file) => ({ file, at: entryAge(path47.join(dir, file)) })).sort((a3, b) => a3.at - b.at || a3.file.localeCompare(b.file));
+  const aged = files.map((file) => ({ file, at: entryAge(path48.join(dir, file)) })).sort((a3, b) => a3.at - b.at || a3.file.localeCompare(b.file));
   for (const { file } of aged.slice(0, aged.length - maxEntries)) {
-    rmSync7(path47.join(dir, file), { force: true });
+    rmSync8(path48.join(dir, file), { force: true });
   }
 }
 function entryAge(file) {
@@ -24745,18 +24812,18 @@ function sanitizeForAi(input) {
 }
 function assertNoSecrets(input) {
   const hits = /* @__PURE__ */ new Set();
-  const visit = (value, path52) => {
+  const visit = (value, path53) => {
     if (typeof value === "string") {
-      if (redactSecrets(value) !== value) hits.add(path52 || "<root>");
+      if (redactSecrets(value) !== value) hits.add(path53 || "<root>");
       return;
     }
     if (Array.isArray(value)) {
-      value.forEach((item, index) => visit(item, `${path52}[${index}]`));
+      value.forEach((item, index) => visit(item, `${path53}[${index}]`));
       return;
     }
     if (value && typeof value === "object") {
       for (const [key, child] of Object.entries(value)) {
-        const childPath = path52 ? `${path52}.${key}` : key;
+        const childPath = path53 ? `${path53}.${key}` : key;
         if (isDeniedKey(key)) {
           hits.add(childPath);
           continue;
@@ -24813,9 +24880,9 @@ async function runAiBridge(req, cfg, deps) {
   if (Buffer.byteLength(body, "utf8") > cfg.maxContextBytes) {
     return { ok: false, reason: "bridge-error", detail: "context-too-large" };
   }
-  const aiDir = path48.join(artifactsRoot(rootDir), "ai");
-  mkdirSync13(aiDir, { recursive: true });
-  const contextFile = path48.join(aiDir, `context-${digest}.json`);
+  const aiDir = path49.join(artifactsRoot(rootDir), "ai");
+  mkdirSync14(aiDir, { recursive: true });
+  const contextFile = path49.join(aiDir, `context-${digest}.json`);
   writeFileAtomic(contextFile, body);
   const argv = command.map((part) => part === "{context}" ? contextFile : part);
   if (!command.includes("{context}")) argv.push(contextFile);
@@ -24856,8 +24923,8 @@ async function runAiBridge(req, cfg, deps) {
 }
 
 // src/portability/bundle.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync14, readFileSync as readFileSync27 } from "fs";
-import path49 from "path";
+import { existsSync as existsSync36, mkdirSync as mkdirSync15, readFileSync as readFileSync27 } from "fs";
+import path50 from "path";
 
 // src/portability/manifest.ts
 import { createHash as createHash7 } from "crypto";
@@ -24944,19 +25011,19 @@ var SecretKeysRefusedError = class extends Error {
 function writeJson(dest, doc) {
   const content = JSON.stringify(doc, null, 2);
   writeFileAtomic(dest, content);
-  return { path: path49.basename(dest), content };
+  return { path: path50.basename(dest), content };
 }
 function pinVersion(repoDir) {
   for (const file of ["forge.json", "package.json"]) {
     try {
-      const parsed = JSON.parse(readFileSync27(path49.join(repoDir, file), "utf8"));
+      const parsed = JSON.parse(readFileSync27(path50.join(repoDir, file), "utf8"));
       const v = parsed?.version;
       if (typeof v === "string" && v) return v;
     } catch {
     }
   }
   try {
-    const pyproject = readFileSync27(path49.join(repoDir, "pyproject.toml"), "utf8");
+    const pyproject = readFileSync27(path50.join(repoDir, "pyproject.toml"), "utf8");
     const m3 = /^version\s*=\s*"([^"]+)"/m.exec(pyproject);
     if (m3) return m3[1];
   } catch {
@@ -24967,8 +25034,8 @@ function collectPins(targetDir, repos) {
   const state = loadState(targetDir);
   const pins = /* @__PURE__ */ new Map();
   for (const repo of repos) {
-    const repoDir = path49.join(targetDir, repo.name);
-    const version = existsSync35(repoDir) ? pinVersion(repoDir) : void 0;
+    const repoDir = path50.join(targetDir, repo.name);
+    const version = existsSync36(repoDir) ? pinVersion(repoDir) : void 0;
     const head = state?.repos[repo.name]?.head;
     const ref = state?.pins?.[repo.name] ?? head;
     pins.set(repo.name, {
@@ -24994,15 +25061,15 @@ async function exportBundle(targetDir, repos, dest, opts) {
   }
   const schemaByRepo = /* @__PURE__ */ new Map();
   for (const repo of repos) {
-    const repoDir = path49.join(targetDir, repo.name);
-    const schema = existsSync35(repoDir) ? deriveSchema(repoDir, repo.envKeys) : { vars: [] };
+    const repoDir = path50.join(targetDir, repo.name);
+    const schema = existsSync36(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);
     }
   }
   if (refused.size) throw new SecretKeysRefusedError([...refused]);
-  mkdirSync14(dest, { recursive: true });
+  mkdirSync15(dest, { recursive: true });
   const inputs = [];
   const produced = [
     BUNDLE_FILES.envelope,
@@ -25015,29 +25082,29 @@ async function exportBundle(targetDir, repos, dest, opts) {
     BUNDLE_FILES.integrity
   ].sort();
   inputs.push(
-    writeJson(path49.join(dest, BUNDLE_FILES.envelope), {
+    writeJson(path50.join(dest, BUNDLE_FILES.envelope), {
       schema: BUNDLE_SCHEMA,
       generatedAt: now,
       files: produced
     })
   );
-  const profile = { ...exportProfile(targetDir, path49.join(dest, BUNDLE_FILES.profile)) };
+  const profile = { ...exportProfile(targetDir, path50.join(dest, BUNDLE_FILES.profile)) };
   const normalizedProfile = { ...profile, exported_at: now };
-  inputs.push(writeJson(path49.join(dest, BUNDLE_FILES.profile), normalizedProfile));
+  inputs.push(writeJson(path50.join(dest, BUNDLE_FILES.profile), normalizedProfile));
   const lock = { ...writeEnvLock(targetDir, repos), generated_at: now };
-  inputs.push(writeJson(path49.join(dest, BUNDLE_FILES.lock), lock));
-  inputs.push(writeJson(path49.join(dest, BUNDLE_FILES.lockCheck), checkEnvLock(targetDir, repos)));
+  inputs.push(writeJson(path50.join(dest, BUNDLE_FILES.lock), lock));
+  inputs.push(writeJson(path50.join(dest, BUNDLE_FILES.lockCheck), checkEnvLock(targetDir, repos)));
   const envKeys = {};
   for (const repo of repos) {
     const keys = [...new Set((schemaByRepo.get(repo.name)?.vars ?? []).map((v) => v.key))].sort();
     envKeys[repo.name] = keys;
   }
-  inputs.push(writeJson(path49.join(dest, BUNDLE_FILES.envKeys), envKeys));
+  inputs.push(writeJson(path50.join(dest, BUNDLE_FILES.envKeys), envKeys));
   if (whitelist.length) {
     const values = {};
     for (const repo of repos) {
-      const envFile = path49.join(targetDir, repo.name, ".env");
-      if (!existsSync35(envFile)) continue;
+      const envFile = path50.join(targetDir, repo.name, ".env");
+      if (!existsSync36(envFile)) continue;
       const entries = parseEnv(readFileSync27(envFile, "utf8")).entries;
       const found = {};
       for (const key of whitelist) {
@@ -25046,11 +25113,11 @@ async function exportBundle(targetDir, repos, dest, opts) {
       }
       if (Object.keys(found).length) values[repo.name] = found;
     }
-    inputs.push(writeJson(path49.join(dest, BUNDLE_FILES.envValues), values));
+    inputs.push(writeJson(path50.join(dest, BUNDLE_FILES.envValues), values));
   }
-  inputs.push(writeJson(path49.join(dest, BUNDLE_FILES.pins), collectPins(targetDir, repos)));
+  inputs.push(writeJson(path50.join(dest, BUNDLE_FILES.pins), collectPins(targetDir, repos)));
   const manifest = buildIntegrityManifest(inputs, { now });
-  inputs.push(writeJson(path49.join(dest, BUNDLE_FILES.integrity), manifest));
+  inputs.push(writeJson(path50.join(dest, BUNDLE_FILES.integrity), manifest));
   return { ok: true, dir: dest, files: produced, manifest };
 }
 function readJsonFile(file) {
@@ -25104,38 +25171,38 @@ function readPins(file) {
 function importBundle(src, opts) {
   const read = (p) => {
     try {
-      return readFileSync27(path49.join(src, p));
+      return readFileSync27(path50.join(src, p));
     } catch {
       return null;
     }
   };
-  const manifestRaw = readJsonFile(path49.join(src, BUNDLE_FILES.integrity));
+  const manifestRaw = readJsonFile(path50.join(src, BUNDLE_FILES.integrity));
   const manifest = manifestRaw && typeof manifestRaw === "object" && manifestRaw.schema === "forge/IntegrityManifest/v1" ? manifestRaw : null;
   const verify = opts?.verifyIntegrity === false ? { ok: true } : verifyIntegrityManifest(manifest, read);
-  const profile = importProfile(path49.join(src, BUNDLE_FILES.profile));
+  const profile = importProfile(path50.join(src, BUNDLE_FILES.profile));
   return {
     dir: src,
     verify,
     manifest,
     profile: "error" in profile ? null : profile,
-    lockfile: readLockfile(path49.join(src, BUNDLE_FILES.lock)),
-    lockCheck: readLockCheck(path49.join(src, BUNDLE_FILES.lockCheck)),
-    envKeys: readStringMap(path49.join(src, BUNDLE_FILES.envKeys)),
-    envValues: readValueMap(path49.join(src, BUNDLE_FILES.envValues)),
-    pins: readPins(path49.join(src, BUNDLE_FILES.pins))
+    lockfile: readLockfile(path50.join(src, BUNDLE_FILES.lock)),
+    lockCheck: readLockCheck(path50.join(src, BUNDLE_FILES.lockCheck)),
+    envKeys: readStringMap(path50.join(src, BUNDLE_FILES.envKeys)),
+    envValues: readValueMap(path50.join(src, BUNDLE_FILES.envValues)),
+    pins: readPins(path50.join(src, BUNDLE_FILES.pins))
   };
 }
 
 // src/intel/learning.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync15, readFileSync as readFileSync28 } from "fs";
-import path50 from "path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync16, readFileSync as readFileSync28 } from "fs";
+import path51 from "path";
 var LEARNING_SCHEMA = "forge-cli/LearningStore/v1";
 function learningFile(targetDir) {
-  return path50.join(artifactsRoot(targetDir), "learning.json");
+  return path51.join(artifactsRoot(targetDir), "learning.json");
 }
 function readStore(targetDir) {
   const file = learningFile(targetDir);
-  if (!existsSync36(file)) return { schema: LEARNING_SCHEMA, enabled: false, observations: [] };
+  if (!existsSync37(file)) return { schema: LEARNING_SCHEMA, enabled: false, observations: [] };
   try {
     const parsed = JSON.parse(readFileSync28(file, "utf8"));
     if (parsed?.schema !== LEARNING_SCHEMA || !Array.isArray(parsed.observations)) {
@@ -25154,7 +25221,7 @@ function readStore(targetDir) {
 }
 function writeStore(targetDir, store) {
   const file = learningFile(targetDir);
-  mkdirSync15(path50.dirname(file), { recursive: true });
+  mkdirSync16(path51.dirname(file), { recursive: true });
   writeFileAtomic(file, JSON.stringify(store, null, 2));
 }
 function learningStatus(targetDir) {
@@ -25395,8 +25462,8 @@ async function runLearningCommand(cli) {
 }
 
 // src/wizard.ts
-import { existsSync as existsSync37 } from "fs";
-import path51 from "path";
+import { existsSync as existsSync38 } from "fs";
+import path52 from "path";
 var STEP_LABELS = [
   S.wizardStepDetect,
   S.wizardStepRecommend,
@@ -25435,8 +25502,8 @@ function renderOperationPlan(plan) {
   return lines.join("\n");
 }
 function planActionsFor(repo, targetDir, steps) {
-  const repoDir = path51.join(targetDir, repo.name);
-  const cloned = existsSync37(repoDir) && hasGitRepo(repoDir);
+  const repoDir = path52.join(targetDir, repo.name);
+  const cloned = existsSync38(repoDir) && hasGitRepo(repoDir);
   const actions = [
     {
       kind: "clone",
@@ -25456,7 +25523,7 @@ function planActionsFor(repo, targetDir, steps) {
   actions.push({
     kind: "env",
     label: "provisionar .env (nunca sobrescreve)",
-    paths: [path51.join(repo.name, ".env")],
+    paths: [path52.join(repo.name, ".env")],
     reversible: false
   });
   if (steps.includes("skills")) {
@@ -25606,7 +25673,7 @@ async function runWizard(cli) {
   const planForges = repos.map((repo) => ({
     forge_id: repo.name,
     repo: repo.name,
-    target_dir: path51.join(targetDir, repo.name),
+    target_dir: path52.join(targetDir, repo.name),
     actions: filterSteps(planActionsFor(repo, targetDir, steps), steps)
   }));
   const plan = buildPlan({
@@ -26000,7 +26067,8 @@ async function main() {
     log.error(S.errReinstallNeedsNames);
     process.exit(2);
   }
-  if (resolved.command === "install" && cli.method === "registry") {
+  const installWantsRegistry = resolved.command === "install" && cli.method !== "git" && (cli.method === "registry" || resolved.names.length > 0 || cli.all === true || (cli.only?.length ?? 0) > 0 || isNonInteractive(cli));
+  if (installWantsRegistry) {
     const names = resolved.names.length ? resolved.names : cli.all ? registryNames() : cli.only ?? [];
     if (!names.length) {
       log.error(S.errRegistryNeedsNames);