@hilbras/omninode 0.9.0 → 1.0.0

package/README.md

@@ -18,8 +18,26 @@ existing intelligence; it does not try to become another model.
 
 ## Status
 
-**v0.9.0 — Phase 8: Planner System** (see [docs/DEVELOPMENT_PLAN.md](docs/DEVELOPMENT_PLAN.md)
-for the full plan and roadmap).
+**v1.0.0 — Phases 10 + 11: Production Release.** The plan is complete: the
+full loop from §28 runs in one command —
+`User → project context → memory → research agents → reports → aggregation →
+planner → plan → execution → result` — with audit logging, error recovery and
+production hardening (see [docs/DEVELOPMENT_PLAN.md](docs/DEVELOPMENT_PLAN.md)
+for the plan and [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the design).
+
+### What's in v1.0
+
+| Capability | Where |
+| --- | --- |
+| Provider abstraction, custom providers, model discovery | `src/providers/`, `src/registry/` |
+| OmniHilbras integration (optional) | `src/providers/omnihilbras/` |
+| CLI agents (stdin/arg/protocol), agent registry | `src/agents/` |
+| Roles, projects, tasks (lifecycle + retry) | `src/roles/`, `src/tasks/` |
+| Pipelines (DAG, parallel, retries, conditions) | `src/pipelines/` |
+| Multi-AI research + report aggregation | `src/reports/` |
+| Planner layer (model + heuristic) | `src/planner/` |
+| Remembera / local memory | `src/memory/` |
+| CLI, configuration, security foundations, docs | `src/cli/`, `src/config/`, `docs/` |
 
 What exists today:
 
@@ -97,6 +115,15 @@ What exists today:
   - Plans persist to `.omninode/plans.json`; pipeline runs record `planId`
   - Configure with `planner: { kind: model | heuristic, model, instruction }`
     — never hardcoded to any provider
+- **End-to-end workflow** (§28, §27 Phase 9):
+  - One-command execution via the top-level `run` alias (`omninode run <pipeline> "<objective>"`)
+  - `omninode status` — full project state overview: providers, agents,
+    roles, pipelines, task/run/report/plan counts, memory provider + entries
+  - Pipeline runs persist their objective and a final `resultSummary` (§28 "Result")
+  - Error recovery: `task retry [--run]` (reset a failed/cancelled task) and
+    `pipeline retry <run-id>` (re-run a recorded failed run as a new run)
+  - Full integration test (`tests/e2e.test.ts`) drives the entire §28 workflow
+    through the real CLI against a local gateway
 - Typed error hierarchy (`src/errors/`)
 - Leveled logger with pluggable sink (`src/logger/`)
 - Configuration system: `omninode.yaml` with `${ENV_VAR}` expansion and strict
@@ -190,6 +217,14 @@ project:
     model: my-gateway:chatgpt
 ```
 
+```bash
+omninode init
+omninode status
+omninode run repo-audit "Audit the authentication module"   # the whole workflow
+omninode pipeline retry run-xxxx                             # recover a failed run
+omninode task retry task-yyyy --run                          # recover a failed task
+```
+
 Persistent memory (§19–§20) — opt in with `memory: { provider: local }` or
 `provider: remembera` in `omninode.yaml`:
 
@@ -233,17 +268,27 @@ Phases 0–11 are laid out in [docs/DEVELOPMENT_PLAN.md](docs/DEVELOPMENT_PLAN.m
 | v0.3.0 | OmniHilbras Integration (optional, like every provider) |
 | v0.4.0 | Agent System |
 | v0.5.0 | Roles & Tasks |
-| v0.7.0 | Multi-AI Reports |
+| v0.6.0 | Pipeline Engine |
 | v0.7.0 | Multi-AI Reports |
 | v0.8.0 | Remembera / Memory |
-| **v0.9.0** | **Planner (current)** |
-| v0.10.0 | End-to-End Runtime |
-| v1.0.0 | Production Release |
+| v0.9.0 | Planner |
+| v0.10.0 | End-to-End Workflow (current) |
+| **v1.0.0** | **Production Release — Phases 10 + 11 (current, final)** |
 
 Core architectural rule: OmniNode must run successfully with **zero Hilbras
 dependencies**. OmniHilbras and Remembera make it more powerful, but neither is
 required for the core engine.
 
+## Documentation
+
+- [Development plan](docs/DEVELOPMENT_PLAN.md) — the full 12-phase roadmap
+- [Architecture](docs/ARCHITECTURE.md) — module map, workflow, local state
+- [Security model](docs/SECURITY.md) — secrets, process execution, env isolation, audit log
+- [Example project](examples/demo/) — a runnable end-to-end demo (`./demo.sh`)
+
+Prefer a container? `docker build -t omninode .` then
+`docker run --rm -v "$PWD:/work" -w /work omninode run my-pipeline "audit the repo"`.
+
 ## Install
 
 ```bash

package/dist/cli/index.js

@@ -6,7 +6,7 @@ import { realpathSync } from "fs";
 import { Command } from "commander";
 
 // src/version.ts
-var OMNINODE_VERSION = "0.9.0";
+var OMNINODE_VERSION = "1.0.0";
 
 // src/errors/index.ts
 var OmniNodeError = class extends Error {
@@ -87,6 +87,7 @@ var agentConfigSchema = z.object({
   env: z.record(z.string()).optional(),
   input_mode: z.enum(["stdin", "arg", "protocol"]).default("stdin"),
   timeout_ms: z.number().int().positive().optional(),
+  inherit_env: z.boolean().optional(),
   metadata: z.record(z.unknown()).optional()
 }).strict();
 var roleConfigSchema = z.object({
@@ -260,6 +261,7 @@ function toAgentConfig(raw) {
     env: raw.env,
     inputMode: raw.input_mode,
     timeoutMs: raw.timeout_ms,
+    inheritEnv: raw.inherit_env,
     metadata: raw.metadata
   };
 }
@@ -897,6 +899,17 @@ function registerModelsCommand(program) {
 import { spawn } from "child_process";
 var DEFAULT_TIMEOUT_MS2 = 6e5;
 var KILL_GRACE_MS = 5e3;
+function buildChildEnv(config) {
+  const configured = config.env ?? {};
+  if (config.inheritEnv !== false) {
+    return { ...process.env, ...configured };
+  }
+  return {
+    PATH: process.env.PATH ?? "",
+    HOME: process.env.HOME ?? "",
+    ...configured
+  };
+}
 function composeTaskText(input) {
   const sections = [`# Objective
 ${input.objective}`];
@@ -963,7 +976,7 @@ var ProcessAgent = class {
         [...this.config.args ?? [], ...mode === "arg" ? [composeTaskText(input)] : []],
         {
           cwd: this.config.cwd,
-          env: { ...process.env, ...this.config.env },
+          env: buildChildEnv(this.config),
           stdio: ["pipe", "pipe", "pipe"]
         }
       );
@@ -1400,6 +1413,7 @@ var TaskEngine = class {
     };
     await this.options.store.save(task);
     this.log.info(`Created task ${task.id}.`);
+    await this.audit("task.created", task.id, { objective: task.objective, project: task.project });
     return task;
   }
   async queue(id) {
@@ -1475,6 +1489,26 @@ 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);
+    await this.audit("task.retry", id, { from: task.status });
+    this.log.info(`Task ${id} reset for retry.`);
+    return reset;
+  }
   async get(id) {
     return this.options.store.get(id);
   }
@@ -1500,16 +1534,68 @@ var TaskEngine = class {
       ...extra.result !== void 0 ? { result: { ...task.result, ...extra.result } } : {}
     };
     await this.options.store.save(updated);
+    await this.audit(`task.${to === "queued" ? "queued" : to}`, updated.id, {
+      from: task.status
+    });
     return updated;
   }
+  async audit(action, id, detail) {
+    await this.options.audit?.record({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      action,
+      id,
+      ...detail !== void 0 ? { detail } : {}
+    });
+  }
 };
 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";
+// src/audit/index.ts
+import { appendFile, mkdir as mkdir2 } from "fs/promises";
 import { dirname as dirname2 } from "path";
+var FileAuditLog = class {
+  filePath;
+  log;
+  constructor(directory = `${process.cwd()}/.omninode`, log = logger) {
+    this.filePath = `${directory}/audit.jsonl`;
+    this.log = log.child({ component: "audit" });
+  }
+  async record(event) {
+    try {
+      await mkdir2(dirname2(this.filePath), { recursive: true });
+      await appendFile(this.filePath, `${JSON.stringify(event)}
+`, "utf8");
+    } catch (error) {
+      this.log.warn(
+        `Audit write failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /** Recent events, oldest first; used by the CLI. */
+  async recent(limit = 20) {
+    const { readFile: readFile6 } = await import("fs/promises");
+    let raw;
+    try {
+      raw = await readFile6(this.filePath, "utf8");
+    } catch {
+      return [];
+    }
+    const events = raw.split("\n").filter((line) => line.length > 0).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return void 0;
+      }
+    }).filter((event) => event !== void 0);
+    return events.slice(-limit);
+  }
+};
+
+// src/memory/local.ts
+import { mkdir as mkdir3, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3 } from "path";
 var STOPWORDS = /* @__PURE__ */ new Set([
   "the",
   "and",
@@ -1622,7 +1708,7 @@ var LocalMemoryProvider = class {
   }
   async saveAll(entries) {
     const tmp = `${this.filePath}.tmp`;
-    await mkdir2(dirname2(this.filePath), { recursive: true });
+    await mkdir3(dirname3(this.filePath), { recursive: true });
     await writeFile2(tmp, `${JSON.stringify(entries, null, 2)}
 `, "utf8");
     await rename2(tmp, this.filePath);
@@ -1829,6 +1915,7 @@ function createTaskEngine(config, log = logger, directory) {
     roles,
     store: new FileTaskStore(directory),
     ...config.project.memory !== void 0 ? { memory: new MemoryService(createMemoryProvider(config.project.memory), log) } : {},
+    audit: new FileAuditLog(),
     log
   });
 }
@@ -1894,6 +1981,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}`);
@@ -2130,8 +2228,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 mkdir4, readFile as readFile3, rename as rename3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname4 } from "path";
 var FileReportStore = class {
   filePath;
   queue = Promise.resolve();
@@ -2204,7 +2302,7 @@ var FileReportStore = class {
   }
   async write(entries) {
     const tmp = `${this.filePath}.tmp`;
-    await mkdir3(dirname3(this.filePath), { recursive: true });
+    await mkdir4(dirname4(this.filePath), { recursive: true });
     await writeFile3(tmp, `${JSON.stringify(entries, null, 2)}
 `, "utf8");
     await rename3(tmp, this.filePath);
@@ -2639,12 +2737,19 @@ var PipelineEngine = class {
     const run2 = {
       id: `run-${Date.now().toString(36)}-${randomBytes5(3).toString("hex")}`,
       pipelineId: def.id,
+      objective,
       status: "running",
       startedAt: now,
       stepRuns: []
     };
     await this.options.store.save(run2);
     this.log.info(`Running pipeline ${def.id} as ${run2.id}.`);
+    await this.options.audit?.record({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      action: "pipeline.run.started",
+      id: run2.id,
+      detail: { pipeline: def.id, objective }
+    });
     const deps = this.effectiveDependencies(def);
     const outcomes = /* @__PURE__ */ new Map();
     const pending = new Set(def.steps.map((s) => s.id));
@@ -2698,9 +2803,19 @@ ${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);
@@ -2720,10 +2835,17 @@ ${contribution}`);
       finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...run2.reports !== void 0 && run2.reports.length > 0 ? { reports: run2.reports } : {},
       ...combinedReportId !== void 0 ? { combinedReportId } : {},
-      ...planId !== void 0 ? { planId } : {}
+      ...planId !== void 0 ? { planId } : {},
+      ...resultSummary !== void 0 ? { resultSummary } : {}
     };
     await this.options.store.save(finished);
     this.log.info(`Pipeline ${def.id} finished: ${finalStatus}.`);
+    await this.options.audit?.record({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      action: "pipeline.run.finished",
+      id: run2.id,
+      detail: { pipeline: def.id, status: finalStatus }
+    });
     return finished;
   }
   async get(runId) {
@@ -2868,6 +2990,12 @@ ${contribution}`);
       };
     }
     await this.options.plans?.save(plan);
+    await this.options.audit?.record({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      action: "plan.generated",
+      id: plan.id,
+      detail: { generatedBy: plan.generatedBy, steps: plan.steps.length }
+    });
     return {
       status: "completed",
       summary: plan.summary,
@@ -2925,8 +3053,8 @@ function createDefaultChatFn(providers) {
 }
 
 // src/pipelines/store.ts
-import { mkdir as mkdir4, readFile as readFile4, rename as rename4, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname4 } from "path";
+import { mkdir as mkdir5, readFile as readFile4, rename as rename4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname5 } from "path";
 var FilePipelineRunStore = class {
   filePath;
   queue = Promise.resolve();
@@ -2973,7 +3101,7 @@ var FilePipelineRunStore = class {
   }
   async write(runs) {
     const tmp = `${this.filePath}.tmp`;
-    await mkdir4(dirname4(this.filePath), { recursive: true });
+    await mkdir5(dirname5(this.filePath), { recursive: true });
     await writeFile4(tmp, `${JSON.stringify(runs, null, 2)}
 `, "utf8");
     await rename4(tmp, this.filePath);
@@ -2981,8 +3109,8 @@ 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";
+import { mkdir as mkdir6, readFile as readFile5, rename as rename5, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname6 } from "path";
 var FilePlanStore = class {
   filePath;
   queue = Promise.resolve();
@@ -3029,7 +3157,7 @@ var FilePlanStore = class {
   }
   async write(plans) {
     const tmp = `${this.filePath}.tmp`;
-    await mkdir5(dirname5(this.filePath), { recursive: true });
+    await mkdir6(dirname6(this.filePath), { recursive: true });
     await writeFile5(tmp, `${JSON.stringify(plans, null, 2)}
 `, "utf8");
     await rename5(tmp, this.filePath);
@@ -3067,6 +3195,7 @@ function buildPipelineEngine(config, log = logger) {
     roles,
     store: new FileTaskStore(),
     ...config.project.memory !== void 0 ? { memory: new MemoryService(createMemoryProvider(config.project.memory), log) } : {},
+    audit: new FileAuditLog(),
     log
   });
   return new PipelineEngine({
@@ -3079,6 +3208,7 @@ function buildPipelineEngine(config, log = logger) {
     ...config.project.planner !== void 0 ? { planner: buildPlanner(config.project.planner, chat, log) } : {},
     plans: new FilePlanStore(),
     reports: new ReportService(new FileReportStore(), log),
+    audit: new FileAuditLog(),
     log
   });
 }
@@ -3100,31 +3230,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)`);
-    }
-    if (finished.combinedReportId) {
-      console.log(`  combined report: ${finished.combinedReportId}`);
+    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.planId) {
-      console.log(`  plan: ${finished.planId}`);
+    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();
@@ -3153,6 +3279,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}`);
     }
@@ -3161,6 +3288,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) {
@@ -3272,6 +3431,96 @@ function registerPlanCommands(program) {
   });
 }
 
+// src/cli/commands/status.ts
+function groupBy(items, key) {
+  const counts = {};
+  for (const item of items) {
+    const k = key(item);
+    counts[k] = (counts[k] ?? 0) + 1;
+  }
+  return counts;
+}
+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).").option("--json", "Emit machine-readable JSON (for scripts and CI).").action(async (options) => {
+    const config = loadConfig();
+    const tasks = await new FileTaskStore().list();
+    const runs = await new FilePipelineRunStore().list();
+    const reportStore = new FileReportStore();
+    const reports = await reportStore.listReports();
+    const combined = await reportStore.listCombined();
+    const plans = await new FilePlanStore().list();
+    let memory;
+    if (config.project.memory !== void 0) {
+      const service2 = new MemoryService(createMemoryProvider(config.project.memory));
+      memory = {
+        provider: service2.providerName,
+        entries: (await service2.providerRef.query({ limit: 1e4 })).length
+      };
+    }
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            version: OMNINODE_VERSION,
+            project: config.project.name,
+            providers: config.project.providers.map((p) => p.name),
+            agents: config.project.agents.map((a) => a.name),
+            roles: config.project.roles.map((r) => r.id),
+            pipelines: config.project.pipelines.map((p) => p.id),
+            tasks: { total: tasks.length, byStatus: groupBy(tasks, (t) => t.status) },
+            runs: { total: runs.length, byStatus: groupBy(runs, (r) => r.status) },
+            reports: { raw: reports.length, combined: combined.length },
+            plans: plans.length,
+            ...memory !== void 0 ? { memory } : {}
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(`OmniNode v${OMNINODE_VERSION} \u2014 project "${config.project.name}"`);
+    console.log(`providers: ${config.project.providers.map((p) => p.name).join(", ") || "none"}`);
+    console.log(`agents:    ${config.project.agents.map((a) => a.name).join(", ") || "none"}`);
+    console.log(`roles:     ${config.project.roles.map((r) => r.id).join(", ") || "none"}`);
+    console.log(`pipelines: ${config.project.pipelines.map((p) => p.id).join(", ") || "none"}`);
+    console.log(`tasks:     ${countBy(tasks, (t) => t.status)}`);
+    console.log(`runs:      ${countBy(runs, (r) => r.status)}`);
+    console.log(`reports:   ${reports.length} raw, ${combined.length} combined`);
+    console.log(`plans:     ${plans.length}`);
+    if (memory) {
+      console.log(`memory:    ${memory.provider}, ${memory.entries} entr(ies)`);
+    } else {
+      console.log("memory:    not configured (local provider available \u2014 add a `memory:` section)");
+    }
+  });
+}
+
+// src/cli/commands/audit.ts
+function registerAuditCommand(program) {
+  program.command("audit").description("Show the recent audit log \u2014 task and pipeline lifecycle events (\xA724).").option("-n, --limit <count>", "Number of events to show (default 20).", (value) => Number(value), 20).action(async (options) => {
+    const events = await new FileAuditLog().recent(options.limit);
+    if (events.length === 0) {
+      console.log("No audit events recorded yet.");
+      return;
+    }
+    for (const event of events) {
+      const id = event.id ? ` ${event.id}` : "";
+      const detail = event.detail && Object.keys(event.detail).length > 0 ? ` ${JSON.stringify(event.detail)}` : "";
+      console.log(`${event.at}  ${event.action}${id}${detail}`);
+    }
+  });
+}
+
 // src/cli/index.ts
 function createProgram() {
   const program = new Command();
@@ -3289,6 +3538,9 @@ function createProgram() {
   registerPipelineCommands(program);
   registerMemoryCommands(program);
   registerPlanCommands(program);
+  registerStatusCommand(program);
+  registerAuditCommand(program);
+  registerRunAlias(program);
   return program;
 }
 async function run(argv) {