@hilbras/omninode 2.0.0-alpha.1 → 2.0.0-alpha.2

package/README.md

@@ -18,7 +18,7 @@ existing intelligence; it does not try to become another model.
 
 ## Status
 
-**v2.0.0-alpha.1 — v2 Phase 1: Architecture & API Stabilization** (the v2
+**v2.0.0-alpha.2 — v2 Phase 2: Execution Reliability** (after Phase 1: architecture & API stabilization) (the v2
 roadmap is [docs/ROADMAP_V2.md](docs/ROADMAP_V2.md); the v1 plan is complete:
 the
 full loop from §28 runs in one command —

package/dist/cli/index.js

@@ -6,7 +6,7 @@ import { realpathSync } from "fs";
 import { Command } from "commander";
 
 // src/version.ts
-var OMNINODE_VERSION = "2.0.0-alpha.1";
+var OMNINODE_VERSION = "2.0.0-alpha.2";
 
 // src/errors/index.ts
 var OmniNodeError = class extends Error {
@@ -1037,7 +1037,19 @@ var ProcessAgent = class {
               new AgentError(
                 "AGENT_TIMEOUT",
                 `Agent "${this.config.name}" timed out after ${timeoutMs}ms and was killed.`,
-                { details: { taskId: input.taskId, stdout: stdout.slice(0, 4e3), stderr: stderr.slice(0, 2e3) } }
+                {
+                  details: {
+                    operation: "agent.run",
+                    agent: this.config.name,
+                    durationMs: timeoutMs,
+                    // The process was started and may have performed side
+                    // effects before being killed — the outcome is unknown,
+                    // not failed (roadmap §6.3).
+                    dispatched: true,
+                    stdout: stdout.slice(0, 4e3),
+                    stderr: stderr.slice(0, 2e3)
+                  }
+                }
               )
             );
             return;
@@ -1397,12 +1409,18 @@ import { randomBytes } from "crypto";
 var ALLOWED_TRANSITIONS = {
   created: ["queued", "running", "cancelled"],
   queued: ["running", "cancelled"],
-  running: ["completed", "failed", "cancelled"],
+  running: ["completed", "failed", "timed_out", "unknown", "cancelled", "partially_completed"],
   waiting: ["running", "cancelled"],
   completed: [],
-  failed: [],
-  cancelled: []
+  // failed → running is the only re-entry: bounded automatic retry (§6.4).
+  failed: ["running"],
+  timed_out: [],
+  cancelled: [],
+  unknown: [],
+  partially_completed: []
 };
+var RETRYABLE_ERROR_CODES = ["AGENT_FAILED"];
+var EXECUTION_HISTORY_LIMIT = 10;
 var TaskEngine = class {
   constructor(options) {
     this.options = options;
@@ -1434,6 +1452,7 @@ var TaskEngine = class {
       id: generateTaskId(),
       objective: input.objective.trim(),
       status: "created",
+      attempt: 0,
       createdAt: now,
       updatedAt: now,
       ...input.project !== void 0 ? { project: input.project } : {},
@@ -1450,8 +1469,10 @@ var TaskEngine = class {
     const task = await this.mustGet(id);
     return this.transition(task, "queued");
   }
-  /** Runs the task through its assigned agent and records the result. */
-  async run(id) {
+  /** Runs the task through its assigned agent and records the result.
+   *  `maxAttempts` enables bounded automatic retries of *retryable* errors
+   *  with linear backoff; unknown/timed_out outcomes are never auto-retried. */
+  async run(id, options = {}) {
     const task = await this.mustGet(id);
     if (task.status !== "created" && task.status !== "queued") {
       throw new TaskError("TASK_INVALID", `Task ${id} is "${task.status}" and cannot be run.`);
@@ -1464,49 +1485,84 @@ var TaskEngine = class {
       throw new TaskError("TASK_INVALID", `Agent "${task.agent}" is not registered anymore.`);
     }
     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;
+    let background = task.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 } : {}
+        objective: task.objective,
+        ...task.role ? { role: task.role } : {},
+        ...task.project ? { project: task.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 } : {},
-        ...background !== void 0 ? { context: background } : {}
-      });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.log.error(`Task ${task.id} failed: ${message}`);
-      return this.transition(running, "failed", {
-        result: { error: message, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    const maxAttempts = Math.max(1, options.maxAttempts ?? 1);
+    const backoffMs = options.retryBackoffMs ?? 0;
+    let current = task;
+    for (let i = 0; i < maxAttempts; i += 1) {
+      const attempt = current.attempt + 1;
+      const executionId = `exec-${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`;
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      current = await this.transition(current, "running", { attempt });
+      let output;
+      let thrown;
+      try {
+        output = await agent.run({
+          taskId: current.id,
+          objective: current.objective,
+          ...role ? { role } : {},
+          ...background !== void 0 ? { context: background } : {}
+        });
+      } catch (error) {
+        thrown = error;
+      }
+      const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (thrown !== void 0 || output === void 0) {
+        const outcome = classifyThrown(thrown);
+        const message = thrown instanceof Error ? thrown.message : String(thrown);
+        const retryable = outcome === "failed" && RETRYABLE_ERROR_CODES.includes(errorCode(thrown)) && i < maxAttempts - 1;
+        current = await this.transition(current, outcome, {
+          attempt,
+          lastError: message,
+          execution: {
+            executionId,
+            attempt,
+            startedAt,
+            finishedAt,
+            outcome,
+            error: message
+          }
+        });
+        this.log.warn(`Task ${current.id} attempt ${attempt} \u2192 ${outcome}: ${message}`);
+        if (retryable) {
+          if (backoffMs > 0) await sleep(backoffMs * attempt);
+          continue;
+        }
+        if (this.options.memory) await this.options.memory.recordTaskOutcome(current);
+        return current;
+      }
+      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
+      };
+      const finalStatus = output.status === "completed" ? "completed" : "failed";
+      current = await this.transition(current, finalStatus, {
+        attempt,
+        result,
+        execution: { executionId, attempt, startedAt, finishedAt, outcome: finalStatus }
       });
+      this.log.info(`Task ${current.id} finished: ${finalStatus}.`);
+      break;
     }
-    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}.`);
     if (this.options.memory) {
-      await this.options.memory.recordTaskOutcome(finished);
+      await this.options.memory.recordTaskOutcome(current);
     }
-    return finished;
+    return current;
   }
   async cancel(id) {
     const task = await this.mustGet(id);
@@ -1519,13 +1575,14 @@ var TaskEngine = class {
     }
     return this.transition(task, "cancelled");
   }
-  /** Error recovery (§27 Phase 9): reset a failed/cancelled task so it can run again. */
+  /** Error recovery: reset a failed/cancelled/unknown/timed_out task so it can run again. */
   async retry(id) {
     const task = await this.mustGet(id);
-    if (task.status !== "failed" && task.status !== "cancelled") {
+    const retryableStates = ["failed", "cancelled", "unknown", "timed_out"];
+    if (!retryableStates.includes(task.status)) {
       throw new TaskError(
         "TASK_INVALID",
-        `Only failed or cancelled tasks can be retried \u2014 task ${id} is "${task.status}".`
+        `Only failed, timed out, unknown or cancelled tasks can be retried \u2014 task ${id} is "${task.status}".`
       );
     }
     const { result: _discarded, ...rest } = task;
@@ -1557,10 +1614,14 @@ var TaskEngine = class {
     if (!allowed.includes(to)) {
       throw new TaskError("TASK_INVALID", `Task ${task.id} cannot move from "${task.status}" to "${to}".`);
     }
+    const executions = extra.execution ? [...task.executions ?? [], extra.execution].slice(-EXECUTION_HISTORY_LIMIT) : task.executions;
     const updated = {
       ...task,
       status: to,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...extra.attempt !== void 0 ? { attempt: extra.attempt } : {},
+      ...extra.lastError !== void 0 ? { lastError: extra.lastError } : {},
+      ...executions !== void 0 ? { executions } : {},
       ...extra.result !== void 0 ? { result: { ...task.result, ...extra.result } } : {}
     };
     await this.options.store.save(updated);
@@ -1581,6 +1642,19 @@ var TaskEngine = class {
 function generateTaskId() {
   return `task-${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`;
 }
+function errorCode(error) {
+  return error?.code ?? "";
+}
+function classifyThrown(error) {
+  if (error instanceof AgentError && error.code === "AGENT_TIMEOUT") {
+    const dispatched = error.details?.dispatched;
+    return dispatched === false ? "timed_out" : "unknown";
+  }
+  return "failed";
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 // src/audit/index.ts
 import { appendFile, mkdir as mkdir2 } from "fs/promises";
@@ -1980,7 +2054,7 @@ 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) => {
+  task.command("retry <task-id>").description("Reset a failed, timed out, unknown or 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);
@@ -2003,6 +2077,15 @@ function printOutcome(task, options = {}) {
     if (task.context?.files) console.log(`  files:   ${task.context.files.join(", ")}`);
     console.log(`  objective: ${task.objective}`);
   }
+  if (options.verbose && task.attempt > 0) {
+    console.log(`  attempt: ${task.attempt}`);
+  }
+  if (task.lastError) console.log(`  error:   ${task.lastError}`);
+  if (options.verbose && task.executions && task.executions.length > 0) {
+    console.log(
+      `  executions: ${task.executions.map((e) => `#${e.attempt}:${e.outcome}`).join(", ")}`
+    );
+  }
   const result = task.result;
   if (!result) return;
   if (result.summary) console.log(`  summary: ${result.summary}`);
@@ -2743,7 +2826,7 @@ ${contribution}`);
         }
         const stepRun = {
           stepId: step.id,
-          status: outcome.status === "skipped" ? "cancelled" : outcome.status === "failed" ? "failed" : "completed",
+          status: outcome.status === "skipped" ? "cancelled" : outcome.status === "failed" ? "failed" : outcome.status === "partial" ? "partially_completed" : "completed",
           ...outcome.taskIds.length > 0 ? { taskIds: outcome.taskIds } : {},
           ...outcome.planId !== void 0 ? { planId: outcome.planId } : {},
           ...outcome.error !== void 0 ? { error: outcome.error } : {}
@@ -2754,8 +2837,10 @@ ${contribution}`);
       run2.reports = [...allReports];
       await this.options.store.save(run2);
     }
-    const failed = [...outcomes.values()].some((o) => o.status === "failed");
-    const finalStatus = failed ? "failed" : "completed";
+    const allOutcomes = [...outcomes.values()];
+    const failed = allOutcomes.some((o) => o.status === "failed");
+    const partial = !failed && allOutcomes.some((o) => o.status === "partial");
+    const finalStatus = failed ? "failed" : partial ? "partial" : "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) {
@@ -2861,6 +2946,7 @@ ${contribution}`);
       )
     );
     const results = await Promise.all(created.map((task) => this.options.tasks.run(task.id)));
+    const completedTasks = results.filter((r) => r.status === "completed");
     const failedTasks = results.filter((r) => r.status !== "completed");
     const lines = results.map((result, index) => {
       const agentName = agentNames[index] ?? "unknown";
@@ -2870,12 +2956,15 @@ ${contribution}`);
     const reports = results.flatMap((r) => r.result?.reports ?? []);
     const summary = lines.join("\n");
     if (failedTasks.length > 0) {
-      const firstError = failedTasks[0]?.result?.error ?? "unknown error";
+      const firstError = failedTasks[0]?.result?.error ?? failedTasks[0]?.lastError ?? "unknown outcome";
+      const states = failedTasks.map((r) => r.status).join(", ");
       return {
-        status: "failed",
+        // Some agents succeeded → the step produced usable but incomplete
+        // intelligence: partial, not failed (roadmap §9.3).
+        status: completedTasks.length > 0 ? "partial" : "failed",
         summary,
         taskIds: created.map((t) => t.id),
-        error: `${failedTasks.length}/${results.length} task(s) failed \u2014 ${firstError}`,
+        error: `${failedTasks.length}/${results.length} task(s) incomplete (${states}) \u2014 ${firstError}`,
         reports
       };
     }
@@ -2891,7 +2980,9 @@ ${contribution}`);
     const result = await this.options.tasks.run(task.id);
     if (result.status !== "completed") {
       return {
-        status: "failed",
+        // Unknown/timed_out outcomes are not failures — the work may have
+        // happened remotely; the step is incomplete, not broken.
+        status: result.status === "unknown" || result.status === "timed_out" ? "partial" : "failed",
         summary: result.result?.summary ?? "",
         taskIds: [task.id],
         error: result.result?.error ?? `task ${task.id} did not complete`,