@wrongstack/core 0.89.3 → 0.107.2

package/dist/execution/index.js

@@ -2173,12 +2173,225 @@ function appendJournal(goal, entry) {
     journal: trimmed
   };
 }
+function parseProgressFromText(text) {
+  const re = /\[progress:\s*(\d{1,3})%\]\s*(?:[—\-]\s*(.+))?/i;
+  const m = text.match(re);
+  if (!m) return null;
+  const progress = Math.min(100, Math.max(0, Number.parseInt(m[1], 10)));
+  const note = m[2]?.trim() || void 0;
+  return { progress, note };
+}
+function recordProgress(goal, progress, note) {
+  const clamped = Math.min(100, Math.max(0, progress));
+  const history = [...goal.progressHistory ?? [], { at: (/* @__PURE__ */ new Date()).toISOString(), progress: clamped, note }];
+  const trimmed = history.length > 200 ? history.slice(-200) : history;
+  return {
+    ...goal,
+    progress: clamped,
+    progressNote: note ?? `${clamped}% complete`,
+    progressHistory: trimmed,
+    progressTrend: computeTrend(trimmed)
+  };
+}
+function computeTrend(history) {
+  if (history.length < 3) return void 0;
+  const recent = history.slice(-5);
+  const deltas = [];
+  for (let i = 1; i < recent.length; i++) {
+    deltas.push(recent[i].progress - recent[i - 1].progress);
+  }
+  if (deltas.length < 2) return void 0;
+  const avgDelta = deltas.reduce((a, b) => a + b, 0) / deltas.length;
+  if (avgDelta > 2) return "accelerating";
+  if (avgDelta < -1) return "stalling";
+  return "steady";
+}
 
 // src/utils/sleep.ts
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
+// src/execution/autonomy-brain.ts
+var RISK_LEVELS = {
+  low: 0,
+  medium: 1,
+  high: 2,
+  critical: 3
+};
+function createAutonomyBrain(opts) {
+  const maxRisk = opts.maxAutoRisk ?? "high";
+  const maxRiskLevel = RISK_LEVELS[maxRisk] ?? 2;
+  const timeoutMs = opts.decisionTimeoutMs ?? 15e3;
+  return {
+    async decide(request) {
+      const requestLevel = RISK_LEVELS[request.risk] ?? 2;
+      if (requestLevel > maxRiskLevel) {
+        const reason = `Auto-denied: risk "${request.risk}" exceeds max "${maxRisk}"`;
+        const decision = { type: "deny", reason };
+        opts.onDecision?.(
+          `\u{1F9E0} Brain: DENIED \u2014 ${request.question.slice(0, 80)} (risk: ${request.risk} > ${maxRisk})`,
+          decision,
+          request
+        );
+        return decision;
+      }
+      const heuristic = quickDecide(request);
+      if (heuristic) {
+        opts.onDecision?.(formatDecisionSummary(heuristic, request), heuristic, request);
+        return heuristic;
+      }
+      const llmDecision = await llmDecide(request, opts.provider, opts.model, timeoutMs);
+      opts.onDecision?.(formatDecisionSummary(llmDecision, request), llmDecision, request);
+      return llmDecision;
+    }
+  };
+}
+function formatDecisionSummary(decision, request) {
+  const question = request.question.length > 80 ? request.question.slice(0, 77) + "\u2026" : request.question;
+  if (decision.type === "deny") {
+    return `\u{1F9E0} Brain: DENIED \u2014 "${question}" \u2192 ${decision.reason}`;
+  }
+  if (decision.type === "answer") {
+    const action = decision.optionId ? `chose [${decision.optionId}]` : decision.text.length > 60 ? decision.text.slice(0, 57) + "\u2026" : decision.text;
+    return `\u{1F9E0} Brain: DECIDED \u2014 "${question}" \u2192 ${action}`;
+  }
+  return `\u{1F9E0} Brain: ASKED HUMAN \u2014 "${question}"`;
+}
+function quickDecide(request) {
+  const q = request.question.toLowerCase();
+  const ctx = request.context?.toLowerCase() ?? "";
+  if (q.includes("deadlock") && ctx.includes("failed")) {
+    return {
+      type: "answer",
+      text: "Skip deadlocked tasks and continue with remaining work. Failed tasks will be reported in the final summary.",
+      rationale: "Heuristic: deadlocked tasks blocked by failed dependencies \u2014 skipping unblocks remaining work."
+    };
+  }
+  if ((q.includes("failed") || q.includes("retry")) && (ctx.includes("3") || ctx.includes("exhausted"))) {
+    return {
+      type: "answer",
+      text: "Mark as failed and move on. Note the failure for the final report.",
+      rationale: "Heuristic: retries exhausted \u2014 continuing would waste resources."
+    };
+  }
+  if (q.includes("goal complete") || q.includes("mission complete")) {
+    return null;
+  }
+  if (q.includes("continue") || q.includes("proceed")) {
+    return {
+      type: "answer",
+      text: "Continue execution. Do not stop.",
+      rationale: "Heuristic: autonomy mode \u2014 continue until all work is complete."
+    };
+  }
+  return null;
+}
+async function llmDecide(request, provider, model, timeoutMs) {
+  const optionsText = request.options?.length ? "\nOptions:\n" + request.options.map(
+    (o) => `  [${o.id}] ${o.label}${o.consequence ? ` \u2014 ${o.consequence}` : ""}${o.recommended ? " \u2605 recommended" : ""}`
+  ).join("\n") : "";
+  const systemPrompt = [
+    "IDENTITY:",
+    "You are the Autonomy Brain \u2014 a dedicated decision engine inside an",
+    "autonomous AI coding agent called WrongStack. Your SOLE purpose is to",
+    "evaluate situations where the autonomous workflow is blocked, stuck, or",
+    "uncertain, and decide the best course of action to keep the system",
+    "running and making progress toward its goal.",
+    "",
+    "WHAT YOU DO:",
+    "- You receive a question + context from an autonomy subsystem (goal",
+    "  engine, phase orchestrator, task decomposer).",
+    "- You evaluate whether the system should continue, pivot, retry, skip,",
+    "  or stop.",
+    "- You output exactly ONE decision. No preamble, no markdown, no",
+    "  elaboration beyond what is needed to justify the decision.",
+    "",
+    "HOW YOU DECIDE:",
+    '1. PREFER CONTINUATION. The default answer is always "continue" unless',
+    "   there is clear evidence that stopping is safer or more productive.",
+    "2. BE SPECIFIC. If options are provided, pick one by its [id]. If not,",
+    "   describe the exact action in 1-2 sentences.",
+    "3. VERIFY COMPLETION. If the question is about whether the goal is done,",
+    "   check deliverables and progress before saying yes. A progress bar at",
+    "   80% with open deliverables means NOT done.",
+    "4. AVOID WASTE. If a task has failed 3+ times with the same approach,",
+    "   recommend a different approach or skipping it \u2014 do not recommend",
+    "   retrying the same thing.",
+    "5. CONSIDER COST. If the question mentions spent budget or token counts,",
+    "   factor that into your decision. A goal that has already spent $50",
+    "   with 90% progress is worth finishing; one at 15% with $100 spent",
+    "   may need re-evaluation.",
+    "",
+    "OUTPUT FORMAT:",
+    "- With options: output the option [id] and a 1-sentence justification.",
+    '  Example: "[resolve] \u2014 conflict is in test files only, safe to auto-resolve."',
+    "- Without options: output the decision as a 1-2 sentence action.",
+    '  Example: "Continue execution. Progress is steady at 60% with 3/5',
+    '  deliverables done. No reason to stop."',
+    "",
+    "CRITICAL RULE:",
+    "You are NOT the main agent. Do not suggest code changes, tool calls,",
+    "or implementation details. Your output is a DECISION, not a plan."
+  ].join("\n");
+  const userMessage = [
+    `Question: ${request.question}`,
+    request.context ? `
+Context:
+${request.context}` : "",
+    optionsText
+  ].filter(Boolean).join("\n");
+  try {
+    const signal = AbortSignal.timeout(timeoutMs);
+    const response = await provider.complete(
+      {
+        model,
+        system: [{ type: "text", text: systemPrompt }],
+        messages: [{ role: "user", content: userMessage || "Decide." }],
+        maxTokens: 200
+      },
+      { signal }
+    );
+    const text = extractText(response).trim();
+    if (request.options?.length) {
+      for (const opt of request.options) {
+        if (text.toLowerCase().includes(opt.id.toLowerCase())) {
+          return {
+            type: "answer",
+            optionId: opt.id,
+            text: opt.label,
+            rationale: text
+          };
+        }
+      }
+    }
+    return {
+      type: "answer",
+      text: text || (request.fallback === "continue" ? "Continue execution." : "Denied by autonomy policy."),
+      rationale: text || void 0
+    };
+  } catch {
+    if (request.fallback === "continue") {
+      return {
+        type: "answer",
+        text: "Continue (Autonomy Brain LLM unavailable \u2014 using fallback)."
+      };
+    }
+    return { type: "deny", reason: "Autonomy Brain LLM unavailable for decision." };
+  }
+}
+function extractText(result) {
+  if (!result || typeof result !== "object") return "";
+  const r = result;
+  if (Array.isArray(r.content)) {
+    return r.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+  }
+  if (Array.isArray(r.choices)) {
+    return r.choices[0]?.message?.content ?? "";
+  }
+  return typeof r.text === "string" ? r.text : "";
+}
+
 // src/execution/eternal-autonomy.ts
 var execFileP = promisify(execFile);
 var BRAINSTORM_DONE = /* @__PURE__ */ Symbol("brainstorm-done");
@@ -2248,7 +2461,7 @@ var EternalAutonomyEngine = class {
           this.consecutiveFailures = 0;
         }
         if (this.stopRequested) break;
-        await sleep(this.opts.cycleGapMs ?? 1e3);
+        await sleep(this.opts.cycleGapMs ?? 0);
       }
     } finally {
       this.state = "stopped";
@@ -2418,6 +2631,18 @@ var EternalAutonomyEngine = class {
       this.stopRequested = true;
       return true;
     }
+    const parsed = parseProgressFromText(finalText);
+    if (parsed) {
+      await this.updateProgress(parsed.progress, parsed.note);
+      if (parsed.progress >= 100) {
+        await this.markGoalCompleted(
+          { source: action.source, task: action.task, directive: action.directive },
+          `progress reached 100%: ${parsed.note ?? "goal complete"}`
+        );
+        this.stopRequested = true;
+        return true;
+      }
+    }
     this.iterationsSinceCompact++;
     await this.maybeCompact().catch((err) => {
       this.opts.onError?.(
@@ -2504,11 +2729,16 @@ var EternalAutonomyEngine = class {
       this.consecutiveBrainstormDone++;
       const threshold = this.opts.brainstormDoneStopThreshold ?? 3;
       if (this.consecutiveBrainstormDone >= threshold) {
-        await this.markGoalCompleted(
-          { source: "brainstorm", task: "no further work", directive: "" },
-          `brainstorm returned DONE ${this.consecutiveBrainstormDone}x in a row`
-        );
-        this.stopRequested = true;
+        const shouldStop = await this.consultBrainForDone(goal);
+        if (shouldStop) {
+          await this.markGoalCompleted(
+            { source: "brainstorm", task: "no further work", directive: "" },
+            `brainstorm returned DONE ${this.consecutiveBrainstormDone}x in a row${this.opts.brain ? ", brain confirmed" : ""}`
+          );
+          this.stopRequested = true;
+        } else {
+          this.consecutiveBrainstormDone = 0;
+        }
       }
       return null;
     }
@@ -2742,6 +2972,69 @@ ${recentJournal}` : "No prior iterations.",
   async appendFailure(task, note) {
     await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
   }
+  /**
+   * Consult the brain on whether the goal is truly complete.
+   * Without a brain, always returns true (use heuristic: DONE threshold met = done).
+   */
+  async consultBrainForDone(goal) {
+    if (!this.opts.brain) return true;
+    const deliverablesStatus = goal.deliverables?.length ? `
+Deliverables: ${goal.deliverables.length} total, progress ${goal.progress ?? "unknown"}%` : "";
+    const recentJournal = goal.journal.slice(-5).map(
+      (e) => `  #${e.iteration} [${e.status}] ${e.task}`
+    ).join("\n");
+    try {
+      const decision = await this.opts.brain.decide({
+        id: `goal-done-${goal.iterations}`,
+        source: "system",
+        question: `Brainstorm returned DONE ${this.consecutiveBrainstormDone}x. Is the goal truly complete?`,
+        context: [
+          `Goal: ${goal.goal}`,
+          `Iterations: ${goal.iterations}`,
+          `Progress: ${goal.progress ?? "unknown"}%`,
+          deliverablesStatus,
+          recentJournal ? `
+Recent work:
+${recentJournal}` : ""
+        ].join("\n"),
+        risk: "high",
+        fallback: "continue"
+      });
+      const summary = formatDecisionSummary(decision, {
+        id: `goal-done-${goal.iterations}`,
+        source: "system",
+        question: "Is the goal complete?",
+        risk: "high",
+        fallback: "continue"
+      });
+      const rationale = "rationale" in decision ? decision.rationale : void 0;
+      await this.appendIterationEntry({
+        source: "brainstorm",
+        task: summary,
+        status: "success",
+        note: rationale
+      });
+      if (decision.type === "deny") {
+        return false;
+      }
+      if (decision.type === "answer") {
+        const text = decision.text.toLowerCase();
+        return text.includes("complete") || text.includes("done") || text.includes("yes");
+      }
+      return true;
+    } catch {
+      return true;
+    }
+  }
+  /**
+   * Persist a progress update from the agent's [PROGRESS: N%] output.
+   */
+  async updateProgress(progress, note) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    const updated = recordProgress(current, progress, note);
+    await saveGoal(this.goalPath, updated);
+  }
   async persistEngineState(state) {
     const current = await loadGoal(this.goalPath);
     if (!current) return;
@@ -5395,6 +5688,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"
+      ]
+    }
   }
 ];
 
@@ -7001,7 +7397,17 @@ ${journalTail.join("\n")}` : "Recent journal: (none \u2014 this is the first ite
 }
 
 // src/execution/goal-preamble.ts
-function buildGoalPreamble(goal) {
+function buildGoalPreamble(goal, deliverables) {
+  const deliverableBlock = deliverables && deliverables.length > 0 ? [
+    "",
+    "CONCRETE DELIVERABLES (check these off as you go):",
+    ...deliverables.map((d, i) => `  ${i + 1}. ${d}`),
+    "",
+    "After EACH iteration, estimate your completion percentage (0\u2013100)",
+    "against this deliverable list. Output it as:",
+    "  [PROGRESS: N%] \u2014 <1-sentence status>",
+    "The eternal engine reads this to update the progress bar."
+  ].join("\n") : "";
   return [
     "[GOAL \u2014 LOCKED IN. You will work on this until it is verifiably done.",
     "The user granted you full autonomy. Read these constraints once, then act.",
@@ -7010,6 +7416,7 @@ function buildGoalPreamble(goal) {
     "---",
     goal,
     "---",
+    deliverableBlock,
     "",
     "AUTHORITY YOU HAVE:",
     "- Spawn as many subagents as the work needs (delegate / spawn_subagent).",
@@ -7031,6 +7438,7 @@ function buildGoalPreamble(goal) {
     "- You can tell the user HOW to verify it themselves in 10 seconds.",
     '- You have NOT hedged. None of: "looks like it should work", "I',
     '  believe this fixes it", "the changes appear correct".',
+    `- Progress bar shows 100%. All deliverables checked off.`,
     "",
     "WHAT IS NOT DONE \u2014 never report any of these as completion:",
     "- An error message you didn't recover from.",
@@ -7045,6 +7453,13 @@ function buildGoalPreamble(goal) {
     "  respond to with a fresh attempt (different role, different model,",
     "  tighter prompt).",
     "",
+    "PROGRESS REPORTING \u2014 MANDATORY every iteration:",
+    "- End every response with exactly: [PROGRESS: N%] \u2014 <status note>",
+    "  where N is your honest estimate (0-100) of how much of the goal",
+    "  is done. The engine tracks this and shows a live progress bar.",
+    "- Example: [PROGRESS: 45%] \u2014 Auth module refactored, 3/5 tests pass,",
+    "  remaining: test coverage + docs update.",
+    "",
     "PERSISTENCE PROTOCOL:",
     "- If blocked, try at least 3 different angles before reporting the",
     "  problem to the user. Different tool inputs, different subagent",
@@ -7320,6 +7735,6 @@ function parseDescription(raw) {
   return { trigger, scope };
 }
 
-export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, ParallelEternalEngine, SelectiveCompactor, ToolExecutor, buildGoalPreamble, makeAutonomyPromptContributor };
+export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, ParallelEternalEngine, SelectiveCompactor, ToolExecutor, buildGoalPreamble, createAutonomyBrain, formatDecisionSummary, makeAutonomyPromptContributor };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map