jorgex-stack 1.0.31 → 1.1.1

package/dist/cli.js

@@ -5,8 +5,8 @@ import * as p6 from "@clack/prompts";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/install.ts
-import fs13 from "fs";
-import path19 from "path";
+import fs15 from "fs";
+import path21 from "path";
 import * as p from "@clack/prompts";
 
 // src/adapters/opencode.ts
@@ -48,6 +48,10 @@ function loadCanonicalAgents(agentsDir) {
     return parseCanonicalAgent(source, file);
   });
 }
+var DEVTOOLS_MCP_SERVER = "chrome-devtools";
+function isCanonicalMcpServerEnabled(name, server, enabledServers) {
+  return !server.optional || server.defaultEnabled === true || enabledServers?.has(name) === true;
+}
 function loadCanonicalMcp(stackDir) {
   return JSON.parse(fs.readFileSync(path.join(stackDir, "mcp", "servers.json"), "utf8"));
 }
@@ -221,7 +225,7 @@ function ensureModelMapFile() {
 // src/lib/detect.ts
 import path5 from "path";
 import { existsSync as existsSync3, statSync } from "fs";
-import { execFileSync, execSync } from "child_process";
+import { execFileSync } from "child_process";
 function lookPath(cmd) {
   const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ".ps1", ""] : [""];
   for (const dir of (process.env.PATH ?? "").split(path5.delimiter)) {
@@ -233,17 +237,24 @@ function lookPath(cmd) {
   }
   return null;
 }
+function planDetectedBinCommand(bin, args) {
+  if (process.platform !== "win32" || !/\.(cmd|bat)$/i.test(bin)) return { command: bin, args };
+  if ([bin, ...args].some((part) => /[&|<>()^%!"\r\n]/.test(part))) return null;
+  const quote = (part) => part === "" || /\s/.test(part) ? `"${part}"` : part;
+  return {
+    command: process.env.ComSpec ?? "cmd.exe",
+    args: ["/d", "/s", "/c", [quote(bin), ...args.map(quote)].join(" ")]
+  };
+}
 function runDetectedBin(bin, args, timeoutMs) {
   try {
-    if (process.platform === "win32" && /\.(cmd|bat)$/i.test(bin)) {
-      if (/[&|<>^%!"]/.test(bin)) return null;
-      return execSync(`"${bin}" ${args.join(" ")}`, {
-        encoding: "utf8",
-        timeout: timeoutMs,
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-    }
-    return execFileSync(bin, args, { encoding: "utf8", timeout: timeoutMs, stdio: ["ignore", "pipe", "pipe"] });
+    const command = planDetectedBinCommand(bin, args);
+    if (command === null) return null;
+    return execFileSync(command.command, command.args, {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
   } catch {
     return null;
   }
@@ -505,6 +516,14 @@ var GIT_GUARD_SCRIPT = "block-destructive-git.cjs";
 function yamlString(value) {
   return JSON.stringify(value);
 }
+function isManagedOptionalStdioServer(server, value) {
+  if (!server.optional || server.transport !== "stdio" || value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const current = value;
+  const expectedCommand = [server.command, ...server.args ?? []];
+  return Object.keys(current).length === 2 && current.type === "local" && Array.isArray(current.command) && current.command.length === expectedCommand.length && current.command.every((arg, index) => arg === expectedCommand[index]);
+}
 var opencodeAdapter = {
   id: "opencode",
   name: "OpenCode",
@@ -636,6 +655,7 @@ ${agent.body}`,
     const original = readTextIfExists(file);
     const contentSource = original === null || original.trim() === "" ? null : original;
     const isFreshConfig = contentSource === null;
+    const mcpOwnership = [];
     const content = upsertJson(contentSource, (root) => {
       root["$schema"] ??= "https://opencode.ai/config.json";
       const defaults = loadCanonicalDefaults(ctx.stackDir)["opencode"];
@@ -647,6 +667,22 @@ ${agent.body}`,
       }
       const mcp = root["mcp"] ??= {};
       for (const [name, server] of Object.entries(canonical.servers)) {
+        const existing = mcp[name];
+        const owned = ctx.ownedMcpServers?.has(name) === true;
+        if (!isCanonicalMcpServerEnabled(name, server, ctx.enabledMcpServers)) {
+          if (owned) {
+            if (isManagedOptionalStdioServer(server, existing)) delete mcp[name];
+            mcpOwnership.push({ server: name, owned: false });
+          }
+          continue;
+        }
+        if (server.optional && existing !== void 0) {
+          if (!owned || !isManagedOptionalStdioServer(server, existing)) {
+            if (owned) mcpOwnership.push({ server: name, owned: false });
+            ctx.warnings.push(`OpenCode: MCP opcional '${name}' ya pertenece a la configuraci\xF3n del usuario; se conserva.`);
+            continue;
+          }
+        }
         if (server.transport === "stdio") {
           if (server.command === "{{ENGRAM_BIN}}" && ctx.engramBin === null) {
             ctx.warnings.push(
@@ -656,6 +692,7 @@ ${agent.body}`,
           }
           const command = server.command === "{{ENGRAM_BIN}}" ? ctx.engramBin : server.command;
           mcp[name] = { type: "local", command: [command, ...server.args ?? []] };
+          if (server.optional && existing === void 0 && !owned) mcpOwnership.push({ server: name, owned: true });
         } else {
           const previous = mcp[name];
           const headers = {};
@@ -685,7 +722,7 @@ ${agent.body}`,
         }
       }
     });
-    return [{ kind: "write", target: file, content }];
+    return [{ kind: "write", target: file, content, ...mcpOwnership.length > 0 ? { mcpOwnership } : {} }];
   },
   planUnmerge(mcp, hooks, ctx) {
     const actions = [];
@@ -694,15 +731,26 @@ ${agent.body}`,
     if (prompt !== null) {
       let content = removeMarkdownSection(prompt, "system-prompt");
       content = removeMarkdownSection(content, "engram-protocol");
+      content = removeMarkdownSection(content, "browser");
       actions.push({ kind: "write", target: systemPromptFile, content });
     }
     const configFile = path7.join(ctx.configDir, "opencode.json");
     const config = readTextIfExists(configFile);
     if (config !== null) {
+      const mcpOwnership = [];
       const content = upsertJson(config, (root) => {
         const mcpBlock = root["mcp"];
         if (mcpBlock) {
-          for (const name of Object.keys(mcp.servers)) delete mcpBlock[name];
+          for (const [name, server] of Object.entries(mcp.servers)) {
+            if (!server.optional) {
+              delete mcpBlock[name];
+              continue;
+            }
+            if (ctx.ownedMcpServers?.has(name) === true) {
+              if (isManagedOptionalStdioServer(server, mcpBlock[name])) delete mcpBlock[name];
+              mcpOwnership.push({ server: name, owned: false });
+            }
+          }
           if (Object.keys(mcpBlock).length === 0) delete root["mcp"];
         }
         const plugin = root["plugin"];
@@ -713,7 +761,7 @@ ${agent.body}`,
           else root["plugin"] = kept;
         }
       });
-      actions.push({ kind: "write", target: configFile, content });
+      actions.push({ kind: "write", target: configFile, content, ...mcpOwnership.length > 0 ? { mcpOwnership } : {} });
     }
     const hooksFile = path7.join(ctx.configDir, "hooks.json");
     const hooksJson = readTextIfExists(hooksFile);
@@ -773,6 +821,14 @@ function hasEngramPlugin(configDir) {
     return false;
   }
 }
+function isManagedOptionalStdioServer2(server, value) {
+  if (!server.optional || server.transport !== "stdio" || value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const current = value;
+  const expectedArgs = server.args ?? [];
+  return Object.keys(current).length === 3 && current.type === "stdio" && current.command === server.command && Array.isArray(current.args) && current.args.length === expectedArgs.length && current.args.every((arg, index) => arg === expectedArgs[index]);
+}
 var claudeCodeAdapter = {
   id: "claude-code",
   name: "Claude Code",
@@ -860,9 +916,26 @@ ${agent.body}`,
   },
   planMainConfig(canonical, ctx) {
     const file = path8.join(path8.dirname(ctx.configDir), `${path8.basename(ctx.configDir)}.json`);
+    const mcpOwnership = [];
     const content = upsertJson(readTextIfExists(file), (root) => {
       const servers = root["mcpServers"] ??= {};
       for (const [name, server] of Object.entries(canonical.servers)) {
+        const existing = servers[name];
+        const owned = ctx.ownedMcpServers?.has(name) === true;
+        if (!isCanonicalMcpServerEnabled(name, server, ctx.enabledMcpServers)) {
+          if (owned) {
+            if (isManagedOptionalStdioServer2(server, existing)) delete servers[name];
+            mcpOwnership.push({ server: name, owned: false });
+          }
+          continue;
+        }
+        if (server.optional && existing !== void 0) {
+          if (!owned || !isManagedOptionalStdioServer2(server, existing)) {
+            if (owned) mcpOwnership.push({ server: name, owned: false });
+            ctx.warnings.push(`Claude Code: MCP opcional '${name}' ya pertenece a la configuraci\xF3n del usuario; se conserva.`);
+            continue;
+          }
+        }
         if (server.transport === "stdio") {
           if (server.command === "{{ENGRAM_BIN}}" && hasEngramPlugin(ctx.configDir)) {
             if (name in servers) delete servers[name];
@@ -879,6 +952,7 @@ ${agent.body}`,
           }
           const command = server.command === "{{ENGRAM_BIN}}" ? ctx.engramBin : server.command;
           servers[name] = { type: "stdio", command, args: server.args ?? [] };
+          if (server.optional && existing === void 0 && !owned) mcpOwnership.push({ server: name, owned: true });
         } else {
           const previous = servers[name];
           const headers = {};
@@ -894,7 +968,7 @@ ${agent.body}`,
         }
       }
     });
-    return [{ kind: "write", target: file, content }];
+    return [{ kind: "write", target: file, content, ...mcpOwnership.length > 0 ? { mcpOwnership } : {} }];
   },
   planUnmerge(mcp, hooks, ctx) {
     const actions = [];
@@ -903,6 +977,7 @@ ${agent.body}`,
     if (prompt !== null) {
       let content = removeMarkdownSection(prompt, "system-prompt");
       content = removeMarkdownSection(content, "engram-protocol");
+      content = removeMarkdownSection(content, "browser");
       actions.push({ kind: "write", target: systemPromptFile, content });
     }
     const settingsFile = path8.join(ctx.configDir, "settings.json");
@@ -916,13 +991,23 @@ ${agent.body}`,
     const mainFile = path8.join(path8.dirname(ctx.configDir), `${path8.basename(ctx.configDir)}.json`);
     const main2 = readTextIfExists(mainFile);
     if (main2 !== null) {
+      const mcpOwnership = [];
       const content = upsertJson(main2, (root) => {
         const servers = root["mcpServers"];
         if (!servers) return;
-        for (const name of Object.keys(mcp.servers)) delete servers[name];
+        for (const [name, server] of Object.entries(mcp.servers)) {
+          if (!server.optional) {
+            delete servers[name];
+            continue;
+          }
+          if (ctx.ownedMcpServers?.has(name) === true) {
+            if (isManagedOptionalStdioServer2(server, servers[name])) delete servers[name];
+            mcpOwnership.push({ server: name, owned: false });
+          }
+        }
         if (Object.keys(servers).length === 0) delete root["mcpServers"];
       });
-      actions.push({ kind: "write", target: mainFile, content });
+      actions.push({ kind: "write", target: mainFile, content, ...mcpOwnership.length > 0 ? { mcpOwnership } : {} });
     }
     return actions;
   }
@@ -940,6 +1025,14 @@ function tomlMultiline(value) {
 ${value.replace(/\r\n/g, "\n").trim()}
 '''`;
 }
+function stdioMcpSection(server) {
+  const args = (server.args ?? []).map(tomlString).join(", ");
+  return `command = ${tomlString(server.command)}
+args = [${args}]`;
+}
+function isManagedOptionalStdioServer3(server, section) {
+  return server.optional === true && server.transport === "stdio" && section?.trim() === stdioMcpSection(server);
+}
 function hasActiveEngramPlugin(configDir) {
   const config = readTextIfExists(path9.join(configDir, "config.toml"));
   if (config === null) return false;
@@ -1043,6 +1136,7 @@ ${body}`
     const original = readTextIfExists(file);
     const contentSource = original === null || original.trim() === "" ? null : original;
     let content = contentSource;
+    const mcpOwnership = [];
     if (contentSource === null) {
       const defaults = loadCanonicalDefaults(ctx.stackDir)["codex"] ?? {};
       for (const [key, value] of Object.entries(defaults)) {
@@ -1089,6 +1183,22 @@ ${body}`
     }
     for (const [name, server] of Object.entries(canonical.servers)) {
       const section = `mcp_servers.${name}`;
+      const existing = readTomlSection(content, section);
+      const owned = ctx.ownedMcpServers?.has(name) === true;
+      if (!isCanonicalMcpServerEnabled(name, server, ctx.enabledMcpServers)) {
+        if (owned) {
+          if (isManagedOptionalStdioServer3(server, existing)) content = removeTomlSection(content, section);
+          mcpOwnership.push({ server: name, owned: false });
+        }
+        continue;
+      }
+      if (server.optional && existing !== null) {
+        if (!owned || !isManagedOptionalStdioServer3(server, existing)) {
+          if (owned) mcpOwnership.push({ server: name, owned: false });
+          ctx.warnings.push(`Codex: MCP opcional '${name}' ya pertenece a la configuraci\xF3n del usuario; se conserva.`);
+          continue;
+        }
+      }
       if (server.transport === "stdio") {
         if (server.command === "{{ENGRAM_BIN}}" && hasActiveEngramPlugin(ctx.configDir)) {
           if (content !== null) content = removeTomlSection(content, section);
@@ -1104,9 +1214,9 @@ ${body}`
           continue;
         }
         const command = server.command === "{{ENGRAM_BIN}}" ? ctx.engramBin : server.command;
-        const args = (server.args ?? []).map(tomlString).join(", ");
         content = upsertTomlSection(content, section, `command = ${tomlString(command)}
-args = [${args}]`);
+args = [${(server.args ?? []).map(tomlString).join(", ")}]`);
+        if (server.optional && existing === null && !owned) mcpOwnership.push({ server: name, owned: true });
       } else {
         const previousSection = readTomlSection(content, section);
         const prevUsesEnvHeaders = previousSection?.includes("env_http_headers") ?? false;
@@ -1127,7 +1237,7 @@ args = [${args}]`);
     }
     if (content === null) return [];
     if (!content.endsWith("\n")) content += "\n";
-    return [{ kind: "write", target: file, content }];
+    return [{ kind: "write", target: file, content, ...mcpOwnership.length > 0 ? { mcpOwnership } : {} }];
   },
   planUnmerge(mcp, hooks, ctx) {
     const actions = [];
@@ -1136,14 +1246,28 @@ args = [${args}]`);
     if (prompt !== null) {
       let content = removeMarkdownSection(prompt, "system-prompt");
       content = removeMarkdownSection(content, "engram-protocol");
+      content = removeMarkdownSection(content, "browser");
       actions.push({ kind: "write", target: systemPromptFile, content });
     }
     const configFile = path9.join(ctx.configDir, "config.toml");
     const config = readTextIfExists(configFile);
     if (config !== null) {
       let content = config;
-      for (const name of Object.keys(mcp.servers)) content = removeTomlSection(content, `mcp_servers.${name}`);
-      actions.push({ kind: "write", target: configFile, content });
+      const mcpOwnership = [];
+      for (const [name, server] of Object.entries(mcp.servers)) {
+        const section = `mcp_servers.${name}`;
+        if (!server.optional) {
+          content = removeTomlSection(content, section);
+          continue;
+        }
+        if (ctx.ownedMcpServers?.has(name) === true) {
+          if (isManagedOptionalStdioServer3(server, readTomlSection(content, section))) {
+            content = removeTomlSection(content, section);
+          }
+          mcpOwnership.push({ server: name, owned: false });
+        }
+      }
+      actions.push({ kind: "write", target: configFile, content, ...mcpOwnership.length > 0 ? { mcpOwnership } : {} });
     }
     const hooksFile = path9.join(ctx.configDir, "hooks.json");
     const hooksJson = readTextIfExists(hooksFile);
@@ -1409,6 +1533,10 @@ function planSystemPrompt(adapter, ctx) {
     normalize2(fs10.readFileSync(path14.join(ctx.stackDir, "system-prompt", "engram-protocol.md"), "utf8"))
   );
   const composedAgentsMd = composeProgrammaticSystemPrompt(ctx.stackDir, agentsMd, ctx.mode);
+  const browser = [
+    ctx.playwrightCliEnabled ? "browser-playwright.md" : null,
+    ctx.enabledMcpServers?.has(DEVTOOLS_MCP_SERVER) ? "browser-chrome-devtools.md" : null
+  ].filter((file) => file !== null).map((file) => normalize2(fs10.readFileSync(path14.join(ctx.stackDir, "system-prompt", file), "utf8"))).join("\n\n");
   let content = readTextIfExists(target);
   content = upsertMarkdownSection(content, "system-prompt", composedAgentsMd);
   if (adapter.injectEngramProtocol(ctx)) {
@@ -1416,6 +1544,7 @@ function planSystemPrompt(adapter, ctx) {
   } else {
     content = removeMarkdownSection(content, "engram-protocol");
   }
+  content = browser === "" ? removeMarkdownSection(content, "browser") : upsertMarkdownSection(content, "browser", browser);
   return [{ kind: "write", target, content }];
 }
 
@@ -1517,13 +1646,256 @@ function planPlugins(adapter, ctx) {
   });
 }
 
+// src/lib/external-tools.ts
+import fs13 from "fs";
+import os2 from "os";
+import path19 from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+var PLAYWRIGHT_CLI = {
+  packageName: "@playwright/cli",
+  bin: "playwright-cli",
+  version: "0.1.17",
+  browserInstallAction: "install-browser"
+};
+function parsePlaywrightCliVersion(output) {
+  if (output === null) return null;
+  return /^(?:playwright-cli\s+)?(\d+\.\d+\.\d+)$/i.exec(output.trim())?.[1] ?? null;
+}
+function resolvePlaywrightCliState({ binPath, versionOutput }) {
+  if (binPath === null) return { status: "absent", binPath: null, detectedVersion: null };
+  const detectedVersion = parsePlaywrightCliVersion(versionOutput);
+  if (detectedVersion === null) return { status: "broken", binPath, detectedVersion: null };
+  return {
+    status: detectedVersion === PLAYWRIGHT_CLI.version ? "current" : "outdated",
+    binPath,
+    detectedVersion
+  };
+}
+function detectPlaywrightCli() {
+  const binPath = lookPath(PLAYWRIGHT_CLI.bin);
+  return resolvePlaywrightCliState({
+    binPath,
+    versionOutput: binPath ? runDetectedBin(binPath, ["--version"], 5e3) : null
+  });
+}
+function resolvePnpmBin() {
+  const pnpm = lookPath("pnpm");
+  if (pnpm !== null && !pnpm.toLowerCase().endsWith(".ps1")) return pnpm;
+  const pnpmCmd = lookPath("pnpm.cmd");
+  return pnpmCmd !== null && !pnpmCmd.toLowerCase().endsWith(".ps1") ? pnpmCmd : null;
+}
+function isPlaywrightBrowserReady(env = process.env, platform = process.platform, homeDir = os2.homedir()) {
+  const configuredPath = env.PLAYWRIGHT_BROWSERS_PATH;
+  const cacheDir = configuredPath ?? (platform === "win32" ? path19.join(env.LOCALAPPDATA ?? path19.join(homeDir, "AppData", "Local"), "ms-playwright") : platform === "darwin" ? path19.join(homeDir, "Library", "Caches", "ms-playwright") : path19.join(env.XDG_CACHE_HOME ?? path19.join(homeDir, ".cache"), "ms-playwright"));
+  if (configuredPath === "0") return { status: "missing", path: cacheDir, errorCode: "DISABLED" };
+  try {
+    const ready = fs13.readdirSync(cacheDir, { withFileTypes: true }).some(
+      (entry) => entry.isDirectory() && /^chromium(?:_headless_shell)?-/.test(entry.name)
+    );
+    return ready ? { status: "ready", path: cacheDir } : { status: "missing", path: cacheDir };
+  } catch (error) {
+    const errorCode = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "UNKNOWN";
+    return errorCode === "ENOENT" ? { status: "missing", path: cacheDir, errorCode } : { status: "unreadable", path: cacheDir, errorCode };
+  }
+}
+function planPlaywrightCliCommand(action, pnpmBin) {
+  const pinnedPackage = `${PLAYWRIGHT_CLI.packageName}@${PLAYWRIGHT_CLI.version}`;
+  switch (action) {
+    case "install":
+    case "update":
+      return { command: pnpmBin, args: ["add", "--global", pinnedPackage] };
+    case "remove":
+      return { command: pnpmBin, args: ["remove", "--global", PLAYWRIGHT_CLI.packageName] };
+    case "install-browser":
+      return { command: pnpmBin, args: ["dlx", pinnedPackage, PLAYWRIGHT_CLI.browserInstallAction] };
+  }
+}
+function executePlaywrightToolAction(action, pnpmBin = resolvePnpmBin()) {
+  if (pnpmBin === null) return false;
+  const command = planPlaywrightCliCommand(action, pnpmBin);
+  const invocation = planDetectedBinCommand(command.command, command.args);
+  if (invocation === null) return false;
+  try {
+    execFileSync2(invocation.command, invocation.args, { stdio: "inherit" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/tool-preferences.ts
+import fs14 from "fs";
+import path20 from "path";
+var PLAYWRIGHT_CLI_PREFERENCE_VERSION = 1;
+var DEVTOOLS_MCP_PREFERENCE_VERSION = 1;
+function readPreference(file) {
+  try {
+    return { raw: fs14.readFileSync(file, "utf8"), errorCode: null };
+  } catch (error) {
+    const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "UNKNOWN";
+    return code === "ENOENT" ? { raw: null, errorCode: null } : { raw: null, errorCode: code };
+  }
+}
+function playwrightCliPreferenceFile(stateDir = dataDir()) {
+  return path20.join(stateDir, "playwright-cli.json");
+}
+function parsePlaywrightCliPreference(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (value.version !== PLAYWRIGHT_CLI_PREFERENCE_VERSION || typeof value.enabled !== "boolean") return void 0;
+    return value.enabled;
+  } catch {
+    return void 0;
+  }
+}
+function playwrightCliPreferenceError(file = playwrightCliPreferenceFile()) {
+  const { raw, errorCode } = readPreference(file);
+  if (errorCode !== null) {
+    return `Playwright CLI: no se pudo leer la preferencia en ${file} (${errorCode}). Corrige o borra ese archivo antes de reintentar.`;
+  }
+  if (raw === null || parsePlaywrightCliPreference(raw) !== void 0) return null;
+  return `Playwright CLI: preferencia inv\xE1lida en ${file}. Corrige o borra ese archivo antes de reintentar.`;
+}
+function loadPlaywrightCliPreference(file = playwrightCliPreferenceFile()) {
+  const { raw } = readPreference(file);
+  if (raw === null) return void 0;
+  return parsePlaywrightCliPreference(raw);
+}
+function savePlaywrightCliPreference(file, enabled) {
+  const error = playwrightCliPreferenceError(file);
+  if (error !== null) throw new Error(error);
+  writeText(file, JSON.stringify({ version: PLAYWRIGHT_CLI_PREFERENCE_VERSION, enabled }) + "\n");
+}
+function devtoolsMcpPreferenceFile(stateDir = dataDir()) {
+  return path20.join(stateDir, "devtools-mcp.json");
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isRuntimeId(value) {
+  return value === "claude-code" || value === "codex" || value === "opencode";
+}
+function parseDevtoolsMcpState(raw) {
+  try {
+    const value = JSON.parse(raw);
+    if (!isRecord(value) || value.version !== DEVTOOLS_MCP_PREFERENCE_VERSION || !isRecord(value.enabled) || !isRecord(value.owned)) return null;
+    const enabled = {};
+    for (const [runtime, selected] of Object.entries(value.enabled)) {
+      if (!isRuntimeId(runtime) || typeof selected !== "boolean") return null;
+      enabled[runtime] = selected;
+    }
+    const owned = {};
+    for (const [runtime, servers] of Object.entries(value.owned)) {
+      if (!isRuntimeId(runtime) || !isRecord(servers)) return null;
+      const managed = {};
+      for (const [server, marked] of Object.entries(servers)) {
+        if (marked !== true) return null;
+        managed[server] = true;
+      }
+      if (Object.keys(managed).length > 0) owned[runtime] = managed;
+    }
+    return { version: DEVTOOLS_MCP_PREFERENCE_VERSION, enabled, owned };
+  } catch {
+    return null;
+  }
+}
+function loadDevtoolsMcpState(file) {
+  const empty = { version: DEVTOOLS_MCP_PREFERENCE_VERSION, enabled: {}, owned: {} };
+  const { raw } = readPreference(file);
+  if (raw === null) return empty;
+  return parseDevtoolsMcpState(raw) ?? empty;
+}
+function devtoolsMcpPreferenceError(file = devtoolsMcpPreferenceFile()) {
+  const { raw, errorCode } = readPreference(file);
+  if (errorCode !== null) {
+    return `Chrome DevTools MCP: no se pudo leer la preferencia en ${file} (${errorCode}). Corrige o borra ese archivo antes de reintentar.`;
+  }
+  if (raw === null || parseDevtoolsMcpState(raw) !== null) return null;
+  return `Chrome DevTools MCP: preferencia inv\xE1lida en ${file}. Corrige o borra ese archivo antes de reintentar.`;
+}
+function saveDevtoolsMcpState(file, state) {
+  const error = devtoolsMcpPreferenceError(file);
+  if (error !== null) throw new Error(error);
+  writeText(file, JSON.stringify(state) + "\n");
+}
+function loadDevtoolsMcpPreference(file, runtime) {
+  return loadDevtoolsMcpState(file).enabled[runtime] === true;
+}
+function saveDevtoolsMcpPreference(file, runtime, enabled) {
+  const state = loadDevtoolsMcpState(file);
+  state.enabled[runtime] = enabled;
+  saveDevtoolsMcpState(file, state);
+}
+function loadDevtoolsMcpOwnership(file, runtime, server) {
+  return loadDevtoolsMcpState(file).owned[runtime]?.[server] === true;
+}
+function saveDevtoolsMcpOwnership(file, runtime, server, owned) {
+  const state = loadDevtoolsMcpState(file);
+  if (owned) {
+    (state.owned[runtime] ??= {})[server] = true;
+  } else {
+    delete state.owned[runtime]?.[server];
+    if (state.owned[runtime] !== void 0 && Object.keys(state.owned[runtime]).length === 0) delete state.owned[runtime];
+  }
+  saveDevtoolsMcpState(file, state);
+}
+function browserPreferenceErrors(stateDir = dataDir()) {
+  return [
+    playwrightCliPreferenceError(playwrightCliPreferenceFile(stateDir)),
+    devtoolsMcpPreferenceError(devtoolsMcpPreferenceFile(stateDir))
+  ].filter((error) => error !== null);
+}
+
 // src/install.ts
 var ADAPTERS = {
   opencode: opencodeAdapter,
   "claude-code": claudeCodeAdapter,
   codex: codexAdapter
 };
-function makeContext(adapter, configDir, mode = DEFAULT_INSTALL_MODE_PREFERENCE) {
+function executePlaywrightToolAction2(action) {
+  return executePlaywrightToolAction(action, resolvePnpmBin());
+}
+function resolvePlaywrightToolPlan(consent) {
+  if (consent.command !== "install" || consent.targetDir) return { actions: [] };
+  const approved = consent.interactive ? consent.yes ? consent.explicitToolSelection : consent.confirmed : consent.yes && consent.explicitToolSelection;
+  return approved ? { actions: ["install", "install-browser"], persistEnabledOnSuccess: true } : { actions: [] };
+}
+async function runPlaywrightToolPlan(plan, deps) {
+  for (const action of plan.actions) {
+    try {
+      if (!await deps.run(action)) return { ok: false, failedAction: action };
+    } catch {
+      return { ok: false, failedAction: action };
+    }
+  }
+  if (plan.persistEnabledOnSuccess) {
+    try {
+      deps.persistEnabled(true);
+    } catch {
+      return { ok: false, failedAction: "persist" };
+    }
+  }
+  return { ok: true };
+}
+function enabledMcpServers(runtime, explicitDevtoolsEnabled, useBrowserPreferences = true) {
+  const devtoolsEnabled = explicitDevtoolsEnabled ?? (useBrowserPreferences && loadDevtoolsMcpPreference(devtoolsMcpPreferenceFile(), runtime));
+  return devtoolsEnabled ? /* @__PURE__ */ new Set([DEVTOOLS_MCP_SERVER]) : /* @__PURE__ */ new Set();
+}
+function ownedMcpServers(runtime, useBrowserPreferences = true) {
+  if (!useBrowserPreferences) return /* @__PURE__ */ new Set();
+  const file = devtoolsMcpPreferenceFile();
+  return loadDevtoolsMcpOwnership(file, runtime, DEVTOOLS_MCP_SERVER) ? /* @__PURE__ */ new Set([DEVTOOLS_MCP_SERVER]) : /* @__PURE__ */ new Set();
+}
+function persistMcpOwnershipChanges(runtime, plan) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const action of plan) {
+    if (action.kind !== "write") continue;
+    for (const change of action.mcpOwnership ?? []) latest.set(change.server, change.owned);
+  }
+  const file = devtoolsMcpPreferenceFile();
+  for (const [server, owned] of latest) saveDevtoolsMcpOwnership(file, runtime, server, owned);
+}
+function makeContext(adapter, configDir, mode = DEFAULT_INSTALL_MODE_PREFERENCE, useBrowserPreferences = true) {
   const models = loadModelMap()[adapter.id];
   if (!models) return null;
   return {
@@ -1533,7 +1905,10 @@ function makeContext(adapter, configDir, mode = DEFAULT_INSTALL_MODE_PREFERENCE)
     subagentConcurrency: mode.subagentConcurrency,
     engramBin: detectEngram(),
     models,
-    warnings: []
+    warnings: [],
+    enabledMcpServers: enabledMcpServers(adapter.id, void 0, useBrowserPreferences),
+    playwrightCliEnabled: useBrowserPreferences && loadPlaywrightCliPreference() === true,
+    ownedMcpServers: ownedMcpServers(adapter.id, useBrowserPreferences)
   };
 }
 function buildPlan(adapter, ctx) {
@@ -1554,14 +1929,16 @@ function diffPlan(plan) {
       if (current === null) return { action, status: "create" };
       return { action, status: current === action.content ? "unchanged" : "update" };
     }
-    if (!fs13.existsSync(action.target)) return { action, status: "create" };
+    if (!fs15.existsSync(action.target)) return { action, status: "create" };
     return { action, status: sameFileContent(action.source, action.target) ? "unchanged" : "update" };
   });
 }
-function applyChanges(changes) {
+function applyChanges(changes, onMcpOwnershipWritten) {
   for (const { action } of changes) {
-    if (action.kind === "write") writeText(action.target, action.content);
-    else copyFile(action.source, action.target);
+    if (action.kind === "write") {
+      writeText(action.target, action.content);
+      if (action.mcpOwnership !== void 0) onMcpOwnershipWritten?.(action);
+    } else copyFile(action.source, action.target);
   }
 }
 function collectAllCurrentTargets(mode = DEFAULT_INSTALL_MODE_PREFERENCE) {
@@ -1578,7 +1955,7 @@ function collectAllCurrentTargets(mode = DEFAULT_INSTALL_MODE_PREFERENCE) {
       continue;
     }
     try {
-      for (const action of buildPlan(adapter, ctx)) targets.add(path19.resolve(action.target));
+      for (const action of buildPlan(adapter, ctx)) targets.add(path21.resolve(action.target));
     } catch (error) {
       complete = false;
       warnings.push(
@@ -1594,6 +1971,17 @@ async function runInstall(opts) {
   const engramBin = detectEngram();
   const modePreference = opts.mode === void 0 ? opts.targetDir === void 0 ? loadInstallModePreference() : DEFAULT_INSTALL_MODE_PREFERENCE : normalizeInstallModePreference(opts.mode);
   const useManifest = opts.targetDir === void 0;
+  const preferenceErrors = useManifest ? browserPreferenceErrors() : [];
+  if (preferenceErrors.length > 0) {
+    for (const error of preferenceErrors) p.log.error(error);
+    p.outro("Install cancelado: corrige las preferencias de navegador antes de reintentar.");
+    return 1;
+  }
+  const toolPlan = opts.playwrightToolConsent === void 0 ? null : resolvePlaywrightToolPlan({
+    ...opts.playwrightToolConsent,
+    targetDir: opts.targetDir !== void 0 || opts.playwrightToolConsent.targetDir
+  });
+  const projectPlaywrightPrompt = opts.dryRun && toolPlan?.persistEnabledOnSuccess === true;
   const modelMap = loadModelMap();
   if (useManifest) ensureModelMapFile();
   p.log.info(engramBin ? `Engram detectado: ${engramBin} (se respeta, D7)` : "Engram NO detectado.");
@@ -1607,6 +1995,7 @@ async function runInstall(opts) {
   }
   let exitCode = 0;
   let successfulRuns = 0;
+  const successfulContexts = [];
   for (const id of opts.runtimes) {
     const adapter = ADAPTERS[id];
     if (!adapter) {
@@ -1632,7 +2021,16 @@ async function runInstall(opts) {
       subagentConcurrency: modePreference.subagentConcurrency,
       engramBin,
       models,
-      warnings: []
+      warnings: [],
+      enabledMcpServers: enabledMcpServers(id, opts.devtoolsMcpSelection?.[id], useManifest),
+      playwrightCliEnabled: projectPlaywrightPrompt || useManifest && loadPlaywrightCliPreference() === true,
+      ownedMcpServers: ownedMcpServers(id, useManifest)
+    };
+    const persistDevtoolsSelection = () => {
+      const selection = opts.devtoolsMcpSelection?.[id];
+      if (useManifest && selection !== void 0) {
+        saveDevtoolsMcpPreference(devtoolsMcpPreferenceFile(), id, selection);
+      }
     };
     let plan = buildPlan(adapter, ctx);
     let diff = diffPlan(plan);
@@ -1648,24 +2046,30 @@ async function runInstall(opts) {
     if (orphans.length > 0) p.log.info(`${orphans.length} hu\xE9rfanos de versiones previas a eliminar`);
     for (const w of ctx.warnings) p.log.warn(w);
     if (opts.dryRun) {
-      for (const c of changes.slice(0, 40)) p.log.message(`  ${c.status === "create" ? "+" : "~"} ${c.action.target}`);
-      if (changes.length > 40) p.log.message(`  \u2026 y ${changes.length - 40} m\xE1s`);
+      const preview = changes.slice(0, 40);
+      const projectedPrompt = projectPlaywrightPrompt ? changes.find((change) => change.action.target === adapter.paths(configDir).systemPromptFile) : void 0;
+      if (projectedPrompt && !preview.includes(projectedPrompt)) preview.push(projectedPrompt);
+      for (const c of preview) p.log.message(`  ${c.status === "create" ? "+" : "~"} ${c.action.target}`);
+      if (changes.length > preview.length) p.log.message(`  \u2026 y ${changes.length - preview.length} m\xE1s`);
       for (const o of orphans) p.log.message(`  - ${o}`);
       continue;
     }
     const writeManifest = () => {
       if (!useManifest) return;
-      const unmergeTargets = new Set(adapter.planUnmerge(canonicalMcp, canonicalHooks, ctx).map((a) => path19.resolve(a.target)));
+      const unmergeTargets = new Set(adapter.planUnmerge(canonicalMcp, canonicalHooks, ctx).map((a) => path21.resolve(a.target)));
       const keepTarget = (target) => !unmergeTargets.has(target);
-      const liveOwned = plan.map((a) => path19.resolve(a.target)).filter(keepTarget);
-      const previousOwned = (prevManifest?.owned ?? []).map((target) => path19.resolve(target)).filter(keepTarget);
+      const liveOwned = plan.map((a) => path21.resolve(a.target)).filter(keepTarget);
+      const previousOwned = (prevManifest?.owned ?? []).map((target) => path21.resolve(target)).filter(keepTarget);
       const owned = canOrphan ? liveOwned : [.../* @__PURE__ */ new Set([...previousOwned, ...liveOwned])];
       writeRuntimeManifest(id, { configDir, owned, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
     };
     if (changes.length === 0 && orphans.length === 0) {
       writeManifest();
+      if (useManifest) persistMcpOwnershipChanges(id, plan);
+      persistDevtoolsSelection();
       p.log.success(`${adapter.name}: ya al d\xEDa (idempotente).`);
       successfulRuns++;
+      successfulContexts.push({ adapter, ctx });
       continue;
     }
     if (!opts.yes && process.stdout.isTTY) {
@@ -1683,10 +2087,10 @@ async function runInstall(opts) {
     }
     const backup = useManifest ? createBackup([...updates.map((c) => c.action.target), ...orphans], `install-${id}`) : null;
     if (backup) p.log.info(`Backup: ${backup.id} (${backup.files.length} archivos)`);
-    applyChanges(changes);
-    const pruneRoot = useManifest ? HOME : path19.dirname(configDir);
+    applyChanges(changes, useManifest ? (action) => persistMcpOwnershipChanges(id, [action]) : void 0);
+    const pruneRoot = useManifest ? HOME : path21.dirname(configDir);
     for (const orphan of orphans) {
-      fs13.rmSync(orphan, { force: true });
+      fs15.rmSync(orphan, { force: true });
       pruneEmptyDirs(orphan, pruneRoot);
     }
     const verifyCtx = { ...ctx, warnings: [] };
@@ -1697,26 +2101,98 @@ async function runInstall(opts) {
       exitCode = 1;
     } else {
       writeManifest();
+      if (useManifest) persistMcpOwnershipChanges(id, plan);
+      persistDevtoolsSelection();
       p.log.success(`${adapter.name}: ${changes.length} archivos aplicados y verificados (idempotente).`);
       successfulRuns++;
+      successfulContexts.push({ adapter, ctx });
+    }
+  }
+  if (toolPlan?.actions.length) {
+    if (opts.dryRun) {
+      p.log.info("Playwright CLI: instalaci\xF3n global y navegador previstos (dry-run; no se ejecutan).");
+    } else if (exitCode === 0) {
+      const result = await runPlaywrightToolPlan(toolPlan, opts.playwrightToolDeps ?? {
+        run: async (action) => executePlaywrightToolAction2(action),
+        persistEnabled: (enabled) => savePlaywrightCliPreference(playwrightCliPreferenceFile(), enabled)
+      });
+      if (!result.ok) {
+        const reason = result.failedAction === "install" ? "no se pudo instalar el paquete global" : result.failedAction === "install-browser" ? "no se pudo descargar el navegador" : "se instalaron los componentes, pero no se pudo guardar la preferencia";
+        p.log.error(`Playwright CLI: ${reason}; la preferencia no se ha marcado como habilitada. Ejecuta 'jorgex-stack install --playwright' para reintentar.`);
+        exitCode = 1;
+      } else {
+        let promptReconciliationFailed = false;
+        for (const { adapter, ctx } of successfulContexts) {
+          const browserCtx = { ...ctx, playwrightCliEnabled: true, warnings: [] };
+          try {
+            const browserChanges = diffPlan(planSystemPrompt(adapter, browserCtx)).filter((change) => change.status !== "unchanged");
+            if (browserChanges.length === 0) continue;
+            const browserUpdates = browserChanges.filter((change) => change.status === "update");
+            const backup = useManifest ? createBackup(browserUpdates.map((change) => change.action.target), `install-browser-${adapter.id}`) : null;
+            if (backup) p.log.info(`Backup: ${backup.id} (${backup.files.length} archivos)`);
+            applyChanges(browserChanges);
+            const dirty = diffPlan(planSystemPrompt(adapter, { ...browserCtx, warnings: [] })).filter((change) => change.status !== "unchanged");
+            if (dirty.length > 0) {
+              p.log.error(`${adapter.name}: verificaci\xF3n de la gu\xEDa de navegador FALL\xD3 (${dirty.length} acciones inestables).`);
+              promptReconciliationFailed = true;
+            }
+          } catch (error) {
+            p.log.error(`${adapter.name}: no se pudo actualizar la gu\xEDa de navegador (${error instanceof Error ? error.message : String(error)}).`);
+            exitCode = 1;
+            promptReconciliationFailed = true;
+          }
+        }
+        if (promptReconciliationFailed) {
+          exitCode = 1;
+          p.log.error("Playwright CLI y navegador se han instalado y la preferencia est\xE1 activada, pero la gu\xEDa de navegador qued\xF3 en estado parcial. Ejecuta 'jorgex-stack sync' para repararla.");
+        } else {
+          p.log.success("Playwright CLI y navegador instalados.");
+        }
+      }
+    }
+  } else if (useManifest && opts.playwrightToolConsent?.command === "sync" && loadPlaywrightCliPreference() === true) {
+    const cli = detectPlaywrightCli();
+    if (cli.status !== "current") {
+      p.log.warn("Playwright CLI sigue habilitado, pero el paquete no est\xE1 listo; sync no instala herramientas. Ejecuta 'jorgex-stack install --playwright'.");
+    } else {
+      const browserCache = isPlaywrightBrowserReady();
+      if (browserCache.status === "unreadable") {
+        p.log.warn(`Playwright CLI sigue habilitado, pero no se puede leer la cach\xE9 de navegadores en ${browserCache.path} (${browserCache.errorCode}). Revisa permisos o ejecuta 'jorgex-stack install --playwright'.`);
+      } else if (browserCache.status === "missing") {
+        p.log.warn("Playwright CLI sigue habilitado, pero falta el navegador; sync no descarga navegadores. Ejecuta 'jorgex-stack install --playwright'.");
+      }
     }
   }
   if (useManifest && !opts.dryRun && exitCode === 0 && successfulRuns > 0) {
     saveInstallModePreference(installModePreferenceFile(), modePreference);
   }
-  p.outro(opts.dryRun ? "Dry-run: no se ha escrito nada." : "Hecho.");
+  p.outro(opts.dryRun ? exitCode === 0 ? "Dry-run: no se ha escrito nada." : "Dry-run completado con errores (revisa arriba)." : exitCode === 0 ? "Hecho." : "Install completado con errores (revisa arriba).");
   return exitCode;
 }
 
 // src/uninstall.ts
-import fs14 from "fs";
-import path20 from "path";
+import fs16 from "fs";
+import path22 from "path";
 import * as p2 from "@clack/prompts";
+function resolvePlaywrightUninstallPlan(input) {
+  return {
+    actions: input.removePackage ? ["remove"] : [],
+    preserveBrowserData: true
+  };
+}
 async function runUninstall(opts) {
   p2.intro(`jorgex-stack ${opts.dryRun ? "uninstall (dry-run)" : "uninstall"}`);
+  const useBrowserPreferences = opts.targetDir === void 0;
+  const preferenceErrors = useBrowserPreferences ? browserPreferenceErrors() : [];
+  if (preferenceErrors.length > 0) {
+    for (const error of preferenceErrors) p2.log.error(error);
+    p2.outro("Uninstall cancelado: corrige las preferencias de navegador antes de reintentar.");
+    return 1;
+  }
   const stackDir = stackRoot();
   const mcp = loadCanonicalMcp(stackDir);
   const hooks = loadCanonicalHooks(stackDir);
+  let exitCode = 0;
   let removeEngram = opts.removeEngram;
   if (!removeEngram && !opts.yes && !opts.dryRun && process.stdout.isTTY) {
     const answer = await p2.confirm({
@@ -1734,13 +2210,15 @@ async function runUninstall(opts) {
     p2.log.info("Engram se conserva: memorias, binario y registro intactos (usa --remove-engram para desregistrarlo).");
   }
   const retained = /* @__PURE__ */ new Set();
-  for (const keep of Object.values(ADAPTERS)) {
-    if (opts.runtimes.includes(keep.id)) continue;
-    const detection = keep.detect();
-    if (!detection.installed) continue;
-    const keepCtx = makeContext(keep, detection.configDir);
-    if (!keepCtx) continue;
-    for (const action of buildPlan(keep, keepCtx)) retained.add(path20.resolve(action.target));
+  if (useBrowserPreferences) {
+    for (const keep of Object.values(ADAPTERS)) {
+      if (opts.runtimes.includes(keep.id)) continue;
+      const detection = keep.detect();
+      if (!detection.installed) continue;
+      const keepCtx = makeContext(keep, detection.configDir);
+      if (!keepCtx) continue;
+      for (const action of buildPlan(keep, keepCtx)) retained.add(path22.resolve(action.target));
+    }
   }
   for (const id of opts.runtimes) {
     const adapter = ADAPTERS[id];
@@ -1754,60 +2232,106 @@ async function runUninstall(opts) {
       p2.log.warn(`${adapter.name} no detectado \u2014 omitido.`);
       continue;
     }
-    const ctx = makeContext(adapter, configDir);
+    const ctx = makeContext(adapter, configDir, void 0, useBrowserPreferences);
     if (!ctx) continue;
     ctx.preserveEngram = !removeEngram;
     const unmerge = adapter.planUnmerge(mcpForUnmerge, hooks, ctx);
-    const mergedTargets = new Set(unmerge.map((a) => path20.resolve(a.target)));
+    const mergedTargets = new Set(unmerge.map((a) => path22.resolve(a.target)));
     const usingRealConfig = opts.targetDir === void 0;
     const prevOwned = usingRealConfig ? readManifest().runtimes[id]?.owned ?? [] : [];
-    const pruneRoot = usingRealConfig ? HOME : path20.dirname(configDir);
+    const pruneRoot = usingRealConfig ? HOME : path22.dirname(configDir);
     const planTargets = [
-      .../* @__PURE__ */ new Set([...buildPlan(adapter, ctx).map((a) => path20.resolve(a.target)), ...prevOwned.map((t) => path20.resolve(t))])
-    ].filter((t) => !mergedTargets.has(t) && fs14.existsSync(t));
+      .../* @__PURE__ */ new Set([...buildPlan(adapter, ctx).map((a) => path22.resolve(a.target)), ...prevOwned.map((t) => path22.resolve(t))])
+    ].filter((t) => !mergedTargets.has(t) && fs16.existsSync(t));
     const deleteTargets = planTargets.filter(
-      (t) => !retained.has(t) && !(ctx.preserveEngram && path20.basename(t) === "engram.ts") && isContainedIn(t, pruneRoot)
+      (t) => !retained.has(t) && !(ctx.preserveEngram && path22.basename(t) === "engram.ts") && isContainedIn(t, pruneRoot)
     );
     const sharedKept = planTargets.length - deleteTargets.length;
     p2.log.step(`${adapter.name} \u2192 ${configDir}`);
     p2.log.info(`${deleteTargets.length} archivos a borrar, ${unmerge.length} archivos compartidos a limpiar`);
     if (sharedKept > 0) p2.log.info(`${sharedKept} archivos se conservan: otros runtimes instalados los siguen usando.`);
     if (opts.dryRun) continue;
-    const backup = createBackup(
-      [...deleteTargets, ...unmerge.map((a) => a.target).filter((t) => fs14.existsSync(t))],
-      `uninstall-${id}`
-    );
+    let backup;
+    try {
+      backup = createBackup(
+        [...deleteTargets, ...unmerge.map((a) => a.target).filter((t) => fs16.existsSync(t))],
+        `uninstall-${id}`
+      );
+    } catch (error) {
+      p2.log.error(`${adapter.name}: no se pudo respaldar una configuraci\xF3n ilegible en ${configDir} \u2014 ${error instanceof Error ? error.message : String(error)}.`);
+      exitCode = 1;
+      continue;
+    }
     if (backup) p2.log.info(`Backup: ${backup.id} (${backup.files.length} archivos)`);
     for (const target of deleteTargets) {
-      fs14.rmSync(target, { force: true });
+      fs16.rmSync(target, { force: true });
       pruneEmptyDirs(target, pruneRoot);
     }
     for (const action of unmerge) {
       if (action.kind !== "write") continue;
       if (action.content.trim() === "") {
-        fs14.rmSync(action.target, { force: true });
+        fs16.rmSync(action.target, { force: true });
       } else {
         writeText(action.target, action.content);
       }
+      if (usingRealConfig) {
+        for (const change of action.mcpOwnership ?? []) {
+          saveDevtoolsMcpOwnership(devtoolsMcpPreferenceFile(), id, change.server, change.owned);
+        }
+      }
     }
     if (usingRealConfig) removeRuntimeManifest(id);
     p2.log.success(`${adapter.name}: stack retirado (lo tuyo queda intacto).`);
   }
-  p2.outro(opts.dryRun ? "Dry-run: no se ha tocado nada." : "Hecho. Usa 'restore' si quieres volver atr\xE1s.");
-  return 0;
+  const playwrightPlan = resolvePlaywrightUninstallPlan({
+    removePackage: opts.targetDir === void 0 && opts.removePlaywright
+  });
+  if (opts.removePlaywright && opts.targetDir !== void 0) {
+    p2.log.info("Playwright CLI: --target-dir conserva el paquete global y los datos del navegador.");
+  } else if (playwrightPlan.actions.length > 0) {
+    if (opts.dryRun) {
+      p2.log.info("Playwright CLI: se retirar\xEDa solo el paquete global; los datos y navegadores se conservan.");
+    } else if (executePlaywrightToolAction2("remove")) {
+      try {
+        savePlaywrightCliPreference(playwrightCliPreferenceFile(), false);
+        p2.log.success("Playwright CLI: paquete global retirado; los datos y navegadores se conservan.");
+      } catch (error) {
+        p2.log.error(`Playwright CLI: paquete global retirado, pero no se pudo guardar la preferencia (${error instanceof Error ? error.message : String(error)}). Corrige la preferencia antes de reintentar.`);
+        exitCode = 1;
+      }
+    } else {
+      p2.log.error("Playwright CLI: no se pudo retirar el paquete global; los datos y la preferencia se conservan.");
+      exitCode = 1;
+    }
+  } else {
+    p2.log.info("Playwright CLI: paquete global y datos del navegador conservados (usa --remove-playwright para retirar solo el paquete).");
+  }
+  p2.outro(opts.dryRun ? "Dry-run: no se ha tocado nada." : exitCode === 0 ? "Hecho. Usa 'restore' si quieres volver atr\xE1s." : "Uninstall completado con errores (revisa arriba).");
+  return exitCode;
 }
 
 // src/doctor.ts
-import path21 from "path";
-import fs15 from "fs";
+import path23 from "path";
+import fs17 from "fs";
 import * as p3 from "@clack/prompts";
 function engramVersion(bin) {
   const out = runDetectedBin(bin, ["--version"], 5e3);
   if (out === null) return null;
   return /(\d+\.\d+\.\d+)/.exec(out)?.[1] ?? out.trim().split("\n")[0] ?? null;
 }
+function resolvePlaywrightDoctorState(input) {
+  if (input.enabled !== true) return { status: "disabled" };
+  if (input.cli.status === "absent") return { status: "missing", missing: "package" };
+  if (input.cli.status === "broken") return { status: "broken" };
+  if (input.cli.status === "outdated") return { status: "outdated" };
+  if (input.browserCache?.status === "unreadable") {
+    return { status: "unreadable", path: input.browserCache.path, errorCode: input.browserCache.errorCode };
+  }
+  if (!input.browserReady) return { status: "missing", missing: "browser" };
+  return { status: "healthy" };
+}
 function context7KeyConfigured(id, configDir) {
-  const file = id === "codex" ? path21.join(configDir, "config.toml") : id === "claude-code" ? path21.join(path21.dirname(configDir), `${path21.basename(configDir)}.json`) : path21.join(configDir, "opencode.json");
+  const file = id === "codex" ? path23.join(configDir, "config.toml") : id === "claude-code" ? path23.join(path23.dirname(configDir), `${path23.basename(configDir)}.json`) : path23.join(configDir, "opencode.json");
   const content = readTextIfExists(file);
   if (content === null) return null;
   const match = /CONTEXT7_API_KEY"?\s*[:=]\s*"([^"]*)"/.exec(content);
@@ -1830,13 +2354,44 @@ async function runDoctor() {
       p3.log.success(`Engram: ${version} (${engramBin})`);
     }
   }
-  const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path21.join(HOME, ".engram");
-  const engramDb = path21.join(engramDataDir, "engram.db");
-  if (fs15.existsSync(engramDb)) {
-    const sizeMb = (fs15.statSync(engramDb).size / 1024 / 1024).toFixed(1);
+  const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path23.join(HOME, ".engram");
+  const engramDb = path23.join(engramDataDir, "engram.db");
+  if (fs17.existsSync(engramDb)) {
+    const sizeMb = (fs17.statSync(engramDb).size / 1024 / 1024).toFixed(1);
     p3.log.info(`Engram DB: ${engramDb} (${sizeMb} MB de memorias \u2014 el stack no la toca JAM\xC1S).`);
   }
-  if (!fs15.existsSync(modelMapFile())) p3.log.info("model-map: a\xFAn no creado (se crea en el primer install o con 'models').");
+  if (!fs17.existsSync(modelMapFile())) p3.log.info("model-map: a\xFAn no creado (se crea en el primer install o con 'models').");
+  const preferenceErrors = browserPreferenceErrors();
+  if (preferenceErrors.length > 0) {
+    for (const error of preferenceErrors) p3.log.error(error);
+    problems += preferenceErrors.length;
+  } else {
+    const browserCache = isPlaywrightBrowserReady();
+    const playwright = resolvePlaywrightDoctorState({
+      enabled: loadPlaywrightCliPreference(),
+      cli: detectPlaywrightCli(),
+      browserReady: browserCache.status === "ready",
+      browserCache
+    });
+    if (playwright.status === "disabled") {
+      p3.log.info("Playwright CLI: deshabilitado (opcional). Usa 'install --playwright' para instalarlo de forma expl\xEDcita.");
+    } else if (playwright.status === "healthy") {
+      p3.log.success("Playwright CLI: paquete y navegador listos.");
+    } else if (playwright.status === "missing") {
+      const target = playwright.missing === "package" ? "el paquete global" : "el navegador de Playwright";
+      p3.log.warn(`Playwright CLI: habilitado, pero falta ${target} \u2192 ejecuta 'jorgex-stack install --playwright'.`);
+      problems++;
+    } else if (playwright.status === "broken") {
+      p3.log.error("Playwright CLI: el binario detectado no responde correctamente \u2192 ejecuta 'jorgex-stack install --playwright'.");
+      problems++;
+    } else if (playwright.status === "unreadable") {
+      p3.log.error(`Playwright CLI: no se puede leer la cach\xE9 de navegadores en ${playwright.path} (${playwright.errorCode}) \u2192 revisa permisos o ejecuta 'jorgex-stack install --playwright'.`);
+      problems++;
+    } else {
+      p3.log.warn("Playwright CLI: versi\xF3n distinta del pin aprobado \u2192 ejecuta 'jorgex-stack update' o 'install --playwright'.");
+      problems++;
+    }
+  }
   const manifest = readManifest();
   const modePreference = loadInstallModePreference();
   const current = collectAllCurrentTargets(modePreference);
@@ -1875,10 +2430,10 @@ async function runDoctor() {
       p3.log.warn(`${adapter.name}: ${orphans.length} archivos hu\xE9rfanos de versiones previas \u2192 ejecuta 'sync'.`);
       problems++;
     }
-    if (adapter.id === "codex" && fs15.existsSync(path21.join(detection.configDir, "hooks.json"))) {
+    if (adapter.id === "codex" && fs17.existsSync(path23.join(detection.configDir, "hooks.json"))) {
       p3.log.info("Codex: recuerda que los hooks requieren aprobaci\xF3n manual \u2014 verifica con /hooks dentro de codex.");
     }
-    if (adapter.id === "codex" && fs15.existsSync(path21.join(detection.configDir, "AGENTS.override.md"))) {
+    if (adapter.id === "codex" && fs17.existsSync(path23.join(detection.configDir, "AGENTS.override.md"))) {
       p3.log.warn(
         "Codex: existe ~/.codex/AGENTS.override.md \u2014 tiene prioridad ABSOLUTA y tapa el AGENTS.md gestionado por el stack."
       );
@@ -1892,17 +2447,17 @@ async function runDoctor() {
 }
 
 // src/update.ts
-import fs18 from "fs";
-import path24 from "path";
-import os3 from "os";
-import { execFileSync as execFileSync4 } from "child_process";
+import fs20 from "fs";
+import path26 from "path";
+import os4 from "os";
+import { execFileSync as execFileSync5 } from "child_process";
 import * as p4 from "@clack/prompts";
 
 // src/lib/github.ts
-import fs16 from "fs";
-import path22 from "path";
-import { execFileSync as execFileSync2 } from "child_process";
-import os2 from "os";
+import fs18 from "fs";
+import path24 from "path";
+import { execFileSync as execFileSync3 } from "child_process";
+import os3 from "os";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 var cachedToken;
@@ -1970,19 +2525,19 @@ async function latestGithubCommit(repo) {
   }
 }
 function validateExtractedTree(destDir) {
-  const resolved = path22.resolve(destDir);
+  const resolved = path24.resolve(destDir);
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs16.readdirSync(dir, { withFileTypes: true });
+      entries = fs18.readdirSync(dir, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
-      const full = path22.join(dir, entry.name);
+      const full = path24.join(dir, entry.name);
       let stat;
       try {
-        stat = fs16.lstatSync(full);
+        stat = fs18.lstatSync(full);
       } catch {
         return false;
       }
@@ -1998,15 +2553,15 @@ function validateExtractedTree(destDir) {
 }
 function resolveTarBin() {
   if (process.platform !== "win32") return "tar";
-  const winTar = path22.join(process.env["SystemRoot"] ?? "C:\\Windows", "System32", "tar.exe");
-  return fs16.existsSync(winTar) ? winTar : "tar";
+  const winTar = path24.join(process.env["SystemRoot"] ?? "C:\\Windows", "System32", "tar.exe");
+  return fs18.existsSync(winTar) ? winTar : "tar";
 }
 async function downloadRepoTarball(repo, sha, destDir, validateSubdir) {
   const url = `https://codeload.github.com/${repo}/tar.gz/${sha}`;
-  const tmp = path22.join(os2.tmpdir(), `jorgex-tarball-${Date.now()}.tar.gz`);
+  const tmp = path24.join(os3.tmpdir(), `jorgex-tarball-${Date.now()}.tar.gz`);
   const fail = (reason) => {
     try {
-      fs16.rmSync(destDir, { recursive: true, force: true });
+      fs18.rmSync(destDir, { recursive: true, force: true });
     } catch {
     }
     return { ok: false, reason };
@@ -2025,46 +2580,46 @@ async function downloadRepoTarball(repo, sha, destDir, validateSubdir) {
     if (!res.body) return fail("respuesta HTTP sin cuerpo");
     await pipeline(
       Readable.fromWeb(res.body),
-      fs16.createWriteStream(tmp)
+      fs18.createWriteStream(tmp)
     );
-    fs16.rmSync(destDir, { recursive: true, force: true });
-    fs16.mkdirSync(destDir, { recursive: true });
+    fs18.rmSync(destDir, { recursive: true, force: true });
+    fs18.mkdirSync(destDir, { recursive: true });
     try {
-      execFileSync2(resolveTarBin(), ["-xzf", tmp, "--strip-components=1", "-C", destDir], { stdio: "pipe" });
+      execFileSync3(resolveTarBin(), ["-xzf", tmp, "--strip-components=1", "-C", destDir], { stdio: "pipe" });
     } catch (err) {
       const e = err;
       const detail = (e.stderr?.toString().trim() || e.message || "").split("\n")[0];
       return fail(detail ? `tar fall\xF3: ${detail}` : "tar no disponible o fall\xF3 la extracci\xF3n");
     }
-    const resolvedDest = path22.resolve(destDir);
-    const validateRoot = validateSubdir ? path22.resolve(resolvedDest, validateSubdir) : resolvedDest;
+    const resolvedDest = path24.resolve(destDir);
+    const validateRoot = validateSubdir ? path24.resolve(resolvedDest, validateSubdir) : resolvedDest;
     if (validateRoot !== resolvedDest && !isContainedIn(validateRoot, resolvedDest)) {
       return fail(`la ruta de validaci\xF3n "${validateSubdir}" escapa del destino`);
     }
-    if (fs16.existsSync(validateRoot) && !validateExtractedTree(validateRoot)) {
+    if (fs18.existsSync(validateRoot) && !validateExtractedTree(validateRoot)) {
       return fail("el \xE1rbol extra\xEDdo contiene symlinks o rutas fuera del destino");
     }
-    const validated = fs16.existsSync(validateRoot);
+    const validated = fs18.existsSync(validateRoot);
     return { ok: true, validated };
   } catch (err) {
     const timedOut = err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError");
     return fail(timedOut ? "timeout de descarga (120s)" : err instanceof Error ? `fallo de red: ${err.message}` : "error desconocido");
   } finally {
     try {
-      fs16.rmSync(tmp, { force: true });
+      fs18.rmSync(tmp, { force: true });
     } catch {
     }
   }
 }
 
 // src/lib/skill-update.ts
-import fs17 from "fs";
-import path23 from "path";
-import { execFileSync as execFileSync3 } from "child_process";
+import fs19 from "fs";
+import path25 from "path";
+import { execFileSync as execFileSync4 } from "child_process";
 var PROTECTED_SKILLS = /* @__PURE__ */ new Set(["agent-delegation", "work-lifecycle", "xreview"]);
 function sameTextContentNormalized(a, b) {
-  const ba = fs17.readFileSync(a);
-  const bb = fs17.readFileSync(b);
+  const ba = fs19.readFileSync(a);
+  const bb = fs19.readFileSync(b);
   if (ba.equals(bb)) return true;
   const sa = ba.toString("utf8").replace(/\r\n/g, "\n");
   const sb = bb.toString("utf8").replace(/\r\n/g, "\n");
@@ -2072,10 +2627,10 @@ function sameTextContentNormalized(a, b) {
 }
 function diffSkillDirs(upstreamDir, localDir) {
   const upstreamFiles = new Set(
-    listFilesRecursive(upstreamDir).map((f) => path23.relative(upstreamDir, f))
+    listFilesRecursive(upstreamDir).map((f) => path25.relative(upstreamDir, f))
   );
   const localFiles = new Set(
-    listFilesRecursive(localDir).map((f) => path23.relative(localDir, f))
+    listFilesRecursive(localDir).map((f) => path25.relative(localDir, f))
   );
   const added = [];
   const modified = [];
@@ -2083,7 +2638,7 @@ function diffSkillDirs(upstreamDir, localDir) {
   for (const rel of upstreamFiles) {
     if (!localFiles.has(rel)) {
       added.push(rel);
-    } else if (!sameTextContentNormalized(path23.join(upstreamDir, rel), path23.join(localDir, rel))) {
+    } else if (!sameTextContentNormalized(path25.join(upstreamDir, rel), path25.join(localDir, rel))) {
       modified.push(rel);
     }
   }
@@ -2101,7 +2656,7 @@ function diffSkillDirs(upstreamDir, localDir) {
 var DIFF_MAX_LINES = 400;
 function renderSkillDiff(upstreamDir, localDir) {
   try {
-    execFileSync3("git", ["diff", "--no-index", "--stat", "--", localDir, upstreamDir], {
+    execFileSync4("git", ["diff", "--no-index", "--stat", "--", localDir, upstreamDir], {
       stdio: "pipe",
       encoding: "utf8"
     });
@@ -2118,7 +2673,7 @@ function renderSkillDiff(upstreamDir, localDir) {
     const stat = se.stdout;
     let fullDiff = "";
     try {
-      execFileSync3("git", ["diff", "--no-index", "--", localDir, upstreamDir], {
+      execFileSync4("git", ["diff", "--no-index", "--", localDir, upstreamDir], {
         stdio: "pipe",
         encoding: "utf8"
       });
@@ -2145,8 +2700,8 @@ function replaceSkill(name, upstreamSkillDir, newCommit, opts) {
   if (PROTECTED_SKILLS.has(name)) {
     throw new Error(`La skill "${name}" es propia del stack y no se actualiza desde upstream.`);
   }
-  const upstreamsFile = upstreamsFilePath ?? path23.join(path23.dirname(stackRoot()), "upstreams.json");
-  const raw = fs17.readFileSync(upstreamsFile, "utf8");
+  const upstreamsFile = upstreamsFilePath ?? path25.join(path25.dirname(stackRoot()), "upstreams.json");
+  const raw = fs19.readFileSync(upstreamsFile, "utf8");
   const data = JSON.parse(raw);
   const skillEntry = data?.skills?.[name];
   if (!skillEntry) {
@@ -2155,8 +2710,8 @@ function replaceSkill(name, upstreamSkillDir, newCommit, opts) {
   if (skillEntry.kind === "release") {
     throw new Error(`La skill "${name}" es de tipo release y no se actualiza con replaceSkill.`);
   }
-  const skillsRoot = localSkillsRoot ?? path23.join(stackRoot(), "skills");
-  const localSkillDir = path23.join(skillsRoot, name);
+  const skillsRoot = localSkillsRoot ?? path25.join(stackRoot(), "skills");
+  const localSkillDir = path25.join(skillsRoot, name);
   const localFiles = listFilesRecursive(localSkillDir);
   if (localFiles.length > 0) {
     createBackup(localFiles, `skill-update-${name}`, backupsRoot2);
@@ -2165,24 +2720,24 @@ function replaceSkill(name, upstreamSkillDir, newCommit, opts) {
   try {
     const upstreamFiles = listFilesRecursive(upstreamSkillDir);
     for (const src of upstreamFiles) {
-      const st = fs17.lstatSync(src);
+      const st = fs19.lstatSync(src);
       if (st.isSymbolicLink()) {
         throw new Error(`Symlink rechazado en upstream de skill "${name}": ${src}`);
       }
-      const rel = path23.relative(upstreamSkillDir, src);
-      const dest = path23.join(stagingDir, rel);
-      ensureDir(path23.dirname(dest));
+      const rel = path25.relative(upstreamSkillDir, src);
+      const dest = path25.join(stagingDir, rel);
+      ensureDir(path25.dirname(dest));
       copyFile(src, dest);
     }
     const oldDir = `${localSkillDir}.old-${process.pid}`;
-    if (fs17.existsSync(localSkillDir)) {
-      fs17.renameSync(localSkillDir, oldDir);
+    if (fs19.existsSync(localSkillDir)) {
+      fs19.renameSync(localSkillDir, oldDir);
     }
-    fs17.renameSync(stagingDir, localSkillDir);
-    fs17.rmSync(oldDir, { recursive: true, force: true });
+    fs19.renameSync(stagingDir, localSkillDir);
+    fs19.rmSync(oldDir, { recursive: true, force: true });
   } catch (err) {
     try {
-      fs17.rmSync(stagingDir, { recursive: true, force: true });
+      fs19.rmSync(stagingDir, { recursive: true, force: true });
     } catch {
     }
     throw err;
@@ -2196,8 +2751,8 @@ function rateLimitHint(prefix) {
   return ghPresentButTokenFailed() ? `${prefix} Tienes gh instalado pero \`gh auth token\` no devolvi\xF3 credencial (\xBFsesi\xF3n caducada?) \u2014 prueba \`gh auth login\` o define GH_TOKEN.` : `${prefix} Define GH_TOKEN o inicia sesi\xF3n en gh CLI.`;
 }
 function loadUpstreams() {
-  const file = path24.join(path24.dirname(stackRoot()), "upstreams.json");
-  return JSON.parse(fs18.readFileSync(file, "utf8"));
+  const file = path26.join(path26.dirname(stackRoot()), "upstreams.json");
+  return JSON.parse(fs20.readFileSync(file, "utf8"));
 }
 function skillsToScan(maintainer, upstreams) {
   return maintainer ? Object.keys(upstreams.skills) : [];
@@ -2214,8 +2769,30 @@ async function latestNpmVersion(pkg) {
     return null;
   }
 }
-async function runUpdateCheck(localVersion) {
+function resolvePlaywrightUpdateCheck(input) {
+  if (input.enabled !== true) return null;
+  if (input.cli.status === "current") {
+    return {
+      level: "success",
+      message: `Playwright CLI: ${PLAYWRIGHT_CLI.version} \u2014 al d\xEDa con el pin aprobado.`
+    };
+  }
+  const local = input.cli.detectedVersion ?? (input.cli.status === "absent" ? "no instalado" : "no verificable");
+  return {
+    level: "warn",
+    message: `Playwright CLI: ${local} local, pin aprobado ${PLAYWRIGHT_CLI.version} \u2192 ejecuta 'jorgex-stack update' o 'jorgex-stack install --playwright'.`
+  };
+}
+async function runUpdateCheck(localVersion, includeBrowserState = true) {
   p4.intro("jorgex-stack update --check");
+  if (includeBrowserState) {
+    const preferenceErrors = browserPreferenceErrors();
+    if (preferenceErrors.length > 0) {
+      for (const error of preferenceErrors) p4.log.error(error);
+      p4.outro("Check cancelado: corrige las preferencias de navegador antes de reintentar.");
+      return 1;
+    }
+  }
   const upstreams = loadUpstreams();
   const npmLatest = await latestNpmVersion("jorgex-stack");
   if (npmLatest === null)
@@ -2240,6 +2817,13 @@ async function runUpdateCheck(localVersion) {
         `engram: ${local} local, ${latest} disponible. Tu instalaci\xF3n NO se toca (D7) \u2014 actualiza t\xFA: github.com/${engramRepo}/releases`
       );
   }
+  if (includeBrowserState && loadPlaywrightCliPreference() === true) {
+    const playwright = resolvePlaywrightUpdateCheck({
+      enabled: true,
+      cli: detectPlaywrightCli()
+    });
+    if (playwright) p4.log[playwright.level](playwright.message);
+  }
   const checkSkillNames = skillsToScan(isGitClone(), upstreams);
   if (checkSkillNames.length === 0) {
     p4.log.info(
@@ -2299,7 +2883,7 @@ function isEngramRunning() {
       const pgrep = lookPath("pgrep");
       if (!pgrep) return null;
       try {
-        execFileSync4(pgrep, ["-x", "engram"], { stdio: "ignore" });
+        execFileSync5(pgrep, ["-x", "engram"], { stdio: "ignore" });
         return true;
       } catch {
         return false;
@@ -2309,8 +2893,8 @@ function isEngramRunning() {
     return null;
   }
 }
-function isGitClone(projectRoot = path24.dirname(stackRoot())) {
-  return fs18.existsSync(path24.join(projectRoot, ".git"));
+function isGitClone(projectRoot = path26.dirname(stackRoot())) {
+  return fs20.existsSync(path26.join(projectRoot, ".git"));
 }
 var STACK_METHOD_CLONE = "git pull + pnpm install + pnpm build";
 function resolvePnpm() {
@@ -2320,29 +2904,29 @@ function resolvePnpm() {
 }
 function cleanupTmp(dir) {
   try {
-    fs18.rmSync(dir, { recursive: true, force: true });
+    fs20.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
 function updateStackGitClone() {
-  const projectRoot = path24.dirname(stackRoot());
+  const projectRoot = path26.dirname(stackRoot());
   const git = lookPath("git");
   if (!git) throw new Error("git no encontrado en PATH.");
   const pnpm = resolvePnpm();
   p4.log.info("Ejecutando git pull\u2026");
-  execFileSync4(git, ["pull"], { cwd: projectRoot, stdio: "inherit" });
+  execFileSync5(git, ["pull"], { cwd: projectRoot, stdio: "inherit" });
   p4.log.info("Ejecutando pnpm install\u2026");
-  execFileSync4(pnpm, ["install"], { cwd: projectRoot, stdio: "inherit" });
+  execFileSync5(pnpm, ["install"], { cwd: projectRoot, stdio: "inherit" });
   p4.log.info("Ejecutando pnpm build\u2026");
-  execFileSync4(pnpm, ["build"], { cwd: projectRoot, stdio: "inherit" });
+  execFileSync5(pnpm, ["build"], { cwd: projectRoot, stdio: "inherit" });
 }
 function updateStackGlobal() {
   const pnpm = resolvePnpm();
   p4.log.info("Ejecutando pnpm add -g jorgex-stack@latest\u2026");
-  execFileSync4(pnpm, ["add", "-g", "jorgex-stack@latest"], { stdio: "inherit" });
+  execFileSync5(pnpm, ["add", "-g", "jorgex-stack@latest"], { stdio: "inherit" });
 }
 async function downloadSkillToTemp(repo, sha, skillPath) {
-  const root = fs18.mkdtempSync(path24.join(os3.tmpdir(), "jorgex-skill-"));
+  const root = fs20.mkdtempSync(path26.join(os4.tmpdir(), "jorgex-skill-"));
   try {
     const result = await downloadRepoTarball(repo, sha, root, skillPath);
     if (!result.ok) {
@@ -2350,15 +2934,15 @@ async function downloadSkillToTemp(repo, sha, skillPath) {
       return { error: result.reason };
     }
     if (skillPath) {
-      const sub = path24.resolve(path24.join(root, skillPath));
+      const sub = path26.resolve(path26.join(root, skillPath));
       if (!isContainedIn(sub, root)) {
         cleanupTmp(root);
         return { error: `la ruta "${skillPath}" escapa del directorio temporal` };
       }
-      if (fs18.existsSync(sub)) return { dir: sub, root };
+      if (fs20.existsSync(sub)) return { dir: sub, root };
       const lastSeg = skillPath.split("/").pop();
-      const sub2 = path24.resolve(path24.join(root, lastSeg));
-      if (isContainedIn(sub2, root) && fs18.existsSync(sub2)) {
+      const sub2 = path26.resolve(path26.join(root, lastSeg));
+      if (isContainedIn(sub2, root) && fs20.existsSync(sub2)) {
         if (!validateExtractedTree(sub2)) {
           cleanupTmp(root);
           return { error: `el sub\xE1rbol "${lastSeg}" contiene symlinks o rutas fuera del destino` };
@@ -2377,11 +2961,11 @@ async function downloadSkillToTemp(repo, sha, skillPath) {
 function pruneEngramDbBackups() {
   try {
     const dir = dataDir();
-    if (!fs18.existsSync(dir)) return;
-    const backups = fs18.readdirSync(dir).filter((f) => f.startsWith("engram-db-backup-") && f.endsWith(".db")).map((f) => ({ name: f, mtime: fs18.statSync(path24.join(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+    if (!fs20.existsSync(dir)) return;
+    const backups = fs20.readdirSync(dir).filter((f) => f.startsWith("engram-db-backup-") && f.endsWith(".db")).map((f) => ({ name: f, mtime: fs20.statSync(path26.join(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
     for (const old of backups.slice(3)) {
       try {
-        fs18.rmSync(path24.join(dir, old.name));
+        fs20.rmSync(path26.join(dir, old.name));
       } catch {
       }
     }
@@ -2389,18 +2973,18 @@ function pruneEngramDbBackups() {
   }
 }
 function rotateLockedBinary(binPath, sweepRoot = HOME) {
-  if (!fs18.existsSync(binPath)) return null;
-  const dir = path24.dirname(binPath);
-  const base = path24.basename(binPath);
+  if (!fs20.existsSync(binPath)) return null;
+  const dir = path26.dirname(binPath);
+  const base = path26.basename(binPath);
   const escapedBase = base.replace(/[.*+?^$()|[\]{}\\]/g, "\\$&");
   const oldPattern = new RegExp("^" + escapedBase + "\\.old-\\d+$");
-  const resolvedDir = path24.resolve(dir);
-  if (resolvedDir === path24.resolve(sweepRoot) || isContainedIn(resolvedDir, sweepRoot)) {
+  const resolvedDir = path26.resolve(dir);
+  if (resolvedDir === path26.resolve(sweepRoot) || isContainedIn(resolvedDir, sweepRoot)) {
     try {
-      for (const entry of fs18.readdirSync(dir)) {
+      for (const entry of fs20.readdirSync(dir)) {
         if (oldPattern.test(entry)) {
           try {
-            fs18.rmSync(path24.join(dir, entry), { force: true });
+            fs20.rmSync(path26.join(dir, entry), { force: true });
           } catch {
           }
         }
@@ -2408,8 +2992,8 @@ function rotateLockedBinary(binPath, sweepRoot = HOME) {
     } catch {
     }
   }
-  const rotated = path24.join(dir, `${base}.old-${Date.now()}`);
-  fs18.renameSync(binPath, rotated);
+  const rotated = path26.join(dir, `${base}.old-${Date.now()}`);
+  fs20.renameSync(binPath, rotated);
   return rotated;
 }
 async function updateEngram(engramRepo, latestVersion) {
@@ -2418,19 +3002,19 @@ async function updateEngram(engramRepo, latestVersion) {
       "Engram est\xE1 en ejecuci\xF3n: los procesos vivos seguir\xE1n usando la versi\xF3n antigua hasta que reinicies los clientes (Claude Code/OpenCode/Codex)."
     );
   }
-  const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path24.join(HOME, ".engram");
-  const engramDb = path24.join(engramDataDir, "engram.db");
-  if (fs18.existsSync(engramDb)) {
+  const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path26.join(HOME, ".engram");
+  const engramDb = path26.join(engramDataDir, "engram.db");
+  if (fs20.existsSync(engramDb)) {
     const doBackup = await p4.confirm({
       message: `\xBFHacer backup de la DB de Engram antes de actualizar? (${engramDb})`,
       initialValue: true
     });
     if (!p4.isCancel(doBackup) && doBackup) {
       const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const dest = path24.join(dataDir(), `engram-db-backup-${ts}.db`);
+      const dest = path26.join(dataDir(), `engram-db-backup-${ts}.db`);
       try {
-        if (!fs18.existsSync(dataDir())) fs18.mkdirSync(dataDir(), { recursive: true });
-        fs18.copyFileSync(engramDb, dest);
+        if (!fs20.existsSync(dataDir())) fs20.mkdirSync(dataDir(), { recursive: true });
+        fs20.copyFileSync(engramDb, dest);
         p4.log.success(`DB respaldada en ${dest} (la DB original NO se modifica jam\xE1s).`);
         pruneEngramDbBackups();
       } catch (err) {
@@ -2443,7 +3027,7 @@ async function updateEngram(engramRepo, latestVersion) {
   if (brew) {
     let brewManages = false;
     try {
-      execFileSync4(brew, ["list", "engram"], { stdio: "pipe" });
+      execFileSync5(brew, ["list", "engram"], { stdio: "pipe" });
       brewManages = true;
     } catch {
     }
@@ -2451,7 +3035,7 @@ async function updateEngram(engramRepo, latestVersion) {
       anyChannelTried = true;
       p4.log.info("Actualizando engram con brew\u2026");
       try {
-        execFileSync4(brew, ["upgrade", "engram"], { stdio: "inherit" });
+        execFileSync5(brew, ["upgrade", "engram"], { stdio: "inherit" });
         return true;
       } catch (err) {
         p4.log.error(`brew upgrade engram fall\xF3: ${err instanceof Error ? err.message : err}`);
@@ -2475,15 +3059,15 @@ async function updateEngram(engramRepo, latestVersion) {
     }
     p4.log.info(`Actualizando engram con go install (${latestVersion})\u2026`);
     try {
-      execFileSync4(
+      execFileSync5(
         go,
         ["install", `github.com/Gentleman-Programming/engram/cmd/engram@v${latestVersion}`],
         { stdio: "inherit" }
       );
-      const rollbackOk = resolveEngramRollback({ installOk: true, rotated, bin, binExists: fs18.existsSync(bin ?? "") });
+      const rollbackOk = resolveEngramRollback({ installOk: true, rotated, bin, binExists: fs20.existsSync(bin ?? "") });
       if (rollbackOk.action === "restore") {
         try {
-          fs18.renameSync(rotated, bin);
+          fs20.renameSync(rotated, bin);
           p4.log.warn(rollbackOk.messages.onRestore);
         } catch {
           p4.log.warn(rollbackOk.messages.onRenameFail);
@@ -2491,10 +3075,10 @@ async function updateEngram(engramRepo, latestVersion) {
       }
       return true;
     } catch (err) {
-      const rollbackFail = resolveEngramRollback({ installOk: false, rotated, bin, binExists: fs18.existsSync(bin ?? "") });
+      const rollbackFail = resolveEngramRollback({ installOk: false, rotated, bin, binExists: fs20.existsSync(bin ?? "") });
       if (rollbackFail.action === "restore") {
         try {
-          fs18.renameSync(rotated, bin);
+          fs20.renameSync(rotated, bin);
           p4.log.info(rollbackFail.messages.onRestore);
         } catch {
           p4.log.error(rollbackFail.messages.onRenameFail);
@@ -2579,14 +3163,26 @@ function buildEligibleSkillUpdates(skills) {
   }
   return result;
 }
-async function runInteractiveUpdate(localVersion, yes, dryRun = false) {
+function resolveUpdateSyncRequired(updated) {
+  return updated.some((item) => item === "stack" || item === "skill" || item.startsWith("skill:"));
+}
+async function runInteractiveUpdate(localVersion, yes, dryRun = false, includeBrowserState = true) {
   if (dryRun || yes || !process.stdout.isTTY) {
-    return { exitCode: await runUpdateCheck(localVersion), appliedUpdates: false };
+    return { exitCode: await runUpdateCheck(localVersion, includeBrowserState), appliedUpdates: false, syncRequired: false };
   }
   p4.intro("jorgex-stack update");
+  if (includeBrowserState) {
+    const preferenceErrors = browserPreferenceErrors();
+    if (preferenceErrors.length > 0) {
+      for (const error of preferenceErrors) p4.log.error(error);
+      p4.outro("Update cancelado: corrige las preferencias de navegador antes de reintentar.");
+      return { exitCode: 1, appliedUpdates: false, syncRequired: false };
+    }
+  }
   const upstreams = loadUpstreams();
   let exitCode = 0;
   let appliedUpdates = false;
+  const updated = [];
   const maintainer = isGitClone();
   const spin = p4.spinner();
   spin.start("Consultando versiones upstream\u2026");
@@ -2645,6 +3241,21 @@ async function runInteractiveUpdate(localVersion, yes, dryRun = false) {
       });
     }
   }
+  let playwrightNeedsUpdate = false;
+  if (includeBrowserState && loadPlaywrightCliPreference() === true) {
+    const playwright = detectPlaywrightCli();
+    if (playwright.status === "current") {
+      p4.log.success("Playwright CLI: al d\xEDa.");
+    } else {
+      playwrightNeedsUpdate = true;
+      const current = playwright.detectedVersion ?? playwright.status;
+      updateItems.push({
+        value: "playwright-cli",
+        label: `Playwright CLI: ${current} \u2192 pin aprobado`,
+        hint: "pnpm add --global @playwright/cli@0.1.17"
+      });
+    }
+  }
   const typedSkillHeads = skillHeads;
   const loggedRepos = /* @__PURE__ */ new Map();
   for (const { name, repo, info, head } of typedSkillHeads) {
@@ -2686,7 +3297,7 @@ async function runInteractiveUpdate(localVersion, yes, dryRun = false) {
   }
   if (updateItems.length === 0) {
     p4.outro("Todo al d\xEDa. No hay actualizaciones disponibles.");
-    return { exitCode: 0, appliedUpdates: false };
+    return { exitCode: 0, appliedUpdates: false, syncRequired: false };
   }
   const selected = await p4.multiselect({
     message: "Selecciona qu\xE9 actualizar (espacio para marcar, intro para confirmar):",
@@ -2696,11 +3307,11 @@ async function runInteractiveUpdate(localVersion, yes, dryRun = false) {
   });
   if (p4.isCancel(selected)) {
     p4.outro("Update cancelado.");
-    return { exitCode: 0, appliedUpdates: false };
+    return { exitCode: 0, appliedUpdates: false, syncRequired: false };
   }
   if (selected.length === 0) {
     p4.outro("Nada seleccionado.");
-    return { exitCode: 0, appliedUpdates: false };
+    return { exitCode: 0, appliedUpdates: false, syncRequired: false };
   }
   const sel = selected;
   if (stackNeedsUpdate && sel.includes("stack")) {
@@ -2721,6 +3332,7 @@ async function runInteractiveUpdate(localVersion, yes, dryRun = false) {
         }
         p4.log.success("Stack actualizado correctamente.");
         appliedUpdates = true;
+        updated.push("stack");
       } catch (err) {
         p4.log.error(`Stack: error al actualizar \u2014 ${err instanceof Error ? err.message : err}`);
         exitCode = 1;
@@ -2752,7 +3364,7 @@ async function runInteractiveUpdate(localVersion, yes, dryRun = false) {
       continue;
     }
     const { dir: tmpDir, root: tmpRoot } = tmpResult;
-    const localSkillDir = path24.join(stackRoot(), "skills", skillInfo.name);
+    const localSkillDir = path26.join(stackRoot(), "skills", skillInfo.name);
     const diff = renderSkillDiff(tmpDir, localSkillDir);
     if (diff) {
       p4.log.info(`Diff de ${skillInfo.name}:
@@ -2776,6 +3388,7 @@ ${diff}`);
       replaceSkill(skillInfo.name, tmpDir, skillInfo.head, {});
       p4.log.success(`skill ${skillInfo.name}: actualizada y re-pineada a ${skillInfo.head.slice(0, 7)}.`);
       appliedUpdates = true;
+      updated.push("skill");
     } catch (err) {
       p4.log.error(`skill ${skillInfo.name}: error \u2014 ${err instanceof Error ? err.message : err}`);
       exitCode = 1;
@@ -2783,6 +3396,27 @@ ${diff}`);
       cleanupTmp(tmpRoot);
     }
   }
+  if (playwrightNeedsUpdate && sel.includes("playwright-cli")) {
+    const confirmPlaywright = await p4.confirm({
+      message: "Actualizar Playwright CLI global al pin aprobado con pnpm add --global?",
+      initialValue: true
+    });
+    if (p4.isCancel(confirmPlaywright) || !confirmPlaywright) {
+      p4.log.info("Playwright CLI: actualizaci\xF3n omitida.");
+    } else {
+      const packageUpdated = executePlaywrightToolAction2("update");
+      const browserInstalled = packageUpdated && executePlaywrightToolAction2("install-browser");
+      if (packageUpdated && browserInstalled) {
+        p4.log.success("Playwright CLI actualizado al pin aprobado.");
+        appliedUpdates = true;
+        updated.push("playwright-cli");
+      } else {
+        const failedStep = packageUpdated ? "descargar el navegador" : "actualizar el paquete global";
+        p4.log.error(`Playwright CLI: no se pudo ${failedStep}. Ejecuta 'jorgex-stack install --playwright' para reintentar el paquete y el navegador.`);
+        exitCode = 1;
+      }
+    }
+  }
   if (engramNeedsUpdate && sel.includes("engram") && engramData?.version) {
     const confirmEngram = await p4.confirm({
       message: `Actualizar engram a v${engramData.version} (canal nativo: brew \u2192 go install \u2192 URL)`,
@@ -2803,15 +3437,17 @@ ${diff}`);
           p4.log.warn("Engram actualizado, pero no se pudo verificar la versi\xF3n \u2014 comprueba con engram --version");
         }
         p4.log.info("Reinicia los clientes (Claude Code/OpenCode/Codex) para que sus MCP usen la versi\xF3n nueva.");
+        appliedUpdates = true;
+        updated.push("engram");
       }
     }
   }
   p4.outro(exitCode === 0 ? "Update completado." : "Update completado con errores (revisa arriba).");
-  return { exitCode, appliedUpdates };
+  return { exitCode, appliedUpdates, syncRequired: resolveUpdateSyncRequired(updated) };
 }
 
 // src/models-picker.ts
-import path25 from "path";
+import path27 from "path";
 import * as p5 from "@clack/prompts";
 var TIERS = ["strong", "standard", "cheap"];
 var EFFORTS = ["low", "medium", "high", "xhigh"];
@@ -2835,7 +3471,7 @@ function opencodeLiveModels(binPath) {
 }
 function agentsByTier() {
   const grouped = { strong: [], standard: [], cheap: [] };
-  for (const agent of loadCanonicalAgents(path25.join(stackRoot(), "agents"))) {
+  for (const agent of loadCanonicalAgents(path27.join(stackRoot(), "agents"))) {
     if (agent.mode === "subagent") grouped[agent.tier].push(agent.name);
   }
   return grouped;
@@ -3015,16 +3651,16 @@ function cancelled() {
 }
 
 // src/lib/release.ts
-import fs19 from "fs";
-import path26 from "path";
-import { execFileSync as execFileSync5 } from "child_process";
+import fs21 from "fs";
+import path28 from "path";
+import { execFileSync as execFileSync6 } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findPackageJson() {
-  let dir = path26.dirname(fileURLToPath2(import.meta.url));
+  let dir = path28.dirname(fileURLToPath2(import.meta.url));
   for (let i = 0; i < 6; i++) {
-    const candidate = path26.join(dir, "package.json");
-    if (fs19.existsSync(candidate)) return candidate;
-    dir = path26.dirname(dir);
+    const candidate = path28.join(dir, "package.json");
+    if (fs21.existsSync(candidate)) return candidate;
+    dir = path28.dirname(dir);
   }
   throw new Error("No se encontr\xF3 package.json cerca del CLI.");
 }
@@ -3033,7 +3669,7 @@ function readPackageVersion() {
 }
 function readPackageMetadata() {
   const packageJson = findPackageJson();
-  const raw = fs19.readFileSync(packageJson, "utf8");
+  const raw = fs21.readFileSync(packageJson, "utf8");
   const parsed = JSON.parse(raw);
   const name = typeof parsed.name === "string" ? parsed.name.trim() : "";
   const version = typeof parsed.version === "string" ? parsed.version.trim() : "";
@@ -3070,6 +3706,10 @@ function parseFlags(args) {
     list: false,
     check: false,
     removeEngram: false,
+    playwright: false,
+    removePlaywright: false,
+    devtools: false,
+    noDevtools: false,
     positional: [],
     unknownFlags: []
   };
@@ -3107,6 +3747,10 @@ function parseFlags(args) {
     else if (arg === "--list") flags.list = true;
     else if (arg === "--check") flags.check = true;
     else if (arg === "--remove-engram") flags.removeEngram = true;
+    else if (arg === "--playwright") flags.playwright = true;
+    else if (arg === "--remove-playwright") flags.removePlaywright = true;
+    else if (arg === "--devtools") flags.devtools = true;
+    else if (arg === "--no-devtools") flags.noDevtools = true;
     else if (arg.startsWith("-")) flags.unknownFlags.push(arg);
     else flags.positional.push(arg);
   }
@@ -3173,6 +3817,48 @@ Corrige o borra ${preferenceFile}, o vuelve a ejecutar con --mode human|programm
     subagentConcurrency: concurrency
   };
 }
+async function resolvePlaywrightToolConsent(command, flags) {
+  const interactive = Boolean(process.stdout.isTTY);
+  let confirmed = false;
+  if (command === "install" && interactive && !flags.yes && !flags.dryRun && flags.targetDir === void 0) {
+    const answer = await p6.confirm({
+      message: "Recomendado: \xBFinstalar Playwright CLI global y descargar sus navegadores?",
+      initialValue: false
+    });
+    if (p6.isCancel(answer)) return null;
+    confirmed = answer === true;
+  }
+  return {
+    command,
+    interactive,
+    yes: flags.yes,
+    targetDir: flags.targetDir !== void 0,
+    explicitToolSelection: flags.playwright,
+    confirmed
+  };
+}
+async function resolveDevtoolsMcpSelection(command, flags, runtimes) {
+  if (flags.devtools && flags.noDevtools) {
+    console.error("Usa solo uno de --devtools o --no-devtools.");
+    process.exitCode = 1;
+    return null;
+  }
+  if (flags.devtools || flags.noDevtools) {
+    return Object.fromEntries(runtimes.map((runtime) => [runtime, flags.devtools]));
+  }
+  if (command !== "install" || flags.yes || flags.dryRun || flags.targetDir !== void 0 || !process.stdout.isTTY) {
+    return {};
+  }
+  const file = devtoolsMcpPreferenceFile();
+  const selected = await p6.multiselect({
+    message: "Chrome DevTools MCP avanzado (full: ~29 tools y ~5.8\u20137.7k tokens de schemas). \xBFEn qu\xE9 runtimes activarlo?",
+    options: runtimes.map((runtime) => ({ value: runtime, label: ADAPTERS[runtime]?.name ?? runtime })),
+    initialValues: runtimes.filter((runtime) => loadDevtoolsMcpPreference(file, runtime))
+  });
+  if (p6.isCancel(selected)) return null;
+  const enabled = new Set(selected);
+  return Object.fromEntries(runtimes.map((runtime) => [runtime, enabled.has(runtime)]));
+}
 function parseCliArgs(argv) {
   const [first, ...rest] = argv;
   const isCommand = COMMANDS.includes(first ?? "install");
@@ -3227,8 +3913,13 @@ Opciones:
   --target-dir <dir>    Dir alternativo (pruebas de paridad; requiere 1 runtime)
   --dry-run             Muestra el plan sin escribir nada
   --yes, -y             No interactivo
+  --playwright          Autoriza Playwright CLI global y sus navegadores (requerido con --yes/sin TTY)
+  --devtools            (install/sync) activa Chrome DevTools MCP para los runtimes destino (opt-in)
+  --no-devtools         (install/sync) desactiva Chrome DevTools MCP (incompatible con --devtools)
   --remove-engram       (uninstall) desregistra Engram de los runtimes;
                         memorias y binario quedan intactos igualmente
+  --remove-playwright   (uninstall) retira solo el paquete global de Playwright;
+                        nunca perfiles, cach\xE9 ni navegadores
 
 Ver PRD.md para el dise\xF1o completo.`);
 }
@@ -3272,17 +3963,31 @@ Flags disponibles: jorgex-stack --help`
         process.exitCode = 1;
         return;
       }
-      if (!await ensureOpenCodeModelsForInstall(command, flags, runtimes)) {
+      const devtoolsMcpSelection = await resolveDevtoolsMcpSelection(command, flags, runtimes);
+      if (devtoolsMcpSelection === null) return;
+      const playwrightToolConsent = await resolvePlaywrightToolConsent(command, flags);
+      if (playwrightToolConsent === null) return;
+      const hasOpenCodeModels = await ensureOpenCodeModelsForInstall(command, flags, runtimes);
+      if (!hasOpenCodeModels) {
         process.exitCode = 1;
         return;
       }
-      process.exitCode = await runInstall({ runtimes, targetDir: flags.targetDir, dryRun: flags.dryRun, yes: flags.yes, mode });
+      const installExitCode = await runInstall({
+        runtimes,
+        targetDir: flags.targetDir,
+        dryRun: flags.dryRun,
+        yes: flags.yes,
+        mode,
+        playwrightToolConsent,
+        devtoolsMcpSelection
+      });
+      process.exitCode = installExitCode;
       return;
     }
     case "uninstall": {
       const runtimes = await resolveRuntimes(flags);
       if (runtimes === null) return;
-      if (runtimes.length === 0) {
+      if (runtimes.length === 0 && !flags.removePlaywright) {
         console.error("Ning\xFAn runtime detectado (opencode, claude-code, codex).");
         process.exitCode = 1;
         return;
@@ -3292,7 +3997,8 @@ Flags disponibles: jorgex-stack --help`
         targetDir: flags.targetDir,
         dryRun: flags.dryRun,
         yes: flags.yes,
-        removeEngram: flags.removeEngram
+        removeEngram: flags.removeEngram,
+        removePlaywright: flags.removePlaywright
       });
       return;
     }
@@ -3302,11 +4008,11 @@ Flags disponibles: jorgex-stack --help`
     }
     case "update": {
       if (flags.check) {
-        process.exitCode = await runUpdateCheck(VERSION);
+        process.exitCode = await runUpdateCheck(VERSION, flags.targetDir === void 0);
         return;
       }
       if (flags.dryRun) {
-        process.exitCode = await runUpdateCheck(VERSION);
+        process.exitCode = await runUpdateCheck(VERSION, flags.targetDir === void 0);
         return;
       }
       const runtimes = await resolveRuntimes(flags);
@@ -3333,11 +4039,16 @@ Flags disponibles: jorgex-stack --help`
       } else if (runtimes.length > 0) {
         console.error("No hay modo guardado; se omite el sync previo y se contin\xFAa con update. Usa --mode expl\xEDcito si quieres sincronizar.");
       }
-      const result = await runInteractiveUpdate(VERSION, flags.yes, flags.dryRun);
+      const result = await runInteractiveUpdate(
+        VERSION,
+        flags.yes,
+        flags.dryRun,
+        flags.targetDir === void 0
+      );
       process.exitCode = result.exitCode;
-      if (result.exitCode === 0 && result.appliedUpdates && runtimes.length > 0 && !canSync) {
+      if (result.syncRequired && runtimes.length > 0 && (result.exitCode !== 0 || !canSync)) {
         p6.log.warn("Skills/stack actualizados, pero el sync con los runtimes sigue pendiente. Ejecuta jorgex-stack sync --mode human|programmatic.");
-      } else if (result.exitCode === 0 && result.appliedUpdates && runtimes.length > 0 && canSync && !flags.yes && process.stdout.isTTY) {
+      } else if (result.exitCode === 0 && result.syncRequired && runtimes.length > 0 && canSync && !flags.yes && process.stdout.isTTY) {
         const apply = await p6.confirm({ message: "\xBFRe-aplicar a los runtimes ahora? (sync)" });
         if (!p6.isCancel(apply) && apply) {
           process.exitCode = await runInstall({
@@ -3350,7 +4061,7 @@ Flags disponibles: jorgex-stack --help`
         } else {
           console.log("Sin aplicar. Cuando quieras: jorgex-stack sync");
         }
-      } else if (result.exitCode === 0 && result.appliedUpdates && runtimes.length > 0 && canSync && (flags.yes || !process.stdout.isTTY)) {
+      } else if (result.exitCode === 0 && result.syncRequired && runtimes.length > 0 && canSync && (flags.yes || !process.stdout.isTTY)) {
         console.log("Skills/stack actualizados. Ejecuta jorgex-stack sync para aplicarlos a los runtimes.");
       }
       return;
@@ -3400,7 +4111,7 @@ Flags disponibles: jorgex-stack --help`
   }
 }
 if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL2(process.argv[1]).href) {
-  main().catch((err) => {
+  await main().catch((err) => {
     console.error(err instanceof Error ? err.message : String(err));
     process.exitCode = 1;
   });