@wrongstack/core 0.6.7 → 0.7.0

package/dist/{events-DounT6pP.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-C8mBUzBv.js';
+import { U as Usage, a5 as Context, D as ToolProgressEvent, x as Tool } from './context-bmR0YgBm.js';
 
 /**
  * EventBus — observe-only typed event bus.

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-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';
+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-BTloSwjE.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-DOnwHAyz.js';
+import '../retry-policy-Dpxp4SET.js';
 import '../models-registry-Y2xbog0E.js';
 import '../logger-BMQgxvdy.js';
 import '../observability-BhnVLBLS.js';
-import '../secret-scrubber-C9UJxFCJ.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;
     /**
@@ -573,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;
@@ -1846,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") {
@@ -2753,14 +2794,14 @@ 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: 7.5 * 60 * 60 * 1e3, maxIterations: 5e3, maxToolCalls: 15e3 },
@@ -2892,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,
@@ -3359,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(() => {
@@ -3495,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);
@@ -3513,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 {
@@ -3787,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;
   }
@@ -3819,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 [
     {