@hilbras/omninode 2.0.0-alpha.10 → 2.0.0-alpha.11

package/dist/index.js

@@ -166,7 +166,9 @@ var pipelineStepConfigSchema = z.object({
   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()
+  condition: z.enum(["always", "on-success", "on-failure"]).optional(),
+  /** Constraints passed to the planner for plan steps (§15). */
+  constraints: z.array(z.string()).optional()
 }).strict();
 var pipelineConfigSchema = z.object({
   id: z.string().min(1).regex(/^[a-z0-9][a-z0-9-]*$/, "pipeline id must be kebab-case"),
@@ -296,7 +298,8 @@ function toPipelineDefinition(raw) {
       model: step.model,
       dependsOn: step.depends_on,
       retries: step.retries,
-      condition: step.condition
+      condition: step.condition,
+      constraints: step.constraints
     }))
   };
 }
@@ -2580,10 +2583,98 @@ function createTaskEngine(config, log = logger, directory) {
 }
 
 // src/pipelines/engine.ts
-import { randomBytes as randomBytes4 } from "crypto";
+import { randomBytes as randomBytes5 } from "crypto";
 
-// src/planner/heuristic.ts
+// src/reports/aggregate.ts
 import { randomBytes as randomBytes2 } from "crypto";
+
+// src/reports/schema.ts
+import { z as z2 } from "zod";
+var evidenceSchema = z2.union([
+  z2.string().transform((excerpt) => ({ kind: "observation", excerpt })),
+  z2.object({
+    kind: z2.enum(["file", "line", "url", "command", "observation", "artifact"]),
+    ref: z2.string().optional(),
+    line: z2.number().int().optional(),
+    excerpt: z2.string().optional(),
+    agent: z2.string().optional()
+  })
+]);
+var findingSchema = z2.object({
+  id: z2.string().min(1),
+  title: z2.string().min(1),
+  detail: z2.string().default(""),
+  description: z2.string().optional(),
+  severity: z2.enum(["info", "low", "medium", "high", "critical"]).optional(),
+  confidence: z2.enum(["low", "medium", "high"]).optional(),
+  severityBySource: z2.record(z2.enum(["info", "low", "medium", "high", "critical"])).optional(),
+  confidenceBySource: z2.record(z2.enum(["low", "medium", "high"])).optional(),
+  recommendations: z2.array(z2.string()).optional(),
+  evidence: z2.array(evidenceSchema).optional(),
+  location: z2.string().optional(),
+  tags: z2.array(z2.string()).optional(),
+  source: z2.object({ agent: z2.string().optional(), reportId: z2.string().optional(), pipelineRunId: z2.string().optional() }).optional(),
+  recommendation: z2.string().optional()
+});
+var artifactSchema = z2.object({
+  kind: z2.enum(["file", "patch", "log", "screenshot", "document", "data"]),
+  ref: z2.string().min(1),
+  description: z2.string().optional(),
+  mediaType: z2.string().optional(),
+  bytes: z2.number().int().optional()
+});
+var reportSchema = z2.object({
+  id: z2.string().min(1),
+  taskId: z2.string().min(1),
+  agent: z2.string().min(1),
+  agentId: z2.string().optional(),
+  pipelineRunId: z2.string().optional(),
+  model: z2.string().optional(),
+  summary: z2.string(),
+  findings: z2.array(findingSchema),
+  recommendations: z2.array(z2.string()),
+  confidence: z2.enum(["low", "medium", "high"]).optional(),
+  evidence: z2.array(evidenceSchema).optional(),
+  artifacts: z2.array(artifactSchema).optional(),
+  createdAt: z2.string().min(1),
+  metadata: z2.record(z2.unknown()).optional()
+});
+function validateReport(value) {
+  const parsed = reportSchema.safeParse(value);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((issue) => ({
+      path: issue.path.join(".") || "(root)",
+      message: issue.message
+    }));
+    return {
+      valid: false,
+      issues,
+      reason: `report failed schema validation (${issues.length} issue(s))`
+    };
+  }
+  const report = parsed.data;
+  report.findings = report.findings.map((finding) => ({
+    ...finding,
+    description: finding.description ?? finding.detail,
+    ...finding.source === void 0 ? { source: { agent: report.agent, reportId: report.id, ...report.pipelineRunId !== void 0 ? { pipelineRunId: report.pipelineRunId } : {} } } : {}
+  }));
+  return { valid: true, report };
+}
+function normalizeEvidence(input) {
+  if (input === void 0) return void 0;
+  return input.map(
+    (item) => typeof item === "string" ? { kind: "observation", excerpt: item } : item
+  );
+}
+function normalizeFinding(finding) {
+  return {
+    ...finding,
+    description: finding.description ?? finding.detail,
+    evidence: normalizeEvidence(finding.evidence)
+  };
+}
+
+// src/reports/aggregate.ts
 var SEVERITY_RANK = {
   info: 0,
   low: 1,
@@ -2591,23 +2682,197 @@ var SEVERITY_RANK = {
   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 conflicts = detectConflicts(findingGroups);
+  const agreements = findingGroups.filter(
+    (group) => group.sources.length > 1 && group.severity !== void 0 && new Set(Object.values(group.severityBySource ?? {})).size === 1
+  );
+  const disputed = conflicts.length;
+  const summary = `${reports.length} report(s) from ${sources.length > 0 ? sources.join(", ") : "no agents"}: ${findingGroups.length} unique finding group(s) (${totalRawFindings} raw), ${agreements.length} agreement(s), ${disputed} conflict(s), ${recommendationGroups.length} recommendation group(s).`;
+  return {
+    id: `combined-${Date.now().toString(36)}-${randomBytes2(3).toString("hex")}`,
+    title: options.objective !== void 0 ? truncate(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)),
+    agreements,
+    conflicts,
+    recommendations: recommendationGroups,
+    sources,
+    reportIds: reports.map((r) => r.id),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    metadata: {
+      agents: sources.length,
+      reports: reports.length,
+      rawFindings: totalRawFindings,
+      findingGroups: findingGroups.length,
+      agreements: agreements.length,
+      conflicts: conflicts.length
+    }
+  };
+}
+function rankConfidence(confidence) {
+  return confidence ? { low: 1, medium: 2, high: 3 }[confidence] : 0;
+}
+function detectConflicts(groups) {
+  const conflicts = [];
+  for (const group of groups) {
+    if (group.sources.length < 2) continue;
+    const severities = new Set(Object.values(group.severityBySource ?? {}));
+    if (severities.size > 1) {
+      conflicts.push({
+        type: "severity",
+        findingTitle: group.title,
+        positions: group.sources.map((source) => position(source, group)),
+        note: `Agents disagree on severity (${[...severities].sort((a, b) => SEVERITY_RANK[a] - SEVERITY_RANK[b]).join(", ")}); the highest severity is shown, every position is preserved.`
+      });
+    }
+    const recommendations = (group.recommendations ?? []).filter((r) => r.length > 0);
+    if (recommendations.length > 1) {
+      conflicts.push({
+        type: "recommendation",
+        findingTitle: group.title,
+        positions: group.sources.map((source) => position(source, group)),
+        note: `Agents proposed ${recommendations.length} different fixes; none was discarded.`
+      });
+    }
+  }
+  return conflicts;
+}
+function position(source, group) {
+  return {
+    agent: source.agent,
+    reportId: source.reportId,
+    ...group.severityBySource?.[source.agent] !== void 0 ? { severity: group.severityBySource[source.agent] } : {},
+    ...group.confidenceBySource?.[source.agent] !== void 0 ? { confidence: group.confidenceBySource[source.agent] } : {},
+    ...group.recommendations?.[0] !== void 0 ? { recommendation: group.recommendations[0] } : {}
+  };
+}
+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(...normalizeEvidence(finding.evidence) ?? []);
+    if (finding.severity && (!group.severity || SEVERITY_RANK[finding.severity] > SEVERITY_RANK[group.severity])) {
+      group.severity = finding.severity;
+    }
+    if (finding.confidence && rankConfidence(finding.confidence) > rankConfidence(group.confidence)) {
+      group.confidence = finding.confidence;
+    }
+    if (finding.severity) {
+      group.severityBySource = { ...group.severityBySource, [report.agent]: finding.severity };
+    }
+    if (finding.confidence) {
+      group.confidenceBySource = { ...group.confidenceBySource, [report.agent]: finding.confidence };
+    }
+    if (finding.recommendation && !group.recommendations?.includes(finding.recommendation)) {
+      group.recommendations = [...group.recommendations ?? [], finding.recommendation];
+    }
+    return;
+  }
+  groups.push({
+    title: finding.title,
+    details: [finding.detail],
+    sources: [source],
+    occurrences: 1,
+    ...finding.severity ? { severity: finding.severity } : {},
+    ...finding.confidence ? { confidence: finding.confidence } : {},
+    ...finding.severity ? { severityBySource: { [report.agent]: finding.severity } } : {},
+    ...finding.confidence ? { confidenceBySource: { [report.agent]: finding.confidence } } : {},
+    ...finding.recommendation ? { recommendations: [finding.recommendation] } : {},
+    evidence: [...normalizeEvidence(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 truncate(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+
+// src/planner/heuristic.ts
+import { randomBytes as randomBytes3 } from "crypto";
+var SEVERITY_RANK2 = {
+  info: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  critical: 4
+};
 var HeuristicPlanner = class {
   name = "heuristic";
   async plan(request) {
     const steps = [];
-    const findings = request.reports.flatMap(
-      (report) => report.findings.map((finding) => ({ finding, agent: report.agent }))
-    );
     const recommendations = dedupe(request.reports.flatMap((r) => r.recommendations));
-    for (const [index, text] of recommendations.entries()) {
+    for (const text of recommendations) {
       steps.push({
         id: `step-${steps.length + 1}`,
-        title: truncate(text, 120),
+        title: truncate2(text, 120),
         order: steps.length + 1,
-        ...index > 0 ? { dependsOn: [`step-${steps.length}`] } : {}
+        ...steps.length > 0 ? { dependsOn: [`step-${steps.length}`] } : {}
       });
     }
-    const significant = findings.filter(({ finding }) => finding.severity ? SEVERITY_RANK[finding.severity] >= SEVERITY_RANK.high : false).sort((a, b) => SEVERITY_RANK[b.finding.severity ?? "info"] - SEVERITY_RANK[a.finding.severity ?? "info"]);
+    const contributed = request.aggregated ? request.aggregated.findings.map((finding) => ({
+      finding: {
+        id: `agg-${slug(finding.title)}`,
+        title: finding.title,
+        detail: finding.details[0] ?? finding.title,
+        ...finding.severity ? { severity: finding.severity } : {},
+        ...finding.recommendations && finding.recommendations.length > 0 ? { recommendation: finding.recommendations[0] } : {}
+      },
+      agent: finding.sources.map((s) => s.agent).join("+")
+    })) : request.reports.flatMap(
+      (report) => report.findings.map((finding) => ({ finding, agent: report.agent }))
+    );
+    const significant = contributed.filter(
+      ({ finding }) => finding.severity ? SEVERITY_RANK2[finding.severity] >= SEVERITY_RANK2.high : false
+    ).sort(
+      (a, b) => SEVERITY_RANK2[b.finding.severity ?? "info"] - SEVERITY_RANK2[a.finding.severity ?? "info"]
+    );
     for (const { finding } of significant) {
       steps.push(remediationStep(finding, steps.length + 1));
     }
@@ -2620,12 +2885,20 @@ var HeuristicPlanner = class {
       });
     }
     const risks = significant.filter(({ finding }) => finding.severity === "critical").map(({ finding }) => `Critical finding unaddressed until its step completes: ${finding.title}`);
+    const conflicts = request.aggregated?.conflicts ?? [];
+    if (conflicts.length > 0) {
+      risks.push(
+        `${conflicts.length} unresolved agent disagreement(s): ${conflicts.map((c) => c.findingTitle).join("; ")}`
+      );
+    }
     return {
-      id: `plan-${Date.now().toString(36)}-${randomBytes2(3).toString("hex")}`,
+      id: `plan-${Date.now().toString(36)}-${randomBytes3(3).toString("hex")}`,
       objective: request.objective,
+      goal: request.aggregated?.title ?? truncate2(request.objective, 120),
       summary: `Derived from ${request.reports.length} report(s): ${recommendations.length} recommendation step(s), ${significant.length} remediation step(s).`,
       steps,
       ...risks.length > 0 ? { risks } : {},
+      ...request.constraints !== void 0 && request.constraints.length > 0 ? { constraints: request.constraints } : {},
       generatedBy: "heuristic",
       ...request.taskId !== void 0 ? { taskId: request.taskId } : {},
       ...request.pipelineRunId !== void 0 ? { pipelineRunId: request.pipelineRunId } : {},
@@ -2636,28 +2909,80 @@ var HeuristicPlanner = class {
 function remediationStep(finding, order) {
   return {
     id: `step-${order}`,
-    title: `Fix: ${truncate(finding.title, 100)}`,
+    title: `Fix: ${truncate2(finding.title, 100)}`,
     description: finding.detail,
     order,
     dependsOn: order > 1 ? [`step-${order - 1}`] : [],
-    sourceFindings: [finding.id]
+    sourceFindings: [finding.id],
+    ...finding.recommendation ? { recommendation: finding.recommendation } : {}
   };
 }
 function dedupe(texts) {
   return [...new Set(texts.map((t) => t.trim()).filter((t) => t.length > 0))];
 }
-function truncate(text, max) {
+function slug(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+}
+function truncate2(text, max) {
   return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
 }
 
 // src/planner/model.ts
-import { randomBytes as randomBytes3 } from "crypto";
-import { z as z2 } from "zod";
+import { randomBytes as randomBytes4 } from "crypto";
+
+// src/planner/schema.ts
+import { z as z3 } from "zod";
+var planStepSchema = z3.object({
+  id: z3.string().min(1).optional(),
+  title: z3.string().min(1),
+  description: z3.string().optional(),
+  order: z3.number().int().optional(),
+  targets: z3.array(z3.string()).optional(),
+  acceptance_criteria: z3.array(z3.string()).optional(),
+  depends_on: z3.array(z3.string()).optional(),
+  source_findings: z3.array(z3.string()).optional()
+});
+var planJsonSchema = z3.object({
+  goal: z3.string().min(1),
+  summary: z3.string().min(1),
+  steps: z3.array(planStepSchema).min(1),
+  risks: z3.array(z3.string()).optional(),
+  notes: z3.array(z3.string()).optional()
+});
+function validatePlan(plan) {
+  const issues = [];
+  const stepIds = /* @__PURE__ */ new Set();
+  for (const [index, step] of plan.steps.entries()) {
+    if (stepIds.has(step.id)) {
+      issues.push({ path: `steps.${index}.id`, message: `duplicate step id "${step.id}"` });
+    }
+    stepIds.add(step.id);
+    if (!step.title || step.title.trim().length === 0) {
+      issues.push({ path: `steps.${index}.title`, message: "title must not be empty" });
+    }
+    for (const dep of step.dependsOn ?? []) {
+      if (!stepIds.has(dep) && !plan.steps.some((s) => s.id === dep)) {
+        issues.push({ path: `steps.${index}.dependsOn`, message: `unknown step dependency "${dep}"` });
+      }
+    }
+  }
+  if (plan.steps.length === 0) {
+    issues.push({ path: "steps", message: "a plan needs at least one step" });
+  }
+  if (!plan.summary || plan.summary.trim().length === 0) {
+    issues.push({ path: "summary", message: "summary must not be empty" });
+  }
+  return issues.length > 0 ? { valid: false, issues, reason: `plan failed validation (${issues.length} issue(s))` } : { valid: true, plan };
+}
 
 // src/planner/context.ts
 function buildPlannerContext(request) {
-  const parts = [`# Objective
+  const parts = [`# Task
 ${request.objective}`];
+  if (request.projectContext) {
+    parts.push(`# Project context
+${request.projectContext}`);
+  }
   if (request.role) {
     const roleLines = [`# Role
 ${request.role.name} (${request.role.id})`];
@@ -2677,7 +3002,7 @@ ${request.role.name} (${request.role.id})`];
       )
     );
     parts.push(
-      `# Findings (${request.reports.length} report(s) by ${agents})
+      `# Agent reports (${request.reports.length} by ${agents})
 ` + (findingLines.length > 0 ? findingLines.join("\n") : "(no findings reported)")
     );
     const recommendationLines = request.reports.flatMap(
@@ -2687,9 +3012,20 @@ ${request.role.name} (${request.role.id})`];
       parts.push(`# Recommendations
 ${recommendationLines.join("\n")}`);
     }
-    const summaryLines = request.reports.map((report) => `- [${report.agent}] ${report.summary}`);
-    parts.push(`# Report summaries
-${summaryLines.join("\n")}`);
+  }
+  if (request.aggregated) {
+    const aggregatedLines = [
+      `- findings: ${request.aggregated.findings.length} (agreements: ${request.aggregated.agreements.length}, conflicts: ${request.aggregated.conflicts.length})`,
+      ...request.aggregated.findings.map(
+        (finding) => `- [${finding.severity ?? "info"}] ${finding.title} (x${finding.occurrences})`
+      ),
+      // Conflicts stay visible to the planner — it must plan around disagreement.
+      ...request.aggregated.conflicts.map(
+        (conflict) => `- CONFLICT (${conflict.type}) on "${conflict.findingTitle}": ${conflict.note}`
+      )
+    ];
+    parts.push(`# Aggregated findings
+${aggregatedLines.join("\n")}`);
   }
   if (request.memory && request.memory.length > 0) {
     parts.push(
@@ -2697,7 +3033,11 @@ ${summaryLines.join("\n")}`);
 ` + request.memory.map((entry) => `- [${entry.scope}] ${entry.content}`).join("\n")
     );
   }
-  if (request.context && request.context.length > 0) {
+  if (request.constraints && request.constraints.length > 0) {
+    parts.push(`# Constraints
+${request.constraints.map((c) => `- ${c}`).join("\n")}`);
+  }
+  if (request.context) {
     parts.push(`# Research context
 ${request.context}`);
   }
@@ -2705,22 +3045,6 @@ ${request.context}`);
 }
 
 // src/planner/model.ts
-var planStepJsonSchema = z2.object({
-  id: z2.string().optional(),
-  title: z2.string().min(1),
-  description: z2.string().optional(),
-  order: z2.number().int().optional(),
-  targets: z2.array(z2.string()).optional(),
-  acceptance_criteria: z2.array(z2.string()).optional(),
-  depends_on: z2.array(z2.string()).optional(),
-  source_findings: z2.array(z2.string()).optional()
-}).strict();
-var planJsonSchema = z2.object({
-  summary: z2.string().min(1),
-  steps: z2.array(planStepJsonSchema).min(1),
-  risks: z2.array(z2.string()).optional(),
-  notes: z2.array(z2.string()).optional()
-}).strict();
 var ModelPlanner = class {
   constructor(options) {
     this.options = options;
@@ -2734,7 +3058,7 @@ var ModelPlanner = class {
     const messages = [
       {
         role: "system",
-        content: 'You are the OmniNode planner. Given the objective and the combined research context, produce a final analysis and a prioritized, actionable implementation plan. Respond with JSON ONLY (no prose, no code fences) matching exactly this shape: {"summary": string, "steps": [{"id": string, "title": string, "description": string, "order": number, "targets": string[], "acceptance_criteria": string[], "source_findings": string[]}], "risks": string[], "notes": string[]}. ' + (this.options.instruction ?? "")
+        content: 'You are the OmniNode planner. Given the objective and the combined research context, produce a final analysis and a prioritized, actionable implementation plan. Respond with JSON ONLY (no prose, no code fences) matching exactly this shape: {"goal": string, "summary": string, "steps": [{"id": string, "title": string, "description": string, "order": number, "targets": string[], "acceptance_criteria": string[], "source_findings": string[]}], "risks": string[], "notes": string[]}. ' + (this.options.instruction ?? "")
       },
       { role: "user", content: context }
     ];
@@ -2745,60 +3069,86 @@ var ModelPlanner = class {
       return this.degrade(request, `planner model call failed: ${describe(error)}`);
     }
     const parsed = parsePlanJson(responseText);
-    if (!parsed) {
-      return this.degrade(request, "planner model output was not valid plan JSON");
+    if (!parsed.ok) {
+      return this.degrade(request, `planner model output rejected: ${parsed.reason}`, parsed.issues);
     }
     const plan = {
-      id: `plan-${Date.now().toString(36)}-${randomBytes3(3).toString("hex")}`,
+      id: `plan-${Date.now().toString(36)}-${randomBytes4(3).toString("hex")}`,
       objective: request.objective,
+      goal: parsed.goal,
       summary: parsed.summary,
       steps: parsed.steps,
       ...parsed.risks !== void 0 ? { risks: parsed.risks } : {},
       ...parsed.notes !== void 0 ? { notes: parsed.notes } : {},
+      ...request.constraints !== void 0 && request.constraints.length > 0 ? { constraints: request.constraints } : {},
       generatedBy: `model:${this.options.model}`,
       model: this.options.model,
       ...request.taskId !== void 0 ? { taskId: request.taskId } : {},
       ...request.pipelineRunId !== void 0 ? { pipelineRunId: request.pipelineRunId } : {},
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    return plan;
+    const validation = validatePlan(plan);
+    if (!validation.valid) {
+      return this.degrade(request, `generated plan rejected: ${validation.reason}`, validation.issues);
+    }
+    return validation.plan;
   }
-  async degrade(request, reason) {
+  async degrade(request, reason, issues = []) {
     if (this.options.fallback) {
       this.log.warn(`${reason} \u2014 using the heuristic fallback planner.`);
       return this.options.fallback.plan(request);
     }
-    throw new PlannerError("PLANNER_FAILED", `Planner failed: ${reason}.`);
+    throw new PlannerError("PLAN_INVALID", `Planner failed: ${reason}.`, {
+      details: { reason, issues }
+    });
   }
 };
 function parsePlanJson(text) {
   const unfenced = text.replace(/```(?:json)?/gi, "");
   const start = unfenced.indexOf("{");
   const end = unfenced.lastIndexOf("}");
-  if (start < 0 || end <= start) return void 0;
+  if (start < 0 || end <= start) {
+    return { ok: false, reason: "planner output contained no JSON object", issues: [] };
+  }
+  let json;
   try {
-    const json = JSON.parse(unfenced.slice(start, end + 1));
-    const parsed = planJsonSchema.safeParse(json);
-    if (!parsed.success) return void 0;
-    const steps = parsed.data.steps.map((step, index) => ({
-      id: step.id ?? `step-${index + 1}`,
-      title: step.title,
-      description: step.description,
-      order: step.order ?? index + 1,
-      targets: step.targets,
-      acceptanceCriteria: step.acceptance_criteria,
-      dependsOn: step.depends_on,
-      sourceFindings: step.source_findings
-    }));
+    json = JSON.parse(unfenced.slice(start, end + 1));
+  } catch (error) {
     return {
-      summary: parsed.data.summary,
-      steps: steps.sort((a, b) => a.order - b.order),
-      risks: parsed.data.risks,
-      notes: parsed.data.notes
+      ok: false,
+      reason: `planner output was not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      issues: []
+    };
+  }
+  const parsed = planJsonSchema.safeParse(json);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      reason: "planner output did not match the plan schema",
+      issues: parsed.error.issues.map((issue) => ({
+        path: issue.path.join(".") || "(root)",
+        message: issue.message
+      }))
     };
-  } catch {
-    return void 0;
   }
+  const steps = parsed.data.steps.map((step, index) => ({
+    id: step.id ?? `step-${index + 1}`,
+    title: step.title,
+    description: step.description,
+    order: step.order ?? index + 1,
+    targets: step.targets,
+    acceptanceCriteria: step.acceptance_criteria,
+    dependsOn: step.depends_on,
+    sourceFindings: step.source_findings
+  })).sort((a, b) => a.order - b.order);
+  return {
+    ok: true,
+    goal: parsed.data.goal,
+    summary: parsed.data.summary,
+    steps,
+    risks: parsed.data.risks,
+    notes: parsed.data.notes
+  };
 }
 function describe(error) {
   return error instanceof Error ? error.message : String(error);
@@ -2947,7 +3297,7 @@ var PipelineEngine = class {
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const run = {
-      id: `run-${Date.now().toString(36)}-${randomBytes4(3).toString("hex")}`,
+      id: `run-${Date.now().toString(36)}-${randomBytes5(3).toString("hex")}`,
       pipelineId: def.id,
       attempt: 1,
       objective,
@@ -3236,11 +3586,14 @@ ${contribution}`);
     };
   }
   async runPlan(step, ctx) {
+    const aggregated = ctx.reports.length > 0 ? aggregateReports(ctx.reports) : void 0;
     const request = {
       objective: ctx.objective,
       reports: ctx.reports,
+      ...aggregated !== void 0 ? { aggregated } : {},
       ...ctx.combinedContext.length > 0 ? { context: ctx.combinedContext } : {},
       ...ctx.role ? { role: ctx.role } : {},
+      ...step.constraints !== void 0 && step.constraints.length > 0 ? { constraints: step.constraints } : {},
       ...ctx.pipelineRunId !== void 0 ? { pipelineRunId: ctx.pipelineRunId } : {}
     };
     let planner;
@@ -3399,255 +3752,6 @@ function buildPlanner(plannerConfig, chat, log = logger) {
   });
 }
 
-// src/reports/aggregate.ts
-import { randomBytes as randomBytes5 } from "crypto";
-
-// src/reports/schema.ts
-import { z as z3 } from "zod";
-var evidenceSchema = z3.union([
-  z3.string().transform((excerpt) => ({ kind: "observation", excerpt })),
-  z3.object({
-    kind: z3.enum(["file", "line", "url", "command", "observation", "artifact"]),
-    ref: z3.string().optional(),
-    line: z3.number().int().optional(),
-    excerpt: z3.string().optional(),
-    agent: z3.string().optional()
-  })
-]);
-var findingSchema = z3.object({
-  id: z3.string().min(1),
-  title: z3.string().min(1),
-  detail: z3.string().default(""),
-  description: z3.string().optional(),
-  severity: z3.enum(["info", "low", "medium", "high", "critical"]).optional(),
-  confidence: z3.enum(["low", "medium", "high"]).optional(),
-  severityBySource: z3.record(z3.enum(["info", "low", "medium", "high", "critical"])).optional(),
-  confidenceBySource: z3.record(z3.enum(["low", "medium", "high"])).optional(),
-  recommendations: z3.array(z3.string()).optional(),
-  evidence: z3.array(evidenceSchema).optional(),
-  location: z3.string().optional(),
-  tags: z3.array(z3.string()).optional(),
-  source: z3.object({ agent: z3.string().optional(), reportId: z3.string().optional(), pipelineRunId: z3.string().optional() }).optional(),
-  recommendation: z3.string().optional()
-});
-var artifactSchema = z3.object({
-  kind: z3.enum(["file", "patch", "log", "screenshot", "document", "data"]),
-  ref: z3.string().min(1),
-  description: z3.string().optional(),
-  mediaType: z3.string().optional(),
-  bytes: z3.number().int().optional()
-});
-var reportSchema = z3.object({
-  id: z3.string().min(1),
-  taskId: z3.string().min(1),
-  agent: z3.string().min(1),
-  agentId: z3.string().optional(),
-  pipelineRunId: z3.string().optional(),
-  model: z3.string().optional(),
-  summary: z3.string(),
-  findings: z3.array(findingSchema),
-  recommendations: z3.array(z3.string()),
-  confidence: z3.enum(["low", "medium", "high"]).optional(),
-  evidence: z3.array(evidenceSchema).optional(),
-  artifacts: z3.array(artifactSchema).optional(),
-  createdAt: z3.string().min(1),
-  metadata: z3.record(z3.unknown()).optional()
-});
-function validateReport(value) {
-  const parsed = reportSchema.safeParse(value);
-  if (!parsed.success) {
-    const issues = parsed.error.issues.map((issue) => ({
-      path: issue.path.join(".") || "(root)",
-      message: issue.message
-    }));
-    return {
-      valid: false,
-      issues,
-      reason: `report failed schema validation (${issues.length} issue(s))`
-    };
-  }
-  const report = parsed.data;
-  report.findings = report.findings.map((finding) => ({
-    ...finding,
-    description: finding.description ?? finding.detail,
-    ...finding.source === void 0 ? { source: { agent: report.agent, reportId: report.id, ...report.pipelineRunId !== void 0 ? { pipelineRunId: report.pipelineRunId } : {} } } : {}
-  }));
-  return { valid: true, report };
-}
-function normalizeEvidence(input) {
-  if (input === void 0) return void 0;
-  return input.map(
-    (item) => typeof item === "string" ? { kind: "observation", excerpt: item } : item
-  );
-}
-function normalizeFinding(finding) {
-  return {
-    ...finding,
-    description: finding.description ?? finding.detail,
-    evidence: normalizeEvidence(finding.evidence)
-  };
-}
-
-// src/reports/aggregate.ts
-var SEVERITY_RANK2 = {
-  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 conflicts = detectConflicts(findingGroups);
-  const agreements = findingGroups.filter(
-    (group) => group.sources.length > 1 && group.severity !== void 0 && new Set(Object.values(group.severityBySource ?? {})).size === 1
-  );
-  const disputed = conflicts.length;
-  const summary = `${reports.length} report(s) from ${sources.length > 0 ? sources.join(", ") : "no agents"}: ${findingGroups.length} unique finding group(s) (${totalRawFindings} raw), ${agreements.length} agreement(s), ${disputed} conflict(s), ${recommendationGroups.length} recommendation group(s).`;
-  return {
-    id: `combined-${Date.now().toString(36)}-${randomBytes5(3).toString("hex")}`,
-    title: options.objective !== void 0 ? truncate2(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)),
-    agreements,
-    conflicts,
-    recommendations: recommendationGroups,
-    sources,
-    reportIds: reports.map((r) => r.id),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    metadata: {
-      agents: sources.length,
-      reports: reports.length,
-      rawFindings: totalRawFindings,
-      findingGroups: findingGroups.length,
-      agreements: agreements.length,
-      conflicts: conflicts.length
-    }
-  };
-}
-function rankConfidence(confidence) {
-  return confidence ? { low: 1, medium: 2, high: 3 }[confidence] : 0;
-}
-function detectConflicts(groups) {
-  const conflicts = [];
-  for (const group of groups) {
-    if (group.sources.length < 2) continue;
-    const severities = new Set(Object.values(group.severityBySource ?? {}));
-    if (severities.size > 1) {
-      conflicts.push({
-        type: "severity",
-        findingTitle: group.title,
-        positions: group.sources.map((source) => position(source, group)),
-        note: `Agents disagree on severity (${[...severities].sort((a, b) => SEVERITY_RANK2[a] - SEVERITY_RANK2[b]).join(", ")}); the highest severity is shown, every position is preserved.`
-      });
-    }
-    const recommendations = (group.recommendations ?? []).filter((r) => r.length > 0);
-    if (recommendations.length > 1) {
-      conflicts.push({
-        type: "recommendation",
-        findingTitle: group.title,
-        positions: group.sources.map((source) => position(source, group)),
-        note: `Agents proposed ${recommendations.length} different fixes; none was discarded.`
-      });
-    }
-  }
-  return conflicts;
-}
-function position(source, group) {
-  return {
-    agent: source.agent,
-    reportId: source.reportId,
-    ...group.severityBySource?.[source.agent] !== void 0 ? { severity: group.severityBySource[source.agent] } : {},
-    ...group.confidenceBySource?.[source.agent] !== void 0 ? { confidence: group.confidenceBySource[source.agent] } : {},
-    ...group.recommendations?.[0] !== void 0 ? { recommendation: group.recommendations[0] } : {}
-  };
-}
-function rank(finding) {
-  return finding.severity ? SEVERITY_RANK2[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(...normalizeEvidence(finding.evidence) ?? []);
-    if (finding.severity && (!group.severity || SEVERITY_RANK2[finding.severity] > SEVERITY_RANK2[group.severity])) {
-      group.severity = finding.severity;
-    }
-    if (finding.confidence && rankConfidence(finding.confidence) > rankConfidence(group.confidence)) {
-      group.confidence = finding.confidence;
-    }
-    if (finding.severity) {
-      group.severityBySource = { ...group.severityBySource, [report.agent]: finding.severity };
-    }
-    if (finding.confidence) {
-      group.confidenceBySource = { ...group.confidenceBySource, [report.agent]: finding.confidence };
-    }
-    if (finding.recommendation && !group.recommendations?.includes(finding.recommendation)) {
-      group.recommendations = [...group.recommendations ?? [], finding.recommendation];
-    }
-    return;
-  }
-  groups.push({
-    title: finding.title,
-    details: [finding.detail],
-    sources: [source],
-    occurrences: 1,
-    ...finding.severity ? { severity: finding.severity } : {},
-    ...finding.confidence ? { confidence: finding.confidence } : {},
-    ...finding.severity ? { severityBySource: { [report.agent]: finding.severity } } : {},
-    ...finding.confidence ? { confidenceBySource: { [report.agent]: finding.confidence } } : {},
-    ...finding.recommendation ? { recommendations: [finding.recommendation] } : {},
-    evidence: [...normalizeEvidence(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 truncate2(text, max) {
-  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
-}
-
 // src/reports/extract.ts
 var BULLET = /^(?:[-*•]|\d+[.)])\s+(.*)$/;
 function parseSections(raw) {
@@ -3874,7 +3978,7 @@ var ProjectStores = class {
 };
 
 // src/version.ts
-var OMNINODE_VERSION = "2.0.0-alpha.10";
+var OMNINODE_VERSION = "2.0.0-alpha.11";
 export {
   AgentAdapterRegistry,
   AgentError,
@@ -3969,6 +4073,7 @@ export {
   parseRetryAfter,
   pipelineConfigSchema,
   pipelineStepConfigSchema,
+  planJsonSchema,
   plannerConfigSchema,
   projectConfigSchema,
   providerConfigSchema,
@@ -3983,6 +4088,7 @@ export {
   sanitizeChunk,
   similar,
   validateEnvelope,
+  validatePlan,
   validateReport,
   validateWorkingDirectory
 };