@wrongstack/core 0.89.3 → 0.104.0

package/dist/extension/index.d.ts

@@ -1,9 +1,9 @@
-export { i as AfterIterationHook, j as AfterRunHook, k as AfterToolExecutionHook, l as AgentExtension, B as BeforeIterationHook, m as BeforeRunHook, n as BeforeToolExecutionHook, E as ExtensionRegistry, O as OnErrorHook, v as ProviderRunnerFn, t as ProviderRunnerWrapper } from '../index-D3Nax3YU.js';
+export { i as AfterIterationHook, j as AfterRunHook, k as AfterToolExecutionHook, l as AgentExtension, B as BeforeIterationHook, m as BeforeRunHook, n as BeforeToolExecutionHook, E as ExtensionRegistry, O as OnErrorHook, v as ProviderRunnerFn, t as ProviderRunnerWrapper } from '../index-DIKEcfgC.js';
 import '../context-CNRYfhUv.js';
 import '../logger-B63L5bTg.js';
-import '../pipeline-C1Ad9OjI.js';
-import '../config-84VaZpH6.js';
+import '../pipeline-BqiA_UMr.js';
+import '../config-BSU-6vah.js';
 import '../models-registry-B6_KfS65.js';
 import '../observability-D-HZN_mF.js';
-import '../brain-s9DyD_Vf.js';
+import '../brain-Dfv4Y82E.js';
 import '../permission-BDv7z0mk.js';

package/dist/goal-preamble-CI8lxeY1.d.ts

@@ -0,0 +1,378 @@
+import { S as SkillLoader, a as SkillManifest, b as SkillEntry } from './skill-Bj6Ezqb8.js';
+import { W as WstackPaths } from './wstack-paths-_lqjzErq.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-Dfv4Y82E.js';
+import { M as MiddlewareHandler } from './pipeline-BqiA_UMr.js';
+import { S as SessionEventBridge } from './session-event-bridge-BpJ5trO9.js';
+import { C as ContextWindowAggressiveOn, c as ContextWindowPolicy } from './config-BSU-6vah.js';
+import { g as Agent, D as DoneCondition } from './agent-subagent-runner-DukQLUcS.js';
+import { R as RunResult, S as SystemPromptContributor } from './index-DIKEcfgC.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>;
+}
+
+/**
+ * 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
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * Block is tagged `ephemeral` so its content (journal tail, iteration
+ * counter) changes each turn without invalidating the upstream prefix
+ * cache.
+ */
+
+interface AutonomyPromptContributorOptions {
+    /** Absolute path to the project's `goal.json`. */
+    goalPath: string;
+    /**
+     * 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.
+     */
+    enabled: () => boolean;
+    /** Number of journal entries to include in the recent-tail block. Default 5. */
+    journalTailSize?: number | 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.
+ */
+declare function makeAutonomyPromptContributor(opts: AutonomyPromptContributorOptions): SystemPromptContributor;
+
+/**
+ * `/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.
+ */
+declare function buildGoalPreamble(goal: string, deliverables?: string[]): string;
+
+export { AutoCompactionMiddleware as A, DefaultSkillLoader as D, IntelligentCompactor as I, SelectiveCompactor as S, AutonomousRunner as a, type AutonomousRunnerOptions as b, type AutonomyPromptContributorOptions as c, type DoneCheckResult as d, DoneConditionChecker as e, type IntelligentCompactorOptions as f, type SelectiveCompactorOptions as g, type SkillLoaderOptions as h, buildGoalPreamble as i, makeAutonomyPromptContributor as m };

package/dist/{goal-store-DvWLNu52.d.ts → goal-store-ht0VmR1A.d.ts}

@@ -30,8 +30,34 @@ interface JournalEntry {
 }
 interface GoalFile {
     version: 1;
-    /** The mission statement. */
+    /** The raw mission statement as entered by the user. */
     goal: string;
+    /**
+     * LLM-refined version of the goal — unambiguous, with concrete
+     * deliverables and acceptance criteria.
+     */
+    refinedGoal?: string | undefined;
+    /**
+     * Concrete, verifiable deliverables extracted from the refined goal.
+     */
+    deliverables?: string[] | undefined;
+    /**
+     * Estimated completion 0-100. Updated by the engine after each
+     * iteration. Null means "not yet assessed".
+     */
+    progress?: number | undefined;
+    /** Human-readable note explaining the current progress estimate. */
+    progressNote?: string | undefined;
+    /**
+     * Time-series of progress measurements for trend analysis.
+     * Last 200 entries retained. Use `recordProgress()` to append.
+     */
+    progressHistory?: ProgressSnapshot[] | undefined;
+    /**
+     * Computed trend from recent progress measurements.
+     * 'accelerating' | 'steady' | 'stalling' | undefined.
+     */
+    progressTrend?: 'accelerating' | 'steady' | 'stalling' | undefined;
     /** When the goal was first set or last replaced. */
     setAt: string;
     /** Updated on every iteration completion. */
@@ -41,23 +67,11 @@ interface GoalFile {
     /** Engine lifecycle state — 'running' means another process owns this goal. */
     engineState: 'idle' | 'running' | 'stopped';
     /**
-     * Mission-level lifecycle. `active` is the default; `completed` is set
-     * when the engine detects `[GOAL_COMPLETE]` in a successful iteration's
-     * final text AND a verification pass agrees; `abandoned` is set by the
-     * user (e.g. `/goal abandon`) or when the engine exceeds a configured
-     * failure ceiling. Once not `active`, the engine refuses to run further
-     * iterations against this goal — protects against accidental restarts
-     * burning through API quota after the work is done.
-     *
-     * Optional for backward compatibility — pre-existing `goal.json` files
-     * without this field load as `active`.
+     * Mission-level lifecycle.
      */
     goalState?: 'active' | 'paused' | 'completed' | 'abandoned' | undefined;
     /**
-     * Per-todo attempt counter. Keyed by TodoItem id. Used by the engine
-     * to skip a todo that has failed N times rather than spinning on it
-     * forever. Persisted so attempt counts survive restarts (`/autonomy
-     * stop` + resume should not reset progress against a stuck task).
+     * Per-todo attempt counter.
      */
     todoAttempts?: Record<string, number>;
     /** Bounded ring buffer of recent iterations (newest last). */
@@ -67,22 +81,23 @@ interface GoalFile {
 declare const MAX_JOURNAL_ENTRIES = 500;
 /**
  * Resolve the goal file path for a given project root.
- * Exposed so the engine and CLI use one canonical path.
- * Uses `~/.wrongstack/projects/<hash>/goal.json` .<hash>/`.
  */
 declare function goalFilePath(projectRoot: string): string;
 declare function loadGoal(filePath: string): Promise<GoalFile | null>;
 declare function saveGoal(filePath: string, goal: GoalFile): Promise<void>;
 declare function emptyGoal(goal: string): GoalFile;
+/**
+ * Set progress estimate on a goal. Returns a new GoalFile.
+ * Clamps progress to 0-100.
+ */
+declare function setProgress(goal: GoalFile, progress: number, note?: string): GoalFile;
 /**
  * Append a journal entry, bumping iteration counters and trimming the
  * ring buffer. Returns a new GoalFile — does not mutate the argument.
  */
 declare function appendJournal(goal: GoalFile, entry: Omit<JournalEntry, 'iteration' | 'at'>): GoalFile;
 /**
- * Aggregate cumulative cost + tokens across all journal entries. Entries
- * without telemetry are skipped (legacy entries from before the field
- * was added still load cleanly).
+ * Aggregate cumulative cost + tokens across all journal entries.
  */
 declare function summarizeUsage(goal: GoalFile): {
     totalCostUsd: number;
@@ -92,5 +107,32 @@ declare function summarizeUsage(goal: GoalFile): {
 };
 /** Format the goal + recent journal as a human-readable status block. */
 declare function formatGoal(goal: GoalFile, journalLimit?: number): string;
+/** A single progress measurement at a point in time. */
+interface ProgressSnapshot {
+    at: string;
+    progress: number;
+    note?: string | undefined;
+}
+/**
+ * Parse [PROGRESS: N%] from agent final text.
+ * Supports formats:
+ *   [PROGRESS: 45%]
+ *   [PROGRESS: 45%] — 3/5 deliverables done
+ *   [progress: 100%]
+ * Returns null if no match.
+ */
+declare function parseProgressFromText(text: string): {
+    progress: number;
+    note?: string;
+} | null;
+/**
+ * Record a progress measurement. Returns a new GoalFile with:
+ * - progress + progressNote updated
+ * - progressHistory appended (last 200 entries kept)
+ * - progress trend computed (accelerating/steady/stalling)
+ */
+declare function recordProgress(goal: GoalFile, progress: number, note?: string): GoalFile;
+/** Max progress history entries to retain. */
+declare const MAX_PROGRESS_HISTORY = 200;
 
-export { type GoalFile as G, type JournalEntry as J, MAX_JOURNAL_ENTRIES as M, appendJournal as a, summarizeUsage as b, emptyGoal as e, formatGoal as f, goalFilePath as g, loadGoal as l, saveGoal as s };
+export { type GoalFile as G, type JournalEntry as J, MAX_JOURNAL_ENTRIES as M, type ProgressSnapshot as P, MAX_PROGRESS_HISTORY as a, appendJournal as b, setProgress as c, summarizeUsage as d, emptyGoal as e, formatGoal as f, goalFilePath as g, loadGoal as l, parseProgressFromText as p, recordProgress as r, saveGoal as s };

package/dist/{index-CqrroYcU.d.ts → index-BWRN6wOb.d.ts}

@@ -1,7 +1,7 @@
-import { T as Token, a as Renderer, S as SystemPromptBuilder, H as HookRegistry } from './pipeline-C1Ad9OjI.js';
-import { E as EventBus, l as MemoryStore, B as BrainArbiter } from './brain-s9DyD_Vf.js';
+import { T as Token, a as Renderer, S as SystemPromptBuilder, H as HookRegistry } from './pipeline-BqiA_UMr.js';
+import { E as EventBus, l as MemoryStore, b as BrainArbiter } from './brain-Dfv4Y82E.js';
 import { C as Compactor } from './compactor-DXLxLcmU.js';
-import { d as ConfigLoader, c as ConfigStore } from './config-84VaZpH6.js';
+import { f as ConfigLoader, e as ConfigStore } from './config-BSU-6vah.js';
 import { E as ErrorHandler, R as RetryPolicy } from './retry-policy-BcmuT_V0.js';
 import { I as InputReader } from './input-reader-E-ffP2ee.js';
 import { L as Logger } from './logger-B63L5bTg.js';
@@ -9,9 +9,9 @@ import { M as ModeStore } from './mode-ARA3HrkY.js';
 import { M as ModelsRegistry } from './models-registry-B6_KfS65.js';
 import { P as PathResolver } from './path-resolver-CPRj4bFY.js';
 import { P as PermissionPolicy, S as SecretScrubber } from './permission-BDv7z0mk.js';
-import { P as ProviderRunner } from './provider-runner-cqvlB_oS.js';
+import { P as ProviderRunner } from './provider-runner-BUunikwY.js';
 import { c as TokenCounter, i as SessionStore } from './context-CNRYfhUv.js';
-import { S as SkillLoader } from './skill-BJxzIyyN.js';
+import { S as SkillLoader } from './skill-Bj6Ezqb8.js';
 
 /**
  * Lifecycle of a single worktree handle.

package/dist/{index-D3Nax3YU.d.ts → index-DIKEcfgC.d.ts}

@@ -1,9 +1,9 @@
 import { l as TextBlock, T as Tool, m as ToolUseBlock, C as Context, n as ToolResultBlock, R as Request, b as Response, P as Provider, g as ContentBlock, a0 as WrongStackError } from './context-CNRYfhUv.js';
 import { L as Logger } from './logger-B63L5bTg.js';
-import { B as BuildContext, H as HookRegistry, a as Renderer, P as Pipeline, C as Container } from './pipeline-C1Ad9OjI.js';
-import { H as HookEvent, u as ProviderConfig } from './config-84VaZpH6.js';
+import { B as BuildContext, H as HookRegistry, a as Renderer, P as Pipeline, C as Container } from './pipeline-BqiA_UMr.js';
+import { H as HookEvent, u as ProviderConfig } from './config-BSU-6vah.js';
 import { T as Tracer } from './observability-D-HZN_mF.js';
-import { E as EventBus } from './brain-s9DyD_Vf.js';
+import { E as EventBus } from './brain-Dfv4Y82E.js';
 import { P as PermissionPolicy, S as SecretScrubber } from './permission-BDv7z0mk.js';
 import { W as WireFamily } from './models-registry-B6_KfS65.js';