jorgex-stack 1.9.57 → 1.9.59

package/dist/chunk-GOLJ5PA3.js

@@ -0,0 +1,711 @@
+#!/usr/bin/env node
+import {
+  createLocalCapabilityReport,
+  detectCodex,
+  hasManagedMarkdownSection,
+  hasTomlChildSection,
+  hasTomlRootKey,
+  headerName,
+  isCanonicalMcpServerEnabled,
+  loadCanonicalDefaults,
+  multilineStringMask,
+  readTextIfExists,
+  readTomlSection,
+  registerOfficialSetupVerifier,
+  removeNativeHooks,
+  removeSystemPromptSections,
+  removeTomlRootKeyIfExact,
+  removeTomlSection,
+  resolveAgentModel,
+  upsertNativeHooks,
+  upsertTomlRootKeyIfMissing,
+  upsertTomlSection
+} from "./chunk-KB5IQEKL.js";
+import {
+  HOME,
+  samePath,
+  stackRoot
+} from "./chunk-NQZVJFV2.js";
+
+// src/adapters/codex.ts
+import path from "path";
+import fs from "fs";
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function readMcpConfig(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch (error) {
+    const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "UNKNOWN";
+    if (code === "ENOENT") return null;
+    throw new Error(`Codex: no se pudo leer la configuraci\xF3n MCP en ${file} (${code}).`);
+  }
+}
+var PRIMARY_MODEL = '"gpt-5.6-sol"';
+var PRIMARY_CONTEXT_WINDOW = "872000";
+var PRIMARY_MODEL_FIELD = "model";
+var PRIMARY_CONTEXT_FIELD = "model_context_window";
+function tomlMultiline(value) {
+  if (value.includes("'''")) return JSON.stringify(value);
+  return `'''
+${value.replace(/\r\n/g, "\n").trim()}
+'''`;
+}
+function stdioMcpSection(server) {
+  const args = (server.args ?? []).map(tomlString).join(", ");
+  return `command = ${tomlString(server.command)}
+args = [${args}]`;
+}
+function isManagedOptionalStdioServer(server, section) {
+  return server.optional === true && server.transport === "stdio" && section?.trim() === stdioMcpSection(server);
+}
+function hasActiveEngramPlugin(configDir) {
+  const config = readTextIfExists(path.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 (fs.existsSync(path.join(configDir, "engram-instructions.md"))) return true;
+  const config = readTextIfExists(path.join(configDir, "config.toml"));
+  return config !== null && /engram-instructions\.md/.test(config);
+}
+var CODEX_JSON_STRING = String.raw`"(?:\\.|[^"\\\r\n])*"`;
+var CODEX_JSON_VALUE = String.raw`(?:${CODEX_JSON_STRING}|-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?|true|false)`;
+var CODEX_JSON_STRING_ARRAY = String.raw`\[(?:\s*${CODEX_JSON_STRING}(?:\s*,\s*${CODEX_JSON_STRING})*\s*)?\]`;
+var CODEX_KEY = String.raw`(?:[A-Za-z0-9_-]+|${CODEX_JSON_STRING})`;
+var CODEX_ASSIGNMENT = new RegExp(String.raw`^\s*(${CODEX_KEY})\s*=\s*(${CODEX_JSON_STRING_ARRAY}|${CODEX_JSON_VALUE})\s*(?:#.*)?$`);
+var CODEX_HEADER = new RegExp(String.raw`^\[\s*(${CODEX_KEY}(?:\s*\.\s*${CODEX_KEY})*)\s*\]\s*(?:#.*)?$`);
+function tomlAssignment(section, key) {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const keyPattern = new RegExp(`^\\s*(?:${escaped}|"${escaped}"|'${escaped}')\\s*=`);
+  const lines = section.split(/\r?\n/);
+  const mask = multilineStringMask(lines);
+  for (const [index, line] of lines.entries()) {
+    if (mask[index] || !keyPattern.test(line)) continue;
+    const match = CODEX_ASSIGNMENT.exec(line);
+    if (match) return { present: true, raw: match[2] };
+    const equals = line.indexOf("=");
+    const raw = equals === -1 ? void 0 : line.slice(equals + 1).trim().replace(/\s+#.*$/, "");
+    return { present: true, ...raw?.startsWith("'") && raw.endsWith("'") ? { raw } : {} };
+  }
+  return { present: false };
+}
+function parseTomlString(raw) {
+  if (raw === void 0) return void 0;
+  const value = raw.trim();
+  if (value.startsWith('"')) {
+    try {
+      const parsed = JSON.parse(value);
+      return typeof parsed === "string" ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return void 0;
+}
+function context7HttpSection(server) {
+  const body = [`url = ${tomlString(server.url)}`];
+  const envHeaders = [];
+  const literalHeaders = [];
+  for (const [key, raw] of Object.entries(server.headers ?? {})) {
+    const envRef = /^\$\{(\w+)\}$/.exec(raw);
+    if (envRef) envHeaders.push(`${tomlString(key)} = ${tomlString(envRef[1])}`);
+    else literalHeaders.push(`${tomlString(key)} = ${tomlString(raw)}`);
+  }
+  if (literalHeaders.length > 0) body.push(`http_headers = { ${literalHeaders.join(", ")} }`);
+  if (envHeaders.length > 0) body.push(`env_http_headers = { ${envHeaders.join(", ")} }`);
+  return body.join("\n");
+}
+function isCompatibleContext7Server(server, section) {
+  if (server.transport !== "http" || typeof server.url !== "string" || section === null) return false;
+  const url = tomlAssignment(section, "url");
+  const command = tomlAssignment(section, "command");
+  const type = tomlAssignment(section, "type");
+  const enabled = tomlAssignment(section, "enabled");
+  const declaredType = type.present ? parseTomlString(type.raw) : "http";
+  return url.present && parseTomlString(url.raw) === server.url && !command.present && declaredType === "http" && (!enabled.present || enabled.raw?.trim() === "true");
+}
+function isCanonicalContext7Server(server, section, config) {
+  return isCompatibleContext7Server(server, section) && section.trim() === context7HttpSection(server) && !hasTomlChildSection(config, "mcp_servers.context7");
+}
+function assertCompatibleContext7(server, section, config) {
+  if (section === null && hasTomlChildSection(config, "mcp_servers.context7") || section !== null && !isCompatibleContext7Server(server, section)) {
+    throw new Error("Codex: MCP 'context7' entra en conflicto con una definici\xF3n existente (endpoint, tipo o estado nativo incompatible). Conserva la configuraci\xF3n y corrige el conflicto antes de reintentar.");
+  }
+}
+var CODEX_PERMISSION_HEADERS = {
+  base: "permissions.jorgex-read-anywhere",
+  filesystem: "permissions.jorgex-read-anywhere.filesystem",
+  workspaceRoots: 'permissions.jorgex-read-anywhere.filesystem.":workspace_roots"'
+};
+var CODEX_PERMISSION_PROFILE = {
+  base: [["extends", ":workspace"]],
+  filesystem: [
+    [":root", "read"],
+    ["~/.ssh/**", "deny"],
+    ["~/.aws/credentials", "deny"],
+    ["~/.npmrc", "deny"],
+    ["~/.git-credentials", "deny"]
+  ],
+  workspaceRoots: [
+    [".", "write"],
+    ["*.env", "deny"],
+    ["*.env.*", "deny"],
+    [".ssh/**", "deny"],
+    [".aws/credentials", "deny"],
+    [".npmrc", "deny"],
+    [".git-credentials", "deny"],
+    ["**/id_rsa", "deny"],
+    ["**/id_ed25519", "deny"],
+    ["**/*.pem", "deny"],
+    ["**/*.key", "deny"]
+  ]
+};
+var CODEX_PERMISSION_SECTIONS = [
+  { header: CODEX_PERMISSION_HEADERS.base, entries: CODEX_PERMISSION_PROFILE.base, quoteKeys: false },
+  { header: CODEX_PERMISSION_HEADERS.filesystem, entries: CODEX_PERMISSION_PROFILE.filesystem, quoteKeys: true },
+  { header: CODEX_PERMISSION_HEADERS.workspaceRoots, entries: CODEX_PERMISSION_PROFILE.workspaceRoots, quoteKeys: true }
+];
+function renderCodexPermissionEntries(entries, quoteKeys) {
+  return entries.map(([key, value]) => `${quoteKeys ? JSON.stringify(key) : key} = ${JSON.stringify(value)}`).join("\n");
+}
+var CODEX_STALE_PERMISSIONS_WARNING = "Codex: permission profile differs from the stack default and was left untouched; re-run with --upgrade-permissions to replace it (a backup is created first), or edit it by hand. Overwriting discards your own permission changes, including any extra hardenings.";
+function codexNormalizedHeader(header) {
+  return headerName(`[${header}]`) ?? header;
+}
+function readCodexRootValue(config, key) {
+  const lines = config.replace(/\r\n/g, "\n").split("\n");
+  const mask = multilineStringMask(lines);
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const keyPattern = new RegExp(`^\\s*(?:${escaped}|"${escaped}"|'${escaped}')\\s*=`);
+  for (const [index, line] of lines.entries()) {
+    if (mask[index]) continue;
+    if (line.trim().startsWith("[")) break;
+    if (!keyPattern.test(line)) continue;
+    const match = CODEX_ASSIGNMENT.exec(line.trim());
+    return match === null ? void 0 : parseTomlString(match[2]);
+  }
+  return void 0;
+}
+function setCodexRootKey(config, key, value) {
+  const eol = config.includes("\r\n") ? "\r\n" : "\n";
+  const lines = config.replace(/\r\n/g, "\n").split("\n");
+  const mask = multilineStringMask(lines);
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const keyPattern = new RegExp(`^\\s*(?:${escaped}|"${escaped}"|'${escaped}')\\s*=`);
+  const assignment = new RegExp(
+    `^(\\s*(?:${escaped}|"${escaped}"|'${escaped}')\\s*=\\s*)(${CODEX_JSON_STRING_ARRAY}|${CODEX_JSON_VALUE})(\\s*(?:#.*)?)$`
+  );
+  for (const [index, line] of lines.entries()) {
+    if (mask[index]) continue;
+    if (line.trim().startsWith("[")) break;
+    if (!keyPattern.test(line)) continue;
+    const match = assignment.exec(line);
+    lines[index] = match === null ? `${key} = ${value}` : `${match[1]}${value}${match[3]}`;
+    return lines.join(eol);
+  }
+  return upsertTomlRootKeyIfMissing(config, key, value);
+}
+function isCodexPermissionBlockCurrent(config, defaults) {
+  const expectedApproval = defaults["approval_policy"];
+  const expectedDefault = defaults["default_permissions"];
+  if (typeof expectedApproval !== "string" || typeof expectedDefault !== "string") return true;
+  if (readCodexRootValue(config, "approval_policy") !== expectedApproval) return false;
+  if (readCodexRootValue(config, "default_permissions") !== expectedDefault) return false;
+  return CODEX_PERMISSION_SECTIONS.every(
+    ({ header, entries, quoteKeys }) => (readTomlSection(config, codexNormalizedHeader(header)) ?? "").trim() === renderCodexPermissionEntries(entries, quoteKeys).trim()
+  );
+}
+function reseedCodexPermissionBlock(config, defaults) {
+  let out = setCodexRootKey(config, "approval_policy", tomlString(String(defaults["approval_policy"])));
+  out = setCodexRootKey(out, "default_permissions", tomlString(String(defaults["default_permissions"])));
+  for (const { header, entries, quoteKeys } of CODEX_PERMISSION_SECTIONS) {
+    out = upsertTomlSection(out, header, renderCodexPermissionEntries(entries, quoteKeys));
+  }
+  return out;
+}
+function parseCodexKey(raw) {
+  if (!raw.startsWith('"')) return raw;
+  try {
+    const value = JSON.parse(raw);
+    return typeof value === "string" ? value : null;
+  } catch {
+    return null;
+  }
+}
+function parseCodexValue(raw) {
+  try {
+    const value = JSON.parse(raw);
+    return Array.isArray(value) && value.every((item) => typeof item === "string") || !Array.isArray(value) && (value === null || typeof value !== "object") ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseCodexHeader(line) {
+  const match = CODEX_HEADER.exec(line.trim());
+  if (match === null) return null;
+  for (const quoted of match[1].match(/"(?:\\.|[^"\\\r\n])*"/g) ?? []) {
+    if (parseCodexKey(quoted) === null) return null;
+  }
+  return match[1].replace(/\s*\.\s*/g, ".");
+}
+function scanCodexToml(config) {
+  if (config.includes("'''") || config.includes('"""')) return null;
+  const root = /* @__PURE__ */ new Map();
+  const sections = /* @__PURE__ */ new Map();
+  const headers = /* @__PURE__ */ new Set();
+  const keys = /* @__PURE__ */ new Set();
+  let section = null;
+  for (const line of config.replace(/\r\n/g, "\n").split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("[")) {
+      const header = parseCodexHeader(trimmed);
+      if (header === null || headers.has(header)) return null;
+      headers.add(header);
+      if (header.startsWith(`${CODEX_PERMISSION_HEADERS.base}.`) && !CODEX_PERMISSION_SECTIONS.some((entry) => entry.header === header)) {
+        return null;
+      }
+      section = header;
+      if (CODEX_PERMISSION_SECTIONS.some((entry) => entry.header === header)) sections.set(header, /* @__PURE__ */ new Map());
+      continue;
+    }
+    const relevant = section === null || CODEX_PERMISSION_SECTIONS.some((entry) => entry.header === section);
+    const match = CODEX_ASSIGNMENT.exec(trimmed);
+    if (!relevant && match === null) continue;
+    if (match === null) return null;
+    const key = parseCodexKey(match[1]);
+    const value = parseCodexValue(match[2]);
+    if (key === null || value === void 0) return null;
+    if (section === null && (key === "profile" || key === "sandbox_mode")) return null;
+    const scope = section ?? "<root>";
+    const declaration = `${scope}\0${key}`;
+    if (keys.has(declaration)) return null;
+    keys.add(declaration);
+    if (section === null) root.set(key, value);
+    else if (sections.has(section)) sections.get(section).set(key, value);
+  }
+  return { root, sections };
+}
+function hasCanonicalCodexPermissionProfile(scan) {
+  for (const { header, entries } of CODEX_PERMISSION_SECTIONS) {
+    const actual = scan.sections.get(header);
+    if (actual === void 0 || actual.size !== entries.length) return false;
+    for (const [key, expected] of entries) {
+      if (actual.get(key) !== expected) return false;
+    }
+  }
+  return true;
+}
+function hasCodexManualApproval(configDir) {
+  const config = readTextIfExists(path.join(configDir, "config.toml"));
+  if (config === null) return false;
+  const scan = scanCodexToml(config);
+  if (scan === null) return false;
+  try {
+    const defaults = loadCanonicalDefaults(stackRoot())["codex"];
+    const expectedApproval = defaults?.["approval_policy"];
+    const expectedPermissions = defaults?.["default_permissions"];
+    return typeof expectedApproval === "string" && typeof expectedPermissions === "string" && scan.root.get("approval_policy") === expectedApproval && scan.root.get("default_permissions") === expectedPermissions && hasCanonicalCodexPermissionProfile(scan);
+  } catch {
+    return false;
+  }
+}
+var codexAdapter = {
+  id: "codex",
+  name: "Codex CLI",
+  detect: detectCodex,
+  reportCapabilities(configDir) {
+    const prompt = readTextIfExists(path.join(configDir, "AGENTS.md"));
+    return createLocalCapabilityReport("codex", [
+      ...hasManagedMarkdownSection(prompt, "system-prompt") ? [{
+        id: "policy-guidance",
+        state: "prompt-only",
+        reason: "The managed policy prompt is advisory and cannot enforce the policy",
+        evidence: { source: "jorgex-stack-system-prompt", version: "1" }
+      }] : [],
+      ...hasCodexManualApproval(configDir) ? [{
+        id: "tool-approval",
+        state: "manual",
+        reason: "Canonical approval declarations require a human decision; runtime activation is not certified",
+        evidence: { source: "jorgex-stack-codex-approval-policy", version: "1" }
+      }] : [],
+      {
+        id: "external-verification",
+        state: "unavailable",
+        reason: "External verification is available only through the external verifier"
+      }
+    ]);
+  },
+  injectEngramProtocol(ctx) {
+    return !hasEngramProtocol(ctx.configDir);
+  },
+  paths(configDir) {
+    const isRealConfigDir = samePath(configDir, process.env.CODEX_HOME ?? path.join(HOME, ".codex"));
+    const agentsHome = isRealConfigDir ? HOME : path.dirname(configDir);
+    const skillsDir = path.join(agentsHome, ".agents", "skills");
+    return {
+      systemPromptFile: path.join(configDir, "AGENTS.md"),
+      agentsDir: path.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: path.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)}`
+      ];
+      return [{ file: `${agent.name}.config.toml`, content: profileLines.join("\n") + "\n", kind: "profile" }];
+    }
+    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 = path.join(ctx.configDir, "hooks.json");
+    const content = upsertNativeHooks(
+      readTextIfExists(hooksFile),
+      canonical,
+      scriptsDir,
+      (matcher) => matcher.split("|").some((p) => p.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 = path.join(ctx.stackDir, "scripts");
+    if (fs.existsSync(scriptsSource)) {
+      for (const f of fs.readdirSync(scriptsSource)) {
+        actions.push({ kind: "copy", source: path.join(scriptsSource, f), target: path.join(scriptsDir, f) });
+      }
+    }
+    return actions;
+  },
+  planMainConfig(canonical, ctx) {
+    const file = path.join(ctx.configDir, "config.toml");
+    const original = readMcpConfig(file);
+    const contentSource = original === null || original.trim() === "" ? null : original;
+    let content = contentSource;
+    const mcpOwnership = [];
+    const primaryModelOwnership = [];
+    const context7 = canonical.servers.context7;
+    if (context7 !== void 0) {
+      assertCompatibleContext7(context7, readTomlSection(contentSource, "mcp_servers.context7"), contentSource);
+    }
+    if (contentSource === null) {
+      const defaults = loadCanonicalDefaults(ctx.stackDir)["codex"] ?? {};
+      for (const [key, value] of Object.entries(defaults)) {
+        const line = `${key} = ${tomlString(String(value))}
+`;
+        content = content === null ? line : line + content;
+      }
+      ctx.warnings.push(
+        "Codex: fresh config enables read-anywhere via the jorgex-read-anywhere permission profile; broad local reads can expose secrets not covered by deny rules."
+      );
+      content = upsertTomlSection(
+        content,
+        CODEX_PERMISSION_HEADERS.base,
+        renderCodexPermissionEntries(CODEX_PERMISSION_PROFILE.base, false)
+      );
+      content = upsertTomlSection(
+        content,
+        CODEX_PERMISSION_HEADERS.filesystem,
+        renderCodexPermissionEntries(CODEX_PERMISSION_PROFILE.filesystem, true)
+      );
+      content += [
+        `
+[${CODEX_PERMISSION_HEADERS.workspaceRoots}]`,
+        renderCodexPermissionEntries(CODEX_PERMISSION_PROFILE.workspaceRoots, true),
+        ""
+      ].join("\n");
+    }
+    if (contentSource !== null) {
+      const codexDefaults = loadCanonicalDefaults(ctx.stackDir)["codex"];
+      if (codexDefaults !== void 0 && !isCodexPermissionBlockCurrent(contentSource, codexDefaults)) {
+        if (ctx.upgradePermissions === true) {
+          content = reseedCodexPermissionBlock(content, codexDefaults);
+        } else {
+          ctx.warnings.push(CODEX_STALE_PERMISSIONS_WARNING);
+        }
+      }
+    }
+    if (!hasTomlRootKey(content, PRIMARY_MODEL_FIELD)) {
+      content = upsertTomlRootKeyIfMissing(content, PRIMARY_MODEL_FIELD, PRIMARY_MODEL);
+      if (ctx.ownedPrimaryModelFields?.has(PRIMARY_MODEL_FIELD) !== true) {
+        primaryModelOwnership.push({ field: PRIMARY_MODEL_FIELD, owned: true });
+      }
+    }
+    if (!hasTomlRootKey(content, PRIMARY_CONTEXT_FIELD)) {
+      content = upsertTomlRootKeyIfMissing(content, PRIMARY_CONTEXT_FIELD, PRIMARY_CONTEXT_WINDOW);
+      if (ctx.ownedPrimaryModelFields?.has(PRIMARY_CONTEXT_FIELD) !== true) {
+        primaryModelOwnership.push({ field: PRIMARY_CONTEXT_FIELD, owned: true });
+      }
+    }
+    for (const [name, server] of Object.entries(canonical.servers)) {
+      if (name === "engram" && hasActiveEngramPlugin(ctx.configDir)) {
+        if (ctx.ownedMcpServers?.has(name) === true) {
+          mcpOwnership.push({ server: name, owned: false });
+        }
+        ctx.warnings.push(
+          "Codex: plugin oficial de Engram activo \u2014 sus hooks y skill no incluyen el MCP; el setup registra un MCP user separado que Stack no posee ni muta."
+        );
+        continue;
+      }
+      const section = `mcp_servers.${name}`;
+      const existing = readTomlSection(content, section);
+      const owned = ctx.ownedMcpServers?.has(name) === true;
+      if (name === "context7" && existing !== null) {
+        if (owned && !isCanonicalContext7Server(server, existing, content)) {
+          mcpOwnership.push({ server: name, owned: false });
+        }
+        continue;
+      }
+      if (!isCanonicalMcpServerEnabled(name, server, ctx.enabledMcpServers)) {
+        if (owned) {
+          if (isManagedOptionalStdioServer(server, existing)) content = removeTomlSection(content, section);
+          mcpOwnership.push({ server: name, owned: false });
+        }
+        continue;
+      }
+      if (server.optional && existing !== null) {
+        if (!owned || !isManagedOptionalStdioServer(server, existing)) {
+          if (owned) mcpOwnership.push({ server: name, owned: false });
+          ctx.warnings.push(`Codex: MCP opcional '${name}' ya pertenece a la configuraci\xF3n del usuario; se conserva.`);
+          continue;
+        }
+      }
+      if (server.transport === "stdio") {
+        if (server.command === "{{ENGRAM_BIN}}" && 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;
+        content = upsertTomlSection(content, section, `command = ${tomlString(command)}
+args = [${(server.args ?? []).map(tomlString).join(", ")}]`);
+        if (server.optional && existing === null && !owned) mcpOwnership.push({ server: name, owned: true });
+      } else {
+        const previousSection = readTomlSection(content, section);
+        const prevUsesEnvHeaders = previousSection?.includes("env_http_headers") ?? false;
+        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 (name === "context7" && existing === null && !owned) {
+          mcpOwnership.push({ server: name, owned: true });
+        }
+      }
+    }
+    if (content === null) return [];
+    if (!content.endsWith("\n")) content += "\n";
+    return [{
+      kind: "write",
+      target: file,
+      content,
+      ...mcpOwnership.length > 0 ? { mcpOwnership } : {},
+      ...primaryModelOwnership.length > 0 ? { primaryModelOwnership } : {}
+    }];
+  },
+  planUnmerge(mcp, hooks, ctx) {
+    const actions = [];
+    const { systemPromptFile } = this.paths(ctx.configDir);
+    const prompt = readTextIfExists(systemPromptFile);
+    if (prompt !== null) {
+      const content = removeSystemPromptSections(prompt);
+      actions.push({ kind: "write", target: systemPromptFile, content });
+    }
+    const configFile = path.join(ctx.configDir, "config.toml");
+    const config = readMcpConfig(configFile);
+    if (config !== null) {
+      let content = config;
+      const primaryModelOwnership = [];
+      if (ctx.ownedPrimaryModelFields?.has(PRIMARY_MODEL_FIELD) === true) {
+        content = removeTomlRootKeyIfExact(content, PRIMARY_MODEL_FIELD, PRIMARY_MODEL);
+        primaryModelOwnership.push({ field: PRIMARY_MODEL_FIELD, owned: false });
+      }
+      if (ctx.ownedPrimaryModelFields?.has(PRIMARY_CONTEXT_FIELD) === true) {
+        content = removeTomlRootKeyIfExact(content, PRIMARY_CONTEXT_FIELD, PRIMARY_CONTEXT_WINDOW);
+        primaryModelOwnership.push({ field: PRIMARY_CONTEXT_FIELD, owned: false });
+      }
+      const mcpOwnership = [];
+      for (const [name, server] of Object.entries(mcp.servers)) {
+        const section = `mcp_servers.${name}`;
+        if (name === "context7") {
+          const current = readTomlSection(content, section);
+          const canonical = isCanonicalContext7Server(server, current, content);
+          const owned = ctx.ownedMcpServers?.has(name) === true;
+          if (owned) {
+            if (canonical) {
+              content = removeTomlSection(content, section);
+            }
+            mcpOwnership.push({ server: name, owned: false });
+          }
+          continue;
+        }
+        if (name === "engram" && hasActiveEngramPlugin(ctx.configDir)) {
+          ctx.warnings.push(
+            "Codex: MCP 'engram' oficial (plugin) se conserva; usa el desinstalador oficial de Engram para retirarlo."
+          );
+          continue;
+        }
+        if (!server.optional) {
+          content = removeTomlSection(content, section);
+          continue;
+        }
+        if (ctx.ownedMcpServers?.has(name) === true) {
+          if (isManagedOptionalStdioServer(server, readTomlSection(content, section))) {
+            content = removeTomlSection(content, section);
+          }
+          mcpOwnership.push({ server: name, owned: false });
+        }
+      }
+      actions.push({
+        kind: "write",
+        target: configFile,
+        content,
+        ...mcpOwnership.length > 0 ? { mcpOwnership } : {},
+        ...primaryModelOwnership.length > 0 ? { primaryModelOwnership } : {}
+      });
+    }
+    const hooksFile = path.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;
+  }
+};
+function parseCodexEngramPluginRef(config) {
+  const header = /\[plugins\."engram@([^"]+)"\]/.exec(config);
+  if (header === null) return null;
+  const block = /\[plugins\."engram@[^"]*"\]([^[]*)/.exec(config);
+  if (block !== null && /enabled\s*=\s*false/.test(block[1])) return null;
+  return header[1];
+}
+function isExactCodexEngramMcp(section, engramBin) {
+  if (section === null) return false;
+  const command = parseTomlString(tomlAssignment(section, "command").raw);
+  if (command !== engramBin) return false;
+  const argsRaw = tomlAssignment(section, "args").raw;
+  if (argsRaw === void 0) return false;
+  try {
+    const args = JSON.parse(argsRaw);
+    return Array.isArray(args) && args.length === 2 && args[0] === "mcp" && args[1] === "--tools=agent";
+  } catch {
+    return false;
+  }
+}
+function resolveCodexInstructionPath(config, configDir, key, fallback) {
+  const ref = config !== null ? readCodexRootValue(config, key) : void 0;
+  const rel = typeof ref === "string" && ref.trim() !== "" ? ref.trim() : fallback;
+  return path.isAbsolute(rel) ? rel : path.join(configDir, rel);
+}
+function isNonEmptyFile(file) {
+  try {
+    const stat = fs.statSync(file);
+    if (!stat.isFile() || stat.size === 0) return false;
+    return fs.readFileSync(file, "utf8").trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function verifyOfficialSetup(args) {
+  const config = readTextIfExists(path.join(args.configDir, "config.toml"));
+  const pluginRef = config !== null ? parseCodexEngramPluginRef(config) : null;
+  const mcpSection = config !== null ? readTomlSection(config, "mcp_servers.engram") : null;
+  const hasMcp = mcpSection !== null && typeof args.engramBin === "string" && args.engramBin !== "" ? isExactCodexEngramMcp(mcpSection, args.engramBin) : false;
+  const mcpPresentButForeign = mcpSection !== null && !hasMcp;
+  const instructionsFile = resolveCodexInstructionPath(config, args.configDir, "model_instructions_file", "engram-instructions.md");
+  const compactFile = resolveCodexInstructionPath(
+    config,
+    args.configDir,
+    "experimental_compact_prompt_file",
+    "engram-compact-prompt.md"
+  );
+  const hasInstructions = isNonEmptyFile(instructionsFile);
+  const hasCompact = isNonEmptyFile(compactFile);
+  const passed = [];
+  const missing = [];
+  if (pluginRef !== null) passed.push("plugin");
+  else missing.push("plugin:missing");
+  if (hasMcp) passed.push("mcp");
+  else missing.push(mcpPresentButForeign ? "mcp:conflict" : "mcp:missing");
+  if (hasInstructions) passed.push("instructions");
+  else missing.push("instructions:missing");
+  if (hasCompact) passed.push("compact");
+  else missing.push("compact:missing");
+  if (missing.length === 0) {
+    return { ok: true, layers: passed, acceptedRef: pluginRef, duplicates: false };
+  }
+  const detail = mcpPresentButForeign ? `MCP 'engram' en conflicto (no apunta al binario oficial ${args.engramBin}); se preserva la config ajena sin reescribir.` : `Codex: setup oficial Engram incompleto (falta: ${missing.join(", ")}).`;
+  return {
+    ok: false,
+    layers: [...passed, ...missing],
+    ...pluginRef !== null ? { acceptedRef: pluginRef } : {},
+    duplicates: false,
+    reason: detail
+  };
+}
+registerOfficialSetupVerifier("codex", verifyOfficialSetup);
+
+export {
+  codexAdapter,
+  verifyOfficialSetup
+};