@hilbras/omninode 0.8.0 → 0.10.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.8.0";
+var OMNINODE_VERSION = "0.10.0";
 
 // src/errors/index.ts
 var OmniNodeError = class extends Error {
@@ -49,6 +49,11 @@ var ProtocolError = class extends OmniNodeError {
     super("PROTOCOL_VIOLATION", message, options);
   }
 };
+var PlannerError = class extends OmniNodeError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+  }
+};
 var MemoryError = class extends OmniNodeError {
   constructor(message, options = {}) {
     super("MEMORY_UNAVAILABLE", message, options);
@@ -111,12 +116,18 @@ var pipelineConfigSchema = z.object({
   role: z.string().optional(),
   steps: z.array(pipelineStepConfigSchema).min(1)
 }).strict();
+var plannerConfigSchema = z.object({
+  kind: z.enum(["model", "heuristic"]).default("model"),
+  model: z.string().optional(),
+  instruction: z.string().optional()
+}).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([]),
+  planner: plannerConfigSchema.optional(),
   memory: z.object({
     provider: z.string().min(1).default("local"),
     base_url: z.string().url().optional(),
@@ -191,6 +202,13 @@ function toAppConfig(yaml) {
       agents: yaml.project.agents.map(toAgentConfig),
       roles: yaml.project.roles.map(toRoleDefinition),
       pipelines: yaml.project.pipelines.map(toPipelineDefinition),
+      ...yaml.project.planner !== void 0 ? {
+        planner: {
+          kind: yaml.project.planner.kind,
+          model: yaml.project.planner.model,
+          instruction: yaml.project.planner.instruction
+        }
+      } : {},
       ...yaml.project.memory !== void 0 ? {
         memory: {
           provider: yaml.project.memory.provider,
@@ -1457,6 +1475,25 @@ var TaskEngine = class {
     }
     return this.transition(task, "cancelled");
   }
+  /** Error recovery (§27 Phase 9): reset a failed/cancelled task so it can run again. */
+  async retry(id) {
+    const task = await this.mustGet(id);
+    if (task.status !== "failed" && task.status !== "cancelled") {
+      throw new TaskError(
+        "TASK_INVALID",
+        `Only failed or cancelled tasks can be retried \u2014 task ${id} is "${task.status}".`
+      );
+    }
+    const { result: _discarded, ...rest } = task;
+    const reset = {
+      ...rest,
+      status: "created",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.options.store.save(reset);
+    this.log.info(`Task ${id} reset for retry.`);
+    return reset;
+  }
   async get(id) {
     return this.options.store.get(id);
   }
@@ -1876,6 +1913,17 @@ function registerTaskCommands(program) {
     const cancelled = await engine.cancel(taskId);
     console.log(`Task ${cancelled.id} is now "${cancelled.status}".`);
   });
+  task.command("retry <task-id>").description("Reset a failed/cancelled task to created; combine with --run to execute it again.").option("--run", "Run the task again immediately after resetting it.").action(async (taskId, options) => {
+    const config = loadConfig();
+    const engine = createTaskEngine(config);
+    const reset = await engine.retry(taskId);
+    console.log(`Task ${reset.id} reset to "${reset.status}".`);
+    if (!options.run) return;
+    console.log(`Running task ${reset.id}...`);
+    const finished = await engine.run(reset.id);
+    printOutcome(finished);
+    if (finished.status !== "completed") process.exitCode = 1;
+  });
 }
 function printOutcome(task, options = {}) {
   console.log(`  id:      ${task.id}`);
@@ -2282,7 +2330,231 @@ function registerReportCommands(program) {
 }
 
 // src/pipelines/engine.ts
+import { randomBytes as randomBytes5 } from "crypto";
+
+// 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()) {
+      steps.push({
+        id: `step-${steps.length + 1}`,
+        title: truncate5(text, 120),
+        order: steps.length + 1,
+        ...index > 0 ? { dependsOn: [`step-${steps.length}`] } : {}
+      });
+    }
+    const significant = findings.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));
+    }
+    if (steps.length === 0) {
+      steps.push({
+        id: "step-1",
+        title: "Gather additional information",
+        description: "The research reports contained no actionable recommendations or significant findings. Investigate the objective further before planning implementation work.",
+        order: 1
+      });
+    }
+    const risks = significant.filter(({ finding }) => finding.severity === "critical").map(({ finding }) => `Critical finding unaddressed until its step completes: ${finding.title}`);
+    return {
+      id: `plan-${Date.now().toString(36)}-${randomBytes3(3).toString("hex")}`,
+      objective: request.objective,
+      summary: `Derived from ${request.reports.length} report(s): ${recommendations.length} recommendation step(s), ${significant.length} remediation step(s).`,
+      steps,
+      ...risks.length > 0 ? { risks } : {},
+      generatedBy: "heuristic",
+      ...request.taskId !== void 0 ? { taskId: request.taskId } : {},
+      ...request.pipelineRunId !== void 0 ? { pipelineRunId: request.pipelineRunId } : {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+function remediationStep(finding, order) {
+  return {
+    id: `step-${order}`,
+    title: `Fix: ${truncate5(finding.title, 100)}`,
+    description: finding.detail,
+    order,
+    dependsOn: order > 1 ? [`step-${order - 1}`] : [],
+    sourceFindings: [finding.id]
+  };
+}
+function dedupe(texts) {
+  return [...new Set(texts.map((t) => t.trim()).filter((t) => t.length > 0))];
+}
+function truncate5(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+
+// src/planner/model.ts
+import { randomBytes as randomBytes4 } from "crypto";
+import { z as z2 } from "zod";
+
+// src/planner/context.ts
+function buildPlannerContext(request) {
+  const parts = [`# Objective
+${request.objective}`];
+  if (request.role) {
+    const roleLines = [`# Role
+${request.role.name} (${request.role.id})`];
+    if (request.role.responsibilities.length > 0) {
+      roleLines.push("Responsibilities:", ...request.role.responsibilities.map((r) => `- ${r}`));
+    }
+    if (request.role.expectedOutputs.length > 0) {
+      roleLines.push("Expected outputs:", ...request.role.expectedOutputs.map((o) => `- ${o}`));
+    }
+    parts.push(roleLines.join("\n"));
+  }
+  if (request.reports.length > 0) {
+    const agents = [...new Set(request.reports.map((r) => r.agent))].join(", ");
+    const findingLines = request.reports.flatMap(
+      (report) => report.findings.map(
+        (finding) => `- [${finding.severity ?? "info"}] ${finding.title} (source: ${report.agent}, finding: ${finding.id})` + (finding.detail ? ` \u2014 ${finding.detail}` : "")
+      )
+    );
+    parts.push(
+      `# Findings (${request.reports.length} report(s) by ${agents})
+` + (findingLines.length > 0 ? findingLines.join("\n") : "(no findings reported)")
+    );
+    const recommendationLines = request.reports.flatMap(
+      (report) => report.recommendations.map((text) => `- ${text} (source: ${report.agent})`)
+    );
+    if (recommendationLines.length > 0) {
+      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.memory && request.memory.length > 0) {
+    parts.push(
+      `# Relevant memory
+` + request.memory.map((entry2) => `- [${entry2.scope}] ${entry2.content}`).join("\n")
+    );
+  }
+  if (request.context && request.context.length > 0) {
+    parts.push(`# Research context
+${request.context}`);
+  }
+  return parts.join("\n\n");
+}
+
+// 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;
+    this.log = (options.log ?? logger).child({ component: "planner", model: options.model });
+  }
+  options;
+  name = "model";
+  log;
+  async plan(request) {
+    const context = buildPlannerContext(request);
+    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 ?? "")
+      },
+      { role: "user", content: context }
+    ];
+    let responseText;
+    try {
+      responseText = await this.options.chat(this.options.model, messages);
+    } catch (error) {
+      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");
+    }
+    const plan = {
+      id: `plan-${Date.now().toString(36)}-${randomBytes4(3).toString("hex")}`,
+      objective: request.objective,
+      summary: parsed.summary,
+      steps: parsed.steps,
+      ...parsed.risks !== void 0 ? { risks: parsed.risks } : {},
+      ...parsed.notes !== void 0 ? { notes: parsed.notes } : {},
+      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;
+  }
+  async degrade(request, reason) {
+    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}.`);
+  }
+};
+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;
+  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
+    }));
+    return {
+      summary: parsed.data.summary,
+      steps: steps.sort((a, b) => a.order - b.order),
+      risks: parsed.data.risks,
+      notes: parsed.data.notes
+    };
+  } catch {
+    return void 0;
+  }
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/pipelines/engine.ts
 var PipelineEngine = class {
   constructor(options) {
     this.options = options;
@@ -2395,8 +2667,9 @@ var PipelineEngine = class {
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const run2 = {
-      id: `run-${Date.now().toString(36)}-${randomBytes3(3).toString("hex")}`,
+      id: `run-${Date.now().toString(36)}-${randomBytes5(3).toString("hex")}`,
       pipelineId: def.id,
+      objective,
       status: "running",
       startedAt: now,
       stepRuns: []
@@ -2423,7 +2696,9 @@ var PipelineEngine = class {
           const ctx = {
             objective,
             ...role ? { role } : {},
-            combinedContext: contextParts.join("\n\n")
+            combinedContext: contextParts.join("\n\n"),
+            reports: [...allReports],
+            pipelineRunId: run2.id
           };
           return this.executeStep(step, ctx);
         })
@@ -2442,6 +2717,7 @@ ${contribution}`);
           stepId: step.id,
           status: outcome.status === "skipped" ? "cancelled" : outcome.status === "failed" ? "failed" : "completed",
           ...outcome.taskIds.length > 0 ? { taskIds: outcome.taskIds } : {},
+          ...outcome.planId !== void 0 ? { planId: outcome.planId } : {},
           ...outcome.error !== void 0 ? { error: outcome.error } : {}
         };
         run2.stepRuns.push(stepRun);
@@ -2452,9 +2728,20 @@ ${contribution}`);
     }
     const failed = [...outcomes.values()].some((o) => o.status === "failed");
     const finalStatus = failed ? "failed" : "completed";
+    const planId = [...outcomes.values()].find((o) => o.planId !== void 0)?.planId;
+    let resultSummary;
+    for (let i = def.steps.length - 1; i >= 0; i -= 1) {
+      const step = def.steps[i];
+      const outcome = outcomes.get(step.id);
+      if (outcome?.status !== "completed" || outcome.taskIds.length === 0) continue;
+      const stepTasks = (await Promise.all(outcome.taskIds.map((id) => this.options.tasks.get(id)))).filter((task) => task !== void 0);
+      const summaries = stepTasks.map((task) => task.result?.summary).filter((summary) => summary !== void 0);
+      if (summaries.length > 0) resultSummary = summaries.join("\n");
+      break;
+    }
     let combinedReportId;
     if (this.options.reports) {
-      const taskIds = [...outcomes.values()].flatMap((o) => o.taskIds);
+      const taskIds = def.steps.filter((step) => step.kind === "research" || step.kind === "analyze").flatMap((step) => outcomes.get(step.id)?.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);
@@ -2473,7 +2760,9 @@ ${contribution}`);
       status: finalStatus,
       finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...run2.reports !== void 0 && run2.reports.length > 0 ? { reports: run2.reports } : {},
-      ...combinedReportId !== void 0 ? { combinedReportId } : {}
+      ...combinedReportId !== void 0 ? { combinedReportId } : {},
+      ...planId !== void 0 ? { planId } : {},
+      ...resultSummary !== void 0 ? { resultSummary } : {}
     };
     await this.options.store.save(finished);
     this.log.info(`Pipeline ${def.id} finished: ${finalStatus}.`);
@@ -2583,33 +2872,34 @@ ${contribution}`);
     };
   }
   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);
+    const request = {
+      objective: ctx.objective,
+      reports: ctx.reports,
+      ...ctx.combinedContext.length > 0 ? { context: ctx.combinedContext } : {},
+      ...ctx.role ? { role: ctx.role } : {},
+      ...ctx.pipelineRunId !== void 0 ? { pipelineRunId: ctx.pipelineRunId } : {}
+    };
+    let planner;
+    if (step.model) {
+      planner = new ModelPlanner({
+        model: step.model,
+        chat: this.getChat(),
+        fallback: new HeuristicPlanner(),
+        log: this.log
+      });
+    } else if (this.options.planner) {
+      planner = this.options.planner;
+    } else {
       return {
         status: "completed",
-        summary: planText.split("\n", 1)[0] ?? planText,
-        contextContribution: planText,
+        summary: "(plan: no model or planner configured \u2014 skipped)",
         taskIds: [],
         reports: []
       };
+    }
+    let plan;
+    try {
+      plan = await planner.plan(request);
     } catch (error) {
       return {
         status: "failed",
@@ -2619,6 +2909,15 @@ Produce the final plan.`
         reports: []
       };
     }
+    await this.options.plans?.save(plan);
+    return {
+      status: "completed",
+      summary: plan.summary,
+      contextContribution: formatPlan(plan),
+      taskIds: [],
+      planId: plan.id,
+      reports: []
+    };
   }
   getChat() {
     if (this.options.chat) return this.options.chat;
@@ -2628,6 +2927,21 @@ Produce the final plan.`
     );
   }
 };
+function formatPlan(plan) {
+  const lines = [
+    `# Implementation Plan (by ${plan.generatedBy})`,
+    plan.summary,
+    "Steps:",
+    ...plan.steps.map((step) => {
+      const targets = step.targets && step.targets.length > 0 ? ` [targets: ${step.targets.join(", ")}]` : "";
+      return `${step.order}. ${step.title}${targets}`;
+    })
+  ];
+  if (plan.risks && plan.risks.length > 0) {
+    lines.push("Risks:", ...plan.risks.map((risk) => `- ${risk}`));
+  }
+  return lines.join("\n");
+}
 function createDefaultChatFn(providers) {
   return async (modelRef, messages) => {
     const separator = modelRef.indexOf(":");
@@ -2708,10 +3022,88 @@ var FilePipelineRunStore = class {
   }
 };
 
+// src/planner/store.ts
+import { mkdir as mkdir5, readFile as readFile5, rename as rename5, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+var FilePlanStore = class {
+  filePath;
+  queue = Promise.resolve();
+  constructor(directory = `${process.cwd()}/.omninode`) {
+    this.filePath = `${directory}/plans.json`;
+  }
+  async save(plan) {
+    return this.synchronized(async () => {
+      const plans = await this.load();
+      const index = plans.findIndex((p) => p.id === plan.id);
+      if (index >= 0) plans[index] = plan;
+      else plans.push(plan);
+      await this.write(plans);
+    });
+  }
+  async get(id) {
+    return this.synchronized(async () => {
+      const plans = await this.load();
+      return plans.find((p) => p.id === id);
+    });
+  }
+  async list(filter = {}) {
+    return this.synchronized(async () => {
+      const plans = await this.load();
+      return plans.filter((plan) => filter.pipelineRunId ? plan.pipelineRunId === filter.pipelineRunId : true).filter((plan) => filter.taskId ? plan.taskId === filter.taskId : 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 readFile5(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  async write(plans) {
+    const tmp = `${this.filePath}.tmp`;
+    await mkdir5(dirname5(this.filePath), { recursive: true });
+    await writeFile5(tmp, `${JSON.stringify(plans, null, 2)}
+`, "utf8");
+    await rename5(tmp, this.filePath);
+  }
+};
+
+// src/planner/factory.ts
+function buildPlanner(plannerConfig, chat, log = logger) {
+  if (!plannerConfig) return void 0;
+  if (plannerConfig.kind === "heuristic") {
+    return new HeuristicPlanner();
+  }
+  if (!plannerConfig.model) {
+    throw new ConfigError(
+      "CONFIG_INVALID",
+      'Planner kind "model" needs a model reference ("provider:model-id") in omninode.yaml.'
+    );
+  }
+  return new ModelPlanner({
+    model: plannerConfig.model,
+    chat,
+    ...plannerConfig.instruction !== void 0 ? { instruction: plannerConfig.instruction } : {},
+    fallback: new HeuristicPlanner(),
+    log
+  });
+}
+
 // src/pipelines/engine-factory.ts
 function buildPipelineEngine(config, log = logger) {
   const agents = buildAgentRegistry(config, log);
   const roles = buildRoleRegistry(config);
+  const chat = createDefaultChatFn(config.project.providers);
   const tasks = new TaskEngine({
     agents,
     roles,
@@ -2725,7 +3117,9 @@ function buildPipelineEngine(config, log = logger) {
     roles,
     providers: config.project.providers,
     store: new FilePipelineRunStore(),
-    chat: createDefaultChatFn(config.project.providers),
+    chat,
+    ...config.project.planner !== void 0 ? { planner: buildPlanner(config.project.planner, chat, log) } : {},
+    plans: new FilePlanStore(),
     reports: new ReportService(new FileReportStore(), log),
     log
   });
@@ -2748,28 +3142,27 @@ function registerPipelineCommands(program) {
   });
   pipeline.command("run <id> [objective]").description(
     "Run a pipeline. The objective argument overrides the definition's default objective."
-  ).action(async (id, objective) => {
+  ).action(async (id, objective) => runPipelineAction(id, objective));
+  pipeline.command("retry <run-id> [objective]").description(
+    "Error recovery: re-run a recorded pipeline run as a new run, reusing its objective."
+  ).action(async (runId, 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)`);
+    const previous = await engine.get(runId);
+    if (!previous) {
+      throw new PipelineError(
+        "PIPELINE_NOT_FOUND",
+        `Pipeline run "${runId}" does not exist in this project's run store.`
+      );
     }
-    if (finished.combinedReportId) {
-      console.log(`  combined report: ${finished.combinedReportId}`);
+    const def = config.project.pipelines.find((p) => p.id === previous.pipelineId);
+    if (!def) {
+      throw new PipelineError(
+        "PIPELINE_NOT_FOUND",
+        `Pipeline "${previous.pipelineId}" (run ${runId}) is no longer configured in omninode.yaml.`
+      );
     }
-    console.log(`Pipeline ${finished.status}. Run id: ${finished.id}`);
-    if (finished.status !== "completed") process.exitCode = 1;
+    await runPipelineAction(def.id, objective ?? previous.objective);
   });
   pipeline.command("runs <id>").description("List recorded runs of a pipeline.").action(async (id) => {
     const config = loadConfig();
@@ -2798,6 +3191,7 @@ function registerPipelineCommands(program) {
     console.log(`  status:     ${run2.status}`);
     console.log(`  started:    ${run2.startedAt ?? "?"}`);
     if (run2.finishedAt) console.log(`  finished:   ${run2.finishedAt}`);
+    if (run2.resultSummary) console.log(`  result:     ${run2.resultSummary}`);
     for (const stepRun of run2.stepRuns) {
       console.log(`  [${stepRun.stepId}] ${stepRun.status}`);
     }
@@ -2806,6 +3200,38 @@ function registerPipelineCommands(program) {
     }
   });
 }
+async function runPipelineAction(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}`);
+  }
+  if (finished.planId) {
+    console.log(`  plan: ${finished.planId}`);
+  }
+  if (finished.resultSummary) {
+    console.log(`  result: ${finished.resultSummary}`);
+  }
+  console.log(`Pipeline ${finished.status}. Run id: ${finished.id}`);
+  if (finished.status !== "completed") process.exitCode = 1;
+}
+function registerRunAlias(program) {
+  program.command("run <id> [objective]").description("Alias of `omninode pipeline run` \u2014 execute a configured pipeline end to end.").action(async (id, objective) => runPipelineAction(id, objective));
+}
 function findPipeline(config, id) {
   const def = config.project.pipelines.find((p) => p.id === id);
   if (!def) {
@@ -2871,6 +3297,98 @@ function registerMemoryCommands(program) {
   });
 }
 
+// src/cli/commands/plan.ts
+function registerPlanCommands(program) {
+  const plan = program.command("plan").description("Inspect implementation plans produced by the planner layer (\xA718).");
+  plan.command("list").description("List stored plans.").option("--run <pipelineRunId>", "Only plans for this pipeline run.").action(async (options) => {
+    const store = new FilePlanStore();
+    const plans = await store.list({
+      ...options.run !== void 0 ? { pipelineRunId: options.run } : {}
+    });
+    if (plans.length === 0) {
+      console.log("No plans stored yet. Run a pipeline with a plan step to generate one.");
+      return;
+    }
+    for (const p of plans) {
+      console.log(`${p.id}  ${p.steps.length} step(s)  by ${p.generatedBy}  ${truncate(p.summary, 50)}`);
+    }
+  });
+  plan.command("show <id>").description("Show a stored implementation plan in full.").action(async (id) => {
+    const store = new FilePlanStore();
+    const found = await store.get(id);
+    if (!found) {
+      throw new OmniNodeError("PLAN_INVALID", `Plan "${id}" was not found in the plan store.`, {
+        details: { id }
+      });
+    }
+    console.log(`Plan ${found.id}`);
+    console.log(`  objective: ${found.objective}`);
+    console.log(`  by:        ${found.generatedBy}`);
+    console.log(`  summary:   ${found.summary}`);
+    console.log("  steps:");
+    for (const step of [...found.steps].sort((a, b) => a.order - b.order)) {
+      const targets = step.targets && step.targets.length > 0 ? ` [${step.targets.join(", ")}]` : "";
+      console.log(`    ${step.order}. ${step.title}${targets}`);
+      if (step.description) console.log(`       ${truncate(step.description, 100)}`);
+      for (const criterion of step.acceptanceCriteria ?? []) {
+        console.log(`       accept: ${criterion}`);
+      }
+    }
+    if (found.risks && found.risks.length > 0) {
+      console.log("  risks:");
+      for (const risk of found.risks) {
+        console.log(`    - ${risk}`);
+      }
+    }
+  });
+}
+
+// src/cli/commands/status.ts
+function countBy(items, key) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const k = key(item);
+    counts.set(k, (counts.get(k) ?? 0) + 1);
+  }
+  if (counts.size === 0) return "0";
+  return `${items.length} (${[...counts.entries()].map(([k, v]) => `${k} ${v}`).join(", ")})`;
+}
+function registerStatusCommand(program) {
+  program.command("status").description("Show the project's OmniNode state overview (config, tasks, runs, reports, plans, memory).").action(async () => {
+    const config = loadConfig();
+    console.log(`OmniNode v${OMNINODE_VERSION} \u2014 project "${config.project.name}"`);
+    console.log(
+      `providers: ${config.project.providers.length > 0 ? config.project.providers.map((p) => p.name).join(", ") : "none"}`
+    );
+    console.log(
+      `agents:    ${config.project.agents.length > 0 ? config.project.agents.map((a) => a.name).join(", ") : "none"}`
+    );
+    console.log(
+      `roles:     ${config.project.roles.length > 0 ? config.project.roles.map((r) => r.id).join(", ") : "none"}`
+    );
+    console.log(
+      `pipelines: ${config.project.pipelines.length > 0 ? config.project.pipelines.map((p) => p.id).join(", ") : "none"}`
+    );
+    const tasks = await new FileTaskStore().list();
+    console.log(`tasks:     ${countBy(tasks, (t) => t.status)}`);
+    const runs = await new FilePipelineRunStore().list();
+    console.log(`runs:      ${countBy(runs, (r) => r.status)}`);
+    const reportStore = new FileReportStore();
+    const reports = await reportStore.listReports();
+    const combined = await reportStore.listCombined();
+    console.log(`reports:   ${reports.length} raw, ${combined.length} combined`);
+    const plans = await new FilePlanStore().list();
+    console.log(`plans:     ${plans.length}`);
+    if (config.project.memory !== void 0) {
+      const memory = new MemoryService(createMemoryProvider(config.project.memory));
+      const entries = await memory.providerRef.query({ limit: 1e4 });
+      console.log(`memory:    ${memory.providerName}, ${entries.length} entr(ies)`);
+    } else {
+      console.log("memory:    not configured (local provider available \u2014 add a `memory:` section)");
+    }
+  });
+}
+
 // src/cli/index.ts
 function createProgram() {
   const program = new Command();
@@ -2887,6 +3405,9 @@ function createProgram() {
   registerModelsCommand(program);
   registerPipelineCommands(program);
   registerMemoryCommands(program);
+  registerPlanCommands(program);
+  registerStatusCommand(program);
+  registerRunAlias(program);
   return program;
 }
 async function run(argv) {