@wrongstack/core 0.6.5 → 0.6.6

package/dist/execution/index.d.ts

@@ -7,7 +7,7 @@ import { c as MiddlewareHandler } from '../system-prompt-gL06H9P4.js';
 import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-DfC6g6KV.js';
 import { A as Agent, R as RunResult, j as SystemPromptContributor } from '../index-DcnXDPdY.js';
 import { D as DoneCondition } from '../multi-agent-D5IbASk_.js';
-import { J as JournalEntry } from '../goal-store-_Er467ya.js';
+import { J as JournalEntry } from '../goal-store-HHgaq5ue.js';
 import { A as AgentFactory } from '../agent-subagent-runner-DsSm9lKN.js';
 import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-CxuWrsKK.js';
 import { W as WstackPaths } from '../wstack-paths-86YPFktR.js';
@@ -334,6 +334,13 @@ interface EternalAutonomyOptions {
     /** Side-channel notifications (logging, UI updates). */
     onIteration?: (entry: JournalEntry) => void;
     onError?: (err: Error, iteration: number) => void;
+    /**
+     * Per-iteration phase notifications for live UI updates (TUI status bar,
+     * etc.). Fires at each major stage transition: idle → decide → execute →
+     * reflect → (sleep | paused | stopped). Fire-and-forget — the engine
+     * does not await the callback.
+     */
+    onStage?: (stage: IterationStage) => void;
     /**
      * Optional injected git status reader — production code uses git, tests
      * stub this out so they don't shell out.
@@ -382,6 +389,33 @@ interface EternalAutonomyOptions {
     transientBackoffMaxMs?: number;
 }
 type EternalEngineState = 'idle' | 'running' | 'stopped';
+/**
+ * Per-iteration phase emitted via `onStage` so UIs can render the
+ * engine's live location in the sense-decide-execute-reflect loop.
+ */
+type IterationStage = {
+    phase: 'idle';
+} | {
+    phase: 'decide';
+    reason: string;
+} | {
+    phase: 'execute';
+    task: string;
+} | {
+    phase: 'reflect';
+    status: 'success' | 'failure' | 'aborted' | 'skipped';
+    note?: string;
+} | {
+    phase: 'sleep';
+    ms: number;
+} | {
+    phase: 'paused';
+} | {
+    phase: 'stopped';
+} | {
+    phase: 'error';
+    message: string;
+};
 declare class EternalAutonomyEngine {
     private readonly opts;
     private state;
@@ -618,4 +652,4 @@ declare function makeAutonomyPromptContributor(opts: AutonomyPromptContributorOp
  */
 declare function buildGoalPreamble(goal: string): string;
 
-export { AutoCompactionMiddleware, AutonomousRunner, type AutonomousRunnerOptions, type AutonomyPromptContributorOptions, DefaultSkillLoader, type DoneCheckResult, DoneConditionChecker, EternalAutonomyEngine, type EternalAutonomyOptions, type EternalEngineState, IntelligentCompactor, type IntelligentCompactorOptions, type ParallelEngineState, ParallelEternalEngine, type ParallelEternalOptions, SelectiveCompactor, type SelectiveCompactorOptions, type SkillLoaderOptions, buildGoalPreamble, makeAutonomyPromptContributor };
+export { AutoCompactionMiddleware, AutonomousRunner, type AutonomousRunnerOptions, type AutonomyPromptContributorOptions, DefaultSkillLoader, type DoneCheckResult, DoneConditionChecker, EternalAutonomyEngine, type EternalAutonomyOptions, type EternalEngineState, IntelligentCompactor, type IntelligentCompactorOptions, type IterationStage, type ParallelEngineState, ParallelEternalEngine, type ParallelEternalOptions, SelectiveCompactor, type SelectiveCompactorOptions, type SkillLoaderOptions, buildGoalPreamble, makeAutonomyPromptContributor };

package/dist/execution/index.js

@@ -1789,23 +1789,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(
@@ -1883,6 +1893,7 @@ var EternalAutonomyEngine = class {
       tokens,
       costUsd
     });
+    emit({ phase: "reflect", status, note });
     let iterationIndex = 0;
     try {
       const reloaded = await loadGoal(this.goalPath);
@@ -1904,6 +1915,7 @@ var EternalAutonomyEngine = class {
         this.consecutiveTransientRetries++;
         const delay = this.computeTransientBackoffMs();
         if (delay > 0) {
+          emit({ phase: "sleep", ms: delay });
           await this.sleepInterruptible(delay);
         }
         return false;
@@ -1917,6 +1929,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;