@elhu/pit 0.1.1

package/dist/daemon/handlers.js

@@ -0,0 +1,1260 @@
+/**
+ * Orchestrator command handlers for the pit daemon.
+ *
+ * This module contains the core orchestration pipeline (clearAndReprompt) and
+ * all handler functions for daemon protocol methods: start, status, pause,
+ * resume, stop, teardown, add, log, agent-idle, agent-permission.
+ *
+ * Each handler takes a DaemonContext as its first argument instead of closing
+ * over module-level variables. The registerOrchestratorHandlers() function
+ * registers all handlers on a PitDaemonServer.
+ */
+import * as path from "node:path";
+import * as beads from "../beads.js";
+import { resolveConfig, DEFAULT_CONFIG } from "../config.js";
+import { resolveAdapter } from "../adapters/index.js";
+import { createDaemonState, createDebouncedSaver, saveDaemonState } from "./state.js";
+import { createLogger } from "../logger.js";
+import { startLoop, updateStatusBar } from "../loop.js";
+import { setupEpic, renderPrompt, resolveTemplateContent, DEFAULT_PROMPT, } from "../setup.js";
+import { sendClearCommand, sendKeys, sendPrompt, sendBell, capturePane, killWindow, sessionExists, createSession, windowExists, getWindowList, getFirstWindowName, createWindow, } from "../tmux.js";
+import { removeWorktree, isWorktreeDirty } from "../worktree.js";
+import { cleanup as cleanupDir } from "../signals.js";
+const logger = createLogger();
+// ---------------------------------------------------------------------------
+// Bell helpers
+// ---------------------------------------------------------------------------
+/**
+ * Ring a bell on the control window (first window in the session) so the
+ * operator is notified rather than the agent's epic window.
+ *
+ * Falls back to fallbackWindow if the first window cannot be determined
+ * (empty session, tmux error, etc.). All errors are silently swallowed —
+ * bell is best-effort.
+ */
+async function ringControlBell(ctx, fallbackWindow) {
+    const firstWindow = await getFirstWindowName(ctx.tmuxSession).catch(() => null);
+    const target = firstWindow ?? fallbackWindow;
+    await sendBell(ctx.tmuxSession, target).catch((_e) => undefined);
+}
+// ---------------------------------------------------------------------------
+// Shared CLEARING pipeline helper
+// ---------------------------------------------------------------------------
+/**
+ * Execute the clear-and-reprompt flow (RUNNING/PAUSED → CLEARING → RUNNING or DONE).
+ *
+ * Callers are responsible for ensuring the state machine is in RUNNING or PAUSED
+ * before calling this (the CLEARING transition is validated by the machine).
+ *
+ * Returns the next ticket if one is available, or null if the epic is done.
+ * Throws on CLEARING pipeline errors — callers should handle by transitioning
+ * to PAUSED with an appropriate reason.
+ */
+export function makeClearAndReprompt(ctx) {
+    return async function clearAndReprompt(options) {
+        // 1. Transition → CLEARING
+        await options.machine.transition("CLEARING", options.transitionReason);
+        // 2. Send clear command
+        await sendClearCommand(ctx.tmuxSession, options.windowName, options.adapter.clearCommand);
+        // 3. Wait for TUI readiness (use persisted clearDelay from config)
+        const clearDelay = ctx.daemonState?.options.clearDelay ?? DEFAULT_CONFIG.clearDelay;
+        await options.adapter.waitForReady({
+            timeoutMs: clearDelay,
+        });
+        // 4. Small delay to prevent tmux race condition
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        // 5. Check for next ticket
+        const nextTicket = await beads.ready(options.epicId, { cwd: ctx.projectRoot });
+        if (!nextTicket) {
+            // No more work — epic complete
+            await options.machine.transition("DONE", "EPIC_COMPLETE");
+            await sendBell(ctx.tmuxSession, options.windowName).catch(() => {
+                // Ignore errors - bell is best-effort
+            });
+            return { nextTicket: null };
+        }
+        // 6. Resolve prompt template and send re-prompt
+        const resolvedPromptPath = ctx.daemonState?.options.promptTemplate
+            ? path.resolve(ctx.daemonState.options.promptTemplate)
+            : undefined;
+        const promptContent = resolveTemplateContent(resolvedPromptPath, ctx.daemonState?.options.inlinePromptTemplate, DEFAULT_PROMPT);
+        await sendPrompt(ctx.tmuxSession, options.windowName, renderPrompt(options.epicId, promptContent));
+        // 7. Transition CLEARING → RUNNING
+        await options.machine.transition("RUNNING", "CLEARED");
+        // 8. Reset ticket timer for the new ticket
+        if (ctx.daemonState?.epics[options.epicId]) {
+            ctx.daemonState.epics[options.epicId].ticketStartedAt = new Date().toISOString();
+        }
+        return { nextTicket };
+    };
+}
+// ---------------------------------------------------------------------------
+// Handler implementations
+// ---------------------------------------------------------------------------
+async function handleStart(ctx, params) {
+    const typedParams = params;
+    // Validate required params
+    if (!typedParams.epics || !Array.isArray(typedParams.epics) || typedParams.epics.length === 0) {
+        throw new Error("epics parameter is required and must be a non-empty array");
+    }
+    // Build CLI overrides from StartParams (only include fields explicitly sent)
+    const cliFlags = {};
+    if (typedParams.agent !== undefined)
+        cliFlags.agent = typedParams.agent;
+    if (typedParams.worktreeDir !== undefined)
+        cliFlags.worktreeDir = typedParams.worktreeDir;
+    if (typedParams.baseBranch !== undefined)
+        cliFlags.baseBranch = typedParams.baseBranch;
+    // ticketTimeout: undefined means "not sent", null means "explicitly disabled"
+    if (typedParams.ticketTimeout !== undefined)
+        cliFlags.ticketTimeout = typedParams.ticketTimeout;
+    if (typedParams.model !== undefined)
+        cliFlags.model = typedParams.model;
+    // Three-tier merge: CLI flags > .pit.json > defaults
+    const resolved = resolveConfig(cliFlags, ctx.fileConfig);
+    const agent = resolved.agent;
+    // resolved.model is string | null (null = no model flag)
+    const sessionModel = resolved.model ?? undefined;
+    const epicModels = typedParams.epicModels ?? {};
+    const options = {
+        worktreeDir: resolved.worktreeDir,
+        baseBranch: resolved.baseBranch,
+        promptTemplate: typedParams.promptTemplate,
+        instructionsTemplate: typedParams.instructionsTemplate,
+        inlinePromptTemplate: resolved.promptTemplate || undefined,
+        clearDelay: resolved.clearDelay,
+        initDelay: resolved.initDelay,
+        ticketTimeout: resolved.ticketTimeout,
+    };
+    // Resolve agent type if 'auto'
+    if (ctx.daemonState === null) {
+        const resolvedAgent = await resolveAdapter(agent);
+        ctx.agentInstance = resolvedAgent;
+        // Create daemon state with persisted options
+        ctx.daemonState = createDaemonState({
+            sessionId: ctx.sessionId,
+            projectRoot: ctx.projectRoot,
+            tmuxSession: ctx.tmuxSession,
+            agent: resolvedAgent.name,
+            options: {
+                worktreeDir: options.worktreeDir,
+                baseBranch: options.baseBranch,
+                clearDelay: options.clearDelay,
+                initDelay: options.initDelay,
+                ticketTimeout: options.ticketTimeout,
+            },
+        });
+        // Create debounced saver
+        ctx.debouncedSaver = createDebouncedSaver(ctx.sessionId);
+        // Save initial state
+        ctx.debouncedSaver(ctx.daemonState);
+    }
+    // Deduplicate epic IDs (log a warning for duplicates)
+    const seen = new Set();
+    const deduplicatedEpics = [];
+    for (const epic of typedParams.epics) {
+        if (seen.has(epic)) {
+            logger.warn(`Duplicate epic ID in start request, ignoring: ${epic}`);
+        }
+        else {
+            seen.add(epic);
+            deduplicatedEpics.push(epic);
+        }
+    }
+    // Ensure the tmux session exists (the daemon doesn't own the session
+    // lifecycle — it may have been created by a previous run or manually).
+    if (!(await sessionExists(ctx.tmuxSession))) {
+        await createSession(ctx.tmuxSession);
+    }
+    // Setup each epic
+    const results = [];
+    const setupOptions = {
+        agent: ctx.agentInstance ? ctx.agentInstance.name : "opencode",
+        epics: deduplicatedEpics,
+        worktreeDir: options.worktreeDir,
+        baseBranch: options.baseBranch,
+        clearDelay: options.clearDelay,
+        initDelay: options.initDelay,
+        tmuxSession: ctx.tmuxSession,
+    };
+    const sessionLogger = createLogger();
+    for (const epic of deduplicatedEpics) {
+        // Check if this epic is already tracked — re-attach instead of re-setup
+        if (ctx.daemonState && ctx.daemonState.epics[epic]) {
+            const existingState = ctx.daemonState.epics[epic];
+            // Map internal MachineState to external state
+            let externalState;
+            switch (existingState.state) {
+                case "SETUP":
+                case "RUNNING":
+                case "CLEARING":
+                    externalState = "running";
+                    break;
+                case "PAUSED":
+                    externalState = "paused";
+                    break;
+                case "DONE":
+                    externalState = "done";
+                    break;
+                default:
+                    externalState = "running";
+            }
+            // Get progress from beads if available
+            let progressResult = { done: 0, total: 0 };
+            try {
+                progressResult = await beads.progress(epic, { cwd: ctx.projectRoot });
+            }
+            catch {
+                // Ignore — progress is best-effort
+            }
+            // For RUNNING/CLEARING states, verify the agent is still alive.
+            // If it has crashed since the last health check, update state to PAUSED
+            // so the caller doesn't get stale 'running' state.
+            if (existingState.state === "RUNNING" ||
+                existingState.state === "CLEARING" ||
+                existingState.state === "SETUP") {
+                try {
+                    const adapter = ctx.agentInstance || (await resolveAdapter("auto"));
+                    const agentOk = await adapter.verifyRunning(ctx.tmuxSession, existingState.windowName);
+                    if (!agentOk) {
+                        logger.warn(`Epic agent not running on re-attach, marking as PAUSED: ${epic}`);
+                        // Update daemonState
+                        const pauseReason = "agent not running (detected on re-attach)";
+                        ctx.daemonState.epics[epic].state = "PAUSED";
+                        ctx.daemonState.epics[epic].pauseReason = pauseReason;
+                        ctx.debouncedSaver?.(ctx.daemonState);
+                        // Transition the loop handle's state machine if available
+                        const loopHandle = ctx.loopHandles.get(epic);
+                        if (loopHandle) {
+                            try {
+                                await loopHandle.machine.transition("PAUSED", "MANUAL_PAUSE", { pauseReason });
+                            }
+                            catch (transitionErr) {
+                                logger.warn(`Failed to transition state machine for epic ${epic} on re-attach`, {
+                                    error: transitionErr instanceof Error ? transitionErr.message : String(transitionErr),
+                                });
+                            }
+                        }
+                        externalState = "paused";
+                    }
+                }
+                catch (verifyErr) {
+                    // verifyRunning threw — log and continue without changing state
+                    logger.warn(`verifyRunning threw during re-attach for epic ${epic}, skipping state update`, {
+                        error: verifyErr instanceof Error ? verifyErr.message : String(verifyErr),
+                    });
+                }
+            }
+            if (epicModels[epic]) {
+                logger.warn(`--epic-model for ${epic} ignored: epic already running (re-attached)`);
+            }
+            logger.info(`Epic already tracked, re-attaching: ${epic}`, { state: externalState });
+            results.push({
+                epic,
+                status: "ok",
+                reused: true,
+                state: externalState,
+                progress: progressResult,
+                worktreePath: existingState.worktreePath,
+                windowName: existingState.windowName,
+            });
+            continue;
+        }
+        try {
+            // Per-epic model resolution: epicModels[epic] > sessionModel > undefined
+            const epicModel = epicModels[epic] ?? sessionModel;
+            const epicSetupOptions = { ...setupOptions, model: epicModel };
+            // Call setupEpic
+            const setupResult = await setupEpic(ctx.agentInstance ? ctx.agentInstance : await resolveAdapter("auto"), epic, ctx.sessionId, ctx.tmuxSession, epicSetupOptions, sessionLogger);
+            if (setupResult.status === "ok") {
+                // Call startLoop to get LoopHandle
+                const windowName = `epic-${epic}`;
+                const loopHandle = startLoop({
+                    epic,
+                    tmuxSession: ctx.tmuxSession,
+                    windowName,
+                    adapter: ctx.agentInstance ? ctx.agentInstance : await resolveAdapter(agent),
+                    logger: sessionLogger,
+                    onStatusBarUpdate: makeStatusBarUpdater(ctx),
+                });
+                // Store LoopHandle in daemon memory
+                ctx.loopHandles.set(epic, loopHandle);
+                // Add epic to DaemonState.epics
+                if (ctx.daemonState) {
+                    ctx.daemonState.epics[epic] = {
+                        epic,
+                        state: loopHandle.state,
+                        pauseReason: loopHandle.pauseReason,
+                        worktreePath: setupResult.worktreePath ? setupResult.worktreePath : "",
+                        windowName,
+                        currentTicket: null,
+                        ticketStartedAt: null,
+                    };
+                    // Set currentTicket to the first ready ticket for this epic
+                    const firstTicket = await beads.ready(epic, { cwd: ctx.projectRoot });
+                    if (firstTicket) {
+                        ctx.daemonState.epics[epic].currentTicket = firstTicket.id;
+                        ctx.daemonState.epics[epic].ticketStartedAt = new Date().toISOString();
+                    }
+                }
+                results.push({
+                    epic,
+                    status: "ok",
+                    worktreePath: setupResult.worktreePath,
+                    windowName,
+                });
+            }
+            else {
+                results.push({
+                    epic,
+                    status: "error",
+                    error: setupResult.error,
+                });
+            }
+        }
+        catch (error) {
+            results.push({
+                epic,
+                status: "error",
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // Save state via debounced saver
+    if (ctx.debouncedSaver) {
+        ctx.debouncedSaver(ctx.daemonState);
+    }
+    // Return StartResult
+    return {
+        sessionId: ctx.sessionId,
+        epics: results,
+    };
+}
+async function handleStatus(ctx) {
+    // Get daemon version from package.json
+    let daemonVersion;
+    try {
+        const pkg = await import("../../package.json", { with: { type: "json" } });
+        daemonVersion = pkg.default.version;
+    }
+    catch {
+        daemonVersion = "unknown";
+    }
+    // Protocol version is always '1.0' initially
+    const protocolVersion = "1.0";
+    // Calculate uptime in seconds
+    const uptime = Math.floor((Date.now() - ctx.daemonStartTime) / 1000);
+    // Initialize status result
+    const statusResult = {
+        daemonVersion,
+        protocolVersion,
+        uptime,
+        sessionId: ctx.sessionId,
+        projectRoot: ctx.projectRoot,
+        tmuxSession: ctx.tmuxSession,
+        epics: [],
+    };
+    // If daemon state is initialized, add epic information
+    if (ctx.daemonState) {
+        for (const [epicId, epicState] of Object.entries(ctx.daemonState.epics)) {
+            // Map internal MachineState to external state
+            let externalState;
+            switch (epicState.state) {
+                case "SETUP":
+                case "RUNNING":
+                case "CLEARING":
+                    externalState = "running";
+                    break;
+                case "PAUSED":
+                    externalState = "paused";
+                    break;
+                case "DONE":
+                    externalState = "done";
+                    break;
+                default:
+                    externalState = "running"; // Default fallback
+            }
+            // Get progress from beads
+            let progressResult;
+            try {
+                progressResult = await beads.progress(epicId, { cwd: ctx.projectRoot });
+            }
+            catch {
+                // If beads fails, return { done: 0, total: 0 }
+                progressResult = { done: 0, total: 0 };
+            }
+            statusResult.epics.push({
+                epic: epicId,
+                state: externalState,
+                progress: progressResult,
+                pauseReason: epicState.pauseReason,
+            });
+        }
+    }
+    return statusResult;
+}
+async function handlePause(ctx, params) {
+    const typedParams = params;
+    // Validate epic exists
+    if (!typedParams.epic) {
+        throw new Error("epic parameter is required");
+    }
+    const loopHandle = ctx.loopHandles.get(typedParams.epic);
+    if (!loopHandle) {
+        throw new Error("EPIC_NOT_FOUND");
+    }
+    // Check state is RUNNING or CLEARING, else INVALID_STATE
+    const previousState = loopHandle.state;
+    if (!["RUNNING", "CLEARING"].includes(previousState)) {
+        throw new Error("INVALID_STATE");
+    }
+    // Call machine.transition
+    await loopHandle.machine.transition("PAUSED", "MANUAL_PAUSE", { pauseReason: "MANUAL_PAUSE" });
+    // Save state via debounced saver
+    if (ctx.debouncedSaver && ctx.daemonState) {
+        ctx.daemonState.epics[typedParams.epic].state = loopHandle.state;
+        ctx.daemonState.epics[typedParams.epic].pauseReason = loopHandle.pauseReason;
+        ctx.debouncedSaver(ctx.daemonState);
+    }
+    // Return result
+    return {
+        epic: typedParams.epic,
+        previousState,
+        newState: "paused",
+    };
+}
+async function handleResume(ctx, params, clearAndReprompt) {
+    const typedParams = params;
+    // Validate epic exists
+    if (!typedParams.epic) {
+        throw new Error("epic parameter is required");
+    }
+    const loopHandle = ctx.loopHandles.get(typedParams.epic);
+    if (!loopHandle) {
+        throw new Error("EPIC_NOT_FOUND");
+    }
+    // Check state is PAUSED, else INVALID_STATE
+    const previousState = loopHandle.state;
+    if (previousState !== "PAUSED") {
+        throw new Error("INVALID_STATE");
+    }
+    let warning;
+    // Handle message vs no message
+    if (typedParams.message && typedParams.message.length > 0) {
+        // Resume with message: transition to RUNNING, clear stale context, then send message
+        await loopHandle.machine.transition("RUNNING", "RESUME_WITH_MESSAGE");
+        const epicState = ctx.daemonState?.epics[typedParams.epic];
+        const windowName = epicState?.windowName || `epic-${typedParams.epic}`;
+        const tmuxSess = ctx.daemonState?.tmuxSession || "pit";
+        const adapter = ctx.agentInstance || (await resolveAdapter("auto"));
+        // Clear stale conversation context before injecting the message
+        try {
+            const clearDelay = ctx.daemonState?.options.clearDelay ?? DEFAULT_CONFIG.clearDelay;
+            await sendClearCommand(tmuxSess, windowName, adapter.clearCommand);
+            await adapter.waitForReady({ timeoutMs: clearDelay });
+            // Small delay to prevent tmux race condition
+            await new Promise((resolve) => setTimeout(resolve, 200));
+        }
+        catch (err) {
+            logger.warn(`Failed to clear context before sending resume message for epic ${typedParams.epic}`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            // Continue anyway — still send the message even if clear failed
+        }
+        // Send message to TUI
+        try {
+            await sendPrompt(tmuxSess, windowName, typedParams.message);
+        }
+        catch (err) {
+            logger.error(`Failed to send resume message to epic ${typedParams.epic}`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        // Reset ticket timer — human intervened, agent gets a fresh window
+        if (ctx.daemonState?.epics[typedParams.epic]) {
+            ctx.daemonState.epics[typedParams.epic].ticketStartedAt = new Date().toISOString();
+        }
+    }
+    else {
+        // Resume without message: handle NEEDS_HUMAN_INPUT case
+        if (loopHandle.pauseReason?.includes("NEEDS_HUMAN_INPUT")) {
+            warning = "Resuming NEEDS_HUMAN_INPUT without message";
+        }
+        const epicState = ctx.daemonState?.epics[typedParams.epic];
+        if (!epicState) {
+            throw new Error("EPIC_NOT_FOUND");
+        }
+        const adapter = ctx.agentInstance || (await resolveAdapter("auto"));
+        // Run CLEARING flow via shared helper
+        try {
+            const { nextTicket } = await clearAndReprompt({
+                epicId: typedParams.epic,
+                machine: loopHandle.machine,
+                windowName: epicState.windowName,
+                adapter,
+                transitionReason: "RESUME_NO_MESSAGE",
+                epicState,
+            });
+            // Update currentTicket to the next ready ticket
+            if (ctx.daemonState) {
+                ctx.daemonState.epics[typedParams.epic].currentTicket = nextTicket?.id ?? null;
+            }
+        }
+        catch (err) {
+            logger.error(`Error during CLEARING flow for epic ${typedParams.epic}:`, { err });
+            throw err;
+        }
+    }
+    // Save state via debounced saver
+    if (ctx.debouncedSaver && ctx.daemonState) {
+        ctx.daemonState.epics[typedParams.epic].state = loopHandle.state;
+        ctx.daemonState.epics[typedParams.epic].pauseReason = loopHandle.pauseReason;
+        ctx.debouncedSaver(ctx.daemonState);
+    }
+    // Return result
+    const result = {
+        epic: typedParams.epic,
+        previousState: "paused",
+        newState: "running",
+    };
+    if (warning) {
+        result.warning = warning;
+    }
+    return result;
+}
+async function handleAgentIdle(ctx, params, clearAndReprompt) {
+    const typedParams = params;
+    // Validate epicId is provided
+    if (!typedParams.epicId) {
+        throw new Error("INVALID_PARAMS");
+    }
+    // Validate epic exists in loopHandles
+    const loopHandle = ctx.loopHandles.get(typedParams.epicId);
+    if (!loopHandle) {
+        throw new Error("EPIC_NOT_FOUND");
+    }
+    // Only process idle events when RUNNING
+    if (loopHandle.state !== "RUNNING") {
+        logger.debug(`[${typedParams.epicId}] agent-idle ignored, state=${loopHandle.state}`);
+        return { ok: true, action: "ignored" };
+    }
+    const epicState = ctx.daemonState?.epics[typedParams.epicId];
+    if (!epicState) {
+        throw new Error("EPIC_NOT_FOUND");
+    }
+    const currentTicket = epicState.currentTicket;
+    const adapter = ctx.agentInstance || (await resolveAdapter("auto"));
+    if (!currentTicket) {
+        // No tracked ticket — unexpected idle, pause
+        logger.warn(`[${typedParams.epicId}] agent-idle with no tracked ticket, pausing`);
+        await loopHandle.machine.transition("PAUSED", "UNRECOGNIZED_IDLE", {
+            pauseReason: "agent idle, no tracked ticket",
+        });
+        await ringControlBell(ctx, epicState.windowName);
+        if (ctx.daemonState) {
+            ctx.daemonState.epics[typedParams.epicId].state = loopHandle.state;
+            ctx.daemonState.epics[typedParams.epicId].pauseReason = loopHandle.pauseReason;
+            ctx.debouncedSaver?.(ctx.daemonState);
+        }
+        return { ok: true, action: "paused" };
+    }
+    // Check if current ticket was closed
+    let ticket;
+    try {
+        ticket = await beads.show(currentTicket, { cwd: ctx.projectRoot });
+    }
+    catch (err) {
+        // beads.show() failed — pause for safety
+        const reason = `beads.show() failed: ${String(err)}`;
+        logger.error(`[${typedParams.epicId}] ${reason}`);
+        await loopHandle.machine.transition("PAUSED", "UNRECOGNIZED_IDLE", { pauseReason: reason });
+        await ringControlBell(ctx, epicState.windowName);
+        if (ctx.daemonState) {
+            ctx.daemonState.epics[typedParams.epicId].state = loopHandle.state;
+            ctx.daemonState.epics[typedParams.epicId].pauseReason = loopHandle.pauseReason;
+            ctx.debouncedSaver?.(ctx.daemonState);
+        }
+        return { ok: true, action: "paused" };
+    }
+    if (ticket && ticket.status === "closed") {
+        // Ticket complete — clear and re-prompt (or epic complete if no more work)
+        try {
+            const { nextTicket } = await clearAndReprompt({
+                epicId: typedParams.epicId,
+                machine: loopHandle.machine,
+                windowName: epicState.windowName,
+                adapter,
+                transitionReason: "TICKET_COMPLETE",
+                epicState,
+            });
+            // Update currentTicket in daemon state
+            if (ctx.daemonState) {
+                ctx.daemonState.epics[typedParams.epicId].state = loopHandle.state;
+                ctx.daemonState.epics[typedParams.epicId].pauseReason = loopHandle.pauseReason;
+                ctx.daemonState.epics[typedParams.epicId].currentTicket = nextTicket?.id ?? null;
+                ctx.debouncedSaver?.(ctx.daemonState);
+            }
+            return {
+                ok: true,
+                action: nextTicket ? "continue" : "done",
+            };
+        }
+        catch (err) {
+            // CLEARING failed — transition to PAUSED
+            const reason = `CLEARING failed: ${String(err)}`;
+            logger.error(`[${typedParams.epicId}] ${reason}`);
+            // State machine may be in CLEARING — transition to PAUSED
+            try {
+                await loopHandle.machine.transition("PAUSED", "UNRECOGNIZED_IDLE", {
+                    pauseReason: reason,
+                });
+            }
+            catch {
+                // Transition may have already happened — ignore
+            }
+            await ringControlBell(ctx, epicState.windowName);
+            if (ctx.daemonState) {
+                ctx.daemonState.epics[typedParams.epicId].state = loopHandle.state;
+                ctx.daemonState.epics[typedParams.epicId].pauseReason = loopHandle.pauseReason;
+                ctx.debouncedSaver?.(ctx.daemonState);
+            }
+            return { ok: true, action: "paused" };
+        }
+    }
+    else {
+        // Ticket not closed — agent went idle without completing work
+        const reason = ticket
+            ? `agent idle, ticket not closed (status: ${ticket.status})`
+            : "agent idle, ticket not found";
+        logger.warn(`[${typedParams.epicId}] ${reason}`);
+        await loopHandle.machine.transition("PAUSED", "UNRECOGNIZED_IDLE", {
+            pauseReason: reason,
+        });
+        await ringControlBell(ctx, epicState.windowName);
+        if (ctx.daemonState) {
+            ctx.daemonState.epics[typedParams.epicId].state = loopHandle.state;
+            ctx.daemonState.epics[typedParams.epicId].pauseReason = loopHandle.pauseReason;
+            ctx.debouncedSaver?.(ctx.daemonState);
+        }
+        return { ok: true, action: "paused" };
+    }
+}
+async function handleAgentPermission(ctx, params) {
+    const typedParams = params;
+    // Validate epicId is provided
+    if (!typedParams.epicId) {
+        throw new Error("INVALID_PARAMS");
+    }
+    // Validate epic exists in loopHandles
+    const loopHandle = ctx.loopHandles.get(typedParams.epicId);
+    if (!loopHandle) {
+        throw new Error("EPIC_NOT_FOUND");
+    }
+    // Log receipt
+    logger.info(`[${typedParams.epicId}] agent-permission received`);
+    // Return success
+    return {
+        ok: true,
+    };
+}
+async function handleLog(ctx, params) {
+    const typedParams = params;
+    // Validate epic exists
+    if (!typedParams.epic) {
+        throw new Error("epic parameter is required");
+    }
+    // Validate epic exists in daemon state
+    const epicState = ctx.daemonState?.epics[typedParams.epic];
+    if (!epicState) {
+        throw new Error("EPIC_NOT_FOUND");
+    }
+    try {
+        // Delegate to existing tmux.capturePane()
+        const output = await capturePane(ctx.daemonState?.tmuxSession || "pit", epicState.windowName, {
+            lines: typedParams.lines ?? 50,
+            stripAnsi: !typedParams.raw,
+        });
+        return {
+            output,
+            epic: typedParams.epic,
+            lines: output.split("\n").length,
+        };
+    }
+    catch (error) {
+        // If tmux error, wrap it as internal error
+        if (error instanceof Error) {
+            const captureError = new Error(`Failed to capture output: ${error.message}`);
+            captureError.cause = error;
+            throw captureError;
+        }
+        const captureError = new Error("Failed to capture output: Unknown error");
+        captureError.cause = error;
+        throw captureError;
+    }
+}
+async function handleStop(ctx, params) {
+    const typedParams = params;
+    const stopped = [];
+    const epicsToStop = typedParams.epic ? [typedParams.epic] : Array.from(ctx.loopHandles.keys());
+    for (const epicId of epicsToStop) {
+        const loopHandle = ctx.loopHandles.get(epicId);
+        if (!loopHandle)
+            continue;
+        // Stop the loop (transitions to DONE)
+        loopHandle.stop();
+        stopped.push(epicId);
+    }
+    // Persist updated state
+    if (ctx.debouncedSaver && ctx.daemonState) {
+        for (const epicId of stopped) {
+            const loopHandle = ctx.loopHandles.get(epicId);
+            if (loopHandle && ctx.daemonState.epics[epicId]) {
+                ctx.daemonState.epics[epicId].state = loopHandle.state;
+            }
+        }
+        ctx.debouncedSaver(ctx.daemonState);
+    }
+    return { success: true, stopped };
+}
+async function handleTeardown(ctx, params) {
+    const typedParams = params;
+    const { epic: singleEpic, keepWorktrees = false, force = false } = typedParams;
+    const cleaned = {
+        windows: [],
+        worktrees: [],
+        dirtyWorktrees: [],
+        sessionDir: "",
+    };
+    // Determine which epics to tear down
+    const epicsToTeardown = singleEpic
+        ? ctx.loopHandles.has(singleEpic)
+            ? [singleEpic]
+            : []
+        : Array.from(ctx.loopHandles.keys());
+    if (singleEpic && !ctx.loopHandles.has(singleEpic)) {
+        throw new Error("EPIC_NOT_FOUND");
+    }
+    // Safety check: for full teardown, refuse if any epic is running unless --force
+    if (!singleEpic && !force && ctx.daemonState) {
+        const runningEpics = [];
+        for (const [epicId, epicState] of Object.entries(ctx.daemonState.epics)) {
+            if (epicState.state === "RUNNING" ||
+                epicState.state === "SETUP" ||
+                epicState.state === "CLEARING") {
+                runningEpics.push(epicId);
+            }
+        }
+        if (runningEpics.length > 0) {
+            throw new Error(`Cannot teardown: epics still running: ${runningEpics.join(", ")}. Use --force to override.`);
+        }
+    }
+    for (const epicId of epicsToTeardown) {
+        const loopHandle = ctx.loopHandles.get(epicId);
+        if (!loopHandle)
+            continue;
+        // Stop the loop (transitions to DONE)
+        loopHandle.stop();
+        // Kill tmux window
+        try {
+            const epicState = ctx.daemonState?.epics[epicId];
+            if (epicState) {
+                const tmuxSess = ctx.daemonState?.tmuxSession || "pit";
+                // For single-epic teardown: if this is the last window, create a
+                // placeholder window first so the session is not auto-destroyed by tmux.
+                if (singleEpic) {
+                    const windows = await getWindowList(tmuxSess);
+                    if (windows.length === 1 && windows[0] === epicState.windowName) {
+                        await createWindow(tmuxSess, "pit", ctx.projectRoot);
+                    }
+                }
+                await killWindow(tmuxSess, epicState.windowName);
+                cleaned.windows.push(epicState.windowName);
+            }
+        }
+        catch (err) {
+            // Window may already be gone - log but continue
+            logger.warn(`Failed to kill window for epic ${epicId}`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        // Remove signal file subdirectory for this epic
+        const epicSignalDir = `/tmp/pit/${ctx.sessionId}/${epicId}`;
+        try {
+            await cleanupDir(epicSignalDir);
+        }
+        catch (err) {
+            logger.warn(`Failed to remove signal dir for epic ${epicId}`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        // Remove worktree by default (unless --keep-worktrees)
+        if (!keepWorktrees && ctx.daemonState?.epics[epicId]) {
+            const epicState = ctx.daemonState.epics[epicId];
+            if (epicState.worktreePath && epicState.worktreePath.length > 0) {
+                // Check for uncommitted changes before removal
+                try {
+                    const dirty = await isWorktreeDirty(epicState.worktreePath);
+                    if (dirty) {
+                        cleaned.dirtyWorktrees.push(epicState.worktreePath);
+                    }
+                }
+                catch (err) {
+                    logger.warn(`Failed to check worktree dirty state for epic ${epicId}`, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                try {
+                    // Extract epic name from worktree path for removeWorktree call
+                    const pathParts = epicState.worktreePath.split("/");
+                    const epicName = pathParts[pathParts.length - 1];
+                    const worktreeDir = pathParts.slice(0, -1).join("/");
+                    await removeWorktree(worktreeDir, epicName);
+                    cleaned.worktrees.push(epicState.worktreePath);
+                }
+                catch (err) {
+                    logger.warn(`Failed to remove worktree for epic ${epicId}`, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+        }
+        // Remove epic from loopHandles and daemon state
+        ctx.loopHandles.delete(epicId);
+        if (ctx.daemonState) {
+            const { [epicId]: _removed, ...rest } = ctx.daemonState.epics;
+            ctx.daemonState.epics = rest;
+        }
+    }
+    // For full teardown (no singleEpic), clean up the session-level signal directory
+    if (!singleEpic) {
+        const sessionDir = `/tmp/pit/${ctx.sessionId}`;
+        cleaned.sessionDir = sessionDir;
+        try {
+            await cleanupDir(sessionDir);
+        }
+        catch (err) {
+            logger.warn(`Failed to remove session dir`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    // Persist updated state
+    if (ctx.debouncedSaver && ctx.daemonState) {
+        ctx.debouncedSaver(ctx.daemonState);
+    }
+    return { success: true, cleaned };
+}
+async function handleAdd(ctx, params) {
+    const typedParams = params;
+    // Validate epic parameter
+    if (!typedParams.epic) {
+        throw new Error("epic parameter is required");
+    }
+    // Session must be active (at least one epic was started)
+    if (!ctx.daemonState || Object.keys(ctx.daemonState.epics).length === 0) {
+        throw new Error("No active session. Use pit start to begin a session.");
+    }
+    // Epic must not already exist
+    if (ctx.daemonState.epics[typedParams.epic]) {
+        throw new Error(`Epic already running: ${typedParams.epic}`);
+    }
+    // Resolve agent type (inherit from session default if omitted)
+    const resolvedAgent = typedParams.agent ?? ctx.daemonState.agent;
+    const adapter = ctx.agentInstance ? ctx.agentInstance : await resolveAdapter(resolvedAgent);
+    // Read model from AddParams — do NOT inherit from session
+    const epicModel = typedParams.model ?? undefined;
+    // Create setup options based on daemon state (forward clearDelay/initDelay from config)
+    const setupOptions = {
+        agent: resolvedAgent,
+        epics: [typedParams.epic],
+        worktreeDir: ctx.daemonState.options.worktreeDir,
+        baseBranch: ctx.daemonState.options.baseBranch,
+        tmuxSession: ctx.daemonState.tmuxSession,
+        promptTemplate: ctx.daemonState.options.promptTemplate,
+        instructionsTemplate: ctx.daemonState.options.instructionsTemplate,
+        inlinePromptTemplate: ctx.daemonState.options.inlinePromptTemplate,
+        clearDelay: ctx.daemonState.options.clearDelay,
+        initDelay: ctx.daemonState.options.initDelay,
+        model: epicModel,
+    };
+    const sessionLogger = createLogger();
+    try {
+        // Call setupEpic to set up the new epic
+        const setupResult = await setupEpic(adapter, typedParams.epic, ctx.daemonState.sessionId, ctx.daemonState.tmuxSession, setupOptions, sessionLogger);
+        if (setupResult.status !== "ok" || !setupResult.worktreePath) {
+            throw new Error(setupResult.error || "Failed to setup epic");
+        }
+        // Start loop for new epic
+        const windowName = `epic-${typedParams.epic}`;
+        const loopHandle = startLoop({
+            epic: typedParams.epic,
+            tmuxSession: ctx.daemonState.tmuxSession,
+            windowName,
+            adapter,
+            logger: sessionLogger,
+            onStatusBarUpdate: makeStatusBarUpdater(ctx),
+        });
+        // Store LoopHandle in daemon memory
+        ctx.loopHandles.set(typedParams.epic, loopHandle);
+        // Add epic to DaemonState.epics
+        ctx.daemonState.epics[typedParams.epic] = {
+            epic: typedParams.epic,
+            state: loopHandle.state,
+            pauseReason: loopHandle.pauseReason,
+            worktreePath: setupResult.worktreePath,
+            windowName,
+            currentTicket: null,
+            ticketStartedAt: null,
+        };
+        // Set currentTicket to the first ready ticket for this epic
+        const firstTicket = await beads.ready(typedParams.epic, { cwd: ctx.projectRoot });
+        if (firstTicket) {
+            ctx.daemonState.epics[typedParams.epic].currentTicket = firstTicket.id;
+            ctx.daemonState.epics[typedParams.epic].ticketStartedAt = new Date().toISOString();
+        }
+        // Save state via debounced saver
+        if (ctx.debouncedSaver) {
+            ctx.debouncedSaver(ctx.daemonState);
+        }
+        return {
+            success: true,
+            epic: typedParams.epic,
+            windowName,
+            worktreePath: setupResult.worktreePath,
+            agent: resolvedAgent,
+        };
+    }
+    catch (error) {
+        const err = new Error(`Failed to add epic ${typedParams.epic}: ${error instanceof Error ? error.message : String(error)}`);
+        err.cause = error;
+        throw err;
+    }
+}
+// ---------------------------------------------------------------------------
+// Health handler
+// ---------------------------------------------------------------------------
+/**
+ * Handle a "health" RPC request.
+ *
+ * Checks the tmux session and each epic's window/agent liveness. Returns a
+ * structured HealthResponse. Does NOT auto-pause degraded epics — that is
+ * the job of the periodic health check (startHealthCheck).
+ */
+export async function handleHealth(ctx) {
+    const checks = {
+        tmuxSession: false,
+        epicsHealthy: 0,
+        epicsDegraded: 0,
+    };
+    const degradedReasons = [];
+    checks.tmuxSession = await sessionExists(ctx.tmuxSession);
+    if (!checks.tmuxSession) {
+        degradedReasons.push("tmux session not found");
+    }
+    if (ctx.daemonState) {
+        for (const [epicId, epicState] of Object.entries(ctx.daemonState.epics)) {
+            const windowOk = await windowExists(ctx.tmuxSession, epicState.windowName);
+            if (!windowOk) {
+                checks.epicsDegraded++;
+                degradedReasons.push(`tmux window missing for ${epicId}`);
+                continue;
+            }
+            if (epicState.state === "RUNNING") {
+                const adapter = ctx.agentInstance || (await resolveAdapter("auto"));
+                const agentOk = await adapter.verifyRunning(ctx.tmuxSession, epicState.windowName);
+                if (!agentOk) {
+                    checks.epicsDegraded++;
+                    degradedReasons.push(`agent not running for ${epicId}`);
+                    continue;
+                }
+            }
+            checks.epicsHealthy++;
+        }
+    }
+    let status;
+    if (!checks.tmuxSession) {
+        status = "unhealthy";
+    }
+    else if (degradedReasons.length > 0) {
+        status = "degraded";
+    }
+    else {
+        status = "healthy";
+    }
+    return {
+        success: true,
+        status,
+        uptime: Math.floor((Date.now() - ctx.daemonStartTime) / 1000),
+        memoryMB: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+        checks,
+        degradedReasons,
+    };
+}
+// ---------------------------------------------------------------------------
+// Shutdown handler
+// ---------------------------------------------------------------------------
+/**
+ * Handle a "shutdown" RPC request.
+ *
+ * Optionally pauses all running epics and saves state. Returns immediately
+ * so the client receives a response before the process exits. The server
+ * itself calls server.shutdown() after delivering the response.
+ */
+export async function handleShutdown(ctx, params) {
+    const typedParams = params;
+    const { pauseEpics = false } = typedParams;
+    if (pauseEpics && ctx.daemonState) {
+        for (const [epicId, epicState] of Object.entries(ctx.daemonState.epics)) {
+            const loopHandle = ctx.loopHandles.get(epicId);
+            if (loopHandle && epicState.state === "RUNNING") {
+                try {
+                    await loopHandle.machine.transition("PAUSED", "MANUAL_PAUSE", {
+                        pauseReason: "DAEMON_SHUTDOWN",
+                    });
+                    epicState.state = loopHandle.state;
+                    epicState.pauseReason = loopHandle.pauseReason;
+                }
+                catch (err) {
+                    logger.warn(`Failed to pause epic ${epicId} during shutdown`, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+        }
+        // Use saveDaemonState directly (not the debounced wrapper) to ensure state is flushed
+        // to disk before the process exits. The debounced saver has a 500ms delay that races
+        // with the subsequent process.exit(0) in the shutdown path.
+        if (ctx.daemonState) {
+            try {
+                await saveDaemonState(ctx.daemonState);
+            }
+            catch (err) {
+                logger.warn("Failed to save daemon state during shutdown", {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
+    return { success: true, message: "Daemon shutting down" };
+}
+// ---------------------------------------------------------------------------
+// Periodic health check
+// ---------------------------------------------------------------------------
+/**
+ * One iteration of the self-monitoring loop.
+ *
+ * Checks the tmux session and every epic's window/agent liveness. Degrades
+ * to PAUSED any epic whose agent has crashed. Enforces per-epic ticket
+ * timeouts when configured.
+ */
+async function periodicHealthCheck(ctx) {
+    try {
+        const tmuxOk = await sessionExists(ctx.tmuxSession);
+        if (!tmuxOk) {
+            logger.error("Daemon health check UNHEALTHY", { reason: "tmux session not found" });
+            return;
+        }
+        const degradedReasons = [];
+        if (ctx.daemonState) {
+            for (const [epicId, epicState] of Object.entries(ctx.daemonState.epics)) {
+                const windowOk = await windowExists(ctx.tmuxSession, epicState.windowName);
+                if (!windowOk) {
+                    degradedReasons.push(`tmux window missing for ${epicId}`);
+                    continue;
+                }
+                if (epicState.state === "RUNNING") {
+                    const adapter = ctx.agentInstance || (await resolveAdapter("auto"));
+                    const agentOk = await adapter.verifyRunning(ctx.tmuxSession, epicState.windowName);
+                    if (!agentOk) {
+                        degradedReasons.push(`agent not running for ${epicId}`);
+                        // Attempt one restart before giving up and pausing.
+                        let restartSucceeded = false;
+                        try {
+                            const worktreePath = ctx.daemonState.epics[epicId]?.worktreePath;
+                            const windowName = epicState.windowName;
+                            const socketPath = `/tmp/pit/${ctx.sessionId}/daemon.sock`;
+                            const env = {
+                                PIT_EPIC: epicId,
+                                PIT_SOCKET_PATH: socketPath,
+                            };
+                            const cmd = adapter.startCommand(worktreePath ?? "", env);
+                            logger.info(`[${epicId}] Agent crashed — attempting restart`, { cmd });
+                            await sendKeys(ctx.tmuxSession, windowName, cmd);
+                            await adapter.waitForReady({ timeoutMs: 10_000 });
+                            const agentOkAfterRestart = await adapter.verifyRunning(ctx.tmuxSession, windowName);
+                            if (agentOkAfterRestart) {
+                                logger.info(`[${epicId}] Agent restart succeeded`);
+                                restartSucceeded = true;
+                            }
+                            else {
+                                logger.warn(`[${epicId}] Agent restart failed — agent still not running`);
+                            }
+                        }
+                        catch (restartErr) {
+                            logger.warn(`[${epicId}] Exception during agent restart — falling through to pause`, {
+                                error: restartErr instanceof Error ? restartErr.message : String(restartErr),
+                            });
+                        }
+                        if (restartSucceeded) {
+                            continue;
+                        }
+                        const loopHandle = ctx.loopHandles.get(epicId);
+                        if (loopHandle) {
+                            try {
+                                await loopHandle.machine.transition("PAUSED", "MANUAL_PAUSE", {
+                                    pauseReason: "agent crashed (detected by health check)",
+                                });
+                                if (ctx.daemonState.epics[epicId]) {
+                                    ctx.daemonState.epics[epicId].state = "PAUSED";
+                                    ctx.daemonState.epics[epicId].pauseReason =
+                                        "agent crashed (detected by health check)";
+                                    ctx.debouncedSaver?.(ctx.daemonState);
+                                }
+                                await ringControlBell(ctx, epicState.windowName);
+                            }
+                            catch (err) {
+                                logger.error(`Failed to auto-pause degraded epic ${epicId}`, {
+                                    error: err instanceof Error ? err.message : String(err),
+                                });
+                            }
+                        }
+                        continue;
+                    }
+                    // Ticket timeout enforcement
+                    const ticketTimeoutMinutes = ctx.daemonState.options.ticketTimeout;
+                    if (ticketTimeoutMinutes !== null &&
+                        ticketTimeoutMinutes !== undefined &&
+                        epicState.ticketStartedAt) {
+                        const elapsed = Date.now() - Date.parse(epicState.ticketStartedAt);
+                        const thresholdMs = ticketTimeoutMinutes * 60 * 1000;
+                        if (elapsed > thresholdMs) {
+                            const loopHandle = ctx.loopHandles.get(epicId);
+                            if (loopHandle) {
+                                const pauseReason = `TIMEOUT: exceeded ${ticketTimeoutMinutes} minutes`;
+                                logger.warn(`[${epicId}] Ticket timeout — pausing epic`, {
+                                    elapsed: Math.floor(elapsed / 1000),
+                                    thresholdMs,
+                                    pauseReason,
+                                });
+                                try {
+                                    await loopHandle.machine.transition("PAUSED", "TICKET_TIMEOUT", {
+                                        pauseReason,
+                                    });
+                                    if (ctx.daemonState.epics[epicId]) {
+                                        ctx.daemonState.epics[epicId].state = "PAUSED";
+                                        ctx.daemonState.epics[epicId].pauseReason = pauseReason;
+                                        ctx.debouncedSaver?.(ctx.daemonState);
+                                    }
+                                    await ringControlBell(ctx, epicState.windowName);
+                                }
+                                catch (err) {
+                                    logger.error(`Failed to timeout-pause epic ${epicId}`, {
+                                        error: err instanceof Error ? err.message : String(err),
+                                    });
+                                }
+                            }
+                            continue;
+                        }
+                    }
+                }
+            }
+        }
+        if (degradedReasons.length > 0) {
+            logger.warn("Daemon health check DEGRADED", { reasons: degradedReasons });
+        }
+    }
+    catch (err) {
+        logger.error("Health check failed", { err });
+    }
+}
+/**
+ * Start the periodic self-monitoring timer (every 60 seconds).
+ *
+ * Returns the interval handle so the caller can store it in
+ * ctx.healthCheckInterval for later cancellation on shutdown.
+ */
+export function startHealthCheck(ctx) {
+    return setInterval(() => {
+        periodicHealthCheck(ctx).catch((err) => {
+            logger.error("Unhandled error in periodic health check", { err });
+        });
+    }, 60_000);
+}
+// ---------------------------------------------------------------------------
+// Status bar updater factory
+// ---------------------------------------------------------------------------
+/**
+ * Create the onStatusBarUpdate callback for startLoop().
+ *
+ * The callback is called on every state transition. It:
+ *   1. Fetches beads.progress() for the triggering epic (fails gracefully).
+ *   2. Builds a Map<string, StatusBarEpic> from all ctx.loopHandles + ctx.daemonState.
+ *   3. Calls updateStatusBar() with the new rich format.
+ *
+ * Place this in handlers.ts so it can close over DaemonContext which contains
+ * the projectRoot and tmuxSession needed for beads.progress().
+ */
+export function makeStatusBarUpdater(ctx) {
+    return async (triggeringEpic) => {
+        // 1. Fetch progress for the triggering epic
+        let triggeringProgress = null;
+        try {
+            triggeringProgress = await beads.progress(triggeringEpic, { cwd: ctx.projectRoot });
+        }
+        catch {
+            // beads unavailable — fall back to null (no progress shown)
+        }
+        // 2. Build Map<string, StatusBarEpic> from all loop handles
+        const epics = new Map();
+        for (const [epicId, loopHandle] of ctx.loopHandles.entries()) {
+            const progress = epicId === triggeringEpic ? triggeringProgress : null;
+            epics.set(epicId, {
+                state: loopHandle.state,
+                progress,
+                pauseReason: loopHandle.pauseReason,
+            });
+        }
+        // If no loop handles yet (unlikely but defensive), nothing to render
+        if (epics.size === 0)
+            return;
+        // 3. Update the tmux status bar
+        await updateStatusBar(ctx.tmuxSession, epics);
+    };
+}
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+/**
+ * Register all orchestrator handlers on the given server.
+ *
+ * Creates a clearAndReprompt function bound to ctx and registers all
+ * command handlers. The health, shutdown, and internal handlers are NOT
+ * registered here — they remain in commands/daemon.ts (shutdown needs
+ * access to the server instance and process lifecycle; health check needs
+ * the interval handle).
+ */
+export function registerOrchestratorHandlers(server, ctx) {
+    const clearAndReprompt = makeClearAndReprompt(ctx);
+    server.registerHandler("start", (params) => handleStart(ctx, params));
+    server.registerHandler("status", () => handleStatus(ctx));
+    server.registerHandler("pause", (params) => handlePause(ctx, params));
+    server.registerHandler("resume", (params) => handleResume(ctx, params, clearAndReprompt));
+    server.registerHandler("agent-idle", (params) => handleAgentIdle(ctx, params, clearAndReprompt));
+    server.registerHandler("agent-permission", (params) => handleAgentPermission(ctx, params));
+    server.registerHandler("log", (params) => handleLog(ctx, params));
+    server.registerHandler("stop", (params) => handleStop(ctx, params));
+    server.registerHandler("teardown", (params) => handleTeardown(ctx, params));
+    server.registerHandler("add", (params) => handleAdd(ctx, params));
+}
+/**
+ * Register ALL daemon handlers on the given server, including health and
+ * shutdown. This is the single entry point for commands/daemon.ts — it
+ * replaces the three separate inline registrations that previously lived
+ * there.
+ */
+export function registerAllHandlers(server, ctx) {
+    registerOrchestratorHandlers(server, ctx);
+    server.registerHandler("health", () => handleHealth(ctx));
+    server.registerHandler("shutdown", (params) => handleShutdown(ctx, params));
+}
+//# sourceMappingURL=handlers.js.map