@neotx/core 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/index.d.ts

@@ -86,14 +86,21 @@ declare const mcpServerConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     args: z.ZodOptional<z.ZodArray<z.ZodString>>;
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>], "type">;
+declare const gitStrategySchema: z.ZodDefault<z.ZodEnum<{
+    pr: "pr";
+    branch: "branch";
+}>>;
+type GitStrategy = z.infer<typeof gitStrategySchema>;
 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>;
+    gitStrategy: z.ZodDefault<z.ZodEnum<{
+        pr: "pr";
+        branch: "branch";
+    }>>;
 }, z.core.$strip>;
 declare const globalConfigSchema: z.ZodObject<{
     repos: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -102,8 +109,10 @@ declare const globalConfigSchema: z.ZodObject<{
         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>;
+        gitStrategy: z.ZodDefault<z.ZodEnum<{
+            pr: "pr";
+            branch: "branch";
+        }>>;
     }, z.core.$strip>>>;
     concurrency: z.ZodDefault<z.ZodObject<{
         maxSessions: z.ZodDefault<z.ZodNumber>;
@@ -121,6 +130,7 @@ declare const globalConfigSchema: z.ZodObject<{
     sessions: z.ZodDefault<z.ZodObject<{
         initTimeoutMs: z.ZodDefault<z.ZodNumber>;
         maxDurationMs: z.ZodDefault<z.ZodNumber>;
+        dir: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>;
     webhooks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         url: z.ZodString;
@@ -131,13 +141,20 @@ declare const globalConfigSchema: z.ZodObject<{
     supervisor: z.ZodDefault<z.ZodObject<{
         port: z.ZodDefault<z.ZodNumber>;
         secret: z.ZodOptional<z.ZodString>;
-        idleIntervalMs: z.ZodDefault<z.ZodNumber>;
-        idleSkipMax: z.ZodDefault<z.ZodNumber>;
         heartbeatTimeoutMs: z.ZodDefault<z.ZodNumber>;
         maxConsecutiveFailures: z.ZodDefault<z.ZodNumber>;
         maxEventsPerSec: z.ZodDefault<z.ZodNumber>;
         dailyCapUsd: z.ZodDefault<z.ZodNumber>;
+        consolidationIntervalMs: z.ZodDefault<z.ZodNumber>;
+        compactionIntervalMs: z.ZodDefault<z.ZodNumber>;
+        eventTimeoutMs: z.ZodDefault<z.ZodNumber>;
         instructions: z.ZodOptional<z.ZodString>;
+        idleSkipMax: z.ZodDefault<z.ZodNumber>;
+        activeWorkSkipMax: z.ZodDefault<z.ZodNumber>;
+        autoDecide: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    memory: z.ZodDefault<z.ZodObject<{
+        embeddings: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"http">;
@@ -166,8 +183,10 @@ declare const neoConfigSchema: z.ZodObject<{
         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>;
+        gitStrategy: z.ZodDefault<z.ZodEnum<{
+            pr: "pr";
+            branch: "branch";
+        }>>;
     }, z.core.$strip>>>;
     concurrency: z.ZodDefault<z.ZodObject<{
         maxSessions: z.ZodDefault<z.ZodNumber>;
@@ -185,6 +204,7 @@ declare const neoConfigSchema: z.ZodObject<{
     sessions: z.ZodDefault<z.ZodObject<{
         initTimeoutMs: z.ZodDefault<z.ZodNumber>;
         maxDurationMs: z.ZodDefault<z.ZodNumber>;
+        dir: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>;
     webhooks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         url: z.ZodString;
@@ -195,13 +215,20 @@ declare const neoConfigSchema: z.ZodObject<{
     supervisor: z.ZodDefault<z.ZodObject<{
         port: z.ZodDefault<z.ZodNumber>;
         secret: z.ZodOptional<z.ZodString>;
-        idleIntervalMs: z.ZodDefault<z.ZodNumber>;
-        idleSkipMax: z.ZodDefault<z.ZodNumber>;
         heartbeatTimeoutMs: z.ZodDefault<z.ZodNumber>;
         maxConsecutiveFailures: z.ZodDefault<z.ZodNumber>;
         maxEventsPerSec: z.ZodDefault<z.ZodNumber>;
         dailyCapUsd: z.ZodDefault<z.ZodNumber>;
+        consolidationIntervalMs: z.ZodDefault<z.ZodNumber>;
+        compactionIntervalMs: z.ZodDefault<z.ZodNumber>;
+        eventTimeoutMs: z.ZodDefault<z.ZodNumber>;
         instructions: z.ZodOptional<z.ZodString>;
+        idleSkipMax: z.ZodDefault<z.ZodNumber>;
+        activeWorkSkipMax: z.ZodDefault<z.ZodNumber>;
+        autoDecide: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    memory: z.ZodDefault<z.ZodObject<{
+        embeddings: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
     mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"http">;
@@ -223,11 +250,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).
  */
@@ -255,6 +365,7 @@ interface AgentDefinition {
     prompt: string;
     tools: string[];
     model: string;
+    mcpServers?: string[] | undefined;
 }
 interface ResolvedAgent {
     name: string;
@@ -263,39 +374,14 @@ 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;
-    worktreePath?: string | undefined;
+    sessionPath?: string | undefined;
     pid?: number | undefined;
     status: "running" | "paused" | "completed" | "failed";
     steps: Record<string, StepResult>;
@@ -308,6 +394,8 @@ interface StepResult {
     sessionId?: string | undefined;
     output?: unknown;
     rawOutput?: string | undefined;
+    prUrl?: string | undefined;
+    prNumber?: number | undefined;
     costUsd: number;
     durationMs: number;
     agent: string;
@@ -318,14 +406,16 @@ interface StepResult {
 }
 type Priority = "critical" | "high" | "medium" | "low";
 interface DispatchInput {
-    workflow: string;
+    agent: string;
     repo: string;
     prompt: string;
     runId?: string | undefined;
+    branch?: string | undefined;
     step?: string | undefined;
     from?: string | undefined;
     retry?: string | undefined;
     priority?: Priority | undefined;
+    gitStrategy?: "pr" | "branch" | undefined;
     overrides?: {
         agents?: Record<string, string> | undefined;
         maxTurns?: number | undefined;
@@ -335,7 +425,7 @@ interface DispatchInput {
 }
 interface TaskResult {
     runId: string;
-    workflow: string;
+    agent: string;
     repo: string;
     status: "success" | "failure" | "timeout" | "cancelled";
     steps: Record<string, StepResult>;
@@ -351,13 +441,12 @@ interface TaskResult {
 interface ActiveSession {
     sessionId: string;
     runId: string;
-    workflow: string;
     step: string;
     agent: string;
     repo: string;
     status: "running" | "queued" | "waiting_gate";
     startedAt: string;
-    worktreePath?: string | undefined;
+    sessionPath?: string | undefined;
 }
 interface OrchestratorStatus {
     paused: boolean;
@@ -368,9 +457,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>;
@@ -380,7 +469,6 @@ interface SessionStartEvent {
     type: "session:start";
     sessionId: string;
     runId: string;
-    workflow: string;
     step: string;
     agent: string;
     repo: string;
@@ -425,16 +513,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";
@@ -448,7 +536,7 @@ interface GateWaitingEvent {
     runId: string;
     gate: string;
     description: string;
-    context: WorkflowContext;
+    context: RunContext;
     approve: () => void;
     reject: (reason: string) => void;
     metadata?: Record<string, unknown> | undefined;
@@ -487,7 +575,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;
@@ -512,7 +600,6 @@ interface MiddlewareContextMap {
 }
 interface MiddlewareContext {
     runId: string;
-    workflow: string;
     step: string;
     agent: string;
     repo: string;
@@ -531,7 +618,6 @@ type MiddlewareResult = {
 interface CostEntry {
     timestamp: string;
     runId: string;
-    workflow: string;
     step: string;
     sessionId: string;
     agent: string;
@@ -611,15 +697,13 @@ declare class Semaphore {
  */
 declare class CostJournal {
     private readonly dir;
-    private dirCreated;
+    private readonly dirCache;
     private dayCache;
     constructor(options: {
         dir: string;
     });
     append(entry: CostEntry): Promise<void>;
     getDayTotal(date?: Date): Promise<number>;
-    private fileForDate;
-    private ensureDir;
 }
 
 /**
@@ -646,28 +730,31 @@ declare class NeoEventEmitter {
  */
 declare class EventJournal {
     private readonly dir;
-    private dirCreated;
+    private readonly dirCache;
     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.
+ * 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)
+ * - Terminal events (session:complete, session:fail, budget:alert) are retried
+ *   with exponential backoff on failure
+ * - Non-terminal events remain fire-and-forget
  */
 declare class WebhookDispatcher {
     private readonly webhooks;
+    private readonly pending;
     constructor(webhooks: WebhookConfig[]);
     dispatch(event: NeoEvent): void;
+    /** Wait for all pending terminal webhook deliveries to complete. */
+    flush(): Promise<void>;
 }
 /**
  * Check if an event type matches a filter list.
@@ -676,27 +763,48 @@ declare class WebhookDispatcher {
  */
 declare function matchesFilter(eventType: string, filters?: string[]): boolean;
 
+interface SessionCloneInfo {
+    path: string;
+    branch: string;
+    repoPath: string;
+}
+/**
+ * Create an isolated git clone for an agent session.
+ * Uses `git clone --local` to hardlink objects (fast, no network).
+ * Then checks out the target branch (existing or new).
+ */
+declare function createSessionClone(options: {
+    repoPath: string;
+    branch: string;
+    baseBranch: string;
+    sessionDir: string;
+}): Promise<SessionCloneInfo>;
+/**
+ * Remove a session clone directory.
+ * Idempotent — does not throw if the directory is already gone.
+ */
+declare function removeSessionClone(sessionPath: string): Promise<void>;
+/**
+ * List all session clones under a base directory.
+ */
+declare function listSessionClones(sessionsBaseDir: string): Promise<SessionCloneInfo[]>;
+
 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.
+ * Resolve the branch name for a run.
+ * If an explicit branch is provided, use it as-is.
+ * Otherwise, generate a deterministic name from the repo's branchPrefix and runId.
  */
-declare function getBranchName(config: RepoConfig, runId: string): string;
-
+declare function getBranchName(config: RepoConfig, runId: string, branch?: string): string;
 /**
- * Per-repository in-memory mutex to serialise git operations.
- * Concurrent git commands on the same repo corrupt the index — this prevents that.
+ * Push a branch from a session clone to a remote. Silently succeeds if
+ * the branch has no new commits to push.
  */
-/**
- * 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>;
+declare function pushSessionBranch(sessionPath: string, branch: string, remote: string): Promise<void>;
 
 /**
  * SDK-compatible sandbox configuration.
@@ -715,40 +823,10 @@ interface SandboxConfig {
 /**
  * Build an SDK-compatible sandbox configuration for an agent.
  *
- * - Writable agents: all their tools are allowed, write paths include the worktree
+ * - Writable agents: all their tools are allowed, write paths include the session clone
  * - 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>;
+declare function buildSandboxConfig(agent: ResolvedAgent, sessionPath?: string): SandboxConfig;
 
 /**
  * Audit log middleware.
@@ -815,32 +893,30 @@ 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;
 }
 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 runStore;
     private readonly journalDir;
-    private readonly builtInWorkflowDir;
-    private readonly customWorkflowDir;
     private costJournal;
     private eventJournal;
     private webhookDispatcher;
+    private memoryStore;
     private _paused;
     private _costToday;
     private _startedAt;
     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;
@@ -870,23 +946,25 @@ declare class Orchestrator extends NeoEventEmitter {
     private buildDispatchContext;
     private executeStep;
     /**
-     * Push the branch, then remove the worktree.
+     * Push the branch (writable only), then remove the session clone.
      * Runs in `finally` so it executes on both success and failure.
      */
-    private finalizeWorktree;
+    private finalizeSession;
     private runAgentSession;
     private finalizeDispatch;
+    private getMemoryStore;
+    private loadMemoryContext;
     private emitCostEvents;
     private emitSessionComplete;
     private emitSessionFail;
     private validateInput;
     private evictExpiredIdempotencyEntries;
     private computeIdempotencyKey;
-    private getFirstStep;
-    private resolveStepAgent;
     private resolveRepo;
-    private buildMiddlewareContext;
     private computeBudgetRemainingPct;
+    private resolveMcpServers;
+    /** Discover running supervisor daemons and return webhook configs for their endpoints. */
+    private discoverSupervisorWebhooks;
     private persistRun;
     private recoverOrphanedRuns;
 }
@@ -930,19 +1008,22 @@ 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;
+declare function getSupervisorDecisionsPath(name: string): string;
 
 interface ParsedOutput {
     rawOutput: string;
     output?: unknown;
     parseError?: string;
+    prUrl?: string;
+    prNumber?: number;
 }
 /**
  * Parse agent output, optionally validating against a Zod schema.
+ * Also extracts structured markers like PR_URL from the output.
  *
  * - If no schema: returns rawOutput only
  * - If schema provided: extracts JSON from output, validates with schema
@@ -954,10 +1035,11 @@ interface SessionOptions {
     agent: ResolvedAgent;
     prompt: string;
     repoPath?: string;
-    worktreePath?: string;
+    sessionPath?: string;
     sandboxConfig: SandboxConfig;
     hooks?: Record<string, unknown>;
-    mcpServers?: McpServerConfig[];
+    mcpServers?: Record<string, McpServerConfig>;
+    env?: Record<string, string>;
     initTimeoutMs: number;
     maxDurationMs: number;
     resumeSessionId?: string | undefined;
@@ -1007,23 +1089,174 @@ 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;
+    repoConfig: RepoConfig;
+    repoPath: string;
+    prompt: string;
+    branch?: string | undefined;
+    gitStrategy: GitStrategy;
+    sessionPath?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    startedAt: string;
+}
+interface SessionExecutionConfig {
+    initTimeoutMs: number;
+    maxDurationMs: number;
+    maxRetries: number;
+    backoffBaseMs: number;
+}
+interface SessionExecutionDeps {
+    middleware: Middleware[];
+    mcpServers?: Record<string, McpServerConfig> | undefined;
+    memoryContext?: string | undefined;
+    onAttempt?: (attempt: number, strategy: string) => void;
+}
+interface SessionExecutionResult extends StepResult {
+    parsed: ParsedOutput;
+}
+/**
+ * Encapsulates session execution logic: prompt building, SDK calls, and response processing.
+ * Extracted from Orchestrator for better testability and separation of concerns.
+ */
+declare class SessionExecutor {
+    private readonly config;
+    private readonly getContextValue;
+    constructor(config: SessionExecutionConfig, getContextValue: (key: string) => unknown);
+    /**
+     * Execute an agent session with the given input and dependencies.
+     * Handles prompt building, SDK invocation via recovery wrapper, and output parsing.
+     */
+    execute(input: SessionExecutionInput, deps: SessionExecutionDeps): Promise<SessionExecutionResult>;
+}
+
+/**
+ * Checks whether a process with the given PID is currently running.
+ *
+ * Uses the POSIX signal 0 trick: `process.kill(pid, 0)` doesn't actually
+ * send a signal but checks whether the process exists and the current
+ * process has permission to signal it. If the process doesn't exist,
+ * an ESRCH error is thrown.
+ *
+ * @param pid - The process ID to check. Must be a positive integer.
+ * @returns `true` if the process is alive and accessible, `false` otherwise.
+ *
+ * @example
+ * ```ts
+ * import { isProcessAlive } from "@/shared/process";
+ *
+ * // Check if current process is alive (always true)
+ * isProcessAlive(process.pid); // => true
+ *
+ * // Check if a non-existent process is alive
+ * isProcessAlive(999999); // => false
+ * ```
+ */
+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>;
     todayCostUsd: z.ZodDefault<z.ZodNumber>;
     costResetDate: z.ZodOptional<z.ZodString>;
     idleSkipCount: z.ZodDefault<z.ZodNumber>;
+    activeWorkSkipCount: z.ZodDefault<z.ZodNumber>;
     status: z.ZodDefault<z.ZodEnum<{
         running: "running";
         draining: "draining";
         stopped: "stopped";
     }>>;
+    lastConsolidationHeartbeat: z.ZodDefault<z.ZodNumber>;
+    lastCompactionHeartbeat: z.ZodDefault<z.ZodNumber>;
+    lastConsolidationTimestamp: z.ZodOptional<z.ZodString>;
+    wakeReason: z.ZodOptional<z.ZodEnum<{
+        events: "events";
+        timer: "timer";
+        active_runs: "active_runs";
+        forced: "forced";
+    }>>;
 }, z.core.$strip>;
 type SupervisorDaemonState = z.infer<typeof supervisorDaemonStateSchema>;
 declare const webhookIncomingEventSchema: z.ZodObject<{
@@ -1038,6 +1271,7 @@ type WebhookIncomingEvent = z.infer<typeof webhookIncomingEventSchema>;
 declare const inboxMessageSchema: z.ZodObject<{
     id: z.ZodString;
     from: z.ZodEnum<{
+        agent: "agent";
         tui: "tui";
         api: "api";
         external: "external";
@@ -1053,19 +1287,81 @@ declare const activityEntrySchema: z.ZodObject<{
         error: "error";
         message: "message";
         decision: "decision";
+        tool_use: "tool_use";
         event: "event";
         heartbeat: "heartbeat";
         action: "action";
+        warning: "warning";
         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>;
+declare const logBufferEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        decision: "decision";
+        action: "action";
+        progress: "progress";
+        blocker: "blocker";
+        milestone: "milestone";
+        discovery: "discovery";
+    }>;
+    message: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    target: z.ZodEnum<{
+        memory: "memory";
+        knowledge: "knowledge";
+        digest: "digest";
+    }>;
+    timestamp: z.ZodString;
+    consolidatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type LogBufferEntry = z.infer<typeof logBufferEntrySchema>;
+declare const internalEventKindSchema: z.ZodEnum<{
+    consolidation_timer: "consolidation_timer";
+    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;
@@ -1076,6 +1372,10 @@ type QueuedEvent = {
     kind: "run_complete";
     runId: string;
     timestamp: string;
+} | {
+    kind: "internal";
+    eventKind: InternalEventKind;
+    timestamp: string;
 };
 
 declare class ActivityLog {
@@ -1101,6 +1401,8 @@ declare class ActivityLog {
 interface SupervisorDaemonOptions {
     name: string;
     config: GlobalConfig;
+    /** Path to bundled default SUPERVISOR.md (e.g. from @neotx/agents) */
+    defaultInstructionsPath?: string | undefined;
 }
 /**
  * Orchestrates all supervisor components: webhook server, event queue,
@@ -1110,10 +1412,12 @@ declare class SupervisorDaemon {
     private readonly name;
     private readonly config;
     private readonly dir;
+    private readonly defaultInstructionsPath;
     private webhookServer;
     private eventQueue;
     private heartbeatLoop;
     private activityLog;
+    private decisionStore;
     private sessionId;
     constructor(options: SupervisorDaemonOptions);
     start(): Promise<void>;
@@ -1122,7 +1426,11 @@ declare class SupervisorDaemon {
     private readState;
     private writeState;
     private readLockPid;
-    private isProcessAlive;
+    /**
+     * Handle decision:answer webhook events.
+     * Extracts decisionId and answer from the payload and records the answer.
+     */
+    private handleDecisionAnswer;
 }
 
 interface EventQueueOptions {
@@ -1138,6 +1446,10 @@ interface GroupedEvents {
     webhooks: QueuedEvent[];
     runCompletions: QueuedEvent[];
 }
+interface DrainAndGroupResult {
+    grouped: GroupedEvents;
+    rawEvents: QueuedEvent[];
+}
 /**
  * In-memory event queue with deduplication, rate limiting, and file watching.
  *
@@ -1171,14 +1483,15 @@ declare class EventQueue {
     /**
      * Drain and group events: deduplicates messages by content,
      * keeps webhooks and run completions separate.
+     * Returns both grouped events AND original raw events for later marking as processed.
      */
-    drainAndGroup(): GroupedEvents;
+    drainAndGroup(): DrainAndGroupResult;
     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;
+    startWatching(inboxPath: string, eventsPath: string): Promise<void>;
     stopWatching(): void;
     /**
      * Replay unprocessed events from disk on startup.
@@ -1203,6 +1516,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;
@@ -1210,38 +1572,114 @@ interface HeartbeatLoopOptions {
     sessionId: string;
     eventQueue: EventQueue;
     activityLog: ActivityLog;
+    /** Path to the inbox/events directory for markProcessed() calls */
+    eventsPath: string;
+    /** 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:
  * 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
+ * 2. Read log buffer entries
+ * 3. Determine standard vs consolidation mode
+ * 4. Build the appropriate prompt
+ * 5. Call sdk.query() for Claude to reason and act
+ * 6. Mark entries consolidated and compact log buffer (consolidation only)
+ * 7. Log activity
+ * 8. Wait for the next event or idle timeout
  */
 declare class HeartbeatLoop {
     private stopping;
     private consecutiveFailures;
     private activeAbort;
-    private readonly config;
+    private config;
     private readonly supervisorDir;
     private readonly statePath;
     private sessionId;
     private readonly eventQueue;
     private readonly activityLog;
+    private readonly _eventsPath;
     private customInstructions;
+    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.
+     */
+    private checkBudgetExceeded;
+    /**
+     * Handle skip logic for idle and active-work scenarios.
+     * Uses IdleDetector to make skip decisions based on context.
+     */
+    private handleSkipLogic;
+    /**
+     * Determine heartbeat mode: compaction > consolidation > standard.
+     */
+    private determineHeartbeatMode;
+    /**
+     * Build the state update object after heartbeat completion.
+     */
+    private buildStateUpdate;
+    /**
+     * Build the prompt for the current heartbeat mode.
+     */
+    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.
+     * 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.
      * Resolution order:
      * 1. Explicit path via `supervisor.instructions` in config
-     * 2. Default: ~/.neo/SUPERVISOR.md
+     * 2. User default: ~/.neo/SUPERVISOR.md
+     * 3. Bundled default from @neotx/agents (if path provided)
      */
     private loadInstructions;
     /** Route a single SDK stream message to the appropriate log handler. */
@@ -1253,53 +1691,164 @@ 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;
 }
 
 /**
- * Load the supervisor memory from disk.
- * Migrates from legacy memory.md if needed.
+ * Append a single entry to the log buffer file.
  */
-declare function loadMemory(dir: string): Promise<string>;
-/**
- * Save the supervisor memory to disk (full overwrite).
- * Automatically compacts if needed.
- */
-declare function saveMemory(dir: string, content: string): Promise<void>;
-/**
- * Extract memory content from Claude's response using <memory>...</memory> tags.
- */
-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;
-};
+declare function appendLogBuffer(dir: string, entry: LogBufferEntry): Promise<void>;
 
-interface HeartbeatPromptOptions {
-    repos: RepoConfig[];
-    memory: string;
-    knowledge: string;
-    memorySizeKB: number;
-    grouped: GroupedEvents;
-    budgetStatus: {
-        todayUsd: number;
-        capUsd: number;
-        remainingPct: number;
-    };
-    activeRuns: string[];
-    heartbeatCount: number;
-    mcpServerNames: string[];
-    customInstructions?: string | undefined;
+interface Embedder {
+    embed(texts: string[]): Promise<number[][]>;
+    readonly dimensions: number;
 }
+declare class LocalEmbedder implements Embedder {
+    readonly dimensions = 384;
+    embed(texts: string[]): Promise<number[][]>;
+}
+
+declare const memoryTypeSchema: z.ZodEnum<{
+    fact: "fact";
+    procedure: "procedure";
+    episode: "episode";
+    focus: "focus";
+    feedback: "feedback";
+    task: "task";
+}>;
+type MemoryType = z.infer<typeof memoryTypeSchema>;
+declare const memoryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        fact: "fact";
+        procedure: "procedure";
+        episode: "episode";
+        focus: "focus";
+        feedback: "feedback";
+        task: "task";
+    }>;
+    scope: z.ZodString;
+    content: z.ZodString;
+    source: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    createdAt: z.ZodString;
+    lastAccessedAt: z.ZodString;
+    accessCount: z.ZodDefault<z.ZodNumber>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    severity: z.ZodOptional<z.ZodString>;
+    supersedes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MemoryEntry = z.infer<typeof memoryEntrySchema>;
+declare const memoryWriteInputSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        fact: "fact";
+        procedure: "procedure";
+        episode: "episode";
+        focus: "focus";
+        feedback: "feedback";
+        task: "task";
+    }>;
+    scope: z.ZodDefault<z.ZodString>;
+    content: z.ZodString;
+    source: z.ZodDefault<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    severity: z.ZodOptional<z.ZodString>;
+    supersedes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MemoryWriteInput = z.input<typeof memoryWriteInputSchema>;
+interface MemoryQuery {
+    scope?: string;
+    types?: MemoryType[];
+    since?: string;
+    limit?: number;
+    sortBy?: "relevance" | "createdAt" | "accessCount";
+    tags?: string[];
+}
+interface MemoryStats {
+    total: number;
+    byType: Record<string, number>;
+    byScope: Record<string, number>;
+}
+
+declare class MemoryStore {
+    private db;
+    private embedder;
+    private hasVec;
+    constructor(dbPath: string, embedder?: Embedder | null);
+    private initSchema;
+    /**
+     * Migrate existing tables whose CHECK constraint predates the 'task' type.
+     * SQLite doesn't allow ALTER CHECK, so we recreate the table if needed.
+     */
+    private migrateCheckConstraint;
+    write(input: MemoryWriteInput): Promise<string>;
+    update(id: string, content: string): void;
+    updateFields(id: string, fields: {
+        content?: string;
+        outcome?: string;
+        runId?: string;
+    }): void;
+    forget(id: string): void;
+    query(opts?: MemoryQuery): MemoryEntry[];
+    search(text: string, opts?: MemoryQuery): Promise<MemoryEntry[]>;
+    markAccessed(ids: string[]): void;
+    decay(maxAgeDays?: number, minAccessCount?: number): number;
+    expireEphemeral(): number;
+    stats(): MemoryStats;
+    close(): void;
+}
+
 /**
- * Build the prompt sent to Claude at each heartbeat.
- *
- * Includes: role definition, current memory, pending events,
- * budget status, active runs, and available integrations.
+ * Reads supervisor status from the daemon state file.
+ * Returns null if the supervisor is not running or state file doesn't exist.
  */
-declare function buildHeartbeatPrompt(opts: HeartbeatPromptOptions): string;
+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;
@@ -1333,49 +1882,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, 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 };
+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 };