@mmerterden/multi-agent-pipeline 8.6.0

package/pipeline/scripts/repo-map.mjs

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+//
+// repo-map.mjs — Aider-style token-budgeted repository map.
+//
+// Pattern source: https://aider.chat/docs/repomap.html
+//   - Walks the repo, extracts top-level declarations per file via regex
+//     (Swift, Kotlin, TS/JS, Python, Bash).
+//   - Builds a cross-file reference graph (file → file when file B mentions
+//     a top-level identifier defined in file A).
+//   - Ranks files: a simplified PageRank (in-degree weighted by referencing
+//     file's own out-degree, normalized). For an MVP this approximates the
+//     "this file matters because important files reference it" intuition.
+//   - Output: markdown, top-N files with their key declarations, truncated
+//     to a token budget. Suitable for inlining into Phase 1 / Phase 4
+//     LLM prompts as ${REPO_MAP}.
+//
+// Determinism: no embeddings, no network. Same input → same output.
+//
+// Usage:
+//   node repo-map.mjs [--root <dir>] [--budget <tokens>] [--top <N>]
+//                     [--format md|json] [--include <glob,...>]
+//                     [--exclude <glob,...>] [--verbose]
+//
+// Exit codes:
+//   0 — printed map (may be empty if no supported files found)
+//   2 — usage / arg error
+//   3 — root directory missing / not a repo
+
+import { promises as fs } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+// ---- CLI args --------------------------------------------------------------
+
+function parseArgs(argv) {
+  const args = {
+    root: process.cwd(),
+    budget: 2000,
+    top: 25,
+    format: 'md',
+    include: null,
+    exclude: null,
+    verbose: false,
+  };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--root') args.root = path.resolve(argv[++i]);
+    else if (a === '--budget') args.budget = parseInt(argv[++i], 10);
+    else if (a === '--top') args.top = parseInt(argv[++i], 10);
+    else if (a === '--format') args.format = argv[++i];
+    else if (a === '--include') args.include = argv[++i].split(',').filter(Boolean);
+    else if (a === '--exclude') args.exclude = argv[++i].split(',').filter(Boolean);
+    else if (a === '--verbose' || a === '-v') args.verbose = true;
+    else if (a === '--help' || a === '-h') {
+      console.log(
+        'usage: repo-map.mjs [--root DIR] [--budget TOKENS] [--top N]\n' +
+          '                   [--format md|json] [--include GLOB,...]\n' +
+          '                   [--exclude GLOB,...] [--verbose]'
+      );
+      process.exit(0);
+    } else {
+      console.error(`repo-map: unknown arg "${a}"`);
+      process.exit(2);
+    }
+  }
+  if (!['md', 'json'].includes(args.format)) {
+    console.error(`repo-map: --format must be md or json (got "${args.format}")`);
+    process.exit(2);
+  }
+  if (!Number.isFinite(args.budget) || args.budget < 100) {
+    console.error('repo-map: --budget must be an integer >= 100');
+    process.exit(2);
+  }
+  if (!Number.isFinite(args.top) || args.top < 1) {
+    console.error('repo-map: --top must be >= 1');
+    process.exit(2);
+  }
+  return args;
+}
+
+// ---- File walking ----------------------------------------------------------
+
+const DEFAULT_IGNORE = new Set([
+  '.git', 'node_modules', 'Pods', '.build', 'DerivedData', '.next',
+  'dist', 'build', '__pycache__', '.venv', 'venv', '.cache',
+  '.gradle', '.idea', '.vscode', 'target',
+]);
+
+const LANG_EXT = {
+  '.swift': 'swift',
+  '.kt':    'kotlin',
+  '.kts':   'kotlin',
+  '.ts':    'ts',
+  '.tsx':   'ts',
+  '.js':    'js',
+  '.mjs':   'js',
+  '.cjs':   'js',
+  '.jsx':   'js',
+  '.py':    'python',
+  '.sh':    'bash',
+  '.bash':  'bash',
+};
+
+async function walk(root, args) {
+  const out = [];
+  async function recurse(dir) {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.name.startsWith('.') && DEFAULT_IGNORE.has(e.name)) continue;
+      if (DEFAULT_IGNORE.has(e.name)) continue;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        await recurse(full);
+      } else if (e.isFile()) {
+        const ext = path.extname(e.name).toLowerCase();
+        if (!LANG_EXT[ext]) continue;
+        // size cap — skip generated / mega files (>500KB) to stay deterministic
+        try {
+          const st = statSync(full);
+          if (st.size > 500_000) continue;
+        } catch {
+          continue;
+        }
+        const rel = path.relative(root, full);
+        if (args.include && !args.include.some((g) => rel.includes(g))) continue;
+        if (args.exclude && args.exclude.some((g) => rel.includes(g))) continue;
+        out.push({ path: rel, lang: LANG_EXT[ext], abs: full });
+      }
+    }
+  }
+  await recurse(root);
+  return out;
+}
+
+// ---- Declaration extractors (regex MVP) -----------------------------------
+// NOTE: regex is approximate; tree-sitter would be more accurate but adds a
+// heavy dep. Each extractor returns an array of { kind, name, signature }.
+
+const EXTRACTORS = {
+  swift: (src) => {
+    const out = [];
+    const re =
+      /^\s*(?:public|internal|fileprivate|private|open)?\s*(?:final\s+|indirect\s+)?(class|struct|protocol|enum|extension|actor|func)\s+([A-Za-z_][A-Za-z0-9_]*)(?:\s*<[^>]*>)?([^{=\n]*)/gm;
+    let m;
+    while ((m = re.exec(src))) {
+      const kind = m[1];
+      const name = m[2];
+      const rest = (m[3] || '').trim();
+      const signature = `${kind} ${name}${rest ? ' ' + rest : ''}`.trim();
+      out.push({ kind, name, signature: truncateSig(signature) });
+    }
+    return out;
+  },
+  kotlin: (src) => {
+    const out = [];
+    const re =
+      /^\s*(?:public|internal|private|protected)?\s*(?:abstract\s+|open\s+|sealed\s+|data\s+|enum\s+|inner\s+|inline\s+)*(class|object|interface|fun)\s+([A-Za-z_][A-Za-z0-9_]*)([^{=\n]*)/gm;
+    let m;
+    while ((m = re.exec(src))) {
+      const kind = m[1];
+      const name = m[2];
+      const rest = (m[3] || '').trim();
+      const signature = `${kind} ${name}${rest ? ' ' + rest : ''}`.trim();
+      out.push({ kind, name, signature: truncateSig(signature) });
+    }
+    return out;
+  },
+  ts: (src) => {
+    const out = [];
+    const re =
+      /^\s*export\s+(?:default\s+)?(?:async\s+)?(class|interface|type|function|const|let|enum)\s+([A-Za-z_][A-Za-z0-9_]*)([^{=;\n]*)/gm;
+    let m;
+    while ((m = re.exec(src))) {
+      const kind = m[1];
+      const name = m[2];
+      const rest = (m[3] || '').trim();
+      const signature = `export ${kind} ${name}${rest ? ' ' + rest : ''}`.trim();
+      out.push({ kind, name, signature: truncateSig(signature) });
+    }
+    return out;
+  },
+  js: (src) => EXTRACTORS.ts(src),
+  python: (src) => {
+    const out = [];
+    const re =
+      /^(?:\s{0,4})(?:async\s+)?(class|def)\s+([A-Za-z_][A-Za-z0-9_]*)(\([^)]*\))?/gm;
+    let m;
+    while ((m = re.exec(src))) {
+      const kind = m[1];
+      const name = m[2];
+      const rest = (m[3] || '').trim();
+      const signature = `${kind} ${name}${rest}`.trim();
+      out.push({ kind, name, signature: truncateSig(signature) });
+    }
+    return out;
+  },
+  bash: (src) => {
+    const out = [];
+    // Bash functions: `name() {` or `function name {` (top-level only)
+    const re = /^(?:function\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*\(\)\s*\{/gm;
+    let m;
+    while ((m = re.exec(src))) {
+      const name = m[1];
+      out.push({ kind: 'fn', name, signature: `${name}()` });
+    }
+    return out;
+  },
+};
+
+function truncateSig(s, max = 100) {
+  s = s.replace(/\s+/g, ' ').trim();
+  return s.length > max ? s.slice(0, max - 1) + '…' : s;
+}
+
+// ---- Pipeline --------------------------------------------------------------
+
+async function buildMap(args) {
+  if (!existsSync(args.root)) {
+    console.error(`repo-map: root not found: ${args.root}`);
+    process.exit(3);
+  }
+  const files = await walk(args.root, args);
+  if (args.verbose) console.error(`repo-map: scanned ${files.length} source files`);
+  if (files.length === 0) {
+    if (args.format === 'json') console.log('[]');
+    else console.log('');
+    return;
+  }
+
+  // Read + extract declarations.
+  const fileDecls = new Map(); // path -> [{kind, name, signature}]
+  const identOwner = new Map(); // identifier name -> Set of file paths defining it
+  for (const f of files) {
+    let src;
+    try {
+      src = await fs.readFile(f.abs, 'utf8');
+    } catch {
+      continue;
+    }
+    const decls = EXTRACTORS[f.lang](src);
+    fileDecls.set(f.path, decls);
+    for (const d of decls) {
+      if (!identOwner.has(d.name)) identOwner.set(d.name, new Set());
+      identOwner.get(d.name).add(f.path);
+    }
+  }
+
+  // Build reference edges: for each file, count occurrences of identifiers
+  // defined ELSEWHERE. Word-boundary match; skip same-file declarations.
+  const inEdges = new Map(); // path -> count of incoming refs
+  const outEdges = new Map(); // path -> count of outgoing refs
+  for (const f of files) inEdges.set(f.path, 0);
+  for (const f of files) outEdges.set(f.path, 0);
+
+  // TF-IDF-style scoring: an identifier defined in N files contributes
+  // 1/N credit per match. This neutralises shared helper names (e.g. `pass`,
+  // `fail`, `init`) that appear in dozens of files without signalling
+  // architectural importance — those split credit thin and don't dominate.
+  // Aider's repo map uses the same intuition (rare symbols rank higher).
+
+  // Hard stop-list for sub-3-char + universally-shared shell helpers.
+  const STOP_IDENTIFIERS = new Set([
+    'init', 'main', 'run', 'start', 'stop', 'pass', 'fail', 'warn', 'need',
+    'check', 'log', 'set', 'get', 'add', 'new', 'fix', 'has', 'is', 'on',
+    'self', 'this', 'next', 'prev', 'data', 'item', 'name', 'type', 'value',
+    'count', 'list', 'map', 'each', 'reduce', 'true', 'false', 'null', 'undefined',
+  ]);
+
+  for (const f of files) {
+    let src;
+    try {
+      src = await fs.readFile(f.abs, 'utf8');
+    } catch {
+      continue;
+    }
+    for (const [name, owners] of identOwner) {
+      if (name.length < 3) continue;
+      if (STOP_IDENTIFIERS.has(name.toLowerCase())) continue;
+      if (owners.size === 1 && owners.has(f.path)) continue;
+      const re = new RegExp(`\\b${escapeRe(name)}\\b`, 'g');
+      const matches = src.match(re);
+      if (!matches) continue;
+      // TF-IDF: credit per occurrence is divided by the number of owners.
+      const creditPerMatch = 1 / owners.size;
+      const credit = matches.length * creditPerMatch;
+      outEdges.set(f.path, outEdges.get(f.path) + credit);
+      for (const owner of owners) {
+        if (owner === f.path) continue;
+        // Distribute incoming credit equally across owners so the score reflects
+        // the count of *distinct* references rather than which owner "got lucky".
+        inEdges.set(owner, inEdges.get(owner) + credit / Math.max(1, owners.size - 1));
+      }
+    }
+  }
+
+  // Simple rank: incoming refs (mass) + small weight for declaration density
+  // (decls / log(file_size)). Normalized 0..1.
+  const ranks = files.map((f) => {
+    const ins = inEdges.get(f.path) || 0;
+    const decls = (fileDecls.get(f.path) || []).length;
+    const score = ins + decls * 0.25;
+    return { ...f, score, ins, decls };
+  });
+  const maxScore = Math.max(1, ...ranks.map((r) => r.score));
+  for (const r of ranks) r.normScore = r.score / maxScore;
+
+  ranks.sort((a, b) => b.score - a.score);
+  const top = ranks.slice(0, args.top);
+
+  if (args.format === 'json') {
+    const obj = top.map((r) => ({
+      path: r.path,
+      lang: r.lang,
+      score: Number(r.normScore.toFixed(4)),
+      incoming_refs: r.ins,
+      declarations: fileDecls.get(r.path) || [],
+    }));
+    console.log(JSON.stringify(obj, null, 2));
+    return;
+  }
+
+  // Markdown — greedy fill within token budget. Token ≈ 4 chars heuristic.
+  const charBudget = args.budget * 4;
+  const header = `# Repo Map (top ${args.top}, budget ${args.budget} tokens)\n`;
+  let used = header.length;
+  let out = header + '\n';
+  let printed = 0;
+
+  for (const r of top) {
+    const decls = fileDecls.get(r.path) || [];
+    const filteredDecls = decls.slice(0, 12); // cap per-file
+    const block =
+      `## ${r.path}  [rank ${r.normScore.toFixed(3)}, in_refs ${r.ins}]\n` +
+      (filteredDecls.length === 0
+        ? '_no top-level declarations extracted_\n'
+        : filteredDecls.map((d) => `- ${d.signature}`).join('\n') + '\n') +
+      '\n';
+    if (used + block.length > charBudget && printed > 0) break;
+    out += block;
+    used += block.length;
+    printed += 1;
+  }
+  if (printed === 0) {
+    out += '_no files extracted within budget_\n';
+  } else if (printed < top.length) {
+    out += `_truncated to ${printed} files (token budget)_\n`;
+  }
+  process.stdout.write(out);
+}
+
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// ---- Main ------------------------------------------------------------------
+
+const args = parseArgs(process.argv);
+buildMap(args).catch((err) => {
+  console.error('repo-map: fatal —', err.message);
+  process.exit(1);
+});

package/pipeline/scripts/run-aggregator.mjs

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+
+/**
+ * @file run-aggregator.mjs — v7.8.0 Paket C
+ *
+ * Unified telemetry aggregator. Reads three independent telemetry sources
+ * for a single pipeline task and emits one normalized `pipeline-run.jsonl`
+ * stream that downstream consumers (retro analysis, OTel forwarder, cost
+ * dashboards) can ingest without re-stitching the inputs.
+ *
+ * Sources:
+ *   - phase-tracker.json   ← live state machine (always present)
+ *   - otel-spans.jsonl     ← MULTI_AGENT_OTEL_SPANS=1 emitter (opt-in)
+ *   - metrics.jsonl        ← global aggregate-metrics.mjs feed (opt-in)
+ *   - cost-table.json      ← per-model pricing for cost computation
+ *
+ * Output: one JSON event per line, sorted by timestamp. Event kinds:
+ *   - `run.start` / `run.end`
+ *   - `phase.start` / `phase.complete` / `phase.failed`
+ *   - `subphase.transition`
+ *   - `tokens` (delta from phase-tracker)
+ *   - `cost` (computed per-phase, attributed by model)
+ *   - `span` (passthrough from otel-spans.jsonl)
+ *   - `summary` (last event — totals)
+ *
+ * Read-only — never modifies the source files.
+ *
+ * Usage:
+ *   node run-aggregator.mjs --task-dir <path>
+ *   node run-aggregator.mjs --task-id 3 --project myproj
+ *   node run-aggregator.mjs --task-dir <path> --out /tmp/run.jsonl
+ *   node run-aggregator.mjs --task-dir <path> --summary-only
+ *
+ * @module pipeline/scripts/run-aggregator
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const argv = process.argv.slice(2);
+const flags = {};
+for (let i = 0; i < argv.length; i++) {
+  const a = argv[i];
+  if (a.startsWith("--")) {
+    const [key, ...rest] = a.slice(2).split("=");
+    if (rest.length) {
+      flags[key] = rest.join("=");
+    } else if (argv[i + 1] && !argv[i + 1].startsWith("--")) {
+      flags[key] = argv[i + 1];
+      i++;
+    } else {
+      flags[key] = true;
+    }
+  }
+}
+
+if (flags.help || flags.h) {
+  console.log(`Usage: run-aggregator.mjs [options]
+
+Inputs:
+  --task-dir <path>     Task directory containing phase-tracker.json
+  --task-id <id>        Resolve via $HOME/.claude/logs/multi-agent/<project>/<id>/
+  --project <slug>      Project slug for --task-id resolution
+
+Output:
+  --out <path>          Write to file (default: <task-dir>/pipeline-run.jsonl)
+  --stdout              Stream to stdout instead of writing file
+  --summary-only        Emit only the final summary event
+
+Options:
+  --cost-table <path>   Override cost table (default: bundled cost-table.json)
+`);
+  process.exit(0);
+}
+
+function die(msg) {
+  process.stderr.write(`run-aggregator: ${msg}\n`);
+  process.exit(1);
+}
+
+function resolveTaskDir() {
+  if (flags["task-dir"]) return flags["task-dir"];
+  if (flags["task-id"] && flags.project) {
+    const HOME = process.env.HOME || process.env.USERPROFILE;
+    return join(HOME, ".claude", "logs", "multi-agent", flags.project, String(flags["task-id"]));
+  }
+  die("either --task-dir or --task-id with --project is required");
+}
+
+function loadJson(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch (e) {
+    die(`failed to parse ${path}: ${e.message}`);
+  }
+}
+
+function loadJsonl(path) {
+  if (!existsSync(path)) return [];
+  const out = [];
+  for (const line of readFileSync(path, "utf-8").split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      // Skip malformed lines silently — telemetry sources may be truncated
+      // mid-write if the pipeline is killed during emission.
+    }
+  }
+  return out;
+}
+
+function loadCostTable() {
+  const path = flags["cost-table"] || join(__dirname, "cost-table.json");
+  const tbl = loadJson(path);
+  if (!tbl?.prices) {
+    process.stderr.write(`run-aggregator: cost table missing or malformed at ${path}, costs will be 0\n`);
+    return { prices: {} };
+  }
+  return tbl;
+}
+
+/**
+ * Compute USD cost for a token pair given a model. Unknown models → 0 with
+ * a `cost_unknown_model: true` marker so consumers can flag the gap without
+ * crashing.
+ */
+function computeCost(modelKey, tokensIn, tokensOut, costTable) {
+  const price = costTable.prices?.[modelKey];
+  if (!price || (typeof price.inPerMtok !== "number" && typeof price.outPerMtok !== "number")) {
+    return { cost_usd: 0, cost_unknown_model: true };
+  }
+  const usd =
+    ((tokensIn || 0) / 1_000_000) * (price.inPerMtok || 0) +
+    ((tokensOut || 0) / 1_000_000) * (price.outPerMtok || 0);
+  return { cost_usd: Number(usd.toFixed(6)) };
+}
+
+/**
+ * Heuristic: phase 1/2 use Opus (per personas + dev-mode docs); phase 3 uses
+ * Sonnet by default unless the run is a `--dev` mode (Opus). Phase 4 review
+ * is multi-model — span events carry per-reviewer model when OTel is on.
+ *
+ * This is a fallback when phase-tracker doesn't record the model used. Live
+ * runs that emit OTel spans get per-call model attribution from the spans.
+ */
+function inferModelForPhase(phaseId) {
+  if (phaseId === "1" || phaseId === "2") return "opus";
+  if (phaseId === "4") return "opus"; // triage is opus; reviewer breakdown comes from spans
+  return "sonnet";
+}
+
+function tsCompare(a, b) {
+  return (a.ts || "").localeCompare(b.ts || "");
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+const taskDir = resolveTaskDir();
+if (!existsSync(taskDir)) die(`task dir not found: ${taskDir}`);
+
+const tracker = loadJson(join(taskDir, "phase-tracker.json"));
+if (!tracker) die(`phase-tracker.json not found in ${taskDir}`);
+
+const otelSpans = loadJsonl(join(taskDir, "otel-spans.jsonl"));
+const costTable = loadCostTable();
+
+const taskId = tracker.task_id || flags["task-id"] || "unknown";
+const events = [];
+
+// run.start
+events.push({
+  kind: "run.start",
+  ts: tracker.started_at || new Date(0).toISOString(),
+  task_id: taskId,
+  source: "phase-tracker",
+});
+
+// Phase events
+let totalIn = 0;
+let totalOut = 0;
+let totalCost = 0;
+let unknownModelHits = 0;
+
+for (const phase of tracker.phases || []) {
+  const tIn = phase.tokens_in || 0;
+  const tOut = phase.tokens_out || 0;
+  const model = phase.model || inferModelForPhase(phase.id);
+  const { cost_usd, cost_unknown_model } = computeCost(model, tIn, tOut, costTable);
+
+  totalIn += tIn;
+  totalOut += tOut;
+  totalCost += cost_usd;
+  if (cost_unknown_model) unknownModelHits++;
+
+  if (phase.started_at) {
+    events.push({
+      kind: "phase.start",
+      ts: phase.started_at,
+      task_id: taskId,
+      phase: phase.id,
+      name: phase.name,
+    });
+  }
+
+  if (phase.completed_at && phase.status) {
+    const eventKind =
+      phase.status === "completed"
+        ? "phase.complete"
+        : phase.status === "failed"
+        ? "phase.failed"
+        : "phase.transition";
+    events.push({
+      kind: eventKind,
+      ts: phase.completed_at,
+      task_id: taskId,
+      phase: phase.id,
+      name: phase.name,
+      status: phase.status,
+      tokens_in: tIn,
+      tokens_out: tOut,
+      model,
+      cost_usd,
+      ...(cost_unknown_model ? { cost_unknown_model: true } : {}),
+    });
+  }
+
+  for (const sub of phase.subs || []) {
+    events.push({
+      kind: "subphase.transition",
+      ts: phase.completed_at || phase.started_at || tracker.started_at || "",
+      task_id: taskId,
+      phase: phase.id,
+      sub_id: sub.id,
+      sub_name: sub.name,
+      status: sub.status,
+    });
+  }
+}
+
+// OTel spans — passthrough with task_id stamped
+for (const span of otelSpans) {
+  events.push({
+    kind: "span",
+    ts: span.ts || span.timestamp || "",
+    task_id: taskId,
+    span_event: span.name || span.event,
+    span_attrs: span.attributes || span.attrs || null,
+    raw: span,
+  });
+}
+
+// Sort all events by ts ascending
+events.sort(tsCompare);
+
+// run.end (best-effort: last completed phase's completed_at)
+const lastTs =
+  events
+    .filter((e) => e.kind.startsWith("phase.complete") || e.kind === "phase.failed")
+    .map((e) => e.ts)
+    .sort()
+    .pop() || tracker.started_at || "";
+
+events.push({
+  kind: "run.end",
+  ts: lastTs,
+  task_id: taskId,
+});
+
+// Summary as the very last line
+const summary = {
+  kind: "summary",
+  ts: lastTs,
+  task_id: taskId,
+  phases_total: tracker.phases?.length ?? 0,
+  phases_completed: (tracker.phases || []).filter((p) => p.status === "completed").length,
+  phases_failed: (tracker.phases || []).filter((p) => p.status === "failed").length,
+  tokens_in: totalIn,
+  tokens_out: totalOut,
+  total_cost_usd: Number(totalCost.toFixed(6)),
+  ...(unknownModelHits > 0 ? { unknown_model_phases: unknownModelHits } : {}),
+  span_count: otelSpans.length,
+};
+
+// ─────────────────────────────────────────────────────────────────────────
+const outLines = (flags["summary-only"] ? [summary] : [...events, summary]).map((e) => JSON.stringify(e));
+const outContent = outLines.join("\n") + "\n";
+
+if (flags.stdout) {
+  process.stdout.write(outContent);
+} else {
+  const outPath = flags.out || join(taskDir, "pipeline-run.jsonl");
+  writeFileSync(outPath, outContent);
+  process.stderr.write(`run-aggregator: wrote ${outLines.length} events to ${outPath}\n`);
+}