jorgex-stack 1.9.59 → 1.9.60

package/dist/chunk-KB5IQEKL.js

@@ -1,1400 +0,0 @@
-#!/usr/bin/env node
-import {
-  HOME,
-  dataDir
-} from "./chunk-NQZVJFV2.js";
-
-// src/lib/fsx.ts
-import fs from "fs";
-import path from "path";
-function readTextIfExists(file) {
-  try {
-    return fs.readFileSync(file, "utf8");
-  } catch {
-    return null;
-  }
-}
-function ensureDir(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-}
-var tmpCounter = 0;
-function tmpPath(target) {
-  return path.join(path.dirname(target), `.jorgex-${process.pid}-${tmpCounter++}.tmp`);
-}
-function renameInto(tmp, target) {
-  try {
-    fs.renameSync(tmp, target);
-  } catch (err) {
-    fs.rmSync(tmp, { force: true });
-    throw err;
-  }
-}
-function writeText(file, content, mode) {
-  ensureDir(path.dirname(file));
-  const tmp = tmpPath(file);
-  fs.writeFileSync(tmp, content, { encoding: "utf8", mode });
-  renameInto(tmp, file);
-}
-function copyFile(source, target) {
-  ensureDir(path.dirname(target));
-  const tmp = tmpPath(target);
-  fs.copyFileSync(source, tmp);
-  renameInto(tmp, target);
-}
-function isContainedIn(child, root) {
-  const rel = path.relative(path.resolve(root), path.resolve(child));
-  return rel !== "" && rel !== ".." && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
-}
-function pruneEmptyDirs(file, root) {
-  let dir = path.dirname(file);
-  while (dir.startsWith(root) && dir !== root) {
-    try {
-      if (fs.readdirSync(dir).length > 0) return;
-      fs.rmdirSync(dir);
-    } catch {
-      return;
-    }
-    dir = path.dirname(dir);
-  }
-}
-function sameFileContent(a, b) {
-  try {
-    const bufA = fs.readFileSync(a);
-    const bufB = fs.readFileSync(b);
-    return bufA.equals(bufB);
-  } catch {
-    return false;
-  }
-}
-function listFilesRecursive(dir) {
-  const out = [];
-  if (!fs.existsSync(dir)) return out;
-  const walk = (d) => {
-    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
-      const p = path.join(d, entry.name);
-      if (entry.isDirectory()) walk(p);
-      else out.push(p);
-    }
-  };
-  walk(dir);
-  return out;
-}
-
-// src/lib/backup.ts
-import fs2 from "fs";
-import path2 from "path";
-import crypto from "crypto";
-var KEEP_BACKUPS = 10;
-function backupsRoot() {
-  return path2.join(dataDir(), "backups");
-}
-function compositeChecksum(files) {
-  const hash = crypto.createHash("sha256");
-  for (const file of [...files].sort()) {
-    const content = crypto.createHash("sha256").update(fs2.readFileSync(file)).digest("hex");
-    hash.update(`${file}:${content}
-`);
-  }
-  return hash.digest("hex");
-}
-function createBackup(files, label, root = backupsRoot()) {
-  const existing = [...new Set(files)].filter((f) => fs2.existsSync(f));
-  if (existing.length === 0) return null;
-  const checksum = compositeChecksum(existing);
-  const latest = listBackups(root)[0];
-  if (latest?.checksum === checksum) return latest;
-  const base = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${label}`;
-  let id = base;
-  let dir = path2.join(root, id);
-  for (let n = 1; fs2.existsSync(dir); n++) {
-    id = `${base}-${n}`;
-    dir = path2.join(root, id);
-  }
-  ensureDir(path2.join(dir, "files"));
-  const entries = existing.map((original, i) => {
-    const stored = path2.join(dir, "files", `${String(i).padStart(4, "0")}-${path2.basename(original)}`);
-    fs2.copyFileSync(original, stored);
-    return { original, stored };
-  });
-  const info = { id, label, createdAt: (/* @__PURE__ */ new Date()).toISOString(), files: entries, checksum };
-  writeText(path2.join(dir, "manifest.json"), JSON.stringify(info, null, 2) + "\n");
-  pruneBackups(root);
-  return info;
-}
-function listBackups(root = backupsRoot()) {
-  if (!fs2.existsSync(root)) return [];
-  const infos = [];
-  for (const entry of fs2.readdirSync(root, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const manifest = readTextIfExists(path2.join(root, entry.name, "manifest.json"));
-    if (manifest === null) continue;
-    try {
-      infos.push(JSON.parse(manifest));
-    } catch {
-      infos.push({ id: entry.name, label: "(manifest corrupto)", createdAt: "", files: [] });
-    }
-  }
-  return 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}`);
-  const boundaryResolved = path2.resolve(boundary);
-  const hasSymlinkAncestor = (file) => {
-    let dir = path2.dirname(path2.resolve(file));
-    while (dir !== boundaryResolved && isContainedIn(dir, boundaryResolved)) {
-      try {
-        if (fs2.lstatSync(dir).isSymbolicLink()) return true;
-      } catch (error) {
-        const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "UNKNOWN";
-        if (code !== "ENOENT") return true;
-      }
-      const parent = path2.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-    return false;
-  };
-  let restored = 0;
-  for (const { original, stored } of info.files) {
-    if (!fs2.existsSync(stored)) continue;
-    if (!isContainedIn(original, boundary)) continue;
-    try {
-      if (fs2.lstatSync(original).isSymbolicLink()) continue;
-    } catch (error) {
-      const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "UNKNOWN";
-      if (code !== "ENOENT") continue;
-    }
-    if (hasSymlinkAncestor(original)) continue;
-    ensureDir(path2.dirname(original));
-    fs2.copyFileSync(stored, original);
-    restored++;
-  }
-  return restored;
-}
-function pruneBackups(root) {
-  const all = listBackups(root);
-  for (const old of all.slice(KEEP_BACKUPS)) {
-    fs2.rmSync(path2.join(root, old.id), { recursive: true, force: true });
-  }
-}
-
-// src/lib/filemerge.ts
-function markers(name) {
-  return { open: `<!-- jorgex:${name} -->`, close: `<!-- /jorgex:${name} -->` };
-}
-function hasHealthyManagedMarkdownMarkers(existing, name) {
-  const { open, close } = markers(name);
-  const count = (marker) => existing.split(marker).length - 1;
-  const onOwnLine = (marker) => existing.split("\n").some((line) => line.trim() === marker);
-  return count(open) === 1 && count(close) === 1 && existing.indexOf(close) > existing.indexOf(open) && onOwnLine(open) && onOwnLine(close);
-}
-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;
-  if (hasHealthyManagedMarkdownMarkers(existing, name)) 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") ? "" : 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 tomlRootEnd(lines) {
-  const mask = multilineStringMask(lines);
-  const index = lines.findIndex((line, lineIndex) => !mask[lineIndex] && headerName(line) !== null);
-  return index === -1 ? lines.length : index;
-}
-function rootKeyLineIndex(lines, key) {
-  const end = tomlRootEnd(lines);
-  const mask = multilineStringMask(lines);
-  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pattern = new RegExp(`^\\s*(?:${escaped}|"${escaped}"|'${escaped}')\\s*=`);
-  return lines.slice(0, end).findIndex((line, index) => !mask[index] && pattern.test(line));
-}
-function hasTomlRootKey(existing, key) {
-  if (existing === null || existing === "") return false;
-  return rootKeyLineIndex(existing.replace(/\r\n/g, "\n").split("\n"), key) !== -1;
-}
-function upsertTomlRootKeyIfMissing(existing, key, value) {
-  if (hasTomlRootKey(existing, key)) return existing;
-  const eol = existing?.includes("\r\n") ? "\r\n" : "\n";
-  const normalized = (existing ?? "").replace(/\r\n/g, "\n");
-  const lines = normalized === "" ? [] : normalized.split("\n");
-  const index = tomlRootEnd(lines);
-  lines.splice(index, 0, `${key} = ${value}`);
-  return lines.join(eol);
-}
-function removeTomlRootKeyIfExact(existing, key, value) {
-  const eol = existing.includes("\r\n") ? "\r\n" : "\n";
-  const normalized = existing.replace(/\r\n/g, "\n");
-  const lines = normalized.split("\n");
-  const index = rootKeyLineIndex(lines, key);
-  if (index === -1) return existing;
-  const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const escapedValue = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const exact = new RegExp(`^\\s*(?:${escapedKey}|"${escapedKey}"|'${escapedKey}')\\s*=\\s*${escapedValue}\\s*(?:#.*)?$`);
-  if (!exact.test(lines[index])) return existing;
-  lines.splice(index, 1);
-  return lines.join(eol);
-}
-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 quoteRunLength(line, start, quote) {
-  let end = start + 1;
-  while (end < line.length && line[end] === quote) end++;
-  return end - start;
-}
-function skipShortString(line, start, quote) {
-  let index = start + 1;
-  while (index < line.length) {
-    if (line[index] === quote) return index + 1;
-    if (quote === '"' && line[index] === "\\") {
-      index += 2;
-      continue;
-    }
-    index++;
-  }
-  return line.length;
-}
-function scanTomlLine(line, initial) {
-  let inside = initial;
-  let index = 0;
-  while (index < line.length) {
-    if (inside !== null) {
-      const quote = inside === '"""' ? '"' : "'";
-      if (line[index] === quote) {
-        const run2 = quoteRunLength(line, index, quote);
-        if (run2 >= 3) {
-          inside = null;
-        }
-        index += run2;
-        continue;
-      }
-      if (inside === '"""' && line[index] === "\\") {
-        index += 2;
-        continue;
-      }
-      index++;
-      continue;
-    }
-    const char = line[index];
-    if (char === "#") break;
-    if (char !== '"' && char !== "'") {
-      index++;
-      continue;
-    }
-    const run = quoteRunLength(line, index, char);
-    if (run >= 3) {
-      inside = char === '"' ? '"""' : "'''";
-      index += 3;
-    } else {
-      index = skipShortString(line, index, char);
-    }
-  }
-  return inside;
-}
-function multilineStringMask(lines) {
-  const mask = [];
-  let inside = null;
-  for (const line of lines) {
-    mask.push(inside !== null);
-    inside = scanTomlLine(line, inside);
-  }
-  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 target = headerName(header) ?? section;
-  const block = `${header}
-${body.trim()}
-`;
-  if (existing === null || existing.trim() === "") return block;
-  const rawLines = existing.split("\n");
-  const lines = rawLines.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
-  const lineStarts = [];
-  let offset = 0;
-  for (let index = 0; index < rawLines.length; index++) {
-    lineStarts.push(offset);
-    offset += rawLines[index].length;
-    if (index < rawLines.length - 1) offset++;
-  }
-  const found = findTomlSection(lines, target);
-  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 startOffset = lineStarts[found.start];
-  const endOffset = lineStarts[sectionEnd] ?? existing.length;
-  return existing.slice(0, startOffset) + block.trimEnd() + "\n" + existing.slice(endOffset);
-}
-function removeTomlSection(existing, section) {
-  const eol = existing.includes("\r\n") ? "\r\n" : "\n";
-  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(eol);
-  if (result.trim() === "") return "";
-  return result.endsWith(eol) ? result : result + eol;
-}
-function readTomlSection(existing, section) {
-  if (existing === null) return null;
-  const lines = existing.split(/\r?\n/);
-  const found = findTomlSection(lines, section);
-  if (found === null) return null;
-  return lines.slice(found.start + 1, found.end).join("\n");
-}
-function hasTomlChildSection(existing, section) {
-  if (existing === null) return false;
-  const lines = existing.split(/\r?\n/);
-  const mask = multilineStringMask(lines);
-  return lines.some((line, index) => !mask[index] && headerName(line)?.startsWith(`${section}.`) === true);
-}
-
-// src/lib/system-prompt-sections.ts
-import fs3 from "fs";
-import path3 from "path";
-var SYSTEM_PROMPT_SECTIONS = [
-  "system-prompt",
-  "engram-protocol",
-  "context7",
-  "playwright",
-  "chrome-devtools",
-  "browser",
-  "writing-style"
-];
-function assertSystemPromptMarkers(content, target) {
-  if (content === null) return;
-  const ranges = [];
-  for (const section of SYSTEM_PROMPT_SECTIONS) {
-    const markers2 = [...content.matchAll(new RegExp(`<!--\\s*\\/?jorgex:${section}(?=[\\s>]|-->|$)`, "g"))];
-    if (markers2.length === 0) continue;
-    if (markers2.length !== 2 || !hasHealthyManagedMarkdownMarkers(content, section)) {
-      throw new Error(`Marcadores jorgex:${section} ambiguos en ${target}. Repara el bloque antes de reintentar; su contenido se conserva.`);
-    }
-    ranges.push({
-      section,
-      start: content.indexOf(`<!-- jorgex:${section} -->`),
-      end: content.indexOf(`<!-- /jorgex:${section} -->`) + `<!-- /jorgex:${section} -->`.length
-    });
-  }
-  ranges.sort((a, b) => a.start - b.start);
-  for (let index = 1; index < ranges.length; index++) {
-    if (ranges[index].start < ranges[index - 1].end) {
-      throw new Error(`Marcadores jorgex:${ranges[index].section} anidados en ${target}. Separa los bloques antes de reintentar; su contenido se conserva.`);
-    }
-  }
-}
-function readSystemPromptFile(target, rootDir) {
-  if (rootDir !== void 0) {
-    const probe = fs3.existsSync(target) ? target : path3.dirname(target);
-    if (fs3.existsSync(probe) && fs3.existsSync(rootDir)) {
-      const resolved = fs3.realpathSync(probe);
-      const root = fs3.realpathSync(rootDir);
-      if (resolved !== root && !isContainedIn(resolved, root)) {
-        throw new Error(`El prompt ${target} sale del destino aislado.`);
-      }
-    }
-  }
-  let bytes;
-  try {
-    bytes = fs3.readFileSync(target);
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw new Error(`No se puede leer el prompt ${target}. Revisa los permisos y el tipo de archivo.`, { cause: error });
-  }
-  try {
-    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
-  } catch (error) {
-    throw new Error(`El prompt ${target} debe usar UTF-8 v\xE1lido.`, { cause: error });
-  }
-}
-function assertSystemPromptFile(target, rootDir) {
-  assertSystemPromptMarkers(readSystemPromptFile(target, rootDir), target);
-}
-function removeSystemPromptSections(content) {
-  assertSystemPromptMarkers(content, "system prompt");
-  return SYSTEM_PROMPT_SECTIONS.reduce((current, section) => removeMarkdownSection(current, section), content);
-}
-
-// src/lib/canonical.ts
-import path4 from "path";
-import fs4 from "fs";
-function parseCanonicalAgent(source, file) {
-  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(source);
-  if (!match) throw new Error(`Agente sin frontmatter: ${file}`);
-  const fields = {};
-  for (const line of match[1].split(/\r?\n/)) {
-    const sep = line.indexOf(":");
-    if (sep === -1) continue;
-    fields[line.slice(0, sep).trim()] = line.slice(sep + 1).trim();
-  }
-  const required = ["name", "description", "mode", "tier"];
-  for (const key of required) {
-    if (!fields[key]) throw new Error(`Agente ${file}: falta '${key}' en el frontmatter`);
-  }
-  return {
-    name: fields.name,
-    description: fields.description,
-    mode: fields.mode === "primary" ? "primary" : "subagent",
-    tier: fields.tier,
-    readonly: fields.readonly === "true",
-    bash: fields.bash ?? "full",
-    spawn: fields.spawn !== "false",
-    body: source.slice(match[0].length)
-  };
-}
-function loadCanonicalAgents(agentsDir) {
-  return fs4.readdirSync(agentsDir).filter((f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md").map((f) => {
-    const file = path4.join(agentsDir, f);
-    const source = fs4.readFileSync(file, "utf8").replace(/\r\n/g, "\n");
-    return parseCanonicalAgent(source, file);
-  });
-}
-var DEVTOOLS_MCP_SERVER = "chrome-devtools";
-function isCanonicalMcpServerEnabled(name, server, enabledServers) {
-  return !server.optional || server.defaultEnabled === true || enabledServers?.has(name) === true;
-}
-function loadCanonicalMcp(stackDir) {
-  return JSON.parse(fs4.readFileSync(path4.join(stackDir, "mcp", "servers.json"), "utf8"));
-}
-function loadCanonicalHooks(stackDir) {
-  return JSON.parse(fs4.readFileSync(path4.join(stackDir, "hooks", "hooks.json"), "utf8"));
-}
-function loadCanonicalDefaults(stackDir) {
-  const file = path4.join(stackDir, "config", "defaults.json");
-  if (!fs4.existsSync(file)) return {};
-  const parsed = JSON.parse(fs4.readFileSync(file, "utf8"));
-  delete parsed["$comment"];
-  return parsed;
-}
-
-// src/lib/model-map.ts
-import path5 from "path";
-import { existsSync } from "fs";
-function resolveAgentModel(models, agentName, tier) {
-  const base = models[tier];
-  const override = models.overrides?.[agentName];
-  if (!override) return base;
-  return {
-    model: override.model || base.model,
-    variant: "variant" in override ? override.variant || void 0 : base.variant
-  };
-}
-var DEFAULT_MODEL_MAP = {
-  "claude-code": {
-    strong: { model: "fable" },
-    standard: { model: "sonnet" },
-    cheap: { model: "haiku" }
-  },
-  // El primary (orchestrator) no usa estos tiers: tanto el profile de CLI como
-  // la skill de la app heredan el modelo elegido por el usuario. Estos defaults
-  // son solo para subagentes; variant → model_reasoning_effort.
-  codex: {
-    strong: { model: "gpt-6-astra", variant: "low" },
-    standard: { model: "gpt-5.6-luna", variant: "max" },
-    cheap: { model: "gpt-5.6-luna", variant: "medium" }
-  }
-};
-function modelMapFile() {
-  return path5.join(dataDir(), "model-map.json");
-}
-function loadModelMap() {
-  const file = modelMapFile();
-  const raw = readTextIfExists(file);
-  if (raw === null) return DEFAULT_MODEL_MAP;
-  let fromDisk;
-  try {
-    fromDisk = JSON.parse(raw);
-  } catch {
-    throw new Error(`El mapa de modelos ${file} contiene JSON inv\xE1lido. Corrige el JSON o restaura una copia antes de continuar.`);
-  }
-  const merged = { ...fromDisk };
-  for (const id of Object.keys(DEFAULT_MODEL_MAP)) {
-    merged[id] = { ...DEFAULT_MODEL_MAP[id], ...fromDisk[id] ?? {} };
-    if (fromDisk[id] && !Object.hasOwn(fromDisk[id], "overrides")) delete merged[id].overrides;
-  }
-  return merged;
-}
-function ensureModelMapFile() {
-  const file = modelMapFile();
-  if (!existsSync(file)) {
-    writeText(file, JSON.stringify(DEFAULT_MODEL_MAP, null, 2) + "\n");
-  }
-  return file;
-}
-
-// src/lib/detect.ts
-import path6 from "path";
-import { existsSync as existsSync2, statSync } from "fs";
-import { execFileSync } from "child_process";
-function lookPath(cmd, env = process.env) {
-  const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ".ps1", ""] : [""];
-  for (const dir of (env.PATH ?? "").split(path6.delimiter)) {
-    if (!dir) continue;
-    for (const ext of exts) {
-      const candidate = path6.join(dir, cmd + ext);
-      if (statSync(candidate, { throwIfNoEntry: false })?.isFile()) return candidate;
-    }
-  }
-  return null;
-}
-function planDetectedBinCommand(bin, args) {
-  if (process.platform !== "win32" || !/\.(cmd|bat)$/i.test(bin)) return { command: bin, args };
-  if ([bin, ...args].some((part) => /[&|<>()^%!"\r\n]/.test(part))) return null;
-  const quote = (part) => part === "" || /\s/.test(part) ? `"${part}"` : part;
-  return {
-    command: process.env.ComSpec ?? "cmd.exe",
-    args: ["/d", "/s", "/c", [quote(bin), ...args.map(quote)].join(" ")]
-  };
-}
-function runDetectedBin(bin, args, timeoutMs, envOverrides) {
-  try {
-    const command = planDetectedBinCommand(bin, args);
-    if (command === null) return null;
-    return execFileSync(command.command, command.args, {
-      encoding: "utf8",
-      timeout: timeoutMs,
-      stdio: ["ignore", "pipe", "pipe"],
-      ...envOverrides === void 0 ? {} : { env: { ...process.env, ...envOverrides } }
-    });
-  } catch {
-    return null;
-  }
-}
-function detectOpenCode() {
-  const configDir = process.env.OPENCODE_CONFIG_DIR ?? path6.join(HOME, ".config", "opencode");
-  const binPath = lookPath("opencode");
-  return {
-    id: "opencode",
-    name: "OpenCode",
-    installed: binPath !== null || existsSync2(configDir),
-    binPath,
-    configDir
-  };
-}
-function detectClaudeCode() {
-  const configDir = process.env.CLAUDE_CONFIG_DIR ?? path6.join(HOME, ".claude");
-  const binPath = lookPath("claude");
-  return {
-    id: "claude-code",
-    name: "Claude Code",
-    installed: binPath !== null || existsSync2(configDir),
-    binPath,
-    configDir
-  };
-}
-function detectCodex() {
-  const configDir = process.env.CODEX_HOME ?? path6.join(HOME, ".codex");
-  const binPath = lookPath("codex");
-  return {
-    id: "codex",
-    name: "Codex CLI",
-    installed: binPath !== null || existsSync2(configDir),
-    binPath,
-    configDir
-  };
-}
-function detectEngram() {
-  const fromEnv = process.env.ENGRAM_BIN;
-  if (fromEnv && existsSync2(fromEnv)) return fromEnv;
-  const onPath = lookPath("engram");
-  if (onPath) return onPath;
-  const candidates = [
-    path6.join(HOME, "go", "bin", "engram.exe"),
-    path6.join(HOME, "go", "bin", "engram"),
-    path6.join(HOME, ".local", "bin", "engram.exe"),
-    path6.join(HOME, ".local", "bin", "engram")
-  ];
-  for (const c of candidates) if (existsSync2(c)) return c;
-  return null;
-}
-function engramVersion(bin) {
-  const out = runDetectedBin(bin, ["--version"], 5e3);
-  if (out === null) return null;
-  return /(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/.exec(out)?.[1] ?? out.trim().split("\n")[0] ?? null;
-}
-
-// src/lib/hooks-format.ts
-import path7 from "path";
-function hookScriptNames(canonical) {
-  return Object.values(canonical.hooks).flat().flatMap((entry) => entry.hooks).map((h) => /\{\{SCRIPTS_DIR\}\}[/\\]([\w./-]+)/.exec(h.command)?.[1]).filter((s) => s !== void 0).map((s) => path7.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) => path7.basename(s));
-        const plainCommands = entry.hooks.map((h) => h.command).filter((c) => !c.includes("{{SCRIPTS_DIR}}"));
-        const index = list.findIndex((existingEntry) => {
-          const e = existingEntry;
-          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/lib/quality-capabilities.ts
-var QUALITY_CAPABILITY_NAMESPACE = "jorgex.quality.capabilities";
-var QUALITY_CAPABILITY_VERSION = 1;
-var QUALITY_CAPABILITY_IDS = [
-  "policy-guidance",
-  "tool-approval",
-  "external-verification"
-];
-var UNAVAILABLE_REASON = "No reviewed local declaration is available";
-var EXTERNAL_VERIFICATION_REASON = "External verification is available only through the external verifier";
-function hasText(value) {
-  return typeof value === "string" && value.trim() !== "";
-}
-function isRuntime(value) {
-  return value === "claude-code" || value === "codex" || value === "opencode" || value === "pi";
-}
-function hasValidEvidence(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-  const evidence = value;
-  return hasText(evidence.source) && hasText(evidence.version);
-}
-function unavailableCapability(id, reason = UNAVAILABLE_REASON) {
-  return { id, state: "unavailable", reason };
-}
-function declarationFor(id, declarations, runtime) {
-  if (runtime === "unknown") {
-    return unavailableCapability(id, "Runtime is unknown; local capability cannot be established");
-  }
-  if (id === "external-verification") {
-    return unavailableCapability(id, EXTERNAL_VERIFICATION_REASON);
-  }
-  const matches = declarations.filter((declaration2) => declaration2?.id === id);
-  if (matches.length === 0) return unavailableCapability(id);
-  if (matches.length !== 1) return unavailableCapability(id, "Duplicate capability declarations are ambiguous");
-  const declaration = matches[0];
-  const state = declaration.state;
-  const reason = hasText(declaration.reason) ? declaration.reason.trim() : void 0;
-  if (!reason) return unavailableCapability(id, "Capability declaration has no reason");
-  if (state !== "prompt-only" && state !== "manual" && state !== "unavailable") {
-    return unavailableCapability(id, "Capability state is not a supported local state");
-  }
-  if (state === "unavailable") return { id, state, reason };
-  if (!hasValidEvidence(declaration.evidence)) {
-    return unavailableCapability(id, "Capability declaration lacks reviewed source/version evidence");
-  }
-  const evidence = declaration.evidence;
-  return {
-    id,
-    state,
-    reason,
-    evidence: {
-      source: evidence.source.trim(),
-      version: evidence.version.trim()
-    }
-  };
-}
-function hasManagedMarkdownSection(content, name) {
-  return content !== null && hasHealthyManagedMarkdownMarkers(content, name);
-}
-function createLocalCapabilityReport(runtime, declarations) {
-  const normalizedRuntime = isRuntime(runtime) ? runtime : "unknown";
-  return {
-    namespace: QUALITY_CAPABILITY_NAMESPACE,
-    version: QUALITY_CAPABILITY_VERSION,
-    runtime: normalizedRuntime,
-    capabilities: QUALITY_CAPABILITY_IDS.map((id) => declarationFor(id, declarations, normalizedRuntime))
-  };
-}
-function localQualityStatus(profile, status) {
-  if ((profile === "high" || profile === "release") && status === "pass") return "incomplete";
-  return status;
-}
-
-// src/lib/official-engram-setup.ts
-import fs5 from "fs";
-import path8 from "path";
-import { execFileSync as execFileSync2 } from "child_process";
-var OFFICIAL_SETUP_RUNTIMES = [
-  "claude-code",
-  "codex",
-  "opencode"
-];
-function isOfficialSetupRuntime(runtime) {
-  return OFFICIAL_SETUP_RUNTIMES.includes(runtime);
-}
-function resolveOfficialSetupArgv(runtime) {
-  switch (runtime) {
-    case "claude-code":
-      return ["setup", "claude-code"];
-    case "codex":
-      return ["setup", "codex"];
-    case "opencode":
-      return ["setup", "opencode"];
-    default:
-      throw new Error(`Runtime setup oficial desconocido: ${runtime}.`);
-  }
-}
-function shouldRunOfficialSetup(opts) {
-  return opts.command === "install" && opts.dryRun === false && opts.targetDir === void 0;
-}
-function snapshotDirEntries(dir) {
-  const out = /* @__PURE__ */ new Set();
-  try {
-    const walk = (current) => {
-      for (const entry of fs5.readdirSync(current, { withFileTypes: true })) {
-        const full = path8.resolve(path8.join(current, entry.name));
-        out.add(full);
-        if (entry.isDirectory()) walk(full);
-      }
-    };
-    walk(path8.resolve(dir));
-    return out;
-  } catch {
-    return null;
-  }
-}
-function errnoCode(error) {
-  return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "UNKNOWN";
-}
-function findSymlinkInTree(root) {
-  const stack = [path8.resolve(root)];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    let entries;
-    try {
-      entries = fs5.readdirSync(current, { withFileTypes: true });
-    } catch (error) {
-      if (errnoCode(error) === "ENOENT") continue;
-      return `${current}: ilegible (${errnoCode(error)}, no se puede descartar alias)`;
-    }
-    for (const entry of entries) {
-      const full = path8.join(current, entry.name);
-      let st;
-      try {
-        st = fs5.lstatSync(full);
-      } catch (error) {
-        if (errnoCode(error) === "ENOENT") continue;
-        return `${full}: ilegible (${errnoCode(error)}, no se puede descartar alias)`;
-      }
-      if (st.isSymbolicLink()) return `${full}: es un symlink (no se sigue ni se copia)`;
-      if (st.isDirectory()) stack.push(full);
-    }
-  }
-  return null;
-}
-function findSetupSymlinkViolation(targets, homeDir) {
-  const homeResolved = path8.resolve(homeDir);
-  for (const target of targets) {
-    const resolved = path8.resolve(target);
-    try {
-      if (fs5.lstatSync(resolved).isSymbolicLink()) {
-        return `${resolved}: el target es un symlink (no se respalda ni se ejecuta setup)`;
-      }
-    } catch (error) {
-      if (errnoCode(error) !== "ENOENT") {
-        return `${resolved}: ilegible (${errnoCode(error)}, no se puede descartar alias)`;
-      }
-    }
-    let dir = path8.dirname(resolved);
-    while (dir !== homeResolved && isContainedIn(dir, homeResolved)) {
-      try {
-        if (fs5.lstatSync(dir).isSymbolicLink()) {
-          return `${dir}: ancestro existente es un symlink (no se atraviesa)`;
-        }
-      } catch (error) {
-        if (errnoCode(error) !== "ENOENT") {
-          return `${dir}: ilegible (${errnoCode(error)}, no se puede descartar alias)`;
-        }
-      }
-      const parent = path8.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-    try {
-      if (fs5.statSync(resolved).isDirectory()) {
-        const bad = findSymlinkInTree(resolved);
-        if (bad !== null) return bad;
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-async function runOfficialSetup(runtime, deps) {
-  if (typeof deps.engramBin !== "string" || !path8.isAbsolute(deps.engramBin)) {
-    throw new Error(`runOfficialSetup: engramBin absoluto requerido (runtime ${runtime}).`);
-  }
-  const argv = resolveOfficialSetupArgv(runtime);
-  if (!Array.isArray(deps.targets) || deps.targets.length === 0) {
-    throw new Error(`runOfficialSetup: targets expl\xEDcitos no vac\xEDos requeridos (runtime ${runtime}).`);
-  }
-  const preciseTargets = [...new Set(deps.targets.map((t) => path8.resolve(t)))];
-  const homeResolved = path8.resolve(deps.homeDir);
-  const outside = preciseTargets.filter(
-    (t) => path8.resolve(t) !== homeResolved && !isContainedIn(t, homeResolved)
-  );
-  if (outside.length > 0) {
-    const detail2 = `runOfficialSetup: target fuera de la frontera de restore (${homeResolved}): ${outside[0]}. Bloqueado antes del setup.`;
-    return {
-      ok: false,
-      ownershipTransferred: false,
-      stderr: detail2,
-      reason: detail2,
-      recovery: "none",
-      backupId: null
-    };
-  }
-  const preViolation = findSetupSymlinkViolation(preciseTargets, homeResolved);
-  if (preViolation !== null) {
-    const detail2 = `runOfficialSetup: symlink rechazado antes del setup (${preViolation}). Bloqueado antes del backup.`;
-    return {
-      ok: false,
-      ownershipTransferred: false,
-      stderr: detail2,
-      reason: detail2,
-      recovery: "none",
-      backupId: null
-    };
-  }
-  let backupId = null;
-  try {
-    const backup = await deps.backup();
-    backupId = backup?.id !== void 0 ? String(backup.id) : null;
-  } catch (error) {
-    const detail2 = error instanceof Error ? error.message : String(error);
-    return {
-      ok: false,
-      ownershipTransferred: false,
-      stderr: detail2,
-      reason: detail2,
-      recovery: "none",
-      backupId: null,
-      backupError: detail2
-    };
-  }
-  const existedBefore = new Set(preciseTargets.filter((t) => {
-    try {
-      return fs5.existsSync(t);
-    } catch {
-      return false;
-    }
-  }));
-  const dirSnapshots = /* @__PURE__ */ new Map();
-  for (const t of preciseTargets) {
-    if (!existedBefore.has(t)) continue;
-    try {
-      if (fs5.statSync(t).isDirectory()) dirSnapshots.set(t, snapshotDirEntries(t));
-    } catch {
-      dirSnapshots.set(t, null);
-    }
-  }
-  let spawnResult;
-  try {
-    spawnResult = await deps.spawn(deps.engramBin, argv, { shell: false });
-  } catch (error) {
-    const detail2 = error instanceof Error ? error.message : String(error);
-    spawnResult = { ok: false, stdout: "", stderr: detail2 };
-  }
-  let verifyResult;
-  try {
-    verifyResult = await deps.verify();
-  } catch (error) {
-    const detail2 = error instanceof Error ? error.message : String(error);
-    verifyResult = { ok: false, reason: detail2 };
-  }
-  const postViolation = findSetupSymlinkViolation(preciseTargets, homeResolved);
-  const tainted = /* @__PURE__ */ new Set();
-  if (postViolation !== null) {
-    for (const t of preciseTargets) {
-      if (findSetupSymlinkViolation([t], homeResolved) !== null) tainted.add(t);
-    }
-  }
-  const ok = spawnResult.ok === true && verifyResult.ok === true && postViolation === null;
-  if (ok) {
-    return {
-      ok: true,
-      ownershipTransferred: verifyResult.ownershipTransferred ?? true,
-      stdout: spawnResult.stdout,
-      stderr: spawnResult.stderr,
-      ...verifyResult.layers === void 0 ? {} : { layers: verifyResult.layers },
-      recovery: "none",
-      backupId
-    };
-  }
-  let restoreError;
-  let restoreFailed = false;
-  if (postViolation !== null) {
-    restoreFailed = true;
-    restoreError = `symlink post-setup (${postViolation}); restore omitido para no escribir a trav\xE9s del enlace`;
-  } else {
-    try {
-      await deps.restore?.();
-    } catch (error) {
-      restoreFailed = true;
-      restoreError = error instanceof Error ? error.message : String(error);
-    }
-  }
-  let cleanupFailed = tainted.size > 0;
-  for (const t of preciseTargets) {
-    if (tainted.has(t)) continue;
-    try {
-      if (!existedBefore.has(t)) {
-        if (fs5.existsSync(t)) fs5.rmSync(t, { recursive: true, force: true });
-        continue;
-      }
-      if (!dirSnapshots.has(t)) continue;
-      const before = dirSnapshots.get(t);
-      if (before === null || before === void 0) {
-        cleanupFailed = true;
-        continue;
-      }
-      const after = snapshotDirEntries(t);
-      if (after === null) {
-        cleanupFailed = true;
-        continue;
-      }
-      const created = [...after].filter((p) => !before.has(p));
-      created.sort((a, b) => {
-        const depthA = a.split(path8.sep).length;
-        const depthB = b.split(path8.sep).length;
-        if (depthA !== depthB) return depthB - depthA;
-        return b.length - a.length;
-      });
-      for (const p of created) {
-        try {
-          if (fs5.existsSync(p)) fs5.rmSync(p, { recursive: true, force: true });
-        } catch {
-          cleanupFailed = true;
-        }
-      }
-    } catch {
-      cleanupFailed = true;
-    }
-  }
-  const incomplete = restoreFailed || cleanupFailed;
-  const detail = [spawnResult.stderr, verifyResult.stderr, verifyResult.reason, (verifyResult.layers ?? []).join(", ")].map((part) => (part ?? "").trim()).filter((part) => part !== "").join("; ") || "setup oficial fall\xF3";
-  const recoveryDetail = incomplete ? `${detail}; recuperaci\xF3n incompleta${restoreError !== void 0 ? `: ${restoreError}` : ""}` : detail;
-  return {
-    ok: false,
-    ownershipTransferred: false,
-    stdout: spawnResult.stdout,
-    stderr: recoveryDetail,
-    reason: recoveryDetail,
-    ...verifyResult.layers === void 0 ? {} : { layers: verifyResult.layers },
-    ...incomplete ? { incompleteRecovery: true } : {},
-    recovery: incomplete ? "incomplete" : "complete",
-    backupId,
-    ...restoreError === void 0 ? {} : { restoreError }
-  };
-}
-function isExplicitClaudeConfigDirEnv(explicit) {
-  if (explicit !== void 0) return explicit;
-  return process.env.CLAUDE_CONFIG_DIR !== void 0;
-}
-var officialSetupVerifiers = {};
-function registerOfficialSetupVerifier(runtime, fn) {
-  officialSetupVerifiers[runtime] = fn;
-}
-function collectOfficialSetupBackupTargets(runtime, configDir, homeDir, isExplicitClaudeConfigDir) {
-  switch (runtime) {
-    case "claude-code": {
-      const explicit = isExplicitClaudeConfigDirEnv(isExplicitClaudeConfigDir);
-      const pathIsDefault = homeDir !== void 0 ? path8.resolve(configDir) === path8.resolve(path8.join(homeDir, ".claude")) : path8.basename(path8.resolve(configDir)) === ".claude";
-      const isDefault = !explicit && pathIsDefault;
-      const nested = path8.join(configDir, ".claude.json");
-      const sibling = path8.join(path8.dirname(configDir), ".claude.json");
-      const targets = [
-        path8.join(configDir, "settings.json"),
-        path8.join(configDir, "plugins", "installed_plugins.json"),
-        path8.join(configDir, "plugins", "known_marketplaces.json"),
-        path8.join(configDir, "plugins", "marketplaces", "engram"),
-        path8.join(configDir, "plugins", "cache", "engram"),
-        path8.join(configDir, "mcp", "engram.json"),
-        // El MCP exacto puede estar en el archivo hermano (modo predeterminado)
-        // o en la ruta anidada (modo explícito); se respaldan ambas ubicaciones.
-        nested,
-        // En el modo predeterminado se añade el archivo hermano efectivo
-        // (`HOME/.claude.json`).
-        ...isDefault && path8.resolve(sibling) !== path8.resolve(nested) ? [sibling] : []
-      ];
-      if (homeDir !== void 0 && !isDefault) {
-        const fallback = path8.join(path8.resolve(homeDir), ".claude.json");
-        if (!targets.map((t) => path8.resolve(t)).includes(path8.resolve(fallback))) {
-          targets.push(fallback);
-        }
-      }
-      return [...new Set(targets)];
-    }
-    case "codex":
-      return [
-        path8.join(configDir, "config.toml"),
-        path8.join(configDir, "engram-instructions.md"),
-        path8.join(configDir, "engram-compact-prompt.md"),
-        path8.join(configDir, "AGENTS.md"),
-        path8.join(configDir, "hooks.json")
-      ];
-    case "opencode":
-      return [
-        path8.join(configDir, "opencode.json"),
-        path8.join(configDir, "opencode.jsonc"),
-        path8.join(configDir, "tui.json"),
-        path8.join(configDir, "tui.jsonc"),
-        path8.join(configDir, "plugins", "engram.ts")
-      ];
-  }
-}
-function validateOfficialSetupDestination(runtime, configDir, homeDir) {
-  if (runtime === "codex") {
-    const expected = path8.resolve(path8.join(homeDir, ".codex"));
-    if (path8.resolve(configDir) !== expected) {
-      return `runOfficialSetupIfNeeded: Codex custom CODEX_HOME (${configDir}) is not supported: the provider ignores CODEX_HOME and 'engram setup codex' always writes ${expected}; use the default <home>/.codex.`;
-    }
-    return null;
-  }
-  if (runtime === "opencode" && path8.basename(path8.resolve(configDir)) !== "opencode") {
-    return `runOfficialSetupIfNeeded: configDir OpenCode incompatible (${configDir}); el provider solo alinea <parent>/opencode v\xEDa XDG_CONFIG_HOME.`;
-  }
-  return null;
-}
-function resolveOfficialSetupEnv(runtime, configDir, homeDir, isExplicitClaudeConfigDir) {
-  switch (runtime) {
-    case "claude-code": {
-      const home = homeDir ?? HOME;
-      const explicit = isExplicitClaudeConfigDirEnv(isExplicitClaudeConfigDir);
-      if (explicit) return { CLAUDE_CONFIG_DIR: configDir };
-      if (path8.resolve(configDir) === path8.resolve(path8.join(home, ".claude"))) {
-        return { CLAUDE_CONFIG_DIR: void 0 };
-      }
-      return { CLAUDE_CONFIG_DIR: configDir };
-    }
-    case "codex":
-      return { CODEX_HOME: void 0 };
-    case "opencode":
-      return { OPENCODE_CONFIG_DIR: configDir, XDG_CONFIG_HOME: path8.dirname(configDir) };
-  }
-}
-async function spawnOfficialSetupBin(bin, argv, env) {
-  try {
-    let childEnv;
-    if (env !== void 0) {
-      childEnv = { ...process.env };
-      for (const [key, value] of Object.entries(env)) {
-        if (value === void 0) delete childEnv[key];
-        else childEnv[key] = value;
-      }
-    }
-    const stdout = execFileSync2(bin, argv, {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 12e4,
-      shell: false,
-      ...childEnv === void 0 ? {} : { env: childEnv }
-    });
-    return { ok: true, stdout: stdout ?? "", stderr: "" };
-  } catch (error) {
-    const stdout = error?.stdout;
-    const stderr = error?.stderr;
-    const toText = (value) => {
-      if (typeof value === "string") return value;
-      if (value instanceof Buffer) return value.toString("utf8");
-      return "";
-    };
-    const errText = error instanceof Error ? error.message : String(error);
-    const captured = toText(stderr).trim();
-    return { ok: false, stdout: toText(stdout), stderr: captured !== "" ? captured : errText };
-  }
-}
-function isClaudeEngramVersionSupported(version) {
-  const trimmed = version.trim();
-  if (trimmed === "") return false;
-  if (trimmed.includes("-")) return false;
-  const match = /(\d+)\.(\d+)\.(\d+)/.exec(trimmed);
-  if (!match) return false;
-  const major = Number(match[1]);
-  const minor = Number(match[2]);
-  if (!Number.isFinite(major) || !Number.isFinite(minor)) return false;
-  if (major > 2) return true;
-  if (major < 2) return false;
-  return minor >= 0;
-}
-async function runOfficialSetupIfNeeded(runtime, opts) {
-  if (!shouldRunOfficialSetup({ command: opts.command, dryRun: opts.dryRun, targetDir: opts.targetDir })) {
-    return { ran: false };
-  }
-  if (runtime === "pi") {
-    return { ran: false };
-  }
-  if (!isOfficialSetupRuntime(runtime)) {
-    const detail = `runOfficialSetupIfNeeded: runtime desconocido en install real: ${runtime}.`;
-    return { ran: true, ok: false, ownershipTransferred: false, stderr: detail, reason: detail, recovery: "none" };
-  }
-  if (typeof opts.engramBin !== "string" || !path8.isAbsolute(opts.engramBin)) {
-    const detail = `runOfficialSetupIfNeeded: engramBin absoluto requerido en install real (runtime ${runtime}).`;
-    return { ran: true, ok: false, ownershipTransferred: false, stderr: detail, reason: detail, recovery: "none" };
-  }
-  const verify = officialSetupVerifiers[runtime];
-  if (!verify) {
-    const detail = `runOfficialSetupIfNeeded: sin verificador registrado en install real (runtime ${runtime}).`;
-    return { ran: true, ok: false, ownershipTransferred: false, stderr: detail, reason: detail, recovery: "none" };
-  }
-  if (runtime === "claude-code") {
-    const raw = opts.engramVersion;
-    const provided = typeof raw === "string" ? raw.trim() : "";
-    if (provided === "" || !isClaudeEngramVersionSupported(provided)) {
-      const shown = provided === "" ? "unknown/unreadable" : provided;
-      const detail = `runOfficialSetupIfNeeded: Engram ${shown} no registra el MCP de Claude Code; check engram --version and update to Engram 2.0.0+ and rerun install; existing binary was not replaced.`;
-      return {
-        ran: true,
-        ok: false,
-        ownershipTransferred: false,
-        stderr: detail,
-        reason: detail,
-        recovery: "none",
-        backupId: null
-      };
-    }
-  }
-  const engramBin = opts.engramBin;
-  const configDir = opts.configDir;
-  const destinationError = validateOfficialSetupDestination(runtime, configDir, opts.homeDir);
-  if (destinationError !== null) {
-    return { ran: true, ok: false, ownershipTransferred: false, stderr: destinationError, reason: destinationError, recovery: "none", backupId: null };
-  }
-  const explicitClaude = runtime === "claude-code" ? isExplicitClaudeConfigDirEnv(opts.isExplicitClaudeConfigDir) : void 0;
-  const targets = collectOfficialSetupBackupTargets(runtime, configDir, opts.homeDir, explicitClaude);
-  const setupEnv = resolveOfficialSetupEnv(runtime, configDir, opts.homeDir, explicitClaude);
-  let backupId = null;
-  let expectedBackupFiles = 0;
-  const expandBackupTargets = (files) => {
-    const out = [];
-    for (const file of files) {
-      try {
-        const stat = fs5.lstatSync(file);
-        if (stat.isSymbolicLink()) continue;
-        if (stat.isDirectory()) {
-          const walk = (dir) => {
-            for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-              const full = path8.join(dir, entry.name);
-              let entryStat;
-              try {
-                entryStat = fs5.lstatSync(full);
-              } catch {
-                continue;
-              }
-              if (entryStat.isSymbolicLink()) continue;
-              if (entryStat.isDirectory()) walk(full);
-              else out.push(full);
-            }
-          };
-          walk(file);
-          continue;
-        }
-      } catch {
-      }
-      out.push(file);
-    }
-    return out;
-  };
-  const result = await runOfficialSetup(runtime, {
-    homeDir: opts.homeDir,
-    engramBin,
-    backup: async () => {
-      const backup = createBackup(expandBackupTargets(targets), `official-engram-setup-${runtime}`);
-      backupId = backup?.id ?? null;
-      expectedBackupFiles = backup?.files.length ?? 0;
-      return { id: backupId ?? "no-backup" };
-    },
-    spawn: async (bin, argv) => spawnOfficialSetupBin(bin, argv, setupEnv),
-    verify: async () => verify({
-      configDir,
-      engramBin,
-      homeDir: opts.homeDir,
-      ...explicitClaude === void 0 ? {} : { isExplicitClaudeConfigDir: explicitClaude }
-    }),
-    restore: async () => {
-      if (backupId === null) return { restored: false };
-      const restored = restoreBackup(backupId);
-      if (restored !== expectedBackupFiles) {
-        throw new Error(
-          `restore incompleto: ${restored}/${expectedBackupFiles} archivos (backup ${backupId}).`
-        );
-      }
-      return { restored: true };
-    },
-    targets
-  });
-  return {
-    ran: true,
-    ok: result.ok,
-    ownershipTransferred: result.ownershipTransferred,
-    ...result.stderr === void 0 ? {} : { stderr: result.stderr },
-    ...result.reason === void 0 ? {} : { reason: result.reason },
-    ...result.incompleteRecovery === void 0 ? {} : { incompleteRecovery: result.incompleteRecovery },
-    ...result.recovery === void 0 ? {} : { recovery: result.recovery },
-    ...result.backupId === void 0 ? {} : { backupId: result.backupId },
-    ...result.restoreError === void 0 ? {} : { restoreError: result.restoreError }
-  };
-}
-
-export {
-  readTextIfExists,
-  ensureDir,
-  writeText,
-  copyFile,
-  isContainedIn,
-  pruneEmptyDirs,
-  sameFileContent,
-  listFilesRecursive,
-  createBackup,
-  listBackups,
-  restoreBackup,
-  hasHealthyManagedMarkdownMarkers,
-  upsertMarkdownSection,
-  removeMarkdownSection,
-  stripLeadingHtmlComments,
-  upsertJson,
-  hasTomlRootKey,
-  upsertTomlRootKeyIfMissing,
-  removeTomlRootKeyIfExact,
-  headerName,
-  multilineStringMask,
-  upsertTomlSection,
-  removeTomlSection,
-  readTomlSection,
-  hasTomlChildSection,
-  SYSTEM_PROMPT_SECTIONS,
-  assertSystemPromptMarkers,
-  readSystemPromptFile,
-  assertSystemPromptFile,
-  removeSystemPromptSections,
-  loadCanonicalAgents,
-  DEVTOOLS_MCP_SERVER,
-  isCanonicalMcpServerEnabled,
-  loadCanonicalMcp,
-  loadCanonicalHooks,
-  loadCanonicalDefaults,
-  resolveAgentModel,
-  DEFAULT_MODEL_MAP,
-  modelMapFile,
-  loadModelMap,
-  ensureModelMapFile,
-  lookPath,
-  planDetectedBinCommand,
-  runDetectedBin,
-  detectOpenCode,
-  detectClaudeCode,
-  detectCodex,
-  detectEngram,
-  engramVersion,
-  hookScriptNames,
-  removeNativeHooks,
-  upsertNativeHooks,
-  hasManagedMarkdownSection,
-  createLocalCapabilityReport,
-  localQualityStatus,
-  shouldRunOfficialSetup,
-  registerOfficialSetupVerifier,
-  validateOfficialSetupDestination,
-  runOfficialSetupIfNeeded
-};