@hilbras/omninode 0.6.0 → 0.8.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.6.0";
+var OMNINODE_VERSION = "0.8.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 MemoryError = class extends OmniNodeError {
+  constructor(message, options = {}) {
+    super("MEMORY_UNAVAILABLE", message, options);
+  }
+};
 function isOmniNodeError(value) {
   return value instanceof OmniNodeError;
 }
@@ -112,7 +117,11 @@ var projectConfigSchema = z.object({
   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()
+  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,
@@ -182,7 +191,13 @@ 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.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 } : {}
   };
@@ -675,6 +690,9 @@ function notImplemented(command, when) {
     `${command} is planned for ${when}. Edit omninode.yaml directly for now.`
   );
 }
+function truncate(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
 function appendToConfigList(listKey, item) {
   const configPath = findConfigFile();
   if (!configPath) {
@@ -1386,13 +1404,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);
@@ -1404,12 +1433,18 @@ var TaskEngine = class {
     const result = {
       ...output.summary !== void 0 ? { summary: output.summary } : {},
       ...output.reports !== void 0 && output.reports.length > 0 ? { reports: output.reports } : {},
+      // Keep the verbatim output (bounded) for report extraction and audit.
+      ...output.rawOutput !== void 0 && output.rawOutput.length > 0 ? { rawOutput: output.rawOutput.slice(0, 1e4) } : {},
       ...output.error !== void 0 ? { error: output.error } : {},
       finishedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     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);
@@ -1454,6 +1489,297 @@ 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, entry2) {
+  if (queryKeywords.size === 0) return 0;
+  const entryKeywords = keywords(`${entry2.content} ${entry2.key}`);
+  let overlap = 0;
+  for (const keyword of queryKeywords) {
+    if (entryKeywords.has(keyword)) overlap += 1;
+  }
+  let tagMatches = 0;
+  for (const tag of entry2.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((entry2) => query.scope ? entry2.scope === query.scope : true).filter(
+        (entry2) => query.tags && query.tags.length > 0 ? query.tags.every((tag) => (entry2.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((entry2) => ({ entry: entry2, score: relevanceScore(queryKeywords, entry2) })).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score).slice(0, query.limit ?? 10).map(({ entry: entry2 }) => entry2);
+    });
+  }
+  async write(entry2) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      const index = entries.findIndex((e) => e.key === entry2.key);
+      const stamped = {
+        ...entry2,
+        createdAt: entry2.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((entry2) => this.toEntry(entry2)).filter((entry2) => entry2 !== void 0);
+  }
+  async write(entry2) {
+    const { status } = await this.request(`${this.baseUrl}/api/memory`, entry2);
+    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 entry2 = raw;
+    if (typeof entry2.key !== "string" || typeof entry2.content !== "string") {
+      this.log.warn("Skipping Remembera memory entry without key/content.");
+      return void 0;
+    }
+    const scope = entry2.scope;
+    return {
+      key: entry2.key,
+      content: entry2.content,
+      scope: scope === "project" || scope === "role" || scope === "task" || scope === "knowledge" ? scope : "knowledge",
+      ...Array.isArray(entry2.tags) ? { tags: entry2.tags.filter((t) => typeof t === "string") } : {},
+      ...typeof entry2.createdAt === "string" ? { createdAt: entry2.createdAt } : {},
+      ...typeof entry2.updatedAt === "string" ? { updatedAt: entry2.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 entry2 of entries) {
+        byScope.set(entry2.scope, [...byScope.get(entry2.scope) ?? [], entry2]);
+      }
+      const parts = [];
+      for (const scope of ["project", "task", "role", "knowledge"]) {
+        const scopeEntries = byScope.get(scope) ?? [];
+        if (scopeEntries.length === 0) continue;
+        const lines = scopeEntries.map((entry2) => `- ${entry2.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/roles/index.ts
 var RoleRegistry = class {
   roles = /* @__PURE__ */ new Map();
@@ -1478,10 +1804,13 @@ function buildRoleRegistry(config) {
 
 // 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
   });
 }
@@ -1538,7 +1867,7 @@ function registerTaskCommands(program) {
       return;
     }
     for (const t of tasks) {
-      console.log(`${t.id}  ${t.status.padEnd(10)} ${truncate(t.objective, 60)}`);
+      console.log(`${t.id}  ${t.status.padEnd(10)} ${truncate2(t.objective, 60)}`);
     }
   });
   task.command("cancel <task-id>").description("Cancel a task that has not finished yet.").action(async (taskId) => {
@@ -1568,20 +1897,392 @@ function printOutcome(task, options = {}) {
   if (result.error) console.log(`  error:   ${result.error}`);
   if (result.finishedAt) console.log(`  ended:   ${result.finishedAt}`);
 }
-function truncate(text, max) {
+function truncate2(text, max) {
   return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
 }
 
+// src/reports/aggregate.ts
+import { randomBytes as randomBytes2 } from "crypto";
+var SEVERITY_RANK = {
+  info: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  critical: 4
+};
+function aggregateReports(reports, options = {}) {
+  const threshold = options.similarityThreshold ?? 0.7;
+  const findingGroups = [];
+  const recommendationGroups = [];
+  for (const report of reports) {
+    for (const finding of report.findings) {
+      mergeFinding(findingGroups, finding, report, threshold);
+    }
+    for (const text of report.recommendations) {
+      mergeRecommendation(recommendationGroups, text, report, threshold);
+    }
+  }
+  const sources = [...new Set(reports.map((r) => r.agent))].sort();
+  const totalRawFindings = reports.reduce((sum, r) => sum + r.findings.length, 0);
+  const summary = `${reports.length} report(s) from ${sources.length > 0 ? sources.join(", ") : "no agents"}: ${findingGroups.length} unique finding group(s) (${totalRawFindings} raw), ${recommendationGroups.length} recommendation group(s).`;
+  return {
+    id: `combined-${Date.now().toString(36)}-${randomBytes2(3).toString("hex")}`,
+    title: options.objective !== void 0 ? truncate3(options.objective, 120) : "Combined report",
+    ...options.objective !== void 0 ? { objective: options.objective } : {},
+    ...options.pipelineRunId !== void 0 ? { pipelineRunId: options.pipelineRunId } : {},
+    taskIds: options.taskIds ?? [],
+    summary,
+    findings: findingGroups.sort((a, b) => rank(b) - rank(a)),
+    recommendations: recommendationGroups,
+    sources,
+    reportIds: reports.map((r) => r.id),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function rank(finding) {
+  return finding.severity ? SEVERITY_RANK[finding.severity] : -1;
+}
+function mergeFinding(groups, finding, report, threshold) {
+  const source = { agent: report.agent, reportId: report.id };
+  const group = groups.find((g) => similar(g.title, finding.title, threshold));
+  if (group) {
+    group.occurrences += 1;
+    group.details.push(finding.detail);
+    group.sources.push(source);
+    group.evidence.push(...finding.evidence ?? []);
+    if (finding.severity && (!group.severity || SEVERITY_RANK[finding.severity] > SEVERITY_RANK[group.severity])) {
+      group.severity = finding.severity;
+    }
+    return;
+  }
+  groups.push({
+    title: finding.title,
+    details: [finding.detail],
+    sources: [source],
+    occurrences: 1,
+    ...finding.severity ? { severity: finding.severity } : {},
+    evidence: [...finding.evidence ?? []]
+  });
+}
+function mergeRecommendation(groups, text, report, threshold) {
+  const source = { agent: report.agent, reportId: report.id };
+  const group = groups.find((g) => similar(g.text, text, threshold));
+  if (group) {
+    group.occurrences += 1;
+    group.sources.push(source);
+    return;
+  }
+  groups.push({ text, sources: [source], occurrences: 1 });
+}
+function similar(a, b, threshold) {
+  const left = tokens(a);
+  const right = tokens(b);
+  if (left.size === 0 || right.size === 0) return false;
+  let intersection = 0;
+  for (const token of left) {
+    if (right.has(token)) intersection += 1;
+  }
+  const union = left.size + right.size - intersection;
+  return intersection / union >= threshold;
+}
+function tokens(text) {
+  return new Set(
+    text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= 3)
+  );
+}
+function truncate3(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+
+// src/reports/extract.ts
+var BULLET = /^(?:[-*•]|\d+[.)])\s+(.*)$/;
+function parseSections(raw) {
+  const sections = [];
+  let current = { heading: "", bullets: [] };
+  for (const line of raw.split("\n")) {
+    const heading = /^(#{1,6})\s+(.*)$/.exec(line.trim());
+    if (heading) {
+      if (current.heading.length > 0 || current.bullets.length > 0) {
+        sections.push(current);
+      }
+      current = { heading: heading[2]?.toLowerCase() ?? "", bullets: [] };
+      continue;
+    }
+    const bullet = BULLET.exec(line.trim());
+    if (bullet && current.heading.length > 0) {
+      current.bullets.push(bullet[1]?.trim() ?? "");
+    }
+  }
+  if (current.heading.length > 0 || current.bullets.length > 0) {
+    sections.push(current);
+  }
+  return sections;
+}
+function collectBullets(sections, patterns) {
+  const matches = sections.filter((section) => patterns.some((p) => p.test(section.heading)));
+  return matches.flatMap((section) => section.bullets).filter((b) => b.length > 0);
+}
+function guessSeverity(text) {
+  if (/critical|severe/i.test(text)) return "critical";
+  if (/\bhigh\b|major/i.test(text)) return "high";
+  if (/medium|moderate/i.test(text)) return "medium";
+  if (/\blow\b|minor/i.test(text)) return "low";
+  return void 0;
+}
+function extractReportFromText(raw, meta) {
+  const trimmed = raw.trim();
+  const nonEmpty = trimmed.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  const proseLine = nonEmpty.find((line) => !line.startsWith("#") && !BULLET.test(line)) ?? nonEmpty[0] ?? "";
+  const cleaned = proseLine.replace(/^#{1,6}\s+/, "").replace(BULLET, "$1");
+  const summary = cleaned.length > 0 ? truncate4(cleaned, 200) : "(no output)";
+  const sections = parseSections(trimmed);
+  const findingTexts = collectBullets(sections, [/finding/, /issue/, /problem/, /vulnerab/]);
+  const recommendationTexts = collectBullets(sections, [/recommend/, /suggestion/, /next step/, /action/]);
+  const evidenceTexts = collectBullets(sections, [/evidence/, /proof/, /log/]);
+  const findings = findingTexts.map((text, index) => ({
+    id: `${meta.taskId}-f-${index + 1}`,
+    title: truncate4(text, 120),
+    detail: text,
+    severity: guessSeverity(text)
+  }));
+  return {
+    id: `${meta.taskId}-report`,
+    taskId: meta.taskId,
+    agent: meta.agent,
+    ...meta.model !== void 0 ? { model: meta.model } : {},
+    summary,
+    findings,
+    recommendations: recommendationTexts.map((t) => truncate4(t, 200)),
+    metadata: evidenceTexts.length > 0 ? { evidence: evidenceTexts } : void 0,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function truncate4(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+
+// src/reports/service.ts
+var ReportService = class {
+  constructor(store, log = logger) {
+    this.store = store;
+    this.log = log.child({ component: "reports" });
+  }
+  store;
+  log;
+  get storeRef() {
+    return this.store;
+  }
+  /** Normalizes finished tasks into reports (§17 — normalizer). */
+  async collectFromTasks(tasks) {
+    const reports = [];
+    for (const task of tasks) {
+      const structured = task.result?.reports ?? [];
+      if (structured.length > 0) {
+        reports.push(...structured);
+        continue;
+      }
+      const text = task.result?.rawOutput ?? task.result?.summary ?? "";
+      if (text.trim().length === 0) continue;
+      reports.push(
+        extractReportFromText(text, {
+          taskId: task.id,
+          agent: task.agent ?? "unknown"
+        })
+      );
+    }
+    return reports;
+  }
+  async saveReports(reports) {
+    if (reports.length === 0) return;
+    await this.store.saveReports(reports);
+    this.log.info(`Stored ${reports.length} report(s).`);
+  }
+  async generateCombined(reports, meta = {}) {
+    if (reports.length === 0) return void 0;
+    const options = {
+      ...meta.objective !== void 0 ? { objective: meta.objective } : {},
+      ...meta.pipelineRunId !== void 0 ? { pipelineRunId: meta.pipelineRunId } : {},
+      ...meta.taskIds !== void 0 ? { taskIds: meta.taskIds } : {}
+    };
+    const combined = aggregateReports(reports, options);
+    await this.store.saveCombined(combined);
+    this.log.info(`Generated combined report ${combined.id}.`);
+    return combined;
+  }
+};
+
+// src/reports/store.ts
+import { mkdir as mkdir3, readFile as readFile3, rename as rename3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+var FileReportStore = class {
+  filePath;
+  queue = Promise.resolve();
+  constructor(directory = `${process.cwd()}/.omninode`) {
+    this.filePath = `${directory}/reports.json`;
+  }
+  async saveReports(reports) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      for (const report of reports) {
+        const index = entries.findIndex(
+          (e) => e.kind === "report" && e.report.id === report.id
+        );
+        const entry2 = { kind: "report", report };
+        if (index >= 0) entries[index] = entry2;
+        else entries.push(entry2);
+      }
+      await this.write(entries);
+    });
+  }
+  async listReports(filter = {}) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      return entries.filter((e) => e.kind === "report").map((e) => e.report).filter((report) => filter.taskId ? report.taskId === filter.taskId : true).filter((report) => filter.agent ? report.agent === filter.agent : true).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    });
+  }
+  async saveCombined(combined) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      const index = entries.findIndex(
+        (e) => e.kind === "combined" && e.combined.id === combined.id
+      );
+      const entry2 = { kind: "combined", combined };
+      if (index >= 0) entries[index] = entry2;
+      else entries.push(entry2);
+      await this.write(entries);
+    });
+  }
+  async getCombined(id) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      const found = entries.find((e) => e.kind === "combined" && e.combined.id === id);
+      return found?.kind === "combined" ? found.combined : void 0;
+    });
+  }
+  async listCombined(filter = {}) {
+    return this.synchronized(async () => {
+      const entries = await this.load();
+      return entries.filter((e) => e.kind === "combined").map((e) => e.combined).filter(
+        (combined) => filter.pipelineRunId ? combined.pipelineRunId === filter.pipelineRunId : true
+      ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    });
+  }
+  synchronized(operation) {
+    const result = this.queue.then(operation, operation);
+    this.queue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  async load() {
+    try {
+      const raw = await readFile3(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  async write(entries) {
+    const tmp = `${this.filePath}.tmp`;
+    await mkdir3(dirname3(this.filePath), { recursive: true });
+    await writeFile3(tmp, `${JSON.stringify(entries, null, 2)}
+`, "utf8");
+    await rename3(tmp, this.filePath);
+  }
+};
+
 // src/cli/commands/reports.ts
+function service() {
+  return new ReportService(new FileReportStore());
+}
 function registerReportCommands(program) {
-  const report = program.command("report").description("Inspect AI reports (Phase 6+).");
-  report.command("list").description("List collected reports (planned for Phase 6 \u2014 Multi-AI Report System).").action(() => {
-    throw notImplemented("omninode report list", "Phase 6 (Multi-AI Report System)");
+  const report = program.command("report").description("Inspect AI reports collected from tasks and pipelines (\xA716\u2013\xA717).");
+  report.command("list").description("List stored reports.").option("--task <taskId>", "Only reports for this task.").option("--agent <name>", "Only reports from this agent.").action(async (options) => {
+    const svc = service();
+    const reports = await svc.storeRef.listReports({
+      ...options.task !== void 0 ? { taskId: options.task } : {},
+      ...options.agent !== void 0 ? { agent: options.agent } : {}
+    });
+    if (reports.length === 0) {
+      console.log("No reports stored yet. Run a pipeline to collect some.");
+      return;
+    }
+    for (const r of reports) {
+      console.log(`${r.id}  ${r.agent.padEnd(10)} ${truncate(r.summary, 60)}`);
+    }
+  });
+  report.command("combined").description("List combined reports (aggregated intelligence, \xA717).").option("--run <pipelineRunId>", "Only combined reports for this pipeline run.").action(async (options) => {
+    const svc = service();
+    const combined = await svc.storeRef.listCombined({
+      ...options.run !== void 0 ? { pipelineRunId: options.run } : {}
+    });
+    if (combined.length === 0) {
+      console.log("No combined reports stored yet. Run a pipeline to generate one.");
+      return;
+    }
+    for (const c of combined) {
+      console.log(
+        `${c.id}  ${c.findings.length} finding(s) from ${c.sources.length} source(s)${c.pipelineRunId ? `  run=${c.pipelineRunId}` : ""}`
+      );
+    }
+  });
+  report.command("show <id>").description("Show a stored report or combined report in full.").action(async (id) => {
+    const svc = service();
+    const reports = await svc.storeRef.listReports();
+    const raw = reports.find((r) => r.id === id);
+    if (raw) {
+      console.log(`Report ${raw.id}`);
+      console.log(`  agent:     ${raw.agent}${raw.model ? ` (${raw.model})` : ""}`);
+      console.log(`  task:      ${raw.taskId}`);
+      console.log(`  summary:   ${raw.summary}`);
+      if (raw.findings.length > 0) {
+        console.log("  findings:");
+        for (const finding of raw.findings) {
+          console.log(`    - [${finding.severity ?? "info"}] ${finding.title}`);
+          for (const evidence of finding.evidence ?? []) {
+            console.log(`      evidence: ${evidence}`);
+          }
+        }
+      }
+      if (raw.recommendations.length > 0) {
+        console.log("  recommendations:");
+        for (const recommendation of raw.recommendations) {
+          console.log(`    - ${recommendation}`);
+        }
+      }
+      return;
+    }
+    const combined = await svc.storeRef.getCombined(id);
+    if (combined) {
+      console.log(`Combined report ${combined.id}`);
+      console.log(`  sources:   ${combined.sources.join(", ")}`);
+      console.log(`  reports:   ${combined.reportIds.length}`);
+      if (combined.pipelineRunId) console.log(`  run:       ${combined.pipelineRunId}`);
+      console.log(`  summary:   ${combined.summary}`);
+      if (combined.findings.length > 0) {
+        console.log("  findings (grouped, duplicates merged):");
+        for (const finding of combined.findings) {
+          console.log(
+            `    - [${finding.severity ?? "info"}] ${finding.title} (x${finding.occurrences}, sources: ${finding.sources.map((s) => s.agent).join(", ")})`
+          );
+        }
+      }
+      if (combined.recommendations.length > 0) {
+        console.log("  recommendations:");
+        for (const recommendation of combined.recommendations) {
+          console.log(`    - ${recommendation.text} (x${recommendation.occurrences})`);
+        }
+      }
+      return;
+    }
+    throw new OmniNodeError("REPORT_NOT_FOUND", `Report "${id}" was not found in the report store.`);
   });
 }
 
 // src/pipelines/engine.ts
-import { randomBytes as randomBytes2 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
 var PipelineEngine = class {
   constructor(options) {
     this.options = options;
@@ -1694,7 +2395,7 @@ var PipelineEngine = class {
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const run2 = {
-      id: `run-${Date.now().toString(36)}-${randomBytes2(3).toString("hex")}`,
+      id: `run-${Date.now().toString(36)}-${randomBytes3(3).toString("hex")}`,
       pipelineId: def.id,
       status: "running",
       startedAt: now,
@@ -1751,11 +2452,28 @@ ${contribution}`);
     }
     const failed = [...outcomes.values()].some((o) => o.status === "failed");
     const finalStatus = failed ? "failed" : "completed";
+    let combinedReportId;
+    if (this.options.reports) {
+      const taskIds = [...outcomes.values()].flatMap((o) => o.taskIds);
+      const tasks = (await Promise.all(taskIds.map((id) => this.options.tasks.get(id)))).filter((task) => task !== void 0);
+      const collected = await this.options.reports.collectFromTasks(tasks);
+      await this.options.reports.saveReports(collected);
+      const combined = await this.options.reports.generateCombined(collected, {
+        objective,
+        pipelineRunId: run2.id,
+        taskIds
+      });
+      combinedReportId = combined?.id;
+      if (collected.length > 0) {
+        run2.reports = collected;
+      }
+    }
     const finished = {
       ...run2,
       status: finalStatus,
       finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ...allReports.length > 0 ? { reports: allReports } : {}
+      ...run2.reports !== void 0 && run2.reports.length > 0 ? { reports: run2.reports } : {},
+      ...combinedReportId !== void 0 ? { combinedReportId } : {}
     };
     await this.options.store.save(finished);
     this.log.info(`Pipeline ${def.id} finished: ${finalStatus}.`);
@@ -1935,8 +2653,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 mkdir4, readFile as readFile4, rename as rename4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4 } from "path";
 var FilePipelineRunStore = class {
   filePath;
   queue = Promise.resolve();
@@ -1974,7 +2692,7 @@ var FilePipelineRunStore = class {
   }
   async load() {
     try {
-      const raw = await readFile2(this.filePath, "utf8");
+      const raw = await readFile4(this.filePath, "utf8");
       const parsed = JSON.parse(raw);
       return Array.isArray(parsed) ? parsed : [];
     } catch {
@@ -1983,10 +2701,10 @@ 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 mkdir4(dirname4(this.filePath), { recursive: true });
+    await writeFile4(tmp, `${JSON.stringify(runs, null, 2)}
 `, "utf8");
-    await rename2(tmp, this.filePath);
+    await rename4(tmp, this.filePath);
   }
 };
 
@@ -1998,6 +2716,7 @@ function buildPipelineEngine(config, log = logger) {
     agents,
     roles,
     store: new FileTaskStore(),
+    ...config.project.memory !== void 0 ? { memory: new MemoryService(createMemoryProvider(config.project.memory), log) } : {},
     log
   });
   return new PipelineEngine({
@@ -2007,6 +2726,7 @@ function buildPipelineEngine(config, log = logger) {
     providers: config.project.providers,
     store: new FilePipelineRunStore(),
     chat: createDefaultChatFn(config.project.providers),
+    reports: new ReportService(new FileReportStore(), log),
     log
   });
 }
@@ -2045,6 +2765,9 @@ function registerPipelineCommands(program) {
     if (finished.reports && finished.reports.length > 0) {
       console.log(`  reports: ${finished.reports.length} structured report(s)`);
     }
+    if (finished.combinedReportId) {
+      console.log(`  combined report: ${finished.combinedReportId}`);
+    }
     console.log(`Pipeline ${finished.status}. Run id: ${finished.id}`);
     if (finished.status !== "completed") process.exitCode = 1;
   });
@@ -2095,6 +2818,59 @@ function findPipeline(config, id) {
   return def;
 }
 
+// src/cli/commands/memory.ts
+function registerMemoryCommands(program) {
+  const memory = program.command("memory").description("Inspect and manage persistent project memory (\xA719\u2013\xA720).");
+  memory.command("status").description("Show the active memory provider and how much is stored.").action(async () => {
+    const config = loadConfig();
+    const configured = config.project.memory?.provider ?? "local (default \u2014 add a `memory:` section to opt in)";
+    const svc = new MemoryService(createMemoryProvider(config.project.memory));
+    const entries = await svc.providerRef.query({ limit: 1e4 });
+    console.log(`provider: ${configured}`);
+    console.log(`entries:  ${entries.length}`);
+    const scopes = /* @__PURE__ */ new Map();
+    for (const entry2 of entries) {
+      scopes.set(entry2.scope, (scopes.get(entry2.scope) ?? 0) + 1);
+    }
+    for (const [scope, count] of [...scopes.entries()].sort()) {
+      console.log(`  ${scope}: ${count}`);
+    }
+  });
+  memory.command("query <text>").description("Search memory for entries relevant to the text.").option("-s, --scope <scope>", "Restrict to a scope: project, task, role or knowledge.").option("-n, --limit <count>", "Maximum entries to return.", (value) => Number(value), 10).action(async (text, options) => {
+    const config = loadConfig();
+    const svc = new MemoryService(createMemoryProvider(config.project.memory));
+    const entries = await svc.providerRef.query({
+      text,
+      ...options.scope !== void 0 ? { scope: options.scope } : {},
+      limit: options.limit
+    });
+    if (entries.length === 0) {
+      console.log("No relevant memory found.");
+      return;
+    }
+    for (const entry2 of entries) {
+      console.log(`[${entry2.scope}] ${entry2.key}`);
+      console.log(`  ${truncate(entry2.content.replace(/\n/g, " "), 120)}`);
+    }
+  });
+  memory.command("write <text>").description("Write an entry to memory.").option("-s, --scope <scope>", "Memory scope: project, task, role or knowledge.", "project").option(
+    "-t, --tags <tags>",
+    "Comma-separated tags.",
+    (value) => value.split(",").map((tag) => tag.trim()).filter((tag) => tag.length > 0)
+  ).option("-k, --key <key>", "Entry key (defaults to a generated note key).").action(async (text, options) => {
+    const config = loadConfig();
+    const svc = new MemoryService(createMemoryProvider(config.project.memory));
+    const key = options.key ?? `note:${Date.now().toString(36)}`;
+    await svc.providerRef.write({
+      key,
+      scope: options.scope,
+      content: text,
+      ...options.tags !== void 0 && options.tags.length > 0 ? { tags: options.tags } : {}
+    });
+    console.log(`Stored memory entry "${key}" (${options.scope}).`);
+  });
+}
+
 // src/cli/index.ts
 function createProgram() {
   const program = new Command();
@@ -2110,6 +2886,7 @@ function createProgram() {
   registerReportCommands(program);
   registerModelsCommand(program);
   registerPipelineCommands(program);
+  registerMemoryCommands(program);
   return program;
 }
 async function run(argv) {