@wrongstack/core 0.1.0

package/dist/system-prompt-BG3nks8P.d.ts

@@ -0,0 +1,16 @@
+import { a2 as Tool, a0 as TextBlock } from './secret-scrubber-Dax_Ou_o.js';
+
+interface BuildContext {
+    cwd: string;
+    projectRoot: string;
+    tools: Tool[];
+    /** Provider id (e.g. "anthropic", "minimax-coding-plan"). */
+    provider?: string;
+    /** Model id (e.g. "claude-sonnet-4-6", "MiniMax-M2.7"). */
+    model?: string;
+}
+interface SystemPromptBuilder {
+    build(ctx: BuildContext): Promise<TextBlock[]>;
+}
+
+export type { BuildContext as B, SystemPromptBuilder as S };

package/dist/tool-executor-DjnMELMV.d.ts

@@ -0,0 +1,689 @@
+import { f as ContentBlock, ag as Context, a2 as Tool, a9 as WireFamily, z as ProviderConfig, y as Provider, ah as Container, ai as EventBus, au as Pipeline, D as Request, K as Response, a5 as ToolUseBlock, a4 as ToolResultBlock, a0 as TextBlock, aw as RunOptions, az as ReadonlyPipeline, d as Config, j as Logger, aj as EventName, ak as Listener, v as PermissionPolicy, S as SecretScrubber, R as Renderer } from './secret-scrubber-Dax_Ou_o.js';
+
+type AttachmentKind = 'text' | 'image' | 'file';
+interface AttachmentMeta {
+    /** Display label for the placeholder e.g. "123 lines" or "PNG 412 KB". */
+    label?: string;
+    /** Original filename if known. */
+    filename?: string;
+    /** MIME type if known. Required for images. */
+    mediaType?: string;
+}
+interface Attachment {
+    readonly id: string;
+    readonly kind: AttachmentKind;
+    readonly meta: AttachmentMeta;
+    /** In-memory payload. For images this is base64; for text/file it's the raw text. */
+    readonly data?: string;
+    /** Disk location if spooled. Mutually exclusive with `data` for large payloads. */
+    readonly path?: string;
+    readonly bytes: number;
+    readonly createdAt: string;
+}
+interface AttachmentRef {
+    readonly id: string;
+    readonly kind: AttachmentKind;
+    /** Index for display, e.g. `#1`. Stable for the lifetime of a session. */
+    readonly seq: number;
+    readonly meta: AttachmentMeta;
+}
+interface AddAttachmentInput {
+    kind: AttachmentKind;
+    data: string;
+    meta?: AttachmentMeta;
+}
+/**
+ * Session-scoped store for content that is too big to inline in display
+ * but must be sent to the model as a real ContentBlock. The input layer
+ * (CLI/TUI) puts pasted text, dropped files, and pasted images here, gets
+ * back a stable AttachmentRef, and shows a placeholder like `[pasted #1]`
+ * to the user. At submit time, `expand()` swaps placeholders for the real
+ * payload as ContentBlock[].
+ */
+interface AttachmentStore {
+    add(input: AddAttachmentInput): Promise<AttachmentRef>;
+    get(id: string): Promise<Attachment | undefined>;
+    list(): AttachmentRef[];
+    /**
+     * Replace all known placeholder tokens in `text` (e.g. `[pasted #1]`,
+     * `[image #2]`) with the corresponding ContentBlock(s) and return the
+     * mixed array. Unknown placeholders are left as plain text.
+     */
+    expand(text: string): Promise<ContentBlock[]>;
+    clear(): Promise<void>;
+}
+
+/**
+ * SecretVault encrypts secrets-at-rest in config files. The wire format is
+ * `enc:v1:<base64-iv>:<base64-tag>:<base64-ciphertext>`. Plaintext strings
+ * (those that do not match this prefix) are passed through unchanged so that
+ * existing configs and env-var-derived values keep working.
+ *
+ * The vault is intentionally NOT designed to defeat a determined local
+ * attacker who can read both the config file and the key file — that level
+ * of secrecy needs the OS keychain. The goal is to keep keys from being
+ * visible in screen shares, accidental log captures, and `cat config.json`
+ * over someone's shoulder.
+ */
+interface SecretVault {
+    encrypt(plaintext: string): string;
+    decrypt(value: string): string;
+    isEncrypted(value: string): boolean;
+}
+declare const ENCRYPTED_PREFIX = "enc:v1:";
+
+/**
+ * A slash command registered with the CLI or available to plugins.
+ * Plugins receive a view of the registry via PluginAPI.slashCommands.
+ *
+ * Commands registered by plugins use a namespaced name: `pluginName:commandName`.
+ * This prevents collisions with built-in commands and other plugins.
+ */
+interface SlashCommand {
+    /** Unique command name. For plugins: `pluginName:commandName`. */
+    name: string;
+    /** Short aliases — also prefixed automatically: `pluginName:alias`. */
+    aliases?: string[];
+    description: string;
+    /**
+     * Execute the command.
+     * @param args Everything after the command name (trimmed by dispatch).
+     * @param ctx The current agent context.
+     * @returns `{ exit: true }` to quit the REPL. `{ message }` to print and continue.
+     */
+    run(args: string, ctx: Context): Promise<{
+        exit?: boolean;
+        message?: string;
+    } | void>;
+}
+
+declare class ToolRegistry {
+    private readonly tools;
+    register(tool: Tool, owner?: string): void;
+    /**
+     * Register a tool as a default. If the tool name is already registered,
+     * this is a no-op — the existing registration (from core or another
+     * plugin) takes precedence. Use `override` to intentionally replace.
+     */
+    registerDefault(tool: Tool, owner?: string): void;
+    unregister(name: string): boolean;
+    /**
+     * Override an existing tool. Throws if the tool is not already registered.
+     * Plugins use this to replace built-in tools with custom implementations.
+     */
+    override(name: string, tool: Tool, owner?: string): void;
+    get(name: string): Tool | undefined;
+    ownerOf(name: string): string | undefined;
+    list(): Tool[];
+    listWithOwner(): {
+        tool: Tool;
+        owner: string;
+    }[];
+    clear(): void;
+}
+
+/**
+ * Factory for constructing a Provider instance. The `family` field
+ * declares the wire protocol so callers can route without inspecting
+ * the returned instance. The `type` is the registry key (e.g. a
+ * provider's models.dev id or a user-chosen alias).
+ */
+interface ProviderFactory$1 {
+    /**
+     * Unique identifier used as the registry key. When registered via
+     * a plugin, this becomes `cfg.type` in `ProviderRegistry.create(cfg)`.
+     */
+    type: string;
+    /**
+     * Declares the wire protocol family so consumers can route based on
+     * capability (e.g. which tool-format converter to use) without
+     * instantiating the provider.
+     */
+    family: WireFamily;
+    create(cfg: ProviderConfig): Provider;
+}
+declare class ProviderRegistry {
+    private readonly factories;
+    register(f: ProviderFactory$1): void;
+    has(type: string): boolean;
+    create(cfg: ProviderConfig): Provider;
+    list(): string[];
+}
+
+/** Default iteration cap. Use 0 or Infinity via config to disable. */
+declare const DEFAULT_MAX_ITERATIONS = 100;
+interface RunResult {
+    status: 'done' | 'failed' | 'max_iterations' | 'aborted';
+    error?: unknown;
+    finalText?: string;
+    iterations: number;
+}
+interface AgentInit {
+    container: Container;
+    tools: ToolRegistry;
+    providers: ProviderRegistry;
+    events: EventBus;
+    pipelines: AgentPipelines;
+    context: Context;
+    maxIterations?: number;
+    iterationTimeoutMs?: number;
+    executionStrategy?: 'parallel' | 'sequential' | 'smart';
+    perIterationOutputCapBytes?: number;
+    /**
+     * When true (default), the agent automatically extends its iteration
+     * limit by 100 when hit, without asking the user. Set to false to
+     * emit `iteration.limit_reached` and wait for a listener to grant/deny.
+     */
+    autoExtendLimit?: boolean;
+}
+interface AgentPipelines {
+    request: Pipeline<Request>;
+    response: Pipeline<Response>;
+    toolCall: Pipeline<ToolCallPipelinePayload>;
+    userInput: Pipeline<UserInputPayload>;
+    assistantOutput: Pipeline<TextBlock>;
+    contextWindow: Pipeline<Context>;
+}
+interface UserInputPayload {
+    content: ContentBlock[];
+    /** Concatenation of text blocks — convenience for middleware that only cares about text. */
+    text: string;
+    ctx: Context;
+}
+type AgentInput = string | ContentBlock[];
+interface ToolCallPipelinePayload {
+    toolUse: ToolUseBlock;
+    result: ToolResultBlock;
+    ctx: Context;
+    /** Undefined when the model invoked a tool name we don't know. */
+    tool?: Tool;
+}
+declare function createDefaultPipelines(): AgentPipelines;
+declare class Agent {
+    readonly container: Container;
+    readonly tools: ToolRegistry;
+    readonly providers: ProviderRegistry;
+    readonly events: EventBus;
+    readonly pipelines: AgentPipelines;
+    readonly ctx: Context;
+    private readonly maxIterations;
+    private readonly iterationTimeoutMs;
+    private readonly executionStrategy;
+    private readonly perIterationOutputCapBytes;
+    private readonly plugins;
+    private readonly toolExecutor;
+    private readonly autoExtendLimit;
+    constructor(init: AgentInit);
+    private get logger();
+    private get retry();
+    private get errorHandler();
+    private get permission();
+    private get scrubber();
+    private get compactor();
+    private get renderer();
+    register(tool: Tool): void;
+    use(plugin: Plugin, api: PluginAPI): Promise<void>;
+    run(userInput: AgentInput, opts?: RunOptions): Promise<RunResult>;
+    private runInner;
+    /**
+     * Emit an event asking listeners (CLI/TUI) whether to extend the iteration
+     * limit. Returns the number of additional iterations granted. If no listener
+     * responds or the user declines, returns 0.
+     */
+    private requestLimitExtension;
+    /**
+     * Consume a Provider.stream() into a Response, emitting text_delta and
+     * tool_use lifecycle events to the EventBus as they arrive. This is the
+     * canonical path when the provider declares `capabilities.streaming`;
+     * complete() is only used as a fallback for legacy providers.
+     */
+    private streamProviderToResponse;
+    private callProviderWithRetry;
+    private executeTools;
+}
+
+interface ToolRegistryView {
+    register(t: Tool): void;
+    unregister(name: string): void;
+    get(name: string): Tool | undefined;
+    list(): Tool[];
+}
+interface ProviderFactory {
+    type: string;
+    family: WireFamily;
+    create(cfg: unknown): Provider;
+}
+interface ProviderRegistryView {
+    register(f: ProviderFactory): void;
+    create(cfg: {
+        type: string;
+    } & Record<string, unknown>): Provider;
+    list(): string[];
+}
+interface MCPRegistryView {
+    start(cfg: unknown): Promise<void>;
+    stop(name: string): Promise<void>;
+    restart(name: string): Promise<void>;
+    list(): {
+        name: string;
+        state: string;
+        toolCount: number;
+    }[];
+}
+interface SlashCommandRegistryView {
+    register(cmd: SlashCommand): void;
+    unregister(name: string): boolean;
+    get(name: string): SlashCommand | undefined;
+    list(): SlashCommand[];
+}
+interface PluginPipelines {
+    request: ReadonlyPipeline<Request>;
+    response: ReadonlyPipeline<Response>;
+    toolCall: ReadonlyPipeline<ToolCallPipelinePayload>;
+    userInput: ReadonlyPipeline<{
+        content: ContentBlock[];
+        text: string;
+        ctx: Context;
+    }>;
+    assistantOutput: ReadonlyPipeline<TextBlock>;
+    contextWindow: ReadonlyPipeline<Context>;
+    [k: string]: ReadonlyPipeline<any>;
+}
+interface PluginAPI {
+    container: Container;
+    pipelines: PluginPipelines;
+    events: EventBus;
+    tools: ToolRegistryView;
+    providers: ProviderRegistryView;
+    mcp: MCPRegistryView;
+    slashCommands: SlashCommandRegistryView;
+    config: Config;
+    log: Logger;
+    /**
+     * Register a one-time event listener. The handler is automatically removed
+     * after the first emission, or when the plugin is uninstalled — whichever
+     * comes first.
+     */
+    onEvent<K extends EventName>(event: K, handler: Listener<K>): () => void;
+}
+interface Plugin {
+    name: string;
+    version?: string;
+    apiVersion: string;
+    /** Mandatory plugin dependencies — loading fails if any are absent. */
+    dependsOn?: string[];
+    /** Optional plugin dependencies — silently skipped if absent. */
+    optionalDeps?: string[];
+    conflictsWith?: string[];
+    setup(api: PluginAPI): void | Promise<void>;
+    teardown?(api: PluginAPI): void | Promise<void>;
+}
+
+interface Mode {
+    id: string;
+    name: string;
+    description: string;
+    /** Additional prompt text injected into system prompt when mode is active */
+    prompt: string;
+    /** Tags for tool_search filtering */
+    tags?: string[];
+    /** Tools that should be prioritized/highlighted when this mode is active */
+    toolPreferences?: string[];
+}
+interface ModeManifest {
+    modes: Mode[];
+    defaultMode?: string;
+}
+interface ModeStore {
+    getActiveMode(): Promise<Mode | null>;
+    setActiveMode(modeId: string | null): Promise<void>;
+    listModes(): Promise<Mode[]>;
+    getMode(modeId: string): Promise<Mode | null>;
+}
+interface ModeConfig {
+    directory: string;
+}
+declare const DEFAULT_MODES: Mode[];
+
+type BridgeMessageType = 'task' | 'result' | 'progress' | 'error' | 'heartbeat' | 'stop' | 'delegate';
+interface BridgeMessage<T = unknown> {
+    id: string;
+    type: BridgeMessageType;
+    from: string;
+    to?: string;
+    payload: T;
+    timestamp: number;
+    priority?: 'low' | 'normal' | 'high' | 'critical';
+}
+interface AgentBridgeConfig {
+    agentId: string;
+    coordinatorId: string;
+    timeoutMs?: number;
+    bufferSize?: number;
+}
+interface AgentBridge {
+    readonly agentId: string;
+    readonly coordinatorId: string;
+    send(msg: BridgeMessage): Promise<void>;
+    broadcast(msg: BridgeMessage): Promise<void>;
+    subscribe(handler: (msg: BridgeMessage) => void | Promise<void>): () => void;
+    request<T>(msg: BridgeMessage, timeoutMs?: number): Promise<BridgeMessage<T>>;
+    stop(): Promise<void>;
+}
+interface BridgeTransport {
+    send(msg: BridgeMessage, to: string): Promise<void>;
+    subscribe(agentId: string, handler: (msg: BridgeMessage) => void | Promise<void>): () => void;
+    close(agentId: string): Promise<void>;
+}
+
+interface SubagentConfig {
+    id: string;
+    name: string;
+    role: string;
+    prompt?: string;
+    maxIterations?: number;
+    maxToolCalls?: number;
+    timeoutMs?: number;
+    tools?: string[];
+    model?: string;
+    priority?: number;
+}
+interface TaskResult<T = unknown> {
+    subagentId: string;
+    taskId: string;
+    status: 'success' | 'failed' | 'timeout' | 'stopped';
+    result?: T;
+    error?: string;
+    iterations: number;
+    toolCalls: number;
+    durationMs: number;
+}
+interface TaskSpec {
+    id: string;
+    description: string;
+    subagentId?: string;
+    priority?: number;
+    maxToolCalls?: number;
+    timeoutMs?: number;
+    context?: Record<string, unknown>;
+}
+interface DoneCondition {
+    type: 'iterations' | 'tool_calls' | 'output_match' | 'custom' | 'all_tasks_done';
+    maxIterations?: number;
+    maxToolCalls?: number;
+    pattern?: string;
+    predicate?: string;
+}
+interface MultiAgentConfig {
+    coordinatorId: string;
+    leaderSystemPrompt?: string;
+    subagents?: SubagentConfig[];
+    maxConcurrent?: number;
+    doneCondition: DoneCondition;
+    timeoutMs?: number;
+}
+interface SpawnResult {
+    subagentId: string;
+    agentId: string;
+}
+interface TaskDelegation {
+    task: TaskSpec;
+    subagentId: string;
+}
+interface CoordinatorEvents {
+    'task.assigned': {
+        task: TaskSpec;
+        subagentId: string;
+    };
+    'task.completed': {
+        task: TaskSpec;
+        result: TaskResult;
+    };
+    'subagent.started': {
+        subagent: SubagentConfig;
+    };
+    'subagent.stopped': {
+        subagentId: string;
+        reason: string;
+    };
+    'done': {
+        results: TaskResult[];
+        totalIterations: number;
+    };
+}
+interface MultiAgentCoordinator {
+    readonly coordinatorId: string;
+    readonly config: MultiAgentConfig;
+    spawn(subagent: SubagentConfig): Promise<SpawnResult>;
+    assign(task: TaskSpec): Promise<void>;
+    delegate(to: string, msg: BridgeMessage): Promise<void>;
+    stop(subagentId: string): Promise<void>;
+    stopAll(): Promise<void>;
+    getStatus(): CoordinatorStatus;
+}
+interface CoordinatorStatus {
+    coordinatorId: string;
+    subagents: {
+        id: string;
+        name: string;
+        status: 'running' | 'idle' | 'stopped' | 'error';
+        currentTask?: string;
+    }[];
+    pendingTasks: number;
+    completedTasks: number;
+    totalIterations: number;
+    done: boolean;
+}
+interface SubagentContext {
+    subagentId: string;
+    tasks: TaskSpec[];
+    parentBridge: AgentBridge;
+    doneCondition: DoneCondition;
+    maxConcurrent: number;
+}
+
+type SpecStatus = 'draft' | 'review' | 'approved' | 'implemented' | 'deprecated';
+type SpecSectionType = 'overview' | 'requirements' | 'architecture' | 'api' | 'data' | 'security' | 'acceptance';
+interface SpecSection {
+    type: SpecSectionType;
+    title: string;
+    content: string;
+    level: number;
+    children?: SpecSection[];
+}
+interface SpecRequirement {
+    id: string;
+    type: 'functional' | 'non-functional' | 'security' | 'performance' | 'ux';
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    description: string;
+    acceptanceCriteria: string[];
+    blockedBy?: string[];
+    implements?: string[];
+}
+interface SpecApiEndpoint {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    path: string;
+    description: string;
+    request?: Record<string, unknown>;
+    response?: Record<string, unknown>;
+    auth?: boolean;
+}
+interface Specification {
+    id: string;
+    title: string;
+    version: string;
+    status: SpecStatus;
+    overview: string;
+    sections: SpecSection[];
+    requirements: SpecRequirement[];
+    apiEndpoints?: SpecApiEndpoint[];
+    dependencies?: string[];
+    createdAt: number;
+    updatedAt: number;
+    metadata?: Record<string, unknown>;
+}
+interface SpecAnalysis {
+    specId: string;
+    completeness: number;
+    coverage: {
+        requirements: number;
+        apiEndpoints: number;
+        edgeCases: number;
+        errorHandling: number;
+    };
+    gaps: string[];
+    risks: {
+        requirement: string;
+        risk: string;
+        severity: 'high' | 'medium' | 'low';
+    }[];
+    suggestions: string[];
+}
+interface SpecValidationResult {
+    valid: boolean;
+    errors: {
+        path: string;
+        message: string;
+    }[];
+    warnings: {
+        path: string;
+        message: string;
+    }[];
+}
+interface SpecTemplate {
+    id: string;
+    name: string;
+    description: string;
+    sections: Omit<SpecSection, 'content'>[];
+    defaultRequirements: Omit<SpecRequirement, 'id' | 'description'>[];
+}
+declare const DEFAULT_SPEC_TEMPLATE: SpecTemplate;
+
+type TaskStatus = 'pending' | 'in_progress' | 'blocked' | 'failed' | 'review' | 'completed';
+type TaskPriority = 'critical' | 'high' | 'medium' | 'low';
+type TaskType = 'feature' | 'bugfix' | 'refactor' | 'docs' | 'test' | 'chore';
+interface TaskNode {
+    id: string;
+    title: string;
+    description: string;
+    type: TaskType;
+    priority: TaskPriority;
+    status: TaskStatus;
+    assignee?: string;
+    estimateHours?: number;
+    actualHours?: number;
+    tags?: string[];
+    specRequirementId?: string;
+    parentId?: string;
+    children?: string[];
+    createdAt: number;
+    updatedAt: number;
+    completedAt?: number;
+    metadata?: Record<string, unknown>;
+}
+interface TaskEdge {
+    id: string;
+    from: string;
+    to: string;
+    type: 'blocks' | 'depends_on' | 'relates_to' | 'implements';
+    weight?: number;
+}
+interface TaskGraph {
+    id: string;
+    specId: string;
+    title: string;
+    nodes: Map<string, TaskNode>;
+    edges: TaskEdge[];
+    rootNodes: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+interface TaskDependency {
+    taskId: string;
+    blockedBy: string[];
+    blocking: string[];
+}
+interface TaskAssignment {
+    taskId: string;
+    assignee: string;
+    assignedAt: number;
+}
+interface TaskProgress {
+    total: number;
+    pending: number;
+    inProgress: number;
+    blocked: number;
+    failed: number;
+    review: number;
+    completed: number;
+    percentComplete: number;
+    estimatedHours: number;
+    actualHours: number;
+}
+interface TaskFilter {
+    status?: TaskStatus[];
+    priority?: TaskPriority[];
+    type?: TaskType[];
+    assignee?: string[];
+    tags?: string[];
+    specRequirementId?: string;
+}
+interface TaskSort {
+    field: 'priority' | 'createdAt' | 'updatedAt' | 'status';
+    direction: 'asc' | 'desc';
+}
+interface CriticalPathResult {
+    taskIds: string[];
+    totalEstimateHours: number;
+    bottleneckTasks: string[];
+}
+declare function computeTaskProgress(graph: TaskGraph): TaskProgress;
+declare function findCriticalPath(graph: TaskGraph): CriticalPathResult;
+declare function topologicalSort(graph: TaskGraph): string[];
+
+/**
+ * Input for a single tool execution, scoped to a single iteration's budget.
+ */
+interface ToolExecution {
+    toolUse: ToolUseBlock;
+    result: ToolResultBlock;
+    /** True if the tool was not found in the registry. */
+    unknownTool?: boolean;
+    /** True if the tool execution threw an exception. */
+    threw?: boolean;
+}
+/**
+ * Output from a single tool execution.
+ */
+interface ToolExecutionOutput {
+    result: ToolResultBlock;
+    tool?: Tool;
+    durationMs: number;
+}
+/**
+ * Result of running a batch of tools for a single agent iteration.
+ */
+interface ToolBatchResult {
+    outputs: ToolExecutionOutput[];
+    remainingBudget: number;
+}
+interface ToolExecutorOptions {
+    permissionPolicy: PermissionPolicy;
+    secretScrubber: SecretScrubber;
+    renderer?: Renderer | undefined;
+    /**
+     * Optional event bus. When provided, the executor emits `tool.started`
+     * before invoking each tool's `execute()`. Closes the observability gap
+     * between "model decided to call tool" and "tool finished".
+     */
+    events?: EventBus | undefined;
+    iterationTimeoutMs?: number;
+    perIterationOutputCapBytes?: number;
+}
+interface ToolExecutorInit {
+    registry: ToolRegistry;
+    options: ToolExecutorOptions;
+}
+type ToolExecutorStrategy = 'parallel' | 'sequential' | 'smart';
+
+export { type TaskProgress as $, type AddAttachmentInput as A, type BridgeMessage as B, type CoordinatorEvents as C, DEFAULT_MODES as D, ENCRYPTED_PREFIX as E, type SpecAnalysis as F, type SpecApiEndpoint as G, type SpecRequirement as H, type SpecSection as I, type SpecSectionType as J, type SpecStatus as K, type SpecTemplate as L, type MCPRegistryView as M, type SpecValidationResult as N, type Specification as O, type Plugin as P, type SubagentConfig as Q, type SubagentContext as R, type SecretVault as S, type TaskAssignment as T, type TaskDelegation as U, type TaskDependency as V, type TaskEdge as W, type TaskFilter as X, type TaskGraph as Y, type TaskNode as Z, type TaskPriority as _, type AgentBridge as a, type TaskResult as a0, type TaskSort as a1, type TaskSpec as a2, type TaskStatus as a3, type TaskType as a4, type ToolBatchResult as a5, type ToolExecution as a6, type ToolExecutionOutput as a7, type ToolExecutorInit as a8, type ToolExecutorOptions as a9, type ToolExecutorStrategy as aa, type ToolRegistryView as ab, computeTaskProgress as ac, findCriticalPath as ad, topologicalSort as ae, ToolRegistry as af, ProviderRegistry as ag, Agent as ah, type AgentInit as ai, type AgentInput as aj, type AgentPipelines as ak, DEFAULT_MAX_ITERATIONS as al, type ProviderFactory$1 as am, type RunResult as an, type UserInputPayload as ao, createDefaultPipelines as ap, type AgentBridgeConfig as b, type Attachment as c, type AttachmentKind as d, type AttachmentMeta as e, type AttachmentRef as f, type AttachmentStore as g, type BridgeMessageType as h, type BridgeTransport as i, type CoordinatorStatus as j, type CriticalPathResult as k, DEFAULT_SPEC_TEMPLATE as l, type DoneCondition as m, type Mode as n, type ModeConfig as o, type ModeManifest as p, type ModeStore as q, type MultiAgentConfig as r, type MultiAgentCoordinator as s, type PluginAPI as t, type PluginPipelines as u, type ProviderFactory as v, type ProviderRegistryView as w, type SlashCommand as x, type SlashCommandRegistryView as y, type SpawnResult as z };