@wrongstack/core 0.280.1 → 0.281.1

package/dist/sdd/index.d.ts

@@ -1,18 +1,18 @@
 import { h as Specification, e as SpecStatus, S as SpecAnalysis, g as SpecValidationResult, f as SpecTemplate, b as SpecRequirement } from '../spec-TBi3Jr6T.js';
 import { d as TaskGraph, e as TaskNode, i as TaskFilter, j as TaskSort, c as TaskProgress, T as TaskType, a as TaskPriority } from '../task-graph-u1q9Jkyk.js';
-import { E as EventBus, B as BrainArbiter } from '../events-Bs2fmldo.js';
-import { h as Agent, i as AgentFactory, g as TaskResult, D as DoneCondition } from '../agent-subagent-runner-PoqNKiR4.js';
-import { W as WorktreeManager } from '../worktree-manager-BjOFF6bt.js';
-import '../tool-BkOgs_KL.js';
-import '../permission-Dx6dIqS2.js';
-import '../index-kidebiDh.js';
+import { E as EventBus, B as BrainArbiter } from '../events-C5hLU0AT.js';
+import { A as Agent, a as AgentFactory, g as TaskResult, D as DoneCondition } from '../agent-subagent-runner-DyOSK2Wy.js';
+import { W as WorktreeManager } from '../worktree-manager-C6CIilTT.js';
+import '../tool-LVSLiE1s.js';
+import '../permission-B6YAtNFz.js';
+import '../index-C1E-_71T.js';
 import '../logger-B63L5bTg.js';
-import '../pipeline-BwAP21_4.js';
+import '../pipeline-E7_jqGyV.js';
 import '../mailbox-types-BGZWrYTJ.js';
-import '../config-Cr3312zc.js';
+import '../config-CN-vdDEI.js';
 import '../observability-D-HZN_mF.js';
 import '../secret-scrubber-3MHDDAtm.js';
-import '../retry-policy-D4feSLk3.js';
+import '../retry-policy-V67lBOJz.js';
 
 interface TaskStore {
     saveGraph(graph: TaskGraph): Promise<void>;

package/dist/sdd/index.js

@@ -3892,20 +3892,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(path5.join(dir, fileName), "utf8").trimEnd();
+      resolved = readFileSync(path5.join(dir, fileName), "utf8").trimEnd();
+      break;
     } catch {
     }
   }
-  return "";
+  promptCache.set(cacheKey, resolved);
+  return resolved;
 }
-function agentPromptDirCandidates() {
-  const here = path5.dirname(fileURLToPath(import.meta.url));
-  const explicitDir = process.env["WRONGSTACK_AGENT_INSTRUCTIONS_DIR"];
+function agentPromptDirCandidates(envDir) {
   const globalRoot = process.env["WRONGSTACK_HOME"] || path5.join(os.homedir(), ".wrongstack");
+  const candKey = `${envDir}\0${globalRoot}`;
+  const cached = candidateCache.get(candKey);
+  if (cached !== void 0) return cached;
+  const here = path5.dirname(fileURLToPath(import.meta.url));
+  const explicitDir = envDir || void 0;
   const candidates = [
     ...explicitDir ? [path5.resolve(explicitDir)] : [],
     path5.join(globalRoot, "instructions", "agents"),
@@ -3915,7 +3927,9 @@ function agentPromptDirCandidates() {
     path5.resolve(here, "../instructions/agents"),
     path5.resolve(here, "instructions/agents")
   ];
-  return candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
+  const ordered = candidates.sort((a, b) => Number(!isDirectory(a)) - Number(!isDirectory(b)));
+  candidateCache.set(candKey, ordered);
+  return ordered;
 }
 function isDirectory(candidate) {
   try {
@@ -5810,6 +5824,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.
@@ -5837,6 +5875,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((resolve4) => {
+      let timer;
+      const handler = ({ result }) => {
+        if (!ids.has(result.taskId)) return;
+        if (timer) clearTimeout(timer);
+        this.off("task.completed", handler);
+        resolve4({
+          completed: [result],
+          pending: taskIds.filter((id) => id !== result.taskId)
+        });
+      };
+      if (opts?.timeoutMs !== void 0) {
+        timer = setTimeout(() => {
+          this.off("task.completed", handler);
+          resolve4({ 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
@@ -9137,14 +9212,21 @@ function makeCommandVerifier(options = {}) {
     });
   };
 }
+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(path5.join(root, relativePath), "utf8").trimEnd();
+      resolved = readFileSync(path5.join(root, relativePath), "utf8").trimEnd();
+      break;
     } catch {
     }
   }
-  return "";
+  textCache.set(relativePath, resolved);
+  return resolved;
 }
 function renderInstructionTemplate(template, values) {
   return template.replace(
@@ -9153,13 +9235,15 @@ function renderInstructionTemplate(template, values) {
   );
 }
 function instructionRootCandidates() {
+  if (rootCandidates !== void 0) return rootCandidates;
   const here = path5.dirname(fileURLToPath(import.meta.url));
   const candidates = [
     path5.resolve(here, "../../instructions"),
     path5.resolve(here, "../instructions"),
     path5.resolve(here, "instructions")
   ];
-  return candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
+  rootCandidates = candidates.sort((a, b) => Number(!isDirectory2(a)) - Number(!isDirectory2(b)));
+  return rootCandidates;
 }
 function isDirectory2(candidate) {
   try {