@wrongstack/core 0.6.5 → 0.6.7

package/dist/{events-CJqwQl8G.d.ts → events-DounT6pP.d.ts}

@@ -1,4 +1,4 @@
-import { U as Usage, a2 as Context, z as ToolProgressEvent, v as Tool } from './context-DN5v-uQX.js';
+import { U as Usage, a2 as Context, z as ToolProgressEvent, v as Tool } from './context-C8mBUzBv.js';
 
 /**
  * EventBus — observe-only typed event bus.
@@ -341,6 +341,15 @@ interface EventMap {
             };
         };
     };
+    /**
+     * Fired by the delegate tool when a subagent finishes. The agent's run
+     * loop listens for this to collect `delegateSummaries` for the RunResult,
+     * so the CLI/TUI can render flashy completion banners.
+     */
+    'subagent.done': {
+        summary: string;
+        ok: boolean;
+    };
     'mcp.server.connected': {
         name: string;
         toolCount: number;

package/dist/execution/index.d.ts

@@ -1,21 +1,21 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-BF7QfYVE.js';
-import { g as Provider, a2 as Context } from '../context-DN5v-uQX.js';
-import { a as Compactor, C as CompactReport } from '../compactor-C8NhpSt5.js';
-import { M as MessageSelector } from '../selector-DDb_mq9X.js';
-import { E as EventBus } from '../events-CJqwQl8G.js';
-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 { A as AgentFactory } from '../agent-subagent-runner-DsSm9lKN.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-CwpjhwHC.js';
+import { g as Provider, a2 as Context } from '../context-C8mBUzBv.js';
+import { a as Compactor, C as CompactReport } from '../compactor-BUJ8550X.js';
+import { M as MessageSelector } from '../selector-DVo3eT-P.js';
+import { E as EventBus } from '../events-DounT6pP.js';
+import { c as MiddlewareHandler } from '../system-prompt-BBGles-N.js';
+import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-BHkYGzUT.js';
+import { A as Agent, R as RunResult, j as SystemPromptContributor } from '../index-DiIGZh5I.js';
+import { D as DoneCondition } from '../multi-agent-Iy8YUe3v.js';
+import { J as JournalEntry } from '../goal-store-HHgaq5ue.js';
+import { A as AgentFactory } from '../agent-subagent-runner-BTloSwjE.js';
 import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-CxuWrsKK.js';
 import { W as WstackPaths } from '../wstack-paths-86YPFktR.js';
-import '../retry-policy-BZSIMxrJ.js';
+import '../retry-policy-DOnwHAyz.js';
 import '../models-registry-Y2xbog0E.js';
 import '../logger-BMQgxvdy.js';
 import '../observability-BhnVLBLS.js';
-import '../secret-scrubber-CT7wefiO.js';
+import '../secret-scrubber-C9UJxFCJ.js';
 
 interface SkillLoaderOptions {
     paths: WstackPaths;
@@ -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.
@@ -380,8 +387,37 @@ interface EternalAutonomyOptions {
     transientBackoffBaseMs?: number;
     /** Ceiling for the exponential backoff. Default 60_000 (60 s). */
     transientBackoffMaxMs?: number;
+    /** Called when the eternal loop stops for any reason (manual stop, goal complete, etc.). */
+    onEternalStop?: () => void;
 }
 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;
@@ -477,6 +513,12 @@ declare class EternalAutonomyEngine {
      * goal is already `completed`.
      */
     private markGoalCompleted;
+    /**
+     * Manually clear the goal — equivalent to `/goal clear` typed by the user.
+     * Sets goalState to `abandoned`, removes the goal file, and fires
+     * `onEternalStop` so the REPL returns to normal mode.
+     */
+    private clearGoalManually;
     private appendFailure;
     private persistEngineState;
 }
@@ -618,4 +660,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

@@ -1707,7 +1707,8 @@ function appendJournal(goal, entry) {
 // src/execution/eternal-autonomy.ts
 var execFileP = promisify(execFile);
 var BRAINSTORM_DONE = /* @__PURE__ */ Symbol("brainstorm-done");
-var GOAL_COMPLETE_MARKER = /^\s*\[goal[_\s-]?complete\]\s*$/im;
+var GOAL_COMPLETE_MARKER = /^\s*\[goal[_\s-]*complete\]\s*$/im;
+var GOAL_CLEAR_MARKER = /^\s*\[\/?goal\s*clear\]\s*$/im;
 var EternalAutonomyEngine = class {
   constructor(opts) {
     this.opts = opts;
@@ -1789,23 +1790,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 +1894,7 @@ var EternalAutonomyEngine = class {
       tokens,
       costUsd
     });
+    emit({ phase: "reflect", status, note });
     let iterationIndex = 0;
     try {
       const reloaded = await loadGoal(this.goalPath);
@@ -1904,6 +1916,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,8 +1930,16 @@ 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);
+      await this.clearGoalManually(finalText);
+      this.stopRequested = true;
+      return true;
+    }
+    if (GOAL_CLEAR_MARKER.test(finalText)) {
+      await this.clearGoalManually(finalText);
       this.stopRequested = true;
       return true;
     }
@@ -2218,6 +2239,30 @@ ${recentJournal}` : "No prior iterations.",
     });
     await saveGoal(this.goalPath, withEntry);
   }
+  /**
+   * Manually clear the goal — equivalent to `/goal clear` typed by the user.
+   * Sets goalState to `abandoned`, removes the goal file, and fires
+   * `onEternalStop` so the REPL returns to normal mode.
+   */
+  async clearGoalManually(note) {
+    const current = await loadGoal(this.goalPath);
+    if (current) {
+      const abandoned = { ...current, goalState: "abandoned" };
+      await saveGoal(this.goalPath, abandoned);
+    }
+    try {
+      const { unlink: unlink2 } = await import('fs/promises');
+      await unlink2(this.goalPath);
+    } catch {
+    }
+    this.opts.onEternalStop?.();
+    void this.appendIterationEntry({
+      source: "manual",
+      task: "goal cleared",
+      status: "success",
+      note: note.slice(0, 240)
+    });
+  }
   async appendFailure(task, note) {
     await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
   }
@@ -2285,10 +2330,10 @@ var SubagentBudget = class _SubagentBudget {
    * or hung listener (Director not built / event filter detached mid-run)
    * leaves the budget over-limit and never enforces anything, since
    * `checkLimit` returns synchronously via `void this.checkLimitAsync`.
-   * Hardcoded for now — most fleets set their own per-task timeout that
-   * dwarfs this anyway. 30 s matches the existing event-emit timeoutMs.
+   * Raised from 30s to 60s to give subagents more headroom before
+   * the threshold negotiation times out and triggers a hard stop.
    */
-  static DECISION_TIMEOUT_MS = 3e4;
+  static DECISION_TIMEOUT_MS = 6e4;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
    * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
@@ -2718,13 +2763,19 @@ function providerStatusToCode(status, type) {
   return "PROVIDER_INVALID_REQUEST";
 }
 var FLEET_ROSTER_BUDGETS = {
-  "audit-log": { timeoutMs: 8 * 60 * 1e3, maxIterations: 150, maxToolCalls: 500 },
-  "bug-hunter": { timeoutMs: 15 * 60 * 1e3, maxIterations: 200, maxToolCalls: 600 },
-  "refactor-planner": { timeoutMs: 12 * 60 * 1e3, maxIterations: 180, maxToolCalls: 550 },
-  "security-scanner": { timeoutMs: 15 * 60 * 1e3, maxIterations: 200, maxToolCalls: 600 }
+  "audit-log": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 5e3, maxToolCalls: 15e3 },
+  "bug-hunter": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
+  "refactor-planner": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 6e3, maxToolCalls: 18e3 },
+  "security-scanner": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 }
+};
+var GENERIC_SUBAGENT_BUDGET = {
+  timeoutMs: 3 * 60 * 60 * 1e3,
+  maxIterations: 5e3,
+  maxToolCalls: 15e3
 };
 function applyRosterBudget(cfg) {
-  const defaultBudget = FLEET_ROSTER_BUDGETS[cfg.role ?? ""];
+  const roleBudget = cfg.role ? FLEET_ROSTER_BUDGETS[cfg.role] : void 0;
+  const defaultBudget = roleBudget ?? (cfg.name ? GENERIC_SUBAGENT_BUDGET : void 0);
   if (!defaultBudget) return cfg;
   return {
     ...cfg,
@@ -2795,7 +2846,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
       // hasParentBridge() — the type now reflects this.
       parentBridge: null,
       doneCondition: this.config.doneCondition,
-      maxConcurrent: this.config.maxConcurrent ?? 4
+      maxConcurrent: this.config.maxConcurrent ?? 16
     };
     this.subagents.set(id, {
       config: { ...subagent, id },
@@ -2922,7 +2973,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     }
   }
   canDispatch() {
-    const max = this.config.maxConcurrent ?? 4;
+    const max = this.config.maxConcurrent ?? 16;
     return this.inFlight < max && this.pendingTasks.length > 0;
   }
   takeNextDispatchableTask() {
@@ -3016,13 +3067,18 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     task.subagentId = subagentId;
     subagent.context.tasks.push(task);
     this.emit("task.assigned", { task, subagentId });
+    const rawMaxIterations = subagent.config.maxIterations;
+    const rawMaxToolCalls = subagent.config.maxToolCalls;
+    const rawMaxTokens = subagent.config.maxTokens;
+    const rawMaxCostUsd = subagent.config.maxCostUsd;
+    const rawTimeoutMs = subagent.config.timeoutMs;
     const configWithRosterDefaults = applyRosterBudget(subagent.config);
     const budget = new SubagentBudget({
-      maxIterations: configWithRosterDefaults.maxIterations ?? this.config.defaultBudget?.maxIterations,
-      maxToolCalls: task.maxToolCalls ?? configWithRosterDefaults.maxToolCalls ?? this.config.defaultBudget?.maxToolCalls,
-      maxTokens: configWithRosterDefaults.maxTokens ?? this.config.defaultBudget?.maxTokens,
-      maxCostUsd: configWithRosterDefaults.maxCostUsd ?? this.config.defaultBudget?.maxCostUsd,
-      timeoutMs: task.timeoutMs ?? configWithRosterDefaults.timeoutMs ?? this.config.defaultBudget?.timeoutMs
+      maxIterations: rawMaxIterations ?? this.config.defaultBudget?.maxIterations ?? configWithRosterDefaults.maxIterations,
+      maxToolCalls: rawMaxToolCalls ?? this.config.defaultBudget?.maxToolCalls ?? configWithRosterDefaults.maxToolCalls,
+      maxTokens: rawMaxTokens ?? this.config.defaultBudget?.maxTokens ?? configWithRosterDefaults.maxTokens,
+      maxCostUsd: rawMaxCostUsd ?? this.config.defaultBudget?.maxCostUsd ?? configWithRosterDefaults.maxCostUsd,
+      timeoutMs: rawTimeoutMs ?? this.config.defaultBudget?.timeoutMs ?? configWithRosterDefaults.timeoutMs
     });
     subagent.activeBudget = budget;
     if (!this.runner) {
@@ -3093,7 +3149,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
                   kind: "timeout",
                   used: elapsed,
                   limit,
-                  timeoutMs: 3e4,
+                  timeoutMs: 6e4,
                   extend: (extra) => resolveDecision({ extend: extra }),
                   deny: () => resolveDecision("stop")
                 });