navori 0.2.16 → 0.2.17

package/dist/assets/core/core-assets/presets/monorepo-turbopnpm/managed/stack.md

@@ -0,0 +1,11 @@
+## Stack — Monorepo (Turborepo + pnpm)
+
+Este directorio es la **raíz de un monorepo**: orquesta, no aloja producto. El código real vive en los workspaces (`apps/*`, `packages/*`), y **cada workspace tiene su propio harness** (su `CLAUDE.md` + `.claude/`) con el preset de su stack. El mapa de workspaces vivos está en el bloque "## Monorepo — raíz".
+
+Regla de oro: **enruta el trabajo al workspace dueño**. Un cambio de producto se hace desde el `CLAUDE.md` de su app, no desde aquí. La raíz solo se toca para lo transversal: `turbo.json`, `pnpm-workspace.yaml`, tsconfig/eslint base, scripts de CI, deps compartidas.
+
+- **Tareas scopeadas, no globales.** Corre por workspace con el filtro de Turbo: `pnpm turbo run <task> --filter=<workspace>` (o `--filter=./apps/<x>`). Evita correr el pipeline entero cuando solo tocaste un app.
+- **No cruces imports entre workspaces por ruta relativa** (`../../otro-app`). Consume un hermano por su nombre de paquete con el protocolo `workspace:*`; si no es un paquete publicable, probablemente el código debería vivir en un `packages/*` compartido.
+- **La dep va en el `package.json` del workspace que la usa**, no en la raíz. Deps en la raíz son solo tooling del monorepo (turbo, changesets, linters compartidos).
+
+Antes de tocar `turbo.json`, `pnpm-workspace.yaml` o mover deps entre workspaces, aplica el skill `turbo-workspaces`.

package/dist/assets/core/core-assets/presets/monorepo-turbopnpm/skills/turbo-workspaces.md

@@ -0,0 +1,50 @@
+---
+name: turbo-workspaces
+description: Cómo navegar y operar un monorepo Turborepo + pnpm — correr tareas scopeadas, agregar deps al workspace correcto, compartir código sin acoplar. Aplica antes de tocar turbo.json, pnpm-workspace.yaml o mover deps.
+type: reference
+---
+
+# Turborepo + pnpm — operación del monorepo
+
+## Cuándo usar este skill
+
+Antes de: correr tareas de build/test/lint, agregar o mover una dependencia, crear un workspace nuevo, o editar `turbo.json` / `pnpm-workspace.yaml`. En un monorepo, "dónde" vive un cambio importa tanto como "qué" cambia.
+
+## Correr tareas (siempre scopeadas)
+
+```bash
+# Una tarea en UN workspace (por nombre de paquete o por ruta)
+pnpm turbo run build --filter=@scope/backend
+pnpm turbo run test --filter=./apps/storefront
+
+# Un workspace y todo lo que depende de él (aguas abajo)
+pnpm turbo run build --filter=@scope/backend...
+
+# Solo lo afectado por tu diff vs una base
+pnpm turbo run test --filter='...[origin/main]'
+```
+
+Regla: no corras el pipeline entero (`turbo run build`) si solo tocaste un app. Turbo cachea, pero el ruido de logs y el tiempo de arranque sí cuestan. Deja el run global para CI.
+
+## Agregar dependencias (al workspace correcto)
+
+```bash
+# Dep de un app concreto — NO en la raíz
+pnpm add zod --filter @scope/backend
+
+# Dep de tooling del monorepo (turbo, changesets, prettier) — esa sí va en la raíz
+pnpm add -Dw turbo
+```
+
+- Una lib de producto (`stripe`, `@tanstack/react-query`, …) va en el `package.json` del app que la importa. Si aparece en la raíz, el harness de ese app no la "ve" y su skill no se materializa donde corresponde.
+- Consumir un workspace hermano se declara explícito: `"@scope/ui": "workspace:*"` en el `package.json` del consumidor. Nunca por `import '../../ui/src/...'`.
+
+## Compartir código sin acoplar
+
+- Código usado por ≥2 apps → extráelo a un `packages/*` con su propio `package.json` y su preset (`navori scan` lo detecta como workspace nuevo).
+- Tipos/utilidades cross-app también van en un `packages/*`, no en `apps/*`. Un app nunca es dependencia de otro app.
+
+## turbo.json — lo esencial
+
+- Cada `task` declara sus `dependsOn` (`^build` = build de las deps primero) y sus `outputs` (para cachear). Un output mal declarado = cache que no invalida o que no cachea.
+- Antes de editar el pipeline, verifica el efecto con `pnpm turbo run <task> --dry-run` (lista qué correría y desde qué caché) antes de correrlo de verdad.

package/dist/assets/core/core-assets/presets/monorepo-turbopnpm.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://navori.dev/schema/navori.preset.v1.json",
+  "id": "monorepo-turbopnpm",
+  "displayName": "Monorepo (Turborepo + pnpm)",
+  "extends": "core",
+  "extras": {
+    "managed": [
+      {
+        "id": "stack-monorepo-turbopnpm",
+        "relPath": "presets/monorepo-turbopnpm/managed/stack.md"
+      }
+    ],
+    "agents": [],
+    "skills": [
+      {
+        "id": "turbo-workspaces",
+        "relPath": "presets/monorepo-turbopnpm/skills/turbo-workspaces.md",
+        "destRelPath": ".claude/skills/turbo-workspaces.md"
+      }
+    ],
+    "hooks": []
+  }
+}

package/dist/index.js

@@ -129,7 +129,16 @@ var MonorepoWorkspaceSchema = z2.object({
   name: z2.string().min(1),
   path: safeRelPath,
   preset: z2.string().optional(),
-  qualityGate: QualityGateSchema.optional()
+  qualityGate: QualityGateSchema.optional(),
+  /** Library-skill ids detected in THIS workspace's own deps. Scopes library
+   * skills per workspace so an app only gets the skills for the libs it ships —
+   * without this the root's aggregated list would spray every skill into every
+   * workspace (e.g. a Stripe skill in a backend that never imports Stripe). */
+  libraries: z2.array(z2.string()).optional(),
+  /** Active dependency migrations detected in THIS workspace's own deps. Scoped
+   * per workspace for the same reason as `libraries` — a mid-migration rule
+   * belongs only to the app whose package.json ships both sides of the pair. */
+  libraryMigrations: z2.array(z2.object({ legacy: z2.string(), preferred: z2.string(), domain: z2.string() })).optional()
 });
 var MonorepoSchema = z2.object({
   enabled: z2.boolean(),
@@ -821,12 +830,10 @@ function detectProject(cwd) {
   const monorepo = detectMonorepo(cwd);
   const stack = detectStack(cwd, pkg, pyproject, cargo);
   const libraryDeps = new Set(stack.deps);
-  if (monorepo) {
-    for (const dep of collectMonorepoWorkspaceDeps(cwd)) libraryDeps.add(dep);
-  }
   const libraries = detectLibrarySkills([...libraryDeps]);
   const migrations = detectMigrations([...libraryDeps]);
-  const { preset: suggestedPreset, gap: suggestedPresetGap } = suggestPreset(stack, monorepo);
+  const usesPnpm = packageManager === "pnpm" || existsSync6(join6(cwd, "pnpm-workspace.yaml"));
+  const { preset: suggestedPreset, gap: suggestedPresetGap } = suggestPreset(stack, monorepo, usesPnpm);
   const qualityGate = guessQualityGate(pkg, packageManager, stack);
   const claudeInfra = detectClaudeInfra(cwd);
   return {
@@ -1076,18 +1083,6 @@ function collectNodeDeps(pkg) {
     ...Object.keys(pkg.peerDependencies ?? {})
   ];
 }
-function collectMonorepoWorkspaceDeps(cwd) {
-  const deps = /* @__PURE__ */ new Set();
-  const seen = /* @__PURE__ */ new Set();
-  for (const pattern of collectWorkspacePatterns(cwd)) {
-    for (const rel of expandPattern(cwd, pattern)) {
-      if (seen.has(rel)) continue;
-      seen.add(rel);
-      for (const dep of collectNodeDeps(readPackageJson(join6(cwd, rel)))) deps.add(dep);
-    }
-  }
-  return [...deps];
-}
 function pick(deps, ...candidates) {
   for (const c of candidates) {
     if (deps.has(c)) return c;
@@ -1171,15 +1166,15 @@ function detectStack(cwd, pkg, pyproject, cargo) {
     deps: Array.from(nodeDeps)
   };
 }
-function suggestPreset(stack, monorepo) {
-  const candidate = pickPresetCandidate(stack, monorepo);
+function suggestPreset(stack, monorepo, usesPnpm) {
+  const candidate = pickPresetCandidate(stack, monorepo, usesPnpm);
   if (candidate === "custom") return { preset: "custom", gap: null };
   if (presetExists(candidate)) return { preset: candidate, gap: null };
   return { preset: "custom", gap: candidate };
 }
-function pickPresetCandidate(stack, monorepo) {
+function pickPresetCandidate(stack, monorepo, usesPnpm) {
   if (monorepo) {
-    if (monorepo.tool === "turbo") return "monorepo-turbopnpm";
+    if (monorepo.tool === "turbo") return usesPnpm ? "monorepo-turbopnpm" : "custom";
     if (monorepo.tool === "pnpm") return "monorepo-pnpm";
     if (monorepo.tool === "npm" || monorepo.tool === "lerna") return "monorepo-npm";
   }
@@ -2419,6 +2414,7 @@ function computeRenderPlan(existing, inputConfig, repoRoot, options = {}) {
 var CLAUDE_COMPUTED_BLOCK_IDS = [
   "skills-index",
   "agentes-disponibles",
+  "contexto-monorepo",
   "contexto-proyecto"
 ];
 function canonicalManagedOrder(config, repoRoot, omitRootOnly = false) {
@@ -3038,6 +3034,48 @@ function buildAgentsIndexBody(config) {
   ].join("\n");
 }
 var CONTEXTO_PROYECTO_ID = "contexto-proyecto";
+var CONTEXTO_MONOREPO_ID = "contexto-monorepo";
+function buildContextoMonorepoBody(config, mono, isWorkspace) {
+  if (isWorkspace) {
+    if (!mono) return null;
+    const tool2 = mono.tool ?? "pnpm";
+    const lines2 = [
+      `## Monorepo \u2014 workspace \`${mono.currentName}\``,
+      "",
+      `Eres el workspace **\`${mono.currentName}\`** (\`${mono.currentPath}\`) de un monorepo \`${tool2}\`. Tienes tu propio harness (este \`CLAUDE.md\` + \`.claude/\`); la config ra\xEDz y los archivos transversales (\`turbo.json\`, \`pnpm-workspace.yaml\`, tsconfig/eslint base) viven en el repo root.`,
+      ""
+    ];
+    if (mono.siblings.length > 0) {
+      lines2.push("Workspaces hermanos \u2014 no los edites desde aqu\xED; el trabajo en un hermano se hace desde su propio harness:");
+      for (const s of mono.siblings) {
+        lines2.push(`- \`${s.name}\` \u2014 \`${s.path}\`${s.preset ? ` (${s.preset})` : ""}`);
+      }
+    } else {
+      lines2.push("Por ahora es el \xFAnico workspace declarado.");
+    }
+    lines2.push("");
+    lines2.push(
+      `Corre tareas scopeadas con \`--filter=${mono.currentName}\`. No importes c\xF3digo de un hermano por ruta relativa; cons\xFAmelo como paquete (\`workspace:*\`).`
+    );
+    lines2.push("");
+    return lines2.join("\n");
+  }
+  const workspaces = config.monorepo?.workspaces ?? [];
+  if (workspaces.length === 0) return null;
+  const tool = config.monorepo?.tool ?? "pnpm";
+  const lines = [
+    "## Monorepo \u2014 ra\xEDz",
+    "",
+    `Este repo es un monorepo \`${tool}\`. El c\xF3digo real vive en los workspaces, cada uno con su propio harness (\`CLAUDE.md\` + \`.claude/\`). Al orquestar, **enruta cada tarea al workspace due\xF1o** y trabaja desde su \`CLAUDE.md\`, no desde aqu\xED.`,
+    "",
+    "Workspaces:"
+  ];
+  for (const w of workspaces) {
+    lines.push(`- \`${w.name}\` \u2014 \`${w.path}\`${w.preset ? ` (${w.preset})` : ""}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
 function buildContextoProyectoBody(config) {
   const proj = config.project ?? {};
   const rows = [];
@@ -3169,6 +3207,26 @@ function renderClaudeEngine(cwd, inputConfig, options = {}) {
   } else {
     claudeMdContent = removeManagedSection(claudeMdContent, CONTEXTO_PROYECTO_ID);
   }
+  const monorepoBody = buildContextoMonorepoBody(config, options.monorepoContext, isWorkspace);
+  if (monorepoBody !== null) {
+    const result = injectManagedSection(
+      claudeMdContent,
+      CONTEXTO_MONOREPO_ID,
+      monorepoBody,
+      CORE_META,
+      "html",
+      options.forceIds?.has(CONTEXTO_MONOREPO_ID) ?? false
+    );
+    claudeMdContent = result.output;
+    claudeMdPlan.entries.push({
+      asset: { id: CONTEXTO_MONOREPO_ID, relPath: "(computed)" },
+      source: "core",
+      status: result.status,
+      newContent: null
+    });
+  } else {
+    claudeMdContent = removeManagedSection(claudeMdContent, CONTEXTO_MONOREPO_ID);
+  }
   const reorder = reorderManagedBlocks(claudeMdContent, canonicalManagedOrder(config, repoRoot, isWorkspace));
   claudeMdContent = reorder.output;
   if (reorder.blockedByInterleaving) {
@@ -3888,6 +3946,15 @@ function kv(rows, opts = {}) {
 }
 
 // src/lib/monorepo.ts
+function buildMonorepoContext(config, current) {
+  const all = config.monorepo?.workspaces ?? [];
+  return {
+    tool: config.monorepo?.tool,
+    currentName: current.name,
+    currentPath: current.path,
+    siblings: all.filter((w) => w.path !== current.path).map((w) => ({ name: w.name, path: w.path, preset: w.preset }))
+  };
+}
 function effectiveConfigForWorkspace(root, workspace) {
   const { monorepo: _monorepo, ...rest } = root;
   const merged = { ...rest };
@@ -3897,6 +3964,10 @@ function effectiveConfigForWorkspace(root, workspace) {
   if (workspace.qualityGate !== void 0) {
     merged.qualityGate = workspace.qualityGate;
   }
+  const project = { ...merged.project ?? {} };
+  project.libraries = workspace.libraries ?? [];
+  project.libraryMigrations = workspace.libraryMigrations ?? [];
+  merged.project = project;
   return merged;
 }
 
@@ -3984,7 +4055,8 @@ function runRender(cwd, dryRunOrOptions = false, force = false) {
     const wsResult = renderClaude ? renderClaudeEngine(wsCwd, wsConfig, {
       dryRun,
       force: forceFlag,
-      repoRoot: cwd
+      repoRoot: cwd,
+      monorepoContext: buildMonorepoContext(config, match)
     }) : void 0;
     const wsExtraEngines = renderNonClaudeEngines(wsCwd, wsConfig, engines, dryRun, {
       repoRoot: cwd
@@ -4030,7 +4102,8 @@ function runRender(cwd, dryRunOrOptions = false, force = false) {
     const wsResult = renderClaude ? renderClaudeEngine(wsCwd, wsConfig, {
       dryRun,
       force: forceFlag,
-      repoRoot: cwd
+      repoRoot: cwd,
+      monorepoContext: buildMonorepoContext(config, ws)
     }) : void 0;
     const wsExtraEngines = renderNonClaudeEngines(wsCwd, wsConfig, engines, dryRun, {
       repoRoot: cwd,
@@ -4654,7 +4727,9 @@ function describeWorkspace(cwd, relPath) {
     name: project.name ?? relPath.split("/").pop(),
     path: relPath,
     suggestedPreset: project.suggestedPreset,
-    framework: project.stack.framework
+    framework: project.stack.framework,
+    libraries: project.libraries,
+    migrations: project.migrations
   };
 }
 
@@ -6379,6 +6454,12 @@ function buildWorkspaceEntry(detected, rootPreset, preset) {
   if (preset && preset !== rootPreset) {
     entry.preset = preset;
   }
+  if (detected.libraries.length > 0) {
+    entry.libraries = detected.libraries;
+  }
+  if (detected.migrations.length > 0) {
+    entry.libraryMigrations = detected.migrations;
+  }
   return entry;
 }
 function formatProjectValue(v) {
@@ -6455,7 +6536,11 @@ var syncCommand = defineCommand4({
     const targets = targetsResult.targets;
     const plans = targets.map((t2) => ({
       target: t2,
-      plan: renderClaudeEngine(t2.cwd, t2.config, { dryRun: true, repoRoot: t2.repoRoot })
+      plan: renderClaudeEngine(t2.cwd, t2.config, {
+        dryRun: true,
+        repoRoot: t2.repoRoot,
+        monorepoContext: t2.monorepoContext
+      })
     }));
     reportPlans(plans);
     const conflicts = collectAllConflicts(plans);
@@ -6538,7 +6623,8 @@ ${lines}`
       const applied = renderClaudeEngine(t2.cwd, t2.config, {
         skipIds: res?.skipIds,
         forceIds: res?.forceIds,
-        repoRoot: t2.repoRoot
+        repoRoot: t2.repoRoot,
+        monorepoContext: t2.monorepoContext
       });
       writtenTotal += applied.written.length;
       if (applied.backupPath) {
@@ -6573,7 +6659,8 @@ function resolveSyncTargets(cwd, config, workspaceFilter) {
           label: `workspace:${match.name}`,
           cwd: resolve15(cwd, match.path),
           repoRoot: cwd,
-          config: effectiveConfigForWorkspace(config, match)
+          config: effectiveConfigForWorkspace(config, match),
+          monorepoContext: buildMonorepoContext(config, match)
         }
       ]
     };
@@ -6584,7 +6671,8 @@ function resolveSyncTargets(cwd, config, workspaceFilter) {
       label: `workspace:${ws.name}`,
       cwd: resolve15(cwd, ws.path),
       repoRoot: cwd,
-      config: effectiveConfigForWorkspace(config, ws)
+      config: effectiveConfigForWorkspace(config, ws),
+      monorepoContext: buildMonorepoContext(config, ws)
     });
   }
   return { ok: true, targets };
@@ -8318,6 +8406,29 @@ function withProject(current, patch) {
   const base = current && typeof current === "object" ? current : {};
   return { ...base, ...patch };
 }
+function refreshWorkspaceScopes(raw, cwd) {
+  const mono = raw.monorepo;
+  if (!mono?.workspaces?.length) return false;
+  const byPath = new Map(scanMonorepoWorkspaces(cwd).map((s) => [s.path, s]));
+  let changed = false;
+  for (const ws of mono.workspaces) {
+    const det = byPath.get(ws.path);
+    if (!det) continue;
+    const curLibs = ws.libraries ?? [];
+    if (!sameSet(curLibs, det.libraries)) {
+      if (det.libraries.length > 0) ws.libraries = det.libraries;
+      else delete ws.libraries;
+      changed = true;
+    }
+    const curMigs = ws.libraryMigrations ?? [];
+    if (!sameMigrations(curMigs, det.migrations)) {
+      if (det.migrations.length > 0) ws.libraryMigrations = det.migrations;
+      else delete ws.libraryMigrations;
+      changed = true;
+    }
+  }
+  return changed;
+}
 function diffConfig(current, detected) {
   const out = [];
   if (current.preset !== detected.suggestedPreset && detected.suggestedPreset !== "custom") {
@@ -8420,7 +8531,8 @@ var updateCommand = defineCommand10({
     const diffs = diffConfig(config, detected);
     const rawConfig = JSON.parse(readFileSync23(configPath, "utf-8"));
     const deadKeys = deadProgressKeys(rawConfig);
-    const willWriteConfig = diffs.length > 0 || deadKeys.length > 0;
+    const wsScopesChanged = refreshWorkspaceScopes(rawConfig, cwd);
+    const willWriteConfig = diffs.length > 0 || deadKeys.length > 0 || wsScopesChanged;
     const preview = runRender(cwd, true);
     const agg = aggregateRender(preview);
     if (!willWriteConfig && agg.writes.length === 0 && agg.conflicts.length === 0 && agg.downgrades.length === 0) {
@@ -8433,9 +8545,12 @@ var updateCommand = defineCommand10({
       );
       p11.log.info(`Config drift detected (${diffs.length}):
 ${lines.join("\n")}`);
-    } else {
+    } else if (!wsScopesChanged) {
       p11.log.info("Config is in sync with the repo");
     }
+    if (wsScopesChanged) {
+      p11.log.info("Re-homed per-workspace library skills onto monorepo.workspaces[] (scoping migration)");
+    }
     if (deadKeys.length > 0) {
       p11.log.info(`Claves obsoletas en "progress" que se limpiar\xE1n: ${deadKeys.join(", ")}`);
     }
@@ -9011,6 +9126,12 @@ function buildMonorepoWorkspace(detected, preset, config) {
   if (preset && preset !== config.preset) {
     entry.preset = preset;
   }
+  if (detected.libraries.length > 0) {
+    entry.libraries = detected.libraries;
+  }
+  if (detected.migrations.length > 0) {
+    entry.libraryMigrations = detected.migrations;
+  }
   return entry;
 }
 var scanCommand = defineCommand14({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "navori",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "description": "Multi-agent harness + SDD scaffolder for Claude Code and other AI engines",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
   ],
   "features": {
     "plugins": 6,
-    "presets": 11,
+    "presets": 12,
     "coreAgents": 8,
     "coreSkills": 6,
     "librarySkills": 12