@brainst0rm/core 0.13.0

package/dist/index.d.ts

@@ -0,0 +1,2086 @@
+import { Session, TurnContext, AgentEvent, ToolPermission, TaskProfile, ModelEntry, Complexity } from '@brainst0rm/shared';
+import { BrainstormConfig, StormFrontmatter } from '@brainst0rm/config';
+import { ProviderRegistry } from '@brainst0rm/providers';
+import { BrainstormRouter, CostTracker } from '@brainst0rm/router';
+import { ToolRegistry, PermissionCheckFn, BrainstormToolDef } from '@brainst0rm/tools';
+import { BrainstormGateway } from '@brainst0rm/gateway';
+import { PatternRepository, SessionPattern } from '@brainst0rm/db';
+
+interface ConversationMessage {
+    role: "user" | "assistant" | "system";
+    content: string;
+}
+declare class SessionManager {
+    private db;
+    private sessions;
+    private messages;
+    private currentSession;
+    private conversationHistory;
+    private turnCount;
+    private sessionStartTime;
+    /** Cached token estimate — updated incrementally on addMessage, invalidated on compact. */
+    private cachedTokenCount;
+    constructor(db: any);
+    start(projectPath: string): Session;
+    resume(sessionId: string): Session | null;
+    /** Resume the most recent session for the given project path. */
+    resumeLatest(projectPath?: string): Session | null;
+    /** Fork a session: create a new session with a copy of the conversation history. */
+    fork(sessionId: string): Session | null;
+    addUserMessage(content: string): void;
+    addAssistantMessage(content: string, modelId?: string): void;
+    /** Inject turn context as an invisible system message the model sees but the user doesn't. */
+    addTurnContext(ctx: TurnContext): void;
+    /** Incrementally update cached token count for a new message. */
+    private addTokenDelta;
+    /** Sync session cost to DB. Call after each tool to keep DB accurate. */
+    syncSessionCost(cost: number): void;
+    getTurnCount(): number;
+    incrementTurn(): number;
+    getSessionMinutes(): number;
+    getHistory(): ConversationMessage[];
+    getSession(): Session | null;
+    listRecent(limit?: number): Session[];
+    getTokenEstimate(): number;
+    needsCompaction(contextWindow: number): boolean;
+    compact(options: {
+        contextWindow: number;
+        keepRecent?: number;
+        summarizeModel?: any;
+    }): Promise<{
+        compacted: boolean;
+        removed: number;
+        tokensBefore: number;
+        tokensAfter: number;
+        summaryCost: number;
+    }>;
+}
+
+/**
+ * Build State Tracker — persists last build/test result across turns.
+ * When a shell command matches the project's build_command or test_command,
+ * the result is captured. If the build is broken, a persistent warning
+ * is injected into the system context until it passes again.
+ */
+interface BuildResult {
+    command: string;
+    exitCode: number;
+    errorSummary: string;
+    timestamp: number;
+}
+type BuildStatus = "passing" | "failing" | "unknown";
+declare class BuildStateTracker {
+    private lastBuild;
+    private lastTest;
+    private buildPatterns;
+    private testPatterns;
+    constructor(buildCommand?: string, testCommand?: string);
+    /** Check if a shell command is a build or test command and record the result. */
+    recordShellResult(command: string, exitCode: number, stderr: string): void;
+    getStatus(): BuildStatus;
+    getLastBuild(): BuildResult | null;
+    getLastTest(): BuildResult | null;
+    /** Format a persistent warning if the build is broken. Empty string if passing. */
+    formatBuildWarning(): string;
+    clear(): void;
+}
+
+/**
+ * Agent Middleware — composable interceptors for the agent loop.
+ *
+ * Inspired by DeerFlow's 12-middleware pipeline, adapted for Brainstorm's
+ * TypeScript architecture. Each middleware handles one cross-cutting concern.
+ */
+interface AgentMiddleware {
+    /** Unique middleware name. */
+    name: string;
+    /** Called before each agent turn. Modify state or inject context. */
+    beforeAgent?(state: MiddlewareState): MiddlewareState | void;
+    /** Called after model response, before tool execution. Modify or filter the response. */
+    afterModel?(message: MiddlewareMessage): MiddlewareMessage | void;
+    /** Called before each tool execution. Can modify, block, or redirect. */
+    wrapToolCall?(call: MiddlewareToolCall): MiddlewareToolCall | MiddlewareBlock | void;
+    /** Called after each tool execution. Modify the result or trigger side effects. */
+    afterToolResult?(result: MiddlewareToolResult): MiddlewareToolResult | void;
+}
+interface MiddlewareState {
+    turn: number;
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    systemPrompt: string;
+    toolNames: string[];
+    metadata: Record<string, unknown>;
+}
+interface MiddlewareMessage {
+    text: string;
+    toolCalls: MiddlewareToolCall[];
+    model: string;
+    tokens: {
+        input: number;
+        output: number;
+    };
+}
+interface MiddlewareToolCall {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+interface MiddlewareToolResult {
+    toolCallId: string;
+    name: string;
+    ok: boolean;
+    output: unknown;
+    error?: string;
+    durationMs: number;
+}
+interface MiddlewareBlock {
+    blocked: true;
+    reason: string;
+    middleware: string;
+}
+/** Type guard for blocked tool calls. */
+declare function isBlocked(result: MiddlewareToolCall | MiddlewareBlock | void): result is MiddlewareBlock;
+
+/**
+ * Middleware Pipeline — chains middleware in order and runs them at each hook point.
+ */
+
+declare class MiddlewarePipeline {
+    private middleware;
+    /** Add middleware to the pipeline. Order matters — first added runs first. */
+    use(mw: AgentMiddleware): void;
+    /** Remove middleware by name. Protected middleware (security-scan, subagent-limit) cannot be removed. */
+    remove(name: string): void;
+    /** Get all registered middleware names. */
+    list(): string[];
+    /** Run beforeAgent hooks. Returns modified state. */
+    runBeforeAgent(state: MiddlewareState): MiddlewareState;
+    /** Run afterModel hooks. Returns modified message. */
+    runAfterModel(message: MiddlewareMessage): MiddlewareMessage;
+    /** Run wrapToolCall hooks. Returns modified call or block signal. */
+    runWrapToolCall(call: MiddlewareToolCall): MiddlewareToolCall | MiddlewareBlock;
+    /** Run afterToolResult hooks. Returns modified result. */
+    runAfterToolResult(result: MiddlewareToolResult): MiddlewareToolResult;
+}
+
+interface CompactionCallbacks {
+    /** Current estimated token count of conversation history. */
+    getTokenEstimate: () => number;
+    /** Run compaction on the conversation. Returns compaction result. */
+    compact: (options: {
+        contextWindow: number;
+        keepRecent?: number;
+        summarizeModel?: any;
+    }) => Promise<{
+        compacted: boolean;
+        removed: number;
+        tokensBefore: number;
+        tokensAfter: number;
+        summaryCost: number;
+    }>;
+}
+interface AgentLoopOptions {
+    config: BrainstormConfig;
+    registry: ProviderRegistry;
+    router: BrainstormRouter;
+    costTracker: CostTracker;
+    tools: ToolRegistry;
+    sessionId: string;
+    projectPath: string;
+    systemPrompt: string;
+    disableTools?: boolean;
+    /** Override model selection — bypass the router. Used by cross-model workflows. */
+    preferredModelId?: string;
+    /** Override max agentic steps (default: config.general.maxSteps). */
+    maxSteps?: number;
+    /** Context compaction support. If provided, compaction is checked before each LLM call. */
+    compaction?: CompactionCallbacks;
+    /** AbortSignal to cancel in-flight LLM calls and tool executions. */
+    signal?: AbortSignal;
+    /** Permission check function. When provided, tools are gated by this check. */
+    permissionCheck?: PermissionCheckFn;
+    /** Callback to inject turn context after each completion. */
+    onTurnComplete?: (ctx: TurnContext) => void;
+    /** Build state tracker — records build/test results for persistent warnings. */
+    buildState?: BuildStateTracker;
+    /** Internal: tracks fallback depth to cap retries (max 2). */
+    _retryDepth?: number;
+    /** Internal: tracks models already tried for error reporting. */
+    _modelsTried?: string[];
+    /** Optional middleware pipeline for composable agent interceptors. */
+    middleware?: MiddlewarePipeline;
+    /** Enable trajectory recording to JSONL. */
+    trajectoryEnabled?: boolean;
+    /** Session checkpointer for crash recovery. */
+    checkpointer?: {
+        saveIfNeeded: (data: any) => boolean;
+    };
+    /** Role-based tool filter. When set, restricts which tools the agent can use. */
+    roleToolFilter?: {
+        allowedTools?: string[];
+        blockedTools?: string[];
+    };
+}
+declare function runAgentLoop(messages: ConversationMessage[], options: AgentLoopOptions): AsyncGenerator<AgentEvent>;
+
+/**
+ * Expert Persona Engine — composable expert playbooks with model-specific tuning.
+ *
+ * Personas are 200+ line expert playbooks carrying domain expertise,
+ * structured reasoning frameworks, output templates, and model-specific
+ * adaptations. They compose with skills and project context.
+ */
+interface PersonaFramework {
+    name: string;
+    description: string;
+    content: string;
+}
+interface ModelAdaptation {
+    /** Regex pattern matching model IDs (e.g., /opus|o3|gemini.*pro/) */
+    modelPattern: RegExp;
+    /** Label for this tier */
+    tier: "deep-thinker" | "balanced" | "fast" | "reasoning" | "vision";
+    /** Prompt modifier injected after the base prompt */
+    modifier: string;
+}
+interface Persona {
+    id: string;
+    name: string;
+    icon: string;
+    description: string;
+    /** The core expert playbook (200+ lines of domain expertise) */
+    basePrompt: string;
+    /** Embedded reasoning frameworks (C4, OWASP, Given/When/Then, etc.) */
+    frameworks: PersonaFramework[];
+    /** Structured output template the persona should follow */
+    outputTemplate?: string;
+    /** Model-specific adaptations — prompt adjusts based on which model receives it */
+    modelAdaptations: ModelAdaptation[];
+    /** Default tools this persona should have access to */
+    permissionMode: "auto" | "confirm" | "plan";
+    /** Default output style */
+    outputStyle: "concise" | "detailed" | "learning";
+    /** Default routing strategy */
+    routingStrategy: string;
+}
+/**
+ * Compose a persona's full system prompt, tuned for the specific model.
+ *
+ * Assembly order:
+ * 1. Base persona prompt (expert playbook)
+ * 2. Model-specific tuning (deep-thinker / balanced / fast / reasoning)
+ * 3. Relevant frameworks (based on token budget)
+ * 4. Output template
+ */
+declare function composePersonaPrompt(persona: Persona, modelId?: string, maxTokens?: number): string;
+declare function getPersona(id: string): Persona | undefined;
+declare function listPersonas(): Persona[];
+
+/**
+ * Output style modes control how verbose and educational the assistant's responses are.
+ *
+ * - concise: Default. Short answers, action-first, no extra explanations.
+ * - detailed: Longer explanations, reasoning shown, trade-offs discussed.
+ * - learning: Educational mode with ★ Insight annotations and trade-off analysis.
+ */
+type OutputStyle = 'concise' | 'detailed' | 'learning';
+/**
+ * Get the system prompt segment for an output style.
+ */
+declare function getOutputStylePrompt(style: OutputStyle): string;
+/**
+ * All valid output style names.
+ */
+declare const OUTPUT_STYLES: OutputStyle[];
+
+interface SystemPromptResult {
+    prompt: string;
+    frontmatter: StormFrontmatter | null;
+}
+declare function buildSystemPrompt(projectPath: string, outputStyle?: OutputStyle, basePromptOverride?: string): SystemPromptResult;
+/**
+ * Parse @file references from user input and inject file contents.
+ *
+ * Patterns: @path/to/file.ts, @./relative/path.js, @src/App.tsx
+ *
+ * Returns cleaned message (@ prefix stripped) and file content messages.
+ */
+declare function parseAtMentions(input: string, projectPath: string): {
+    cleanedInput: string;
+    fileContexts: Array<{
+        role: "user";
+        content: string;
+    }>;
+};
+/**
+ * Build a natural-language tool listing for injection into the system prompt.
+ * Helps models understand available tools without relying solely on AI SDK schemas.
+ */
+declare function buildToolAwarenessSection(tools: Array<{
+    name: string;
+    description: string;
+    permission: string;
+}>): string;
+
+type PermissionMode = "auto" | "confirm" | "plan";
+/**
+ * PermissionManager controls tool execution approval.
+ *
+ * Three modes cycle with Shift+Tab:
+ * - auto: all tools execute without asking (fastest, trust the model)
+ * - confirm: write/shell tools require [y/n/always] confirmation
+ * - plan: only read-only tools allowed (no writes, no shell)
+ *
+ * Supports persistent allowlists: "always allow" decisions survive across sessions.
+ * Stored in ~/.brainstorm/permissions.json and can also be set via config.toml.
+ */
+declare class PermissionManager {
+    private mode;
+    private sessionAlways;
+    private persistentAllowlist;
+    private persistentDenylist;
+    constructor(defaultMode?: PermissionMode, configPermissions?: {
+        allowlist?: string[];
+        denylist?: string[];
+        role?: "viewer" | "developer" | "admin";
+    });
+    getMode(): PermissionMode;
+    /** Cycle to the next permission mode. */
+    cycle(): PermissionMode;
+    setMode(mode: PermissionMode): void;
+    /**
+     * Check if a tool is allowed to execute in the current mode.
+     * Returns: 'allow' (proceed), 'confirm' (ask user), 'deny' (blocked).
+     */
+    check(toolName: string, toolPermission: ToolPermission): "allow" | "confirm" | "deny";
+    /** Mark a tool as "always allow" for this session only. */
+    alwaysAllow(toolName: string): void;
+    /** Persistently allow a tool across all future sessions. */
+    persistAllow(toolName: string): void;
+    /** Persistently deny a tool across all future sessions. */
+    persistDeny(toolName: string): void;
+    /** Remove a tool from both persistent lists. */
+    persistRemove(toolName: string): void;
+    /** Get current persistent allowlist. */
+    getAllowlist(): string[];
+    /** Get current persistent denylist. */
+    getDenylist(): string[];
+    private loadPersisted;
+    private savePersisted;
+    /** Get description of current mode for TUI display. */
+    getModeDescription(): string;
+    /** Get mode color for TUI. */
+    getModeColor(): string;
+    /** Format a user-friendly denial message with remediation guidance. */
+    formatDenialMessage(toolName: string, toolPermission: ToolPermission): string;
+}
+
+/** Increment the in-flight tool counter. Call before each tool execution. */
+declare function enterToolExecution(): void;
+/** Decrement the in-flight tool counter. Call after each tool completes. */
+declare function exitToolExecution(): void;
+/** Returns true if tools are currently executing (compaction should be deferred). */
+declare function isToolInFlight(): boolean;
+/**
+ * Estimate token count for a list of messages.
+ * Uses ~4 chars per token as a rough heuristic (good enough for budget checks).
+ */
+declare function estimateTokenCount(messages: ConversationMessage[]): number;
+/**
+ * Check if compaction is needed based on token count vs context window.
+ * Triggers at 80% of the model's context window.
+ */
+declare function needsCompaction(messages: ConversationMessage[], contextWindow: number): boolean;
+/** Get context usage as a percentage (0-100). Useful for pre-compaction warnings. */
+declare function getContextPercent(messages: ConversationMessage[], contextWindow: number): number;
+/**
+ * Compact conversation history by summarizing old messages.
+ *
+ * Strategy:
+ * 1. Keep system prompt (first message if role=system) intact
+ * 2. Keep the last `keepRecent` messages intact
+ * 3. Summarize everything in between using the provided model
+ * 4. Return the compacted message list
+ *
+ * If no model is available for summarization, falls back to simple truncation.
+ */
+declare function compactContext(messages: ConversationMessage[], options: {
+    contextWindow: number;
+    keepRecent?: number;
+    summarizeModel?: any;
+    pricing?: {
+        inputPer1MTokens: number;
+        outputPer1MTokens: number;
+    };
+}): Promise<{
+    messages: ConversationMessage[];
+    compacted: boolean;
+    summaryCost: number;
+}>;
+
+type SubagentType = "explore" | "plan" | "code" | "review" | "general" | "decompose" | "external" | "research";
+interface SubagentTypeConfig {
+    /** Tools this subagent type is allowed to use */
+    allowedTools: string[] | "all";
+    /** System prompt prefix for behavioral instructions */
+    systemPrompt: string;
+    /** Default max steps (keep focused subagents short) */
+    defaultMaxSteps: number;
+    /** Model complexity hint: 'cheap' routes to cost-first, 'capable' to quality-first */
+    modelHint: "cheap" | "capable";
+}
+/**
+ * Get the configuration for a subagent type.
+ */
+declare function getSubagentTypeConfig(type: SubagentType): SubagentTypeConfig;
+/**
+ * All valid subagent type names.
+ */
+declare const SUBAGENT_TYPE_NAMES: SubagentType[];
+/** Callback for subagent lifecycle hooks (injected to avoid circular deps with @brainst0rm/hooks). */
+type SubagentHookFn = (event: "SubagentStart" | "SubagentStop", context: {
+    subagentType: string;
+    prompt?: string;
+    budget?: number;
+    result?: string;
+    cost?: number;
+    toolCalls?: number;
+    model?: string;
+}) => Promise<void>;
+interface SubagentOptions {
+    config: BrainstormConfig;
+    registry: ProviderRegistry;
+    router: BrainstormRouter;
+    costTracker: CostTracker;
+    tools: ToolRegistry;
+    projectPath: string;
+    /** Subagent type — determines tool access, system prompt, and model hint. */
+    type?: SubagentType;
+    /** System prompt override (overrides type's default). */
+    systemPrompt?: string;
+    /** Max steps override (overrides type's default). */
+    maxSteps?: number;
+    /** Budget limit in dollars. If exceeded, subagent is terminated (parent continues). */
+    budgetLimit?: number;
+    /** Optional hook callback for SubagentStart/SubagentStop events. */
+    onHook?: SubagentHookFn;
+    /** Permission check — when provided, subagent tools are gated by this function. */
+    permissionCheck?: (toolName: string, toolPermission: any) => "allow" | "confirm" | "deny";
+    /** When true and container mode is active, code subagents get their own DockerSandbox. */
+    containerIsolation?: boolean;
+}
+interface SubagentResult {
+    text: string;
+    cost: number;
+    modelUsed: string;
+    toolCalls: string[];
+    type: SubagentType;
+    budgetExceeded: boolean;
+    partialOutput?: string;
+}
+/**
+ * Spawn an isolated subagent for a focused task.
+ *
+ * Subagents get their own context — they don't see the parent conversation.
+ * This prevents context bloat while enabling parallel work.
+ *
+ * The subagent type determines:
+ * - Which tools are available (explore = read-only, code = all)
+ * - System prompt behavior (review = bug-focused, plan = structured output)
+ * - Model selection hint (explore → cheap, code → capable)
+ */
+declare function spawnSubagent(task: string, options: SubagentOptions): Promise<SubagentResult>;
+/**
+ * Spawn multiple subagents in parallel.
+ * Uses Promise.allSettled so one failure doesn't kill all results.
+ */
+declare function spawnParallel(specs: Array<{
+    task: string;
+    type?: SubagentType;
+}>, options: SubagentOptions): Promise<SubagentResult[]>;
+
+interface SkillDefinition {
+    name: string;
+    description: string;
+    content: string;
+    source: "project" | "global" | "claude-compat";
+    /** Optional: restrict which tools this skill can use. */
+    tools?: string[];
+    /** Optional: routing preference when this skill is active. */
+    modelPreference?: "cheap" | "quality" | "fast" | "auto";
+    /** Optional: max agentic steps for this skill. */
+    maxSteps?: number;
+    /** Optional: system prompt override (separate from content which is the user prompt). */
+    systemPrompt?: string;
+}
+/**
+ * Load skills from .brainstorm/skills/ directories.
+ * Also loads Claude Code skills (.claude/commands/) for native compatibility.
+ *
+ * Skills are .md files with optional YAML frontmatter:
+ * ---
+ * description: "What this skill does"
+ * ---
+ * # Skill content (injected as prompt)
+ */
+declare function loadSkills(projectPath: string): SkillDefinition[];
+declare function findSkill(skills: SkillDefinition[], name: string): SkillDefinition | undefined;
+
+interface MemoryEntry {
+    id: string;
+    type: "user" | "project" | "feedback" | "reference";
+    name: string;
+    description: string;
+    content: string;
+    createdAt: number;
+    updatedAt: number;
+}
+declare class MemoryManager {
+    private memoryDir;
+    private indexPath;
+    private entries;
+    private indexDirty;
+    private indexTimer;
+    private gateway;
+    constructor(projectPath: string, gateway?: BrainstormGateway | null);
+    /** Save a memory entry. Creates or updates the file. */
+    save(entry: Omit<MemoryEntry, "id" | "createdAt" | "updatedAt">): MemoryEntry;
+    /** Get a memory entry by ID. */
+    get(id: string): MemoryEntry | undefined;
+    /** List all memory entries. */
+    list(): MemoryEntry[];
+    /** Delete a memory entry. */
+    delete(id: string): boolean;
+    /** Get context string for injection into system prompt (first 200 lines of index). */
+    getContextString(): string;
+    /** Get the memory directory path (for subagent access). */
+    getMemoryDir(): string;
+    /** Get raw file contents for all memory files (for dream consolidation). */
+    getRawFiles(): Array<{
+        filename: string;
+        content: string;
+    }>;
+    /** Search memories by TF-IDF relevance, with keyword fallback. */
+    search(query: string): MemoryEntry[];
+    private loadAll;
+    private parseMemoryFile;
+    /** Schedule a debounced index rebuild. */
+    private scheduleIndexUpdate;
+    /** Immediately write the index file if dirty. */
+    flushIndex(): void;
+    /** Backup a corrupt memory file instead of deleting it. */
+    private backupCorruptFile;
+}
+
+/**
+ * Memory consolidation ("dream") — the REM sleep for Brainstorm's memory system.
+ *
+ * Spawns a code-type subagent to review, deduplicate, and consolidate memory files.
+ * Inspired by Claude Code's auto-dream feature.
+ */
+declare const DREAM_SYSTEM_PROMPT = "You are a memory consolidation agent. Your job is to clean up and optimize a set of memory files stored as Markdown with YAML frontmatter.\n\n# Rules\n\n1. **Merge duplicates**: If two files cover the same topic, merge them into one file. Keep the most complete and recent information from both.\n2. **Resolve contradictions**: If two memories contradict each other, keep the one with more recent information. Add a note about what changed.\n3. **Convert dates**: Replace relative dates (\"yesterday\", \"last week\", \"recently\") with absolute dates if you can determine them from context.\n4. **Prune stale references**: If a memory references a specific file path, use the glob tool to check if it still exists. If not, note it as potentially stale.\n5. **Trim noise**: Remove memories that are purely ephemeral (task progress from completed work, debugging notes for resolved bugs) unless they contain lessons learned.\n6. **Preserve structure**: Each memory file must keep the YAML frontmatter format:\n   ```\n   ---\n   name: Memory Name\n   description: One-line description\n   type: user|project|feedback|reference\n   ---\n\n   Content here\n   ```\n7. **Update MEMORY.md**: After consolidation, rewrite the MEMORY.md index with links to all remaining files. Keep it under 200 lines.\n8. **Be conservative**: When uncertain whether to delete, keep the memory. Better to have a slightly redundant memory than lose important context.\n\n# Output\n\nAfter completing consolidation, summarize what you did:\n- How many files merged\n- How many files deleted\n- How many contradictions resolved\n- How many stale references found";
+/**
+ * Build the dream prompt with all current memory files embedded.
+ */
+declare function buildDreamPrompt(memoryDir: string, files: Array<{
+    filename: string;
+    content: string;
+}>): string;
+
+/**
+ * Filter a tool registry to only read-only tools (for plan mode).
+ */
+declare function getPlanModeTools(registry: ToolRegistry): Record<string, any>;
+/**
+ * Build the plan mode system prompt addition.
+ */
+declare function getPlanModePrompt(): string;
+
+/**
+ * Plan execution types — the data model for autonomous multi-model plan execution.
+ *
+ * Hierarchy: PlanFile → Epoch → Phase → Sprint → Task
+ * Each level has status, cost tracking, and rollup progress.
+ */
+
+type PlanNodeStatus = "pending" | "in_progress" | "completed" | "failed" | "blocked" | "skipped";
+interface PlanFile {
+    id: string;
+    filePath: string;
+    name: string;
+    status: PlanNodeStatus;
+    createdDate?: string;
+    targetDate?: string;
+    phases: PlanPhase[];
+    totalTasks: number;
+    completedTasks: number;
+}
+interface PlanPhase {
+    id: string;
+    name: string;
+    status: PlanNodeStatus;
+    startDate?: string;
+    sprints: PlanSprint[];
+    taskCount: number;
+    completedCount: number;
+}
+interface PlanSprint {
+    id: string;
+    name: string;
+    status: PlanNodeStatus;
+    tasks: PlanTask[];
+}
+interface PlanTask {
+    id: string;
+    description: string;
+    status: PlanNodeStatus;
+    assignedSkill?: string;
+    cost?: number;
+    modelUsed?: string;
+    startedAt?: number;
+    completedAt?: number;
+    readonly?: boolean;
+    metadata: Record<string, string>;
+    /** Line number in the plan file (for write-back) */
+    lineNumber: number;
+}
+interface TaskDispatch {
+    subagentType: SubagentType;
+    modelHint: "cheap" | "capable" | "quality";
+    requiresVerification: boolean;
+    routingStrategy?: string;
+}
+interface PlanExecutorOptions {
+    projectPath: string;
+    buildCommand?: string;
+    testCommand?: string;
+    defaultBudgetPerTask: number;
+    planBudgetLimit?: number;
+    mode: "interactive" | "autonomous" | "dry-run";
+    maxRetries: number;
+    compactBetweenPhases: boolean;
+}
+type PlanEvent = {
+    type: "plan-started";
+    plan: PlanFile;
+    totalTasks: number;
+} | {
+    type: "phase-started";
+    phase: PlanPhase;
+} | {
+    type: "phase-completed";
+    phase: PlanPhase;
+    cost: number;
+} | {
+    type: "sprint-started";
+    sprint: PlanSprint;
+} | {
+    type: "task-started";
+    task: PlanTask;
+    subagentType: string;
+    model: string;
+} | {
+    type: "task-completed";
+    task: PlanTask;
+    cost: number;
+    summary: string;
+    model: string;
+    toolCalls: string[];
+} | {
+    type: "task-failed";
+    task: PlanTask;
+    reason: string;
+    error?: string;
+} | {
+    type: "task-budget-exceeded";
+    task: PlanTask;
+    cost: number;
+} | {
+    type: "task-retrying";
+    task: PlanTask;
+    model: string;
+    attempt: number;
+} | {
+    type: "build-check";
+    passed: boolean;
+    output?: string;
+} | {
+    type: "plan-completed";
+    plan: PlanFile;
+    totalCost: number;
+} | {
+    type: "plan-paused";
+    reason: string;
+} | {
+    type: "skill-activated";
+    skillName: string;
+    taskId: string;
+} | {
+    type: "dry-run-task";
+    task: PlanTask;
+    dispatch: TaskDispatch;
+    estimatedCost: number;
+} | {
+    type: "dry-run-summary";
+    totalTasks: number;
+    estimatedCost: number;
+    tasksByType: Record<string, number>;
+};
+
+/**
+ * PlanExecutor — autonomous multi-model plan execution engine.
+ *
+ * Reads a .plan.md file and works through it task-by-task:
+ * 1. Parse plan into hierarchy (phases → sprints → tasks)
+ * 2. For each pending task: classify → dispatch subagent → observe → record
+ * 3. Handle failures with retries and model fallbacks
+ * 4. Update plan file checkboxes on completion
+ * 5. Track cost per task, per phase, per plan
+ *
+ * This is the Brainstorm equivalent of Claude Code's autonomous execution
+ * pattern, but extended across all models via BrainstormRouter.
+ */
+
+interface SubagentDispatcher {
+    /** Spawn a subagent to execute a task. Returns result summary + cost. */
+    execute(prompt: string, opts: {
+        subagentType: string;
+        modelHint: string;
+        budgetLimit: number;
+        projectPath: string;
+        skill?: string;
+        routingStrategy?: string;
+    }): Promise<{
+        text: string;
+        cost: number;
+        modelUsed: string;
+        toolCalls: string[];
+        budgetExceeded: boolean;
+    }>;
+    /** Run a build/test command and return pass/fail. */
+    checkBuild(command: string, cwd: string): Promise<{
+        passed: boolean;
+        output: string;
+    }>;
+}
+/**
+ * Execute a plan file autonomously.
+ *
+ * Yields PlanEvent objects for real-time observation.
+ * The caller provides a SubagentDispatcher that bridges to the actual agent loop.
+ */
+declare function executePlan(planPath: string, dispatcher: SubagentDispatcher, options: PlanExecutorOptions): AsyncGenerator<PlanEvent>;
+
+/**
+ * Plan file parser — reads .plan.md files into PlanFile tree structure.
+ *
+ * Format:
+ * - YAML frontmatter: plan metadata (name, status, dates)
+ * - ## headings: Phases
+ * - ### headings: Sprints
+ * - - [x] / - [ ]: Tasks (with optional {key:value} metadata)
+ *
+ * Also supports write-back: toggles [x] checkboxes and appends cost metadata.
+ */
+
+/**
+ * Parse a .plan.md file into a PlanFile tree.
+ */
+declare function parsePlanFile(filePath: string): PlanFile;
+/**
+ * Parse plan content string (for testing without filesystem).
+ */
+declare function parsePlanContent(content: string, filePath?: string): PlanFile;
+/**
+ * Update a task's checkbox and metadata in the plan file.
+ * Toggles `- [ ]` to `- [x]` and appends `{cost:$X.XX model:name}`.
+ */
+declare function updateTaskInFile(filePath: string, task: PlanTask, updates: {
+    completed?: boolean;
+    cost?: number;
+    model?: string;
+    skill?: string;
+}): void;
+
+/**
+ * Task classifier — maps plan task descriptions to subagent type + model hint.
+ *
+ * This is where the plan executor decides HOW to execute each task:
+ * which subagent type, which model tier, and whether to verify after.
+ */
+
+/**
+ * Classify a plan task into a dispatch decision.
+ *
+ * Returns the subagent type, model hint, and whether to run build verification.
+ */
+declare function classifyPlanTask(task: PlanTask): TaskDispatch;
+/**
+ * Estimate cost for a task based on its dispatch classification.
+ */
+declare function estimateTaskCost(dispatch: TaskDispatch): number;
+
+/**
+ * Orchestration Pipeline — 9-phase software development lifecycle.
+ *
+ * Combines patterns from:
+ * - MetaGPT/ChatDev: role-based sequential pipeline
+ * - Augment Intent: spec-driven coordination with parallel agents
+ * - MapCoder: multi-stage per-task pipeline (recall → plan → generate → debug)
+ *
+ * Each phase dispatches to a role agent (.agent.md file) via the existing
+ * subagent infrastructure. BrainstormRouter automatically selects the model
+ * for each phase — no manual model selection.
+ *
+ * Phases: Spec → Architecture → Implementation → Review → Verify → Refactor → Deploy → Document → Report
+ */
+type PipelinePhase = "spec" | "architecture" | "implementation" | "review" | "verify" | "refactor" | "deploy" | "document" | "report";
+interface PhaseResult {
+    phase: PipelinePhase;
+    agentId: string;
+    output: string;
+    cost: number;
+    toolCalls: string[];
+    duration: number;
+    success: boolean;
+    error?: string;
+}
+type PipelineEvent = {
+    type: "pipeline-started";
+    request: string;
+    phases: PipelinePhase[];
+} | {
+    type: "phase-started";
+    phase: PipelinePhase;
+    agentId: string;
+} | {
+    type: "phase-completed";
+    result: PhaseResult;
+} | {
+    type: "phase-failed";
+    phase: PipelinePhase;
+    error: string;
+} | {
+    type: "review-findings";
+    findings: ReviewFinding[];
+    hasCritical: boolean;
+} | {
+    type: "feedback-loop";
+    from: PipelinePhase;
+    to: PipelinePhase;
+    reason: string;
+} | {
+    type: "pipeline-completed";
+    results: PhaseResult[];
+    totalCost: number;
+} | {
+    type: "pipeline-paused";
+    phase: PipelinePhase;
+    reason: string;
+};
+interface ReviewFinding {
+    severity: "critical" | "high" | "medium" | "low";
+    description: string;
+    file?: string;
+    line?: number;
+    reviewer: string;
+}
+interface PipelineOptions {
+    projectPath: string;
+    buildCommand?: string;
+    testCommand?: string;
+    deployCommands?: string[];
+    deploy?: boolean;
+    budget?: number;
+    phases?: PipelinePhase[];
+    resumeFrom?: PipelinePhase;
+    dryRun?: boolean;
+}
+interface PhaseDispatcher {
+    /** Execute a single phase with a named agent. */
+    runPhase(agentId: string, subagentType: string, prompt: string, opts: {
+        budget: number;
+        projectPath: string;
+    }): Promise<{
+        text: string;
+        cost: number;
+        toolCalls: string[];
+    }>;
+    /** Execute multiple agents in parallel. */
+    runParallel(specs: Array<{
+        agentId: string;
+        subagentType: string;
+        prompt: string;
+    }>, opts: {
+        budget: number;
+        projectPath: string;
+    }): Promise<Array<{
+        agentId: string;
+        text: string;
+        cost: number;
+        toolCalls: string[];
+    }>>;
+    /** Run a shell command. */
+    runCommand(command: string, cwd: string): Promise<{
+        passed: boolean;
+        output: string;
+    }>;
+}
+/**
+ * Execute the full orchestration pipeline.
+ *
+ * Each phase dispatches to a role agent via the PhaseDispatcher.
+ * BrainstormRouter handles model selection automatically.
+ * Every run is captured as a trajectory for BrainstormLLM v2 training.
+ */
+declare function runOrchestrationPipeline(request: string, dispatcher: PhaseDispatcher, options: PipelineOptions): AsyncGenerator<PipelineEvent>;
+
+/**
+ * Trajectory Capture — records orchestration pipeline executions as training data.
+ *
+ * Every pipeline run produces a structured trajectory that captures:
+ * - The user's request
+ * - Each phase's agent, model, tools, cost, duration, and output quality
+ * - The pipeline outcome (build pass, test pass, review findings)
+ * - Feedback loops (review → re-implementation cycles)
+ *
+ * Trajectories are emitted as JSONL for:
+ * 1. Local storage (~/.brainstorm/trajectories/orchestration/)
+ * 2. BrainstormRouter Intelligence API (POST /v1/agent/trajectory)
+ * 3. HuggingFace dataset push (justinjilg/brainstorm-orchestration-trajectories)
+ *
+ * This data trains BrainstormLLM v2 — the orchestration model.
+ */
+
+interface OrchestrationTrajectory {
+    id: string;
+    timestamp: string;
+    request: string;
+    projectPath: string;
+    projectType?: string;
+    phases: PhaseTrajectory[];
+    outcome: PipelineOutcome;
+    totalCost: number;
+    totalDuration: number;
+    feedbackLoops: FeedbackLoop[];
+}
+interface PhaseTrajectory {
+    phase: PipelinePhase;
+    agentId: string;
+    modelUsed?: string;
+    subagentType: string;
+    toolCalls: string[];
+    inputTokens?: number;
+    outputTokens?: number;
+    cost: number;
+    duration: number;
+    success: boolean;
+    skipped: boolean;
+    error?: string;
+    outputLength: number;
+}
+interface PipelineOutcome {
+    success: boolean;
+    phasesCompleted: number;
+    phasesTotal: number;
+    buildPassed?: boolean;
+    testsPassed?: boolean;
+    reviewFindings: number;
+    criticalFindings: number;
+    filesChanged?: number;
+}
+interface FeedbackLoop {
+    from: PipelinePhase;
+    to: PipelinePhase;
+    reason: string;
+    timestamp: number;
+}
+declare class TrajectoryRecorder$1 {
+    private id;
+    private request;
+    private projectPath;
+    private startTime;
+    private phases;
+    private feedbackLoops;
+    private currentPhase;
+    private outcome;
+    constructor(request: string, projectPath: string);
+    /** Process a pipeline event and record relevant data. */
+    recordEvent(event: PipelineEvent): void;
+    /** Finalize and persist the trajectory. Returns the trajectory object. */
+    finalize(): OrchestrationTrajectory;
+    /** Push trajectory to BrainstormRouter's trajectory endpoint. */
+    private pushToBR;
+    /** Get the trajectory ID (for linking to BR API). */
+    getId(): string;
+}
+/**
+ * Convert a trajectory into SFT training examples for BrainstormLLM v2.
+ *
+ * Each phase in the trajectory becomes one training example:
+ * - Input: request + phase + project context
+ * - Label: what worked (agent, tools, cost, duration)
+ * - Weight: pipeline outcome quality (success = 1.0, partial = 0.5, fail = 0.1)
+ */
+declare function trajectoryToSFTExamples(trajectory: OrchestrationTrajectory): Array<{
+    input: string;
+    label: string;
+    weight: number;
+}>;
+/**
+ * Format SFT examples as JSONL for training.
+ */
+declare function sftExamplesToJSONL(examples: Array<{
+    input: string;
+    label: string;
+    weight: number;
+}>): string;
+
+/**
+ * Pipeline Dispatcher — bridges the orchestration pipeline to real subagent execution.
+ *
+ * Creates a PhaseDispatcher that wires each pipeline phase to `spawnSubagent()`
+ * with the correct agent definition, tool set, and budget. The agent's `.agent.md`
+ * system prompt is loaded and injected. BrainstormRouter handles model selection
+ * automatically — no manual model picking.
+ */
+
+/**
+ * Create a real PhaseDispatcher that executes phases via spawnSubagent().
+ *
+ * Pass the runtime dependencies (config, registry, router, etc.) and get
+ * back a dispatcher that the orchestration pipeline can use.
+ */
+declare function createPipelineDispatcher(subagentOptions: SubagentOptions): PhaseDispatcher;
+
+interface MultimodalContent {
+    type: 'image' | 'text';
+    mimeType?: string;
+    data?: string;
+    text?: string;
+}
+/**
+ * Check if a file path is an image that can be sent to a vision model.
+ */
+declare function isImageFile(filePath: string): boolean;
+/**
+ * Check if a file is a PDF.
+ */
+declare function isPdfFile(filePath: string): boolean;
+/**
+ * Read a file and return multimodal content.
+ * Images are base64-encoded for vision model consumption.
+ * PDFs are parsed to extract text content.
+ */
+declare function readMultimodalFile(filePath: string, pages?: string): Promise<MultimodalContent | null>;
+/**
+ * Check if a model supports vision (for routing decisions).
+ */
+declare function requiresVisionModel(contents: MultimodalContent[]): boolean;
+
+/**
+ * Load ignore patterns from .brainstormignore + defaults.
+ */
+declare function loadIgnorePatterns(projectPath: string): string[];
+/**
+ * Check if a file path matches any ignore pattern.
+ */
+declare function isIgnored(filePath: string, projectPath: string, patterns: string[]): boolean;
+
+/**
+ * Scans text for credential patterns and redacts them before sending to LLM providers.
+ * 19 regex patterns matching common credential formats.
+ */
+interface ScanResult {
+    hasFindings: boolean;
+    findings: Array<{
+        name: string;
+        position: number;
+        preview: string;
+    }>;
+}
+/**
+ * Scan text for credential patterns.
+ */
+declare function scanForCredentials(text: string): ScanResult;
+/**
+ * Redact all detected credentials in text.
+ */
+declare function redactCredentials(text: string): string;
+
+/**
+ * Path Safety Guard — prevents path traversal attacks.
+ *
+ * All file operations must go through resolveSafe() which validates
+ * that the resolved path is within the project directory.
+ * Prevents: ../../etc/passwd, symlink escapes, absolute path bypasses.
+ */
+/**
+ * Resolve a path safely within the project directory.
+ * Throws if the resolved path escapes the workspace root.
+ *
+ * Security: resolves symlinks via realpathSync to prevent symlink-based escapes.
+ * Also blocks explicit '..' segments in the path.
+ */
+declare function resolveSafe(filePath: string, workspaceRoot: string): string;
+/**
+ * Check if a path is within the workspace (non-throwing version).
+ */
+declare function isWithinWorkspace(filePath: string, workspaceRoot: string): boolean;
+declare class PathTraversalError extends Error {
+    readonly attemptedPath: string;
+    readonly workspaceRoot: string;
+    constructor(attemptedPath: string, workspaceRoot: string);
+}
+
+/**
+ * Lightweight response filter that strips common LLM filler patterns.
+ *
+ * Applied to the beginning of streamed text output. Not aggressive —
+ * only strips patterns that are clearly filler, not meaningful content.
+ * The system prompt does the heavy lifting; this catches what leaks through.
+ */
+/**
+ * Filter a complete response text, stripping filler patterns.
+ * Used for non-streaming contexts (e.g., subagent results).
+ */
+declare function filterResponse(text: string): string;
+/**
+ * Streaming filter that strips filler from the beginning of a text-delta stream.
+ *
+ * Buffers the first few deltas to detect filler prefixes.
+ * Call `filter(delta)` for each text-delta, then `flush()` when the stream ends.
+ */
+interface StreamFilter {
+    /** Process a text delta. Returns filtered text to emit (may be empty while buffering). */
+    filter(delta: string): string;
+    /** Flush remaining buffered content. Call when the stream ends. */
+    flush(): string;
+}
+declare function createStreamFilter(): StreamFilter;
+
+/**
+ * Normalize insight markers in streamed text.
+ * Catches common model variations and standardizes to "★ Insight:".
+ */
+declare function normalizeInsightMarkers(text: string): string;
+
+/**
+ * Create the subagent tool with runtime context injected.
+ *
+ * This tool lives in @brainst0rm/core (not @brainst0rm/tools) because it
+ * depends on the subagent execution engine, which would create a circular
+ * dependency if placed in the tools package.
+ *
+ * The model can call this tool to spawn focused subagents for parallel work:
+ * - explore: fast codebase search (read-only, cheap model)
+ * - plan: design implementation approach (read + task tools)
+ * - code: implement changes (full tool access, capable model)
+ * - review: review code for bugs (read + git tools)
+ * - general: any focused task (all tools, cheap model)
+ */
+declare function createSubagentTool(options: SubagentOptions): BrainstormToolDef;
+
+/**
+ * Loop Detector — detects repetitive agent behavior within a single turn.
+ *
+ * Tracks consecutive tool calls and emits warnings when the agent appears stuck:
+ * - N consecutive reads with no write → nudge to write
+ * - Same file read twice → warn about duplicate read
+ * - Same tool called N times in a row → warn about potential loop
+ */
+interface LoopWarning {
+    type: "consecutive-reads" | "duplicate-read" | "tool-repeat" | "escalation";
+    message: string;
+}
+declare class LoopDetector {
+    private recentTools;
+    private filesReadThisTurn;
+    private writesSinceLastCheck;
+    private readonly readThreshold;
+    private readonly repeatThreshold;
+    /** Count of consecutive warning-bearing tool calls (reset on clean call). */
+    private consecutiveWarnings;
+    private readonly escalationThreshold;
+    constructor(readThreshold?: number, repeatThreshold?: number);
+    /** Record a tool call and check for loop patterns. Returns warnings if any. */
+    recordToolCall(toolName: string, filePath?: string): LoopWarning[];
+    reset(): void;
+    private countConsecutiveReads;
+}
+
+/**
+ * Lightweight user tone detection — heuristic-based, no ML.
+ * Analyzes recent user messages to detect frustration, urgency, or exploration.
+ * Used internally to adjust agent behavior (not shown to user).
+ */
+type UserTone = 'calm' | 'frustrated' | 'urgent' | 'exploring' | 'appreciative';
+interface ToneResult {
+    tone: UserTone;
+    confidence: number;
+}
+/** Detect the dominant tone from the last N user messages. */
+declare function detectTone(messages: string[], lookback?: number): ToneResult;
+/** Get guidance text for the agent based on detected tone. */
+declare function toneGuidance(tone: UserTone): string;
+
+/**
+ * User Reaction Signal Tracker — detect acceptance/rejection of agent responses.
+ * Analyzes user messages for satisfaction signals per session.
+ * Injected as context so the agent knows what worked and what didn't.
+ */
+type ReactionSignal = 'accepted' | 'rejected' | 'neutral';
+interface ReactionEntry {
+    turn: number;
+    signal: ReactionSignal;
+    userMessage: string;
+}
+declare class ReactionTracker {
+    private reactions;
+    /** Analyze a user message and record the reaction signal. */
+    record(turn: number, userMessage: string): ReactionSignal;
+    /** Get the last N reactions. */
+    getRecent(n?: number): ReactionEntry[];
+    /** Format reaction context for system prompt injection. */
+    formatReactionContext(): string;
+    clear(): void;
+}
+
+/**
+ * Cross-Session Learning — records per-project patterns that improve over time.
+ *
+ * Patterns tracked:
+ * - tool_success: which tools fail frequently (e.g., file_edit fails on JSX)
+ * - command_timing: how long shell commands take (e.g., npm test takes 45s)
+ * - user_preference: what users prefer (e.g., always rejects layout changes)
+ * - model_choice: which models work best for this project
+ *
+ * Loaded on session start, updated during session, decayed over 30 days.
+ */
+
+declare class SessionPatternLearner {
+    private repo;
+    private projectPath;
+    constructor(repo: PatternRepository, projectPath: string);
+    /** Record a tool success/failure pattern. */
+    recordToolResult(toolName: string, success: boolean): void;
+    /** Record a shell command timing. */
+    recordCommandTiming(command: string, durationMs: number): void;
+    /** Record a user preference signal. */
+    recordUserPreference(key: string, value: string): void;
+    /** Record which model was successful for a task type. */
+    recordModelChoice(taskType: string, modelId: string): void;
+    /** Get all patterns for the current project. */
+    getPatterns(): SessionPattern[];
+    /** Format patterns for system prompt injection. */
+    formatForPrompt(): string;
+    /** Run decay on old patterns. Called periodically (e.g., on session start). */
+    decay(): number;
+}
+
+/**
+ * Error-Fix Pair Detection — "Why Did That Work?" analysis.
+ *
+ * Detects when the agent fixes a build error:
+ *   Turn N: build fails with error message
+ *   Turn N+1: agent edits files
+ *   Turn N+2: build passes
+ *
+ * Captures the error signature + fix description for future reference.
+ * When the same error occurs again, the stored fix is suggested.
+ */
+
+interface ErrorFixPair {
+    errorSignature: string;
+    filesChanged: string[];
+    fixDescription: string;
+    timestamp: number;
+}
+/** Normalize an error message into a stable signature for matching. */
+declare function normalizeErrorSignature(errorMessage: string): string;
+declare class ErrorFixTracker {
+    private lastError;
+    private lastEdits;
+    /** Record a build/test failure. */
+    recordError(errorMessage: string, turn: number): void;
+    /** Record file edits (potential fix). */
+    recordEdits(files: string[], turn: number): void;
+    /**
+     * Record a build/test success. If we had error → edits → success,
+     * this completes the fix pair.
+     */
+    detectFixPair(turn: number): ErrorFixPair | null;
+    /** Store a detected fix pair in the pattern database. */
+    storeFixPair(repo: PatternRepository, projectPath: string, pair: ErrorFixPair): void;
+    /** Look up known fixes for an error. */
+    lookupFix(repo: PatternRepository, projectPath: string, errorMessage: string): string | null;
+    reset(): void;
+}
+
+/**
+ * Speculative Execution — try two approaches in parallel.
+ *
+ * Creates a git worktree per approach, runs each as a subagent,
+ * compares results (which one builds? which is cleaner?),
+ * and applies the winning changes.
+ *
+ * Uses git worktrees for isolation:
+ *   git worktree add /tmp/brainstorm-spec-<id> -b spec-<id>
+ *   ... run approach ...
+ *   git worktree remove /tmp/brainstorm-spec-<id>
+ */
+interface SpeculativeApproach {
+    name: string;
+    prompt: string;
+}
+interface SpeculativeResult {
+    name: string;
+    worktreePath: string;
+    buildPassed: boolean;
+    filesChanged: string[];
+    error?: string;
+}
+interface SpeculativeOutcome {
+    winner: SpeculativeResult | null;
+    results: SpeculativeResult[];
+    reason: string;
+}
+/** Create a git worktree for isolated execution. */
+declare function createWorktree(projectPath: string, name: string): string;
+/** Remove a git worktree and its branch. */
+declare function removeWorktree(projectPath: string, worktreePath: string): void;
+/** Check if a build passes in a worktree. */
+declare function checkBuild(worktreePath: string, buildCommand?: string): boolean;
+/** Get list of changed files in a worktree relative to the base branch. */
+declare function getChangedFiles(worktreePath: string): string[];
+/** Compare two speculative results and pick the winner. */
+declare function pickWinner(results: SpeculativeResult[]): SpeculativeOutcome;
+
+/**
+ * Model Self-Evaluation — run a cheap reviewer after file writes.
+ * Catches obvious mistakes (missing imports, wrong file, logic errors)
+ * before the user sees the response.
+ *
+ * Uses a separate model call (Haiku-class) to review the changes.
+ * Configurable: off by default for speed, enabled in config.
+ */
+interface SelfReviewResult {
+    issues: string[];
+    passed: boolean;
+    reviewCost: number;
+}
+interface SelfReviewOptions {
+    filesWritten: Array<{
+        path: string;
+        content: string;
+    }>;
+    originalRequest: string;
+    modelResponse: string;
+}
+/**
+ * Build the self-review prompt for a cheap model to evaluate.
+ * Returns null if there's nothing to review (no file writes).
+ */
+declare function buildSelfReviewPrompt(options: SelfReviewOptions): string | null;
+/**
+ * Parse the self-review response into structured results.
+ */
+declare function parseSelfReviewResponse(response: string): SelfReviewResult;
+
+/**
+ * Semantic File Watcher — detect external file changes between turns.
+ * Uses fs.watch (no external dependencies) to track changes in the project.
+ * Filters out node_modules, .git, dist, .next, and other noise.
+ */
+interface FileChange {
+    path: string;
+    type: 'created' | 'modified' | 'deleted';
+}
+declare class FileWatcher {
+    private projectPath;
+    private watcher;
+    private changes;
+    private agentWrites;
+    private debounceTimers;
+    constructor(projectPath: string);
+    /** Start watching the project directory. */
+    start(): void;
+    /** Register a file as written by the agent (to distinguish from external changes). */
+    recordAgentWrite(filePath: string): void;
+    /** Consume and return all changes since last call. Clears the buffer. */
+    consumeChanges(): FileChange[];
+    /** Format changes as a context string for system prompt injection. */
+    formatChanges(): string;
+    /** Stop watching. */
+    stop(): void;
+}
+
+/**
+ * Project Health Dashboard — collect project state on session start.
+ * Runs quick checks: git status, build state, dependency freshness.
+ * Injected as persistent context so the agent always knows project state.
+ */
+interface ProjectHealth {
+    gitBranch: string;
+    gitAhead: number;
+    gitBehind: number;
+    gitDirty: boolean;
+    gitUntracked: number;
+    buildStatus: 'unknown' | 'passing' | 'failing';
+    outdatedDeps: number;
+    lastCommitAge: string;
+}
+/** Collect project health metrics. Non-blocking, all checks have timeouts. */
+declare function collectProjectHealth(projectPath: string): ProjectHealth;
+/** Format health as a compact context string. */
+declare function formatProjectHealth(health: ProjectHealth): string;
+
+/**
+ * Repository Map — lightweight code knowledge graph.
+ *
+ * Parses project files using regex to extract exports, imports, and symbols.
+ * Builds a dependency graph and ranks files by connectivity (simplified PageRank).
+ * Injects the top files into the system prompt instead of raw file listings,
+ * dramatically reducing token usage.
+ *
+ * Uses regex parsing (no native addons). For deeper AST analysis,
+ * tree-sitter can be added as an optional dependency in the future.
+ */
+interface SymbolSignature {
+    name: string;
+    kind: "function" | "class" | "interface" | "type" | "const" | "enum";
+    signature: string;
+    exported: boolean;
+}
+interface RepoMapEntry {
+    file: string;
+    exports: string[];
+    imports: string[];
+    symbols: string[];
+    signatures: SymbolSignature[];
+    lineCount: number;
+}
+interface RepoMap {
+    entries: RepoMapEntry[];
+    edges: Array<{
+        from: string;
+        to: string;
+    }>;
+    topFiles: string[];
+    totalFiles: number;
+    generated: number;
+}
+/**
+ * Build a repository map for the given project.
+ * Uses incremental updates: only re-parses files whose mtime changed.
+ * Results cached in memory (30s TTL) and entries cached by mtime.
+ *
+ * @param projectPath - Root directory of the project
+ * @param maxFiles - Maximum number of top files to include (default: 15)
+ */
+declare function buildRepoMap(projectPath: string, maxFiles?: number): RepoMap;
+/**
+ * Format the repo map as a compact context string for system prompt injection.
+ */
+declare function repoMapToContext(map: RepoMap): string;
+/**
+ * Generate a structured repo map string suitable for system prompt injection.
+ *
+ * Includes function/class signatures, export lists per file, and import relationships.
+ * This is the primary entry point for the agent context builder.
+ *
+ * @param projectPath - Root directory of the project
+ * @param maxFiles - Maximum number of top files to include (default: 20)
+ */
+declare function generateRepoMap(projectPath: string, maxFiles?: number): string;
+
+/**
+ * Semantic Code Search — TF-IDF based code search.
+ *
+ * Indexes project files by extracting symbols and code snippets,
+ * builds TF-IDF vectors, and supports cosine similarity search.
+ * Zero external dependencies — pure math fallback when no embedding model available.
+ */
+interface SearchResult {
+    filePath: string;
+    symbolName: string | null;
+    snippet: string;
+    score: number;
+}
+interface TFIDFDocument {
+    filePath: string;
+    symbolName: string | null;
+    snippet: string;
+    terms: Map<string, number>;
+}
+/**
+ * Index project files for semantic search.
+ * Uses buildRepoMap for file discovery and TF-IDF for vectorization.
+ */
+declare function indexProject(projectPath: string): {
+    docs: TFIDFDocument[];
+    idf: Map<string, number>;
+};
+/**
+ * Search project code using TF-IDF cosine similarity.
+ * Returns top-K results ranked by relevance.
+ */
+declare function semanticSearch(query: string, projectPath: string, topK?: number): SearchResult[];
+
+/**
+ * Context Lineage — Git History Indexing.
+ *
+ * Parses recent commits to build a searchable commit history.
+ * Summarizes each diff to a one-liner via regex (no LLM call).
+ * Inspired by Augment Code's Context Lineage feature.
+ */
+interface CommitSummary {
+    hash: string;
+    date: string;
+    author: string;
+    message: string;
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+    summary: string;
+}
+/**
+ * Index recent commits from git history.
+ * Parses git log --stat output and generates one-line summaries via regex.
+ */
+declare function indexRecentCommits(projectPath: string, maxCommits?: number): CommitSummary[];
+/**
+ * Search commit history using keyword matching on summaries and messages.
+ */
+declare function searchCommitHistory(query: string, projectPath: string, topK?: number): CommitSummary[];
+/**
+ * Format recent relevant commits as a context section for the system prompt.
+ */
+declare function formatCommitContext(projectPath: string, maxCommits?: number): string | null;
+
+/**
+ * Audit Logger — append-only tool call audit trail.
+ *
+ * Records every tool call with sanitized arguments, result status,
+ * duration, model, and cost. Stored in SQLite audit_log table.
+ */
+
+/**
+ * Create audit logging middleware.
+ * Records every tool call to the audit_log table.
+ */
+declare function createAuditMiddleware(sessionId: string): AgentMiddleware;
+/**
+ * Query audit log entries for a session.
+ */
+declare function getAuditLog(sessionId?: string, limit?: number): Array<{
+    id: number;
+    sessionId: string;
+    toolName: string;
+    argsJson: string | null;
+    resultOk: boolean;
+    durationMs: number | null;
+    createdAt: number;
+}>;
+
+/**
+ * Style Learner — detect coding conventions from the codebase.
+ *
+ * Analyzes existing code for patterns: indent style, quote style,
+ * naming conventions, import ordering. Injects as "Project Style Guide"
+ * in the system prompt. Pure regex analysis — no LLM needed.
+ *
+ * Inspired by Augment Code's persistent learning from codebase style.
+ */
+interface StyleProfile {
+    indentStyle: "tabs" | "spaces-2" | "spaces-4" | "mixed";
+    quoteStyle: "single" | "double" | "mixed";
+    semicolons: "always" | "never" | "mixed";
+    namingConvention: "camelCase" | "snake_case" | "mixed";
+    trailingCommas: "yes" | "no" | "mixed";
+    importStyle: "named" | "default" | "mixed";
+    commentStyle: "line" | "block" | "jsdoc" | "mixed";
+    lineLength: number;
+    hasJSDoc: boolean;
+}
+/**
+ * Analyze the codebase and detect coding style conventions.
+ */
+declare function learnStyle(projectPath: string): StyleProfile;
+/**
+ * Format style profile as a context section for the system prompt.
+ */
+declare function formatStyleContext(projectPath: string): string | null;
+
+/**
+ * ACP-lite — External Agent Invocation.
+ *
+ * CLI-to-CLI bridge: invoke Claude Code, Codex CLI, or other AI assistants
+ * as external agents. Budget-guarded child process execution.
+ *
+ * Inspired by DeerFlow RFC #1296 and Augment Intent BYOA.
+ */
+interface ExternalAgentConfig {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    timeout?: number;
+}
+interface ExternalAgentResult {
+    output: string;
+    exitCode: number;
+    durationMs: number;
+}
+/**
+ * Invoke an external agent CLI with a task prompt.
+ * The prompt is passed as the last argument.
+ */
+declare function invokeExternalAgent(config: ExternalAgentConfig, task: string): ExternalAgentResult;
+
+/**
+ * Community Knowledge Graph — crowdsourced debugging intelligence.
+ *
+ * When Brainstorm fixes a build error (error → fix pair), the fix can be
+ * anonymized and shared via BrainstormRouter. Other users hitting the same
+ * error get the fix suggested automatically.
+ *
+ * Client-side implementation. Requires BR API endpoints:
+ *   POST /v1/community/fixes  — submit anonymized fix pair
+ *   GET  /v1/community/fixes  — query known fixes by error signature
+ *
+ * Opt-in via config: [community] share_fixes = true
+ */
+
+interface CommunityFixPair {
+    /** Normalized error signature (no paths, no line numbers). */
+    errorSignature: string;
+    /** Detected framework from package.json (e.g., "next", "react"). */
+    framework: string;
+    /** Relevant dependency and version (e.g., "drizzle-orm@0.45"). */
+    dependency?: string;
+    /** Human-readable fix description. */
+    fixDescription: string;
+    /** Anonymized diff (stripped of project-specific paths). */
+    fixDiff?: string;
+    /** Confidence that this fix is correct (0-1). */
+    confidence: number;
+    /** Whether the build passed after applying this fix. */
+    verified: boolean;
+}
+interface CommunityFixResult {
+    /** Error signature that was queried. */
+    errorSignature: string;
+    /** Known fixes from the community. */
+    fixes: Array<CommunityFixPair & {
+        /** Number of users who confirmed this fix worked. */
+        confirmations: number;
+        /** When this fix was first submitted. */
+        firstSeen: string;
+    }>;
+}
+/**
+ * Submit an anonymized fix pair to BrainstormRouter's community knowledge graph.
+ *
+ * @param baseUrl - BrainstormRouter API base URL
+ * @param apiKey - API key for authentication
+ * @param fixPair - The error-fix pair to submit
+ * @param framework - Detected framework (from package.json)
+ */
+declare function submitCommunityFix(baseUrl: string, apiKey: string, fixPair: ErrorFixPair, framework: string): Promise<boolean>;
+/**
+ * Query known community fixes for a given error.
+ *
+ * @param baseUrl - BrainstormRouter API base URL
+ * @param apiKey - API key for authentication
+ * @param errorMessage - The raw error message to look up
+ */
+declare function queryCommunityFixes(baseUrl: string, apiKey: string, errorMessage: string): Promise<CommunityFixResult | null>;
+/**
+ * Format community fixes for injection into the agent context.
+ */
+declare function formatCommunityFixes(result: CommunityFixResult): string;
+/**
+ * Detect the project framework from package.json.
+ */
+declare function detectFramework(projectPath: string): string;
+
+/**
+ * Trajectory Reduction — AgentDiet-inspired context optimization.
+ *
+ * After each turn, classifies conversation messages as:
+ *   - active: still relevant to the current task
+ *   - expired: superseded by later information
+ *   - redundant: duplicate of another message
+ *
+ * Removes expired/redundant messages BEFORE token-based compaction,
+ * achieving 40-60% token savings without quality loss.
+ *
+ * Heuristic-first: no LLM call needed for most reductions.
+ * Inspired by ByteDance Trae Agent's AgentDiet technique.
+ */
+
+type MessageStatus = "active" | "expired" | "redundant";
+interface ReductionResult {
+    /** Messages after reduction. */
+    reduced: ConversationMessage[];
+    /** Number of messages removed. */
+    removedCount: number;
+    /** Estimated tokens saved. */
+    estimatedTokensSaved: number;
+    /** Breakdown of removal reasons. */
+    reasons: Record<string, number>;
+}
+/**
+ * Reduce a conversation trajectory by removing expired and redundant messages.
+ *
+ * @param messages - Full conversation history
+ * @param currentTurn - Current turn number (for age-based expiry)
+ * @returns Reduced conversation with removal stats
+ */
+declare function reduceTrajectory(messages: ConversationMessage[], currentTurn: number): ReductionResult;
+/**
+ * Format reduction stats for turn context injection.
+ */
+declare function formatReductionStats(result: ReductionResult): string;
+
+/**
+ * Structured Trajectory Recording — JSONL event log for every agent interaction.
+ *
+ * Records LLM calls, tool executions, routing decisions, compaction events,
+ * and errors as structured events. Enables:
+ *   - Post-hoc debugging
+ *   - SWE-bench evaluation
+ *   - BrainstormRouter intelligence feedback
+ *   - Cost analysis per task type
+ *
+ * Writes to ~/.brainstorm/trajectories/<session-id>.jsonl
+ *
+ * Inspired by Trae Agent's trajectory recording system, enhanced with
+ * BrainstormRouter routing metadata that no other tool captures.
+ */
+type TrajectoryEventType = "session-start" | "llm-call" | "tool-call" | "tool-result" | "routing-decision" | "turn-summary" | "compaction" | "trajectory-reduction" | "error" | "session-end";
+interface TrajectoryEvent {
+    type: TrajectoryEventType;
+    timestamp: string;
+    sessionId: string;
+    turn: number;
+    data: Record<string, unknown>;
+}
+interface LLMCallData {
+    model: string;
+    provider: string;
+    inputTokens: number;
+    outputTokens: number;
+    latencyMs: number;
+    cost: number;
+    strategy: string;
+}
+interface ToolCallData {
+    name: string;
+    input: Record<string, unknown>;
+    durationMs: number;
+}
+interface ToolResultData {
+    name: string;
+    ok: boolean;
+    error?: string;
+    durationMs: number;
+}
+interface RoutingDecisionData {
+    candidates: Array<{
+        model: string;
+        score: number;
+    }>;
+    winner: string;
+    strategy: string;
+    reasoning: string;
+    taskType: string;
+    complexity: string;
+}
+/**
+ * Records agent trajectory events to JSONL files.
+ */
+declare class TrajectoryRecorder {
+    private filePath;
+    private sessionId;
+    private turn;
+    private enabled;
+    constructor(sessionId: string, enabled?: boolean);
+    /** Set the current turn number. */
+    setTurn(turn: number): void;
+    /** Record a session start event. */
+    recordSessionStart(metadata: Record<string, unknown>): void;
+    /** Record an LLM call. */
+    recordLLMCall(data: LLMCallData): void;
+    /** Record a tool call (before execution). */
+    recordToolCall(data: ToolCallData): void;
+    /** Record a tool result (after execution). */
+    recordToolResult(data: ToolResultData): void;
+    /** Record a routing decision. */
+    recordRoutingDecision(data: RoutingDecisionData): void;
+    /** Record a turn summary (TurnContext snapshot). */
+    recordTurnSummary(data: Record<string, unknown>): void;
+    /** Record a compaction event. */
+    recordCompaction(data: {
+        messagesBefore: number;
+        messagesAfter: number;
+        tokensSaved: number;
+    }): void;
+    /** Record a trajectory reduction event. */
+    recordReduction(data: {
+        removedCount: number;
+        tokensSaved: number;
+        reasons: Record<string, number>;
+    }): void;
+    /** Record an error. */
+    recordError(data: {
+        message: string;
+        recoveryAction?: string;
+        model?: string;
+    }): void;
+    /** Record session end. */
+    recordSessionEnd(data: {
+        totalCost: number;
+        totalTurns: number;
+        durationMs: number;
+    }): void;
+    /** Get the trajectory file path. */
+    getFilePath(): string;
+    private record;
+}
+
+/**
+ * Cost Prediction — estimate task cost before execution.
+ *
+ * Uses task classification + model pricing + historical patterns to predict
+ * how much a task will cost across different model tiers.
+ *
+ * Market's #1 pain point: "How much will this cost?"
+ * BrainstormRouter advantage: historical routing data enables predictions
+ * like "refactoring in a Next.js project typically costs $0.08 with Sonnet."
+ */
+
+interface CostPrediction {
+    /** Best estimate for the task. */
+    estimated: number;
+    /** Confidence range [low, high]. */
+    range: [number, number];
+    /** Per-tier breakdown. */
+    tiers: CostTier[];
+    /** Task type used for prediction. */
+    taskType: string;
+    /** Complexity level. */
+    complexity: string;
+}
+interface CostTier {
+    label: string;
+    model: string;
+    estimatedCost: number;
+    estimatedTokens: number;
+    estimatedLatencyMs: number;
+}
+/**
+ * Predict the cost of a task before execution.
+ *
+ * @param taskProfile - Classified task profile from the router
+ * @param models - Available models with pricing
+ * @returns Cost prediction with per-tier breakdown
+ */
+declare function predictTaskCost(taskProfile: TaskProfile, models: ModelEntry[]): CostPrediction;
+/**
+ * Format a cost prediction for display.
+ */
+declare function formatCostPrediction(prediction: CostPrediction): string;
+
+/** Injects TurnContext summary between turns for agent self-awareness. */
+declare const turnContextMiddleware: AgentMiddleware;
+
+/** Filters unhealthy tools from the available tool set. */
+declare const toolHealthMiddleware: AgentMiddleware;
+
+/** Tracks build/test results and injects warnings when build is broken. */
+declare const buildStateMiddleware: AgentMiddleware;
+
+/** Detects repetitive tool call patterns and injects warnings. */
+declare const loopDetectionMiddleware: AgentMiddleware;
+
+/** Adjusts response style based on detected user tone. */
+declare const sentimentMiddleware: AgentMiddleware;
+
+/**
+ * Hardware-enforces maximum concurrent subagent spawns.
+ * Inspired by DeerFlow's SubagentLimitMiddleware:
+ * "prompt-based limits are less reliable than hardware enforcement."
+ */
+declare const subagentLimitMiddleware: AgentMiddleware;
+
+/**
+ * Runs trajectory reduction after tool results to prune expired/redundant context.
+ * Integrates with the TrajectoryReducer from session/trajectory-reducer.ts.
+ */
+declare const trajectoryReductionMiddleware: AgentMiddleware;
+
+/** Triggers linting after file write/edit tool calls. */
+declare const autoLintMiddleware: AgentMiddleware;
+
+declare function createDefaultMiddlewarePipeline(projectPath?: string, contextWindow?: number): MiddlewarePipeline;
+
+/**
+ * Session Checkpoint Recovery — survive crashes and accidental closes.
+ *
+ * Periodically serializes session state to SQLite so long sessions
+ * can be resumed after CLI crashes, network drops, or terminal closes.
+ *
+ * Inspired by DeerFlow's LangGraph checkpoint layer, adapted for
+ * Brainstorm's SQLite-based persistence.
+ */
+
+interface SessionCheckpointData {
+    sessionId: string;
+    turnNumber: number;
+    conversationHistory: ConversationMessage[];
+    scratchpad: Record<string, string>;
+    filesRead: string[];
+    filesWritten: string[];
+    buildStatus: string;
+    totalCost: number;
+    projectPath: string;
+    /** Subagent state for long-running task recovery. */
+    subagentState?: {
+        type: string;
+        task: string;
+        toolCallsSoFar: string[];
+        partialOutput: string;
+        cost: number;
+    };
+}
+/**
+ * Manages session checkpoints in SQLite.
+ */
+declare class SessionCheckpointer {
+    private db;
+    private saveInterval;
+    private lastSaveTurn;
+    /**
+     * @param db - better-sqlite3 database instance
+     * @param saveInterval - Save every N turns (default: 5)
+     */
+    constructor(db: any, saveInterval?: number);
+    /**
+     * Save a checkpoint if enough turns have passed since the last save.
+     */
+    saveIfNeeded(data: SessionCheckpointData): boolean;
+    /**
+     * Force-save a checkpoint regardless of interval.
+     */
+    save(data: SessionCheckpointData): boolean;
+    /**
+     * Load the most recent checkpoint for a session.
+     */
+    load(sessionId: string): SessionCheckpointData | null;
+    /**
+     * Find sessions that have checkpoints but didn't end cleanly.
+     * Returns sessions with checkpoints newer than maxAgeMs.
+     */
+    listRecoverable(maxAgeMs?: number): Array<{
+        sessionId: string;
+        turnNumber: number;
+        createdAt: number;
+        projectPath: string;
+    }>;
+    /**
+     * Remove all checkpoints for a session (call on clean exit).
+     */
+    cleanup(sessionId: string): void;
+    /**
+     * Remove all checkpoints older than maxAgeMs.
+     */
+    cleanupOld(maxAgeMs?: number): number;
+}
+
+/**
+ * Ensemble Generation — multi-model diversity for hard tasks.
+ *
+ * For tasks classified as complex/expert, generate from 2-3 models in parallel
+ * and pick the best result via voting or comparison. Simple tasks keep
+ * single-model routing (cheap).
+ *
+ * BrainstormRouter advantage: we pick the optimal 3 models dynamically
+ * from production data. Trae Agent hardcodes Claude + Gemini + o4-mini.
+ *
+ * Inspired by ByteDance Trae Agent's generation-pruning-selection pipeline.
+ */
+
+interface EnsembleCandidate {
+    model: string;
+    text: string;
+    tokenCount: number;
+    latencyMs: number;
+    cost: number;
+}
+interface EnsembleResult {
+    winner: EnsembleCandidate;
+    candidates: EnsembleCandidate[];
+    strategy: EnsembleStrategy;
+    reason: string;
+    earlyTermination: boolean;
+}
+type EnsembleStrategy = "shortest" | "vote" | "first-pass";
+/**
+ * Check if a task should use ensemble generation.
+ */
+declare function shouldUseEnsemble(complexity: Complexity, ensembleEnabled: boolean): boolean;
+/**
+ * Prune duplicate results by token-level similarity.
+ * Uses Jaccard similarity on word tokens.
+ */
+declare function pruneResults(candidates: EnsembleCandidate[], similarityThreshold?: number): EnsembleCandidate[];
+/**
+ * Select the winning candidate from pruned results.
+ */
+declare function selectWinner(candidates: EnsembleCandidate[], strategy?: EnsembleStrategy): EnsembleResult;
+/**
+ * Check for early termination: if first 2 results are very similar,
+ * skip the 3rd model call.
+ */
+declare function checkEarlyTermination(candidatesSoFar: EnsembleCandidate[], similarityThreshold?: number): boolean;
+/**
+ * Format ensemble result for context injection.
+ */
+declare function formatEnsembleResult(result: EnsembleResult): string;
+
+/**
+ * Step Summarization — async one-line summaries for TUI display.
+ *
+ * After each agent step, generates a concise summary + activity tag
+ * using a cheap model. Runs async (fire-and-forget) to avoid blocking.
+ *
+ * Inspired by Trae Agent's Lakeview step summarization system.
+ */
+type ActivityTag = 'READING' | 'WRITING' | 'TESTING' | 'DEBUGGING' | 'PLANNING' | 'SEARCHING' | 'REVIEWING' | 'COMMITTING';
+interface StepSummary {
+    /** One-line summary (max 80 chars). */
+    summary: string;
+    /** Activity classification tag. */
+    tag: ActivityTag;
+    /** Step number. */
+    step: number;
+    /** Timestamp. */
+    timestamp: number;
+}
+/** Classify a tool call into an activity tag. */
+declare function classifyActivity(toolName: string): ActivityTag;
+/**
+ * Generate a quick summary from tool call info (no LLM needed).
+ * For simple cases, heuristic summarization is sufficient.
+ */
+declare function summarizeStep(step: number, toolName: string, toolInput: Record<string, unknown>, ok: boolean): StepSummary;
+/**
+ * Format step summaries as a timeline for display.
+ */
+declare function formatStepTimeline(summaries: StepSummary[]): string;
+
+export { type ActivityTag, type AgentLoopOptions, type AgentMiddleware, type BuildResult, BuildStateTracker, type BuildStatus, type CommitSummary, type CommunityFixPair, type CommunityFixResult, type CompactionCallbacks, type CostPrediction, type CostTier, DREAM_SYSTEM_PROMPT, type EnsembleCandidate, type EnsembleResult, type EnsembleStrategy, type ErrorFixPair, ErrorFixTracker, type ExternalAgentConfig, type ExternalAgentResult, type FileChange, FileWatcher, type LLMCallData, LoopDetector, type LoopWarning, type MemoryEntry, MemoryManager, type MessageStatus, type MiddlewareBlock, type MiddlewareMessage, MiddlewarePipeline, type MiddlewareState, type MiddlewareToolCall, type MiddlewareToolResult, type MultimodalContent, OUTPUT_STYLES, type OrchestrationTrajectory, TrajectoryRecorder$1 as OrchestrationTrajectoryRecorder, type OutputStyle, PathTraversalError, PermissionManager, type Persona, type PhaseDispatcher, type PhaseResult, type PhaseTrajectory, type PipelineEvent, type PipelineOptions, type PipelineOutcome, type PipelinePhase, type PlanEvent, type PlanExecutorOptions, type PlanFile, type PlanNodeStatus, type PlanPhase, type PlanSprint, type PlanTask, type ProjectHealth, type ReactionEntry, type ReactionSignal, ReactionTracker, type ReductionResult, type RepoMap, type RepoMapEntry, type ReviewFinding, type RoutingDecisionData, SUBAGENT_TYPE_NAMES, type ScanResult, type SearchResult, type SelfReviewOptions, type SelfReviewResult, type SessionCheckpointData, SessionCheckpointer, SessionManager, SessionPatternLearner, type SkillDefinition, type SpeculativeApproach, type SpeculativeOutcome, type SpeculativeResult, type StepSummary, type StreamFilter, type StyleProfile, type SubagentDispatcher, type SubagentHookFn, type SubagentOptions, type SubagentResult, type SubagentType, type SymbolSignature, type TaskDispatch, type ToneResult, type ToolCallData, type ToolResultData, type TrajectoryEvent, type TrajectoryEventType, TrajectoryRecorder, type UserTone, autoLintMiddleware, buildDreamPrompt, buildRepoMap, buildSelfReviewPrompt, buildStateMiddleware, buildSystemPrompt, buildToolAwarenessSection, checkBuild, checkEarlyTermination, classifyActivity, classifyPlanTask, collectProjectHealth, compactContext, composePersonaPrompt, createAuditMiddleware, createDefaultMiddlewarePipeline, createPipelineDispatcher, createStreamFilter, createSubagentTool, createWorktree, detectFramework, detectTone, enterToolExecution, estimateTaskCost, estimateTokenCount, executePlan, exitToolExecution, filterResponse, findSkill, formatCommitContext, formatCommunityFixes, formatCostPrediction, formatEnsembleResult, formatProjectHealth, formatReductionStats, formatStepTimeline, formatStyleContext, generateRepoMap, getAuditLog, getChangedFiles, getContextPercent, getOutputStylePrompt, getPersona, getPlanModePrompt, getPlanModeTools, getSubagentTypeConfig, indexProject, indexRecentCommits, invokeExternalAgent, isBlocked, isIgnored, isImageFile, isPdfFile, isToolInFlight, isWithinWorkspace, learnStyle, listPersonas, loadIgnorePatterns, loadSkills, loopDetectionMiddleware, needsCompaction, normalizeErrorSignature, normalizeInsightMarkers, parseAtMentions, parsePlanContent, parsePlanFile, parseSelfReviewResponse, pickWinner, predictTaskCost, pruneResults, queryCommunityFixes, readMultimodalFile, redactCredentials, reduceTrajectory, removeWorktree, repoMapToContext, requiresVisionModel, resolveSafe, runAgentLoop, runOrchestrationPipeline, scanForCredentials, searchCommitHistory, selectWinner, semanticSearch, sentimentMiddleware, sftExamplesToJSONL, shouldUseEnsemble, spawnParallel, spawnSubagent, subagentLimitMiddleware, submitCommunityFix, summarizeStep, toneGuidance, toolHealthMiddleware, trajectoryReductionMiddleware, trajectoryToSFTExamples, turnContextMiddleware, updateTaskInFile };