@wrongstack/core 0.54.1 → 0.63.4

package/dist/{events-CbHTS4ZZ.d.ts → events-k8CHjcrN.d.ts}

@@ -1,4 +1,4 @@
-import { $ as Usage, d as Context, X as ToolProgressEvent, Q as Tool } from './context-DtPKqKYV.js';
+import { $ as Usage, d as Context, X as ToolProgressEvent, Q as Tool } from './context-iFMEO2rN.js';
 
 /**
  * Brain coordination primitives.
@@ -210,6 +210,25 @@ interface EventMap {
         description: string;
         retryable: boolean;
     };
+    /**
+     * Fired by the fallback-model extension when the primary model is overloaded
+     * (after its own retries are exhausted) and the agent switches to the next
+     * model in the configured `fallbackModels` chain. `providerSwitched` is true
+     * when the fallback also changed the active provider (cross-provider). UIs
+     * render this as a notice: "⚠ opus overloaded — falling back to sonnet".
+     */
+    'provider.fallback': {
+        from: {
+            providerId: string;
+            model: string;
+        };
+        to: {
+            providerId: string;
+            model: string;
+        };
+        status: number;
+        providerSwitched: boolean;
+    };
     'tool.started': {
         name: string;
         id: string;

package/dist/execution/index.d.ts

@@ -1,23 +1,23 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-CgU0yWpB.js';
-import { m as Provider, d as Context } from '../context-DtPKqKYV.js';
-import { a as Compactor, C as CompactReport } from '../compactor-Duhsf0ge.js';
-import { M as MessageSelector } from '../selector-BvSPdJj6.js';
-import { E as EventBus } from '../events-CbHTS4ZZ.js';
-import { b as MiddlewareHandler } from '../system-prompt-dtzV_mLm.js';
-import { a as SessionEventBridge, J as JournalEntry } from '../goal-store-DwcTDDiX.js';
-import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-bht0txXS.js';
-import { c as Agent, R as RunResult, w as SystemPromptContributor } from '../index-CI271MjL.js';
-import { D as DoneCondition } from '../multi-agent-BmC_xiog.js';
-import { A as AgentFactory } from '../agent-subagent-runner-By7jruZ_.js';
-import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-CjNX4uBD.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-CIjpGaRA.js';
+import { m as Provider, d as Context } from '../context-iFMEO2rN.js';
+import { a as Compactor, C as CompactReport } from '../compactor-0vjZ8KTk.js';
+import { M as MessageSelector } from '../selector-DxhW7ML3.js';
+import { E as EventBus } from '../events-k8CHjcrN.js';
+import { b as MiddlewareHandler } from '../system-prompt-7LHyBbIf.js';
+import { a as SessionEventBridge, J as JournalEntry } from '../goal-store-iHltMi5n.js';
+import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-BdDuaZmB.js';
+import { c as Agent, R as RunResult, C as SystemPromptContributor } from '../index-Bc6BiP5q.js';
+import { D as DoneCondition } from '../multi-agent-SASYOrWA.js';
+import { A as AgentFactory } from '../agent-subagent-runner-Zc3f37Sg.js';
+import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-CNUJYq7U.js';
 import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-CxuWrsKK.js';
 import { a as WstackPaths } from '../wstack-paths-eMXnY1_X.js';
-import '../retry-policy-Chtlvr5b.js';
+import '../retry-policy-BfBScewS.js';
 import '../models-registry-BcYJDKLm.js';
 import '../logger-DDd5C--Z.js';
 import '../observability-BhnVLBLS.js';
 import '../secret-scrubber-3MHDDAtm.js';
-import '../permission-Drm7LpPo.js';
+import '../permission-Ld-i5ugf.js';
 import 'node:events';
 
 interface SkillLoaderOptions {

package/dist/execution/index.js

@@ -1466,8 +1466,9 @@ var ToolExecutor = class {
    */
   async executeBatch(toolUses, ctx, strategy) {
     let budget = this.opts.perIterationOutputCapBytes ?? 1e5;
-    const runOne = async (use) => {
+    const runOne = async (use0) => {
       const start = Date.now();
+      let use = use0;
       const tool = this.registry.get(use.name);
       if (!tool) {
         const result = this.unknownToolResult(use, () => this.registry.list().map((t) => t.name));
@@ -1500,10 +1501,36 @@ Please call the tool again with arguments that match its inputSchema. You can us
         budget = this.decrementBudget(result, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
+      if (this.opts.hookRunner?.has("PreToolUse")) {
+        const pre = await this.opts.hookRunner.preToolUse(tool.name, use.input, ctx);
+        if (pre.block) {
+          const result = this.blockedByHookResult(use, pre.reason);
+          budget = this.decrementBudget(result, budget);
+          return { result, tool, durationMs: Date.now() - start };
+        }
+        if (pre.input) {
+          const reval = validateAgainstSchema(pre.input, tool.inputSchema);
+          if (!reval.ok) {
+            const errorDetails = reval.errors.map((e) => `  - ${e.path || "input"}: ${e.message}`).join("\n");
+            const result = {
+              type: "tool_result",
+              tool_use_id: use.id,
+              content: `A PreToolUse hook rewrote the arguments for "${tool.name}" into an invalid shape.
+
+Validation errors:
+${errorDetails}`,
+              is_error: true
+            };
+            budget = this.decrementBudget(result, budget);
+            return { result, tool, durationMs: Date.now() - start };
+          }
+          use = { ...use, input: pre.input };
+        }
+      }
       const decision = await this.opts.permissionPolicy.evaluate(tool, use.input, ctx);
       let effectivePermission = decision.permission;
       const policy = this.opts.permissionPolicy;
-      const yolo = policy.getYolo?.() === true || policy.getForceAllYolo?.() === true;
+      const yolo = policy.getYolo?.() === true || policy.getYoloDestructive?.() === true || policy.getForceAllYolo?.() === true;
       if (toolDangerousCaps.length > 0 && effectivePermission === "auto" && !yolo) {
         effectivePermission = "confirm";
       }
@@ -1546,7 +1573,20 @@ Please call the tool again with arguments that match its inputSchema. You can us
         "tool.has_dangerous_capabilities": toolCapsForAudit.length > 0
       });
       try {
-        const result = await this.executeTool(tool, use, ctx, budget);
+        let result = await this.executeTool(tool, use, ctx, budget);
+        if (this.opts.hookRunner?.has("PostToolUse")) {
+          const post = await this.opts.hookRunner.postToolUse(
+            tool.name,
+            use.input,
+            { content: String(result.content), isError: !!result.is_error },
+            ctx
+          );
+          if (post.additionalContext) {
+            result = { ...result, content: `${result.content}
+
+${post.additionalContext}` };
+          }
+        }
         budget = this.decrementBudget(result, budget);
         span?.setAttribute("tool.is_error", !!result.is_error);
         span?.setAttribute(
@@ -1735,6 +1775,14 @@ ${excerpt}`;
       is_error: true
     };
   }
+  blockedByHookResult(use, reason) {
+    return {
+      type: "tool_result",
+      tool_use_id: use.id,
+      content: `Tool "${use.name}" was blocked by a PreToolUse hook: ${reason ?? "no reason given"}`,
+      is_error: true
+    };
+  }
   decrementBudget(result, budget) {
     const contentBytes = typeof result.content === "string" ? Buffer.byteLength(result.content, "utf8") : Buffer.byteLength(JSON.stringify(result.content), "utf8");
     return Math.max(0, budget - contentBytes);
@@ -2544,7 +2592,8 @@ ${recentJournal}` : "No prior iterations.",
       "   \u2022 When this iteration's Task is finished (real artifact / passing",
       "     test / applied diff / clean output), emit `[done]` on its own line.",
       "   \u2022 Do not stop on the first obstacle \u2014 try at least 3 distinct",
-      "     approaches before giving up. YOLO is active; no confirmations.",
+      "     approaches before giving up. YOLO is active for normal project work;",
+      "     destructive-gated confirmations still belong to the permission flow.",
       "",
       "2. UPDATE TODO STATE (when Source is `todo`)",
       "   \u2022 Mark this todo `in_progress` via the todos tool before tool work.",
@@ -6634,7 +6683,8 @@ ${recentJournal}` : "No prior iterations.",
       "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
       "\u2022 Execute the assigned task end-to-end using multiple tool calls.",
       "\u2022 Emit `[done]` on its own line when the task is complete.",
-      "\u2022 Do not ask for confirmation \u2014 YOLO is active.",
+      "\u2022 Do not ask before routine in-project tool use \u2014 YOLO is active for normal project work.",
+      "\u2022 If a destructive-gated confirmation appears, wait for the permission flow.",
       "\u2022 If the overall Mission is accomplished, emit `[GOAL_COMPLETE]` followed by a verification recipe.",
       "\u2022 Keep output concise \u2014 summarize findings, do not transcribe files."
     ].join("\n");
@@ -6891,8 +6941,10 @@ ${journalTail.join("\n")}` : "Recent journal: (none \u2014 this is the first ite
       "  decide.",
       "",
       "### Operating principles",
-      "- YOLO is active. Do NOT ask for confirmation, do NOT propose",
-      "  options. Pick the best path and execute it.",
+      "- YOLO is active for normal project work. Proceed with routine",
+      "  in-project tool use without pre-confirming; pick the best path and execute it.",
+      "  If the permission system raises a destructive-gated confirmation, wait",
+      "  for that flow instead of trying to bypass it.",
       "- Use tools freely; multiple calls per turn are normal and expected.",
       "- When working on a todo, mark it `in_progress` via the todos tool",
       "  before tool work and `completed` (or `cancelled` with a reason)",
@@ -7016,7 +7068,7 @@ var DefaultRetryPolicy = class {
 };
 
 // src/execution/error-handler.ts
-var CONTEXT_OVERFLOW_RE = /context|too long|tokens/i;
+var CONTEXT_OVERFLOW_RE = /context|too long|tokens|exceeds the context window|context window/i;
 function buildRecoveryStrategies(opts) {
   return [
     {
@@ -7024,7 +7076,7 @@ function buildRecoveryStrategies(opts) {
       compactor: opts?.compactor,
       async attempt(err, ctx) {
         if (!(err instanceof ProviderError)) return null;
-        if (err.status !== 413 && !CONTEXT_OVERFLOW_RE.test(err.message)) return null;
+        if (err.status !== 413 && !isContextOverflowError(err)) return null;
         if (this.compactor) {
           try {
             const report = await this.compactor.compact(ctx, { aggressive: true });
@@ -7058,6 +7110,14 @@ function buildRecoveryStrategies(opts) {
   ];
 }
 var DEFAULT_RECOVERY_STRATEGIES = buildRecoveryStrategies();
+function isContextOverflowError(err) {
+  return CONTEXT_OVERFLOW_RE.test([
+    err.message,
+    err.body?.message,
+    err.body?.type,
+    err.body?.raw
+  ].filter(Boolean).join("\n"));
+}
 var DefaultErrorHandler = class {
   strategies;
   constructor(strategies = DEFAULT_RECOVERY_STRATEGIES) {
@@ -7074,7 +7134,7 @@ var DefaultErrorHandler = class {
       if (err.status === 429) return { kind: "rate_limit", retryable: true };
       if (err.status === 529) return { kind: "overloaded", retryable: true };
       if (err.status >= 500) return { kind: "server", retryable: true };
-      if (err.status === 413 || CONTEXT_OVERFLOW_RE.test(err.message)) {
+      if (err.status === 413 || isContextOverflowError(err)) {
         return { kind: "context_overflow", retryable: false };
       }
       if (err.status >= 400) return { kind: "client", retryable: false };