@hilbras/omninode 0.7.0 → 0.9.0

package/dist/index.js

@@ -39,6 +39,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);
@@ -154,13 +159,23 @@ 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([]),
-  memory: z.object({ provider: z.string().min(1) }).strict().optional()
+  planner: plannerConfigSchema.optional(),
+  memory: z.object({
+    provider: z.string().min(1).default("local"),
+    base_url: z.string().url().optional(),
+    api_key_env_var: z.string().min(1).optional()
+  }).strict().optional()
 }).strict();
 var appConfigSchema = z.object({
   project: projectConfigSchema,
@@ -230,7 +245,20 @@ function toAppConfig(yaml) {
       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.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,
+          baseUrl: yaml.project.memory.base_url,
+          apiKeyEnvVar: yaml.project.memory.api_key_env_var
+        }
+      } : {}
     },
     ...yaml.logging !== void 0 ? { logging: yaml.logging } : {}
   };
@@ -1079,13 +1107,24 @@ var TaskEngine = class {
     const role = task.role ? this.options.roles.get(task.role) : void 0;
     const running = await this.transition(task, "running");
     this.log.info(`Running task ${task.id} on agent "${task.agent}".`);
+    let background = running.context?.background;
+    if (this.options.memory) {
+      const memoryContext = await this.options.memory.gatherContext({
+        objective: running.objective,
+        ...running.role ? { role: running.role } : {},
+        ...running.project ? { project: running.project } : {}
+      });
+      if (memoryContext.length > 0) {
+        background = [memoryContext, background].filter((part) => part && part.length > 0).join("\n\n");
+      }
+    }
     let output;
     try {
       output = await agent.run({
         taskId: running.id,
         objective: running.objective,
         ...role ? { role } : {},
-        ...running.context?.background ? { context: running.context.background } : {}
+        ...background !== void 0 ? { context: background } : {}
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -1103,8 +1142,12 @@ var TaskEngine = class {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     const finalStatus = output.status === "completed" ? "completed" : "failed";
+    const finished = await this.transition(running, finalStatus, { result });
     this.log.info(`Task ${task.id} finished: ${finalStatus}.`);
-    return this.transition(running, finalStatus, { result });
+    if (this.options.memory) {
+      await this.options.memory.recordTaskOutcome(finished);
+    }
+    return finished;
   }
   async cancel(id) {
     const task = await this.mustGet(id);
@@ -1149,18 +1192,536 @@ function generateTaskId() {
   return `task-${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`;
 }
 
+// src/memory/local.ts
+import { mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "this",
+  "that",
+  "from",
+  "into",
+  "was",
+  "were",
+  "have",
+  "has",
+  "had",
+  "are",
+  "but",
+  "not",
+  "you",
+  "his",
+  "her",
+  "its",
+  "their",
+  "them",
+  "then",
+  "than",
+  "when",
+  "what",
+  "which",
+  "will",
+  "would",
+  "been",
+  "were",
+  "also",
+  "because",
+  "about",
+  "after",
+  "before"
+]);
+function keywords(text) {
+  return new Set(
+    (text ?? "").toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= 4 && !STOPWORDS.has(t))
+  );
+}
+function relevanceScore(queryKeywords, entry) {
+  if (queryKeywords.size === 0) return 0;
+  const entryKeywords = keywords(`${entry.content} ${entry.key}`);
+  let overlap = 0;
+  for (const keyword of queryKeywords) {
+    if (entryKeywords.has(keyword)) overlap += 1;
+  }
+  let tagMatches = 0;
+  for (const tag of entry.tags ?? []) {
+    if (queryKeywords.has(tag.toLowerCase())) tagMatches += 1;
+  }
+  return overlap * 2 + tagMatches * 1.5;
+}
+var LocalMemoryProvider = class {
+  name = "local";
+  filePath;
+  queue = Promise.resolve();
+  constructor(directory = `${process.cwd()}/.omninode`) {
+    this.filePath = `${directory}/memory.json`;
+  }
+  async query(query) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      const filtered = entries.filter((entry) => query.scope ? entry.scope === query.scope : true).filter(
+        (entry) => query.tags && query.tags.length > 0 ? query.tags.every((tag) => (entry.tags ?? []).includes(tag)) : true
+      );
+      if (!query.text || query.text.trim().length === 0) {
+        return filtered.sort((a, b) => (b.updatedAt ?? b.createdAt ?? "").localeCompare(a.updatedAt ?? a.createdAt ?? "")).slice(0, query.limit ?? 10);
+      }
+      const queryKeywords = keywords(query.text);
+      return filtered.map((entry) => ({ entry, score: relevanceScore(queryKeywords, entry) })).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score).slice(0, query.limit ?? 10).map(({ entry }) => entry);
+    });
+  }
+  async write(entry) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      const index = entries.findIndex((e) => e.key === entry.key);
+      const stamped = {
+        ...entry,
+        createdAt: entry.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (index >= 0) entries[index] = stamped;
+      else entries.push(stamped);
+      await this.saveAll(entries);
+    });
+  }
+  async count() {
+    return (await this.load()).length;
+  }
+  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 saveAll(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/memory/remembera.ts
+var RememberaMemoryProvider = class {
+  name = "remembera";
+  baseUrl;
+  apiKeyEnvVar;
+  env;
+  log;
+  constructor(config, log = logger) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.apiKeyEnvVar = config.apiKeyEnvVar;
+    this.env = config.env ?? process.env;
+    this.log = log.child({ component: "remembera" });
+  }
+  headers() {
+    const key = this.apiKeyEnvVar ? resolveApiKey({ name: "remembera", apiKeyEnvVar: this.apiKeyEnvVar }, this.env) : void 0;
+    return key ? { authorization: `Bearer ${key}` } : {};
+  }
+  async query(query) {
+    const { status, body } = await this.request(`${this.baseUrl}/api/memory/query`, query);
+    if (status !== 200) {
+      throw new MemoryError(`Remembera query returned HTTP ${status}.`);
+    }
+    const entries = body.entries;
+    if (!Array.isArray(entries)) {
+      throw new MemoryError("Remembera query response had no entries array.");
+    }
+    return entries.map((entry) => this.toEntry(entry)).filter((entry) => entry !== void 0);
+  }
+  async write(entry) {
+    const { status } = await this.request(`${this.baseUrl}/api/memory`, entry);
+    if (status !== 200 && status !== 201) {
+      throw new MemoryError(`Remembera write returned HTTP ${status}.`);
+    }
+  }
+  async request(url, body) {
+    const headers = this.headers();
+    try {
+      return await requestJson(url, {
+        method: "POST",
+        headers,
+        body
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new MemoryError(`Remembera request to ${url} failed: ${message}`, { cause: error });
+    }
+  }
+  toEntry(raw) {
+    if (raw === null || typeof raw !== "object") {
+      this.log.warn("Skipping malformed Remembera memory entry.");
+      return void 0;
+    }
+    const entry = raw;
+    if (typeof entry.key !== "string" || typeof entry.content !== "string") {
+      this.log.warn("Skipping Remembera memory entry without key/content.");
+      return void 0;
+    }
+    const scope = entry.scope;
+    return {
+      key: entry.key,
+      content: entry.content,
+      scope: scope === "project" || scope === "role" || scope === "task" || scope === "knowledge" ? scope : "knowledge",
+      ...Array.isArray(entry.tags) ? { tags: entry.tags.filter((t) => typeof t === "string") } : {},
+      ...typeof entry.createdAt === "string" ? { createdAt: entry.createdAt } : {},
+      ...typeof entry.updatedAt === "string" ? { updatedAt: entry.updatedAt } : {}
+    };
+  }
+};
+
+// src/memory/factory.ts
+function createMemoryProvider(config) {
+  if (!config || config.provider === "local") {
+    return new LocalMemoryProvider();
+  }
+  if (config.provider === "remembera") {
+    if (!config.baseUrl) {
+      throw new ConfigError(
+        "CONFIG_INVALID",
+        `Memory provider "remembera" needs a base_url in omninode.yaml.`
+      );
+    }
+    return new RememberaMemoryProvider({
+      baseUrl: config.baseUrl,
+      apiKeyEnvVar: config.apiKeyEnvVar
+    });
+  }
+  throw new ConfigError(
+    "CONFIG_INVALID",
+    `Unknown memory provider "${config.provider}". Available: local, remembera.`
+  );
+}
+
+// src/memory/service.ts
+var MAX_CONTEXT_CHARS = 4e3;
+var MemoryService = class {
+  constructor(provider, log = logger) {
+    this.provider = provider;
+    this.log = log.child({ component: "memory", provider: provider.name });
+  }
+  provider;
+  log;
+  get providerRef() {
+    return this.provider;
+  }
+  get providerName() {
+    return this.provider.name;
+  }
+  /** Relevant context for a task objective; empty string when nothing matches. */
+  async gatherContext(query) {
+    try {
+      const entries = await this.provider.query({
+        text: query.objective,
+        ...query.role ? { tags: [query.role] } : {},
+        limit: 8
+      });
+      if (entries.length === 0) return "";
+      const byScope = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        byScope.set(entry.scope, [...byScope.get(entry.scope) ?? [], entry]);
+      }
+      const parts = [];
+      for (const scope of ["project", "task", "role", "knowledge"]) {
+        const scopeEntries = byScope.get(scope) ?? [];
+        if (scopeEntries.length === 0) continue;
+        const lines = scopeEntries.map((entry) => `- ${entry.content}`).join("\n");
+        parts.push(`### Relevant memory (${scope})
+${lines}`);
+      }
+      const context = parts.join("\n\n");
+      return context.length > MAX_CONTEXT_CHARS ? `${context.slice(0, MAX_CONTEXT_CHARS)}\u2026` : context;
+    } catch (error) {
+      this.log.warn(
+        `Memory query failed (continuing without memory): ${error instanceof Error ? error.message : String(error)}`
+      );
+      return "";
+    }
+  }
+  /** Records a finished task's outcome — best-effort. */
+  async recordTaskOutcome(task) {
+    const outcome = task.result?.summary ?? task.result?.error ?? "(no output)";
+    try {
+      await this.provider.write({
+        key: `task:${task.id}`,
+        scope: "task",
+        content: `Objective: ${task.objective}
+Status: ${task.status}
+Outcome: ${outcome}`,
+        tags: ["task", ...task.agent ? [task.agent] : [], ...task.role ? [task.role] : []],
+        createdAt: task.createdAt
+      });
+      const significant = (task.result?.reports ?? []).flatMap(
+        (report) => report.findings.filter((finding) => finding.severity === "high" || finding.severity === "critical").map((finding) => ({ report, finding }))
+      );
+      for (const { report, finding } of significant) {
+        await this.provider.write({
+          key: `finding:${report.id}:${finding.id}`,
+          scope: "project",
+          content: `[${finding.severity}] ${finding.title} \u2014 ${finding.detail}`,
+          tags: ["known-problem", report.agent]
+        });
+      }
+    } catch (error) {
+      this.log.warn(
+        `Memory write failed (continuing): ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+};
+
 // src/tasks/engine-factory.ts
 function createTaskEngine(config, log = logger, directory) {
+  const agents = buildAgentRegistry(config, log);
+  const roles = buildRoleRegistry(config);
   return new TaskEngine({
-    agents: buildAgentRegistry(config, log),
-    roles: buildRoleRegistry(config),
+    agents,
+    roles,
     store: new FileTaskStore(directory),
+    ...config.project.memory !== void 0 ? { memory: new MemoryService(createMemoryProvider(config.project.memory), log) } : {},
     log
   });
 }
 
 // src/pipelines/engine.ts
+import { randomBytes as randomBytes4 } from "crypto";
+
+// src/planner/heuristic.ts
 import { randomBytes as randomBytes2 } from "crypto";
+var SEVERITY_RANK = {
+  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: truncate(text, 120),
+        order: steps.length + 1,
+        ...index > 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"]);
+    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)}-${randomBytes2(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: ${truncate(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 truncate(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";
+
+// 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((entry) => `- [${entry.scope}] ${entry.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)}-${randomBytes3(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;
@@ -1273,7 +1834,7 @@ var PipelineEngine = class {
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const run = {
-      id: `run-${Date.now().toString(36)}-${randomBytes2(3).toString("hex")}`,
+      id: `run-${Date.now().toString(36)}-${randomBytes4(3).toString("hex")}`,
       pipelineId: def.id,
       status: "running",
       startedAt: now,
@@ -1301,7 +1862,9 @@ var PipelineEngine = class {
           const ctx = {
             objective,
             ...role ? { role } : {},
-            combinedContext: contextParts.join("\n\n")
+            combinedContext: contextParts.join("\n\n"),
+            reports: [...allReports],
+            pipelineRunId: run.id
           };
           return this.executeStep(step, ctx);
         })
@@ -1320,6 +1883,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 } : {}
         };
         run.stepRuns.push(stepRun);
@@ -1330,6 +1894,7 @@ ${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 combinedReportId;
     if (this.options.reports) {
       const taskIds = [...outcomes.values()].flatMap((o) => o.taskIds);
@@ -1351,7 +1916,8 @@ ${contribution}`);
       status: finalStatus,
       finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...run.reports !== void 0 && run.reports.length > 0 ? { reports: run.reports } : {},
-      ...combinedReportId !== void 0 ? { combinedReportId } : {}
+      ...combinedReportId !== void 0 ? { combinedReportId } : {},
+      ...planId !== void 0 ? { planId } : {}
     };
     await this.options.store.save(finished);
     this.log.info(`Pipeline ${def.id} finished: ${finalStatus}.`);
@@ -1461,33 +2027,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",
@@ -1497,6 +2064,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;
@@ -1506,6 +2082,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(":");
@@ -1531,8 +2122,8 @@ function createDefaultChatFn(providers) {
 }
 
 // src/pipelines/store.ts
-import { mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
+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();
@@ -1570,7 +2161,7 @@ var FilePipelineRunStore = class {
   }
   async load() {
     try {
-      const raw = await readFile2(this.filePath, "utf8");
+      const raw = await readFile3(this.filePath, "utf8");
       const parsed = JSON.parse(raw);
       return Array.isArray(parsed) ? parsed : [];
     } catch {
@@ -1579,16 +2170,93 @@ var FilePipelineRunStore = class {
   }
   async write(runs) {
     const tmp = `${this.filePath}.tmp`;
-    await mkdir2(dirname2(this.filePath), { recursive: true });
-    await writeFile2(tmp, `${JSON.stringify(runs, null, 2)}
+    await mkdir3(dirname3(this.filePath), { recursive: true });
+    await writeFile3(tmp, `${JSON.stringify(runs, null, 2)}
 `, "utf8");
-    await rename2(tmp, this.filePath);
+    await rename3(tmp, this.filePath);
+  }
+};
+
+// src/planner/store.ts
+import { mkdir as mkdir4, readFile as readFile4, rename as rename4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4 } 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 readFile4(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  async write(plans) {
+    const tmp = `${this.filePath}.tmp`;
+    await mkdir4(dirname4(this.filePath), { recursive: true });
+    await writeFile4(tmp, `${JSON.stringify(plans, null, 2)}
+`, "utf8");
+    await rename4(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/reports/aggregate.ts
-import { randomBytes as randomBytes3 } from "crypto";
-var SEVERITY_RANK = {
+import { randomBytes as randomBytes5 } from "crypto";
+var SEVERITY_RANK2 = {
   info: 0,
   low: 1,
   medium: 2,
@@ -1611,8 +2279,8 @@ function aggregateReports(reports, options = {}) {
   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)}-${randomBytes3(3).toString("hex")}`,
-    title: options.objective !== void 0 ? truncate(options.objective, 120) : "Combined report",
+    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 ?? [],
@@ -1625,7 +2293,7 @@ function aggregateReports(reports, options = {}) {
   };
 }
 function rank(finding) {
-  return finding.severity ? SEVERITY_RANK[finding.severity] : -1;
+  return finding.severity ? SEVERITY_RANK2[finding.severity] : -1;
 }
 function mergeFinding(groups, finding, report, threshold) {
   const source = { agent: report.agent, reportId: report.id };
@@ -1635,7 +2303,7 @@ function mergeFinding(groups, finding, report, threshold) {
     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])) {
+    if (finding.severity && (!group.severity || SEVERITY_RANK2[finding.severity] > SEVERITY_RANK2[group.severity])) {
       group.severity = finding.severity;
     }
     return;
@@ -1675,7 +2343,7 @@ function tokens(text) {
     text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= 3)
   );
 }
-function truncate(text, max) {
+function truncate2(text, max) {
   return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
 }
 
@@ -1719,14 +2387,14 @@ function extractReportFromText(raw, meta) {
   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 ? truncate2(cleaned, 200) : "(no output)";
+  const summary = cleaned.length > 0 ? truncate3(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: truncate2(text, 120),
+    title: truncate3(text, 120),
     detail: text,
     severity: guessSeverity(text)
   }));
@@ -1737,12 +2405,12 @@ function extractReportFromText(raw, meta) {
     ...meta.model !== void 0 ? { model: meta.model } : {},
     summary,
     findings,
-    recommendations: recommendationTexts.map((t) => truncate2(t, 200)),
+    recommendations: recommendationTexts.map((t) => truncate3(t, 200)),
     metadata: evidenceTexts.length > 0 ? { evidence: evidenceTexts } : void 0,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function truncate2(text, max) {
+function truncate3(text, max) {
   return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
 }
 
@@ -1797,8 +2465,8 @@ var ReportService = class {
 };
 
 // src/reports/store.ts
-import { mkdir as mkdir3, readFile as readFile3, rename as rename3, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3 } from "path";
+import { mkdir as mkdir5, readFile as readFile5, rename as rename5, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname5 } from "path";
 var FileReportStore = class {
   filePath;
   queue = Promise.resolve();
@@ -1862,7 +2530,7 @@ var FileReportStore = class {
   }
   async load() {
     try {
-      const raw = await readFile3(this.filePath, "utf8");
+      const raw = await readFile5(this.filePath, "utf8");
       const parsed = JSON.parse(raw);
       return Array.isArray(parsed) ? parsed : [];
     } catch {
@@ -1871,10 +2539,10 @@ var FileReportStore = class {
   }
   async write(entries) {
     const tmp = `${this.filePath}.tmp`;
-    await mkdir3(dirname3(this.filePath), { recursive: true });
-    await writeFile3(tmp, `${JSON.stringify(entries, null, 2)}
+    await mkdir5(dirname5(this.filePath), { recursive: true });
+    await writeFile5(tmp, `${JSON.stringify(entries, null, 2)}
 `, "utf8");
-    await rename3(tmp, this.filePath);
+    await rename5(tmp, this.filePath);
   }
 };
 
@@ -1882,10 +2550,12 @@ var FileReportStore = class {
 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,
     store: new FileTaskStore(),
+    ...config.project.memory !== void 0 ? { memory: new MemoryService(createMemoryProvider(config.project.memory), log) } : {},
     log
   });
   return new PipelineEngine({
@@ -1894,23 +2564,28 @@ 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
   });
 }
 
 // src/version.ts
-var OMNINODE_VERSION = "0.7.0";
+var OMNINODE_VERSION = "0.9.0";
 export {
   AgentError,
   AgentRegistry,
   ConfigError,
   ConsoleLogSink,
   FilePipelineRunStore,
+  FileReportStore,
   FileTaskStore,
+  LocalMemoryProvider,
   Logger,
   MemoryError,
+  MemoryService,
   ModelRegistry,
   OMNINODE_VERSION,
   OPENAI_COMPATIBLE_TYPES,
@@ -1919,13 +2594,17 @@ export {
   OpenAICompatibleProvider,
   PipelineEngine,
   PipelineError,
+  PlannerError,
   ProcessAgent,
   ProtocolError,
   ProviderError,
+  RememberaMemoryProvider,
+  ReportService,
   RoleRegistry,
   TaskEngine,
   TaskError,
   agentConfigSchema,
+  aggregateReports,
   appConfigSchema,
   authHeaders,
   buildAgentRegistry,
@@ -1934,21 +2613,26 @@ export {
   composeTaskText,
   createAgent,
   createDefaultChatFn,
+  createMemoryProvider,
   createProvider,
   createTaskEngine,
   defaultProjectConfigYaml,
   expandEnvRefs,
+  extractReportFromText,
   findConfigFile,
   isOmniNodeError,
+  keywords,
   loadConfig,
   logger,
   pipelineConfigSchema,
   pipelineStepConfigSchema,
+  plannerConfigSchema,
   projectConfigSchema,
   providerConfigSchema,
   registryKey,
   requestJson,
   resolveApiKey,
-  roleConfigSchema
+  roleConfigSchema,
+  similar
 };
 //# sourceMappingURL=index.js.map