@wrongstack/core 0.63.4 → 0.68.0

package/dist/infrastructure/index.d.ts

@@ -1,10 +1,10 @@
 export { D as DefaultLogger, a as DefaultLoggerOptions } from '../logger-bOzkF5LL.js';
-export { D as DefaultPathResolver, a as DefaultTokenCounter } from '../path-resolver-C5sPVne8.js';
-export { C as ContextManagerAction, a as ContextManagerInput, b as ContextManagerResult, c as ContextManagerToolOptions, d as allServers, e as awsServer, f as blockServer, g as braveSearchServer, h as context7Server, i as contextManagerTool, j as createContextManagerTool, k as everArtServer, l as filesystemServer, m as githubServer, n as googleMapsServer, o as miniMaxVisionServer, s as sentinelServer, p as slackServer, z as zaiVisionServer } from '../mcp-servers-CwqQDMYy.js';
+export { D as DefaultPathResolver, a as DefaultTokenCounter } from '../path-resolver-DVkEcIw8.js';
+export { C as ContextManagerAction, a as ContextManagerInput, b as ContextManagerResult, c as ContextManagerToolOptions, d as allServers, e as awsServer, f as blockServer, g as braveSearchServer, h as context7Server, i as contextManagerTool, j as createContextManagerTool, k as everArtServer, l as filesystemServer, m as githubServer, n as googleMapsServer, o as miniMaxVisionServer, s as sentinelServer, p as slackServer, z as zaiVisionServer } from '../mcp-servers-DwoNBf6r.js';
 import '../logger-DDd5C--Z.js';
-import '../events-k8CHjcrN.js';
-import '../context-iFMEO2rN.js';
+import '../events-CIplI98R.js';
+import '../context-y87Jc5ei.js';
 import '../models-registry-BcYJDKLm.js';
 import '../path-resolver-CPRj4bFY.js';
-import '../compactor-0vjZ8KTk.js';
-import '../config-BdDuaZmB.js';
+import '../compactor-D_ExJajC.js';
+import '../config--86aHSln.js';

package/dist/kernel/index.d.ts

@@ -1,18 +1,18 @@
-export { B as BindOptions, C as Container, D as Decorator, F as Factory, M as Middleware, b as MiddlewareHandler, N as NextFn, P as Pipeline, d as PipelineOptions, T as Token } from '../system-prompt-7LHyBbIf.js';
-export { E as EventBus, i as EventLogger, j as EventMap, k as EventName, L as Listener, S as ScopedEventBus } from '../events-k8CHjcrN.js';
-export { R as RunController, b as RunControllerOptions, T as TOKENS } from '../index-CWdW_CJt.js';
-import '../config-BdDuaZmB.js';
+export { B as BindOptions, C as Container, D as Decorator, F as Factory, M as Middleware, b as MiddlewareHandler, N as NextFn, P as Pipeline, d as PipelineOptions, T as Token } from '../system-prompt-b61lOd49.js';
+export { E as EventBus, i as EventLogger, j as EventMap, k as EventName, L as Listener, S as ScopedEventBus } from '../events-CIplI98R.js';
+export { R as RunController, b as RunControllerOptions, T as TOKENS } from '../index-b5uhfTSl.js';
+import '../config--86aHSln.js';
 import '../models-registry-BcYJDKLm.js';
-import '../context-iFMEO2rN.js';
-import '../compactor-0vjZ8KTk.js';
-import '../retry-policy-BfBScewS.js';
+import '../context-y87Jc5ei.js';
+import '../compactor-D_ExJajC.js';
+import '../retry-policy-CG3qvH_e.js';
 import '../input-reader-E-ffP2ee.js';
 import '../logger-DDd5C--Z.js';
 import '../memory-CEXuo7sz.js';
 import '../mode-CV077NjV.js';
 import '../path-resolver-CPRj4bFY.js';
-import '../permission-Ld-i5ugf.js';
-import '../provider-runner-DJQa211J.js';
+import '../permission-C1A5whY5.js';
+import '../provider-runner-mXvXGSIw.js';
 import '../observability-BhnVLBLS.js';
 import '../secret-scrubber-3MHDDAtm.js';
 import '../skill-CxuWrsKK.js';

package/dist/{mcp-servers-CwqQDMYy.d.ts → mcp-servers-DwoNBf6r.d.ts}

@@ -1,6 +1,6 @@
-import { a as Compactor } from './compactor-0vjZ8KTk.js';
-import { M as Message, Q as Tool } from './context-iFMEO2rN.js';
-import { M as MCPServerConfig } from './config-BdDuaZmB.js';
+import { a as Compactor } from './compactor-D_ExJajC.js';
+import { M as Message, Q as Tool } from './context-y87Jc5ei.js';
+import { M as MCPServerConfig } from './config--86aHSln.js';
 
 type ContextManagerAction = 'check' | 'summary' | 'prune' | 'add_note' | 'compact' | 'repair';
 interface ContextManagerInput {

package/dist/models/index.d.ts

@@ -1,7 +1,7 @@
 export { D as DefaultModelsRegistry, a as DefaultModelsRegistryOptions, c as classifyFamily } from '../models-registry-Cuq1C8V9.js';
 import { c as ModeStore, a as ModeConfig, M as Mode } from '../mode-CV077NjV.js';
-import { m as Provider, M as Message } from '../context-iFMEO2rN.js';
-import { M as MessageSelector, S as SelectorResult } from '../selector-DxhW7ML3.js';
+import { m as Provider, M as Message } from '../context-y87Jc5ei.js';
+import { M as MessageSelector, S as SelectorResult } from '../selector-RvBR_YRW.js';
 import '../models-registry-BcYJDKLm.js';
 
 declare class DefaultModeStore implements ModeStore {

package/dist/{multi-agent-coordinator-CNUJYq7U.d.ts → multi-agent-coordinator-CWnH-CiX.d.ts}

@@ -1,5 +1,4 @@
-import { n as SubagentConfig, l as MultiAgentCoordinator, M as MultiAgentConfig, t as SubagentRunner, S as SpawnResult, v as TaskSpec, B as BridgeMessage, A as AgentBridge, k as CoordinatorStatus, u as TaskResult } from './multi-agent-SASYOrWA.js';
-import { F as FleetBus } from './agent-subagent-runner-Zc3f37Sg.js';
+import { L as SubagentConfig, v as MultiAgentCoordinator, u as MultiAgentConfig, U as SubagentRunner, F as FleetBus, J as SpawnResult, Y as TaskSpec, B as BridgeMessage, a as AgentBridge, o as CoordinatorStatus, X as TaskResult } from './agent-subagent-runner-DRZ9-NnR.js';
 import { EventEmitter } from 'node:events';
 
 /**
@@ -299,6 +298,15 @@ declare class DefaultMultiAgentCoordinator extends EventEmitter implements Multi
      * underflow guard on every task after the first.
      */
     private drainPendingAsAborted;
+    /**
+     * Emit a synthetic `stopped`/`aborted_by_parent` completion for a single
+     * PENDING task — one that was never counted in `inFlight`. This MUST bypass
+     * `recordCompletion`: that path does `inFlight--`, which for a pending task
+     * steals a decrement from a genuinely in-flight task and trips the underflow
+     * guard — suppressing that real task's `task.completed` and hanging its
+     * `awaitTasks()` caller. Pushes the result and fires the event directly.
+     */
+    private emitPendingAborted;
     private runDispatched;
     private executeWithTimeout;
     private recordCompletion;

package/dist/{null-fleet-bus-DRoJ0uOY.d.ts → null-fleet-bus-CuN0ObJr.d.ts}

@@ -1,12 +1,11 @@
-import { c as AgentPhase, b as AgentDefinition, d as DefaultMultiAgentCoordinator, f as DispatchClassifier } from './multi-agent-coordinator-CNUJYq7U.js';
-import { n as SubagentConfig, u as TaskResult, k as CoordinatorStatus, v as TaskSpec, M as MultiAgentConfig, t as SubagentRunner } from './multi-agent-SASYOrWA.js';
-import { B as SessionWriter, Q as Tool, y as SessionStore } from './context-iFMEO2rN.js';
-import { F as FleetBus, e as FleetUsage, f as FleetUsageAggregator } from './agent-subagent-runner-Zc3f37Sg.js';
+import { c as AgentPhase, b as AgentDefinition, d as DefaultMultiAgentCoordinator, f as DispatchClassifier } from './multi-agent-coordinator-CWnH-CiX.js';
+import { F as FleetBus, r as FleetUsage, L as SubagentConfig, s as FleetUsageAggregator, X as TaskResult, o as CoordinatorStatus, Y as TaskSpec, u as MultiAgentConfig, U as SubagentRunner } from './agent-subagent-runner-DRZ9-NnR.js';
+import { B as SessionWriter, Q as Tool, y as SessionStore } from './context-y87Jc5ei.js';
 import { EventEmitter } from 'node:events';
-import { B as BrainArbiter, E as EventBus } from './events-k8CHjcrN.js';
+import { B as BrainArbiter, E as EventBus } from './events-CIplI98R.js';
 import { a as DirectorStateSnapshot } from './director-state-BmYi3DGA.js';
-import { p as ModelMatrixEntry } from './config-BdDuaZmB.js';
-import { I as InMemoryAgentBridge } from './agent-bridge-B5rxWrg3.js';
+import { p as ModelMatrixEntry } from './config--86aHSln.js';
+import { I as InMemoryAgentBridge } from './agent-bridge-D-j6OOBT.js';
 
 /**
  * Agent catalog aggregator.
@@ -779,6 +778,23 @@ declare class LargeAnswerStore {
     clear(): void;
 }
 
+/**
+ * Director-specific error types. Extracted to keep the Director class
+ * focused on orchestration logic.
+ */
+declare class FleetSpawnBudgetError extends Error {
+    readonly kind: 'max_spawns' | 'max_spawn_depth';
+    readonly limit: number;
+    readonly observed: number;
+    constructor(kind: 'max_spawns' | 'max_spawn_depth', limit: number, observed: number, message?: string);
+}
+declare class FleetCostCapError extends Error {
+    readonly kind: 'max_cost_usd';
+    readonly limit: number;
+    readonly observed: number;
+    constructor(limit: number, observed: number);
+}
+
 /**
  * Director — high-level orchestrator that owns a `MultiAgentCoordinator`,
  * a `FleetBus`, and a `FleetUsageAggregator`. Exposes a small imperative
@@ -985,30 +1001,7 @@ interface DirectorOptions {
 }
 /** Either a static matrix or a live getter (re-read on every spawn). */
 type ModelMatrixSource = Record<string, ModelMatrixEntry> | (() => Record<string, ModelMatrixEntry> | undefined);
-/**
- * Thrown by `Director.spawn()` when a configured spawn cap (`maxSpawns`,
- * `maxSpawnDepth`) is hit. Distinct error class so callers — including
- * the `spawn_subagent` tool surface — can recognize the budget case and
- * report it cleanly instead of treating it like an unexpected failure.
- */
-declare class FleetSpawnBudgetError extends Error {
-    readonly kind: 'max_spawns' | 'max_spawn_depth';
-    readonly limit: number;
-    readonly observed: number;
-    constructor(kind: 'max_spawns' | 'max_spawn_depth', limit: number, observed: number, message?: string);
-}
-/**
- * Thrown by `Director.spawn()` when the fleet-wide cost cap is exceeded.
- * Distinct from `FleetSpawnBudgetError` (spawn count/depth) — this is a
- * dollar-denominated ceiling that tracks cumulative spend across all
- * subagents in the fleet.
- */
-declare class FleetCostCapError extends Error {
-    readonly kind: 'max_cost_usd';
-    readonly limit: number;
-    readonly observed: number;
-    constructor(limit: number, observed: number);
-}
+
 declare class Director implements ICoordinator {
     /** Alias for the ICoordinator contract. `id` is retained for backward compatibility. */
     get coordinatorId(): string;

package/dist/observability/index.d.ts

@@ -1,6 +1,6 @@
 import { e as MetricsSink, M as MetricLabels, f as MetricsSnapshot, b as HealthRegistry, H as HealthCheck, A as AggregateHealth, T as Tracer, S as Span } from '../observability-BhnVLBLS.js';
-import { E as EventBus } from '../events-k8CHjcrN.js';
-import '../context-iFMEO2rN.js';
+import { E as EventBus } from '../events-CIplI98R.js';
+import '../context-y87Jc5ei.js';
 
 /**
  * In-memory metrics sink. Suitable for embedded use, tests, and /metrics

package/dist/parallel-eternal-engine-0UwotoSx.d.ts

@@ -0,0 +1,483 @@
+import { d as Context, n as ProviderError, Q as Tool, _ as ToolUseBlock, Y as ToolResultBlock } from './context-y87Jc5ei.js';
+import { a as Compactor, C as CompactReport } from './compactor-D_ExJajC.js';
+import { R as RecoveryDecision, E as ErrorHandler, a as RetryPolicy } from './retry-policy-CG3qvH_e.js';
+import { b as ModelsRegistry } from './models-registry-BcYJDKLm.js';
+import { r as ToolExecutorOptions, s as ToolExecutorStrategy, T as ToolBatchResult } from './index-DKUvyTvV.js';
+import { A as Agent, c as AgentFactory } from './agent-subagent-runner-DRZ9-NnR.js';
+import { J as JournalEntry } from './goal-store-C7jcumEh.js';
+import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from './multi-agent-coordinator-CWnH-CiX.js';
+
+interface CompactorOptions {
+    preserveK?: number;
+    eliseThreshold?: number;
+    estimator?: (text: string) => number;
+}
+
+declare class HybridCompactor implements Compactor {
+    private readonly preserveK;
+    private readonly eliseThreshold;
+    private readonly estimator;
+    constructor(opts?: CompactorOptions);
+    compact(ctx: Context, opts?: {
+        aggressive?: boolean;
+    }): Promise<CompactReport>;
+    /**
+     * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+     * This is the accurate figure for context-window pressure monitoring.
+     */
+    private estimateFullRequest;
+    private eliseOldToolResults;
+    private collapseAncientTurns;
+    private estimateMessages;
+}
+
+/**
+ * Tiered error recovery strategies.
+ * Each strategy is attempted in order until one returns a decision.
+ */
+interface RecoveryStrategy {
+    /** Human-readable label for logs. */
+    label: string;
+    /** Optional compactor for context_overflow recovery. */
+    compactor?: Compactor;
+    /** Returns an explicit recovery decision, or null to fall through. */
+    attempt: (err: unknown, ctx: Context) => Promise<RecoveryDecision | null>;
+}
+/**
+ * Builds the ordered list of recovery strategies used by DefaultErrorHandler.
+ * Exported so callers can customise or extend the strategy chain.
+ */
+declare function buildRecoveryStrategies(opts?: {
+    compactor?: Compactor;
+    modelsRegistry?: ModelsRegistry;
+}): RecoveryStrategy[];
+declare const DEFAULT_RECOVERY_STRATEGIES: RecoveryStrategy[];
+declare class DefaultErrorHandler implements ErrorHandler {
+    private readonly strategies;
+    constructor(strategies?: RecoveryStrategy[]);
+    classify(err: unknown): {
+        kind: 'rate_limit' | 'overloaded' | 'server' | 'client' | 'network' | 'abort' | 'context_overflow' | 'unknown';
+        retryable: boolean;
+    };
+    recover(err: unknown, ctx: Context): Promise<RecoveryDecision | null>;
+}
+
+declare class DefaultRetryPolicy implements RetryPolicy {
+    shouldRetry(err: Error | ProviderError, attempt: number): boolean;
+    maxAttempts(err: Error | ProviderError): number;
+    delayMs(attempt: number): number;
+}
+
+declare class ToolExecutor {
+    private readonly registry;
+    private opts;
+    private readonly serializer;
+    private readonly iterationTimeoutMs;
+    constructor(registry: {
+        get(name: string): Tool | undefined;
+        list(): Tool[];
+    }, opts: ToolExecutorOptions);
+    /**
+     * Clear the interactive confirm awaiter so the executor returns
+     * `ToolConfirmPendingResult` instead of blocking on stdin. Used by
+     * the CLI to switch from inline prompts (REPL) to event-driven
+     * confirmation (TUI) at runtime.
+     */
+    clearConfirmAwaiter(): void;
+    /**
+     * Execute a batch of tool uses using the configured strategy.
+     * Returns the execution results and the remaining output budget.
+     */
+    executeBatch(toolUses: ToolUseBlock[], ctx: Context, strategy: ToolExecutorStrategy): Promise<ToolBatchResult>;
+    /**
+     * Execute a single tool with timeout, permission check, and output capping.
+     * Emits `tool.started` via the injected EventBus (if any) right before
+     * invoking the tool — closes the observability gap between "model decided
+     * to call a tool" and "tool.executed".
+     */
+    executeTool(tool: Tool, use: ToolUseBlock, ctx: Context, budget: number): Promise<ToolResultBlock>;
+    private runWithTimeout;
+    private runStreamedTool;
+    private unknownToolResult;
+    private malformedInputResult;
+    private deniedResult;
+    private blockedByHookResult;
+    private decrementBudget;
+    /**
+     * Compute the suggestedPattern string for a tool+input pair.
+     * Matches the logic in DefaultPermissionPolicy so the TUI shows the
+     * same subject that the trust file would use.
+     */
+    private subjectFor;
+}
+
+/**
+ * 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;
+    /**
+     * Maximum number of internal agent.run iterations the engine grants per
+     * eternal-loop tick. The engine sets `autonomousContinue: true` so the
+     * agent can run multi-step tasks end-to-end within one tick instead of
+     * bouncing back to the engine after every single tool call. Default 500.
+     * Previous 50 was far too low — agents hit the limit and restart constantly.
+     */
+    iterationMaxAgentSteps?: 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;
+    /**
+     * Per-todo failed-attempt ceiling. When the engine picks the same todo
+     * and the iteration fails this many times in total, the todo is taken
+     * out of rotation (engine prefers other sources) until it changes
+     * status. Default 3. Prevents the loop from spinning forever on one
+     * stuck task.
+     */
+    todoMaxAttempts?: number;
+    /**
+     * Consecutive brainstorm-DONE responses required to consider the goal
+     * complete and stop the engine. When the LLM's brainstorm step keeps
+     * answering `DONE`, the engine treats that as "no more work" and, after
+     * this many in a row, marks the goal as completed instead of sleeping
+     * forever. Default 3.
+     */
+    brainstormDoneStopThreshold?: number;
+    /** Side-channel notifications (logging, UI updates). */
+    onIteration?: (entry: JournalEntry) => void;
+    onError?: (err: Error, iteration: number) => void;
+    /**
+     * Per-iteration phase notifications for live UI updates (TUI status bar,
+     * etc.). Fires at each major stage transition: idle → decide → execute →
+     * reflect → (sleep | paused | stopped). Fire-and-forget — the engine
+     * does not await the callback.
+     */
+    onStage?: (stage: IterationStage) => 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;
+    /**
+     * Base delay (ms) for the first transient-error backoff. Subsequent
+     * transient failures double this, capped at `transientBackoffMaxMs`.
+     * Default 2_000.
+     *
+     * "Transient" means the underlying error is recoverable per
+     * `WrongStackError.recoverable` (ProviderError sets this for 429/529/5xx
+     * /network errors). Permanent errors (auth/invalid request) skip the
+     * backoff and count toward `failureBudget` like before — backing off
+     * on a permanent failure is wasted time.
+     */
+    transientBackoffBaseMs?: number;
+    /** Ceiling for the exponential backoff. Default 60_000 (60 s). */
+    transientBackoffMaxMs?: number;
+    /** Called when the eternal loop stops for any reason (manual stop, goal complete, etc.). */
+    onEternalStop?: () => void;
+}
+type EternalEngineState = 'idle' | 'running' | 'stopped';
+/**
+ * Per-iteration phase emitted via `onStage` so UIs can render the
+ * engine's live location in the sense-decide-execute-reflect loop.
+ */
+type IterationStage = {
+    phase: 'idle';
+} | {
+    phase: 'decide';
+    reason: string;
+} | {
+    phase: 'execute';
+    task: string;
+} | {
+    phase: 'reflect';
+    status: 'success' | 'failure' | 'aborted' | 'skipped';
+    note?: string;
+} | {
+    phase: 'sleep';
+    ms: number;
+} | {
+    phase: 'paused';
+} | {
+    phase: 'stopped';
+} | {
+    phase: 'error';
+    message: string;
+};
+declare class EternalAutonomyEngine {
+    private readonly opts;
+    private state;
+    private stopRequested;
+    private consecutiveFailures;
+    private consecutiveBrainstormDone;
+    /**
+     * 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.
+     */
+    private consecutiveTransientRetries;
+    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;
+    /**
+     * 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.
+     */
+    private computeTransientBackoffMs;
+    /**
+     * 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.
+     */
+    private sleepInterruptible;
+    private appendIterationEntry;
+    /**
+     * 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`.
+     */
+    private bumpTodoAttempt;
+    /**
+     * 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`.
+     */
+    private markGoalCompleted;
+    /**
+     * Manually clear the goal — equivalent to `/goal clear` typed by the user.
+     * Sets goalState to `abandoned`, removes the goal file, and fires
+     * `onEternalStop` so the REPL returns to normal mode.
+     */
+    private clearGoalManually;
+    private appendFailure;
+    private persistEngineState;
+}
+
+type ParallelEngineState = 'idle' | 'running' | 'stopped';
+type ParallelIterationStage = {
+    phase: 'idle';
+} | {
+    phase: 'decompose';
+} | {
+    phase: 'fanout';
+    slots: number;
+} | {
+    phase: 'await';
+    taskIds: string[];
+} | {
+    phase: 'aggregate';
+    successCount: number;
+    total: number;
+    goalComplete: boolean;
+} | {
+    phase: 'sleep';
+    ms: number;
+} | {
+    phase: 'stopped';
+} | {
+    phase: 'error';
+    message: string;
+};
+interface ParallelEternalOptions {
+    /** The coordinating agent — NOT a subagent. Owns container/tools/providers. */
+    agent: Agent;
+    /** Project root (used for goal.json path). */
+    projectRoot: string;
+    /**
+     * Override the resolved goal.json path. Defaults to
+     * `goalFilePath(projectRoot)` (a hashed location under the home dir).
+     * Primarily for tests that want an isolated goal file under a temp dir.
+     */
+    goalPath?: string;
+    /**
+     * Number of parallel subagent slots per tick.
+     * Default: 4. Range 1–16; values >8 are for high-throughput machines.
+     */
+    parallelSlots?: number;
+    /** Per-subagent default timeout in ms. Default: 300_000 (5 min). */
+    iterationTimeoutMs?: number;
+    onIteration?: (entry: JournalEntry) => void;
+    onError?: (err: Error, iteration: number) => void;
+    /** Per-tick phase notifications for live UI/status updates. */
+    onStage?: (stage: ParallelIterationStage) => void;
+    gitStatusReader?: () => Promise<string>;
+    now?: () => Date;
+    compactor?: Compactor;
+    compactEveryNIterations?: number;
+    aggressiveCompactRatio?: number;
+    maxContextTokens?: number;
+    /** Override the default agent factory (uses main agent if not provided). */
+    subagentFactory?: AgentFactory;
+    /**
+     * Route each decomposed slot task to the best-fit catalog agent via the
+     * smart dispatcher (heuristic keyword scoring). When enabled (default), each
+     * slot spawns in-role — the role's budget tier applies and a persona line is
+     * injected into the task — instead of as a faceless generic worker. Set
+     * false to keep the legacy generic spawn.
+     */
+    dispatch?: boolean;
+    /**
+     * Optional LLM fallback for ambiguous tasks. Passed straight to
+     * `dispatchAgent`; when omitted, routing is pure heuristic (instant, no
+     * provider call — preferred for a continuously-ticking autonomous loop).
+     */
+    dispatchClassifier?: DispatchClassifier;
+}
+/**
+ * Sense → Decide → Fan-out (4–8 parallel agents) → Aggregate → Loop.
+ *
+ * Each tick:
+ *   1. Sense    — load goal, todos, git status
+ *   2. Decide   — decompose goal into N parallel sub-tasks
+ *   3. Fan-out  — spawn N subagents simultaneously, await all
+ *   4. Aggregate — write journal, update todos, check [GOAL_COMPLETE]
+ *   5. Loop     — continue until stop() or mission complete
+ *
+ * Uses DefaultMultiAgentCoordinator + AgentSubagentRunner for subagent lifecycle.
+ */
+declare class ParallelEternalEngine {
+    private readonly opts;
+    private state;
+    private stopRequested;
+    private iterationsSinceCompact;
+    private iterations;
+    private consecutiveFailures;
+    private readonly goalPath;
+    private readonly slots;
+    private readonly timeoutMs;
+    private coordinator;
+    private agentFactory;
+    private readonly dispatchEnabled;
+    private readonly dispatchClassifier?;
+    constructor(opts: ParallelEternalOptions);
+    get currentState(): ParallelEngineState;
+    /**
+     * Get the underlying coordinator for stats/monitoring.
+     */
+    getCoordinator(): DefaultMultiAgentCoordinator | null;
+    stop(): void;
+    prime(): Promise<void>;
+    run(): Promise<void>;
+    /**
+     * Execute one tick: decompose → fan-out → aggregate → compact.
+     * Called by the REPL in its main loop (REPL drives, engine is stateless per tick).
+     */
+    runOneIteration(): Promise<boolean>;
+    private fanOut;
+    private decomposeGoal;
+    private readGitStatus;
+    private brainstormSubtasks;
+    private maybeCompact;
+    private appendIterationEntry;
+    private appendFailure;
+    private persistState;
+}
+
+export { type CompactorOptions as C, DEFAULT_RECOVERY_STRATEGIES as D, EternalAutonomyEngine as E, HybridCompactor as H, type IterationStage as I, type ParallelEngineState as P, type RecoveryStrategy as R, ToolExecutor as T, DefaultErrorHandler as a, DefaultRetryPolicy as b, type EternalAutonomyOptions as c, type EternalEngineState as d, ParallelEternalEngine as e, type ParallelEternalOptions as f, type ParallelIterationStage as g, buildRecoveryStrategies as h };

package/dist/{path-resolver-C5sPVne8.d.ts → path-resolver-DVkEcIw8.d.ts}

@@ -1,6 +1,6 @@
-import { E as EventBus } from './events-k8CHjcrN.js';
+import { E as EventBus } from './events-CIplI98R.js';
 import { b as ModelsRegistry, R as ResolvedModel } from './models-registry-BcYJDKLm.js';
-import { O as TokenCounter, $ as Usage, C as CacheStats } from './context-iFMEO2rN.js';
+import { O as TokenCounter, $ as Usage, C as CacheStats } from './context-y87Jc5ei.js';
 import { P as PathResolver } from './path-resolver-CPRj4bFY.js';
 
 /**