@wrongstack/core 0.1.9 → 0.1.10

package/dist/defaults/index.d.ts

@@ -1,2309 +1,34 @@
-import { g as Logger, f as LogLevel, P as PathResolver, r as ModelsRegistry, O as EventBus, z as ResolvedModel, j as MemoryStore, i as MemoryScope, S as SecretScrubber, t as PermissionPolicy, I as InputReader, s as PermissionDecision, B as RetryPolicy, E as ErrorHandler, a as Compactor, R as RecoveryDecision, H as SkillLoader, J as SkillManifest, G as SkillEntry, b as Config, c as ConfigLoader, d as ConfigStore, C as CompactReport, a0 as MiddlewareHandler, p as ModelsDevPayload, A as ResolvedProvider, W as WireFamily, n as ModeStore, l as ModeConfig, k as Mode, M as MCPServerConfig } from '../mode-Pjt5vMS6.js';
-import { u as TokenCounter, U as Usage, C as CacheStats, p as SessionStore, o as SessionMetadata, r as SessionWriter, l as ResumedSession, S as SessionData, q as SessionSummary, c as ContentBlock, v as Tool, a0 as Context, i as ProviderError, h as Provider, M as Message, F as ToolUseBlock, B as ToolResultBlock, n as SessionEvent } from '../provider-txgB0Oq9.js';
-import { h as AttachmentStore, A as AddAttachmentInput, g as AttachmentRef, d as Attachment, S as SecretVault, x as MultiAgentCoordinator, w as MultiAgentConfig, a9 as SubagentRunner, a5 as SubagentConfig, X as SpawnResult, al as TaskSpec, B as BridgeMessage, a as AgentBridge, l as CoordinatorStatus, aj as TaskResult, aC as Agent, aE as AgentInput, j as BridgeTransport, b as AgentBridgeConfig, o as DoneCondition, aM as RunResult, a4 as Specification, Y as SpecAnalysis, a3 as SpecValidationResult, af as TaskGraph, ag as TaskNode, ae as TaskFilter, ak as TaskSort, ai as TaskProgress, an as TaskType, ah as TaskPriority, at as ToolExecutorOptions, au as ToolExecutorStrategy, ao as ToolBatchResult, O as SessionReader, n as DefaultSessionReaderOptions, N as SessionQuery, T as SessionSummaryLite, R as SessionSearchQuery, Q as SessionSearchHit, L as SessionExportOptions, u as MetricsSink, s as MetricLabels, v as MetricsSnapshot, q as HealthRegistry, H as HealthCheck, c as AggregateHealth, aw as Tracer, W as Span } from '../session-reader-9sOTgmeC.js';
-export { aG as BudgetExceededError, aH as BudgetKind, aI as BudgetLimits, aJ as BudgetUsage, aN as SubagentBudget } from '../session-reader-9sOTgmeC.js';
-import { a as WstackPaths } from '../wstack-paths-BGu2INTm.js';
-import { EventEmitter } from 'node:events';
-
-interface DefaultLoggerOptions {
-    level?: LogLevel;
-    file?: string;
-    pretty?: boolean;
-    bindings?: Record<string, unknown>;
-}
-declare class DefaultLogger implements Logger {
-    level: LogLevel;
-    private readonly file?;
-    private readonly bindings;
-    private readonly pretty;
-    constructor(opts?: DefaultLoggerOptions);
-    error(msg: string, ctx?: unknown): void;
-    warn(msg: string, ctx?: unknown): void;
-    info(msg: string, ctx?: unknown): void;
-    debug(msg: string, ctx?: unknown): void;
-    trace(msg: string, ctx?: unknown): void;
-    child(bindings: Record<string, unknown>): Logger;
-    private log;
-}
-
-declare class DefaultPathResolver implements PathResolver {
-    readonly projectRoot: string;
-    readonly cwd: string;
-    constructor(cwd?: string);
-    detectProjectRoot(start: string): string;
-    resolve(input: string): string;
-    isInsideRoot(absPath: string): boolean;
-    ensureInsideRoot(absPath: string): string;
-}
-
-/**
- * Token counter that derives pricing from the ModelsRegistry instead of a
- * hardcoded table. If a model is unknown to the registry (or the registry is
- * unavailable) the counter still tracks token totals but reports zero cost.
- */
-declare class DefaultTokenCounter implements TokenCounter {
-    private input;
-    private output;
-    private cacheRead;
-    private cacheWrite;
-    private costInput;
-    private costOutput;
-    private readonly registry?;
-    private readonly providerId?;
-    private readonly events?;
-    private priceCache;
-    constructor(opts?: {
-        registry?: ModelsRegistry;
-        providerId?: string;
-        events?: EventBus;
-    });
-    account(usage: Usage, model?: string): void;
-    /** Synchronous variant for code paths that have already resolved the model. */
-    accountWithModel(usage: Usage, resolved: ResolvedModel): void;
-    total(): Usage;
-    estimateCost(): {
-        input: number;
-        output: number;
-        total: number;
-        currency: 'USD';
-    };
-    cacheStats(): CacheStats;
-    /** Invalidate cached prices so the next account() call fetches fresh data. */
-    invalidateCache(): void;
-    reset(): void;
-    private applyPrice;
-}
-
-interface SessionStoreOptions {
-    dir: string;
-    /** Optional EventBus for emitting session diagnostics. */
-    events?: EventBus;
-}
-declare class DefaultSessionStore implements SessionStore {
-    private readonly dir;
-    private readonly events?;
-    constructor(opts: SessionStoreOptions);
-    create(meta: Omit<SessionMetadata, 'startedAt'>): Promise<SessionWriter>;
-    resume(id: string): Promise<ResumedSession>;
-    load(id: string): Promise<SessionData>;
-    list(limit?: number): Promise<SessionSummary[]>;
-    private summaryFor;
-    delete(id: string): Promise<void>;
-    private summarize;
-    private metaFromEvents;
-    private replay;
-}
-
-/**
- * The persisted form of a single queued user message. The TUI's
- * in-memory QueueItem has a render id; that's pure UI bookkeeping, so
- * we drop it when serializing — fresh ids are assigned on rehydrate.
- */
-interface PersistedQueueItem {
-    displayText: string;
-    blocks: ContentBlock[];
-}
-/**
- * Side-file storage for a session's pending input queue. Lives at
- * `<sessionDir>/queue.json` next to the attachment spool. Reads are
- * tolerant (missing/malformed file → empty array); writes are atomic
- * (tmp + rename) so a crash mid-write can never leave a partial file
- * the next launch would choke on.
- *
- * The contract is "snapshot replacement": every mutation hands the
- * full queue and we rewrite the file. The queue is small (rarely more
- * than a handful of messages), so this is cheaper than delta logging
- * and avoids the replay complexity.
- */
-declare class QueueStore {
-    private readonly file;
-    constructor(opts: {
-        dir: string;
-    });
-    write(items: PersistedQueueItem[]): Promise<void>;
-    read(): Promise<PersistedQueueItem[]>;
-    clear(): Promise<void>;
-}
-
-interface AttachmentStoreOptions {
-    /**
-     * Directory for spooling payloads larger than `spoolThresholdBytes`.
-     * When omitted, all payloads stay in memory.
-     */
-    spoolDir?: string;
-    spoolThresholdBytes?: number;
-}
-/**
- * In-memory attachment store with optional disk spool. Placeholder syntax
- * is `[<kind> #<seq>]` where kind is `pasted` / `image` / `file`. Unknown
- * placeholders are passed through as-is so users can write that literal
- * text without losing it.
- */
-declare class DefaultAttachmentStore implements AttachmentStore {
-    private readonly items;
-    private readonly refs;
-    private nextSeq;
-    private readonly spoolDir;
-    private readonly spoolThreshold;
-    constructor(opts?: AttachmentStoreOptions);
-    add(input: AddAttachmentInput): Promise<AttachmentRef>;
-    get(id: string): Promise<Attachment | undefined>;
-    list(): AttachmentRef[];
-    expand(text: string): Promise<ContentBlock[]>;
-    clear(): Promise<void>;
-    private toBlock;
-}
-
-interface MemoryStoreOptions {
-    paths: WstackPaths;
-}
-/**
- * Three scopes:
- *   project-agents → <project>/.wrongstack/AGENTS.md     (committed)
- *   project-memory → ~/.wrongstack/projects/<hash>/memory.md   (per-project agent notes)
- *   user-memory    → ~/.wrongstack/memory.md             (global personal memory)
- */
-declare class DefaultMemoryStore implements MemoryStore {
-    private readonly files;
-    /**
-     * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
-     * `clear` are read-modify-write against a single file; without a lock,
-     * two concurrent calls on the same scope can read the same baseline and
-     * the later write silently drops the earlier entry. We chain each
-     * mutation onto the prior promise for the same scope so they run in
-     * issue order. Different scopes still proceed in parallel.
-     */
-    private readonly writeChain;
-    constructor(opts: MemoryStoreOptions);
-    private runSerialized;
-    readAll(): Promise<string>;
-    read(scope: MemoryScope): Promise<string>;
-    remember(text: string, scope?: MemoryScope): Promise<void>;
-    forget(query: string, scope?: MemoryScope): Promise<number>;
-    private forgetUnsafe;
-    consolidate(scope: MemoryScope): Promise<void>;
-    private consolidateUnsafe;
-    clear(scope?: MemoryScope): Promise<void>;
-}
-
-declare class DefaultSecretScrubber implements SecretScrubber {
-    scrub(text: string): string;
-    private scrubOne;
-    scrubObject<T>(obj: T): T;
-}
-
-interface SecretVaultOptions {
-    /** Absolute path to the key file. Created with mode 0o600 if missing. */
-    keyFile: string;
-}
-/**
- * Default vault: AES-256-GCM with a key stored at `keyFile` (mode 0o600).
- * The key is loaded lazily on first encrypt/decrypt; if it does not exist,
- * a fresh one is generated. Decryption of plaintext values is a no-op so
- * legacy configs continue to work.
- */
-declare class DefaultSecretVault implements SecretVault {
-    private readonly keyFile;
-    private key?;
-    constructor(opts: SecretVaultOptions);
-    isEncrypted(value: string): boolean;
-    encrypt(plaintext: string): string;
-    decrypt(value: string): string;
-    private loadOrCreateKey;
-}
-/**
- * Walk a Config-shaped object and decrypt any apiKey-like fields in place,
- * returning a new object. Used by the config loader so the rest of the
- * system never has to know about the wire format.
- */
-declare function decryptConfigSecrets<T>(cfg: T, vault: SecretVault): T;
-declare function encryptConfigSecrets<T>(cfg: T, vault: SecretVault): T;
-/**
- * Re-write `~/.wrongstack/config.json` (or any path) with all secret-bearing
- * fields encrypted. Used by the `wstack auth` subcommand.
- */
-declare function rewriteConfigEncrypted(configPath: string, vault: SecretVault, patch?: Record<string, unknown>): Promise<void>;
-/**
- * Scan a config file on disk for plaintext secret-bearing fields and
- * rewrite the file with them encrypted in place. Returns a count of how
- * many fields were migrated. Idempotent — calling on a fully-encrypted
- * file is a no-op and writes nothing. Used by the CLI on every boot so
- * users who had plaintext keys before the vault landed are upgraded
- * transparently.
- */
-declare function migratePlaintextSecrets(configPath: string, vault: SecretVault): Promise<{
-    migrated: number;
-    file: string;
-}>;
-
-interface PermissionPolicyOptions {
-    trustFile: string;
-    yolo?: boolean;
-    promptDelegate?: (tool: Tool, input: unknown, suggestedPattern: string) => Promise<'yes' | 'no' | 'always' | 'deny'>;
-    inputReader?: InputReader;
-}
-declare class DefaultPermissionPolicy implements PermissionPolicy {
-    private policy;
-    private loaded;
-    private readonly trustFile;
-    private readonly yolo;
-    private readonly promptDelegate?;
-    constructor(opts: PermissionPolicyOptions);
-    reload(): Promise<void>;
-    evaluate(tool: Tool, input: unknown, _ctx: Context): Promise<PermissionDecision>;
-    trust(rule: {
-        tool: string;
-        pattern: string;
-    }): Promise<void>;
-    private subjectFor;
-    private findNamespaceEntry;
-}
-
-declare class DefaultRetryPolicy implements RetryPolicy {
-    private static readonly NETWORK_ERR_RE;
-    shouldRetry(err: Error | ProviderError, attempt: number): boolean;
-    maxAttempts(err: Error | ProviderError): number;
-    delayMs(attempt: number): number;
-}
-
-/**
- * Tiered error recovery strategies.
- * Each strategy is attempted in order until one returns a decision.
- */
-interface RecoveryStrategy {
-    /** Human-readable label for logs. */
-    label: string;
-    /** Optional compactor for context_overflow recovery. */
-    compactor?: Compactor;
-    /** Returns an explicit recovery decision, or null to fall through. */
-    attempt: (err: unknown, ctx: Context) => Promise<RecoveryDecision | null>;
-}
-declare class DefaultErrorHandler implements ErrorHandler {
-    private readonly strategies;
-    constructor(strategies?: RecoveryStrategy[]);
-    classify(err: unknown): {
-        kind: 'rate_limit' | 'overloaded' | 'server' | 'client' | 'network' | 'abort' | 'context_overflow' | 'unknown';
-        retryable: boolean;
-    };
-    recover(err: unknown, ctx: Context): Promise<RecoveryDecision | null>;
-}
-
-interface SkillLoaderOptions {
-    paths: WstackPaths;
-    bundledDir?: string;
-}
-/**
- * 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[]>;
-    readBody(name: string): Promise<string>;
-}
-
-/**
- * A single config source. Higher priority wins in merges.
- * Sources are applied in priority order (lowest first), so a source
- * with priority=10 overrides one with priority=1.
- */
-interface ConfigSource {
-    /** Unique name for debugging and error messages. */
-    name: string;
-    /** Lower numbers merge first, higher numbers override lower. Default: 50. */
-    priority?: number;
-    /**
-     * Read the raw config patch. Return an empty object if unavailable.
-     * Errors are surfaced but do not abort loading — the source is skipped.
-     */
-    read(): Promise<Partial<Config>>;
-}
-interface ConfigLoaderOptions {
-    paths: WstackPaths;
-    strict?: boolean;
-    vault?: SecretVault;
-    /** Extra sources merged after the built-in layers. */
-    sources?: ConfigSource[];
-}
-declare class DefaultConfigLoader implements ConfigLoader {
-    private readonly paths;
-    private readonly strict;
-    private readonly vault;
-    private readonly extraSources;
-    constructor(opts: ConfigLoaderOptions);
-    load(opts?: {
-        cliFlags?: Partial<Config>;
-        cwd?: string;
-    }): Promise<Config>;
-    private readJson;
-    private validateBehavior;
-    private validateIdentity;
-}
-
-/**
- * Reference implementation of `ConfigStore`. Stores a single frozen Config
- * and notifies watchers synchronously on every update. Updates use a deep
- * clone so callers can mutate their `partial` argument freely without
- * tainting state.
- *
- * For the CLI: instantiate once at boot, pass the store (not the Config)
- * to subsystems that care about runtime changes (provider switching,
- * extension reload).
- */
-declare class DefaultConfigStore implements ConfigStore {
-    private current;
-    private watchers;
-    constructor(initial: Config);
-    get(): Readonly<Config>;
-    getSection<K extends keyof Config>(key: K): Readonly<Config[K]>;
-    getExtension(pluginName: string): Readonly<Record<string, unknown>>;
-    update(partial: Partial<Config>): Readonly<Config>;
-    watch(cb: (next: Readonly<Config>, prev: Readonly<Config>) => void): () => void;
-}
-
-/**
- * L2-D: Config version migration framework. Pure functions, decoupled
- * from disk/CLI — caller passes a parsed JSON object and gets back the
- * up-to-date `Config` shape (or a structured error explaining why
- * migration failed).
- *
- * Migrations are registered as `{ from, to, migrate }` triples and run
- * sequentially. Each migration is independently testable. Adding a new
- * version means appending one migration; existing user configs are
- * upgraded in place at load time.
- */
-interface MigrationContext {
-    /**
-     * Original on-disk version of the input. Migrations may use this to
-     * decide between in-place patches and rewrites.
-     */
-    fromVersion: number;
-    /**
-     * Set when the migration writes back to disk. Callers persist the
-     * migrated config when this is true so the user doesn't see the same
-     * migration banner on every boot.
-     */
-    shouldPersist: boolean;
-}
-interface ConfigMigration {
-    /** Version of the input this migration accepts. */
-    from: number;
-    /** Version of the output it produces. */
-    to: number;
-    /** Pure transform — no I/O. */
-    migrate(input: Record<string, unknown>, ctx: MigrationContext): Record<string, unknown>;
-    /** Optional human-readable description for migration logs / banners. */
-    describe?: string;
-}
-interface MigrationResult {
-    /** Final config (still typed as `unknown`-keyed — caller validates). */
-    config: Record<string, unknown>;
-    /** Ordered list of `from→to` versions that ran. */
-    applied: string[];
-    /** True when at least one migration produced changes worth persisting. */
-    shouldPersist: boolean;
-}
-declare class ConfigMigrationError extends Error {
-    readonly fromVersion: number;
-    readonly targetVersion: number;
-    readonly missingStep: number | null;
-    constructor(opts: {
-        message: string;
-        fromVersion: number;
-        targetVersion: number;
-        missingStep: number | null;
-    });
-}
-/**
- * Run registered migrations until the input reaches `targetVersion`.
- *
- * Resolution rules:
- * 1. If `input.version === targetVersion`, no migrations run; `shouldPersist`
- *    is false.
- * 2. Otherwise walk the migration chain from `input.version` upward,
- *    picking the migration whose `from` matches the current version.
- * 3. Stop when `current.version === targetVersion`.
- * 4. If no migration matches at some point, throw `ConfigMigrationError`
- *    with the missing step recorded for diagnostics.
- *
- * Migrations may be downward (e.g. for staged rollouts), but `targetVersion`
- * must be reachable strictly via the registered chain — there's no implicit
- * "skip" or transitive resolution.
- */
-declare function runConfigMigrations(input: Record<string, unknown>, targetVersion: number, migrations: readonly ConfigMigration[]): MigrationResult;
-/**
- * Default empty migration registry. Real migrations are appended as new
- * Config versions are introduced. Example (when v2 lands):
- *
- *   export const CONFIG_MIGRATIONS: readonly ConfigMigration[] = [
- *     {
- *       from: 1, to: 2, describe: 'rename `apiKey` → `auth.apiKey`',
- *       migrate(cfg) {
- *         const apiKey = cfg.apiKey;
- *         delete cfg.apiKey;
- *         return { ...cfg, auth: { ...(cfg.auth ?? {}), apiKey } };
- *       },
- *     },
- *   ];
- */
-declare const DEFAULT_CONFIG_MIGRATIONS: readonly ConfigMigration[];
-
-interface CompactorOptions {
-    preserveK?: number;
-    eliseThreshold?: number;
-    estimator?: (text: string) => number;
-}
-declare class HybridCompactor implements Compactor {
-    private readonly preserveK;
-    private readonly eliseThreshold;
-    private readonly estimator;
-    constructor(opts?: CompactorOptions);
-    compact(ctx: Context, opts?: {
-        aggressive?: boolean;
-    }): Promise<CompactReport>;
-    private eliseOldToolResults;
-    private collapseAncientTurns;
-    private estimateMessages;
-}
-
-/**
- * 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;
-    /** Fraction of maxContext that triggers soft compaction (default 0.75). */
-    softThreshold?: number;
-    /** Fraction of maxContext that triggers hard compaction (default 0.9). */
-    hardThreshold?: number;
-    /** Max context window in tokens (used only for threshold fraction math). */
-    maxContext?: number;
-    /** How many recent (user+assistant) pairs to always preserve (default 4). */
-    preserveK?: number;
-    /** Token threshold below which tool results are not elided (default 500). */
-    eliseThreshold?: number;
-    /** System prompt for the summarizer sub-LLM. */
-    summarizerPrompt?: string;
-    /**
-     * 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;
-}
-/**
- * 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;
-    }): Promise<CompactReport>;
-    private summarizeAncientTurns;
-    private findSafeBoundary;
-    private findExchangeStart;
-    private callSummarizer;
-    private messagesToText;
-    private lightweightCompact;
-    private eliseOldToolResults;
-    private hasTextContent;
-    private estimateTokens;
-}
-
-/**
- * Result of LLM-driven message importance analysis.
- * The selector marks each message range with an importance tier,
- * and optionally provides a natural-language summary for collapsed ranges.
- */
-interface SelectorResult {
-    /**
-     * Ordered list of kept message ranges. Each entry describes a
-     * message range that should be preserved verbatim in the context.
-     */
-    kept: Array<{
-        from: number;
-        to: number;
-        importance: 'critical' | 'high' | 'medium';
-    }>;
-    /**
-     * Collapsed ranges — either replaced by the compactor or omitted.
-     * Each entry may carry a summary text produced by the LLM.
-     */
-    collapsed: Array<{
-        from: number;
-        to: number;
-        summary?: string;
-    }>;
-    /**
-     * Raw reasoning from the selector LLM (for debugging / audit).
-     */
-    reasoning: string;
-}
-/**
- * Message selector that uses an LLM to decide which message ranges
- * to keep vs collapse/summarize. The selector runs as a separate API
- * call before compaction, making it more surgical than fixed-window
- * or rules-based approaches.
- */
-interface MessageSelector {
-    /**
-     * Analyze `messages` and return a structured plan for what to keep
-     * vs collapse. May modify the messages array in-place if needed,
-     * or return a plan that the caller (Compactor) executes.
-     *
-     * @param messages  Current message history (may be modified in-place)
-     * @param maxToKeep Token budget — selector should aim to keep total
-     *                  retained message content under this threshold
-     */
-    select(messages: Message[], maxToKeep: number): Promise<SelectorResult>;
-}
-
-/**
- * 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;
-    /** Fraction of maxContext that triggers a warning (default 0.6). */
-    warnThreshold?: number;
-    /** Fraction of maxContext that triggers soft compaction (default 0.75). */
-    softThreshold?: number;
-    /** Fraction of maxContext that triggers hard compaction (default 0.9). */
-    hardThreshold?: number;
-    /** Max context window in tokens (used for threshold fraction math). */
-    maxContext?: number;
-    /** How many recent (user+assistant) pairs to always preserve (default 4). */
-    preserveK?: number;
-    /** Token threshold below which tool results are not elided (default 500). */
-    eliseThreshold?: number;
-    /** Model for selector LLM calls (default: same as provider default). */
-    selectorModel?: string;
-    /** Summarizer model for collapsed ranges (default: same as selectorModel). */
-    summarizerModel?: string;
-    /** Prompt for the summarizer sub-LLM. */
-    summarizerPrompt?: string;
-}
-/**
- * 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;
-    }): Promise<CompactReport>;
-    /**
-     * 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;
-}
-
-interface LLMSelectorOptions {
-    /** Provider used for the selector LLM call. Required. */
-    provider: Provider;
-    /** Model for the selector. Defaults to the provider's default model. */
-    model?: string;
-    /**
-     * Maximum tokens to keep in context (target budget).
-     * Selector will aim to keep total content below this.
-     */
-    maxContextTokens?: number;
-    /**
-     * Prompt instructing the selector how to behave.
-     * Should guide the LLM on importance tiers and output format.
-     */
-    systemPrompt?: string;
-}
-/**
- * LLM-powered message selector. Calls a sub-LLM to analyze the
- * message history and produce a keep/collapse plan — more surgical
- * than fixed-window rules.
- */
-declare class LLMSelector implements MessageSelector {
-    private readonly provider;
-    private readonly model;
-    private readonly maxContextTokens;
-    private readonly systemPrompt;
-    constructor(opts: LLMSelectorOptions);
-    select(messages: Message[], maxToKeep: number): Promise<SelectorResult>;
-    private fallbackSelect;
-    private parseSelectorOutput;
-}
-
-type CompactionFailureMode = 'throw' | 'throw_on_hard' | 'continue';
-interface AutoCompactionOptions {
-    aggressiveOn?: 'hard' | 'soft' | 'warn';
-    events?: EventBus;
-    failureMode?: CompactionFailureMode;
-}
-/**
- * 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.
- */
-declare class AutoCompactionMiddleware {
-    readonly name = "AutoCompaction";
-    private readonly compactor;
-    private readonly warnThreshold;
-    private readonly softThreshold;
-    private readonly hardThreshold;
-    private readonly maxContext;
-    private readonly estimator;
-    private readonly aggressiveOn;
-    private readonly events?;
-    private readonly failureMode;
-    /**
-     * @param compactor        Compactor to use for compaction.
-     * @param maxContext       Provider's max context window in tokens.
-     * @param estimator        Token estimation function.
-     * @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 | 'hard' | 'soft' | 'warn', events?: EventBus);
-    handler(): MiddlewareHandler<Context>;
-    private compact;
-}
-
-interface DefaultModelsRegistryOptions {
-    cacheFile: string;
-    url?: string;
-    ttlSeconds?: number;
-    fetchImpl?: typeof fetch;
-    /** Pre-seeded payload — useful for offline scenarios and tests. */
-    seed?: ModelsDevPayload;
-    /**
-     * Maximum age in seconds for stale cache fallback when network fails.
-     * Defaults to 7 days. Set to `Infinity` for full offline resilience
-     * (risk: deprecated models, wrong pricing). Set to `0` to disable
-     * stale fallback entirely.
-     */
-    maxStaleAgeSeconds?: number;
-}
-declare function classifyFamily(npm: string | undefined): WireFamily;
-declare class DefaultModelsRegistry implements ModelsRegistry {
-    private payload?;
-    private fetchedAt?;
-    private readonly cacheFile;
-    private readonly url;
-    private readonly ttlMs;
-    private readonly fetchImpl;
-    private readonly seed?;
-    private readonly maxStaleAgeMs;
-    constructor(opts: DefaultModelsRegistryOptions);
-    load(opts?: {
-        force?: boolean;
-    }): Promise<ModelsDevPayload>;
-    refresh(): Promise<ModelsDevPayload>;
-    listProviders(): Promise<ResolvedProvider[]>;
-    getProvider(id: string): Promise<ResolvedProvider | undefined>;
-    getModel(providerId: string, modelId: string): Promise<ResolvedModel | undefined>;
-    suggestModel(providerId: string): Promise<string | undefined>;
-    ageSeconds(): Promise<number>;
-    private resolveProvider;
-    private isFresh;
-    private isWithinMaxStaleAge;
-    private readCache;
-    /** Used by `wstack models refresh` to expose where the cache lives. */
-    cacheLocation(): string;
-}
-
-declare class DefaultModeStore implements ModeStore {
-    private activeModeId;
-    private modes;
-    private configDir;
-    constructor(config: ModeConfig);
-    getActiveMode(): Promise<Mode | null>;
-    setActiveMode(modeId: string | null): Promise<void>;
-    listModes(): Promise<Mode[]>;
-    getMode(modeId: string): Promise<Mode | null>;
-    addMode(mode: Mode): Promise<void>;
-    removeMode(modeId: string): Promise<void>;
-    private loadActiveMode;
-    private saveActiveMode;
-}
-interface ModeLoaderOptions {
-    projectModesDir?: string;
-    userModesDir?: string;
-}
-declare function loadProjectModes(modesDir: string): Promise<Mode[]>;
-declare function loadUserModes(modesDir: string): Promise<Mode[]>;
-
-interface MultiAgentCoordinatorOptions {
-    /**
-     * Callback that executes a task on behalf of a subagent. Required for
-     * `assign()` to actually run anything — without it, tasks queue forever.
-     * The coordinator provides per-subagent isolation (own budget, own signal,
-     * own bridge) and enforces timeout + concurrency.
-     */
-    runner?: SubagentRunner;
-}
-declare class DefaultMultiAgentCoordinator extends EventEmitter implements MultiAgentCoordinator {
-    readonly coordinatorId: string;
-    readonly config: MultiAgentConfig;
-    private readonly runner?;
-    private readonly subagents;
-    private pendingTasks;
-    private completedResults;
-    private totalIterations;
-    private inFlight;
-    constructor(config: MultiAgentConfig, options?: MultiAgentCoordinatorOptions);
-    spawn(subagent: SubagentConfig): Promise<SpawnResult>;
-    assign(task: TaskSpec): Promise<void>;
-    delegate(to: string, msg: BridgeMessage): Promise<void>;
-    /**
-     * Wire up the communication bridge for a subagent. Call after spawn() once
-     * the caller has created the bidirectional connection.
-     */
-    setSubagentBridge(subagentId: string, bridge: AgentBridge): void;
-    stop(subagentId: string): Promise<void>;
-    stopAll(): Promise<void>;
-    getStatus(): CoordinatorStatus;
-    /** Expose snapshot of completed results — useful for callers awaiting all done. */
-    results(): readonly TaskResult[];
-    /**
-     * Manual completion — for callers that drive subagents without a runner
-     * (e.g. external orchestrators). When a runner is configured the coordinator
-     * calls this itself.
-     */
-    completeTask(result: TaskResult): void;
-    private tryDispatchNext;
-    private canDispatch;
-    private findIdleSubagent;
-    private runDispatched;
-    private executeWithTimeout;
-    private recordCompletion;
-    private isDone;
-}
-
-/**
- * Caller-supplied factory that builds an isolated `Agent` for a subagent.
- * The factory MUST construct a fresh `Context` per call — sharing context
- * between subagents defeats isolation. Each Agent should also use either
- * its own `EventBus` or a forwarded view, so per-subagent metrics can be
- * attributed correctly.
- */
-type AgentFactory = (config: SubagentConfig) => Promise<AgentFactoryResult>;
-interface AgentFactoryResult {
-    agent: Agent;
-    /** Event bus the factory wired to this agent — required for budget hookup. */
-    events: EventBus;
-}
-interface AgentRunnerOptions {
-    factory: AgentFactory;
-    /**
-     * Format a TaskSpec into the user input the agent will receive. Defaults
-     * to `task.description ?? ''`. Override when subagents expect structured
-     * input (e.g. JSON contracts, role-prefixed prompts).
-     */
-    formatTaskInput?: (task: TaskSpec, config: SubagentConfig) => AgentInput;
-}
-/**
- * Builds a `SubagentRunner` that drives a real `Agent` per task while honoring
- * the coordinator's budget and abort signal. This is the production adapter —
- * the coordinator's `runner` option in CLI/TUI assemblies points here.
- *
- * Lifecycle per task:
- *   1. factory(config) → fresh Agent + EventBus.
- *   2. Subscribe to events to feed the budget (tool calls, token usage).
- *   3. Call agent.run(input, { signal }) — the coordinator's signal cancels.
- *   4. Map RunResult.status onto a `SubagentRunOutcome` or throw on failure.
- *   5. Unsubscribe and let the factory's resources be GC'd.
- *
- * The budget is checked synchronously from event handlers — a runaway agent
- * that crosses its tool-call limit triggers `BudgetExceededError`, which the
- * coordinator surfaces as `status: 'failed'` on the task result.
- */
-declare function makeAgentSubagentRunner(opts: AgentRunnerOptions): SubagentRunner;
-
-/**
- * Single fleet-wide event with subagent attribution. Whatever a child
- * agent emits on its own EventBus gets re-published here, prefixed with
- * `subagentId` so a single subscriber can multiplex across the fleet.
- *
- * The director uses `FleetBus.filter('tool.executed', …)` to see every
- * tool call across the fleet; the TUI uses
- * `FleetBus.subscribe(id, handler)` to render a per-subagent panel.
- */
-interface FleetEvent {
-    subagentId: string;
-    taskId?: string;
-    ts: number;
-    type: string;
-    payload: unknown;
-}
-type FleetHandler = (event: FleetEvent) => void;
-/**
- * Fan-in for per-subagent EventBuses. Each subagent's bus is plugged in
- * via `attach()`; the FleetBus re-emits every event with subagent
- * attribution. Detachment is automatic via the returned disposer — call
- * it when a subagent terminates so we don't leak listeners.
- *
- * The bus exposes two subscription modes: by `subagentId` (everything
- * from one child) and by `type` (one event-type across the fleet). They
- * compose — if you need a per-subagent + per-type slice, subscribe by
- * type and filter on `event.subagentId` in your handler.
- */
-declare class FleetBus {
-    private readonly byId;
-    private readonly byType;
-    private readonly any;
-    /**
-     * Hook a subagent's EventBus into the fleet. EventBus is strongly
-     * typed and doesn't expose an `onAny` hook, so we subscribe to the
-     * canonical set of event types a subagent emits during a run. New
-     * event types added to the kernel must be added here too — but the
-     * cost is a tiny single line per type, and the explicit list keeps
-     * the wire format clear.
-     *
-     * Returns a disposer that detaches every subscription; call on
-     * subagent teardown so the listeners don't outlive the run.
-     */
-    attach(subagentId: string, bus: EventBus, taskId?: string): () => void;
-    /** Subscribe to every event from one subagent. */
-    subscribe(subagentId: string, handler: FleetHandler): () => void;
-    /** Subscribe to one event type across all subagents. */
-    filter(type: string, handler: FleetHandler): () => void;
-    /** Subscribe to literally everything. The fleet roll-up uses this. */
-    onAny(handler: FleetHandler): () => void;
-    emit(event: FleetEvent): void;
-}
-/**
- * Roll-up of token usage + cost across an entire director run. The
- * director's `fleet_status` tool returns this so the model can reason
- * about budget in its next turn ("the researcher already burned $0.40,
- * lean on summaries for the next task").
- */
-interface FleetUsage {
-    total: {
-        input: number;
-        output: number;
-        cacheRead: number;
-        cacheWrite: number;
-        cost: number;
-    };
-    perSubagent: Record<string, SubagentUsageSnapshot>;
-}
-interface SubagentUsageSnapshot {
-    subagentId: string;
-    provider?: string;
-    model?: string;
-    input: number;
-    output: number;
-    cacheRead: number;
-    cacheWrite: number;
-    cost: number;
-    toolCalls: number;
-    iterations: number;
-    startedAt: number;
-    lastEventAt: number;
-}
-/**
- * Aggregates provider.response + tool.executed events from the FleetBus
- * into a live `FleetUsage` snapshot. Costs are computed by the caller
- * via a `priceLookup(subagentId)` so we don't bake provider-pricing
- * coupling into core; the CLI/tests supply a function that resolves
- * each subagent's per-token rates from the models registry.
- */
-declare class FleetUsageAggregator {
-    private readonly bus;
-    private readonly priceLookup?;
-    private readonly metaLookup?;
-    private readonly perSubagent;
-    private readonly total;
-    constructor(bus: FleetBus, priceLookup?: ((subagentId: string) => {
-        input?: number;
-        output?: number;
-        cacheRead?: number;
-        cacheWrite?: number;
-    } | undefined) | undefined, metaLookup?: ((subagentId: string) => {
-        provider?: string;
-        model?: string;
-    } | undefined) | undefined);
-    /** Live snapshot — safe to call from a tool's execute() body. */
-    snapshot(): FleetUsage;
-    private ensure;
-    private onProviderResponse;
-    private onToolExecuted;
-    private onIterationStarted;
-}
-
-/**
- * In-memory pub/sub transport for agent-to-agent messaging.
- * Subscribers register by agentId and receive messages via callback.
- */
-declare class InMemoryBridgeTransport implements BridgeTransport {
-    private readonly subs;
-    send(msg: BridgeMessage, to: string): Promise<void>;
-    subscribe(agentId: string, handler: (msg: BridgeMessage) => void): () => void;
-    close(agentId: string): Promise<void>;
-}
-
-declare class InMemoryAgentBridge implements AgentBridge {
-    readonly agentId: string;
-    readonly coordinatorId: string;
-    private readonly transport;
-    private readonly subscriptions;
-    private pendingRequests;
-    private stopped;
-    private timeoutMs;
-    constructor(config: AgentBridgeConfig, transport: BridgeTransport);
-    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>;
-}
-declare function createMessage<T = unknown>(type: BridgeMessage['type'], from: string, payload: T, to?: string): BridgeMessage<T>;
-
-/**
- * Director — high-level orchestrator that owns a `MultiAgentCoordinator`,
- * a `FleetBus`, and a `FleetUsageAggregator`. Exposes a small imperative
- * API (`spawn`, `assign`, `awaitTasks`, `terminate`, `status`, `usage`)
- * that's easy to test, and a `tools()` factory that wraps the same API
- * as agent-callable `Tool`s so an LLM can drive the orchestration.
- *
- * This class is intentionally *not* an `Agent`. It's a coordinator +
- * observability surface. To make it LLM-driven, construct an Agent
- * with `director.tools()` registered. That keeps the construction
- * symmetric with how other agents are built and avoids smuggling a
- * heavy LLM dependency into core just for the director path.
- */
-interface DirectorOptions {
-    config: MultiAgentConfig;
-    runner?: SubagentRunner;
-    /**
-     * When set, the director writes a `fleet.json` manifest to this path
-     * recording every spawned subagent (id, provider, model, role, task
-     * ids). Used by `wstack replay <runId>` to rehydrate a fleet. Pass an
-     * absolute file path — the directory must already exist (the
-     * director-session factory creates it when used together).
-     */
-    manifestPath?: string;
-    /**
-     * Optional roster used by `leaderSystemPrompt()` to render a roles
-     * summary into the leader's preamble. Same shape as the roster passed
-     * to `tools()` — typically the same value.
-     */
-    roster?: Record<string, SubagentConfig>;
-    /**
-     * Override the built-in fleet preamble (see `DEFAULT_DIRECTOR_PREAMBLE`).
-     * Pass an empty string to suppress the preamble entirely.
-     */
-    directorPreamble?: string;
-    /**
-     * Override the built-in subagent baseline (see
-     * `DEFAULT_SUBAGENT_BASELINE`). Pass an empty string to suppress.
-     */
-    subagentBaseline?: string;
-    /**
-     * Absolute path to a directory the fleet can use as a shared scratchpad
-     * (read + write by every subagent). When set, the director creates it on
-     * construction and `subagentSystemPrompt()` automatically injects a
-     * "Shared notes" block telling subagents where to drop their findings.
-     * This is the cheap fleet-coordination channel — agents don't need each
-     * other's transcripts, just each other's conclusions.
-     *
-     * Convention: under a fleet run rooted at `<sessionsRoot>/<runId>/`,
-     * pass `<sessionsRoot>/<runId>/shared/` here.
-     */
-    sharedScratchpadPath?: string;
-    /**
-     * Maximum number of spawns this director can perform across its
-     * lifetime. Default: unlimited. Acts as a hard fleet-wide cost cap —
-     * a runaway leader that keeps spawning workers gets cut off cleanly
-     * instead of burning provider tokens until the user kills the
-     * process. The N+1-th spawn call rejects with a `DirectorBudgetError`.
-     */
-    maxSpawns?: number;
-    /**
-     * Maximum nesting depth for spawns. The director constructed by the
-     * user is at depth `spawnDepth` (default 0); any subagent that itself
-     * acts as a director would construct its own `Director` with
-     * `spawnDepth: parent.spawnDepth + 1`. When `spawnDepth >= maxSpawnDepth`,
-     * `spawn()` rejects. Default: 2 (root director can spawn workers; a
-     * worker that becomes a sub-director cannot itself spawn further).
-     * This stops infinite recursive director chains from a hostile or
-     * confused prompt.
-     */
-    maxSpawnDepth?: number;
-    /**
-     * Current spawn-chain depth for this director instance. Defaults to 0.
-     * A nested director should pass `parent.spawnDepth + 1`. Together with
-     * `maxSpawnDepth` this bounds the chain.
-     */
-    spawnDepth?: number;
-}
-/**
- * Thrown by `Director.spawn()` when a configured spawn cap (`maxSpawns`,
- * `maxSpawnDepth`) is hit. Distinct error class so callers — including
- * the `spawn_subagent` tool surface — can recognize the budget case and
- * report it cleanly instead of treating it like an unexpected failure.
- */
-declare class DirectorBudgetError extends Error {
-    readonly kind: 'max_spawns' | 'max_spawn_depth';
-    readonly limit: number;
-    readonly observed: number;
-    constructor(kind: 'max_spawns' | 'max_spawn_depth', limit: number, observed: number);
-}
-declare class Director {
-    readonly id: string;
-    readonly fleet: FleetBus;
-    readonly usage: FleetUsageAggregator;
-    /**
-     * Director-side bridge endpoint. Subagents are wired to the same
-     * in-memory transport so the director can `ask()` them synchronously
-     * and they can `send()` progress back. Exposed so external code (e.g.
-     * the TUI) can subscribe to inbound messages.
-     */
-    readonly bridge: InMemoryAgentBridge;
-    private readonly transport;
-    private readonly coordinator;
-    /** Resolves with the matching `TaskResult` the first time the
-     *  coordinator emits `task.completed` for a given task id. Each entry
-     *  is created lazily on first poll/await and cleared once consumed. */
-    private readonly taskWaiters;
-    /** Cache of completed results in case the consumer asks AFTER the
-     *  coordinator already fired the event — `awaitTasks(['t-1'])` after
-     *  t-1 finished should resolve immediately, not hang. */
-    private readonly completed;
-    /** Per-subagent provider/model metadata, captured at spawn time so the
-     *  FleetUsageAggregator's metaLookup can surface readable rows. */
-    private readonly subagentMeta;
-    private readonly priceLookups;
-    /** Bridge endpoints we created per subagent (so we can `stop()` them
-     *  on shutdown and free transport subscriptions). */
-    private readonly subagentBridges;
-    /** Tracks per-spawn config + assigned task ids for manifest writing. */
-    private readonly manifestEntries;
-    private readonly manifestPath?;
-    private readonly roster?;
-    private readonly directorPreamble;
-    private readonly subagentBaseline;
-    /** Absolute path to the fleet's shared scratchpad directory, or null
-     *  when none was configured. Exposed as a readonly getter for callers
-     *  that need to surface the path to the user (e.g. the CLI logging
-     *  the location after `--director` boots). */
-    readonly sharedScratchpadPath: string | null;
-    /** Spawn cap (lifetime total). Infinity means unlimited. */
-    readonly maxSpawns: number;
-    /** Nesting cap. The N-th director in a chain has `spawnDepth = N-1`. */
-    readonly maxSpawnDepth: number;
-    /** This director's position in a director chain. Root director = 0. */
-    readonly spawnDepth: number;
-    /** Live spawn counter for `maxSpawns` enforcement. */
-    private spawnCount;
-    constructor(opts: DirectorOptions);
-    /**
-     * Spawn a subagent. Identical to the coordinator's `spawn()` but
-     * captures provider/model metadata for the usage aggregator and
-     * lets the FleetBus attach to the runner's EventBus when the task
-     * actually runs (see `attachSubagentBus`).
-     *
-     * Caller-supplied `priceLookup` is optional but recommended — without
-     * it the `cost` column in `usage.snapshot()` stays at 0.
-     */
-    spawn(config: SubagentConfig, priceLookup?: {
-        input?: number;
-        output?: number;
-        cacheRead?: number;
-        cacheWrite?: number;
-    }): Promise<string>;
-    /**
-     * Synchronously ask a subagent something via the bridge. Sends a
-     * `task` message addressed to the subagent and awaits a matching
-     * reply (matched by message id). Subagent runners that handle these
-     * requests subscribe to `ctx.bridge` and reply with a message whose
-     * `id` equals the incoming request's id (see `InMemoryAgentBridge`'s
-     * `request<T>` implementation).
-     *
-     * Returns the response payload directly (the bridge wrapper is
-     * unwrapped for ergonomics). Times out after `timeoutMs` (default
-     * matches the bridge's own default of 30s) — surface those rejections
-     * to the caller as actionable errors instead of letting tools hang.
-     */
-    ask<T = unknown>(subagentId: string, payload: unknown, timeoutMs?: number): Promise<T>;
-    /**
-     * Read completed task results and format them as a structured text
-     * block the director's LLM can paste into its own context. The
-     * Director keeps every completed `TaskResult` in `completed` so this
-     * is a pure read — no bridge round-trip, cheap to call.
-     *
-     * The returned string is intentionally markdown-flavored: headers per
-     * subagent, a one-line meta row (iter / tools / ms), and the task's
-     * result text. Pass `style: 'json'` for a programmatic shape instead
-     * (useful when the director model is doing structured-output work).
-     */
-    rollUp(taskIds: string[], style?: 'markdown' | 'json'): string;
-    /**
-     * Write the fleet manifest to `manifestPath`. Returns the path written
-     * or null when no path was configured. Captures every spawn + its
-     * assigned tasks — paired with per-subagent JSONLs, this is enough to
-     * replay an entire director run.
-     */
-    writeManifest(): Promise<string | null>;
-    /**
-     * Tear down the director: stop every subagent, close every bridge
-     * endpoint, and (when configured) write the final manifest. Idempotent
-     * — calling shutdown twice is a no-op on the second invocation.
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Hand a task to the coordinator. Returns the assigned task id so
-     * callers can wait on it via `awaitTasks([id])`. The coordinator's
-     * concurrency limit applies — the task may queue before running.
-     */
-    assign(task: TaskSpec): Promise<string>;
-    /**
-     * Block until every task id resolves. Returns results in the same
-     * order as the input. If any task hasn't completed by the time this
-     * is called, the promise hangs until it does — pair with a timeout
-     * at the caller if that's a concern. Resolves immediately for ids
-     * whose results were already cached.
-     */
-    awaitTasks(taskIds: string[]): Promise<TaskResult[]>;
-    terminate(subagentId: string): Promise<void>;
-    terminateAll(): Promise<void>;
-    status(): CoordinatorStatus;
-    /**
-     * Subscribe to coordinator events. Currently only `task.completed` is
-     * exposed (the others are internal lifecycle). Returns an unsubscribe
-     * function. External callers (e.g. the CLI's `MultiAgentHost`) use this
-     * to drive their own pending/results tracking without poking the
-     * coordinator directly.
-     */
-    on(event: 'task.completed', handler: (payload: {
-        task: TaskSpec;
-        result: TaskResult;
-    }) => void): () => void;
-    /**
-     * Snapshot of every task that has resolved (success, failed, timeout,
-     * stopped) since the director started. Returned in completion order
-     * via the internal map's iteration order. Used by `/fleet status` to
-     * paint the completed table without reaching into private state.
-     */
-    completedResults(): TaskResult[];
-    snapshot(): FleetUsage;
-    /**
-     * Compose the leader/director-agent system prompt: fleet preamble +
-     * (optional) roster summary + user base prompt. Pass the result to your
-     * leader Agent's `ctx.systemPrompt` when constructing it.
-     *
-     * `basePrompt` defaults to `config.leaderSystemPrompt` so callers can
-     * use the no-arg form when the multi-agent config already carries it.
-     */
-    leaderSystemPrompt(basePrompt?: string): string;
-    /**
-     * Compose a subagent's system prompt for a given `SubagentConfig`:
-     * baseline + role + task + per-spawn override. Returned by value — does
-     * not mutate the config. Factories (the user-supplied `AgentFactory`)
-     * should call this when building each subagent's Agent so the bridge
-     * contract, role context, and override are all surfaced.
-     *
-     * When `taskBrief` is omitted the Task section is dropped. Pass the
-     * actual task description here to reinforce it in the system prompt
-     * (the runner already passes it as user input — duplicating in the
-     * system prompt is optional but improves anchoring on small models).
-     */
-    subagentSystemPrompt(config: SubagentConfig, taskBrief?: string): string;
-    /**
-     * Build the tool set the LLM-driven director uses to orchestrate.
-     * Returns an array of `Tool` definitions; register these on the
-     * director's `Agent` to expose `spawn_subagent`, `assign_task`, etc.
-     * Each tool's `execute()` delegates straight to the matching method
-     * above.
-     *
-     * Tools all carry `permission: 'auto'` — the *user* has already
-     * approved running the director when they kicked off the run, so
-     * gating individual orchestration calls behind a confirm prompt
-     * would just be noise. The actual subagent tools they spawn are
-     * still permission-checked normally.
-     */
-    tools(roster?: Record<string, SubagentConfig>): Tool[];
-}
-
-/**
- * Per-subagent session factory.
- *
- * Director runs produce many parallel transcripts — one per spawned
- * subagent — and we want them all rooted under the same director-run
- * directory so a future `wstack replay <runId>` can rehydrate the whole
- * fleet from a single tree.
- *
- * The factory builds (or accepts) a `SessionStore` whose `dir` points at
- * `<sessionsRoot>/<directorRunId>/`, and returns a small `create()`
- * function that the orchestration layer calls per-spawn. Each call
- * yields a fresh `SessionWriter` whose JSONL file lives in that
- * directory, named by either the caller-supplied `subagentId` (preferred,
- * so the file name is human-readable) or a derived id.
- *
- * **Why a thin factory instead of plumbing options through every spawn
- * site?** Because the director is the only caller that needs this
- * isolation pattern, and shoving `sessionStore` options into
- * `SubagentConfig` would leak storage details into a config shape that
- * agents and the coordinator have no business knowing about.
- */
-interface DirectorSessionFactoryOptions {
-    /**
-     * Either a parent directory where `<directorRunId>/` will be created,
-     * or a pre-built `SessionStore` whose `dir` already points at the
-     * director run directory. Tests pass an in-memory store for isolation;
-     * production code passes the path under `~/.wrongstack/sessions/`.
-     */
-    store?: SessionStore;
-    sessionsRoot?: string;
-    /**
-     * Director run id — namespaces all subagent JSONLs under one folder.
-     * Defaults to a timestamped id; supplied explicitly when resuming a
-     * prior fleet manifest.
-     */
-    directorRunId?: string;
-}
-interface DirectorSessionFactory {
-    /** Absolute directory where this director run's transcripts live. */
-    readonly dir: string;
-    /** The director run id used to namespace the directory. */
-    readonly directorRunId: string;
-    /**
-     * Create a fresh `SessionWriter` for the named subagent. Each
-     * subagent gets its own JSONL file. The writer's `id` matches the
-     * supplied `subagentId` so disk paths line up with in-memory ids.
-     */
-    createSubagentSession(args: {
-        subagentId: string;
-        provider?: string;
-        model?: string;
-        title?: string;
-    }): Promise<SessionWriter>;
-}
-/**
- * Build a `DirectorSessionFactory`. Pass either a pre-configured
- * `SessionStore` (tests) or a `sessionsRoot` path (production). When
- * neither is supplied the factory throws — there's no sane default for
- * "where do these JSONLs live".
- */
-declare function makeDirectorSessionFactory(opts: DirectorSessionFactoryOptions): DirectorSessionFactory;
-
-/**
- * System-prompt composition helpers for the Director ecosystem.
- *
- * Two callers need composed prompts:
- *
- *   1. The **leader** (the director's own Agent) — needs a preamble that
- *      explains the fleet protocol: when to spawn, when to await, how to
- *      roll up, and the eight orchestration tools it owns.
- *
- *   2. Each **subagent** — needs a baseline that explains it has a parent
- *      it can call via the bridge, a role-specific block, the task brief,
- *      and finally any per-spawn `systemPromptOverride` from `SubagentConfig`.
- *
- * Both composers are pure functions: feed them parts, they return a string.
- * No I/O, no side effects, no implicit defaults beyond the ones exported
- * here. Callers (CLI multi-agent factory, Director itself) decide which
- * parts to fill in — that keeps the composition seam visible and testable.
- */
-/**
- * Default fleet-protocol preamble injected at the **front** of the
- * director-agent's system prompt. Kept deliberately short — long preambles
- * crowd out the user's leader prompt and the LLM stops attending. The tool
- * descriptions live on the tool definitions themselves; this preamble only
- * teaches *when* to reach for them.
- */
-declare const DEFAULT_DIRECTOR_PREAMBLE = "You are the Director of a multi-agent fleet. You orchestrate worker\nsubagents by spawning them, assigning tasks, awaiting completions, and\nrolling up their outputs into your next decision.\n\nCore fleet tools available to you:\n  - spawn_subagent       \u2014 create a worker with a chosen provider / model / role\n  - assign_task          \u2014 hand a piece of work to a specific subagent\n  - await_tasks          \u2014 block until named task ids complete (parallel-safe)\n  - ask_subagent         \u2014 synchronously query a running subagent via the bridge\n  - roll_up              \u2014 aggregate finished tasks into a markdown/json summary\n  - terminate_subagent   \u2014 abort a stuck worker (use sparingly)\n  - fleet_status         \u2014 snapshot of all subagents and pending tasks\n  - fleet_usage          \u2014 token + cost breakdown per subagent and total\n\nWorking rules:\n  1. Decompose first. Before spawning, decide which sub-tasks are\n     independent and can run in parallel. Sequential work doesn't need a\n     subagent \u2014 do it yourself.\n  2. Match worker to job. Cheap/fast model for triage, capable model for\n     synthesis. Different providers per sibling is allowed and encouraged.\n  3. Always pair an assign with an await. Don't fire-and-forget; you owe\n     the user a single coherent answer at the end.\n  4. Roll up before deciding. After await_tasks resolves, call roll_up so\n     the results are folded back into your context in a compact form.\n  5. Budget is real. Check fleet_usage periodically. If a subagent is\n     thrashing, terminate it rather than letting cost climb silently.\n  6. Never claim a subagent's work as your own without verifying it. If a\n     result looks wrong, ask_subagent for clarification before passing it\n     to the user.";
-/**
- * Default baseline prepended to every subagent's system prompt. Tells the
- * subagent its place in the hierarchy and the bridge contract — without
- * this, a subagent has no way to know it *can* ask the parent for
- * clarification, and it will hallucinate answers when context is missing.
- *
- * Bridge contract: subagents may `send` progress and `request` answers, but
- * MAY NOT exfiltrate the parent's full system prompt or tools list. The
- * baseline reinforces this in plain text — the actual enforcement is at
- * the bridge transport layer.
- */
-declare const DEFAULT_SUBAGENT_BASELINE = "You are a subagent operating under a Director. You were spawned to handle\na specific slice of a larger plan \u2014 do that slice well and report back.\n\nBridge contract:\n  - You have a parent (the Director). You may call `request` on the\n    parent bridge to ask a clarifying question. Use this sparingly; the\n    parent is also working.\n  - You MAY NOT request the parent's system prompt, tool list, or other\n    subagents' context. Those are not yours to read.\n  - Your final task output is what the Director sees. Be concise,\n    structured, and self-contained \u2014 assume the Director will paste your\n    output into its own context.";
-/** Parts the leader-prompt composer accepts. All optional. */
-interface DirectorPromptParts {
-    /** The user's existing leader system prompt — typically what was passed
-     *  via `MultiAgentConfig.leaderSystemPrompt`. */
-    basePrompt?: string;
-    /** Override the built-in fleet preamble. Pass empty string to suppress. */
-    directorPreamble?: string;
-    /** Optional roster summary block — a short list of pre-configured roles
-     *  the director can spawn (e.g. "researcher, coder, reviewer"). Helps
-     *  small models discover the available shapes without scanning tools. */
-    rosterSummary?: string;
-}
-/**
- * Compose the leader/director's system prompt. Order:
- *   1. Director preamble (fleet protocol)
- *   2. Roster summary (optional, when provided)
- *   3. User base prompt (the per-project leader prompt)
- *
- * Sections are separated by a blank line. Empty parts are skipped so the
- * output never contains stray blank-line runs.
- */
-declare function composeDirectorPrompt(parts?: DirectorPromptParts): string;
-/** Parts the subagent-prompt composer accepts. Layered from generic to
- *  specific; later layers override earlier ones when they conflict. */
-interface SubagentPromptParts {
-    /** Base persona/identity for *every* subagent. Defaults to the bridge
-     *  contract baseline. Pass empty string to suppress. */
-    baseline?: string;
-    /** Role-specific block, e.g. "You are a code reviewer. Focus on…". */
-    role?: string;
-    /** Task brief — usually the same string the runner passes as user input,
-     *  but exposed here in case the factory wants it duplicated in the
-     *  system prompt for reinforcement. */
-    task?: string;
-    /**
-     * Absolute path to a shared scratchpad directory the whole fleet can
-     * read/write. When set, the composer adds a "Shared notes" block that
-     * tells the subagent where to drop findings and where to look for
-     * sibling output. This is the cheap fleet-coordination channel —
-     * agents don't need each other's transcripts, just each other's
-     * conclusions. Falls between `task` and `override` so the override
-     * can still narrow or replace it.
-     */
-    sharedScratchpad?: string;
-    /** Final per-spawn override from `SubagentConfig.systemPromptOverride`.
-     *  Added last so it wins on conflict — that's by design: the spawn site
-     *  knows the most about what this specific subagent should do. */
-    override?: string;
-}
-/**
- * Compose a subagent's system prompt. Order:
- *   1. Baseline (bridge contract)
- *   2. Role
- *   3. Task brief
- *   4. Per-spawn override
- *
- * Same blank-line-separated joining as the director composer.
- *
- * Layering rationale: the baseline never needs to change between
- * subagents; the role is the "what kind of worker is this"; the task is
- * the "what should you do *now*"; the override is the spawn-site escape
- * hatch ("…and respond only in JSON"). Putting override last means it
- * never gets squashed by something earlier in the chain.
- */
-declare function composeSubagentPrompt(parts?: SubagentPromptParts): string;
-/**
- * Render a short bullet list summarising a roster — useful for stuffing
- * into `composeDirectorPrompt({ rosterSummary })` so the director model
- * can see available roles without scanning tool descriptions.
- *
- * Each entry: `- <role-id>: <name>[ (provider/model)] — <prompt-headline>`
- * The prompt headline is the first non-empty line of `config.prompt`,
- * truncated to 80 chars. Skipped entirely when the role has no prompt.
- */
-declare function rosterSummaryFromConfigs(roster: Record<string, {
-    name: string;
-    provider?: string;
-    model?: string;
-    prompt?: string;
-    role?: string;
-}>): string;
-
-/**
- * Pre-built subagent role configurations for the WrongStack fleet.
- * These can be passed to `MultiAgentHost.spawn()` or used as templates
- * for the director's roster.
- */
-
-/**
- * Audit Log Agent — analyzes session logs, event streams, and traces.
- * Use for: post-mortems, trend analysis, operational insights.
- */
-declare const AUDIT_LOG_AGENT: SubagentConfig;
-/**
- * Bug Hunter Agent — systematic bug and code smell detection.
- * Use for: pre-refactoring health checks, code review, regression prevention.
- */
-declare const BUG_HUNTER_AGENT: SubagentConfig;
-/**
- * Refactor Planner Agent — structured refactoring planning.
- * Use for: large rewrites, technical debt reduction, architecture improvements.
- */
-declare const REFACTOR_PLANNER_AGENT: SubagentConfig;
-/**
- * Security Scanner Agent — vulnerability and secret detection.
- * Use for: CI checks, pre-release audits, dependency vulnerability scanning.
- */
-declare const SECURITY_SCANNER_AGENT: SubagentConfig;
-/** All pre-built agents in a map for easy lookup by role. */
-declare const FLEET_ROSTER: Record<string, SubagentConfig>;
-/** Quick-access list for spawning all at once. */
-declare const ALL_FLEET_AGENTS: SubagentConfig[];
-
-type AutonomousResult = RunResult & {
-    toolCalls: number;
-    reason?: string;
-};
-interface DoneCheckResult {
-    done: boolean;
-    reason?: string;
-    iterations: number;
-    toolCalls: number;
-}
-declare class DoneConditionChecker {
-    private readonly condition;
-    private readonly compiledRegex;
-    constructor(condition: DoneCondition);
-    check(state: {
-        iterations: number;
-        toolCalls: number;
-        lastOutput?: string;
-    }): DoneCheckResult;
-}
-interface AutonomousRunnerOptions {
-    agent: Agent;
-    context: Context;
-    doneCondition: DoneCondition;
-    iterationTimeoutMs?: number;
-    onIteration?: (state: {
-        iteration: number;
-        toolCalls: number;
-    }) => void;
-    onDone?: (result: AutonomousResult) => void;
-}
-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;
-}
-
-declare class SpecParser {
-    parse(content: string): Specification;
-    private extractTitle;
-    private extractVersion;
-    private extractOverview;
-    private extractSections;
-    private extractRequirements;
-    private parseRequirementLine;
-    private mapSectionType;
-    analyze(spec: Specification): SpecAnalysis;
-    validate(spec: Specification): SpecValidationResult;
-}
-
-interface TaskStore {
-    saveGraph(graph: TaskGraph): Promise<void>;
-    loadGraph(id: string): Promise<TaskGraph | null>;
-    listGraphs(): Promise<{
-        id: string;
-        title: string;
-        updatedAt: number;
-    }[]>;
-    deleteGraph(id: string): Promise<void>;
-}
-interface TaskTrackerOptions {
-    store: TaskStore;
-    /**
-     * Called when an in-the-background persistence (`saveGraph`) rejects.
-     * The synchronous TaskTracker methods (addNode/addEdge/updateNodeStatus)
-     * fire-and-forget their writes; without this, a failing store silently
-     * loses graph mutations. Defaults to a console.warn.
-     */
-    onPersistError?: (err: unknown) => void;
-}
-interface TaskTransition {
-    from: TaskNode['status'];
-    to: TaskNode['status'];
-    timestamp: number;
-    reason?: string;
-}
-declare class TaskTracker {
-    private readonly opts;
-    private graph;
-    private transitions;
-    constructor(opts: TaskTrackerOptions);
-    createGraph(specId: string, title: string): Promise<TaskGraph>;
-    loadGraph(id: string): Promise<TaskGraph | null>;
-    addNode(node: Omit<TaskNode, 'id' | 'createdAt' | 'updatedAt'>): TaskNode;
-    addEdge(from: string, to: string, type?: TaskGraph['edges'][0]['type']): void;
-    updateNodeStatus(id: string, status: TaskNode['status'], reason?: string): void;
-    getNode(id: string): TaskNode | undefined;
-    getAllNodes(filter?: TaskFilter, sort?: TaskSort): TaskNode[];
-    getChildren(parentId: string): TaskNode[];
-    getDependents(taskId: string): string[];
-    getBlockers(taskId: string): string[];
-    canStart(taskId: string): boolean;
-    getProgress(): TaskProgress;
-    getTransitions(taskId?: string): TaskTransition[];
-    private unblockDependents;
-    private checkAndBlockIfNeeded;
-    /**
-     * Fire-and-forget persistence with attached error handler.
-     * Synchronous mutators (addNode/addEdge/updateNodeStatus) use this to
-     * avoid forcing an async cascade through every caller; if the store
-     * rejects, the configured `onPersistError` is invoked so failures are
-     * surfaced instead of swallowed by an unhandled promise rejection.
-     */
-    private persist;
-}
-
-interface TaskGeneratorOptions {
-    taskTracker: TaskTracker;
-}
-interface GeneratedTask {
-    specRequirementId?: string;
-    title: string;
-    description: string;
-    type: TaskType;
-    priority: TaskPriority;
-    estimateHours?: number;
-    tags?: string[];
-}
-declare class TaskGenerator {
-    private readonly opts;
-    constructor(opts: TaskGeneratorOptions);
-    generateFromSpec(spec: Specification): Promise<TaskGraph>;
-    private createTaskFromRequirement;
-    private createTaskFromEndpoint;
-    private buildDescription;
-    private mapRequirementType;
-    private estimateHours;
-    private estimateForEndpoint;
-    generateSubtasks(parentTaskId: string, spec: Specification): Promise<void>;
-}
-declare class DefaultTaskStore implements TaskStore {
-    private graphs;
-    saveGraph(graph: TaskGraph): Promise<void>;
-    loadGraph(id: string): Promise<TaskGraph | null>;
-    listGraphs(): Promise<{
-        id: string;
-        title: string;
-        updatedAt: number;
-    }[]>;
-    deleteGraph(id: string): Promise<void>;
-    private cloneGraph;
-}
-
-/**
- * Extended event map used internally by TaskFlow and multi-agent components.
- * These events are emitted on the injected EventBus and are a subset of
- * the full EventMap — they do not require a separate registration.
- */
-interface TaskFlowEventMap {
-    'phase.change': {
-        from: TaskFlowPhase;
-        to: TaskFlowPhase;
-    };
-    'task.started': {
-        taskId: string;
-    };
-    'task.completed': {
-        taskId: string;
-        result?: unknown;
-    };
-    'task.failed': {
-        taskId: string;
-        error: string;
-    };
-    'task.review': {
-        taskId: string;
-    };
-    'spec.analyzed': {
-        analysis: SpecAnalysis;
-    };
-    'progress': {
-        percent: number;
-        message: string;
-    };
-    'done': {
-        graph: TaskGraph;
-    };
-    'error': {
-        phase: TaskFlowPhase;
-        error: Error;
-    };
-}
-type TaskFlowPhase = 'idle' | 'parsing' | 'analyzing' | 'generating' | 'executing' | 'reviewing' | 'completing' | 'done' | 'failed';
-type TaskFlowEventName = keyof TaskFlowEventMap;
-interface TaskFlowOptions {
-    tracker: TaskTracker;
-    events: EventBus;
-    doneCondition?: DoneCondition;
-    maxConcurrent?: number;
-}
-interface TaskFlowExecutionContext {
-    executeTask: (task: TaskNode) => Promise<unknown>;
-    onTaskComplete?: (task: TaskNode, result: unknown) => void;
-    onTaskFail?: (task: TaskNode, error: Error) => void;
-}
-declare class TaskFlow {
-    private readonly opts;
-    private phase;
-    private spec;
-    private graph;
-    private stopped;
-    constructor(opts: TaskFlowOptions);
-    private emit;
-    fromSpec(specContent: string): Promise<TaskGraph>;
-    execute(ctx: TaskFlowExecutionContext): Promise<TaskGraph>;
-    reviewTask(taskId: string, approved: boolean, comment?: string): Promise<void>;
-    stop(): void;
-    getPhase(): TaskFlowPhase;
-    getGraph(): TaskGraph | null;
-    getSpec(): Specification | null;
-    private setPhase;
-    private getExecutableTasks;
-    private executeSingleTask;
-    private checkDoneCondition;
-    private emitProgress;
-}
-interface SpecDrivenDevOptions {
-    workingDirectory: string;
-    events: EventBus;
-    doneCondition?: DoneCondition;
-}
-declare class SpecDrivenDev {
-    private store;
-    private tracker;
-    private readonly events;
-    private flows;
-    constructor(opts: SpecDrivenDevOptions);
-    createFlow(specContent: string, options?: Partial<TaskFlowOptions>): Promise<TaskFlow>;
-    getTracker(): TaskTracker;
-    getFlow(graphId: string): TaskFlow | undefined;
-    listFlows(): {
-        id: string;
-        title: string;
-        phase: TaskFlowPhase;
-    }[];
-}
-
-/**
- * Per-project lockfile used for crash detection. The CLI writes one of
- * these alongside the session JSONLs (`<projectSessions>/active.json`)
- * when an interactive run starts, and deletes it on clean exit. If we
- * find one on the next launch whose owning PID is dead (or whose host
- * doesn't match), we know the previous run was killed mid-flight and
- * the session it was writing to is a recovery candidate.
- *
- * The lockfile is intentionally per-project (already isolated by
- * `wpaths.projectSessions`), so two TUIs in two different repos do not
- * fight each other.
- */
-interface RecoveryLockOptions {
-    /** Directory the lockfile lives in. Usually `wpaths.projectSessions`. */
-    dir: string;
-    /** This process's PID. Default: `process.pid`. */
-    pid?: number;
-    /** Hostname recorded for the lock. Default: `os.hostname()`. */
-    hostname?: string;
-    /** Locks older than this are considered orphaned (disk wiped, etc.). Default 24h. */
-    maxAgeMs?: number;
-    /** Used to check whether the abandoned session was actually closed cleanly. */
-    sessionStore?: SessionStore;
-    /**
-     * Override the PID-liveness probe. Default: `process.kill(pid, 0)` —
-     * succeeds (or throws EPERM) when the PID is alive, throws ESRCH when
-     * it is gone. Tests inject a deterministic stub.
-     */
-    isPidAlive?: (pid: number) => boolean;
-}
-interface AbandonedSession {
-    sessionId: string;
-    pid: number;
-    startedAt: string;
-    /** Lockfile age in ms at the time of the check. */
-    ageMs: number;
-    /** Number of messages already on disk for this session. */
-    messageCount: number;
-}
-declare class RecoveryLock {
-    private readonly file;
-    private readonly pid;
-    private readonly hostname;
-    private readonly maxAgeMs;
-    private readonly sessionStore?;
-    private readonly probe;
-    constructor(opts: RecoveryLockOptions);
-    /**
-     * Examine the lockfile and decide whether it represents an abandoned
-     * session. Returns `null` if the file is missing, points to a live
-     * instance, references a clean-closed session, is too old, or is
-     * malformed. Otherwise returns enough detail to prompt the user.
-     *
-     * Important: this is a read-only check. We never delete an active
-     * lock from here — if another wstack instance is alive, the caller
-     * should bail or run with a fresh session instead.
-     */
-    checkAbandoned(): Promise<AbandonedSession | null>;
-    /**
-     * Claim the lock for the given session. Overwrites any existing lock
-     * — the caller should have already handled abandonment (via
-     * `checkAbandoned`) before calling this.
-     */
-    write(sessionId: string): Promise<void>;
-    /**
-     * Release the lock. Idempotent — silently succeeds if the file is
-     * already gone (e.g. someone else cleared it, or the directory was
-     * wiped).
-     */
-    clear(): Promise<void>;
-    private readLock;
-}
-
-declare class ToolExecutor {
-    private readonly registry;
-    private readonly opts;
-    private readonly serializer;
-    private readonly iterationTimeoutMs;
-    constructor(registry: {
-        get(name: string): Tool | undefined;
-        list(): Tool[];
-    }, opts: ToolExecutorOptions);
-    /**
-     * Execute a batch of tool uses using the configured strategy.
-     * Returns the execution results and the remaining output budget.
-     */
-    executeBatch(toolUses: ToolUseBlock[], ctx: Context, strategy: ToolExecutorStrategy): Promise<ToolBatchResult>;
-    /**
-     * Execute a single tool with timeout, permission check, and output capping.
-     * Emits `tool.started` via the injected EventBus (if any) right before
-     * invoking the tool — closes the observability gap between "model decided
-     * to call a tool" and "tool.executed".
-     */
-    executeTool(tool: Tool, use: ToolUseBlock, ctx: Context, budget: number): Promise<ToolResultBlock>;
-    private runWithTimeout;
-    private runStreamedTool;
-    private unknownToolResult;
-    private deniedResult;
-    private decrementBudget;
-    /**
-     * Compute the suggestedPattern string for a tool+input pair.
-     * Matches the logic in DefaultPermissionPolicy so the TUI shows the
-     * same subject that the trust file would use.
-     */
-    private subjectFor;
-}
-
-/**
- * L2-A: read-only view over a `SessionStore` with query, replay, search,
- * and export helpers. Implemented on top of the public `SessionStore`
- * surface so any concrete store can be inspected without re-implementation.
- *
- * The heavy operations re-parse the JSONL stream on every call — fine for
- * /resume and one-off analytics. Wrap with a memoizing decorator if needed.
- */
-declare class DefaultSessionReader implements SessionReader {
-    private readonly store;
-    constructor(opts: DefaultSessionReaderOptions);
-    query(q?: SessionQuery): Promise<SessionSummaryLite[]>;
-    replay(sessionId: string): AsyncIterable<SessionEvent>;
-    search(q: SessionSearchQuery, sessionId?: string): Promise<SessionSearchHit[]>;
-    export(sessionId: string, opts: SessionExportOptions): Promise<string>;
-    metadata(sessionId: string): Promise<SessionMetadata>;
-}
-
-/**
- * In-memory metrics sink. Suitable for embedded use, tests, and /metrics
- * scrape over HTTP. For production push-based pipelines, write an adapter
- * that implements MetricsSink and forwards to OTLP/StatsD/Prometheus.
- */
-declare class InMemoryMetricsSink implements MetricsSink {
-    private counters;
-    private gauges;
-    private histograms;
-    counter(name: string, value?: number, labels?: MetricLabels): void;
-    gauge(name: string, value: number, labels?: MetricLabels): void;
-    histogram(name: string, value: number, labels?: MetricLabels): void;
-    snapshot(): MetricsSnapshot;
-    reset(): void;
-    private getOrCreate;
-}
-/** Cheap noop sink — drop-in default when observability is not configured. */
-declare class NoopMetricsSink implements MetricsSink {
-    counter(): void;
-    gauge(): void;
-    histogram(): void;
-    snapshot(): MetricsSnapshot;
-    reset(): void;
-}
-
-/**
- * Aggregates registered health checks. Worst status wins — one unhealthy check
- * makes the whole system unhealthy. Use timeouts so a slow probe can't stall
- * the response.
- */
-declare class DefaultHealthRegistry implements HealthRegistry {
-    private checks;
-    private readonly timeoutMs;
-    constructor(opts?: {
-        timeoutMs?: number;
-    });
-    register(check: HealthCheck): void;
-    unregister(name: string): void;
-    run(): Promise<AggregateHealth>;
-    private runOne;
-}
-
-/**
- * Default tracer is a noop — zero overhead when observability is not wired up.
- * Replace at runtime with an OpenTelemetry-backed Tracer to enable real spans.
- */
-declare class NoopTracer implements Tracer {
-    startSpan(): Span;
-}
-
-/**
- * Lightweight OTel adapter. Doesn't pull in `@opentelemetry/api` directly —
- * the user passes their already-initialized OTel Tracer through, and this
- * wrapper translates our minimal Span surface onto theirs.
- *
- * Usage:
- *   import { trace } from '@opentelemetry/api';
- *   const tracer = trace.getTracer('wrongstack', '1.0');
- *   const wrappedTracer = new OTelTracer(tracer);
- *   // pass `wrappedTracer` as Agent.tracer / ToolExecutor.tracer.
- *
- * The shape of the upstream Tracer is intentionally typed loosely so we
- * don't need a build-time dependency. Anything OTel-compatible works,
- * including OpenInference, Tempo, etc.
- */
-
-interface OTelLikeSpan {
-    setAttribute(key: string, value: string | number | boolean): unknown;
-    recordException(err: {
-        message: string;
-        stack?: string;
-        name?: string;
-    }): unknown;
-    setStatus?(status: {
-        code: number;
-        message?: string;
-    }): unknown;
-    end(): unknown;
-}
-interface OTelLikeTracer {
-    startSpan(name: string, options?: {
-        attributes?: Record<string, string | number | boolean>;
-    }): OTelLikeSpan;
-}
-declare class OTelTracer implements Tracer {
-    private readonly upstream;
-    constructor(upstream: OTelLikeTracer);
-    startSpan(name: string, attrs?: Record<string, string | number | boolean>): Span;
-}
-
-/**
- * Subscribes a MetricsSink to the EventBus. Returns an unsubscribe function
- * that detaches all listeners. This is the single integration point between
- * the agent's event stream and the observability layer — no metric calls
- * leak into core call sites.
- */
-declare function wireMetricsToEvents(events: EventBus, sink: MetricsSink): () => void;
-
-/**
- * Render a `MetricsSnapshot` as Prometheus text-format bytes. The output
- * always ends with a trailing newline (Prometheus requires it).
- */
-declare function renderPrometheus(snapshot: MetricsSnapshot): string;
-/** MIME type Prometheus servers must respond with on /metrics. */
-declare const PROMETHEUS_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
-interface MetricsServerOptions {
-    port: number;
-    /** Bind address. Defaults to 127.0.0.1 so we don't accidentally expose metrics publicly. */
-    host?: string;
-    sink: MetricsSink;
-    /** Path to serve on. Defaults to /metrics. */
-    path?: string;
-    /**
-     * V2-C: optional health registry. When provided, the server also responds
-     * on `/healthz` (configurable via `healthPath`) with a JSON aggregate of
-     * every registered health check. K8s probes expect a single HTTP server
-     * exposing both `/metrics` and `/healthz`, so we mount them on the same
-     * port rather than opening a sibling listener.
-     */
-    healthRegistry?: HealthRegistry;
-    /** Path to serve health JSON on. Defaults to /healthz. */
-    healthPath?: string;
-}
-interface MetricsServerHandle {
-    port: number;
-    url: string;
-    close(): Promise<void>;
-}
-/**
- * Start an HTTP server that exposes a Prometheus scrape endpoint.
- * Uses node:http directly to avoid pulling a framework into the core graph.
- *
- * Why bind to 127.0.0.1 by default: telemetry endpoints inside an agent
- * process can leak prompt content via metric labels (tool name, error
- * message, etc.). The default keeps that on the loopback interface;
- * operators who want network scraping opt in explicitly with host: '0.0.0.0'.
- */
-declare function startMetricsServer(opts: MetricsServerOptions): Promise<MetricsServerHandle>;
-
-/**
- * V2-A: OTLP/JSON metrics push exporter.
- *
- * Periodically POSTs `MetricsSink.snapshot()` to an OTLP HTTP receiver
- * (the OpenTelemetry Collector, vendor agents like Honeycomb, Datadog,
- * Grafana Cloud, etc.). The wire format is OTLP/JSON v1.0 — covered by
- * the spec at github.com/open-telemetry/opentelemetry-proto.
- *
- * Why no `@opentelemetry/*` dep: the core graph is intentionally
- * dependency-free. The JSON shape is well-defined and stable; bringing
- * in the official SDK would add ~3MB and pin us to its release cadence.
- * Operators who need the OTLP gRPC transport or vendor-specific quirks
- * can wrap an `@opentelemetry/exporter-metrics-otlp-grpc` in a custom
- * `MetricsSink` instead — the seam exists.
- */
-interface OtlpMetricsExporterOptions {
-    /** Source of metric data. The exporter reads `snapshot()` per interval. */
-    sink: MetricsSink;
-    /**
-     * OTLP HTTP endpoint base URL. Path `/v1/metrics` is appended unless
-     * the URL already ends with `/v1/metrics` (idempotent).
-     * Example: `http://otel-collector:4318` or `https://otlp.example.com`.
-     */
-    endpoint: string;
-    /** Push interval in milliseconds. Defaults to 30s (Prometheus default). */
-    intervalMs?: number;
-    /** Optional bearer token / API key (sent as `Authorization`). */
-    authorization?: string;
-    /** Extra request headers (vendor-specific keys go here). */
-    headers?: Record<string, string>;
-    /** Resource attributes attached to every export. Defaults: `service.name=wrongstack`. */
-    resourceAttributes?: Record<string, string>;
-    /** Instrumentation scope. Default: `wrongstack`. */
-    scopeName?: string;
-    /** Per-request timeout. Defaults to 10s. */
-    timeoutMs?: number;
-    /** Override fetch (for tests). Defaults to global `fetch`. */
-    fetchImpl?: typeof globalThis.fetch;
-    /** Called when a push fails. Defaults to silent (telemetry must never crash the host). */
-    onError?: (err: unknown) => void;
-}
-interface OtlpMetricsExporterHandle {
-    /** Push immediately (in addition to the scheduled interval). */
-    flush(): Promise<void>;
-    /** Stop the timer, attempt a final flush, then resolve. */
-    stop(): Promise<void>;
-}
-interface OtlpAttribute$1 {
-    key: string;
-    value: {
-        stringValue: string;
-    };
-}
-interface OtlpDataPoint {
-    attributes: OtlpAttribute$1[];
-    timeUnixNano: string;
-    asDouble?: number;
-    asInt?: string;
-    count?: string;
-    sum?: number;
-    quantileValues?: {
-        quantile: number;
-        value: number;
-    }[];
-}
-interface OtlpMetric {
-    name: string;
-    description?: string;
-    unit?: string;
-    sum?: {
-        dataPoints: OtlpDataPoint[];
-        aggregationTemporality: 2;
-        isMonotonic: true;
-    };
-    gauge?: {
-        dataPoints: OtlpDataPoint[];
-    };
-    summary?: {
-        dataPoints: OtlpDataPoint[];
-    };
-}
-interface OtlpExportRequest {
-    resourceMetrics: {
-        resource: {
-            attributes: OtlpAttribute$1[];
-        };
-        scopeMetrics: {
-            scope: {
-                name: string;
-                version?: string;
-            };
-            metrics: OtlpMetric[];
-        }[];
-    }[];
-}
-/**
- * Build the OTLP/JSON export body from a sink snapshot. Exported for tests
- * and for callers that want to ship via their own transport.
- */
-declare function buildOtlpMetricsRequest(sink: MetricsSink, opts?: {
-    resourceAttributes?: Record<string, string>;
-    scopeName?: string;
-}): OtlpExportRequest;
-/**
- * Start pushing metrics to an OTLP HTTP receiver. Returns a handle with
- * `flush()` and `stop()`.
- */
-declare function startOtlpMetricsExporter(opts: OtlpMetricsExporterOptions): OtlpMetricsExporterHandle;
-
-type SpanAttrValue = string | number | boolean;
-interface RecordedSpan {
-    traceId: string;
-    spanId: string;
-    name: string;
-    startTimeUnixNano: bigint;
-    endTimeUnixNano?: bigint;
-    attributes: Record<string, SpanAttrValue>;
-    status: {
-        code: number;
-        message?: string;
-    };
-}
-interface OtlpTraceExporterOptions {
-    /** OTLP HTTP endpoint base URL. `/v1/traces` is appended unless already present. */
-    endpoint: string;
-    /** Push interval in milliseconds. Defaults to 5s (traces are bursty). */
-    intervalMs?: number;
-    /** Hard cap on buffered spans. When exceeded, oldest are dropped. Defaults to 2048. */
-    maxBufferedSpans?: number;
-    /** Authorization header. */
-    authorization?: string;
-    /** Extra request headers. */
-    headers?: Record<string, string>;
-    /** Resource attributes. Defaults to `service.name=wrongstack`. */
-    resourceAttributes?: Record<string, string>;
-    /** Instrumentation scope name. Default `wrongstack`. */
-    scopeName?: string;
-    /** Per-request timeout in ms. Default 10s. */
-    timeoutMs?: number;
-    /** Override fetch (for tests). */
-    fetchImpl?: typeof globalThis.fetch;
-    /** Called on push failure. Defaults to silent. */
-    onError?: (err: unknown) => void;
-}
-interface OtlpTraceExporterHandle {
-    /** The Tracer to install on Agent / ToolExecutor. */
-    readonly tracer: Tracer;
-    /** Push buffered spans immediately. */
-    flush(): Promise<void>;
-    /** Stop the timer, push remaining spans, resolve. */
-    stop(): Promise<void>;
-    /** Test helper: snapshot of spans currently in the buffer (not yet pushed). */
-    readonly buffered: () => readonly RecordedSpan[];
-}
-interface OtlpAttribute {
-    key: string;
-    value: {
-        stringValue: string;
-    } | {
-        boolValue: boolean;
-    } | {
-        doubleValue: number;
-    } | {
-        intValue: string;
-    };
-}
-interface OtlpSpan {
-    traceId: string;
-    spanId: string;
-    name: string;
-    kind: 1;
-    startTimeUnixNano: string;
-    endTimeUnixNano: string;
-    attributes: OtlpAttribute[];
-    status: {
-        code: number;
-        message?: string;
-    };
-}
-interface OtlpTracesRequest {
-    resourceSpans: {
-        resource: {
-            attributes: OtlpAttribute[];
-        };
-        scopeSpans: {
-            scope: {
-                name: string;
-            };
-            spans: OtlpSpan[];
-        }[];
-    }[];
-}
-declare function buildOtlpTracesRequest(spans: readonly RecordedSpan[], opts?: {
-    resourceAttributes?: Record<string, string>;
-    scopeName?: string;
-}): OtlpTracesRequest;
-/**
- * Start the OTLP trace exporter. Returns a `Tracer` to install on the
- * runtime (`Agent.run` etc.) and `flush()`/`stop()` controls.
- */
-declare function startOtlpTraceExporter(opts: OtlpTraceExporterOptions): OtlpTraceExporterHandle;
-
-type ContextManagerAction = 'check' | 'summary' | 'prune' | 'add_note' | 'compact';
-interface ContextManagerInput {
-    action: ContextManagerAction;
-    /** 0-based message indices for prune/summary (inclusive). */
-    from?: number;
-    to?: number;
-    /** Text for add_note / summary actions. For summary, this is the LLM-provided summary text. */
-    text?: string;
-    /** Inject after which index (for add_note). Defaults to prepend (0). */
-    afterIndex?: number;
-}
-interface ContextManagerResult {
-    action: ContextManagerAction;
-    beforeTokens: number;
-    afterTokens?: number;
-    removedCount?: number;
-    messageCount: number;
-    summary?: string;
-    notes?: string;
-}
-/**
- * Options for creating a context manager tool.
- * `compactor` is required for the "compact" action; without it the action returns an error.
- */
-interface ContextManagerToolOptions {
-    compactor?: Compactor;
-    /**
-     * Optional sub-LLM summarizer. When provided, the "summary" action calls this
-     * to produce real summaries of message ranges instead of placeholder text.
-     * (signature matches Provider.complete — return the summary text in result.content[0].text)
-     */
-    summarizer?: (messages: Message[]) => Promise<string>;
-}
-declare function createContextManagerTool(opts?: ContextManagerToolOptions): Tool<ContextManagerInput, ContextManagerResult>;
-/** Pre-built instance with no compactor — compact action will return an error. */
-declare const contextManagerTool: Tool<ContextManagerInput, ContextManagerResult>;
-
-/**
- * Built-in MCP server presets available to all WrongStack users out of the box.
- * These servers must be explicitly enabled in config (disabled by default).
- *
- * To enable: set `mcpServers: { serverName: { enabled: true } }` in your config.
- *
- * Some servers require environment variables or additional config — see notes below.
- *
- * Transport types:
- *   stdio       — spawns a local npm package binary via child_process
- *   sse         — HTTP SSE endpoint (client POSTs requests)
- *   streamable-http — session-based HTTP with NDJSON responses
- */
-/** Filesystem access: read, write, list, search, tree. Good for exploring projects. */
-declare const filesystemServer: () => MCPServerConfig;
-/** GitHub API: issues, PRs, repos, search, file operations. Requires GITHUB_PERSONAL_ACCESS_TOKEN. */
-declare const githubServer: () => MCPServerConfig;
-/**
- * Context7 — codebase-aware documentation and Q&A using context from your code.
- * Live documentation for any library, grounded in your actual versions.
- */
-declare const context7Server: () => MCPServerConfig;
-/**
- * Brave Search — web search via Brave Browser's API.
- * Requires BRAVE_SEARCH_API_KEY. Free tier: 2,000 queries/month.
- * Sign up at https://api.search.brave.com/
- */
-declare const braveSearchServer: () => MCPServerConfig;
-/**
- * Block (Block, Inc.) — Postgres database access via SQL.
- * Useful for running queries against a connected database during development.
- */
-declare const blockServer: () => MCPServerConfig;
-/**
- * EverArt — AI image generation via various providers.
- * Requires EVERART_API_KEY.
- */
-declare const everArtServer: () => MCPServerConfig;
-/**
- * Slack — messaging, channels, search.
- * Requires SLACK_BOT_TOKEN and either SLACK_TEAM_ID or SLACK_USER_TOKEN.
- */
-declare const slackServer: () => MCPServerConfig;
-/**
- * AWS knowledge base — EC2, S3, Lambda, IAM, CloudFormation, cost management.
- * Requires AWS access key + secret in environment.
- */
-declare const awsServer: () => MCPServerConfig;
-/**
- * Google Maps — directions, distance matrix, geocoding, places.
- * Requires GOOGLE_MAPS_API_KEY.
- */
-declare const googleMapsServer: () => MCPServerConfig;
-/** Sentinel — security vulnerability scanning (sentinel-labs). */
-declare const sentinelServer: () => MCPServerConfig;
-/** Everything bundled — full set of built-in servers. Useful for `wstack mcp add --all`. */
-declare const allServers: () => Record<string, MCPServerConfig>;
-
-export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, type AbandonedSession, type AgentFactory, type AgentFactoryResult, type AgentRunnerOptions, type AttachmentStoreOptions, AutoCompactionMiddleware, AutonomousRunner, type AutonomousRunnerOptions, BUG_HUNTER_AGENT, type CompactorOptions, type ConfigLoaderOptions, type ConfigMigration, ConfigMigrationError, type ConfigSource, type ContextManagerAction, type ContextManagerInput, type ContextManagerResult, type ContextManagerToolOptions, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, type DefaultLoggerOptions, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, type DefaultModelsRegistryOptions, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, DefaultTokenCounter, Director, DirectorBudgetError, type DirectorPromptParts, type DirectorSessionFactory, type DirectorSessionFactoryOptions, type DoneCheckResult, DoneConditionChecker, FLEET_ROSTER, FleetBus, type FleetEvent, type FleetHandler, type FleetUsage, FleetUsageAggregator, type GeneratedTask, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, type IntelligentCompactorOptions, LLMSelector, type LLMSelectorOptions, type MemoryStoreOptions, type MetricsServerHandle, type MetricsServerOptions, type MigrationContext, type MigrationResult, type ModeLoaderOptions, type MultiAgentCoordinatorOptions, NoopMetricsSink, NoopTracer, OTelTracer, type OtlpMetricsExporterHandle, type OtlpMetricsExporterOptions, type OtlpTraceExporterHandle, type OtlpTraceExporterOptions, PROMETHEUS_CONTENT_TYPE, type PermissionPolicyOptions, type PersistedQueueItem, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, type RecoveryLockOptions, SECURITY_SCANNER_AGENT, type SecretVaultOptions, SelectiveCompactor, type SelectiveCompactorOptions, type SessionStoreOptions, type SkillLoaderOptions, SpecDrivenDev, type SpecDrivenDevOptions, SpecParser, type SubagentPromptParts, type SubagentUsageSnapshot, TaskFlow, type TaskFlowEventMap, type TaskFlowEventName, type TaskFlowExecutionContext, type TaskFlowOptions, type TaskFlowPhase, TaskGenerator, type TaskGeneratorOptions, type TaskStore, TaskTracker, type TaskTrackerOptions, type TaskTransition, ToolExecutor, allServers, awsServer, blockServer, braveSearchServer, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createContextManagerTool, createMessage, decryptConfigSecrets, encryptConfigSecrets, everArtServer, filesystemServer, githubServer, googleMapsServer, loadProjectModes, loadUserModes, makeAgentSubagentRunner, makeDirectorSessionFactory, migratePlaintextSecrets, renderPrometheus, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, sentinelServer, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, wireMetricsToEvents };
+export { D as DefaultLogger, a as DefaultLoggerOptions } from '../logger-BH6AE0W9.js';
+export { AbandonedSession, AttachmentStoreOptions, ConfigLoaderOptions, ConfigMigration, ConfigMigrationError, ConfigSource, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultSessionStore, MemoryStoreOptions, MigrationContext, MigrationResult, PersistedQueueItem, QueueStore, RecoveryLock, RecoveryLockOptions, SessionAnalyzer, SessionStoreOptions, runConfigMigrations } from '../storage/index.js';
+export { D as DefaultSessionReader } from '../session-reader-Drq8RvJu.js';
+export { D as DefaultSecretScrubber, a as DefaultSecretVault, S as SecretVaultOptions, d as decryptConfigSecrets, e as encryptConfigSecrets, m as migratePlaintextSecrets, r as rewriteConfigEncrypted } from '../secret-scrubber-DF88luOe.js';
+export { DefaultPermissionPolicy, PermissionPolicyOptions } from '../security/index.js';
+export { C as CompactorOptions, D as DefaultErrorHandler, a as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-CpuJPYm9.js';
+export { AutoCompactionMiddleware, AutonomousRunner, AutonomousRunnerOptions, DefaultSkillLoader, DoneCheckResult, DoneConditionChecker, IntelligentCompactor, IntelligentCompactorOptions, SelectiveCompactor, SelectiveCompactorOptions, SkillLoaderOptions } from '../execution/index.js';
+export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AgentFactory, AgentFactoryResult, AgentRunnerOptions, BUG_HUNTER_AGENT, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultMultiAgentCoordinator, Director, DirectorBudgetError, DirectorPromptParts, DirectorSessionFactory, DirectorSessionFactoryOptions, FLEET_ROSTER, FleetBus, FleetEvent, FleetHandler, FleetUsage, FleetUsageAggregator, MultiAgentCoordinatorOptions, REFACTOR_PLANNER_AGENT, SECURITY_SCANNER_AGENT, SubagentPromptParts, SubagentUsageSnapshot, composeDirectorPrompt, composeSubagentPrompt, makeAgentSubagentRunner, makeDirectorSessionFactory, rosterSummaryFromConfigs } from '../coordination/index.js';
+export { B as BudgetExceededError, a as BudgetKind, b as BudgetLimits, c as BudgetUsage, S as SubagentBudget } from '../multi-agent-fmkRHtof.js';
+export { I as InMemoryAgentBridge, a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-6KPqsFx6.js';
+export { D as DefaultModelsRegistry, a as DefaultModelsRegistryOptions, c as classifyFamily } from '../models-registry-DqzwpBQy.js';
+export { DefaultModeStore, LLMSelector, LLMSelectorOptions, ModeLoaderOptions, loadProjectModes, loadUserModes } from '../models/index.js';
+export { DefaultTaskStore, GeneratedTask, SpecDrivenDev, SpecDrivenDevOptions, SpecParser, TaskFlow, TaskFlowEventMap, TaskFlowEventName, TaskFlowExecutionContext, TaskFlowOptions, TaskFlowPhase, TaskGenerator, TaskGeneratorOptions, TaskStore, TaskTracker, TaskTrackerOptions, TaskTransition } from '../sdd/index.js';
+export { DefaultHealthRegistry, InMemoryMetricsSink, MetricsServerHandle, MetricsServerOptions, NoopMetricsSink, NoopTracer, OTelTracer, OtlpMetricsExporterHandle, OtlpMetricsExporterOptions, OtlpTraceExporterHandle, OtlpTraceExporterOptions, PROMETHEUS_CONTENT_TYPE, buildOtlpMetricsRequest, buildOtlpTracesRequest, renderPrometheus, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, wireMetricsToEvents } from '../observability/index.js';
+export { C as ContextManagerAction, a as ContextManagerInput, b as ContextManagerResult, c as ContextManagerToolOptions, d as allServers, e as awsServer, f as blockServer, g as braveSearchServer, h as context7Server, i as contextManagerTool, j as createContextManagerTool, k as everArtServer, l as filesystemServer, m as githubServer, n as googleMapsServer, s as sentinelServer, o as slackServer } from '../mcp-servers-Dzgg4x1w.js';
+import '../logger-BMQgxvdy.js';
+import '../events-BMNaEFZl.js';
+import '../context-BmM2xGUZ.js';
+import '../memory-CEXuo7sz.js';
+import '../wstack-paths-BGu2INTm.js';
+import '../config-BU9f_5yH.js';
+import '../models-registry-Y2xbog0E.js';
+import '../secret-vault-DoISxaKO.js';
+import '../secret-scrubber-CicHLN4G.js';
+import '../input-reader-E-ffP2ee.js';
+import '../compactor-B4mQZXf2.js';
+import '../skill-DhfSizKv.js';
+import '../plugin-DJk6LL8B.js';
+import '../observability-BhnVLBLS.js';
+import '../renderer-rk_1Swwc.js';
+import '../selector-BbJqiEP4.js';
+import 'node:events';
+import '../mode-CV077NjV.js';
+import '../task-graph-BITvWt4t.js';