@wrongstack/core 0.280.1 → 0.281.1

package/dist/{events-Bs2fmldo.d.ts → events-C5hLU0AT.d.ts}

@@ -1,5 +1,5 @@
-import { U as Usage, C as Context, l as ToolErrorCategory, m as ToolProgressEvent, T as Tool, n as RiskTier, o as ToolOutputMetadata } from './tool-BkOgs_KL.js';
-import { a as PermissionDecision } from './permission-Dx6dIqS2.js';
+import { U as Usage, d as Context, l as ToolErrorCategory, m as ToolProgressEvent, g as Tool, n as RiskTier, o as ToolOutputMetadata } from './tool-LVSLiE1s.js';
+import { a as PermissionDecision } from './permission-B6YAtNFz.js';
 
 /**
  * Brain coordination primitives.
@@ -992,6 +992,42 @@ interface EventMap {
         tokens: number;
         maxContext: number;
     };
+    /**
+     * A supervision rule detected a condition worth engaging on (starvation,
+     * overload, backlog, stuck agent, failure streak). Fires even when the
+     * subsequent decision is "do nothing" — the signal trail is the audit log.
+     */
+    'fleet.supervisor.signal': {
+        sessionId?: string | undefined;
+        /** Rule kind, e.g. 'pinned_starvation' | 'overloaded_worker' | 'backlog' | 'stuck_agent' | 'failure_streak' | 'idle_with_work'. */
+        kind: string;
+        subagentId?: string | undefined;
+        taskId?: string | undefined;
+        detail: string;
+    };
+    /**
+     * The supervisor consulted its decision path for a signal. `via:'rule'`
+     * means the deterministic policy answered without an LLM; `via:'brain'`
+     * means the tiered BrainArbiter was engaged. `outcome:'escalated'` =
+     * unresolved ask_human, no action taken.
+     */
+    'fleet.supervisor.decision': {
+        sessionId?: string | undefined;
+        kind: string;
+        proposedAction: string;
+        via: 'rule' | 'brain';
+        outcome: 'approved' | 'denied' | 'escalated' | 'skipped';
+        rationale?: string | undefined;
+    };
+    /** The supervisor executed (or failed to execute) an approved action. */
+    'fleet.supervisor.action': {
+        sessionId?: string | undefined;
+        action: 'retarget' | 'spawn_helper' | 'steer' | 'notify_leader' | 'terminate';
+        subagentId?: string | undefined;
+        taskId?: string | undefined;
+        ok: boolean;
+        detail?: string | undefined;
+    };
     /** A parallel SDD run started. */
     'sdd.run.started': {
         sessionId?: string | undefined;

package/dist/execution/index.d.ts

@@ -1,25 +1,25 @@
-export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, C as CompactorStrategy, U as ContextWindowBudgetSnapshot, D as DefaultDesignKitLoader, d as DefaultPromptLoader, e as DefaultSkillLoader, f as DesignKitLoaderOptions, h as DoneCheckResult, i as DoneConditionChecker, I as IntelligentCompactor, j as IntelligentCompactorOptions, P as PersistedActiveKit, k as PromptLoaderOptions, S as SelectiveCompactor, l as SelectiveCompactorOptions, m as SkillLoaderOptions, n as StrategyCompactorOptions, _ as _resetDesignKitLoaderMemo, o as _resetDesignRulesCache, p as activateDesign, r as buildGoalPreamble, s as clearActiveKit, t as clearPersistedActiveKit, u as createStrategyCompactor, v as designProjectDir, w as detectFrontendFile, x as detectFrontendIntent, y as getDesignKitLoader, z as getDesignState, B as installDesignStudioMiddleware, E as loadActiveKit, F as loadProjectDesignRules, G as makeAutonomyPromptContributor, H as makeDesignDetectToolCallMiddleware, J as makeDesignDetectUserInputMiddleware, K as makeDesignStudioRequestMiddleware, M as recordKitChoice, O as renderPrompt, Q as resolveBundledDesignKitsDir, R as setActiveKit } from '../strategy-compactor-CQwhbErd.js';
-import { P as Provider, a as ReasoningConfig, r as Capabilities, c as Request } from '../tool-BkOgs_KL.js';
-import { e as BrainDecision, h as BrainDecisionRequest, B as BrainArbiter } from '../events-Bs2fmldo.js';
-export { C as CompactorOptions, h as DefaultErrorHandler, i as DefaultRetryPolicy, E as EternalAutonomyEngine, k as EternalAutonomyOptions, l as EternalEngineState, H as HybridCompactor, I as IterationStage, P as ParallelEngineState, m as ParallelEternalEngine, n as ParallelEternalOptions, o as ParallelIterationStage, T as ToolExecutor } from '../tool-executor-SiE1wlZo.js';
-import { h as ModelRuntimeConfig } from '../config-Cr3312zc.js';
-import '../pipeline-BwAP21_4.js';
+export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, C as CompactorOptions, d as CompactorStrategy, Z as ContextWindowBudgetSnapshot, $ as DEFAULT_RECOVERY_STRATEGIES, D as DefaultDesignKitLoader, e as DefaultErrorHandler, f as DefaultPromptLoader, g as DefaultRetryPolicy, h as DefaultSkillLoader, i as DesignKitLoaderOptions, k as DoneCheckResult, l as DoneConditionChecker, H as HybridCompactor, I as IntelligentCompactor, m as IntelligentCompactorOptions, P as PersistedActiveKit, n as PromptLoaderOptions, a0 as RecoveryStrategy, S as SelectiveCompactor, o as SelectiveCompactorOptions, p as SkillLoaderOptions, q as StrategyCompactorOptions, T as ToolExecutor, _ as _resetDesignKitLoaderMemo, r as _resetDesignRulesCache, s as activateDesign, u as buildGoalPreamble, a1 as buildRecoveryStrategies, v as clearActiveKit, w as clearPersistedActiveKit, x as createStrategyCompactor, y as designProjectDir, z as detectFrontendFile, B as detectFrontendIntent, E as getDesignKitLoader, F as getDesignState, G as installDesignStudioMiddleware, J as loadActiveKit, K as loadProjectDesignRules, L as makeAutonomyPromptContributor, M as makeDesignDetectToolCallMiddleware, N as makeDesignDetectUserInputMiddleware, O as makeDesignStudioRequestMiddleware, R as recordKitChoice, V as renderPrompt, W as resolveBundledDesignKitsDir, X as setActiveKit } from '../tool-executor-BWtYwuPI.js';
+import { P as Provider, a as ReasoningConfig, r as Capabilities, c as Request } from '../tool-LVSLiE1s.js';
+import { e as BrainDecision, h as BrainDecisionRequest, B as BrainArbiter } from '../events-C5hLU0AT.js';
+export { E as EternalAutonomyEngine, h as EternalAutonomyOptions, i as EternalEngineState, I as IterationStage, P as ParallelEngineState, j as ParallelEternalEngine, k as ParallelEternalOptions, l as ParallelIterationStage } from '../parallel-eternal-engine-Cc2CNgmv.js';
+import { h as ModelRuntimeConfig } from '../config-CN-vdDEI.js';
+import '../pipeline-E7_jqGyV.js';
 import '../mailbox-types-BGZWrYTJ.js';
-import '../session-event-bridge-CqdiGnfU.js';
-import '../compactor-U3agvUIG.js';
-import '../agent-subagent-runner-PoqNKiR4.js';
-import '../index-kidebiDh.js';
+import '../session-event-bridge-vA2fLV58.js';
+import '../compactor-BxddyCFu.js';
+import '../agent-subagent-runner-DyOSK2Wy.js';
+import '../index-C1E-_71T.js';
 import '../logger-B63L5bTg.js';
-import '../permission-Dx6dIqS2.js';
+import '../permission-B6YAtNFz.js';
 import '../observability-D-HZN_mF.js';
 import '../secret-scrubber-3MHDDAtm.js';
-import '../retry-policy-D4feSLk3.js';
-import '../selector-Dy-MzKp1.js';
+import '../retry-policy-V67lBOJz.js';
+import '../selector-Bx2HgUkU.js';
 import '../skill-DHniprNl.js';
-import '../wstack-paths-CMl_cYgq.js';
+import '../wstack-paths-C3K40Qst.js';
 import '../prompt-DLd35n4Q.js';
-import '../goal-store-C4F6DjC0.js';
-import '../multi-agent-coordinator-CieyUoEL.js';
+import '../goal-store-BLGZq16t.js';
+import '../multi-agent-coordinator-IpHCuHUa.js';
 import 'node:events';
 
 /**

package/dist/execution/index.js

@@ -1,4 +1,4 @@
-import { randomUUID, createHash, randomBytes } from 'crypto';
+import { randomUUID, randomInt, createHash, randomBytes } from 'crypto';
 import * as fs from 'fs/promises';
 import * as path3 from 'path';
 import * as os from 'os';
@@ -193,7 +193,7 @@ function walk(value, schema, path12, errors, depth) {
     return;
   }
   if (schema.enum !== void 0) {
-    if (!schema.enum.some((e) => deepEqual(e, value))) {
+    if (!enumIncludes(schema.enum, value)) {
       errors.push({
         path: path12 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
@@ -263,6 +263,10 @@ function joinPath(parent, key) {
   if (!parent) return key;
   return `${parent}.${key}`;
 }
+function enumIncludes(values, value) {
+  if (value === null || typeof value !== "object") return values.includes(value);
+  return values.some((candidate) => deepEqual(candidate, value));
+}
 function deepEqual(a, b) {
   if (a === b) return true;
   if (typeof a !== typeof b) return false;
@@ -1457,6 +1461,7 @@ function resolveWstackPaths(opts) {
     projectHash: hash,
     projectSlug: slug,
     projectGoal: path3.join(projectDir, "goal.json"),
+    projectInputHistory: path3.join(projectDir, "input-history.json"),
     projectSpecs: path3.join(projectDir, "specs"),
     projectTaskGraphs: path3.join(projectDir, "task-graphs"),
     projectSddSession: path3.join(projectDir, "sdd-session.json"),
@@ -2137,14 +2142,21 @@ var AutonomousRunner = class {
     this.stopped = true;
   }
 };
+var textCache = /* @__PURE__ */ new Map();
+var rootCandidates;
 function readBundledInstructionText(relativePath) {
+  const cached = textCache.get(relativePath);
+  if (cached !== void 0) return cached;
+  let resolved = "";
   for (const root of instructionRootCandidates()) {
     try {
-      return readFileSync(path3.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync(path3.join(root, relativePath), "utf8").trimEnd();
+      break;
     } catch {
     }
   }
-  return "";
+  textCache.set(relativePath, resolved);
+  return resolved;
 }
 function renderInstructionTemplate(template, values) {
   return template.replace(
@@ -2153,13 +2165,15 @@ function renderInstructionTemplate(template, values) {
   );
 }
 function instructionRootCandidates() {
+  if (rootCandidates !== void 0) return rootCandidates;
   const here = path3.dirname(fileURLToPath(import.meta.url));
   const candidates = [
     path3.resolve(here, "../../instructions"),
     path3.resolve(here, "../instructions"),
     path3.resolve(here, "instructions")
   ];
-  return candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
+  rootCandidates = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
+  return rootCandidates;
 }
 function isDirectory(candidate) {
   try {
@@ -3915,7 +3929,38 @@ function buildRecoveryStrategies(opts) {
       async attempt(err, ctx) {
         if (!(err instanceof ProviderError)) return null;
         if (err.status !== 529 && err.status < 500) return null;
-        return null;
+        const registry = opts?.modelsRegistry;
+        if (!registry) return null;
+        try {
+          const providerId = ctx.provider?.id;
+          if (!providerId) return null;
+          const provider = await registry.getProvider(providerId);
+          if (!provider) return null;
+          const currentModel = await registry.getModel(providerId, ctx.model);
+          if (!currentModel) return null;
+          const visibleModels = opts?.getConfig?.().providers?.[providerId]?.models;
+          const candidates = provider.models.filter((m) => {
+            if (visibleModels !== void 0 && !visibleModels.includes(m.id)) return false;
+            const modelCost = m.cost?.input ?? Number.POSITIVE_INFINITY;
+            const currentCost = currentModel.cost?.input ?? Number.POSITIVE_INFINITY;
+            if (modelCost >= currentCost) return false;
+            if (currentModel.capabilities.tools && !m.tool_call) return false;
+            if (currentModel.capabilities.vision && !m.modalities?.input?.includes("image"))
+              return false;
+            return true;
+          });
+          if (candidates.length === 0) return null;
+          const fallback = candidates.reduce(
+            (prev, curr) => (curr.cost?.input ?? Number.POSITIVE_INFINITY) < (prev.cost?.input ?? Number.POSITIVE_INFINITY) ? curr : prev
+          );
+          return {
+            action: "retry",
+            reason: "model_downgrade",
+            model: fallback.id
+          };
+        } catch {
+          return null;
+        }
       }
     }
   ];
@@ -5625,20 +5670,32 @@ var TOOLS = {
   /** Web research. */
   research: ["read", "grep", "glob", "search", "fetch", "mailbox"]
 };
+var promptCache = /* @__PURE__ */ new Map();
+var candidateCache = /* @__PURE__ */ new Map();
 function agentPrompt(id) {
+  const envDir = process.env["WRONGSTACK_AGENT_INSTRUCTIONS_DIR"] ?? "";
+  const cacheKey = `${envDir}\0${id}`;
+  const cached = promptCache.get(cacheKey);
+  if (cached !== void 0) return cached;
   const fileName = `${id}.md`;
-  for (const dir of agentPromptDirCandidates()) {
+  let resolved = "";
+  for (const dir of agentPromptDirCandidates(envDir)) {
     try {
-      return readFileSync(path3.join(dir, fileName), "utf8").trimEnd();
+      resolved = readFileSync(path3.join(dir, fileName), "utf8").trimEnd();
+      break;
     } catch {
     }
   }
-  return "";
+  promptCache.set(cacheKey, resolved);
+  return resolved;
 }
-function agentPromptDirCandidates() {
-  const here = path3.dirname(fileURLToPath(import.meta.url));
-  const explicitDir = process.env["WRONGSTACK_AGENT_INSTRUCTIONS_DIR"];
+function agentPromptDirCandidates(envDir) {
   const globalRoot = process.env["WRONGSTACK_HOME"] || path3.join(os.homedir(), ".wrongstack");
+  const candKey = `${envDir}\0${globalRoot}`;
+  const cached = candidateCache.get(candKey);
+  if (cached !== void 0) return cached;
+  const here = path3.dirname(fileURLToPath(import.meta.url));
+  const explicitDir = envDir || void 0;
   const candidates = [
     ...explicitDir ? [path3.resolve(explicitDir)] : [],
     path3.join(globalRoot, "instructions", "agents"),
@@ -5648,7 +5705,9 @@ function agentPromptDirCandidates() {
     path3.resolve(here, "../instructions/agents"),
     path3.resolve(here, "instructions/agents")
   ];
-  return candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
+  const ordered = candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
+  candidateCache.set(candKey, ordered);
+  return ordered;
 }
 function isDirectory2(candidate) {
   try {
@@ -7710,6 +7769,30 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   results() {
     return this.completedResults;
   }
+  /** Defensive snapshot of the still-queued (not yet dispatched) tasks. */
+  listPendingTasks() {
+    return this.pendingTasks.map((t) => ({ ...t }));
+  }
+  /**
+   * Re-pin a still-PENDING task to a different subagent (`undefined` =
+   * unpin, any idle worker may take it), then try to dispatch. Returns
+   * `false` when the task is not in the pending queue — already
+   * dispatched, completed, or unknown. Running tasks can never be pulled;
+   * they can only be steered or terminated. The mutation is synchronous
+   * (same tick as the check), so it cannot race a concurrent dispatch:
+   * `tryDispatchNext` runs on this same call stack or a later one.
+   *
+   * The task keeps its id, so waiters, the report-back notifier, and
+   * checkpoint bookkeeping resolve unchanged when it eventually completes.
+   */
+  retargetPendingTask(taskId, subagentId) {
+    const task = this.pendingTasks.find((t) => t.id === taskId);
+    if (!task) return false;
+    if (subagentId !== void 0 && !this.subagents.has(subagentId)) return false;
+    task.subagentId = subagentId;
+    this.tryDispatchNext();
+    return true;
+  }
   /**
    * Wait for one or more tasks to complete and return their results.
    * If a task is already done when called, returns immediately.
@@ -7737,6 +7820,43 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       })
     );
   }
+  /**
+   * Wait until AT LEAST ONE of the named tasks completes. Returns every
+   * requested result already available at that moment (drain-what's-done)
+   * plus the ids still outstanding, so callers can loop "handle finishers,
+   * re-await the remainder" instead of blocking on the whole batch.
+   *
+   * Unlike `awaitTasks`, this never rejects and deliberately does NOT
+   * inherit `config.timeoutMs` — a "return whatever is done" call has no
+   * business timing out unless the caller asks for a window explicitly.
+   */
+  async awaitTasksAny(taskIds, opts) {
+    const ids = new Set(taskIds);
+    const completed = this.completedResults.filter((r) => ids.has(r.taskId));
+    if (completed.length > 0 || ids.size === 0) {
+      const done = new Set(completed.map((r) => r.taskId));
+      return { completed, pending: taskIds.filter((id) => !done.has(id)) };
+    }
+    return new Promise((resolve5) => {
+      let timer;
+      const handler = ({ result }) => {
+        if (!ids.has(result.taskId)) return;
+        if (timer) clearTimeout(timer);
+        this.off("task.completed", handler);
+        resolve5({
+          completed: [result],
+          pending: taskIds.filter((id) => id !== result.taskId)
+        });
+      };
+      if (opts?.timeoutMs !== void 0) {
+        timer = setTimeout(() => {
+          this.off("task.completed", handler);
+          resolve5({ completed: [], pending: [...taskIds], timedOut: true });
+        }, opts.timeoutMs);
+      }
+      this.on("task.completed", handler);
+    });
+  }
   /**
    * Manual completion — for callers that drive subagents without a runner
    * (e.g. external orchestrators). When a runner is configured the coordinator
@@ -8679,8 +8799,7 @@ ${lastFew}` : "No prior iterations.",
     await saveGoal(this.goalPath, { ...current, engineState: state }, this.opts.events);
   }
 };
-
-// src/execution/retry-policy.ts
+var MAX_RETRY_AFTER_MS = 6e4;
 var DefaultRetryPolicy = class {
   shouldRetry(err, attempt) {
     if (err instanceof ProviderError) {
@@ -8702,13 +8821,37 @@ var DefaultRetryPolicy = class {
     }
     return 2;
   }
-  delayMs(attempt) {
+  /**
+   * Compute the retry delay.
+   *
+   * Precedence:
+   *   1. If `err` is a `ProviderError` with a populated
+   *      `body.retryAfterMs`, honour it — clamped into
+   *      [0, MAX_RETRY_AFTER_MS]. The provider told us exactly when
+   *      to come back; we should listen.
+   *   2. Otherwise fall through to the exponential-with-jitter
+   *      schedule (`1000 * 2^attempt + jitter`, capped at 30s).
+   *
+   * `err` is optional for back-compat with the existing interface;
+   * callers should pass it whenever available.
+   */
+  delayMs(attempt, err) {
+    const hint = retryAfterMsFromError(err);
+    if (hint !== void 0) {
+      return Math.max(0, Math.min(hint, MAX_RETRY_AFTER_MS));
+    }
     const base = 1e3;
     const exp = base * 2 ** attempt;
-    const jitter = Math.random() * base;
+    const jitter = randomInt(0, base);
     return Math.min(3e4, exp + jitter);
   }
 };
+function retryAfterMsFromError(err) {
+  if (!err || !(err instanceof ProviderError)) return void 0;
+  const ms = err.body?.retryAfterMs;
+  if (typeof ms !== "number" || !Number.isFinite(ms) || ms <= 0) return void 0;
+  return ms;
+}
 
 // src/models/llm-selector.ts
 var DEFAULT_SYSTEM_PROMPT = readBundledInstructionText("llm/llm-selector.md");
@@ -10621,6 +10764,6 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
   }
 }
 
-export { AutoCompactionMiddleware, AutonomousRunner, DefaultDesignKitLoader, DefaultErrorHandler, DefaultPromptLoader, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, ParallelEternalEngine, SelectiveCompactor, ToolExecutor, _resetDesignKitLoaderMemo, _resetDesignRulesCache, activateDesign, applyModelRuntime, buildGoalPreamble, clearActiveKit, clearPersistedActiveKit, createAutonomyBrain, createStrategyCompactor, createTieredBrainArbiter, designProjectDir, detectFrontendFile, detectFrontendIntent, formatDecisionSummary, getDesignKitLoader, getDesignState, installDesignStudioMiddleware, loadActiveKit, loadProjectDesignRules, makeAutonomyPromptContributor, makeDesignDetectToolCallMiddleware, makeDesignDetectUserInputMiddleware, makeDesignStudioRequestMiddleware, mergeModelRuntime, recordKitChoice, renderPrompt, resolveBundledDesignKitsDir, resolveCacheForRequest, resolveModelRuntime, resolveReasoningForRequest, setActiveKit };
+export { AutoCompactionMiddleware, AutonomousRunner, DEFAULT_RECOVERY_STRATEGIES, DefaultDesignKitLoader, DefaultErrorHandler, DefaultPromptLoader, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, ParallelEternalEngine, SelectiveCompactor, ToolExecutor, _resetDesignKitLoaderMemo, _resetDesignRulesCache, activateDesign, applyModelRuntime, buildGoalPreamble, buildRecoveryStrategies, clearActiveKit, clearPersistedActiveKit, createAutonomyBrain, createStrategyCompactor, createTieredBrainArbiter, designProjectDir, detectFrontendFile, detectFrontendIntent, formatDecisionSummary, getDesignKitLoader, getDesignState, installDesignStudioMiddleware, loadActiveKit, loadProjectDesignRules, makeAutonomyPromptContributor, makeDesignDetectToolCallMiddleware, makeDesignDetectUserInputMiddleware, makeDesignStudioRequestMiddleware, mergeModelRuntime, recordKitChoice, renderPrompt, resolveBundledDesignKitsDir, resolveCacheForRequest, resolveModelRuntime, resolveReasoningForRequest, setActiveKit };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map