@ronaldjdevfs/forge 1.2.0 → 1.3.1

package/skills/forge/reference/transactional-outbox.md

@@ -0,0 +1,311 @@
+# Transactional Outbox — Entrega Confiable de Eventos
+
+Publicar un evento y escribir en la BD en la misma operación atómica es un problema conocido como **dual-write**. Sin un mecanismo explícito, el sistema puede terminar con datos escritos sin evento publicado, o evento publicado sin datos escritos. El outbox pattern resuelve esto.
+
+---
+
+## El Problema del Dual-Write
+
+```ts
+// ❌ Sin outbox: race condition
+async function placeOrder(command: PlaceOrderCommand): Promise<void> {
+  await this.orderRepo.save(order);         // 1. Escribe en BD
+  await this.eventBus.publish(event);        // 2. Publica evento
+  // Si el paso 2 falla, el pedido existe pero nadie lo sabe
+  // Si el paso 1 falla después del paso 2, hay un evento huérfano
+}
+```
+
+**Escenarios de fallo:**
+- BD commit exitoso, broker caído → evento perdido
+- BD commit lento, timeout del cliente → retry → pedido duplicado
+- Broker recibe evento, BD falla → evento fantasma
+
+---
+
+## El Patrón Outbox
+
+### Cómo funciona
+
+1. **Escribir en la BD**: la operación de negocio + el evento se guardan en la misma transacción
+2. **Relayer**: un proceso independiente lee la tabla outbox y publica los eventos al broker
+3. **Eliminar**: una vez publicado exitosamente, el evento se elimina o marca como enviado
+
+```mermaid
+flowchart LR
+    subgraph "Feature (Orders)"
+        UseCase[Caso de uso]
+        Repo[(BD principal)]
+        OutboxTabla[(Tabla outbox)]
+    end
+    subgraph "Outbox Processor"
+        Relayer[Relayer]
+    end
+    subgraph "Infraestructura"
+        Broker[Message Broker]
+    end
+
+    UseCase --> Repo
+    UseCase --> OutboxTabla
+    Relayer --> OutboxTabla
+    Relayer --> Broker
+    Broker --> Consumers[Consumidores]
+```
+
+### Tabla outbox
+
+```sql
+CREATE TABLE IF NOT EXISTS public.outbox (
+  id            UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  event_type    VARCHAR(255) NOT NULL,
+  aggregate_id  VARCHAR(255) NOT NULL,        -- ID de la entidad que originó el evento
+  aggregate_type VARCHAR(255) NOT NULL,       -- tipo de entidad
+  payload       JSONB NOT NULL,               -- datos del evento
+  occurred_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  processed_at  TIMESTAMPTZ,                  -- NULL = no procesado
+  retry_count   INT NOT NULL DEFAULT 0,
+  last_error    TEXT
+);
+
+CREATE INDEX idx_outbox_unprocessed ON public.outbox (processed_at ASC NULLS FIRST, occurred_at ASC);
+```
+
+### Uso en el caso de uso
+
+```ts
+// application/use-cases/PlaceOrderUseCase.ts
+export class PlaceOrderUseCase {
+  constructor(
+    private readonly unitOfWork: IUnitOfWork,
+  ) {}
+
+  async execute(command: PlaceOrderCommand): Promise<string> {
+    return this.unitOfWork.withTransaction(async (uow) => {
+      const order = OrderEntity.create(command.customerId, command.items);
+      await uow.orderRepo.save(order);
+
+      // El evento se persiste en la misma transacción que el pedido
+      uow.outbox.add(new OrderPlacedEvent({
+        orderId: order.id,
+        customerId: order.customerId,
+        total: order.total,
+        items: order.items.map((i) => ({ productId: i.productId, quantity: i.quantity })),
+      }));
+
+      return order.id;
+    });
+  }
+}
+```
+
+### Outbox como parte del UnitOfWork
+
+```ts
+// domain/IUnitOfWork.ts
+import { OutboxEvent } from "./OutboxEvent";
+
+export interface IUnitOfWork {
+  withTransaction<T>(
+    fn: (uow: {
+      orderRepo: IOrderRepository;
+      outbox: {
+        add(event: DomainEvent): void;
+        getPending(): OutboxEvent[];
+      };
+    }) => Promise<T>,
+  ): Promise<T>;
+}
+```
+
+---
+
+## Outbox Processor (Relayer)
+
+El relayer es un proceso que corre en platform/scheduler o como worker independiente.
+
+### Poll-based (más simple)
+
+```ts
+// platform/scheduler/OutboxRelayer.ts
+export class OutboxRelayer {
+  private readonly pollInterval = 1000; // 1 segundo
+  private running = false;
+
+  constructor(
+    private readonly outboxRepo: IOutboxRepository,
+    private readonly eventBus: IEventBus,
+    private readonly logger: ILogger,
+  ) {}
+
+  async start(): Promise<void> {
+    this.running = true;
+    while (this.running) {
+      await this.processBatch();
+      await this.sleep(this.pollInterval);
+    }
+  }
+
+  private async processBatch(): Promise<void> {
+    const batch = await this.outboxRepo.getUnprocessed(50);
+    for (const event of batch) {
+      try {
+        await this.eventBus.publish(event.toDomainEvent());
+        await this.outboxRepo.markProcessed(event.id);
+      } catch (error) {
+        await this.outboxRepo.incrementRetry(event.id, error.message);
+        if (event.retryCount >= 10) {
+          await this.outboxRepo.markAsDeadLetter(event.id);
+          this.logger.error(`Event ${event.id} moved to DLQ after ${event.retryCount} retries`);
+        }
+      }
+    }
+  }
+
+  stop(): void {
+    this.running = false;
+  }
+}
+```
+
+### Log-based (CDC) — más escalable
+
+Usa Change Data Capture (Debezium, PostgreSQL logical replication) para leer la tabla outbox desde el WAL de Postgres:
+
+```
+[Postgres WAL] → [Debezium] → [Kafka] → [Consumidores]
+```
+
+**Ventajas:**
+- Sin polling, sin carga en la BD
+- Latencia de milisegundos
+- Escala horizontalmente
+
+**Desventajas:**
+- Infraestructura adicional (Debezium, Kafka connect)
+- Configuración más compleja
+- Monitoreo adicional
+
+---
+
+## Dead Letter Queue (DLQ)
+
+Eventos que no pudieron publicarse después de N reintentos:
+
+```sql
+-- Tabla outbox_dlq para eventos fallidos
+CREATE TABLE IF NOT EXISTS public.outbox_dlq (
+  id              UUID PRIMARY KEY,
+  event_type      VARCHAR(255) NOT NULL,
+  aggregate_id    VARCHAR(255) NOT NULL,
+  payload         JSONB NOT NULL,
+  occurred_at     TIMESTAMPTZ NOT NULL,
+  failed_at       TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  last_error      TEXT NOT NULL,
+  retry_count     INT NOT NULL
+);
+```
+
+**Manejo de DLQ:**
+- Alerta a operaciones cuando un evento entra a DLQ
+- Dashboard para revisar y reprocesar eventos fallidos
+- Reprocesamiento manual con límite de reintentos
+- Eventos en DLQ por más de 7 días: escalar a equipo
+
+---
+
+## Idempotencia en Consumidores
+
+El outbox garantiza *at-least-once delivery*. Los consumidores deben ser idempotentes para garantizar *exactly-once processing*.
+
+```ts
+// adapters/in/events/OrderPlacedConsumer.ts
+export class OrderPlacedConsumer {
+  constructor(
+    private readonly processedEvents: IProcessedEventRepository,
+    private readonly inventoryService: IInventoryService,
+  ) {}
+
+  async handle(event: OrderPlacedEvent): Promise<void> {
+    // Deduplicación: si ya procesamos este event ID, ignoramos
+    const alreadyProcessed = await this.processedEvents.exists(event.eventId);
+    if (alreadyProcessed) return;
+
+    await this.inventoryService.reserveStock(event.orderId, event.items);
+
+    // Registrar event ID como procesado (en la misma transacción si es posible)
+    await this.processedEvents.markProcessed(event.eventId);
+  }
+}
+```
+
+Ver `reference/idempotency.md` para más detalles sobre deduplicación.
+
+---
+
+## Implementación en el Modelo de Forge
+
+### Estructura
+
+```
+src/features/orders/
+  domain/
+    events/
+      OrderPlacedEvent.ts
+    IUnitOfWork.ts               ← incluye outbox.add()
+    OutboxEvent.ts               ← wrapper del evento para persistir
+  adapters/
+    out/
+      persistence/
+        PostgresUnitOfWork.ts    ← transacción + outbox en misma conexión
+        OutboxRepository.ts      ← CRUD de la tabla outbox
+
+src/platform/
+  scheduler/
+    OutboxRelayer.ts             ← proceso que publica eventos
+```
+
+### Template de feature con outbox
+
+Para features que publican eventos, el template debe incluir:
+
+```
+src/features/<name>/
+  domain/
+    IOutbox.ts                           ← interfaz outbox en UnitOfWork
+  adapters/
+    out/
+      persistence/
+        <Name>UnitOfWork.ts              ← UnitOfWork con outbox integrado
+        <Name>OutboxRepository.ts        ← repositorio de outbox
+```
+
+---
+
+## Anti-patrones
+
+| Anti-patrón | Problema | Solución |
+|---|---|---|
+| **Outbox sin cleanup** | La tabla outbox crece sin límite. Los índices se degradan. | Archivar eventos procesados > 7 días a tabla de histórico. `DELETE FROM outbox WHERE processed_at < NOW() - INTERVAL '7 days'`. |
+| **Relayer sin límite de reintentos** | Un evento falla infinitamente, consumiendo recursos. | Máximo 10 reintentos, luego DLQ. |
+| **Eventos sin idempotencia** | El mismo evento se procesa dos veces si el relayer falla tras publicar pero antes de marcar. | Siempre deduplicar por event ID en el consumidor. |
+| **Outbox sin índice** | `getUnprocessed()` escanea toda la tabla. | Índice compuesto en `(processed_at NULLS FIRST, occurred_at ASC)`. |
+| **Relayer como parte del caso de uso** | Publicar eventos en el mismo proceso que escribe. Si el relayer falla, el caso de uso falla. | El relayer es un proceso separado (otro hilo, otro worker, otro deploy). |
+| **Transactional outbox sin transacción** | La escritura del evento y la operación de negocio no están en la misma transacción. | El outbox SOLO funciona dentro de una transacción. Si tu ORM/Bd no soporta transacciones, no uses outbox (usa CDC). |
+
+---
+
+## Conexión con Forge
+
+| Comando | Acción |
+|---|---|
+| `forge cast` | Incluir outbox en features que publican eventos |
+| `forge inspect` | Verifica que features con eventos tienen outbox implementado |
+| `forge quench` | Regla detect: feature publica eventos pero no tiene tabla outbox |
+| `forge graph` | Visualiza el flujo: Feature → Outbox → Relayer → Broker → Consumers |
+
+## Ver también
+
+- `reference/events.md` — eventos de dominio que el outbox publica
+- `reference/idempotency.md` — deduplicación en el relayer
+- `reference/sagas.md` — outbox como mecanismo de entrega en sagas
+- `reference/data-patterns.md` — repository pattern para outbox

package/skills/forge/scripts/architecture.mjs

@@ -4,7 +4,7 @@ import { join, basename } from "path";
 import { writeFileSync, existsSync } from "fs";
 import { buildContext } from "./context.mjs";
 import { detectProfile, detectProfileExtended } from "./profile.mjs";
-import { buildGraph, exportGraph } from "./graph.mjs";
+import { getGraph, exportGraph } from "./graph.mjs";
 import { buildOwnershipReport } from "./armorer.mjs";
 import { allChecks } from "./detect.mjs";
 
@@ -154,15 +154,18 @@ async function main() {
 
   const ctx = await buildContext();
   const profile = detectProfile(ctx);
-  const graph = buildGraph();
+  const graph = ctx.graph || getGraph();
   const ownership = buildOwnershipReport();
   const features = ctx.features.migrated;
   const result = allChecks(features, graph, ctx);
 
+  const CAT_MAX = { structure: 30, layers: 25, decorators: 20, ownership: 20, platform: 15, dependencies: 15, graph: 20, customRules: 5, naming: 10 };
   const totalScore = (result.structure?.score || 0) + (result.layers?.score || 0)
     + (result.ownership?.score || 0) + (result.platform?.score || 0)
-    + (result.dependencies?.score || 0) + (result.graph?.score || 0);
-  const maxScore = 20 + 20 + 20 + 15 + 15 + 20;
+    + (result.dependencies?.score || 0) + (result.graph?.score || 0)
+    + (result.decorators?.score || 0) + (result.customRules?.score || 0)
+    + (result.naming?.score || 0);
+  const maxScore = Object.values(CAT_MAX).reduce((a, b) => a + b, 0);
   const auditScore = maxScore > 0 ? Math.round((totalScore / maxScore) * 100) : 0;
 
   const md = generateMd(ctx, profile, graph, ownership, auditScore);
@@ -173,4 +176,6 @@ async function main() {
   console.log(`  Platform: ${ctx.platform.components.length} | Features: ${ctx.features.migrated.length} | Shared: ${ctx.shared.components.length} | Infra: ${ctx.infra.components.length}`);
 }
 
-main().catch(console.error);
+if (process.argv[1] && (process.argv[1].endsWith("architecture.mjs") || process.argv[1].endsWith("architecture.js"))) {
+  main().catch(console.error);
+}

package/skills/forge/scripts/assay.mjs

@@ -19,7 +19,7 @@
 import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync } from "fs";
 import { join, basename } from "path";
 import { loadState, loadHistory } from "./forge-config.mjs";
-import { buildGraph } from "./graph.mjs";
+import { getGraph } from "./graph.mjs";
 import {
   CYAN, GREEN, RED, YELLOW, BOLD, RESET, DIM, GRAY,
   formatJson, formatViolation,
@@ -327,7 +327,7 @@ function getLastInspectReport() {
 
 function rebuildGraph() {
   try {
-    return buildGraph(ROOT);
+    return getGraph(ROOT);
   } catch {
     return { nodes: [], edges: [], stats: { hasCycles: false, dependencyHealth: 100, totalNodes: 0, totalEdges: 0, violations: 0, riskScore: 0, health: "unknown" } };
   }

package/skills/forge/scripts/chain.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
-import { buildGraph } from "./graph.mjs";
+import { getGraph } from "./graph.mjs";
 
-export function buildDependencyGraph(projectRoot) {
-  const graph = buildGraph(projectRoot);
+export function buildDependencyGraph(projectRoot, existingGraph = null) {
+  const graph = existingGraph || getGraph(projectRoot);
 
   const layers = {
     platform: [],
@@ -194,9 +194,35 @@ export function buildDependencyGraph(projectRoot) {
 }
 
 async function main() {
-  const depGraph = buildDependencyGraph();
   const args = process.argv.slice(2);
-  if (args.includes("--json")) {
+  const isJson = args.includes("--json");
+  const summary = args.includes("--summary");
+
+  const depGraph = buildDependencyGraph();
+
+  if (summary) {
+    const out = {
+      features: depGraph.features.length,
+      hasCycles: depGraph.hasCycles,
+      globalCycles: depGraph.globalCycles,
+      illegalChains: depGraph.illegalChains.length,
+      isolated: depGraph.isolated.length,
+      layers: {
+        platform: depGraph.layers.platform.nodes.length,
+        features: depGraph.layers.features.nodes.length,
+        shared: depGraph.layers.shared.nodes.length,
+        infra: depGraph.layers.infra.nodes.length,
+      },
+    };
+    if (isJson) {
+      console.log(JSON.stringify(out, null, 2));
+    } else {
+      console.log(`Chain: ${out.features} features, cycles: ${out.hasCycles}, illegal chains: ${out.illegalChains}, isolated: ${out.isolated}`);
+    }
+    return;
+  }
+
+  if (isJson) {
     console.log(JSON.stringify(depGraph, null, 2));
   } else {
     console.log("## Chain — Multi-layer Dependency Analysis\n");

package/skills/forge/scripts/context.mjs

@@ -2,8 +2,9 @@
 
 import { readFileSync, existsSync, readdirSync, statSync } from "fs";
 import { join, basename, resolve } from "path";
-import { buildGraph } from "./graph.mjs";
+import { getGraph } from "./graph.mjs";
 import { buildOwnershipReport } from "./armorer.mjs";
+import { saveCache, loadCache } from "./forge-config.mjs";
 
 const ROOT = process.cwd();
 const SRC = join(ROOT, "src");
@@ -256,10 +257,24 @@ export function detectWorkspaces(projectRoot = ROOT) {
   }));
 }
 
-export async function buildContext(projectRoot = ROOT, workspaceScope = null) {
+export async function buildContext(projectRoot = ROOT, workspaceScope = null, opts = {}) {
+  const { force = false } = opts;
   const root = workspaceScope || projectRoot;
   const src = join(root, "src");
 
+  // Try cache first
+  if (!force) {
+    const cached = loadCache("context", root);
+    if (cached.valid && cached.data) {
+      // Ensure graph is loaded (it may be separate cache entry)
+      if (!cached.data.graph) {
+        const graphCached = getGraph(root, { force: false });
+        cached.data.graph = graphCached;
+      }
+      return cached.data;
+    }
+  }
+
   const pkg = readJson(join(root, "package.json")) || {};
   const tsconfig = readJson(join(root, "tsconfig.json"));
 
@@ -280,7 +295,7 @@ export async function buildContext(projectRoot = ROOT, workspaceScope = null) {
   const shared = classifyComponents(ownership.ownership.shared, SHARED_KNOWN);
   const infra = classifyComponents(ownership.ownership.infra, INFRA_KNOWN);
   const orphans = ownership.orphans;
-  const graph = buildGraph(root);
+  const graph = getGraph(root, { force });
 
   const hasFeatures = migratedFeatures.length > 0;
   const hasLegacy = legacyFeatures.length > 0;
@@ -290,7 +305,7 @@ export async function buildContext(projectRoot = ROOT, workspaceScope = null) {
   const monorepo = isRoot ? detectMonorepo(projectRoot) : null;
   const workspaces = isRoot ? detectWorkspaces(projectRoot) : [];
 
-  return {
+  const ctx = {
     projectName: basename(root),
     isWorkspace: !isRoot,
     workspaceScope: isRoot ? null : basename(root),
@@ -329,6 +344,11 @@ export async function buildContext(projectRoot = ROOT, workspaceScope = null) {
     graph,
     dependencies: {},
   };
+
+  // Save to cache
+  saveCache("context", ctx, root);
+
+  return ctx;
 }
 
 async function main() {

package/skills/forge/scripts/detect.mjs

@@ -2,11 +2,12 @@
 
 import { join, relative, basename } from "path";
 import { readFileSync, existsSync, readdirSync, statSync, writeFileSync, renameSync, mkdirSync } from "fs";
-import { buildGraph } from "./graph.mjs";
+import { getGraph } from "./graph.mjs";
 import { buildOwnershipReport } from "./armorer.mjs";
 import { parseImportsWithLines } from "./parse-imports.mjs";
 import { detectNamingViolations, computeExpectedName } from "./rename.mjs";
 import { formatViolation, formatCheck, GREEN, RED, YELLOW, CYAN, BOLD, RESET, DIM, GRAY } from "./formatter.mjs";
+import { buildPipeline, printPipeline } from "./recommendation-engine.mjs";
 
 const ROOT = process.cwd();
 const SRC = join(ROOT, "src");
@@ -728,11 +729,11 @@ export function checkGraph(graph) {
       label: `[${v.rule}] ${v.description}`,
       pass: false,
       detail: `${v.from} → ${v.to}${v.file ? ` (${v.file})` : ""}`,
-      fix: v.rule === "R1" ? "Core no debe importar de features. Mover la lógica a shared."
-        : v.rule === "R2" ? "Domain no puede importar infraestructura. Extraer interfaz y usar adapter."
-        : v.rule === "R3" ? "Feature no accede infraestructura directamente. Crear adapter en el feature."
-        : v.rule === "R4" ? "Feature no importa otro feature directamente. Inyectar interfaz."
-        : v.rule === "R5" ? "Romper el ciclo de dependencias extrayendo interfaz común a shared/."
+      fix: v.rule === "R1" ? "Feature no debe importar infraestructura directamente. Extraer interfaz al dominio y usar adapter en infra."
+        : v.rule === "R2" ? "Platform no debe depender de features. Extraer la interfaz a shared/ o mover la lógica."
+        : v.rule === "R3" ? "Shared no debe importar de features. Shared debe ser puro, sin dependencias de negocio."
+        : v.rule === "R4" ? "Shared no debe importar infraestructura. Shared debe ser puro, sin dependencias técnicas."
+        : v.rule === "R5" ? "Domain no puede importar infraestructura. El dominio debe estar aislado de la infra."
         : "Revisar la dirección de la dependencia",
     });
     score += penalty;
@@ -838,7 +839,7 @@ export function checkPlatform(ctx) {
 export function checkDependencies(ctx) {
   const checks = [];
   let score = 0;
-  const graph = ctx.graph || buildGraph();
+  const graph = ctx.graph || getGraph();
 
   if (!graph || graph.nodes.length === 0) {
     checks.push({ ...severity("No hay nodos en el grafo para analizar dependencias", SEVERITY.WARNING), pass: false });
@@ -917,26 +918,29 @@ export function checkCustomRules(features) {
       continue;
     }
 
+    const featureFiles = [];
     for (const feat of features) {
-      if (!feat.files) continue;
-      for (const f of feat.files) {
-        if (fileRe && !fileRe.test(f)) continue;
-        const content = read(f);
-        if (!content) continue;
-
-        contentRe.lastIndex = 0;
-        let match;
-        while ((match = contentRe.exec(content)) !== null) {
-          violations++;
-          const line = content.slice(0, match.index).split("\n").length;
-          checks.push({
-            severity: rule.severity || SEVERITY.ERROR,
-            label: `[${rule.id}] ${rule.message || "Violación de regla custom"} en ${relative(ROOT, f)}:${line}`,
-            pass: false,
-            detail: `Match: "${match[0].slice(0, 80)}"`,
-            fix: rule.fix || null,
-          });
-        }
+      const featDir = join(FEATURES, feat);
+      if (isDir(featDir)) featureFiles.push(...findFiles(featDir));
+    }
+    const targetFiles = featureFiles.length > 0 ? featureFiles : findFiles(SRC);
+    for (const f of targetFiles) {
+      if (fileRe && !fileRe.test(f)) continue;
+      const content = read(f);
+      if (!content) continue;
+
+      contentRe.lastIndex = 0;
+      let match;
+      while ((match = contentRe.exec(content)) !== null) {
+        violations++;
+        const line = content.slice(0, match.index).split("\n").length;
+        checks.push({
+          severity: rule.severity || SEVERITY.ERROR,
+          label: `[${rule.id}] ${rule.message || "Violación de regla custom"} en ${relative(ROOT, f)}:${line}`,
+          pass: false,
+          detail: `Match: "${match[0].slice(0, 80)}"`,
+          fix: rule.fix || null,
+        });
       }
     }
   }
@@ -982,7 +986,7 @@ export function checkNaming(projectRoot = ROOT) {
 }
 
 export function allChecks(features, graph, ctx) {
-  const g = graph || buildGraph(process.cwd());
+  const g = graph || getGraph();
   const c = ctx || {};
   return {
     structure: checkStructure(features),
@@ -1116,7 +1120,7 @@ async function main() {
   const { buildContext } = await import("./context.mjs");
   const ctx = await buildContext();
   const features = detectFeaturesOnSrc();
-  const graph = buildGraph(ROOT);
+  const graph = ctx.graph || getGraph();
   const results = allChecks(features, graph, ctx);
 
   // Load inline ignores
@@ -1128,13 +1132,13 @@ async function main() {
   }
 
   // Filter out ignored violations
-  const filtered = all.filter(c => {
+  let filtered = all.filter(c => {
     if (c.pass) return true;
     if (isIgnored(c, allIgnores)) return false;
     return true;
   });
 
-  if (filterSeverity) all = all.filter((c) => c.severity === filterSeverity);
+  if (filterSeverity) filtered = filtered.filter((c) => c.severity === filterSeverity);
 
   if (doFix) {
     const result = applyFixes(filtered);
@@ -1184,6 +1188,11 @@ async function main() {
       console.log(formatCheck(c));
     }
     console.log(`\nTotal: ${filtered.length} checks${ignoredCount > 0 ? ` (${ignoredCount} ignorados inline)` : ""}`);
+
+    if (filtered.some(c => !c.pass)) {
+      const pipeline = buildPipeline(filtered, ctx.graph, ctx.ownership, null, ctx);
+      printPipeline(pipeline);
+    }
   }
 }