@wrongstack/core 0.5.6 → 0.6.0

package/dist/{events-qnDZbrtb.d.ts → events-DPQKFX7W.d.ts}

@@ -1,4 +1,4 @@
-import { U as Usage, a2 as Context, z as ToolProgressEvent, v as Tool } from './context-CLZXPPYk.js';
+import { U as Usage, a2 as Context, z as ToolProgressEvent, v as Tool } from './context-CDRyrkKQ.js';
 
 /**
  * EventBus — observe-only typed event bus.

package/dist/execution/index.d.ts

@@ -1,19 +1,20 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-DSvmOBe6.js';
-import { g as Provider, a2 as Context } from '../context-CLZXPPYk.js';
-import { a as Compactor, C as CompactReport } from '../compactor-BWhJXxsW.js';
-import { M as MessageSelector } from '../selector-DB2-byKH.js';
-import { E as EventBus } from '../events-qnDZbrtb.js';
-import { c as MiddlewareHandler } from '../system-prompt-DI4Dtc1I.js';
-import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-BgM0BIpz.js';
-import { r as Agent, R as RunResult } from '../index-DPLJw_ZI.js';
-import { D as DoneCondition } from '../multi-agent-Cv8wk47i.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-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-LLUxJmYY.js';
+import '../retry-policy-LKS8MHsB.js';
 import '../models-registry-Y2xbog0E.js';
 import '../logger-BMQgxvdy.js';
 import '../observability-BhnVLBLS.js';
-import '../secret-scrubber-BhJTNr9v.js';
+import '../secret-scrubber-CfMdAJ_l.js';
 
 interface SkillLoaderOptions {
     paths: WstackPaths;
@@ -252,6 +253,13 @@ interface AutonomousRunnerOptions {
         toolCalls: number;
     }) => void;
     onDone?: (result: AutonomousResult) => void;
+    /**
+     * When true and `doneCondition.type === 'directive'`, the runner
+     * runs the agent with `autonomousContinue: true` so the agent loop
+     * handles its own [continue]/[done] markers internally (no outer
+     * re-invocation needed). The runner still provides iteration/timeouts.
+     */
+    enableAutonomousContinue?: boolean;
 }
 declare class AutonomousRunner {
     private readonly opts;
@@ -266,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 };