@ronaldjdevfs/forge 1.3.0-beta → 1.3.1

package/skills/forge/scripts/inspect.mjs

@@ -7,6 +7,7 @@ import { detectProfile, detectProfileExtended } from "./profile.mjs";
 import { buildDependencyGraph } from "./chain.mjs";
 import { allChecks, checkStructure, checkLayers, checkDecorators } from "./detect.mjs";
 import { saveHistory, updateStateFromAudit } from "./forge-config.mjs";
+import { buildPipeline, printPipeline } from "./recommendation-engine.mjs";
 
 const ROOT = process.cwd();
 
@@ -22,12 +23,15 @@ const CAT_NAMES = {
 };
 
 const CAT_MAX = {
-  structure: 20,
-  layers: 20,
+  structure: 30,
+  layers: 25,
+  decorators: 20,
   ownership: 20,
   platform: 15,
   dependencies: 15,
   graph: 20,
+  customRules: 5,
+  naming: 10,
 };
 
 function countBySeverity(checks) {
@@ -64,8 +68,8 @@ function printReport(report, ctx, profile, graph, archGraph, profileExtended) {
   const barLen = 40;
   const pct = report.max > 0 ? Math.round((report.total / report.max) * 100) : 0;
 
-  function scoreBar(score, max) {
-    const p = max > 0 ? Math.round((score / max) * barLen) : 0;
+  function renderScoreBar(score, max) {
+    const p = Math.min(max > 0 ? Math.round((score / max) * barLen) : 0, barLen);
     const filled = "█".repeat(p);
     const empty = "░".repeat(barLen - p);
     const color = score >= max * 0.8 ? GREEN : score >= max * 0.5 ? YELLOW : RED;
@@ -128,7 +132,7 @@ function printReport(report, ctx, profile, graph, archGraph, profileExtended) {
     const name = CAT_NAMES[key] || key;
     const cmax = CAT_MAX[key] || cat.max || 10;
     console.log(`  ${BOLD}${name} (${cat.score}/${cmax})${RESET}`);
-    console.log(`  ${scoreBar(cat.score, cmax)}`);
+    console.log(`  ${renderScoreBar(cat.score, cmax)}`);
 
     for (const check of cat.checks) {
       const icon = check.pass ? `${GREEN}✔${RESET}` : `${RED}✘${RESET}`;
@@ -142,41 +146,16 @@ function printReport(report, ctx, profile, graph, archGraph, profileExtended) {
     console.log();
   }
 
-  if (report.recommendations.length > 0) {
-    console.log(`  ${BOLD}${YELLOW}Recomendaciones${RESET}`);
-    const unique = [...new Set(report.recommendations)];
-    unique.forEach((r, i) => console.log(`   ${i + 1}. ${r}`));
-    console.log();
-  }
-
-  /* Contextual suggestions */
-  const suggestions = [];
-  const v = report.severityCounts;
-  if ((v.CRITICAL || 0) > 0) suggestions.push("forge quench — revisar reglas CRITICAL en detalle");
-  if ((v.ERROR || 0) > 0) suggestions.push("forge quench — corregir violaciones ERROR antes de avanzar");
-  if (graph.hasCycles) suggestions.push("forge reforge — eliminar ciclos del grafo de dependencias");
-  if (ctx.platform.exists && ctx.platform.components.length < 3) suggestions.push("forge forge — bootstrap de componentes platform faltantes");
-  if (!ctx.platform.exists) suggestions.push("forge forge — iniciar bootstrap de platform");
-  if (ctx.features.legacy.length > 0) suggestions.push(`forge relocate — migrar ${ctx.features.legacy.length} feature(s) legacy a estructura hexagonal`);
-  if (archGraph && archGraph.stats.dependencyHealth < 70) suggestions.push("forge temper — endurecer inyección de dependencias");
-  if (archGraph && archGraph.stats.riskScore > 50) suggestions.push("forge reforge — reducir riesgo arquitectónico");
-  if (pct >= 80) suggestions.push("forge inspect — mantener auditoría periódica");
-  if (pct < 50) suggestions.push("forge inspect — auditoría focalizada tras correcciones");
-
-  // Profile-derived suggestions
-  if (profileExtended) {
-    for (const dep of profileExtended.depIssues || []) {
-      suggestions.push(`profiler: ${dep}`);
-    }
-    for (const s of profileExtended.suggestions || []) {
-      suggestions.push(`profiler: ${s}`);
+  /* Unified pipeline recommendation */
+  const allViolations = [];
+  for (const [, cat] of Object.entries(report.categories)) {
+    for (const c of cat.checks) {
+      if (!c.pass) allViolations.push(c);
     }
   }
-
-  if (suggestions.length > 0) {
-    console.log(`  ${BOLD}${CYAN}Siguientes pasos sugeridos${RESET}`);
-    suggestions.forEach((s, i) => console.log(`   ${i + 1}. ${s}`));
-    console.log();
+  const pipeline = buildPipeline(allViolations, graph, ctx.ownership, profileExtended, ctx);
+  if (pipeline.length > 0) {
+    printPipeline(pipeline);
   }
 
   console.log("═".repeat(58) + "\n");
@@ -234,16 +213,38 @@ function getChangedFeatures(changedFiles, allFeatures) {
 async function main() {
   const args = process.argv.slice(2);
   const isJson = args.includes("--json");
-  const isDiff = args.includes("--diff");
+  const isDiff = args.includes("--diff") || !args.includes("--full");
+  const isSummary = args.includes("--summary");
+  const force = args.includes("--force");
   const filterSeverity = args.includes("--severity") ? args[args.indexOf("--severity") + 1] : null;
 
-  const ctx = await buildContext();
+  const ctx = await buildContext(ROOT, null, { force });
   const profileExtended = detectProfileExtended(ctx);
   const profile = profileExtended.profile;
-  const chainGraph = buildDependencyGraph();
   const archGraph = ctx.graph;
+  const chainGraph = buildDependencyGraph(process.cwd(), archGraph);
   const features = ctx.features.migrated;
 
+  if (isSummary) {
+    const result = allChecks(features, archGraph, ctx);
+    const report = buildReport({ categories: result });
+    const pct = report.max > 0 ? Math.round((report.total / report.max) * 100) : 0;
+    if (isJson) {
+      console.log(JSON.stringify({
+        score: report.total,
+        max: report.max,
+        pct,
+        grade: pct >= 90 ? "A" : pct >= 80 ? "B" : pct >= 65 ? "C" : pct >= 50 ? "D" : "F",
+        severityCounts: report.severityCounts,
+        violations: report.violations.length,
+        health: pct >= 80 ? "healthy" : pct >= 50 ? "fair" : "poor",
+      }, null, 2));
+    } else {
+      console.log(`Score: ${report.total}/${report.max} (${pct}%) | Violations: ${report.violations.length} | Health: ${pct >= 80 ? "healthy" : pct >= 50 ? "fair" : "poor"}`);
+    }
+    return;
+  }
+
   if (isDiff) {
     const changedFiles = getChangedFiles();
     const changedFeatures = getChangedFeatures(changedFiles, features);
@@ -282,8 +283,12 @@ async function main() {
     };
 
     // Provide a simpler report
-    let totalScore = result.structure.score + result.layers.score + (result.decorators?.score || 0);
-    const maxScore = 60; // structure 20 + layers 20 + decorators 20
+    let totalScore = 0;
+    let maxScore = 0;
+    for (const [key, cat] of Object.entries(result)) {
+      totalScore += cat.score;
+      maxScore += CAT_MAX[key] || 20;
+    }
     const pct = Math.round((totalScore / maxScore) * 100);
 
     if (!isJson) {
@@ -291,7 +296,8 @@ async function main() {
 
       for (const [key, cat] of Object.entries(result)) {
         const name = key.charAt(0).toUpperCase() + key.slice(1);
-        console.log(`  ${BOLD}${name} (${cat.score}/${cat.score === 0 && cat.checks.length > 0 ? "—" : maxScore})${RESET}`);
+        const cmax = CAT_MAX[key] || cat.max || 20;
+        console.log(`  ${BOLD}${name} (${cat.score}/${cat.score === 0 && cat.checks.length > 0 ? "—" : cmax})${RESET}`);
         for (const check of cat.checks) {
           const icon = check.pass ? `${GREEN}✔${RESET}` : `${RED}✘${RESET}`;
           const sev = check.pass ? "" : ` ${SEVERITY_COLORS[check.severity]}[${check.severity}]${RESET}`;
@@ -309,24 +315,26 @@ async function main() {
         categories: result,
       }, null, 2));
     }
-    updateStateFromAudit({ total: totalScore, grade: `${pct}%`, violations: [], health: "diff", context: { features: { total: features.length, migrated: features, legacy: [] } } });
+    updateStateFromAudit({ total: totalScore, max: maxScore, grade: `${pct}%`, violations: [], health: "diff", context: { features: { total: features.length, migrated: features, legacy: [] } } });
     saveHistory({ score: totalScore, grade: `${pct}%`, violationCount: 0, totalFeatures: features.length, migratedFeatures: features.length });
     process.exit(0);
   }
 
   const result = allChecks(features, archGraph, ctx);
   const report = buildReport({ categories: result });
+  const pct = report.max > 0 ? Math.round((report.total / report.max) * 100) : 0;
 
   updateStateFromAudit({
     total: report.total,
-    grade: report.grade,
+    max: report.max,
+    grade: pct >= 90 ? "A" : pct >= 80 ? "B" : pct >= 65 ? "C" : pct >= 50 ? "D" : "F",
     violations: report.violations || [],
-    health: report.total >= 80 ? "healthy" : report.total >= 50 ? "fair" : "poor",
+    health: pct >= 80 ? "healthy" : pct >= 50 ? "fair" : "poor",
     context: { features: { total: features.length, migrated: features, legacy: ctx.features?.legacy || [] } },
   });
   saveHistory({
     score: report.total,
-    grade: report.grade,
+    grade: pct >= 90 ? "A" : pct >= 80 ? "B" : pct >= 65 ? "C" : pct >= 50 ? "D" : "F",
     violationCount: (report.violations || []).length,
     totalFeatures: features.length,
     migratedFeatures: features.length,

package/skills/forge/scripts/parse-imports.mjs

@@ -214,8 +214,6 @@ function parseWithRegexLines(content, filePath) {
 export function parseImportPaths(content, filePath) {
   const astResult = filePath ? parseWithAST(content, filePath) : null;
   if (astResult) return astResult;
-  const regexResult = parseWithAST(content); // second try without filePath hint
-  if (regexResult) return regexResult;
   return parseWithRegex(content);
 }
 

package/skills/forge/scripts/posttool.mjs

@@ -1,30 +1,224 @@
 #!/usr/bin/env node
 
 /**
- * posttool.mjs — DEPRECATED: Backward-compat wrapper.
+ * posttool.mjs — PostToolUse hook para Forge.
  *
- * Use forgeSentinel.mjs en su lugar.
- *   node forgeSentinel.mjs [options]
+ * Se ejecuta después de que el agente escribe código. Analiza los archivos
+ * modificados y reporta violaciones arquitectónicas.
  *
- * Este wrapper delega en forgeSentinel.mjs para mantener compatibilidad
- * con scripts y referencias existentes.
+ * Uso (CLI):
+ *   node posttool.mjs                                    → analiza archivos changed en git
+ *   node posttool.mjs <file1> [file2...]                 → analiza archivos específicos
+ *   node posttool.mjs --diff                             → solo archivos changed vs default branch
+ *   node posttool.mjs --json                             → salida JSON
+ *   node posttool.mjs --strict                           → exit code 1 si hay CRITICAL/ERROR
+ *   node posttool.mjs --reminder                         → solo recordatorio (no bloquea)
+ *
+ * Uso (API):
+ *   import { postToolCheck } from "./posttool.mjs";
+ *   const result = await postToolCheck([...files]);
+ *
+ * Integración en SKILL.md (Fase 7 del pipeline):
+ *   node .opencode/skills/forge/scripts/posttool.mjs --reminder
  */
 
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { readFileSync, existsSync, statSync, readdirSync } from "fs";
+import { join, relative, resolve, extname } from "path";
+import { execFileSync } from "child_process";
+import { getGraph } from "./graph.mjs";
+import { buildContext } from "./context.mjs";
+import { detectFeaturesOnSrc, allChecks, loadAllInlineIgnores, isIgnored } from "./detect.mjs";
+import { evaluateRules } from "./registry/rules.mjs";
+import {
+  CYAN, GREEN, RED, YELLOW, BOLD, RESET, DIM, GRAY,
+  formatViolation, formatCheck, formatJson,
+} from "./formatter.mjs";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = process.cwd();
 
-// Re-export for backward compat
-export { runSentinelCheck as postToolCheck } from "./forgeSentinel-lib.mjs";
+function getChangedFiles() {
+  let files = [];
+  try {
+    const defaultBranch = execFileSync("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] })
+      .trim().replace("refs/remotes/origin/", "");
+    const raw = execFileSync("git", ["diff", "--name-only", "--diff-filter=ACMR", `${defaultBranch}...HEAD`], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    files = raw.trim().split("\n").filter(Boolean);
+  } catch {}
 
-if (process.argv[1]?.endsWith("posttool.mjs")) {
-  const forgeSentinel = join(__dirname, "forgeSentinel.mjs");
+  if (files.length === 0) {
+    try {
+      const raw = execFileSync("git", ["status", "--porcelain"], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+      files = raw.split("\n").filter(Boolean).map(l => l.slice(3));
+    } catch {}
+  }
+
+  return files.filter(f => f.startsWith("src/"));
+}
+
+function readFile(path) {
+  try { return readFileSync(path, "utf-8"); } catch { return null; }
+}
+
+/**
+ * Check modified files for violations.
+ * Returns { violations, graphViolations, total, hasCritical, hasErrors, summary }
+ */
+export async function postToolCheck(files, opts = {}) {
+  const { strict = false, reminder = false } = opts;
+
+  if (!files || files.length === 0) {
+    files = getChangedFiles();
+  }
+
+  // Only check source files
+  files = files.filter(f =>
+    f.endsWith(".ts") || f.endsWith(".mjs") || f.endsWith(".js") || f.endsWith(".tsx")
+  );
+
+  if (files.length === 0) {
+    return { violations: [], graphViolations: [], total: 0, hasCritical: false, hasErrors: false, filesChecked: 0, summary: "Sin archivos fuente modificados" };
+  }
+
+  // Build context and run full audit
+  const ctx = await buildContext();
+  const features = detectFeaturesOnSrc();
+  const graph = ctx.graph || getGraph();
+  const results = allChecks(features, graph, ctx);
+
+  // Load inline ignores
+  const allIgnores = loadAllInlineIgnores(join(ROOT, "src"));
+
+  // Collect violations that touch the modified files
+  const violations = [];
+  for (const [, cat] of Object.entries(results)) {
+    for (const check of cat.checks) {
+      if (check.pass) continue;
+
+      // Only include violations touching modified files
+      const touchesFile = files.some(f =>
+        (check.detail && check.detail.includes(f)) ||
+        (check.label && check.label.includes(f))
+      );
+
+      if (!touchesFile && !reminder) continue;
+
+      // Check inline ignores
+      if (isIgnored(check, allIgnores)) continue;
+
+      violations.push(check);
+    }
+  }
+
+  // Also evaluate graph rules for changed files
+  const graphViolations = evaluateRules(graph, ctx).filter(v => {
+    const touchesFile = files.some(f =>
+      (v.file && v.file.includes(f)) ||
+      (v.from && v.from.includes(f)) ||
+      (v.to && v.to.includes(f))
+    );
+    return touchesFile || reminder;
+  });
+
+  const allViolations = [...violations, ...graphViolations];
+  const hasCritical = allViolations.some(v => v.severity === "CRITICAL");
+  const hasErrors = allViolations.some(v => v.severity === "ERROR");
+
+  return {
+    violations: allViolations,
+    total: allViolations.length,
+    hasCritical,
+    hasErrors,
+    filesChecked: files.length,
+    summary: hasCritical
+      ? `⚠ ${allViolations.length} violación(es) — ${allViolations.filter(v => v.severity === "CRITICAL").length} CRITICAL, ${allViolations.filter(v => v.severity === "ERROR").length} ERROR`
+      : hasErrors
+        ? `⚠ ${allViolations.length} violación(es) — ${allViolations.filter(v => v.severity === "ERROR").length} ERROR`
+        : `${allViolations.length} violación(es) menores (WARNING/INFO)`,
+  };
+}
+
+function printResult(result, opts = {}) {
+  const { reminder = false } = opts;
+
+  console.log(`\n${BOLD}${CYAN}═══ Forge PostTool Hook ═══${RESET}`);
+
+  if (result.total === 0) {
+    console.log(` ${GREEN}✔${RESET} Sin violaciones arquitectónicas en archivos modificados`);
+    console.log(` ${DIM}Archivos revisados: ${result.filesChecked}${RESET}\n`);
+    return;
+  }
+
+  console.log(` ${DIM}Archivos revisados: ${result.filesChecked}${RESET}`);
+  console.log(` ${DIM}Violaciones: ${result.total}${RESET}\n`);
+
+  if (reminder) {
+    console.log(`  ${YELLOW}Recordatorio:${RESET} Los archivos modificados tienen ${result.total} violación(es) arquitectónica(s).`);
+    console.log(`  Ejecuta ${CYAN}forge quench${RESET} para ver el detalle completo.\n`);
+
+    if (result.hasCritical) {
+      const criticalCount = result.violations.filter(v => v.severity === "CRITICAL").length;
+      console.log(`  ${RED}⚠ ${criticalCount} violación(es) CRITICAL detectadas${RESET}`);
+    }
+    if (result.hasErrors) {
+      const errorCount = result.violations.filter(v => v.severity === "ERROR").length;
+      console.log(`  ${RED}⚠ ${errorCount} violación(es) ERROR detectadas${RESET}`);
+    }
+
+    // Print first 5 violations as summary
+    const toShow = result.violations.slice(0, 5);
+    for (const v of toShow) {
+      console.log(formatCheck(v));
+    }
+    if (result.violations.length > 5) {
+      console.log(`  ${DIM}... y ${result.violations.length - 5} más${RESET}`);
+    }
+    console.log();
+    return;
+  }
+
+  // Full output
+  for (const v of result.violations) {
+    console.log(formatCheck(v));
+  }
+
+  console.log(`\n  ${BOLD}Resumen:${RESET} ${result.summary}`);
+  if (result.hasCritical) {
+    console.log(`  ${RED}⚠ Se requiere acción correctiva antes de continuar${RESET}`);
+  }
+  console.log();
+}
+
+async function main() {
   const args = process.argv.slice(2);
-  const { execFileSync } = await import("child_process");
-  try {
-    execFileSync(process.execPath, [forgeSentinel, ...args], { stdio: "inherit" });
-  } catch {
-    process.exit(0);
+  const isJson = args.includes("--json");
+  const strict = args.includes("--strict");
+  const reminder = args.includes("--reminder");
+  const isDiff = args.includes("--diff");
+
+  let files;
+  if (isDiff) {
+    files = getChangedFiles();
+  } else {
+    // Files passed as arguments
+    files = args.filter(a => !a.startsWith("--"));
+    if (files.length === 0) {
+      files = getChangedFiles();
+    }
   }
+
+  const result = await postToolCheck(files, { strict, reminder });
+
+  if (isJson) {
+    console.log(formatJson(result));
+  } else {
+    printResult(result, { reminder });
+  }
+
+  if (strict && (result.hasCritical || result.hasErrors)) {
+    process.exit(1);
+  }
+}
+
+if (process.argv[1]?.endsWith("posttool.mjs")) {
+  main().catch(console.error);
 }

package/skills/forge/scripts/recommendation-engine.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+import { CYAN, GREEN, RED, YELLOW, BOLD, RESET, DIM, GRAY, SEVERITY_COLORS } from "./formatter.mjs";
+
+function countByRule(violations) {
+  const counts = {};
+  for (const v of violations) {
+    const rule = v.rule || "other";
+    if (!counts[rule]) counts[rule] = [];
+    counts[rule].push(v);
+  }
+  return counts;
+}
+
+export function buildPipeline(auditChecks, graph, ownership, profile, ctx) {
+  const violations = auditChecks.filter(c => !c.pass);
+  const pipeline = [];
+
+  // --- CRITICAL: R2 (platform→feature) → forge temper ---
+  const r2 = violations.filter(v => v.rule === "R2" || (v.fix && v.fix.includes("Extraer interfaz") && v.severity === "CRITICAL"));
+  if (r2.length > 0) {
+    pipeline.push({ command: "temper", args: "", priority: "CRITICAL", reason: `Corrige ${r2.length} violación(es) R2 (platform→feature)`, count: r2.length });
+  }
+
+  // --- ERROR: R3 (shared→feature) → forge reforge ---
+  const r3 = violations.filter(v => v.rule === "R3" || (v.fix && v.fix.includes("Feature no accede")));
+  // --- ERROR: R4 (shared→infra) → forge reforge ---
+  const r4 = violations.filter(v => v.rule === "R4" || (v.fix && v.fix.includes("Feature no importa otro feature")));
+  // --- ERROR: R8 (cross-feature) → forge reforge ---
+  const r8 = violations.filter(v => v.rule === "R8");
+  const sharedIssues = [...r3, ...r4, ...r8];
+  if (sharedIssues.length > 0) {
+    pipeline.push({ command: "reforge", args: "", priority: "ERROR", reason: `Corrige ${sharedIssues.length} violación(es) de capas (shared mal acoplado)`, count: sharedIssues.length });
+  }
+
+  // --- ERROR: R9 (cycles) → forge reforge ---
+  const r9 = violations.filter(v => v.rule === "R9" || (v.label && v.label.includes("Ciclo")));
+  if (r9.length > 0 || (graph && graph.hasCycles)) {
+    pipeline.push({ command: "reforge", args: "--cycles", priority: "ERROR", reason: `Elimina ${r9.length || 1} ciclo(s) de dependencia (R9)`, count: r9.length || 1 });
+  }
+
+  // --- R1 (feature→infra) → forge reforge ---
+  const r1 = violations.filter(v => v.rule === "R1");
+  if (r1.length > 0) {
+    pipeline.push({ command: "reforge", args: "", priority: "ERROR", reason: `Corrige ${r1.length} violación(es) R1 (feature→infra)`, count: r1.length });
+  }
+
+  // --- WARNING: orphan/misplaced → forge relocate ---
+  const orphans = ownership?.orphans || [];
+  const misplaced = ownership?.misplaced || [];
+  const duplicates = ownership?.duplicates || [];
+  const relocationCount = orphans.length + misplaced.length + duplicates.length;
+  if (relocationCount > 0) {
+    pipeline.push({ command: "relocate", args: "", priority: "WARNING", reason: `Migra ${relocationCount} componente(s) huérfanos/duplicados/mal ubicados`, count: relocationCount });
+  }
+
+  // --- WARNING: naming violations → forge reforge ---
+  const namingCount = violations.filter(v => v.severity === "SUGGESTION" && v.label && v.label.includes("Naming")).length;
+  if (namingCount > 0) {
+    pipeline.push({ command: "reforge", args: "<filename>", priority: "WARNING", reason: `Corrige ${namingCount} violación(es) de naming (ejecutar por feature)`, count: namingCount });
+  }
+
+  // --- Legacy features → forge relocate ---
+  const legacyCount = ctx?.features?.legacy?.length || 0;
+  if (legacyCount > 0) {
+    pipeline.push({ command: "relocate", args: "", priority: "WARNING", reason: `Migra ${legacyCount} feature(s) legacy a estructura hexagonal`, count: legacyCount });
+  }
+
+  // --- Missing platform → forge forge ---
+  if (ctx && !ctx.platform?.exists) {
+    pipeline.push({ command: "forge", args: "", priority: "INFO", reason: "Inicializa bootstrap de platform layer", count: 1 });
+  }
+
+  // --- Package dependencies → (not a forge command, just suggestion) ---
+  const profileSugs = profile?.suggestions || [];
+  if (profileSugs.length > 0) {
+    pipeline.push({ command: "profile", args: "--install", priority: "SUGGESTION", reason: `${profileSugs.length} dependencia(s) sugeridas por perfil`, count: profileSugs.length });
+  }
+
+  // --- Verify & finalize ---
+  if (pipeline.length > 0) {
+    pipeline.push({ command: "quench", args: "", priority: "INFO", reason: "Verifica que todas las correcciones pasen", count: 0 });
+    pipeline.push({ command: "inscribe", args: "", priority: "INFO", reason: "Actualiza ARCHITECTURE.md con el nuevo estado", count: 0 });
+  }
+
+  // Sort by priority
+  const order = { CRITICAL: 0, ERROR: 1, WARNING: 2, INFO: 3, SUGGESTION: 4 };
+  pipeline.sort((a, b) => (order[a.priority] ?? 99) - (order[b.priority] ?? 99));
+
+  return pipeline;
+}
+
+export function printPipeline(pipeline) {
+  if (!pipeline || pipeline.length === 0) return;
+  console.log(`\n${BOLD}${CYAN}═══ Pipeline recomendado ═══${RESET}`);
+  console.log(`${DIM}Para resolver los problemas encontrados, ejecuta en orden:${RESET}\n`);
+  let step = 1;
+  for (const item of pipeline) {
+    const color = SEVERITY_COLORS[item.priority] || GRAY;
+    const cmd = item.command === "forge" ? "forge forge" : `forge ${item.command}`;
+    const args = item.args ? ` ${item.args}` : "";
+    const countStr = item.count > 0 ? ` ${DIM}(${item.count})${RESET}` : "";
+    console.log(` ${GREEN}${step}.${RESET} ${BOLD}${CYAN}${cmd}${args}${RESET} ${DIM}→${RESET} ${color}${item.reason}${countStr}${RESET}`);
+    step++;
+  }
+  console.log();
+}
+
+export function pipelineToJson(pipeline) {
+  return JSON.stringify({ pipeline }, null, 2);
+}
+
+/* ── CLI ── */
+if (process.argv[1] && (process.argv[1].endsWith("recommendation-engine.mjs") || process.argv[1].endsWith("recommendation-engine.js"))) {
+  const { buildContext } = await import("./context.mjs");
+  const ctx = await buildContext();
+  const features = ctx.features?.migrated || [];
+  const graph = ctx.graph;
+  const checks = [];
+  for (const [, cat] of Object.entries(ctx.checks || {})) {
+    if (cat.checks) checks.push(...cat.checks);
+  }
+  const pipeline = buildPipeline(checks, graph, ctx.ownership, ctx, ctx);
+  printPipeline(pipeline);
+}

package/skills/forge/scripts/rollback.mjs

@@ -18,6 +18,7 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, cpSync, rmSync, statSync } from "fs";
 import { join, relative, resolve, basename } from "path";
+import { fileURLToPath } from "url";
 import { execFileSync } from "child_process";
 
 const ROOT = process.cwd();
@@ -157,7 +158,8 @@ export function listBackups(target) {
 
 export function verifyAfterChange() {
   try {
-    const out = shell("node", [join(import.meta.url, "..", "inspect.mjs"), "--diff", "--json"]);
+    const __dirname = fileURLToPath(new URL(".", import.meta.url));
+    const out = shell("node", [join(__dirname, "inspect.mjs"), "--diff", "--json"]);
     if (!out) return { score: 0, improved: false, error: "inspect falló" };
 
     const result = JSON.parse(out);
@@ -167,7 +169,7 @@ export function verifyAfterChange() {
     let suggestedCommit = null;
     if (improved && score > 0) {
       const branch = shell("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
-      suggestedCommit = `git add -A && git commit -m "forge: relocate/reforge (score: ${score}/110)"`;
+      suggestedCommit = `git add -A && git commit -m "forge: relocate/reforge (score: ${score})"`;
     }
 
     return { score, improved, suggestedCommit };
@@ -205,7 +207,7 @@ if (action === "backup" && arg) {
     console.error(`rollback: ${result.error}`);
     process.exit(1);
   }
-  console.log(`Score: ${result.score}/110 | ${result.improved ? "✓ Mejoró/igual" : "✘ Empeoró"}${result.suggestedCommit ? `\nSugerencia: ${result.suggestedCommit}` : ""}`);
+  console.log(`Score: ${result.score} | ${result.improved ? "✓ Mejoró/igual" : "✘ Empeoró"}${result.suggestedCommit ? `\nSugerencia: ${result.suggestedCommit}` : ""}`);
   process.exit(result.improved ? 0 : 1);
 } else {
   console.log("Uso: node rollback.mjs <backup|restore|list|verify> [target|id]");

package/skills/forge/templates/feature/acl-gateway.ts.md

@@ -0,0 +1,52 @@
+```typescript
+// src/features/<domain>/adapters/out/legacy-<system>/<Domain>Gateway.ts
+import { injectable } from "tsyringe";
+import type { External<Domain>DTO } from "./External<Domain>DTO.js";
+
+@injectable()
+export class <Domain>Gateway {
+  private readonly baseUrl: string;
+
+  constructor() {
+    this.baseUrl = process.env.LEGACY_<SYSTEM>_URL ?? "";
+  }
+
+  async fetch(id: string): Promise<External<Domain>DTO | null> {
+    const response = await fetch(`${this.baseUrl}/api/${id}`, {
+      headers: { Authorization: `Bearer ${this.getApiKey()}` },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (response.status === 404) return null;
+    if (!response.ok) throw new Error(`Legacy error: ${response.statusText}`);
+    return response.json();
+  }
+
+  async upsert(dto: External<Domain>DTO): Promise<External<Domain>DTO> {
+    const response = await fetch(`${this.baseUrl}/api`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.getApiKey()}`,
+      },
+      body: JSON.stringify(dto),
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!response.ok) throw new Error(`Legacy error: ${response.statusText}`);
+    return response.json();
+  }
+
+  async remove(id: string): Promise<void> {
+    const response = await fetch(`${this.baseUrl}/api/${id}`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${this.getApiKey()}` },
+    });
+    if (!response.ok && response.status !== 404) {
+      throw new Error(`Legacy error: ${response.statusText}`);
+    }
+  }
+
+  private getApiKey(): string {
+    return process.env.LEGACY_<SYSTEM>_API_KEY ?? "";
+  }
+}
+```