jorgex-stack 1.0.0

package/dist/cli.js

@@ -0,0 +1,2894 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as p6 from "@clack/prompts";
+
+// src/install.ts
+import fs11 from "fs";
+import path17 from "path";
+import * as p from "@clack/prompts";
+
+// src/adapters/opencode.ts
+import path7 from "path";
+import fs3 from "fs";
+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);
+  });
+}
+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 path4 from "path";
+import { existsSync as existsSync2 } from "fs";
+
+// src/lib/paths.ts
+import os from "os";
+import path2 from "path";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+var HOME = os.homedir();
+function stackRoot() {
+  let dir = path2.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 6; i++) {
+    const candidate = path2.join(dir, "stack");
+    if (existsSync(path2.join(candidate, "system-prompt", "AGENTS.md"))) return candidate;
+    dir = path2.dirname(dir);
+  }
+  throw new Error("No se encontr\xF3 stack/ relativa al CLI \u2014 instalaci\xF3n rota.");
+}
+function dataDir() {
+  return path2.join(HOME, ".jorgex-stack");
+}
+function samePath(a, b) {
+  const resolvedA = path2.resolve(a);
+  const resolvedB = path2.resolve(b);
+  if (process.platform === "win32") return resolvedA.toLowerCase() === resolvedB.toLowerCase();
+  return resolvedA === resolvedB;
+}
+
+// src/lib/fsx.ts
+import fs2 from "fs";
+import path3 from "path";
+function readTextIfExists(file) {
+  try {
+    return fs2.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+function ensureDir(dir) {
+  fs2.mkdirSync(dir, { recursive: true });
+}
+var tmpCounter = 0;
+function tmpPath(target) {
+  return path3.join(path3.dirname(target), `.jorgex-${process.pid}-${tmpCounter++}.tmp`);
+}
+function renameInto(tmp, target) {
+  try {
+    fs2.renameSync(tmp, target);
+  } catch (err) {
+    fs2.rmSync(tmp, { force: true });
+    throw err;
+  }
+}
+function writeText(file, content) {
+  ensureDir(path3.dirname(file));
+  const tmp = tmpPath(file);
+  fs2.writeFileSync(tmp, content, "utf8");
+  renameInto(tmp, file);
+}
+function copyFile(source, target) {
+  ensureDir(path3.dirname(target));
+  const tmp = tmpPath(target);
+  fs2.copyFileSync(source, tmp);
+  renameInto(tmp, target);
+}
+function isContainedIn(child, root) {
+  const rel = path3.relative(path3.resolve(root), path3.resolve(child));
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${path3.sep}`) && !path3.isAbsolute(rel);
+}
+function pruneEmptyDirs(file, root) {
+  let dir = path3.dirname(file);
+  while (dir.startsWith(root) && dir !== root) {
+    try {
+      if (fs2.readdirSync(dir).length > 0) return;
+      fs2.rmdirSync(dir);
+    } catch {
+      return;
+    }
+    dir = path3.dirname(dir);
+  }
+}
+function sameFileContent(a, b) {
+  try {
+    const bufA = fs2.readFileSync(a);
+    const bufB = fs2.readFileSync(b);
+    return bufA.equals(bufB);
+  } catch {
+    return false;
+  }
+}
+function listFilesRecursive(dir) {
+  const out = [];
+  if (!fs2.existsSync(dir)) return out;
+  const walk = (d) => {
+    for (const entry of fs2.readdirSync(d, { withFileTypes: true })) {
+      const p7 = path3.join(d, entry.name);
+      if (entry.isDirectory()) walk(p7);
+      else out.push(p7);
+    }
+  };
+  walk(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 = {
+  opencode: {
+    strong: { model: "openai/gpt-5.4", variant: "high" },
+    standard: { model: "openai/gpt-5.4-mini", variant: "high" },
+    cheap: { model: "minimax/MiniMax-M3" }
+  },
+  "claude-code": {
+    strong: { model: "fable" },
+    standard: { model: "sonnet" },
+    cheap: { model: "haiku" }
+  },
+  // Codex: "default" = no fijar modelo (usa el del CLI, que OpenAI actualiza
+  // solo — D6); variant → model_reasoning_effort.
+  codex: {
+    strong: { model: "default", variant: "high" },
+    standard: { model: "default", variant: "medium" },
+    cheap: { model: "default", variant: "low" }
+  }
+};
+function modelMapFile() {
+  return path4.join(dataDir(), "model-map.json");
+}
+function loadModelMap() {
+  const raw = readTextIfExists(modelMapFile());
+  if (raw === null) return DEFAULT_MODEL_MAP;
+  let fromDisk;
+  try {
+    fromDisk = JSON.parse(raw);
+  } catch {
+    return DEFAULT_MODEL_MAP;
+  }
+  const merged = {};
+  for (const id of Object.keys(DEFAULT_MODEL_MAP)) {
+    merged[id] = { ...DEFAULT_MODEL_MAP[id], ...fromDisk[id] ?? {} };
+  }
+  return merged;
+}
+function ensureModelMapFile() {
+  const file = modelMapFile();
+  if (!existsSync2(file)) {
+    writeText(file, JSON.stringify(DEFAULT_MODEL_MAP, null, 2) + "\n");
+  }
+  return file;
+}
+
+// src/lib/detect.ts
+import path5 from "path";
+import { existsSync as existsSync3, statSync } from "fs";
+import { execFileSync, execSync } from "child_process";
+function lookPath(cmd) {
+  const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ".ps1", ""] : [""];
+  for (const dir of (process.env.PATH ?? "").split(path5.delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      const candidate = path5.join(dir, cmd + ext);
+      if (statSync(candidate, { throwIfNoEntry: false })?.isFile()) return candidate;
+    }
+  }
+  return null;
+}
+function runDetectedBin(bin, args, timeoutMs) {
+  try {
+    if (process.platform === "win32" && /\.(cmd|bat)$/i.test(bin)) {
+      if (/[&|<>^%!"]/.test(bin)) return null;
+      return execSync(`"${bin}" ${args.join(" ")}`, {
+        encoding: "utf8",
+        timeout: timeoutMs,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    }
+    return execFileSync(bin, args, { encoding: "utf8", timeout: timeoutMs, stdio: ["ignore", "pipe", "pipe"] });
+  } catch {
+    return null;
+  }
+}
+function detectOpenCode() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR ?? path5.join(HOME, ".config", "opencode");
+  const binPath = lookPath("opencode");
+  return {
+    id: "opencode",
+    name: "OpenCode",
+    installed: binPath !== null || existsSync3(configDir),
+    binPath,
+    configDir
+  };
+}
+function detectClaudeCode() {
+  const configDir = path5.join(HOME, ".claude");
+  const binPath = lookPath("claude");
+  return {
+    id: "claude-code",
+    name: "Claude Code",
+    installed: binPath !== null || existsSync3(configDir),
+    binPath,
+    configDir
+  };
+}
+function detectCodex() {
+  const configDir = process.env.CODEX_HOME ?? path5.join(HOME, ".codex");
+  const binPath = lookPath("codex");
+  return {
+    id: "codex",
+    name: "Codex CLI",
+    installed: binPath !== null || existsSync3(configDir),
+    binPath,
+    configDir
+  };
+}
+function detectEngram() {
+  const fromEnv = process.env.ENGRAM_BIN;
+  if (fromEnv && existsSync3(fromEnv)) return fromEnv;
+  const onPath = lookPath("engram");
+  if (onPath) return onPath;
+  const candidates = [
+    path5.join(HOME, "go", "bin", "engram.exe"),
+    path5.join(HOME, "go", "bin", "engram"),
+    path5.join(HOME, ".local", "bin", "engram.exe"),
+    path5.join(HOME, ".local", "bin", "engram")
+  ];
+  for (const c of candidates) if (existsSync3(c)) return c;
+  return null;
+}
+
+// src/lib/filemerge.ts
+function markers(name) {
+  return { open: `<!-- jorgex:${name} -->`, close: `<!-- /jorgex:${name} -->` };
+}
+function repairOrphanMarkers(existing, name) {
+  const { open, close } = markers(name);
+  const count = (marker) => existing.split(marker).length - 1;
+  const opens = count(open);
+  const closes = count(close);
+  if (opens === 0 && closes === 0) return existing;
+  const onOwnLine = (marker) => existing.split("\n").some((line) => line.trim() === marker);
+  const healthy = opens === 1 && closes === 1 && existing.indexOf(close) > existing.indexOf(open) && onOwnLine(open) && onOwnLine(close);
+  if (healthy) return existing;
+  return existing.split("\n").map((line) => line.trim() === open || line.trim() === close ? null : line.split(open).join("").split(close).join("")).filter((line) => line !== null).join("\n");
+}
+function upsertMarkdownSection(existing, name, content) {
+  const { open, close } = markers(name);
+  const block = `${open}
+${content.trim()}
+${close}`;
+  if (existing === null || existing.trim() === "") return block + "\n";
+  existing = repairOrphanMarkers(existing, name);
+  const start = existing.indexOf(open);
+  const end = existing.indexOf(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";
+  return existing + sep + block + "\n";
+}
+function removeMarkdownSection(existing, name) {
+  existing = repairOrphanMarkers(existing, name);
+  const { open, close } = markers(name);
+  const start = existing.indexOf(open);
+  const end = existing.indexOf(close);
+  if (start === -1 || end === -1 || end < start) return existing;
+  const before = existing.slice(0, start).replace(/\n+$/, "\n");
+  const after = existing.slice(end + close.length).replace(/^\n+/, "\n");
+  const joined = before + after;
+  return joined.trim() === "" ? "" : joined.replace(/^\n+/, "");
+}
+function stripLeadingHtmlComments(md) {
+  let out = md.trimStart();
+  while (out.startsWith("<!--")) {
+    const end = out.indexOf("-->");
+    if (end === -1) break;
+    out = out.slice(end + 3).trimStart();
+  }
+  return out;
+}
+function upsertJson(existing, mutate) {
+  let root = {};
+  if (existing !== null && existing.trim() !== "") {
+    root = JSON.parse(existing);
+  }
+  mutate(root);
+  return JSON.stringify(root, null, 2) + "\n";
+}
+function headerName(line) {
+  const match = /^\s*\[\s*([^\]]+?)\s*\]\s*(#.*)?$/.exec(line);
+  if (!match) return null;
+  return match[1].split(".").map((part) => part.trim().replace(/^["']|["']$/g, "")).join(".");
+}
+function multilineStringMask(lines) {
+  const mask = [];
+  let inside = null;
+  for (const line of lines) {
+    if (inside !== null) {
+      mask.push(true);
+      if (line.includes(inside)) inside = null;
+      continue;
+    }
+    mask.push(false);
+    for (const delim of ["'''", '"""']) {
+      if ((line.split(delim).length - 1) % 2 === 1) {
+        inside = delim;
+        break;
+      }
+    }
+  }
+  return mask;
+}
+function findTomlSection(lines, section) {
+  const mask = multilineStringMask(lines);
+  const start = lines.findIndex((line, i) => !mask[i] && headerName(line) === section);
+  if (start === -1) return null;
+  let end = start + 1;
+  while (end < lines.length && (mask[end] || headerName(lines[end]) === null)) end++;
+  return { start, end };
+}
+function upsertTomlSection(existing, section, body) {
+  const header = `[${section}]`;
+  const block = `${header}
+${body.trim()}
+`;
+  if (existing === null || existing.trim() === "") return block;
+  const lines = existing.split(/\r?\n/);
+  const found = findTomlSection(lines, section);
+  if (found === null) {
+    const sep = existing.endsWith("\n") ? "\n" : "\n\n";
+    return existing + sep + block;
+  }
+  let sectionEnd = found.end;
+  while (sectionEnd > found.start + 1 && lines[sectionEnd - 1].trim() === "") sectionEnd--;
+  const result = [...lines.slice(0, found.start), block.trimEnd(), ...lines.slice(sectionEnd)].join("\n");
+  return result.endsWith("\n") ? result : result + "\n";
+}
+function removeTomlSection(existing, section) {
+  const lines = existing.split(/\r?\n/);
+  const found = findTomlSection(lines, section);
+  if (found === null) return existing;
+  let realStart = found.start;
+  while (realStart > 0 && lines[realStart - 1].trim() === "") realStart--;
+  const result = [...lines.slice(0, realStart), ...lines.slice(found.end)].join("\n");
+  if (result.trim() === "") return "";
+  return result.endsWith("\n") ? result : result + "\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/hooks-format.ts
+import path6 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) => path6.basename(s));
+}
+function plainHookCommands(canonical) {
+  return new Set(
+    Object.values(canonical.hooks).flat().flatMap((entry) => entry.hooks).map((h) => h.command).filter((c) => !c.includes("{{SCRIPTS_DIR}}"))
+  );
+}
+function removeNativeHooks(existing, canonical) {
+  if (existing === null || existing.trim() === "") return existing;
+  const scriptNames = hookScriptNames(canonical);
+  const plainCommands = plainHookCommands(canonical);
+  return upsertJson(existing, (root) => {
+    const hooks = root["hooks"];
+    if (!hooks) return;
+    for (const event of Object.keys(hooks)) {
+      const list = hooks[event];
+      if (!Array.isArray(list)) continue;
+      hooks[event] = list.filter((entry) => {
+        const e = entry;
+        if (!Array.isArray(e?.hooks)) return true;
+        const ours = e.hooks.some((hh) => {
+          const cmd = String(hh?.command ?? "");
+          return scriptNames.some((s) => cmd.includes(s)) || plainCommands.has(cmd);
+        });
+        return !ours;
+      });
+      if (hooks[event].length === 0) delete hooks[event];
+    }
+    if (Object.keys(hooks).length === 0) delete root["hooks"];
+  });
+}
+function upsertNativeHooks(existing, canonical, scriptsDir, mapMatcher = (m) => m) {
+  const scriptsDirForCommand = scriptsDir.replace(/\\/g, "/");
+  return upsertJson(existing, (root) => {
+    const hooks = root["hooks"] ??= {};
+    for (const [event, entries] of Object.entries(canonical.hooks)) {
+      const list = hooks[event] ??= [];
+      for (const entry of entries) {
+        const matcher = entry.matcher !== void 0 ? mapMatcher(entry.matcher) : void 0;
+        const rendered = {
+          ...matcher !== void 0 ? { matcher } : {},
+          hooks: entry.hooks.map((h) => ({
+            type: h.type,
+            command: h.command.replace(/\{\{SCRIPTS_DIR\}\}/g, scriptsDirForCommand),
+            ...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) => path6.basename(s));
+        const plainCommands = entry.hooks.map((h) => h.command).filter((c) => !c.includes("{{SCRIPTS_DIR}}"));
+        const index = list.findIndex((existingEntry) => {
+          const e = existingEntry;
+          if (!Array.isArray(e?.hooks)) return false;
+          return e.hooks.some((hh) => {
+            const cmd = String(hh?.command ?? "");
+            return scriptNames.some((s) => cmd.includes(s)) || plainCommands.includes(cmd);
+          });
+        });
+        if (index >= 0) list[index] = rendered;
+        else list.push(rendered);
+      }
+    }
+  });
+}
+
+// src/adapters/opencode.ts
+function yamlString(value) {
+  return JSON.stringify(value);
+}
+var opencodeAdapter = {
+  id: "opencode",
+  name: "OpenCode",
+  detect: detectOpenCode,
+  injectEngramProtocol() {
+    return false;
+  },
+  paths(configDir) {
+    const isRealConfigDir = samePath(
+      configDir,
+      process.env.OPENCODE_CONFIG_DIR ?? path7.join(HOME, ".config", "opencode")
+    );
+    const agentsHome = isRealConfigDir ? HOME : path7.dirname(configDir);
+    return {
+      systemPromptFile: path7.join(configDir, "AGENTS.md"),
+      agentsDir: path7.join(configDir, "agents"),
+      skillsDir: path7.join(agentsHome, ".agents", "skills"),
+      commandsDir: path7.join(configDir, "commands"),
+      pluginsDir: path7.join(configDir, "plugins"),
+      scriptsDir: path7.join(configDir, "scripts"),
+      outputStylesDir: null,
+      profilesDir: null
+    };
+  },
+  renderAgent(agent, models) {
+    const lines = [`description: ${yamlString(agent.description)}`, `mode: ${agent.mode}`];
+    if (agent.mode === "subagent") {
+      const tierModel = resolveAgentModel(models, agent.name, agent.tier);
+      lines.push(`model: ${tierModel.model}`);
+      if (tierModel.variant) lines.push(`variant: ${tierModel.variant}`);
+      lines.push("permission:");
+      lines.push(`  edit: ${agent.readonly ? "deny" : "allow"}`);
+      if (agent.bash === "none") lines.push("  bash: deny");
+      else if (agent.bash === "git-read") lines.push('  bash:\n    "git diff*": allow\n    "git log*": allow');
+      else lines.push("  bash: allow");
+      if (!agent.spawn) lines.push("  task: deny");
+      lines.push("tools:");
+      lines.push(`  write: ${agent.readonly ? "false" : "true"}`);
+    }
+    return [
+      {
+        file: `${agent.name}.md`,
+        content: `---
+${lines.join("\n")}
+---
+${agent.body}`,
+        kind: "agent"
+      }
+    ];
+  },
+  renderCommand(file, content) {
+    return { file, content: content.replace(/\{\{input\}\}/g, "$ARGUMENTS") };
+  },
+  planHooks(canonical, ctx) {
+    const actions = [];
+    const { scriptsDir } = this.paths(ctx.configDir);
+    const bashEntries = {};
+    for (const [event, entries] of Object.entries(canonical.hooks)) {
+      if (event !== "PostToolUse") {
+        ctx.warnings.push(`opencode: evento de hook '${event}' a\xFAn no soportado por el puente \u2014 omitido.`);
+        continue;
+      }
+      for (const entry of entries) {
+        if (!(entry.matcher ?? "").split("|").some((p7) => p7.trim().toLowerCase() === "bash")) {
+          ctx.warnings.push(`opencode: matcher de hook '${entry.matcher}' no soportado \u2014 omitido.`);
+          continue;
+        }
+        const includes = entry["x-command-includes"] ?? "*";
+        for (const hook of entry.hooks) {
+          const match = /\{\{SCRIPTS_DIR\}\}[/\\]([\w./\\-]+)/.exec(hook.command);
+          if (!match) {
+            ctx.warnings.push(`opencode: hook sin {{SCRIPTS_DIR}} no traducible: ${hook.command}`);
+            continue;
+          }
+          const script = `scripts/${path7.basename(match[1])}`;
+          (bashEntries[includes] ??= []).push(script);
+        }
+      }
+    }
+    const hooksFile = path7.join(ctx.configDir, "hooks.json");
+    const content = upsertJson(readTextIfExists(hooksFile), (root) => {
+      const after = root["tool.execute.after"] ??= {};
+      const bash = after["bash"] ??= {};
+      for (const [includes, scripts] of Object.entries(bashEntries)) {
+        const list = bash[includes] ??= [];
+        for (const s of scripts) if (!list.includes(s)) list.push(s);
+      }
+    });
+    actions.push({ kind: "write", target: hooksFile, content });
+    const scriptsSource = path7.join(ctx.stackDir, "scripts");
+    if (fs3.existsSync(scriptsSource)) {
+      for (const f of fs3.readdirSync(scriptsSource)) {
+        actions.push({ kind: "copy", source: path7.join(scriptsSource, f), target: path7.join(scriptsDir, f) });
+      }
+    }
+    return actions;
+  },
+  planMainConfig(canonical, ctx) {
+    const file = path7.join(ctx.configDir, "opencode.json");
+    const { pluginsDir } = this.paths(ctx.configDir);
+    const content = upsertJson(readTextIfExists(file), (root) => {
+      root["$schema"] ??= "https://opencode.ai/config.json";
+      const defaults = loadCanonicalDefaults(ctx.stackDir)["opencode"];
+      if (defaults?.["permission"] !== void 0 && !("permission" in root)) {
+        root["permission"] = defaults["permission"];
+      }
+      const mcp = root["mcp"] ??= {};
+      for (const [name, server] of Object.entries(canonical.servers)) {
+        if (server.transport === "stdio") {
+          if (server.command === "{{ENGRAM_BIN}}" && ctx.engramBin === null) {
+            ctx.warnings.push(
+              "Engram no detectado: el MCP 'engram' no se registra. Inst\xE1lalo (github.com/Gentleman-Programming/engram) y re-ejecuta sync."
+            );
+            continue;
+          }
+          const command = server.command === "{{ENGRAM_BIN}}" ? ctx.engramBin : server.command;
+          mcp[name] = { type: "local", command: [command, ...server.args ?? []] };
+        } else {
+          const previous = mcp[name];
+          const headers = {};
+          for (const [key, raw] of Object.entries(server.headers ?? {})) {
+            const envRef = /^\$\{(\w+)\}$/.exec(raw);
+            headers[key] = previous?.headers?.[key] || (envRef ? `{env:${envRef[1]}}` : raw);
+          }
+          mcp[name] = {
+            type: "remote",
+            url: server.url,
+            ...Object.keys(headers).length > 0 ? { headers } : {}
+          };
+        }
+      }
+      if (pluginsDir !== null) {
+        const plugin = root["plugin"];
+        if (Array.isArray(plugin)) {
+          const pluginsDirPrefix = pathToFileURL(pluginsDir).href + "/";
+          const kept = plugin.filter((url) => !url.startsWith(pluginsDirPrefix));
+          if (kept.length === 0) delete root["plugin"];
+          else root["plugin"] = kept;
+          if (kept.some((u) => /engram/i.test(u))) {
+            ctx.warnings.push(
+              "OpenCode: hay un plugin de Engram registrado como paquete \u2014 revisa que no conviva con el engram.ts del stack (duplicar\xEDa la integraci\xF3n)."
+            );
+          }
+        }
+      }
+    });
+    return [{ kind: "write", target: file, content }];
+  },
+  planUnmerge(mcp, hooks, ctx) {
+    const actions = [];
+    const { systemPromptFile, pluginsDir } = this.paths(ctx.configDir);
+    const prompt = readTextIfExists(systemPromptFile);
+    if (prompt !== null) {
+      let content = removeMarkdownSection(prompt, "system-prompt");
+      content = removeMarkdownSection(content, "engram-protocol");
+      actions.push({ kind: "write", target: systemPromptFile, content });
+    }
+    const configFile = path7.join(ctx.configDir, "opencode.json");
+    const config = readTextIfExists(configFile);
+    if (config !== null) {
+      const content = upsertJson(config, (root) => {
+        const mcpBlock = root["mcp"];
+        if (mcpBlock) {
+          for (const name of Object.keys(mcp.servers)) delete mcpBlock[name];
+          if (Object.keys(mcpBlock).length === 0) delete root["mcp"];
+        }
+        const plugin = root["plugin"];
+        if (Array.isArray(plugin) && pluginsDir !== null) {
+          const pluginsDirPrefix = pathToFileURL(pluginsDir).href + "/";
+          const kept = plugin.filter((url) => !url.startsWith(pluginsDirPrefix));
+          if (kept.length === 0) delete root["plugin"];
+          else root["plugin"] = kept;
+        }
+      });
+      actions.push({ kind: "write", target: configFile, content });
+    }
+    const hooksFile = path7.join(ctx.configDir, "hooks.json");
+    const hooksJson = readTextIfExists(hooksFile);
+    if (hooksJson !== null) {
+      const ourScripts = hookScriptNames(hooks);
+      const content = upsertJson(hooksJson, (root) => {
+        const after = root["tool.execute.after"];
+        if (!after) return;
+        for (const tool of Object.keys(after)) {
+          const byCommand = after[tool];
+          for (const includes of Object.keys(byCommand)) {
+            byCommand[includes] = byCommand[includes].filter(
+              (script) => !ourScripts.some((s) => script.includes(s))
+            );
+            if (byCommand[includes].length === 0) delete byCommand[includes];
+          }
+          if (Object.keys(byCommand).length === 0) delete after[tool];
+        }
+        if (Object.keys(after).length === 0) delete root["tool.execute.after"];
+      });
+      actions.push({ kind: "write", target: hooksFile, content: content.trim() === "{}" ? "" : content });
+    }
+    return actions;
+  }
+};
+
+// src/adapters/claude-code.ts
+import path8 from "path";
+import fs4 from "fs";
+function yamlString2(value) {
+  return JSON.stringify(value);
+}
+var memoryTools = (names) => names.flatMap((n) => [`mcp__engram__${n}`, `mcp__plugin_engram_engram__${n}`]);
+var MEMORY_TOOLS = memoryTools(["mem_save", "mem_search", "mem_context"]);
+var ENGRAM_AGENT_TOOLS = [
+  "Read",
+  "Skill",
+  ...memoryTools(["mem_context", "mem_search", "mem_get_observation", "mem_timeline", "mem_current_project"])
+];
+function toolsFor(agent) {
+  if (agent.name === "engram") return ENGRAM_AGENT_TOOLS.join(", ");
+  if (!agent.readonly) return null;
+  const tools = ["Read", "Grep", "Glob", "Skill"];
+  if (agent.bash !== "none") tools.push("Bash");
+  tools.push(...MEMORY_TOOLS);
+  return tools.join(", ");
+}
+function hasEngramPlugin(configDir) {
+  if (fs4.existsSync(path8.join(configDir, "plugins", "marketplaces", "engram"))) return true;
+  const registry = readTextIfExists(path8.join(configDir, "plugins", "installed_plugins.json"));
+  if (registry === null) return false;
+  try {
+    const parsed = JSON.parse(registry);
+    const keys = [...Object.keys(parsed), ...Object.keys(parsed["plugins"] ?? {})];
+    return keys.some((k) => k === "engram" || k.startsWith("engram@"));
+  } catch {
+    return false;
+  }
+}
+var claudeCodeAdapter = {
+  id: "claude-code",
+  name: "Claude Code",
+  detect: detectClaudeCode,
+  injectEngramProtocol(ctx) {
+    return !hasEngramPlugin(ctx.configDir);
+  },
+  paths(configDir) {
+    return {
+      systemPromptFile: path8.join(configDir, "CLAUDE.md"),
+      agentsDir: path8.join(configDir, "agents"),
+      skillsDir: path8.join(configDir, "skills"),
+      commandsDir: path8.join(configDir, "commands"),
+      pluginsDir: null,
+      scriptsDir: path8.join(configDir, "scripts"),
+      outputStylesDir: path8.join(configDir, "output-styles"),
+      profilesDir: null
+    };
+  },
+  renderAgent(agent, models) {
+    if (agent.mode === "primary") {
+      const title = agent.name.charAt(0).toUpperCase() + agent.name.slice(1);
+      const style = `---
+name: ${title}
+description: ${yamlString2(agent.description)}
+keep-coding-instructions: true
+---
+${agent.body}`;
+      const skillDescription = `${agent.description} Invoke to switch into ${agent.name} mode and apply its flow to the current task.`;
+      const skill = `---
+name: ${agent.name}
+description: ${yamlString2(skillDescription)}
+---
+${agent.body}`;
+      return [
+        { file: `${agent.name}.md`, content: style, kind: "output-style" },
+        { file: `${agent.name}/SKILL.md`, content: skill, kind: "skill" }
+      ];
+    }
+    const lines = [`name: ${agent.name}`, `description: ${yamlString2(agent.description)}`];
+    const tools = toolsFor(agent);
+    if (tools !== null) lines.push(`tools: ${tools}`);
+    lines.push(`model: ${resolveAgentModel(models, agent.name, agent.tier).model}`);
+    return [
+      {
+        file: `${agent.name}.md`,
+        content: `---
+${lines.join("\n")}
+---
+${agent.body}`,
+        kind: "agent"
+      }
+    ];
+  },
+  renderCommand(file, content) {
+    return { file, content: content.replace(/\{\{input\}\}/g, "$ARGUMENTS") };
+  },
+  planHooks(canonical, ctx) {
+    const actions = [];
+    const { scriptsDir } = this.paths(ctx.configDir);
+    const settingsFile = path8.join(ctx.configDir, "settings.json");
+    let content = upsertNativeHooks(readTextIfExists(settingsFile), canonical, scriptsDir);
+    const defaults = loadCanonicalDefaults(ctx.stackDir)["claude-code"];
+    if (defaults?.["permissions"] !== void 0) {
+      content = upsertJson(content, (root) => {
+        if (!("permissions" in root)) root["permissions"] = defaults["permissions"];
+      });
+    }
+    actions.push({ kind: "write", target: settingsFile, content });
+    const scriptsSource = path8.join(ctx.stackDir, "scripts");
+    if (fs4.existsSync(scriptsSource)) {
+      for (const f of fs4.readdirSync(scriptsSource)) {
+        actions.push({ kind: "copy", source: path8.join(scriptsSource, f), target: path8.join(scriptsDir, f) });
+      }
+    }
+    return actions;
+  },
+  planMainConfig(canonical, ctx) {
+    const file = path8.join(path8.dirname(ctx.configDir), `${path8.basename(ctx.configDir)}.json`);
+    const content = upsertJson(readTextIfExists(file), (root) => {
+      const servers = root["mcpServers"] ??= {};
+      for (const [name, server] of Object.entries(canonical.servers)) {
+        if (server.transport === "stdio") {
+          if (server.command === "{{ENGRAM_BIN}}" && hasEngramPlugin(ctx.configDir)) {
+            if (name in servers) delete servers[name];
+            ctx.warnings.push(
+              "Claude Code: Engram ya est\xE1 integrado v\xEDa plugin \u2014 no se registra el MCP para no duplicar las tools de memoria."
+            );
+            continue;
+          }
+          if (server.command === "{{ENGRAM_BIN}}" && ctx.engramBin === null) {
+            ctx.warnings.push(
+              "Engram no detectado: el MCP 'engram' no se registra. Inst\xE1lalo (github.com/Gentleman-Programming/engram) y re-ejecuta sync."
+            );
+            continue;
+          }
+          const command = server.command === "{{ENGRAM_BIN}}" ? ctx.engramBin : server.command;
+          servers[name] = { command, args: server.args ?? [] };
+        } else {
+          const previous = servers[name];
+          const headers = {};
+          for (const [key, raw] of Object.entries(server.headers ?? {})) {
+            const envRef = /^\$\{(\w+)\}$/.exec(raw);
+            headers[key] = previous?.headers?.[key] || (envRef ? "" : raw);
+          }
+          servers[name] = {
+            type: "http",
+            url: server.url,
+            ...Object.keys(headers).length > 0 ? { headers } : {}
+          };
+        }
+      }
+    });
+    return [{ kind: "write", target: file, content }];
+  },
+  planUnmerge(mcp, hooks, ctx) {
+    const actions = [];
+    const { systemPromptFile } = this.paths(ctx.configDir);
+    const prompt = readTextIfExists(systemPromptFile);
+    if (prompt !== null) {
+      let content = removeMarkdownSection(prompt, "system-prompt");
+      content = removeMarkdownSection(content, "engram-protocol");
+      actions.push({ kind: "write", target: systemPromptFile, content });
+    }
+    const settingsFile = path8.join(ctx.configDir, "settings.json");
+    const settings = readTextIfExists(settingsFile);
+    if (settings !== null) {
+      const content = removeNativeHooks(settings, hooks);
+      if (content !== null) {
+        actions.push({ kind: "write", target: settingsFile, content: content.trim() === "{}" ? "" : content });
+      }
+    }
+    const mainFile = path8.join(path8.dirname(ctx.configDir), `${path8.basename(ctx.configDir)}.json`);
+    const main2 = readTextIfExists(mainFile);
+    if (main2 !== null) {
+      const content = upsertJson(main2, (root) => {
+        const servers = root["mcpServers"];
+        if (!servers) return;
+        for (const name of Object.keys(mcp.servers)) delete servers[name];
+        if (Object.keys(servers).length === 0) delete root["mcpServers"];
+      });
+      actions.push({ kind: "write", target: mainFile, content });
+    }
+    return actions;
+  }
+};
+
+// src/adapters/codex.ts
+import path9 from "path";
+import fs5 from "fs";
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function tomlMultiline(value) {
+  if (value.includes("'''")) return JSON.stringify(value);
+  return `'''
+${value.replace(/\r\n/g, "\n").trim()}
+'''`;
+}
+function hasActiveEngramPlugin(configDir) {
+  const config = readTextIfExists(path9.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(path9.join(configDir, "engram-instructions.md"))) return true;
+  const config = readTextIfExists(path9.join(configDir, "config.toml"));
+  return config !== null && /engram-instructions\.md/.test(config);
+}
+var codexAdapter = {
+  id: "codex",
+  name: "Codex CLI",
+  detect: detectCodex,
+  injectEngramProtocol(ctx) {
+    return !hasEngramProtocol(ctx.configDir);
+  },
+  paths(configDir) {
+    const isRealConfigDir = samePath(configDir, process.env.CODEX_HOME ?? path9.join(HOME, ".codex"));
+    const agentsHome = isRealConfigDir ? HOME : path9.dirname(configDir);
+    const skillsDir = path9.join(agentsHome, ".agents", "skills");
+    return {
+      systemPromptFile: path9.join(configDir, "AGENTS.md"),
+      agentsDir: path9.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: path9.join(configDir, "scripts"),
+      outputStylesDir: null,
+      profilesDir: configDir
+    };
+  },
+  renderAgent(agent, models) {
+    const tierModel = resolveAgentModel(models, agent.name, agent.tier);
+    if (agent.mode === "primary") {
+      const profileLines = [
+        "# Managed by jorgex-stack \u2014 modo orquestador del agente principal.",
+        `# Uso: codex --profile ${agent.name}`,
+        `developer_instructions = ${tomlMultiline(agent.body)}`
+      ];
+      const skillDescription = `${agent.description} Invoke to switch into ${agent.name} mode and apply its flow to the current task.`;
+      const skill = `---
+name: ${agent.name}
+description: ${JSON.stringify(skillDescription)}
+---
+${agent.body}`;
+      return [
+        { file: `${agent.name}.config.toml`, content: profileLines.join("\n") + "\n", kind: "profile" },
+        { file: `${agent.name}/SKILL.md`, content: skill, kind: "skill" }
+      ];
+    }
+    const lines = [
+      `name = ${tomlString(agent.name)}`,
+      `description = ${tomlString(agent.description)}`
+    ];
+    if (tierModel.model !== "default") lines.push(`model = ${tomlString(tierModel.model)}`);
+    if (tierModel.variant) lines.push(`model_reasoning_effort = ${tomlString(tierModel.variant)}`);
+    lines.push(`sandbox_mode = ${tomlString(agent.readonly ? "read-only" : "workspace-write")}`);
+    lines.push(`developer_instructions = ${tomlMultiline(agent.body)}`);
+    return [{ file: `${agent.name}.toml`, content: lines.join("\n") + "\n", kind: "agent" }];
+  },
+  renderCommand(file, content) {
+    const name = file.replace(/\.md$/, "");
+    let description = name;
+    let body = content;
+    const fm = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(content);
+    if (fm) {
+      const match = /(?:^|\n)description:\s*(.+)/.exec(fm[1]);
+      if (match) description = match[1].trim();
+      body = content.slice(fm[0].length);
+    }
+    body = body.replace(/\{\{input\}\}/g, "the user's request in this conversation");
+    return {
+      file: `${name}/SKILL.md`,
+      content: `---
+name: ${name}
+description: ${JSON.stringify(description)}
+---
+${body}`
+    };
+  },
+  planHooks(canonical, ctx) {
+    const actions = [];
+    const { scriptsDir } = this.paths(ctx.configDir);
+    const hooksFile = path9.join(ctx.configDir, "hooks.json");
+    const content = upsertNativeHooks(
+      readTextIfExists(hooksFile),
+      canonical,
+      scriptsDir,
+      (matcher) => matcher.split("|").some((p7) => p7.trim() === "Bash") ? "shell" : matcher
+    );
+    actions.push({ kind: "write", target: hooksFile, content });
+    ctx.warnings.push(
+      "Codex: los hooks no-managed requieren aprobaci\xF3n manual \u2014 ejecuta /hooks dentro de codex para activarlos."
+    );
+    const scriptsSource = path9.join(ctx.stackDir, "scripts");
+    if (fs5.existsSync(scriptsSource)) {
+      for (const f of fs5.readdirSync(scriptsSource)) {
+        actions.push({ kind: "copy", source: path9.join(scriptsSource, f), target: path9.join(scriptsDir, f) });
+      }
+    }
+    return actions;
+  },
+  planMainConfig(canonical, ctx) {
+    const file = path9.join(ctx.configDir, "config.toml");
+    let content = readTextIfExists(file);
+    const defaults = loadCanonicalDefaults(ctx.stackDir)["codex"] ?? {};
+    for (const [key, value] of Object.entries(defaults)) {
+      if (content !== null && new RegExp(`^\\s*${key}\\s*=`, "m").test(content)) continue;
+      const line = `${key} = ${tomlString(String(value))}
+`;
+      content = content === null ? line : line + content;
+    }
+    for (const [name, server] of Object.entries(canonical.servers)) {
+      const section = `mcp_servers.${name}`;
+      if (server.transport === "stdio") {
+        if (server.command === "{{ENGRAM_BIN}}" && hasActiveEngramPlugin(ctx.configDir)) {
+          if (content !== null) content = removeTomlSection(content, section);
+          ctx.warnings.push(
+            "Codex: Engram ya est\xE1 integrado v\xEDa plugin de marketplace \u2014 no se registra el MCP para no duplicar las tools de memoria."
+          );
+          continue;
+        }
+        if (server.command === "{{ENGRAM_BIN}}" && ctx.engramBin === null) {
+          ctx.warnings.push(
+            "Engram no detectado: el MCP 'engram' no se registra. Inst\xE1lalo (github.com/Gentleman-Programming/engram) y re-ejecuta sync."
+          );
+          continue;
+        }
+        const command = server.command === "{{ENGRAM_BIN}}" ? ctx.engramBin : server.command;
+        const args = (server.args ?? []).map(tomlString).join(", ");
+        content = upsertTomlSection(content, section, `command = ${tomlString(command)}
+args = [${args}]`);
+      } else {
+        const previousSection = readTomlSection(content, section);
+        const prevUsesEnvHeaders = previousSection?.includes("env_http_headers") ?? false;
+        const literalPairs = [];
+        const refPairs = [];
+        for (const [key, raw] of Object.entries(server.headers ?? {})) {
+          const envRef = /^\$\{(\w+)\}$/.exec(raw);
+          const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          const previousValue = !prevUsesEnvHeaders && previousSection !== null ? new RegExp(`(?:^|[{,]\\s*)"?${escaped}"?\\s*=\\s*"([^"]*)"`, "m").exec(previousSection)?.[1] : void 0;
+          if (previousValue) literalPairs.push(`${tomlString(key)} = ${tomlString(previousValue)}`);
+          else refPairs.push(`${tomlString(key)} = ${tomlString(envRef ? envRef[1] : raw)}`);
+        }
+        const body = [`url = ${tomlString(server.url)}`];
+        if (literalPairs.length > 0) body.push(`http_headers = { ${literalPairs.join(", ")} }`);
+        if (refPairs.length > 0) body.push(`env_http_headers = { ${refPairs.join(", ")} }`);
+        content = upsertTomlSection(content, section, body.join("\n"));
+      }
+    }
+    if (content === null) return [];
+    if (!content.endsWith("\n")) content += "\n";
+    return [{ kind: "write", target: file, content }];
+  },
+  planUnmerge(mcp, hooks, ctx) {
+    const actions = [];
+    const { systemPromptFile } = this.paths(ctx.configDir);
+    const prompt = readTextIfExists(systemPromptFile);
+    if (prompt !== null) {
+      let content = removeMarkdownSection(prompt, "system-prompt");
+      content = removeMarkdownSection(content, "engram-protocol");
+      actions.push({ kind: "write", target: systemPromptFile, content });
+    }
+    const configFile = path9.join(ctx.configDir, "config.toml");
+    const config = readTextIfExists(configFile);
+    if (config !== null) {
+      let content = config;
+      for (const name of Object.keys(mcp.servers)) content = removeTomlSection(content, `mcp_servers.${name}`);
+      actions.push({ kind: "write", target: configFile, content });
+    }
+    const hooksFile = path9.join(ctx.configDir, "hooks.json");
+    const hooksJson = readTextIfExists(hooksFile);
+    if (hooksJson !== null) {
+      const content = removeNativeHooks(hooksJson, hooks);
+      if (content !== null) {
+        actions.push({ kind: "write", target: hooksFile, content: content.trim() === "{}" ? "" : content });
+      }
+    }
+    return actions;
+  }
+};
+
+// src/lib/backup.ts
+import fs6 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(fs6.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) => fs6.existsSync(f));
+  if (existing.length === 0) return null;
+  const checksum = compositeChecksum(existing);
+  const latest = listBackups(root)[0];
+  if (latest?.checksum === checksum) return latest;
+  const id = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${label}`;
+  const 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)}`);
+    fs6.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 (!fs6.existsSync(root)) return [];
+  const infos = [];
+  for (const entry of fs6.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 (!fs6.existsSync(stored)) continue;
+    if (!isContainedIn(original, boundary)) continue;
+    ensureDir(path10.dirname(original));
+    fs6.copyFileSync(stored, original);
+    restored++;
+  }
+  return restored;
+}
+function pruneBackups(root) {
+  const all = listBackups(root);
+  for (const old of all.slice(KEEP_BACKUPS)) {
+    fs6.rmSync(path10.join(root, old.id), { recursive: true, force: true });
+  }
+}
+
+// src/lib/manifest.ts
+import fs7 from "fs";
+import path11 from "path";
+function manifestFile() {
+  return path11.join(dataDir(), "manifest.json");
+}
+function readManifest(file = manifestFile()) {
+  const raw = readTextIfExists(file);
+  if (raw === null) return { runtimes: {} };
+  try {
+    const parsed = JSON.parse(raw);
+    return { runtimes: parsed.runtimes ?? {} };
+  } catch {
+    return { runtimes: {} };
+  }
+}
+function writeRuntimeManifest(id, entry, file = manifestFile()) {
+  const manifest = readManifest(file);
+  manifest.runtimes[id] = entry;
+  writeText(file, JSON.stringify(manifest, null, 2) + "\n");
+}
+function removeRuntimeManifest(id, file = manifestFile()) {
+  const manifest = readManifest(file);
+  if (!(id in manifest.runtimes)) return;
+  delete manifest.runtimes[id];
+  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) && fs7.existsSync(f)
+  );
+}
+
+// src/components/system-prompt.ts
+import path12 from "path";
+import fs8 from "fs";
+var normalize = (s) => s.replace(/\r\n/g, "\n");
+function planSystemPrompt(adapter, ctx) {
+  const target = adapter.paths(ctx.configDir).systemPromptFile;
+  const agentsMd = normalize(fs8.readFileSync(path12.join(ctx.stackDir, "system-prompt", "AGENTS.md"), "utf8"));
+  const protocol = stripLeadingHtmlComments(
+    normalize(fs8.readFileSync(path12.join(ctx.stackDir, "system-prompt", "engram-protocol.md"), "utf8"))
+  );
+  let content = readTextIfExists(target);
+  content = upsertMarkdownSection(content, "system-prompt", agentsMd);
+  if (adapter.injectEngramProtocol(ctx)) {
+    content = upsertMarkdownSection(content, "engram-protocol", protocol);
+  } else {
+    content = removeMarkdownSection(content, "engram-protocol");
+  }
+  return [{ kind: "write", target, content }];
+}
+
+// src/components/agents.ts
+import path13 from "path";
+function planAgents(adapter, ctx) {
+  const { agentsDir, commandsDir, outputStylesDir, skillsDir, profilesDir } = adapter.paths(ctx.configDir);
+  const dirFor = {
+    agent: agentsDir,
+    command: commandsDir,
+    "output-style": outputStylesDir,
+    skill: skillsDir,
+    profile: profilesDir
+  };
+  return loadCanonicalAgents(path13.join(ctx.stackDir, "agents")).flatMap(
+    (agent) => adapter.renderAgent(agent, ctx.models).flatMap((rendered) => {
+      const dir = dirFor[rendered.kind];
+      if (dir === null) {
+        ctx.warnings.push(`${adapter.name}: sin destino para '${rendered.kind}' (${rendered.file}) \u2014 omitido.`);
+        return [];
+      }
+      return [{ kind: "write", target: path13.join(dir, rendered.file), content: rendered.content }];
+    })
+  );
+}
+
+// src/components/skills.ts
+import path14 from "path";
+function planSkills(adapter, ctx) {
+  const { skillsDir } = adapter.paths(ctx.configDir);
+  const source = path14.join(ctx.stackDir, "skills");
+  return listFilesRecursive(source).map((file) => ({
+    kind: "copy",
+    source: file,
+    target: path14.join(skillsDir, path14.relative(source, file))
+  }));
+}
+
+// src/components/commands.ts
+import path15 from "path";
+import fs9 from "fs";
+function planCommands(adapter, ctx) {
+  const { commandsDir } = adapter.paths(ctx.configDir);
+  const source = path15.join(ctx.stackDir, "commands");
+  if (!fs9.existsSync(source)) return [];
+  return fs9.readdirSync(source).filter((f) => f.endsWith(".md")).map((f) => {
+    const raw = fs9.readFileSync(path15.join(source, f), "utf8").replace(/\r\n/g, "\n");
+    const rendered = adapter.renderCommand(f, raw);
+    return { kind: "write", target: path15.join(commandsDir, rendered.file), content: rendered.content };
+  });
+}
+
+// src/components/hooks.ts
+function planHooks(adapter, ctx) {
+  return adapter.planHooks(loadCanonicalHooks(ctx.stackDir), ctx);
+}
+
+// src/components/mcp.ts
+function planMcp(adapter, ctx) {
+  return adapter.planMainConfig(loadCanonicalMcp(ctx.stackDir), ctx);
+}
+
+// src/components/plugins.ts
+import path16 from "path";
+import fs10 from "fs";
+function planPlugins(adapter, ctx) {
+  const { pluginsDir } = adapter.paths(ctx.configDir);
+  if (pluginsDir === null) return [];
+  const source = path16.join(ctx.stackDir, "plugins", adapter.id);
+  if (!fs10.existsSync(source)) return [];
+  return fs10.readdirSync(source).filter((f) => f.endsWith(".ts")).map((f) => {
+    const sourceFile = path16.join(source, f);
+    const target = path16.join(pluginsDir, f);
+    const raw = fs10.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(
+        fs10.readFileSync(path16.join(ctx.stackDir, "system-prompt", "engram-protocol.md"), "utf8").replace(/\r\n/g, "\n")
+      );
+      content = content.replace(/"\{\{ENGRAM_PROTOCOL\}\}"/g, JSON.stringify(protocol));
+    }
+    if (content === raw) return { kind: "copy", source: sourceFile, target };
+    return { kind: "write", target, content };
+  });
+}
+
+// src/install.ts
+var ADAPTERS = {
+  opencode: opencodeAdapter,
+  "claude-code": claudeCodeAdapter,
+  codex: codexAdapter
+};
+function makeContext(adapter, configDir) {
+  const models = loadModelMap()[adapter.id];
+  if (!models) return null;
+  return {
+    stackDir: stackRoot(),
+    configDir,
+    engramBin: detectEngram(),
+    models,
+    warnings: []
+  };
+}
+function buildPlan(adapter, ctx) {
+  return [
+    ...planSystemPrompt(adapter, ctx),
+    ...planAgents(adapter, ctx),
+    ...planSkills(adapter, ctx),
+    ...planCommands(adapter, ctx),
+    ...planHooks(adapter, ctx),
+    ...planMcp(adapter, ctx),
+    ...planPlugins(adapter, ctx)
+  ];
+}
+function diffPlan(plan) {
+  return plan.map((action) => {
+    if (action.kind === "write") {
+      const current = readTextIfExists(action.target);
+      if (current === null) return { action, status: "create" };
+      return { action, status: current === action.content ? "unchanged" : "update" };
+    }
+    if (!fs11.existsSync(action.target)) return { action, status: "create" };
+    return { action, status: sameFileContent(action.source, action.target) ? "unchanged" : "update" };
+  });
+}
+function applyChanges(changes) {
+  for (const { action } of changes) {
+    if (action.kind === "write") writeText(action.target, action.content);
+    else copyFile(action.source, action.target);
+  }
+}
+function collectAllCurrentTargets() {
+  const targets = /* @__PURE__ */ new Set();
+  let complete = true;
+  for (const adapter of Object.values(ADAPTERS)) {
+    const detection = adapter.detect();
+    if (!detection.installed) continue;
+    const ctx = makeContext(adapter, detection.configDir);
+    if (!ctx) continue;
+    try {
+      for (const action of buildPlan(adapter, ctx)) targets.add(path17.resolve(action.target));
+    } catch {
+      complete = false;
+    }
+  }
+  return { targets, complete };
+}
+async function runInstall(opts) {
+  p.intro(`jorgex-stack ${opts.dryRun ? "install (dry-run)" : "install"}`);
+  const stackDir = stackRoot();
+  const engramBin = detectEngram();
+  const modelMap = loadModelMap();
+  ensureModelMapFile();
+  p.log.info(engramBin ? `Engram detectado: ${engramBin} (se respeta, D7)` : "Engram NO detectado.");
+  const useManifest = opts.targetDir === void 0;
+  const current = useManifest ? collectAllCurrentTargets() : { targets: /* @__PURE__ */ new Set(), complete: false };
+  const canOrphan = useManifest && current.complete;
+  const canonicalMcp = loadCanonicalMcp(stackDir);
+  const canonicalHooks = loadCanonicalHooks(stackDir);
+  let exitCode = 0;
+  for (const id of opts.runtimes) {
+    const adapter = ADAPTERS[id];
+    if (!adapter) {
+      p.log.warn(`${id}: adapter pendiente (F3/F4) \u2014 omitido.`);
+      continue;
+    }
+    const detection = adapter.detect();
+    const configDir = opts.targetDir ?? detection.configDir;
+    if (!detection.installed && opts.targetDir === void 0) {
+      p.log.warn(`${adapter.name} no detectado en esta m\xE1quina \u2014 omitido.`);
+      continue;
+    }
+    const models = modelMap[id];
+    if (!models) {
+      p.log.warn(`${adapter.name}: sin model-map para este runtime \u2014 omitido.`);
+      continue;
+    }
+    const ctx = {
+      stackDir,
+      configDir,
+      engramBin,
+      models,
+      warnings: []
+    };
+    let plan = buildPlan(adapter, ctx);
+    let diff = diffPlan(plan);
+    let creates = diff.filter((d) => d.status === "create");
+    let updates = diff.filter((d) => d.status === "update");
+    let changes = [...creates, ...updates];
+    const prevManifest = canOrphan ? readManifest().runtimes[id] : void 0;
+    const orphans = prevManifest ? findOrphans(prevManifest.owned, current.targets) : [];
+    p.log.step(`${adapter.name} \u2192 ${configDir}`);
+    p.log.info(
+      `${diff.length} archivos gestionados: ${creates.length} nuevos, ${updates.length} modificados, ${diff.length - changes.length} sin cambios`
+    );
+    if (orphans.length > 0) p.log.info(`${orphans.length} hu\xE9rfanos de versiones previas a eliminar`);
+    for (const w of ctx.warnings) p.log.warn(w);
+    if (opts.dryRun) {
+      for (const c of changes.slice(0, 40)) p.log.message(`  ${c.status === "create" ? "+" : "~"} ${c.action.target}`);
+      if (changes.length > 40) p.log.message(`  \u2026 y ${changes.length - 40} m\xE1s`);
+      for (const o of orphans) p.log.message(`  - ${o}`);
+      continue;
+    }
+    const writeManifest = () => {
+      if (!useManifest) return;
+      const unmergeTargets = new Set(adapter.planUnmerge(canonicalMcp, canonicalHooks, ctx).map((a) => path17.resolve(a.target)));
+      const owned = plan.map((a) => path17.resolve(a.target)).filter((t) => !unmergeTargets.has(t));
+      writeRuntimeManifest(id, { configDir, owned, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    };
+    if (changes.length === 0 && orphans.length === 0) {
+      writeManifest();
+      p.log.success(`${adapter.name}: ya al d\xEDa (idempotente).`);
+      continue;
+    }
+    if (!opts.yes && process.stdout.isTTY) {
+      const orphanNote = orphans.length > 0 ? ` (+ ${orphans.length} hu\xE9rfanos a eliminar)` : "";
+      const ok = await p.confirm({ message: `\xBFAplicar ${changes.length} cambios en ${adapter.name}?${orphanNote}` });
+      if (p.isCancel(ok) || !ok) {
+        p.log.warn(`${adapter.name}: omitido por el usuario.`);
+        continue;
+      }
+      plan = buildPlan(adapter, { ...ctx, warnings: [] });
+      diff = diffPlan(plan);
+      creates = diff.filter((d) => d.status === "create");
+      updates = diff.filter((d) => d.status === "update");
+      changes = [...creates, ...updates];
+    }
+    const backup = createBackup([...updates.map((c) => c.action.target), ...orphans], `install-${id}`);
+    if (backup) p.log.info(`Backup: ${backup.id} (${backup.files.length} archivos)`);
+    applyChanges(changes);
+    const pruneRoot = useManifest ? HOME : path17.dirname(configDir);
+    for (const orphan of orphans) {
+      fs11.rmSync(orphan, { force: true });
+      pruneEmptyDirs(orphan, pruneRoot);
+    }
+    const verifyCtx = { ...ctx, warnings: [] };
+    const dirty = diffPlan(buildPlan(adapter, verifyCtx)).filter((d) => d.status !== "unchanged");
+    if (dirty.length > 0) {
+      p.log.error(`${adapter.name}: verificaci\xF3n de idempotencia FALL\xD3 (${dirty.length} acciones inestables).`);
+      for (const d of dirty.slice(0, 10)) p.log.message(`  ! ${d.action.target}`);
+      exitCode = 1;
+    } else {
+      writeManifest();
+      p.log.success(`${adapter.name}: ${changes.length} archivos aplicados y verificados (idempotente).`);
+    }
+  }
+  p.outro(opts.dryRun ? "Dry-run: no se ha escrito nada." : "Hecho.");
+  return exitCode;
+}
+
+// src/uninstall.ts
+import fs12 from "fs";
+import path18 from "path";
+import * as p2 from "@clack/prompts";
+async function runUninstall(opts) {
+  p2.intro(`jorgex-stack ${opts.dryRun ? "uninstall (dry-run)" : "uninstall"}`);
+  const stackDir = stackRoot();
+  const mcp = loadCanonicalMcp(stackDir);
+  const hooks = loadCanonicalHooks(stackDir);
+  let removeEngram = opts.removeEngram;
+  if (!removeEngram && !opts.yes && !opts.dryRun && process.stdout.isTTY) {
+    const answer = await p2.confirm({
+      message: "\xBFQuitar tambi\xE9n el registro de Engram (MCP/plugin) de los runtimes? Tus memorias (~/.engram) y el binario NO se tocan en ning\xFAn caso.",
+      initialValue: false
+    });
+    if (p2.isCancel(answer)) {
+      p2.cancel("Cancelado \u2014 no se ha tocado nada.");
+      return 1;
+    }
+    removeEngram = answer === true;
+  }
+  const mcpForUnmerge = removeEngram ? mcp : { servers: Object.fromEntries(Object.entries(mcp.servers).filter(([name]) => name !== "engram")) };
+  if (!removeEngram) {
+    p2.log.info("Engram se conserva: memorias, binario y registro intactos (usa --remove-engram para desregistrarlo).");
+  }
+  const retained = /* @__PURE__ */ new Set();
+  for (const keep of Object.values(ADAPTERS)) {
+    if (opts.runtimes.includes(keep.id)) continue;
+    const detection = keep.detect();
+    if (!detection.installed) continue;
+    const keepCtx = makeContext(keep, detection.configDir);
+    if (!keepCtx) continue;
+    for (const action of buildPlan(keep, keepCtx)) retained.add(path18.resolve(action.target));
+  }
+  for (const id of opts.runtimes) {
+    const adapter = ADAPTERS[id];
+    if (!adapter) {
+      p2.log.warn(`${id}: sin adapter \u2014 omitido.`);
+      continue;
+    }
+    const detection = adapter.detect();
+    const configDir = opts.targetDir ?? detection.configDir;
+    if (!detection.installed && opts.targetDir === void 0) {
+      p2.log.warn(`${adapter.name} no detectado \u2014 omitido.`);
+      continue;
+    }
+    const ctx = makeContext(adapter, configDir);
+    if (!ctx) continue;
+    ctx.preserveEngram = !removeEngram;
+    const unmerge = adapter.planUnmerge(mcpForUnmerge, hooks, ctx);
+    const mergedTargets = new Set(unmerge.map((a) => path18.resolve(a.target)));
+    const usingRealConfig = opts.targetDir === void 0;
+    const prevOwned = usingRealConfig ? readManifest().runtimes[id]?.owned ?? [] : [];
+    const pruneRoot = usingRealConfig ? HOME : path18.dirname(configDir);
+    const planTargets = [
+      .../* @__PURE__ */ new Set([...buildPlan(adapter, ctx).map((a) => path18.resolve(a.target)), ...prevOwned.map((t) => path18.resolve(t))])
+    ].filter((t) => !mergedTargets.has(t) && fs12.existsSync(t));
+    const deleteTargets = planTargets.filter(
+      (t) => !retained.has(t) && !(ctx.preserveEngram && path18.basename(t) === "engram.ts") && isContainedIn(t, pruneRoot)
+    );
+    const sharedKept = planTargets.length - deleteTargets.length;
+    p2.log.step(`${adapter.name} \u2192 ${configDir}`);
+    p2.log.info(`${deleteTargets.length} archivos a borrar, ${unmerge.length} archivos compartidos a limpiar`);
+    if (sharedKept > 0) p2.log.info(`${sharedKept} archivos se conservan: otros runtimes instalados los siguen usando.`);
+    if (opts.dryRun) continue;
+    const backup = createBackup(
+      [...deleteTargets, ...unmerge.map((a) => a.target).filter((t) => fs12.existsSync(t))],
+      `uninstall-${id}`
+    );
+    if (backup) p2.log.info(`Backup: ${backup.id} (${backup.files.length} archivos)`);
+    for (const target of deleteTargets) {
+      fs12.rmSync(target, { force: true });
+      pruneEmptyDirs(target, pruneRoot);
+    }
+    for (const action of unmerge) {
+      if (action.kind !== "write") continue;
+      if (action.content.trim() === "") {
+        fs12.rmSync(action.target, { force: true });
+      } else {
+        writeText(action.target, action.content);
+      }
+    }
+    if (usingRealConfig) removeRuntimeManifest(id);
+    p2.log.success(`${adapter.name}: stack retirado (lo tuyo queda intacto).`);
+  }
+  p2.outro(opts.dryRun ? "Dry-run: no se ha tocado nada." : "Hecho. Usa 'restore' si quieres volver atr\xE1s.");
+  return 0;
+}
+
+// src/doctor.ts
+import path19 from "path";
+import fs13 from "fs";
+import * as p3 from "@clack/prompts";
+function engramVersion(bin) {
+  const out = runDetectedBin(bin, ["--version"], 5e3);
+  if (out === null) return null;
+  return /(\d+\.\d+\.\d+)/.exec(out)?.[1] ?? out.trim().split("\n")[0] ?? null;
+}
+function context7KeyConfigured(id, configDir) {
+  const file = id === "codex" ? path19.join(configDir, "config.toml") : id === "claude-code" ? path19.join(path19.dirname(configDir), `${path19.basename(configDir)}.json`) : path19.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");
+  let problems = 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");
+    problems++;
+  } else {
+    const version = engramVersion(engramBin);
+    if (version === null) {
+      p3.log.error(`Engram: binario en ${engramBin} pero no responde a --version.`);
+      problems++;
+    } else {
+      p3.log.success(`Engram: ${version} (${engramBin})`);
+    }
+  }
+  const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path19.join(HOME, ".engram");
+  const engramDb = path19.join(engramDataDir, "engram.db");
+  if (fs13.existsSync(engramDb)) {
+    const sizeMb = (fs13.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 (!fs13.existsSync(modelMapFile())) p3.log.info("model-map: a\xFAn no creado (se crea en el primer install o con 'models').");
+  const manifest = readManifest();
+  const current = collectAllCurrentTargets();
+  for (const adapter of Object.values(ADAPTERS)) {
+    const detection = adapter.detect();
+    if (!detection.installed) {
+      p3.log.warn(`${adapter.name}: no instalado en esta m\xE1quina.`);
+      continue;
+    }
+    const ctx = makeContext(adapter, detection.configDir);
+    if (!ctx) continue;
+    let pending;
+    try {
+      pending = diffPlan(buildPlan(adapter, ctx)).filter((d) => d.status !== "unchanged").length;
+    } catch (err) {
+      p3.log.error(
+        `${adapter.name}: config ilegible en ${detection.configDir} \u2014 ${err instanceof Error ? err.message : err}`
+      );
+      problems++;
+      continue;
+    }
+    if (pending > 0) {
+      p3.log.warn(`${adapter.name}: ${pending} archivos gestionados desactualizados o ausentes \u2192 ejecuta 'sync'.`);
+      problems++;
+    } else {
+      p3.log.success(`${adapter.name}: config del stack al d\xEDa (${detection.configDir}).`);
+    }
+    const prev = manifest.runtimes[adapter.id];
+    const orphans = prev && current.complete ? findOrphans(prev.owned, current.targets) : [];
+    if (orphans.length > 0) {
+      p3.log.warn(`${adapter.name}: ${orphans.length} archivos hu\xE9rfanos de versiones previas \u2192 ejecuta 'sync'.`);
+      problems++;
+    }
+    if (adapter.id === "codex" && fs13.existsSync(path19.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" && fs13.existsSync(path19.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).`);
+  }
+  p3.outro(problems === 0 ? "Todo sano." : `${problems} avisos \u2014 revisa arriba.`);
+  return problems > 0 ? 1 : 0;
+}
+
+// src/update.ts
+import fs16 from "fs";
+import path22 from "path";
+import os3 from "os";
+import { execFileSync as execFileSync4 } from "child_process";
+import * as p4 from "@clack/prompts";
+
+// src/lib/github.ts
+import fs14 from "fs";
+import path20 from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+import os2 from "os";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+var cachedToken;
+var ghTokenFailed = false;
+function githubToken() {
+  if (cachedToken !== void 0) return cachedToken;
+  const env = process.env["GH_TOKEN"]?.trim() || process.env["GITHUB_TOKEN"]?.trim();
+  if (env) return cachedToken = env;
+  const gh = lookPath("gh");
+  if (gh) {
+    const fromGh = runDetectedBin(gh, ["auth", "token"], 5e3)?.trim();
+    if (fromGh) return cachedToken = fromGh;
+    ghTokenFailed = true;
+  }
+  return cachedToken = null;
+}
+function ghPresentButTokenFailed() {
+  return ghTokenFailed;
+}
+function authHeaders() {
+  const token = githubToken();
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+var rateLimitHit = false;
+function githubRateLimited() {
+  return rateLimitHit;
+}
+function githubHeaders() {
+  return {
+    Accept: "application/vnd.github+json",
+    "User-Agent": "jorgex-stack",
+    ...authHeaders()
+  };
+}
+async function latestGithubRelease(repo) {
+  try {
+    const res = await fetch(`https://api.github.com/repos/${repo}/releases/latest`, {
+      headers: githubHeaders(),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      if (res.status === 403 || res.status === 429) rateLimitHit = true;
+      return null;
+    }
+    const data = await res.json();
+    return data.tag_name?.replace(/^v/, "") ?? null;
+  } catch {
+    return null;
+  }
+}
+async function latestGithubCommit(repo) {
+  try {
+    const res = await fetch(`https://api.github.com/repos/${repo}/commits?per_page=1`, {
+      headers: githubHeaders(),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      if (res.status === 403 || res.status === 429) rateLimitHit = true;
+      return null;
+    }
+    const data = await res.json();
+    return data[0]?.sha ?? null;
+  } catch {
+    return null;
+  }
+}
+function validateExtractedTree(destDir) {
+  const resolved = path20.resolve(destDir);
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs14.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+    for (const entry of entries) {
+      const full = path20.join(dir, entry.name);
+      let stat;
+      try {
+        stat = fs14.lstatSync(full);
+      } catch {
+        return false;
+      }
+      if (stat.isSymbolicLink()) return false;
+      if (!isContainedIn(full, resolved)) return false;
+      if (entry.isDirectory()) {
+        if (!walk(full)) return false;
+      }
+    }
+    return true;
+  };
+  return walk(resolved);
+}
+function resolveTarBin() {
+  if (process.platform !== "win32") return "tar";
+  const winTar = path20.join(process.env["SystemRoot"] ?? "C:\\Windows", "System32", "tar.exe");
+  return fs14.existsSync(winTar) ? winTar : "tar";
+}
+async function downloadRepoTarball(repo, sha, destDir, validateSubdir) {
+  const url = `https://codeload.github.com/${repo}/tar.gz/${sha}`;
+  const tmp = path20.join(os2.tmpdir(), `jorgex-tarball-${Date.now()}.tar.gz`);
+  const fail = (reason) => {
+    try {
+      fs14.rmSync(destDir, { recursive: true, force: true });
+    } catch {
+    }
+    return { ok: false, reason };
+  };
+  try {
+    const res = await fetch(url, {
+      headers: { "User-Agent": "jorgex-stack", ...authHeaders() },
+      signal: AbortSignal.timeout(12e4)
+    });
+    if (!res.ok) {
+      if (res.status === 403 || res.status === 429) rateLimitHit = true;
+      return fail(
+        `HTTP ${res.status}${res.status === 403 || res.status === 429 ? " \u2014 rate limit; define GH_TOKEN o inicia sesi\xF3n en gh" : ""}`
+      );
+    }
+    if (!res.body) return fail("respuesta HTTP sin cuerpo");
+    await pipeline(
+      Readable.fromWeb(res.body),
+      fs14.createWriteStream(tmp)
+    );
+    fs14.rmSync(destDir, { recursive: true, force: true });
+    fs14.mkdirSync(destDir, { recursive: true });
+    try {
+      execFileSync2(resolveTarBin(), ["-xzf", tmp, "--strip-components=1", "-C", destDir], { stdio: "pipe" });
+    } catch (err) {
+      const e = err;
+      const detail = (e.stderr?.toString().trim() || e.message || "").split("\n")[0];
+      return fail(detail ? `tar fall\xF3: ${detail}` : "tar no disponible o fall\xF3 la extracci\xF3n");
+    }
+    const resolvedDest = path20.resolve(destDir);
+    const validateRoot = validateSubdir ? path20.resolve(resolvedDest, validateSubdir) : resolvedDest;
+    if (validateRoot !== resolvedDest && !isContainedIn(validateRoot, resolvedDest)) {
+      return fail(`la ruta de validaci\xF3n "${validateSubdir}" escapa del destino`);
+    }
+    if (fs14.existsSync(validateRoot) && !validateExtractedTree(validateRoot)) {
+      return fail("el \xE1rbol extra\xEDdo contiene symlinks o rutas fuera del destino");
+    }
+    const validated = fs14.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 {
+      fs14.rmSync(tmp, { force: true });
+    } catch {
+    }
+  }
+}
+
+// src/lib/skill-update.ts
+import fs15 from "fs";
+import path21 from "path";
+import { execFileSync as execFileSync3 } from "child_process";
+var PROTECTED_SKILLS = /* @__PURE__ */ new Set(["agent-delegation", "work-lifecycle"]);
+function sameTextContentNormalized(a, b) {
+  const ba = fs15.readFileSync(a);
+  const bb = fs15.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");
+  return sa === sb;
+}
+function diffSkillDirs(upstreamDir, localDir) {
+  const upstreamFiles = new Set(
+    listFilesRecursive(upstreamDir).map((f) => path21.relative(upstreamDir, f))
+  );
+  const localFiles = new Set(
+    listFilesRecursive(localDir).map((f) => path21.relative(localDir, f))
+  );
+  const added = [];
+  const modified = [];
+  const deleted = [];
+  for (const rel of upstreamFiles) {
+    if (!localFiles.has(rel)) {
+      added.push(rel);
+    } else if (!sameTextContentNormalized(path21.join(upstreamDir, rel), path21.join(localDir, rel))) {
+      modified.push(rel);
+    }
+  }
+  for (const rel of localFiles) {
+    if (!upstreamFiles.has(rel)) {
+      deleted.push(rel);
+    }
+  }
+  return {
+    added: added.sort(),
+    modified: modified.sort(),
+    deleted: deleted.sort()
+  };
+}
+var DIFF_MAX_LINES = 400;
+function renderSkillDiff(upstreamDir, localDir) {
+  try {
+    execFileSync3("git", ["diff", "--no-index", "--stat", "--", localDir, upstreamDir], {
+      stdio: "pipe",
+      encoding: "utf8"
+    });
+    return "";
+  } catch (statErr) {
+    const se = statErr;
+    if (typeof se.stdout !== "string" || se.status !== 1) {
+      const d = diffSkillDirs(upstreamDir, localDir);
+      const total = d.added.length + d.modified.length + d.deleted.length;
+      if (total === 0) return "";
+      return `[git no disponible \u2014 resumen de cambios]
+  a\xF1adidos: ${d.added.length}, modificados: ${d.modified.length}, eliminados: ${d.deleted.length}`;
+    }
+    const stat = se.stdout;
+    let fullDiff = "";
+    try {
+      execFileSync3("git", ["diff", "--no-index", "--", localDir, upstreamDir], {
+        stdio: "pipe",
+        encoding: "utf8"
+      });
+    } catch (diffErr) {
+      const de = diffErr;
+      if (typeof de.stdout === "string" && de.status === 1) {
+        const lines = de.stdout.split("\n");
+        if (lines.length > DIFF_MAX_LINES) {
+          fullDiff = lines.slice(0, DIFF_MAX_LINES).join("\n") + `
+(truncado \u2014 ${lines.length - DIFF_MAX_LINES} l\xEDneas omitidas)`;
+        } else {
+          fullDiff = de.stdout;
+        }
+      }
+    }
+    return fullDiff ? `${stat}
+${fullDiff}` : stat;
+  }
+}
+function replaceSkill(name, upstreamSkillDir, newCommit, opts) {
+  const upstreamsFilePath = opts?.upstreamsFilePath;
+  const localSkillsRoot = opts?.localSkillsRoot;
+  const backupsRoot2 = opts?.backupsRoot;
+  if (PROTECTED_SKILLS.has(name)) {
+    throw new Error(`La skill "${name}" es propia del stack y no se actualiza desde upstream.`);
+  }
+  const upstreamsFile = upstreamsFilePath ?? path21.join(path21.dirname(stackRoot()), "upstreams.json");
+  const raw = fs15.readFileSync(upstreamsFile, "utf8");
+  const data = JSON.parse(raw);
+  const skillEntry = data?.skills?.[name];
+  if (!skillEntry) {
+    throw new Error(`Skill "${name}" no encontrada en upstreams.json.`);
+  }
+  if (skillEntry.kind === "release") {
+    throw new Error(`La skill "${name}" es de tipo release y no se actualiza con replaceSkill.`);
+  }
+  const skillsRoot = localSkillsRoot ?? path21.join(stackRoot(), "skills");
+  const localSkillDir = path21.join(skillsRoot, name);
+  const localFiles = listFilesRecursive(localSkillDir);
+  if (localFiles.length > 0) {
+    createBackup(localFiles, `skill-update-${name}`, backupsRoot2);
+  }
+  const stagingDir = `${localSkillDir}.staging-${process.pid}`;
+  try {
+    const upstreamFiles = listFilesRecursive(upstreamSkillDir);
+    for (const src of upstreamFiles) {
+      const st = fs15.lstatSync(src);
+      if (st.isSymbolicLink()) {
+        throw new Error(`Symlink rechazado en upstream de skill "${name}": ${src}`);
+      }
+      const rel = path21.relative(upstreamSkillDir, src);
+      const dest = path21.join(stagingDir, rel);
+      ensureDir(path21.dirname(dest));
+      copyFile(src, dest);
+    }
+    const oldDir = `${localSkillDir}.old-${process.pid}`;
+    if (fs15.existsSync(localSkillDir)) {
+      fs15.renameSync(localSkillDir, oldDir);
+    }
+    fs15.renameSync(stagingDir, localSkillDir);
+    fs15.rmSync(oldDir, { recursive: true, force: true });
+  } catch (err) {
+    try {
+      fs15.rmSync(stagingDir, { recursive: true, force: true });
+    } catch {
+    }
+    throw err;
+  }
+  skillEntry.commit = newCommit;
+  writeText(upstreamsFile, JSON.stringify(data, null, 2) + "\n");
+}
+
+// src/update.ts
+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 = path22.join(path22.dirname(stackRoot()), "upstreams.json");
+  return JSON.parse(fs16.readFileSync(file, "utf8"));
+}
+async function latestNpmVersion(pkg) {
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${pkg}/latest`, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function runUpdateCheck(localVersion) {
+  p4.intro("jorgex-stack update --check");
+  const upstreams = loadUpstreams();
+  const npmLatest = await latestNpmVersion("jorgex-stack");
+  if (npmLatest === null)
+    p4.log.info(`jorgex-stack: v${localVersion} local (a\xFAn no publicado en npm o sin red).`);
+  else if (npmLatest === localVersion)
+    p4.log.success(`jorgex-stack: v${localVersion} \u2014 al d\xEDa.`);
+  else
+    p4.log.warn(
+      `jorgex-stack: v${localVersion} local, v${npmLatest} en npm \u2192 pnpm dlx jorgex-stack@latest`
+    );
+  const engramRepo = upstreams.tools["engram"]?.source.replace(/^github:/, "");
+  if (engramRepo) {
+    const bin = detectEngram();
+    const local = bin ? engramVersion(bin) : null;
+    const latest = await latestGithubRelease(engramRepo);
+    if (local === null) p4.log.warn("engram: no detectado en esta m\xE1quina.");
+    else if (latest === null)
+      p4.log.info(`engram: ${local} local (no se pudo consultar el upstream).`);
+    else if (latest === local) p4.log.success(`engram: ${local} \u2014 al d\xEDa.`);
+    else
+      p4.log.warn(
+        `engram: ${local} local, ${latest} disponible. Tu instalaci\xF3n NO se toca (D7) \u2014 actualiza t\xFA: github.com/${engramRepo}/releases`
+      );
+  }
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const [name, info] of Object.entries(upstreams.skills)) {
+    const repo = info.source.replace(/^github:/, "");
+    const entry = byRepo.get(repo) ?? { skills: [], pinned: info.commit };
+    entry.skills.push(info.modified ? `${name} (modificada localmente)` : name);
+    byRepo.set(repo, entry);
+  }
+  const heads = await Promise.all(
+    [...byRepo.keys()].map(async (repo) => [repo, await latestGithubCommit(repo)])
+  );
+  let moved = 0;
+  for (const [repo, head] of heads) {
+    const { skills, pinned } = byRepo.get(repo);
+    if (!pinned)
+      p4.log.warn(
+        `${repo}: sin pin en upstreams.json \u2014 a\xF1ade el commit revisado. Skills: ${skills.join(", ")}`
+      );
+    else if (head === null)
+      p4.log.info(`${repo}: pin ${pinned.slice(0, 7)} (no se pudo consultar el upstream).`);
+    else if (head === pinned)
+      p4.log.success(`${repo}: al d\xEDa con el pin ${pinned.slice(0, 7)} (${skills.join(", ")}).`);
+    else {
+      moved++;
+      p4.log.warn(
+        `${repo}: el upstream se movi\xF3 (pin ${pinned.slice(0, 7)} \u2192 ${head.slice(0, 7)}). Skills: ${skills.join(", ")}.
+  Revisa el diff y, si lo aceptas, actualiza la copia vendorizada y el pin: github.com/${repo}/compare/${pinned.slice(0, 7)}...${head.slice(0, 7)}`
+      );
+    }
+  }
+  if (moved === 0 && heads.every(([, head]) => head !== null)) {
+    p4.log.info("Skills de terceros: ning\xFAn upstream se ha movido respecto a su pin.");
+  }
+  if (githubRateLimited()) {
+    p4.log.warn(rateLimitHint("GitHub limit\xF3 algunas consultas (rate limit sin token)."));
+  }
+  p4.outro("Check completado.");
+  return 0;
+}
+function isEngramRunning() {
+  try {
+    if (process.platform === "win32") {
+      const ps = lookPath("powershell") ?? lookPath("pwsh");
+      if (ps) {
+        const out = runDetectedBin(ps, ["-NoProfile", "-Command", "Get-Process -Name engram -ErrorAction SilentlyContinue | Measure-Object | Select-Object -ExpandProperty Count"], 5e3);
+        return out !== null ? parseInt(out.trim(), 10) > 0 : null;
+      }
+      return null;
+    } else {
+      const pgrep = lookPath("pgrep");
+      if (!pgrep) return null;
+      try {
+        execFileSync4(pgrep, ["-x", "engram"], { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  } catch {
+    return null;
+  }
+}
+function isGitClone() {
+  const projectRoot = path22.dirname(stackRoot());
+  return fs16.existsSync(path22.join(projectRoot, ".git"));
+}
+var STACK_METHOD_CLONE = "git pull + pnpm install + pnpm build";
+function resolvePnpm() {
+  const bin = lookPath("pnpm") ?? lookPath("pnpm.cmd") ?? lookPath("pnpm.ps1");
+  if (!bin) throw new Error("pnpm no encontrado en PATH.");
+  return bin;
+}
+function cleanupTmp(dir) {
+  try {
+    fs16.rmSync(dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function updateStackGitClone() {
+  const projectRoot = path22.dirname(stackRoot());
+  const git = lookPath("git");
+  if (!git) throw new Error("git no encontrado en PATH.");
+  const pnpm = resolvePnpm();
+  p4.log.info("Ejecutando git pull\u2026");
+  execFileSync4(git, ["pull"], { cwd: projectRoot, stdio: "inherit" });
+  p4.log.info("Ejecutando pnpm install\u2026");
+  execFileSync4(pnpm, ["install"], { cwd: projectRoot, stdio: "inherit" });
+  p4.log.info("Ejecutando pnpm build\u2026");
+  execFileSync4(pnpm, ["build"], { cwd: projectRoot, stdio: "inherit" });
+}
+function updateStackGlobal() {
+  const pnpm = resolvePnpm();
+  p4.log.info("Ejecutando pnpm add -g jorgex-stack@latest\u2026");
+  execFileSync4(pnpm, ["add", "-g", "jorgex-stack@latest"], { stdio: "inherit" });
+}
+async function downloadSkillToTemp(repo, sha, skillPath) {
+  const root = fs16.mkdtempSync(path22.join(os3.tmpdir(), "jorgex-skill-"));
+  try {
+    const result = await downloadRepoTarball(repo, sha, root, skillPath);
+    if (!result.ok) {
+      cleanupTmp(root);
+      return { error: result.reason };
+    }
+    if (skillPath) {
+      const sub = path22.resolve(path22.join(root, skillPath));
+      if (!isContainedIn(sub, root)) {
+        cleanupTmp(root);
+        return { error: `la ruta "${skillPath}" escapa del directorio temporal` };
+      }
+      if (fs16.existsSync(sub)) return { dir: sub, root };
+      const lastSeg = skillPath.split("/").pop();
+      const sub2 = path22.resolve(path22.join(root, lastSeg));
+      if (isContainedIn(sub2, root) && fs16.existsSync(sub2)) {
+        if (!validateExtractedTree(sub2)) {
+          cleanupTmp(root);
+          return { error: `el sub\xE1rbol "${lastSeg}" contiene symlinks o rutas fuera del destino` };
+        }
+        return { dir: sub2, root };
+      }
+      cleanupTmp(root);
+      return { error: `la ruta "${skillPath}" no existe en el tarball del upstream` };
+    }
+    return { dir: root, root };
+  } catch (err) {
+    cleanupTmp(root);
+    return { error: err instanceof Error ? err.message : "error desconocido" };
+  }
+}
+function pruneEngramDbBackups() {
+  try {
+    const dir = dataDir();
+    if (!fs16.existsSync(dir)) return;
+    const backups = fs16.readdirSync(dir).filter((f) => f.startsWith("engram-db-backup-") && f.endsWith(".db")).map((f) => ({ name: f, mtime: fs16.statSync(path22.join(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+    for (const old of backups.slice(3)) {
+      try {
+        fs16.rmSync(path22.join(dir, old.name));
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function rotateLockedBinary(binPath, sweepRoot = HOME) {
+  if (!fs16.existsSync(binPath)) return null;
+  const dir = path22.dirname(binPath);
+  const base = path22.basename(binPath);
+  const escapedBase = base.replace(/[.*+?^$()|[\]{}\\]/g, "\\$&");
+  const oldPattern = new RegExp("^" + escapedBase + "\\.old-\\d+$");
+  const resolvedDir = path22.resolve(dir);
+  if (resolvedDir === path22.resolve(sweepRoot) || isContainedIn(resolvedDir, sweepRoot)) {
+    try {
+      for (const entry of fs16.readdirSync(dir)) {
+        if (oldPattern.test(entry)) {
+          try {
+            fs16.rmSync(path22.join(dir, entry), { force: true });
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const rotated = path22.join(dir, `${base}.old-${Date.now()}`);
+  fs16.renameSync(binPath, rotated);
+  return rotated;
+}
+async function updateEngram(engramRepo, latestVersion) {
+  if (isEngramRunning()) {
+    p4.log.info(
+      "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 ?? path22.join(HOME, ".engram");
+  const engramDb = path22.join(engramDataDir, "engram.db");
+  if (fs16.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 = path22.join(dataDir(), `engram-db-backup-${ts}.db`);
+      try {
+        if (!fs16.existsSync(dataDir())) fs16.mkdirSync(dataDir(), { recursive: true });
+        fs16.copyFileSync(engramDb, dest);
+        p4.log.success(`DB respaldada en ${dest} (la DB original NO se modifica jam\xE1s).`);
+        pruneEngramDbBackups();
+      } catch (err) {
+        p4.log.warn(`No se pudo copiar la DB: ${err instanceof Error ? err.message : err}. Continuando sin backup.`);
+      }
+    }
+  }
+  let anyChannelTried = false;
+  const brew = lookPath("brew");
+  if (brew) {
+    let brewManages = false;
+    try {
+      execFileSync4(brew, ["list", "engram"], { stdio: "pipe" });
+      brewManages = true;
+    } catch {
+    }
+    if (brewManages) {
+      anyChannelTried = true;
+      p4.log.info("Actualizando engram con brew\u2026");
+      try {
+        execFileSync4(brew, ["upgrade", "engram"], { stdio: "inherit" });
+        return true;
+      } catch (err) {
+        p4.log.error(`brew upgrade engram fall\xF3: ${err instanceof Error ? err.message : err}`);
+        return false;
+      }
+    }
+  }
+  const go = lookPath("go");
+  if (go) {
+    anyChannelTried = true;
+    let rotated = null;
+    const bin = detectEngram();
+    if (process.platform === "win32" && bin) {
+      try {
+        rotated = rotateLockedBinary(bin);
+      } catch (err) {
+        p4.log.warn(
+          `No se pudo rotar el binario en uso: ${err instanceof Error ? err.message : err}. go install puede fallar por bloqueo.`
+        );
+      }
+    }
+    p4.log.info(`Actualizando engram con go install (${latestVersion})\u2026`);
+    try {
+      execFileSync4(
+        go,
+        ["install", `github.com/Gentleman-Programming/engram/cmd/engram@v${latestVersion}`],
+        { stdio: "inherit" }
+      );
+      const rollbackOk = resolveEngramRollback({ installOk: true, rotated, bin, binExists: fs16.existsSync(bin ?? "") });
+      if (rollbackOk.action === "restore") {
+        try {
+          fs16.renameSync(rotated, bin);
+          p4.log.warn(rollbackOk.messages.onRestore);
+        } catch {
+          p4.log.warn(rollbackOk.messages.onRenameFail);
+        }
+      }
+      return true;
+    } catch (err) {
+      const rollbackFail = resolveEngramRollback({ installOk: false, rotated, bin, binExists: fs16.existsSync(bin ?? "") });
+      if (rollbackFail.action === "restore") {
+        try {
+          fs16.renameSync(rotated, bin);
+          p4.log.info(rollbackFail.messages.onRestore);
+        } catch {
+          p4.log.error(rollbackFail.messages.onRenameFail);
+        }
+      } else if (rollbackFail.action === "leave_old") {
+        p4.log.warn(rollbackFail.messages.onLeaveOld);
+      }
+      p4.log.error(`go install fall\xF3: ${err instanceof Error ? err.message : err}`);
+      return false;
+    }
+  }
+  if (anyChannelTried) {
+    p4.log.error(
+      `Los canales de actualizaci\xF3n disponibles fallaron \u2014 revisa el error arriba; descarga manual: github.com/${engramRepo}/releases/tag/v${latestVersion}`
+    );
+  } else {
+    p4.log.warn(
+      `No se encontr\xF3 brew ni go en PATH.
+  Descarga manual: github.com/${engramRepo}/releases/tag/v${latestVersion}`
+    );
+  }
+  return false;
+}
+function resolveEngramRollback(input) {
+  const { installOk, rotated, bin, binExists } = input;
+  if (!rotated || !bin) return { action: "none" };
+  if (installOk && !binExists) {
+    return {
+      action: "restore",
+      messages: {
+        onRestore: `go install instal\xF3 en otra ruta (GOBIN distinto); el binario activo en ${bin} se ha restaurado. Comprueba qu\xE9 engram resuelve tu PATH.`,
+        onRenameFail: `go install instal\xF3 en otra ruta y no se pudo restaurar ${bin}; tu binario anterior est\xE1 en ${rotated}.`
+      }
+    };
+  }
+  if (!installOk && !binExists) {
+    return {
+      action: "restore",
+      messages: {
+        onRestore: "Rotaci\xF3n revertida \u2014 el binario anterior sigue en su sitio.",
+        onRenameFail: `No se pudo revertir la rotaci\xF3n: tu binario anterior est\xE1 en ${rotated} \u2014 ren\xF3mbralo a ${bin} a mano.`
+      }
+    };
+  }
+  if (!installOk && binExists) {
+    return {
+      action: "leave_old",
+      messages: {
+        onLeaveOld: `El install fall\xF3 pero dej\xF3 un binario en ${bin}; tu copia anterior queda en ${rotated}.`
+      }
+    };
+  }
+  return { action: "none" };
+}
+function buildEligibleSkillUpdates(skills) {
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const { name, repo, info, head } of skills) {
+    if (info.kind === "release") continue;
+    const existing = byRepo.get(repo);
+    if (!existing) {
+      byRepo.set(repo, { names: [name], pinned: info.commit ?? "", headVal: head });
+    } else {
+      existing.names.push(name);
+    }
+  }
+  const result = [];
+  for (const [repo, { names, pinned, headVal }] of byRepo) {
+    if (!pinned) continue;
+    if (headVal === null) continue;
+    if (headVal === pinned) continue;
+    for (const name of names) {
+      const skill = skills.find((s) => s.name === name);
+      result.push({
+        name,
+        repo,
+        head: headVal,
+        pinned,
+        skillPath: skill.info.path,
+        modified: skill.info.modified ?? false
+      });
+    }
+  }
+  return result;
+}
+async function runInteractiveUpdate(localVersion, yes, dryRun = false) {
+  if (dryRun || yes || !process.stdout.isTTY) {
+    return { exitCode: await runUpdateCheck(localVersion), appliedUpdates: false };
+  }
+  p4.intro("jorgex-stack update");
+  const upstreams = loadUpstreams();
+  let exitCode = 0;
+  let appliedUpdates = false;
+  const spin = p4.spinner();
+  spin.start("Consultando versiones upstream\u2026");
+  const [npmLatest, engramLatestRaw, ...skillHeads] = await Promise.all([
+    latestNpmVersion("jorgex-stack"),
+    (async () => {
+      const repo = upstreams.tools["engram"]?.source.replace(/^github:/, "");
+      if (!repo) return null;
+      return { repo, version: await latestGithubRelease(repo) };
+    })(),
+    ...Object.keys(upstreams.skills).map(async (name) => {
+      const info = upstreams.skills[name];
+      const repo = info.source.replace(/^github:/, "");
+      const head = await latestGithubCommit(repo);
+      return { name, repo, info, head };
+    })
+  ]);
+  spin.stop("Consulta completada.");
+  if (githubRateLimited()) {
+    p4.log.warn(rateLimitHint("GitHub limit\xF3 algunas consultas \u2014 los upstreams 'sin conexi\xF3n' pueden ser eso."));
+  }
+  const updateItems = [];
+  const engramData = engramLatestRaw;
+  let stackNeedsUpdate = false;
+  if (npmLatest === null) {
+    p4.log.info(`jorgex-stack: v${localVersion} local (a\xFAn no publicado en npm o sin red).`);
+  } else if (npmLatest === localVersion) {
+    p4.log.success(`jorgex-stack: v${localVersion} \u2014 al d\xEDa.`);
+  } else {
+    stackNeedsUpdate = true;
+    const mode = isGitClone() ? STACK_METHOD_CLONE : `pnpm add -g jorgex-stack@${npmLatest}`;
+    updateItems.push({
+      value: "stack",
+      label: `jorgex-stack: v${localVersion} \u2192 v${npmLatest}`,
+      hint: mode
+    });
+  }
+  let engramNeedsUpdate = false;
+  let engramLocalVersion = null;
+  if (engramData) {
+    const engramBinLocal = detectEngram();
+    engramLocalVersion = engramBinLocal ? engramVersion(engramBinLocal) : null;
+    if (engramLocalVersion === null) {
+      p4.log.warn("engram: no detectado en esta m\xE1quina.");
+    } else if (engramData.version === null) {
+      p4.log.info(`engram: ${engramLocalVersion} local (no se pudo consultar el upstream).`);
+    } else if (engramData.version === engramLocalVersion) {
+      p4.log.success(`engram: ${engramLocalVersion} \u2014 al d\xEDa.`);
+    } else {
+      engramNeedsUpdate = true;
+      updateItems.push({
+        value: "engram",
+        label: `engram: ${engramLocalVersion} \u2192 ${engramData.version}`,
+        hint: "canal nativo (brew \u2192 go install \u2192 URL)"
+      });
+    }
+  }
+  const typedSkillHeads = skillHeads;
+  const loggedRepos = /* @__PURE__ */ new Map();
+  for (const { name, repo, info, head } of typedSkillHeads) {
+    if (info.kind === "release") {
+      if (head !== null && info.commit && head !== info.commit) {
+        p4.log.warn(`${name} (release): upstream se movi\xF3. Revisa: github.com/${repo}/releases`);
+      }
+      continue;
+    }
+    const existing = loggedRepos.get(repo);
+    if (!existing) {
+      loggedRepos.set(repo, { names: [name], pinned: info.commit ?? "", headVal: head, anyRelease: false });
+    } else {
+      existing.names.push(name);
+    }
+  }
+  for (const [repo, { names, pinned, headVal }] of loggedRepos) {
+    if (!pinned) {
+      p4.log.warn(`${repo}: sin pin \u2014 no se puede actualizar. Skills: ${names.join(", ")}`);
+    } else if (headVal === null) {
+      p4.log.info(`${repo}: sin conexi\xF3n al upstream. Skills: ${names.join(", ")}`);
+    } else if (headVal === pinned) {
+      p4.log.success(`${repo}: al d\xEDa (pin ${pinned.slice(0, 7)}). Skills: ${names.join(", ")}`);
+    }
+  }
+  const skillUpdates = buildEligibleSkillUpdates(typedSkillHeads);
+  for (const skillInfo of skillUpdates) {
+    const modifiedWarning = skillInfo.modified ? " \u26A0 modificada localmente" : "";
+    updateItems.push({
+      value: `skill:${skillInfo.name}`,
+      label: `skill ${skillInfo.name}: ${skillInfo.pinned.slice(0, 7)} \u2192 ${skillInfo.head.slice(0, 7)}${modifiedWarning}`,
+      hint: `github.com/${skillInfo.repo}/compare/${skillInfo.pinned.slice(0, 7)}...${skillInfo.head.slice(0, 7)}`
+    });
+  }
+  if (updateItems.length === 0) {
+    p4.outro("Todo al d\xEDa. No hay actualizaciones disponibles.");
+    return { exitCode: 0, appliedUpdates: false };
+  }
+  const selected = await p4.multiselect({
+    message: "Selecciona qu\xE9 actualizar (espacio para marcar, intro para confirmar):",
+    options: updateItems,
+    initialValues: updateItems.map((i) => i.value),
+    required: false
+  });
+  if (p4.isCancel(selected)) {
+    p4.outro("Update cancelado.");
+    return { exitCode: 0, appliedUpdates: false };
+  }
+  if (selected.length === 0) {
+    p4.outro("Nada seleccionado.");
+    return { exitCode: 0, appliedUpdates: false };
+  }
+  const sel = selected;
+  if (stackNeedsUpdate && sel.includes("stack")) {
+    const isClone = isGitClone();
+    const method = isClone ? STACK_METHOD_CLONE : "pnpm add -g jorgex-stack@latest";
+    const confirm5 = await p4.confirm({
+      message: `Actualizar el stack con: ${method}`,
+      initialValue: true
+    });
+    if (p4.isCancel(confirm5) || !confirm5) {
+      p4.log.info("Stack: actualizaci\xF3n omitida.");
+    } else {
+      try {
+        if (isClone) {
+          updateStackGitClone();
+        } else {
+          updateStackGlobal();
+        }
+        p4.log.success("Stack actualizado correctamente.");
+        appliedUpdates = true;
+      } catch (err) {
+        p4.log.error(`Stack: error al actualizar \u2014 ${err instanceof Error ? err.message : err}`);
+        exitCode = 1;
+      }
+    }
+  }
+  for (const skillInfo of skillUpdates) {
+    if (!sel.includes(`skill:${skillInfo.name}`)) continue;
+    if (skillInfo.modified) {
+      p4.log.warn(
+        `skill ${skillInfo.name}: TIENE CAMBIOS LOCALES. Actualizar sobreescribir\xE1 esas modificaciones (backup autom\xE1tico).`
+      );
+      const forceConfirm = await p4.confirm({
+        message: `\xBFConfirmas sobreescribir los cambios locales de ${skillInfo.name}?`,
+        initialValue: false
+      });
+      if (p4.isCancel(forceConfirm) || !forceConfirm) {
+        p4.log.info(`skill ${skillInfo.name}: omitida.`);
+        continue;
+      }
+    }
+    const spin2 = p4.spinner();
+    spin2.start(`Descargando upstream de ${skillInfo.name}\u2026`);
+    const tmpResult = await downloadSkillToTemp(skillInfo.repo, skillInfo.head, skillInfo.skillPath);
+    spin2.stop("error" in tmpResult ? "Error de descarga." : "Descargado.");
+    if ("error" in tmpResult) {
+      p4.log.error(`skill ${skillInfo.name}: descarga fallida \u2014 ${tmpResult.error}. Omitiendo.`);
+      exitCode = 1;
+      continue;
+    }
+    const { dir: tmpDir, root: tmpRoot } = tmpResult;
+    const localSkillDir = path22.join(stackRoot(), "skills", skillInfo.name);
+    const diff = renderSkillDiff(tmpDir, localSkillDir);
+    if (diff) {
+      p4.log.info(`Diff de ${skillInfo.name}:
+${diff}`);
+    } else {
+      p4.log.info(`${skillInfo.name}: sin cambios en contenido (el repo se movi\xF3 pero la skill no cambi\xF3).`);
+      cleanupTmp(tmpRoot);
+      continue;
+    }
+    const applySkill = await p4.confirm({
+      message: `\xBFAplicar la actualizaci\xF3n de ${skillInfo.name}?`,
+      // Default No — política deliberate-pin (el diff es de contenido)
+      initialValue: false
+    });
+    if (p4.isCancel(applySkill) || !applySkill) {
+      p4.log.info(`skill ${skillInfo.name}: omitida.`);
+      cleanupTmp(tmpRoot);
+      continue;
+    }
+    try {
+      replaceSkill(skillInfo.name, tmpDir, skillInfo.head, {});
+      p4.log.success(`skill ${skillInfo.name}: actualizada y re-pineada a ${skillInfo.head.slice(0, 7)}.`);
+      appliedUpdates = true;
+    } catch (err) {
+      p4.log.error(`skill ${skillInfo.name}: error \u2014 ${err instanceof Error ? err.message : err}`);
+      exitCode = 1;
+    } finally {
+      cleanupTmp(tmpRoot);
+    }
+  }
+  if (engramNeedsUpdate && sel.includes("engram") && engramData?.version) {
+    const confirmEngram = await p4.confirm({
+      message: `Actualizar engram a v${engramData.version} (canal nativo: brew \u2192 go install \u2192 URL)`,
+      initialValue: true
+    });
+    if (p4.isCancel(confirmEngram) || !confirmEngram) {
+      p4.log.info("Engram: actualizaci\xF3n omitida.");
+    } else {
+      const ok = await updateEngram(engramData.repo, engramData.version);
+      if (!ok) {
+        exitCode = 1;
+      } else {
+        const binPost = detectEngram();
+        const versionPost = binPost ? engramVersion(binPost) : null;
+        if (versionPost) {
+          p4.log.success(`Engram: ahora en v${versionPost}.`);
+        } else {
+          p4.log.warn("Engram actualizado, pero no se pudo verificar la versi\xF3n \u2014 comprueba con engram --version");
+        }
+        p4.log.info("Reinicia los clientes (Claude Code/OpenCode/Codex) para que sus MCP usen la versi\xF3n nueva.");
+      }
+    }
+  }
+  p4.outro(exitCode === 0 ? "Update completado." : "Update completado con errores (revisa arriba).");
+  return { exitCode, appliedUpdates };
+}
+
+// src/models-picker.ts
+import path23 from "path";
+import * as p5 from "@clack/prompts";
+var TIERS = ["strong", "standard", "cheap"];
+var EFFORTS = ["low", "medium", "high", "xhigh"];
+var CLAUDE_ALIASES = ["fable", "opus", "sonnet", "haiku", "inherit"];
+var CODEX_MODELS = ["default", "gpt-5.5", "gpt-5.4", "gpt-5.4-mini"];
+var CODEX_CUSTOM = "__custom__";
+var CANCEL = /* @__PURE__ */ Symbol("cancel");
+function opencodeLiveModels(binPath) {
+  const out = runDetectedBin(binPath, ["models"], 2e4);
+  if (out === null) return null;
+  const models = out.split(/\r?\n/).map((l) => l.trim()).filter((l) => l !== "" && l.includes("/"));
+  return models.length > 0 ? models : null;
+}
+function agentsByTier() {
+  const grouped = { strong: [], standard: [], cheap: [] };
+  for (const agent of loadCanonicalAgents(path23.join(stackRoot(), "agents"))) {
+    if (agent.mode === "subagent") grouped[agent.tier].push(agent.name);
+  }
+  return grouped;
+}
+async function askModel(det, subject, current) {
+  if (det.id === "codex") {
+    const effort = await p5.select({
+      message: `${det.name} \xB7 ${subject} \u2014 reasoning effort`,
+      options: EFFORTS.map((v) => ({ value: v, label: v })),
+      initialValue: current.variant ?? "medium"
+    });
+    if (p5.isCancel(effort)) return CANCEL;
+    const modelOptions = [
+      ...CODEX_MODELS.includes(current.model) ? [] : [{ value: current.model, label: `${current.model} (actual)` }],
+      ...CODEX_MODELS.map((m) => ({
+        value: m,
+        label: m === "default" ? "default \u2014 el del CLI, se actualiza solo (recomendado)" : m
+      })),
+      { value: CODEX_CUSTOM, label: "otro\u2026 (escribir un ID a mano)" }
+    ];
+    let model = await p5.select({
+      message: `${det.name} \xB7 ${subject} \u2014 modelo`,
+      options: modelOptions,
+      initialValue: current.model
+    });
+    if (p5.isCancel(model)) return CANCEL;
+    if (model === CODEX_CUSTOM) {
+      const typed = await p5.text({
+        message: `${det.name} \xB7 ${subject} \u2014 ID exacto del modelo (min\xFAsculas; compru\xE9balo con /model dentro de codex)`,
+        initialValue: current.model,
+        validate: (v) => !v || v.trim() === "" ? 'Vac\xEDo no \u2014 usa "default" o un ID.' : void 0
+      });
+      if (p5.isCancel(typed)) return CANCEL;
+      model = typed.trim().toLowerCase();
+    }
+    return { model, variant: effort };
+  }
+  const optionsList = det.options;
+  const options = optionsList.map((m) => ({ value: m, label: m }));
+  if (!optionsList.includes(current.model)) options.unshift({ value: current.model, label: `${current.model} (actual)` });
+  const choice = await p5.select({
+    message: `${det.name} \xB7 ${subject} \u2014 modelo`,
+    options,
+    initialValue: current.model,
+    maxItems: 12
+  });
+  if (p5.isCancel(choice)) return CANCEL;
+  if (det.id === "claude-code") return { model: choice };
+  const keptCurrent = choice === current.model && current.variant ? current.variant : null;
+  const variant = await p5.select({
+    message: `${det.name} \xB7 ${subject} \u2014 reasoning effort (variant; solo si el modelo lo soporta)`,
+    options: [
+      { value: "", label: "(sin variant \u2014 el default del modelo)" },
+      ...EFFORTS.map((v) => ({ value: v, label: v })),
+      ...keptCurrent && !EFFORTS.includes(keptCurrent) ? [{ value: keptCurrent, label: `${keptCurrent} (actual)` }] : []
+    ],
+    initialValue: keptCurrent ?? ""
+  });
+  if (p5.isCancel(variant)) return CANCEL;
+  return { model: choice, ...variant ? { variant } : {} };
+}
+async function runModelsPicker(opts) {
+  const file = ensureModelMapFile();
+  if (opts.yes || !process.stdout.isTTY) {
+    console.log(`Model-map en ${file} (defaults). Ed\xEDtalo o ejecuta 'models' sin --yes para el picker.`);
+    return 0;
+  }
+  p5.intro("jorgex-stack models \u2014 modelos por tier o por subagente");
+  const map = loadModelMap();
+  const grouped = agentsByTier();
+  const tierLine = (tier) => grouped[tier].join(", ");
+  const agentCount = TIERS.reduce((n, tier) => n + grouped[tier].length, 0);
+  const detections = [];
+  if (opts.runtimes.includes("opencode")) {
+    const opencode = detectOpenCode();
+    detections.push({
+      id: "opencode",
+      name: "OpenCode",
+      installed: opencode.installed,
+      options: opencode.binPath ? opencodeLiveModels(opencode.binPath) : null
+    });
+  }
+  if (opts.runtimes.includes("claude-code")) {
+    detections.push({ id: "claude-code", name: "Claude Code", installed: detectClaudeCode().installed, options: CLAUDE_ALIASES });
+  }
+  if (opts.runtimes.includes("codex")) {
+    detections.push({ id: "codex", name: "Codex CLI", installed: detectCodex().installed, options: null });
+  }
+  for (const det of detections) {
+    if (!det.installed) {
+      p5.log.info(`${det.name}: no instalado \u2014 se mantienen los defaults.`);
+      continue;
+    }
+    if (det.id === "opencode" && det.options === null) {
+      p5.log.warn("OpenCode: no se pudo listar `opencode models` \u2014 se mantiene la selecci\xF3n actual.");
+      continue;
+    }
+    const runtimeMap = { ...map[det.id] };
+    p5.log.message(
+      `${det.name} \u2014 tiers y sus subagentes:
+  strong   \u2192 ${tierLine("strong")}
+  standard \u2192 ${tierLine("standard")}
+  cheap    \u2192 ${tierLine("cheap")}`
+    );
+    const mode = await p5.select({
+      message: `${det.name} \u2014 \xBFc\xF3mo asignar los modelos?`,
+      options: [
+        { value: "tier", label: "Por tier \u2014 3 grupos (r\xE1pido)" },
+        { value: "agent", label: `Por subagente \u2014 uno a uno (${agentCount} subagentes, control total)` }
+      ],
+      initialValue: "tier"
+    });
+    if (p5.isCancel(mode)) return cancelled();
+    if (mode === "tier") {
+      for (const tier of TIERS) {
+        const asked = await askModel(det, `tier ${tier} (${tierLine(tier)})`, runtimeMap[tier]);
+        if (asked === CANCEL) return cancelled();
+        runtimeMap[tier] = asked;
+      }
+      const overrideCount = Object.keys(runtimeMap.overrides ?? {}).length;
+      if (overrideCount > 0) {
+        p5.log.info(
+          `${det.name}: se conservan ${overrideCount} ajustes por subagente previos \u2014 elige "Por subagente" para revisarlos.`
+        );
+      }
+    } else {
+      const overrides = { ...runtimeMap.overrides ?? {} };
+      for (const tier of TIERS) {
+        const base = runtimeMap[tier];
+        for (const name of grouped[tier]) {
+          const asked = await askModel(det, `${name} (tier ${tier})`, resolveAgentModel(runtimeMap, name, tier));
+          if (asked === CANCEL) return cancelled();
+          const sameAsTier = asked.model === base.model && (asked.variant ?? "") === (base.variant ?? "");
+          if (sameAsTier) {
+            delete overrides[name];
+          } else {
+            overrides[name] = {
+              model: asked.model,
+              ...asked.variant ? { variant: asked.variant } : base.variant ? { variant: "" } : {}
+            };
+          }
+        }
+      }
+      if (Object.keys(overrides).length > 0) runtimeMap.overrides = overrides;
+      else delete runtimeMap.overrides;
+    }
+    map[det.id] = runtimeMap;
+  }
+  writeText(file, JSON.stringify(map, null, 2) + "\n");
+  p5.log.success(`Guardado en ${file}`);
+  return 0;
+}
+function cancelled() {
+  p5.cancel("Cancelado \u2014 no se ha guardado nada.");
+  return 1;
+}
+
+// src/cli.ts
+var VERSION = "0.6.0";
+var COMMANDS = ["install", "sync", "models", "update", "doctor", "restore", "uninstall"];
+function parseFlags(args) {
+  const flags = {
+    agents: [],
+    dryRun: false,
+    yes: false,
+    list: false,
+    check: false,
+    removeEngram: false,
+    positional: []
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--agents" || arg === "-a") flags.agents = (args[++i] ?? "").split(",").filter(Boolean);
+    else if (arg.startsWith("--agents=")) flags.agents = arg.slice(9).split(",").filter(Boolean);
+    else if (arg === "--target-dir") flags.targetDir = args[++i];
+    else if (arg.startsWith("--target-dir=")) flags.targetDir = arg.slice(13);
+    else if (arg === "--dry-run") flags.dryRun = true;
+    else if (arg === "--yes" || arg === "-y") flags.yes = true;
+    else if (arg === "--list") flags.list = true;
+    else if (arg === "--check") flags.check = true;
+    else if (arg === "--remove-engram") flags.removeEngram = true;
+    else flags.positional.push(arg);
+  }
+  return flags;
+}
+async function resolveRuntimes(flags) {
+  if (flags.agents.length > 0) return flags.agents;
+  const detected = Object.values(ADAPTERS).filter((a) => a.detect().installed);
+  if (detected.length === 0) return [];
+  if (flags.yes || !process.stdout.isTTY || flags.targetDir !== void 0) return detected.map((a) => a.id);
+  const choice = await p6.multiselect({
+    message: "\xBFEn qu\xE9 runtimes? (detectados en esta m\xE1quina)",
+    options: detected.map((a) => ({ value: a.id, label: a.name })),
+    initialValues: detected.map((a) => a.id)
+  });
+  if (p6.isCancel(choice)) return null;
+  return choice;
+}
+function printHelp() {
+  console.log(`jorgex-stack v${VERSION}
+
+Uso: pnpm dlx jorgex-stack [comando] [opciones]
+
+Comandos:
+  install     Instala el stack en los runtimes elegidos (default, interactivo)
+  sync        Re-aplica la config (idempotente; alias de install)
+  models      Picker de modelos por tier (OpenCode: lista en vivo de 'opencode models')
+  update      --check: compara stack/Engram/skills con sus upstreams
+  doctor      Estado: Engram, drift de config, hooks de Codex, key de context7
+  restore     --list para ver backups \xB7 'restore <id>' para restaurar
+  uninstall   Retira SOLO lo gestionado por el stack (con backup).
+              Engram se CONSERVA por defecto (memorias, binario y registro);
+              desregistrarlo exige --remove-engram o el s\xED expl\xEDcito
+
+Opciones:
+  --agents, -a opencode,claude-code,codex   Runtimes destino (default: detectados)
+  --target-dir <dir>    Dir alternativo (pruebas de paridad; requiere 1 runtime)
+  --dry-run             Muestra el plan sin escribir nada
+  --yes, -y             No interactivo
+  --remove-engram       (uninstall) desregistra Engram de los runtimes;
+                        memorias y binario quedan intactos igualmente
+
+Ver PRD.md para el dise\xF1o completo.`);
+}
+async function main() {
+  const [first, ...rest] = process.argv.slice(2);
+  if (first === "--help" || first === "-h") return printHelp();
+  if (first === "--version" || first === "-v") return console.log(VERSION);
+  const isCommand = COMMANDS.includes(first ?? "install");
+  if (first !== void 0 && !isCommand && !first.startsWith("-")) {
+    console.error(`Comando desconocido: ${first}`);
+    printHelp();
+    process.exitCode = 1;
+    return;
+  }
+  const command = isCommand ? first ?? "install" : "install";
+  const flags = parseFlags(isCommand ? rest : process.argv.slice(2));
+  if (flags.targetDir !== void 0 && flags.agents.length !== 1) {
+    console.error("--target-dir requiere exactamente un runtime en --agents.");
+    process.exitCode = 1;
+    return;
+  }
+  switch (command) {
+    case "install":
+    case "sync": {
+      const runtimes = await resolveRuntimes(flags);
+      if (runtimes === null) return;
+      if (runtimes.length === 0) {
+        console.error("Ning\xFAn runtime detectado (opencode, claude-code, codex).");
+        process.exitCode = 1;
+        return;
+      }
+      process.exitCode = await runInstall({ runtimes, targetDir: flags.targetDir, dryRun: flags.dryRun, yes: flags.yes });
+      return;
+    }
+    case "uninstall": {
+      const runtimes = await resolveRuntimes(flags);
+      if (runtimes === null) return;
+      if (runtimes.length === 0) {
+        console.error("Ning\xFAn runtime detectado (opencode, claude-code, codex).");
+        process.exitCode = 1;
+        return;
+      }
+      process.exitCode = await runUninstall({
+        runtimes,
+        targetDir: flags.targetDir,
+        dryRun: flags.dryRun,
+        yes: flags.yes,
+        removeEngram: flags.removeEngram
+      });
+      return;
+    }
+    case "doctor": {
+      process.exitCode = await runDoctor();
+      return;
+    }
+    case "update": {
+      if (flags.check) {
+        process.exitCode = await runUpdateCheck(VERSION);
+        return;
+      }
+      if (flags.dryRun) {
+        process.exitCode = await runUpdateCheck(VERSION);
+        return;
+      }
+      const runtimes = await resolveRuntimes(flags);
+      if (runtimes === null) return;
+      if (runtimes.length > 0) {
+        const code = await runInstall({ runtimes, targetDir: flags.targetDir, dryRun: flags.dryRun, yes: true });
+        if (code !== 0) {
+          process.exitCode = code;
+          return;
+        }
+      }
+      const result = await runInteractiveUpdate(VERSION, flags.yes, flags.dryRun);
+      process.exitCode = result.exitCode;
+      if (result.exitCode === 0 && result.appliedUpdates && runtimes.length > 0 && !flags.yes && process.stdout.isTTY) {
+        const apply = await p6.confirm({ message: "\xBFRe-aplicar a los runtimes ahora? (sync)" });
+        if (!p6.isCancel(apply) && apply) {
+          process.exitCode = await runInstall({ runtimes, targetDir: flags.targetDir, dryRun: false, yes: false });
+        } else {
+          console.log("Sin aplicar. Cuando quieras: jorgex-stack sync");
+        }
+      } else if (result.exitCode === 0 && result.appliedUpdates && runtimes.length > 0 && (flags.yes || !process.stdout.isTTY)) {
+        console.log("Skills/stack actualizados. Ejecuta jorgex-stack sync para aplicarlos a los runtimes.");
+      }
+      return;
+    }
+    case "models": {
+      const runtimes = await resolveRuntimes(flags);
+      if (runtimes === null) return;
+      if (runtimes.length === 0) {
+        console.error("Ning\xFAn runtime detectado (opencode, claude-code, codex).");
+        process.exitCode = 1;
+        return;
+      }
+      const code = await runModelsPicker({ yes: flags.yes, runtimes });
+      process.exitCode = code;
+      if (code === 0 && !flags.yes && process.stdout.isTTY) {
+        const apply = await p6.confirm({ message: "\xBFAplicar ahora los modelos a los agentes instalados? (sync)" });
+        if (!p6.isCancel(apply) && apply) {
+          process.exitCode = await runInstall({ runtimes, targetDir: flags.targetDir, dryRun: flags.dryRun, yes: false });
+        } else {
+          console.log("Sin aplicar. Cuando quieras: jorgex-stack sync");
+        }
+      }
+      return;
+    }
+    case "restore": {
+      if (flags.list || flags.positional.length === 0) {
+        const backups = listBackups();
+        if (backups.length === 0) return console.log("No hay backups.");
+        for (const b of backups) console.log(`${b.id}  (${b.files.length} archivos, ${b.createdAt})`);
+        if (!flags.list) console.log("\nUsa: jorgex-stack restore <id>");
+        return;
+      }
+      const restored = restoreBackup(flags.positional[0]);
+      console.log(`Restaurados ${restored} archivos.`);
+      return;
+    }
+  }
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});