@wrongstack/core 0.6.6 → 0.7.0

package/dist/{events-CJqwQl8G.d.ts → events-CEKFTmIY.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, a5 as Context, D as ToolProgressEvent, x as Tool } from './context-bmR0YgBm.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,22 @@
-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';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-D5NFi_LV.js';
+import { i as Provider, a5 as Context } from '../context-bmR0YgBm.js';
+import { a as Compactor, C as CompactReport } from '../compactor-CWV1u-IU.js';
+import { M as MessageSelector } from '../selector-CP39HhCe.js';
+import { E as EventBus } from '../events-CEKFTmIY.js';
+import { c as MiddlewareHandler } from '../system-prompt-CfgXqyv2.js';
+import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-C34JRwl4.js';
+import { A as Agent, R as RunResult, j as SystemPromptContributor } from '../index-BJIFLGII.js';
+import { D as DoneCondition } from '../multi-agent-Cm1wYSrw.js';
 import { J as JournalEntry } from '../goal-store-HHgaq5ue.js';
-import { A as AgentFactory } from '../agent-subagent-runner-DsSm9lKN.js';
+import { A as AgentFactory, D as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-CCupVFqv.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-Dpxp4SET.js';
 import '../models-registry-Y2xbog0E.js';
 import '../logger-BMQgxvdy.js';
 import '../observability-BhnVLBLS.js';
-import '../secret-scrubber-CT7wefiO.js';
+import '../secret-scrubber-C2YCYtkn.js';
+import 'node:events';
 
 interface SkillLoaderOptions {
     paths: WstackPaths;
@@ -301,7 +302,8 @@ interface EternalAutonomyOptions {
      * Maximum number of internal agent.run iterations the engine grants per
      * eternal-loop tick. The engine sets `autonomousContinue: true` so the
      * agent can run multi-step tasks end-to-end within one tick instead of
-     * bouncing back to the engine after every single tool call. Default 50.
+     * bouncing back to the engine after every single tool call. Default 500.
+     * Previous 50 was far too low — agents hit the limit and restart constantly.
      */
     iterationMaxAgentSteps?: number;
     /**
@@ -387,6 +389,8 @@ 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';
 /**
@@ -511,6 +515,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;
 }
@@ -565,6 +575,10 @@ declare class ParallelEternalEngine {
     private agentFactory;
     constructor(opts: ParallelEternalOptions);
     get currentState(): ParallelEngineState;
+    /**
+     * Get the underlying coordinator for stats/monitoring.
+     */
+    getCoordinator(): DefaultMultiAgentCoordinator | null;
     stop(): void;
     prime(): Promise<void>;
     run(): Promise<void>;

package/dist/execution/index.js

@@ -917,6 +917,22 @@ Summarize the following message range:`;
 };
 
 // src/types/errors.ts
+var ERROR_CODES = {
+  // Provider
+  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
+  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
+  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
+  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
+  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
+  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
+  // Agent
+  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
+  AGENT_ABORTED: "AGENT_ABORTED",
+  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
+  // File system
+  FS_READ_FAILED: "FS_READ_FAILED",
+  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED"};
 var WrongStackError = class extends Error {
   code;
   subsystem;
@@ -951,23 +967,39 @@ var AgentError = class extends WrongStackError {
       message: opts.message,
       code: opts.code,
       subsystem: "agent",
-      severity: opts.code === "AGENT_ABORTED" ? "warning" : "error",
-      recoverable: opts.recoverable ?? opts.code === "AGENT_ITERATION_LIMIT",
+      severity: opts.code === ERROR_CODES.AGENT_ABORTED ? "warning" : "error",
+      recoverable: opts.recoverable ?? opts.code === ERROR_CODES.AGENT_ITERATION_LIMIT,
       context: opts.context,
       cause: opts.cause
     });
     this.name = "AgentError";
   }
 };
-function toWrongStackError(err, code = "AGENT_RUN_FAILED") {
+function toWrongStackError(err, code = ERROR_CODES.AGENT_RUN_FAILED) {
   if (err instanceof WrongStackError) return err;
   const message = err instanceof Error ? err.message : String(err);
   return new AgentError({
     message,
-    code: code === "UNKNOWN" ? "AGENT_RUN_FAILED" : code,
+    code: code === "UNKNOWN" ? ERROR_CODES.AGENT_RUN_FAILED : code,
     cause: err
   });
 }
+var FsError = class extends WrongStackError {
+  path;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "fs",
+      severity: "error",
+      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
+      context: { path: opts.path, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FsError";
+    this.path = opts.path;
+  }
+};
 
 // src/execution/auto-compaction-middleware.ts
 var AutoCompactionMiddleware = class {
@@ -1059,7 +1091,7 @@ var AutoCompactionMiddleware = class {
       if (fatal) {
         throw new AgentError({
           message: `Auto-compaction failed at ${pressure.level} threshold`,
-          code: "AGENT_CONTEXT_OVERFLOW",
+          code: ERROR_CODES.AGENT_CONTEXT_OVERFLOW,
           recoverable: true,
           context: {
             level: pressure.level,
@@ -1688,7 +1720,16 @@ async function loadGoal(filePath) {
   }
 }
 async function saveGoal(filePath, goal) {
-  await atomicWrite(filePath, JSON.stringify(goal, null, 2), { mode: 384 });
+  try {
+    await atomicWrite(filePath, JSON.stringify(goal, null, 2), { mode: 384 });
+  } catch (err) {
+    throw new FsError({
+      message: err instanceof Error ? err.message : String(err),
+      code: ERROR_CODES.FS_ATOMIC_WRITE_FAILED,
+      path: filePath,
+      cause: err
+    });
+  }
 }
 function appendJournal(goal, entry) {
   const iteration = goal.iterations + 1;
@@ -1707,7 +1748,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;
@@ -1845,7 +1887,7 @@ var EternalAutonomyEngine = class {
           // Cap the inner loop so a runaway agent.run can't burn through
           // the iteration timeout — the engine's own outer loop is the
           // long-running thing, each tick should be bounded.
-          maxIterations: this.opts.iterationMaxAgentSteps ?? 50
+          maxIterations: this.opts.iterationMaxAgentSteps ?? 500
         }
       );
       if (result.status === "aborted") {
@@ -1933,7 +1975,12 @@ var EternalAutonomyEngine = class {
     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;
     }
@@ -2233,6 +2280,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 });
   }
@@ -2300,10 +2371,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.
@@ -2723,23 +2794,29 @@ function truncate(s, n) {
   return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
 }
 function providerStatusToCode(status, type) {
-  if (status === 0) return "PROVIDER_NETWORK_ERROR";
-  if (type === "rate_limit_error" || status === 429) return "PROVIDER_RATE_LIMITED";
-  if (type === "authentication_error" || status === 401) return "PROVIDER_AUTH_FAILED";
-  if (type === "overloaded_error" || status === 529) return "PROVIDER_OVERLOADED";
-  if (type === "invalid_request_error" || status === 400) return "PROVIDER_INVALID_REQUEST";
-  if (status === 408) return "PROVIDER_NETWORK_ERROR";
-  if (status >= 500) return "PROVIDER_SERVER_ERROR";
-  return "PROVIDER_INVALID_REQUEST";
+  if (status === 0) return ERROR_CODES.PROVIDER_NETWORK_ERROR;
+  if (type === "rate_limit_error" || status === 429) return ERROR_CODES.PROVIDER_RATE_LIMITED;
+  if (type === "authentication_error" || status === 401) return ERROR_CODES.PROVIDER_AUTH_FAILED;
+  if (type === "overloaded_error" || status === 529) return ERROR_CODES.PROVIDER_OVERLOADED;
+  if (type === "invalid_request_error" || status === 400) return ERROR_CODES.PROVIDER_INVALID_REQUEST;
+  if (status === 408) return ERROR_CODES.PROVIDER_NETWORK_ERROR;
+  if (status >= 500) return ERROR_CODES.PROVIDER_SERVER_ERROR;
+  return ERROR_CODES.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,
@@ -2810,7 +2887,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 },
@@ -2856,6 +2933,30 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     this.drainPendingAsAborted("Coordinator stopAll() drained the pending queue");
     await Promise.allSettled([...this.subagents.keys()].map((id) => this.stop(id)));
   }
+  async remove(subagentId) {
+    await this.stop(subagentId);
+    this.subagents.delete(subagentId);
+  }
+  /**
+   * Get current coordinator stats for monitoring/debugging.
+   */
+  getStats() {
+    let running = 0, idle = 0, stopped = 0;
+    for (const [, entry] of this.subagents) {
+      if (entry.status === "running") running++;
+      else if (entry.status === "idle") idle++;
+      else stopped++;
+    }
+    return {
+      total: this.subagents.size,
+      running,
+      idle,
+      stopped,
+      inFlight: this.inFlight,
+      pending: this.pendingTasks.length,
+      completed: this.completedResults.length
+    };
+  }
   getStatus() {
     return {
       coordinatorId: this.coordinatorId,
@@ -2937,7 +3038,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() {
@@ -3031,13 +3132,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) {
@@ -3108,7 +3214,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
                   kind: "timeout",
                   used: elapsed,
                   limit,
-                  timeoutMs: 3e4,
+                  timeoutMs: 6e4,
                   extend: (extra) => resolveDecision({ extend: extra }),
                   deny: () => resolveDecision("stop")
                 });
@@ -3318,6 +3424,12 @@ var ParallelEternalEngine = class {
   get currentState() {
     return this.state;
   }
+  /**
+   * Get the underlying coordinator for stats/monitoring.
+   */
+  getCoordinator() {
+    return this.coordinator;
+  }
   stop() {
     this.stopRequested = true;
     void this.persistState("stopped").catch(() => {
@@ -3454,8 +3566,8 @@ Task: ${task}
           await coordinator.spawn({
             id: subagentId,
             name: `slot-${subagentId.slice(-6)}`,
-            maxIterations: 50,
-            maxToolCalls: 200,
+            // Let the coordinator apply its default budget (from roster or generic).
+            // Hardcoding low limits here defeats the x10 budget improvement.
             timeoutMs: this.timeoutMs
           });
           subagentIds.push(subagentId);
@@ -3472,7 +3584,7 @@ Task: ${task}
     let results = [];
     try {
       const ctrl = new AbortController();
-      const timer = setTimeout(() => ctrl.abort(), this.timeoutMs + 6e4);
+      const timer = setTimeout(() => ctrl.abort(), Math.max(this.timeoutMs * 2, 72e5));
       try {
         results = await coordinator.awaitTasks(taskIds);
       } finally {
@@ -3746,16 +3858,18 @@ function buildGoalPreamble(goal) {
   ].join("\n");
 }
 
+// src/execution/regex-patterns.ts
+var NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
+
 // src/execution/retry-policy.ts
-var DefaultRetryPolicy = class _DefaultRetryPolicy {
-  static NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
+var DefaultRetryPolicy = class {
   shouldRetry(err, attempt) {
     if (err instanceof ProviderError) {
       if (!err.retryable) return false;
       return attempt < this.maxAttempts(err);
     }
     const msg = err.message ?? "";
-    const isNetwork = _DefaultRetryPolicy.NETWORK_ERR_RE.test(msg);
+    const isNetwork = NETWORK_ERR_RE.test(msg);
     if (isNetwork) return attempt < 2;
     return false;
   }
@@ -3778,7 +3892,6 @@ var DefaultRetryPolicy = class _DefaultRetryPolicy {
 
 // src/execution/error-handler.ts
 var CONTEXT_OVERFLOW_RE = /context|too long|tokens/i;
-var NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
 function buildRecoveryStrategies(opts) {
   return [
     {