@wrongstack/core 0.89.1 → 0.104.0

package/dist/execution/index.js

@@ -6,13 +6,15 @@ import { randomUUID, createHash, randomBytes } from 'crypto';
 import * as os from 'os';
 import { EventEmitter } from 'events';
 
-// src/utils/token-estimate.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/utils/token-estimate.ts
 var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
 var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
 var ESTIMATE_CACHE_MAX_SIZE = 1e4;
@@ -100,12 +102,6 @@ function estimateRequestTokensCalibrated(messages, systemPrompt, tools) {
 }
 
 // src/utils/message-invariants.ts
-function expectDefined2(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 function repairToolUseAdjacency(messages) {
   const removedToolUses = [];
   const removedToolResults = [];
@@ -113,7 +109,7 @@ function repairToolUseAdjacency(messages) {
   let changed = false;
   const out = [];
   for (let i = 0; i < messages.length; i++) {
-    const original = expectDefined2(messages[i]);
+    const original = expectDefined(messages[i]);
     let msg = original;
     if (hasToolUse(msg)) {
       const nextIds = toolResultIds(messages[i + 1]);
@@ -613,12 +609,6 @@ var IntelligentCompactor = class {
 };
 
 // src/models/llm-selector.ts
-function expectDefined3(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var DEFAULT_SYSTEM_PROMPT = `You are a context pruning assistant. Given a conversation history and a token budget, decide which message ranges are worth keeping verbatim and which should be collapsed into summaries.
 
 Output a JSON object with this structure:
@@ -659,7 +649,7 @@ function formatMessages(messages, maxChars = 8e3) {
   const lines = [];
   let used = 0;
   for (let i = 0; i < messages.length; i++) {
-    const m = expectDefined3(messages[i]);
+    const m = expectDefined(messages[i]);
     const role = m.role.padEnd(10, " ");
     let text;
     if (typeof m.content === "string") {
@@ -724,7 +714,7 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
     let tokenCount = 0;
     let startIdx = 0;
     for (let i = messages.length - 1; i >= 0; i--) {
-      const m = expectDefined3(messages[i]);
+      const m = expectDefined(messages[i]);
       const cost = typeof m.content === "string" ? Math.ceil(m.content.length / 4) : m.content.reduce(
         (acc, b) => acc + (b.type === "text" ? Math.ceil(b.text.length / 4) : Math.ceil(JSON.stringify(b).length / 4)),
         0
@@ -1457,12 +1447,6 @@ function createToolOutputSerializer(opts = {}) {
 }
 
 // src/execution/tool-executor.ts
-function expectDefined4(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var ToolExecutor = class {
   constructor(registry, opts) {
     this.registry = registry;
@@ -1869,7 +1853,7 @@ function hasMalformedArguments(input) {
 function extractMalformedRaw(input) {
   if (!hasMalformedArguments(input)) return void 0;
   const obj = input;
-  const value = obj[expectDefined4(Object.keys(obj)[0])];
+  const value = obj[expectDefined(Object.keys(obj)[0])];
   if (value === void 0 || value === null) return void 0;
   if (typeof value === "string") return value;
   try {
@@ -2189,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");
@@ -2264,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";
@@ -2434,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?.(
@@ -2520,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;
     }
@@ -2758,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;
@@ -3123,15 +3400,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();
@@ -3239,15 +3508,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;
@@ -5411,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"
+      ]
+    }
   }
 ];
 
@@ -6557,12 +6937,6 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
 };
 
 // src/execution/parallel-eternal-engine.ts
-function expectDefined5(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected value to be defined");
-  }
-  return value;
-}
 var GOAL_COMPLETE_MARKER2 = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var ParallelEternalEngine = class {
   constructor(opts) {
@@ -6718,7 +7092,7 @@ var ParallelEternalEngine = class {
   // Fan-out
   // -------------------------------------------------------------------------
   async fanOut(goal, tasks) {
-    const coordinator = expectDefined5(this.coordinator);
+    const coordinator = expectDefined(this.coordinator);
     const slotCount = Math.min(this.slots, tasks.length);
     const routes = this.dispatchEnabled ? await Promise.all(
       tasks.slice(0, slotCount).map(
@@ -6750,7 +7124,7 @@ ${recentJournal}` : "No prior iterations.",
     const routeInfo = [];
     const spawnPromises = [];
     for (let i = 0; i < slotCount; i++) {
-      const task = expectDefined5(tasks[i]);
+      const task = expectDefined(tasks[i]);
       const route = routes[i] ?? null;
       const subagentId = `parallel-${this.iterations}-${i}`;
       const taskId = randomUUID();
@@ -7023,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.",
@@ -7032,6 +7416,7 @@ function buildGoalPreamble(goal) {
     "---",
     goal,
     "---",
+    deliverableBlock,
     "",
     "AUTHORITY YOU HAVE:",
     "- Spawn as many subagents as the work needs (delegate / spawn_subagent).",
@@ -7053,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.",
@@ -7067,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",
@@ -7342,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