jorgex-stack 1.0.29 → 1.0.31

package/README.md

@@ -8,16 +8,24 @@ Portable multi-agent harness: one configuration source — 15 agents, 17 skills,
 
 Install and run via npm without cloning the repository:
 
+```bash
+# First installation
+pnpm dlx jorgex-stack install
+
+# Already installed: apply the latest published stack while keeping the existing model selection
+pnpm dlx jorgex-stack sync
 ```
-pnpm dlx jorgex-stack install    # install runtimes; first OpenCode setup selects connected models
-pnpm dlx jorgex-stack models     # model picker by runtime and tier (strong/standard/cheap)
-pnpm dlx jorgex-stack sync       # alias of install (same idempotent apply)
-pnpm dlx jorgex-stack doctor     # checks that everything is healthy (Engram, drift, hooks, keys)
-pnpm dlx jorgex-stack update     # interactive: scans stack + Engram, multiselect, diff/confirm
-                                 # With --check: report only, no changes
-                                 # With --yes: batch mode (report only)
-pnpm dlx jorgex-stack restore    # restores a backup
-pnpm dlx jorgex-stack uninstall  # uninstalls our files and keeps user data (Engram intact)
+
+Other important commands:
+
+```bash
+pnpm dlx jorgex-stack doctor          # check Engram, config drift, hooks and keys
+pnpm dlx jorgex-stack models          # change models by runtime, tier or subagent
+pnpm dlx jorgex-stack update --check  # report available stack, Engram and skill updates
+pnpm dlx jorgex-stack update          # interactively review and apply available updates
+pnpm dlx jorgex-stack restore --list  # list automatic backups
+pnpm dlx jorgex-stack restore <id>    # restore one backup
+pnpm dlx jorgex-stack uninstall       # remove managed files; keep Engram data intact
 ```
 
 For development from a clone, run the same commands through `pnpm cli <command>` (see [Development](#development)).

package/dist/cli.js

@@ -5,7 +5,7 @@ import * as p6 from "@clack/prompts";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/install.ts
-import fs14 from "fs";
+import fs13 from "fs";
 import path19 from "path";
 import * as p from "@clack/prompts";
 
@@ -546,8 +546,6 @@ var opencodeAdapter = {
 ${deny}`);
       }
       if (!agent.spawn) lines.push("  task: deny");
-      lines.push("tools:");
-      lines.push(`  write: ${agent.readonly ? "false" : "true"}`);
     }
     return [
       {
@@ -803,16 +801,7 @@ 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" }
-      ];
+      return [{ file: `${agent.name}.md`, content: style, kind: "output-style" }];
     }
     const lines = [`name: ${agent.name}`, `description: ${yamlString2(agent.description)}`];
     const tools = toolsFor(agent);
@@ -995,16 +984,7 @@ var codexAdapter = {
         `# 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" }
-      ];
+      return [{ file: `${agent.name}.config.toml`, content: profileLines.join("\n") + "\n", kind: "profile" }];
     }
     const lines = [
       `name = ${tomlString(agent.name)}`,
@@ -1379,13 +1359,6 @@ import path13 from "path";
 var PROGRAMMATIC_ROOT = ["modes", "programmatic"];
 var PROGRAMMATIC_MARKER = "<!-- jorgex:programmatic-mode -->";
 var LEGACY_RESULT_CONTRACT_SECTION = /\n?##\s+Result contract[\s\S]*$/;
-var LEGACY_SKILL_DELEGATION_SECTION = /\n?##\s+Formato obligatorio[\s\S]*$/;
-var LEGACY_DELEGATION_LINE = /- For each `→ \[agent\]: \.\.\.` line, launch the corresponding specialist\./;
-var LEGACY_PROGRAMMATIC_PHRASES = [
-  [/\bResult contract\b/g, "strict JSON handoff"],
-  [/Status \/ Delegations \/ Risks/g, "status, delegations, and risks"],
-  [LEGACY_DELEGATION_LINE, "- Process the JSON `delegations[]` array and launch the corresponding specialist."]
-];
 var normalize = (value) => value.replace(/\r\n/g, "\n");
 function loadProgrammaticAddendum(stackDir, fileName) {
   return normalize(fs9.readFileSync(path13.join(stackDir, ...PROGRAMMATIC_ROOT, fileName), "utf8")).trim();
@@ -1399,10 +1372,7 @@ ${addendum}
 `;
 }
 function stripLegacyResultContract(body) {
-  return LEGACY_PROGRAMMATIC_PHRASES.reduce(
-    (text2, [pattern, replacement]) => text2.replace(pattern, replacement),
-    normalize(body).replace(LEGACY_RESULT_CONTRACT_SECTION, "")
-  ).trimEnd();
+  return normalize(body).replace(LEGACY_RESULT_CONTRACT_SECTION, "").replace(/\bResult contract\b/g, "strict JSON handoff").trimEnd();
 }
 function concurrencyRule(concurrency) {
   if (concurrency === "parallel") {
@@ -1422,22 +1392,13 @@ function composeProgrammaticSystemPrompt(stackDir, content, mode) {
 }
 function composeProgrammaticAgentBody(stackDir, agent, mode, concurrency) {
   if (mode !== "programmatic") return normalize(agent.body);
-  const fileName = agent.mode === "primary" ? "orchestrator.addendum.md" : "subagent.addendum.md";
-  let addendum = loadProgrammaticAddendum(stackDir, fileName);
   if (agent.mode === "primary") {
-    addendum = addendum.replace("{{CONCURRENCY_RULE}}", concurrencyRule(concurrency ?? "serial"));
+    const addendum2 = loadProgrammaticAddendum(stackDir, "orchestrator.addendum.md").replace("{{CONCURRENCY_RULE}}", concurrencyRule(concurrency ?? "serial"));
+    return appendAddendum(agent.body, addendum2);
   }
+  const addendum = loadProgrammaticAddendum(stackDir, "subagent.addendum.md");
   return appendAddendum(stripLegacyResultContract(agent.body), addendum);
 }
-function composeProgrammaticSkillBody(stackDir, skillPath, content, mode) {
-  if (mode !== "programmatic") return normalize(content);
-  if (skillPath !== path13.join("agent-delegation", "SKILL.md")) return normalize(content);
-  const base = normalize(content).replace(
-    "Las delegaciones van **en tu output final**, en el formato de abajo. El orquestador las lee y decide a qui\xE9n invocar.",
-    "Las delegaciones van como strings en el JSON final `delegations[]`. El orquestador las lee y decide a qui\xE9n invocar."
-  ).replace(LEGACY_SKILL_DELEGATION_SECTION, "").trimEnd();
-  return appendAddendum(base, loadProgrammaticAddendum(stackDir, "agent-delegation.addendum.md"));
-}
 
 // src/components/system-prompt.ts
 var normalize2 = (s) => s.replace(/\r\n/g, "\n");
@@ -1461,12 +1422,11 @@ function planSystemPrompt(adapter, ctx) {
 // src/components/agents.ts
 import path15 from "path";
 function planAgents(adapter, ctx) {
-  const { agentsDir, commandsDir, outputStylesDir, skillsDir, profilesDir, scriptsDir } = adapter.paths(ctx.configDir);
+  const { agentsDir, commandsDir, outputStylesDir, profilesDir, scriptsDir } = adapter.paths(ctx.configDir);
   const dirFor = {
     agent: agentsDir,
     command: commandsDir,
     "output-style": outputStylesDir,
-    skill: skillsDir,
     profile: profilesDir
   };
   const scriptsBase = scriptsDir.replace(/\\/g, "/");
@@ -1489,43 +1449,35 @@ function planAgents(adapter, ctx) {
 
 // src/components/skills.ts
 import path16 from "path";
-import fs11 from "fs";
 function planSkills(adapter, ctx) {
   const { skillsDir } = adapter.paths(ctx.configDir);
   const source = path16.join(ctx.stackDir, "skills");
   return listFilesRecursive(source).map((file) => {
     const relative = path16.relative(source, file);
-    if (relative === path16.join("agent-delegation", "SKILL.md") && ctx.mode === "programmatic") {
-      return {
-        kind: "write",
-        target: path16.join(skillsDir, relative),
-        content: composeProgrammaticSkillBody(ctx.stackDir, relative, fs11.readFileSync(file, "utf8"), ctx.mode)
-      };
-    }
     return { kind: "copy", source: file, target: path16.join(skillsDir, relative) };
   });
 }
 
 // src/components/commands.ts
 import path17 from "path";
-import fs12 from "fs";
+import fs11 from "fs";
 function planCommands(adapter, ctx) {
   const { commandsDir } = adapter.paths(ctx.configDir);
   const source = path17.join(ctx.stackDir, "commands");
-  if (!fs12.existsSync(source)) return [];
+  if (!fs11.existsSync(source)) return [];
   const commandFiles = [
     ...listMarkdownFiles(source),
     ...listMarkdownFiles(path17.join(source, adapter.id))
   ];
   return commandFiles.map(({ file, fullPath }) => {
-    const raw = fs12.readFileSync(fullPath, "utf8").replace(/\r\n/g, "\n");
+    const raw = fs11.readFileSync(fullPath, "utf8").replace(/\r\n/g, "\n");
     const rendered = adapter.renderCommand(file, raw);
     return { kind: "write", target: path17.join(commandsDir, rendered.file), content: rendered.content };
   });
 }
 function listMarkdownFiles(dir) {
-  if (!fs12.existsSync(dir)) return [];
-  return fs12.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => ({ file: entry.name, fullPath: path17.join(dir, entry.name) }));
+  if (!fs11.existsSync(dir)) return [];
+  return fs11.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => ({ file: entry.name, fullPath: path17.join(dir, entry.name) }));
 }
 
 // src/components/hooks.ts
@@ -1540,22 +1492,22 @@ function planMcp(adapter, ctx) {
 
 // src/components/plugins.ts
 import path18 from "path";
-import fs13 from "fs";
+import fs12 from "fs";
 function planPlugins(adapter, ctx) {
   const { pluginsDir } = adapter.paths(ctx.configDir);
   if (pluginsDir === null) return [];
   const source = path18.join(ctx.stackDir, "plugins", adapter.id);
-  if (!fs13.existsSync(source)) return [];
+  if (!fs12.existsSync(source)) return [];
   return listFilesRecursive(source).filter((f) => f.endsWith(".ts")).map((sourceFile) => {
     const target = path18.join(pluginsDir, path18.relative(source, sourceFile));
-    const raw = fs13.readFileSync(sourceFile, "utf8");
+    const raw = fs12.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(
-        fs13.readFileSync(path18.join(ctx.stackDir, "system-prompt", "engram-protocol.md"), "utf8").replace(/\r\n/g, "\n")
+        fs12.readFileSync(path18.join(ctx.stackDir, "system-prompt", "engram-protocol.md"), "utf8").replace(/\r\n/g, "\n")
       );
       content = content.replace(/"\{\{ENGRAM_PROTOCOL\}\}"/g, JSON.stringify(protocol));
     }
@@ -1602,7 +1554,7 @@ function diffPlan(plan) {
       if (current === null) return { action, status: "create" };
       return { action, status: current === action.content ? "unchanged" : "update" };
     }
-    if (!fs14.existsSync(action.target)) return { action, status: "create" };
+    if (!fs13.existsSync(action.target)) return { action, status: "create" };
     return { action, status: sameFileContent(action.source, action.target) ? "unchanged" : "update" };
   });
 }
@@ -1734,7 +1686,7 @@ async function runInstall(opts) {
     applyChanges(changes);
     const pruneRoot = useManifest ? HOME : path19.dirname(configDir);
     for (const orphan of orphans) {
-      fs14.rmSync(orphan, { force: true });
+      fs13.rmSync(orphan, { force: true });
       pruneEmptyDirs(orphan, pruneRoot);
     }
     const verifyCtx = { ...ctx, warnings: [] };
@@ -1757,7 +1709,7 @@ async function runInstall(opts) {
 }
 
 // src/uninstall.ts
-import fs15 from "fs";
+import fs14 from "fs";
 import path20 from "path";
 import * as p2 from "@clack/prompts";
 async function runUninstall(opts) {
@@ -1812,7 +1764,7 @@ async function runUninstall(opts) {
     const pruneRoot = usingRealConfig ? HOME : path20.dirname(configDir);
     const planTargets = [
       .../* @__PURE__ */ new Set([...buildPlan(adapter, ctx).map((a) => path20.resolve(a.target)), ...prevOwned.map((t) => path20.resolve(t))])
-    ].filter((t) => !mergedTargets.has(t) && fs15.existsSync(t));
+    ].filter((t) => !mergedTargets.has(t) && fs14.existsSync(t));
     const deleteTargets = planTargets.filter(
       (t) => !retained.has(t) && !(ctx.preserveEngram && path20.basename(t) === "engram.ts") && isContainedIn(t, pruneRoot)
     );
@@ -1822,18 +1774,18 @@ async function runUninstall(opts) {
     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) => fs15.existsSync(t))],
+      [...deleteTargets, ...unmerge.map((a) => a.target).filter((t) => fs14.existsSync(t))],
       `uninstall-${id}`
     );
     if (backup) p2.log.info(`Backup: ${backup.id} (${backup.files.length} archivos)`);
     for (const target of deleteTargets) {
-      fs15.rmSync(target, { force: true });
+      fs14.rmSync(target, { force: true });
       pruneEmptyDirs(target, pruneRoot);
     }
     for (const action of unmerge) {
       if (action.kind !== "write") continue;
       if (action.content.trim() === "") {
-        fs15.rmSync(action.target, { force: true });
+        fs14.rmSync(action.target, { force: true });
       } else {
         writeText(action.target, action.content);
       }
@@ -1847,7 +1799,7 @@ async function runUninstall(opts) {
 
 // src/doctor.ts
 import path21 from "path";
-import fs16 from "fs";
+import fs15 from "fs";
 import * as p3 from "@clack/prompts";
 function engramVersion(bin) {
   const out = runDetectedBin(bin, ["--version"], 5e3);
@@ -1880,11 +1832,11 @@ async function runDoctor() {
   }
   const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path21.join(HOME, ".engram");
   const engramDb = path21.join(engramDataDir, "engram.db");
-  if (fs16.existsSync(engramDb)) {
-    const sizeMb = (fs16.statSync(engramDb).size / 1024 / 1024).toFixed(1);
+  if (fs15.existsSync(engramDb)) {
+    const sizeMb = (fs15.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 (!fs16.existsSync(modelMapFile())) p3.log.info("model-map: a\xFAn no creado (se crea en el primer install o con 'models').");
+  if (!fs15.existsSync(modelMapFile())) p3.log.info("model-map: a\xFAn no creado (se crea en el primer install o con 'models').");
   const manifest = readManifest();
   const modePreference = loadInstallModePreference();
   const current = collectAllCurrentTargets(modePreference);
@@ -1923,10 +1875,10 @@ async function runDoctor() {
       p3.log.warn(`${adapter.name}: ${orphans.length} archivos hu\xE9rfanos de versiones previas \u2192 ejecuta 'sync'.`);
       problems++;
     }
-    if (adapter.id === "codex" && fs16.existsSync(path21.join(detection.configDir, "hooks.json"))) {
+    if (adapter.id === "codex" && fs15.existsSync(path21.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" && fs16.existsSync(path21.join(detection.configDir, "AGENTS.override.md"))) {
+    if (adapter.id === "codex" && fs15.existsSync(path21.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."
       );
@@ -1940,14 +1892,14 @@ async function runDoctor() {
 }
 
 // src/update.ts
-import fs19 from "fs";
+import fs18 from "fs";
 import path24 from "path";
 import os3 from "os";
 import { execFileSync as execFileSync4 } from "child_process";
 import * as p4 from "@clack/prompts";
 
 // src/lib/github.ts
-import fs17 from "fs";
+import fs16 from "fs";
 import path22 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 import os2 from "os";
@@ -2022,7 +1974,7 @@ function validateExtractedTree(destDir) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs17.readdirSync(dir, { withFileTypes: true });
+      entries = fs16.readdirSync(dir, { withFileTypes: true });
     } catch {
       return false;
     }
@@ -2030,7 +1982,7 @@ function validateExtractedTree(destDir) {
       const full = path22.join(dir, entry.name);
       let stat;
       try {
-        stat = fs17.lstatSync(full);
+        stat = fs16.lstatSync(full);
       } catch {
         return false;
       }
@@ -2047,14 +1999,14 @@ function validateExtractedTree(destDir) {
 function resolveTarBin() {
   if (process.platform !== "win32") return "tar";
   const winTar = path22.join(process.env["SystemRoot"] ?? "C:\\Windows", "System32", "tar.exe");
-  return fs17.existsSync(winTar) ? winTar : "tar";
+  return fs16.existsSync(winTar) ? winTar : "tar";
 }
 async function downloadRepoTarball(repo, sha, destDir, validateSubdir) {
   const url = `https://codeload.github.com/${repo}/tar.gz/${sha}`;
   const tmp = path22.join(os2.tmpdir(), `jorgex-tarball-${Date.now()}.tar.gz`);
   const fail = (reason) => {
     try {
-      fs17.rmSync(destDir, { recursive: true, force: true });
+      fs16.rmSync(destDir, { recursive: true, force: true });
     } catch {
     }
     return { ok: false, reason };
@@ -2073,10 +2025,10 @@ async function downloadRepoTarball(repo, sha, destDir, validateSubdir) {
     if (!res.body) return fail("respuesta HTTP sin cuerpo");
     await pipeline(
       Readable.fromWeb(res.body),
-      fs17.createWriteStream(tmp)
+      fs16.createWriteStream(tmp)
     );
-    fs17.rmSync(destDir, { recursive: true, force: true });
-    fs17.mkdirSync(destDir, { recursive: true });
+    fs16.rmSync(destDir, { recursive: true, force: true });
+    fs16.mkdirSync(destDir, { recursive: true });
     try {
       execFileSync2(resolveTarBin(), ["-xzf", tmp, "--strip-components=1", "-C", destDir], { stdio: "pipe" });
     } catch (err) {
@@ -2089,30 +2041,30 @@ async function downloadRepoTarball(repo, sha, destDir, validateSubdir) {
     if (validateRoot !== resolvedDest && !isContainedIn(validateRoot, resolvedDest)) {
       return fail(`la ruta de validaci\xF3n "${validateSubdir}" escapa del destino`);
     }
-    if (fs17.existsSync(validateRoot) && !validateExtractedTree(validateRoot)) {
+    if (fs16.existsSync(validateRoot) && !validateExtractedTree(validateRoot)) {
       return fail("el \xE1rbol extra\xEDdo contiene symlinks o rutas fuera del destino");
     }
-    const validated = fs17.existsSync(validateRoot);
+    const validated = fs16.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 {
-      fs17.rmSync(tmp, { force: true });
+      fs16.rmSync(tmp, { force: true });
     } catch {
     }
   }
 }
 
 // src/lib/skill-update.ts
-import fs18 from "fs";
+import fs17 from "fs";
 import path23 from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 var PROTECTED_SKILLS = /* @__PURE__ */ new Set(["agent-delegation", "work-lifecycle", "xreview"]);
 function sameTextContentNormalized(a, b) {
-  const ba = fs18.readFileSync(a);
-  const bb = fs18.readFileSync(b);
+  const ba = fs17.readFileSync(a);
+  const bb = fs17.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");
@@ -2194,7 +2146,7 @@ function replaceSkill(name, upstreamSkillDir, newCommit, opts) {
     throw new Error(`La skill "${name}" es propia del stack y no se actualiza desde upstream.`);
   }
   const upstreamsFile = upstreamsFilePath ?? path23.join(path23.dirname(stackRoot()), "upstreams.json");
-  const raw = fs18.readFileSync(upstreamsFile, "utf8");
+  const raw = fs17.readFileSync(upstreamsFile, "utf8");
   const data = JSON.parse(raw);
   const skillEntry = data?.skills?.[name];
   if (!skillEntry) {
@@ -2213,7 +2165,7 @@ function replaceSkill(name, upstreamSkillDir, newCommit, opts) {
   try {
     const upstreamFiles = listFilesRecursive(upstreamSkillDir);
     for (const src of upstreamFiles) {
-      const st = fs18.lstatSync(src);
+      const st = fs17.lstatSync(src);
       if (st.isSymbolicLink()) {
         throw new Error(`Symlink rechazado en upstream de skill "${name}": ${src}`);
       }
@@ -2223,14 +2175,14 @@ function replaceSkill(name, upstreamSkillDir, newCommit, opts) {
       copyFile(src, dest);
     }
     const oldDir = `${localSkillDir}.old-${process.pid}`;
-    if (fs18.existsSync(localSkillDir)) {
-      fs18.renameSync(localSkillDir, oldDir);
+    if (fs17.existsSync(localSkillDir)) {
+      fs17.renameSync(localSkillDir, oldDir);
     }
-    fs18.renameSync(stagingDir, localSkillDir);
-    fs18.rmSync(oldDir, { recursive: true, force: true });
+    fs17.renameSync(stagingDir, localSkillDir);
+    fs17.rmSync(oldDir, { recursive: true, force: true });
   } catch (err) {
     try {
-      fs18.rmSync(stagingDir, { recursive: true, force: true });
+      fs17.rmSync(stagingDir, { recursive: true, force: true });
     } catch {
     }
     throw err;
@@ -2245,7 +2197,7 @@ function rateLimitHint(prefix) {
 }
 function loadUpstreams() {
   const file = path24.join(path24.dirname(stackRoot()), "upstreams.json");
-  return JSON.parse(fs19.readFileSync(file, "utf8"));
+  return JSON.parse(fs18.readFileSync(file, "utf8"));
 }
 function skillsToScan(maintainer, upstreams) {
   return maintainer ? Object.keys(upstreams.skills) : [];
@@ -2358,7 +2310,7 @@ function isEngramRunning() {
   }
 }
 function isGitClone(projectRoot = path24.dirname(stackRoot())) {
-  return fs19.existsSync(path24.join(projectRoot, ".git"));
+  return fs18.existsSync(path24.join(projectRoot, ".git"));
 }
 var STACK_METHOD_CLONE = "git pull + pnpm install + pnpm build";
 function resolvePnpm() {
@@ -2368,7 +2320,7 @@ function resolvePnpm() {
 }
 function cleanupTmp(dir) {
   try {
-    fs19.rmSync(dir, { recursive: true, force: true });
+    fs18.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -2390,7 +2342,7 @@ function updateStackGlobal() {
   execFileSync4(pnpm, ["add", "-g", "jorgex-stack@latest"], { stdio: "inherit" });
 }
 async function downloadSkillToTemp(repo, sha, skillPath) {
-  const root = fs19.mkdtempSync(path24.join(os3.tmpdir(), "jorgex-skill-"));
+  const root = fs18.mkdtempSync(path24.join(os3.tmpdir(), "jorgex-skill-"));
   try {
     const result = await downloadRepoTarball(repo, sha, root, skillPath);
     if (!result.ok) {
@@ -2403,10 +2355,10 @@ async function downloadSkillToTemp(repo, sha, skillPath) {
         cleanupTmp(root);
         return { error: `la ruta "${skillPath}" escapa del directorio temporal` };
       }
-      if (fs19.existsSync(sub)) return { dir: sub, root };
+      if (fs18.existsSync(sub)) return { dir: sub, root };
       const lastSeg = skillPath.split("/").pop();
       const sub2 = path24.resolve(path24.join(root, lastSeg));
-      if (isContainedIn(sub2, root) && fs19.existsSync(sub2)) {
+      if (isContainedIn(sub2, root) && fs18.existsSync(sub2)) {
         if (!validateExtractedTree(sub2)) {
           cleanupTmp(root);
           return { error: `el sub\xE1rbol "${lastSeg}" contiene symlinks o rutas fuera del destino` };
@@ -2425,11 +2377,11 @@ async function downloadSkillToTemp(repo, sha, skillPath) {
 function pruneEngramDbBackups() {
   try {
     const dir = dataDir();
-    if (!fs19.existsSync(dir)) return;
-    const backups = fs19.readdirSync(dir).filter((f) => f.startsWith("engram-db-backup-") && f.endsWith(".db")).map((f) => ({ name: f, mtime: fs19.statSync(path24.join(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+    if (!fs18.existsSync(dir)) return;
+    const backups = fs18.readdirSync(dir).filter((f) => f.startsWith("engram-db-backup-") && f.endsWith(".db")).map((f) => ({ name: f, mtime: fs18.statSync(path24.join(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
     for (const old of backups.slice(3)) {
       try {
-        fs19.rmSync(path24.join(dir, old.name));
+        fs18.rmSync(path24.join(dir, old.name));
       } catch {
       }
     }
@@ -2437,7 +2389,7 @@ function pruneEngramDbBackups() {
   }
 }
 function rotateLockedBinary(binPath, sweepRoot = HOME) {
-  if (!fs19.existsSync(binPath)) return null;
+  if (!fs18.existsSync(binPath)) return null;
   const dir = path24.dirname(binPath);
   const base = path24.basename(binPath);
   const escapedBase = base.replace(/[.*+?^$()|[\]{}\\]/g, "\\$&");
@@ -2445,10 +2397,10 @@ function rotateLockedBinary(binPath, sweepRoot = HOME) {
   const resolvedDir = path24.resolve(dir);
   if (resolvedDir === path24.resolve(sweepRoot) || isContainedIn(resolvedDir, sweepRoot)) {
     try {
-      for (const entry of fs19.readdirSync(dir)) {
+      for (const entry of fs18.readdirSync(dir)) {
         if (oldPattern.test(entry)) {
           try {
-            fs19.rmSync(path24.join(dir, entry), { force: true });
+            fs18.rmSync(path24.join(dir, entry), { force: true });
           } catch {
           }
         }
@@ -2457,7 +2409,7 @@ function rotateLockedBinary(binPath, sweepRoot = HOME) {
     }
   }
   const rotated = path24.join(dir, `${base}.old-${Date.now()}`);
-  fs19.renameSync(binPath, rotated);
+  fs18.renameSync(binPath, rotated);
   return rotated;
 }
 async function updateEngram(engramRepo, latestVersion) {
@@ -2468,7 +2420,7 @@ async function updateEngram(engramRepo, latestVersion) {
   }
   const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path24.join(HOME, ".engram");
   const engramDb = path24.join(engramDataDir, "engram.db");
-  if (fs19.existsSync(engramDb)) {
+  if (fs18.existsSync(engramDb)) {
     const doBackup = await p4.confirm({
       message: `\xBFHacer backup de la DB de Engram antes de actualizar? (${engramDb})`,
       initialValue: true
@@ -2477,8 +2429,8 @@ async function updateEngram(engramRepo, latestVersion) {
       const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const dest = path24.join(dataDir(), `engram-db-backup-${ts}.db`);
       try {
-        if (!fs19.existsSync(dataDir())) fs19.mkdirSync(dataDir(), { recursive: true });
-        fs19.copyFileSync(engramDb, dest);
+        if (!fs18.existsSync(dataDir())) fs18.mkdirSync(dataDir(), { recursive: true });
+        fs18.copyFileSync(engramDb, dest);
         p4.log.success(`DB respaldada en ${dest} (la DB original NO se modifica jam\xE1s).`);
         pruneEngramDbBackups();
       } catch (err) {
@@ -2528,10 +2480,10 @@ async function updateEngram(engramRepo, latestVersion) {
         ["install", `github.com/Gentleman-Programming/engram/cmd/engram@v${latestVersion}`],
         { stdio: "inherit" }
       );
-      const rollbackOk = resolveEngramRollback({ installOk: true, rotated, bin, binExists: fs19.existsSync(bin ?? "") });
+      const rollbackOk = resolveEngramRollback({ installOk: true, rotated, bin, binExists: fs18.existsSync(bin ?? "") });
       if (rollbackOk.action === "restore") {
         try {
-          fs19.renameSync(rotated, bin);
+          fs18.renameSync(rotated, bin);
           p4.log.warn(rollbackOk.messages.onRestore);
         } catch {
           p4.log.warn(rollbackOk.messages.onRenameFail);
@@ -2539,10 +2491,10 @@ async function updateEngram(engramRepo, latestVersion) {
       }
       return true;
     } catch (err) {
-      const rollbackFail = resolveEngramRollback({ installOk: false, rotated, bin, binExists: fs19.existsSync(bin ?? "") });
+      const rollbackFail = resolveEngramRollback({ installOk: false, rotated, bin, binExists: fs18.existsSync(bin ?? "") });
       if (rollbackFail.action === "restore") {
         try {
-          fs19.renameSync(rotated, bin);
+          fs18.renameSync(rotated, bin);
           p4.log.info(rollbackFail.messages.onRestore);
         } catch {
           p4.log.error(rollbackFail.messages.onRenameFail);
@@ -3063,7 +3015,7 @@ function cancelled() {
 }
 
 // src/lib/release.ts
-import fs20 from "fs";
+import fs19 from "fs";
 import path26 from "path";
 import { execFileSync as execFileSync5 } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -3071,7 +3023,7 @@ function findPackageJson() {
   let dir = path26.dirname(fileURLToPath2(import.meta.url));
   for (let i = 0; i < 6; i++) {
     const candidate = path26.join(dir, "package.json");
-    if (fs20.existsSync(candidate)) return candidate;
+    if (fs19.existsSync(candidate)) return candidate;
     dir = path26.dirname(dir);
   }
   throw new Error("No se encontr\xF3 package.json cerca del CLI.");
@@ -3081,7 +3033,7 @@ function readPackageVersion() {
 }
 function readPackageMetadata() {
   const packageJson = findPackageJson();
-  const raw = fs20.readFileSync(packageJson, "utf8");
+  const raw = fs19.readFileSync(packageJson, "utf8");
   const parsed = JSON.parse(raw);
   const name = typeof parsed.name === "string" ? parsed.name.trim() : "";
   const version = typeof parsed.version === "string" ? parsed.version.trim() : "";

package/package.json

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

package/stack/agents/README.md

@@ -1,6 +1,6 @@
 # Agentes canónicos
 
-Una sola fuente por agente. El instalador los traduce al formato de cada runtime (PRD §6): Markdown+frontmatter para Claude Code y OpenCode, TOML para Codex.
+Una sola fuente por agente. El instalador los traduce al formato de cada runtime (PRD §6): Markdown+frontmatter para Claude Code y OpenCode, TOML para Codex. El workflow completo del orchestrator vive únicamente en `skills/orchestrator/SKILL.md`; el agente primary es un wrapper corto que obliga a cargar esa skill.
 
 ## Frontmatter canónico
 
@@ -19,7 +19,7 @@ Una sola fuente por agente. El instalador los traduce al formato de cada runtime
 | Canónico | Claude Code | Codex | OpenCode |
 |---|---|---|---|
 | `tier` | alias `fable`/`opus`/`sonnet`/`haiku` según model-map | `model` + `model_reasoning_effort` | `provider/model` del model-map |
-| `readonly: true` | `tools: Read, Grep, Glob` (+Bash si aplica) | `sandbox_mode = "read-only"` | `tools: { write: false }`, `permission: { edit: deny }` |
+| `readonly: true` | `tools: Read, Grep, Glob` (+Bash si aplica) | `sandbox_mode = "read-only"` | `permission: { edit: deny }` |
 | `bash: git-read` | `Bash` completo en tools — la restricción a git read es solo de prompt (el frontmatter de Claude Code no tiene esa granularidad) | con `readonly: true` el sandbox read-only impide escrituras; con `readonly: false` la restricción es solo de prompt | `permission.bash: { "git diff*": allow, "git log*": allow }` (única aplicación real) |
 | `bash: none` | sin `Bash` en tools | sandbox read-only | `permission: { bash: deny }` |
 | `spawn: false` | sin tool `Agent`/`Task` | n/a | `permission: { task: deny }` |