@wrongstack/core 0.6.0 → 0.6.1

package/dist/execution/index.js

@@ -1245,13 +1245,17 @@ var ToolExecutor = class {
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(new Error("tool timeout")), timeoutMs);
     const combined = AbortSignal.any([parentSignal, ctrl.signal]);
+    let cleanupCalled = false;
+    let caught = false;
     try {
       if (typeof tool.executeStream === "function") {
         return await this.runStreamedTool(tool, input, ctx, combined, toolUseId);
       }
       return await tool.execute(input, ctx, { signal: combined });
     } catch (err) {
+      caught = true;
       if (combined.aborted && typeof tool.cleanup === "function") {
+        cleanupCalled = true;
         try {
           await tool.cleanup(input, ctx);
         } catch {
@@ -1260,6 +1264,16 @@ var ToolExecutor = class {
       throw err;
     } finally {
       clearTimeout(timer);
+      if (combined.aborted && !caught) {
+        if (!cleanupCalled && typeof tool.cleanup === "function") {
+          try {
+            await tool.cleanup(input, ctx);
+          } catch {
+          }
+        }
+        const reason = combined.reason instanceof Error ? combined.reason : new Error(typeof combined.reason === "string" ? combined.reason : "aborted");
+        throw reason;
+      }
     }
   }
   async runStreamedTool(tool, input, ctx, signal, toolUseId) {
@@ -1317,7 +1331,8 @@ var ToolExecutor = class {
     if (subjectKey) {
       const v = obj[subjectKey];
       if (typeof v === "string") {
-        return subjectKey === "path" || subjectKey === "file" || subjectKey === "files" ? normalizePath(v) : escapeGlob(v);
+        const isPathKey = subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
+        return isPathKey ? normalizePath(v) : escapeGlob(v);
       }
     }
     if (toolName === "bash" && typeof obj.command === "string") {
@@ -1639,6 +1654,8 @@ function appendJournal(goal, entry) {
 
 // src/execution/eternal-autonomy.ts
 var execFileP = promisify(execFile);
+var BRAINSTORM_DONE = /* @__PURE__ */ Symbol("brainstorm-done");
+var GOAL_COMPLETE_MARKER = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var EternalAutonomyEngine = class {
   constructor(opts) {
     this.opts = opts;
@@ -1648,6 +1665,14 @@ var EternalAutonomyEngine = class {
   state = "idle";
   stopRequested = false;
   consecutiveFailures = 0;
+  consecutiveBrainstormDone = 0;
+  /**
+   * Count of consecutive transient (recoverable) provider failures. Drives
+   * the exponential backoff between iterations. Reset on the first
+   * successful iteration so a single bad afternoon doesn't permanently
+   * slow the loop down.
+   */
+  consecutiveTransientRetries = 0;
   currentCtrl = null;
   iterationsSinceCompact = 0;
   goalPath;
@@ -1717,9 +1742,16 @@ var EternalAutonomyEngine = class {
       this.stopRequested = true;
       return false;
     }
+    const missionState = goal.goalState ?? "active";
+    if (missionState !== "active") {
+      this.stopRequested = true;
+      return false;
+    }
     const action = await this.decide(goal);
     if (!action) {
-      await sleep(5e3);
+      if (!this.stopRequested) {
+        await sleep(5e3);
+      }
       return false;
     }
     const ctrl = new AbortController();
@@ -1730,13 +1762,29 @@ var EternalAutonomyEngine = class {
     );
     let status = "success";
     let note;
+    let finalText = "";
+    let isTransientFailure = false;
     const tc = this.opts.agent.ctx?.tokenCounter;
     const beforeUsage = tc?.total?.();
     const beforeCost = tc?.estimateCost?.().total;
     try {
       const result = await this.opts.agent.run(
         [{ type: "text", text: action.directive }],
-        { signal: ctrl.signal }
+        {
+          signal: ctrl.signal,
+          // Enable per-call autonomous continuation so the agent can chain
+          // multiple internal tool/response cycles end-to-end on one
+          // directive instead of returning to the engine after a single
+          // round-trip. The model uses `[continue]` / `[done]` markers
+          // (or the `continue_to_next_iteration` tool) to control the
+          // inner loop. Without this flag the engine produced shallow
+          // iterations and almost never let a real task finish.
+          autonomousContinue: true,
+          // Cap the inner loop so a runaway agent.run can't burn through
+          // the iteration timeout — the engine's own outer loop is the
+          // long-running thing, each tick should be bounded.
+          maxIterations: this.opts.iterationMaxAgentSteps ?? 50
+        }
       );
       if (result.status === "aborted") {
         status = "aborted";
@@ -1744,22 +1792,30 @@ var EternalAutonomyEngine = class {
       } else if (result.status === "failed") {
         status = "failure";
         note = result.error?.describe?.() ?? "agent run failed";
+        isTransientFailure = result.error?.recoverable === true;
       } else if (result.status === "max_iterations") {
         status = "failure";
         note = `max iterations (${result.iterations})`;
       } else {
         status = "success";
-        const tail = (result.finalText ?? "").slice(0, 240).replace(/\s+/g, " ").trim();
+        finalText = result.finalText ?? "";
+        const tail = finalText.slice(0, 240).replace(/\s+/g, " ").trim();
         if (tail) note = tail;
       }
     } catch (err) {
       const isAbort = err instanceof Error && (err.name === "AbortError" || err.message.includes("abort"));
       status = isAbort ? "aborted" : "failure";
       note = err instanceof Error ? err.message : String(err);
+      if (!isAbort && typeof err?.recoverable === "boolean") {
+        isTransientFailure = err.recoverable;
+      }
     } finally {
       clearTimeout(timer);
       this.currentCtrl = null;
     }
+    if (action.source === "todo" && action.todoId && status !== "success") {
+      await this.bumpTodoAttempt(action.todoId);
+    }
     const afterUsage = tc?.total?.();
     const afterCost = tc?.estimateCost?.().total;
     const tokens = beforeUsage && afterUsage ? {
@@ -1792,6 +1848,14 @@ var EternalAutonomyEngine = class {
       costUsd
     });
     if (status === "failure") {
+      if (isTransientFailure) {
+        this.consecutiveTransientRetries++;
+        const delay = this.computeTransientBackoffMs();
+        if (delay > 0) {
+          await this.sleepInterruptible(delay);
+        }
+        return false;
+      }
       this.consecutiveFailures++;
       return false;
     }
@@ -1800,6 +1864,12 @@ var EternalAutonomyEngine = class {
       this.consecutiveFailures++;
       return false;
     }
+    this.consecutiveTransientRetries = 0;
+    if (GOAL_COMPLETE_MARKER.test(finalText)) {
+      await this.markGoalCompleted(action, finalText);
+      this.stopRequested = true;
+      return true;
+    }
     this.iterationsSinceCompact++;
     await this.maybeCompact().catch((err) => {
       this.opts.onError?.(
@@ -1863,11 +1933,12 @@ var EternalAutonomyEngine = class {
   async decide(goal) {
     const forceBrainstorm = this.consecutiveFailures >= (this.opts.failureBudget ?? 3);
     if (!forceBrainstorm) {
-      const todo = this.pickPendingTodo();
+      const todo = this.pickPendingTodo(goal);
       if (todo) {
         return {
           source: "todo",
           task: todo.content,
+          todoId: todo.id,
           directive: this.buildDirective(goal, "todo", todo.content)
         };
       }
@@ -1881,17 +1952,38 @@ var EternalAutonomyEngine = class {
       }
     }
     const brainstormed = await this.brainstormTask(goal);
+    if (brainstormed === BRAINSTORM_DONE) {
+      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;
+      }
+      return null;
+    }
     if (!brainstormed) return null;
+    this.consecutiveBrainstormDone = 0;
     return {
       source: "brainstorm",
       task: brainstormed,
       directive: this.buildDirective(goal, "brainstorm", brainstormed)
     };
   }
-  pickPendingTodo() {
+  pickPendingTodo(goal) {
     const todos = this.opts.agent.ctx.todos;
     if (!Array.isArray(todos)) return null;
-    return todos.find((t) => t.status === "pending") ?? null;
+    const attempts = goal.todoAttempts ?? {};
+    const ceiling = this.opts.todoMaxAttempts ?? 3;
+    for (const t of todos) {
+      if (t.status !== "pending") continue;
+      const used = attempts[t.id] ?? 0;
+      if (used >= ceiling) continue;
+      return t;
+    }
+    return null;
   }
   async pickGitTask() {
     let out;
@@ -1928,7 +2020,10 @@ ${lastFew}` : "No prior iterations yet.",
       "- One sentence, imperative form, under 200 chars.",
       "- No preamble, no explanation, no markdown \u2014 just the task line.",
       "- If recent iterations show repeated failures on the same target, pivot.",
-      "- If the goal appears fully accomplished, output exactly: DONE"
+      "- If the goal appears fully accomplished AND you can name a concrete",
+      "  artifact / test / output that proves it, output exactly: DONE",
+      "- Be conservative with DONE: if the recent journal contains failures",
+      "  or aborted entries, the goal is almost certainly NOT done."
     ].join("\n");
     try {
       const ctrl = new AbortController();
@@ -1940,9 +2035,11 @@ ${lastFew}` : "No prior iterations yet.",
         );
         if (result.status !== "done") return null;
         const text = (result.finalText ?? "").trim();
-        if (!text || text === "DONE") return null;
+        if (!text) return null;
+        if (/^DONE\.?$/i.test(text)) return BRAINSTORM_DONE;
         const firstLine = text.split("\n").find((l) => l.trim().length > 0)?.trim();
         if (!firstLine) return null;
+        if (/^DONE\.?$/i.test(firstLine)) return BRAINSTORM_DONE;
         return firstLine.slice(0, 240);
       } finally {
         clearTimeout(timer);
@@ -1952,19 +2049,82 @@ ${lastFew}` : "No prior iterations yet.",
     }
   }
   buildDirective(goal, source, task) {
+    const recentJournal = goal.journal.slice(-5).map((e) => `  #${e.iteration} [${e.status}] ${e.task}${e.note ? ` \u2014 ${e.note.slice(0, 80)}` : ""}`).join("\n");
     return [
-      "[ETERNAL AUTONOMY \u2014 iteration directive]",
+      "\u2550\u2550\u2550 ETERNAL AUTONOMY \u2014 iteration directive \u2550\u2550\u2550",
       "",
-      `Goal: ${goal.goal}`,
+      `Mission: ${goal.goal}`,
+      `Iteration: #${goal.iterations + 1}`,
       `Source: ${source}`,
       `Task: ${task}`,
       "",
-      "Execute this task end-to-end using the tools available to you. Make the",
-      "changes, run tests if relevant, and commit / push as appropriate. Do not",
-      "ask for confirmation \u2014 YOLO mode is active. When the task is done, stop;",
-      "the loop will pick the next action."
+      recentJournal ? `Recent journal (last 5):
+${recentJournal}` : "No prior iterations.",
+      "",
+      "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
+      "You are inside a long-running autonomous loop. Each iteration you",
+      "execute ONE concrete task that advances the Mission. No user is",
+      "available to clarify \u2014 make defensible decisions and move forward.",
+      "",
+      "1. EXECUTE END-TO-END",
+      "   \u2022 Use multiple tool calls freely. Emit `[continue]` on its own line",
+      "     to chain to the next internal step without returning.",
+      "   \u2022 When this iteration's Task is finished (real artifact / passing",
+      "     test / applied diff / clean output), emit `[done]` on its own line.",
+      "   \u2022 Do not stop on the first obstacle \u2014 try at least 3 distinct",
+      "     approaches before giving up. YOLO is active; no confirmations.",
+      "",
+      "2. UPDATE TODO STATE (when Source is `todo`)",
+      "   \u2022 Mark this todo `in_progress` via the todos tool before tool work.",
+      "   \u2022 Mark it `completed` on success, with a one-line outcome note.",
+      "   \u2022 If you cannot make progress after 2 distinct attempts, mark it",
+      "     `cancelled` with the obstacle. The loop will skip it next time.",
+      "",
+      "3. MISSION-COMPLETE PROTOCOL",
+      "   \u2022 If \u2014 and ONLY if \u2014 the OVERALL Mission (not just this Task) is",
+      "     verifiably accomplished, emit on its own line:",
+      "         [GOAL_COMPLETE]",
+      "     followed by a one-paragraph verification recipe (artifact path,",
+      "     test command, or 10-second reproduction). This halts the loop.",
+      "   \u2022 NEVER emit [GOAL_COMPLETE] on optimism, partial progress, or",
+      '     "looks fine". Required: a concrete artifact that proves it AND',
+      "     no recent journal failures contradicting completion.",
+      "   \u2022 If unsure, emit `[done]` instead and let the next iteration",
+      "     decide. The loop is patient; false completion is not.",
+      "",
+      "4. NO INTERACTIVITY",
+      "   \u2022 Do not ask questions, do not request confirmation, do not propose",
+      "     options. Pick the best path and execute. The user is asleep."
     ].join("\n");
   }
+  /**
+   * Exponential backoff for transient provider errors. `2^N * base`
+   * capped at `transientBackoffMaxMs`. Zero base disables backoff.
+   * Public-private to keep `runOneIteration` readable; the value is
+   * recomputed each call from the current retry count, so callers
+   * don't have to track state.
+   */
+  computeTransientBackoffMs() {
+    const base = this.opts.transientBackoffBaseMs ?? 2e3;
+    const cap = this.opts.transientBackoffMaxMs ?? 6e4;
+    if (base <= 0) return 0;
+    const exponent = Math.max(0, this.consecutiveTransientRetries - 1);
+    return Math.min(cap, base * Math.pow(2, exponent));
+  }
+  /**
+   * Sleep that wakes early if `stopRequested` flips. Polls every 250 ms
+   * so SIGINT / `/autonomy stop` can land in the middle of a long
+   * backoff instead of waiting up to a minute for the timer.
+   */
+  async sleepInterruptible(totalMs) {
+    const step = 250;
+    let remaining = totalMs;
+    while (remaining > 0 && !this.stopRequested) {
+      const chunk = Math.min(step, remaining);
+      await sleep(chunk);
+      remaining -= chunk;
+    }
+  }
   async appendIterationEntry(entry) {
     const current = await loadGoal(this.goalPath);
     if (!current) {
@@ -1973,6 +2133,39 @@ ${lastFew}` : "No prior iterations yet.",
     const updated = appendJournal(current, entry);
     await saveGoal(this.goalPath, updated);
   }
+  /**
+   * Persistent per-todo failure counter. Skipped silently when the goal
+   * file has been removed (graceful clear). Each non-success iteration
+   * against a todo source bumps the counter by 1; `pickPendingTodo` reads
+   * the counter to rotate past stuck todos once they cross `todoMaxAttempts`.
+   */
+  async bumpTodoAttempt(todoId) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    const attempts = { ...current.todoAttempts ?? {} };
+    attempts[todoId] = (attempts[todoId] ?? 0) + 1;
+    await saveGoal(this.goalPath, { ...current, todoAttempts: attempts });
+  }
+  /**
+   * Flip the mission to `completed` and journal it. Called from two
+   * paths: (a) `[GOAL_COMPLETE]` marker in a successful iteration's
+   * finalText, (b) `brainstorm` returning DONE consecutively past the
+   * configured threshold. Idempotent — re-entry is a no-op once the
+   * goal is already `completed`.
+   */
+  async markGoalCompleted(action, note) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    if (current.goalState === "completed") return;
+    const withFlag = { ...current, goalState: "completed" };
+    const withEntry = appendJournal(withFlag, {
+      source: action.source,
+      task: `MISSION COMPLETE \u2014 ${action.task}`.slice(0, 240),
+      status: "success",
+      note: note.slice(0, 240)
+    });
+    await saveGoal(this.goalPath, withEntry);
+  }
   async appendFailure(task, note) {
     await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
   }
@@ -1987,6 +2180,142 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/execution/autonomy-prompt-contributor.ts
+function makeAutonomyPromptContributor(opts) {
+  return async (ctx) => {
+    if (ctx.subagent) return [];
+    if (!opts.enabled()) return [];
+    let goal;
+    try {
+      goal = await loadGoal(opts.goalPath);
+    } catch {
+      return [];
+    }
+    if (!goal) return [];
+    const missionState = goal.goalState ?? "active";
+    if (missionState !== "active") return [];
+    const tailSize = opts.journalTailSize ?? 5;
+    const journalTail = goal.journal.slice(-tailSize).map((e) => {
+      const note = e.note ? ` \u2014 ${e.note.slice(0, 80)}` : "";
+      return `  #${e.iteration} [${e.status}] ${e.task}${note}`;
+    });
+    const text = [
+      "## ETERNAL AUTONOMY \u2014 active mission",
+      "",
+      "You are inside a long-running autonomous loop. The user is asleep",
+      "and is not available to confirm decisions. Each turn you receive a",
+      "directive describing one concrete sub-task that advances the mission.",
+      "",
+      `Mission: ${goal.goal}`,
+      `Iteration: #${goal.iterations}`,
+      journalTail.length > 0 ? `Recent journal (last ${journalTail.length}):
+${journalTail.join("\n")}` : "Recent journal: (none \u2014 this is the first iteration)",
+      "",
+      "### Loop control markers",
+      "Emit these on their own line in your final text \u2014 case-insensitive,",
+      "whitespace-tolerant, but they must occupy the entire line:",
+      "- `[continue]` \u2014 chain to the next internal step without returning.",
+      "- `[done]` \u2014 the current sub-task is finished; return to the engine.",
+      "- `[GOAL_COMPLETE]` \u2014 emit ONLY when the OVERALL mission is",
+      "  verifiably done. Must be followed by a one-paragraph verification",
+      "  recipe (artifact path, test command, or 10-second reproduction).",
+      "  The engine halts on this marker \u2014 false positives waste real",
+      "  human time. If unsure, emit `[done]` and let the next iteration",
+      "  decide.",
+      "",
+      "### Operating principles",
+      "- YOLO is active. Do NOT ask for confirmation, do NOT propose",
+      "  options. Pick the best path and execute it.",
+      "- Use tools freely; multiple calls per turn are normal and expected.",
+      "- When working on a todo, mark it `in_progress` via the todos tool",
+      "  before tool work and `completed` (or `cancelled` with a reason)",
+      "  when done. The loop reads todo state between iterations.",
+      "- If an approach fails twice in a row, pivot. Don't grind on the",
+      "  same wall \u2014 try a different angle, file a cancel on the todo, or",
+      "  surface the obstacle via `[done]` and let the next iteration",
+      "  re-plan."
+    ].join("\n");
+    return [
+      {
+        type: "text",
+        text,
+        cache_control: { type: "ephemeral" }
+      }
+    ];
+  };
+}
+
+// src/execution/goal-preamble.ts
+function buildGoalPreamble(goal) {
+  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.",
+    "",
+    "YOUR GOAL:",
+    "---",
+    goal,
+    "---",
+    "",
+    "AUTHORITY YOU HAVE:",
+    "- Spawn as many subagents as the work needs (delegate / spawn_subagent).",
+    "  Parallel + recursive fan-out are both fine. There is no spawn budget.",
+    "- Use any provider/model per subagent \u2014 pick the right tool for each",
+    "  piece of work. Heavy reasoning model for planning, fast model for",
+    "  batch work, specialist model for domain code.",
+    "- Run unlimited tool calls and iterations. There is NO hidden budget.",
+    "  The Agent loop auto-extends every 100 iterations forever.",
+    "- Retry failed tools with different inputs, alternative paths, fresh",
+    "  subagents. Switch providers mid-run if one is rate-limited.",
+    "- Re-plan freely when an approach hits a dead end. You are not obliged",
+    "  to stick with the first plan you proposed.",
+    "",
+    'WHAT "DONE" MEANS \u2014 non-negotiable:',
+    "- You can name a concrete artifact (a passing test, a written file at",
+    "  a specific path, a fixed bug verified by re-running the failing case,",
+    "  a clean grep that previously had matches).",
+    "- 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".',
+    "",
+    "WHAT IS NOT DONE \u2014 never report any of these as completion:",
+    "- An error message you didn't recover from.",
+    '- An empty result, a 0-line file, a "no matches found" you accepted',
+    "  without questioning the search.",
+    '- "Should I continue?" / "Want me to also...?" / "Let me know if you',
+    '  want X." Those are hedges. The user already told you to finish the',
+    "  goal \u2014 just do it.",
+    "- Partial progress dressed up as success. Fixed 3 of 5 bugs = 60%",
+    "  done, not done.",
+    "- A subagent's failed/timeout/stopped TaskResult that you didn't",
+    "  respond to with a fresh attempt (different role, different model,",
+    "  tighter prompt).",
+    "",
+    "PERSISTENCE PROTOCOL:",
+    "- If blocked, try at least 3 different angles before reporting the",
+    "  problem to the user. Different tool inputs, different subagent",
+    "  roles, different providers, different decomposition of the task.",
+    "- If a tool fails, read its error, alter the input, try again. Do",
+    "  not just report the failure back.",
+    "- If a subagent returns useless output, respawn with a tighter prompt",
+    '  or a different role. Do not accept "I could not determine\u2026" as the',
+    "  final answer.",
+    "- Use `ask_subagent` for one-shot questions when you don't need a",
+    "  full delegated task.",
+    "",
+    "REPORTING:",
+    "- Stream short progress notes between major actions so the user can",
+    "  monitor. Do not go silent for 50 tool calls then dump a wall of",
+    "  text \u2014 but also do not narrate every tool call.",
+    "- Use the shared scratchpad (if available) to leave breadcrumbs",
+    "  subagents can read.",
+    "- Final response must include: (a) what was accomplished, (b) how",
+    "  to verify, (c) any caveats (residual TODOs, things the user",
+    "  should know about).",
+    "",
+    "BEGIN.]"
+  ].join("\n");
+}
+
 // src/types/provider.ts
 var ProviderError = class extends WrongStackError {
   status;
@@ -2299,6 +2628,6 @@ function parseDescription(raw) {
   return { trigger, scope };
 }
 
-export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, SelectiveCompactor, ToolExecutor };
+export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, SelectiveCompactor, ToolExecutor, buildGoalPreamble, makeAutonomyPromptContributor };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map