@wrongstack/core 0.89.3 → 0.107.2

package/dist/execution/index.d.ts

@@ -1,387 +1,83 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, E as EternalAutonomyEngine, c as EternalAutonomyOptions, d as EternalEngineState, H as HybridCompactor, I as IterationStage, P as ParallelEngineState, e as ParallelEternalEngine, f as ParallelEternalOptions, g as ParallelIterationStage, T as ToolExecutor } from '../parallel-eternal-engine-CTpcrb9O.js';
-import { P as Provider, C as Context } from '../context-CNRYfhUv.js';
-import { C as Compactor, a as CompactReport } from '../compactor-DXLxLcmU.js';
-import { M as MessageSelector } from '../selector-C7wcdqMA.js';
-import { E as EventBus } from '../brain-s9DyD_Vf.js';
-import { d as MiddlewareHandler } from '../pipeline-C1Ad9OjI.js';
-import { a as SessionEventBridge } from '../session-event-bridge-IVzs2GpE.js';
-import { k as ContextWindowAggressiveOn, o as ContextWindowPolicy } from '../config-84VaZpH6.js';
-import { g as Agent, O as DoneCondition } from '../agent-subagent-runner-C6eqID1t.js';
-import { R as RunResult, S as SystemPromptContributor } from '../index-D3Nax3YU.js';
-import { S as SkillLoader, b as SkillManifest, a as SkillEntry } from '../skill-BJxzIyyN.js';
-import { W as WstackPaths } from '../wstack-paths-_lqjzErq.js';
+export { C as CompactorOptions, D as DefaultErrorHandler, a as DefaultRetryPolicy, E as EternalAutonomyEngine, b as EternalAutonomyOptions, c as EternalEngineState, H as HybridCompactor, I as IterationStage, P as ParallelEngineState, d as ParallelEternalEngine, e as ParallelEternalOptions, f as ParallelIterationStage, T as ToolExecutor } from '../parallel-eternal-engine-CUtmM_0V.js';
+export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, D as DefaultSkillLoader, d as DoneCheckResult, e as DoneConditionChecker, I as IntelligentCompactor, f as IntelligentCompactorOptions, S as SelectiveCompactor, g as SelectiveCompactorOptions, h as SkillLoaderOptions, i as buildGoalPreamble, m as makeAutonomyPromptContributor } from '../goal-preamble-CI8lxeY1.js';
+import { P as Provider } from '../context-CNRYfhUv.js';
+import { B as BrainDecision, a as BrainDecisionRequest, b as BrainArbiter } from '../brain-Dfv4Y82E.js';
 import '../retry-policy-BcmuT_V0.js';
+import '../compactor-DXLxLcmU.js';
 import '../models-registry-B6_KfS65.js';
-import '../goal-store-DvWLNu52.js';
-import '../multi-agent-coordinator-DHNrjPaA.js';
-import 'node:events';
+import '../index-DIKEcfgC.js';
 import '../logger-B63L5bTg.js';
+import '../pipeline-BqiA_UMr.js';
+import '../config-BSU-6vah.js';
 import '../observability-D-HZN_mF.js';
 import '../permission-BDv7z0mk.js';
-
-interface SkillLoaderOptions {
-    paths: WstackPaths;
-    bundledDir?: string | undefined;
-}
-/**
- * Discovery order (later layers shadow earlier ones at boot, but we walk
- * highest priority first and skip names already seen):
- *   1. Project-committed:  <project>/.wrongstack/skills/
- *   2. User-global:        ~/.wrongstack/skills/
- *   3. Bundled with build: packages/core/skills/
- */
-declare class DefaultSkillLoader implements SkillLoader {
-    private readonly dirs;
-    private cache?;
-    constructor(opts: SkillLoaderOptions);
-    list(): Promise<SkillManifest[]>;
-    find(name: string): Promise<SkillManifest | undefined>;
-    manifestText(): Promise<string>;
-    listEntries(): Promise<SkillEntry[]>;
-    invalidateCache(): void;
-    readBody(name: string): Promise<string>;
-}
+import '../agent-subagent-runner-DukQLUcS.js';
+import '../goal-store-ht0VmR1A.js';
+import '../multi-agent-coordinator-51LvnXkD.js';
+import 'node:events';
+import '../skill-Bj6Ezqb8.js';
+import '../wstack-paths-_lqjzErq.js';
+import '../selector-C7wcdqMA.js';
+import '../session-event-bridge-BpJ5trO9.js';
 
 /**
- * Options for IntelligentCompactor.
- */
-interface IntelligentCompactorOptions {
-    /** Provider to use for LLM-assisted summarization. Required. */
-    provider: Provider;
-    /** Fraction of maxContext that triggers a warning (default 0.6). */
-    warnThreshold?: number | undefined;
-    /** Fraction of maxContext that triggers soft compaction (default 0.75). */
-    softThreshold?: number | undefined;
-    /** Fraction of maxContext that triggers hard compaction (default 0.9). */
-    hardThreshold?: number | undefined;
-    /** Max context window in tokens (used only for threshold fraction math). */
-    maxContext?: number | undefined;
-    /** How many recent (user+assistant) pairs to always preserve (default 4). */
-    preserveK?: number | undefined;
-    /** Token threshold below which tool results are not elided (default 500). */
-    eliseThreshold?: number | undefined;
-    /** System prompt for the summarizer sub-LLM. */
-    summarizerPrompt?: string | undefined;
-    /**
-     * Model ID to use for summarization. When not set, the same model as the
-     * agent is used (which risks cascading failure on context overflow). Set to
-     * a fast/cheap model like `claude-3-5-haiku-20240620` for resilience.
-     */
-    summarizerModel?: string | undefined;
-}
-/**
- * IntelligentCompactor uses an LLM to:
- *  - Analyze message importance and preserve critical context
- *  - Generate semantic summaries for old message ranges
- *  - Make intelligent decisions about what to compact
+ * AutonomyBrain — a self-driving decision layer for autonomous workflows.
  *
- * It extends HybridCompactor's elision logic with LLM-assisted summarization.
- */
-declare class IntelligentCompactor implements Compactor {
-    private readonly provider;
-    private readonly warnThreshold;
-    private readonly softThreshold;
-    private readonly hardThreshold;
-    private readonly maxContext;
-    private readonly preserveK;
-    private readonly eliseThreshold;
-    private readonly summarizerPrompt;
-    private readonly summarizerModel?;
-    constructor(opts: IntelligentCompactorOptions);
-    compact(ctx: Context, opts?: {
-        aggressive?: boolean | undefined;
-    }): 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 summarizeAncientTurns;
-    private findSafeBoundary;
-    private findExchangeStart;
-    private callSummarizer;
-    private messagesToText;
-    private lightweightCompact;
-    private eliseOldToolResults;
-    private hasTextContent;
-    private estimateTokens;
-}
-
-/**
- * Options for SelectiveCompactor — the most configurable compactor.
- */
-interface SelectiveCompactorOptions {
-    /** Provider for LLM calls (selector + summarizer). Required. */
-    provider: Provider;
-    /** Selector for LLM-driven importance analysis. */
-    selector?: MessageSelector | undefined;
-    /** Fraction of maxContext that triggers a warning (default 0.6). */
-    warnThreshold?: number | undefined;
-    /** Fraction of maxContext that triggers soft compaction (default 0.75). */
-    softThreshold?: number | undefined;
-    /** Fraction of maxContext that triggers hard compaction (default 0.9). */
-    hardThreshold?: number | undefined;
-    /** Max context window in tokens (used for threshold fraction math). */
-    maxContext?: number | undefined;
-    /** How many recent (user+assistant) pairs to always preserve (default 4). */
-    preserveK?: number | undefined;
-    /** Token threshold below which tool results are not elided (default 500). */
-    eliseThreshold?: number | undefined;
-    /** Model for selector LLM calls (default: same as provider default). */
-    selectorModel?: string | undefined;
-    /** Summarizer model for collapsed ranges (default: same as selectorModel). */
-    summarizerModel?: string | undefined;
-    /** Prompt for the summarizer sub-LLM. */
-    summarizerPrompt?: string | undefined;
-}
-/**
- * SelectiveCompactor uses an LLM-driven MessageSelector to make
- * surgical decisions about which message ranges to keep vs collapse.
+ * Unlike the standard BrainArbiter which asks the human when uncertain,
+ * AutonomyBrain makes decisions autonomously within configured risk
+ * boundaries, keeping the system running unattended. It uses the session
+ * LLM to evaluate situations and produce decisions.
  *
- * Compared to HybridCompactor / IntelligentCompactor:
- * - HybridCompactor: rule-based (preserveK + elision), no LLM calls
- * - IntelligentCompactor: LLM summarization but no structured selection
- * - SelectiveCompactor: full LLM-driven selection + optional summarization
- */
-declare class SelectiveCompactor implements Compactor {
-    private readonly provider;
-    private readonly selector;
-    private readonly warnThreshold;
-    private readonly softThreshold;
-    private readonly hardThreshold;
-    private readonly maxContext;
-    private readonly preserveK;
-    private readonly eliseThreshold;
-    private readonly summarizerModel;
-    private readonly summarizerPrompt;
-    constructor(opts: SelectiveCompactorOptions);
-    compact(ctx: Context, opts?: {
-        aggressive?: boolean | undefined;
-    }): 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 repairProtocolAdjacency;
-    /**
-     * Run the LLM selector to decide what to keep vs collapse.
-     * Returns the token savings achieved.
-     */
-    private runSelector;
-    /**
-     * Execute a SelectorResult plan: collapse/remove ranges and
-     * insert summaries where the selector provided them.
-     */
-    private executePlan;
-    private summarizeRange;
-    private messagePreview;
-    /**
-     * Fallback when selector fails: aggressively trim from the oldest end
-     * until we hit targetBudget.
-     */
-    private aggressiveRecencyTrim;
-    private computeTargetBudget;
-    private eliseOldToolResults;
-    private hasTextContent;
-    private estimateTokens;
-    private roughTokenEstimate;
-}
-
-type CompactionFailureMode = 'throw' | 'throw_on_hard' | 'continue';
-interface AutoCompactionOptions {
-    aggressiveOn?: ContextWindowAggressiveOn | undefined;
-    events?: EventBus | undefined;
-    failureMode?: CompactionFailureMode | undefined;
-    policyProvider?: (ctx: Context) => Pick<ContextWindowPolicy, 'thresholds' | 'aggressiveOn'> | null | undefined;
-    /** Optional bridge for writing compaction events into the persistent session log. */
-    sessionBridge?: SessionEventBridge | undefined;
-}
-/**
- * Pipeline middleware that monitors context token load and automatically
- * triggers compaction when the warn/soft/hard thresholds are crossed.
- * Runs before the next agent iteration.
+ * ## Identity
+ * The AutonomyBrain is NOT the main agent. It is a dedicated decision
+ * engine with a single purpose: evaluate blocked/stuck situations in
+ * autonomous workflows and decide whether to continue, pivot, or stop.
  *
- * Uses `estimateRequestTokens` for accurate full-request token counting:
- * messages + systemPrompt + toolDefs. This replaces the previous pattern
- * of applying an OVERHEAD_FACTOR to a messages-only estimate.
- */
-declare class AutoCompactionMiddleware {
-    readonly name = "AutoCompaction";
-    private readonly compactor;
-    /** Deprecated. Kept for backward compat with tests that pass simpleEstimator. */
-    private readonly _estimator?;
-    private readonly warnThreshold;
-    private readonly softThreshold;
-    private readonly hardThreshold;
-    /** Writable so model-switch can update the denominator without re-registering the middleware. */
-    private _maxContext;
-    private readonly aggressiveOn;
-    private readonly events?;
-    private readonly failureMode;
-    private readonly policyProvider?;
-    private readonly sessionBridge?;
-    /**
-     * Once a compaction attempt reduces nothing (preserveK protects everything,
-     * no oversized tool_results remain to elide), retrying on every iteration
-     * just spams `compaction.fired` events without making progress. We remember
-     * the no-op and skip until either the pressure level escalates or context
-     * has grown by at least this many tokens since the failed attempt.
-     */
-    private static readonly NOOP_RETRY_DELTA_TOKENS;
-    /** Tracks the most recent no-op attempt so we can avoid re-firing per turn. */
-    private lastNoopAttempt;
-    /**
-     * @param compactor        Compactor to use for compaction.
-     * @param maxContext Provider's max context window in tokens.
-     * @param _estimator       Deprecated parameter kept for backward compatibility.
-     *                         The middleware now uses `estimateRequestTokens` internally
-     *                         for accurate full-request token counting (messages +
-     *                         systemPrompt + toolDefs).
-     * @param thresholds       Threshold fractions (0-1) of maxContext.
-     * @param opts             Optional behavior. By default, failures at the
-     *                         hard threshold throw AGENT_CONTEXT_OVERFLOW so
-     *                         the agent does not continue into a likely
-     *                         provider context overflow. Warn/soft failures
-     *                         still emit compaction.failed and continue.
-     */
-    constructor(compactor: Compactor, maxContext: number, _estimator: (ctx: Context) => number, thresholds: {
-        warn: number;
-        soft: number;
-        hard: number;
-    }, optsOrAggressiveOn?: AutoCompactionOptions | ContextWindowAggressiveOn, events?: EventBus | undefined);
-    /** Allow callers (e.g. model-switch in WebUI) to update the context window
-     *  denominator when the active model changes. */
-    setMaxContext(maxContext: number): void;
-    handler(): MiddlewareHandler<Context>;
-    /**
-     * Returns true when the previous compaction at the same or higher pressure
-     * level reduced nothing and context has not grown materially since. Prevents
-     * a stuck preserveK window from spamming compaction events every iteration.
-     */
-    private shouldSkipNoopRetry;
-    private recordAttempt;
-    private compact;
-}
-
-type AutonomousResult = RunResult & {
-    toolCalls: number;
-    reason?: string | undefined;
-};
-interface DoneCheckResult {
-    done: boolean;
-    reason?: string | undefined;
-    iterations: number;
-    toolCalls: number;
-}
-declare class DoneConditionChecker {
-    private readonly condition;
-    private readonly compiledRegex;
-    constructor(condition: DoneCondition);
-    check(state: {
-        iterations: number;
-        toolCalls: number;
-        lastOutput?: string | undefined;
-    }): DoneCheckResult;
-}
-interface AutonomousRunnerOptions {
-    agent: Agent;
-    context: Context;
-    doneCondition: DoneCondition;
-    iterationTimeoutMs?: number | undefined;
-    onIteration?: (state: {
-        iteration: number | undefined;
-        toolCalls: number;
-    }) => void;
-    onDone?: (((result: AutonomousResult) => void)) | undefined;
-    /**
-     * 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 | undefined;
-}
-declare class AutonomousRunner {
-    private readonly opts;
-    private iterations;
-    private toolCalls;
-    private lastOutput?;
-    private stopped;
-    private readonly doneChecker;
-    constructor(opts: AutonomousRunnerOptions);
-    run(): Promise<AutonomousResult>;
-    private runLoop;
-    stop(): void;
-}
-
-/**
- * System-prompt contributor that surfaces eternal-autonomy state to the
- * model on every turn.
+ * ## Decision Flow
+ * 1. RISK GATE — if request risk > maxAutoRisk, auto-deny
+ * 2. HEURISTIC — fast pattern-match for common situations (deadlock, retry-exhausted)
+ * 3. LLM EVALUATION — complex decisions (goal completion, conflict resolution)
  *
- * Why this exists: when the engine drives a long-running loop, the
- * per-iteration directive carries the rules. But the directive is a USER
- * message — it scrolls out of working memory after a few compactions and
- * the model forgets it's in autonomy mode (forgets `[GOAL_COMPLETE]`,
- * forgets the todo-state protocol, forgets the no-confirmation rule).
- * Injecting the same anchor as a CACHED system-prompt block solves that
- * — the rules sit next to the identity layer and survive compactions.
+ * ## Decision Logging
+ * Every decision is emitted via `onDecision` callback with a human-readable
+ * summary suitable for chat history and journal entries.
  *
- * Block is tagged `ephemeral` so its content (journal tail, iteration
- * counter) changes each turn without invalidating the upstream prefix
- * cache.
+ * Usage:
+ *   const brain = createAutonomyBrain({
+ *     provider, model, maxAutoRisk: 'high',
+ *     onDecision: (summary) => journal.push(summary),
+ *   });
  */
 
-interface AutonomyPromptContributorOptions {
-    /** Absolute path to the project's `goal.json`. */
-    goalPath: string;
+interface AutonomyBrainOptions {
+    /** LLM provider for decision-making. */
+    provider: Provider;
+    /** Model to use for decisions (should be fast + cheap). */
+    model: string;
+    /** Maximum risk level the brain will auto-decide. Default: 'high'.
+     *  'low'    — only auto-decide low-risk questions
+     *  'medium' — auto-decide low/medium
+     *  'high'   — auto-decide low/medium/high
+     *  'all'    — auto-decide everything (including critical)
+     */
+    maxAutoRisk?: 'low' | 'medium' | 'high' | 'all' | undefined;
+    /** Timeout for each decision call (ms). Default: 15_000. */
+    decisionTimeoutMs?: number | undefined;
     /**
-     * Gating function. The contributor consults this on every build and
-     * returns an empty array when `false` — without this, the block would
-     * leak into interactive runs that happen to have a goal on disk and
-     * teach the model loop-control markers it shouldn't emit.
-     *
-     * Typical wiring: enable while `eternal` or `eternal-parallel` autonomy is active.
+     * Called after every decision with a human-readable summary.
+     * Use this to log decisions into chat history, journal, or status line.
+     * Example: "🧠 Brain: skipped deadlocked tasks → continuing with phase 3/5"
      */
-    enabled: () => boolean;
-    /** Number of journal entries to include in the recent-tail block. Default 5. */
-    journalTailSize?: number | undefined;
+    onDecision?: ((summary: string, decision: BrainDecision, request: BrainDecisionRequest) => void) | undefined;
 }
 /**
- * Build a contributor that renders the autonomy-state system block.
- * Returns `[]` when disabled, no goal exists, or the goal has been
- * completed/abandoned — all silent fast-paths.
+ * Create a self-driving brain that makes autonomous decisions.
+ * Never asks the human — within its risk boundary it answers, above it denies.
  */
-declare function makeAutonomyPromptContributor(opts: AutonomyPromptContributorOptions): SystemPromptContributor;
-
+declare function createAutonomyBrain(opts: AutonomyBrainOptions): BrainArbiter;
 /**
- * `/goal <description>` preamble — the "no force can stop this" mode.
- *
- * Unlike STEERING (which redirects mid-flight), GOAL is a contract:
- * the user hands over a problem, the agent commits to verifiably
- * finishing it, and every iteration re-reads this preamble from the
- * conversation history. The hardening is entirely prompt-level —
- * the system has already removed implicit budget caps, so this
- * preamble's job is to remove the MODEL's tendency to hedge, ask
- * permission, or declare premature success.
- *
- * The four sections are intentional:
- *   1. AUTHORITY — explicit grant of unbounded fan-out + model
- *      switching. Without this the model self-throttles ("I shouldn't
- *      spawn too many…") even when budgets are unlimited.
- *   2. DONE — concrete bar for completion. Forces a verifiable
- *      artifact (test passing, file written, bug re-run clean).
- *      Without this the model returns "I believe it's fixed" and
- *      counts that as done.
- *   3. NOT DONE — explicit anti-patterns. Each item is something we
- *      saw real agents do as a "completion" that wasn't.
- *   4. PERSISTENCE — three-angle rule for blockers. Stops the model
- *      from giving up on the first tool failure.
- *
- * Located in @wrongstack/core (rather than @wrongstack/tui) so headless
- * callers and the WebUI can issue `/goal set` without dragging the TUI
- * package in. The tui re-exports this for backward compatibility.
+ * Format a decision as a human-readable one-liner for chat history.
  */
-declare function buildGoalPreamble(goal: string): string;
+declare function formatDecisionSummary(decision: BrainDecision, request: BrainDecisionRequest): string;
 
-export { AutoCompactionMiddleware, AutonomousRunner, type AutonomousRunnerOptions, type AutonomyPromptContributorOptions, DefaultSkillLoader, type DoneCheckResult, DoneConditionChecker, IntelligentCompactor, type IntelligentCompactorOptions, SelectiveCompactor, type SelectiveCompactorOptions, type SkillLoaderOptions, buildGoalPreamble, makeAutonomyPromptContributor };
+export { type AutonomyBrainOptions, createAutonomyBrain, formatDecisionSummary };