@neotx/core 0.1.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,1359 @@
+import { z, ZodType } from 'zod';
+import { HookEvent as HookEvent$1, HookCallbackMatcher } from '@anthropic-ai/claude-agent-sdk';
+
+declare const agentModelSchema: z.ZodEnum<{
+    opus: "opus";
+    sonnet: "sonnet";
+    haiku: "haiku";
+}>;
+declare const agentToolSchema: z.ZodEnum<{
+    Read: "Read";
+    Write: "Write";
+    Edit: "Edit";
+    Bash: "Bash";
+    Glob: "Glob";
+    Grep: "Grep";
+    Agent: "Agent";
+    WebSearch: "WebSearch";
+    WebFetch: "WebFetch";
+    NotebookEdit: "NotebookEdit";
+}>;
+declare const agentToolEntrySchema: z.ZodUnion<readonly [z.ZodEnum<{
+    Read: "Read";
+    Write: "Write";
+    Edit: "Edit";
+    Bash: "Bash";
+    Glob: "Glob";
+    Grep: "Grep";
+    Agent: "Agent";
+    WebSearch: "WebSearch";
+    WebFetch: "WebFetch";
+    NotebookEdit: "NotebookEdit";
+}>, z.ZodLiteral<"$inherited">]>;
+declare const agentSandboxSchema: z.ZodEnum<{
+    readonly: "readonly";
+    writable: "writable";
+}>;
+declare const agentConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    extends: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodEnum<{
+        opus: "opus";
+        sonnet: "sonnet";
+        haiku: "haiku";
+    }>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+        Read: "Read";
+        Write: "Write";
+        Edit: "Edit";
+        Bash: "Bash";
+        Glob: "Glob";
+        Grep: "Grep";
+        Agent: "Agent";
+        WebSearch: "WebSearch";
+        WebFetch: "WebFetch";
+        NotebookEdit: "NotebookEdit";
+    }>, z.ZodLiteral<"$inherited">]>>>;
+    prompt: z.ZodOptional<z.ZodString>;
+    promptAppend: z.ZodOptional<z.ZodString>;
+    sandbox: z.ZodOptional<z.ZodEnum<{
+        readonly: "readonly";
+        writable: "writable";
+    }>>;
+    maxTurns: z.ZodOptional<z.ZodNumber>;
+    mcpServers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type AgentConfig = z.infer<typeof agentConfigSchema>;
+type AgentModel = z.infer<typeof agentModelSchema>;
+type AgentTool = z.infer<typeof agentToolSchema>;
+type AgentToolEntry = z.infer<typeof agentToolEntrySchema>;
+
+/**
+ * Load a single agent definition from a YAML file.
+ * If the `prompt` field points to a .md file, resolve it relative
+ * to the YAML file's directory and read its content.
+ */
+declare function loadAgentFile(filePath: string): Promise<AgentConfig>;
+
+declare const mcpServerConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"http">;
+    url: z.ZodString;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"stdio">;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>], "type">;
+declare const repoConfigSchema: z.ZodObject<{
+    path: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    defaultBranch: z.ZodDefault<z.ZodString>;
+    branchPrefix: z.ZodDefault<z.ZodString>;
+    pushRemote: z.ZodDefault<z.ZodString>;
+    autoCreatePr: z.ZodDefault<z.ZodBoolean>;
+    prBaseBranch: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const globalConfigSchema: z.ZodObject<{
+    repos: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        defaultBranch: z.ZodDefault<z.ZodString>;
+        branchPrefix: z.ZodDefault<z.ZodString>;
+        pushRemote: z.ZodDefault<z.ZodString>;
+        autoCreatePr: z.ZodDefault<z.ZodBoolean>;
+        prBaseBranch: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    concurrency: z.ZodDefault<z.ZodObject<{
+        maxSessions: z.ZodDefault<z.ZodNumber>;
+        maxPerRepo: z.ZodDefault<z.ZodNumber>;
+        queueMax: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    budget: z.ZodDefault<z.ZodObject<{
+        dailyCapUsd: z.ZodDefault<z.ZodNumber>;
+        alertThresholdPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    recovery: z.ZodDefault<z.ZodObject<{
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        backoffBaseMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    sessions: z.ZodDefault<z.ZodObject<{
+        initTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxDurationMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    webhooks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        secret: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    supervisor: z.ZodDefault<z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+        secret: z.ZodOptional<z.ZodString>;
+        idleIntervalMs: z.ZodDefault<z.ZodNumber>;
+        heartbeatTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxConsecutiveFailures: z.ZodDefault<z.ZodNumber>;
+        maxEventsPerSec: z.ZodDefault<z.ZodNumber>;
+        dailyCapUsd: z.ZodDefault<z.ZodNumber>;
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"http">;
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"stdio">;
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>], "type">>>;
+    claudeCodePath: z.ZodOptional<z.ZodString>;
+    idempotency: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        key: z.ZodDefault<z.ZodEnum<{
+            prompt: "prompt";
+            metadata: "metadata";
+        }>>;
+        ttlMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const neoConfigSchema: z.ZodObject<{
+    repos: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        defaultBranch: z.ZodDefault<z.ZodString>;
+        branchPrefix: z.ZodDefault<z.ZodString>;
+        pushRemote: z.ZodDefault<z.ZodString>;
+        autoCreatePr: z.ZodDefault<z.ZodBoolean>;
+        prBaseBranch: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    concurrency: z.ZodDefault<z.ZodObject<{
+        maxSessions: z.ZodDefault<z.ZodNumber>;
+        maxPerRepo: z.ZodDefault<z.ZodNumber>;
+        queueMax: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    budget: z.ZodDefault<z.ZodObject<{
+        dailyCapUsd: z.ZodDefault<z.ZodNumber>;
+        alertThresholdPct: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    recovery: z.ZodDefault<z.ZodObject<{
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        backoffBaseMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    sessions: z.ZodDefault<z.ZodObject<{
+        initTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxDurationMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    webhooks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        secret: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    supervisor: z.ZodDefault<z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+        secret: z.ZodOptional<z.ZodString>;
+        idleIntervalMs: z.ZodDefault<z.ZodNumber>;
+        heartbeatTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxConsecutiveFailures: z.ZodDefault<z.ZodNumber>;
+        maxEventsPerSec: z.ZodDefault<z.ZodNumber>;
+        dailyCapUsd: z.ZodDefault<z.ZodNumber>;
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"http">;
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"stdio">;
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>], "type">>>;
+    claudeCodePath: z.ZodOptional<z.ZodString>;
+    idempotency: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        key: z.ZodDefault<z.ZodEnum<{
+            prompt: "prompt";
+            metadata: "metadata";
+        }>>;
+        ttlMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type NeoConfig = z.infer<typeof neoConfigSchema>;
+type GlobalConfig = NeoConfig;
+type RepoConfig = z.infer<typeof repoConfigSchema>;
+type RepoConfigInput = z.input<typeof repoConfigSchema>;
+type McpServerConfig = z.infer<typeof mcpServerConfigSchema>;
+/**
+ * Load NeoConfig from a single file (legacy compatibility).
+ */
+declare function loadConfig(configPath: string): Promise<NeoConfig>;
+/**
+ * Load the global config from ~/.neo/config.yml.
+ * Creates the file with defaults if it does not exist.
+ */
+declare function loadGlobalConfig(): Promise<NeoConfig>;
+/**
+ * Add a repo to ~/.neo/config.yml. Deduplicates by resolved path.
+ */
+declare function addRepoToGlobalConfig(repo: RepoConfigInput): Promise<void>;
+/**
+ * Remove a repo from ~/.neo/config.yml by path, name, or slug.
+ */
+declare function removeRepoFromGlobalConfig(pathOrName: string): Promise<boolean>;
+/**
+ * List all registered repos from ~/.neo/config.yml.
+ */
+declare function listReposFromGlobalConfig(): Promise<RepoConfig[]>;
+
+interface AgentDefinition {
+    description: string;
+    prompt: string;
+    tools: string[];
+    model: string;
+}
+interface ResolvedAgent {
+    name: string;
+    definition: AgentDefinition;
+    sandbox: "writable" | "readonly";
+    maxTurns?: number | undefined;
+    source: "built-in" | "custom" | "extended";
+}
+interface WorkflowDefinition {
+    name: string;
+    description?: string | undefined;
+    steps: Record<string, WorkflowStepDef | WorkflowGateDef>;
+}
+interface WorkflowStepDef {
+    type?: "step" | undefined;
+    agent: string;
+    dependsOn?: string[] | undefined;
+    prompt?: string | undefined;
+    sandbox?: "writable" | "readonly" | undefined;
+    maxTurns?: number | undefined;
+    mcpServers?: string[] | undefined;
+    recovery?: {
+        maxRetries?: number | undefined;
+        nonRetryable?: string[] | undefined;
+    } | undefined;
+}
+interface WorkflowGateDef {
+    type: "gate";
+    dependsOn?: string[] | undefined;
+    description: string;
+    timeout?: string | undefined;
+    autoApprove?: boolean | undefined;
+}
+interface PersistedRun {
+    version: 1;
+    runId: string;
+    workflow: string;
+    repo: string;
+    prompt: string;
+    branch?: string | undefined;
+    worktreePath?: string | undefined;
+    pid?: number | undefined;
+    status: "running" | "paused" | "completed" | "failed";
+    steps: Record<string, StepResult>;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: Record<string, unknown> | undefined;
+}
+interface StepResult {
+    status: "pending" | "running" | "success" | "failure" | "skipped";
+    sessionId?: string | undefined;
+    output?: unknown;
+    rawOutput?: string | undefined;
+    costUsd: number;
+    durationMs: number;
+    agent: string;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+    error?: string | undefined;
+    attempt: number;
+}
+type Priority = "critical" | "high" | "medium" | "low";
+interface DispatchInput {
+    workflow: string;
+    repo: string;
+    prompt: string;
+    runId?: string | undefined;
+    step?: string | undefined;
+    from?: string | undefined;
+    retry?: string | undefined;
+    priority?: Priority | undefined;
+    overrides?: {
+        agents?: Record<string, string> | undefined;
+        maxTurns?: number | undefined;
+        sandbox?: "writable" | "readonly" | undefined;
+    } | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}
+interface TaskResult {
+    runId: string;
+    workflow: string;
+    repo: string;
+    status: "success" | "failure" | "timeout" | "cancelled";
+    steps: Record<string, StepResult>;
+    prUrl?: string | undefined;
+    prNumber?: number | undefined;
+    branch?: string | undefined;
+    summary?: string | undefined;
+    costUsd: number;
+    durationMs: number;
+    timestamp: string;
+    metadata?: Record<string, unknown> | undefined;
+}
+interface ActiveSession {
+    sessionId: string;
+    runId: string;
+    workflow: string;
+    step: string;
+    agent: string;
+    repo: string;
+    status: "running" | "queued" | "waiting_gate";
+    startedAt: string;
+    worktreePath?: string | undefined;
+}
+interface OrchestratorStatus {
+    paused: boolean;
+    activeSessions: ActiveSession[];
+    queueDepth: number;
+    costToday: number;
+    budgetCapUsd: number;
+    budgetRemainingPct: number;
+    uptime: number;
+}
+interface WorkflowContext {
+    runId: string;
+    workflow: string;
+    repo: string;
+    prompt: string;
+    steps: Record<string, StepResult>;
+    startedAt: Date;
+}
+interface SessionStartEvent {
+    type: "session:start";
+    sessionId: string;
+    runId: string;
+    workflow: string;
+    step: string;
+    agent: string;
+    repo: string;
+    metadata?: Record<string, unknown> | undefined;
+    timestamp: string;
+}
+interface SessionCompleteEvent {
+    type: "session:complete";
+    sessionId: string;
+    runId: string;
+    status: "success" | "failure";
+    costUsd: number;
+    durationMs: number;
+    output?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+    timestamp: string;
+}
+interface SessionFailEvent {
+    type: "session:fail";
+    sessionId: string;
+    runId: string;
+    error: string;
+    attempt: number;
+    maxRetries: number;
+    willRetry: boolean;
+    metadata?: Record<string, unknown> | undefined;
+    timestamp: string;
+}
+interface AgentToolUseEvent {
+    type: "agent:tool_use";
+    sessionId: string;
+    agent: string;
+    tool: string;
+    input: Record<string, unknown>;
+    durationMs: number;
+    timestamp: string;
+}
+interface AgentMessageEvent {
+    type: "agent:message";
+    sessionId: string;
+    agent: string;
+    text: string;
+    timestamp: string;
+}
+interface WorkflowStepStartEvent {
+    type: "workflow:step_start";
+    runId: string;
+    step: string;
+    agent: string;
+    metadata?: Record<string, unknown> | undefined;
+    timestamp: string;
+}
+interface WorkflowStepCompleteEvent {
+    type: "workflow:step_complete";
+    runId: string;
+    step: string;
+    status: "success" | "failure" | "skipped";
+    costUsd: number;
+    durationMs: number;
+    metadata?: Record<string, unknown> | undefined;
+    timestamp: string;
+}
+interface GateWaitingEvent {
+    type: "gate:waiting";
+    runId: string;
+    gate: string;
+    description: string;
+    context: WorkflowContext;
+    approve: () => void;
+    reject: (reason: string) => void;
+    metadata?: Record<string, unknown> | undefined;
+    timestamp: string;
+}
+interface CostUpdateEvent {
+    type: "cost:update";
+    sessionId: string;
+    sessionCost: number;
+    todayTotal: number;
+    budgetRemainingPct: number;
+    timestamp: string;
+}
+interface BudgetAlertEvent {
+    type: "budget:alert";
+    todayTotal: number;
+    capUsd: number;
+    utilizationPct: number;
+    timestamp: string;
+}
+interface QueueEnqueueEvent {
+    type: "queue:enqueue";
+    sessionId: string;
+    repo: string;
+    position: number;
+    timestamp: string;
+}
+interface QueueDequeueEvent {
+    type: "queue:dequeue";
+    sessionId: string;
+    repo: string;
+    waitedMs: number;
+    timestamp: string;
+}
+interface OrchestratorShutdownEvent {
+    type: "orchestrator:shutdown";
+    timestamp: string;
+}
+type NeoEvent = SessionStartEvent | SessionCompleteEvent | SessionFailEvent | AgentToolUseEvent | AgentMessageEvent | WorkflowStepStartEvent | WorkflowStepCompleteEvent | GateWaitingEvent | CostUpdateEvent | BudgetAlertEvent | QueueEnqueueEvent | QueueDequeueEvent | OrchestratorShutdownEvent;
+type HookEvent = "PreToolUse" | "PostToolUse" | "Notification";
+interface Middleware {
+    name: string;
+    on: HookEvent;
+    match?: string | string[] | undefined;
+    handler: MiddlewareHandler;
+}
+type MiddlewareHandler = (event: MiddlewareEvent, context: MiddlewareContext) => Promise<MiddlewareResult>;
+interface MiddlewareEvent {
+    hookEvent: HookEvent;
+    sessionId: string;
+    toolName?: string | undefined;
+    input?: Record<string, unknown> | undefined;
+    output?: string | undefined;
+    message?: string | undefined;
+}
+/** Well-known context keys set by the orchestrator. */
+interface MiddlewareContextMap {
+    costToday: number;
+    budgetCapUsd: number;
+    [key: string]: unknown;
+}
+interface MiddlewareContext {
+    runId: string;
+    workflow: string;
+    step: string;
+    agent: string;
+    repo: string;
+    get: <K extends string & keyof MiddlewareContextMap>(key: K) => MiddlewareContextMap[K] | undefined;
+    set: <K extends string & keyof MiddlewareContextMap>(key: K, value: MiddlewareContextMap[K]) => void;
+}
+type MiddlewareResult = {
+    decision: "pass";
+} | {
+    decision: "block";
+    reason: string;
+} | {
+    decision: "async";
+    asyncTimeout: number;
+};
+interface CostEntry {
+    timestamp: string;
+    runId: string;
+    workflow: string;
+    step: string;
+    sessionId: string;
+    agent: string;
+    costUsd: number;
+    models: Record<string, number>;
+    durationMs: number;
+    repo?: string;
+}
+
+declare class AgentRegistry {
+    private readonly builtInDir;
+    private readonly customDir;
+    private agents;
+    constructor(builtInDir: string, customDir?: string);
+    load(): Promise<void>;
+    get(name: string): ResolvedAgent | undefined;
+    list(): ResolvedAgent[];
+    has(name: string): boolean;
+}
+
+/**
+ * Resolve an agent config into a fully-merged ResolvedAgent.
+ *
+ * Resolution rules:
+ * 1. No `extends` → agent must define all required fields
+ * 2. With `extends: "developer"` → start from built-in, apply overrides
+ * 3. Same name as built-in without `extends:` → treated as `extends: <name>` implicitly
+ */
+declare function resolveAgent(config: AgentConfig, builtIns: Map<string, AgentConfig>): ResolvedAgent;
+
+interface SemaphoreConfig {
+    maxSessions: number;
+    maxPerRepo: number;
+    queueMax?: number;
+}
+interface SemaphoreCallbacks {
+    onEnqueue?: (sessionId: string, repo: string, position: number) => void;
+    onDequeue?: (sessionId: string, repo: string, waitedMs: number) => void;
+}
+/**
+ * Concurrency semaphore with global + per-repo limits and a priority queue.
+ * When at capacity, `acquire()` blocks until a slot is available.
+ */
+declare class Semaphore {
+    private readonly maxSessions;
+    private readonly maxPerRepo;
+    private readonly queue;
+    private readonly callbacks;
+    private readonly activeSessions;
+    private readonly repoCounts;
+    constructor(config: SemaphoreConfig, callbacks?: SemaphoreCallbacks);
+    /**
+     * Acquire a slot. Blocks (via promise) if at capacity.
+     * Throws if the queue is full.
+     */
+    acquire(repo: string, sessionId: string, priority?: Priority, signal?: AbortSignal): Promise<void>;
+    /** Release a slot and process the next waiting entry. */
+    release(sessionId: string): void;
+    /** Non-blocking attempt to acquire a slot. Returns true if successful. */
+    tryAcquire(repo: string, sessionId: string): boolean;
+    /** Total number of active slots. */
+    activeCount(): number;
+    /** Number of active slots for a specific repo. */
+    activeCountForRepo(repo: string): number;
+    /** Can a slot be acquired for this repo without blocking? */
+    isAvailable(repo: string): boolean;
+    /** Current queue depth. */
+    queueDepth(): number;
+    private canAcquire;
+    private allocate;
+    private processQueue;
+}
+
+/**
+ * Append-only JSONL journal for cost tracking.
+ * Monthly file rotation: cost-YYYY-MM.jsonl
+ */
+declare class CostJournal {
+    private readonly dir;
+    private dirCreated;
+    private dayCache;
+    constructor(options: {
+        dir: string;
+    });
+    append(entry: CostEntry): Promise<void>;
+    getDayTotal(date?: Date): Promise<number>;
+    private fileForDate;
+    private ensureDir;
+}
+
+/**
+ * Safe EventEmitter wrapper (ADR-022).
+ *
+ * - Catches listener errors to prevent cascading crashes
+ * - Emits on both the specific event type and the wildcard "*" channel
+ * - Swallows errors from the error handler itself to guarantee stability
+ */
+declare class NeoEventEmitter {
+    private readonly emitter;
+    emit(event: NeoEvent): void;
+    on(eventType: string, listener: (event: NeoEvent) => void): this;
+    off(eventType: string, listener: (event: NeoEvent) => void): this;
+    once(eventType: string, listener: (event: NeoEvent) => void): this;
+    removeAllListeners(eventType?: string): this;
+    private safeEmit;
+}
+
+/**
+ * Append-only JSONL journal for events.
+ * Monthly file rotation: events-YYYY-MM.jsonl
+ * Write-only for v0.1 — read API comes in v0.2.
+ */
+declare class EventJournal {
+    private readonly dir;
+    private dirCreated;
+    constructor(options: {
+        dir: string;
+    });
+    append(event: NeoEvent): Promise<void>;
+    private fileForDate;
+    private ensureDir;
+}
+
+type WebhookConfig = NeoConfig["webhooks"][number];
+/**
+ * Fire-and-forget webhook dispatcher for NeoEvents.
+ *
+ * - Matches events against per-webhook filters (exact or wildcard like "session:*")
+ * - Excludes gate:waiting events (contain non-serializable callbacks)
+ * - Signs payloads with HMAC-SHA256 when a secret is configured
+ * - Never throws — errors are silently swallowed (consistent with EventJournal)
+ */
+declare class WebhookDispatcher {
+    private readonly webhooks;
+    constructor(webhooks: WebhookConfig[]);
+    dispatch(event: NeoEvent): void;
+}
+/**
+ * Check if an event type matches a filter list.
+ * Supports exact matches and wildcard prefixes (e.g. "session:*").
+ * No filter (undefined) means all events match.
+ */
+declare function matchesFilter(eventType: string, filters?: string[]): boolean;
+
+declare function createBranch(repoPath: string, branch: string, baseBranch: string): Promise<void>;
+declare function pushBranch(repoPath: string, branch: string, remote: string): Promise<void>;
+declare function fetchRemote(repoPath: string, remote: string): Promise<void>;
+declare function deleteBranch(repoPath: string, branch: string): Promise<void>;
+declare function getCurrentBranch(repoPath: string): Promise<string>;
+/**
+ * Generate a deterministic branch name for a run.
+ * Uses the repo's branchPrefix (default "feat") and the runId.
+ */
+declare function getBranchName(config: RepoConfig, runId: string): string;
+
+/**
+ * Per-repository in-memory mutex to serialise git operations.
+ * Concurrent git commands on the same repo corrupt the index — this prevents that.
+ */
+/**
+ * Execute `fn` while holding an exclusive lock for `repoPath`.
+ * Concurrent calls for the same repo are queued and executed serially.
+ * Operations on different repos run in parallel.
+ */
+declare function withGitLock<T>(repoPath: string, fn: () => Promise<T>): Promise<T>;
+
+/**
+ * SDK-compatible sandbox configuration.
+ * Controls which tools an agent can use and which paths it can access.
+ */
+interface SandboxConfig {
+    /** Tools the agent is allowed to use */
+    allowedTools: string[];
+    /** Directories the agent can read from */
+    readablePaths: string[];
+    /** Directories the agent can write to (empty for readonly agents) */
+    writablePaths: string[];
+    /** Whether the agent has write access */
+    writable: boolean;
+}
+/**
+ * Build an SDK-compatible sandbox configuration for an agent.
+ *
+ * - Writable agents: all their tools are allowed, write paths include the worktree
+ * - Readonly agents: write tools are filtered out, no writable paths
+ */
+declare function buildSandboxConfig(agent: ResolvedAgent, worktreePath?: string): SandboxConfig;
+
+interface WorktreeInfo {
+    path: string;
+    branch: string;
+    repoPath: string;
+}
+/**
+ * Create a new git worktree with an associated branch.
+ * Creates the branch from baseBranch, then adds the worktree at worktreeDir.
+ */
+declare function createWorktree(options: {
+    repoPath: string;
+    branch: string;
+    baseBranch: string;
+    worktreeDir: string;
+}): Promise<WorktreeInfo>;
+/**
+ * Remove a worktree. Does NOT delete the branch (branch stays for the PR).
+ * Idempotent — does not throw if the worktree is already gone.
+ */
+declare function removeWorktree(worktreePath: string): Promise<void>;
+/**
+ * List all worktrees for a repository.
+ */
+declare function listWorktrees(repoPath: string): Promise<WorktreeInfo[]>;
+/**
+ * Clean up worktrees under worktreeBaseDir that no longer have a matching run.
+ * Removes any subdirectory that is a git worktree.
+ */
+declare function cleanupOrphanedWorktrees(worktreeBaseDir: string): Promise<void>;
+
+/**
+ * Audit log middleware.
+ *
+ * Buffers JSONL entries in memory and flushes to disk either when
+ * the buffer reaches `flushSize` entries or every `flushIntervalMs`.
+ * File per session. Uses `{ decision: "async" }` so it never blocks the chain.
+ *
+ * Call `flush()` to force-write remaining entries (e.g. on shutdown).
+ */
+interface AuditLogMiddleware extends Middleware {
+    flush: () => Promise<void>;
+}
+declare function auditLog(options: {
+    dir: string;
+    includeInput?: boolean;
+    includeOutput?: boolean;
+    flushIntervalMs?: number;
+    flushSize?: number;
+}): AuditLogMiddleware;
+
+/**
+ * Budget guard middleware.
+ *
+ * Checks daily cost against budget cap on every tool call.
+ * If over budget, blocks with reason "Daily budget exceeded".
+ * Uses the middleware context's `get("costToday")` and `get("budgetCapUsd")`.
+ */
+declare function budgetGuard(): Middleware;
+
+interface MiddlewareChain {
+    execute(event: MiddlewareEvent, context: MiddlewareContext): Promise<MiddlewareResult>;
+}
+declare function buildMiddlewareChain(middleware: Middleware[]): MiddlewareChain;
+/**
+ * SDK hooks type — maps hook event names to callback matchers.
+ */
+type SDKHooks = Partial<Record<HookEvent$1, HookCallbackMatcher[]>>;
+/**
+ * Convert a middleware chain to Agent SDK hooks format.
+ *
+ * Creates one HookCallbackMatcher per supported event (PreToolUse, PostToolUse, Notification).
+ * The matcher delegates to the chain's execute method, translating SDK input to our
+ * MiddlewareEvent format.
+ */
+declare function buildSDKHooks(chain: MiddlewareChain, context: MiddlewareContext, middleware?: Middleware[]): SDKHooks;
+
+/**
+ * Loop detection middleware.
+ *
+ * Tracks Bash commands per session. If the same command appears
+ * `threshold` times, blocks it and tells the agent to escalate.
+ *
+ * Call `cleanup(sessionId)` when a session ends to prevent memory leaks.
+ */
+interface LoopDetectionMiddleware extends Middleware {
+    cleanup: (sessionId: string) => void;
+}
+declare function loopDetection(options: {
+    threshold: number;
+    scope?: "session";
+}): LoopDetectionMiddleware;
+
+interface OrchestratorOptions {
+    middleware?: Middleware[] | undefined;
+    journalDir?: string | undefined;
+    builtInWorkflowDir?: string | undefined;
+    customWorkflowDir?: string | undefined;
+}
+declare class Orchestrator extends NeoEventEmitter {
+    private readonly config;
+    private readonly semaphore;
+    private readonly userMiddleware;
+    private readonly workflows;
+    private readonly registeredAgents;
+    private readonly _activeSessions;
+    private readonly idempotencyCache;
+    private readonly abortControllers;
+    private readonly repoIndex;
+    private readonly createdRunDirs;
+    private readonly journalDir;
+    private readonly builtInWorkflowDir;
+    private readonly customWorkflowDir;
+    private costJournal;
+    private eventJournal;
+    private webhookDispatcher;
+    private _paused;
+    private _costToday;
+    private _startedAt;
+    private _drainResolve;
+    constructor(config: NeoConfig, options?: OrchestratorOptions);
+    registerWorkflow(definition: WorkflowDefinition): void;
+    registerAgent(agent: ResolvedAgent): void;
+    dispatch(input: DispatchInput): Promise<TaskResult>;
+    pause(): void;
+    resume(): void;
+    kill(sessionId: string): Promise<void>;
+    drain(): Promise<void>;
+    get status(): OrchestratorStatus;
+    get activeSessions(): ActiveSession[];
+    start(): Promise<void>;
+    shutdown(): Promise<void>;
+    emit(event: NeoEvent): void;
+    static middleware: {
+        loopDetection: (options: {
+            threshold: number;
+            scope?: "session";
+        }) => LoopDetectionMiddleware;
+        auditLog: (options: {
+            dir: string;
+            includeInput?: boolean;
+            includeOutput?: boolean;
+            flushIntervalMs?: number;
+            flushSize?: number;
+        }) => AuditLogMiddleware;
+        budgetGuard: () => Middleware;
+    };
+    private preDispatchChecks;
+    private buildDispatchContext;
+    private executeStep;
+    private runAgentSession;
+    private finalizeDispatch;
+    private emitCostEvents;
+    private emitSessionComplete;
+    private emitSessionFail;
+    private validateInput;
+    private evictExpiredIdempotencyEntries;
+    private computeIdempotencyKey;
+    private getFirstStep;
+    private resolveStepAgent;
+    private resolveRepo;
+    private buildMiddlewareContext;
+    private computeBudgetRemainingPct;
+    private persistRun;
+    private recoverOrphanedRuns;
+}
+
+/**
+ * Global data directory for runtime artifacts (journals, runs).
+ * Located at ~/.neo, similar to how Claude Code uses ~/.claude.
+ */
+declare function getDataDir(): string;
+declare function getJournalsDir(): string;
+declare function getRunsDir(): string;
+/**
+ * Derive a filesystem-safe slug from a repo config.
+ * Uses `name` if present, otherwise `basename(path)`.
+ */
+declare function toRepoSlug(repo: {
+    name?: string | undefined;
+    path: string;
+}): string;
+/**
+ * Runs directory for a specific repo: ~/.neo/runs/<slug>/
+ */
+declare function getRepoRunsDir(repoSlug: string): string;
+/**
+ * Path to the dispatch request file for a detached run.
+ */
+declare function getRunDispatchPath(repoSlug: string, runId: string): string;
+/**
+ * Path to the log file for a detached run.
+ */
+declare function getRunLogPath(repoSlug: string, runId: string): string;
+/**
+ * Directory for all supervisor instances: ~/.neo/supervisors/
+ */
+declare function getSupervisorsDir(): string;
+/**
+ * Directory for a specific supervisor instance: ~/.neo/supervisors/<name>/
+ */
+declare function getSupervisorDir(name: string): string;
+/**
+ * Path to a supervisor state file: ~/.neo/supervisors/<name>/state.json
+ */
+declare function getSupervisorStatePath(name: string): string;
+declare function getSupervisorMemoryPath(name: string): string;
+declare function getSupervisorActivityPath(name: string): string;
+declare function getSupervisorInboxPath(name: string): string;
+declare function getSupervisorEventsPath(name: string): string;
+declare function getSupervisorLockPath(name: string): string;
+
+interface ParsedOutput {
+    rawOutput: string;
+    output?: unknown;
+    parseError?: string;
+}
+/**
+ * Parse agent output, optionally validating against a Zod schema.
+ *
+ * - If no schema: returns rawOutput only
+ * - If schema provided: extracts JSON from output, validates with schema
+ * - On failure: returns rawOutput + parseError (caller decides whether to retry)
+ */
+declare function parseOutput(raw: string, schema?: ZodType): ParsedOutput;
+
+interface SessionOptions {
+    agent: ResolvedAgent;
+    prompt: string;
+    repoPath?: string;
+    worktreePath?: string;
+    sandboxConfig: SandboxConfig;
+    hooks?: Record<string, unknown>;
+    mcpServers?: McpServerConfig[];
+    initTimeoutMs: number;
+    maxDurationMs: number;
+    resumeSessionId?: string | undefined;
+    onEvent?: ((event: SessionEvent) => void) | undefined;
+}
+interface SessionResult {
+    sessionId: string;
+    output: string;
+    costUsd: number;
+    durationMs: number;
+    turnCount: number;
+}
+type SessionEvent = {
+    type: "session:start";
+    sessionId: string;
+} | {
+    type: "session:complete";
+    sessionId: string;
+    result: SessionResult;
+} | {
+    type: "session:fail";
+    sessionId: string;
+    error: string;
+};
+declare function runSession(options: SessionOptions): Promise<SessionResult>;
+declare class SessionError extends Error {
+    readonly errorType: string;
+    readonly sessionId: string;
+    constructor(message: string, errorType: string, sessionId: string);
+}
+
+interface RecoveryOptions extends SessionOptions {
+    maxRetries: number;
+    backoffBaseMs: number;
+    nonRetryable?: string[];
+    onAttempt?: (attempt: number, strategy: string) => void;
+}
+/**
+ * Run a session with 3-level recovery escalation (ADR-020).
+ *
+ * Level 1 (attempt 1): Normal execution — new session
+ * Level 2 (attempt 2): Resume session — pass resumeSessionId from level 1
+ * Level 3 (attempt 3): Fresh session — abandon previous, start clean
+ *
+ * Non-retryable errors skip to immediate failure.
+ * Backoff: backoffBaseMs * attempt between levels.
+ */
+declare function runWithRecovery(options: RecoveryOptions): Promise<SessionResult>;
+
+declare const supervisorDaemonStateSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    tmuxSession: z.ZodString;
+    sessionId: z.ZodString;
+    port: z.ZodNumber;
+    cwd: z.ZodString;
+    startedAt: z.ZodString;
+    lastHeartbeat: z.ZodOptional<z.ZodString>;
+    heartbeatCount: z.ZodDefault<z.ZodNumber>;
+    totalCostUsd: z.ZodDefault<z.ZodNumber>;
+    todayCostUsd: z.ZodDefault<z.ZodNumber>;
+    costResetDate: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<{
+        running: "running";
+        draining: "draining";
+        stopped: "stopped";
+    }>>;
+}, z.core.$strip>;
+type SupervisorDaemonState = z.infer<typeof supervisorDaemonStateSchema>;
+declare const webhookIncomingEventSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    event: z.ZodOptional<z.ZodString>;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    receivedAt: z.ZodString;
+    processedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type WebhookIncomingEvent = z.infer<typeof webhookIncomingEventSchema>;
+declare const inboxMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    from: z.ZodEnum<{
+        tui: "tui";
+        api: "api";
+        external: "external";
+    }>;
+    text: z.ZodString;
+    timestamp: z.ZodString;
+    processedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type InboxMessage = z.infer<typeof inboxMessageSchema>;
+declare const activityEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        error: "error";
+        message: "message";
+        decision: "decision";
+        event: "event";
+        heartbeat: "heartbeat";
+        action: "action";
+        thinking: "thinking";
+        plan: "plan";
+        dispatch: "dispatch";
+        tool_use: "tool_use";
+    }>;
+    summary: z.ZodString;
+    detail: z.ZodOptional<z.ZodUnknown>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+type ActivityEntry = z.infer<typeof activityEntrySchema>;
+type QueuedEvent = {
+    kind: "webhook";
+    data: WebhookIncomingEvent;
+} | {
+    kind: "message";
+    data: InboxMessage;
+} | {
+    kind: "run_complete";
+    runId: string;
+    timestamp: string;
+};
+
+declare class ActivityLog {
+    private readonly filePath;
+    private readonly dir;
+    constructor(dir: string);
+    /**
+     * Append a structured entry to the activity log.
+     * Rotates the file if it exceeds MAX_SIZE_BYTES.
+     */
+    append(entry: ActivityEntry): Promise<void>;
+    /**
+     * Create and append a new entry with auto-generated id and timestamp.
+     */
+    log(type: ActivityEntry["type"], summary: string, detail?: unknown): Promise<void>;
+    /**
+     * Read the last N entries from the activity log.
+     */
+    tail(n: number): Promise<ActivityEntry[]>;
+    private checkRotation;
+}
+
+interface SupervisorDaemonOptions {
+    name: string;
+    config: GlobalConfig;
+}
+/**
+ * Orchestrates all supervisor components: webhook server, event queue,
+ * heartbeat loop, memory, and activity logging.
+ */
+declare class SupervisorDaemon {
+    private readonly name;
+    private readonly config;
+    private readonly dir;
+    private webhookServer;
+    private eventQueue;
+    private heartbeatLoop;
+    private activityLog;
+    private sessionId;
+    constructor(options: SupervisorDaemonOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private getHealthInfo;
+    private readState;
+    private writeState;
+    private readLockPid;
+    private isProcessAlive;
+}
+
+interface EventQueueOptions {
+    maxEventsPerSec: number;
+}
+/**
+ * In-memory event queue with deduplication, rate limiting, and file watching.
+ *
+ * Accumulates events from 3 sources:
+ * - Webhooks (pushed directly by WebhookServer)
+ * - Inbox messages (watched from inbox.jsonl)
+ * - Run completions (watched from runs directory)
+ *
+ * The daemon drains this queue at each heartbeat.
+ */
+declare class EventQueue {
+    private readonly queue;
+    private readonly seenIds;
+    private readonly maxSeenIds;
+    private readonly maxEventsPerSec;
+    private eventCountThisSecond;
+    private currentSecond;
+    private watchers;
+    private fileOffsets;
+    /** Resolve function to wake up the heartbeat loop when an event arrives */
+    private wakeUp;
+    constructor(options: EventQueueOptions);
+    /**
+     * Push an event into the queue. Applies dedup and rate limiting.
+     */
+    push(event: QueuedEvent): boolean;
+    /**
+     * Drain all queued events and return them. Clears the queue.
+     */
+    drain(): QueuedEvent[];
+    size(): number;
+    /**
+     * Start watching inbox.jsonl and events.jsonl for new entries.
+     * New lines are parsed and pushed into the queue.
+     */
+    startWatching(inboxPath: string, eventsPath: string): void;
+    stopWatching(): void;
+    /**
+     * Replay unprocessed events from disk on startup.
+     */
+    replayUnprocessed(inboxPath: string, eventsPath: string): Promise<void>;
+    /**
+     * Returns a promise that resolves when a new event arrives or timeout is reached.
+     */
+    waitForEvent(timeoutMs: number): Promise<void>;
+    /**
+     * Interrupt any pending waitForEvent — used during shutdown.
+     */
+    interrupt(): void;
+    private getEventId;
+    private watchJsonlFile;
+    private readNewLines;
+    private replayFile;
+    /**
+     * Mark events as processed by rewriting the source files.
+     */
+    markProcessed(inboxPath: string, eventsPath: string, events: QueuedEvent[]): Promise<void>;
+    private markInFile;
+}
+
+interface HeartbeatLoopOptions {
+    config: GlobalConfig;
+    supervisorDir: string;
+    statePath: string;
+    sessionId: string;
+    eventQueue: EventQueue;
+    activityLog: ActivityLog;
+}
+/**
+ * The core autonomous loop. At each iteration:
+ * 1. Drain events from the queue
+ * 2. Build a prompt with context + memory + events
+ * 3. Call sdk.query() for Claude to reason and act
+ * 4. Extract and save updated memory
+ * 5. Log activity
+ * 6. Wait for the next event or idle timeout
+ */
+declare class HeartbeatLoop {
+    private stopping;
+    private consecutiveFailures;
+    private activeAbort;
+    private readonly config;
+    private readonly supervisorDir;
+    private readonly statePath;
+    private sessionId;
+    private readonly eventQueue;
+    private readonly activityLog;
+    private customInstructions;
+    constructor(options: HeartbeatLoopOptions);
+    start(): Promise<void>;
+    stop(): void;
+    private runHeartbeat;
+    private readState;
+    private updateState;
+    /**
+     * Load custom instructions from SUPERVISOR.md.
+     * Resolution order:
+     * 1. Explicit path via `supervisor.instructions` in config
+     * 2. Default: ~/.neo/SUPERVISOR.md
+     */
+    private loadInstructions;
+    /** Route a single SDK stream message to the appropriate log handler. */
+    private logStreamMessage;
+    /** Log thinking and plan blocks from assistant content. */
+    private logContentBlocks;
+    /** Log tool use events — distinguish MCP tools from built-in tools. */
+    private logToolUse;
+    /** Detect agent dispatches from bash tool results. */
+    private logToolResult;
+    private sleep;
+}
+
+/**
+ * Load the supervisor memory from disk.
+ * Returns empty string if no memory file exists yet.
+ */
+declare function loadMemory(dir: string): Promise<string>;
+/**
+ * Save the supervisor memory to disk (full overwrite).
+ */
+declare function saveMemory(dir: string, content: string): Promise<void>;
+/**
+ * Extract memory content from Claude's response using <memory>...</memory> tags.
+ * Handles both JSON and markdown content inside the tags.
+ * Returns null if no memory block is found.
+ */
+declare function extractMemoryFromResponse(response: string): string | null;
+/**
+ * Check if memory content exceeds the recommended size limit.
+ */
+declare function checkMemorySize(content: string): {
+    ok: boolean;
+    sizeKB: number;
+};
+
+interface HeartbeatPromptOptions {
+    repos: RepoConfig[];
+    memory: string;
+    memorySizeKB: number;
+    events: QueuedEvent[];
+    budgetStatus: {
+        todayUsd: number;
+        capUsd: number;
+        remainingPct: number;
+    };
+    activeRuns: string[];
+    heartbeatCount: number;
+    mcpServerNames: string[];
+    customInstructions?: string | undefined;
+}
+/**
+ * Build the prompt sent to Claude at each heartbeat.
+ *
+ * Includes: role definition, current memory, pending events,
+ * budget status, active runs, and available integrations.
+ */
+declare function buildHeartbeatPrompt(opts: HeartbeatPromptOptions): string;
+
+interface WebhookServerOptions {
+    port: number;
+    secret?: string | undefined;
+    eventsPath: string;
+    onEvent: (event: WebhookIncomingEvent) => void;
+    getHealth: () => Record<string, unknown>;
+}
+/**
+ * Minimal HTTP server for receiving incoming webhooks.
+ *
+ * Routes:
+ *   POST /webhook — receive any JSON payload, persist to disk, push to queue
+ *   GET  /health  — liveness check with daemon status
+ *
+ * Uses raw http.createServer — zero external dependencies.
+ */
+declare class WebhookServer {
+    private server;
+    private readonly port;
+    private readonly secret;
+    private readonly eventsPath;
+    private readonly onEvent;
+    private readonly getHealth;
+    constructor(options: WebhookServerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+    private handleWebhook;
+    private readBody;
+    private sendJson;
+}
+
+declare const workflowStepDefSchema: z.ZodObject<{
+    type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"step">>>;
+    agent: z.ZodString;
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    prompt: z.ZodOptional<z.ZodString>;
+    sandbox: z.ZodOptional<z.ZodEnum<{
+        readonly: "readonly";
+        writable: "writable";
+    }>>;
+    maxTurns: z.ZodOptional<z.ZodNumber>;
+    mcpServers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    recovery: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        nonRetryable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    condition: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const workflowGateDefSchema: z.ZodObject<{
+    type: z.ZodLiteral<"gate">;
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodString;
+    timeout: z.ZodOptional<z.ZodString>;
+    autoApprove: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare function loadWorkflow(filePath: string): Promise<WorkflowDefinition>;
+
+/**
+ * Registry for workflow definitions.
+ * Loads built-in workflows from a directory and optional custom workflows.
+ * Custom workflows with the same name override built-in ones.
+ */
+declare class WorkflowRegistry {
+    private readonly builtInDir;
+    private readonly customDir;
+    private readonly workflows;
+    constructor(builtInDir: string, customDir?: string);
+    load(): Promise<void>;
+    get(name: string): WorkflowDefinition | undefined;
+    list(): WorkflowDefinition[];
+    has(name: string): boolean;
+    private loadFromDir;
+}
+
+declare const VERSION = "0.1.0";
+
+export { type ActiveSession, type ActivityEntry, ActivityLog, type AgentConfig, type AgentDefinition, type AgentMessageEvent, type AgentModel, AgentRegistry, type AgentTool, type AgentToolEntry, type AgentToolUseEvent, type AuditLogMiddleware, type BudgetAlertEvent, type CostEntry, CostJournal, type CostUpdateEvent, type DispatchInput, EventJournal, EventQueue, type GateWaitingEvent, type GlobalConfig, HeartbeatLoop, type HeartbeatLoopOptions, type HeartbeatPromptOptions, type HookEvent, type InboxMessage, type LoopDetectionMiddleware, type McpServerConfig, type Middleware, type MiddlewareChain, type MiddlewareContext, type MiddlewareContextMap, type MiddlewareEvent, type MiddlewareHandler, type MiddlewareResult, type NeoConfig, type NeoEvent, NeoEventEmitter, Orchestrator, type OrchestratorOptions, type OrchestratorShutdownEvent, type OrchestratorStatus, type ParsedOutput, type PersistedRun, type Priority, type QueueDequeueEvent, type QueueEnqueueEvent, type QueuedEvent, type RecoveryOptions, type RepoConfig, type RepoConfigInput, type ResolvedAgent, type SDKHooks, type SandboxConfig, Semaphore, type SemaphoreCallbacks, type SemaphoreConfig, type SessionCompleteEvent, SessionError, type SessionEvent, type SessionFailEvent, type SessionOptions, type SessionResult, type SessionStartEvent, type StepResult, SupervisorDaemon, type SupervisorDaemonOptions, type SupervisorDaemonState, type SupervisorDaemonState as SupervisorState, type TaskResult, VERSION, WebhookDispatcher, type WebhookIncomingEvent, WebhookServer, type WorkflowContext, type WorkflowDefinition, type WorkflowGateDef, WorkflowRegistry, type WorkflowStepCompleteEvent, type WorkflowStepDef, type WorkflowStepStartEvent, type WorktreeInfo, activityEntrySchema, addRepoToGlobalConfig, agentConfigSchema, agentModelSchema, agentSandboxSchema, agentToolEntrySchema, agentToolSchema, auditLog, budgetGuard, buildHeartbeatPrompt, buildMiddlewareChain, buildSDKHooks, buildSandboxConfig, checkMemorySize, cleanupOrphanedWorktrees, createBranch, createWorktree, deleteBranch, extractMemoryFromResponse, fetchRemote, getBranchName, getCurrentBranch, getDataDir, getJournalsDir, getRepoRunsDir, getRunDispatchPath, getRunLogPath, getRunsDir, getSupervisorActivityPath, getSupervisorDir, getSupervisorEventsPath, getSupervisorInboxPath, getSupervisorLockPath, getSupervisorMemoryPath, getSupervisorStatePath, getSupervisorsDir, globalConfigSchema, inboxMessageSchema, listReposFromGlobalConfig, listWorktrees, loadAgentFile, loadConfig, loadGlobalConfig, loadMemory, loadWorkflow, loopDetection, matchesFilter, mcpServerConfigSchema, neoConfigSchema, parseOutput, pushBranch, removeRepoFromGlobalConfig, removeWorktree, repoConfigSchema, resolveAgent, runSession, runWithRecovery, saveMemory, supervisorDaemonStateSchema, supervisorDaemonStateSchema as supervisorStateSchema, toRepoSlug, webhookIncomingEventSchema, withGitLock, workflowGateDefSchema, workflowStepDefSchema };