jorgex-stack 1.0.14 → 1.0.16

package/dist/cli.js

@@ -5,8 +5,8 @@ import * as p6 from "@clack/prompts";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/install.ts
-import fs11 from "fs";
-import path17 from "path";
+import fs14 from "fs";
+import path19 from "path";
 import * as p from "@clack/prompts";
 
 // src/adapters/opencode.ts
@@ -1104,53 +1104,136 @@ args = [${args}]`);
   }
 };
 
-// src/lib/backup.ts
+// src/lib/install-mode.ts
 import fs6 from "fs";
 import path10 from "path";
+var INSTALL_MODES = /* @__PURE__ */ new Set(["human", "programmatic"]);
+var SUBAGENT_CONCURRENCIES = /* @__PURE__ */ new Set(["serial", "parallel"]);
+var DEFAULT_INSTALL_MODE_PREFERENCE = {
+  mode: "human",
+  subagentConcurrency: "serial"
+};
+function installModePreferenceFile() {
+  return path10.join(dataDir(), "install-mode.json");
+}
+function hasInstallModePreference(file = installModePreferenceFile()) {
+  return fs6.existsSync(file);
+}
+function isInstallMode(value) {
+  return INSTALL_MODES.has(value);
+}
+function isSubagentConcurrency(value) {
+  return SUBAGENT_CONCURRENCIES.has(value);
+}
+function normalizeInstallModePreference(value) {
+  if (!value) {
+    throw new Error("Preferencia de instalaci\xF3n vac\xEDa o corrupta.");
+  }
+  if (value.mode === "human") {
+    if (value.subagentConcurrency !== "serial") {
+      throw new Error("Preferencia de instalaci\xF3n inconsistente: human solo puede usar serial.");
+    }
+    return DEFAULT_INSTALL_MODE_PREFERENCE;
+  }
+  if (value.mode === "programmatic") {
+    const subagentConcurrency = value.subagentConcurrency;
+    if (subagentConcurrency === void 0 || !isSubagentConcurrency(subagentConcurrency)) {
+      throw new Error("Preferencia de instalaci\xF3n inv\xE1lida o corrupta.");
+    }
+    return {
+      mode: "programmatic",
+      subagentConcurrency
+    };
+  }
+  throw new Error("Preferencia de instalaci\xF3n inv\xE1lida o corrupta.");
+}
+function loadInstallModePreference(file = installModePreferenceFile()) {
+  if (!fs6.existsSync(file)) return DEFAULT_INSTALL_MODE_PREFERENCE;
+  try {
+    const raw = fs6.readFileSync(file, "utf8");
+    return normalizeInstallModePreference(JSON.parse(raw));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`No se pudo leer la preferencia de instalaci\xF3n en ${file}: ${message}`);
+  }
+}
+function saveInstallModePreference(file, value) {
+  writeText(file, JSON.stringify(value, null, 2) + "\n");
+}
+function parseInstallModePreferenceFlags(mode, subagentConcurrency) {
+  if (mode !== void 0 && !isInstallMode(mode)) {
+    return { error: `Modo inv\xE1lido: ${mode}` };
+  }
+  if (subagentConcurrency !== void 0 && !isSubagentConcurrency(subagentConcurrency)) {
+    return { error: `Concurrencia de subagentes inv\xE1lida: ${subagentConcurrency}` };
+  }
+  if (subagentConcurrency !== void 0 && mode !== "programmatic") {
+    return { error: "--subagent-concurrency requiere --mode programmatic." };
+  }
+  if (mode === "human") {
+    if (subagentConcurrency !== void 0) {
+      return { error: "--subagent-concurrency no se puede usar con --mode human." };
+    }
+    return { preference: DEFAULT_INSTALL_MODE_PREFERENCE };
+  }
+  if (mode === "programmatic") {
+    return {
+      preference: {
+        mode,
+        subagentConcurrency: subagentConcurrency ?? "serial"
+      }
+    };
+  }
+  return {};
+}
+
+// src/lib/backup.ts
+import fs7 from "fs";
+import path11 from "path";
 import crypto from "crypto";
 var KEEP_BACKUPS = 10;
 function backupsRoot() {
-  return path10.join(dataDir(), "backups");
+  return path11.join(dataDir(), "backups");
 }
 function compositeChecksum(files) {
   const hash = crypto.createHash("sha256");
   for (const file of [...files].sort()) {
-    const content = crypto.createHash("sha256").update(fs6.readFileSync(file)).digest("hex");
+    const content = crypto.createHash("sha256").update(fs7.readFileSync(file)).digest("hex");
     hash.update(`${file}:${content}
 `);
   }
   return hash.digest("hex");
 }
 function createBackup(files, label, root = backupsRoot()) {
-  const existing = [...new Set(files)].filter((f) => fs6.existsSync(f));
+  const existing = [...new Set(files)].filter((f) => fs7.existsSync(f));
   if (existing.length === 0) return null;
   const checksum = compositeChecksum(existing);
   const latest = listBackups(root)[0];
   if (latest?.checksum === checksum) return latest;
   const base = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${label}`;
   let id = base;
-  let dir = path10.join(root, id);
-  for (let n = 1; fs6.existsSync(dir); n++) {
+  let dir = path11.join(root, id);
+  for (let n = 1; fs7.existsSync(dir); n++) {
     id = `${base}-${n}`;
-    dir = path10.join(root, id);
+    dir = path11.join(root, id);
   }
-  ensureDir(path10.join(dir, "files"));
+  ensureDir(path11.join(dir, "files"));
   const entries = existing.map((original, i) => {
-    const stored = path10.join(dir, "files", `${String(i).padStart(4, "0")}-${path10.basename(original)}`);
-    fs6.copyFileSync(original, stored);
+    const stored = path11.join(dir, "files", `${String(i).padStart(4, "0")}-${path11.basename(original)}`);
+    fs7.copyFileSync(original, stored);
     return { original, stored };
   });
   const info = { id, label, createdAt: (/* @__PURE__ */ new Date()).toISOString(), files: entries, checksum };
-  writeText(path10.join(dir, "manifest.json"), JSON.stringify(info, null, 2) + "\n");
+  writeText(path11.join(dir, "manifest.json"), JSON.stringify(info, null, 2) + "\n");
   pruneBackups(root);
   return info;
 }
 function listBackups(root = backupsRoot()) {
-  if (!fs6.existsSync(root)) return [];
+  if (!fs7.existsSync(root)) return [];
   const infos = [];
-  for (const entry of fs6.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs7.readdirSync(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const manifest = readTextIfExists(path10.join(root, entry.name, "manifest.json"));
+    const manifest = readTextIfExists(path11.join(root, entry.name, "manifest.json"));
     if (manifest === null) continue;
     try {
       infos.push(JSON.parse(manifest));
@@ -1165,10 +1248,10 @@ function restoreBackup(id, root = backupsRoot(), boundary = HOME) {
   if (!info) throw new Error(`Backup no encontrado: ${id}`);
   let restored = 0;
   for (const { original, stored } of info.files) {
-    if (!fs6.existsSync(stored)) continue;
+    if (!fs7.existsSync(stored)) continue;
     if (!isContainedIn(original, boundary)) continue;
-    ensureDir(path10.dirname(original));
-    fs6.copyFileSync(stored, original);
+    ensureDir(path11.dirname(original));
+    fs7.copyFileSync(stored, original);
     restored++;
   }
   return restored;
@@ -1176,15 +1259,15 @@ function restoreBackup(id, root = backupsRoot(), boundary = HOME) {
 function pruneBackups(root) {
   const all = listBackups(root);
   for (const old of all.slice(KEEP_BACKUPS)) {
-    fs6.rmSync(path10.join(root, old.id), { recursive: true, force: true });
+    fs7.rmSync(path11.join(root, old.id), { recursive: true, force: true });
   }
 }
 
 // src/lib/manifest.ts
-import fs7 from "fs";
-import path11 from "path";
+import fs8 from "fs";
+import path12 from "path";
 function manifestFile() {
-  return path11.join(dataDir(), "manifest.json");
+  return path12.join(dataDir(), "manifest.json");
 }
 function readManifest(file = manifestFile()) {
   const raw = readTextIfExists(file);
@@ -1208,23 +1291,92 @@ function removeRuntimeManifest(id, file = manifestFile()) {
   writeText(file, JSON.stringify(manifest, null, 2) + "\n");
 }
 function findOrphans(prevOwned, currentTargets, root = HOME) {
-  return prevOwned.map((f) => path11.resolve(f)).filter(
-    (f) => !currentTargets.has(f) && path11.basename(f) !== "engram.ts" && isContainedIn(f, root) && fs7.existsSync(f)
+  return prevOwned.map((f) => path12.resolve(f)).filter(
+    (f) => !currentTargets.has(f) && path12.basename(f) !== "engram.ts" && isContainedIn(f, root) && fs8.existsSync(f)
   );
 }
 
 // src/components/system-prompt.ts
-import path12 from "path";
-import fs8 from "fs";
-var normalize = (s) => s.replace(/\r\n/g, "\n");
+import path14 from "path";
+import fs10 from "fs";
+
+// src/lib/mode-composition.ts
+import fs9 from "fs";
+import path13 from "path";
+var PROGRAMMATIC_ROOT = ["modes", "programmatic"];
+var PROGRAMMATIC_MARKER = "<!-- jorgex:programmatic-mode -->";
+var LEGACY_RESULT_CONTRACT_SECTION = /\n?##\s+Result contract[\s\S]*$/;
+var 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();
+}
+function appendAddendum(base, addendum) {
+  const normalizedBase = normalize(base);
+  if (normalizedBase.includes(PROGRAMMATIC_MARKER)) return normalizedBase;
+  return `${normalizedBase.trimEnd()}
+
+${addendum}
+`;
+}
+function stripLegacyResultContract(body) {
+  return LEGACY_PROGRAMMATIC_PHRASES.reduce(
+    (text2, [pattern, replacement]) => text2.replace(pattern, replacement),
+    normalize(body).replace(LEGACY_RESULT_CONTRACT_SECTION, "")
+  ).trimEnd();
+}
+function concurrencyRule(concurrency) {
+  if (concurrency === "parallel") {
+    return [
+      "- Parallel delegation is allowed when safe.",
+      "- Set max_parallel_subagents explicitly when the runtime supports it."
+    ].join("\n");
+  }
+  return [
+    "- Launch one subagent at a time.",
+    "- No parallel delegation."
+  ].join("\n");
+}
+function composeProgrammaticSystemPrompt(stackDir, content, mode) {
+  if (mode !== "programmatic") return normalize(content);
+  return appendAddendum(normalize(content), loadProgrammaticAddendum(stackDir, "AGENTS.addendum.md"));
+}
+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"));
+  }
+  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");
 function planSystemPrompt(adapter, ctx) {
   const target = adapter.paths(ctx.configDir).systemPromptFile;
-  const agentsMd = normalize(fs8.readFileSync(path12.join(ctx.stackDir, "system-prompt", "AGENTS.md"), "utf8"));
+  const agentsMd = normalize2(fs10.readFileSync(path14.join(ctx.stackDir, "system-prompt", "AGENTS.md"), "utf8"));
   const protocol = stripLeadingHtmlComments(
-    normalize(fs8.readFileSync(path12.join(ctx.stackDir, "system-prompt", "engram-protocol.md"), "utf8"))
+    normalize2(fs10.readFileSync(path14.join(ctx.stackDir, "system-prompt", "engram-protocol.md"), "utf8"))
   );
+  const composedAgentsMd = composeProgrammaticSystemPrompt(ctx.stackDir, agentsMd, ctx.mode);
   let content = readTextIfExists(target);
-  content = upsertMarkdownSection(content, "system-prompt", agentsMd);
+  content = upsertMarkdownSection(content, "system-prompt", composedAgentsMd);
   if (adapter.injectEngramProtocol(ctx)) {
     content = upsertMarkdownSection(content, "engram-protocol", protocol);
   } else {
@@ -1234,7 +1386,7 @@ function planSystemPrompt(adapter, ctx) {
 }
 
 // src/components/agents.ts
-import path13 from "path";
+import path15 from "path";
 function planAgents(adapter, ctx) {
   const { agentsDir, commandsDir, outputStylesDir, skillsDir, profilesDir, scriptsDir } = adapter.paths(ctx.configDir);
   const dirFor = {
@@ -1245,51 +1397,62 @@ function planAgents(adapter, ctx) {
     profile: profilesDir
   };
   const scriptsBase = scriptsDir.replace(/\\/g, "/");
-  return loadCanonicalAgents(path13.join(ctx.stackDir, "agents")).flatMap(
-    (agent) => adapter.renderAgent(agent, ctx.models).flatMap((rendered) => {
+  return loadCanonicalAgents(path15.join(ctx.stackDir, "agents")).flatMap((agent) => {
+    const composedAgent = {
+      ...agent,
+      body: composeProgrammaticAgentBody(ctx.stackDir, agent, ctx.mode, ctx.subagentConcurrency)
+    };
+    return adapter.renderAgent(composedAgent, ctx.models).flatMap((rendered) => {
       const dir = dirFor[rendered.kind];
       if (dir === null) {
         ctx.warnings.push(`${adapter.name}: sin destino para '${rendered.kind}' (${rendered.file}) \u2014 omitido.`);
         return [];
       }
       const content = rendered.content.replace(/\{\{SCRIPTS_DIR\}\}/g, scriptsBase);
-      return [{ kind: "write", target: path13.join(dir, rendered.file), content }];
-    })
-  );
+      return [{ kind: "write", target: path15.join(dir, rendered.file), content }];
+    });
+  });
 }
 
 // src/components/skills.ts
-import path14 from "path";
+import path16 from "path";
+import fs11 from "fs";
 function planSkills(adapter, ctx) {
   const { skillsDir } = adapter.paths(ctx.configDir);
-  const source = path14.join(ctx.stackDir, "skills");
-  return listFilesRecursive(source).map((file) => ({
-    kind: "copy",
-    source: file,
-    target: path14.join(skillsDir, path14.relative(source, file))
-  }));
+  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 path15 from "path";
-import fs9 from "fs";
+import path17 from "path";
+import fs12 from "fs";
 function planCommands(adapter, ctx) {
   const { commandsDir } = adapter.paths(ctx.configDir);
-  const source = path15.join(ctx.stackDir, "commands");
-  if (!fs9.existsSync(source)) return [];
+  const source = path17.join(ctx.stackDir, "commands");
+  if (!fs12.existsSync(source)) return [];
   const commandFiles = [
     ...listMarkdownFiles(source),
-    ...listMarkdownFiles(path15.join(source, adapter.id))
+    ...listMarkdownFiles(path17.join(source, adapter.id))
   ];
   return commandFiles.map(({ file, fullPath }) => {
-    const raw = fs9.readFileSync(fullPath, "utf8").replace(/\r\n/g, "\n");
+    const raw = fs12.readFileSync(fullPath, "utf8").replace(/\r\n/g, "\n");
     const rendered = adapter.renderCommand(file, raw);
-    return { kind: "write", target: path15.join(commandsDir, rendered.file), content: rendered.content };
+    return { kind: "write", target: path17.join(commandsDir, rendered.file), content: rendered.content };
   });
 }
 function listMarkdownFiles(dir) {
-  if (!fs9.existsSync(dir)) return [];
-  return fs9.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => ({ file: entry.name, fullPath: path15.join(dir, entry.name) }));
+  if (!fs12.existsSync(dir)) return [];
+  return fs12.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => ({ file: entry.name, fullPath: path17.join(dir, entry.name) }));
 }
 
 // src/components/hooks.ts
@@ -1303,26 +1466,27 @@ function planMcp(adapter, ctx) {
 }
 
 // src/components/plugins.ts
-import path16 from "path";
-import fs10 from "fs";
+import path18 from "path";
+import fs13 from "fs";
 function planPlugins(adapter, ctx) {
   const { pluginsDir } = adapter.paths(ctx.configDir);
   if (pluginsDir === null) return [];
-  const source = path16.join(ctx.stackDir, "plugins", adapter.id);
-  if (!fs10.existsSync(source)) return [];
+  const source = path18.join(ctx.stackDir, "plugins", adapter.id);
+  if (!fs13.existsSync(source)) return [];
   return listFilesRecursive(source).filter((f) => f.endsWith(".ts")).map((sourceFile) => {
-    const target = path16.join(pluginsDir, path16.relative(source, sourceFile));
-    const raw = fs10.readFileSync(sourceFile, "utf8");
+    const target = path18.join(pluginsDir, path18.relative(source, sourceFile));
+    const raw = fs13.readFileSync(sourceFile, "utf8");
     let content = raw;
     if (content.includes('"{{ENGRAM_BIN}}"')) {
       content = content.replace(/"\{\{ENGRAM_BIN\}\}"/g, JSON.stringify(ctx.engramBin ?? "engram"));
     }
     if (content.includes('"{{ENGRAM_PROTOCOL}}"')) {
       const protocol = stripLeadingHtmlComments(
-        fs10.readFileSync(path16.join(ctx.stackDir, "system-prompt", "engram-protocol.md"), "utf8").replace(/\r\n/g, "\n")
+        fs13.readFileSync(path18.join(ctx.stackDir, "system-prompt", "engram-protocol.md"), "utf8").replace(/\r\n/g, "\n")
       );
       content = content.replace(/"\{\{ENGRAM_PROTOCOL\}\}"/g, JSON.stringify(protocol));
     }
+    content = content.replace(/(from\s+["'])(\.{1,2}\/[^"']+?)\.js(["'])/g, "$1$2.ts$3");
     if (content === raw) return { kind: "copy", source: sourceFile, target };
     return { kind: "write", target, content };
   });
@@ -1334,12 +1498,14 @@ var ADAPTERS = {
   "claude-code": claudeCodeAdapter,
   codex: codexAdapter
 };
-function makeContext(adapter, configDir) {
+function makeContext(adapter, configDir, mode = DEFAULT_INSTALL_MODE_PREFERENCE) {
   const models = loadModelMap()[adapter.id];
   if (!models) return null;
   return {
     stackDir: stackRoot(),
     configDir,
+    mode: mode.mode,
+    subagentConcurrency: mode.subagentConcurrency,
     engramBin: detectEngram(),
     models,
     warnings: []
@@ -1363,7 +1529,7 @@ function diffPlan(plan) {
       if (current === null) return { action, status: "create" };
       return { action, status: current === action.content ? "unchanged" : "update" };
     }
-    if (!fs11.existsSync(action.target)) return { action, status: "create" };
+    if (!fs14.existsSync(action.target)) return { action, status: "create" };
     return { action, status: sameFileContent(action.source, action.target) ? "unchanged" : "update" };
   });
 }
@@ -1373,35 +1539,49 @@ function applyChanges(changes) {
     else copyFile(action.source, action.target);
   }
 }
-function collectAllCurrentTargets() {
+function collectAllCurrentTargets(mode = DEFAULT_INSTALL_MODE_PREFERENCE) {
   const targets = /* @__PURE__ */ new Set();
   let complete = true;
+  const warnings = [];
   for (const adapter of Object.values(ADAPTERS)) {
     const detection = adapter.detect();
     if (!detection.installed) continue;
-    const ctx = makeContext(adapter, detection.configDir);
-    if (!ctx) continue;
+    const ctx = makeContext(adapter, detection.configDir, mode);
+    if (!ctx) {
+      complete = false;
+      warnings.push(`${adapter.name}: limpieza de hu\xE9rfanos deshabilitada \u2014 falta contexto/model-map instalable para este runtime.`);
+      continue;
+    }
     try {
-      for (const action of buildPlan(adapter, ctx)) targets.add(path17.resolve(action.target));
-    } catch {
+      for (const action of buildPlan(adapter, ctx)) targets.add(path19.resolve(action.target));
+    } catch (error) {
       complete = false;
+      warnings.push(
+        `${adapter.name}: limpieza de hu\xE9rfanos deshabilitada \u2014 no se pudo construir el plan completo (${error instanceof Error ? error.message : String(error)}).`
+      );
     }
   }
-  return { targets, complete };
+  return { targets, complete, warnings };
 }
 async function runInstall(opts) {
   p.intro(`jorgex-stack ${opts.dryRun ? "install (dry-run)" : "install"}`);
   const stackDir = stackRoot();
   const engramBin = detectEngram();
+  const modePreference = opts.mode === void 0 ? opts.targetDir === void 0 ? loadInstallModePreference() : DEFAULT_INSTALL_MODE_PREFERENCE : normalizeInstallModePreference(opts.mode);
+  const useManifest = opts.targetDir === void 0;
   const modelMap = loadModelMap();
-  ensureModelMapFile();
+  if (useManifest) ensureModelMapFile();
   p.log.info(engramBin ? `Engram detectado: ${engramBin} (se respeta, D7)` : "Engram NO detectado.");
-  const useManifest = opts.targetDir === void 0;
-  const current = useManifest ? collectAllCurrentTargets() : { targets: /* @__PURE__ */ new Set(), complete: false };
+  const current = useManifest ? collectAllCurrentTargets(modePreference) : { targets: /* @__PURE__ */ new Set(), complete: false, warnings: [] };
   const canOrphan = useManifest && current.complete;
   const canonicalMcp = loadCanonicalMcp(stackDir);
   const canonicalHooks = loadCanonicalHooks(stackDir);
+  if (useManifest && (!current.complete || current.warnings.length > 0)) {
+    p.log.warn("Limpieza de hu\xE9rfanos deshabilitada: no se pudo construir el plan completo de todos los runtimes.");
+    for (const warning of current.warnings) p.log.warn(warning);
+  }
   let exitCode = 0;
+  let successfulRuns = 0;
   for (const id of opts.runtimes) {
     const adapter = ADAPTERS[id];
     if (!adapter) {
@@ -1422,6 +1602,8 @@ async function runInstall(opts) {
     const ctx = {
       stackDir,
       configDir,
+      mode: modePreference.mode,
+      subagentConcurrency: modePreference.subagentConcurrency,
       engramBin,
       models,
       warnings: []
@@ -1431,8 +1613,8 @@ async function runInstall(opts) {
     let creates = diff.filter((d) => d.status === "create");
     let updates = diff.filter((d) => d.status === "update");
     let changes = [...creates, ...updates];
-    const prevManifest = canOrphan ? readManifest().runtimes[id] : void 0;
-    const orphans = prevManifest ? findOrphans(prevManifest.owned, current.targets) : [];
+    const prevManifest = useManifest ? readManifest().runtimes[id] : void 0;
+    const orphans = canOrphan && prevManifest ? findOrphans(prevManifest.owned, current.targets) : [];
     p.log.step(`${adapter.name} \u2192 ${configDir}`);
     p.log.info(
       `${diff.length} archivos gestionados: ${creates.length} nuevos, ${updates.length} modificados, ${diff.length - changes.length} sin cambios`
@@ -1447,13 +1629,17 @@ async function runInstall(opts) {
     }
     const writeManifest = () => {
       if (!useManifest) return;
-      const unmergeTargets = new Set(adapter.planUnmerge(canonicalMcp, canonicalHooks, ctx).map((a) => path17.resolve(a.target)));
-      const owned = plan.map((a) => path17.resolve(a.target)).filter((t) => !unmergeTargets.has(t));
+      const unmergeTargets = new Set(adapter.planUnmerge(canonicalMcp, canonicalHooks, ctx).map((a) => path19.resolve(a.target)));
+      const keepTarget = (target) => !unmergeTargets.has(target);
+      const liveOwned = plan.map((a) => path19.resolve(a.target)).filter(keepTarget);
+      const previousOwned = (prevManifest?.owned ?? []).map((target) => path19.resolve(target)).filter(keepTarget);
+      const owned = canOrphan ? liveOwned : [.../* @__PURE__ */ new Set([...previousOwned, ...liveOwned])];
       writeRuntimeManifest(id, { configDir, owned, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
     };
     if (changes.length === 0 && orphans.length === 0) {
       writeManifest();
       p.log.success(`${adapter.name}: ya al d\xEDa (idempotente).`);
+      successfulRuns++;
       continue;
     }
     if (!opts.yes && process.stdout.isTTY) {
@@ -1469,12 +1655,12 @@ async function runInstall(opts) {
       updates = diff.filter((d) => d.status === "update");
       changes = [...creates, ...updates];
     }
-    const backup = createBackup([...updates.map((c) => c.action.target), ...orphans], `install-${id}`);
+    const backup = useManifest ? createBackup([...updates.map((c) => c.action.target), ...orphans], `install-${id}`) : null;
     if (backup) p.log.info(`Backup: ${backup.id} (${backup.files.length} archivos)`);
     applyChanges(changes);
-    const pruneRoot = useManifest ? HOME : path17.dirname(configDir);
+    const pruneRoot = useManifest ? HOME : path19.dirname(configDir);
     for (const orphan of orphans) {
-      fs11.rmSync(orphan, { force: true });
+      fs14.rmSync(orphan, { force: true });
       pruneEmptyDirs(orphan, pruneRoot);
     }
     const verifyCtx = { ...ctx, warnings: [] };
@@ -1486,15 +1672,19 @@ async function runInstall(opts) {
     } else {
       writeManifest();
       p.log.success(`${adapter.name}: ${changes.length} archivos aplicados y verificados (idempotente).`);
+      successfulRuns++;
     }
   }
+  if (useManifest && !opts.dryRun && exitCode === 0 && successfulRuns > 0) {
+    saveInstallModePreference(installModePreferenceFile(), modePreference);
+  }
   p.outro(opts.dryRun ? "Dry-run: no se ha escrito nada." : "Hecho.");
   return exitCode;
 }
 
 // src/uninstall.ts
-import fs12 from "fs";
-import path18 from "path";
+import fs15 from "fs";
+import path20 from "path";
 import * as p2 from "@clack/prompts";
 async function runUninstall(opts) {
   p2.intro(`jorgex-stack ${opts.dryRun ? "uninstall (dry-run)" : "uninstall"}`);
@@ -1524,7 +1714,7 @@ async function runUninstall(opts) {
     if (!detection.installed) continue;
     const keepCtx = makeContext(keep, detection.configDir);
     if (!keepCtx) continue;
-    for (const action of buildPlan(keep, keepCtx)) retained.add(path18.resolve(action.target));
+    for (const action of buildPlan(keep, keepCtx)) retained.add(path20.resolve(action.target));
   }
   for (const id of opts.runtimes) {
     const adapter = ADAPTERS[id];
@@ -1542,15 +1732,15 @@ async function runUninstall(opts) {
     if (!ctx) continue;
     ctx.preserveEngram = !removeEngram;
     const unmerge = adapter.planUnmerge(mcpForUnmerge, hooks, ctx);
-    const mergedTargets = new Set(unmerge.map((a) => path18.resolve(a.target)));
+    const mergedTargets = new Set(unmerge.map((a) => path20.resolve(a.target)));
     const usingRealConfig = opts.targetDir === void 0;
     const prevOwned = usingRealConfig ? readManifest().runtimes[id]?.owned ?? [] : [];
-    const pruneRoot = usingRealConfig ? HOME : path18.dirname(configDir);
+    const pruneRoot = usingRealConfig ? HOME : path20.dirname(configDir);
     const planTargets = [
-      .../* @__PURE__ */ new Set([...buildPlan(adapter, ctx).map((a) => path18.resolve(a.target)), ...prevOwned.map((t) => path18.resolve(t))])
-    ].filter((t) => !mergedTargets.has(t) && fs12.existsSync(t));
+      .../* @__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));
     const deleteTargets = planTargets.filter(
-      (t) => !retained.has(t) && !(ctx.preserveEngram && path18.basename(t) === "engram.ts") && isContainedIn(t, pruneRoot)
+      (t) => !retained.has(t) && !(ctx.preserveEngram && path20.basename(t) === "engram.ts") && isContainedIn(t, pruneRoot)
     );
     const sharedKept = planTargets.length - deleteTargets.length;
     p2.log.step(`${adapter.name} \u2192 ${configDir}`);
@@ -1558,18 +1748,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) => fs12.existsSync(t))],
+      [...deleteTargets, ...unmerge.map((a) => a.target).filter((t) => fs15.existsSync(t))],
       `uninstall-${id}`
     );
     if (backup) p2.log.info(`Backup: ${backup.id} (${backup.files.length} archivos)`);
     for (const target of deleteTargets) {
-      fs12.rmSync(target, { force: true });
+      fs15.rmSync(target, { force: true });
       pruneEmptyDirs(target, pruneRoot);
     }
     for (const action of unmerge) {
       if (action.kind !== "write") continue;
       if (action.content.trim() === "") {
-        fs12.rmSync(action.target, { force: true });
+        fs15.rmSync(action.target, { force: true });
       } else {
         writeText(action.target, action.content);
       }
@@ -1582,8 +1772,8 @@ async function runUninstall(opts) {
 }
 
 // src/doctor.ts
-import path19 from "path";
-import fs13 from "fs";
+import path21 from "path";
+import fs16 from "fs";
 import * as p3 from "@clack/prompts";
 function engramVersion(bin) {
   const out = runDetectedBin(bin, ["--version"], 5e3);
@@ -1591,7 +1781,7 @@ function engramVersion(bin) {
   return /(\d+\.\d+\.\d+)/.exec(out)?.[1] ?? out.trim().split("\n")[0] ?? null;
 }
 function context7KeyConfigured(id, configDir) {
-  const file = id === "codex" ? path19.join(configDir, "config.toml") : id === "claude-code" ? path19.join(path19.dirname(configDir), `${path19.basename(configDir)}.json`) : path19.join(configDir, "opencode.json");
+  const file = id === "codex" ? path21.join(configDir, "config.toml") : id === "claude-code" ? path21.join(path21.dirname(configDir), `${path21.basename(configDir)}.json`) : path21.join(configDir, "opencode.json");
   const content = readTextIfExists(file);
   if (content === null) return null;
   const match = /CONTEXT7_API_KEY"?\s*[:=]\s*"([^"]*)"/.exec(content);
@@ -1614,22 +1804,28 @@ async function runDoctor() {
       p3.log.success(`Engram: ${version} (${engramBin})`);
     }
   }
-  const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path19.join(HOME, ".engram");
-  const engramDb = path19.join(engramDataDir, "engram.db");
-  if (fs13.existsSync(engramDb)) {
-    const sizeMb = (fs13.statSync(engramDb).size / 1024 / 1024).toFixed(1);
+  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);
     p3.log.info(`Engram DB: ${engramDb} (${sizeMb} MB de memorias \u2014 el stack no la toca JAM\xC1S).`);
   }
-  if (!fs13.existsSync(modelMapFile())) p3.log.info("model-map: a\xFAn no creado (se crea en el primer install o con 'models').");
+  if (!fs16.existsSync(modelMapFile())) p3.log.info("model-map: a\xFAn no creado (se crea en el primer install o con 'models').");
   const manifest = readManifest();
-  const current = collectAllCurrentTargets();
+  const modePreference = loadInstallModePreference();
+  const current = collectAllCurrentTargets(modePreference);
+  if (!current.complete || current.warnings.length > 0) {
+    p3.log.warn("Limpieza de hu\xE9rfanos deshabilitada: no se pudo construir el plan completo de todos los runtimes.");
+    for (const warning of current.warnings) p3.log.warn(warning);
+    problems++;
+  }
   for (const adapter of Object.values(ADAPTERS)) {
     const detection = adapter.detect();
     if (!detection.installed) {
       p3.log.warn(`${adapter.name}: no instalado en esta m\xE1quina.`);
       continue;
     }
-    const ctx = makeContext(adapter, detection.configDir);
+    const ctx = makeContext(adapter, detection.configDir, modePreference);
     if (!ctx) continue;
     let pending;
     try {
@@ -1653,10 +1849,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" && fs13.existsSync(path19.join(detection.configDir, "hooks.json"))) {
+    if (adapter.id === "codex" && fs16.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" && fs13.existsSync(path19.join(detection.configDir, "AGENTS.override.md"))) {
+    if (adapter.id === "codex" && fs16.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."
       );
@@ -1670,15 +1866,15 @@ async function runDoctor() {
 }
 
 // src/update.ts
-import fs16 from "fs";
-import path22 from "path";
+import fs19 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 fs14 from "fs";
-import path20 from "path";
+import fs17 from "fs";
+import path22 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 import os2 from "os";
 import { Readable } from "stream";
@@ -1748,19 +1944,19 @@ async function latestGithubCommit(repo) {
   }
 }
 function validateExtractedTree(destDir) {
-  const resolved = path20.resolve(destDir);
+  const resolved = path22.resolve(destDir);
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs14.readdirSync(dir, { withFileTypes: true });
+      entries = fs17.readdirSync(dir, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
-      const full = path20.join(dir, entry.name);
+      const full = path22.join(dir, entry.name);
       let stat;
       try {
-        stat = fs14.lstatSync(full);
+        stat = fs17.lstatSync(full);
       } catch {
         return false;
       }
@@ -1776,15 +1972,15 @@ function validateExtractedTree(destDir) {
 }
 function resolveTarBin() {
   if (process.platform !== "win32") return "tar";
-  const winTar = path20.join(process.env["SystemRoot"] ?? "C:\\Windows", "System32", "tar.exe");
-  return fs14.existsSync(winTar) ? winTar : "tar";
+  const winTar = path22.join(process.env["SystemRoot"] ?? "C:\\Windows", "System32", "tar.exe");
+  return fs17.existsSync(winTar) ? winTar : "tar";
 }
 async function downloadRepoTarball(repo, sha, destDir, validateSubdir) {
   const url = `https://codeload.github.com/${repo}/tar.gz/${sha}`;
-  const tmp = path20.join(os2.tmpdir(), `jorgex-tarball-${Date.now()}.tar.gz`);
+  const tmp = path22.join(os2.tmpdir(), `jorgex-tarball-${Date.now()}.tar.gz`);
   const fail = (reason) => {
     try {
-      fs14.rmSync(destDir, { recursive: true, force: true });
+      fs17.rmSync(destDir, { recursive: true, force: true });
     } catch {
     }
     return { ok: false, reason };
@@ -1803,10 +1999,10 @@ async function downloadRepoTarball(repo, sha, destDir, validateSubdir) {
     if (!res.body) return fail("respuesta HTTP sin cuerpo");
     await pipeline(
       Readable.fromWeb(res.body),
-      fs14.createWriteStream(tmp)
+      fs17.createWriteStream(tmp)
     );
-    fs14.rmSync(destDir, { recursive: true, force: true });
-    fs14.mkdirSync(destDir, { recursive: true });
+    fs17.rmSync(destDir, { recursive: true, force: true });
+    fs17.mkdirSync(destDir, { recursive: true });
     try {
       execFileSync2(resolveTarBin(), ["-xzf", tmp, "--strip-components=1", "-C", destDir], { stdio: "pipe" });
     } catch (err) {
@@ -1814,35 +2010,35 @@ async function downloadRepoTarball(repo, sha, destDir, validateSubdir) {
       const detail = (e.stderr?.toString().trim() || e.message || "").split("\n")[0];
       return fail(detail ? `tar fall\xF3: ${detail}` : "tar no disponible o fall\xF3 la extracci\xF3n");
     }
-    const resolvedDest = path20.resolve(destDir);
-    const validateRoot = validateSubdir ? path20.resolve(resolvedDest, validateSubdir) : resolvedDest;
+    const resolvedDest = path22.resolve(destDir);
+    const validateRoot = validateSubdir ? path22.resolve(resolvedDest, validateSubdir) : resolvedDest;
     if (validateRoot !== resolvedDest && !isContainedIn(validateRoot, resolvedDest)) {
       return fail(`la ruta de validaci\xF3n "${validateSubdir}" escapa del destino`);
     }
-    if (fs14.existsSync(validateRoot) && !validateExtractedTree(validateRoot)) {
+    if (fs17.existsSync(validateRoot) && !validateExtractedTree(validateRoot)) {
       return fail("el \xE1rbol extra\xEDdo contiene symlinks o rutas fuera del destino");
     }
-    const validated = fs14.existsSync(validateRoot);
+    const validated = fs17.existsSync(validateRoot);
     return { ok: true, validated };
   } catch (err) {
     const timedOut = err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError");
     return fail(timedOut ? "timeout de descarga (120s)" : err instanceof Error ? `fallo de red: ${err.message}` : "error desconocido");
   } finally {
     try {
-      fs14.rmSync(tmp, { force: true });
+      fs17.rmSync(tmp, { force: true });
     } catch {
     }
   }
 }
 
 // src/lib/skill-update.ts
-import fs15 from "fs";
-import path21 from "path";
+import fs18 from "fs";
+import path23 from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 var PROTECTED_SKILLS = /* @__PURE__ */ new Set(["agent-delegation", "work-lifecycle"]);
 function sameTextContentNormalized(a, b) {
-  const ba = fs15.readFileSync(a);
-  const bb = fs15.readFileSync(b);
+  const ba = fs18.readFileSync(a);
+  const bb = fs18.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");
@@ -1850,10 +2046,10 @@ function sameTextContentNormalized(a, b) {
 }
 function diffSkillDirs(upstreamDir, localDir) {
   const upstreamFiles = new Set(
-    listFilesRecursive(upstreamDir).map((f) => path21.relative(upstreamDir, f))
+    listFilesRecursive(upstreamDir).map((f) => path23.relative(upstreamDir, f))
   );
   const localFiles = new Set(
-    listFilesRecursive(localDir).map((f) => path21.relative(localDir, f))
+    listFilesRecursive(localDir).map((f) => path23.relative(localDir, f))
   );
   const added = [];
   const modified = [];
@@ -1861,7 +2057,7 @@ function diffSkillDirs(upstreamDir, localDir) {
   for (const rel of upstreamFiles) {
     if (!localFiles.has(rel)) {
       added.push(rel);
-    } else if (!sameTextContentNormalized(path21.join(upstreamDir, rel), path21.join(localDir, rel))) {
+    } else if (!sameTextContentNormalized(path23.join(upstreamDir, rel), path23.join(localDir, rel))) {
       modified.push(rel);
     }
   }
@@ -1923,8 +2119,8 @@ function replaceSkill(name, upstreamSkillDir, newCommit, opts) {
   if (PROTECTED_SKILLS.has(name)) {
     throw new Error(`La skill "${name}" es propia del stack y no se actualiza desde upstream.`);
   }
-  const upstreamsFile = upstreamsFilePath ?? path21.join(path21.dirname(stackRoot()), "upstreams.json");
-  const raw = fs15.readFileSync(upstreamsFile, "utf8");
+  const upstreamsFile = upstreamsFilePath ?? path23.join(path23.dirname(stackRoot()), "upstreams.json");
+  const raw = fs18.readFileSync(upstreamsFile, "utf8");
   const data = JSON.parse(raw);
   const skillEntry = data?.skills?.[name];
   if (!skillEntry) {
@@ -1933,8 +2129,8 @@ function replaceSkill(name, upstreamSkillDir, newCommit, opts) {
   if (skillEntry.kind === "release") {
     throw new Error(`La skill "${name}" es de tipo release y no se actualiza con replaceSkill.`);
   }
-  const skillsRoot = localSkillsRoot ?? path21.join(stackRoot(), "skills");
-  const localSkillDir = path21.join(skillsRoot, name);
+  const skillsRoot = localSkillsRoot ?? path23.join(stackRoot(), "skills");
+  const localSkillDir = path23.join(skillsRoot, name);
   const localFiles = listFilesRecursive(localSkillDir);
   if (localFiles.length > 0) {
     createBackup(localFiles, `skill-update-${name}`, backupsRoot2);
@@ -1943,24 +2139,24 @@ function replaceSkill(name, upstreamSkillDir, newCommit, opts) {
   try {
     const upstreamFiles = listFilesRecursive(upstreamSkillDir);
     for (const src of upstreamFiles) {
-      const st = fs15.lstatSync(src);
+      const st = fs18.lstatSync(src);
       if (st.isSymbolicLink()) {
         throw new Error(`Symlink rechazado en upstream de skill "${name}": ${src}`);
       }
-      const rel = path21.relative(upstreamSkillDir, src);
-      const dest = path21.join(stagingDir, rel);
-      ensureDir(path21.dirname(dest));
+      const rel = path23.relative(upstreamSkillDir, src);
+      const dest = path23.join(stagingDir, rel);
+      ensureDir(path23.dirname(dest));
       copyFile(src, dest);
     }
     const oldDir = `${localSkillDir}.old-${process.pid}`;
-    if (fs15.existsSync(localSkillDir)) {
-      fs15.renameSync(localSkillDir, oldDir);
+    if (fs18.existsSync(localSkillDir)) {
+      fs18.renameSync(localSkillDir, oldDir);
     }
-    fs15.renameSync(stagingDir, localSkillDir);
-    fs15.rmSync(oldDir, { recursive: true, force: true });
+    fs18.renameSync(stagingDir, localSkillDir);
+    fs18.rmSync(oldDir, { recursive: true, force: true });
   } catch (err) {
     try {
-      fs15.rmSync(stagingDir, { recursive: true, force: true });
+      fs18.rmSync(stagingDir, { recursive: true, force: true });
     } catch {
     }
     throw err;
@@ -1974,8 +2170,8 @@ function rateLimitHint(prefix) {
   return ghPresentButTokenFailed() ? `${prefix} Tienes gh instalado pero \`gh auth token\` no devolvi\xF3 credencial (\xBFsesi\xF3n caducada?) \u2014 prueba \`gh auth login\` o define GH_TOKEN.` : `${prefix} Define GH_TOKEN o inicia sesi\xF3n en gh CLI.`;
 }
 function loadUpstreams() {
-  const file = path22.join(path22.dirname(stackRoot()), "upstreams.json");
-  return JSON.parse(fs16.readFileSync(file, "utf8"));
+  const file = path24.join(path24.dirname(stackRoot()), "upstreams.json");
+  return JSON.parse(fs19.readFileSync(file, "utf8"));
 }
 function skillsToScan(maintainer, upstreams) {
   return maintainer ? Object.keys(upstreams.skills) : [];
@@ -2087,8 +2283,8 @@ function isEngramRunning() {
     return null;
   }
 }
-function isGitClone(projectRoot = path22.dirname(stackRoot())) {
-  return fs16.existsSync(path22.join(projectRoot, ".git"));
+function isGitClone(projectRoot = path24.dirname(stackRoot())) {
+  return fs19.existsSync(path24.join(projectRoot, ".git"));
 }
 var STACK_METHOD_CLONE = "git pull + pnpm install + pnpm build";
 function resolvePnpm() {
@@ -2098,12 +2294,12 @@ function resolvePnpm() {
 }
 function cleanupTmp(dir) {
   try {
-    fs16.rmSync(dir, { recursive: true, force: true });
+    fs19.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
 function updateStackGitClone() {
-  const projectRoot = path22.dirname(stackRoot());
+  const projectRoot = path24.dirname(stackRoot());
   const git = lookPath("git");
   if (!git) throw new Error("git no encontrado en PATH.");
   const pnpm = resolvePnpm();
@@ -2120,7 +2316,7 @@ function updateStackGlobal() {
   execFileSync4(pnpm, ["add", "-g", "jorgex-stack@latest"], { stdio: "inherit" });
 }
 async function downloadSkillToTemp(repo, sha, skillPath) {
-  const root = fs16.mkdtempSync(path22.join(os3.tmpdir(), "jorgex-skill-"));
+  const root = fs19.mkdtempSync(path24.join(os3.tmpdir(), "jorgex-skill-"));
   try {
     const result = await downloadRepoTarball(repo, sha, root, skillPath);
     if (!result.ok) {
@@ -2128,15 +2324,15 @@ async function downloadSkillToTemp(repo, sha, skillPath) {
       return { error: result.reason };
     }
     if (skillPath) {
-      const sub = path22.resolve(path22.join(root, skillPath));
+      const sub = path24.resolve(path24.join(root, skillPath));
       if (!isContainedIn(sub, root)) {
         cleanupTmp(root);
         return { error: `la ruta "${skillPath}" escapa del directorio temporal` };
       }
-      if (fs16.existsSync(sub)) return { dir: sub, root };
+      if (fs19.existsSync(sub)) return { dir: sub, root };
       const lastSeg = skillPath.split("/").pop();
-      const sub2 = path22.resolve(path22.join(root, lastSeg));
-      if (isContainedIn(sub2, root) && fs16.existsSync(sub2)) {
+      const sub2 = path24.resolve(path24.join(root, lastSeg));
+      if (isContainedIn(sub2, root) && fs19.existsSync(sub2)) {
         if (!validateExtractedTree(sub2)) {
           cleanupTmp(root);
           return { error: `el sub\xE1rbol "${lastSeg}" contiene symlinks o rutas fuera del destino` };
@@ -2155,11 +2351,11 @@ async function downloadSkillToTemp(repo, sha, skillPath) {
 function pruneEngramDbBackups() {
   try {
     const dir = dataDir();
-    if (!fs16.existsSync(dir)) return;
-    const backups = fs16.readdirSync(dir).filter((f) => f.startsWith("engram-db-backup-") && f.endsWith(".db")).map((f) => ({ name: f, mtime: fs16.statSync(path22.join(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+    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);
     for (const old of backups.slice(3)) {
       try {
-        fs16.rmSync(path22.join(dir, old.name));
+        fs19.rmSync(path24.join(dir, old.name));
       } catch {
       }
     }
@@ -2167,18 +2363,18 @@ function pruneEngramDbBackups() {
   }
 }
 function rotateLockedBinary(binPath, sweepRoot = HOME) {
-  if (!fs16.existsSync(binPath)) return null;
-  const dir = path22.dirname(binPath);
-  const base = path22.basename(binPath);
+  if (!fs19.existsSync(binPath)) return null;
+  const dir = path24.dirname(binPath);
+  const base = path24.basename(binPath);
   const escapedBase = base.replace(/[.*+?^$()|[\]{}\\]/g, "\\$&");
   const oldPattern = new RegExp("^" + escapedBase + "\\.old-\\d+$");
-  const resolvedDir = path22.resolve(dir);
-  if (resolvedDir === path22.resolve(sweepRoot) || isContainedIn(resolvedDir, sweepRoot)) {
+  const resolvedDir = path24.resolve(dir);
+  if (resolvedDir === path24.resolve(sweepRoot) || isContainedIn(resolvedDir, sweepRoot)) {
     try {
-      for (const entry of fs16.readdirSync(dir)) {
+      for (const entry of fs19.readdirSync(dir)) {
         if (oldPattern.test(entry)) {
           try {
-            fs16.rmSync(path22.join(dir, entry), { force: true });
+            fs19.rmSync(path24.join(dir, entry), { force: true });
           } catch {
           }
         }
@@ -2186,8 +2382,8 @@ function rotateLockedBinary(binPath, sweepRoot = HOME) {
     } catch {
     }
   }
-  const rotated = path22.join(dir, `${base}.old-${Date.now()}`);
-  fs16.renameSync(binPath, rotated);
+  const rotated = path24.join(dir, `${base}.old-${Date.now()}`);
+  fs19.renameSync(binPath, rotated);
   return rotated;
 }
 async function updateEngram(engramRepo, latestVersion) {
@@ -2196,19 +2392,19 @@ async function updateEngram(engramRepo, latestVersion) {
       "Engram est\xE1 en ejecuci\xF3n: los procesos vivos seguir\xE1n usando la versi\xF3n antigua hasta que reinicies los clientes (Claude Code/OpenCode/Codex)."
     );
   }
-  const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path22.join(HOME, ".engram");
-  const engramDb = path22.join(engramDataDir, "engram.db");
-  if (fs16.existsSync(engramDb)) {
+  const engramDataDir = process.env.ENGRAM_DATA_DIR ?? path24.join(HOME, ".engram");
+  const engramDb = path24.join(engramDataDir, "engram.db");
+  if (fs19.existsSync(engramDb)) {
     const doBackup = await p4.confirm({
       message: `\xBFHacer backup de la DB de Engram antes de actualizar? (${engramDb})`,
       initialValue: true
     });
     if (!p4.isCancel(doBackup) && doBackup) {
       const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const dest = path22.join(dataDir(), `engram-db-backup-${ts}.db`);
+      const dest = path24.join(dataDir(), `engram-db-backup-${ts}.db`);
       try {
-        if (!fs16.existsSync(dataDir())) fs16.mkdirSync(dataDir(), { recursive: true });
-        fs16.copyFileSync(engramDb, dest);
+        if (!fs19.existsSync(dataDir())) fs19.mkdirSync(dataDir(), { recursive: true });
+        fs19.copyFileSync(engramDb, dest);
         p4.log.success(`DB respaldada en ${dest} (la DB original NO se modifica jam\xE1s).`);
         pruneEngramDbBackups();
       } catch (err) {
@@ -2258,10 +2454,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: fs16.existsSync(bin ?? "") });
+      const rollbackOk = resolveEngramRollback({ installOk: true, rotated, bin, binExists: fs19.existsSync(bin ?? "") });
       if (rollbackOk.action === "restore") {
         try {
-          fs16.renameSync(rotated, bin);
+          fs19.renameSync(rotated, bin);
           p4.log.warn(rollbackOk.messages.onRestore);
         } catch {
           p4.log.warn(rollbackOk.messages.onRenameFail);
@@ -2269,10 +2465,10 @@ async function updateEngram(engramRepo, latestVersion) {
       }
       return true;
     } catch (err) {
-      const rollbackFail = resolveEngramRollback({ installOk: false, rotated, bin, binExists: fs16.existsSync(bin ?? "") });
+      const rollbackFail = resolveEngramRollback({ installOk: false, rotated, bin, binExists: fs19.existsSync(bin ?? "") });
       if (rollbackFail.action === "restore") {
         try {
-          fs16.renameSync(rotated, bin);
+          fs19.renameSync(rotated, bin);
           p4.log.info(rollbackFail.messages.onRestore);
         } catch {
           p4.log.error(rollbackFail.messages.onRenameFail);
@@ -2530,7 +2726,7 @@ async function runInteractiveUpdate(localVersion, yes, dryRun = false) {
       continue;
     }
     const { dir: tmpDir, root: tmpRoot } = tmpResult;
-    const localSkillDir = path22.join(stackRoot(), "skills", skillInfo.name);
+    const localSkillDir = path24.join(stackRoot(), "skills", skillInfo.name);
     const diff = renderSkillDiff(tmpDir, localSkillDir);
     if (diff) {
       p4.log.info(`Diff de ${skillInfo.name}:
@@ -2589,7 +2785,7 @@ ${diff}`);
 }
 
 // src/models-picker.ts
-import path23 from "path";
+import path25 from "path";
 import * as p5 from "@clack/prompts";
 var TIERS = ["strong", "standard", "cheap"];
 var EFFORTS = ["low", "medium", "high", "xhigh"];
@@ -2605,7 +2801,7 @@ function opencodeLiveModels(binPath) {
 }
 function agentsByTier() {
   const grouped = { strong: [], standard: [], cheap: [] };
-  for (const agent of loadCanonicalAgents(path23.join(stackRoot(), "agents"))) {
+  for (const agent of loadCanonicalAgents(path25.join(stackRoot(), "agents"))) {
     if (agent.mode === "subagent") grouped[agent.tier].push(agent.name);
   }
   return grouped;
@@ -2764,16 +2960,16 @@ function cancelled() {
 }
 
 // src/lib/release.ts
-import fs17 from "fs";
-import path24 from "path";
+import fs20 from "fs";
+import path26 from "path";
 import { execFileSync as execFileSync5 } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findPackageJson() {
-  let dir = path24.dirname(fileURLToPath2(import.meta.url));
+  let dir = path26.dirname(fileURLToPath2(import.meta.url));
   for (let i = 0; i < 6; i++) {
-    const candidate = path24.join(dir, "package.json");
-    if (fs17.existsSync(candidate)) return candidate;
-    dir = path24.dirname(dir);
+    const candidate = path26.join(dir, "package.json");
+    if (fs20.existsSync(candidate)) return candidate;
+    dir = path26.dirname(dir);
   }
   throw new Error("No se encontr\xF3 package.json cerca del CLI.");
 }
@@ -2782,7 +2978,7 @@ function readPackageVersion() {
 }
 function readPackageMetadata() {
   const packageJson = findPackageJson();
-  const raw = fs17.readFileSync(packageJson, "utf8");
+  const raw = fs20.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() : "";
@@ -2800,6 +2996,8 @@ function parseFlags(args) {
     agents: [],
     dryRun: false,
     yes: false,
+    mode: void 0,
+    subagentConcurrency: void 0,
     help: false,
     version: false,
     list: false,
@@ -2807,12 +3005,33 @@ function parseFlags(args) {
     removeEngram: false,
     positional: []
   };
+  const readValue = (index) => {
+    const value = args[index + 1];
+    if (value === void 0 || value.startsWith("-")) return [void 0, index];
+    return [value, index + 1];
+  };
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (arg === "--agents" || arg === "-a") flags.agents = (args[++i] ?? "").split(",").filter(Boolean);
-    else if (arg.startsWith("--agents=")) flags.agents = arg.slice(9).split(",").filter(Boolean);
-    else if (arg === "--target-dir") flags.targetDir = args[++i];
-    else if (arg.startsWith("--target-dir=")) flags.targetDir = arg.slice(13);
+    if (arg === "--agents" || arg === "-a") {
+      const [value, nextIndex] = readValue(i);
+      flags.agents = (value ?? "").split(",").filter(Boolean);
+      i = nextIndex;
+    } else if (arg.startsWith("--agents=")) flags.agents = arg.slice(9).split(",").filter(Boolean);
+    else if (arg === "--target-dir") {
+      const [value, nextIndex] = readValue(i);
+      flags.targetDir = value;
+      i = nextIndex;
+    } else if (arg.startsWith("--target-dir=")) flags.targetDir = arg.slice(13);
+    else if (arg === "--mode") {
+      const [value, nextIndex] = readValue(i);
+      flags.mode = value ?? "";
+      i = nextIndex;
+    } else if (arg.startsWith("--mode=")) flags.mode = arg.slice(7);
+    else if (arg === "--subagent-concurrency") {
+      const [value, nextIndex] = readValue(i);
+      flags.subagentConcurrency = value ?? "";
+      i = nextIndex;
+    } else if (arg.startsWith("--subagent-concurrency=")) flags.subagentConcurrency = arg.slice(23);
     else if (arg === "--dry-run") flags.dryRun = true;
     else if (arg === "--yes" || arg === "-y") flags.yes = true;
     else if (arg === "--help" || arg === "-h") flags.help = true;
@@ -2824,6 +3043,67 @@ function parseFlags(args) {
   }
   return flags;
 }
+async function resolveInstallMode(flags, promptIfMissing = true) {
+  const explicit = parseInstallModePreferenceFlags(flags.mode, flags.subagentConcurrency);
+  if (explicit.error) {
+    console.error(explicit.error);
+    process.exitCode = 1;
+    return null;
+  }
+  if (explicit.preference) return explicit.preference;
+  if (flags.targetDir !== void 0) {
+    p6.log.info("--target-dir ignora la preferencia guardada y usa modo human por defecto; usa --mode programmatic si quieres otro modo.");
+    return DEFAULT_INSTALL_MODE_PREFERENCE;
+  }
+  const preferenceFile = installModePreferenceFile();
+  if (hasInstallModePreference(preferenceFile)) {
+    try {
+      return loadInstallModePreference(preferenceFile);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      console.error(
+        `${reason}
+Corrige o borra ${preferenceFile}, o vuelve a ejecutar con --mode human|programmatic.`
+      );
+      process.exitCode = 1;
+      return null;
+    }
+  }
+  if (!promptIfMissing) {
+    console.error("No hay modo guardado; usa --mode expl\xEDcito para este sync.");
+    process.exitCode = 1;
+    return null;
+  }
+  if (flags.yes || !process.stdout.isTTY) return DEFAULT_INSTALL_MODE_PREFERENCE;
+  const selected = await p6.select({
+    message: "\xBFC\xF3mo quieres instalar el modo del stack?",
+    options: [
+      { value: "human", label: "Human (comportamiento actual)" },
+      { value: "programmatic", label: "Programmatic (elige concurrencia)" }
+    ],
+    initialValue: DEFAULT_INSTALL_MODE_PREFERENCE.mode
+  });
+  if (p6.isCancel(selected)) return null;
+  if (selected === "human") {
+    return {
+      mode: "human",
+      subagentConcurrency: "serial"
+    };
+  }
+  const concurrency = await p6.select({
+    message: "Concurrencia de subagentes en modo programmatic",
+    options: [
+      { value: "serial", label: "Serial (default)" },
+      { value: "parallel", label: "Parallel" }
+    ],
+    initialValue: DEFAULT_INSTALL_MODE_PREFERENCE.subagentConcurrency
+  });
+  if (p6.isCancel(concurrency)) return null;
+  return {
+    mode: "programmatic",
+    subagentConcurrency: concurrency
+  };
+}
 function parseCliArgs(argv) {
   const [first, ...rest] = argv;
   const isCommand = COMMANDS.includes(first ?? "install");
@@ -2872,6 +3152,8 @@ Comandos:
 
 Opciones:
   --agents, -a opencode,claude-code,codex   Runtimes destino (default: detectados)
+  --mode human|programmatic   Modo de instalaci\xF3n (default: preferencia guardada o human)
+  --subagent-concurrency serial|parallel  Concurrencia de subagentes en modo programmatic
   --target-dir <dir>    Dir alternativo (pruebas de paridad; requiere 1 runtime)
   --dry-run             Muestra el plan sin escribir nada
   --yes, -y             No interactivo
@@ -2899,6 +3181,8 @@ async function main() {
   switch (command) {
     case "install":
     case "sync": {
+      const mode = await resolveInstallMode(flags);
+      if (mode === null) return;
       const runtimes = await resolveRuntimes(flags);
       if (runtimes === null) return;
       if (runtimes.length === 0) {
@@ -2906,7 +3190,7 @@ async function main() {
         process.exitCode = 1;
         return;
       }
-      process.exitCode = await runInstall({ runtimes, targetDir: flags.targetDir, dryRun: flags.dryRun, yes: flags.yes });
+      process.exitCode = await runInstall({ runtimes, targetDir: flags.targetDir, dryRun: flags.dryRun, yes: flags.yes, mode });
       return;
     }
     case "uninstall": {
@@ -2941,23 +3225,46 @@ async function main() {
       }
       const runtimes = await resolveRuntimes(flags);
       if (runtimes === null) return;
-      if (runtimes.length > 0) {
-        const code = await runInstall({ runtimes, targetDir: flags.targetDir, dryRun: flags.dryRun, yes: true });
+      const preferenceFile = installModePreferenceFile();
+      const explicitMode = flags.mode !== void 0 || flags.subagentConcurrency !== void 0;
+      const hasSavedMode = hasInstallModePreference(preferenceFile);
+      const canResolveMode = flags.targetDir !== void 0 || explicitMode || hasSavedMode;
+      const mode = runtimes.length > 0 && canResolveMode ? await resolveInstallMode(flags, false) : DEFAULT_INSTALL_MODE_PREFERENCE;
+      if (mode === null) return;
+      const canSync = runtimes.length === 0 || canResolveMode;
+      if (runtimes.length > 0 && canSync) {
+        const code = await runInstall({
+          runtimes,
+          targetDir: flags.targetDir,
+          dryRun: flags.dryRun,
+          yes: true,
+          mode
+        });
         if (code !== 0) {
           process.exitCode = code;
           return;
         }
+      } else if (runtimes.length > 0) {
+        console.error("No hay modo guardado; se omite el sync previo y se contin\xFAa con update. Usa --mode expl\xEDcito si quieres sincronizar.");
       }
       const result = await runInteractiveUpdate(VERSION, flags.yes, flags.dryRun);
       process.exitCode = result.exitCode;
-      if (result.exitCode === 0 && result.appliedUpdates && runtimes.length > 0 && !flags.yes && process.stdout.isTTY) {
+      if (result.exitCode === 0 && result.appliedUpdates && runtimes.length > 0 && !canSync) {
+        p6.log.warn("Skills/stack actualizados, pero el sync con los runtimes sigue pendiente. Ejecuta jorgex-stack sync --mode human|programmatic.");
+      } else if (result.exitCode === 0 && result.appliedUpdates && runtimes.length > 0 && canSync && !flags.yes && process.stdout.isTTY) {
         const apply = await p6.confirm({ message: "\xBFRe-aplicar a los runtimes ahora? (sync)" });
         if (!p6.isCancel(apply) && apply) {
-          process.exitCode = await runInstall({ runtimes, targetDir: flags.targetDir, dryRun: false, yes: false });
+          process.exitCode = await runInstall({
+            runtimes,
+            targetDir: flags.targetDir,
+            dryRun: false,
+            yes: false,
+            mode
+          });
         } else {
           console.log("Sin aplicar. Cuando quieras: jorgex-stack sync");
         }
-      } else if (result.exitCode === 0 && result.appliedUpdates && runtimes.length > 0 && (flags.yes || !process.stdout.isTTY)) {
+      } else if (result.exitCode === 0 && result.appliedUpdates && runtimes.length > 0 && canSync && (flags.yes || !process.stdout.isTTY)) {
         console.log("Skills/stack actualizados. Ejecuta jorgex-stack sync para aplicarlos a los runtimes.");
       }
       return;
@@ -2975,7 +3282,17 @@ async function main() {
       if (code === 0 && !flags.yes && process.stdout.isTTY) {
         const apply = await p6.confirm({ message: "\xBFAplicar ahora los modelos a los agentes instalados? (sync)" });
         if (!p6.isCancel(apply) && apply) {
-          process.exitCode = await runInstall({ runtimes, targetDir: flags.targetDir, dryRun: flags.dryRun, yes: false });
+          const preferenceFile = installModePreferenceFile();
+          const explicitMode = flags.mode !== void 0 || flags.subagentConcurrency !== void 0;
+          const hasSavedMode = hasInstallModePreference(preferenceFile);
+          const canResolveMode = flags.targetDir !== void 0 || explicitMode || hasSavedMode;
+          if (!canResolveMode) {
+            p6.log.warn("Model-map guardado: se omite el sync con los runtimes porque falta un modo. Ejecuta jorgex-stack sync --mode human|programmatic.");
+            return;
+          }
+          const mode = await resolveInstallMode(flags, false);
+          if (mode === null) return;
+          process.exitCode = await runInstall({ runtimes, targetDir: flags.targetDir, dryRun: flags.dryRun, yes: false, mode });
         } else {
           console.log("Sin aplicar. Cuando quieras: jorgex-stack sync");
         }