@wrongstack/core 0.63.4 → 0.68.0

package/dist/extension/index.d.ts

@@ -1,10 +1,10 @@
-export { A as AfterIterationHook, a as AfterRunHook, b as AfterToolExecutionHook, d as AgentExtension, B as BeforeIterationHook, h as BeforeRunHook, i as BeforeToolExecutionHook, E as ExtensionRegistry, O as OnErrorHook, w as ProviderRunnerFn, x as ProviderRunnerWrapper } from '../index-Bc6BiP5q.js';
-import '../context-iFMEO2rN.js';
+export { A as AfterIterationHook, a as AfterRunHook, b as AfterToolExecutionHook, c as AgentExtension, B as BeforeIterationHook, g as BeforeRunHook, h as BeforeToolExecutionHook, E as ExtensionRegistry, O as OnErrorHook, n as ProviderRunnerFn, o as ProviderRunnerWrapper } from '../index-DKUvyTvV.js';
+import '../context-y87Jc5ei.js';
 import '../logger-DDd5C--Z.js';
-import '../system-prompt-7LHyBbIf.js';
-import '../config-BdDuaZmB.js';
+import '../system-prompt-b61lOd49.js';
+import '../config--86aHSln.js';
 import '../models-registry-BcYJDKLm.js';
 import '../observability-BhnVLBLS.js';
-import '../events-k8CHjcrN.js';
+import '../events-CIplI98R.js';
 import '../secret-scrubber-3MHDDAtm.js';
-import '../permission-Ld-i5ugf.js';
+import '../permission-C1A5whY5.js';

package/dist/goal-store-C7jcumEh.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Long-running autonomous mission. A goal survives across sessions and
+ * drives the EternalAutonomyEngine — every iteration of the engine
+ * consults the goal to choose what to do next.
+ *
+ * Storage: `~/.wrongstack/projects/<hash>/goal.json`. Persistent and
+ * project-scoped on purpose: the goal belongs to the codebase, not the
+ * REPL session.
+ */
+interface JournalEntry {
+    /** ISO timestamp of the iteration. */
+    at: string;
+    /** Sequential iteration counter (1-based, monotonically increasing). */
+    iteration: number;
+    /** Source that produced the action ('todo' | 'git' | 'brainstorm' | 'resume' | 'manual' | 'parallel'). */
+    source: 'todo' | 'git' | 'brainstorm' | 'resume' | 'manual' | 'parallel';
+    /** Short one-line description of what the iteration set out to do. */
+    task: string;
+    /** Outcome status. */
+    status: 'success' | 'failure' | 'aborted' | 'skipped';
+    /** Optional free-form note (error message, summary, etc.). */
+    note?: string;
+    /** Optional token usage delta for this iteration. */
+    tokens?: {
+        input: number;
+        output: number;
+    };
+    /** Optional USD cost delta for this iteration (provider-estimated). */
+    costUsd?: number;
+}
+interface GoalFile {
+    version: 1;
+    /** The mission statement. */
+    goal: string;
+    /** When the goal was first set or last replaced. */
+    setAt: string;
+    /** Updated on every iteration completion. */
+    lastActivityAt: string;
+    /** Total iterations the engine has run against this goal (cumulative). */
+    iterations: number;
+    /** 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`.
+     */
+    goalState?: 'active' | 'paused' | 'completed' | 'abandoned';
+    /**
+     * 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).
+     */
+    todoAttempts?: Record<string, number>;
+    /** Bounded ring buffer of recent iterations (newest last). */
+    journal: JournalEntry[];
+}
+/** Cap on persisted journal entries — older entries are evicted FIFO. */
+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;
+/**
+ * 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).
+ */
+declare function summarizeUsage(goal: GoalFile): {
+    totalCostUsd: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    iterationsWithUsage: number;
+};
+/** Format the goal + recent journal as a human-readable status block. */
+declare function formatGoal(goal: GoalFile, journalLimit?: number): string;
+
+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 };

package/dist/{index-Bc6BiP5q.d.ts → index-DKUvyTvV.d.ts}

@@ -1,13 +1,31 @@
-import { Q as Tool, Y as ToolResultBlock, _ as ToolUseBlock, d as Context, T as TextBlock, p as Request, q as Response, m as Provider, a0 as WrongStackError, c as ContentBlock, u as RunOptions, J as JSONSchema } from './context-iFMEO2rN.js';
+import { T as TextBlock, Q as Tool, Y as ToolResultBlock, _ as ToolUseBlock, d as Context, p as Request, q as Response, m as Provider, a0 as WrongStackError, c as ContentBlock } from './context-y87Jc5ei.js';
 import { a as Logger } from './logger-DDd5C--Z.js';
-import { H as HookRegistry, e as Renderer, a as BuildContext, C as Container, P as Pipeline, R as ReadonlyPipeline } from './system-prompt-7LHyBbIf.js';
-import { l as HookEvent, r as ProviderConfig, n as HookMatcher, I as InProcessHook, a as Config } from './config-BdDuaZmB.js';
+import { a as BuildContext, H as HookRegistry, e as Renderer, P as Pipeline, C as Container } from './system-prompt-b61lOd49.js';
+import { l as HookEvent, r as ProviderConfig } from './config--86aHSln.js';
 import { T as Tracer } from './observability-BhnVLBLS.js';
-import { E as EventBus, k as EventName, L as Listener } from './events-k8CHjcrN.js';
+import { E as EventBus } from './events-CIplI98R.js';
 import { S as SecretScrubber } from './secret-scrubber-3MHDDAtm.js';
-import { a as PermissionPolicy } from './permission-Ld-i5ugf.js';
+import { a as PermissionPolicy } from './permission-C1A5whY5.js';
 import { W as WireFamily } from './models-registry-BcYJDKLm.js';
 
+/**
+ * A contributor that injects additional TextBlocks into the system prompt.
+ *
+ * Contributors are called on every `build()` in registration order.
+ * Their output is inserted after the core blocks (identity, tool usage,
+ * environment) but before the mode and plan blocks. This lets plugins
+ * inject ephemeral context — current state, recent events, plugin-specific
+ * instructions — without replacing the entire system prompt builder.
+ *
+ * @example
+ * ```ts
+ * api.extensions.registerSystemPromptContributor(async (ctx) => {
+ *   return [{ type: 'text', text: '## My Plugin Context\n...' }];
+ * });
+ * ```
+ */
+type SystemPromptContributor = (ctx: BuildContext) => Promise<TextBlock[]>;
+
 /**
  * A function that wraps (decorates) an existing tool. Receives the
  * original tool and returns a modified version — typically the same
@@ -243,24 +261,6 @@ interface ToolExecutorLike {
     executeTool(tool: Tool, use: ToolUseBlock, ctx: Context, budget: number): Promise<ToolResultBlock>;
 }
 
-/**
- * A contributor that injects additional TextBlocks into the system prompt.
- *
- * Contributors are called on every `build()` in registration order.
- * Their output is inserted after the core blocks (identity, tool usage,
- * environment) but before the mode and plan blocks. This lets plugins
- * inject ephemeral context — current state, recent events, plugin-specific
- * instructions — without replacing the entire system prompt builder.
- *
- * @example
- * ```ts
- * api.extensions.registerSystemPromptContributor(async (ctx) => {
- *   return [{ type: 'text', text: '## My Plugin Context\n...' }];
- * });
- * ```
- */
-type SystemPromptContributor = (ctx: BuildContext) => Promise<TextBlock[]>;
-
 /**
  * Extension points for the Agent lifecycle.
  *
@@ -467,7 +467,7 @@ declare class ExtensionRegistry {
  * the returned instance. The `type` is the registry key (e.g. a
  * provider's models.dev id or a user-chosen alias).
  */
-interface ProviderFactory$1 {
+interface ProviderFactory {
     /**
      * Unique identifier used as the registry key. When registered via
      * a plugin, this becomes `cfg.type` in `ProviderRegistry.create(cfg)`.
@@ -488,17 +488,17 @@ declare class ProviderRegistry {
      * exists, it is replaced. Use this for both initial registration and
      * runtime overrides (e.g. from plugins or CLI flags).
      */
-    register(f: ProviderFactory$1): void;
+    register(f: ProviderFactory): void;
     /**
      * Bulk-register multiple provider factories at once.
      */
-    registerAll(factories: ProviderFactory$1[]): void;
+    registerAll(factories: ProviderFactory[]): void;
     /**
      * Override an existing factory. Throws if no factory is registered
      * for the given type. Use this to safely replace a provider at runtime
      * (e.g. in tests or when a plugin provides a custom implementation).
      */
-    override(type: string, f: ProviderFactory$1): void;
+    override(type: string, f: ProviderFactory): void;
     has(type: string): boolean;
     create(cfg: ProviderConfig): Provider;
     list(): string[];
@@ -508,22 +508,9 @@ declare class ProviderRegistry {
 declare const DEFAULT_MAX_ITERATIONS = 100;
 interface RunResult {
     status: 'done' | 'failed' | 'max_iterations' | 'aborted';
-    /**
-     * Set when `status === 'failed'` (always) or `'aborted'` (when the abort
-     * carried an error context). Always a `WrongStackError` so callers can
-     * branch on `code`, `severity`, and `recoverable` without parsing strings.
-     * Raw throws are wrapped into an `AgentError` with code `AGENT_RUN_FAILED`
-     * by `Agent.run` before they reach this field.
-     */
     error?: WrongStackError;
     finalText?: string;
     iterations: number;
-    /**
-     * Subagent delegate summaries collected during the run. Populated by the
-     * `delegate` tool — each entry is the `summary` + `ok` fields returned
-     * when a subagent finishes. Callers (e.g. TUI/CLI renderer) use this to
-     * surface flashy completion banners in the terminal.
-     */
     delegateSummaries?: Array<{
         summary: string;
         ok: boolean;
@@ -540,58 +527,12 @@ interface AgentInit {
     iterationTimeoutMs?: number;
     executionStrategy?: 'parallel' | 'sequential' | 'smart';
     perIterationOutputCapBytes?: number;
-    /**
-     * When true (default), the agent automatically extends its iteration
-     * limit by 100 when hit, without asking the user. Set to false to
-     * emit `iteration.limit_reached` and wait for a listener to grant/deny.
-     */
     autoExtendLimit?: boolean;
-    /**
-     * When true, the agent supports autonomous continuation — the model
-     * can signal "keep going" either via the `continue_to_next_iteration()`
-     * tool or by placing a `[continue]` / `[next step]` / `[proceed]` /
-     * `[done]` marker on its own line in the final text output. The agent
-     * loop re-runs without returning to the caller when `continue` is
-     * signalled, or exits with `status: 'done'` when `stop` is signalled.
-     *
-     * The text-marker parser runs in `processResponse()` before the
-     * loop-exit check so markers in the final text block are honoured
-     * even when no tool was called.
-     */
     autonomousContinue?: boolean;
-    /**
-     * Optional confirm handler. When set, the executor calls it synchronously
-     * when a tool needs user confirmation (CLI path). When omitted, the
-     * executor returns a `ToolConfirmPendingResult` and the agent emits
-     * `tool.confirm_needed` for the TUI to resolve.
-     */
     confirmAwaiter?: ConfirmAwaiter | undefined;
-    /**
-     * Override the PermissionPolicy resolved from the container. Subagents
-     * use this to force auto-approval — they cannot respond to interactive
-     * permission prompts, so inheriting the leader's non-YOLO policy would
-     * silently hang the entire delegated run on the first tool call.
-     */
     permissionPolicy?: PermissionPolicy;
-    /**
-     * Optional tracer. When provided, `Agent.run` opens an `agent.run` span,
-     * per-iteration `agent.iteration` spans, and `provider.complete` spans
-     * inside the retry loop. Tool spans are opened by the ToolExecutor.
-     * Default is `NoopTracer` (zero overhead).
-     */
     tracer?: Tracer | undefined;
-    /**
-     * Optional extension registry. Plugins and host applications register
-     * extensions here to hook into the agent lifecycle (beforeRun, afterRun,
-     * beforeIteration, onError, wrapProviderRunner, etc.).
-     * When not provided, the agent creates an empty registry internally —
-     * no overhead, zero breakage.
-     */
     extensions?: ExtensionRegistry | undefined;
-    /**
-     * Mandatory tool executor. Callers (e.g. CLI wiring) inject a pre-built
-     * instance so `core/` does not need a runtime import of `execution/`.
-     */
     toolExecutor: ToolExecutorLike;
 }
 interface AgentPipelines {
@@ -604,7 +545,6 @@ interface AgentPipelines {
 }
 interface UserInputPayload {
     content: ContentBlock[];
-    /** Concatenation of text blocks — convenience for middleware that only cares about text. */
     text: string;
     ctx: Context;
 }
@@ -613,362 +553,8 @@ interface ToolCallPipelinePayload {
     toolUse: ToolUseBlock;
     result: ToolResultBlock;
     ctx: Context;
-    /** Undefined when the model invoked a tool name we don't know. */
     tool?: Tool;
 }
 declare function createDefaultPipelines(): AgentPipelines;
-declare class Agent {
-    readonly container: Container;
-    readonly tools: ToolRegistry;
-    readonly providers: ProviderRegistry;
-    readonly events: EventBus;
-    readonly pipelines: AgentPipelines;
-    readonly ctx: Context;
-    private readonly maxIterations;
-    private readonly executionStrategy;
-    private readonly perIterationOutputCapBytes;
-    private readonly plugins;
-    private readonly toolExecutor;
-    private readonly autoExtendLimit;
-    /** Enables autonomous continue: model can signal `[continue]` or call continue_to_next_iteration() to re-run. */
-    private readonly autonomousContinue;
-    private readonly tracer;
-    readonly extensions: ExtensionRegistry;
-    constructor(init: AgentInit);
-    private get logger();
-    private get retry();
-    private get errorHandler();
-    private get permission();
-    private get renderer();
-    /**
-     * Switch from inline CLI prompts to event-driven confirmation.
-     * Clears both the ToolExecutor's confirmAwaiter (so it returns
-     * `ToolConfirmPendingResult`) and the permission policy's
-     * promptDelegate (so `evaluate()` returns `confirm`).
-     *
-     * Call this before entering TUI or any mode where stdin is owned
-     * by a UI framework (Ink, WebUI WS bridge). Without this, the
-     * inline prompt writes to stdout and blocks on stdin — both of
-     * which are owned by the framework — making the prompt invisible
-     * and the input deadlocked.
-     */
-    disableInteractiveConfirmation(): void;
-    register(tool: Tool): void;
-    use(plugin: Plugin, api: PluginAPI): Promise<void>;
-    /** Tear down all plugins in reverse order, calling their teardown hooks. */
-    teardown(): Promise<void>;
-    run(userInput: AgentInput, opts?: RunOptions): Promise<RunResult>;
-    private runInner;
-    /**
-     * Check if iteration limit has been reached and request extension if needed.
-     * Returns the new effective limit (possibly extended) and a RunResult if
-     * the loop should exit. Returns `{ limit }` with no result when the
-     * iteration may proceed.
-     */
-    private checkIterationLimit;
-    /**
-     * Build request and run through request pipeline.
-     */
-    private buildAndRunRequestPipeline;
-    /**
-     * Process the provider response: run response pipeline, emit events,
-     * update session, render text, handle abort.
-     */
-    private processResponse;
-    /**
-     * Execute tools and append tool results to context.
-     * When a tool returns `tool_confirm_pending` (no confirmAwaiter set),
-     * we pause and emit `tool.confirm_needed`. The run is blocked until
-     * the event listener resolves the confirmation, then we re-run the
-     * single tool.
-     */
-    private executeTools;
-    /**
-     * Fold any pending `/btw` notes into the conversation. Called at the top of
-     * each iteration so a note set mid-run reaches the model on its next turn.
-     *
-     * To stay valid across all provider wire families we never create two
-     * consecutive user messages: if the last message is a user turn (e.g. the
-     * tool_result block from the previous iteration) we append the note as an
-     * extra text block on that turn; otherwise we add a fresh user message.
-     */
-    private injectPendingBtwNotes;
-    private waitForConfirm;
-    private executeSingleWithDecision;
-    /**
-     * Run context window pipeline. The pipeline may be empty, or it may contain
-     * middleware with its own injected dependencies.
-     */
-    private compactContextIfNeeded;
-    /**
-     * Emit the current context window load as a `ctx.pct` event so subscribers
-     * (FleetBus → TUI) can render a live fill bar per agent.
-     */
-    private emitContextPct;
-}
-
-/**
- * A slash command registered with the CLI or available to plugins.
- * Plugins receive a view of the registry via PluginAPI.slashCommands.
- *
- * Commands registered by plugins use a namespaced name: `pluginName:commandName`.
- * This prevents collisions with built-in commands and other plugins.
- */
-interface SlashCommand {
-    /** Unique command name. For plugins: `pluginName:commandName`. */
-    name: string;
-    /** Short aliases — also prefixed automatically: `pluginName:alias`. */
-    aliases?: string[];
-    description: string;
-    /**
-     * Optional compact argument hint for interactive menus. This is not parsed
-     * by the registry; it only helps TUI/REPL surfaces show the expected shape,
-     * for example `[list|install <alias>|disable <name>]`.
-     */
-    argsHint?: string;
-    /**
-     * Optional detailed help shown by `/help <name>`. Use this for usage,
-     * arguments, examples, side-effects — anything that doesn't fit in
-     * `description`. Renders verbatim, so format with line breaks.
-     * If absent, `/help <name>` falls back to `description`.
-     */
-    help?: string;
-    /**
-     * Execute the command.
-     * @param args Everything after the command name (trimmed by dispatch).
-     * @param ctx The current agent context.
-     * @returns `{ exit: true }` to quit the REPL. `{ message }` to print and
-     * continue. `{ runText }` to send a follow-up user-role message to the
-     * model immediately (e.g. `/steer <text>` builds a STEERING preamble
-     * here and asks the TUI to run it as the next turn). The TUI prints
-     * `message` first (if any) so the user sees the slash result before
-     * the model's response starts streaming. `{ metadata }` carries
-     * structured data for the REPL/TUI to act on (e.g. SDD session state).
-     */
-    run(args: string, ctx: Context): Promise<{
-        exit?: boolean;
-        message?: string;
-        runText?: string;
-        metadata?: Record<string, unknown>;
-    } | void>;
-}
-
-interface ToolRegistryView {
-    register(t: Tool): void;
-    unregister(name: string): void;
-    /** Wrap (decorate) an existing tool. The wrapper gets the current tool and returns the decorated version. */
-    wrap(name: string, wrapper: ToolWrapper): void;
-    get(name: string): Tool | undefined;
-    list(): Tool[];
-}
-interface ProviderFactory {
-    type: string;
-    family: WireFamily;
-    create(cfg: unknown): Provider;
-}
-interface ProviderRegistryView {
-    register(f: ProviderFactory): void;
-    create(cfg: {
-        type: string;
-    } & Record<string, unknown>): Provider;
-    list(): string[];
-}
-interface MCPRegistryView {
-    start(cfg: unknown): Promise<void>;
-    stop(name: string): Promise<void>;
-    restart(name: string): Promise<void>;
-    list(): {
-        name: string;
-        state: string;
-        toolCount: number;
-    }[];
-}
-interface SlashCommandRegistryView {
-    register(cmd: SlashCommand): void;
-    unregister(name: string): boolean;
-    get(name: string): SlashCommand | undefined;
-    list(): SlashCommand[];
-}
-/**
- * Read-only view of the session writer. Plugins can append custom events
- * to the JSONL session log and read the transcript path.
- *
- * The `append` method accepts any JSON-serializable payload — custom
- * event types are persisted verbatim next to the built-in events.
- */
-interface SessionWriterView {
-    readonly transcriptPath?: string;
-    append(event: Record<string, unknown> & {
-        type: string;
-        ts: string;
-    }): Promise<void>;
-}
-/**
- * Metrics sink scoped to a plugin. The host auto-prefixes metric names
- * with `plugin.<pluginName>.` so plugins don't need to namespace
- * manually. Plugins call counter/histogram/gauge directly; the values
- * flow to the host's MetricsSink (Prometheus, OTLP, or noop).
- */
-interface MetricsSinkView {
-    counter(name: string, value?: number, labels?: Record<string, string>): void;
-    histogram(name: string, value: number, labels?: Record<string, string>): void;
-    gauge(name: string, value: number, labels?: Record<string, string>): void;
-}
-interface PluginPipelines {
-    request: ReadonlyPipeline<Request>;
-    response: ReadonlyPipeline<Response>;
-    toolCall: ReadonlyPipeline<ToolCallPipelinePayload>;
-    userInput: ReadonlyPipeline<{
-        content: ContentBlock[];
-        text: string;
-        ctx: Context;
-    }>;
-    assistantOutput: ReadonlyPipeline<TextBlock>;
-    contextWindow: ReadonlyPipeline<Context>;
-    [k: string]: ReadonlyPipeline<any>;
-}
-interface PluginAPI {
-    container: Container;
-    pipelines: PluginPipelines;
-    events: EventBus;
-    tools: ToolRegistryView;
-    providers: ProviderRegistryView;
-    mcp: MCPRegistryView;
-    slashCommands: SlashCommandRegistryView;
-    /** Live session writer — plugins can append custom events here. */
-    session: SessionWriterView;
-    /** Scoped metrics sink — counters/histograms/gauges auto-namespaced under `plugin.<name>.` */
-    metrics: MetricsSinkView;
-    /** Registry for agent lifecycle extensions — hooks like beforeRun, beforeIteration, onError, etc. */
-    extensions: ExtensionRegistry;
-    /**
-     * Register a system prompt contributor. Plugins call this to inject
-     * ephemeral TextBlocks into the system prompt on every build.
-     * Returns an unregister function.
-     */
-    registerSystemPromptContributor(c: SystemPromptContributor): () => void;
-    /**
-     * Register an in-process lifecycle hook. `matcher` is a tool-name filter for
-     * `PreToolUse`/`PostToolUse` (`"Bash"`, `"edit|write"`, `"*"`) and ignored
-     * for other events. The hook can block, rewrite tool input, or inject extra
-     * context — see `HookOutcome`. Automatically removed when the plugin is
-     * uninstalled. Returns an unregister function.
-     */
-    registerHook(event: HookEvent, matcher: HookMatcher | undefined, hook: InProcessHook): () => void;
-    config: Config;
-    log: Logger;
-    /**
-     * Register a one-time event listener. The handler is automatically removed
-     * after the first emission, or when the plugin is uninstalled — whichever
-     * comes first.
-     */
-    onEvent<K extends EventName>(event: K, handler: Listener<K>): () => void;
-    /**
-     * Subscribe to all events matching a glob-style pattern.
-     * `'tool.*'` matches all tool events. `'*'` matches everything.
-     * Returns an unsubscribe function.
-     */
-    onPattern(pattern: string, handler: (event: string, payload: unknown) => void): () => void;
-    /**
-     * Emit a custom event on the agent's EventBus. Use for inter-plugin
-     * communication or to surface plugin-specific state to the host.
-     *
-     * Custom events use a `pluginName:eventName` convention to avoid
-     * collisions with built-in events (e.g. `my-plugin:cache_hit`).
-     * The payload is passed through to all subscribers.
-     */
-    emitCustom(event: string, payload: unknown): void;
-    /**
-     * Register a callback that fires when the configuration changes at
-     * runtime (e.g. via `/config` slash command or programmatic update).
-     * The handler receives the new and previous config snapshots.
-     * Returns an unsubscribe function.
-     */
-    onConfigChange(handler: (next: Readonly<Config>, prev: Readonly<Config>) => void): () => void;
-}
-/**
- * Capability declaration — informs the host which subsystems a plugin
- * intends to touch. Used for diagnostics and per-plugin enable/disable UX
- * (e.g. "this plugin registers tools — disable to remove them"). Not
- * enforced at runtime: a plugin that declares `tools: false` can still
- * call `api.tools.register()`, but the host can flag the discrepancy.
- */
-interface PluginCapabilities {
-    /** Will register tools via `api.tools.register()`. */
-    tools?: boolean;
-    /** Will register provider factories via `api.providers.register()`. */
-    providers?: boolean;
-    /**
-     * Pipelines the plugin hooks into. Use the standard names
-     * (`request | response | toolCall | userInput | assistantOutput | contextWindow`)
-     * or custom pipeline names exposed by other plugins.
-     */
-    pipelines?: string[];
-    /** Will register slash commands via `api.slashCommands.register()`. */
-    slashCommands?: boolean;
-    /** Will start MCP servers via `api.mcp.start()`. */
-    mcp?: boolean;
-}
-/**
- * Structured dependency declaration. The string form (`dependsOn: ['foo']`)
- * is shorthand for `[{ name: 'foo' }]` — both work. Use the structured form
- * when you need a version constraint:
- *
- *   dependsOn: [{ name: 'wstack-auth', version: '^1.2.0' }]
- */
-interface PluginDependency {
-    name: string;
-    /** npm-style semver range. Supports `^`, `~`, exact, and unprefixed. */
-    version?: string;
-}
-interface Plugin {
-    name: string;
-    version?: string;
-    /** One-line summary for `wstack plugins list` and error messages. */
-    description?: string;
-    /** Semver range against the kernel API version (KERNEL_API_VERSION). */
-    apiVersion: string;
-    /**
-     * Capability hints — what subsystems the plugin will register against.
-     * Optional; provided for diagnostics and UX. The loader does not enforce
-     * these, but mismatch is surfaced via logger at warn level.
-     */
-    capabilities?: PluginCapabilities;
-    /**
-     * JSON Schema for the options under `Config.plugins[<name>].options`.
-     * When present, the loader validates that section before calling `setup`
-     * and rejects the plugin with a clear error path on failure.
-     */
-    configSchema?: JSONSchema;
-    /**
-     * Mandatory plugin dependencies — loading fails if any are absent or
-     * version-incompatible. Accepts both the legacy string-array form and
-     * the structured form with version constraints.
-     */
-    dependsOn?: (string | PluginDependency)[];
-    /** Optional plugin dependencies — silently skipped if absent. */
-    optionalDeps?: (string | PluginDependency)[];
-    conflictsWith?: string[];
-    /**
-     * Default configuration values, deep-merged under the plugin's options
-     * key before `configSchema` validation. User-provided values take
-     * precedence over defaults — this is a fallback, not an override.
-     *
-     * @example
-     * defaultConfig: { ttl: 3600, maxSize: 100 }
-     */
-    defaultConfig?: Record<string, unknown>;
-    setup(api: PluginAPI): void | Promise<void>;
-    teardown?(api: PluginAPI): void | Promise<void>;
-    /**
-     * Optional health check. Called by the host (e.g. `/diag plugins` slash
-     * command or health endpoint) to surface plugin status. Return
-     * `{ ok: false, message: '...' }` when the plugin is degraded.
-     */
-    health?(): Promise<{
-        ok: boolean;
-        message?: string;
-    }>;
-}
 
-export { type AfterIterationHook as A, type BeforeIterationHook as B, type SystemPromptContributor as C, DEFAULT_MAX_ITERATIONS as D, ExtensionRegistry as E, type ToolCallPipelinePayload as F, type ToolExecutorOptions as G, type HookRunEnv as H, type ToolExecutorStrategy as I, ToolRegistry as J, type ToolRegistryView as K, type ToolWrapper as L, type MCPRegistryView as M, createDefaultPipelines as N, type OnErrorHook as O, type Plugin as P, type RunResult as R, type SessionWriterView as S, type ToolBatchResult as T, type UserInputPayload as U, type AfterRunHook as a, type AfterToolExecutionHook as b, Agent as c, type AgentExtension as d, type AgentInit as e, type AgentInput as f, type AgentPipelines as g, type BeforeRunHook as h, type BeforeToolExecutionHook as i, HookRunner as j, type HookRunnerOptions as k, type MetricsSinkView as l, type PluginAPI as m, type PluginCapabilities as n, type PluginDependency as o, type PluginPipelines as p, type PreToolUseResult as q, type PromptResult as r, type ProviderFactory as s, type ProviderFactory$1 as t, ProviderRegistry as u, type ProviderRegistryView as v, type ProviderRunnerFn as w, type ProviderRunnerWrapper as x, type SlashCommand as y, type SlashCommandRegistryView as z };
+export { type AfterIterationHook as A, type BeforeIterationHook as B, DEFAULT_MAX_ITERATIONS as D, ExtensionRegistry as E, type HookRunEnv as H, type OnErrorHook as O, type PreToolUseResult as P, type RunResult as R, type SystemPromptContributor as S, type ToolBatchResult as T, type UserInputPayload as U, type AfterRunHook as a, type AfterToolExecutionHook as b, type AgentExtension as c, type AgentInit as d, type AgentInput as e, type AgentPipelines as f, type BeforeRunHook as g, type BeforeToolExecutionHook as h, HookRunner as i, type HookRunnerOptions as j, type PromptResult as k, type ProviderFactory as l, ProviderRegistry as m, type ProviderRunnerFn as n, type ProviderRunnerWrapper as o, type ToolCallPipelinePayload as p, type ToolExecutorLike as q, type ToolExecutorOptions as r, type ToolExecutorStrategy as s, ToolRegistry as t, type ToolWrapper as u, createDefaultPipelines as v };