@wrongstack/core 0.257.0 → 0.260.0

package/dist/execution/index.d.ts

@@ -1,23 +1,23 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, E as EternalAutonomyEngine, c as EternalAutonomyOptions, d as EternalEngineState, H as HybridCompactor, I as IterationStage, P as ParallelEngineState, e as ParallelEternalEngine, f as ParallelEternalOptions, g as ParallelIterationStage, T as ToolExecutor } from '../parallel-eternal-engine-C0juOszP.js';
-export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, C as CompactorStrategy, D as DefaultSkillLoader, d as DoneCheckResult, e as DoneConditionChecker, I as IntelligentCompactor, f as IntelligentCompactorOptions, S as SelectiveCompactor, g as SelectiveCompactorOptions, h as SkillLoaderOptions, i as StrategyCompactorOptions, j as buildGoalPreamble, k as createStrategyCompactor, m as makeAutonomyPromptContributor } from '../goal-preamble-UiEkbNmW.js';
-import { P as Provider } from '../context-CGdgA0q6.js';
-import { b as BrainDecision, e as BrainDecisionRequest, B as BrainArbiter } from '../brain-TjEEwSpw.js';
-import '../retry-policy-Tg7LXkoK.js';
-import '../compactor-C5sT4U7I.js';
-import '../config-DuAu23zm.js';
-import '../index-CitPrI3a.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, E as EternalAutonomyEngine, c as EternalAutonomyOptions, d as EternalEngineState, H as HybridCompactor, I as IterationStage, P as ParallelEngineState, e as ParallelEternalEngine, f as ParallelEternalOptions, g as ParallelIterationStage, T as ToolExecutor } from '../parallel-eternal-engine-0SItuq5r.js';
+export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, C as CompactorStrategy, D as DefaultSkillLoader, d as DoneCheckResult, e as DoneConditionChecker, I as IntelligentCompactor, f as IntelligentCompactorOptions, S as SelectiveCompactor, g as SelectiveCompactorOptions, h as SkillLoaderOptions, i as StrategyCompactorOptions, j as buildGoalPreamble, k as createStrategyCompactor, m as makeAutonomyPromptContributor } from '../goal-preamble-B1IXJtLX.js';
+import { P as Provider } from '../context-JFOVvu6z.js';
+import { b as BrainDecision, e as BrainDecisionRequest, B as BrainArbiter } from '../brain-C2yDd7Lw.js';
+import '../retry-policy-Cavrzmtk.js';
+import '../compactor-t0R_AIt_.js';
+import '../config-FG6As4H5.js';
+import '../index-BPcg4N3M.js';
 import '../logger-B63L5bTg.js';
-import '../pipeline-JG8XoudC.js';
+import '../pipeline-zflkI2dp.js';
 import '../observability-D-HZN_mF.js';
-import '../permission-CwBBpCoF.js';
-import '../agent-subagent-runner-US741uBH.js';
-import '../goal-store-CV9Yz2X_.js';
-import '../multi-agent-coordinator-DqTUEAeC.js';
+import '../permission-BJ7eO9Vl.js';
+import '../agent-subagent-runner-BNIGZx18.js';
+import '../goal-store-CPXz6Mml.js';
+import '../multi-agent-coordinator-CEmrSCMJ.js';
 import 'node:events';
 import '../skill-DGIXCtdv.js';
 import '../wstack-paths-CJjEwPXn.js';
-import '../selector-DWsqVjGf.js';
-import '../session-event-bridge-BAFWdgQ3.js';
+import '../selector-B7AivHsu.js';
+import '../session-event-bridge-BmIDxdJd.js';
 
 /**
  * AutonomyBrain — a self-driving decision layer for autonomous workflows.

package/dist/execution/index.js

@@ -2546,13 +2546,32 @@ var MAX_JOURNAL_ENTRIES = 500;
 function goalFilePath(projectRoot) {
   return resolveWstackPaths({ projectRoot }).projectGoal;
 }
-async function loadGoal(filePath) {
+async function loadGoal(filePath, events) {
+  const t0 = Date.now();
   let raw;
   try {
     raw = await fs.readFile(filePath, "utf8");
   } catch (err) {
     const code = err.code;
-    if (code === "ENOENT") return null;
+    if (code === "ENOENT") {
+      events?.emit("storage.read", {
+        sessionId: "~boot~",
+        store: "goal",
+        filePath,
+        operation: "load",
+        outcome: "success",
+        durationMs: Date.now() - t0
+      });
+      return null;
+    }
+    events?.emit("storage.error", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "load",
+      error: err instanceof Error ? err.message : String(err),
+      recoverable: false
+    });
     throw err;
   }
   try {
@@ -2565,8 +2584,25 @@ async function loadGoal(filePath) {
         message: "invalid schema \u2014 consider deleting and re-creating",
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }));
+      events?.emit("storage.read", {
+        sessionId: "~boot~",
+        store: "goal",
+        filePath,
+        operation: "load",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: "invalid_schema"
+      });
       return null;
     }
+    events?.emit("storage.read", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "load",
+      outcome: "success",
+      durationMs: Date.now() - t0
+    });
     return parsed;
   } catch {
     console.warn(JSON.stringify({
@@ -2576,13 +2612,39 @@ async function loadGoal(filePath) {
       message: "JSON parse failed \u2014 consider deleting and re-creating",
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     }));
+    events?.emit("storage.read", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "load",
+      outcome: "failure",
+      durationMs: Date.now() - t0,
+      error: "parse_failed"
+    });
     return null;
   }
 }
-async function saveGoal(filePath, goal) {
+async function saveGoal(filePath, goal, events) {
+  const t0 = Date.now();
   try {
     await atomicWrite(filePath, JSON.stringify(goal, null, 2), { mode: 384 });
+    events?.emit("storage.write", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "save",
+      outcome: "success",
+      durationMs: Date.now() - t0
+    });
   } catch (err) {
+    events?.emit("storage.error", {
+      sessionId: "~boot~",
+      store: "goal",
+      filePath,
+      operation: "save",
+      error: err instanceof Error ? err.message : String(err),
+      recoverable: false
+    });
     throw new FsError({
       message: err instanceof Error ? err.message : String(err),
       code: ERROR_CODES.FS_ATOMIC_WRITE_FAILED,
@@ -2938,7 +3000,7 @@ var EternalAutonomyEngine = class {
     const emit = (stage) => {
       this.opts.onStage?.(stage);
     };
-    const goal = await loadGoal(this.goalPath);
+    const goal = await loadGoal(this.goalPath, this.opts.events);
     if (!goal) {
       emit({ phase: "stopped" });
       this.stopRequested = true;
@@ -3042,7 +3104,7 @@ var EternalAutonomyEngine = class {
     emit({ phase: "reflect", status, note });
     let iterationIndex = 0;
     try {
-      const reloaded = await loadGoal(this.goalPath);
+      const reloaded = await loadGoal(this.goalPath, this.opts.events);
       iterationIndex = reloaded?.iterations ?? 0;
     } catch {
     }
@@ -3362,12 +3424,12 @@ ${recentJournal}` : "No prior iterations.",
     }
   }
   async appendIterationEntry(entry) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) {
       return;
     }
     const updated = appendJournal(current, entry);
-    await saveGoal(this.goalPath, updated);
+    await saveGoal(this.goalPath, updated, this.opts.events);
   }
   /**
    * Persistent per-todo failure counter. Skipped silently when the goal
@@ -3376,11 +3438,11 @@ ${recentJournal}` : "No prior iterations.",
    * the counter to rotate past stuck todos once they cross `todoMaxAttempts`.
    */
   async bumpTodoAttempt(todoId) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) return;
     const attempts = { ...current.todoAttempts ?? {} };
     attempts[todoId] = (attempts[todoId] ?? 0) + 1;
-    await saveGoal(this.goalPath, { ...current, todoAttempts: attempts });
+    await saveGoal(this.goalPath, { ...current, todoAttempts: attempts }, this.opts.events);
   }
   /**
    * Flip the mission to `completed` and journal it. Called from two
@@ -3390,7 +3452,7 @@ ${recentJournal}` : "No prior iterations.",
    * goal is already `completed`.
    */
   async markGoalCompleted(action, note) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) return;
     if (current.goalState === "completed") return;
     const withFlag = { ...current, goalState: "completed" };
@@ -3400,7 +3462,7 @@ ${recentJournal}` : "No prior iterations.",
       status: "success",
       note: note.slice(0, 240)
     });
-    await saveGoal(this.goalPath, withEntry);
+    await saveGoal(this.goalPath, withEntry, this.opts.events);
     this.opts.onEternalStop?.();
   }
   /**
@@ -3409,10 +3471,10 @@ ${recentJournal}` : "No prior iterations.",
    * `onEternalStop` so the REPL returns to normal mode.
    */
   async clearGoalManually(note) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (current) {
       const abandoned = { ...current, goalState: "abandoned" };
-      await saveGoal(this.goalPath, abandoned);
+      await saveGoal(this.goalPath, abandoned, this.opts.events);
     }
     try {
       const { unlink: unlink3 } = await import('fs/promises');
@@ -3488,16 +3550,16 @@ ${recentJournal}` : ""
    * Persist a progress update from the agent's [PROGRESS: N%] output.
    */
   async updateProgress(progress, note) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) return;
     const updated = recordProgress(current, progress, note);
-    await saveGoal(this.goalPath, updated);
+    await saveGoal(this.goalPath, updated, this.opts.events);
   }
   async persistEngineState(state) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) return;
     if (current.engineState === state) return;
-    await saveGoal(this.goalPath, { ...current, engineState: state });
+    await saveGoal(this.goalPath, { ...current, engineState: state }, this.opts.events);
   }
 };
 
@@ -3846,6 +3908,20 @@ var SubagentBudget = class _SubagentBudget {
 };
 
 // src/coordination/agent-subagent-runner.ts
+function withDisabledToolFiltering(factory) {
+  return async (config) => {
+    const result = await factory(config);
+    const disabled = config.disabledTools ?? [];
+    if (disabled.length === 0) return result;
+    const registry = result.agent.tools;
+    if (registry && typeof registry.unregister === "function") {
+      for (const toolName of disabled) {
+        registry.unregister(toolName);
+      }
+    }
+    return result;
+  };
+}
 function makeAgentSubagentRunner(opts) {
   const format = opts.formatTaskInput ?? defaultFormatTaskInput;
   return async (task, ctx) => {
@@ -6655,17 +6731,17 @@ function normalize(text) {
   return ` ${text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
 }
 function scoreAgents(task, catalog = AGENT_CATALOG) {
-  const hay = normalize(task);
+  const haySet = new Set(normalize(task).split(/\s+/).filter(Boolean));
   const out = [];
   for (const def of Object.values(catalog)) {
     if (!def?.config?.role) continue;
     let score = 0;
     const matched = [];
     for (const kw of def.capability.keywords) {
-      const needle = normalize(kw);
-      if (hay.includes(needle.trimEnd() + " ") || hay.includes(" " + needle.trimStart())) {
-        const words = kw.trim().split(/\s+/).length;
-        score += words;
+      const needleWords = normalize(kw).split(/\s+/).filter(Boolean);
+      const allPresent = needleWords.every((w) => haySet.has(w));
+      if (allPresent) {
+        score += needleWords.length;
         matched.push(kw);
       }
     }
@@ -7828,7 +7904,8 @@ var ParallelEternalEngine = class {
       doneCondition: { type: "all_tasks_done" }
     };
     this.coordinator = new DefaultMultiAgentCoordinator(config);
-    const runner = makeAgentSubagentRunner({ factory: this.agentFactory });
+    const filteredFactory = withDisabledToolFiltering(this.agentFactory);
+    const runner = makeAgentSubagentRunner({ factory: filteredFactory });
     this.coordinator.setRunner?.(runner);
     try {
       while (!this.stopRequested) {
@@ -7863,7 +7940,7 @@ var ParallelEternalEngine = class {
       this.opts.onStage?.(stage);
     };
     this.iterations++;
-    const goal = await loadGoal(this.goalPath);
+    const goal = await loadGoal(this.goalPath, this.opts.events);
     if (!goal) {
       this.stopRequested = true;
       emit({ phase: "stopped" });
@@ -7881,7 +7958,8 @@ var ParallelEternalEngine = class {
         doneCondition: { type: "all_tasks_done" }
       };
       this.coordinator = new DefaultMultiAgentCoordinator(config);
-      const runner = makeAgentSubagentRunner({ factory: this.agentFactory });
+      const filteredFactory = withDisabledToolFiltering(this.agentFactory);
+      const runner = makeAgentSubagentRunner({ factory: filteredFactory });
       this.coordinator.setRunner?.(runner);
     }
     emit({ phase: "decompose" });
@@ -7990,13 +8068,17 @@ ${personaLine}Task: ${task}
                 role: route.role,
                 tools: route.definition.config.tools,
                 systemPromptOverride: route.definition.config.prompt,
-                timeoutMs: this.timeoutMs
+                timeoutMs: this.timeoutMs,
+                // Disable delegation — subagents are leaf workers, not orchestrators
+                disabledTools: ["delegate"]
               } : {
                 id: subagentId,
                 name: `slot-${subagentId.slice(-6)}`,
                 // Let the coordinator apply its default budget (roster or generic).
                 // Hardcoding low limits here defeats the x10 budget improvement.
-                timeoutMs: this.timeoutMs
+                timeoutMs: this.timeoutMs,
+                // Disable delegation — subagents are leaf workers, not orchestrators
+                disabledTools: ["delegate"]
               }
             );
             subagentIds.push(subagentId);
@@ -8142,10 +8224,10 @@ ${lastFew}` : "No prior iterations.",
   // Helpers
   // -------------------------------------------------------------------------
   async appendIterationEntry(entry) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) return;
     const updated = appendJournal(current, entry);
-    await saveGoal(this.goalPath, updated);
+    await saveGoal(this.goalPath, updated, this.opts.events);
     const entryWithMeta = {
       at: (this.opts.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
       iteration: updated.iterations,
@@ -8157,10 +8239,10 @@ ${lastFew}` : "No prior iterations.",
     await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
   }
   async persistState(state) {
-    const current = await loadGoal(this.goalPath);
+    const current = await loadGoal(this.goalPath, this.opts.events);
     if (!current) return;
     if (current.engineState === state) return;
-    await saveGoal(this.goalPath, { ...current, engineState: state });
+    await saveGoal(this.goalPath, { ...current, engineState: state }, this.opts.events);
   }
 };
 
@@ -8471,6 +8553,8 @@ function compactSkillBody(body) {
 var DefaultSkillLoader = class {
   dirs;
   cache;
+  entriesCache;
+  bodyCache = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.dirs = [
       { dir: opts.paths.inProjectSkills, source: "project" },
@@ -8529,6 +8613,7 @@ var DefaultSkillLoader = class {
     return lines.join("\n");
   }
   async listEntries() {
+    if (this.entriesCache) return this.entriesCache;
     const skills = await this.list();
     const entries = [];
     for (const s of skills) {
@@ -8539,33 +8624,47 @@ var DefaultSkillLoader = class {
       } catch {
       }
     }
+    this.entriesCache = entries;
     return entries;
   }
   invalidateCache() {
     this.cache = void 0;
+    this.entriesCache = void 0;
+    this.bodyCache.clear();
   }
   async readBody(name) {
+    const cached = this.bodyCache.get(name);
+    if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
-    return fs.readFile(m.path, "utf8");
+    const body = await fs.readFile(m.path, "utf8");
+    this.bodyCache.set(name, body);
+    return body;
   }
   async readSaveBody(name) {
+    const key = `save:${name}`;
+    const cached = this.bodyCache.get(key);
+    if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
     const savePath = path2.join(path2.dirname(m.path), "SKILL.save.md");
+    let result;
     try {
-      return await fs.readFile(savePath, "utf8");
+      result = await fs.readFile(savePath, "utf8");
     } catch {
       const full = await fs.readFile(m.path, "utf8");
       const body = stripFrontmatter(full);
       const compact = compactSkillBody(body);
       if (compact) {
-        return `## Overview
+        result = `## Overview
 
 ${compact}`;
+      } else {
+        result = body.trim().slice(0, 300);
       }
-      return body.trim().slice(0, 300);
     }
+    this.bodyCache.set(key, result);
+    return result;
   }
 };
 function parseFrontmatter(raw) {