@wrongstack/core 0.5.7 → 0.6.1

package/dist/execution/index.js

@@ -1,5 +1,8 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { randomBytes } from 'crypto';
 
 // src/utils/token-estimate.ts
 var RoughTokenEstimate = (text) => Math.max(1, Math.ceil(text.length / 4));
@@ -1242,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 {
@@ -1257,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) {
@@ -1314,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") {
@@ -1533,6 +1551,770 @@ var AutonomousRunner = class {
     this.stopped = true;
   }
 };
+async function atomicWrite(targetPath, content, opts = {}) {
+  const dir = path.dirname(targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  const tmp = path.join(dir, `.${path.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    if (typeof content === "string") {
+      await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+    } else {
+      await fs.writeFile(tmp, content, { flag: "wx" });
+    }
+    try {
+      const fh = await fs.open(tmp, "r+");
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    }
+    let mode;
+    try {
+      const stat2 = await fs.stat(targetPath);
+      mode = stat2.mode & 511;
+    } catch {
+      mode = opts.mode;
+    }
+    if (mode !== void 0) {
+      await fs.chmod(tmp, mode);
+    }
+    await renameWithRetry(tmp, targetPath);
+  } catch (err) {
+    try {
+      await fs.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
+async function renameWithRetry(from, to) {
+  if (process.platform !== "win32") {
+    await fs.rename(from, to);
+    return;
+  }
+  const delays = [10, 25, 60, 120, 250];
+  let lastErr;
+  for (let i = 0; i <= delays.length; i++) {
+    try {
+      await fs.rename(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err?.code;
+      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
+        throw err;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delays[i]));
+    }
+  }
+  throw lastErr;
+}
+
+// src/storage/goal-store.ts
+var MAX_JOURNAL_ENTRIES = 500;
+function goalFilePath(projectRoot) {
+  return path.join(projectRoot, ".wrongstack", "goal.json");
+}
+async function loadGoal(filePath) {
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || typeof parsed.goal !== "string" || !Array.isArray(parsed.journal)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveGoal(filePath, goal) {
+  await atomicWrite(filePath, JSON.stringify(goal, null, 2), { mode: 384 });
+}
+function appendJournal(goal, entry) {
+  const iteration = goal.iterations + 1;
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const full = { ...entry, iteration, at };
+  const journal = [...goal.journal, full];
+  const trimmed = journal.length > MAX_JOURNAL_ENTRIES ? journal.slice(journal.length - MAX_JOURNAL_ENTRIES) : journal;
+  return {
+    ...goal,
+    iterations: iteration,
+    lastActivityAt: at,
+    journal: trimmed
+  };
+}
+
+// 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;
+    this.goalPath = goalFilePath(opts.projectRoot);
+  }
+  opts;
+  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;
+  /** Current engine state — readable for UIs. */
+  get currentState() {
+    return this.state;
+  }
+  /** Synchronously request stop. Resolves once the running iteration aborts. */
+  stop() {
+    this.stopRequested = true;
+    this.currentCtrl?.abort();
+    void this.persistEngineState("stopped").catch(() => {
+    });
+    this.state = "stopped";
+  }
+  /**
+   * Mark the engine as 'running' on disk + reset stop state so a new
+   * batch of `runOneIteration()` calls can proceed. Called by the REPL
+   * when the user invokes `/autonomy eternal`. Idempotent.
+   */
+  async prime() {
+    this.stopRequested = false;
+    this.state = "running";
+    await this.persistEngineState("running").catch(() => {
+    });
+  }
+  /**
+   * Main loop. Returns when stop() is called or the goal file is removed.
+   * Does NOT throw — every iteration is wrapped to keep the loop alive.
+   */
+  async run() {
+    this.state = "running";
+    await this.persistEngineState("running");
+    try {
+      while (!this.stopRequested) {
+        let iterationOk = false;
+        try {
+          iterationOk = await this.runOneIteration();
+        } catch (err) {
+          this.consecutiveFailures++;
+          this.opts.onError?.(err instanceof Error ? err : new Error(String(err)), this.consecutiveFailures);
+          await this.appendFailure("engine error", err instanceof Error ? err.message : String(err));
+        }
+        if (iterationOk) {
+          this.consecutiveFailures = 0;
+        }
+        if (this.stopRequested) break;
+        await sleep(this.opts.cycleGapMs ?? 1e3);
+      }
+    } finally {
+      this.state = "stopped";
+      await this.persistEngineState("stopped").catch(() => {
+      });
+    }
+  }
+  /**
+   * Execute a single sense-decide-execute-reflect cycle.
+   * Returns true on success, false on handled failure / no-op.
+   *
+   * Exposed publicly so the REPL can pace iterations from its main loop
+   * — running the engine and the REPL as a single sequential consumer of
+   * `agent.run()` avoids race conditions on the shared Context.
+   */
+  async runOneIteration() {
+    const goal = await loadGoal(this.goalPath);
+    if (!goal) {
+      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) {
+      if (!this.stopRequested) {
+        await sleep(5e3);
+      }
+      return false;
+    }
+    const ctrl = new AbortController();
+    this.currentCtrl = ctrl;
+    const timer = setTimeout(
+      () => ctrl.abort(),
+      this.opts.iterationTimeoutMs ?? 5 * 6e4
+    );
+    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,
+          // 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";
+        note = "stopped by user";
+      } 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";
+        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 ? {
+      input: Math.max(0, afterUsage.input - beforeUsage.input),
+      output: Math.max(0, afterUsage.output - beforeUsage.output)
+    } : void 0;
+    const costUsd = typeof beforeCost === "number" && typeof afterCost === "number" ? Math.max(0, afterCost - beforeCost) : void 0;
+    await this.appendIterationEntry({
+      source: action.source,
+      task: action.task,
+      status,
+      note,
+      tokens,
+      costUsd
+    });
+    let iterationIndex = 0;
+    try {
+      const reloaded = await loadGoal(this.goalPath);
+      iterationIndex = reloaded?.iterations ?? 0;
+    } catch {
+    }
+    this.opts.onIteration?.({
+      at: (this.opts.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+      iteration: iterationIndex,
+      source: action.source,
+      task: action.task,
+      status,
+      note,
+      tokens,
+      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;
+    }
+    if (status === "aborted") {
+      if (this.stopRequested) return false;
+      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?.(
+        err instanceof Error ? err : new Error(String(err)),
+        this.consecutiveFailures
+      );
+    });
+    return true;
+  }
+  /**
+   * Run compaction when either trigger fires:
+   *   - We've done >= compactEveryNIterations since the last compact.
+   *   - Current request tokens exceed aggressiveCompactRatio * maxContext.
+   *
+   * The second check uses *aggressive* mode to free more headroom; the
+   * cadence check uses non-aggressive (cheaper).
+   */
+  async maybeCompact() {
+    const compactor = this.opts.compactor;
+    if (!compactor) return;
+    const ctx = this.opts.agent.ctx;
+    if (!ctx) return;
+    const cadence = this.opts.compactEveryNIterations ?? 25;
+    const threshold = this.opts.aggressiveCompactRatio ?? 0.85;
+    const maxCtx = this.opts.maxContextTokens;
+    let aggressive = false;
+    let shouldRun = false;
+    if (this.iterationsSinceCompact >= cadence) {
+      shouldRun = true;
+    }
+    if (maxCtx && maxCtx > 0) {
+      const used = ctx.tokenCounter?.currentRequestTokens?.();
+      if (used) {
+        const total = used.input + used.cacheRead;
+        if (total / maxCtx >= threshold) {
+          shouldRun = true;
+          aggressive = true;
+        }
+      }
+    }
+    if (!shouldRun) return;
+    const report = await compactor.compact(ctx, { aggressive });
+    this.iterationsSinceCompact = 0;
+    const saved = report.before - report.after;
+    await this.appendIterationEntry({
+      source: "manual",
+      task: `compaction (${aggressive ? "aggressive" : "cadence"})`,
+      status: "success",
+      note: `saved ~${saved} tokens (${report.before}\u2192${report.after})`
+    });
+  }
+  /**
+   * Hybrid idea source.
+   *   1. Pending todos on the agent's context.
+   *   2. Dirty git working tree → propose a "review and finish this" task.
+   *   3. Otherwise: brainstorm via the LLM against the goal.
+   *
+   * After failureBudget consecutive failures, force brainstorm so the
+   * engine doesn't loop on the same broken todo or stuck git state.
+   */
+  async decide(goal) {
+    const forceBrainstorm = this.consecutiveFailures >= (this.opts.failureBudget ?? 3);
+    if (!forceBrainstorm) {
+      const todo = this.pickPendingTodo(goal);
+      if (todo) {
+        return {
+          source: "todo",
+          task: todo.content,
+          todoId: todo.id,
+          directive: this.buildDirective(goal, "todo", todo.content)
+        };
+      }
+      const gitTask = await this.pickGitTask();
+      if (gitTask) {
+        return {
+          source: "git",
+          task: gitTask,
+          directive: this.buildDirective(goal, "git", gitTask)
+        };
+      }
+    }
+    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(goal) {
+    const todos = this.opts.agent.ctx.todos;
+    if (!Array.isArray(todos)) return 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;
+    try {
+      out = await (this.opts.gitStatusReader?.() ?? this.readGitStatus());
+    } catch {
+      return null;
+    }
+    const dirty = out.trim();
+    if (!dirty) return null;
+    const lines = dirty.split("\n").slice(0, 8);
+    const preview = lines.join(", ");
+    return `Inspect the dirty working tree and either finish the in-progress work or revert it. Files: ${preview}`;
+  }
+  async readGitStatus() {
+    const { stdout } = await execFileP("git", ["status", "--porcelain"], {
+      cwd: this.opts.projectRoot,
+      timeout: 5e3
+    });
+    return stdout;
+  }
+  async brainstormTask(goal) {
+    const lastFew = goal.journal.slice(-5).map((e) => `  - [${e.status}] ${e.task}`).join("\n");
+    const directive = [
+      "You are deciding the next action in an autonomous loop pursuing a long-running goal.",
+      "",
+      `Goal: ${goal.goal}`,
+      "",
+      lastFew ? `Recent iterations:
+${lastFew}` : "No prior iterations yet.",
+      "",
+      "Output ONE concrete, immediately-actionable task that advances the goal.",
+      "Constraints:",
+      "- 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 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();
+      const timer = setTimeout(() => ctrl.abort(), 6e4);
+      try {
+        const result = await this.opts.agent.run(
+          [{ type: "text", text: directive }],
+          { signal: ctrl.signal, maxIterations: 1 }
+        );
+        if (result.status !== "done") return null;
+        const text = (result.finalText ?? "").trim();
+        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);
+      }
+    } catch {
+      return null;
+    }
+  }
+  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 [
+      "\u2550\u2550\u2550 ETERNAL AUTONOMY \u2014 iteration directive \u2550\u2550\u2550",
+      "",
+      `Mission: ${goal.goal}`,
+      `Iteration: #${goal.iterations + 1}`,
+      `Source: ${source}`,
+      `Task: ${task}`,
+      "",
+      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) {
+      return;
+    }
+    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 });
+  }
+  async persistEngineState(state) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    if (current.engineState === state) return;
+    await saveGoal(this.goalPath, { ...current, engineState: state });
+  }
+};
+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 {
@@ -1664,7 +2446,7 @@ function buildRecoveryStrategies(opts) {
       async attempt(err) {
         if (!(err instanceof ProviderError) || err.status !== 429) return null;
         const delayMs = err.body?.retryAfterMs ?? 5e3;
-        const delay = Math.max(1e3, Math.min(delayMs, 6e4));
+        const delay = Math.min(6e4, Math.max(1e3, delayMs));
         await new Promise((r) => setTimeout(r, delay));
         return { action: "retry", reason: "rate_limit_backoff" };
       }
@@ -1846,6 +2628,6 @@ function parseDescription(raw) {
   return { trigger, scope };
 }
 
-export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, 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