jorgex-stack 1.9.36 → 1.9.37

package/dist/cli.js

@@ -15,133 +15,80 @@ import {
 
 // src/cli.ts
 import * as p6 from "@clack/prompts";
-import fs25 from "fs";
+import fs26 from "fs";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/install.ts
-import fs15 from "fs";
-import path20 from "path";
+import fs16 from "fs";
+import path21 from "path";
 import * as p from "@clack/prompts";
 
-// src/adapters/opencode.ts
-import path6 from "path";
+// src/lib/writing-style.ts
 import fs3 from "fs";
-import { isDeepStrictEqual } from "util";
-import { pathToFileURL } from "url";
-
-// src/lib/canonical.ts
-import path from "path";
-import fs from "fs";
-function parseCanonicalAgent(source, file) {
-  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(source);
-  if (!match) throw new Error(`Agente sin frontmatter: ${file}`);
-  const fields = {};
-  for (const line of match[1].split(/\r?\n/)) {
-    const sep = line.indexOf(":");
-    if (sep === -1) continue;
-    fields[line.slice(0, sep).trim()] = line.slice(sep + 1).trim();
-  }
-  const required = ["name", "description", "mode", "tier"];
-  for (const key of required) {
-    if (!fields[key]) throw new Error(`Agente ${file}: falta '${key}' en el frontmatter`);
-  }
-  return {
-    name: fields.name,
-    description: fields.description,
-    mode: fields.mode === "primary" ? "primary" : "subagent",
-    tier: fields.tier,
-    readonly: fields.readonly === "true",
-    bash: fields.bash ?? "full",
-    spawn: fields.spawn !== "false",
-    body: source.slice(match[0].length)
-  };
-}
-function loadCanonicalAgents(agentsDir) {
-  return fs.readdirSync(agentsDir).filter((f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md").map((f) => {
-    const file = path.join(agentsDir, f);
-    const source = fs.readFileSync(file, "utf8").replace(/\r\n/g, "\n");
-    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"));
-}
-function loadCanonicalHooks(stackDir) {
-  return JSON.parse(fs.readFileSync(path.join(stackDir, "hooks", "hooks.json"), "utf8"));
-}
-function loadCanonicalDefaults(stackDir) {
-  const file = path.join(stackDir, "config", "defaults.json");
-  if (!fs.existsSync(file)) return {};
-  const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
-  delete parsed["$comment"];
-  return parsed;
-}
-
-// src/lib/model-map.ts
 import path3 from "path";
-import { existsSync } from "fs";
 
-// src/lib/fsx.ts
+// src/lib/backup.ts
 import fs2 from "fs";
 import path2 from "path";
+import crypto from "crypto";
+
+// src/lib/fsx.ts
+import fs from "fs";
+import path from "path";
 function readTextIfExists(file) {
   try {
-    return fs2.readFileSync(file, "utf8");
+    return fs.readFileSync(file, "utf8");
   } catch {
     return null;
   }
 }
 function ensureDir(dir) {
-  fs2.mkdirSync(dir, { recursive: true });
+  fs.mkdirSync(dir, { recursive: true });
 }
 var tmpCounter = 0;
 function tmpPath(target) {
-  return path2.join(path2.dirname(target), `.jorgex-${process.pid}-${tmpCounter++}.tmp`);
+  return path.join(path.dirname(target), `.jorgex-${process.pid}-${tmpCounter++}.tmp`);
 }
 function renameInto(tmp, target) {
   try {
-    fs2.renameSync(tmp, target);
+    fs.renameSync(tmp, target);
   } catch (err) {
-    fs2.rmSync(tmp, { force: true });
+    fs.rmSync(tmp, { force: true });
     throw err;
   }
 }
-function writeText(file, content) {
-  ensureDir(path2.dirname(file));
+function writeText(file, content, mode) {
+  ensureDir(path.dirname(file));
   const tmp = tmpPath(file);
-  fs2.writeFileSync(tmp, content, "utf8");
+  fs.writeFileSync(tmp, content, { encoding: "utf8", mode });
   renameInto(tmp, file);
 }
 function copyFile(source, target) {
-  ensureDir(path2.dirname(target));
+  ensureDir(path.dirname(target));
   const tmp = tmpPath(target);
-  fs2.copyFileSync(source, tmp);
+  fs.copyFileSync(source, tmp);
   renameInto(tmp, target);
 }
 function isContainedIn(child, root) {
-  const rel = path2.relative(path2.resolve(root), path2.resolve(child));
-  return rel !== "" && rel !== ".." && !rel.startsWith(`..${path2.sep}`) && !path2.isAbsolute(rel);
+  const rel = path.relative(path.resolve(root), path.resolve(child));
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
 }
 function pruneEmptyDirs(file, root) {
-  let dir = path2.dirname(file);
+  let dir = path.dirname(file);
   while (dir.startsWith(root) && dir !== root) {
     try {
-      if (fs2.readdirSync(dir).length > 0) return;
-      fs2.rmdirSync(dir);
+      if (fs.readdirSync(dir).length > 0) return;
+      fs.rmdirSync(dir);
     } catch {
       return;
     }
-    dir = path2.dirname(dir);
+    dir = path.dirname(dir);
   }
 }
 function sameFileContent(a, b) {
   try {
-    const bufA = fs2.readFileSync(a);
-    const bufB = fs2.readFileSync(b);
+    const bufA = fs.readFileSync(a);
+    const bufB = fs.readFileSync(b);
     return bufA.equals(bufB);
   } catch {
     return false;
@@ -149,10 +96,10 @@ function sameFileContent(a, b) {
 }
 function listFilesRecursive(dir) {
   const out = [];
-  if (!fs2.existsSync(dir)) return out;
+  if (!fs.existsSync(dir)) return out;
   const walk = (d) => {
-    for (const entry of fs2.readdirSync(d, { withFileTypes: true })) {
-      const p7 = path2.join(d, entry.name);
+    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+      const p7 = path.join(d, entry.name);
       if (entry.isDirectory()) walk(p7);
       else out.push(p7);
     }
@@ -161,143 +108,77 @@ function listFilesRecursive(dir) {
   return out;
 }
 
-// src/lib/model-map.ts
-function resolveAgentModel(models, agentName, tier) {
-  const base = models[tier];
-  const override = models.overrides?.[agentName];
-  if (!override) return base;
-  return {
-    model: override.model || base.model,
-    variant: "variant" in override ? override.variant || void 0 : base.variant
-  };
-}
-var DEFAULT_MODEL_MAP = {
-  "claude-code": {
-    strong: { model: "fable" },
-    standard: { model: "sonnet" },
-    cheap: { model: "haiku" }
-  },
-  // El primary (orchestrator) no usa estos tiers: tanto el profile de CLI como
-  // la skill de la app heredan el modelo elegido por el usuario. Estos defaults
-  // son solo para subagentes; variant → model_reasoning_effort.
-  codex: {
-    strong: { model: "gpt-6-astra", variant: "low" },
-    standard: { model: "gpt-5.6-luna", variant: "max" },
-    cheap: { model: "gpt-5.6-luna", variant: "medium" }
-  }
-};
-function modelMapFile() {
-  return path3.join(dataDir(), "model-map.json");
+// src/lib/backup.ts
+var KEEP_BACKUPS = 10;
+function backupsRoot() {
+  return path2.join(dataDir(), "backups");
 }
-function loadModelMap() {
-  const file = modelMapFile();
-  const raw = readTextIfExists(file);
-  if (raw === null) return DEFAULT_MODEL_MAP;
-  let fromDisk;
-  try {
-    fromDisk = JSON.parse(raw);
-  } catch {
-    throw new Error(`El mapa de modelos ${file} contiene JSON inv\xE1lido. Corrige el JSON o restaura una copia antes de continuar.`);
-  }
-  const merged = { ...fromDisk };
-  for (const id of Object.keys(DEFAULT_MODEL_MAP)) {
-    merged[id] = { ...DEFAULT_MODEL_MAP[id], ...fromDisk[id] ?? {} };
-    if (fromDisk[id] && !Object.hasOwn(fromDisk[id], "overrides")) delete merged[id].overrides;
+function compositeChecksum(files) {
+  const hash = crypto.createHash("sha256");
+  for (const file of [...files].sort()) {
+    const content = crypto.createHash("sha256").update(fs2.readFileSync(file)).digest("hex");
+    hash.update(`${file}:${content}
+`);
   }
-  return merged;
+  return hash.digest("hex");
 }
-function ensureModelMapFile() {
-  const file = modelMapFile();
-  if (!existsSync(file)) {
-    writeText(file, JSON.stringify(DEFAULT_MODEL_MAP, null, 2) + "\n");
+function createBackup(files, label, root = backupsRoot()) {
+  const existing = [...new Set(files)].filter((f) => fs2.existsSync(f));
+  if (existing.length === 0) return null;
+  const checksum = compositeChecksum(existing);
+  const latest = listBackups(root)[0];
+  if (latest?.checksum === checksum) return latest;
+  const base = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${label}`;
+  let id = base;
+  let dir = path2.join(root, id);
+  for (let n = 1; fs2.existsSync(dir); n++) {
+    id = `${base}-${n}`;
+    dir = path2.join(root, id);
   }
-  return file;
+  ensureDir(path2.join(dir, "files"));
+  const entries = existing.map((original, i) => {
+    const stored = path2.join(dir, "files", `${String(i).padStart(4, "0")}-${path2.basename(original)}`);
+    fs2.copyFileSync(original, stored);
+    return { original, stored };
+  });
+  const info = { id, label, createdAt: (/* @__PURE__ */ new Date()).toISOString(), files: entries, checksum };
+  writeText(path2.join(dir, "manifest.json"), JSON.stringify(info, null, 2) + "\n");
+  pruneBackups(root);
+  return info;
 }
-
-// src/lib/detect.ts
-import path4 from "path";
-import { existsSync as existsSync2, statSync } from "fs";
-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(path4.delimiter)) {
-    if (!dir) continue;
-    for (const ext of exts) {
-      const candidate = path4.join(dir, cmd + ext);
-      if (statSync(candidate, { throwIfNoEntry: false })?.isFile()) return candidate;
+function listBackups(root = backupsRoot()) {
+  if (!fs2.existsSync(root)) return [];
+  const infos = [];
+  for (const entry of fs2.readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const manifest = readTextIfExists(path2.join(root, entry.name, "manifest.json"));
+    if (manifest === null) continue;
+    try {
+      infos.push(JSON.parse(manifest));
+    } catch {
+      infos.push({ id: entry.name, label: "(manifest corrupto)", createdAt: "", files: [] });
     }
   }
-  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(" ")]
-  };
+  return infos.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
 }
-function runDetectedBin(bin, args, timeoutMs, envOverrides) {
-  try {
-    const command = planDetectedBinCommand(bin, args);
-    if (command === null) return null;
-    return execFileSync(command.command, command.args, {
-      encoding: "utf8",
-      timeout: timeoutMs,
-      stdio: ["ignore", "pipe", "pipe"],
-      ...envOverrides === void 0 ? {} : { env: { ...process.env, ...envOverrides } }
-    });
-  } catch {
-    return null;
+function restoreBackup(id, root = backupsRoot(), boundary = HOME) {
+  const info = listBackups(root).find((b) => b.id === id);
+  if (!info) throw new Error(`Backup no encontrado: ${id}`);
+  let restored = 0;
+  for (const { original, stored } of info.files) {
+    if (!fs2.existsSync(stored)) continue;
+    if (!isContainedIn(original, boundary)) continue;
+    ensureDir(path2.dirname(original));
+    fs2.copyFileSync(stored, original);
+    restored++;
   }
+  return restored;
 }
-function detectOpenCode() {
-  const configDir = process.env.OPENCODE_CONFIG_DIR ?? path4.join(HOME, ".config", "opencode");
-  const binPath = lookPath("opencode");
-  return {
-    id: "opencode",
-    name: "OpenCode",
-    installed: binPath !== null || existsSync2(configDir),
-    binPath,
-    configDir
-  };
-}
-function detectClaudeCode() {
-  const configDir = path4.join(HOME, ".claude");
-  const binPath = lookPath("claude");
-  return {
-    id: "claude-code",
-    name: "Claude Code",
-    installed: binPath !== null || existsSync2(configDir),
-    binPath,
-    configDir
-  };
-}
-function detectCodex() {
-  const configDir = process.env.CODEX_HOME ?? path4.join(HOME, ".codex");
-  const binPath = lookPath("codex");
-  return {
-    id: "codex",
-    name: "Codex CLI",
-    installed: binPath !== null || existsSync2(configDir),
-    binPath,
-    configDir
-  };
-}
-function detectEngram() {
-  const fromEnv = process.env.ENGRAM_BIN;
-  if (fromEnv && existsSync2(fromEnv)) return fromEnv;
-  const onPath = lookPath("engram");
-  if (onPath) return onPath;
-  const candidates = [
-    path4.join(HOME, "go", "bin", "engram.exe"),
-    path4.join(HOME, "go", "bin", "engram"),
-    path4.join(HOME, ".local", "bin", "engram.exe"),
-    path4.join(HOME, ".local", "bin", "engram")
-  ];
-  for (const c of candidates) if (existsSync2(c)) return c;
-  return null;
+function pruneBackups(root) {
+  const all = listBackups(root);
+  for (const old of all.slice(KEEP_BACKUPS)) {
+    fs2.rmSync(path2.join(root, old.id), { recursive: true, force: true });
+  }
 }
 
 // src/lib/filemerge.ts
@@ -331,7 +212,7 @@ ${close}`;
   if (start !== -1 && end !== -1 && end > start) {
     return existing.slice(0, start) + block + existing.slice(end + close.length);
   }
-  const sep = existing.endsWith("\n") ? "\n" : "\n\n";
+  const sep = existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
   return existing + sep + block + "\n";
 }
 function removeMarkdownSection(existing, name) {
@@ -513,18 +394,313 @@ function removeTomlSection(existing, section) {
   if (result.trim() === "") return "";
   return result.endsWith(eol) ? result : result + eol;
 }
-function readTomlSection(existing, section) {
-  if (existing === null) return null;
-  const lines = existing.split(/\r?\n/);
-  const found = findTomlSection(lines, section);
-  if (found === null) return null;
-  return lines.slice(found.start + 1, found.end).join("\n");
+function readTomlSection(existing, section) {
+  if (existing === null) return null;
+  const lines = existing.split(/\r?\n/);
+  const found = findTomlSection(lines, section);
+  if (found === null) return null;
+  return lines.slice(found.start + 1, found.end).join("\n");
+}
+
+// src/lib/writing-style.ts
+var DEFAULT_SECTION = "writing-style-default";
+var DEFAULT_OPEN = `<!-- jorgex:${DEFAULT_SECTION} -->`;
+var DEFAULT_CLOSE = `<!-- /jorgex:${DEFAULT_SECTION} -->`;
+function assertContained(file, rootDir) {
+  const relative = path3.relative(fs3.realpathSync(rootDir), fs3.realpathSync(file));
+  if (relative === ".." || relative.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative)) {
+    throw new Error(`La ruta de estilo ${file} sale del destino aislado.`);
+  }
+}
+function validateBackupRoot(rootDir) {
+  if (rootDir === void 0) return;
+  const backupRoot = path3.join(rootDir, "backups");
+  try {
+    fs3.lstatSync(backupRoot);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  assertContained(backupRoot, rootDir);
+  if (!fs3.statSync(backupRoot).isDirectory()) throw new Error(`El destino de backups ${backupRoot} no es un directorio.`);
+}
+function resolveWritingStyleFile(options = {}) {
+  return path3.join(options.targetDir ?? options.stateDir ?? dataDir(), "writing-style.md");
+}
+function readStyleText(sourcePath, options = {}) {
+  let stat;
+  try {
+    stat = fs3.lstatSync(sourcePath);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw new Error(`No se puede leer el estilo ${sourcePath}. Revisa los permisos del archivo.`, { cause: error });
+  }
+  if (options.rootDir !== void 0) {
+    assertContained(sourcePath, options.rootDir);
+  }
+  if (!(stat.isSymbolicLink() ? fs3.statSync(sourcePath) : stat).isFile()) {
+    throw new Error(`La fuente de estilo ${sourcePath} debe ser un archivo.`);
+  }
+  let bytes;
+  try {
+    bytes = fs3.readFileSync(sourcePath);
+  } catch (error) {
+    throw new Error(`No se puede leer el estilo ${sourcePath}. Revisa los permisos del archivo.`, { cause: error });
+  }
+  let content;
+  try {
+    content = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+  } catch {
+    throw new Error(`La fuente de estilo ${sourcePath} debe usar UTF-8 v\xE1lido.`);
+  }
+  return content;
+}
+function readWritingStyle(sourcePath, options = {}) {
+  const content = readStyleText(sourcePath, options)?.replace(/\r\n?/g, "\n").trim() ?? "";
+  if (content.includes("jorgex:")) throw new Error(`La fuente de estilo ${sourcePath} contiene marcadores jorgex: reservados.`);
+  return { sourcePath, content: content || null };
+}
+function prepareWritingStyle(sourcePath, options = {}) {
+  const canonicalPath = path3.join(options.stackDir ?? stackRoot(), "system-prompt", "writing-style.md");
+  const canonical = readWritingStyle(canonicalPath).content;
+  if (canonical === null) throw new Error(`Falta el estilo can\xF3nico o est\xE1 vac\xEDo en ${canonicalPath}; repara la instalaci\xF3n de Stack.`);
+  const originalContent = readStyleText(sourcePath, options);
+  if (originalContent?.includes("jorgex:")) {
+    if (!hasHealthyManagedMarkdownMarkers(originalContent, DEFAULT_SECTION) || originalContent.replace(DEFAULT_OPEN, "").replace(DEFAULT_CLOSE, "").includes("jorgex:")) {
+      throw new Error(`Marcadores de estilo ambiguos o desconocidos en ${sourcePath}; revisa el bloque ${DEFAULT_SECTION}.`);
+    }
+  }
+  const installedContent = upsertMarkdownSection(originalContent, DEFAULT_SECTION, canonical);
+  if (originalContent !== null && originalContent !== installedContent) validateBackupRoot(options.rootDir);
+  const content = installedContent.replace(DEFAULT_OPEN, "").replace(DEFAULT_CLOSE, "").replace(/\r\n?/g, "\n").trim();
+  return {
+    sourcePath,
+    content,
+    canonicalPath,
+    originalContent,
+    installedContent,
+    rootDir: options.rootDir,
+    backupRoot: options.rootDir === void 0 ? void 0 : path3.join(options.rootDir, "backups")
+  };
+}
+function applyWritingStyle(plan, dryRun = false) {
+  if (dryRun) return;
+  const current = readStyleText(plan.sourcePath, { rootDir: plan.rootDir });
+  if (current === plan.installedContent) return;
+  if (current !== plan.originalContent) {
+    throw new Error(`El estilo ${plan.sourcePath} cambi\xF3 durante la preparaci\xF3n; vuelve a ejecutar el comando.`);
+  }
+  if (current !== null) {
+    validateBackupRoot(plan.rootDir);
+    createBackup([plan.sourcePath], "writing-style", plan.backupRoot);
+  }
+  const mode = current === null ? 384 : fs3.statSync(plan.sourcePath).mode & 511;
+  writeText(plan.sourcePath, plan.installedContent, mode);
+}
+
+// src/adapters/opencode.ts
+import path8 from "path";
+import fs5 from "fs";
+import { isDeepStrictEqual } from "util";
+import { pathToFileURL } from "url";
+
+// src/lib/canonical.ts
+import path4 from "path";
+import fs4 from "fs";
+function parseCanonicalAgent(source, file) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(source);
+  if (!match) throw new Error(`Agente sin frontmatter: ${file}`);
+  const fields = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const sep = line.indexOf(":");
+    if (sep === -1) continue;
+    fields[line.slice(0, sep).trim()] = line.slice(sep + 1).trim();
+  }
+  const required = ["name", "description", "mode", "tier"];
+  for (const key of required) {
+    if (!fields[key]) throw new Error(`Agente ${file}: falta '${key}' en el frontmatter`);
+  }
+  return {
+    name: fields.name,
+    description: fields.description,
+    mode: fields.mode === "primary" ? "primary" : "subagent",
+    tier: fields.tier,
+    readonly: fields.readonly === "true",
+    bash: fields.bash ?? "full",
+    spawn: fields.spawn !== "false",
+    body: source.slice(match[0].length)
+  };
+}
+function loadCanonicalAgents(agentsDir) {
+  return fs4.readdirSync(agentsDir).filter((f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md").map((f) => {
+    const file = path4.join(agentsDir, f);
+    const source = fs4.readFileSync(file, "utf8").replace(/\r\n/g, "\n");
+    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(fs4.readFileSync(path4.join(stackDir, "mcp", "servers.json"), "utf8"));
+}
+function loadCanonicalHooks(stackDir) {
+  return JSON.parse(fs4.readFileSync(path4.join(stackDir, "hooks", "hooks.json"), "utf8"));
+}
+function loadCanonicalDefaults(stackDir) {
+  const file = path4.join(stackDir, "config", "defaults.json");
+  if (!fs4.existsSync(file)) return {};
+  const parsed = JSON.parse(fs4.readFileSync(file, "utf8"));
+  delete parsed["$comment"];
+  return parsed;
+}
+
+// src/lib/model-map.ts
+import path5 from "path";
+import { existsSync } from "fs";
+function resolveAgentModel(models, agentName, tier) {
+  const base = models[tier];
+  const override = models.overrides?.[agentName];
+  if (!override) return base;
+  return {
+    model: override.model || base.model,
+    variant: "variant" in override ? override.variant || void 0 : base.variant
+  };
+}
+var DEFAULT_MODEL_MAP = {
+  "claude-code": {
+    strong: { model: "fable" },
+    standard: { model: "sonnet" },
+    cheap: { model: "haiku" }
+  },
+  // El primary (orchestrator) no usa estos tiers: tanto el profile de CLI como
+  // la skill de la app heredan el modelo elegido por el usuario. Estos defaults
+  // son solo para subagentes; variant → model_reasoning_effort.
+  codex: {
+    strong: { model: "gpt-6-astra", variant: "low" },
+    standard: { model: "gpt-5.6-luna", variant: "max" },
+    cheap: { model: "gpt-5.6-luna", variant: "medium" }
+  }
+};
+function modelMapFile() {
+  return path5.join(dataDir(), "model-map.json");
+}
+function loadModelMap() {
+  const file = modelMapFile();
+  const raw = readTextIfExists(file);
+  if (raw === null) return DEFAULT_MODEL_MAP;
+  let fromDisk;
+  try {
+    fromDisk = JSON.parse(raw);
+  } catch {
+    throw new Error(`El mapa de modelos ${file} contiene JSON inv\xE1lido. Corrige el JSON o restaura una copia antes de continuar.`);
+  }
+  const merged = { ...fromDisk };
+  for (const id of Object.keys(DEFAULT_MODEL_MAP)) {
+    merged[id] = { ...DEFAULT_MODEL_MAP[id], ...fromDisk[id] ?? {} };
+    if (fromDisk[id] && !Object.hasOwn(fromDisk[id], "overrides")) delete merged[id].overrides;
+  }
+  return merged;
+}
+function ensureModelMapFile() {
+  const file = modelMapFile();
+  if (!existsSync(file)) {
+    writeText(file, JSON.stringify(DEFAULT_MODEL_MAP, null, 2) + "\n");
+  }
+  return file;
+}
+
+// src/lib/detect.ts
+import path6 from "path";
+import { existsSync as existsSync2, statSync } from "fs";
+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(path6.delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      const candidate = path6.join(dir, cmd + ext);
+      if (statSync(candidate, { throwIfNoEntry: false })?.isFile()) return candidate;
+    }
+  }
+  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, envOverrides) {
+  try {
+    const command = planDetectedBinCommand(bin, args);
+    if (command === null) return null;
+    return execFileSync(command.command, command.args, {
+      encoding: "utf8",
+      timeout: timeoutMs,
+      stdio: ["ignore", "pipe", "pipe"],
+      ...envOverrides === void 0 ? {} : { env: { ...process.env, ...envOverrides } }
+    });
+  } catch {
+    return null;
+  }
+}
+function detectOpenCode() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR ?? path6.join(HOME, ".config", "opencode");
+  const binPath = lookPath("opencode");
+  return {
+    id: "opencode",
+    name: "OpenCode",
+    installed: binPath !== null || existsSync2(configDir),
+    binPath,
+    configDir
+  };
+}
+function detectClaudeCode() {
+  const configDir = path6.join(HOME, ".claude");
+  const binPath = lookPath("claude");
+  return {
+    id: "claude-code",
+    name: "Claude Code",
+    installed: binPath !== null || existsSync2(configDir),
+    binPath,
+    configDir
+  };
+}
+function detectCodex() {
+  const configDir = process.env.CODEX_HOME ?? path6.join(HOME, ".codex");
+  const binPath = lookPath("codex");
+  return {
+    id: "codex",
+    name: "Codex CLI",
+    installed: binPath !== null || existsSync2(configDir),
+    binPath,
+    configDir
+  };
+}
+function detectEngram() {
+  const fromEnv = process.env.ENGRAM_BIN;
+  if (fromEnv && existsSync2(fromEnv)) return fromEnv;
+  const onPath = lookPath("engram");
+  if (onPath) return onPath;
+  const candidates = [
+    path6.join(HOME, "go", "bin", "engram.exe"),
+    path6.join(HOME, "go", "bin", "engram"),
+    path6.join(HOME, ".local", "bin", "engram.exe"),
+    path6.join(HOME, ".local", "bin", "engram")
+  ];
+  for (const c of candidates) if (existsSync2(c)) return c;
+  return null;
 }
 
 // src/lib/hooks-format.ts
-import path5 from "path";
+import path7 from "path";
 function hookScriptNames(canonical) {
-  return Object.values(canonical.hooks).flat().flatMap((entry) => entry.hooks).map((h) => /\{\{SCRIPTS_DIR\}\}[/\\]([\w./-]+)/.exec(h.command)?.[1]).filter((s) => s !== void 0).map((s) => path5.basename(s));
+  return Object.values(canonical.hooks).flat().flatMap((entry) => entry.hooks).map((h) => /\{\{SCRIPTS_DIR\}\}[/\\]([\w./-]+)/.exec(h.command)?.[1]).filter((s) => s !== void 0).map((s) => path7.basename(s));
 }
 function plainHookCommands(canonical) {
   return new Set(
@@ -571,7 +747,7 @@ function upsertNativeHooks(existing, canonical, scriptsDir, mapMatcher = (m) =>
             ...h.timeout !== void 0 ? { timeout: h.timeout } : {}
           }))
         };
-        const scriptNames = entry.hooks.map((h) => /\{\{SCRIPTS_DIR\}\}[/\\]([\w./-]+)/.exec(h.command)?.[1]).filter((s) => s !== void 0).map((s) => path5.basename(s));
+        const scriptNames = entry.hooks.map((h) => /\{\{SCRIPTS_DIR\}\}[/\\]([\w./-]+)/.exec(h.command)?.[1]).filter((s) => s !== void 0).map((s) => path7.basename(s));
         const plainCommands = entry.hooks.map((h) => h.command).filter((c) => !c.includes("{{SCRIPTS_DIR}}"));
         const index = list.findIndex((existingEntry) => {
           const e = existingEntry;
@@ -715,7 +891,7 @@ function pruneEmpty(parent, key) {
   if (value !== null && Object.keys(value).length === 0) delete parent[key];
 }
 function hasOpenCodeManualApproval(configDir) {
-  const content = readTextIfExists(path6.join(configDir, "opencode.json"));
+  const content = readTextIfExists(path8.join(configDir, "opencode.json"));
   if (content === null) return false;
   try {
     const root = JSON.parse(content);
@@ -731,7 +907,7 @@ var opencodeAdapter = {
   name: "OpenCode",
   detect: detectOpenCode,
   reportCapabilities(configDir) {
-    const prompt = readTextIfExists(path6.join(configDir, "AGENTS.md"));
+    const prompt = readTextIfExists(path8.join(configDir, "AGENTS.md"));
     return createLocalCapabilityReport("opencode", [
       ...hasManagedMarkdownSection(prompt, "system-prompt") ? [{
         id: "policy-guidance",
@@ -753,16 +929,16 @@ var opencodeAdapter = {
   paths(configDir) {
     const isRealConfigDir = samePath(
       configDir,
-      process.env.OPENCODE_CONFIG_DIR ?? path6.join(HOME, ".config", "opencode")
+      process.env.OPENCODE_CONFIG_DIR ?? path8.join(HOME, ".config", "opencode")
     );
-    const agentsHome = isRealConfigDir ? HOME : path6.dirname(configDir);
+    const agentsHome = isRealConfigDir ? HOME : path8.dirname(configDir);
     return {
-      systemPromptFile: path6.join(configDir, "AGENTS.md"),
-      agentsDir: path6.join(configDir, "agents"),
-      skillsDir: path6.join(agentsHome, ".agents", "skills"),
-      commandsDir: path6.join(configDir, "commands"),
-      pluginsDir: path6.join(configDir, "plugins"),
-      scriptsDir: path6.join(configDir, "scripts"),
+      systemPromptFile: path8.join(configDir, "AGENTS.md"),
+      agentsDir: path8.join(configDir, "agents"),
+      skillsDir: path8.join(agentsHome, ".agents", "skills"),
+      commandsDir: path8.join(configDir, "commands"),
+      pluginsDir: path8.join(configDir, "plugins"),
+      scriptsDir: path8.join(configDir, "scripts"),
       outputStylesDir: null,
       profilesDir: null
     };
@@ -820,12 +996,12 @@ ${agent.body}`,
             ctx.warnings.push(`opencode: hook sin {{SCRIPTS_DIR}} no traducible: ${hook.command}`);
             continue;
           }
-          const script = `scripts/${path6.basename(match[1])}`;
+          const script = `scripts/${path8.basename(match[1])}`;
           (bashEntries[includes] ??= []).push(script);
         }
       }
     }
-    const hooksFile = path6.join(ctx.configDir, "hooks.json");
+    const hooksFile = path8.join(ctx.configDir, "hooks.json");
     const content = upsertJson(readTextIfExists(hooksFile), (root) => {
       const afterValue = root["tool.execute.after"] ??= {};
       if (afterValue === null || typeof afterValue !== "object" || Array.isArray(afterValue)) {
@@ -860,16 +1036,16 @@ ${agent.body}`,
       }
     });
     actions.push({ kind: "write", target: hooksFile, content });
-    const scriptsSource = path6.join(ctx.stackDir, "scripts");
-    if (fs3.existsSync(scriptsSource)) {
-      for (const f of fs3.readdirSync(scriptsSource)) {
-        actions.push({ kind: "copy", source: path6.join(scriptsSource, f), target: path6.join(scriptsDir, f) });
+    const scriptsSource = path8.join(ctx.stackDir, "scripts");
+    if (fs5.existsSync(scriptsSource)) {
+      for (const f of fs5.readdirSync(scriptsSource)) {
+        actions.push({ kind: "copy", source: path8.join(scriptsSource, f), target: path8.join(scriptsDir, f) });
       }
     }
     return actions;
   },
   planMainConfig(canonical, ctx) {
-    const file = path6.join(ctx.configDir, "opencode.json");
+    const file = path8.join(ctx.configDir, "opencode.json");
     const { pluginsDir } = this.paths(ctx.configDir);
     const original = readTextIfExists(file);
     const contentSource = original === null || original.trim() === "" ? null : original;
@@ -979,9 +1155,10 @@ ${agent.body}`,
       let content = removeMarkdownSection(prompt, "system-prompt");
       content = removeMarkdownSection(content, "engram-protocol");
       content = removeMarkdownSection(content, "browser");
+      content = removeMarkdownSection(content, "writing-style");
       actions.push({ kind: "write", target: systemPromptFile, content });
     }
-    const configFile = path6.join(ctx.configDir, "opencode.json");
+    const configFile = path8.join(ctx.configDir, "opencode.json");
     const config = readTextIfExists(configFile);
     if (config !== null) {
       const mcpOwnership = [];
@@ -1049,7 +1226,7 @@ ${agent.body}`,
         ...primaryModelOwnership.length > 0 ? { primaryModelOwnership } : {}
       });
     }
-    const hooksFile = path6.join(ctx.configDir, "hooks.json");
+    const hooksFile = path8.join(ctx.configDir, "hooks.json");
     const hooksJson = readTextIfExists(hooksFile);
     if (hooksJson !== null) {
       const ourScripts = hookScriptNames(hooks);
@@ -1075,8 +1252,8 @@ ${agent.body}`,
 };
 
 // src/adapters/claude-code.ts
-import path7 from "path";
-import fs4 from "fs";
+import path9 from "path";
+import fs6 from "fs";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 function yamlString2(value) {
   return JSON.stringify(value);
@@ -1092,7 +1269,7 @@ function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function hasClaudeManualApproval(configDir) {
-  const content = readTextIfExists(path7.join(configDir, "settings.json"));
+  const content = readTextIfExists(path9.join(configDir, "settings.json"));
   if (content === null) return false;
   try {
     const root = JSON.parse(content);
@@ -1112,8 +1289,8 @@ function toolsFor(agent) {
   return tools.join(", ");
 }
 function hasEngramPlugin(configDir) {
-  if (fs4.existsSync(path7.join(configDir, "plugins", "marketplaces", "engram"))) return true;
-  const registry = readTextIfExists(path7.join(configDir, "plugins", "installed_plugins.json"));
+  if (fs6.existsSync(path9.join(configDir, "plugins", "marketplaces", "engram"))) return true;
+  const registry = readTextIfExists(path9.join(configDir, "plugins", "installed_plugins.json"));
   if (registry === null) return false;
   try {
     const parsed = JSON.parse(registry);
@@ -1136,7 +1313,7 @@ var claudeCodeAdapter = {
   name: "Claude Code",
   detect: detectClaudeCode,
   reportCapabilities(configDir) {
-    const prompt = readTextIfExists(path7.join(configDir, "CLAUDE.md"));
+    const prompt = readTextIfExists(path9.join(configDir, "CLAUDE.md"));
     return createLocalCapabilityReport("claude-code", [
       ...hasManagedMarkdownSection(prompt, "system-prompt") ? [{
         id: "policy-guidance",
@@ -1157,13 +1334,13 @@ var claudeCodeAdapter = {
   },
   paths(configDir) {
     return {
-      systemPromptFile: path7.join(configDir, "CLAUDE.md"),
-      agentsDir: path7.join(configDir, "agents"),
-      skillsDir: path7.join(configDir, "skills"),
-      commandsDir: path7.join(configDir, "commands"),
+      systemPromptFile: path9.join(configDir, "CLAUDE.md"),
+      agentsDir: path9.join(configDir, "agents"),
+      skillsDir: path9.join(configDir, "skills"),
+      commandsDir: path9.join(configDir, "commands"),
       pluginsDir: null,
-      scriptsDir: path7.join(configDir, "scripts"),
-      outputStylesDir: path7.join(configDir, "output-styles"),
+      scriptsDir: path9.join(configDir, "scripts"),
+      outputStylesDir: path9.join(configDir, "output-styles"),
       profilesDir: null
     };
   },
@@ -1209,9 +1386,9 @@ ${agent.body}`,
   planHooks(canonical, ctx) {
     const actions = [];
     const { scriptsDir } = this.paths(ctx.configDir);
-    const original = readTextIfExists(path7.join(ctx.configDir, "settings.json"));
+    const original = readTextIfExists(path9.join(ctx.configDir, "settings.json"));
     const contentSource = original === null || original.trim() === "" ? null : original;
-    const settingsFile = path7.join(ctx.configDir, "settings.json");
+    const settingsFile = path9.join(ctx.configDir, "settings.json");
     let content = upsertNativeHooks(contentSource, canonical, scriptsDir);
     const defaults = loadCanonicalDefaults(ctx.stackDir)["claude-code"];
     if (contentSource === null && defaults?.["permissions"] !== void 0) {
@@ -1225,16 +1402,16 @@ ${agent.body}`,
       });
     }
     actions.push({ kind: "write", target: settingsFile, content });
-    const scriptsSource = path7.join(ctx.stackDir, "scripts");
-    if (fs4.existsSync(scriptsSource)) {
-      for (const f of fs4.readdirSync(scriptsSource)) {
-        actions.push({ kind: "copy", source: path7.join(scriptsSource, f), target: path7.join(scriptsDir, f) });
+    const scriptsSource = path9.join(ctx.stackDir, "scripts");
+    if (fs6.existsSync(scriptsSource)) {
+      for (const f of fs6.readdirSync(scriptsSource)) {
+        actions.push({ kind: "copy", source: path9.join(scriptsSource, f), target: path9.join(scriptsDir, f) });
       }
     }
     return actions;
   },
   planMainConfig(canonical, ctx) {
-    const file = path7.join(path7.dirname(ctx.configDir), `${path7.basename(ctx.configDir)}.json`);
+    const file = path9.join(path9.dirname(ctx.configDir), `${path9.basename(ctx.configDir)}.json`);
     const mcpOwnership = [];
     const content = upsertJson(readTextIfExists(file), (root) => {
       const servers = root["mcpServers"] ??= {};
@@ -1297,9 +1474,10 @@ ${agent.body}`,
       let content = removeMarkdownSection(prompt, "system-prompt");
       content = removeMarkdownSection(content, "engram-protocol");
       content = removeMarkdownSection(content, "browser");
+      content = removeMarkdownSection(content, "writing-style");
       actions.push({ kind: "write", target: systemPromptFile, content });
     }
-    const settingsFile = path7.join(ctx.configDir, "settings.json");
+    const settingsFile = path9.join(ctx.configDir, "settings.json");
     const settings = readTextIfExists(settingsFile);
     if (settings !== null) {
       const content = removeNativeHooks(settings, hooks);
@@ -1307,7 +1485,7 @@ ${agent.body}`,
         actions.push({ kind: "write", target: settingsFile, content: content.trim() === "{}" ? "" : content });
       }
     }
-    const mainFile = path7.join(path7.dirname(ctx.configDir), `${path7.basename(ctx.configDir)}.json`);
+    const mainFile = path9.join(path9.dirname(ctx.configDir), `${path9.basename(ctx.configDir)}.json`);
     const main2 = readTextIfExists(mainFile);
     if (main2 !== null) {
       const mcpOwnership = [];
@@ -1333,8 +1511,8 @@ ${agent.body}`,
 };
 
 // src/adapters/codex.ts
-import path8 from "path";
-import fs5 from "fs";
+import path10 from "path";
+import fs7 from "fs";
 function tomlString(value) {
   return JSON.stringify(value);
 }
@@ -1357,15 +1535,15 @@ function isManagedOptionalStdioServer3(server, section) {
   return server.optional === true && server.transport === "stdio" && section?.trim() === stdioMcpSection(server);
 }
 function hasActiveEngramPlugin(configDir) {
-  const config = readTextIfExists(path8.join(configDir, "config.toml"));
+  const config = readTextIfExists(path10.join(configDir, "config.toml"));
   if (config === null) return false;
   const match = /\[plugins\."engram@[^"]*"\]([^[]*)/.exec(config);
   return match !== null && !/enabled\s*=\s*false/.test(match[1]);
 }
 function hasEngramProtocol(configDir) {
   if (hasActiveEngramPlugin(configDir)) return true;
-  if (fs5.existsSync(path8.join(configDir, "engram-instructions.md"))) return true;
-  const config = readTextIfExists(path8.join(configDir, "config.toml"));
+  if (fs7.existsSync(path10.join(configDir, "engram-instructions.md"))) return true;
+  const config = readTextIfExists(path10.join(configDir, "config.toml"));
   return config !== null && /engram-instructions\.md/.test(config);
 }
 var CODEX_JSON_STRING = String.raw`"(?:\\.|[^"\\\r\n])*"`;
@@ -1490,7 +1668,7 @@ function hasCanonicalCodexPermissionProfile(scan) {
   return true;
 }
 function hasCodexManualApproval(configDir) {
-  const config = readTextIfExists(path8.join(configDir, "config.toml"));
+  const config = readTextIfExists(path10.join(configDir, "config.toml"));
   if (config === null) return false;
   const scan = scanCodexToml(config);
   if (scan === null) return false;
@@ -1508,7 +1686,7 @@ var codexAdapter = {
   name: "Codex CLI",
   detect: detectCodex,
   reportCapabilities(configDir) {
-    const prompt = readTextIfExists(path8.join(configDir, "AGENTS.md"));
+    const prompt = readTextIfExists(path10.join(configDir, "AGENTS.md"));
     return createLocalCapabilityReport("codex", [
       ...hasManagedMarkdownSection(prompt, "system-prompt") ? [{
         id: "policy-guidance",
@@ -1533,18 +1711,18 @@ var codexAdapter = {
     return !hasEngramProtocol(ctx.configDir);
   },
   paths(configDir) {
-    const isRealConfigDir = samePath(configDir, process.env.CODEX_HOME ?? path8.join(HOME, ".codex"));
-    const agentsHome = isRealConfigDir ? HOME : path8.dirname(configDir);
-    const skillsDir = path8.join(agentsHome, ".agents", "skills");
+    const isRealConfigDir = samePath(configDir, process.env.CODEX_HOME ?? path10.join(HOME, ".codex"));
+    const agentsHome = isRealConfigDir ? HOME : path10.dirname(configDir);
+    const skillsDir = path10.join(agentsHome, ".agents", "skills");
     return {
-      systemPromptFile: path8.join(configDir, "AGENTS.md"),
-      agentsDir: path8.join(configDir, "agents"),
+      systemPromptFile: path10.join(configDir, "AGENTS.md"),
+      agentsDir: path10.join(configDir, "agents"),
       skillsDir,
       // Los custom prompts de Codex están deprecados: los commands se
       // instalan como skills (renderCommand produce <nombre>/SKILL.md).
       commandsDir: skillsDir,
       pluginsDir: null,
-      scriptsDir: path8.join(configDir, "scripts"),
+      scriptsDir: path10.join(configDir, "scripts"),
       outputStylesDir: null,
       profilesDir: configDir
     };
@@ -1592,7 +1770,7 @@ ${body}`
   planHooks(canonical, ctx) {
     const actions = [];
     const { scriptsDir } = this.paths(ctx.configDir);
-    const hooksFile = path8.join(ctx.configDir, "hooks.json");
+    const hooksFile = path10.join(ctx.configDir, "hooks.json");
     const content = upsertNativeHooks(
       readTextIfExists(hooksFile),
       canonical,
@@ -1603,16 +1781,16 @@ ${body}`
     ctx.warnings.push(
       "Codex: los hooks no-managed requieren aprobaci\xF3n manual \u2014 ejecuta /hooks dentro de codex para activarlos."
     );
-    const scriptsSource = path8.join(ctx.stackDir, "scripts");
-    if (fs5.existsSync(scriptsSource)) {
-      for (const f of fs5.readdirSync(scriptsSource)) {
-        actions.push({ kind: "copy", source: path8.join(scriptsSource, f), target: path8.join(scriptsDir, f) });
+    const scriptsSource = path10.join(ctx.stackDir, "scripts");
+    if (fs7.existsSync(scriptsSource)) {
+      for (const f of fs7.readdirSync(scriptsSource)) {
+        actions.push({ kind: "copy", source: path10.join(scriptsSource, f), target: path10.join(scriptsDir, f) });
       }
     }
     return actions;
   },
   planMainConfig(canonical, ctx) {
-    const file = path8.join(ctx.configDir, "config.toml");
+    const file = path10.join(ctx.configDir, "config.toml");
     const original = readTextIfExists(file);
     const contentSource = original === null || original.trim() === "" ? null : original;
     let content = contentSource;
@@ -1729,9 +1907,10 @@ args = [${(server.args ?? []).map(tomlString).join(", ")}]`);
       let content = removeMarkdownSection(prompt, "system-prompt");
       content = removeMarkdownSection(content, "engram-protocol");
       content = removeMarkdownSection(content, "browser");
+      content = removeMarkdownSection(content, "writing-style");
       actions.push({ kind: "write", target: systemPromptFile, content });
     }
-    const configFile = path8.join(ctx.configDir, "config.toml");
+    const configFile = path10.join(ctx.configDir, "config.toml");
     const config = readTextIfExists(configFile);
     if (config !== null) {
       let content = config;
@@ -1766,7 +1945,7 @@ args = [${(server.args ?? []).map(tomlString).join(", ")}]`);
         ...primaryModelOwnership.length > 0 ? { primaryModelOwnership } : {}
       });
     }
-    const hooksFile = path8.join(ctx.configDir, "hooks.json");
+    const hooksFile = path10.join(ctx.configDir, "hooks.json");
     const hooksJson = readTextIfExists(hooksFile);
     if (hooksJson !== null) {
       const content = removeNativeHooks(hooksJson, hooks);
@@ -1779,8 +1958,8 @@ args = [${(server.args ?? []).map(tomlString).join(", ")}]`);
 };
 
 // src/lib/install-mode.ts
-import fs6 from "fs";
-import path9 from "path";
+import fs8 from "fs";
+import path11 from "path";
 var INSTALL_MODES = /* @__PURE__ */ new Set(["human", "programmatic"]);
 var SUBAGENT_CONCURRENCIES = /* @__PURE__ */ new Set(["serial", "parallel"]);
 var DEFAULT_INSTALL_MODE_PREFERENCE = {
@@ -1788,10 +1967,10 @@ var DEFAULT_INSTALL_MODE_PREFERENCE = {
   subagentConcurrency: "serial"
 };
 function installModePreferenceFile() {
-  return path9.join(dataDir(), "install-mode.json");
+  return path11.join(dataDir(), "install-mode.json");
 }
 function hasInstallModePreference(file = installModePreferenceFile()) {
-  return fs6.existsSync(file);
+  return fs8.existsSync(file);
 }
 function isInstallMode(value) {
   return INSTALL_MODES.has(value);
@@ -1822,9 +2001,9 @@ function normalizeInstallModePreference(value) {
   throw new Error("Preferencia de instalaci\xF3n inv\xE1lida o corrupta.");
 }
 function loadInstallModePreference(file = installModePreferenceFile()) {
-  if (!fs6.existsSync(file)) return DEFAULT_INSTALL_MODE_PREFERENCE;
+  if (!fs8.existsSync(file)) return DEFAULT_INSTALL_MODE_PREFERENCE;
   try {
-    const raw = fs6.readFileSync(file, "utf8");
+    const raw = fs8.readFileSync(file, "utf8");
     return normalizeInstallModePreference(JSON.parse(raw));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -1861,87 +2040,11 @@ function parseInstallModePreferenceFlags(mode, subagentConcurrency) {
   return {};
 }
 
-// src/lib/backup.ts
-import fs7 from "fs";
-import path10 from "path";
-import crypto from "crypto";
-var KEEP_BACKUPS = 10;
-function backupsRoot() {
-  return path10.join(dataDir(), "backups");
-}
-function compositeChecksum(files) {
-  const hash = crypto.createHash("sha256");
-  for (const file of [...files].sort()) {
-    const content = crypto.createHash("sha256").update(fs7.readFileSync(file)).digest("hex");
-    hash.update(`${file}:${content}
-`);
-  }
-  return hash.digest("hex");
-}
-function createBackup(files, label, root = backupsRoot()) {
-  const existing = [...new Set(files)].filter((f) => fs7.existsSync(f));
-  if (existing.length === 0) return null;
-  const checksum = compositeChecksum(existing);
-  const latest = listBackups(root)[0];
-  if (latest?.checksum === checksum) return latest;
-  const base = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${label}`;
-  let id = base;
-  let dir = path10.join(root, id);
-  for (let n = 1; fs7.existsSync(dir); n++) {
-    id = `${base}-${n}`;
-    dir = path10.join(root, id);
-  }
-  ensureDir(path10.join(dir, "files"));
-  const entries = existing.map((original, i) => {
-    const stored = path10.join(dir, "files", `${String(i).padStart(4, "0")}-${path10.basename(original)}`);
-    fs7.copyFileSync(original, stored);
-    return { original, stored };
-  });
-  const info = { id, label, createdAt: (/* @__PURE__ */ new Date()).toISOString(), files: entries, checksum };
-  writeText(path10.join(dir, "manifest.json"), JSON.stringify(info, null, 2) + "\n");
-  pruneBackups(root);
-  return info;
-}
-function listBackups(root = backupsRoot()) {
-  if (!fs7.existsSync(root)) return [];
-  const infos = [];
-  for (const entry of fs7.readdirSync(root, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const manifest = readTextIfExists(path10.join(root, entry.name, "manifest.json"));
-    if (manifest === null) continue;
-    try {
-      infos.push(JSON.parse(manifest));
-    } catch {
-      infos.push({ id: entry.name, label: "(manifest corrupto)", createdAt: "", files: [] });
-    }
-  }
-  return infos.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-}
-function restoreBackup(id, root = backupsRoot(), boundary = HOME) {
-  const info = listBackups(root).find((b) => b.id === id);
-  if (!info) throw new Error(`Backup no encontrado: ${id}`);
-  let restored = 0;
-  for (const { original, stored } of info.files) {
-    if (!fs7.existsSync(stored)) continue;
-    if (!isContainedIn(original, boundary)) continue;
-    ensureDir(path10.dirname(original));
-    fs7.copyFileSync(stored, original);
-    restored++;
-  }
-  return restored;
-}
-function pruneBackups(root) {
-  const all = listBackups(root);
-  for (const old of all.slice(KEEP_BACKUPS)) {
-    fs7.rmSync(path10.join(root, old.id), { recursive: true, force: true });
-  }
-}
-
 // src/lib/manifest.ts
-import fs8 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path12 from "path";
 function manifestFile() {
-  return path11.join(dataDir(), "manifest.json");
+  return path12.join(dataDir(), "manifest.json");
 }
 function readManifest(file = manifestFile()) {
   const raw = readTextIfExists(file);
@@ -1965,24 +2068,24 @@ function removeRuntimeManifest(id, file = manifestFile()) {
   writeText(file, JSON.stringify(manifest, null, 2) + "\n");
 }
 function findOrphans(prevOwned, currentTargets, root = HOME) {
-  return prevOwned.map((f) => path11.resolve(f)).filter(
-    (f) => !currentTargets.has(f) && path11.basename(f) !== "engram.ts" && isContainedIn(f, root) && fs8.existsSync(f)
+  return prevOwned.map((f) => path12.resolve(f)).filter(
+    (f) => !currentTargets.has(f) && path12.basename(f) !== "engram.ts" && isContainedIn(f, root) && fs9.existsSync(f)
   );
 }
 
 // src/components/system-prompt.ts
-import path13 from "path";
-import fs10 from "fs";
+import path14 from "path";
+import fs11 from "fs";
 
 // src/lib/mode-composition.ts
-import fs9 from "fs";
-import path12 from "path";
+import fs10 from "fs";
+import path13 from "path";
 var PROGRAMMATIC_ROOT = ["modes", "programmatic"];
 var PROGRAMMATIC_MARKER = "<!-- jorgex:programmatic-mode -->";
 var LEGACY_RESULT_CONTRACT_SECTION = /\n?##\s+Result contract[\s\S]*$/;
 var normalize = (value) => value.replace(/\r\n/g, "\n");
 function loadProgrammaticAddendum(stackDir, fileName) {
-  return normalize(fs9.readFileSync(path12.join(stackDir, ...PROGRAMMATIC_ROOT, fileName), "utf8")).trim();
+  return normalize(fs10.readFileSync(path13.join(stackDir, ...PROGRAMMATIC_ROOT, fileName), "utf8")).trim();
 }
 function appendAddendum(base, addendum) {
   const normalizedBase = normalize(base);
@@ -2025,15 +2128,15 @@ function composeProgrammaticAgentBody(stackDir, agent, mode, concurrency) {
 var normalize2 = (s) => s.replace(/\r\n/g, "\n");
 function planSystemPrompt(adapter, ctx) {
   const target = adapter.paths(ctx.configDir).systemPromptFile;
-  const agentsMd = normalize2(fs10.readFileSync(path13.join(ctx.stackDir, "system-prompt", "AGENTS.md"), "utf8"));
+  const agentsMd = normalize2(fs11.readFileSync(path14.join(ctx.stackDir, "system-prompt", "AGENTS.md"), "utf8"));
   const protocol = stripLeadingHtmlComments(
-    normalize2(fs10.readFileSync(path13.join(ctx.stackDir, "system-prompt", "engram-protocol.md"), "utf8"))
+    normalize2(fs11.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(path13.join(ctx.stackDir, "system-prompt", file), "utf8"))).join("\n\n");
+  ].filter((file) => file !== null).map((file) => normalize2(fs11.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)) {
@@ -2042,11 +2145,13 @@ function planSystemPrompt(adapter, ctx) {
     content = removeMarkdownSection(content, "engram-protocol");
   }
   content = browser === "" ? removeMarkdownSection(content, "browser") : upsertMarkdownSection(content, "browser", browser);
+  const style = ctx.mode === "programmatic" ? null : ctx.writingStyle?.content;
+  content = style ? upsertMarkdownSection(content, "writing-style", style) : removeMarkdownSection(content, "writing-style");
   return [{ kind: "write", target, content }];
 }
 
 // src/components/agents.ts
-import path14 from "path";
+import path15 from "path";
 function planAgents(adapter, ctx) {
   const { agentsDir, commandsDir, outputStylesDir, profilesDir, scriptsDir } = adapter.paths(ctx.configDir);
   const dirFor = {
@@ -2056,7 +2161,7 @@ function planAgents(adapter, ctx) {
     profile: profilesDir
   };
   const scriptsBase = scriptsDir.replace(/\\/g, "/");
-  return loadCanonicalAgents(path14.join(ctx.stackDir, "agents")).flatMap((agent) => {
+  return loadCanonicalAgents(path15.join(ctx.stackDir, "agents")).flatMap((agent) => {
     const composedAgent = {
       ...agent,
       body: composeProgrammaticAgentBody(ctx.stackDir, agent, ctx.mode, ctx.subagentConcurrency)
@@ -2068,42 +2173,42 @@ function planAgents(adapter, ctx) {
         return [];
       }
       const content = rendered.content.replace(/\{\{SCRIPTS_DIR\}\}/g, scriptsBase);
-      return [{ kind: "write", target: path14.join(dir, rendered.file), content }];
+      return [{ kind: "write", target: path15.join(dir, rendered.file), content }];
     });
   });
 }
 
 // src/components/skills.ts
-import path15 from "path";
+import path16 from "path";
 function planSkills(adapter, ctx) {
   const { skillsDir } = adapter.paths(ctx.configDir);
-  const source = path15.join(ctx.stackDir, "skills");
+  const source = path16.join(ctx.stackDir, "skills");
   return listFilesRecursive(source).map((file) => {
-    const relative = path15.relative(source, file);
-    return { kind: "copy", source: file, target: path15.join(skillsDir, relative) };
+    const relative = path16.relative(source, file);
+    return { kind: "copy", source: file, target: path16.join(skillsDir, relative) };
   });
 }
 
 // src/components/commands.ts
-import path16 from "path";
-import fs11 from "fs";
+import path17 from "path";
+import fs12 from "fs";
 function planCommands(adapter, ctx) {
   const { commandsDir } = adapter.paths(ctx.configDir);
-  const source = path16.join(ctx.stackDir, "commands");
-  if (!fs11.existsSync(source)) return [];
+  const source = path17.join(ctx.stackDir, "commands");
+  if (!fs12.existsSync(source)) return [];
   const commandFiles = [
     ...listMarkdownFiles(source),
-    ...listMarkdownFiles(path16.join(source, adapter.id))
+    ...listMarkdownFiles(path17.join(source, adapter.id))
   ];
   return commandFiles.map(({ file, fullPath }) => {
-    const raw = fs11.readFileSync(fullPath, "utf8").replace(/\r\n/g, "\n");
+    const raw = fs12.readFileSync(fullPath, "utf8").replace(/\r\n/g, "\n");
     const rendered = adapter.renderCommand(file, raw);
-    return { kind: "write", target: path16.join(commandsDir, rendered.file), content: rendered.content };
+    return { kind: "write", target: path17.join(commandsDir, rendered.file), content: rendered.content };
   });
 }
 function listMarkdownFiles(dir) {
-  if (!fs11.existsSync(dir)) return [];
-  return fs11.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => ({ file: entry.name, fullPath: path16.join(dir, entry.name) }));
+  if (!fs12.existsSync(dir)) return [];
+  return fs12.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => ({ file: entry.name, fullPath: path17.join(dir, entry.name) }));
 }
 
 // src/components/hooks.ts
@@ -2117,23 +2222,23 @@ function planMcp(adapter, ctx) {
 }
 
 // src/components/plugins.ts
-import path17 from "path";
-import fs12 from "fs";
+import path18 from "path";
+import fs13 from "fs";
 function planPlugins(adapter, ctx) {
   const { pluginsDir } = adapter.paths(ctx.configDir);
   if (pluginsDir === null) return [];
-  const source = path17.join(ctx.stackDir, "plugins", adapter.id);
-  if (!fs12.existsSync(source)) return [];
+  const source = path18.join(ctx.stackDir, "plugins", adapter.id);
+  if (!fs13.existsSync(source)) return [];
   return listFilesRecursive(source).filter((f) => f.endsWith(".ts")).map((sourceFile) => {
-    const target = path17.join(pluginsDir, path17.relative(source, sourceFile));
-    const raw = fs12.readFileSync(sourceFile, "utf8");
+    const target = path18.join(pluginsDir, path18.relative(source, sourceFile));
+    const raw = fs13.readFileSync(sourceFile, "utf8");
     let content = raw;
     if (content.includes('"{{ENGRAM_BIN}}"')) {
       content = content.replace(/"\{\{ENGRAM_BIN\}\}"/g, JSON.stringify(ctx.engramBin ?? "engram"));
     }
     if (content.includes('"{{ENGRAM_PROTOCOL}}"')) {
       const protocol = stripLeadingHtmlComments(
-        fs12.readFileSync(path17.join(ctx.stackDir, "system-prompt", "engram-protocol.md"), "utf8").replace(/\r\n/g, "\n")
+        fs13.readFileSync(path18.join(ctx.stackDir, "system-prompt", "engram-protocol.md"), "utf8").replace(/\r\n/g, "\n")
       );
       content = content.replace(/"\{\{ENGRAM_PROTOCOL\}\}"/g, JSON.stringify(protocol));
     }
@@ -2144,9 +2249,9 @@ function planPlugins(adapter, ctx) {
 }
 
 // src/lib/external-tools.ts
-import fs13 from "fs";
+import fs14 from "fs";
 import os from "os";
-import path18 from "path";
+import path19 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 var PLAYWRIGHT_CLI = {
   packageName: "@playwright/cli",
@@ -2191,9 +2296,9 @@ function detectPlaywrightCli() {
   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) => {
+    const known = [path19.join(pnpmHome, name), path19.join(pnpmHome, "bin", name)].find((file) => {
       try {
-        return fs13.statSync(file).isFile();
+        return fs14.statSync(file).isFile();
       } catch {
         return false;
       }
@@ -2212,7 +2317,7 @@ function resolvePnpmBin() {
   return pnpmCmd !== null && !pnpmCmd.toLowerCase().endsWith(".ps1") ? pnpmCmd : null;
 }
 function resolvePnpmHome(env = process.env, platform = process.platform, homeDir = os.homedir()) {
-  const paths = platform === "win32" ? path18.win32 : path18.posix;
+  const paths = platform === "win32" ? path19.win32 : path19.posix;
   if (env.PNPM_HOME) return env.PNPM_HOME;
   if (env.XDG_DATA_HOME) return paths.join(env.XDG_DATA_HOME, "pnpm");
   if (platform === "darwin") return paths.join(homeDir, "Library", "pnpm");
@@ -2221,7 +2326,7 @@ function resolvePnpmHome(env = process.env, platform = process.platform, homeDir
 }
 function setupPnpmGlobal(pnpmBin, env = process.env, platform = process.platform, homeDir = os.homedir()) {
   const pnpmHome = resolvePnpmHome(env, platform, homeDir);
-  const paths = platform === "win32" ? path18.win32 : path18.posix;
+  const paths = platform === "win32" ? path19.win32 : path19.posix;
   if (!paths.isAbsolute(pnpmHome)) return { ok: false, reason: "PNPM_HOME debe ser una ruta absoluta; corrige la configuraci\xF3n antes de reintentar." };
   const pathEntries = [pnpmHome, paths.join(pnpmHome, "bin")];
   if (env.PATH !== void 0) pathEntries.push(env.PATH);
@@ -2241,10 +2346,10 @@ function setupPnpmGlobal(pnpmBin, env = process.env, platform = process.platform
 }
 function isPlaywrightBrowserReady(env = process.env, platform = process.platform, homeDir = os.homedir()) {
   const configuredPath = env.PLAYWRIGHT_BROWSERS_PATH;
-  const cacheDir = configuredPath ?? (platform === "win32" ? path18.join(env.LOCALAPPDATA ?? path18.join(homeDir, "AppData", "Local"), "ms-playwright") : platform === "darwin" ? path18.join(homeDir, "Library", "Caches", "ms-playwright") : path18.join(env.XDG_CACHE_HOME ?? path18.join(homeDir, ".cache"), "ms-playwright"));
+  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(
+    const ready = fs14.readdirSync(cacheDir, { withFileTypes: true }).some(
       (entry) => entry.isDirectory() && /^chromium(?:_headless_shell)?-/.test(entry.name)
     );
     return ready ? { status: "ready", path: cacheDir } : { status: "missing", path: cacheDir };
@@ -2276,9 +2381,9 @@ function verifyPlaywrightBrowser(pnpmBin, env = process.env, cwd) {
       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 (!path19.isAbsolute(root)) return false;
+    const packageFile = fs14.realpathSync(path19.join(root, "@playwright", "cli", "package.json"));
+    const installed = JSON.parse(fs14.readFileSync(packageFile, "utf8"));
     if (installed.name !== PLAYWRIGHT_CLI.packageName || installed.version !== PLAYWRIGHT_CLI.version) return false;
     const probe = `
       const { createRequire } = require('node:module');
@@ -2321,7 +2426,7 @@ 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 cwd = action === "install-browser" ? fs14.mkdtempSync(path19.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, {
@@ -2336,27 +2441,27 @@ function executePlaywrightToolAction(action, pnpmBin = resolvePnpmBin(), env) {
   } catch {
     return { ok: false, reason: "action-failed" };
   } finally {
-    if (cwd !== void 0) fs13.rmSync(cwd, { recursive: true, force: true });
+    if (cwd !== void 0) fs14.rmSync(cwd, { recursive: true, force: true });
   }
 }
 
 // src/lib/tool-preferences.ts
-import fs14 from "fs";
-import path19 from "path";
+import fs15 from "fs";
+import path20 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 };
+    return { raw: fs15.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 path19.join(stateDir, "playwright-cli.json");
+  return path20.join(stateDir, "playwright-cli.json");
 }
 function parsePlaywrightCliPreference(raw) {
   try {
@@ -2402,10 +2507,10 @@ function savePlaywrightCliPreference(file, enabled, selection) {
   writeText(file, content);
 }
 function devtoolsMcpPreferenceFile(stateDir = dataDir()) {
-  return path19.join(stateDir, "devtools-mcp.json");
+  return path20.join(stateDir, "devtools-mcp.json");
 }
 function primaryModelOwnershipFile(stateDir = dataDir()) {
-  return path19.join(stateDir, "primary-model.json");
+  return path20.join(stateDir, "primary-model.json");
 }
 function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -2515,7 +2620,7 @@ function primaryModelOwnershipError(file = primaryModelOwnershipFile()) {
   return `Primary model: ownership inv\xE1lido en ${file}. Corrige o borra ese archivo antes de reintentar.`;
 }
 function primaryModelConfigKey(configDir) {
-  const resolved = path19.resolve(configDir);
+  const resolved = path20.resolve(configDir);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function loadPrimaryModelOwnership(file, runtime, configDir) {
@@ -2635,7 +2740,7 @@ function diffPlan(plan) {
       if (current === null) return { action, status: "create" };
       return { action, status: current === action.content ? "unchanged" : "update" };
     }
-    if (!fs15.existsSync(action.target)) return { action, status: "create" };
+    if (!fs16.existsSync(action.target)) return { action, status: "create" };
     return { action, status: sameFileContent(action.source, action.target) ? "unchanged" : "update" };
   });
 }
@@ -2661,7 +2766,7 @@ function collectAllCurrentTargets(mode = DEFAULT_INSTALL_MODE_PREFERENCE) {
       continue;
     }
     try {
-      for (const action of buildPlan(adapter, ctx)) targets.add(path20.resolve(action.target));
+      for (const action of buildPlan(adapter, ctx)) targets.add(path21.resolve(action.target));
     } catch (error) {
       complete = false;
       warnings.push(
@@ -2674,6 +2779,15 @@ function collectAllCurrentTargets(mode = DEFAULT_INSTALL_MODE_PREFERENCE) {
 async function runInstall(opts) {
   const showSummary = opts.showSummary !== false;
   if (showSummary) p.intro(`jorgex-stack ${opts.dryRun ? "install (dry-run)" : "install"}`);
+  let writingStyle;
+  let preparedStyle;
+  try {
+    if (opts.writingStyle !== void 0) writingStyle = opts.writingStyle;
+    else writingStyle = preparedStyle = prepareWritingStyle(resolveWritingStyleFile({ targetDir: opts.targetDir }), { rootDir: opts.targetDir });
+  } catch (error) {
+    p.log.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
   const stackDir = stackRoot();
   const engramBin = opts.engramBin === void 0 ? detectEngram() : opts.engramBin;
   const modePreference = opts.mode === void 0 ? opts.targetDir === void 0 ? loadInstallModePreference() : DEFAULT_INSTALL_MODE_PREFERENCE : normalizeInstallModePreference(opts.mode);
@@ -2691,7 +2805,16 @@ async function runInstall(opts) {
   const projectPlaywrightPrompt = opts.dryRun && toolPlan?.persistEnabledOnSuccess === true;
   const hasFileRuntimes = opts.runtimes.length > 0;
   const modelMap = hasFileRuntimes ? loadModelMap() : {};
-  if (hasFileRuntimes && useManifest) ensureModelMapFile();
+  if (preparedStyle !== void 0) {
+    try {
+      p.log.info(`Estilo de escritura: ${preparedStyle.sourcePath}${opts.dryRun ? " (instalaci\xF3n prevista; sin escrituras)" : ""}.`);
+      applyWritingStyle(preparedStyle, opts.dryRun);
+    } catch (error) {
+      p.log.error(error instanceof Error ? error.message : String(error));
+      return 1;
+    }
+  }
+  if (hasFileRuntimes && useManifest && !opts.dryRun) ensureModelMapFile();
   p.log.info(engramBin ? `Engram detectado: ${engramBin} (se respeta, D7)` : "Engram NO detectado.");
   const current = hasFileRuntimes && useManifest ? collectAllCurrentTargets(modePreference) : { targets: /* @__PURE__ */ new Set(), complete: false, warnings: [] };
   const canOrphan = hasFileRuntimes && useManifest && current.complete;
@@ -2723,6 +2846,7 @@ async function runInstall(opts) {
       continue;
     }
     const ctx = {
+      writingStyle,
       stackDir,
       configDir,
       mode: modePreference.mode,
@@ -2765,10 +2889,10 @@ async function runInstall(opts) {
     }
     const writeManifest = () => {
       if (!useManifest) return;
-      const unmergeTargets = new Set(adapter.planUnmerge(canonicalMcp, canonicalHooks, ctx).map((a) => path20.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) => path20.resolve(a.target)).filter(keepTarget);
-      const previousOwned = (prevManifest?.owned ?? []).map((target) => path20.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() });
     };
@@ -2797,9 +2921,9 @@ 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, useManifest ? (action) => persistConfigurationOwnershipChanges(id, configDir, [action]) : void 0);
-    const pruneRoot = useManifest ? HOME : path20.dirname(configDir);
+    const pruneRoot = useManifest ? HOME : path21.dirname(configDir);
     for (const orphan of orphans) {
-      fs15.rmSync(orphan, { force: true });
+      fs16.rmSync(orphan, { force: true });
       pruneEmptyDirs(orphan, pruneRoot);
     }
     const verifyCtx = { ...ctx, warnings: [] };
@@ -2924,29 +3048,29 @@ async function runInstall(opts) {
 }
 
 // src/uninstall.ts
-import fs17 from "fs";
-import path24 from "path";
+import fs18 from "fs";
+import path25 from "path";
 import * as p2 from "@clack/prompts";
 
 // src/lib/pi-projection-lifecycle.ts
-import fs16 from "fs";
-import path23 from "path";
+import fs17 from "fs";
+import path24 from "path";
 import { createHash } from "crypto";
 
 // src/adapters/pi.ts
-import path21 from "path";
+import path22 from "path";
 var piAdapter = {
   id: "pi",
   paths(configDir) {
-    const piConfigDir = process.env.PI_CODING_AGENT_DIR ?? path21.join(HOME, ".pi", "agent");
-    const agentsHome = samePath(configDir, piConfigDir) ? HOME : path21.join(path21.dirname(configDir), "home");
+    const piConfigDir = process.env.PI_CODING_AGENT_DIR ?? path22.join(HOME, ".pi", "agent");
+    const agentsHome = samePath(configDir, piConfigDir) ? HOME : path22.join(path22.dirname(configDir), "home");
     return {
-      systemPromptFile: path21.join(configDir, "AGENTS.md"),
-      agentsDir: path21.join(configDir, "agents"),
-      skillsDir: path21.join(agentsHome, ".agents", "skills"),
-      commandsDir: path21.join(configDir, "prompts"),
+      systemPromptFile: path22.join(configDir, "AGENTS.md"),
+      agentsDir: path22.join(configDir, "agents"),
+      skillsDir: path22.join(agentsHome, ".agents", "skills"),
+      commandsDir: path22.join(configDir, "prompts"),
       pluginsDir: null,
-      scriptsDir: path21.join(configDir, "scripts"),
+      scriptsDir: path22.join(configDir, "scripts"),
       outputStylesDir: null,
       profilesDir: null
     };
@@ -2960,7 +3084,7 @@ var piAdapter = {
 };
 
 // src/lib/pi-package-lifecycle.ts
-import path22 from "path";
+import path23 from "path";
 var REQUIRED_CAPABILITIES = /* @__PURE__ */ new Set([
   "foundation-contract-v1",
   "runner-json-v1",
@@ -3092,7 +3216,7 @@ function parseReceiptShape(receiptJson) {
       return null;
     }
     if (engram === void 0) return "upgrade-required";
-    if (engram === null || typeof engram !== "object" || Array.isArray(engram) || typeof Reflect.get(engram, "binary") !== "string" || !path22.isAbsolute(Reflect.get(engram, "binary"))) {
+    if (engram === null || typeof engram !== "object" || Array.isArray(engram) || typeof Reflect.get(engram, "binary") !== "string" || !path23.isAbsolute(Reflect.get(engram, "binary"))) {
       return null;
     }
     return parsed;
@@ -3129,7 +3253,7 @@ function planPiPackageLifecycle(input) {
   if (input.receiptJson !== null) {
     const parsedReceipt = parseReceipt(input.receiptJson, input.candidate, {
       kind: input.scope.kind,
-      codingAgentDir: path22.resolve(input.scope.codingAgentDir)
+      codingAgentDir: path23.resolve(input.scope.codingAgentDir)
     }, input.engramBin);
     if (parsedReceipt === "upgrade-required") return blocked(input, "receipt-upgrade-required");
     if (parsedReceipt === null) return blocked(input, "receipt-corrupt");
@@ -3164,7 +3288,7 @@ function planPiPackageLifecycle(input) {
     },
     receipt: expectedReceipt(input.candidate, "installing", {
       kind: input.scope.kind,
-      codingAgentDir: path22.resolve(input.scope.codingAgentDir)
+      codingAgentDir: path23.resolve(input.scope.codingAgentDir)
     }, input.engramBin),
     ownership: ownership(true)
   };
@@ -3179,7 +3303,7 @@ function parseRunnerRecord(stdout, stderr, command, candidate, packageRunner) {
     const parsed = JSON.parse(body);
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     const record = parsed;
-    if (record.schemaVersion !== candidate.contract.runner.schemaVersion || record.command !== command || record.ok !== true || record.package === null || typeof record.package !== "object" || record.package.name !== candidate.package.name || record.package.version !== candidate.package.version || typeof record.package.root !== "string" || !path22.isAbsolute(record.package.root) || path22.resolve(packageRunner) !== path22.resolve(record.package.root, "bin", "jorgex-pi.mjs")) {
+    if (record.schemaVersion !== candidate.contract.runner.schemaVersion || record.command !== command || record.ok !== true || record.package === null || typeof record.package !== "object" || record.package.name !== candidate.package.name || record.package.version !== candidate.package.version || typeof record.package.root !== "string" || !path23.isAbsolute(record.package.root) || path23.resolve(packageRunner) !== path23.resolve(record.package.root, "bin", "jorgex-pi.mjs")) {
       return null;
     }
     return record;
@@ -3265,10 +3389,10 @@ function validateOwnedOperationState(input) {
   }))) {
     return { kind: "blocked", reason: "receipt-untrusted" };
   }
-  if (receipt.scope.kind !== (input.paths.targetDir ? "target-dir" : "real") || path22.resolve(receipt.scope.codingAgentDir) !== path22.resolve(input.paths.codingAgentDir)) {
+  if (receipt.scope.kind !== (input.paths.targetDir ? "target-dir" : "real") || path23.resolve(receipt.scope.codingAgentDir) !== path23.resolve(input.paths.codingAgentDir)) {
     return { kind: "blocked", reason: "source-divergent" };
   }
-  if (input.engramBin !== null && path22.resolve(receipt.engram.binary) !== path22.resolve(input.engramBin)) {
+  if (input.engramBin !== null && path23.resolve(receipt.engram.binary) !== path23.resolve(input.engramBin)) {
     return { kind: "blocked", reason: "receipt-corrupt" };
   }
   const source = receipt.candidate.package.source;
@@ -3375,7 +3499,7 @@ var RETIRED_PLAYWRIGHT_FILES = [
   "references/video-recording.md"
 ];
 function retiredPlaywrightFiles(scope) {
-  return RETIRED_PLAYWRIGHT_FILES.map((file) => path23.resolve(scope.home, ".agents", "skills", "playwright-cli", file));
+  return RETIRED_PLAYWRIGHT_FILES.map((file) => path24.resolve(scope.home, ".agents", "skills", "playwright-cli", file));
 }
 function handoffEnabled(input, kind) {
   return (kind === "devtools" ? input.devtoolsMcpEnabled : input.playwrightHandoffEnabled) === true;
@@ -3384,18 +3508,18 @@ var preparedPiProjectionUninstalls = /* @__PURE__ */ new WeakMap();
 function projectionScope(scope) {
   return {
     ...scope,
-    settingsFile: path23.join(scope.codingAgentDir, "settings.json")
+    settingsFile: path24.join(scope.codingAgentDir, "settings.json")
   };
 }
 function isInside(root, file) {
-  const relative = path23.relative(path23.resolve(root), path23.resolve(file));
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path23.sep}`) && !path23.isAbsolute(relative);
+  const relative = path24.relative(path24.resolve(root), path24.resolve(file));
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path24.sep}`) && !path24.isAbsolute(relative);
 }
 function isManagedPath(scope, file) {
   return isInside(scope.home, file) || isInside(scope.codingAgentDir, file);
 }
 function isAllowedPath(scope, file) {
-  return isManagedPath(scope, file) || path23.resolve(file) === path23.resolve(scope.receiptFile);
+  return isManagedPath(scope, file) || path24.resolve(file) === path24.resolve(scope.receiptFile);
 }
 function projectedPiAdapter(scope) {
   const paths = piAdapter.paths(scope.codingAgentDir);
@@ -3403,12 +3527,13 @@ function projectedPiAdapter(scope) {
     ...piAdapter,
     paths: () => ({
       ...paths,
-      skillsDir: path23.join(scope.home, ".agents", "skills")
+      skillsDir: path24.join(scope.home, ".agents", "skills")
     })
   };
 }
 function projectionPlan(input, scope) {
   const ctx = {
+    writingStyle: input.writingStyle,
     stackDir: input.stackDir,
     configDir: scope.codingAgentDir,
     engramBin: input.engramBin,
@@ -3446,20 +3571,20 @@ function projectionPlan(input, scope) {
   return actions;
 }
 function handoffPath(scope, kind) {
-  return path23.resolve(scope.codingAgentDir, "jorgex-pi", `${kind}.v1.json`);
+  return path24.resolve(scope.codingAgentDir, "jorgex-pi", `${kind}.v1.json`);
 }
 function contentHash(content) {
   return createHash("sha256").update(content).digest("hex");
 }
 function canonicalActionContent(action) {
-  return action.kind === "write" ? action.content : fs16.readFileSync(action.source, "utf8");
+  return action.kind === "write" ? action.content : fs17.readFileSync(action.source, "utf8");
 }
 function hasActionDrift(action, deps) {
   return deps.readText(action.target) !== canonicalActionContent(action);
 }
 function applyActions(actions, deps, handoffs = []) {
   for (const action of actions) {
-    const handoff = handoffs.find((entry) => path23.resolve(action.target) === entry.file);
+    const handoff = handoffs.find((entry) => path24.resolve(action.target) === entry.file);
     if (handoff) {
       try {
         if (deps.readText(handoff.file) !== handoff.previous) return handoffConflict(handoff.kind, handoff.file);
@@ -3479,9 +3604,9 @@ function assertPlanContained(plan, scope) {
   }
 }
 function receiptFor(plan, scope) {
-  const systemPrompt = path23.join(scope.codingAgentDir, "AGENTS.md");
+  const systemPrompt = path24.join(scope.codingAgentDir, "AGENTS.md");
   const owned = [...new Set(
-    plan.map((action) => path23.resolve(action.target)).filter((target) => target !== systemPrompt)
+    plan.map((action) => path24.resolve(action.target)).filter((target) => target !== systemPrompt)
   )];
   const receipt = {
     schemaVersion: 1,
@@ -3494,7 +3619,7 @@ function receiptFor(plan, scope) {
     owned
   };
   for (const kind of HANDOFF_KINDS) {
-    const action = plan.find((entry) => path23.resolve(entry.target) === handoffPath(scope, kind));
+    const action = plan.find((entry) => path24.resolve(entry.target) === handoffPath(scope, kind));
     if (action) receipt[kind] = { sha256: contentHash(canonicalActionContent(action)) };
   }
   return receipt;
@@ -3535,7 +3660,7 @@ function parseReceipt2(raw, expected) {
     if (matches(expectedOwned)) return { schemaVersion: 1, scope: expected.scope, owned: expectedOwned, ...digests };
     const retired = retiredPlaywrightFiles(expected.scope);
     if (retired.some((file) => expectedOwned.includes(file))) return null;
-    const skillsRoot = `${path23.resolve(expected.scope.home, ".agents", "skills")}${path23.sep}`;
+    const skillsRoot = `${path24.resolve(expected.scope.home, ".agents", "skills")}${path24.sep}`;
     const insertion = expectedOwned.findIndex((file) => !file.startsWith(skillsRoot) || file > retired[0]);
     const legacyOwned = [...expectedOwned];
     legacyOwned.splice(insertion === -1 ? legacyOwned.length : insertion, 0, ...retired);
@@ -3554,13 +3679,13 @@ function realPiProjectionScope() {
   return {
     kind: "real",
     home: HOME,
-    codingAgentDir: process.env.PI_CODING_AGENT_DIR ?? path23.join(HOME, ".pi", "agent"),
-    receiptFile: path23.join(dataDir(), "pi-projection-receipt.json")
+    codingAgentDir: process.env.PI_CODING_AGENT_DIR ?? path24.join(HOME, ".pi", "agent"),
+    receiptFile: path24.join(dataDir(), "pi-projection-receipt.json")
   };
 }
 function readTextOnlyIfMissing(file) {
   try {
-    return fs16.readFileSync(file, "utf8");
+    return fs17.readFileSync(file, "utf8");
   } catch (error) {
     if (typeof error === "object" && error !== null && Reflect.get(error, "code") === "ENOENT") return null;
     throw error;
@@ -3593,13 +3718,13 @@ function manifestOwned(manifest) {
   return new Set([
     ...manifest.runtimes.codex?.owned ?? [],
     ...manifest.runtimes.opencode?.owned ?? []
-  ].map((file) => path23.resolve(file)));
+  ].map((file) => path24.resolve(file)));
 }
 function withoutManagedPromptSections(content) {
-  return ["system-prompt", "engram-protocol", "browser"].reduce((current, section) => removeMarkdownSection(current, section), content);
+  return ["system-prompt", "engram-protocol", "browser", "writing-style"].reduce((current, section) => removeMarkdownSection(current, section), content);
 }
 function uniquePaths(paths) {
-  return [...new Set(paths.map((file) => path23.resolve(file)))];
+  return [...new Set(paths.map((file) => path24.resolve(file)))];
 }
 function blocked2(reason, paths, remedy) {
   return { kind: "blocked", reason, paths: uniquePaths(paths), remedy };
@@ -3706,7 +3831,7 @@ function preparePiProjectionUninstall(input, deps) {
   }
   const scope = projectionScope(input.scope);
   const expectedReceipt2 = expectedProjectionReceipt(input, scope);
-  const prompt = path23.join(scope.codingAgentDir, "AGENTS.md");
+  const prompt = path24.join(scope.codingAgentDir, "AGENTS.md");
   let existingPrompt;
   try {
     existingPrompt = deps.readText(prompt);
@@ -3714,7 +3839,7 @@ function preparePiProjectionUninstall(input, deps) {
     return cleanupFailure([prompt]);
   }
   const promptContent = existingPrompt === null ? null : withoutManagedPromptSections(existingPrompt);
-  const promptUpdate = promptContent === null || promptContent === existingPrompt ? null : { file: path23.resolve(prompt), content: promptContent };
+  const promptUpdate = promptContent === null || promptContent === existingPrompt ? null : { file: path24.resolve(prompt), content: promptContent };
   const receiptRead = readProjectionReceipt(scope.receiptFile, deps);
   if (receiptRead.kind === "unreadable") return receiptUnreadable(scope.receiptFile);
   let ownedToRemove = [];
@@ -3732,7 +3857,7 @@ function preparePiProjectionUninstall(input, deps) {
       return cleanupFailure([scope.receiptFile]);
     }
     ownedToRemove = receipt.owned.filter((owned) => !retained.has(owned));
-    receiptFile = path23.resolve(scope.receiptFile);
+    receiptFile = path24.resolve(scope.receiptFile);
     backupTargets = [...backupTargets, ...receipt.owned, receiptFile];
   }
   const handoffs = [];
@@ -3810,10 +3935,10 @@ function runPiProjectionLifecycle(input, deps) {
     const prepared = preparePiProjectionUninstall(input, deps);
     return prepared.kind === "blocked" ? prepared : completePiProjectionUninstall(prepared.plan, deps);
   }
-  if (input.devtoolsMcpEnabled && (!input.pnpmBin || !path23.isAbsolute(input.pnpmBin))) {
+  if (input.devtoolsMcpEnabled && (!input.pnpmBin || !path24.isAbsolute(input.pnpmBin))) {
     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))) {
+  if (input.playwrightHandoffEnabled && (!input.playwrightCliCommand || !path24.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);
@@ -3826,12 +3951,12 @@ function runPiProjectionLifecycle(input, deps) {
   const expectedReceipt2 = receiptContent(receipt);
   const drifted = plan.filter((action) => hasActionDrift(action, deps));
   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)) {
+    if (handoffEnabled(input, kind) && checked.previous?.[kind]?.sha256 !== receipt[kind]?.sha256 && !drifted.some((action) => path24.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));
+    const paths = drifted.map((action) => path24.resolve(action.target));
     paths.push(...removedHandoffs.map(({ file }) => file), ...retiredSkills);
     const currentSettings2 = deps.readText(scope.settingsFile);
     if (currentSettings2 === null || filterProjectedPiPackage(currentSettings2, input.packageSource) !== currentSettings2) {
@@ -3890,16 +4015,17 @@ function runPiProjectionLifecycle(input, deps) {
   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);
+  const targetRoot = input.targetDir === void 0 ? null : path24.resolve(input.targetDir);
   const scope = targetRoot === null ? realPiProjectionScope() : {
     kind: "target-dir",
-    home: path23.join(targetRoot, "home"),
-    codingAgentDir: path23.join(targetRoot, "pi-agent"),
-    receiptFile: path23.join(targetRoot, "state", "pi-projection-receipt.json")
+    home: path24.join(targetRoot, "home"),
+    codingAgentDir: path24.join(targetRoot, "pi-agent"),
+    receiptFile: path24.join(targetRoot, "state", "pi-projection-receipt.json")
   };
   return {
     input: {
       operation: input.operation,
+      writingStyle: input.writingStyle,
       scope,
       packageSource: input.packageSource,
       stackDir: stackRoot(),
@@ -3915,14 +4041,14 @@ function systemProjectionLifecycle(input) {
       backup: (paths) => createBackup(
         paths,
         `pi-projection-${input.operation}`,
-        targetRoot === null ? void 0 : path23.join(targetRoot, "backups")
+        targetRoot === null ? void 0 : path24.join(targetRoot, "backups")
       ),
       writeText,
       copyFile,
       removeFile: (file) => {
-        fs16.rmSync(file, { force: true });
-        if (retiredPlaywrightFiles(scope).includes(path23.resolve(file))) {
-          pruneEmptyDirs(file, path23.join(scope.home, ".agents", "skills"));
+        fs17.rmSync(file, { force: true });
+        if (retiredPlaywrightFiles(scope).includes(path24.resolve(file))) {
+          pruneEmptyDirs(file, path24.join(scope.home, ".agents", "skills"));
         }
       },
       readManifest: targetRoot === null ? readManifest : () => ({ runtimes: {} })
@@ -4001,7 +4127,7 @@ async function runUninstall(opts) {
       if (!detection.installed) continue;
       const keepCtx = makeContext(keep, detection.configDir);
       if (!keepCtx) continue;
-      for (const action of buildPlan(keep, keepCtx)) retained.add(path24.resolve(action.target));
+      for (const action of buildPlan(keep, keepCtx)) retained.add(path25.resolve(action.target));
     }
   }
   for (const id of opts.runtimes) {
@@ -4020,15 +4146,15 @@ async function runUninstall(opts) {
     if (!ctx) continue;
     ctx.preserveEngram = !removeEngram;
     const unmerge = adapter.planUnmerge(mcpForUnmerge, hooks, ctx);
-    const mergedTargets = new Set(unmerge.map((a) => path24.resolve(a.target)));
+    const mergedTargets = new Set(unmerge.map((a) => path25.resolve(a.target)));
     const usingRealConfig = opts.targetDir === void 0;
     const prevOwned = usingRealConfig ? readManifest().runtimes[id]?.owned ?? [] : [];
-    const pruneRoot = usingRealConfig ? HOME : path24.dirname(configDir);
+    const pruneRoot = usingRealConfig ? HOME : path25.dirname(configDir);
     const planTargets = [
-      .../* @__PURE__ */ new Set([...buildPlan(adapter, ctx).map((a) => path24.resolve(a.target)), ...prevOwned.map((t) => path24.resolve(t))])
-    ].filter((t) => !mergedTargets.has(t) && fs17.existsSync(t));
+      .../* @__PURE__ */ new Set([...buildPlan(adapter, ctx).map((a) => path25.resolve(a.target)), ...prevOwned.map((t) => path25.resolve(t))])
+    ].filter((t) => !mergedTargets.has(t) && fs18.existsSync(t));
     const deleteTargets = planTargets.filter(
-      (t) => !retained.has(t) && !(ctx.preserveEngram && path24.basename(t) === "engram.ts") && isContainedIn(t, pruneRoot)
+      (t) => !retained.has(t) && !(ctx.preserveEngram && path25.basename(t) === "engram.ts") && isContainedIn(t, pruneRoot)
     );
     const sharedKept = planTargets.length - deleteTargets.length;
     p2.log.step(`${adapter.name} \u2192 ${configDir}`);
@@ -4038,7 +4164,7 @@ async function runUninstall(opts) {
     let backup;
     try {
       backup = createBackup(
-        [...deleteTargets, ...unmerge.map((a) => a.target).filter((t) => fs17.existsSync(t))],
+        [...deleteTargets, ...unmerge.map((a) => a.target).filter((t) => fs18.existsSync(t))],
         `uninstall-${id}`
       );
     } catch (error) {
@@ -4048,13 +4174,13 @@ async function runUninstall(opts) {
     }
     if (backup) p2.log.info(`Backup: ${backup.id} (${backup.files.length} archivos)`);
     for (const target of deleteTargets) {
-      fs17.rmSync(target, { force: true });
+      fs18.rmSync(target, { force: true });
       pruneEmptyDirs(target, pruneRoot);
     }
     for (const action of unmerge) {
       if (action.kind !== "write") continue;
       if (action.content.trim() === "") {
-        fs17.rmSync(action.target, { force: true });
+        fs18.rmSync(action.target, { force: true });
       } else {
         writeText(action.target, action.content);
       }
@@ -4108,9 +4234,17 @@ async function runUninstall(opts) {
 }
 
 // src/doctor.ts
-import path25 from "path";
-import fs18 from "fs";
+import path26 from "path";
+import fs19 from "fs";
 import * as p3 from "@clack/prompts";
+function readDoctorTextIfExists(file) {
+  try {
+    return fs19.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
 function engramVersion(bin) {
   const out = runDetectedBin(bin, ["--version"], 5e3);
   if (out === null) return null;
@@ -4129,16 +4263,71 @@ function resolvePlaywrightDoctorState(input) {
   return { status: "healthy" };
 }
 function context7KeyConfigured(id, configDir) {
-  const file = id === "codex" ? path25.join(configDir, "config.toml") : id === "claude-code" ? path25.join(path25.dirname(configDir), `${path25.basename(configDir)}.json`) : path25.join(configDir, "opencode.json");
+  const file = id === "codex" ? path26.join(configDir, "config.toml") : id === "claude-code" ? path26.join(path26.dirname(configDir), `${path26.basename(configDir)}.json`) : path26.join(configDir, "opencode.json");
   const content = readTextIfExists(file);
   if (content === null) return null;
   const match = /CONTEXT7_API_KEY"?\s*[:=]\s*"([^"]*)"/.exec(content);
   if (!match) return null;
   return match[1] !== "";
 }
-async function runDoctor() {
-  p3.intro("jorgex-stack doctor");
+function reportWritingStyle(options, style, mode) {
   let problems = 0;
+  p3.log.info(`Estilo de escritura incluido: ${style.canonicalPath}; fuente local ${style.sourcePath}; tama\xF1o ${Buffer.byteLength(style.content, "utf8")} bytes de texto normalizado. La carga nativa no est\xE1 verificada.`);
+  if (style.originalContent === style.installedContent) p3.log.success("Archivo local de estilo actualizado con el canon incluido.");
+  else {
+    p3.log.warn(`Archivo local de estilo ${style.originalContent === null ? "pendiente de instalar" : "desactualizado; pendiente de sincronizar"}; ejecuta install o sync (${style.sourcePath}).`);
+    problems++;
+  }
+  const expected = mode.mode !== "programmatic" ? upsertMarkdownSection(null, "writing-style", style.content).trim() : null;
+  const runtimes = options.runtimes ?? Object.values(ADAPTERS).filter((adapter) => options.targetDir !== void 0 || adapter.detect().installed).map((adapter) => adapter.id);
+  for (const id of runtimes) {
+    const adapter = id === "pi" ? piAdapter : ADAPTERS[id];
+    if (adapter === void 0) continue;
+    const configDir = id === "pi" ? options.targetDir === void 0 ? process.env.PI_CODING_AGENT_DIR ?? path26.join(HOME, ".pi", "agent") : path26.join(options.targetDir, "pi-agent") : options.targetDir ?? ADAPTERS[id].detect().configDir;
+    const file = adapter.paths(configDir).systemPromptFile;
+    try {
+      const content = readDoctorTextIfExists(file) ?? "";
+      const open = "<!-- jorgex:writing-style -->";
+      const close = "<!-- /jorgex:writing-style -->";
+      const healthy = hasHealthyManagedMarkdownMarkers(content, "writing-style");
+      const block = healthy ? content.slice(content.indexOf(open), content.indexOf(close) + close.length) : null;
+      const matches = expected === null ? !content.includes(open) && !content.includes(close) : healthy && block === expected;
+      if (matches) p3.log.success(`${id}: proyecci\xF3n de estilo coincide (${file})${mode.mode === "programmatic" ? "; omitida en modo programmatic" : ""}.`);
+      else {
+        p3.log.warn(`${id}: proyecci\xF3n de estilo desactualizada o ausente (${file}); ejecuta sync.`);
+        problems++;
+      }
+      if (id === "codex") {
+        const override = path26.join(configDir, "AGENTS.override.md");
+        if ((readDoctorTextIfExists(override) ?? "").trim() !== "") {
+          p3.log.warn(`Codex: ${override} no vac\xEDo puede ocultar el AGENTS.md gestionado; rev\xEDsalo sin modificarlo autom\xE1ticamente.`);
+          problems++;
+        }
+      }
+    } catch {
+      p3.log.error(`${id}: no se puede leer la proyecci\xF3n de estilo o su override en ${configDir}; revisa archivos y permisos.`);
+      problems++;
+    }
+  }
+  return problems;
+}
+async function runDoctor(options = {}) {
+  p3.intro("jorgex-stack doctor");
+  let writingStyle;
+  let modePreference;
+  try {
+    writingStyle = prepareWritingStyle(resolveWritingStyleFile({ targetDir: options.targetDir }), { rootDir: options.targetDir });
+    modePreference = options.mode ?? (options.targetDir === void 0 ? loadInstallModePreference() : DEFAULT_INSTALL_MODE_PREFERENCE);
+  } catch (error) {
+    p3.log.error(error instanceof Error ? error.message : String(error));
+    p3.outro("No se puede diagnosticar el estilo; corrige la fuente o la preferencia indicada.");
+    return 1;
+  }
+  let problems = reportWritingStyle(options, writingStyle, modePreference);
+  if (options.targetDir !== void 0 || options.runtimes !== void 0 && options.runtimes.length > 0 && options.runtimes.every((id) => id === "pi")) {
+    p3.outro("Diagn\xF3stico limitado al estilo; no se han ejecutado las comprobaciones globales del sistema.");
+    return problems > 0 ? 1 : 0;
+  }
   const engramBin = detectEngram();
   if (engramBin === null) {
     p3.log.warn("Engram: NO detectado. El protocolo de memoria no funcionar\xE1 \u2014 inst\xE1lalo: github.com/Gentleman-Programming/engram");
@@ -4152,13 +4341,13 @@ async function runDoctor() {
       p3.log.success(`Engram: ${version} (${engramBin})`);
     }
   }
-  const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path25.join(HOME, ".engram");
-  const engramDb = path25.join(engramDataDir, "engram.db");
-  if (fs18.existsSync(engramDb)) {
-    const sizeMb = (fs18.statSync(engramDb).size / 1024 / 1024).toFixed(1);
+  const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path26.join(HOME, ".engram");
+  const engramDb = path26.join(engramDataDir, "engram.db");
+  if (fs19.existsSync(engramDb)) {
+    const sizeMb = (fs19.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 (!fs18.existsSync(modelMapFile())) p3.log.info("model-map: a\xFAn no creado (se crea en el primer install o con 'models').");
+  if (!fs19.existsSync(modelMapFile())) p3.log.info("model-map: a\xFAn no creado (se crea en el primer install o con 'models').");
   const preferenceErrors = browserPreferenceErrors();
   const primaryOwnershipError = primaryModelOwnershipError();
   if (primaryOwnershipError !== null) {
@@ -4199,7 +4388,6 @@ async function runDoctor() {
     }
   }
   const manifest = readManifest();
-  const modePreference = loadInstallModePreference();
   const current = collectAllCurrentTargets(modePreference);
   if (!current.complete || current.warnings.length > 0) {
     p3.log.warn("Limpieza de hu\xE9rfanos deshabilitada: no se pudo construir el plan completo de todos los runtimes.");
@@ -4207,6 +4395,7 @@ async function runDoctor() {
     problems++;
   }
   for (const adapter of Object.values(ADAPTERS)) {
+    if (options.runtimes !== void 0 && !options.runtimes.includes(adapter.id)) continue;
     const detection = adapter.detect();
     if (!detection.installed) {
       p3.log.warn(`${adapter.name}: no instalado en esta m\xE1quina.`);
@@ -4217,6 +4406,7 @@ async function runDoctor() {
     p3.log.info(`${adapter.name}: capabilities diagnostic (${capabilitySummary}); no certifica enforcement local.`);
     const ctx = makeContext(adapter, detection.configDir, modePreference);
     if (!ctx) continue;
+    ctx.writingStyle = writingStyle;
     let pending;
     try {
       pending = diffPlan(buildPlan(adapter, ctx)).filter((d) => d.status !== "unchanged").length;
@@ -4239,15 +4429,9 @@ async function runDoctor() {
       p3.log.warn(`${adapter.name}: ${orphans.length} archivos hu\xE9rfanos de versiones previas \u2192 ejecuta 'sync'.`);
       problems++;
     }
-    if (adapter.id === "codex" && fs18.existsSync(path25.join(detection.configDir, "hooks.json"))) {
+    if (adapter.id === "codex" && fs19.existsSync(path26.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" && fs18.existsSync(path25.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."
-      );
-      problems++;
-    }
     const key = context7KeyConfigured(adapter.id, detection.configDir);
     if (key === false) p3.log.info(`${adapter.name}: context7 sin key (opcional \u2014 con\xE9ctala cuando quieras).`);
   }
@@ -4256,15 +4440,15 @@ async function runDoctor() {
 }
 
 // src/update.ts
-import fs21 from "fs";
-import path28 from "path";
+import fs22 from "fs";
+import path29 from "path";
 import os3 from "os";
 import { execFileSync as execFileSync5 } from "child_process";
 import * as p4 from "@clack/prompts";
 
 // src/lib/github.ts
-import fs19 from "fs";
-import path26 from "path";
+import fs20 from "fs";
+import path27 from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 import os2 from "os";
 import { Readable } from "stream";
@@ -4334,19 +4518,19 @@ async function latestGithubCommit(repo) {
   }
 }
 function validateExtractedTree(destDir) {
-  const resolved = path26.resolve(destDir);
+  const resolved = path27.resolve(destDir);
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs19.readdirSync(dir, { withFileTypes: true });
+      entries = fs20.readdirSync(dir, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
-      const full = path26.join(dir, entry.name);
+      const full = path27.join(dir, entry.name);
       let stat;
       try {
-        stat = fs19.lstatSync(full);
+        stat = fs20.lstatSync(full);
       } catch {
         return false;
       }
@@ -4362,15 +4546,15 @@ function validateExtractedTree(destDir) {
 }
 function resolveTarBin() {
   if (process.platform !== "win32") return "tar";
-  const winTar = path26.join(process.env["SystemRoot"] ?? "C:\\Windows", "System32", "tar.exe");
-  return fs19.existsSync(winTar) ? winTar : "tar";
+  const winTar = path27.join(process.env["SystemRoot"] ?? "C:\\Windows", "System32", "tar.exe");
+  return fs20.existsSync(winTar) ? winTar : "tar";
 }
 async function downloadRepoTarball(repo, sha, destDir, validateSubdir) {
   const url = `https://codeload.github.com/${repo}/tar.gz/${sha}`;
-  const tmp = path26.join(os2.tmpdir(), `jorgex-tarball-${Date.now()}.tar.gz`);
+  const tmp = path27.join(os2.tmpdir(), `jorgex-tarball-${Date.now()}.tar.gz`);
   const fail = (reason) => {
     try {
-      fs19.rmSync(destDir, { recursive: true, force: true });
+      fs20.rmSync(destDir, { recursive: true, force: true });
     } catch {
     }
     return { ok: false, reason };
@@ -4389,10 +4573,10 @@ async function downloadRepoTarball(repo, sha, destDir, validateSubdir) {
     if (!res.body) return fail("respuesta HTTP sin cuerpo");
     await pipeline(
       Readable.fromWeb(res.body),
-      fs19.createWriteStream(tmp)
+      fs20.createWriteStream(tmp)
     );
-    fs19.rmSync(destDir, { recursive: true, force: true });
-    fs19.mkdirSync(destDir, { recursive: true });
+    fs20.rmSync(destDir, { recursive: true, force: true });
+    fs20.mkdirSync(destDir, { recursive: true });
     try {
       execFileSync3(resolveTarBin(), ["-xzf", tmp, "--strip-components=1", "-C", destDir], { stdio: "pipe" });
     } catch (err) {
@@ -4400,30 +4584,30 @@ async function downloadRepoTarball(repo, sha, destDir, validateSubdir) {
       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 = path26.resolve(destDir);
-    const validateRoot = validateSubdir ? path26.resolve(resolvedDest, validateSubdir) : resolvedDest;
+    const resolvedDest = path27.resolve(destDir);
+    const validateRoot = validateSubdir ? path27.resolve(resolvedDest, validateSubdir) : resolvedDest;
     if (validateRoot !== resolvedDest && !isContainedIn(validateRoot, resolvedDest)) {
       return fail(`la ruta de validaci\xF3n "${validateSubdir}" escapa del destino`);
     }
-    if (fs19.existsSync(validateRoot) && !validateExtractedTree(validateRoot)) {
+    if (fs20.existsSync(validateRoot) && !validateExtractedTree(validateRoot)) {
       return fail("el \xE1rbol extra\xEDdo contiene symlinks o rutas fuera del destino");
     }
-    const validated = fs19.existsSync(validateRoot);
+    const validated = fs20.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 {
-      fs19.rmSync(tmp, { force: true });
+      fs20.rmSync(tmp, { force: true });
     } catch {
     }
   }
 }
 
 // src/lib/skill-update.ts
-import fs20 from "fs";
-import path27 from "path";
+import fs21 from "fs";
+import path28 from "path";
 import { execFileSync as execFileSync4 } from "child_process";
 var PROTECTED_SKILLS = /* @__PURE__ */ new Set([
   "agent-delegation",
@@ -4434,8 +4618,8 @@ var PROTECTED_SKILLS = /* @__PURE__ */ new Set([
   "xreview"
 ]);
 function sameTextContentNormalized(a, b) {
-  const ba = fs20.readFileSync(a);
-  const bb = fs20.readFileSync(b);
+  const ba = fs21.readFileSync(a);
+  const bb = fs21.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");
@@ -4443,10 +4627,10 @@ function sameTextContentNormalized(a, b) {
 }
 function diffSkillDirs(upstreamDir, localDir) {
   const upstreamFiles = new Set(
-    listFilesRecursive(upstreamDir).map((f) => path27.relative(upstreamDir, f))
+    listFilesRecursive(upstreamDir).map((f) => path28.relative(upstreamDir, f))
   );
   const localFiles = new Set(
-    listFilesRecursive(localDir).map((f) => path27.relative(localDir, f))
+    listFilesRecursive(localDir).map((f) => path28.relative(localDir, f))
   );
   const added = [];
   const modified = [];
@@ -4454,7 +4638,7 @@ function diffSkillDirs(upstreamDir, localDir) {
   for (const rel of upstreamFiles) {
     if (!localFiles.has(rel)) {
       added.push(rel);
-    } else if (!sameTextContentNormalized(path27.join(upstreamDir, rel), path27.join(localDir, rel))) {
+    } else if (!sameTextContentNormalized(path28.join(upstreamDir, rel), path28.join(localDir, rel))) {
       modified.push(rel);
     }
   }
@@ -4516,8 +4700,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 ?? path27.join(path27.dirname(stackRoot()), "upstreams.json");
-  const raw = fs20.readFileSync(upstreamsFile, "utf8");
+  const upstreamsFile = upstreamsFilePath ?? path28.join(path28.dirname(stackRoot()), "upstreams.json");
+  const raw = fs21.readFileSync(upstreamsFile, "utf8");
   const data = JSON.parse(raw);
   const skillEntry = data?.skills?.[name];
   if (!skillEntry) {
@@ -4526,8 +4710,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 ?? path27.join(stackRoot(), "skills");
-  const localSkillDir = path27.join(skillsRoot, name);
+  const skillsRoot = localSkillsRoot ?? path28.join(stackRoot(), "skills");
+  const localSkillDir = path28.join(skillsRoot, name);
   const localFiles = listFilesRecursive(localSkillDir);
   if (localFiles.length > 0) {
     createBackup(localFiles, `skill-update-${name}`, backupsRoot2);
@@ -4536,24 +4720,24 @@ function replaceSkill(name, upstreamSkillDir, newCommit, opts) {
   try {
     const upstreamFiles = listFilesRecursive(upstreamSkillDir);
     for (const src of upstreamFiles) {
-      const st = fs20.lstatSync(src);
+      const st = fs21.lstatSync(src);
       if (st.isSymbolicLink()) {
         throw new Error(`Symlink rechazado en upstream de skill "${name}": ${src}`);
       }
-      const rel = path27.relative(upstreamSkillDir, src);
-      const dest = path27.join(stagingDir, rel);
-      ensureDir(path27.dirname(dest));
+      const rel = path28.relative(upstreamSkillDir, src);
+      const dest = path28.join(stagingDir, rel);
+      ensureDir(path28.dirname(dest));
       copyFile(src, dest);
     }
     const oldDir = `${localSkillDir}.old-${process.pid}`;
-    if (fs20.existsSync(localSkillDir)) {
-      fs20.renameSync(localSkillDir, oldDir);
+    if (fs21.existsSync(localSkillDir)) {
+      fs21.renameSync(localSkillDir, oldDir);
     }
-    fs20.renameSync(stagingDir, localSkillDir);
-    fs20.rmSync(oldDir, { recursive: true, force: true });
+    fs21.renameSync(stagingDir, localSkillDir);
+    fs21.rmSync(oldDir, { recursive: true, force: true });
   } catch (err) {
     try {
-      fs20.rmSync(stagingDir, { recursive: true, force: true });
+      fs21.rmSync(stagingDir, { recursive: true, force: true });
     } catch {
     }
     throw err;
@@ -4567,8 +4751,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 = path28.join(path28.dirname(stackRoot()), "upstreams.json");
-  return JSON.parse(fs21.readFileSync(file, "utf8"));
+  const file = path29.join(path29.dirname(stackRoot()), "upstreams.json");
+  return JSON.parse(fs22.readFileSync(file, "utf8"));
 }
 function skillsToScan(maintainer, upstreams) {
   return maintainer ? Object.keys(upstreams.skills) : [];
@@ -4717,8 +4901,8 @@ function isEngramRunning() {
     return null;
   }
 }
-function isGitClone(projectRoot = path28.dirname(stackRoot())) {
-  return fs21.existsSync(path28.join(projectRoot, ".git"));
+function isGitClone(projectRoot = path29.dirname(stackRoot())) {
+  return fs22.existsSync(path29.join(projectRoot, ".git"));
 }
 var STACK_METHOD_CLONE = "git pull + pnpm install + pnpm build";
 function resolvePnpm() {
@@ -4728,12 +4912,12 @@ function resolvePnpm() {
 }
 function cleanupTmp(dir) {
   try {
-    fs21.rmSync(dir, { recursive: true, force: true });
+    fs22.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
 function updateStackGitClone() {
-  const projectRoot = path28.dirname(stackRoot());
+  const projectRoot = path29.dirname(stackRoot());
   const git = lookPath("git");
   if (!git) throw new Error("git no encontrado en PATH.");
   const pnpm = resolvePnpm();
@@ -4750,7 +4934,7 @@ function updateStackGlobal() {
   execFileSync5(pnpm, ["add", "-g", "jorgex-stack@latest"], { stdio: "inherit" });
 }
 async function downloadSkillToTemp(repo, sha, skillPath) {
-  const root = fs21.mkdtempSync(path28.join(os3.tmpdir(), "jorgex-skill-"));
+  const root = fs22.mkdtempSync(path29.join(os3.tmpdir(), "jorgex-skill-"));
   try {
     const result = await downloadRepoTarball(repo, sha, root, skillPath);
     if (!result.ok) {
@@ -4758,15 +4942,15 @@ async function downloadSkillToTemp(repo, sha, skillPath) {
       return { error: result.reason };
     }
     if (skillPath) {
-      const sub = path28.resolve(path28.join(root, skillPath));
+      const sub = path29.resolve(path29.join(root, skillPath));
       if (!isContainedIn(sub, root)) {
         cleanupTmp(root);
         return { error: `la ruta "${skillPath}" escapa del directorio temporal` };
       }
-      if (fs21.existsSync(sub)) return { dir: sub, root };
+      if (fs22.existsSync(sub)) return { dir: sub, root };
       const lastSeg = skillPath.split("/").pop();
-      const sub2 = path28.resolve(path28.join(root, lastSeg));
-      if (isContainedIn(sub2, root) && fs21.existsSync(sub2)) {
+      const sub2 = path29.resolve(path29.join(root, lastSeg));
+      if (isContainedIn(sub2, root) && fs22.existsSync(sub2)) {
         if (!validateExtractedTree(sub2)) {
           cleanupTmp(root);
           return { error: `el sub\xE1rbol "${lastSeg}" contiene symlinks o rutas fuera del destino` };
@@ -4785,11 +4969,11 @@ async function downloadSkillToTemp(repo, sha, skillPath) {
 function pruneEngramDbBackups() {
   try {
     const dir = dataDir();
-    if (!fs21.existsSync(dir)) return;
-    const backups = fs21.readdirSync(dir).filter((f) => f.startsWith("engram-db-backup-") && f.endsWith(".db")).map((f) => ({ name: f, mtime: fs21.statSync(path28.join(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+    if (!fs22.existsSync(dir)) return;
+    const backups = fs22.readdirSync(dir).filter((f) => f.startsWith("engram-db-backup-") && f.endsWith(".db")).map((f) => ({ name: f, mtime: fs22.statSync(path29.join(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
     for (const old of backups.slice(3)) {
       try {
-        fs21.rmSync(path28.join(dir, old.name));
+        fs22.rmSync(path29.join(dir, old.name));
       } catch {
       }
     }
@@ -4797,18 +4981,18 @@ function pruneEngramDbBackups() {
   }
 }
 function rotateLockedBinary(binPath, sweepRoot = HOME) {
-  if (!fs21.existsSync(binPath)) return null;
-  const dir = path28.dirname(binPath);
-  const base = path28.basename(binPath);
+  if (!fs22.existsSync(binPath)) return null;
+  const dir = path29.dirname(binPath);
+  const base = path29.basename(binPath);
   const escapedBase = base.replace(/[.*+?^$()|[\]{}\\]/g, "\\$&");
   const oldPattern = new RegExp("^" + escapedBase + "\\.old-\\d+$");
-  const resolvedDir = path28.resolve(dir);
-  if (resolvedDir === path28.resolve(sweepRoot) || isContainedIn(resolvedDir, sweepRoot)) {
+  const resolvedDir = path29.resolve(dir);
+  if (resolvedDir === path29.resolve(sweepRoot) || isContainedIn(resolvedDir, sweepRoot)) {
     try {
-      for (const entry of fs21.readdirSync(dir)) {
+      for (const entry of fs22.readdirSync(dir)) {
         if (oldPattern.test(entry)) {
           try {
-            fs21.rmSync(path28.join(dir, entry), { force: true });
+            fs22.rmSync(path29.join(dir, entry), { force: true });
           } catch {
           }
         }
@@ -4816,8 +5000,8 @@ function rotateLockedBinary(binPath, sweepRoot = HOME) {
     } catch {
     }
   }
-  const rotated = path28.join(dir, `${base}.old-${Date.now()}`);
-  fs21.renameSync(binPath, rotated);
+  const rotated = path29.join(dir, `${base}.old-${Date.now()}`);
+  fs22.renameSync(binPath, rotated);
   return rotated;
 }
 async function updateEngram(engramRepo, latestVersion) {
@@ -4826,19 +5010,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 ?? path28.join(HOME, ".engram");
-  const engramDb = path28.join(engramDataDir, "engram.db");
-  if (fs21.existsSync(engramDb)) {
+  const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path29.join(HOME, ".engram");
+  const engramDb = path29.join(engramDataDir, "engram.db");
+  if (fs22.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 = path28.join(dataDir(), `engram-db-backup-${ts}.db`);
+      const dest = path29.join(dataDir(), `engram-db-backup-${ts}.db`);
       try {
-        if (!fs21.existsSync(dataDir())) fs21.mkdirSync(dataDir(), { recursive: true });
-        fs21.copyFileSync(engramDb, dest);
+        if (!fs22.existsSync(dataDir())) fs22.mkdirSync(dataDir(), { recursive: true });
+        fs22.copyFileSync(engramDb, dest);
         p4.log.success(`DB respaldada en ${dest} (la DB original NO se modifica jam\xE1s).`);
         pruneEngramDbBackups();
       } catch (err) {
@@ -4888,10 +5072,10 @@ async function updateEngram(engramRepo, latestVersion) {
         ["install", `github.com/Gentleman-Programming/engram/cmd/engram@v${latestVersion}`],
         { stdio: "inherit" }
       );
-      const rollbackOk = resolveEngramRollback({ installOk: true, rotated, bin, binExists: fs21.existsSync(bin ?? "") });
+      const rollbackOk = resolveEngramRollback({ installOk: true, rotated, bin, binExists: fs22.existsSync(bin ?? "") });
       if (rollbackOk.action === "restore") {
         try {
-          fs21.renameSync(rotated, bin);
+          fs22.renameSync(rotated, bin);
           p4.log.warn(rollbackOk.messages.onRestore);
         } catch {
           p4.log.warn(rollbackOk.messages.onRenameFail);
@@ -4899,10 +5083,10 @@ async function updateEngram(engramRepo, latestVersion) {
       }
       return true;
     } catch (err) {
-      const rollbackFail = resolveEngramRollback({ installOk: false, rotated, bin, binExists: fs21.existsSync(bin ?? "") });
+      const rollbackFail = resolveEngramRollback({ installOk: false, rotated, bin, binExists: fs22.existsSync(bin ?? "") });
       if (rollbackFail.action === "restore") {
         try {
-          fs21.renameSync(rotated, bin);
+          fs22.renameSync(rotated, bin);
           p4.log.info(rollbackFail.messages.onRestore);
         } catch {
           p4.log.error(rollbackFail.messages.onRenameFail);
@@ -5172,7 +5356,7 @@ async function runInteractiveUpdate(localVersion, yes, dryRun = false, includeBr
       continue;
     }
     const { dir: tmpDir, root: tmpRoot } = tmpResult;
-    const localSkillDir = path28.join(stackRoot(), "skills", skillInfo.name);
+    const localSkillDir = path29.join(stackRoot(), "skills", skillInfo.name);
     const diff = renderSkillDiff(tmpDir, localSkillDir);
     if (diff) {
       p4.log.info(`Diff de ${skillInfo.name}:
@@ -5258,7 +5442,7 @@ ${diff}`);
 }
 
 // src/models-picker.ts
-import path29 from "path";
+import path30 from "path";
 import * as p5 from "@clack/prompts";
 var TIERS = ["strong", "standard", "cheap"];
 var EFFORTS = ["low", "medium", "high", "xhigh"];
@@ -5284,7 +5468,7 @@ function opencodeLiveModels(binPath) {
 }
 function agentsByTier() {
   const grouped = { strong: [], standard: [], cheap: [] };
-  for (const agent of loadCanonicalAgents(path29.join(stackRoot(), "agents"))) {
+  for (const agent of loadCanonicalAgents(path30.join(stackRoot(), "agents"))) {
     if (agent.mode === "subagent") grouped[agent.tier].push(agent.name);
   }
   return grouped;
@@ -5469,16 +5653,16 @@ function cancelled() {
 }
 
 // src/lib/release.ts
-import fs22 from "fs";
-import path30 from "path";
+import fs23 from "fs";
+import path31 from "path";
 import { execFileSync as execFileSync6 } from "child_process";
 import { fileURLToPath } from "url";
 function findPackageJson() {
-  let dir = path30.dirname(fileURLToPath(import.meta.url));
+  let dir = path31.dirname(fileURLToPath(import.meta.url));
   for (let i = 0; i < 6; i++) {
-    const candidate = path30.join(dir, "package.json");
-    if (fs22.existsSync(candidate)) return candidate;
-    dir = path30.dirname(dir);
+    const candidate = path31.join(dir, "package.json");
+    if (fs23.existsSync(candidate)) return candidate;
+    dir = path31.dirname(dir);
   }
   throw new Error("No se encontr\xF3 package.json cerca del CLI.");
 }
@@ -5487,7 +5671,7 @@ function readPackageVersion() {
 }
 function readPackageMetadata() {
   const packageJson = findPackageJson();
-  const raw = fs22.readFileSync(packageJson, "utf8");
+  const raw = fs23.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() : "";
@@ -5499,8 +5683,8 @@ function readPackageMetadata() {
 
 // src/lib/pi-runtime.ts
 import os4 from "os";
-import path31 from "path";
-import fs23 from "fs";
+import path32 from "path";
+import fs24 from "fs";
 import { spawnSync } from "child_process";
 import { createHash as createHash2 } from "crypto";
 
@@ -5667,14 +5851,14 @@ function healthyDoctor(stdout, stderr, packageRunner, candidate) {
     if (record === null || typeof record !== "object" || Array.isArray(record)) return false;
     const packageValue = Reflect.get(record, "package");
     const result = Reflect.get(record, "result");
-    return Reflect.get(record, "schemaVersion") === 1 && Reflect.get(record, "command") === "doctor" && Reflect.get(record, "ok") === true && packageValue !== null && typeof packageValue === "object" && Reflect.get(packageValue, "name") === "jorgex-pi" && Reflect.get(packageValue, "version") === (candidate.package?.version ?? /^npm:jorgex-pi@([^\s]+)$/.exec(candidate.source)?.[1]) && path31.resolve(packageRunner) === path31.resolve(String(Reflect.get(packageValue, "root")), "bin", "jorgex-pi.mjs") && result !== null && typeof result === "object" && Reflect.get(result, "healthy") === true;
+    return Reflect.get(record, "schemaVersion") === 1 && Reflect.get(record, "command") === "doctor" && Reflect.get(record, "ok") === true && packageValue !== null && typeof packageValue === "object" && Reflect.get(packageValue, "name") === "jorgex-pi" && Reflect.get(packageValue, "version") === (candidate.package?.version ?? /^npm:jorgex-pi@([^\s]+)$/.exec(candidate.source)?.[1]) && path32.resolve(packageRunner) === path32.resolve(String(Reflect.get(packageValue, "root")), "bin", "jorgex-pi.mjs") && result !== null && typeof result === "object" && Reflect.get(result, "healthy") === true;
   } catch {
     return false;
   }
 }
 function installPiFromVerifiedTarball(input, deps) {
   const paths = input.targetDir === void 0 ? userPaths(input.engramBin, input.piExecutable) : targetPaths(input.targetDir, input.engramBin, input.piExecutable);
-  const destination = input.targetDir === void 0 ? path31.join(dataDir(), "packages", `jorgex-pi-${PI_RUNTIME_CANDIDATE.package.version}.tgz`) : path31.join(path31.resolve(input.targetDir), "downloads", `jorgex-pi-${PI_RUNTIME_CANDIDATE.package.version}.tgz`);
+  const destination = input.targetDir === void 0 ? path32.join(dataDir(), "packages", `jorgex-pi-${PI_RUNTIME_CANDIDATE.package.version}.tgz`) : path32.join(path32.resolve(input.targetDir), "downloads", `jorgex-pi-${PI_RUNTIME_CANDIDATE.package.version}.tgz`);
   const artifact = deps.download(destination);
   if (artifact.bytes !== input.candidate.bytes || artifact.sha256 !== input.candidate.sha256 || artifact.sha512 !== input.candidate.sha512) {
     return { kind: "blocked", reason: "tarball-integrity" };
@@ -5682,7 +5866,7 @@ function installPiFromVerifiedTarball(input, deps) {
   deps.backupSettings();
   const scope = {
     kind: input.targetDir === void 0 ? "real" : "target-dir",
-    codingAgentDir: path31.resolve(paths.codingAgentDir)
+    codingAgentDir: path32.resolve(paths.codingAgentDir)
   };
   const installing = flatCandidateReceipt(input.candidate, scope, "installing", input.engramBin);
   deps.writeReceiptAtomic(`${JSON.stringify(installing)}
@@ -5711,30 +5895,30 @@ function installPiFromVerifiedTarball(input, deps) {
   return { kind: "installed", receipt };
 }
 function runtimePath(piExecutable) {
-  const entries = process.platform === "win32" ? [piExecutable === void 0 ? null : path31.dirname(piExecutable), path31.dirname(process.execPath), process.env.SystemRoot ? path31.join(process.env.SystemRoot, "System32") : null] : [piExecutable === void 0 ? null : path31.dirname(piExecutable), path31.dirname(process.execPath), "/usr/local/bin", "/usr/bin", "/bin"];
-  return [...new Set(entries.filter((entry) => entry !== null))].join(path31.delimiter);
+  const entries = process.platform === "win32" ? [piExecutable === void 0 ? null : path32.dirname(piExecutable), path32.dirname(process.execPath), process.env.SystemRoot ? path32.join(process.env.SystemRoot, "System32") : null] : [piExecutable === void 0 ? null : path32.dirname(piExecutable), path32.dirname(process.execPath), "/usr/local/bin", "/usr/bin", "/bin"];
+  return [...new Set(entries.filter((entry) => entry !== null))].join(path32.delimiter);
 }
 function targetPaths(targetDir, engramBin, piExecutable) {
-  const root = path31.resolve(targetDir);
-  const codingAgentDir = path31.join(root, "pi-agent");
-  const home = path31.join(root, "home");
-  const temporary = path31.join(root, "tmp");
+  const root = path32.resolve(targetDir);
+  const codingAgentDir = path32.join(root, "pi-agent");
+  const home = path32.join(root, "home");
+  const temporary = path32.join(root, "tmp");
   return {
     codingAgentDir,
-    receiptPath: path31.join(root, "state", "pi-receipt.json"),
-    packageRunner: path31.join(codingAgentDir, "npm", "node_modules", "jorgex-pi", "bin", "jorgex-pi.mjs"),
+    receiptPath: path32.join(root, "state", "pi-receipt.json"),
+    packageRunner: path32.join(codingAgentDir, "npm", "node_modules", "jorgex-pi", "bin", "jorgex-pi.mjs"),
     environment: {
       HOME: home,
       USERPROFILE: home,
-      APPDATA: path31.join(root, "appdata"),
-      LOCALAPPDATA: path31.join(root, "localappdata"),
-      XDG_CONFIG_HOME: path31.join(root, "xdg-config"),
-      XDG_DATA_HOME: path31.join(root, "xdg-data"),
-      XDG_CACHE_HOME: path31.join(root, "xdg-cache"),
+      APPDATA: path32.join(root, "appdata"),
+      LOCALAPPDATA: path32.join(root, "localappdata"),
+      XDG_CONFIG_HOME: path32.join(root, "xdg-config"),
+      XDG_DATA_HOME: path32.join(root, "xdg-data"),
+      XDG_CACHE_HOME: path32.join(root, "xdg-cache"),
       TEMP: temporary,
       TMP: temporary,
       TMPDIR: temporary,
-      npm_config_cache: path31.join(root, "npm-cache"),
+      npm_config_cache: path32.join(root, "npm-cache"),
       NPM_CONFIG_IGNORE_SCRIPTS: "true",
       NPM_CONFIG_UPDATE_NOTIFIER: "false",
       PI_CODING_AGENT_DIR: codingAgentDir,
@@ -5745,15 +5929,15 @@ function targetPaths(targetDir, engramBin, piExecutable) {
 }
 function userPaths(engramBin, piExecutable) {
   const home = os4.homedir();
-  const codingAgentDir = process.env.PI_CODING_AGENT_DIR ?? path31.join(home, ".pi", "agent");
+  const codingAgentDir = process.env.PI_CODING_AGENT_DIR ?? path32.join(home, ".pi", "agent");
   return {
     codingAgentDir,
-    receiptPath: path31.join(dataDir(), "pi-receipt.json"),
-    packageRunner: path31.join(codingAgentDir, "npm", "node_modules", "jorgex-pi", "bin", "jorgex-pi.mjs"),
+    receiptPath: path32.join(dataDir(), "pi-receipt.json"),
+    packageRunner: path32.join(codingAgentDir, "npm", "node_modules", "jorgex-pi", "bin", "jorgex-pi.mjs"),
     environment: {
       HOME: home,
-      XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME ?? path31.join(home, ".config"),
-      XDG_CACHE_HOME: process.env.XDG_CACHE_HOME ?? path31.join(home, ".cache"),
+      XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME ?? path32.join(home, ".config"),
+      XDG_CACHE_HOME: process.env.XDG_CACHE_HOME ?? path32.join(home, ".cache"),
       TMPDIR: os4.tmpdir(),
       NPM_CONFIG_IGNORE_SCRIPTS: "true",
       NPM_CONFIG_UPDATE_NOTIFIER: "false",
@@ -5781,7 +5965,7 @@ function runPiRuntime(input, deps) {
     return { kind: "blocked", reason: "tarball-integrity" };
   }
   const paths = input.targetDir === void 0 ? userPaths(input.engramBin, input.detected.executable) : targetPaths(input.targetDir, input.engramBin, input.detected.executable);
-  const settingsJson = deps.readSettings(path31.join(paths.codingAgentDir, "settings.json"));
+  const settingsJson = deps.readSettings(path32.join(paths.codingAgentDir, "settings.json"));
   const receiptJson = deps.readReceipt(paths.receiptPath);
   const lifecycleInput = {
     candidate: PI_RUNTIME_CANDIDATE,
@@ -5839,19 +6023,19 @@ function runPiRuntime(input, deps) {
   return result;
 }
 function readJsonFile(file) {
-  return JSON.parse(fs23.readFileSync(file, "utf8"));
+  return JSON.parse(fs24.readFileSync(file, "utf8"));
 }
 function packageVersionFromExecutable(executable) {
   let current;
   try {
-    current = path31.dirname(fs23.realpathSync(executable));
+    current = path32.dirname(fs24.realpathSync(executable));
   } catch {
     return null;
   }
   for (let depth = 0; depth < 8; depth++) {
     const manifests = [
-      path31.join(current, "package.json"),
-      path31.join(current, "node_modules", "@earendil-works", "pi-coding-agent", "package.json")
+      path32.join(current, "package.json"),
+      path32.join(current, "node_modules", "@earendil-works", "pi-coding-agent", "package.json")
     ];
     for (const manifest of manifests) {
       try {
@@ -5862,7 +6046,7 @@ function packageVersionFromExecutable(executable) {
       } catch {
       }
     }
-    const parent = path31.dirname(current);
+    const parent = path32.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -5877,35 +6061,35 @@ function detectPiRuntime() {
     installed: executable !== null,
     executable,
     version: executable === null ? null : packageVersionFromExecutable(executable),
-    codingAgentDir: process.env.PI_CODING_AGENT_DIR ?? path31.join(home, ".pi", "agent")
+    codingAgentDir: process.env.PI_CODING_AGENT_DIR ?? path32.join(home, ".pi", "agent")
   };
 }
 function hasManagedPiRuntime(targetDir) {
-  const receipt = targetDir === void 0 ? path31.join(dataDir(), "pi-receipt.json") : path31.join(path31.resolve(targetDir), "state", "pi-receipt.json");
-  return fs23.statSync(receipt, { throwIfNoEntry: false })?.isFile() === true;
+  const receipt = targetDir === void 0 ? path32.join(dataDir(), "pi-receipt.json") : path32.join(path32.resolve(targetDir), "state", "pi-receipt.json");
+  return fs24.statSync(receipt, { throwIfNoEntry: false })?.isFile() === true;
 }
 function resolvePiEngramBin(targetDir) {
   if (targetDir === void 0) return detectEngram();
-  const candidate = path31.join(path31.resolve(targetDir), "bin", process.platform === "win32" ? "engram.exe" : "engram");
-  return fs23.statSync(candidate, { throwIfNoEntry: false })?.isFile() ? candidate : null;
+  const candidate = path32.join(path32.resolve(targetDir), "bin", process.platform === "win32" ? "engram.exe" : "engram");
+  return fs24.statSync(candidate, { throwIfNoEntry: false })?.isFile() ? candidate : null;
 }
 function readOptional(file, fallback) {
   try {
-    return fs23.readFileSync(file, "utf8");
+    return fs24.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return fallback;
     throw error;
   }
 }
 function hashPiTarball(file) {
-  const descriptor = fs23.openSync(file, "r");
+  const descriptor = fs24.openSync(file, "r");
   const sha2562 = createHash2("sha256");
   const sha512 = createHash2("sha512");
   const buffer = Buffer.allocUnsafe(1024 * 1024);
   let bytes = 0;
   try {
     while (true) {
-      const read = fs23.readSync(descriptor, buffer, 0, buffer.length, null);
+      const read = fs24.readSync(descriptor, buffer, 0, buffer.length, null);
       if (read === 0) break;
       bytes += read;
       const chunk = buffer.subarray(0, read);
@@ -5913,27 +6097,27 @@ function hashPiTarball(file) {
       sha512.update(chunk);
     }
   } finally {
-    fs23.closeSync(descriptor);
+    fs24.closeSync(descriptor);
   }
   return { path: file, bytes, sha256: sha2562.digest("hex"), sha512: sha512.digest("hex") };
 }
 async function acquirePiTarball(destination) {
-  const existing = fs23.statSync(destination, { throwIfNoEntry: false });
+  const existing = fs24.statSync(destination, { throwIfNoEntry: false });
   if (existing?.isFile()) {
     const observed = hashPiTarball(destination);
     if (observed.bytes === PI_RUNTIME_CANDIDATE.tarball.bytes && observed.sha256 === PI_RUNTIME_CANDIDATE.tarball.sha256 && observed.sha512 === PI_RUNTIME_CANDIDATE.tarball.sha512) {
       return observed;
     }
-    fs23.rmSync(destination, { force: true });
+    fs24.rmSync(destination, { force: true });
   }
-  fs23.mkdirSync(path31.dirname(destination), { recursive: true });
+  fs24.mkdirSync(path32.dirname(destination), { recursive: true });
   const partial = `${destination}.partial-${process.pid}`;
   const response = await fetch(`https://registry.npmjs.org/jorgex-pi/-/jorgex-pi-${PI_RUNTIME_CANDIDATE.package.version}.tgz`, {
     redirect: "error",
     headers: { accept: "application/octet-stream" }
   });
   if (!response.ok || response.body === null) throw new Error(`No se pudo descargar jorgex-pi@${PI_RUNTIME_CANDIDATE.package.version} (${response.status}).`);
-  const descriptor = fs23.openSync(partial, "wx", 384);
+  const descriptor = fs24.openSync(partial, "wx", 384);
   let bytes = 0;
   try {
     for await (const chunk of response.body) {
@@ -5941,15 +6125,15 @@ async function acquirePiTarball(destination) {
       bytes += buffer.length;
       if (bytes > PI_RUNTIME_CANDIDATE.tarball.bytes) throw new Error("El tarball de jorgex-pi excede el tama\xF1o fijado.");
       let offset = 0;
-      while (offset < buffer.length) offset += fs23.writeSync(descriptor, buffer, offset);
+      while (offset < buffer.length) offset += fs24.writeSync(descriptor, buffer, offset);
     }
   } catch (error) {
-    fs23.closeSync(descriptor);
-    fs23.rmSync(partial, { force: true });
+    fs24.closeSync(descriptor);
+    fs24.rmSync(partial, { force: true });
     throw error;
   }
-  fs23.closeSync(descriptor);
-  fs23.renameSync(partial, destination);
+  fs24.closeSync(descriptor);
+  fs24.renameSync(partial, destination);
   return hashPiTarball(destination);
 }
 function runProcess(invocation) {
@@ -5999,7 +6183,7 @@ async function runPiRuntimeSystem(input) {
         remedy: "Instala Engram o configura un ENGRAM_BIN absoluto antes de reintentar."
       };
     }
-    const destination = input.targetDir === void 0 ? path31.join(dataDir(), "packages", `jorgex-pi-${PI_RUNTIME_CANDIDATE.package.version}.tgz`) : path31.join(path31.resolve(input.targetDir), "downloads", `jorgex-pi-${PI_RUNTIME_CANDIDATE.package.version}.tgz`);
+    const destination = input.targetDir === void 0 ? path32.join(dataDir(), "packages", `jorgex-pi-${PI_RUNTIME_CANDIDATE.package.version}.tgz`) : path32.join(path32.resolve(input.targetDir), "downloads", `jorgex-pi-${PI_RUNTIME_CANDIDATE.package.version}.tgz`);
     let artifact;
     try {
       artifact = await acquirePiTarball(destination);
@@ -6019,18 +6203,18 @@ async function runPiRuntimeSystem(input) {
     }, {
       download: () => artifact,
       backupSettings: () => createBackup(
-        [path31.join(paths.codingAgentDir, "settings.json")],
+        [path32.join(paths.codingAgentDir, "settings.json")],
         "pi-package-install",
-        input.targetDir === void 0 ? void 0 : path31.join(path31.resolve(input.targetDir), "backups")
+        input.targetDir === void 0 ? void 0 : path32.join(path32.resolve(input.targetDir), "backups")
       ),
       run: runProcess,
-      readSettings: () => readOptional(path31.join(paths.codingAgentDir, "settings.json"), '{"packages":[]}'),
-      rewriteSettings: (content) => writeText(path31.join(paths.codingAgentDir, "settings.json"), `${content}
+      readSettings: () => readOptional(path32.join(paths.codingAgentDir, "settings.json"), '{"packages":[]}'),
+      rewriteSettings: (content) => writeText(path32.join(paths.codingAgentDir, "settings.json"), `${content}
 `),
       writeReceiptAtomic: (content) => writeText(paths.receiptPath, content)
     });
   }
-  const packageRoot = path31.dirname(path31.dirname(paths.packageRunner));
+  const packageRoot = path32.dirname(path32.dirname(paths.packageRunner));
   const writeReceipt = (receipt) => {
     writeText(paths.receiptPath, `${JSON.stringify(receipt, null, 2)}
 `);
@@ -6048,13 +6232,13 @@ async function runPiRuntimeSystem(input) {
       value,
       {
         backupSettings: () => createBackup(
-          [path31.join(paths.codingAgentDir, "settings.json")],
+          [path32.join(paths.codingAgentDir, "settings.json")],
           "pi-package-uninstall",
-          input.targetDir === void 0 ? void 0 : path31.join(path31.resolve(input.targetDir), "backups")
+          input.targetDir === void 0 ? void 0 : path32.join(path32.resolve(input.targetDir), "backups")
         ),
         run: runProcess,
-        isPackageAbsent: () => !fs23.existsSync(packageRoot),
-        deleteReceipt: () => fs23.rmSync(paths.receiptPath, { force: true })
+        isPackageAbsent: () => !fs24.existsSync(packageRoot),
+        deleteReceipt: () => fs24.rmSync(paths.receiptPath, { force: true })
       }
     )
   };
@@ -6126,12 +6310,24 @@ async function runManagedPiSystem(input) {
       remedy: `Pi ${input.detected.version} no est\xE1 entre las versiones verificadas (${supportedVersions.join(", ")}). Actualiza Stack a una versi\xF3n compatible antes de gestionar Pi.`
     };
   }
-  const { devtoolsMcpEnabled: explicitDevtools, playwrightCliEnabled: explicitPlaywright, ...runtimeInput } = input;
+  const {
+    devtoolsMcpEnabled: explicitDevtools,
+    playwrightCliEnabled: explicitPlaywright,
+    writingStyle: suppliedStyle,
+    writingStyleMode,
+    ...runtimeInput
+  } = input;
+  const readsStyle = input.operation !== "uninstall" && input.operation !== "models";
+  const preparedStyle = readsStyle && suppliedStyle === void 0 ? prepareWritingStyle(resolveWritingStyleFile({ targetDir: input.targetDir }), { rootDir: input.targetDir }) : void 0;
+  const style = readsStyle ? suppliedStyle ?? preparedStyle : void 0;
+  const mode = readsStyle ? writingStyleMode ?? (input.targetDir === void 0 ? loadInstallModePreference().mode : "human") : "human";
+  const writingStyle = style && mode === "programmatic" ? { ...style, content: null } : style;
   const devtoolsMcpEnabled = explicitDevtools ?? (input.targetDir === void 0 && loadDevtoolsMcpPreference(devtoolsMcpPreferenceFile(), "pi"));
   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 = {
+    writingStyle,
     targetDir: input.targetDir,
     packageSource: PI_RUNTIME_CANDIDATE.package.source,
     engramBin: input.engramBin,
@@ -6141,6 +6337,7 @@ async function runManagedPiSystem(input) {
     devtoolsMcpEnabled,
     pnpmBin: devtoolsMcpEnabled && input.operation !== "uninstall" ? resolvePnpmBin() : null
   };
+  if (preparedStyle !== void 0 && input.operation !== "doctor") applyWritingStyle(preparedStyle);
   const result = await runManagedPiOperation(input.operation, {
     async runPackage(operation) {
       return managedPackageResult(await runPiRuntimeSystem({ ...runtimeInput, operation }));
@@ -6174,7 +6371,7 @@ async function runManagedPiSystem(input) {
 }
 
 // src/lib/quality-runner.ts
-import path32 from "path";
+import path33 from "path";
 import { spawn, spawnSync as spawnSync2 } from "child_process";
 function normalizeLimit(value, name) {
   if (value === void 0) return void 0;
@@ -6306,7 +6503,7 @@ function killProcessTree(child) {
   if (pid === void 0) return;
   if (process.platform === "win32") {
     const systemRoot = process.env.SystemRoot ?? process.env.WINDIR ?? "C:\\Windows";
-    const taskkill = path32.join(systemRoot, "System32", "taskkill.exe");
+    const taskkill = path33.join(systemRoot, "System32", "taskkill.exe");
     const result = spawnSync2(taskkill, ["/pid", String(pid), "/t", "/f"], {
       shell: false,
       stdio: "ignore",
@@ -6552,9 +6749,9 @@ async function runQualityPlan(input) {
 }
 
 // src/lib/engram-install.ts
-import fs24 from "fs";
+import fs25 from "fs";
 import os5 from "os";
-import path33 from "path";
+import path34 from "path";
 import { execFileSync as execFileSync7 } from "child_process";
 import { createHash as createHash3 } from "crypto";
 
@@ -6599,15 +6796,15 @@ var engram_release_default = {
 async function installMissingEngram(options = {}) {
   const platform = options.platform ?? process.platform;
   const homeDir = options.homeDir ?? os5.homedir();
-  if (!path33.isAbsolute(homeDir)) return { ok: false, reason: "El directorio personal debe ser absoluto." };
+  if (!path34.isAbsolute(homeDir)) return { ok: false, reason: "El directorio personal debe ser absoluto." };
   const binaryName = platform === "win32" ? "engram.exe" : "engram";
-  const bin = path33.join(homeDir, ".local", "bin", binaryName);
+  const bin = path34.join(homeDir, ".local", "bin", binaryName);
   let staging;
   try {
-    const existing = fs24.lstatSync(bin, { throwIfNoEntry: false });
+    const existing = fs25.lstatSync(bin, { throwIfNoEntry: false });
     if (existing) {
-      if (!fs24.statSync(bin).isFile()) throw new Error(`El destino Engram no es un archivo: ${bin}`);
-      fs24.accessSync(bin, platform === "win32" ? fs24.constants.F_OK : fs24.constants.X_OK);
+      if (!fs25.statSync(bin).isFile()) throw new Error(`El destino Engram no es un archivo: ${bin}`);
+      fs25.accessSync(bin, platform === "win32" ? fs25.constants.F_OK : fs25.constants.X_OK);
       return { ok: true, bin };
     }
     const key = `${platform === "win32" ? "windows" : platform}_${options.arch ?? process.arch}`;
@@ -6636,24 +6833,24 @@ async function installMissingEngram(options = {}) {
     if (size !== asset.size || createHash3("sha256").update(archive).digest("hex") !== asset.sha256) {
       throw new Error("Engram: tama\xF1o o hash SHA-256 no coincide con el artefacto aprobado.");
     }
-    fs24.mkdirSync(path33.dirname(bin), { recursive: true });
-    staging = fs24.mkdtempSync(path33.join(path33.dirname(bin), ".engram-install-"));
-    const archivePath = path33.join(staging, asset.name);
-    fs24.writeFileSync(archivePath, archive, { flag: "wx", mode: 384 });
+    fs25.mkdirSync(path34.dirname(bin), { recursive: true });
+    staging = fs25.mkdtempSync(path34.join(path34.dirname(bin), ".engram-install-"));
+    const archivePath = path34.join(staging, asset.name);
+    fs25.writeFileSync(archivePath, archive, { flag: "wx", mode: 384 });
     const binary = execFileSync7(resolveTarBin(), ["-xOf", archivePath, binaryName], {
       maxBuffer: 64 * 1024 * 1024,
       timeout: 3e4,
       stdio: ["ignore", "pipe", "pipe"]
     });
     if (binary.length === 0) throw new Error("El artefacto Engram no contiene un binario v\xE1lido.");
-    const stagedBin = path33.join(staging, binaryName);
-    fs24.writeFileSync(stagedBin, binary, { flag: "wx", mode: 493 });
-    fs24.linkSync(stagedBin, bin);
+    const stagedBin = path34.join(staging, binaryName);
+    fs25.writeFileSync(stagedBin, binary, { flag: "wx", mode: 493 });
+    fs25.linkSync(stagedBin, bin);
     return { ok: true, bin };
   } catch (error) {
     return { ok: false, reason: error instanceof Error ? error.message : String(error) };
   } finally {
-    if (staging) fs24.rmSync(staging, { recursive: true, force: true });
+    if (staging) fs25.rmSync(staging, { recursive: true, force: true });
   }
 }
 
@@ -6977,7 +7174,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, playwrightCliEnabled) {
+async function runSelectedPi(operation, targetDir, yes = false, resolvedEngramBin, devtoolsMcpEnabled, writingStyle, modePreference, playwrightCliEnabled) {
   if (targetDir === void 0 && operation !== "models") {
     const preferenceErrors = browserPreferenceErrors();
     if (preferenceErrors.length > 0) {
@@ -6985,6 +7182,13 @@ async function runSelectedPi(operation, targetDir, yes = false, resolvedEngramBi
       return 1;
     }
   }
+  if (operation === "install" || operation === "sync" || operation === "update") {
+    if (writingStyle === void 0) {
+      const prepared = prepareWritingStyle(resolveWritingStyleFile({ targetDir }), { rootDir: targetDir });
+      applyWritingStyle(prepared);
+      writingStyle = prepared;
+    }
+  }
   const detected = detectPiRuntime();
   if (!detected.installed || detected.executable === null) {
     console.error("Pi no detectado. Instala el runtime Pi antes de gestionar jorgex-pi.");
@@ -7016,6 +7220,8 @@ async function runSelectedPi(operation, targetDir, yes = false, resolvedEngramBi
     engramBin = requirement.bin;
   }
   const result = await runManagedPiSystem({
+    writingStyle,
+    writingStyleMode: modePreference?.mode,
     operation,
     targetDir,
     detected: { executable: detected.executable, version: detected.version },
@@ -7032,6 +7238,10 @@ async function runSelectedPi(operation, targetDir, yes = false, resolvedEngramBi
   else p6.log.success(`Pi: ${result.kind}.`);
   return 0;
 }
+function persistSuccessfulGlobalMode(mode, targetDir, dryRun, exitCode) {
+  if (mode === void 0 || targetDir !== void 0 || dryRun || exitCode !== 0) return;
+  saveInstallModePreference(installModePreferenceFile(), mode);
+}
 function printHelp() {
   console.log(`jorgex-stack v${VERSION}
 
@@ -7125,7 +7335,7 @@ Flags disponibles: jorgex-stack --help`
         return;
       }
       try {
-        const plan = JSON.parse(fs25.readFileSync(flags.positional[0], "utf8"));
+        const plan = JSON.parse(fs26.readFileSync(flags.positional[0], "utf8"));
         const result = await runQualityPlan(plan);
         const serialized = serializeQualityReceipt(result.receipt);
         if (flags.receipt === void 0) process.stdout.write(`${serialized}
@@ -7153,6 +7363,7 @@ Flags disponibles: jorgex-stack --help`
       let completed = false;
       p6.intro(`jorgex-stack ${command}${flags.dryRun ? " (dry-run)" : ""}`);
       try {
+        const writingStyle = prepareWritingStyle(resolveWritingStyleFile({ targetDir: flags.targetDir }), { rootDir: flags.targetDir });
         if (flags.targetDir === void 0) {
           const errors = browserPreferenceErrors();
           if (errors.length > 0) {
@@ -7161,7 +7372,7 @@ Flags disponibles: jorgex-stack --help`
             return;
           }
         }
-        const mode = fileRuntimes.length > 0 ? await resolveInstallMode(flags) : void 0;
+        const mode = fileRuntimes.length > 0 || flags.mode !== void 0 || flags.subagentConcurrency !== void 0 ? await resolveInstallMode(flags) : void 0;
         if (mode === null) return;
         const devtoolsMcpSelection = await resolveDevtoolsMcpSelection(command, flags, runtimes);
         if (devtoolsMcpSelection === null) {
@@ -7173,6 +7384,8 @@ Flags disponibles: jorgex-stack --help`
           exitCode = process.exitCode === 1 ? 1 : 0;
           return;
         }
+        p6.log.info(`Estilo de escritura: ${writingStyle.sourcePath}${flags.dryRun ? " (instalaci\xF3n prevista; sin escrituras)" : ""}.`);
+        applyWritingStyle(writingStyle, flags.dryRun);
         if (!await ensureOpenCodeModelsForInstall(command, flags, fileRuntimes)) {
           exitCode = 1;
           return;
@@ -7190,6 +7403,7 @@ Flags disponibles: jorgex-stack --help`
         if (fileRuntimes.length > 0) {
           exitCode = await runInstall({
             runtimes: fileRuntimes,
+            writingStyle,
             targetDir: flags.targetDir,
             dryRun: flags.dryRun,
             yes: flags.yes,
@@ -7206,6 +7420,7 @@ Flags disponibles: jorgex-stack --help`
             p6.log.info("Playwright CLI: instalaci\xF3n global y navegador previstos (dry-run; no se ejecutan).");
           } else {
             exitCode = await runInstall({
+              writingStyle,
               runtimes: [],
               targetDir: flags.targetDir,
               dryRun: false,
@@ -7219,15 +7434,21 @@ Flags disponibles: jorgex-stack --help`
         }
         if (runtimes.includes("pi") && piCanRun) {
           if (flags.dryRun) p6.log.info(`Pi: ${command} previsto; dry-run no ejecuta subprocess ni escribe receipt.`);
-          else exitCode = Math.max(exitCode, await runSelectedPi(
-            command,
-            flags.targetDir,
-            flags.yes,
-            flags.targetDir === void 0 ? engramBin : void 0,
-            devtoolsMcpSelection.pi,
-            flags.targetDir === void 0 && exitCode === 0 && resolvePlaywrightToolPlan(playwrightToolConsent).actions.length > 0 ? playwrightToolConsent.runtimeSelection?.pi : void 0
-          ));
+          else {
+            const piExitCode = await runSelectedPi(
+              command,
+              flags.targetDir,
+              flags.yes,
+              flags.targetDir === void 0 ? engramBin : void 0,
+              devtoolsMcpSelection.pi,
+              writingStyle,
+              mode,
+              flags.targetDir === void 0 && exitCode === 0 && resolvePlaywrightToolPlan(playwrightToolConsent).actions.length > 0 ? playwrightToolConsent.runtimeSelection?.pi : void 0
+            );
+            exitCode = Math.max(exitCode, piExitCode);
+          }
         }
+        if (runtimes.includes("pi")) persistSuccessfulGlobalMode(mode, flags.targetDir, flags.dryRun, exitCode);
         completed = true;
       } catch (error) {
         p6.log.error(error instanceof Error ? error.message : String(error));
@@ -7264,10 +7485,15 @@ Flags disponibles: jorgex-stack --help`
       return;
     }
     case "doctor": {
-      const fileDoctorSelected = flags.agents.length === 0 || flags.agents.some(isFileManagedRuntime);
-      let exitCode = fileDoctorSelected ? await runDoctor() : 0;
+      const mode = flags.mode !== void 0 || flags.subagentConcurrency !== void 0 ? await resolveInstallMode(flags) : void 0;
+      if (mode === null) return;
       const piSelected = flags.agents.includes("pi") || flags.agents.length === 0 && detectPiRuntime().installed && hasManagedPiRuntime(flags.targetDir);
-      if (piSelected) exitCode = Math.max(exitCode, await runSelectedPi("doctor", flags.targetDir));
+      const doctorRuntimes = flags.agents.length > 0 ? flags.agents : flags.targetDir === void 0 ? [
+        ...Object.values(ADAPTERS).filter((adapter) => adapter.detect().installed).map((adapter) => adapter.id),
+        ...piSelected ? ["pi"] : []
+      ] : [...Object.keys(ADAPTERS), ...piSelected ? ["pi"] : []];
+      let exitCode = await runDoctor({ targetDir: flags.targetDir, runtimes: doctorRuntimes, mode });
+      if (piSelected) exitCode = Math.max(exitCode, await runSelectedPi("doctor", flags.targetDir, false, void 0, void 0, void 0, mode));
       process.exitCode = exitCode;
       return;
     }
@@ -7283,20 +7509,28 @@ Flags disponibles: jorgex-stack --help`
       const runtimes = await resolveRuntimes(flags);
       if (runtimes === null) return;
       const fileRuntimes = runtimes.filter(isFileManagedRuntime);
-      if (fileRuntimes.length === 0 && runtimes.includes("pi")) {
-        process.exitCode = await runSelectedPi("update", flags.targetDir);
-        return;
-      }
       const preferenceFile = installModePreferenceFile();
       const explicitMode = flags.mode !== void 0 || flags.subagentConcurrency !== void 0;
       const hasSavedMode = hasInstallModePreference(preferenceFile);
       const canResolveMode = flags.targetDir !== void 0 || explicitMode || hasSavedMode;
-      const mode = fileRuntimes.length > 0 && canResolveMode ? await resolveInstallMode(flags, false) : DEFAULT_INSTALL_MODE_PREFERENCE;
+      const mode = canResolveMode ? await resolveInstallMode(flags, false) : DEFAULT_INSTALL_MODE_PREFERENCE;
       if (mode === null) return;
+      const writingStyle = prepareWritingStyle(
+        resolveWritingStyleFile({ targetDir: flags.targetDir }),
+        { rootDir: flags.targetDir }
+      );
+      applyWritingStyle(writingStyle, flags.dryRun);
+      if (fileRuntimes.length === 0 && runtimes.includes("pi")) {
+        const piExitCode = await runSelectedPi("update", flags.targetDir, false, void 0, void 0, writingStyle, mode);
+        process.exitCode = piExitCode;
+        persistSuccessfulGlobalMode(mode, flags.targetDir, flags.dryRun, piExitCode);
+        return;
+      }
       const canSync = fileRuntimes.length === 0 || canResolveMode;
       if (fileRuntimes.length > 0 && canSync) {
         const code = await runInstall({
           runtimes: fileRuntimes,
+          writingStyle,
           targetDir: flags.targetDir,
           dryRun: flags.dryRun,
           yes: true,
@@ -7317,7 +7551,7 @@ Flags disponibles: jorgex-stack --help`
       );
       process.exitCode = result.exitCode;
       if (result.exitCode === 0 && runtimes.includes("pi")) {
-        process.exitCode = Math.max(process.exitCode, await runSelectedPi("update", flags.targetDir));
+        process.exitCode = Math.max(process.exitCode, await runSelectedPi("update", flags.targetDir, false, void 0, void 0, writingStyle, mode));
       }
       if (result.syncRequired && fileRuntimes.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.");
@@ -7326,6 +7560,7 @@ Flags disponibles: jorgex-stack --help`
         if (!p6.isCancel(apply) && apply) {
           process.exitCode = await runInstall({
             runtimes: fileRuntimes,
+            writingStyle,
             targetDir: flags.targetDir,
             dryRun: false,
             yes: false,
@@ -7337,6 +7572,9 @@ Flags disponibles: jorgex-stack --help`
       } else if (result.exitCode === 0 && result.syncRequired && fileRuntimes.length > 0 && canSync && (flags.yes || !process.stdout.isTTY)) {
         console.log("Skills/stack actualizados. Ejecuta jorgex-stack sync para aplicarlos a los runtimes.");
       }
+      if (runtimes.includes("pi")) {
+        persistSuccessfulGlobalMode(mode, flags.targetDir, flags.dryRun, process.exitCode ?? result.exitCode);
+      }
       return;
     }
     case "models": {