jorgex-stack 1.9.31 → 1.9.33

package/README.md

@@ -42,6 +42,14 @@ pnpm dlx jorgex-stack install
 pnpm dlx jorgex-stack sync
 ```
 
+For a fresh Engram installation, always consult the current published Stack and bypass only the `pnpm dlx` cache:
+
+```bash
+pnpm --config.dlx-cache-max-age=0 dlx jorgex-stack@latest install --engram
+```
+
+`dlx-cache-max-age` is separate from the pnpm 11 dependency-age filter: it controls only the cached `dlx` package, while `minimumReleaseAgeExclude` applies only to the named package resolution. An explicit Stack version such as `@1.9.30` does not reuse the cache entry for another version. Do not use `@latest` for Pi; Pi consumption still requires its exact validated pin.
+
 Other important commands:
 
 ```bash
@@ -120,7 +128,7 @@ pnpm dlx jorgex-stack@1.9.7 sync --agents pi
 pnpm dlx jorgex-stack@1.9.7 uninstall --agents pi
 ```
 
-Stack downloads the frozen registry tarball, verifies its exact size plus SHA-256/SHA-512, backs up Pi's `settings.json`, and only then asks Pi to install that local file. The historical `0.8.0` tarball was `89128340` bytes; the exact adopted artifact and integrity values are authoritative in `src/lib/pi-runtime-pin.json`, while the lifecycle remains authoritative in `src/lib/pi-runtime.ts`. Pi's own package-manager invocation is the narrow runtime exception to the repository's pnpm-only rule; the Stack lifecycle never launches npm directly. After the package is healthy, Stack projects the shared resources into Pi: marked `jorgex:system-prompt` and `jorgex:engram-protocol` sections in `~/.pi/agent/AGENTS.md`, canonical skills under `~/.agents/skills`, and `~/.pi/agent/prompts/lean-audit.md`. When the managed Playwright preference is active, the projection also adds or removes the marked `jorgex:browser` section dynamically. The Pi-only `install --agents pi --playwright` flow installs and persists that Playwright capability just like the other harnesses. The adopted Pi `0.8.13` candidate also supports the optional Chrome DevTools handoff; Stack persists the selected handoff as part of the Pi projection and records its SHA-256 in the optional `devtools.sha256` field of `~/.jorgex-stack/pi-projection-receipt.json` after a successful operation. Context7 remains outside the Pi scope. The published `1.9.7` entry `{ "source": "npm:jorgex-pi@0.8.4", "skills": [], "prompts": [] }` and the `0.8.5` snapshot reference are historical; they do not describe the adopted pin. Filters are applied only after this projection exists, so the package does not duplicate shared resources. Package ownership is recorded separately in `~/.jorgex-stack/pi-receipt.json`; projection ownership is recorded in `~/.jorgex-stack/pi-projection-receipt.json`. Package receipts reject manual, duplicate, divergent, partial, corrupt, copied-to-another-scope, or unknown-history state. Projection cleanup requires an exact scope-bound ownership receipt; DevTools conflicts preserve the handoff for review.
+Stack downloads the frozen registry tarball, verifies its exact size plus SHA-256/SHA-512, backs up Pi's `settings.json`, and only then asks Pi to install that local file. The historical `0.8.0` tarball was `89128340` bytes; the exact adopted artifact and integrity values are authoritative in `src/lib/pi-runtime-pin.json`, while the lifecycle remains authoritative in `src/lib/pi-runtime.ts`. Pi's own package-manager invocation is the narrow runtime exception to the repository's pnpm-only rule; the Stack lifecycle never launches npm directly. After the package is healthy, Stack projects the shared resources into Pi: marked `jorgex:system-prompt` and `jorgex:engram-protocol` sections in `~/.pi/agent/AGENTS.md`, canonical skills under `~/.agents/skills`, and `~/.pi/agent/prompts/lean-audit.md`. When the managed Playwright preference is active, the projection also adds or removes the marked `jorgex:browser` section dynamically. The global Playwright package and Chromium cache are shared by the machine; `--playwright-runtimes` controls which runtime receives the guide. The pin vigente declara `playwright-handoff-v1`, por lo que Pi puede seleccionarse y recibe su handoff de Playwright además de la guía. El paquete Pi fijado también soporta el handoff opcional de Chrome DevTools; Stack persiste cada handoff como parte de la proyección y registra su SHA-256 en el receipt correspondiente tras una operación correcta. Context7 remains outside the Pi scope. The published `1.9.7` entry `{ "source": "npm:jorgex-pi@0.8.4", "skills": [], "prompts": [] }` and the `0.8.5` snapshot reference are historical; they do not describe the adopted pin. Filters are applied only after this projection exists, so the package does not duplicate shared resources. Package ownership is recorded separately in `~/.jorgex-stack/pi-receipt.json`; projection ownership is recorded in `~/.jorgex-stack/pi-projection-receipt.json`. Package receipts reject manual, duplicate, divergent, partial, corrupt, copied-to-another-scope, or unknown-history state. Projection cleanup requires an exact scope-bound ownership receipt; DevTools conflicts preserve the handoff for review.
 
 Historically, the published Pi 0.8.0 direct-package snapshot added `work-audit`: the snapshot grew from **17 to 18 skill trees** (96 to 97 files), and the active runtime allowlist grew from **16 to 17 skills**. The historical Pi 0.8.5 snapshot reference records 18 skill trees and 98 files; it does not describe the adopted pin. Reference F2-A is included while the private F1 skills remain preserved. `playwright-cli` remains in the snapshot but inactive because browser automation is a separate opt-in integration.
 
@@ -136,7 +144,7 @@ Engram remains mandatory and user-owned. An existing binary is preserved. `insta
 
 Históricamente, Stack `1.9.7` reconocía el receipt exacto de Pi `npm:jorgex-pi@0.8.4`. Usa versiones exactas, nunca `latest`, y no edites receipts o hashes ni borres `HOME`, Engram o la proyección de otro runtime para forzar confianza. El pin y los comandos actuales de transición y rollback están en [docs/references/pi-runtime.md](docs/references/pi-runtime.md).
 
-The 24-hour managed-consumption maturity rule applies only to real installation or consumption of the new Pi package; development, PR validation, merge and Stack publication may proceed immediately. Installing it on a real user scope before the maturity window requires Jorge's explicit exception.
+Pi puede consumirse inmediatamente después de publicar y verificar el artefacto adoptado. El pin exacto, la procedencia, los SHA-256/SHA-512, el SRI, la compatibilidad y el procedimiento de rollback siguen siendo obligatorios; no uses `latest` ni una versión aproximada.
 
 `update --agents pi` only runs the Pi package lifecycle; it does not enter the global Stack updater. `update --check --agents pi` is a read-only Pi doctor. Uninstall runs package cleanup, backs up Pi's settings before removal, removes only the exact receipt-owned package after verifying absence, and preserves all companion/user state. Full behavior, failure states and troubleshooting are in [docs/references/pi-runtime.md](docs/references/pi-runtime.md).
 
@@ -156,6 +164,9 @@ pnpm dlx jorgex-stack install
 # Non-interactive / agent: --playwright authorizes the global install.
 pnpm dlx jorgex-stack install --yes --playwright
 
+# Instala el paquete compartido y activa la guía solo en estos runtimes.
+pnpm dlx jorgex-stack install --playwright --playwright-runtimes=opencode,claude-code
+
 # Enable Chrome DevTools MCP explicitly per runtime.
 pnpm dlx jorgex-stack install --devtools
 pnpm dlx jorgex-stack install --no-devtools
@@ -163,7 +174,7 @@ pnpm dlx jorgex-stack install --agents pi --devtools
 pnpm dlx jorgex-stack sync --agents pi --no-devtools
 ```
 
-Under the hood, `--playwright` runs two `pnpm` argv-only plans back to back: `pnpm add --global @playwright/cli@0.1.18` (the package) and then `pnpm dlx @playwright/cli@0.1.18 install-browser` (the browser binary cache). Removal is `pnpm remove --global @playwright/cli` (no version suffix). If installation fails, the error identifies the failed phase — global package, browser download, or preference persistence — and recommends `jorgex-stack install --playwright`; the preference is not marked enabled unless the complete plan succeeds.
+Under the hood, `--playwright` runs two `pnpm` argv-only plans back to back: `pnpm add --global @playwright/cli@0.1.18` (the package) and then `pnpm dlx @playwright/cli@0.1.18 install-browser chromium` (the Chromium cache). It then verifies that the pinned package launches Chromium headless against `about:blank`. Removal is `pnpm remove --global @playwright/cli` (no version suffix). If installation fails, the error identifies the failed phase — global package, browser download, browser launch, or preference persistence — and recommends `jorgex-stack install --playwright`; the preference is not marked enabled unless the complete plan succeeds.
 
 Daily operation:
 
@@ -179,7 +190,7 @@ Daily operation:
 
 1. **Stack** (jorgex-stack): detects whether it is a git clone or a global install, then offers an update with confirmation.
 2. **Engram** (binary): detects the installed version and offers an update through the **native channel** (brew -> `go install` -> release URL). Nothing needs to be stopped: as in upstream macOS/Linux, live processes keep using the old version until clients restart; on Windows, the in-use `.exe` is rotated by rename before installation. **Automatic DB backup before updating**. The database and memories are never touched.
-3. **Playwright CLI** (only when explicitly enabled): compares the detected binary with the approved bundle pin and offers to realign it with explicit confirmation. The realignment re-applies **both** plans — `pnpm add --global @playwright/cli@0.1.18` (package) and `pnpm dlx @playwright/cli@0.1.18 install-browser` (browser cache) — and fails closed if either step returns non-zero. The error identifies whether the package-update or browser-download phase failed and recommends `jorgex-stack install --playwright` to retry both; a Playwright update does not require `sync`.
+3. **Playwright CLI** (only when explicitly enabled): compares the detected binary with the approved bundle pin and offers to realign it with explicit confirmation. The realignment re-applies **both** plans — `pnpm add --global @playwright/cli@0.1.18` (package) and `pnpm dlx @playwright/cli@0.1.18 install-browser chromium` (Chromium cache) — and fails closed if either step returns non-zero. The error identifies whether the package-update or browser-download phase failed and recommends `jorgex-stack install --playwright` to retry both; a Playwright update does not require `sync`.
 4. **Vendored skills** (maintainer only): third-party skills ship **pinned** with the stack version, so the installed package never reaches out to their upstreams. Only when running from a git clone (`pnpm cli update`) does `update` scan the upstreams in `upstreams.json`, download to a temp directory, **show a mandatory diff**, and ask for confirmation. A moved upstream is only a candidate until that review is accepted and a deliberate re-pin is made for a future release; it is never treated as an accepted official update automatically. Skills with local changes (`modified: true`) warn and require double confirmation.
 
 Usage:
@@ -237,6 +248,8 @@ La integración de este App pertenece al release del repositorio Stack. No conce
 
 Requirements: Node >= 22.5 and pnpm (never npm).
 
+pnpm 11 dependency resolution uses `minimumReleaseAge=1440` by default, with `minimumReleaseAgeExclude` for `jorgex-stack` and `jorgex-pi`. Keep that exclusion in the user-level pnpm config for `pnpm dlx` launched from HOME and in each repository workspace config for local commands; preserve every unrelated existing setting. This documents the maintainer environment and does not change other users' global configuration.
+
 ```
 pnpm install
 pnpm build        # tsup -> dist/

package/dist/cli.d.ts

@@ -23,6 +23,7 @@ interface Flags {
     removeEngram: boolean;
     engram: boolean;
     playwright: boolean;
+    playwrightRuntimes?: SelectableRuntimeId[];
     removePlaywright: boolean;
     devtools: boolean;
     noDevtools: boolean;

package/dist/cli.js

@@ -2165,6 +2165,8 @@ function resolvePnpmFailureRemedy(reason) {
       return PNPM_GLOBAL_BIN_REMEDY;
     case "action-failed":
       return null;
+    case "browser-launch":
+      return "Chromium se descarg\xF3, pero no ha podido arrancar. Revisa el error de lanzamiento y las dependencias de tu sistema antes de reintentar.";
   }
 }
 function hasNonzeroProcessStatus(error) {
@@ -2186,6 +2188,18 @@ function resolvePlaywrightCliState({ binPath, versionOutput }) {
 }
 function detectPlaywrightCli() {
   const binPath = lookPath(PLAYWRIGHT_CLI.bin);
+  if (binPath === null) {
+    const pnpmHome = resolvePnpmHome();
+    const name = process.platform === "win32" ? `${PLAYWRIGHT_CLI.bin}.cmd` : PLAYWRIGHT_CLI.bin;
+    const known = [path18.join(pnpmHome, name), path18.join(pnpmHome, "bin", name)].find((file) => {
+      try {
+        return fs13.statSync(file).isFile();
+      } catch {
+        return false;
+      }
+    });
+    if (known) return { status: "not-in-path", binPath: known, detectedVersion: null };
+  }
   return resolvePlaywrightCliState({
     binPath,
     versionOutput: binPath ? runDetectedBin(binPath, ["--version"], 5e3, { NO_UPDATE_NOTIFIER: "1" }) : null
@@ -2248,7 +2262,44 @@ function planPlaywrightCliCommand(action, pnpmBin) {
     case "remove":
       return { command: pnpmBin, args: ["remove", "--global", PLAYWRIGHT_CLI.packageName] };
     case "install-browser":
-      return { command: pnpmBin, args: ["dlx", pinnedPackage, PLAYWRIGHT_CLI.browserInstallAction] };
+      return { command: pnpmBin, args: ["dlx", pinnedPackage, PLAYWRIGHT_CLI.browserInstallAction, "chromium"] };
+  }
+}
+function verifyPlaywrightBrowser(pnpmBin, env = process.env, cwd) {
+  const rootCommand = planDetectedBinCommand(pnpmBin, ["root", "--global"]);
+  if (rootCommand === null) return false;
+  try {
+    const root = execFileSync2(rootCommand.command, rootCommand.args, {
+      encoding: "utf8",
+      timeout: 5e3,
+      env,
+      cwd,
+      stdio: ["ignore", "pipe", "inherit"]
+    }).trim();
+    if (!path18.isAbsolute(root)) return false;
+    const packageFile = fs13.realpathSync(path18.join(root, "@playwright", "cli", "package.json"));
+    const installed = JSON.parse(fs13.readFileSync(packageFile, "utf8"));
+    if (installed.name !== PLAYWRIGHT_CLI.packageName || installed.version !== PLAYWRIGHT_CLI.version) return false;
+    const probe = `
+      const { createRequire } = require('node:module');
+      const { chromium } = createRequire(process.argv[1])('playwright');
+      (async () => {
+        const browser = await chromium.launch({ headless: true, timeout: 15000 });
+        try {
+          const page = await browser.newPage();
+          await page.goto('about:blank', { timeout: 5000 });
+        } finally { await browser.close(); }
+      })().catch(error => { console.error(error.message); process.exitCode = 1; });
+    `;
+    execFileSync2(process.execPath, ["-e", probe, packageFile], {
+      timeout: 25e3,
+      stdio: "inherit",
+      cwd,
+      env: { ...env, NO_UPDATE_NOTIFIER: "1" }
+    });
+    return true;
+  } catch {
+    return false;
   }
 }
 function executePlaywrightToolAction(action, pnpmBin = resolvePnpmBin(), env) {
@@ -2270,14 +2321,22 @@ function executePlaywrightToolAction(action, pnpmBin = resolvePnpmBin(), env) {
   const command = planPlaywrightCliCommand(action, pnpmBin);
   const invocation = planDetectedBinCommand(command.command, command.args);
   if (invocation === null) return { ok: false, reason: "pnpm-command" };
+  const cwd = action === "install-browser" ? fs13.mkdtempSync(path18.join(os.tmpdir(), "jorgex-playwright-")) : void 0;
+  const childEnv = action === "install-browser" ? { ...env ?? process.env, NO_UPDATE_NOTIFIER: "1" } : env ?? process.env;
   try {
     execFileSync2(invocation.command, invocation.args, {
       stdio: "inherit",
-      ...env === void 0 ? {} : { env }
+      env: childEnv,
+      ...cwd === void 0 ? {} : { cwd }
     });
+    if (action === "install-browser" && !verifyPlaywrightBrowser(pnpmBin, childEnv, cwd)) {
+      return { ok: false, reason: "browser-launch" };
+    }
     return { ok: true };
   } catch {
     return { ok: false, reason: "action-failed" };
+  } finally {
+    if (cwd !== void 0) fs13.rmSync(cwd, { recursive: true, force: true });
   }
 }
 
@@ -2287,6 +2346,7 @@ import path19 from "path";
 var PLAYWRIGHT_CLI_PREFERENCE_VERSION = 1;
 var DEVTOOLS_MCP_PREFERENCE_VERSION = 1;
 var PRIMARY_MODEL_OWNERSHIP_VERSION = 1;
+var PLAYWRIGHT_RUNTIMES = ["opencode", "claude-code", "codex", "pi"];
 function readPreference(file) {
   try {
     return { raw: fs14.readFileSync(file, "utf8"), errorCode: null };
@@ -2301,8 +2361,11 @@ function playwrightCliPreferenceFile(stateDir = dataDir()) {
 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;
+    if (!isRecord2(value)) return void 0;
+    if (value.version === 1 && typeof value.enabled === "boolean") return { version: 1, enabled: value.enabled };
+    if (value.version !== 2 || !isRecord2(value.enabled)) return void 0;
+    if (Object.entries(value.enabled).some(([runtime, enabled]) => !PLAYWRIGHT_RUNTIMES.includes(runtime) || typeof enabled !== "boolean")) return void 0;
+    return { version: 2, enabled: value.enabled };
   } catch {
     return void 0;
   }
@@ -2315,15 +2378,28 @@ function playwrightCliPreferenceError(file = playwrightCliPreferenceFile()) {
   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()) {
+function loadPlaywrightCliPreference(file = playwrightCliPreferenceFile(), runtime) {
   const { raw } = readPreference(file);
-  if (raw === null) return void 0;
-  return parsePlaywrightCliPreference(raw);
+  const state = raw === null ? void 0 : parsePlaywrightCliPreference(raw);
+  if (state === void 0) return void 0;
+  if (state.version === 1) return state.enabled;
+  return runtime === void 0 ? Object.values(state.enabled).some(Boolean) : state.enabled[runtime] === true;
 }
-function savePlaywrightCliPreference(file, enabled) {
+function savePlaywrightCliPreference(file, enabled, selection) {
   const error = playwrightCliPreferenceError(file);
   if (error !== null) throw new Error(error);
-  writeText(file, JSON.stringify({ version: PLAYWRIGHT_CLI_PREFERENCE_VERSION, enabled }) + "\n");
+  const { raw } = readPreference(file);
+  const previous = raw === null ? void 0 : parsePlaywrightCliPreference(raw);
+  if (selection === void 0 && previous?.version !== 2) {
+    writeText(file, JSON.stringify({ version: PLAYWRIGHT_CLI_PREFERENCE_VERSION, enabled }) + "\n");
+    return;
+  }
+  const inherited = previous?.version === 2 ? previous.enabled : Object.fromEntries(PLAYWRIGHT_RUNTIMES.map((runtime) => [runtime, previous?.enabled === true]));
+  const choices = { ...inherited, ...selection };
+  const state = { version: 2, enabled: enabled ? choices : Object.fromEntries(Object.keys(choices).map((runtime) => [runtime, false])) };
+  const content = JSON.stringify(state) + "\n";
+  if (parsePlaywrightCliPreference(content) === void 0) throw new Error("Playwright CLI: selecci\xF3n de runtimes inv\xE1lida.");
+  writeText(file, content);
 }
 function devtoolsMcpPreferenceFile(stateDir = dataDir()) {
   return path19.join(stateDir, "devtools-mcp.json");
@@ -2536,7 +2612,7 @@ function makeContext(adapter, configDir, mode = DEFAULT_INSTALL_MODE_PREFERENCE,
     models,
     warnings: [],
     enabledMcpServers: enabledMcpServers(adapter.id, void 0, useBrowserPreferences),
-    playwrightCliEnabled: useBrowserPreferences && loadPlaywrightCliPreference() === true,
+    playwrightCliEnabled: useBrowserPreferences && loadPlaywrightCliPreference(playwrightCliPreferenceFile(), adapter.id) === true,
     ownedMcpServers: ownedMcpServers(adapter.id, useBrowserPreferences),
     ownedPrimaryModelFields: useBrowserPreferences ? loadPrimaryModelOwnership(primaryModelOwnershipFile(), adapter.id, configDir) : /* @__PURE__ */ new Set()
   };
@@ -2655,7 +2731,7 @@ async function runInstall(opts) {
       models,
       warnings: [],
       enabledMcpServers: enabledMcpServers(id, opts.devtoolsMcpSelection?.[id], useManifest),
-      playwrightCliEnabled: projectPlaywrightPrompt || useManifest && loadPlaywrightCliPreference() === true,
+      playwrightCliEnabled: projectPlaywrightPrompt ? opts.playwrightToolConsent?.runtimeSelection?.[id] ?? true : useManifest && loadPlaywrightCliPreference(playwrightCliPreferenceFile(), id) === true,
       ownedMcpServers: ownedMcpServers(id, useManifest),
       ownedPrimaryModelFields: useManifest ? loadPrimaryModelOwnership(primaryModelOwnershipFile(), id, configDir) : /* @__PURE__ */ new Set()
     };
@@ -2750,7 +2826,11 @@ async function runInstall(opts) {
           const pnpmBin = resolvePnpmBin();
           return executePlaywrightToolAction2(action, pnpmBin, env);
         },
-        persistEnabled: (enabled) => savePlaywrightCliPreference(playwrightCliPreferenceFile(), enabled),
+        persistEnabled: (enabled) => {
+          const selected = opts.playwrightToolConsent?.runtimeSelection;
+          const fileSelection = selected === void 0 ? void 0 : Object.fromEntries(Object.entries(selected).filter(([runtime]) => runtime !== "pi"));
+          savePlaywrightCliPreference(playwrightCliPreferenceFile(), enabled, fileSelection);
+        },
         setupPnpm: (pnpmBin) => setupPnpmGlobal(pnpmBin)
       };
       let setupAttempted = false;
@@ -2778,6 +2858,7 @@ async function runInstall(opts) {
             return first;
           }
           preparedEnv = setup.env;
+          p.log.info("pnpm preparado para esta instalaci\xF3n. Abre una terminal nueva al terminar para que otras herramientas y doctor reciban el PATH actualizado.");
           return baseDeps.run(action, preparedEnv);
         }
       });
@@ -2789,7 +2870,11 @@ async function runInstall(opts) {
       } else {
         let promptReconciliationFailed = false;
         for (const { adapter, ctx } of successfulContexts) {
-          const browserCtx = { ...ctx, playwrightCliEnabled: true, warnings: [] };
+          const browserCtx = {
+            ...ctx,
+            playwrightCliEnabled: opts.playwrightToolConsent?.runtimeSelection?.[adapter.id] ?? true,
+            warnings: []
+          };
           try {
             const browserChanges = diffPlan(planSystemPrompt(adapter, browserCtx)).filter((change) => change.status !== "unchanged");
             if (browserChanges.length === 0) continue;
@@ -2812,7 +2897,7 @@ async function runInstall(opts) {
           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.");
+          p.log.success("Playwright CLI instalado y arranque de Chromium verificado.");
         }
       }
     }
@@ -3276,6 +3361,10 @@ function runPiPackageManagedOperation(input, deps) {
 }
 
 // src/lib/pi-projection-lifecycle.ts
+var HANDOFF_KINDS = ["devtools", "playwright"];
+function handoffEnabled(input, kind) {
+  return (kind === "devtools" ? input.devtoolsMcpEnabled : input.playwrightHandoffEnabled) === true;
+}
 var preparedPiProjectionUninstalls = /* @__PURE__ */ new WeakMap();
 function projectionScope(scope) {
   return {
@@ -3322,18 +3411,27 @@ function projectionPlan(input, scope) {
   if (input.devtoolsMcpEnabled && input.pnpmBin) {
     const server = loadCanonicalMcp(input.stackDir).servers[DEVTOOLS_MCP_SERVER];
     if (server?.transport !== "stdio" || !Array.isArray(server.args)) throw new Error("Falta la configuraci\xF3n can\xF3nica de DevTools.");
-    actions.push({ kind: "write", target: devtoolsPath(scope), content: `${JSON.stringify({
+    actions.push({ kind: "write", target: handoffPath(scope, "devtools"), content: `${JSON.stringify({
       schemaVersion: 1,
       enabled: true,
       command: input.pnpmBin,
       args: server.args
     }, null, 2)}
+` });
+  }
+  if (input.playwrightHandoffEnabled && input.playwrightCliCommand) {
+    actions.push({ kind: "write", target: handoffPath(scope, "playwright"), content: `${JSON.stringify({
+      schemaVersion: 1,
+      enabled: true,
+      command: input.playwrightCliCommand,
+      version: PLAYWRIGHT_CLI.version
+    }, null, 2)}
 ` });
   }
   return actions;
 }
-function devtoolsPath(scope) {
-  return path23.resolve(scope.codingAgentDir, "jorgex-pi", "devtools.v1.json");
+function handoffPath(scope, kind) {
+  return path23.resolve(scope.codingAgentDir, "jorgex-pi", `${kind}.v1.json`);
 }
 function contentHash(content) {
   return createHash("sha256").update(content).digest("hex");
@@ -3344,13 +3442,14 @@ function canonicalActionContent(action) {
 function hasActionDrift(action, deps) {
   return deps.readText(action.target) !== canonicalActionContent(action);
 }
-function applyActions(actions, deps, handoff) {
+function applyActions(actions, deps, handoffs = []) {
   for (const action of actions) {
-    if (handoff && path23.resolve(action.target) === handoff.file) {
+    const handoff = handoffs.find((entry) => path23.resolve(action.target) === entry.file);
+    if (handoff) {
       try {
-        if (deps.readText(handoff.file) !== handoff.previous) return devtoolsConflict(handoff.file);
+        if (deps.readText(handoff.file) !== handoff.previous) return handoffConflict(handoff.kind, handoff.file);
       } catch {
-        return devtoolsConflict(handoff.file);
+        return handoffConflict(handoff.kind, handoff.file);
       }
     }
     if (action.kind === "write") deps.writeText(action.target, action.content);
@@ -3369,8 +3468,7 @@ function receiptFor(plan, scope) {
   const owned = [...new Set(
     plan.map((action) => path23.resolve(action.target)).filter((target) => target !== systemPrompt)
   )];
-  const handoff = plan.find((action) => path23.resolve(action.target) === devtoolsPath(scope));
-  return {
+  const receipt = {
     schemaVersion: 1,
     scope: {
       kind: scope.kind,
@@ -3378,9 +3476,13 @@ function receiptFor(plan, scope) {
       codingAgentDir: scope.codingAgentDir,
       receiptFile: scope.receiptFile
     },
-    owned,
-    ...handoff ? { devtools: { sha256: contentHash(canonicalActionContent(handoff)) } } : {}
+    owned
   };
+  for (const kind of HANDOFF_KINDS) {
+    const action = plan.find((entry) => path23.resolve(entry.target) === handoffPath(scope, kind));
+    if (action) receipt[kind] = { sha256: contentHash(canonicalActionContent(action)) };
+  }
+  return receipt;
 }
 function receiptContent(receipt) {
   return `${JSON.stringify(receipt, null, 2)}
@@ -3398,25 +3500,24 @@ function parseReceipt2(raw, expected) {
     const version = Reflect.get(receipt, "schemaVersion");
     const receivedScope = Reflect.get(receipt, "scope");
     const owned = Reflect.get(receipt, "owned");
-    const devtools = Reflect.get(receipt, "devtools");
-    const hasDevtools = Object.hasOwn(receipt, "devtools");
-    if (version !== expected.schemaVersion || !hasExactKeys(receipt, ["schemaVersion", "scope", "owned", ...hasDevtools ? ["devtools"] : []]) || receivedScope === null || typeof receivedScope !== "object" || Array.isArray(receivedScope) || !hasExactKeys(receivedScope, ["kind", "home", "codingAgentDir", "receiptFile"])) {
+    const presentKinds = HANDOFF_KINDS.filter((kind) => Object.hasOwn(receipt, kind));
+    if (version !== expected.schemaVersion || !hasExactKeys(receipt, ["schemaVersion", "scope", "owned", ...presentKinds]) || receivedScope === null || typeof receivedScope !== "object" || Array.isArray(receivedScope) || !hasExactKeys(receivedScope, ["kind", "home", "codingAgentDir", "receiptFile"])) {
       return null;
     }
     if (Reflect.get(receivedScope, "kind") !== expected.scope.kind || Reflect.get(receivedScope, "home") !== expected.scope.home || Reflect.get(receivedScope, "codingAgentDir") !== expected.scope.codingAgentDir || Reflect.get(receivedScope, "receiptFile") !== expected.scope.receiptFile || !Array.isArray(owned)) {
       return null;
     }
-    if (hasDevtools && (devtools === null || typeof devtools !== "object" || Array.isArray(devtools) || !hasExactKeys(devtools, ["sha256"]) || typeof Reflect.get(devtools, "sha256") !== "string" || !/^[a-f0-9]{64}$/.test(Reflect.get(devtools, "sha256")))) return null;
-    const handoff = devtoolsPath(expected.scope);
-    const expectedOwned = expected.owned.filter((file) => file !== handoff);
-    if (hasDevtools) expectedOwned.push(handoff);
+    const digests = {};
+    for (const kind of presentKinds) {
+      const value = Reflect.get(receipt, kind);
+      if (value === null || typeof value !== "object" || Array.isArray(value) || !hasExactKeys(value, ["sha256"]) || typeof Reflect.get(value, "sha256") !== "string" || !/^[a-f0-9]{64}$/.test(Reflect.get(value, "sha256"))) return null;
+      digests[kind] = { sha256: Reflect.get(value, "sha256") };
+    }
+    const handoffPaths = HANDOFF_KINDS.map((kind) => handoffPath(expected.scope, kind));
+    const expectedOwned = expected.owned.filter((file) => !handoffPaths.includes(file));
+    for (const kind of presentKinds) expectedOwned.push(handoffPath(expected.scope, kind));
     if (owned.length !== expectedOwned.length || !owned.every((file, index) => typeof file === "string" && file === expectedOwned[index])) return null;
-    return {
-      schemaVersion: 1,
-      scope: expected.scope,
-      owned: expectedOwned,
-      ...hasDevtools ? { devtools: { sha256: Reflect.get(devtools, "sha256") } } : {}
-    };
+    return { schemaVersion: 1, scope: expected.scope, owned: expectedOwned, ...digests };
   } catch {
     return null;
   }
@@ -3542,34 +3643,39 @@ function readProjectionReceipt(receiptFile, deps) {
     return { kind: "unreadable" };
   }
 }
-function devtoolsConflict(file) {
+function handoffConflict(kind, file) {
+  const label = kind === "devtools" ? "DevTools" : "Playwright";
   return blocked2(
-    "projection-devtools-conflict",
+    `projection-${kind}-conflict`,
     [file],
-    "El handoff de DevTools es ajeno o fue modificado. Cons\xE9rvalo y revisa su propiedad antes de reintentar; Stack no lo sobrescribe ni elimina."
+    `El handoff de ${label} es ajeno o fue modificado. Cons\xE9rvalo y revisa su propiedad antes de reintentar; Stack no lo sobrescribe ni elimina.`
   );
 }
-function inspectDevtools(input, scope, expected, deps) {
-  const file = devtoolsPath(scope);
+function inspectHandoffs(input, scope, expected, deps) {
   const read = readProjectionReceipt(scope.receiptFile, deps);
   if (read.kind === "unreadable") return receiptUnreadable(scope.receiptFile);
   const previous = read.kind === "present" ? parseReceipt2(read.content, expected) : null;
-  let content;
-  try {
-    content = deps.readText(file);
-  } catch {
-    return devtoolsConflict(file);
-  }
-  let recordedDevtools = false;
-  if (read.kind === "present") {
+  const handoffs = [];
+  for (const kind of HANDOFF_KINDS) {
+    const file = handoffPath(scope, kind);
+    let content;
     try {
-      recordedDevtools = Object.hasOwn(JSON.parse(read.content), "devtools");
+      content = deps.readText(file);
     } catch {
+      return handoffConflict(kind, file);
     }
-    if (!previous && (input.devtoolsMcpEnabled || content !== null || recordedDevtools)) return receiptInvalid(scope.receiptFile);
+    let recorded = false;
+    if (read.kind === "present") {
+      try {
+        recorded = Object.hasOwn(JSON.parse(read.content), kind);
+      } catch {
+      }
+      if (!previous && (handoffEnabled(input, kind) || content !== null || recorded)) return receiptInvalid(scope.receiptFile);
+    }
+    if (content !== null && (!previous?.[kind] || contentHash(content) !== previous[kind].sha256)) return handoffConflict(kind, file);
+    handoffs.push({ kind, file, content });
   }
-  if (content !== null && (!previous?.devtools || contentHash(content) !== previous.devtools.sha256)) return devtoolsConflict(file);
-  return { kind: "checked", previous, content };
+  return { kind: "checked", previous, handoffs };
 }
 function preparePiProjectionUninstall(input, deps) {
   if (input.operation !== "uninstall") {
@@ -3606,14 +3712,19 @@ function preparePiProjectionUninstall(input, deps) {
     receiptFile = path23.resolve(scope.receiptFile);
     backupTargets = [...backupTargets, ...receipt.owned, receiptFile];
   }
-  const handoff = devtoolsPath(scope);
-  let handoffContent;
-  try {
-    handoffContent = deps.readText(handoff);
-  } catch {
-    return devtoolsConflict(handoff);
+  const handoffs = [];
+  for (const kind of HANDOFF_KINDS) {
+    const file = handoffPath(scope, kind);
+    let content;
+    try {
+      content = deps.readText(file);
+    } catch {
+      return handoffConflict(kind, file);
+    }
+    const digest = ownedReceipt?.[kind]?.sha256;
+    if (content !== null && (digest === void 0 || contentHash(content) !== digest)) return handoffConflict(kind, file);
+    if (digest !== void 0) handoffs.push({ kind, file, sha256: digest });
   }
-  if (handoffContent !== null && (!ownedReceipt?.devtools || contentHash(handoffContent) !== ownedReceipt.devtools.sha256)) return devtoolsConflict(handoff);
   const backup = backupExisting(backupTargets, deps);
   if (backup.kind === "backup-failed") return backupFailure(backup.paths);
   const token = {};
@@ -3621,7 +3732,7 @@ function preparePiProjectionUninstall(input, deps) {
     prompt: promptUpdate,
     ownedToRemove,
     receiptFile,
-    ...ownedReceipt?.devtools ? { devtools: { file: handoff, sha256: ownedReceipt.devtools.sha256 } } : {}
+    handoffs
   });
   return { kind: "prepared", plan: token };
 }
@@ -3633,14 +3744,14 @@ function completePiProjectionUninstall(plan, deps) {
   if (prepared === void 0) {
     return cleanupFailure([]);
   }
-  if (prepared.devtools) {
+  for (const handoff of prepared.handoffs) {
     let current;
     try {
-      current = deps.readText(prepared.devtools.file);
+      current = deps.readText(handoff.file);
     } catch {
-      return devtoolsConflict(prepared.devtools.file);
+      return handoffConflict(handoff.kind, handoff.file);
     }
-    if (current !== null && contentHash(current) !== prepared.devtools.sha256) return devtoolsConflict(prepared.devtools.file);
+    if (current !== null && contentHash(current) !== handoff.sha256) return handoffConflict(handoff.kind, handoff.file);
   }
   if (prepared.prompt !== null) {
     try {
@@ -3651,9 +3762,10 @@ function completePiProjectionUninstall(plan, deps) {
   }
   for (const owned of prepared.ownedToRemove) {
     try {
-      if (prepared.devtools?.file === owned) {
+      const handoff = prepared.handoffs.find((entry) => entry.file === owned);
+      if (handoff) {
         const current = deps.readText(owned);
-        if (current !== null && contentHash(current) !== prepared.devtools.sha256) return devtoolsConflict(owned);
+        if (current !== null && contentHash(current) !== handoff.sha256) return handoffConflict(handoff.kind, owned);
       }
       deps.removeFile(owned);
     } catch {
@@ -3676,22 +3788,27 @@ function runPiProjectionLifecycle(input, deps) {
     return prepared.kind === "blocked" ? prepared : completePiProjectionUninstall(prepared.plan, deps);
   }
   if (input.devtoolsMcpEnabled && (!input.pnpmBin || !path23.isAbsolute(input.pnpmBin))) {
-    return blocked2("projection-devtools-command", [devtoolsPath(scope)], "DevTools requiere un ejecutable pnpm absoluto disponible en PATH.");
+    return blocked2("projection-devtools-command", [handoffPath(scope, "devtools")], "DevTools requiere un ejecutable pnpm absoluto disponible en PATH.");
+  }
+  if (input.playwrightHandoffEnabled && (!input.playwrightCliCommand || !path23.isAbsolute(input.playwrightCliCommand) || /[\u0000-\u001f\u007f]/.test(input.playwrightCliCommand))) {
+    return blocked2("projection-playwright-command", [handoffPath(scope, "playwright")], "Playwright requiere un ejecutable absoluto verificado. Abre una terminal nueva tras pnpm setup y reintenta install --playwright.");
   }
   const plan = projectionPlan(input, scope);
   assertPlanContained(plan, scope);
   const receipt = receiptFor(plan, scope);
-  const devtools = inspectDevtools(input, scope, receipt, deps);
-  if (devtools.kind === "blocked") return input.operation === "doctor" ? { kind: "drift", paths: devtools.paths } : devtools;
-  const removeHandoff = !input.devtoolsMcpEnabled && devtools.previous?.devtools !== void 0 && devtools.content !== null;
+  const checked = inspectHandoffs(input, scope, receipt, deps);
+  if (checked.kind === "blocked") return input.operation === "doctor" ? { kind: "drift", paths: checked.paths } : checked;
+  const removedHandoffs = checked.handoffs.filter(({ kind, content }) => !handoffEnabled(input, kind) && checked.previous?.[kind] !== void 0 && content !== null);
   const expectedReceipt2 = receiptContent(receipt);
   const drifted = plan.filter((action) => hasActionDrift(action, deps));
-  if (input.devtoolsMcpEnabled && devtools.previous?.devtools?.sha256 !== receipt.devtools?.sha256 && !drifted.some((action) => path23.resolve(action.target) === devtoolsPath(scope))) {
-    return input.operation === "doctor" ? { kind: "drift", paths: [devtoolsPath(scope)] } : devtoolsConflict(devtoolsPath(scope));
+  for (const { kind, file } of checked.handoffs) {
+    if (handoffEnabled(input, kind) && checked.previous?.[kind]?.sha256 !== receipt[kind]?.sha256 && !drifted.some((action) => path23.resolve(action.target) === file)) {
+      return input.operation === "doctor" ? { kind: "drift", paths: [file] } : handoffConflict(kind, file);
+    }
   }
   if (input.operation === "doctor") {
     const paths = drifted.map((action) => path23.resolve(action.target));
-    if (removeHandoff) paths.push(devtoolsPath(scope));
+    paths.push(...removedHandoffs.map(({ file }) => file));
     const currentSettings2 = deps.readText(scope.settingsFile);
     if (currentSettings2 === null || filterProjectedPiPackage(currentSettings2, input.packageSource) !== currentSettings2) {
       paths.push(scope.settingsFile);
@@ -3707,30 +3824,38 @@ function runPiProjectionLifecycle(input, deps) {
   }
   const packageWillChange = filteredSettings !== null && filteredSettings !== currentSettings;
   const receiptChanged = deps.readText(scope.receiptFile) !== expectedReceipt2;
-  if (drifted.length > 0 || packageWillChange || receiptChanged || removeHandoff) {
+  if (drifted.length > 0 || packageWillChange || receiptChanged || removedHandoffs.length > 0) {
     const backup = backupExisting([
       ...drifted.map((action) => action.target),
-      ...removeHandoff ? [devtoolsPath(scope)] : [],
+      ...removedHandoffs.map(({ file }) => file),
       ...packageWillChange ? [scope.settingsFile] : [],
       ...receiptChanged ? [scope.receiptFile] : []
     ], deps);
     if (backup.kind === "backup-failed") return backupFailure(backup.paths);
   }
-  if (removeHandoff) {
+  for (const { kind, file } of removedHandoffs) {
     try {
-      const current = deps.readText(devtoolsPath(scope));
-      if (current !== null && contentHash(current) !== devtools.previous?.devtools?.sha256) return devtoolsConflict(devtoolsPath(scope));
-      deps.removeFile(devtoolsPath(scope));
+      const current = deps.readText(file);
+      if (current !== null && contentHash(current) !== checked.previous?.[kind]?.sha256) return handoffConflict(kind, file);
     } catch {
-      return cleanupFailure([devtoolsPath(scope)]);
+      return handoffConflict(kind, file);
     }
   }
-  const writeResult = applyActions(drifted, deps, input.devtoolsMcpEnabled ? { file: devtoolsPath(scope), previous: devtools.content } : void 0);
+  for (const { kind, file } of removedHandoffs) {
+    try {
+      const current = deps.readText(file);
+      if (current !== null && contentHash(current) !== checked.previous?.[kind]?.sha256) return handoffConflict(kind, file);
+      deps.removeFile(file);
+    } catch {
+      return cleanupFailure([file]);
+    }
+  }
+  const writeResult = applyActions(drifted, deps, checked.handoffs.filter(({ kind }) => handoffEnabled(input, kind)).map(({ kind, file, content }) => ({ kind, file, previous: content })));
   if (writeResult) return writeResult;
   if (packageWillChange && filteredSettings !== null) deps.writeText(scope.settingsFile, filteredSettings);
   if (receiptChanged) deps.writeText(scope.receiptFile, expectedReceipt2);
   if (input.operation === "install") return { kind: "installed", receipt };
-  return { kind: "synced", changed: drifted.length > 0 || packageWillChange || receiptChanged || removeHandoff };
+  return { kind: "synced", changed: drifted.length > 0 || packageWillChange || receiptChanged || removedHandoffs.length > 0 };
 }
 function systemProjectionLifecycle(input) {
   const targetRoot = input.targetDir === void 0 ? null : path23.resolve(input.targetDir);
@@ -3749,7 +3874,9 @@ function systemProjectionLifecycle(input) {
       engramBin: input.engramBin ?? "",
       playwrightCliEnabled: input.playwrightCliEnabled,
       devtoolsMcpEnabled: input.devtoolsMcpEnabled,
-      pnpmBin: input.pnpmBin
+      pnpmBin: input.pnpmBin,
+      playwrightHandoffEnabled: input.playwrightHandoffEnabled,
+      playwrightCliCommand: input.playwrightCliCommand
     },
     deps: {
       readText: readTextOnlyIfMissing,
@@ -3954,6 +4081,7 @@ function engramVersion(bin) {
 }
 function resolvePlaywrightDoctorState(input) {
   if (input.enabled !== true) return { status: "disabled" };
+  if (input.cli.status === "not-in-path") return { status: "not-in-path" };
   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" };
@@ -4014,7 +4142,10 @@ async function runDoctor() {
     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.");
+      p3.log.success("Playwright CLI: paquete y cach\xE9 de Chromium detectados (doctor no prueba el arranque).");
+    } else if (playwright.status === "not-in-path") {
+      p3.log.warn("Playwright CLI: instalado en el directorio de pnpm, pero fuera del PATH de esta terminal. Abre una terminal nueva tras pnpm setup; no hace falta reinstalarlo.");
+      problems++;
     } 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'.`);
@@ -5340,16 +5471,16 @@ import { createHash as createHash2 } from "crypto";
 var pi_runtime_pin_default = {
   package: {
     name: "jorgex-pi",
-    version: "0.8.13",
-    source: "npm:jorgex-pi@0.8.13"
+    version: "0.8.15",
+    source: "npm:jorgex-pi@0.8.15"
   },
   provenance: {
-    commit: "e28a677da0a112925251cf11269b70cb5c8aa15e"
+    commit: "9d619e205685df0b8b122aa24b81e8694182e3ca"
   },
   tarball: {
-    bytes: 89143404,
-    sha256: "6bbe877249b900af582c8881e0dd7993951ea1cef6e7252522c626c078de7478",
-    sha512: "bb527d1f3812406f2184f778b22cca00ead33692fecac0012cf8cdcdc469b7cccf3c789c35b4327dd599d06542162bd07eefeeaaa40de19662ec5fc422b14af8"
+    bytes: 89145074,
+    sha256: "a866da924e0d7ad2b5a5ef285671c06b742d5b64cd62d463a8a39d8e7b5d4453",
+    sha512: "ac5a70bcf336bd28eccb06360a8874c2a3bb2887fe420b6f97a0b61ca1b1c97d2db26fd28033fa296ab273423b1b5884d123dfc56ad1d6e274aefd828d9d25c6"
   }
 };
 
@@ -5372,6 +5503,7 @@ var PI_RUNTIME_CANDIDATE = {
       "mcp-adapter-v1",
       "engram-runtime-tools-v1",
       "chrome-devtools-handoff-v1",
+      "playwright-handoff-v1",
       "runner-json-v1",
       "tui-branding-v1",
       "managed-primary-model-v1",
@@ -5480,9 +5612,12 @@ function normalizeInstalledSource(settingsJson, alias, canonical) {
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     const packages = Reflect.get(parsed, "packages");
     if (!Array.isArray(packages)) return null;
-    const hasCanonical = packages.some((entry) => entry === canonical || entry !== null && typeof entry === "object" && !Array.isArray(entry) && Reflect.get(entry, "source") === canonical);
-    if (packages.filter((entry) => entry === alias).length !== 1 || hasCanonical) return null;
-    Reflect.set(parsed, "packages", packages.map((entry) => entry === alias ? canonical : entry));
+    const sourceOf = (entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry) ? Reflect.get(entry, "source") : entry;
+    if (packages.filter((entry) => sourceOf(entry) === alias).length !== 1 || packages.some((entry) => sourceOf(entry) === canonical)) return null;
+    Reflect.set(parsed, "packages", packages.map((entry) => {
+      if (sourceOf(entry) !== alias) return entry;
+      return typeof entry === "string" ? canonical : { ...entry, source: canonical };
+    }));
     return JSON.stringify(parsed);
   } catch {
     return null;
@@ -5943,14 +6078,18 @@ function managedPackageResult(result) {
   return result;
 }
 async function runManagedPiSystem(input) {
-  const { devtoolsMcpEnabled: explicitDevtools, ...runtimeInput } = input;
+  const { devtoolsMcpEnabled: explicitDevtools, playwrightCliEnabled: explicitPlaywright, ...runtimeInput } = input;
   const devtoolsMcpEnabled = explicitDevtools ?? (input.targetDir === void 0 && loadDevtoolsMcpPreference(devtoolsMcpPreferenceFile(), "pi"));
-  const playwrightCliEnabled = input.targetDir === void 0 && loadPlaywrightCliPreference() === true;
+  const supportsPlaywright = PI_RUNTIME_CANDIDATE.contract.capabilities.includes("playwright-handoff-v1");
+  const playwrightCliEnabled = input.targetDir === void 0 && supportsPlaywright && (explicitPlaywright ?? loadPlaywrightCliPreference(void 0, "pi") === true);
+  const playwrightCliCommand = playwrightCliEnabled && input.operation !== "uninstall" && input.operation !== "models" ? detectPlaywrightCli().binPath : null;
   const projectionInput = {
     targetDir: input.targetDir,
     packageSource: PI_RUNTIME_CANDIDATE.package.source,
     engramBin: input.engramBin,
     playwrightCliEnabled,
+    playwrightHandoffEnabled: playwrightCliEnabled,
+    playwrightCliCommand,
     devtoolsMcpEnabled,
     pnpmBin: devtoolsMcpEnabled && input.operation !== "uninstall" ? resolvePnpmBin() : null
   };
@@ -5980,6 +6119,9 @@ async function runManagedPiSystem(input) {
   if (input.targetDir === void 0 && explicitDevtools !== void 0 && (input.operation === "install" || input.operation === "sync") && result.kind !== "blocked") {
     saveDevtoolsMcpPreference(devtoolsMcpPreferenceFile(), "pi", explicitDevtools);
   }
+  if (input.targetDir === void 0 && supportsPlaywright && explicitPlaywright !== void 0 && (input.operation === "install" || input.operation === "sync") && result.kind !== "blocked") {
+    savePlaywrightCliPreference(playwrightCliPreferenceFile(), true, { pi: explicitPlaywright });
+  }
   return result;
 }
 
@@ -6472,6 +6614,7 @@ var VERSION = readPackageVersion();
 var COMMANDS = ["install", "sync", "models", "update", "doctor", "restore", "uninstall", "quality"];
 var QUALITY_REJECTED_VALUE_FLAGS = /* @__PURE__ */ new Set([
   "--agents",
+  "--playwright-runtimes",
   "-a",
   "--target-dir",
   "--mode",
@@ -6557,7 +6700,13 @@ function parseFlags(args, allowReceipt = false) {
       flags.subagentConcurrency = value ?? "";
       i = nextIndex;
     } else if (arg.startsWith("--subagent-concurrency=")) flags.subagentConcurrency = arg.slice(23);
-    else if (arg === "--dry-run") flags.dryRun = true;
+    else if (arg === "--playwright-runtimes") {
+      const [value, nextIndex] = readValue(i);
+      flags.playwrightRuntimes = (value ?? "").split(",").filter(Boolean);
+      i = nextIndex;
+    } else if (arg.startsWith("--playwright-runtimes=")) {
+      flags.playwrightRuntimes = arg.slice("--playwright-runtimes=".length).split(",").filter(Boolean);
+    } else if (arg === "--dry-run") flags.dryRun = true;
     else if (arg === "--yes" || arg === "-y") flags.yes = true;
     else if (arg === "--help" || arg === "-h") flags.help = true;
     else if (arg === "--version" || arg === "-v") flags.version = true;
@@ -6635,8 +6784,25 @@ Corrige o borra ${preferenceFile}, o vuelve a ejecutar con --mode human|programm
     subagentConcurrency: concurrency
   };
 }
-async function resolvePlaywrightToolConsent(command, flags) {
+async function resolvePlaywrightToolConsent(command, flags, runtimes) {
   const interactive = Boolean(process.stdout.isTTY);
+  const supported = runtimes.filter((runtime) => runtime !== "pi" || PI_RUNTIME_CANDIDATE.contract.capabilities.includes("playwright-handoff-v1"));
+  if (flags.playwrightRuntimes !== void 0) {
+    const requested = flags.playwrightRuntimes;
+    let error;
+    if (requested.length === 0) error = "--playwright-runtimes requiere al menos un runtime.";
+    for (const runtime of requested) {
+      if (!["opencode", "claude-code", "codex", "pi"].includes(runtime)) error = `Runtime Playwright desconocido: ${runtime}.`;
+      else if (!runtimes.includes(runtime)) error = `El runtime ${runtime} no est\xE1 en --agents/destinos de esta instalaci\xF3n.`;
+      else if (!supported.includes(runtime)) error = "Pi requiere un candidato con playwright-handoff-v1 para activar Playwright.";
+      if (error) break;
+    }
+    if (error) {
+      console.error(error);
+      process.exitCode = 1;
+      return null;
+    }
+  }
   let confirmed = false;
   if (command === "install" && interactive && !flags.yes && !flags.dryRun && flags.targetDir === void 0) {
     const answer = await p6.confirm({
@@ -6646,13 +6812,33 @@ async function resolvePlaywrightToolConsent(command, flags) {
     if (p6.isCancel(answer)) return null;
     confirmed = answer === true;
   }
+  let runtimeSelection;
+  const approved = interactive && !flags.yes ? confirmed : flags.yes && flags.playwright;
+  if (command === "install" && approved && supported.length > 0) {
+    let selected = flags.playwrightRuntimes ?? supported;
+    if (interactive && !flags.yes && !flags.dryRun && flags.targetDir === void 0 && flags.playwrightRuntimes === void 0) {
+      const answer = await p6.multiselect({
+        message: "\xBFEn qu\xE9 runtimes activar la gu\xEDa de Playwright? (instalaci\xF3n global compartida)",
+        required: false,
+        options: supported.map((runtime) => ({ value: runtime, label: runtime === "pi" ? "Pi" : ADAPTERS[runtime]?.name ?? runtime })),
+        initialValues: supported.filter((runtime) => loadPlaywrightCliPreference(void 0, runtime) === true)
+      });
+      if (p6.isCancel(answer)) return null;
+      selected = answer;
+    }
+    runtimeSelection = Object.fromEntries(supported.map((runtime) => [runtime, selected.includes(runtime)]));
+  }
+  if (command === "install" && approved && runtimes.includes("pi") && !supported.includes("pi")) {
+    p6.log.info("La activaci\xF3n de Playwright en Pi requiere la pr\xF3xima adopci\xF3n del paquete Pi; el binario global s\xED puede instalarse.");
+  }
   return {
     command,
     interactive,
     yes: flags.yes,
     targetDir: flags.targetDir !== void 0,
     explicitToolSelection: flags.playwright,
-    confirmed
+    confirmed,
+    ...runtimeSelection === void 0 ? {} : { runtimeSelection }
   };
 }
 async function resolveDevtoolsMcpSelection(command, flags, runtimes) {
@@ -6743,7 +6929,7 @@ async function resolveHostEngramForInstall(flags) {
     return { ok: false, message: `Engram: ${error instanceof Error ? error.message : String(error)}` };
   }
 }
-async function runSelectedPi(operation, targetDir, yes = false, resolvedEngramBin, devtoolsMcpEnabled) {
+async function runSelectedPi(operation, targetDir, yes = false, resolvedEngramBin, devtoolsMcpEnabled, playwrightCliEnabled) {
   if (targetDir === void 0 && operation !== "models") {
     const preferenceErrors = browserPreferenceErrors();
     if (preferenceErrors.length > 0) {
@@ -6786,7 +6972,8 @@ async function runSelectedPi(operation, targetDir, yes = false, resolvedEngramBi
     targetDir,
     detected: { executable: detected.executable, version: detected.version },
     engramBin,
-    ...devtoolsMcpEnabled === void 0 ? {} : { devtoolsMcpEnabled }
+    ...devtoolsMcpEnabled === void 0 ? {} : { devtoolsMcpEnabled },
+    ...playwrightCliEnabled === void 0 ? {} : { playwrightCliEnabled }
   });
   if (result.kind === "blocked") {
     const paths = "paths" in result ? `: ${result.paths.join(", ")}` : "";
@@ -6827,6 +7014,7 @@ Opciones:
   --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
+  --playwright-runtimes <csv>  Activa su gu\xEDa s\xF3lo en estos runtimes de --agents (con --playwright)
   --remove-playwright   (uninstall) retira solo el paquete global de Playwright;
                         nunca perfiles, cach\xE9 ni navegadores
   --receipt <path>      (quality) escribe el receipt en ese path de forma at\xF3mica
@@ -6861,6 +7049,11 @@ Flags disponibles: jorgex-stack --help`
     process.exitCode = 1;
     return;
   }
+  if (flags.playwrightRuntimes !== void 0 && (command !== "install" || !flags.playwright)) {
+    console.error("--playwright-runtimes requiere install --playwright.");
+    process.exitCode = 1;
+    return;
+  }
   if (command !== "quality" && flags.targetDir !== void 0 && flags.agents.length !== 1) {
     console.error("--target-dir requiere exactamente un runtime en --agents.");
     process.exitCode = 1;
@@ -6927,8 +7120,11 @@ Flags disponibles: jorgex-stack --help`
           exitCode = process.exitCode === 1 ? 1 : 0;
           return;
         }
-        const playwrightToolConsent = await resolvePlaywrightToolConsent(command, flags);
-        if (playwrightToolConsent === null) return;
+        const playwrightToolConsent = await resolvePlaywrightToolConsent(command, flags, runtimes);
+        if (playwrightToolConsent === null) {
+          exitCode = process.exitCode === 1 ? 1 : 0;
+          return;
+        }
         if (!await ensureOpenCodeModelsForInstall(command, flags, fileRuntimes)) {
           exitCode = 1;
           return;
@@ -6980,7 +7176,8 @@ Flags disponibles: jorgex-stack --help`
             flags.targetDir,
             flags.yes,
             flags.targetDir === void 0 ? engramBin : void 0,
-            devtoolsMcpSelection.pi
+            devtoolsMcpSelection.pi,
+            flags.targetDir === void 0 && exitCode === 0 && resolvePlaywrightToolPlan(playwrightToolConsent).actions.length > 0 ? playwrightToolConsent.runtimeSelection?.pi : void 0
           ));
         }
         completed = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jorgex-stack",
-  "version": "1.9.31",
+  "version": "1.9.33",
   "description": "Harness multi-agente portable: instala la config JorgeX (agentes, skills, hooks, Engram, MCPs) en Claude Code, Codex CLI, OpenCode y Pi",
   "type": "module",
   "license": "MIT",