@hilbras/omninode 0.5.2 → 0.7.0

package/dist/cli/index.js

@@ -6,7 +6,7 @@ import { realpathSync } from "fs";
 import { Command } from "commander";
 
 // src/version.ts
-var OMNINODE_VERSION = "0.5.2";
+var OMNINODE_VERSION = "0.7.0";
 
 // src/errors/index.ts
 var OmniNodeError = class extends Error {
@@ -39,6 +39,11 @@ var TaskError = class extends OmniNodeError {
     super(code, message, options);
   }
 };
+var PipelineError = class extends OmniNodeError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+  }
+};
 var ProtocolError = class extends OmniNodeError {
   constructor(message, options = {}) {
     super("PROTOCOL_VIOLATION", message, options);
@@ -84,11 +89,29 @@ var roleConfigSchema = z.object({
   system_prompt: z.string().optional(),
   metadata: z.record(z.unknown()).optional()
 }).strict();
+var pipelineStepConfigSchema = z.object({
+  id: z.string().min(1),
+  kind: z.enum(["research", "collect", "analyze", "plan", "execute", "custom"]),
+  agents: z.array(z.string()).optional(),
+  agent: z.string().optional(),
+  model: z.string().optional(),
+  depends_on: z.array(z.string()).optional(),
+  retries: z.number().int().min(0).max(10).optional(),
+  condition: z.enum(["always", "on-success", "on-failure"]).optional()
+}).strict();
+var pipelineConfigSchema = z.object({
+  id: z.string().min(1).regex(/^[a-z0-9][a-z0-9-]*$/, "pipeline id must be kebab-case"),
+  name: z.string().optional(),
+  objective: z.string().optional(),
+  role: z.string().optional(),
+  steps: z.array(pipelineStepConfigSchema).min(1)
+}).strict();
 var projectConfigSchema = z.object({
   name: z.string().min(1),
   providers: z.array(providerConfigSchema).default([]),
   agents: z.array(agentConfigSchema).default([]),
   roles: z.array(roleConfigSchema).default([]),
+  pipelines: z.array(pipelineConfigSchema).default([]),
   memory: z.object({ provider: z.string().min(1) }).strict().optional()
 }).strict();
 var appConfigSchema = z.object({
@@ -158,11 +181,30 @@ function toAppConfig(yaml) {
       providers: yaml.project.providers.map(toProviderConfig),
       agents: yaml.project.agents.map(toAgentConfig),
       roles: yaml.project.roles.map(toRoleDefinition),
+      pipelines: yaml.project.pipelines.map(toPipelineDefinition),
       ...yaml.project.memory !== void 0 ? { memory: yaml.project.memory } : {}
     },
     ...yaml.logging !== void 0 ? { logging: yaml.logging } : {}
   };
 }
+function toPipelineDefinition(raw) {
+  return {
+    id: raw.id,
+    name: raw.name,
+    objective: raw.objective,
+    role: raw.role,
+    steps: raw.steps.map((step) => ({
+      id: step.id,
+      kind: step.kind,
+      agents: step.agents,
+      agent: step.agent,
+      model: step.model,
+      dependsOn: step.depends_on,
+      retries: step.retries,
+      condition: step.condition
+    }))
+  };
+}
 function toProviderConfig(raw) {
   return {
     name: raw.name,
@@ -633,6 +675,9 @@ function notImplemented(command, when) {
     `${command} is planned for ${when}. Edit omninode.yaml directly for now.`
   );
 }
+function truncate(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
 function appendToConfigList(listKey, item) {
   const configPath = findConfigFile();
   if (!configPath) {
@@ -1216,23 +1261,42 @@ import { mkdir, readFile, rename, writeFile } from "fs/promises";
 import { dirname } from "path";
 var FileTaskStore = class {
   filePath;
+  /**
+   * Read-modify-write operations are serialized: parallel pipeline tasks
+   * would otherwise race on the JSON file (last writer wins).
+   */
+  queue = Promise.resolve();
   constructor(directory = `${process.cwd()}/.omninode`) {
     this.filePath = `${directory}/tasks.json`;
   }
   async save(task) {
-    const tasks = await this.load();
-    const index = tasks.findIndex((t) => t.id === task.id);
-    if (index >= 0) tasks[index] = task;
-    else tasks.push(task);
-    await this.write(tasks);
+    return this.synchronized(async () => {
+      const tasks = await this.load();
+      const index = tasks.findIndex((t) => t.id === task.id);
+      if (index >= 0) tasks[index] = task;
+      else tasks.push(task);
+      await this.write(tasks);
+    });
   }
   async get(id) {
-    const tasks = await this.load();
-    return tasks.find((t) => t.id === id);
+    return this.synchronized(async () => {
+      const tasks = await this.load();
+      return tasks.find((t) => t.id === id);
+    });
   }
   async list(filter = {}) {
-    const tasks = await this.load();
-    return tasks.filter((task) => filter.status ? task.status === filter.status : true).filter((task) => filter.project ? task.project === filter.project : true).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return this.synchronized(async () => {
+      const tasks = await this.load();
+      return tasks.filter((task) => filter.status ? task.status === filter.status : true).filter((task) => filter.project ? task.project === filter.project : true).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    });
+  }
+  synchronized(operation) {
+    const result = this.queue.then(operation, operation);
+    this.queue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
   }
   async load() {
     try {
@@ -1343,6 +1407,8 @@ var TaskEngine = class {
     const result = {
       ...output.summary !== void 0 ? { summary: output.summary } : {},
       ...output.reports !== void 0 && output.reports.length > 0 ? { reports: output.reports } : {},
+      // Keep the verbatim output (bounded) for report extraction and audit.
+      ...output.rawOutput !== void 0 && output.rawOutput.length > 0 ? { rawOutput: output.rawOutput.slice(0, 1e4) } : {},
       ...output.error !== void 0 ? { error: output.error } : {},
       finishedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -1477,7 +1543,7 @@ function registerTaskCommands(program) {
       return;
     }
     for (const t of tasks) {
-      console.log(`${t.id}  ${t.status.padEnd(10)} ${truncate(t.objective, 60)}`);
+      console.log(`${t.id}  ${t.status.padEnd(10)} ${truncate2(t.objective, 60)}`);
     }
   });
   task.command("cancel <task-id>").description("Cancel a task that has not finished yet.").action(async (taskId) => {
@@ -1507,16 +1573,924 @@ function printOutcome(task, options = {}) {
   if (result.error) console.log(`  error:   ${result.error}`);
   if (result.finishedAt) console.log(`  ended:   ${result.finishedAt}`);
 }
-function truncate(text, max) {
+function truncate2(text, max) {
   return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
 }
 
+// src/reports/aggregate.ts
+import { randomBytes as randomBytes2 } from "crypto";
+var SEVERITY_RANK = {
+  info: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  critical: 4
+};
+function aggregateReports(reports, options = {}) {
+  const threshold = options.similarityThreshold ?? 0.7;
+  const findingGroups = [];
+  const recommendationGroups = [];
+  for (const report of reports) {
+    for (const finding of report.findings) {
+      mergeFinding(findingGroups, finding, report, threshold);
+    }
+    for (const text of report.recommendations) {
+      mergeRecommendation(recommendationGroups, text, report, threshold);
+    }
+  }
+  const sources = [...new Set(reports.map((r) => r.agent))].sort();
+  const totalRawFindings = reports.reduce((sum, r) => sum + r.findings.length, 0);
+  const summary = `${reports.length} report(s) from ${sources.length > 0 ? sources.join(", ") : "no agents"}: ${findingGroups.length} unique finding group(s) (${totalRawFindings} raw), ${recommendationGroups.length} recommendation group(s).`;
+  return {
+    id: `combined-${Date.now().toString(36)}-${randomBytes2(3).toString("hex")}`,
+    title: options.objective !== void 0 ? truncate3(options.objective, 120) : "Combined report",
+    ...options.objective !== void 0 ? { objective: options.objective } : {},
+    ...options.pipelineRunId !== void 0 ? { pipelineRunId: options.pipelineRunId } : {},
+    taskIds: options.taskIds ?? [],
+    summary,
+    findings: findingGroups.sort((a, b) => rank(b) - rank(a)),
+    recommendations: recommendationGroups,
+    sources,
+    reportIds: reports.map((r) => r.id),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function rank(finding) {
+  return finding.severity ? SEVERITY_RANK[finding.severity] : -1;
+}
+function mergeFinding(groups, finding, report, threshold) {
+  const source = { agent: report.agent, reportId: report.id };
+  const group = groups.find((g) => similar(g.title, finding.title, threshold));
+  if (group) {
+    group.occurrences += 1;
+    group.details.push(finding.detail);
+    group.sources.push(source);
+    group.evidence.push(...finding.evidence ?? []);
+    if (finding.severity && (!group.severity || SEVERITY_RANK[finding.severity] > SEVERITY_RANK[group.severity])) {
+      group.severity = finding.severity;
+    }
+    return;
+  }
+  groups.push({
+    title: finding.title,
+    details: [finding.detail],
+    sources: [source],
+    occurrences: 1,
+    ...finding.severity ? { severity: finding.severity } : {},
+    evidence: [...finding.evidence ?? []]
+  });
+}
+function mergeRecommendation(groups, text, report, threshold) {
+  const source = { agent: report.agent, reportId: report.id };
+  const group = groups.find((g) => similar(g.text, text, threshold));
+  if (group) {
+    group.occurrences += 1;
+    group.sources.push(source);
+    return;
+  }
+  groups.push({ text, sources: [source], occurrences: 1 });
+}
+function similar(a, b, threshold) {
+  const left = tokens(a);
+  const right = tokens(b);
+  if (left.size === 0 || right.size === 0) return false;
+  let intersection = 0;
+  for (const token of left) {
+    if (right.has(token)) intersection += 1;
+  }
+  const union = left.size + right.size - intersection;
+  return intersection / union >= threshold;
+}
+function tokens(text) {
+  return new Set(
+    text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= 3)
+  );
+}
+function truncate3(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+
+// src/reports/extract.ts
+var BULLET = /^(?:[-*•]|\d+[.)])\s+(.*)$/;
+function parseSections(raw) {
+  const sections = [];
+  let current = { heading: "", bullets: [] };
+  for (const line of raw.split("\n")) {
+    const heading = /^(#{1,6})\s+(.*)$/.exec(line.trim());
+    if (heading) {
+      if (current.heading.length > 0 || current.bullets.length > 0) {
+        sections.push(current);
+      }
+      current = { heading: heading[2]?.toLowerCase() ?? "", bullets: [] };
+      continue;
+    }
+    const bullet = BULLET.exec(line.trim());
+    if (bullet && current.heading.length > 0) {
+      current.bullets.push(bullet[1]?.trim() ?? "");
+    }
+  }
+  if (current.heading.length > 0 || current.bullets.length > 0) {
+    sections.push(current);
+  }
+  return sections;
+}
+function collectBullets(sections, patterns) {
+  const matches = sections.filter((section) => patterns.some((p) => p.test(section.heading)));
+  return matches.flatMap((section) => section.bullets).filter((b) => b.length > 0);
+}
+function guessSeverity(text) {
+  if (/critical|severe/i.test(text)) return "critical";
+  if (/\bhigh\b|major/i.test(text)) return "high";
+  if (/medium|moderate/i.test(text)) return "medium";
+  if (/\blow\b|minor/i.test(text)) return "low";
+  return void 0;
+}
+function extractReportFromText(raw, meta) {
+  const trimmed = raw.trim();
+  const nonEmpty = trimmed.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  const proseLine = nonEmpty.find((line) => !line.startsWith("#") && !BULLET.test(line)) ?? nonEmpty[0] ?? "";
+  const cleaned = proseLine.replace(/^#{1,6}\s+/, "").replace(BULLET, "$1");
+  const summary = cleaned.length > 0 ? truncate4(cleaned, 200) : "(no output)";
+  const sections = parseSections(trimmed);
+  const findingTexts = collectBullets(sections, [/finding/, /issue/, /problem/, /vulnerab/]);
+  const recommendationTexts = collectBullets(sections, [/recommend/, /suggestion/, /next step/, /action/]);
+  const evidenceTexts = collectBullets(sections, [/evidence/, /proof/, /log/]);
+  const findings = findingTexts.map((text, index) => ({
+    id: `${meta.taskId}-f-${index + 1}`,
+    title: truncate4(text, 120),
+    detail: text,
+    severity: guessSeverity(text)
+  }));
+  return {
+    id: `${meta.taskId}-report`,
+    taskId: meta.taskId,
+    agent: meta.agent,
+    ...meta.model !== void 0 ? { model: meta.model } : {},
+    summary,
+    findings,
+    recommendations: recommendationTexts.map((t) => truncate4(t, 200)),
+    metadata: evidenceTexts.length > 0 ? { evidence: evidenceTexts } : void 0,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function truncate4(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+
+// src/reports/service.ts
+var ReportService = class {
+  constructor(store, log = logger) {
+    this.store = store;
+    this.log = log.child({ component: "reports" });
+  }
+  store;
+  log;
+  get storeRef() {
+    return this.store;
+  }
+  /** Normalizes finished tasks into reports (§17 — normalizer). */
+  async collectFromTasks(tasks) {
+    const reports = [];
+    for (const task of tasks) {
+      const structured = task.result?.reports ?? [];
+      if (structured.length > 0) {
+        reports.push(...structured);
+        continue;
+      }
+      const text = task.result?.rawOutput ?? task.result?.summary ?? "";
+      if (text.trim().length === 0) continue;
+      reports.push(
+        extractReportFromText(text, {
+          taskId: task.id,
+          agent: task.agent ?? "unknown"
+        })
+      );
+    }
+    return reports;
+  }
+  async saveReports(reports) {
+    if (reports.length === 0) return;
+    await this.store.saveReports(reports);
+    this.log.info(`Stored ${reports.length} report(s).`);
+  }
+  async generateCombined(reports, meta = {}) {
+    if (reports.length === 0) return void 0;
+    const options = {
+      ...meta.objective !== void 0 ? { objective: meta.objective } : {},
+      ...meta.pipelineRunId !== void 0 ? { pipelineRunId: meta.pipelineRunId } : {},
+      ...meta.taskIds !== void 0 ? { taskIds: meta.taskIds } : {}
+    };
+    const combined = aggregateReports(reports, options);
+    await this.store.saveCombined(combined);
+    this.log.info(`Generated combined report ${combined.id}.`);
+    return combined;
+  }
+};
+
+// src/reports/store.ts
+import { mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+var FileReportStore = class {
+  filePath;
+  queue = Promise.resolve();
+  constructor(directory = `${process.cwd()}/.omninode`) {
+    this.filePath = `${directory}/reports.json`;
+  }
+  async saveReports(reports) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      for (const report of reports) {
+        const index = entries.findIndex(
+          (e) => e.kind === "report" && e.report.id === report.id
+        );
+        const entry2 = { kind: "report", report };
+        if (index >= 0) entries[index] = entry2;
+        else entries.push(entry2);
+      }
+      await this.write(entries);
+    });
+  }
+  async listReports(filter = {}) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      return entries.filter((e) => e.kind === "report").map((e) => e.report).filter((report) => filter.taskId ? report.taskId === filter.taskId : true).filter((report) => filter.agent ? report.agent === filter.agent : true).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    });
+  }
+  async saveCombined(combined) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      const index = entries.findIndex(
+        (e) => e.kind === "combined" && e.combined.id === combined.id
+      );
+      const entry2 = { kind: "combined", combined };
+      if (index >= 0) entries[index] = entry2;
+      else entries.push(entry2);
+      await this.write(entries);
+    });
+  }
+  async getCombined(id) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      const found = entries.find((e) => e.kind === "combined" && e.combined.id === id);
+      return found?.kind === "combined" ? found.combined : void 0;
+    });
+  }
+  async listCombined(filter = {}) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      return entries.filter((e) => e.kind === "combined").map((e) => e.combined).filter(
+        (combined) => filter.pipelineRunId ? combined.pipelineRunId === filter.pipelineRunId : true
+      ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    });
+  }
+  synchronized(operation) {
+    const result = this.queue.then(operation, operation);
+    this.queue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  async load() {
+    try {
+      const raw = await readFile2(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  async write(entries) {
+    const tmp = `${this.filePath}.tmp`;
+    await mkdir2(dirname2(this.filePath), { recursive: true });
+    await writeFile2(tmp, `${JSON.stringify(entries, null, 2)}
+`, "utf8");
+    await rename2(tmp, this.filePath);
+  }
+};
+
 // src/cli/commands/reports.ts
+function service() {
+  return new ReportService(new FileReportStore());
+}
 function registerReportCommands(program) {
-  const report = program.command("report").description("Inspect AI reports (Phase 6+).");
-  report.command("list").description("List collected reports (planned for Phase 6 \u2014 Multi-AI Report System).").action(() => {
-    throw notImplemented("omninode report list", "Phase 6 (Multi-AI Report System)");
+  const report = program.command("report").description("Inspect AI reports collected from tasks and pipelines (\xA716\u2013\xA717).");
+  report.command("list").description("List stored reports.").option("--task <taskId>", "Only reports for this task.").option("--agent <name>", "Only reports from this agent.").action(async (options) => {
+    const svc = service();
+    const reports = await svc.storeRef.listReports({
+      ...options.task !== void 0 ? { taskId: options.task } : {},
+      ...options.agent !== void 0 ? { agent: options.agent } : {}
+    });
+    if (reports.length === 0) {
+      console.log("No reports stored yet. Run a pipeline to collect some.");
+      return;
+    }
+    for (const r of reports) {
+      console.log(`${r.id}  ${r.agent.padEnd(10)} ${truncate(r.summary, 60)}`);
+    }
+  });
+  report.command("combined").description("List combined reports (aggregated intelligence, \xA717).").option("--run <pipelineRunId>", "Only combined reports for this pipeline run.").action(async (options) => {
+    const svc = service();
+    const combined = await svc.storeRef.listCombined({
+      ...options.run !== void 0 ? { pipelineRunId: options.run } : {}
+    });
+    if (combined.length === 0) {
+      console.log("No combined reports stored yet. Run a pipeline to generate one.");
+      return;
+    }
+    for (const c of combined) {
+      console.log(
+        `${c.id}  ${c.findings.length} finding(s) from ${c.sources.length} source(s)${c.pipelineRunId ? `  run=${c.pipelineRunId}` : ""}`
+      );
+    }
   });
+  report.command("show <id>").description("Show a stored report or combined report in full.").action(async (id) => {
+    const svc = service();
+    const reports = await svc.storeRef.listReports();
+    const raw = reports.find((r) => r.id === id);
+    if (raw) {
+      console.log(`Report ${raw.id}`);
+      console.log(`  agent:     ${raw.agent}${raw.model ? ` (${raw.model})` : ""}`);
+      console.log(`  task:      ${raw.taskId}`);
+      console.log(`  summary:   ${raw.summary}`);
+      if (raw.findings.length > 0) {
+        console.log("  findings:");
+        for (const finding of raw.findings) {
+          console.log(`    - [${finding.severity ?? "info"}] ${finding.title}`);
+          for (const evidence of finding.evidence ?? []) {
+            console.log(`      evidence: ${evidence}`);
+          }
+        }
+      }
+      if (raw.recommendations.length > 0) {
+        console.log("  recommendations:");
+        for (const recommendation of raw.recommendations) {
+          console.log(`    - ${recommendation}`);
+        }
+      }
+      return;
+    }
+    const combined = await svc.storeRef.getCombined(id);
+    if (combined) {
+      console.log(`Combined report ${combined.id}`);
+      console.log(`  sources:   ${combined.sources.join(", ")}`);
+      console.log(`  reports:   ${combined.reportIds.length}`);
+      if (combined.pipelineRunId) console.log(`  run:       ${combined.pipelineRunId}`);
+      console.log(`  summary:   ${combined.summary}`);
+      if (combined.findings.length > 0) {
+        console.log("  findings (grouped, duplicates merged):");
+        for (const finding of combined.findings) {
+          console.log(
+            `    - [${finding.severity ?? "info"}] ${finding.title} (x${finding.occurrences}, sources: ${finding.sources.map((s) => s.agent).join(", ")})`
+          );
+        }
+      }
+      if (combined.recommendations.length > 0) {
+        console.log("  recommendations:");
+        for (const recommendation of combined.recommendations) {
+          console.log(`    - ${recommendation.text} (x${recommendation.occurrences})`);
+        }
+      }
+      return;
+    }
+    throw new OmniNodeError("REPORT_NOT_FOUND", `Report "${id}" was not found in the report store.`);
+  });
+}
+
+// src/pipelines/engine.ts
+import { randomBytes as randomBytes3 } from "crypto";
+var PipelineEngine = class {
+  constructor(options) {
+    this.options = options;
+    this.log = (options.log ?? logger).child({ component: "pipelines" });
+  }
+  options;
+  log;
+  get store() {
+    return this.options.store;
+  }
+  /** Structural + semantic validation (§27 Phase 5 — pipeline parser). */
+  validate(def) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const step of def.steps) {
+      if (ids.has(step.id)) {
+        throw new PipelineError("PIPELINE_INVALID", `Duplicate step id "${step.id}".`);
+      }
+      ids.add(step.id);
+    }
+    for (const step of def.steps) {
+      for (const dep of step.dependsOn ?? []) {
+        if (!ids.has(dep)) {
+          throw new PipelineError(
+            "PIPELINE_INVALID",
+            `Step "${step.id}" depends on unknown step "${dep}".`
+          );
+        }
+      }
+      if (step.kind === "research" && (step.agents ?? []).length === 0) {
+        throw new PipelineError(
+          "PIPELINE_INVALID",
+          `Research step "${step.id}" needs at least one agent.`
+        );
+      }
+      if ((step.kind === "execute" || step.kind === "custom") && !step.agent) {
+        throw new PipelineError("PIPELINE_INVALID", `Step "${step.id}" (${step.kind}) needs an agent.`);
+      }
+    }
+    this.assertAcyclic(def);
+  }
+  assertAcyclic(def) {
+    const deps = this.effectiveDependencies(def);
+    const remaining = /* @__PURE__ */ new Map();
+    const dependents = /* @__PURE__ */ new Map();
+    for (const [id, list] of deps) {
+      remaining.set(id, list.length);
+      for (const d of list) {
+        dependents.set(d, [...dependents.get(d) ?? [], id]);
+      }
+    }
+    const queue = [...deps.keys()].filter((id) => (remaining.get(id) ?? 0) === 0);
+    let processed = 0;
+    while (queue.length > 0) {
+      const id = queue.shift();
+      processed += 1;
+      for (const next of dependents.get(id) ?? []) {
+        const left = (remaining.get(next) ?? 0) - 1;
+        remaining.set(next, left);
+        if (left === 0) queue.push(next);
+      }
+    }
+    if (processed < deps.size) {
+      const stuck = [...deps.keys()].filter((id) => (remaining.get(id) ?? 0) > 0);
+      throw new PipelineError(
+        "PIPELINE_INVALID",
+        `Pipeline "${def.id}" has a dependency cycle involving: ${stuck.join(", ")}.`
+      );
+    }
+  }
+  /**
+   * Steps run sequentially in definition order unless they declare explicit
+   * dependencies, which enable parallel branches.
+   */
+  effectiveDependencies(def) {
+    const deps = /* @__PURE__ */ new Map();
+    def.steps.forEach((step, index) => {
+      const explicit = step.dependsOn ?? [];
+      deps.set(
+        step.id,
+        explicit.length > 0 ? explicit : index > 0 ? [def.steps[index - 1].id] : []
+      );
+    });
+    return deps;
+  }
+  async run(def, options = {}) {
+    this.validate(def);
+    const objective = (options.objective ?? def.objective ?? "").trim();
+    if (objective.length === 0) {
+      throw new PipelineError(
+        "PIPELINE_INVALID",
+        `Pipeline "${def.id}" needs an objective \u2014 pass one or set it in the definition.`
+      );
+    }
+    const role = def.role ? this.options.roles.get(def.role) : void 0;
+    if (def.role && !role) {
+      throw new PipelineError(
+        "PIPELINE_INVALID",
+        `Role "${def.role}" (pipeline "${def.id}") is not defined in project.roles.`
+      );
+    }
+    for (const step of def.steps) {
+      for (const name of [...step.agents ?? [], ...step.agent ? [step.agent] : []]) {
+        if (!this.options.agents.get(name)) {
+          throw new PipelineError(
+            "PIPELINE_INVALID",
+            `Step "${step.id}" references unregistered agent "${name}".`
+          );
+        }
+      }
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const run2 = {
+      id: `run-${Date.now().toString(36)}-${randomBytes3(3).toString("hex")}`,
+      pipelineId: def.id,
+      status: "running",
+      startedAt: now,
+      stepRuns: []
+    };
+    await this.options.store.save(run2);
+    this.log.info(`Running pipeline ${def.id} as ${run2.id}.`);
+    const deps = this.effectiveDependencies(def);
+    const outcomes = /* @__PURE__ */ new Map();
+    const pending = new Set(def.steps.map((s) => s.id));
+    const contextParts = [];
+    const allReports = [];
+    while (pending.size > 0) {
+      const ready = def.steps.filter(
+        (step) => pending.has(step.id) && (deps.get(step.id) ?? []).every((d) => outcomes.has(d))
+      );
+      if (ready.length === 0) {
+        throw new PipelineError("PIPELINE_FAILED", `Pipeline "${def.id}" scheduling stalled.`);
+      }
+      const settled = await Promise.all(
+        ready.map(async (step) => {
+          if (!this.shouldRun(step, deps.get(step.id) ?? [], outcomes)) {
+            return { status: "skipped", summary: "", taskIds: [], reports: [] };
+          }
+          const ctx = {
+            objective,
+            ...role ? { role } : {},
+            combinedContext: contextParts.join("\n\n")
+          };
+          return this.executeStep(step, ctx);
+        })
+      );
+      ready.forEach((step, index) => {
+        const outcome = settled[index];
+        outcomes.set(step.id, outcome);
+        pending.delete(step.id);
+        allReports.push(...outcome.reports);
+        if (outcome.status !== "skipped" && outcome.summary.length > 0) {
+          const contribution = outcome.contextContribution ?? outcome.summary;
+          contextParts.push(`## Step "${step.id}" (${step.kind})
+${contribution}`);
+        }
+        const stepRun = {
+          stepId: step.id,
+          status: outcome.status === "skipped" ? "cancelled" : outcome.status === "failed" ? "failed" : "completed",
+          ...outcome.taskIds.length > 0 ? { taskIds: outcome.taskIds } : {},
+          ...outcome.error !== void 0 ? { error: outcome.error } : {}
+        };
+        run2.stepRuns.push(stepRun);
+        options.onStep?.(stepRun);
+      });
+      run2.reports = [...allReports];
+      await this.options.store.save(run2);
+    }
+    const failed = [...outcomes.values()].some((o) => o.status === "failed");
+    const finalStatus = failed ? "failed" : "completed";
+    let combinedReportId;
+    if (this.options.reports) {
+      const taskIds = [...outcomes.values()].flatMap((o) => o.taskIds);
+      const tasks = (await Promise.all(taskIds.map((id) => this.options.tasks.get(id)))).filter((task) => task !== void 0);
+      const collected = await this.options.reports.collectFromTasks(tasks);
+      await this.options.reports.saveReports(collected);
+      const combined = await this.options.reports.generateCombined(collected, {
+        objective,
+        pipelineRunId: run2.id,
+        taskIds
+      });
+      combinedReportId = combined?.id;
+      if (collected.length > 0) {
+        run2.reports = collected;
+      }
+    }
+    const finished = {
+      ...run2,
+      status: finalStatus,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...run2.reports !== void 0 && run2.reports.length > 0 ? { reports: run2.reports } : {},
+      ...combinedReportId !== void 0 ? { combinedReportId } : {}
+    };
+    await this.options.store.save(finished);
+    this.log.info(`Pipeline ${def.id} finished: ${finalStatus}.`);
+    return finished;
+  }
+  async get(runId) {
+    return this.options.store.get(runId);
+  }
+  async listRuns(filter) {
+    return this.options.store.list(filter);
+  }
+  shouldRun(step, deps, outcomes) {
+    const condition = step.condition ?? "on-success";
+    const depStatuses = deps.map((d) => outcomes.get(d)?.status);
+    const anyFailed = depStatuses.includes("failed");
+    const anySkipped = depStatuses.includes("skipped");
+    if (condition === "always") return true;
+    if (condition === "on-failure") return anyFailed;
+    return !anyFailed && !anySkipped;
+  }
+  async executeStep(step, ctx) {
+    const retries = step.retries ?? 0;
+    let last;
+    for (let attempt = 0; attempt <= retries; attempt += 1) {
+      if (attempt > 0) {
+        this.log.warn(`Step "${step.id}" failed \u2014 retry ${attempt}/${retries}.`);
+      }
+      last = await this.executeStepOnce(step, ctx);
+      if (last.status !== "failed") return last;
+    }
+    return last;
+  }
+  async executeStepOnce(step, ctx) {
+    switch (step.kind) {
+      case "research":
+        return this.runFanOut(step, ctx);
+      case "collect":
+        return { status: "completed", summary: "(collect: outputs gathered from previous steps)", taskIds: [], reports: [] };
+      case "analyze":
+        if (!step.agent) {
+          return { status: "completed", summary: "(analyze: pass-through, no agent assigned)", taskIds: [], reports: [] };
+        }
+        return this.runSingle(step, ctx, step.agent);
+      case "plan":
+        return this.runPlan(step, ctx);
+      case "execute":
+      case "custom":
+        return this.runSingle(step, ctx, step.agent);
+    }
+  }
+  /** Research fan-out: one task per agent, in parallel (§15). */
+  async runFanOut(step, ctx) {
+    const agentNames = step.agents ?? [];
+    const created = await Promise.all(
+      agentNames.map(
+        (name) => this.options.tasks.create({
+          objective: ctx.objective,
+          agent: name,
+          ...ctx.role ? { role: ctx.role.id } : {},
+          ...ctx.combinedContext.length > 0 ? { context: { background: ctx.combinedContext } } : {}
+        })
+      )
+    );
+    const results = await Promise.all(created.map((task) => this.options.tasks.run(task.id)));
+    const failedTasks = results.filter((r) => r.status !== "completed");
+    const lines = results.map((result, index) => {
+      const agentName = agentNames[index] ?? "unknown";
+      const outcome = result.result?.summary ?? result.result?.error ?? "(no output)";
+      return `- ${agentName}: ${outcome}`;
+    });
+    const reports = results.flatMap((r) => r.result?.reports ?? []);
+    const summary = lines.join("\n");
+    if (failedTasks.length > 0) {
+      const firstError = failedTasks[0]?.result?.error ?? "unknown error";
+      return {
+        status: "failed",
+        summary,
+        taskIds: created.map((t) => t.id),
+        error: `${failedTasks.length}/${results.length} task(s) failed \u2014 ${firstError}`,
+        reports
+      };
+    }
+    return { status: "completed", summary, taskIds: created.map((t) => t.id), reports };
+  }
+  async runSingle(step, ctx, agentName) {
+    const task = await this.options.tasks.create({
+      objective: ctx.objective,
+      agent: agentName,
+      ...ctx.role ? { role: ctx.role.id } : {},
+      ...ctx.combinedContext.length > 0 ? { context: { background: ctx.combinedContext } } : {}
+    });
+    const result = await this.options.tasks.run(task.id);
+    if (result.status !== "completed") {
+      return {
+        status: "failed",
+        summary: result.result?.summary ?? "",
+        taskIds: [task.id],
+        error: result.result?.error ?? `task ${task.id} did not complete`,
+        reports: result.result?.reports ?? []
+      };
+    }
+    return {
+      status: "completed",
+      summary: result.result?.summary ?? "(no output)",
+      taskIds: [task.id],
+      reports: result.result?.reports ?? []
+    };
+  }
+  async runPlan(step, ctx) {
+    if (!step.model) {
+      return { status: "completed", summary: "(plan: no model configured \u2014 skipped)", taskIds: [], reports: [] };
+    }
+    const messages = [
+      {
+        role: "system",
+        content: "You are a planning assistant inside OmniNode. Given the objective and the combined research context, produce a prioritized, actionable plan."
+      },
+      {
+        role: "user",
+        content: `# Objective
+${ctx.objective}
+
+${ctx.combinedContext}
+
+Produce the final plan.`
+      }
+    ];
+    try {
+      const planText = await this.getChat()(step.model, messages);
+      return {
+        status: "completed",
+        summary: planText.split("\n", 1)[0] ?? planText,
+        contextContribution: planText,
+        taskIds: [],
+        reports: []
+      };
+    } catch (error) {
+      return {
+        status: "failed",
+        summary: "",
+        taskIds: [],
+        error: error instanceof Error ? error.message : String(error),
+        reports: []
+      };
+    }
+  }
+  getChat() {
+    if (this.options.chat) return this.options.chat;
+    throw new PipelineError(
+      "PIPELINE_FAILED",
+      "No chat function available \u2014 configure a provider for plan steps."
+    );
+  }
+};
+function createDefaultChatFn(providers) {
+  return async (modelRef, messages) => {
+    const separator = modelRef.indexOf(":");
+    if (separator <= 0 || separator === modelRef.length - 1) {
+      throw new PipelineError(
+        "PIPELINE_INVALID",
+        `Invalid model reference "${modelRef}". Use "provider:model-id".`
+      );
+    }
+    const providerName = modelRef.slice(0, separator);
+    const modelId = modelRef.slice(separator + 1);
+    const providerConfig = providers.find((p) => p.name === providerName);
+    if (!providerConfig) {
+      throw new PipelineError(
+        "PIPELINE_INVALID",
+        `Provider "${providerName}" (model "${modelRef}") is not configured.`
+      );
+    }
+    const provider = createProvider(providerConfig);
+    const response = await provider.chat({ model: modelId, messages });
+    return response.content;
+  };
+}
+
+// src/pipelines/store.ts
+import { mkdir as mkdir3, readFile as readFile3, rename as rename3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+var FilePipelineRunStore = class {
+  filePath;
+  queue = Promise.resolve();
+  constructor(directory = `${process.cwd()}/.omninode`) {
+    this.filePath = `${directory}/pipelines.json`;
+  }
+  async save(run2) {
+    return this.synchronized(async () => {
+      const runs = await this.load();
+      const index = runs.findIndex((r) => r.id === run2.id);
+      if (index >= 0) runs[index] = run2;
+      else runs.push(run2);
+      await this.write(runs);
+    });
+  }
+  async get(id) {
+    return this.synchronized(async () => {
+      const runs = await this.load();
+      return runs.find((r) => r.id === id);
+    });
+  }
+  async list(filter = {}) {
+    return this.synchronized(async () => {
+      const runs = await this.load();
+      return runs.filter((run2) => filter.pipelineId ? run2.pipelineId === filter.pipelineId : true).filter((run2) => filter.status ? run2.status === filter.status : true).sort((a, b) => (a.startedAt ?? "").localeCompare(b.startedAt ?? ""));
+    });
+  }
+  synchronized(operation) {
+    const result = this.queue.then(operation, operation);
+    this.queue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  async load() {
+    try {
+      const raw = await readFile3(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  async write(runs) {
+    const tmp = `${this.filePath}.tmp`;
+    await mkdir3(dirname3(this.filePath), { recursive: true });
+    await writeFile3(tmp, `${JSON.stringify(runs, null, 2)}
+`, "utf8");
+    await rename3(tmp, this.filePath);
+  }
+};
+
+// src/pipelines/engine-factory.ts
+function buildPipelineEngine(config, log = logger) {
+  const agents = buildAgentRegistry(config, log);
+  const roles = buildRoleRegistry(config);
+  const tasks = new TaskEngine({
+    agents,
+    roles,
+    store: new FileTaskStore(),
+    log
+  });
+  return new PipelineEngine({
+    tasks,
+    agents,
+    roles,
+    providers: config.project.providers,
+    store: new FilePipelineRunStore(),
+    chat: createDefaultChatFn(config.project.providers),
+    reports: new ReportService(new FileReportStore(), log),
+    log
+  });
+}
+
+// src/cli/commands/pipelines.ts
+function registerPipelineCommands(program) {
+  const pipeline = program.command("pipeline").description("Run multi-step AI pipelines defined in omninode.yaml (\xA714).");
+  pipeline.command("list").description("List configured pipelines.").action(async () => {
+    const config = loadConfig();
+    const pipelines = config.project.pipelines;
+    if (pipelines.length === 0) {
+      console.log("No pipelines configured. Add one under `project.pipelines` in omninode.yaml.");
+      return;
+    }
+    for (const def of pipelines) {
+      const name = def.name ? `  ${def.name}` : "";
+      console.log(`${def.id}${name}  ${def.steps.length} step(s)`);
+    }
+  });
+  pipeline.command("run <id> [objective]").description(
+    "Run a pipeline. The objective argument overrides the definition's default objective."
+  ).action(async (id, objective) => {
+    const config = loadConfig();
+    const def = findPipeline(config, id);
+    const engine = buildPipelineEngine(config);
+    console.log(
+      `Running pipeline "${def.id}" (${def.steps.length} step(s))${objective ? ` \u2014 "${objective}"` : ""}...`
+    );
+    const finished = await engine.run(def, {
+      ...objective !== void 0 ? { objective } : {},
+      onStep: (stepRun) => {
+        const suffix = stepRun.error ? ` \u2014 ${stepRun.error}` : "";
+        console.log(`  [${stepRun.stepId}] ${stepRun.status}${suffix}`);
+      }
+    });
+    if (finished.reports && finished.reports.length > 0) {
+      console.log(`  reports: ${finished.reports.length} structured report(s)`);
+    }
+    if (finished.combinedReportId) {
+      console.log(`  combined report: ${finished.combinedReportId}`);
+    }
+    console.log(`Pipeline ${finished.status}. Run id: ${finished.id}`);
+    if (finished.status !== "completed") process.exitCode = 1;
+  });
+  pipeline.command("runs <id>").description("List recorded runs of a pipeline.").action(async (id) => {
+    const config = loadConfig();
+    const engine = buildPipelineEngine(config);
+    const runs = await engine.listRuns({ pipelineId: id });
+    if (runs.length === 0) {
+      console.log(`No recorded runs for pipeline "${id}".`);
+      return;
+    }
+    for (const run2 of runs) {
+      console.log(`${run2.id}  ${run2.status.padEnd(10)} ${run2.startedAt ?? "?"}`);
+    }
+  });
+  pipeline.command("status <run-id>").description("Show the recorded state of a pipeline run.").action(async (runId) => {
+    const config = loadConfig();
+    const engine = buildPipelineEngine(config);
+    const run2 = await engine.get(runId);
+    if (!run2) {
+      throw new PipelineError(
+        "PIPELINE_NOT_FOUND",
+        `Pipeline run "${runId}" does not exist in this project's run store.`
+      );
+    }
+    console.log(`  id:         ${run2.id}`);
+    console.log(`  pipeline:   ${run2.pipelineId}`);
+    console.log(`  status:     ${run2.status}`);
+    console.log(`  started:    ${run2.startedAt ?? "?"}`);
+    if (run2.finishedAt) console.log(`  finished:   ${run2.finishedAt}`);
+    for (const stepRun of run2.stepRuns) {
+      console.log(`  [${stepRun.stepId}] ${stepRun.status}`);
+    }
+    if (run2.reports && run2.reports.length > 0) {
+      console.log(`  reports:    ${run2.reports.length}`);
+    }
+  });
+}
+function findPipeline(config, id) {
+  const def = config.project.pipelines.find((p) => p.id === id);
+  if (!def) {
+    const available = config.project.pipelines.map((p) => p.id).join(", ") || "(none)";
+    throw new PipelineError(
+      "PIPELINE_NOT_FOUND",
+      `Pipeline "${id}" is not configured. Configured pipelines: ${available}.`
+    );
+  }
+  return def;
 }
 
 // src/cli/index.ts
@@ -1533,6 +2507,7 @@ function createProgram() {
   registerTaskCommands(program);
   registerReportCommands(program);
   registerModelsCommand(program);
+  registerPipelineCommands(program);
   return program;
 }
 async function run(argv) {