@wrongstack/core 0.1.8 → 0.1.10

package/dist/session-reader-9sOTgmeC.d.ts

@@ -1,1087 +0,0 @@
-import { c as ContentBlock, a0 as Context, v as Tool, B as ToolResultBlock, F as ToolUseBlock, h as Provider, R as Request, k as Response, T as TextBlock, a5 as RunOptions, W as WrongStackError, J as JSONSchema, U as Usage, n as SessionEvent, o as SessionMetadata, p as SessionStore } from './provider-txgB0Oq9.js';
-import { t as PermissionPolicy, S as SecretScrubber, y as Renderer, O as EventBus, W as WireFamily, x as ProviderConfig, N as Container, a2 as Pipeline, a5 as ReadonlyPipeline, b as Config, g as Logger, Q as EventName, U as Listener } from './mode-Pjt5vMS6.js';
-
-type AttachmentKind = 'text' | 'image' | 'file';
-interface AttachmentMeta {
-    /** Display label for the placeholder e.g. "123 lines" or "PNG 412 KB". */
-    label?: string;
-    /** Original filename if known. */
-    filename?: string;
-    /** MIME type if known. Required for images. */
-    mediaType?: string;
-}
-interface Attachment {
-    readonly id: string;
-    readonly kind: AttachmentKind;
-    readonly meta: AttachmentMeta;
-    /** In-memory payload. For images this is base64; for text/file it's the raw text. */
-    readonly data?: string;
-    /** Disk location if spooled. Mutually exclusive with `data` for large payloads. */
-    readonly path?: string;
-    readonly bytes: number;
-    readonly createdAt: string;
-}
-interface AttachmentRef {
-    readonly id: string;
-    readonly kind: AttachmentKind;
-    /** Index for display, e.g. `#1`. Stable for the lifetime of a session. */
-    readonly seq: number;
-    readonly meta: AttachmentMeta;
-}
-interface AddAttachmentInput {
-    kind: AttachmentKind;
-    data: string;
-    meta?: AttachmentMeta;
-}
-/**
- * Session-scoped store for content that is too big to inline in display
- * but must be sent to the model as a real ContentBlock. The input layer
- * (CLI/TUI) puts pasted text, dropped files, and pasted images here, gets
- * back a stable AttachmentRef, and shows a placeholder like `[pasted #1]`
- * to the user. At submit time, `expand()` swaps placeholders for the real
- * payload as ContentBlock[].
- */
-interface AttachmentStore {
-    add(input: AddAttachmentInput): Promise<AttachmentRef>;
-    get(id: string): Promise<Attachment | undefined>;
-    list(): AttachmentRef[];
-    /**
-     * Replace all known placeholder tokens in `text` (e.g. `[pasted #1]`,
-     * `[image #2]`) with the corresponding ContentBlock(s) and return the
-     * mixed array. Unknown placeholders are left as plain text.
-     */
-    expand(text: string): Promise<ContentBlock[]>;
-    clear(): Promise<void>;
-}
-
-/**
- * SecretVault encrypts secrets-at-rest in config files. The wire format is
- * `enc:v1:<base64-iv>:<base64-tag>:<base64-ciphertext>`. Plaintext strings
- * (those that do not match this prefix) are passed through unchanged so that
- * existing configs and env-var-derived values keep working.
- *
- * The vault is intentionally NOT designed to defeat a determined local
- * attacker who can read both the config file and the key file — that level
- * of secrecy needs the OS keychain. The goal is to keep keys from being
- * visible in screen shares, accidental log captures, and `cat config.json`
- * over someone's shoulder.
- */
-interface SecretVault {
-    encrypt(plaintext: string): string;
-    decrypt(value: string): string;
-    isEncrypted(value: string): boolean;
-}
-declare const ENCRYPTED_PREFIX = "enc:v1:";
-
-/**
- * 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 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.
-     */
-    run(args: string, ctx: Context): Promise<{
-        exit?: boolean;
-        message?: string;
-    } | void>;
-}
-
-declare class ToolRegistry {
-    private readonly tools;
-    register(tool: Tool, owner?: string): void;
-    /**
-     * Attempt to register a tool. Returns true if successful, false if a tool
-     * with the same name is already registered. Useful in multi-agent or plugin
-     * scenarios where duplicate registration may be intentional.
-     */
-    tryRegister(tool: Tool, owner?: string): boolean;
-    /**
-     * Register a tool as a default. If the tool name is already registered,
-     * this is a no-op — the existing registration (from core or another
-     * plugin) takes precedence. Use `override` to intentionally replace.
-     */
-    registerDefault(tool: Tool, owner?: string): void;
-    unregister(name: string): boolean;
-    /**
-     * Override an existing tool. Throws if the tool is not already registered.
-     * Plugins use this to replace built-in tools with custom implementations.
-     */
-    override(name: string, tool: Tool, owner?: string): void;
-    get(name: string): Tool | undefined;
-    ownerOf(name: string): string | undefined;
-    list(): Tool[];
-    listWithOwner(): {
-        tool: Tool;
-        owner: string;
-    }[];
-    clear(): void;
-}
-
-/**
- * Observability primitives — metrics, tracing, health. Implementations live in
- * `defaults/observability/`. Consumers depend on these interfaces so a noop
- * sink can be swapped for an OTel/Prometheus adapter without touching call
- * sites.
- */
-type MetricLabels = Record<string, string>;
-interface MetricsSink {
-    /** Monotonically-increasing counter (e.g. total tool calls). */
-    counter(name: string, value?: number, labels?: MetricLabels): void;
-    /** Latency / size distribution (e.g. tool duration). */
-    histogram(name: string, value: number, labels?: MetricLabels): void;
-    /** Current value (e.g. active subagents, pending tasks). */
-    gauge(name: string, value: number, labels?: MetricLabels): void;
-    /** Point-in-time export — for /metrics scrape, debug dumps, tests. */
-    snapshot(): MetricsSnapshot;
-    /** Reset all metrics. Useful for tests; production code should rarely use. */
-    reset(): void;
-}
-interface MetricSeries {
-    name: string;
-    type: 'counter' | 'histogram' | 'gauge';
-    labels: MetricLabels;
-    /** Counter/gauge: latest value. Histogram: count, sum, min, max, p50, p95, p99. */
-    values: Record<string, number>;
-}
-interface MetricsSnapshot {
-    timestamp: number;
-    series: MetricSeries[];
-}
-type HealthStatus = 'healthy' | 'degraded' | 'unhealthy';
-interface HealthCheckResult {
-    status: HealthStatus;
-    detail?: string;
-    /** Optional structured data (e.g. latency, version) for dashboards. */
-    data?: Record<string, unknown>;
-}
-interface HealthCheck {
-    readonly name: string;
-    check(): Promise<HealthCheckResult>;
-}
-interface AggregateHealth {
-    status: HealthStatus;
-    timestamp: number;
-    checks: (HealthCheckResult & {
-        name: string;
-    })[];
-}
-interface HealthRegistry {
-    register(check: HealthCheck): void;
-    unregister(name: string): void;
-    run(): Promise<AggregateHealth>;
-}
-/**
- * Minimal OTel-compatible Span. The default implementation is a noop; wire an
- * OpenTelemetry adapter in production to get distributed tracing for free.
- */
-interface Span {
-    setAttribute(key: string, value: string | number | boolean): void;
-    recordError(err: Error): void;
-    end(): void;
-}
-interface Tracer {
-    startSpan(name: string, attrs?: Record<string, string | number | boolean>): Span;
-}
-
-/**
- * Input for a single tool execution, scoped to a single iteration's budget.
- */
-interface ToolExecution {
-    toolUse: ToolUseBlock;
-    result: ToolResultBlock;
-    /** True if the tool was not found in the registry. */
-    unknownTool?: boolean;
-    /** True if the tool execution threw an exception. */
-    threw?: boolean;
-}
-/**
- * Output from a single tool execution.
- */
-interface ToolExecutionOutput {
-    result: ToolResultBlock | ToolConfirmPendingResult;
-    tool?: Tool;
-    durationMs: number;
-}
-/**
- * Result of running a batch of tools for a single agent iteration.
- */
-interface ToolBatchResult {
-    outputs: ToolExecutionOutput[];
-    remainingBudget: number;
-}
-type ConfirmAwaiter = (tool: Tool, input: unknown, toolUseId: string, suggestedPattern: string) => Promise<'yes' | 'no' | 'always' | 'deny'>;
-interface ToolExecutorOptions {
-    permissionPolicy: PermissionPolicy;
-    secretScrubber: SecretScrubber;
-    renderer?: Renderer | undefined;
-    /**
-     * Optional event bus. When provided, the executor emits `tool.started`
-     * before invoking each tool's `execute()`. Closes the observability gap
-     * between "model decided to call tool" and "tool finished".
-     */
-    events?: EventBus | undefined;
-    /**
-     * Optional tracer. When provided, every tool execution opens a
-     * `tool.<name>` span with attributes for tool name, permission decision,
-     * input size, output size, and outcome. Spans are no-op by default.
-     */
-    tracer?: Tracer | undefined;
-    /**
-     * Async callback invoked when a tool needs user confirmation.
-     * When omitted and confirmation is required, the executor returns a
-     * failure result immediately (TUI path). When provided (CLI path),
-     * the callback handles the interactive prompt and returns a decision.
-     */
-    confirmAwaiter?: ConfirmAwaiter | undefined;
-    iterationTimeoutMs?: number;
-    perIterationOutputCapBytes?: number;
-}
-interface ToolExecutorInit {
-    registry: ToolRegistry;
-    options: ToolExecutorOptions;
-}
-/**
- * Result returned by executeBatch when a tool needs confirmation and
- * no confirmAwaiter is available. The TUI catches this and surfaces a
- * confirmation dialog; once resolved the tool is re-executed.
- * The string tag identifies it as a "pending confirm" result so callers
- * can distinguish it from an error without inspecting content strings.
- */
-interface ToolConfirmPendingResult {
-    type: 'tool_confirm_pending';
-    toolUseId: string;
-    toolName: string;
-    input: unknown;
-    suggestedPattern: string;
-}
-type ToolExecutorStrategy = 'parallel' | 'sequential' | 'smart';
-
-/**
- * Factory for constructing a Provider instance. The `family` field
- * declares the wire protocol so callers can route without inspecting
- * 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 {
-    /**
-     * Unique identifier used as the registry key. When registered via
-     * a plugin, this becomes `cfg.type` in `ProviderRegistry.create(cfg)`.
-     */
-    type: string;
-    /**
-     * Declares the wire protocol family so consumers can route based on
-     * capability (e.g. which tool-format converter to use) without
-     * instantiating the provider.
-     */
-    family: WireFamily;
-    create(cfg: ProviderConfig): Provider;
-}
-declare class ProviderRegistry {
-    private readonly factories;
-    /**
-     * Register a provider factory. If a factory with the same type already
-     * 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;
-    /**
-     * 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;
-    has(type: string): boolean;
-    create(cfg: ProviderConfig): Provider;
-    list(): string[];
-}
-
-/** Default iteration cap. Use 0 or Infinity via config to disable. */
-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;
-}
-interface AgentInit {
-    container: Container;
-    tools: ToolRegistry;
-    providers: ProviderRegistry;
-    events: EventBus;
-    pipelines: AgentPipelines;
-    context: Context;
-    maxIterations?: number;
-    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;
-    /**
-     * 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;
-    /**
-     * 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;
-}
-interface AgentPipelines {
-    request: Pipeline<Request>;
-    response: Pipeline<Response>;
-    toolCall: Pipeline<ToolCallPipelinePayload>;
-    userInput: Pipeline<UserInputPayload>;
-    assistantOutput: Pipeline<TextBlock>;
-    contextWindow: Pipeline<Context>;
-}
-interface UserInputPayload {
-    content: ContentBlock[];
-    /** Concatenation of text blocks — convenience for middleware that only cares about text. */
-    text: string;
-    ctx: Context;
-}
-type AgentInput = string | ContentBlock[];
-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 iterationTimeoutMs;
-    private readonly executionStrategy;
-    private readonly perIterationOutputCapBytes;
-    private readonly plugins;
-    private readonly toolExecutor;
-    private readonly autoExtendLimit;
-    private readonly tracer;
-    constructor(init: AgentInit);
-    private get logger();
-    private get retry();
-    private get errorHandler();
-    private get permission();
-    private get scrubber();
-    private get renderer();
-    register(tool: Tool): void;
-    use(plugin: Plugin, api: PluginAPI): Promise<void>;
-    run(userInput: AgentInput, opts?: RunOptions): Promise<RunResult>;
-    private runInner;
-    /**
-     * Normalize user input and emit through userInput pipeline + session append.
-     */
-    private normalizeAndEmitUserInput;
-    /**
-     * 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;
-    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;
-}
-
-interface ToolRegistryView {
-    register(t: Tool): void;
-    unregister(name: string): 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[];
-}
-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;
-    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;
-}
-/**
- * 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[];
-    setup(api: PluginAPI): void | Promise<void>;
-    teardown?(api: PluginAPI): void | Promise<void>;
-}
-
-type BridgeMessageType = 'task' | 'result' | 'progress' | 'error' | 'heartbeat' | 'stop' | 'delegate';
-interface BridgeMessage<T = unknown> {
-    id: string;
-    type: BridgeMessageType;
-    from: string;
-    to?: string;
-    payload: T;
-    timestamp: number;
-    priority?: 'low' | 'normal' | 'high' | 'critical';
-}
-interface AgentBridgeConfig {
-    agentId: string;
-    coordinatorId: string;
-    timeoutMs?: number;
-    bufferSize?: number;
-}
-interface AgentBridge {
-    readonly agentId: string;
-    readonly coordinatorId: string;
-    send(msg: BridgeMessage): Promise<void>;
-    broadcast(msg: BridgeMessage): Promise<void>;
-    subscribe(handler: (msg: BridgeMessage) => void | Promise<void>): () => void;
-    request<T>(msg: BridgeMessage, timeoutMs?: number): Promise<BridgeMessage<T>>;
-    stop(): Promise<void>;
-}
-interface BridgeTransport {
-    send(msg: BridgeMessage, to: string): Promise<void>;
-    subscribe(agentId: string, handler: (msg: BridgeMessage) => void | Promise<void>): () => void;
-    close(agentId: string): Promise<void>;
-}
-
-type BudgetKind = 'tool_calls' | 'iterations' | 'tokens' | 'timeout' | 'cost';
-declare class BudgetExceededError extends Error {
-    readonly kind: BudgetKind;
-    readonly limit: number;
-    readonly observed: number;
-    constructor(kind: BudgetKind, limit: number, observed: number);
-}
-interface BudgetLimits {
-    maxIterations?: number;
-    maxToolCalls?: number;
-    maxTokens?: number;
-    /** Estimated USD cost ceiling. */
-    maxCostUsd?: number;
-    /** Wall-clock timeout from start() to checkTimeout(). */
-    timeoutMs?: number;
-}
-interface BudgetUsage {
-    iterations: number;
-    toolCalls: number;
-    tokens: {
-        input: number;
-        output: number;
-        total: number;
-    };
-    costUsd: number;
-    elapsedMs: number;
-}
-/**
- * Per-subagent budget enforcement. Each subagent gets its own instance so a
- * runaway agent can't drain the cost ceiling of its siblings. All record/check
- * methods are O(1) and safe to call from hot paths.
- *
- * Behavior: `record*` methods throw `BudgetExceededError` synchronously the
- * moment a limit is crossed. The caller (runner/coordinator) catches this and
- * marks the task as 'failed' with the budget kind, so the operator can see
- * exactly which ceiling tripped.
- */
-declare class SubagentBudget {
-    readonly limits: Readonly<BudgetLimits>;
-    private iterations;
-    private toolCalls;
-    private tokenInput;
-    private tokenOutput;
-    private costUsd;
-    private startTime;
-    constructor(limits?: BudgetLimits);
-    start(): void;
-    recordIteration(): void;
-    recordToolCall(): void;
-    recordUsage(usage: Usage, costUsd?: number): void;
-    /**
-     * Throws if the wall-clock budget is exhausted. Call this from the iteration
-     * loop so a hung tool can't keep a subagent running past its deadline.
-     */
-    checkTimeout(): void;
-    /** Returns true if a timeout has occurred without throwing. Useful for races. */
-    isTimedOut(): boolean;
-    usage(): BudgetUsage;
-}
-
-interface SubagentConfig {
-    id?: string;
-    name: string;
-    role?: string;
-    prompt?: string;
-    maxIterations?: number;
-    maxToolCalls?: number;
-    maxTokens?: number;
-    maxCostUsd?: number;
-    timeoutMs?: number;
-    tools?: string[];
-    model?: string;
-    priority?: number;
-    /**
-     * Provider registry id (e.g. `'anthropic'`, `'openai'`, `'google'`).
-     * Allows a director to mix providers across siblings — one subagent on
-     * Sonnet, another on GPT-5, another on Haiku. Falls back to the
-     * factory's default provider when omitted, which is the legacy
-     * single-provider behavior.
-     */
-    provider?: string;
-    /**
-     * Per-subagent session JSONL path. When omitted the orchestrator-
-     * supplied factory derives a path under `<sessionRoot>/<runId>/`.
-     * Override to redirect the transcript elsewhere (long-term storage,
-     * a different filesystem, etc.).
-     */
-    sessionPath?: string;
-    /**
-     * Additional text appended to the role's base system prompt. Does not
-     * replace it. Useful for last-mile guidance like "you may only call
-     * read tools, never write" or "respond in JSON only".
-     */
-    systemPromptOverride?: string;
-    /**
-     * Routing for streaming output. `'director'` (default) forwards
-     * text/tool events to the parent's FleetBus so the director can read
-     * the subagent's stream. `'silent'` keeps everything subagent-local;
-     * the director only sees the final task result. `'user'` forwards
-     * direct to the user-facing renderer (gate this behind an explicit
-     * config flag — it can confuse the chat surface).
-     */
-    textStream?: 'director' | 'silent' | 'user';
-    toolStream?: 'director' | 'silent' | 'user';
-}
-interface TaskResult<T = unknown> {
-    subagentId: string;
-    taskId: string;
-    status: 'success' | 'failed' | 'timeout' | 'stopped';
-    result?: T;
-    error?: string;
-    iterations: number;
-    toolCalls: number;
-    durationMs: number;
-}
-interface TaskSpec {
-    id: string;
-    description: string;
-    subagentId?: string;
-    priority?: number;
-    maxToolCalls?: number;
-    timeoutMs?: number;
-    context?: Record<string, unknown>;
-}
-interface DoneCondition {
-    type: 'iterations' | 'tool_calls' | 'output_match' | 'custom' | 'all_tasks_done';
-    maxIterations?: number;
-    maxToolCalls?: number;
-    pattern?: string;
-    predicate?: string;
-}
-interface MultiAgentConfig {
-    coordinatorId: string;
-    leaderSystemPrompt?: string;
-    subagents?: SubagentConfig[];
-    maxConcurrent?: number;
-    doneCondition: DoneCondition;
-    timeoutMs?: number;
-    /**
-     * Optional default budget applied to every spawned subagent. Per-subagent
-     * fields in `SubagentConfig` override these. Coordinator enforces them by
-     * constructing a `SubagentBudget` per spawn — see `SubagentRunContext.budget`.
-     */
-    defaultBudget?: {
-        maxIterations?: number;
-        maxToolCalls?: number;
-        maxTokens?: number;
-        maxCostUsd?: number;
-        timeoutMs?: number;
-    };
-}
-interface SpawnResult {
-    subagentId: string;
-    agentId: string;
-}
-interface TaskDelegation {
-    task: TaskSpec;
-    subagentId: string;
-}
-interface CoordinatorEvents {
-    'task.assigned': {
-        task: TaskSpec;
-        subagentId: string;
-    };
-    'task.completed': {
-        task: TaskSpec;
-        result: TaskResult;
-    };
-    'subagent.started': {
-        subagent: SubagentConfig;
-    };
-    'subagent.stopped': {
-        subagentId: string;
-        reason: string;
-    };
-    'done': {
-        results: TaskResult[];
-        totalIterations: number;
-    };
-}
-interface MultiAgentCoordinator {
-    readonly coordinatorId: string;
-    readonly config: MultiAgentConfig;
-    spawn(subagent: SubagentConfig): Promise<SpawnResult>;
-    assign(task: TaskSpec): Promise<void>;
-    delegate(to: string, msg: BridgeMessage): Promise<void>;
-    stop(subagentId: string): Promise<void>;
-    stopAll(): Promise<void>;
-    getStatus(): CoordinatorStatus;
-}
-/**
- * Caller-supplied runner that actually executes a task. The coordinator
- * provides isolated state (own budget, own AbortSignal, own bridge handle)
- * and enforces concurrency limits — the runner just runs the task and reports
- * the outcome. This is the injection seam that decouples the coordinator
- * from `Agent` so it can be tested with mocks and reused for non-Agent
- * subagents (workers, MCP-driven subagents, etc.).
- */
-type SubagentRunner = (task: TaskSpec, ctx: SubagentRunContext) => Promise<SubagentRunOutcome>;
-interface SubagentRunContext {
-    subagentId: string;
-    config: SubagentConfig;
-    budget: SubagentBudget;
-    signal: AbortSignal;
-    /** Null until `setSubagentBridge` is called for this subagent. */
-    bridge: AgentBridge | null;
-}
-interface SubagentRunOutcome {
-    result?: unknown;
-    iterations: number;
-    toolCalls: number;
-}
-interface CoordinatorStatus {
-    coordinatorId: string;
-    subagents: {
-        id: string;
-        name: string;
-        status: 'running' | 'idle' | 'stopped' | 'error';
-        currentTask?: string;
-    }[];
-    pendingTasks: number;
-    completedTasks: number;
-    totalIterations: number;
-    done: boolean;
-}
-interface SubagentContext {
-    subagentId: string;
-    tasks: TaskSpec[];
-    /**
-     * Two-phase initialization: `spawn()` creates the subagent before the
-     * bridge is wired (`setSubagentBridge()`), so `parentBridge` is nullable
-     * by design. Readers must `hasParentBridge()`-guard or null-check before
-     * use; the prior `null as unknown as AgentBridge` cast was a type lie
-     * that hid this from the compiler.
-     */
-    parentBridge: AgentBridge | null;
-    doneCondition: DoneCondition;
-    maxConcurrent: number;
-}
-
-type SpecStatus = 'draft' | 'review' | 'approved' | 'implemented' | 'deprecated';
-type SpecSectionType = 'overview' | 'requirements' | 'architecture' | 'api' | 'data' | 'security' | 'acceptance';
-interface SpecSection {
-    type: SpecSectionType;
-    title: string;
-    content: string;
-    level: number;
-    children?: SpecSection[];
-}
-interface SpecRequirement {
-    id: string;
-    type: 'functional' | 'non-functional' | 'security' | 'performance' | 'ux';
-    priority: 'critical' | 'high' | 'medium' | 'low';
-    description: string;
-    acceptanceCriteria: string[];
-    blockedBy?: string[];
-    implements?: string[];
-}
-interface SpecApiEndpoint {
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-    path: string;
-    description: string;
-    request?: Record<string, unknown>;
-    response?: Record<string, unknown>;
-    auth?: boolean;
-}
-interface Specification {
-    id: string;
-    title: string;
-    version: string;
-    status: SpecStatus;
-    overview: string;
-    sections: SpecSection[];
-    requirements: SpecRequirement[];
-    apiEndpoints?: SpecApiEndpoint[];
-    dependencies?: string[];
-    createdAt: number;
-    updatedAt: number;
-    metadata?: Record<string, unknown>;
-}
-interface SpecAnalysis {
-    specId: string;
-    completeness: number;
-    coverage: {
-        requirements: number;
-        apiEndpoints: number;
-        edgeCases: number;
-        errorHandling: number;
-    };
-    gaps: string[];
-    risks: {
-        requirement: string;
-        risk: string;
-        severity: 'high' | 'medium' | 'low';
-    }[];
-    suggestions: string[];
-}
-interface SpecValidationResult {
-    valid: boolean;
-    errors: {
-        path: string;
-        message: string;
-    }[];
-    warnings: {
-        path: string;
-        message: string;
-    }[];
-}
-interface SpecTemplate {
-    id: string;
-    name: string;
-    description: string;
-    sections: Omit<SpecSection, 'content'>[];
-    defaultRequirements: Omit<SpecRequirement, 'id' | 'description'>[];
-}
-declare const DEFAULT_SPEC_TEMPLATE: SpecTemplate;
-
-type TaskStatus = 'pending' | 'in_progress' | 'blocked' | 'failed' | 'review' | 'completed';
-type TaskPriority = 'critical' | 'high' | 'medium' | 'low';
-type TaskType = 'feature' | 'bugfix' | 'refactor' | 'docs' | 'test' | 'chore';
-interface TaskNode {
-    id: string;
-    title: string;
-    description: string;
-    type: TaskType;
-    priority: TaskPriority;
-    status: TaskStatus;
-    assignee?: string;
-    estimateHours?: number;
-    actualHours?: number;
-    tags?: string[];
-    specRequirementId?: string;
-    parentId?: string;
-    children?: string[];
-    createdAt: number;
-    updatedAt: number;
-    completedAt?: number;
-    metadata?: Record<string, unknown>;
-}
-interface TaskEdge {
-    id: string;
-    from: string;
-    to: string;
-    type: 'blocks' | 'depends_on' | 'relates_to' | 'implements';
-    weight?: number;
-}
-interface TaskGraph {
-    id: string;
-    specId: string;
-    title: string;
-    nodes: Map<string, TaskNode>;
-    edges: TaskEdge[];
-    rootNodes: string[];
-    createdAt: number;
-    updatedAt: number;
-}
-interface TaskDependency {
-    taskId: string;
-    blockedBy: string[];
-    blocking: string[];
-}
-interface TaskAssignment {
-    taskId: string;
-    assignee: string;
-    assignedAt: number;
-}
-interface TaskProgress {
-    total: number;
-    pending: number;
-    inProgress: number;
-    blocked: number;
-    failed: number;
-    review: number;
-    completed: number;
-    percentComplete: number;
-    estimatedHours: number;
-    actualHours: number;
-}
-interface TaskFilter {
-    status?: TaskStatus[];
-    priority?: TaskPriority[];
-    type?: TaskType[];
-    assignee?: string[];
-    tags?: string[];
-    specRequirementId?: string;
-}
-interface TaskSort {
-    field: 'priority' | 'createdAt' | 'updatedAt' | 'status';
-    direction: 'asc' | 'desc';
-}
-interface CriticalPathResult {
-    taskIds: string[];
-    totalEstimateHours: number;
-    bottleneckTasks: string[];
-}
-declare function computeTaskProgress(graph: TaskGraph): TaskProgress;
-declare function findCriticalPath(graph: TaskGraph): CriticalPathResult;
-declare function topologicalSort(graph: TaskGraph): string[];
-
-/**
- * L2-A: SessionReader — query, replay, search, export over a `SessionStore`.
- *
- * Keeps a clean read-only interface (no `append`, no `delete`) so analytics
- * code can be wired against a store without granting it the writer surface.
- */
-type SessionEventType = SessionEvent['type'];
-interface SessionQuery {
-    /** Filter by start timestamp (ISO). Sessions started before this are excluded. */
-    since?: string;
-    /** Filter by start timestamp (ISO). Sessions started after this are excluded. */
-    until?: string;
-    /** Substring match against title (case-insensitive). */
-    titleContains?: string;
-    /** Filter by provider id. */
-    provider?: string;
-    /** Filter by model id. */
-    model?: string;
-    /** Minimum total tokens (input+output) to keep. */
-    minTokens?: number;
-    /** Limit result count. Defaults to no limit. */
-    limit?: number;
-}
-interface SessionSearchHit {
-    sessionId: string;
-    eventIndex: number;
-    ts: string;
-    type: SessionEventType;
-    /** Short snippet of the matched text — null for events without text content. */
-    snippet: string | null;
-}
-interface SessionSearchQuery {
-    /** Plain text or regex pattern. */
-    query: string;
-    /** Treat `query` as a regex. Defaults to false (literal substring). */
-    regex?: boolean;
-    /** Case-insensitive match. Defaults to true. */
-    caseInsensitive?: boolean;
-    /** Limit only to these event types. Defaults to all event types. */
-    types?: SessionEventType[];
-    /** Limit hit count. Defaults to 100. */
-    limit?: number;
-}
-interface SessionExportOptions {
-    /** "markdown" produces a human-readable chat log; "json" passes through raw events. */
-    format: 'markdown' | 'json' | 'text';
-    /** Include tool_use/tool_result blocks. Defaults to true. */
-    includeTools?: boolean;
-    /** Include system/diagnostic events (errors, compaction). Defaults to true. */
-    includeDiagnostics?: boolean;
-}
-interface SessionSummaryLite {
-    id: string;
-    title: string;
-    startedAt: string;
-    endedAt?: string;
-    provider: string;
-    model: string;
-    tokenTotal: number;
-}
-interface SessionReader {
-    /** List sessions matching the query. Uses the underlying store's summary cache. */
-    query(q?: SessionQuery): Promise<SessionSummaryLite[]>;
-    /** Yield events for `sessionId` in chronological order. */
-    replay(sessionId: string): AsyncIterable<SessionEvent>;
-    /** Full-text/regex search across one or all sessions. */
-    search(q: SessionSearchQuery, sessionId?: string): Promise<SessionSearchHit[]>;
-    /** Render a session for human or downstream-tool consumption. */
-    export(sessionId: string, opts: SessionExportOptions): Promise<string>;
-    /** Read the metadata header without loading the full event stream. */
-    metadata(sessionId: string): Promise<SessionMetadata>;
-}
-interface DefaultSessionReaderOptions {
-    store: SessionStore;
-}
-
-export { type SpecSection as $, type AddAttachmentInput as A, type BridgeMessage as B, type ConfirmAwaiter as C, DEFAULT_SPEC_TEMPLATE as D, ENCRYPTED_PREFIX as E, type PluginDependency as F, type PluginPipelines as G, type HealthCheck as H, type ProviderFactory as I, type ProviderRegistryView as J, type SessionEventType as K, type SessionExportOptions as L, type MCPRegistryView as M, type SessionQuery as N, type SessionReader as O, type Plugin as P, type SessionSearchHit as Q, type SessionSearchQuery as R, type SecretVault as S, type SessionSummaryLite as T, type SlashCommand as U, type SlashCommandRegistryView as V, type Span as W, type SpawnResult as X, type SpecAnalysis as Y, type SpecApiEndpoint as Z, type SpecRequirement as _, type AgentBridge as a, type SpecSectionType as a0, type SpecStatus as a1, type SpecTemplate as a2, type SpecValidationResult as a3, type Specification as a4, type SubagentConfig as a5, type SubagentContext as a6, type SubagentRunContext as a7, type SubagentRunOutcome as a8, type SubagentRunner as a9, ToolRegistry as aA, ProviderRegistry as aB, Agent as aC, type AgentInit as aD, type AgentInput as aE, type AgentPipelines as aF, BudgetExceededError as aG, type BudgetKind as aH, type BudgetLimits as aI, type BudgetUsage as aJ, DEFAULT_MAX_ITERATIONS as aK, type ProviderFactory$1 as aL, type RunResult as aM, SubagentBudget as aN, type UserInputPayload as aO, createDefaultPipelines as aP, type TaskAssignment as aa, type TaskDelegation as ab, type TaskDependency as ac, type TaskEdge as ad, type TaskFilter as ae, type TaskGraph as af, type TaskNode as ag, type TaskPriority as ah, type TaskProgress as ai, type TaskResult as aj, type TaskSort as ak, type TaskSpec as al, type TaskStatus as am, type TaskType as an, type ToolBatchResult as ao, type ToolConfirmPendingResult as ap, type ToolExecution as aq, type ToolExecutionOutput as ar, type ToolExecutorInit as as, type ToolExecutorOptions as at, type ToolExecutorStrategy as au, type ToolRegistryView as av, type Tracer as aw, computeTaskProgress as ax, findCriticalPath as ay, topologicalSort as az, type AgentBridgeConfig as b, type AggregateHealth as c, type Attachment as d, type AttachmentKind as e, type AttachmentMeta as f, type AttachmentRef as g, type AttachmentStore as h, type BridgeMessageType as i, type BridgeTransport as j, type CoordinatorEvents as k, type CoordinatorStatus as l, type CriticalPathResult as m, type DefaultSessionReaderOptions as n, type DoneCondition as o, type HealthCheckResult as p, type HealthRegistry as q, type HealthStatus as r, type MetricLabels as s, type MetricSeries as t, type MetricsSink as u, type MetricsSnapshot as v, type MultiAgentConfig as w, type MultiAgentCoordinator as x, type PluginAPI as y, type PluginCapabilities as z };