@wrongstack/core 0.5.7 → 0.6.0

package/dist/execution/index.d.ts

@@ -1,12 +1,13 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-DbAFkHdP.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-B03CRwu-.js';
 import { g as Provider, a2 as Context } from '../context-CDRyrkKQ.js';
 import { a as Compactor, C as CompactReport } from '../compactor-RIPuTtWK.js';
 import { M as MessageSelector } from '../selector-C7HqnZJU.js';
 import { E as EventBus } from '../events-DPQKFX7W.js';
 import { c as MiddlewareHandler } from '../system-prompt-Dl2QY1_B.js';
 import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-BGGuP_Ar.js';
-import { r as Agent, R as RunResult } from '../index-j2WyAyML.js';
+import { r as Agent, R as RunResult } from '../index-B0qTujQW.js';
 import { D as DoneCondition } from '../multi-agent-Cpp7FXUl.js';
+import { J as JournalEntry } from '../goal-store-BQ3YX1h1.js';
 import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-CxuWrsKK.js';
 import { W as WstackPaths } from '../wstack-paths-86YPFktR.js';
 import '../retry-policy-LKS8MHsB.js';
@@ -273,4 +274,136 @@ declare class AutonomousRunner {
     stop(): void;
 }
 
-export { AutoCompactionMiddleware, AutonomousRunner, type AutonomousRunnerOptions, DefaultSkillLoader, type DoneCheckResult, DoneConditionChecker, IntelligentCompactor, type IntelligentCompactorOptions, SelectiveCompactor, type SelectiveCompactorOptions, type SkillLoaderOptions };
+/**
+ * Sense-decide-execute-reflect loop on top of a long-running Goal.
+ *
+ * Each iteration:
+ *   1. Sense   — read goal, pending todos, `git status --porcelain`.
+ *   2. Decide  — pick a source (todo / git / brainstorm) and a task.
+ *   3. Execute — single agent.run with a directive prompt.
+ *   4. Reflect — append a journal entry, persist state to disk.
+ *
+ * The loop runs forever until `stop()` is called externally (REPL SIGINT
+ * handler, /autonomy stop). No internal time/cost cap by design — the
+ * user wants "sittin sene". Failures are logged and the loop continues
+ * with a different source on the next tick.
+ */
+interface EternalAutonomyOptions {
+    agent: Agent;
+    projectRoot: string;
+    /**
+     * Per-iteration agent timeout. Defaults to 5 minutes. A single hung
+     * provider call should not freeze the whole eternal loop.
+     */
+    iterationTimeoutMs?: number;
+    /**
+     * Minimum sleep between iterations. Defaults to 1 s — enough for
+     * SIGINT handlers to fire mid-loop without pegging a core when the
+     * provider is being rate-limited.
+     */
+    cycleGapMs?: number;
+    /**
+     * Maximum consecutive failures before the source rotation forces a
+     * brainstorm cycle. Default 3. Acts as a soft-recovery, not a stop.
+     */
+    failureBudget?: number;
+    /** Side-channel notifications (logging, UI updates). */
+    onIteration?: (entry: JournalEntry) => void;
+    onError?: (err: Error, iteration: number) => void;
+    /**
+     * Optional injected git status reader — production code uses git, tests
+     * stub this out so they don't shell out.
+     */
+    gitStatusReader?: () => Promise<string>;
+    /**
+     * Optional clock — tests stub for deterministic timestamps.
+     */
+    now?: () => Date;
+    /**
+     * Optional compactor. When provided, the engine runs compaction every
+     * `compactEveryNIterations` iterations to keep the agent's message
+     * history under control during multi-day eternal loops. Without
+     * compaction, an infinite loop will eventually overflow the provider's
+     * context window and start failing.
+     */
+    compactor?: Compactor;
+    /** How many iterations between compaction calls. Default 25. */
+    compactEveryNIterations?: number;
+    /**
+     * Aggressive compaction threshold. When ctx token usage exceeds this
+     * fraction of `maxContextTokens`, compaction runs in aggressive mode
+     * regardless of the iteration cadence. 0.85 by default.
+     */
+    aggressiveCompactRatio?: number;
+    /**
+     * Model's max context window in tokens. When set, the engine watches
+     * `currentRequestTokens()` against this and triggers aggressive compact
+     * before the next iteration would overflow. Omit to disable threshold
+     * checks (iteration cadence still applies).
+     */
+    maxContextTokens?: number;
+}
+type EternalEngineState = 'idle' | 'running' | 'stopped';
+declare class EternalAutonomyEngine {
+    private readonly opts;
+    private state;
+    private stopRequested;
+    private consecutiveFailures;
+    private currentCtrl;
+    private iterationsSinceCompact;
+    private readonly goalPath;
+    constructor(opts: EternalAutonomyOptions);
+    /** Current engine state — readable for UIs. */
+    get currentState(): EternalEngineState;
+    /** Synchronously request stop. Resolves once the running iteration aborts. */
+    stop(): void;
+    /**
+     * 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.
+     */
+    prime(): Promise<void>;
+    /**
+     * 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.
+     */
+    run(): Promise<void>;
+    /**
+     * 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.
+     */
+    runOneIteration(): Promise<boolean>;
+    /**
+     * 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).
+     */
+    private maybeCompact;
+    /**
+     * 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.
+     */
+    private decide;
+    private pickPendingTodo;
+    private pickGitTask;
+    private readGitStatus;
+    private brainstormTask;
+    private buildDirective;
+    private appendIterationEntry;
+    private appendFailure;
+    private persistEngineState;
+}
+
+export { AutoCompactionMiddleware, AutonomousRunner, type AutonomousRunnerOptions, DefaultSkillLoader, type DoneCheckResult, DoneConditionChecker, EternalAutonomyEngine, type EternalAutonomyOptions, type EternalEngineState, IntelligentCompactor, type IntelligentCompactorOptions, SelectiveCompactor, type SelectiveCompactorOptions, type SkillLoaderOptions };

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));
@@ -1533,6 +1536,456 @@ 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 EternalAutonomyEngine = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.goalPath = goalFilePath(opts.projectRoot);
+  }
+  opts;
+  state = "idle";
+  stopRequested = false;
+  consecutiveFailures = 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 action = await this.decide(goal);
+    if (!action) {
+      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;
+    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 }
+      );
+      if (result.status === "aborted") {
+        status = "aborted";
+        note = "stopped by user";
+      } else if (result.status === "failed") {
+        status = "failure";
+        note = result.error?.describe?.() ?? "agent run failed";
+      } 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();
+        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);
+    } finally {
+      clearTimeout(timer);
+      this.currentCtrl = null;
+    }
+    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") {
+      this.consecutiveFailures++;
+      return false;
+    }
+    if (status === "aborted") {
+      if (this.stopRequested) return false;
+      this.consecutiveFailures++;
+      return false;
+    }
+    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();
+      if (todo) {
+        return {
+          source: "todo",
+          task: todo.content,
+          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) return null;
+    return {
+      source: "brainstorm",
+      task: brainstormed,
+      directive: this.buildDirective(goal, "brainstorm", brainstormed)
+    };
+  }
+  pickPendingTodo() {
+    const todos = this.opts.agent.ctx.todos;
+    if (!Array.isArray(todos)) return null;
+    return todos.find((t) => t.status === "pending") ?? 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, output exactly: 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 || text === "DONE") return null;
+        const firstLine = text.split("\n").find((l) => l.trim().length > 0)?.trim();
+        if (!firstLine) return null;
+        return firstLine.slice(0, 240);
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+      return null;
+    }
+  }
+  buildDirective(goal, source, task) {
+    return [
+      "[ETERNAL AUTONOMY \u2014 iteration directive]",
+      "",
+      `Goal: ${goal.goal}`,
+      `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."
+    ].join("\n");
+  }
+  async appendIterationEntry(entry) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) {
+      return;
+    }
+    const updated = appendJournal(current, entry);
+    await saveGoal(this.goalPath, updated);
+  }
+  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/types/provider.ts
 var ProviderError = class extends WrongStackError {
@@ -1664,7 +2117,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 +2299,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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map