@wrongstack/core 0.89.1 → 0.104.0

package/dist/sdd/index.js

@@ -761,7 +761,7 @@ var TaskTracker = class {
     const blockers = this.getBlockers(taskId);
     return blockers.every((id) => {
       const node = this.graph?.nodes.get(id);
-      return node?.status === "completed";
+      return node?.status === "completed" || node?.status === "failed";
     });
   }
   getProgress() {
@@ -793,7 +793,7 @@ var TaskTracker = class {
         const remainingBlockers = this.getBlockers(depId);
         const allUnblocked = remainingBlockers.every((id) => {
           const blocker = this.graph?.nodes.get(id);
-          return blocker?.status === "completed";
+          return blocker?.status === "completed" || blocker?.status === "failed";
         });
         if (allUnblocked) {
           dep.status = "pending";
@@ -807,7 +807,7 @@ var TaskTracker = class {
     const blockers = this.getBlockers(taskId);
     const someBlocked = blockers.some((id) => {
       const blocker = this.graph?.nodes.get(id);
-      return blocker?.status !== "completed";
+      return blocker?.status !== "completed" && blocker?.status !== "failed";
     });
     if (someBlocked) {
       const node = this.graph.nodes.get(taskId);
@@ -1243,13 +1243,15 @@ var TaskGraphStore = class {
   }
 };
 
-// src/sdd/spec-builder.ts
-function expectDefined(value) {
+// src/utils/expect-defined.ts
+function expectDefined(value, label) {
   if (value === null || value === void 0) {
     throw new Error("Expected value to be defined");
   }
   return value;
 }
+
+// src/sdd/spec-builder.ts
 function buildQuestioningPrompt(session, min, max) {
   const answered = session.answers.length;
   const remaining = Math.max(0, min - answered);
@@ -2037,12 +2039,6 @@ function truncate(str, maxLen) {
 }
 
 // src/sdd/critical-path.ts
-function expectDefined2(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function analyzeCriticalPath(graph) {
   const nodes = Array.from(graph.nodes.values());
   const topoOrder = topologicalSort(graph);
@@ -2118,7 +2114,7 @@ function getTransitiveBlocked(_graph, taskId, blocksMap) {
   const visited = /* @__PURE__ */ new Set();
   const queue = [taskId];
   while (queue.length > 0) {
-    const current = expectDefined2(queue.shift());
+    const current = expectDefined(queue.shift());
     const blocked = blocksMap.get(current);
     if (!blocked) continue;
     for (const id of blocked) {
@@ -2164,7 +2160,7 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
     if (!changed) break;
   }
   let maxDist = 0;
-  let maxId = expectDefined2(allIds[0]);
+  let maxId = expectDefined(allIds[0]);
   for (const id of allIds) {
     const d = dist.get(id) ?? 0;
     if (d > maxDist) {
@@ -2991,15 +2987,7 @@ function makeAgentSubagentRunner(opts) {
     let budgetError = null;
     const onBudgetError = (err) => {
       if (err instanceof BudgetThresholdSignal) {
-        err.decision.then((decision) => {
-          if (decision === "stop") {
-            budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
-            aborter.abort();
-          }
-        }).catch(() => {
-          budgetError = new BudgetExceededError(err.kind, err.limit, err.used);
-          aborter.abort();
-        });
+        budgetError = err;
         return;
       }
       aborter.abort();
@@ -3107,15 +3095,23 @@ function makeAgentSubagentRunner(opts) {
     }
     if (budgetError) {
       if ("decision" in budgetError) {
-        const decision = await budgetError.decision;
-        if (decision === "stop") {
+        try {
+          const decision = await budgetError.decision;
+          if (decision === "stop") {
+            budgetError = new BudgetExceededError(
+              budgetError.kind,
+              budgetError.limit,
+              budgetError.used
+            );
+          } else {
+            budgetError = null;
+          }
+        } catch {
           budgetError = new BudgetExceededError(
             budgetError.kind,
             budgetError.limit,
             budgetError.used
           );
-        } else {
-          budgetError = null;
         }
       }
       if (budgetError) throw budgetError;
@@ -5454,6 +5450,109 @@ Working rules:
         "cloud cost"
       ]
     }
+  },
+  {
+    config: {
+      id: "tech-stack",
+      name: "Tech Stack Validator",
+      role: "tech-stack",
+      tools: ["search", "fetch", "read", "grep", "glob", "outdated", "audit", "json"],
+      prompt: `You are the Tech Stack Validator \u2014 a single-shot validation agent that fires
+before any package, library, or framework choice is committed.
+
+Your ONLY job: verify that a technology choice is current, real, and not obsolete.
+You are the "this isn't code, this is 10-year-old technology" agent. Intervene
+hard when the LLM hallucinates a version number or suggests dead tech.
+
+## Critical rules
+
+1. **Verify existence.** Search npm registry (fetch https://registry.npmjs.org/<pkg>/latest)
+   or web search. A package that doesn't exist = hallucination.
+
+2. **Check latest version.** Never trust any version number from the model. Always
+   fetch the actual latest stable version from npm or the project's release page.
+
+3. **Reject dead packages.** No release in >2 years + unresolved critical issues =
+   dead. Suggest a maintained replacement.
+
+4. **Reject prehistoric tech.** Any package/pattern superseded \u22655 years ago is
+   REJECTED. Key blocklist:
+   - axios / node-fetch / got / request \u2192 native fetch (Node 18+)
+   - moment \u2192 date-fns / luxon / Temporal
+   - jQuery (new projects) \u2192 vanilla DOM / React
+   - Gulp / Grunt \u2192 tsup / esbuild / vite
+   - CoffeeScript / Flow \u2192 TypeScript
+   - Bluebird \u2192 native Promises
+   - crypto-js \u2192 node:crypto / Web Crypto
+   - Bower \u2192 npm/pnpm
+   - underscore \u2192 lodash or native ES2020+
+
+5. **The intervention phrase.** When rejecting on age grounds, you MUST output
+   exactly: "This isn't code, this is X-year-old technology." where X =
+   current year \u2212 the year the technology was made obsolete. Follow with
+   what replaced it and a one-step migration path.
+
+6. **Prefer built-in over third-party.** Check Node 22+ native APIs first:
+   node:test, node:sqlite, fetch, WebSocket, Web Crypto \u2014 all built-in.
+
+## Workflow (single-shot \u2014 do NOT loop)
+
+1. Receive the proposed package + version
+2. Search npm registry or web for the latest version
+3. Check age, maintenance status, deprecation
+4. Output verdict: APPROVED (with exact version) or REJECTED (with replacement)
+
+## Output format
+
+### Tech Stack Validation \u2014 <package>
+
+**Status**: APPROVED | REJECTED
+
+**Package**: <name>@<version>
+**Source**: <URL you checked \u2014 npm registry, GitHub, web search>
+**Age**: <first release> \u2014 <last release date>
+**Verdict**: 1\u20132 sentence explanation.
+
+When REJECTED on age:
+**"This isn't code, this is X-year-old technology."**
+**Replaced by**: <modern alternative>
+**Migration**: <one concrete step>
+
+When APPROVED:
+**Install**: pnpm add <name>@^<major>.<minor>.0`
+    },
+    budget: {
+      timeoutMs: 6e4,
+      maxIterations: 5,
+      maxToolCalls: 20,
+      maxTokens: 4e4,
+      maxCostUsd: 0.1
+    },
+    capability: {
+      phase: "meta",
+      summary: "Single-shot tech stack validator: checks npm for latest versions, rejects dead/obsolete packages, enforces modern alternatives.",
+      keywords: [
+        "tech stack",
+        "version",
+        "package",
+        "library",
+        "framework",
+        "dependency",
+        "install",
+        "upgrade",
+        "latest",
+        "npm",
+        "pnpm add",
+        "outdated",
+        "obsolete",
+        "deprecated",
+        "what version",
+        "which package",
+        "check version",
+        "verify version",
+        "is this current"
+      ]
+    }
   }
 ];
 
@@ -6364,25 +6463,22 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
 };
 
 // src/sdd/sdd-parallel-run.ts
-function expectDefined3(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var SddParallelRun = class {
   constructor(opts) {
     this.opts = opts;
     this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
     this.timeoutMs = opts.taskTimeoutMs ?? 3e5;
+    this.maxRetries = Math.max(0, opts.maxRetries ?? 2);
     this.decomposer = new SddTaskDecomposer(opts.tracker, opts.graph, { parallelSlots: this.slots });
   }
   opts;
   slots;
   timeoutMs;
+  maxRetries;
   decomposer;
   coordinator = null;
   stopRequested = false;
+  retryMap = /* @__PURE__ */ new Map();
   // -------------------------------------------------------------------
   // Public API
   // -------------------------------------------------------------------
@@ -6394,6 +6490,7 @@ var SddParallelRun = class {
   /** Execute all waves until completion or deadlock. Returns final summary. */
   async run() {
     this.stopRequested = false;
+    this.retryMap.clear();
     const startTime = Date.now();
     let totalCompleted = 0;
     let totalFailed = 0;
@@ -6518,13 +6615,24 @@ var SddParallelRun = class {
     const successCount = results.filter((r) => r.status === "success").length;
     const failCount = results.length - successCount;
     for (let i = 0; i < results.length; i++) {
-      const result = expectDefined3(results[i]);
-      const taskId = expectDefined3(taskIds[i]);
+      const result = expectDefined(results[i]);
+      const taskId = expectDefined(taskIds[i]);
       if (result.status === "success") {
         this.opts.tracker.updateNodeStatus(taskId, "completed");
+        this.retryMap.delete(taskId);
       } else {
         const errMsg = result.error?.kind ? `${result.error.kind}: ${result.error.message}` : result.error?.message ?? "unknown error";
-        this.opts.tracker.updateNodeStatus(taskId, "failed", errMsg);
+        const currentRetries = this.retryMap.get(taskId) ?? 0;
+        if (currentRetries < this.maxRetries) {
+          this.retryMap.set(taskId, currentRetries + 1);
+          this.opts.tracker.updateNodeStatus(
+            taskId,
+            "pending",
+            `Retry ${currentRetries + 1}/${this.maxRetries}: ${errMsg}`
+          );
+        } else {
+          this.opts.tracker.updateNodeStatus(taskId, "failed", errMsg);
+        }
       }
     }
     return {
@@ -6539,6 +6647,7 @@ var SddParallelRun = class {
   }
   buildProgress() {
     const gp = this.opts.tracker.getProgress();
+    const isDeadlocked = !this.decomposer.isDone() && this.decomposer.nextBatch().deadlocked;
     return {
       wave: this.decomposer.getWaveCount(),
       total: gp.total,
@@ -6548,7 +6657,7 @@ var SddParallelRun = class {
       blocked: gp.blocked,
       pending: gp.pending,
       percent: gp.percentComplete,
-      deadlocked: false
+      deadlocked: isDeadlocked
     };
   }
 };