@neotx/core 0.1.0-alpha.15 → 0.1.0-alpha.19

package/dist/index.d.ts

@@ -244,11 +244,94 @@ declare const neoConfigSchema: z.ZodObject<{
         ttlMs: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+declare const repoOverrideConfigSchema: z.ZodObject<{
+    concurrency: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        maxSessions: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        maxPerRepo: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        queueMax: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    budget: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        dailyCapUsd: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        alertThresholdPct: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    recovery: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        backoffBaseMs: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    sessions: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        initTimeoutMs: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        maxDurationMs: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        dir: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    }, 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>;
+
+/**
+ * Configuration store that loads and merges config files.
+ *
+ * Config precedence (highest to lowest):
+ * 1. Repo config: <repoPath>/.neo/config.yml
+ * 2. Global config: ~/.neo/config.yml
+ * 3. Default values (hardcoded)
+ *
+ * @example
+ * const store = new ConfigStore('/path/to/repo');
+ * await store.load();
+ * const dailyCap = store.get<number>('budget.dailyCapUsd');
+ */
+declare class ConfigStore {
+    private repoPath;
+    private config;
+    constructor(repoPath?: string);
+    /**
+     * Loads and merges config files from all locations.
+     * Must be called before get() or getAll().
+     */
+    load(): Promise<void>;
+    /**
+     * Gets a config value using dot notation.
+     *
+     * @param key - Dot-separated path (e.g., "budget.dailyCapUsd")
+     * @returns The value at the path
+     * @throws Error if load() has not been called
+     *
+     * @example
+     * store.get<number>('budget.dailyCapUsd') // 500
+     * store.get<string>('sessions.dir') // '/tmp/neo-sessions'
+     */
+    get<T>(key: string): T;
+    /**
+     * Returns the full merged configuration.
+     *
+     * @throws Error if load() has not been called
+     */
+    getAll(): NeoConfig;
+    /**
+     * Returns the repository path, if one was provided.
+     * Used by ConfigWatcher to determine which files to watch.
+     */
+    getRepoPath(): string | undefined;
+    /**
+     * Loads global config from ~/.neo/config.yml
+     */
+    private loadGlobalConfig;
+    /**
+     * Loads repo-level overrides from <repoPath>/.neo/config.yml
+     */
+    private loadRepoConfig;
+    /**
+     * Loads and parses a YAML config file.
+     *
+     * @param filePath - Absolute path to the config file
+     * @returns Parsed YAML content or null if file doesn't exist
+     */
+    private loadFile;
+}
+
 /**
  * Load NeoConfig from a single file (legacy compatibility).
  */
@@ -285,35 +368,10 @@ interface ResolvedAgent {
     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;
+    agent: string;
     repo: string;
     prompt: string;
     branch?: string | undefined;
@@ -342,7 +400,7 @@ interface StepResult {
 }
 type Priority = "critical" | "high" | "medium" | "low";
 interface DispatchInput {
-    workflow: string;
+    agent: string;
     repo: string;
     prompt: string;
     runId?: string | undefined;
@@ -361,7 +419,7 @@ interface DispatchInput {
 }
 interface TaskResult {
     runId: string;
-    workflow: string;
+    agent: string;
     repo: string;
     status: "success" | "failure" | "timeout" | "cancelled";
     steps: Record<string, StepResult>;
@@ -377,7 +435,6 @@ interface TaskResult {
 interface ActiveSession {
     sessionId: string;
     runId: string;
-    workflow: string;
     step: string;
     agent: string;
     repo: string;
@@ -394,9 +451,9 @@ interface OrchestratorStatus {
     budgetRemainingPct: number;
     uptime: number;
 }
-interface WorkflowContext {
+interface RunContext {
     runId: string;
-    workflow: string;
+    agent: string;
     repo: string;
     prompt: string;
     steps: Record<string, StepResult>;
@@ -406,7 +463,6 @@ interface SessionStartEvent {
     type: "session:start";
     sessionId: string;
     runId: string;
-    workflow: string;
     step: string;
     agent: string;
     repo: string;
@@ -451,16 +507,16 @@ interface AgentMessageEvent {
     text: string;
     timestamp: string;
 }
-interface WorkflowStepStartEvent {
-    type: "workflow:step_start";
+interface StepStartEvent {
+    type: "step:start";
     runId: string;
     step: string;
     agent: string;
     metadata?: Record<string, unknown> | undefined;
     timestamp: string;
 }
-interface WorkflowStepCompleteEvent {
-    type: "workflow:step_complete";
+interface StepCompleteEvent {
+    type: "step:complete";
     runId: string;
     step: string;
     status: "success" | "failure" | "skipped";
@@ -474,7 +530,7 @@ interface GateWaitingEvent {
     runId: string;
     gate: string;
     description: string;
-    context: WorkflowContext;
+    context: RunContext;
     approve: () => void;
     reject: (reason: string) => void;
     metadata?: Record<string, unknown> | undefined;
@@ -513,7 +569,7 @@ interface OrchestratorShutdownEvent {
     type: "orchestrator:shutdown";
     timestamp: string;
 }
-type NeoEvent = SessionStartEvent | SessionCompleteEvent | SessionFailEvent | AgentToolUseEvent | AgentMessageEvent | WorkflowStepStartEvent | WorkflowStepCompleteEvent | GateWaitingEvent | CostUpdateEvent | BudgetAlertEvent | QueueEnqueueEvent | QueueDequeueEvent | OrchestratorShutdownEvent;
+type NeoEvent = SessionStartEvent | SessionCompleteEvent | SessionFailEvent | AgentToolUseEvent | AgentMessageEvent | StepStartEvent | StepCompleteEvent | GateWaitingEvent | CostUpdateEvent | BudgetAlertEvent | QueueEnqueueEvent | QueueDequeueEvent | OrchestratorShutdownEvent;
 type HookEvent = "PreToolUse" | "PostToolUse" | "Notification";
 interface Middleware {
     name: string;
@@ -538,7 +594,6 @@ interface MiddlewareContextMap {
 }
 interface MiddlewareContext {
     runId: string;
-    workflow: string;
     step: string;
     agent: string;
     repo: string;
@@ -557,7 +612,6 @@ type MiddlewareResult = {
 interface CostEntry {
     timestamp: string;
     runId: string;
-    workflow: string;
     step: string;
     sessionId: string;
     agent: string;
@@ -833,8 +887,6 @@ declare function loopDetection(options: {
 interface OrchestratorOptions {
     middleware?: Middleware[] | undefined;
     journalDir?: string | undefined;
-    builtInWorkflowDir?: string | undefined;
-    customWorkflowDir?: string | undefined;
     /** Skip orphan recovery on start — workers should set this to true to avoid false orphan detection on concurrent launches. */
     skipOrphanRecovery?: boolean | undefined;
 }
@@ -842,7 +894,6 @@ 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;
@@ -850,8 +901,6 @@ declare class Orchestrator extends NeoEventEmitter {
     private readonly repoIndex;
     private readonly runStore;
     private readonly journalDir;
-    private readonly builtInWorkflowDir;
-    private readonly customWorkflowDir;
     private costJournal;
     private eventJournal;
     private webhookDispatcher;
@@ -862,7 +911,6 @@ declare class Orchestrator extends NeoEventEmitter {
     private _drainResolve;
     private readonly skipOrphanRecovery;
     constructor(config: NeoConfig, options?: OrchestratorOptions);
-    registerWorkflow(definition: WorkflowDefinition): void;
     registerAgent(agent: ResolvedAgent): void;
     dispatch(input: DispatchInput): Promise<TaskResult>;
     pause(): void;
@@ -906,8 +954,6 @@ declare class Orchestrator extends NeoEventEmitter {
     private validateInput;
     private evictExpiredIdempotencyEntries;
     private computeIdempotencyKey;
-    private getFirstStep;
-    private resolveStepAgent;
     private resolveRepo;
     private computeBudgetRemainingPct;
     private resolveMcpServers;
@@ -960,6 +1006,7 @@ declare function getSupervisorActivityPath(name: string): string;
 declare function getSupervisorInboxPath(name: string): string;
 declare function getSupervisorEventsPath(name: string): string;
 declare function getSupervisorLockPath(name: string): string;
+declare function getSupervisorDecisionsPath(name: string): string;
 
 interface ParsedOutput {
     rawOutput: string;
@@ -1036,11 +1083,15 @@ interface RecoveryOptions extends SessionOptions {
  */
 declare function runWithRecovery(options: RecoveryOptions): Promise<SessionResult>;
 
+declare function loadRepoInstructions(repoPath: string): Promise<string | undefined>;
+declare function buildGitStrategyInstructions(strategy: GitStrategy, agent: ResolvedAgent, branch: string, baseBranch: string, remote: string, metadata?: Record<string, unknown>): string | null;
+declare function buildReportingInstructions(_runId: string): string;
+declare function buildFullPrompt(agentPrompt: string | undefined, repoInstructions: string | undefined, gitInstructions: string | null, taskPrompt: string, memoryContext?: string | undefined, cwdInstructions?: string | undefined, reportingInstructions?: string | undefined): string;
+
 interface SessionExecutionInput {
     runId: string;
     sessionId: string;
     agent: ResolvedAgent;
-    stepDef: WorkflowStepDef;
     repoConfig: RepoConfig;
     repoPath: string;
     prompt: string;
@@ -1065,10 +1116,6 @@ interface SessionExecutionDeps {
 interface SessionExecutionResult extends StepResult {
     parsed: ParsedOutput;
 }
-declare function loadRepoInstructions(repoPath: string): Promise<string | undefined>;
-declare function buildGitStrategyInstructions(strategy: GitStrategy, agent: ResolvedAgent, branch: string, baseBranch: string, remote: string, metadata?: Record<string, unknown>): string | null;
-declare function buildReportingInstructions(_runId: string): string;
-declare function buildFullPrompt(agentPrompt: string | undefined, repoInstructions: string | undefined, gitInstructions: string | null, taskPrompt: string, memoryContext?: string | undefined, cwdInstructions?: string | undefined, reportingInstructions?: string | undefined): string;
 /**
  * Encapsulates session execution logic: prompt building, SDK calls, and response processing.
  * Extracted from Orchestrator for better testability and separation of concerns.
@@ -1108,12 +1155,81 @@ declare class SessionExecutor {
  */
 declare function isProcessAlive(pid: number): boolean;
 
+declare const decisionOptionSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const decisionSchema: z.ZodObject<{
+    id: z.ZodString;
+    question: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    type: z.ZodDefault<z.ZodString>;
+    source: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    defaultAnswer: z.ZodOptional<z.ZodString>;
+    answeredAt: z.ZodOptional<z.ZodString>;
+    answer: z.ZodOptional<z.ZodString>;
+    expiredAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type DecisionOption = z.infer<typeof decisionOptionSchema>;
+type Decision = z.infer<typeof decisionSchema>;
+type DecisionInput = Omit<Decision, "id" | "createdAt" | "answeredAt" | "answer" | "expiredAt">;
+/**
+ * JSONL-backed store for decisions.
+ * Append-only with in-place updates for answers and expiration.
+ */
+declare class DecisionStore {
+    private readonly filePath;
+    private readonly dir;
+    private readonly dirCache;
+    constructor(filePath: string);
+    /**
+     * Create a new decision and persist it.
+     * @returns The generated decision ID
+     */
+    create(input: DecisionInput): Promise<string>;
+    /**
+     * Answer a decision by ID.
+     * Reads all entries, updates the matching one, and rewrites the file.
+     */
+    answer(id: string, answer: string): Promise<void>;
+    /**
+     * Get all pending decisions (unanswered, not expired, not timed out).
+     */
+    pending(): Promise<Decision[]>;
+    /**
+     * Get answered decisions, optionally filtered by timestamp.
+     * @param since - ISO timestamp to filter decisions answered after this time
+     */
+    answered(since?: string): Promise<Decision[]>;
+    /**
+     * Get a specific decision by ID.
+     */
+    get(id: string): Promise<Decision | null>;
+    /**
+     * Auto-answer expired decisions with their defaultAnswer.
+     * Decisions without defaultAnswer are marked as expired (expiredAt).
+     * @returns The decisions that were auto-answered or marked expired
+     */
+    expire(): Promise<Decision[]>;
+    private readAll;
+    private writeAll;
+}
+
 declare const supervisorDaemonStateSchema: z.ZodObject<{
     pid: z.ZodNumber;
     sessionId: z.ZodString;
+    startedAt: 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>;
@@ -1169,6 +1285,7 @@ declare const activityEntrySchema: z.ZodObject<{
         event: "event";
         heartbeat: "heartbeat";
         action: "action";
+        warning: "warning";
         thinking: "thinking";
         plan: "plan";
         dispatch: "dispatch";
@@ -1206,6 +1323,39 @@ declare const internalEventKindSchema: z.ZodEnum<{
     active_run_check: "active_run_check";
 }>;
 type InternalEventKind = z.infer<typeof internalEventKindSchema>;
+declare const supervisorStatusSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    sessionId: z.ZodString;
+    startedAt: z.ZodString;
+    heartbeatCount: z.ZodNumber;
+    totalCostUsd: z.ZodNumber;
+    todayCostUsd: z.ZodNumber;
+    status: z.ZodEnum<{
+        running: "running";
+        idle: "idle";
+        stopping: "stopping";
+    }>;
+    lastHeartbeat: z.ZodString;
+    activeRunCount: z.ZodNumber;
+    recentActivitySummary: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type SupervisorStatus = z.infer<typeof supervisorStatusSchema>;
+declare const activityQueryOptionsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        message: "message";
+        decision: "decision";
+        event: "event";
+        action: "action";
+        plan: "plan";
+        dispatch: "dispatch";
+    }>>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ActivityQueryOptions = z.infer<typeof activityQueryOptionsSchema>;
 type QueuedEvent = {
     kind: "webhook";
     data: WebhookIncomingEvent;
@@ -1261,6 +1411,7 @@ declare class SupervisorDaemon {
     private eventQueue;
     private heartbeatLoop;
     private activityLog;
+    private decisionStore;
     private sessionId;
     constructor(options: SupervisorDaemonOptions);
     start(): Promise<void>;
@@ -1269,6 +1420,11 @@ declare class SupervisorDaemon {
     private readState;
     private writeState;
     private readLockPid;
+    /**
+     * Handle decision:answer webhook events.
+     * Extracts decisionId and answer from the payload and records the answer.
+     */
+    private handleDecisionAnswer;
 }
 
 interface EventQueueOptions {
@@ -1354,6 +1510,55 @@ declare class EventQueue {
     private markInFile;
 }
 
+declare const supervisorWebhookEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"supervisor_started">;
+    supervisorId: z.ZodString;
+    startedAt: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"heartbeat">;
+    supervisorId: z.ZodString;
+    heartbeatNumber: z.ZodNumber;
+    timestamp: z.ZodString;
+    runsActive: z.ZodNumber;
+    budget: z.ZodObject<{
+        todayUsd: z.ZodNumber;
+        limitUsd: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"run_dispatched">;
+    supervisorId: z.ZodString;
+    runId: z.ZodString;
+    agent: z.ZodString;
+    repo: z.ZodString;
+    branch: z.ZodString;
+    prompt: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"run_completed">;
+    supervisorId: z.ZodString;
+    runId: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    output: z.ZodOptional<z.ZodString>;
+    costUsd: z.ZodNumber;
+    durationMs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"supervisor_stopped">;
+    supervisorId: z.ZodString;
+    stoppedAt: z.ZodString;
+    reason: z.ZodEnum<{
+        error: "error";
+        budget_exceeded: "budget_exceeded";
+        shutdown: "shutdown";
+        manual: "manual";
+    }>;
+}, z.core.$strip>], "type">;
+type SupervisorWebhookEvent = z.infer<typeof supervisorWebhookEventSchema>;
+
+/** Callback for emitting webhook events */
+type WebhookEventEmitter = (event: SupervisorWebhookEvent) => void | Promise<void>;
 interface HeartbeatLoopOptions {
     config: GlobalConfig;
     supervisorDir: string;
@@ -1366,6 +1571,12 @@ interface HeartbeatLoopOptions {
     /** Path to bundled default SUPERVISOR.md (e.g. from @neotx/agents) */
     defaultInstructionsPath?: string | undefined;
     memoryDbPath?: string | undefined;
+    /** Optional callback to emit webhook events at lifecycle points */
+    onWebhookEvent?: WebhookEventEmitter | undefined;
+    /** Repository path for config watching (enables hot-reload) */
+    repoPath?: string | undefined;
+    /** Debounce time in ms for config file changes (default: 500) */
+    configWatcherDebounceMs?: number | undefined;
 }
 /**
  * The core autonomous loop. At each iteration:
@@ -1382,7 +1593,7 @@ declare class HeartbeatLoop {
     private stopping;
     private consecutiveFailures;
     private activeAbort;
-    private readonly config;
+    private config;
     private readonly supervisorDir;
     private readonly statePath;
     private sessionId;
@@ -1393,12 +1604,30 @@ declare class HeartbeatLoop {
     private readonly defaultInstructionsPath;
     private memoryStore;
     private readonly memoryDbPath;
+    private readonly onWebhookEvent;
+    private decisionStore;
+    /** ConfigWatcher for hot-reload support */
+    private configWatcher;
+    private configStore;
+    private readonly repoPath;
+    private readonly configWatcherDebounceMs;
     constructor(options: HeartbeatLoopOptions);
     /** Path to the inbox/events directory for markProcessed() calls */
     get eventsPath(): string;
     private getMemoryStore;
+    private getDecisionStore;
     start(): Promise<void>;
     stop(): void;
+    /**
+     * Initialize and start the ConfigWatcher for hot-reload support.
+     * Subscribes to config file changes and logs reload events.
+     */
+    private initConfigWatcher;
+    /**
+     * Handle config file changes. Propagates reloaded config to the running
+     * loop and triggers an immediate heartbeat.
+     */
+    private handleConfigChange;
     private runHeartbeat;
     /**
      * Check if supervisor daily budget is exceeded.
@@ -1422,11 +1651,21 @@ declare class HeartbeatLoop {
     private buildHeartbeatModePrompt;
     /**
      * Call the Claude SDK and stream results.
+     *
+     * Uses Promise.race to enable non-blocking abort detection. The standard
+     * `for await (const message of stream)` pattern only checks the abort signal
+     * AFTER each yield — if the SDK hangs (no messages), the abort never executes.
+     * This implementation races each iterator.next() against an abort promise,
+     * allowing immediate response to shutdown/timeout signals.
      */
     private callSdk;
     private readState;
     private updateState;
-    /** Read persisted run files and return summaries of active (running/paused) runs. */
+    /**
+     * Read persisted run files and return summaries of active (running/paused) runs.
+     * Validates that "running" runs are actually alive by checking their PID.
+     * Stale runs (dead PID past grace period) are filtered out to prevent ghost runs.
+     */
     private getActiveRuns;
     /**
      * Load custom instructions from SUPERVISOR.md.
@@ -1445,6 +1684,31 @@ declare class HeartbeatLoop {
     /** Detect agent dispatches from bash tool results. */
     private logToolResult;
     private sleep;
+    /**
+     * Process decision:answer events from inbox messages.
+     * Expected format: "decision:answer <decisionId> <answer>"
+     */
+    private processDecisionAnswers;
+    /**
+     * Read persisted run data to extract actual status, cost, and duration.
+     * Returns null if the run file cannot be found or parsed.
+     */
+    private readPersistedRun;
+    /**
+     * Emit a webhook event if a callback is configured.
+     * Validates the event against its schema before emission.
+     */
+    private emitWebhookEvent;
+    /** Emit SupervisorStartedEvent */
+    private emitSupervisorStarted;
+    /** Emit SupervisorStoppedEvent */
+    private emitSupervisorStopped;
+    /** Emit HeartbeatEvent */
+    private emitHeartbeatCompleted;
+    /** Emit RunDispatchedEvent from tool result detection */
+    private emitRunDispatched;
+    /** Emit RunCompletedEvent when processing run_complete events */
+    private emitRunCompleted;
 }
 
 /**
@@ -1558,6 +1822,27 @@ declare class MemoryStore {
     close(): void;
 }
 
+/**
+ * Reads supervisor status from the daemon state file.
+ * Returns null if the supervisor is not running or state file doesn't exist.
+ */
+declare class StatusReader {
+    readonly dataDir: string;
+    private readonly statePath;
+    private readonly activityPath;
+    constructor(dataDir: string);
+    /**
+     * Read and parse supervisor status from disk.
+     * Returns null if the state file doesn't exist (supervisor not running).
+     */
+    getStatus(): Promise<SupervisorStatus | null>;
+    /**
+     * Query activity entries with optional filtering.
+     * Returns empty array if the activity file doesn't exist or is empty.
+     */
+    queryActivity(options?: ActivityQueryOptions): ActivityEntry[];
+}
+
 interface WebhookServerOptions {
     port: number;
     secret?: string | undefined;
@@ -1590,49 +1875,49 @@ declare class WebhookServer {
     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>;
+declare const webhookEntrySchema: z.ZodObject<{
+    url: z.ZodString;
+    events: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    secret: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    createdAt: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
-declare function loadWorkflow(filePath: string): Promise<WorkflowDefinition>;
-
+type WebhookEntry = z.infer<typeof webhookEntrySchema>;
+type WebhookEntryInput = z.input<typeof webhookEntrySchema>;
 /**
- * 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.
+ * Add a webhook endpoint to ~/.neo/webhooks.json.
+ * Deduplicates by URL.
  */
-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 function addWebhook(input: WebhookEntryInput): Promise<WebhookEntry>;
+/**
+ * Remove a webhook endpoint by URL.
+ * Returns true if removed, false if not found.
+ */
+declare function removeWebhook(url: string): Promise<boolean>;
+/**
+ * List all configured webhooks.
+ */
+declare function listWebhooks(): Promise<WebhookEntry[]>;
+interface WebhookTestPayload {
+    type: "test";
+    timestamp: string;
+    runId: string;
+    status: "test";
+    summary: string;
+}
+interface WebhookTestResult {
+    url: string;
+    success: boolean;
+    statusCode?: number;
+    error?: string;
+    durationMs: number;
 }
+/**
+ * Send a test payload to all configured webhooks.
+ * Returns results for each endpoint.
+ */
+declare function testWebhooks(): Promise<WebhookTestResult[]>;
 
 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, type Embedder, EventJournal, EventQueue, type GateWaitingEvent, type GitStrategy, type GlobalConfig, HeartbeatLoop, type HeartbeatLoopOptions, type HookEvent, type InboxMessage, LocalEmbedder, type LoopDetectionMiddleware, type McpServerConfig, type MemoryEntry, type MemoryQuery, type MemoryStats, MemoryStore, type MemoryType, type MemoryWriteInput, 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 SessionCloneInfo, type SessionCompleteEvent, SessionError, type SessionEvent, type SessionExecutionConfig, type SessionExecutionDeps, type SessionExecutionInput, type SessionExecutionResult, SessionExecutor, 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, activityEntrySchema, addRepoToGlobalConfig, agentConfigSchema, agentModelSchema, agentSandboxSchema, agentToolEntrySchema, agentToolSchema, appendLogBuffer, auditLog, budgetGuard, buildFullPrompt, buildGitStrategyInstructions, buildMiddlewareChain, buildReportingInstructions, buildSDKHooks, buildSandboxConfig, createBranch, createSessionClone, deleteBranch, fetchRemote, getBranchName, getCurrentBranch, getDataDir, getJournalsDir, getRepoRunsDir, getRunDispatchPath, getRunLogPath, getRunsDir, getSupervisorActivityPath, getSupervisorDir, getSupervisorEventsPath, getSupervisorInboxPath, getSupervisorLockPath, getSupervisorStatePath, getSupervisorsDir, globalConfigSchema, inboxMessageSchema, isProcessAlive, listReposFromGlobalConfig, listSessionClones, loadAgentFile, loadConfig, loadGlobalConfig, loadRepoInstructions, loadWorkflow, loopDetection, matchesFilter, mcpServerConfigSchema, neoConfigSchema, parseOutput, pushBranch, pushSessionBranch, removeRepoFromGlobalConfig, removeSessionClone, repoConfigSchema, resolveAgent, runSession, runWithRecovery, supervisorDaemonStateSchema, supervisorDaemonStateSchema as supervisorStateSchema, toRepoSlug, webhookIncomingEventSchema, workflowGateDefSchema, workflowStepDefSchema };
+export { type ActiveSession, type ActivityEntry, ActivityLog, type ActivityQueryOptions, type AgentConfig, type AgentDefinition, type AgentMessageEvent, type AgentModel, AgentRegistry, type AgentTool, type AgentToolEntry, type AgentToolUseEvent, type AuditLogMiddleware, type BudgetAlertEvent, ConfigStore, type CostEntry, CostJournal, type CostUpdateEvent, type Decision, type DecisionInput, type DecisionOption, DecisionStore, type DispatchInput, type Embedder, EventJournal, EventQueue, type GateWaitingEvent, type GitStrategy, type GlobalConfig, HeartbeatLoop, type HeartbeatLoopOptions, type HookEvent, type InboxMessage, LocalEmbedder, type LoopDetectionMiddleware, type McpServerConfig, type MemoryEntry, type MemoryQuery, type MemoryStats, MemoryStore, type MemoryType, type MemoryWriteInput, 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 RunContext, type SDKHooks, type SandboxConfig, Semaphore, type SemaphoreCallbacks, type SemaphoreConfig, type SessionCloneInfo, type SessionCompleteEvent, SessionError, type SessionEvent, type SessionExecutionConfig, type SessionExecutionDeps, type SessionExecutionInput, type SessionExecutionResult, SessionExecutor, type SessionFailEvent, type SessionOptions, type SessionResult, type SessionStartEvent, StatusReader, type StepCompleteEvent, type StepResult, type StepStartEvent, SupervisorDaemon, type SupervisorDaemonOptions, type SupervisorDaemonState, type SupervisorDaemonState as SupervisorState, type SupervisorStatus, type TaskResult, VERSION, WebhookDispatcher, type WebhookEntry, type WebhookEntryInput, type WebhookIncomingEvent, WebhookServer, type WebhookTestPayload, type WebhookTestResult, activityEntrySchema, addRepoToGlobalConfig, addWebhook, agentConfigSchema, agentModelSchema, agentSandboxSchema, agentToolEntrySchema, agentToolSchema, appendLogBuffer, auditLog, budgetGuard, buildFullPrompt, buildGitStrategyInstructions, buildMiddlewareChain, buildReportingInstructions, buildSDKHooks, buildSandboxConfig, createBranch, createSessionClone, decisionOptionSchema, decisionSchema, deleteBranch, fetchRemote, getBranchName, getCurrentBranch, getDataDir, getJournalsDir, getRepoRunsDir, getRunDispatchPath, getRunLogPath, getRunsDir, getSupervisorActivityPath, getSupervisorDecisionsPath, getSupervisorDir, getSupervisorEventsPath, getSupervisorInboxPath, getSupervisorLockPath, getSupervisorStatePath, getSupervisorsDir, globalConfigSchema, inboxMessageSchema, isProcessAlive, listReposFromGlobalConfig, listSessionClones, listWebhooks, loadAgentFile, loadConfig, loadGlobalConfig, loadRepoInstructions, loopDetection, matchesFilter, mcpServerConfigSchema, neoConfigSchema, parseOutput, pushBranch, pushSessionBranch, removeRepoFromGlobalConfig, removeSessionClone, removeWebhook, repoConfigSchema, repoOverrideConfigSchema, resolveAgent, runSession, runWithRecovery, supervisorDaemonStateSchema, supervisorDaemonStateSchema as supervisorStateSchema, supervisorStatusSchema, testWebhooks, toRepoSlug, webhookEntrySchema, webhookIncomingEventSchema };