@wrongstack/core 0.6.5 → 0.6.6

package/dist/defaults/index.d.ts

@@ -32,11 +32,11 @@ import '../index-DcnXDPdY.js';
 import '../system-prompt-gL06H9P4.js';
 import '../observability-BhnVLBLS.js';
 import '../selector-DDb_mq9X.js';
-import '../goal-store-_Er467ya.js';
+import '../goal-store-HHgaq5ue.js';
 import '../skill-CxuWrsKK.js';
 import 'node:events';
 import '../mode-CV077NjV.js';
-import '../task-graph-BITvWt4t.js';
+import '../task-graph-D1YQbpxF.js';
 
 /**
  * Default ProviderRunner — thin adapter over `runProviderWithRetry`.

package/dist/defaults/index.js

@@ -5449,23 +5449,33 @@ var EternalAutonomyEngine = class {
    * `agent.run()` avoids race conditions on the shared Context.
    */
   async runOneIteration() {
+    const emit = (stage) => {
+      this.opts.onStage?.(stage);
+    };
     const goal = await loadGoal(this.goalPath);
     if (!goal) {
+      emit({ phase: "stopped" });
       this.stopRequested = true;
       return false;
     }
     const missionState = goal.goalState ?? "active";
     if (missionState !== "active") {
+      emit({ phase: missionState === "paused" ? "paused" : "stopped" });
       this.stopRequested = true;
       return false;
     }
+    emit({ phase: "decide", reason: "picking next task" });
     const action = await this.decide(goal);
     if (!action) {
       if (!this.stopRequested) {
+        emit({ phase: "sleep", ms: 5e3 });
         await sleep(5e3);
+      } else {
+        emit({ phase: "stopped" });
       }
       return false;
     }
+    emit({ phase: "execute", task: action.task });
     const ctrl = new AbortController();
     this.currentCtrl = ctrl;
     const timer = setTimeout(
@@ -5543,6 +5553,7 @@ var EternalAutonomyEngine = class {
       tokens,
       costUsd
     });
+    emit({ phase: "reflect", status, note });
     let iterationIndex = 0;
     try {
       const reloaded = await loadGoal(this.goalPath);
@@ -5564,6 +5575,7 @@ var EternalAutonomyEngine = class {
         this.consecutiveTransientRetries++;
         const delay = this.computeTransientBackoffMs();
         if (delay > 0) {
+          emit({ phase: "sleep", ms: delay });
           await this.sleepInterruptible(delay);
         }
         return false;
@@ -5577,6 +5589,9 @@ var EternalAutonomyEngine = class {
       return false;
     }
     this.consecutiveTransientRetries = 0;
+    const cycleGapMs = this.opts.cycleGapMs ?? 1e3;
+    emit({ phase: "sleep", ms: cycleGapMs });
+    await sleep(cycleGapMs);
     if (GOAL_COMPLETE_MARKER.test(finalText)) {
       await this.markGoalCompleted(action, finalText);
       this.stopRequested = true;
@@ -10247,6 +10262,10 @@ var TaskTracker = class {
     node.updatedAt = now;
     if (status === "completed") {
       node.completedAt = now;
+      node.startedAt = node.startedAt ?? now;
+    }
+    if (status === "in_progress") {
+      node.startedAt = now;
     }
     this.transitions.push({ from, to: status, timestamp: now, reason });
     if (status === "completed") {
@@ -10258,6 +10277,23 @@ var TaskTracker = class {
     this.graph.updatedAt = now;
     this.persist();
   }
+  /**
+   * Update node fields (title, description, priority, estimateHours, tags).
+   * Does NOT change status. Use updateNodeStatus for status changes.
+   */
+  updateNode(id, patch) {
+    if (!this.graph) throw new Error("No graph loaded");
+    const node = this.graph.nodes.get(id);
+    if (!node) throw new Error(`Node ${id} not found`);
+    if (patch.title !== void 0) node.title = patch.title;
+    if (patch.description !== void 0) node.description = patch.description;
+    if (patch.priority !== void 0) node.priority = patch.priority;
+    if (patch.estimateHours !== void 0) node.estimateHours = patch.estimateHours;
+    if (patch.tags !== void 0) node.tags = patch.tags;
+    node.updatedAt = Date.now();
+    this.graph.updatedAt = node.updatedAt;
+    this.persist();
+  }
   getNode(id) {
     return this.graph?.nodes.get(id);
   }