@ouro.bot/cli 0.1.0-alpha.81 → 0.1.0-alpha.810

package/dist/heart/daemon/daemon.js

@@ -34,43 +34,475 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OuroDaemon = void 0;
+exports.messageFromHabitPokeError = messageFromHabitPokeError;
+exports.parseOrphanPidsFromPs = parseOrphanPidsFromPs;
+exports.filterPidfilePidsToActualOrphans = filterPidfilePidsToActualOrphans;
+exports.mergeUniqueOrphanPids = mergeUniqueOrphanPids;
+exports.waitForOrphanProcessesToSettle = waitForOrphanProcessesToSettle;
+exports.assertOrphanCleanupComplete = assertOrphanCleanupComplete;
+exports.drainOrphanProcessesBeforeStartup = drainOrphanProcessesBeforeStartup;
+exports.killOrphanProcesses = killOrphanProcesses;
+exports.writePidfile = writePidfile;
+exports.handleAgentSenseTurn = handleAgentSenseTurn;
+exports.handleAgentAskTurn = handleAgentAskTurn;
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const node_crypto_1 = require("node:crypto");
 const identity_1 = require("../identity");
+const agent_discovery_1 = require("./agent-discovery");
 const runtime_1 = require("../../nerves/runtime");
 const runtime_metadata_1 = require("./runtime-metadata");
 const runtime_mode_1 = require("./runtime-mode");
-const update_hooks_1 = require("./update-hooks");
+const update_hooks_1 = require("../versioning/update-hooks");
 const bundle_meta_1 = require("./hooks/bundle-meta");
+const agent_config_v2_1 = require("./hooks/agent-config-v2");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
-const update_checker_1 = require("./update-checker");
-const staged_restart_1 = require("./staged-restart");
+const update_checker_1 = require("../versioning/update-checker");
 const child_process_1 = require("child_process");
 const pending_1 = require("../../mind/pending");
-const channel_1 = require("../../mind/friends/channel");
+const agent_service_1 = require("./agent-service");
+const friends_1 = require("@ouro.bot/friends");
 const mcp_manager_1 = require("../../repertoire/mcp-manager");
+const mailbox_http_1 = require("../mailbox/mailbox-http");
+const mailbox_types_1 = require("../mailbox/mailbox-types");
+const mailbox_read_1 = require("../mailbox/mailbox-read");
+const mailbox_view_1 = require("../mailbox/mailbox-view");
+const provider_visibility_1 = require("../provider-visibility");
+const provider_binding_resolver_1 = require("../provider-binding-resolver");
+const private_runtime_1 = require("../private-runtime");
+const socket_client_1 = require("./socket-client");
+const flight_recorder_1 = require("../../arc/flight-recorder");
+const await_private_wake_1 = require("./await-private-wake");
+const habit_private_wake_1 = require("./habit-private-wake");
+const habit_parser_1 = require("../habits/habit-parser");
+const habit_runtime_state_1 = require("../habits/habit-runtime-state");
+const router_1 = require("../external-events/router");
+const habit_policy_1 = require("../../rsvp/habit-policy");
+const container_runtime_1 = require("./container-runtime");
+const habit_session_1 = require("../habits/habit-session");
+const turn_execution_lease_1 = require("../turn-execution-lease");
+const frontend_session_service_1 = require("../frontend-session-service");
+const frontend_socket_1 = require("../frontend-socket");
+const frontend_journal_1 = require("../frontend-journal");
+const frontend_approval_runtime_1 = require("../frontend-approval-runtime");
+const PIDFILE_PATH = path.join(os.homedir(), ".ouro-cli", "daemon.pids");
+/**
+ * Defense-in-depth: detect if we're running under vitest. The pidfile lives
+ * at a hardcoded path under the user's real ~/.ouro-cli/ — there's no DI
+ * seam to redirect it. So when a test creates a real OuroDaemon and calls
+ * start(), the daemon's killOrphanProcesses() reads the REAL pidfile,
+ * ps-verifies the PIDs, and SIGTERMs the production daemon. We saw this
+ * cause an outage on 2026-04-08 (alpha.265 daemon killed 93s after startup
+ * by a vitest test that called daemon.start()).
+ *
+ * Both killOrphanProcesses() and writePidfile() short-circuit under vitest
+ * to make the production pidfile sacred. Tests that need to verify these
+ * functions' behavior should use the extracted pure helpers
+ * (parseOrphanPidsFromPs, filterPidfilePidsToActualOrphans).
+ */
+function isVitestProcess() {
+    /* v8 ignore next -- defensive: process and process.argv always exist in node @preserve */
+    if (typeof process === "undefined" || !Array.isArray(process.argv))
+        return false;
+    return process.argv.some((arg) => typeof arg === "string" && arg.includes("vitest"));
+}
+function messageFromHabitPokeError(error) {
+    if (error instanceof Error)
+        return error.message;
+    /* v8 ignore next -- defensive fallback for hostile/non-Error throws from filesystem or parsers @preserve */
+    return String(error);
+}
+/**
+ * Scan `ps -eo pid,ppid,command` output for daemon-owned entry points whose
+ * parent has died (PPID reparented to init/PID 1). Returns the list of PIDs
+ * that are safe to SIGTERM — true orphans, not children of live sibling
+ * daemons running from worktrees, test suites, or other users of the harness.
+ *
+ * Exported so unit tests can exercise the filter without shelling out.
+ */
+function parseOrphanPidsFromPs(psOutput, selfPid) {
+    const orphans = [];
+    for (const line of psOutput.split("\n")) {
+        // Explicitly exclude MCP server processes — they share a harness entry
+        // point but are not daemon children and must never be killed.
+        if (line.includes("mcp-serve") || line.includes("mcp serve"))
+            continue;
+        // Match only daemon-owned JS entry points.
+        if (!line.includes("agent-entry.js")
+            && !line.includes("daemon-entry.js")
+            && !line.includes("bluebubbles/entry.js")
+            && !line.includes("mail-entry.js")
+            && !line.includes("teams-entry.js")
+            && !line.includes("a2a-entry.js")
+            && !line.includes("telegram-entry.js")
+            && !line.includes("voice-entry.js"))
+            continue;
+        // Parse `<pid> <ppid> <command...>`. ps pads these with leading spaces.
+        // Regex guarantees both groups are \d+ so parseInt can't produce NaN.
+        const match = line.trim().match(/^(\d+)\s+(\d+)\s/);
+        if (!match)
+            continue;
+        const pid = parseInt(match[1], 10);
+        const ppid = parseInt(match[2], 10);
+        if (pid === selfPid)
+            continue;
+        // CRITICAL: only kill processes whose parent is init (PID 1). A live
+        // PPID means the process belongs to another daemon instance (parallel
+        // test run, sibling worktree, another user of /tmp/ouroboros-daemon.sock).
+        // Killing those will crash unrelated harnesses — we saw this in B6
+        // when a vitest worker's daemon killed a production agent's children.
+        if (ppid !== 1)
+            continue;
+        orphans.push(pid);
+    }
+    return orphans;
+}
+/**
+ * Given a list of PIDs from the pidfile, return only those that are actual
+ * orphans (PPID reparented to init/PID 1). Protects against a polluted
+ * pidfile killing a PID that the OS has reassigned to an unrelated process.
+ *
+ * Implementation: shells out to `ps -p <csv> -o pid,ppid` for a batch lookup.
+ * Returns the empty list if ps fails — safer to skip cleanup than to
+ * wildcard-kill on a bad read.
+ *
+ * Exported for direct unit coverage.
+ */
+function filterPidfilePidsToActualOrphans(candidatePids, psRunner = runPsCheck) {
+    if (candidatePids.length === 0)
+        return [];
+    const psOutput = psRunner(candidatePids);
+    if (psOutput === null)
+        return [];
+    const survivingOrphans = [];
+    // `ps -p x,y,z -o pid,ppid` emits a header line then one row per found PID.
+    // PIDs not found (already exited) are silently omitted — which is the
+    // correct behavior for us: we only want to kill live orphans.
+    for (const line of psOutput.split("\n")) {
+        const match = line.trim().match(/^(\d+)\s+(\d+)$/);
+        if (!match)
+            continue;
+        const pid = parseInt(match[1], 10);
+        const ppid = parseInt(match[2], 10);
+        if (ppid !== 1)
+            continue;
+        if (!candidatePids.includes(pid))
+            continue;
+        survivingOrphans.push(pid);
+    }
+    return survivingOrphans;
+}
+function mergeUniqueOrphanPids(...sources) {
+    const merged = [];
+    const seen = new Set();
+    for (const source of sources) {
+        for (const pid of source) {
+            if (seen.has(pid))
+                continue;
+            seen.add(pid);
+            merged.push(pid);
+        }
+    }
+    return merged;
+}
+const ORPHAN_CLEANUP_SETTLE_TIMEOUT_MS = 5_000;
+const ORPHAN_CLEANUP_SETTLE_POLL_INTERVAL_MS = 50;
+/* v8 ignore start -- process liveness probe; pure wait behavior covered via injected deps @preserve */
+function defaultIsPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+/* v8 ignore stop */
+/* v8 ignore start -- real timer wiring; wait behavior covered via injected sleep @preserve */
+async function defaultSettleSleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+/* v8 ignore stop */
+async function waitForOrphanProcessesToSettle(pids, deps = {}) {
+    if (pids.length === 0)
+        return [];
+    const isPidAlive = deps.isPidAlive ?? defaultIsPidAlive;
+    const now = deps.now ?? Date.now;
+    const sleep = deps.sleep ?? defaultSettleSleep;
+    const timeoutMs = deps.timeoutMs ?? ORPHAN_CLEANUP_SETTLE_TIMEOUT_MS;
+    const pollIntervalMs = deps.pollIntervalMs ?? ORPHAN_CLEANUP_SETTLE_POLL_INTERVAL_MS;
+    const deadline = now() + timeoutMs;
+    let survivors = pids.filter(isPidAlive);
+    while (survivors.length > 0 && now() < deadline) {
+        await sleep(pollIntervalMs);
+        survivors = pids.filter(isPidAlive);
+    }
+    return survivors;
+}
+function assertOrphanCleanupComplete(survivingPids) {
+    if (survivingPids.length === 0)
+        return;
+    const errorReason = `refusing startup while ${survivingPids.length} orphaned Ouro processes remain: ${survivingPids.join(", ")}`;
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.orphan_cleanup_incomplete",
+        message: errorReason,
+        meta: { survivingPids },
+    });
+    throw new Error(errorReason);
+}
+const ORPHAN_CLEANUP_MAX_SIGNAL_PASSES = 8;
+async function drainOrphanProcessesBeforeStartup(socketPath = socket_client_1.DEFAULT_DAEMON_SOCKET_PATH, deps = {}) {
+    const signalOrphans = deps.signalOrphans ?? killOrphanProcesses;
+    const settleOrphans = deps.settleOrphans ?? waitForOrphanProcessesToSettle;
+    const maxSignalPasses = deps.maxSignalPasses ?? ORPHAN_CLEANUP_MAX_SIGNAL_PASSES;
+    for (let pass = 0; pass < maxSignalPasses; pass += 1) {
+        const signaledPids = signalOrphans(socketPath);
+        if (signaledPids.length === 0)
+            return;
+        const survivingPids = await settleOrphans(signaledPids);
+        assertOrphanCleanupComplete(survivingPids);
+    }
+    const errorReason = `orphan cleanup did not reach a fixed point after ${maxSignalPasses} signaling round(s)`;
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.orphan_cleanup_not_converged",
+        message: errorReason,
+        meta: { maxSignalPasses },
+    });
+    throw new Error(errorReason);
+}
+/* v8 ignore start -- shells out to ps; covered by filterPidfilePidsToActualOrphans unit tests via injected runner @preserve */
+function runPsCheck(pids) {
+    try {
+        const csv = pids.join(",");
+        return (0, child_process_1.execSync)(`ps -p ${csv} -o pid=,ppid=`, { encoding: "utf-8", timeout: 5000 });
+    }
+    catch {
+        // ps returns non-zero when none of the requested PIDs exist. Treat as
+        // "no survivors" rather than an error.
+        return "";
+    }
+}
+/* v8 ignore stop */
+/**
+ * Kill all ouro processes from the previous daemon instance using the pidfile.
+ * On startup, reads PIDs from ~/.ouro-cli/daemon.pids, kills them all, then
+ * deletes the file. The new daemon writes its own PIDs after spawning.
+ *
+ * Safety: pidfile contents are verified before being killed — each PID must
+ * be an actual orphan (PPID reparented to init/PID 1) via
+ * `filterPidfilePidsToActualOrphans`. Otherwise a polluted pidfile (written
+ * by a test, or a crashed daemon whose PIDs have since been reused by the
+ * OS) could SIGTERM unrelated processes.
+ *
+ * Falls back to ps-based scanning scoped to true orphans (PPID=1) if the
+ * pidfile doesn't exist (first run, previous daemon crashed before writing,
+ * manual cleanup). The scope is narrow on purpose — see parseOrphanPidsFromPs.
+ */
+/* v8 ignore start -- process lifecycle: uses kill/ps, tested via deployment @preserve */
+function isProductionDaemonSocketPath(socketPath) {
+    return socketPath === socket_client_1.DEFAULT_DAEMON_SOCKET_PATH;
+}
+function killOrphanProcesses(socketPath = socket_client_1.DEFAULT_DAEMON_SOCKET_PATH) {
+    if (!isProductionDaemonSocketPath(socketPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.orphan_cleanup_nonproduction_blocked",
+            message: "blocked orphan cleanup for non-production daemon socket",
+            meta: { socketPath, pidfilePath: PIDFILE_PATH },
+        });
+        return [];
+    }
+    if (isVitestProcess()) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.orphan_cleanup_test_blocked",
+            message: "blocked killOrphanProcesses from touching real pidfile under vitest",
+            meta: { pidfilePath: PIDFILE_PATH },
+        });
+        return [];
+    }
+    try {
+        let pidfileOrphans = [];
+        let scanOrphans = [];
+        // Primary: read pidfile from previous daemon
+        try {
+            const raw = fs.readFileSync(PIDFILE_PATH, "utf-8");
+            const candidates = raw.split("\n")
+                .map((s) => parseInt(s.trim(), 10))
+                .filter((n) => !isNaN(n) && n !== process.pid);
+            // Verify each candidate is an actual live orphan before killing. See
+            // docstring above for why this matters.
+            pidfileOrphans = filterPidfilePidsToActualOrphans(candidates);
+            fs.unlinkSync(PIDFILE_PATH);
+        }
+        catch {
+            // No pidfile — the ps scan below still covers true orphans.
+        }
+        // Always supplement the pidfile with the scoped ps scan. A stale or
+        // partial pidfile can otherwise kill one old daemon while leaving a
+        // sibling PPID=1 daemon alive without a socket.
+        try {
+            const result = (0, child_process_1.execSync)("ps -eo pid,ppid,command", { encoding: "utf-8", timeout: 5000 });
+            scanOrphans = parseOrphanPidsFromPs(result, process.pid);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(`could not discover orphaned Ouro processes: ${detail}`);
+        }
+        const pidsToKill = mergeUniqueOrphanPids(pidfileOrphans, scanOrphans);
+        if (pidsToKill.length > 0) {
+            for (const pid of pidsToKill) {
+                try {
+                    process.kill(pid, "SIGTERM");
+                }
+                catch { /* already exited */ }
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.orphan_cleanup",
+                message: `killed ${pidsToKill.length} orphaned ouro processes`,
+                meta: { pids: pidsToKill },
+            });
+        }
+        return pidsToKill;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.orphan_cleanup_error",
+            message: "failed to clean up orphaned ouro processes",
+            meta: { error: error instanceof Error ? error.message : String(error) },
+        });
+        throw error instanceof Error ? error : new Error(String(error));
+    }
+}
+/**
+ * Write all managed PIDs (daemon + children) to the pidfile.
+ * Called after all agents and senses are spawned.
+ */
+function writePidfile(extraPids = [], socketPath = socket_client_1.DEFAULT_DAEMON_SOCKET_PATH) {
+    if (!isProductionDaemonSocketPath(socketPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.write_pidfile_nonproduction_blocked",
+            message: "blocked production pidfile write for non-production daemon socket",
+            meta: { socketPath, pidfilePath: PIDFILE_PATH, attemptedPids: extraPids.length },
+        });
+        return;
+    }
+    if (isVitestProcess()) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.write_pidfile_test_blocked",
+            message: "blocked writePidfile from clobbering real pidfile under vitest",
+            meta: { pidfilePath: PIDFILE_PATH, attemptedPids: extraPids.length },
+        });
+        return;
+    }
+    try {
+        const pids = [process.pid, ...extraPids].filter(Boolean);
+        fs.mkdirSync(path.dirname(PIDFILE_PATH), { recursive: true });
+        fs.writeFileSync(PIDFILE_PATH, pids.join("\n") + "\n", "utf-8");
+    }
+    catch { /* best effort */ }
+}
+function readSocketIdentity(socketPath) {
+    try {
+        const stats = fs.lstatSync(socketPath);
+        return {
+            dev: stats.dev,
+            ino: stats.ino,
+            ctimeMs: stats.ctimeMs,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function sameSocketIdentity(left, right) {
+    if (!left || !right)
+        return false;
+    return left.dev === right.dev && left.ino === right.ino && left.ctimeMs === right.ctimeMs;
+}
 function buildWorkerRows(snapshots) {
     return snapshots.map((snapshot) => ({
         agent: snapshot.name,
         worker: snapshot.channel,
+        autoStart: snapshot.autoStart ?? true,
         status: snapshot.status,
         pid: snapshot.pid,
         restartCount: snapshot.restartCount,
         startedAt: snapshot.startedAt,
+        lastExitCode: snapshot.lastExitCode ?? null,
+        lastSignal: snapshot.lastSignal ?? null,
+        errorReason: snapshot.errorReason ?? null,
+        fixHint: snapshot.fixHint ?? null,
     }));
 }
+function unhealthySenseRows(senses) {
+    return senses.filter((row) => {
+        if (!row.enabled)
+            return false;
+        if (row.status === "disabled" || row.status === "not_attached")
+            return false;
+        if (row.status === "interactive" || row.status === "running")
+            return false;
+        return true;
+    });
+}
+function isParkedWorker(row) {
+    return row.autoStart === false && row.status === "stopped";
+}
+function unhealthyWorkerRows(workers) {
+    return workers.filter((row) => !isParkedWorker(row) && row.status !== "running");
+}
+function unhealthyHealthChecks(healthChecks) {
+    return healthChecks.filter((row) => row.status !== "ok");
+}
+function overviewHealth(workers, senses, healthChecks = []) {
+    if (unhealthyWorkerRows(workers).length > 0)
+        return "warn";
+    if (unhealthySenseRows(senses).length > 0)
+        return "warn";
+    if (unhealthyHealthChecks(healthChecks).length > 0)
+        return "warn";
+    return "ok";
+}
 function formatStatusSummary(payload) {
-    if (payload.overview.workerCount === 0 && payload.overview.senseCount === 0) {
+    if (payload.overview.workerCount === 0 && payload.overview.senseCount === 0 && (payload.healthChecks ?? []).length === 0) {
         return "no managed agents";
     }
-    const rows = [
-        ...payload.workers.map((row) => `${row.agent}/${row.worker}:${row.status}`),
-        ...payload.senses
-            .filter((row) => row.enabled)
-            .map((row) => `${row.agent}/${row.sense}:${row.status}`),
+    const degraded = [
+        ...unhealthyWorkerRows(payload.workers)
+            .map((row) => `worker:${row.agent}/${row.worker}:${row.status}`),
+        ...unhealthySenseRows(payload.senses)
+            .map((row) => `sense:${row.agent}/${row.sense}:${row.status}`),
+        ...(payload.healthChecks ?? [])
+            .filter((row) => row.status !== "ok")
+            .map((row) => `health-check:${row.name}:${row.status}`),
     ];
-    const detail = rows.length > 0 ? `\titems=${rows.join(",")}` : "";
+    const detail = degraded.length > 0 ? `\tdegraded=${degraded.join(",")}` : "";
+    if (!detail) {
+        const rows = [
+            ...payload.workers.map((row) => `${row.agent}/${row.worker}:${row.status}`),
+            ...payload.senses
+                .filter((row) => row.enabled)
+                .map((row) => `${row.agent}/${row.sense}:${row.status}`),
+        ];
+        const items = rows.length > 0 ? `\titems=${rows.join(",")}` : "";
+        return `daemon=${payload.overview.daemon}\tworkers=${payload.overview.workerCount}\tsenses=${payload.overview.senseCount}\thealth=${payload.overview.health}${items}`;
+    }
     return `daemon=${payload.overview.daemon}\tworkers=${payload.overview.workerCount}\tsenses=${payload.overview.senseCount}\thealth=${payload.overview.health}${detail}`;
 }
 function parseIncomingCommand(raw) {
@@ -90,6 +522,94 @@ function parseIncomingCommand(raw) {
     }
     return parsed;
 }
+function isValidSenseReviveCommand(command) {
+    return typeof command.agent === "string"
+        && typeof command.sense === "string"
+        && typeof command.reason === "string";
+}
+function isValidTaskPokeCommand(command) {
+    return typeof command.agent === "string"
+        && command.agent.trim().length > 0
+        && typeof command.taskId === "string"
+        && command.taskId.trim().length > 0;
+}
+function isValidHabitPokeCommand(command) {
+    return typeof command.agent === "string"
+        && command.agent.trim().length > 0
+        && typeof command.habitName === "string"
+        && command.habitName.trim().length > 0;
+}
+function isValidHabitProbeCommand(command) {
+    return typeof command.agent === "string"
+        && command.agent.trim().length > 0
+        && typeof command.habitName === "string"
+        && command.habitName.trim().length > 0
+        && (command.noSend === undefined || command.noSend === true);
+}
+function taskIdFromTaskPokePrivateWakeCommand(command) {
+    if (command.kind !== "private.wake" || command.triggerSource !== "task-poke")
+        return null;
+    const taskRef = command.originRefs?.find((ref) => ref.kind === "task" && typeof ref.id === "string");
+    if (!taskRef || typeof taskRef.id !== "string")
+        return null;
+    const trimmed = taskRef.id.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+/**
+ * Handle agent.senseTurn command: runs a full agent turn via the daemon process.
+ * Dynamic import lazy-loads shared-turn. Hot-reload works because ouro dev
+ * restarts the daemon process (fresh module cache).
+ */
+async function handleAgentSenseTurn(command, runtime) {
+    return (0, turn_execution_lease_1.withTurnExecutionLease)(async () => {
+        try {
+            const { setAgentName } = await Promise.resolve().then(() => __importStar(require("../identity")));
+            setAgentName(command.agent);
+            const { runSenseTurn } = await Promise.resolve().then(() => __importStar(require("../../senses/shared-turn")));
+            const result = await runSenseTurn({
+                agentName: command.agent,
+                channel: command.channel,
+                sessionKey: command.sessionKey,
+                friendId: command.friendId,
+                userMessage: command.message,
+                ...(runtime?.socketPath ? { toolContext: { daemonSocketPath: runtime.socketPath } } : {}),
+                // Per-turn, per-agent runtime MCP injection (e.g. Workbench's ouro_workbench).
+                // Scoped to THIS turn only — never stored as module state, so a concurrent
+                // turn for a different agent cannot inherit these servers.
+                ...(command.runtimeMcp ? { runtimeMcpServers: command.runtimeMcp } : {}),
+            });
+            return {
+                ok: true,
+                message: result.response,
+                data: { ponderDeferred: result.ponderDeferred },
+            };
+        }
+        catch (error) {
+            /* v8 ignore next -- branch: String(error) fallback only for non-Error throws @preserve */
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: `sense turn failed: ${errorMessage}` };
+        }
+    });
+}
+async function handleAgentAskTurn(command, runtime) {
+    /* v8 ignore start -- ask command parameter defaults are legacy MCP compatibility; send_message shares the primary path @preserve */
+    const question = typeof command.question === "string" ? command.question : "";
+    if (!question.trim())
+        return { ok: false, error: "Missing required parameter: question" };
+    const channel = typeof command.channel === "string" && command.channel.trim() ? command.channel.trim() : "mcp";
+    const sessionKey = typeof command.sessionKey === "string" && command.sessionKey.trim()
+        ? command.sessionKey.trim()
+        : `agent-ask:${command.friendId}`;
+    /* v8 ignore stop */
+    return handleAgentSenseTurn({
+        kind: "agent.senseTurn",
+        agent: command.agent,
+        friendId: command.friendId,
+        channel,
+        sessionKey,
+        message: question,
+    }, runtime);
+}
 class OuroDaemon {
     socketPath;
     processManager;
@@ -98,7 +618,33 @@ class OuroDaemon {
     router;
     senseManager;
     bundlesRoot;
+    mode;
     server = null;
+    mailboxServer = null;
+    frontendSocketServer = null;
+    socketIdentity = null;
+    senseAutostartTimer = null;
+    externalEventReconcileTimer = null;
+    externalEventReconcileRunning = false;
+    constructedAtMs = Date.now();
+    mailboxServerFactory;
+    frontendSocketPath;
+    frontendSessionService;
+    frontendSocketServerFactory;
+    privateRuntimePolicyDeps;
+    onStopCommandComplete;
+    externalEventRoot;
+    privilegedEventSpoolRoot;
+    privilegedEventScanner;
+    rsvpHabitRunner;
+    nativeHabitRunner;
+    nativeHabitMatch;
+    nativeHabitClaims = new Set();
+    authenticatedSchedulerPokes = new WeakMap();
+    schedulerFireVerifier;
+    schedulerFireConsumer;
+    orphanStartupDrain;
+    externalEventSourceReadiness;
     constructor(options) {
         this.socketPath = options.socketPath;
         this.processManager = options.processManager;
@@ -107,6 +653,126 @@ class OuroDaemon {
         this.router = options.router;
         this.senseManager = options.senseManager ?? null;
         this.bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+        this.mode = options.mode ?? "production";
+        this.mailboxServerFactory = options.mailboxServerFactory ?? this.createDefaultMailboxServer.bind(this);
+        this.frontendSocketPath = options.frontendSocketPath ?? (0, frontend_socket_1.frontendSocketPathForDaemon)(this.socketPath);
+        /* v8 ignore next -- path-only default adapter; frontend service tests inject and verify the same root contract @preserve */
+        const frontendAgentRoot = (agent) => path.join(this.bundlesRoot, `${agent}.ouro`);
+        this.frontendSessionService = options.frontendSessionService ?? new frontend_session_service_1.FrontendSessionService({
+            journal: new frontend_journal_1.FrontendJournalStore({ agentRoot: frontendAgentRoot }),
+            authority: (0, frontend_approval_runtime_1.createFrontendApprovalRuntime)({
+                agentRoot: frontendAgentRoot,
+                settleApproval: frontend_approval_runtime_1.settleFrontendApproval,
+            }),
+        });
+        this.frontendSocketServerFactory = options.frontendSocketServerFactory ?? frontend_socket_1.startFrontendSocketServer;
+        this.privateRuntimePolicyDeps = options.privateRuntimePolicyDeps ?? {};
+        this.onStopCommandComplete = options.onStopCommandComplete ?? null;
+        this.externalEventRoot = options.externalEventRoot ?? null;
+        this.privilegedEventSpoolRoot = options.privilegedEventSpoolRoot ?? "/run/ouro-events";
+        this.privilegedEventScanner = options.privilegedEventScanner ?? router_1.scanPrivilegedEventSpool;
+        this.rsvpHabitRunner = options.rsvpHabitRunner;
+        this.nativeHabitRunner = options.nativeHabitRunner;
+        this.nativeHabitMatch = options.nativeHabitMatch;
+        this.schedulerFireVerifier = options.schedulerFireVerifier;
+        this.schedulerFireConsumer = options.schedulerFireConsumer;
+        this.orphanStartupDrain = options.orphanStartupDrain ?? drainOrphanProcessesBeforeStartup;
+        this.externalEventSourceReadiness = options.externalEventSourceReadiness ?? (async (agent, source) => {
+            const { ensureSanctuarySourceRuntimeReady } = await Promise.resolve().then(() => __importStar(require("../../senses/sanctuary-runtime")));
+            await ensureSanctuarySourceRuntimeReady(agent, source);
+        });
+    }
+    /* v8 ignore start -- default mailbox server wiring: production-only path, tests inject mailboxServerFactory stub instead. startMailboxHttpServer itself has full coverage in mailbox-http.test.ts @preserve */
+    createDefaultMailboxServer() {
+        return (0, mailbox_http_1.startMailboxHttpServer)({
+            host: "127.0.0.1",
+            port: mailbox_types_1.MAILBOX_DEFAULT_PORT,
+            bundlesRoot: this.bundlesRoot,
+            readMachineState: () => (0, mailbox_read_1.readMailboxMachineState)({ bundlesRoot: this.bundlesRoot }),
+            readMachineView: ({ machine }) => {
+                const overview = this.buildStatusPayload().overview;
+                return (0, mailbox_view_1.buildMailboxMachineView)({
+                    machine,
+                    daemon: {
+                        status: overview.daemon,
+                        health: overview.health,
+                        mode: overview.mode,
+                        socketPath: overview.socketPath,
+                        mailboxUrl: overview.mailboxUrl,
+                        entryPath: overview.entryPath,
+                        workerCount: overview.workerCount,
+                        senseCount: overview.senseCount,
+                    },
+                });
+            },
+            readAgentState: (agentName) => (0, mailbox_read_1.readMailboxAgentState)(agentName, { bundlesRoot: this.bundlesRoot }),
+            readAgentView: (agentName) => {
+                const agent = (0, mailbox_read_1.readMailboxAgentState)(agentName, { bundlesRoot: this.bundlesRoot });
+                return (0, mailbox_view_1.buildMailboxAgentView)({
+                    agent,
+                    viewer: { kind: "human" },
+                });
+            },
+        });
+    }
+    /* v8 ignore stop */
+    buildStatusPayload() {
+        const snapshots = this.processManager.listAgentSnapshots();
+        const workers = buildWorkerRows(snapshots);
+        const senses = this.senseManager?.listSenseRows() ?? [];
+        const healthChecks = this.overlaySchedulerHealth(this.healthMonitor.getLastResults?.() ?? []);
+        const repoRoot = (0, identity_1.getRepoRoot)();
+        const sync = (0, agent_discovery_1.listBundleSyncRows)({ bundlesRoot: this.bundlesRoot });
+        const agents = (0, agent_discovery_1.listAllBundleAgents)({ bundlesRoot: this.bundlesRoot });
+        const providerAgents = (0, agent_discovery_1.listEnabledBundleAgents)({ bundlesRoot: this.bundlesRoot });
+        const providers = providerAgents.flatMap((agentName) => (0, provider_visibility_1.providerVisibilityStatusRows)((0, provider_visibility_1.buildAgentProviderVisibility)({
+            agentName,
+            agentRoot: path.join(this.bundlesRoot, `${agentName}.ouro`),
+        })));
+        const externalEvents = (0, router_1.listExternalEventStatus)(this.externalEventRoot ?? (0, router_1.getExternalEventRoot)());
+        const mailboxUrl = this.mailboxServer?.origin ?? "http://127.0.0.1:0";
+        return {
+            overview: {
+                daemon: "running",
+                health: overviewHealth(workers, senses, healthChecks),
+                socketPath: this.socketPath,
+                mailboxUrl,
+                outlookUrl: mailboxUrl,
+                ...(0, runtime_metadata_1.getRuntimeMetadata)(),
+                workerCount: workers.length,
+                senseCount: senses.length,
+                entryPath: path.join(repoRoot, "dist", "heart", "daemon", "daemon-entry.js"),
+                mode: (0, runtime_mode_1.detectRuntimeMode)(repoRoot),
+            },
+            workers,
+            senses,
+            ...(healthChecks.length > 0 ? { healthChecks } : {}),
+            sync,
+            agents,
+            ...(providers.length > 0 ? { providers } : {}),
+            ...(externalEvents.length > 0 ? { externalEvents } : {}),
+        };
+    }
+    overlaySchedulerHealth(healthChecks) {
+        const degradedJobs = this.scheduler.listDegradedJobs?.() ?? [];
+        if (degradedJobs.length === 0)
+            return healthChecks;
+        const cronHealth = {
+            name: "cron-health",
+            status: "warn",
+            message: `cron jobs degraded; timer fallback active: ${degradedJobs
+                .map((job) => `${job.id} (${job.reason})`)
+                .join(", ")}`,
+        };
+        const next = healthChecks.map((check) => ({ ...check }));
+        const existingIndex = next.findIndex((check) => check.name === "cron-health");
+        if (existingIndex === -1) {
+            next.push(cronHealth);
+        }
+        else {
+            next[existingIndex] = cronHealth;
+        }
+        return next;
     }
     async start() {
         if (this.server)
@@ -117,65 +783,201 @@ class OuroDaemon {
             message: "starting daemon server",
             meta: { socketPath: this.socketPath },
         });
+        try {
+            await this.startInner();
+        }
+        catch (err) {
+            // Emit a paired terminating event (`_error`) so the nerves audit's
+            // start_end_pairing rule is satisfied when startup throws mid-sequence
+            // and `stop()` (which emits `server_end`) is never called.
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.server_error",
+                message: "daemon start failed",
+                meta: {
+                    error: err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err),
+                },
+            });
+            throw err;
+        }
+    }
+    async startInner() {
+        const containerPolicy = (0, container_runtime_1.readContainerRuntimePolicy)();
         // Register update hooks and apply pending updates before starting agents
         (0, update_hooks_1.registerUpdateHook)(bundle_meta_1.bundleMetaHook);
+        (0, update_hooks_1.registerUpdateHook)(agent_config_v2_1.agentConfigV2Hook);
         const currentVersion = (0, bundle_manifest_1.getPackageVersion)();
-        await (0, update_hooks_1.applyPendingUpdates)(this.bundlesRoot, currentVersion);
+        if (containerPolicy?.updates !== "disabled")
+            await (0, update_hooks_1.applyPendingUpdates)(this.bundlesRoot, currentVersion);
         // Start periodic update checker (polls npm registry every 30 minutes)
-        const bundlesRoot = this.bundlesRoot;
-        const daemon = this;
-        (0, update_checker_1.startUpdateChecker)({
-            currentVersion,
-            deps: {
-                distTag: "alpha",
-                fetchRegistryJson: /* v8 ignore next -- integration: real HTTP fetch @preserve */ async () => {
-                    const res = await fetch("https://registry.npmjs.org/@ouro.bot/cli");
-                    return res.json();
-                },
-            },
-            onUpdate: /* v8 ignore start -- integration: real npm install + process spawn @preserve */ async (result) => {
-                if (!result.latestVersion)
-                    return;
-                await (0, staged_restart_1.performStagedRestart)(result.latestVersion, {
-                    execSync: (cmd) => (0, child_process_1.execSync)(cmd, { stdio: "inherit" }),
-                    spawnSync: child_process_1.spawnSync,
-                    resolveNewCodePath: (_version) => {
-                        try {
-                            const resolved = (0, child_process_1.execSync)(`node -e "console.log(require.resolve('@ouro.bot/cli/package.json'))"`, { encoding: "utf-8" }).trim();
-                            return resolved ? path.dirname(resolved) : null;
-                        }
-                        catch {
-                            return null;
-                        }
+        // Skip in dev mode — dev builds should not auto-update from npm
+        if (this.mode === "dev" || containerPolicy?.updates === "disabled") {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.update_checker_skip",
+                message: "skipping update checker in dev mode",
+                meta: { reason: this.mode === "dev" ? "dev mode" : "container policy" },
+            });
+        }
+        else {
+            (0, update_checker_1.startUpdateChecker)({
+                currentVersion,
+                deps: {
+                    distTag: update_checker_1.CLI_UPDATE_DIST_TAG,
+                    /* v8 ignore start -- integration: real HTTP fetch @preserve */
+                    fetchRegistryJson: async () => {
+                        const res = await fetch("https://registry.npmjs.org/@ouro.bot/cli");
+                        return res.json();
                     },
-                    gracefulShutdown: () => daemon.stop(),
-                    nodePath: process.execPath,
-                    bundlesRoot,
-                });
-            },
-            /* v8 ignore stop */
-        });
-        // Pre-initialize MCP connections so they're ready for the first command (non-blocking)
-        /* v8 ignore next -- catch callback: getSharedMcpManager logs errors internally @preserve */
-        (0, mcp_manager_1.getSharedMcpManager)().catch(() => { });
-        await this.processManager.startAutoStartAgents();
-        await this.senseManager?.startAutoStartSenses();
+                    /* v8 ignore stop */
+                },
+            });
+        }
+        // MCP connections are lazily initialized per-agent during senseTurn
+        // (daemon manages multiple agents; agent identity must be set before loading MCP config)
+        await this.orphanStartupDrain(this.socketPath);
+        await this.openCommandSocket();
+        await this.reconcileExternalEvents();
+        this.externalEventReconcileTimer = setInterval(() => {
+            void this.reconcileExternalEvents();
+        }, 1_000);
+        this.externalEventReconcileTimer.unref?.();
+        this.triggerAutoStartAgents();
+        this.triggerAutoStartSensesWhenAgentsSettled();
+        // Write all managed PIDs to disk so the next daemon can clean up
+        /* v8 ignore start -- pidfile write: collects PIDs from process managers @preserve */
+        const agentPids = this.processManager.listAgentSnapshots().map((s) => s.pid).filter((p) => p !== null);
+        const sensePids = this.senseManager?.listManagedPids?.() ?? [];
+        writePidfile([...agentPids, ...sensePids], this.socketPath);
+        /* v8 ignore stop */
         this.scheduler.start?.();
         await this.scheduler.reconcile?.();
         await this.drainPendingBundleMessages();
         await this.drainPendingSenseMessages();
+        // startInner is only reachable when this.server is null (guarded in
+        // start()), and stop() nulls out this.mailboxServer alongside this.server,
+        // so mailboxServer is guaranteed unset here — no need for a guard.
+        try {
+            this.mailboxServer = await this.mailboxServerFactory();
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.mailbox_start_failed",
+                message: `Mailbox server failed to start: ${String(error)}`,
+                meta: { port: mailbox_types_1.MAILBOX_DEFAULT_PORT },
+            });
+        }
+        try {
+            this.frontendSocketServer = await this.frontendSocketServerFactory({
+                socketPath: this.frontendSocketPath,
+                service: this.frontendSessionService,
+            });
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.frontend_socket_start_failed",
+                message: `Frontend socket failed to start: ${String(error)}`,
+                meta: { socketPath: this.frontendSocketPath },
+            });
+        }
+    }
+    triggerAutoStartAgents() {
+        if (this.processManager.triggerAutoStartAgents) {
+            this.processManager.triggerAutoStartAgents();
+            return;
+        }
+        void this.processManager.startAutoStartAgents().catch((error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.agent_autostart_error",
+                message: "agent autostart failed after daemon socket opened",
+                meta: { error: error instanceof Error ? error.message : String(error) },
+            });
+        });
+    }
+    triggerAutoStartSenses() {
+        /* v8 ignore next -- defensive: callers already check senseManager before delegating here @preserve */
+        if (!this.senseManager)
+            return;
+        if (this.senseManager.triggerAutoStartSenses) {
+            this.senseManager.triggerAutoStartSenses();
+            return;
+        }
+        void this.senseManager.startAutoStartSenses().catch((error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.sense_autostart_error",
+                message: "sense autostart failed after daemon socket opened",
+                meta: { error: error instanceof Error ? error.message : String(error) },
+            });
+        });
+    }
+    triggerAutoStartSensesWhenAgentsSettled() {
+        if (!this.senseManager)
+            return;
+        const waitingOnAgents = this.processManager.listAgentSnapshots()
+            .some((snapshot) => snapshot.status === "starting");
+        if (!waitingOnAgents) {
+            this.triggerAutoStartSenses();
+            return;
+        }
+        this.senseAutostartTimer = setTimeout(() => {
+            this.senseAutostartTimer = null;
+            this.triggerAutoStartSensesWhenAgentsSettled();
+        }, 250);
+    }
+    async openCommandSocket() {
         if (fs.existsSync(this.socketPath)) {
             fs.unlinkSync(this.socketPath);
         }
-        this.server = net.createServer((connection) => {
+        // allowHalfOpen: true lets the server keep its writable side open after
+        // the client sends FIN. Without this, when a client calls `client.end()`
+        // after writing a command, node closes the server's writable side
+        // automatically — so a long-running response (like an agent.senseTurn
+        // LLM turn that takes 5+ seconds) never reaches the client. The
+        // socket-client fix in #303/#334 also removed client.end() on the
+        // sending side, but this option is defense in depth: even if a future
+        // caller half-closes, the server still writes its response correctly.
+        this.server = net.createServer({ allowHalfOpen: true }, (connection) => {
             let raw = "";
             let responded = false;
+            /* v8 ignore start — connection error handler requires real socket error @preserve */
+            connection.on("error", (err) => {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.connection_error",
+                    message: "socket connection error",
+                    meta: { error: err.message, code: err.code ?? null },
+                });
+            });
+            /* v8 ignore stop */
             const flushResponse = async () => {
                 if (responded)
                     return;
                 responded = true;
                 const response = await this.handleRawPayload(raw);
-                connection.end(response);
+                try {
+                    connection.end(response);
+                    /* v8 ignore start — EPIPE catch requires real socket disconnect @preserve */
+                }
+                catch (err) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "daemon",
+                        event: "daemon.connection_end_error",
+                        message: "failed to send response to client (EPIPE)",
+                        meta: { error: err instanceof Error ? err.message : String(err) },
+                    });
+                }
+                /* v8 ignore stop */
             };
             connection.on("data", (chunk) => {
                 raw += chunk.toString("utf-8");
@@ -188,7 +990,23 @@ class OuroDaemon {
         const server = this.server;
         await new Promise((resolve, reject) => {
             server.once("error", reject);
-            server.listen(this.socketPath, () => resolve());
+            server.listen(this.socketPath, () => {
+                // Replace the one-time error listener with a persistent one after successful listen
+                server.removeAllListeners("error");
+                this.socketIdentity = readSocketIdentity(this.socketPath);
+                /* v8 ignore start — server error after listen requires real socket race condition @preserve */
+                server.on("error", (err) => {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "error",
+                        component: "daemon",
+                        event: "daemon.server_error",
+                        message: "daemon server error after listen",
+                        meta: { error: err.message, code: err.code ?? null },
+                    });
+                });
+                /* v8 ignore stop */
+                resolve();
+            });
         });
     }
     async drainPendingBundleMessages() {
@@ -240,7 +1058,7 @@ class OuroDaemon {
         }
     }
     /** Drains per-sense pending dirs for always-on senses across all agents. */
-    static ALWAYS_ON_SENSES = new Set((0, channel_1.getAlwaysOnSenseNames)());
+    static ALWAYS_ON_SENSES = new Set((0, friends_1.getAlwaysOnSenseNames)());
     async drainPendingSenseMessages() {
         if (!fs.existsSync(this.bundlesRoot))
             return;
@@ -327,26 +1145,114 @@ class OuroDaemon {
         }
     }
     async stop() {
+        // Must be named `_end` (not `_stop`) to satisfy the nerves audit's
+        // start/end pairing rule — see src/nerves/coverage/audit-rules.ts.
+        // This is the counterpart to `daemon.server_start` emitted at line 480.
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
-            event: "daemon.server_stop",
+            event: "daemon.server_end",
             message: "stopping daemon server",
             meta: { socketPath: this.socketPath },
         });
+        this.frontendSessionService.cancelAllTurns();
+        if (this.frontendSocketServer) {
+            await this.frontendSocketServer.stop();
+            this.frontendSocketServer = null;
+        }
+        this.frontendSessionService.close?.();
         (0, update_checker_1.stopUpdateChecker)();
         (0, mcp_manager_1.shutdownSharedMcpManager)();
         this.scheduler.stop?.();
-        await this.processManager.stopAll();
-        await this.senseManager?.stopAll();
+        this.healthMonitor.stopPeriodicChecks?.();
+        if (this.senseAutostartTimer) {
+            clearTimeout(this.senseAutostartTimer);
+            this.senseAutostartTimer = null;
+        }
+        if (this.externalEventReconcileTimer) {
+            clearInterval(this.externalEventReconcileTimer);
+            this.externalEventReconcileTimer = null;
+        }
+        const workerStopTasks = [Promise.resolve().then(() => this.processManager.stopAll())];
+        if (this.senseManager) {
+            workerStopTasks.push(Promise.resolve().then(() => this.senseManager.stopAll()));
+        }
+        const workerStopResults = await Promise.allSettled(workerStopTasks);
+        const workerStopFailures = workerStopResults.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
         if (this.server) {
-            await new Promise((resolve) => {
-                this.server?.close(() => resolve());
-            });
+            // DO NOT `await` server.close() here. server.close() resolves only
+            // after every open connection has closed. When stop() is invoked
+            // from the daemon.stop command handler, the calling client's
+            // connection is STILL open — its flushResponse() is currently
+            // awaiting THIS function. Awaiting close() creates a deadlock:
+            //
+            //   client → flushResponse → handleRawPayload → daemon.stop case
+            //   → stop() → await server.close() (waits for client's connection)
+            //   → client's connection waits for flushResponse to call
+            //     connection.end() → DEADLOCK
+            //
+            // Both processes sit in kevent forever. Verified live on
+            // 2026-04-08: alpha.268 daemon hung at `daemon.server_end` log
+            // line for 5+ minutes after a client sent daemon.stop, while the
+            // client (alpha.270 ouro up) hung waiting for the response.
+            //
+            // This regressed when #303/#334/#339 stopped half-closing the
+            // client socket and switched the server to allowHalfOpen: true.
+            // Previously, the client called .end() after writing its command,
+            // which (with allowHalfOpen: false) caused node to auto-tear-down
+            // the server's writable side — incidentally unblocking
+            // server.close() before the response was sent. The half-close
+            // breakage masked this deadlock; the fix exposed it.
+            //
+            // Solution: fire close() and let it complete asynchronously. Once
+            // stop() returns, the daemon.stop case returns its response,
+            // flushResponse() calls connection.end(response), the connection
+            // closes, and server.close()'s pending callback fires. The event
+            // loop drains and the daemon exits cleanly.
+            this.server.close();
             this.server = null;
         }
-        if (fs.existsSync(this.socketPath)) {
+        if (this.mailboxServer) {
+            await this.mailboxServer.stop();
+            this.mailboxServer = null;
+        }
+        const socketPathExists = fs.existsSync(this.socketPath);
+        const currentSocketIdentity = socketPathExists ? readSocketIdentity(this.socketPath) : null;
+        if (sameSocketIdentity(this.socketIdentity, currentSocketIdentity)) {
             fs.unlinkSync(this.socketPath);
         }
+        else if (socketPathExists) {
+            const expectedSocketIdentity = { dev: null, ino: null, ctimeMs: null, ...this.socketIdentity };
+            const actualSocketIdentity = { dev: null, ino: null, ctimeMs: null, ...currentSocketIdentity };
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.socket_cleanup_skipped",
+                message: "skipped daemon socket cleanup because the socket path no longer belongs to this daemon",
+                meta: {
+                    socketPath: this.socketPath,
+                    expectedDev: expectedSocketIdentity.dev,
+                    expectedIno: expectedSocketIdentity.ino,
+                    expectedCtimeMs: expectedSocketIdentity.ctimeMs,
+                    actualDev: actualSocketIdentity.dev,
+                    actualIno: actualSocketIdentity.ino,
+                    actualCtimeMs: actualSocketIdentity.ctimeMs,
+                },
+            });
+        }
+        this.socketIdentity = null;
+        if (workerStopFailures.length > 0) {
+            const errorReason = `daemon shutdown could not drain ${workerStopFailures.length} managed worker group(s)`;
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.worker_shutdown_error",
+                message: errorReason,
+                meta: {
+                    failures: workerStopFailures.map((error) => error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error rejection @preserve */ String(error)),
+                },
+            });
+            throw new AggregateError(workerStopFailures, errorReason);
+        }
     }
     async handleRawPayload(raw) {
         try {
@@ -368,32 +1274,654 @@ class OuroDaemon {
             message: "handling daemon command",
             meta: { kind: command.kind },
         });
+        try {
+            return await this.handleCommandInner(command);
+            /* v8 ignore start — command error catch tested in daemon-command-error.test; instanceof branches defensive @preserve */
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.command_error",
+                message: "unexpected error handling daemon command",
+                meta: {
+                    kind: command.kind,
+                    error: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack ?? null : null,
+                },
+            });
+            throw error;
+        }
+        /* v8 ignore stop */
+    }
+    hasManagedPrivateRuntime(agent) {
+        return this.processManager.listAgentSnapshots().some((snapshot) => snapshot.name === agent && snapshot.channel === "private-runtime");
+    }
+    buildPrivateRuntimeWakeRequest(command) {
+        if (command.kind === "inner.wake") {
+            return {
+                agent: command.agent,
+                origin: "daemon.private.wake",
+                reason: "legacy inner.wake compatibility alias",
+                providerLane: "inner",
+                triggerSource: "legacy",
+                budgetClass: "interactive",
+                originRefs: [{ kind: "daemon-command", id: "inner.wake" }],
+            };
+        }
+        const hasNoSendCapability = command.originRefs?.some((ref) => ref.kind === "capability" && ref.id === "no-send") ?? false;
+        if ((command.noSend === true) !== hasNoSendCapability) {
+            throw new Error("private-runtime no-send capability does not match its bound origin reference");
+        }
+        return {
+            agent: command.agent,
+            origin: "daemon.private.wake",
+            reason: command.reason ?? "manual private-runtime wake",
+            providerLane: "inner",
+            triggerSource: command.triggerSource ?? "manual",
+            budgetClass: command.budgetClass ?? "interactive",
+            ...(command.idempotencyKey ? { idempotencyKey: command.idempotencyKey } : {}),
+            originRefs: command.originRefs ?? [{ kind: "daemon-command", id: "private.wake" }],
+        };
+    }
+    buildAwaitPrivateWakeCommand(command) {
+        return (0, await_private_wake_1.buildAwaitPrivateWakeCommand)({
+            agent: command.agent,
+            awaitName: command.awaitName,
+            triggerSource: "await-poke",
+        });
+    }
+    buildTaskPokePrivateWakeCommand(command, receiptId) {
+        return {
+            kind: "private.wake",
+            agent: command.agent,
+            reason: `task poke ${command.taskId}`,
+            triggerSource: "task-poke",
+            budgetClass: "scheduled",
+            idempotencyKey: `task-poke:${command.agent}:${command.taskId}:${receiptId}`,
+            originRefs: [
+                { kind: "task", id: command.taskId },
+                { kind: "queue-receipt", id: receiptId },
+                { kind: "daemon-command", id: "task.poke" },
+            ],
+        };
+    }
+    buildExternalEventPrivateWakeCommand(command, receiptId, generation, attemptCount) {
+        return {
+            kind: "private.wake",
+            agent: command.agent,
+            reason: `external event ${command.source}/${command.eventType}`,
+            triggerSource: "external-event",
+            budgetClass: "interactive",
+            idempotencyKey: `external-event:${command.agent}:${command.source}:${command.eventId}:generation:${generation}:attempt:${attemptCount}`,
+            originRefs: [
+                { kind: "external-event", id: command.eventId, source: command.source, eventType: command.eventType },
+                { kind: "queue-receipt", id: receiptId },
+                { kind: "daemon-command", id: "external.event.submit" },
+            ],
+        };
+    }
+    resolveHabitDispatch(options) {
+        const agentRoot = path.join(this.bundlesRoot, `${options.agent}.ouro`);
+        const habitPath = path.join(agentRoot, "habits", `${options.habitName}.md`);
+        const isRsvp = (0, habit_policy_1.isRsvpHabitName)(options.habitName);
+        let readFailure = null;
+        let habit;
+        if (!fs.existsSync(habitPath)) {
+            readFailure = "missing";
+            habit = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "read_error", "", "habit file not found");
+        }
+        else {
+            try {
+                habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
+            }
+            catch (error) {
+                readFailure = "read";
+                habit = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "read_error", "", messageFromHabitPokeError(error));
+            }
+        }
+        if (habit.status !== "active") {
+            let skipReason = `habit status ${habit.status} is non-executable`;
+            if (isRsvp && habit.status === "degraded") {
+                if (readFailure === "missing") {
+                    skipReason = "RSVP habit file not found";
+                }
+                else {
+                    skipReason = `RSVP habit metadata invalid: ${habit.degradedDetail ?? habit.degradedReason}`;
+                }
+            }
+            else if (readFailure === "missing"
+                && options.source === "habit-poke"
+                && options.trigger !== "manual"
+                && options.trigger !== "poke") {
+                skipReason = "habit file not found";
+            }
+            return { kind: "skipped", habit, skipReason };
+        }
+        if (isRsvp && !habit.rsvp) {
+            return {
+                kind: "skipped",
+                habit,
+                skipReason: "RSVP habit metadata is required before private runtime wake",
+            };
+        }
+        if (options.trigger === "poke" || options.trigger === "manual") {
+            return { kind: "ready", habit };
+        }
+        if (typeof options.occurrenceId === "string" && options.occurrenceId.trim().length > 0) {
+            return { kind: "ready", habit, occurrenceId: options.occurrenceId.trim() };
+        }
+        if (habit.cadence === null) {
+            return { kind: "skipped", habit, skipReason: "habit has no cadence" };
+        }
+        if (habit.lastRun === null) {
+            return { kind: "ready", habit, occurrenceId: `${options.trigger}:first-run:${habit.cadence}` };
+        }
+        return {
+            kind: "ready",
+            habit,
+            occurrenceId: `${options.trigger}:last-run:${habit.lastRun}:cadence:${habit.cadence}`,
+        };
+    }
+    emitHabitDispatchSkipped(options) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.habit_dispatch_skipped",
+            message: "habit dispatch rejected by current lifecycle state",
+            meta: {
+                agent: options.agent,
+                habitName: options.habitName,
+                trigger: options.trigger,
+                status: options.resolution.habit.status,
+                degradedReason: options.resolution.habit.status === "degraded"
+                    ? options.resolution.habit.degradedReason
+                    : null,
+                detail: options.resolution.habit.status === "degraded"
+                    ? options.resolution.habit.degradedDetail
+                    : null,
+                reason: options.resolution.skipReason,
+            },
+        });
+    }
+    emitHabitDispatchReady(options) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_dispatch_ready",
+            message: "habit dispatch accepted by current lifecycle state",
+            meta: {
+                agent: options.agent,
+                habitName: options.habitName,
+                trigger: options.trigger,
+                status: options.resolution.habit.status,
+                occurrenceId: options.resolution.occurrenceId ?? null,
+            },
+        });
+    }
+    skippedHabitDispatchResponse(options) {
+        return {
+            ok: true,
+            message: `skipped scheduled habit ${options.habitName} for ${options.agent}: ${options.skipReason}`,
+        };
+    }
+    async runNativeRsvpHabit(command, trigger, occurrenceId, noSend = false) {
+        const runner = this.rsvpHabitRunner ?? (async (input) => {
+            const { runNativeRsvpHabit } = await Promise.resolve().then(() => __importStar(require("../../rsvp/native-habit-runner")));
+            return runNativeRsvpHabit(input);
+        });
+        const result = await runner({
+            agent: command.agent,
+            bundlesRoot: this.bundlesRoot,
+            habitName: command.habitName,
+            trigger,
+            ...(occurrenceId ? { occurrenceId } : {}),
+            ...(noSend ? { noSend: true } : {}),
+        });
+        if (noSend) {
+            const payload = result.payload;
+            const status = payload?.status;
+            const transportInvocationCount = payload?.transportInvocationCount;
+            const contractError = "native RSVP habit probe violated the immutable no-send result contract";
+            if (!result.ok) {
+                return {
+                    ok: false,
+                    error: result.message,
+                    data: {
+                        ok: false,
+                        noSend: true,
+                        status: typeof status === "string" ? status : "degraded",
+                        transportInvocationCount: null,
+                        error: result.message,
+                    },
+                };
+            }
+            if (payload?.noSend !== true
+                || typeof status !== "string"
+                || typeof transportInvocationCount !== "number"
+                || transportInvocationCount !== 0) {
+                return {
+                    ok: false,
+                    error: contractError,
+                    data: {
+                        ok: false,
+                        noSend: true,
+                        status: typeof status === "string" ? status : "degraded",
+                        transportInvocationCount: null,
+                        error: contractError,
+                    },
+                };
+            }
+            return {
+                ok: true,
+                message: result.message,
+                data: { noSend: true, status, transportInvocationCount: 0 },
+            };
+        }
+        return {
+            ok: result.ok,
+            message: result.message,
+            data: result,
+        };
+    }
+    buildPrivateRuntimeWorkerWakeMessage(command, decision, externalEvent) {
+        const awaitName = (0, await_private_wake_1.awaitNameFromPrivateWakeCommand)(command);
+        if (awaitName) {
+            return {
+                type: "await",
+                awaitName,
+                privateTurnDecision: decision,
+            };
+        }
+        const taskId = taskIdFromTaskPokePrivateWakeCommand(command);
+        if (taskId) {
+            return {
+                type: "poke",
+                taskId,
+                privateTurnDecision: decision,
+            };
+        }
+        const habitMessage = (0, habit_private_wake_1.habitMessageFromPrivateWakeCommand)(command);
+        if (habitMessage) {
+            return {
+                type: "habit",
+                habitName: habitMessage.habitName,
+                trigger: habitMessage.trigger,
+                ...(habitMessage.noSend ? { noSend: true } : {}),
+                privateTurnDecision: decision,
+            };
+        }
+        return { type: "message", privateTurnDecision: decision, ...(externalEvent ? { externalEvent } : {}) };
+    }
+    queueOperatorCliMessageForPrivateRuntime(command) {
+        if (command.kind !== "private.wake" || command.triggerSource !== "operator-cli")
+            return;
+        const receiptId = command.originRefs?.find((ref) => ref.kind === "daemon-receipt")?.id;
+        if (!receiptId)
+            return;
+        const messages = this.router.peekInbox?.(command.agent) ?? [];
+        const routed = messages.find((message) => message.id === receiptId);
+        if (!routed)
+            return;
+        const pendingDir = path.join(this.bundlesRoot, `${command.agent}.ouro`, "state", "pending", pending_1.PRIVATE_RUNTIME_PENDING.friendId, pending_1.PRIVATE_RUNTIME_PENDING.channel, pending_1.PRIVATE_RUNTIME_PENDING.key);
+        const queuedAtMs = Date.parse(routed.queuedAt);
+        (0, pending_1.queuePendingMessageOnce)(pendingDir, {
+            from: routed.from,
+            content: routed.content,
+            timestamp: Number.isFinite(queuedAtMs) ? queuedAtMs : Date.now(),
+            mode: "relay",
+            requestId: routed.id,
+            packetId: `operator-cli:${command.agent}:${routed.id}`,
+        });
+    }
+    queueExternalEventForPrivateRuntime(record, quiet = false) {
+        const pendingDir = path.join(this.bundlesRoot, `${record.agent}.ouro`, "state", "pending", pending_1.PRIVATE_RUNTIME_PENDING.friendId, pending_1.PRIVATE_RUNTIME_PENDING.channel, pending_1.PRIVATE_RUNTIME_PENDING.key);
+        const originKey = `${record.source}:${record.eventId}`;
+        const parsedReceivedAt = Date.parse(record.receivedAt);
+        (0, pending_1.queuePendingMessageOnce)(pendingDir, {
+            from: "ouro-external-event",
+            friendId: "ouro-external-event",
+            channel: "external-event",
+            key: originKey,
+            content: (0, router_1.buildExternalEventMessage)(record),
+            timestamp: Number.isFinite(parsedReceivedAt) ? parsedReceivedAt : Date.now(),
+            delegatedFrom: {
+                friendId: "ouro-external-event",
+                channel: "external-event",
+                key: originKey,
+            },
+            obligationStatus: "pending",
+            mode: "relay",
+            packetId: `external-event:${record.agent}:${record.source}:${record.eventId}:generation:${record.generation}:attempt:${record.attemptCount}`,
+        });
+        if (!quiet) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.external_event_private_runtime_queued",
+                message: "queued external event for private-runtime attention",
+                meta: {
+                    agent: record.agent,
+                    source: record.source,
+                    eventType: record.eventType,
+                    eventId: record.eventId,
+                    pendingDir,
+                },
+            });
+        }
+    }
+    externalEventRootPath() {
+        return this.externalEventRoot ?? (0, router_1.getExternalEventRoot)();
+    }
+    externalEventLease(record) {
+        /* v8 ignore next -- dispatcher calls this only with the record returned by claimExternalEvent @preserve */
+        if (!record.claimOwner)
+            throw new Error("External event dispatch requires a claimed receipt");
+        return {
+            schemaVersion: 1,
+            recordPath: record.recordPath,
+            agent: record.agent,
+            source: record.source,
+            eventId: record.eventId,
+            generation: record.generation,
+            observationRevision: record.observationRevision,
+            claimOwner: record.claimOwner,
+        };
+    }
+    async dispatchExternalEvents(records) {
+        const claimed = [];
+        let failureClass;
+        try {
+            for (const key of new Set(records.map((record) => `${record.agent}\0${record.source}`))) {
+                const [agent, source] = key.split("\0");
+                await this.externalEventSourceReadiness(agent, source);
+            }
+            for (const record of records) {
+                const owner = `external-event:${record.agent}:${record.source}:${record.eventId}:generation:${record.generation}:attempt:${record.attemptCount + 1}`;
+                claimed.push((0, router_1.claimExternalEvent)(record.recordPath, { owner, expectedVersion: record.version, expectedGeneration: record.generation }));
+            }
+            const primary = claimed[0];
+            const [primaryLease, ...relatedEvents] = claimed.map((record) => this.externalEventLease(record));
+            const lease = { ...primaryLease, ...(relatedEvents.length > 0 ? { relatedEvents } : {}) };
+            const receipt = {
+                id: `external-event:${primary.agent}:${primary.source}:${primary.eventId}:generation:${primary.generation}:attempt:${primary.attemptCount}`,
+                queuedAt: primary.updatedAt,
+            };
+            const wake = await this.handlePrivateRuntimeWake(this.buildExternalEventPrivateWakeCommand({
+                kind: "external.event.submit",
+                agent: primary.agent,
+                source: primary.source,
+                eventType: primary.eventType,
+                eventId: primary.eventId,
+            }, receipt.id, primary.generation, primary.attemptCount), () => {
+                const batched = claimed.length > 1;
+                for (const record of claimed)
+                    this.queueExternalEventForPrivateRuntime(record, batched);
+                if (batched) {
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "daemon",
+                        event: "daemon.external_event_private_runtime_batch_queued",
+                        message: "queued an external-event batch for private-runtime attention",
+                        meta: { agent: primary.agent, source: primary.source, eventCount: claimed.length },
+                    });
+                }
+            }, lease);
+            failureClass = wake.denialCode === "managed_runtime_unavailable"
+                ? "managed_runtime_unavailable"
+                : wake.data?.decision?.denialCode === "provider_lane_unavailable"
+                    ? "provider_lane_unavailable"
+                    : undefined;
+            const denied = !wake.ok || wake.data?.decision?.executable === false;
+            if (denied)
+                throw new Error(wake.error ?? wake.message ?? /* v8 ignore next -- daemon wake responses always carry an error or message @preserve */ "external-event private turn was denied");
+            return { events: claimed, event: primary, receipt, wake };
+        }
+        catch (error) {
+            for (const record of claimed) {
+                (0, router_1.settleExternalEventFailureIfOwned)(record.recordPath, {
+                    owner: record.claimOwner, expectedGeneration: record.generation,
+                    error: failureClass ? `external-event private-runtime dispatch failed: ${failureClass}` : "external-event private-runtime dispatch failed",
+                    ...(failureClass ? { failureClass } : {}),
+                });
+            }
+            throw error;
+        }
+    }
+    dispatchExternalEvent(record) {
+        return this.dispatchExternalEvents([record]);
+    }
+    async reconcileExternalEvents() {
+        /* v8 ignore next -- re-entrancy guard is exercised only by overlapping real timer callbacks @preserve */
+        if (this.externalEventReconcileRunning)
+            return;
+        this.externalEventReconcileRunning = true;
+        try {
+            const now = new Date().toISOString();
+            if (fs.existsSync(this.privilegedEventSpoolRoot)) {
+                this.privilegedEventScanner({ spoolRoot: this.privilegedEventSpoolRoot, eventRoot: this.externalEventRootPath() });
+            }
+            const statuses = (0, router_1.listExternalEventStatus)(this.externalEventRootPath());
+            const readinessKeys = new Set();
+            for (const status of statuses) {
+                if (status.corrupt)
+                    continue;
+                const candidate = (0, router_1.readExternalEventRecord)(status.recordPath);
+                if (candidate.dispatchEnabled === false)
+                    continue;
+                const retryDue = candidate.executionState === "retry_wait" && candidate.nextAttemptAt !== null && Date.parse(candidate.nextAttemptAt) <= Date.parse(now);
+                const leaseExpired = candidate.executionState === "running" && candidate.claimExpiresAt !== null && Date.parse(candidate.claimExpiresAt) <= Date.parse(now);
+                const recoverableDeadLetter = candidate.executionState === "dead_letter"
+                    && (0, router_1.externalEventRecoveryFailure)(candidate) !== null
+                    && candidate.recoveryGrant?.generation !== candidate.generation;
+                const dispatchable = candidate.executionState === "received" || candidate.executionState === "queued" || retryDue || leaseExpired || recoverableDeadLetter;
+                if (dispatchable && (candidate.source === "sanctuary-health" || candidate.source === "sanctuary-usenet"))
+                    readinessKeys.add(`${candidate.agent}\0${candidate.source}`);
+            }
+            const blockedReadinessKeys = new Set();
+            for (const key of readinessKeys) {
+                const [agent, source] = key.split("\0");
+                try {
+                    await this.externalEventSourceReadiness(agent, source);
+                }
+                catch (error) {
+                    blockedReadinessKeys.add(key);
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "daemon",
+                        event: "daemon.external_event_readiness_blocked",
+                        message: "external-event reconciliation is waiting for source runtime readiness",
+                        meta: { agent, source, error: (error instanceof Error ? error.message : String(error)).slice(0, 1_000) },
+                    });
+                }
+            }
+            const dueRecords = [];
+            const providerEvidenceByAgent = new Map();
+            const runtimeEvidenceByAgent = new Map();
+            const recoveredByClass = new Map();
+            for (const status of statuses) {
+                if (status.corrupt)
+                    continue;
+                let record = (0, router_1.readExternalEventRecord)(status.recordPath);
+                if (record.dispatchEnabled === false)
+                    continue;
+                if (blockedReadinessKeys.has(`${record.agent}\0${record.source}`))
+                    continue;
+                if (record.executionState === "dead_letter") {
+                    const failure = (0, router_1.externalEventRecoveryFailure)(record);
+                    if (!failure || record.recoveryGrant?.generation === record.generation)
+                        continue;
+                    let evidence = null;
+                    try {
+                        if (failure.class === "provider_lane_unavailable") {
+                            if (!providerEvidenceByAgent.has(record.agent)) {
+                                providerEvidenceByAgent.set(record.agent, null);
+                                const binding = (0, provider_binding_resolver_1.resolveEffectiveProviderBinding)({
+                                    agentName: record.agent,
+                                    agentRoot: path.join(this.bundlesRoot, `${record.agent}.ouro`),
+                                    lane: "inner",
+                                });
+                                providerEvidenceByAgent.set(record.agent, binding.ok && binding.binding.credential.status === "present"
+                                    && binding.binding.readiness.status === "ready" && binding.binding.readiness.checkedAt
+                                    ? { observedAt: binding.binding.readiness.checkedAt }
+                                    : null);
+                            }
+                            const current = providerEvidenceByAgent.get(record.agent);
+                            const readinessIsCurrentBoot = current && Date.parse(current.observedAt) >= this.constructedAtMs;
+                            if (current && ((0, router_1.isExactLegacyProviderRecoveryFailure)(record)
+                                ? readinessIsCurrentBoot
+                                : Date.parse(current.observedAt) > Date.parse(failure.failedAt))) {
+                                evidence = { class: failure.class, observedAt: current.observedAt };
+                            }
+                        }
+                        else if (failure.class === "execution_lease_expired") {
+                            if (!runtimeEvidenceByAgent.has(record.agent)) {
+                                const snapshot = this.processManager.listAgentSnapshots().find((candidate) => candidate.name === record.agent && candidate.channel === "private-runtime"
+                                    && candidate.status === "running" && candidate.pid !== null && candidate.startedAt !== null);
+                                runtimeEvidenceByAgent.set(record.agent, snapshot?.startedAt ? { observedAt: snapshot.startedAt } : null);
+                            }
+                            const current = runtimeEvidenceByAgent.get(record.agent);
+                            if (current && Date.parse(current.observedAt) > Date.parse(failure.failedAt)) {
+                                evidence = { class: failure.class, observedAt: current.observedAt };
+                            }
+                        }
+                        else if (this.hasManagedPrivateRuntime(record.agent) && Date.parse(now) > Date.parse(failure.failedAt)) {
+                            evidence = { class: failure.class, observedAt: now };
+                        }
+                        if (!evidence)
+                            continue;
+                        const revival = (0, router_1.reviveExternalEventAfterRecovery)(record.recordPath, { expectedVersion: record.version, expectedGeneration: record.generation, evidence, now: () => now, quiet: true });
+                        record = revival.record;
+                        recoveredByClass.set(failure.class, (recoveredByClass.get(failure.class) ?? 0) + 1);
+                    }
+                    catch (error) {
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "daemon",
+                            event: "daemon.external_event_recovery_error",
+                            message: "external event dead-letter recovery check failed",
+                            meta: { agent: record.agent, source: record.source, eventId: record.eventId, generation: record.generation, error: error instanceof Error ? error.message : String(error) },
+                        });
+                        continue;
+                    }
+                }
+                if (record.executionState === "running" && record.claimExpiresAt && Date.parse(record.claimExpiresAt) <= Date.parse(now)) {
+                    record = (0, router_1.reconcileExternalEvent)(record.recordPath);
+                }
+                const due = record.executionState === "received"
+                    || record.executionState === "queued"
+                    || (record.executionState === "retry_wait" && record.nextAttemptAt !== null && Date.parse(record.nextAttemptAt) <= Date.parse(now));
+                if (due)
+                    dueRecords.push(record);
+            }
+            if (recoveredByClass.size > 0) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.external_event_recovery_batch",
+                    message: "requeued external events after cached infrastructure recovery evidence",
+                    meta: { recovered: Object.fromEntries(recoveredByClass) },
+                });
+            }
+            const batches = new Map();
+            for (const record of dueRecords) {
+                const key = `${record.agent}\0${record.source}`;
+                const batch = batches.get(key) ?? [];
+                batch.push(record);
+                batches.set(key, batch);
+            }
+            for (const records of batches.values()) {
+                for (let offset = 0; offset < records.length; offset += 32) {
+                    const batch = records.slice(offset, offset + 32);
+                    try {
+                        await this.dispatchExternalEvents(batch);
+                    }
+                    catch (error) {
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "daemon",
+                            event: "daemon.external_event_dispatch_error",
+                            message: "external event dispatch failed",
+                            meta: { recordPath: batch[0].recordPath, batchSize: batch.length, error: error instanceof Error ? error.message : /* v8 ignore next -- dispatch failures are Error objects @preserve */ String(error) },
+                        });
+                    }
+                }
+            }
+        }
+        finally {
+            this.externalEventReconcileRunning = false;
+        }
+    }
+    async handlePrivateRuntimeWake(command, beforeDispatch, externalEvent) {
+        if (!this.hasManagedPrivateRuntime(command.agent)) {
+            return {
+                ok: false,
+                error: `No managed agent '${command.agent}' is registered with daemon-managed private runtime.`,
+                denialCode: "managed_runtime_unavailable",
+            };
+        }
+        const decision = await (0, private_runtime_1.requestPrivateTurnDecision)(this.buildPrivateRuntimeWakeRequest(command), {
+            bundlesRoot: this.bundlesRoot,
+            ...this.privateRuntimePolicyDeps,
+        });
+        if (!decision.executable) {
+            return {
+                ok: true,
+                message: `private-runtime wake denied for ${command.agent}: ${decision.deniedReason}`,
+                ...(decision.denialCode ? { denialCode: decision.denialCode } : {}),
+                data: { decision },
+            };
+        }
+        this.queueOperatorCliMessageForPrivateRuntime(command);
+        await beforeDispatch?.(decision);
+        await this.processManager.startAgent(command.agent);
+        const message = this.buildPrivateRuntimeWorkerWakeMessage(command, decision, externalEvent);
+        if (this.processManager.dispatchToAgent)
+            await this.processManager.dispatchToAgent(command.agent, message);
+        else
+            this.processManager.sendToAgent?.(command.agent, message);
+        return {
+            ok: true,
+            message: `woke private runtime for ${command.agent}`,
+            data: { decision },
+        };
+    }
+    async handleCommandInner(command) {
         switch (command.kind) {
             case "daemon.start":
                 await this.start();
                 return { ok: true, message: "daemon started" };
             case "daemon.stop":
-                await this.stop();
+                try {
+                    await this.stop();
+                }
+                finally {
+                    await this.onStopCommandComplete?.();
+                }
                 return { ok: true, message: "daemon stopped" };
-            case "daemon.status": {
-                const snapshots = this.processManager.listAgentSnapshots();
-                const workers = buildWorkerRows(snapshots);
-                const senses = this.senseManager?.listSenseRows() ?? [];
-                const repoRoot = (0, identity_1.getRepoRoot)();
-                const data = {
-                    overview: {
-                        daemon: "running",
-                        health: workers.every((worker) => worker.status === "running") ? "ok" : "warn",
-                        socketPath: this.socketPath,
-                        ...(0, runtime_metadata_1.getRuntimeMetadata)(),
-                        workerCount: workers.length,
-                        senseCount: senses.length,
-                        entryPath: path.join(repoRoot, "dist", "heart", "daemon", "daemon-entry.js"),
-                        mode: (0, runtime_mode_1.detectRuntimeMode)(repoRoot),
+            case "daemon.restart": {
+                // Restart is "stop + let launchctl respawn." Under launchctl's KeepAlive
+                // policy the process is auto-restarted on exit, so daemon.restart and
+                // daemon.stop differ only in intent + audit trail. In dev (no launchctl),
+                // the process simply exits — same observable behavior as daemon.stop.
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.restart_requested",
+                    message: "daemon restart requested",
+                    meta: {
+                        reason: command.reason ?? null,
+                        requestedBy: command.requestedBy ?? null,
                     },
-                    workers,
-                    senses,
+                });
+                try {
+                    await this.stop();
+                }
+                finally {
+                    await this.onStopCommandComplete?.();
+                }
+                return {
+                    ok: true,
+                    message: "daemon restarting — launchctl will respawn",
                 };
+            }
+            case "daemon.status": {
+                const data = this.buildStatusPayload();
                 return {
                     ok: true,
                     summary: formatStatusSummary(data),
@@ -412,15 +1940,112 @@ class OuroDaemon {
                     message: "log streaming available via ouro logs",
                     data: { logDir: "~/AgentBundles/<agent>.ouro/state/daemon/logs" },
                 };
+            case "daemon.sense_revive": {
+                if (!isValidSenseReviveCommand(command)) {
+                    return {
+                        ok: false,
+                        error: "Invalid daemon.sense_revive payload: expected string fields 'agent', 'sense', and 'reason'.",
+                    };
+                }
+                const revivedSenseRow = await this.senseManager?.reviveSense?.(command.agent, command.sense);
+                if (revivedSenseRow) {
+                    return {
+                        ok: true,
+                        message: `revived ${command.agent}/${command.sense}`,
+                        data: revivedSenseRow,
+                    };
+                }
+                const managedSenseSnapshots = this.processManager.listAgentSnapshots()
+                    .filter((snapshot) => snapshot.name.startsWith(`${command.agent}:`));
+                if (managedSenseSnapshots.length === 0) {
+                    return {
+                        ok: false,
+                        error: `No managed agent '${command.agent}' is registered with daemon-managed senses.`,
+                    };
+                }
+                const exactTargetName = `${command.agent}:${command.sense}`;
+                const target = managedSenseSnapshots.find((snapshot) => snapshot.name === exactTargetName)
+                    ?? managedSenseSnapshots.find((snapshot) => snapshot.channel === command.sense);
+                if (!target) {
+                    return {
+                        ok: false,
+                        error: `No managed sense '${command.sense}' is registered for agent '${command.agent}'.`,
+                    };
+                }
+                this.processManager.resetAgentFailureState(target.name);
+                await this.processManager.startAgent(target.name);
+                const freshSnapshot = this.processManager.listAgentSnapshots()
+                    .find((snapshot) => snapshot.name === target.name) ?? target;
+                return {
+                    ok: true,
+                    message: `revived ${command.agent}/${command.sense}`,
+                    data: freshSnapshot,
+                };
+            }
             case "agent.start":
                 await this.processManager.startAgent(command.agent);
                 return { ok: true, message: `started ${command.agent}` };
             case "agent.stop":
                 await this.processManager.stopAgent?.(command.agent);
                 return { ok: true, message: `stopped ${command.agent}` };
-            case "agent.restart":
-                await this.processManager.restartAgent?.(command.agent);
-                return { ok: true, message: `restarted ${command.agent}` };
+            case "agent.restart": {
+                if (!this.processManager.restartAgent) {
+                    return { ok: false, error: "Managed agent restart is not available." };
+                }
+                const managedSnapshot = this.processManager.listAgentSnapshots()
+                    .find((snapshot) => snapshot.name === command.agent);
+                if (!managedSnapshot) {
+                    return { ok: false, error: `Unknown managed agent '${command.agent}'.` };
+                }
+                if (managedSnapshot.autoStart === false && managedSnapshot.status === "stopped") {
+                    return { ok: true, message: `restart skipped for parked non-autostart agent '${command.agent}'` };
+                }
+                const restartWork = command.skipConfigCheck === true
+                    ? this.processManager.restartAgent(command.agent, { skipConfigCheck: true })
+                    : this.processManager.restartAgent(command.agent);
+                void restartWork.catch((error) => {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "error",
+                        component: "daemon",
+                        event: "daemon.agent_restart_request_error",
+                        message: "managed agent restart failed after request acknowledgement",
+                        meta: {
+                            agent: command.agent,
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                });
+                return { ok: true, message: `restart requested for ${command.agent}` };
+            }
+            case "agent.ask":
+                return handleAgentAskTurn(command, { socketPath: this.socketPath });
+            case "agent.status":
+                return (0, agent_service_1.handleAgentStatus)(command);
+            case "agent.catchup":
+                return (0, agent_service_1.handleAgentCatchup)(command);
+            case "agent.delegate":
+                return (0, agent_service_1.handleAgentDelegate)(command);
+            case "agent.getContext":
+                return (0, agent_service_1.handleAgentGetContext)(command);
+            case "agent.searchFacts":
+                return (0, agent_service_1.handleAgentSearchFacts)(command);
+            case "agent.getTask":
+                return (0, agent_service_1.handleAgentGetTask)(command);
+            case "agent.checkScope":
+                return (0, agent_service_1.handleAgentCheckScope)(command);
+            case "agent.requestDecision":
+                return (0, agent_service_1.handleAgentRequestDecision)(command);
+            case "agent.checkGuidance":
+                return (0, agent_service_1.handleAgentCheckGuidance)(command);
+            case "agent.reportProgress":
+                return (0, agent_service_1.handleAgentReportProgress)(command);
+            case "agent.reportBlocker":
+                return (0, agent_service_1.handleAgentReportBlocker)(command);
+            case "agent.reportComplete":
+                return (0, agent_service_1.handleAgentReportComplete)(command);
+            case "agent.senseTurn":
+                return handleAgentSenseTurn(command, { socketPath: this.socketPath });
+            /* v8 ignore stop */
             case "cron.list": {
                 const jobs = this.scheduler.listJobs();
                 const summary = jobs.length === 0
@@ -429,10 +2054,28 @@ class OuroDaemon {
                 return { ok: true, summary, data: jobs };
             }
             case "cron.trigger": {
+                const habitResult = await this.scheduler.triggerHabitJob?.(command.jobId);
+                if (habitResult?.ok) {
+                    return { ok: true, message: habitResult.message };
+                }
                 const result = await this.scheduler.triggerJob(command.jobId);
                 return { ok: result.ok, message: result.message };
             }
             case "message.send": {
+                // Pure queue-only delivery. We DO NOT wake the recipient — that was
+                // the 2026-05-11 $50 bleed. The Claude Code post-tool-use hook
+                // (cli-exec.ts) intentionally sends only message.send for tool-use
+                // events to avoid waking the agent on every tool call. The hook's
+                // intent was completely defeated by this handler calling
+                // `sendToAgent({type: "message"})`, which woke the private runtime
+                // worker on EVERY message.send anyway. ~30 message.send/min × the
+                // 3-turn instinct-loop cap = ~90 turns/min sustained for hours.
+                //
+                // Callers that want immediate processing must send `private.wake`
+                // explicitly after message.send. The CLI `ouro msg` does so
+                // (lifecycle-boundary delivery should wake); the hook does so
+                // only on session-start / stop, not per tool-use; the API does
+                // not (notifications go to the queue).
                 const receipt = await this.router.send({
                     from: command.from,
                     to: command.to,
@@ -441,7 +2084,6 @@ class OuroDaemon {
                     sessionId: command.sessionId,
                     taskRef: command.taskRef,
                 });
-                this.processManager.sendToAgent?.(command.to, { type: "message" });
                 return { ok: true, message: `queued message ${receipt.id}`, data: receipt };
             }
             case "message.poll": {
@@ -452,13 +2094,127 @@ class OuroDaemon {
                     data: messages,
                 };
             }
-            case "inner.wake":
-                await this.processManager.startAgent(command.agent);
-                this.processManager.sendToAgent?.(command.agent, { type: "message" });
+            case "external.event.submit": {
+                const record = (0, router_1.recordExternalEvent)({
+                    agent: command.agent,
+                    source: command.source,
+                    eventType: command.eventType,
+                    eventId: command.eventId,
+                    summary: command.summary,
+                    evidence: command.evidence,
+                    payloadPath: command.payloadPath,
+                    priority: command.priority,
+                    observationRevision: command.observationRevision,
+                    transition: command.transition,
+                }, {
+                    ...(this.externalEventRoot ? { root: this.externalEventRoot } : {}),
+                    dispatchEnabled: command.wake !== false,
+                });
+                if (!record.shouldWake || command.wake === false) {
+                    return {
+                        ok: true,
+                        message: `updated external event ${record.source}/${record.eventId} without wake`,
+                        data: { event: record, receipt: null, wake: null },
+                    };
+                }
+                const dispatched = await this.dispatchExternalEvent(record);
                 return {
                     ok: true,
-                    message: `woke inner dialog for ${command.agent}`,
+                    message: `queued external event ${record.source}/${record.eventId} as ${dispatched.receipt.id}; ${dispatched.wake.message ?? "wake skipped"}`,
+                    data: dispatched,
                 };
+            }
+            case "external.event.repair": {
+                if (this.externalEventReconcileRunning)
+                    return { ok: false, error: "external event reconciliation is already active; repair made no changes" };
+                this.externalEventReconcileRunning = true;
+                try {
+                    try {
+                        const result = (0, router_1.repairExternalEventsFromManifest)(command.manifestPath, { root: this.externalEventRootPath() });
+                        return { ok: result.failed.length === 0, message: `external event repair applied=${result.applied.length} alreadyApplied=${result.alreadyApplied.length} failed=${result.failed.length} pending=${result.pending.length}`, data: result };
+                    }
+                    catch (error) {
+                        const message = (error instanceof Error ? error.message : /* v8 ignore next -- defensive: repair parser and filesystem dependencies throw Error instances @preserve */ String(error)).slice(0, 1_000);
+                        const result = { applied: [], alreadyApplied: [], failed: [{ identity: "<manifest>", error: message }], pending: [] };
+                        (0, runtime_1.emitNervesEvent)({ level: "error", component: "daemon", event: "daemon.external_event_repair", message: "rejected external event repair manifest", meta: { applied: 0, alreadyApplied: 0, failed: 1, pending: 0 } });
+                        return { ok: false, error: `external event repair rejected: ${message}`, data: result };
+                    }
+                }
+                finally {
+                    this.externalEventReconcileRunning = false;
+                }
+            }
+            case "private.decisions": {
+                const requestedLimit = Number.isInteger(command.limit) && command.limit && command.limit > 0 ? command.limit : 20;
+                const limit = Math.min(requestedLimit, 1000);
+                const ledgerPath = (0, private_runtime_1.privateTurnLedgerPath)(command.agent, { bundlesRoot: this.bundlesRoot });
+                const ledgerExists = fs.existsSync(ledgerPath);
+                let decisions;
+                try {
+                    decisions = ledgerExists ? (0, private_runtime_1.readPrivateTurnLedger)(ledgerPath) : [];
+                }
+                catch {
+                    return {
+                        ok: false,
+                        error: `private-runtime decision ledger is malformed: ${ledgerPath}; repair or remove malformed JSONL rows before reading decisions`,
+                    };
+                }
+                const guidance = ledgerExists
+                    ? undefined
+                    : `No private-runtime decision ledger exists for ${command.agent}; run an explicit private-runtime trigger or check ${path.dirname(ledgerPath)}.`;
+                const payload = (0, private_runtime_1.buildPrivateDecisionReadPayload)({
+                    agent: command.agent,
+                    ledgerPath,
+                    decisions,
+                    limit,
+                    ...(guidance ? { guidance } : {}),
+                });
+                return {
+                    ok: true,
+                    summary: (0, private_runtime_1.privateDecisionCountSummary)(payload.decisions.length),
+                    ...(guidance ? { message: guidance } : {}),
+                    data: payload,
+                };
+            }
+            case "inner.wake":
+                return this.handlePrivateRuntimeWake(command);
+            case "private.wake": {
+                const scheduledHabit = (0, habit_private_wake_1.habitMessageFromPrivateWakeCommand)(command);
+                if (!scheduledHabit || !this.hasManagedPrivateRuntime(command.agent)) {
+                    return this.handlePrivateRuntimeWake(command);
+                }
+                const occurrenceRef = command.originRefs?.find((ref) => ref.kind === "habit-occurrence");
+                const occurrenceId = typeof occurrenceRef?.id === "string" && occurrenceRef.id.trim().length > 0
+                    ? occurrenceRef.id.trim()
+                    : undefined;
+                const resolution = this.resolveHabitDispatch({
+                    agent: command.agent,
+                    habitName: scheduledHabit.habitName,
+                    trigger: scheduledHabit.trigger,
+                    source: "private-wake",
+                    ...(occurrenceId ? { occurrenceId } : {}),
+                });
+                if (resolution.kind === "skipped") {
+                    this.emitHabitDispatchSkipped({
+                        agent: command.agent,
+                        habitName: scheduledHabit.habitName,
+                        trigger: scheduledHabit.trigger,
+                        resolution,
+                    });
+                    return this.skippedHabitDispatchResponse({
+                        agent: command.agent,
+                        habitName: scheduledHabit.habitName,
+                        skipReason: resolution.skipReason,
+                    });
+                }
+                this.emitHabitDispatchReady({
+                    agent: command.agent,
+                    habitName: scheduledHabit.habitName,
+                    trigger: scheduledHabit.trigger,
+                    resolution,
+                });
+                return this.handlePrivateRuntimeWake(command);
+            }
             case "chat.connect":
                 await this.processManager.startAgent(command.agent);
                 return {
@@ -466,6 +2222,12 @@ class OuroDaemon {
                     message: `connected to ${command.agent}`,
                 };
             case "task.poke": {
+                if (!isValidTaskPokeCommand(command)) {
+                    return {
+                        ok: false,
+                        error: "Invalid task.poke payload: expected non-empty string fields 'agent' and 'taskId'.",
+                    };
+                }
                 const receipt = await this.router.send({
                     from: "ouro-poke",
                     to: command.agent,
@@ -474,39 +2236,246 @@ class OuroDaemon {
                     taskRef: command.taskId,
                 });
                 await this.scheduler.recordTaskRun?.(command.agent, command.taskId);
-                this.processManager.sendToAgent?.(command.agent, { type: "poke", taskId: command.taskId });
+                await this.handlePrivateRuntimeWake(this.buildTaskPokePrivateWakeCommand(command, receipt.id));
                 return {
                     ok: true,
                     message: `queued poke ${receipt.id}`,
                     data: receipt,
                 };
             }
-            case "mcp.list": {
-                const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)();
-                if (!mcpManager) {
-                    return { ok: true, data: [], message: "no MCP servers configured" };
-                }
-                return { ok: true, data: mcpManager.listAllTools() };
-            }
-            case "mcp.call": {
-                const mcpCallManager = await (0, mcp_manager_1.getSharedMcpManager)();
-                if (!mcpCallManager) {
-                    return { ok: false, error: "no MCP servers configured" };
-                }
+            case "habit.scheduler-fire": {
+                if (!this.schedulerFireVerifier || !this.schedulerFireConsumer)
+                    return { ok: false, error: "authenticated scheduler fire is unavailable" };
+                let origin;
                 try {
-                    const parsedArgs = command.args ? JSON.parse(command.args) : {};
-                    const result = await mcpCallManager.callTool(command.server, command.tool, parsedArgs);
-                    return { ok: true, data: result };
+                    origin = this.schedulerFireVerifier(command);
+                    this.schedulerFireConsumer(origin);
                 }
                 catch (error) {
-                    /* v8 ignore next -- defensive: callTool errors are always Error instances @preserve */
                     return { ok: false, error: error instanceof Error ? error.message : String(error) };
                 }
+                const poke = { kind: "habit.poke", agent: command.agent, habitName: command.habitName, trigger: "cron", occurrenceId: origin.occurrenceId };
+                this.authenticatedSchedulerPokes.set(poke, origin);
+                try {
+                    return await this.handleCommand(poke);
+                }
+                finally {
+                    this.authenticatedSchedulerPokes.delete(poke);
+                }
+            }
+            case "habit.poke": {
+                if (!isValidHabitPokeCommand(command)) {
+                    return {
+                        ok: false,
+                        error: "Invalid habit.poke payload: expected non-empty string fields 'agent' and 'habitName'.",
+                    };
+                }
+                const trigger = command.trigger ?? "poke";
+                if (!(0, flight_recorder_1.isHabitRunTrigger)(trigger)) {
+                    return { ok: false, error: `invalid habit trigger: ${String(trigger)}` };
+                }
+                const schedulerOrigin = this.authenticatedSchedulerPokes.get(command);
+                if (command.agent === "sanctuary" && command.habitName === "sanctuary-health" && trigger === "cron" && !schedulerOrigin) {
+                    return { ok: false, error: "Sanctuary cron habit requires authenticated Supercronic provenance" };
+                }
+                if (!(0, habit_policy_1.isRsvpHabitName)(command.habitName) && !this.hasManagedPrivateRuntime(command.agent)) {
+                    return {
+                        ok: false,
+                        error: `No managed agent '${command.agent}' is registered with daemon-managed private runtime.`,
+                    };
+                }
+                const resolution = this.resolveHabitDispatch({
+                    agent: command.agent,
+                    habitName: command.habitName,
+                    trigger,
+                    source: "habit-poke",
+                    ...(command.occurrenceId ? { occurrenceId: command.occurrenceId } : {}),
+                });
+                if (resolution.kind === "skipped") {
+                    this.emitHabitDispatchSkipped({
+                        agent: command.agent,
+                        habitName: command.habitName,
+                        trigger,
+                        resolution,
+                    });
+                    return this.skippedHabitDispatchResponse({
+                        agent: command.agent,
+                        habitName: command.habitName,
+                        skipReason: resolution.skipReason,
+                    });
+                }
+                this.emitHabitDispatchReady({
+                    agent: command.agent,
+                    habitName: command.habitName,
+                    trigger,
+                    resolution,
+                });
+                if (this.nativeHabitRunner && this.nativeHabitMatch?.(command.agent, command.habitName)) {
+                    const occurrenceId = resolution.occurrenceId ?? `${trigger}:${command.agent}:${command.habitName}`;
+                    const claimKey = `${command.agent}:${command.habitName}`;
+                    if (this.nativeHabitClaims.has(claimKey)) {
+                        return { ok: true, message: `skipped overlapping native habit occurrence ${occurrenceId}` };
+                    }
+                    this.nativeHabitClaims.add(claimKey);
+                    const startedAt = new Date().toISOString();
+                    const runnerId = (0, node_crypto_1.randomUUID)();
+                    let nativeResult;
+                    try {
+                        nativeResult = await this.nativeHabitRunner({
+                            agent: command.agent,
+                            habitName: command.habitName,
+                            trigger,
+                            occurrenceId,
+                            runnerId,
+                            ...(schedulerOrigin ? { schedulerOrigin } : {}),
+                        }) ?? { ok: false, error: "native habit runner declined a matched habit" };
+                    }
+                    catch (error) {
+                        nativeResult = { ok: false, error: error instanceof Error ? error.message : String(error) };
+                    }
+                    const endedAt = new Date().toISOString();
+                    let completion;
+                    try {
+                        completion = (0, habit_session_1.completeHabitRun)({
+                            agentRoot: path.join(this.bundlesRoot, `${command.agent}.ouro`),
+                            habit: resolution.habit,
+                            runId: runnerId,
+                            trigger,
+                            startedAt,
+                            endedAt,
+                            operationId: occurrenceId,
+                            permissionEnvelope: { schemaVersion: 1, canMessageOutward: true, returnRoutes: [], deniedTools: [], warnings: [] },
+                            toolPolicy: { requestedTools: null, grantedTools: [], deniedTools: [], outwardMessagingAllowed: true },
+                            ...(nativeResult.ok ? {} : { errors: [nativeResult.error ?? nativeResult.message ?? "native habit failed"] }),
+                        });
+                    }
+                    finally {
+                        this.nativeHabitClaims.delete(claimKey);
+                    }
+                    if (!completion.receiptWritten || !completion.runtimeStateRecorded) {
+                        return { ok: false, error: "native habit completed but its durable receipt or cursor could not be recorded", data: nativeResult };
+                    }
+                    return nativeResult;
+                }
+                if ((0, habit_policy_1.isRsvpHabitName)(command.habitName)) {
+                    return this.runNativeRsvpHabit(command, trigger, resolution.occurrenceId);
+                }
+                return this.handlePrivateRuntimeWake((0, habit_private_wake_1.buildHabitPrivateWakeCommand)({
+                    agent: command.agent,
+                    habitName: command.habitName,
+                    trigger,
+                    sourceRef: { kind: "daemon-command", id: "habit.poke" },
+                    occurrenceId: resolution.occurrenceId,
+                }));
+            }
+            case "habit.probe": {
+                if (!isValidHabitProbeCommand(command)) {
+                    return {
+                        ok: false,
+                        error: "Invalid habit.probe payload: expected non-empty agent/habitName and noSend=true.",
+                    };
+                }
+                const trigger = "manual";
+                if (!(0, habit_policy_1.isRsvpHabitName)(command.habitName) && !this.hasManagedPrivateRuntime(command.agent)) {
+                    return {
+                        ok: false,
+                        error: `No managed agent '${command.agent}' is registered with daemon-managed private runtime.`,
+                    };
+                }
+                const resolution = this.resolveHabitDispatch({
+                    agent: command.agent,
+                    habitName: command.habitName,
+                    trigger,
+                    source: "habit-probe",
+                });
+                if (resolution.kind === "skipped") {
+                    this.emitHabitDispatchSkipped({
+                        agent: command.agent,
+                        habitName: command.habitName,
+                        trigger,
+                        resolution,
+                    });
+                    return {
+                        ok: true,
+                        message: `habit probe rejected by lifecycle: status=${resolution.habit.status}`,
+                        data: {
+                            noSend: true,
+                            status: resolution.habit.status,
+                            transportInvocationCount: 0,
+                        },
+                    };
+                }
+                this.emitHabitDispatchReady({
+                    agent: command.agent,
+                    habitName: command.habitName,
+                    trigger,
+                    resolution,
+                });
+                if ((0, habit_policy_1.isRsvpHabitName)(command.habitName)) {
+                    return this.runNativeRsvpHabit(command, trigger, resolution.occurrenceId, true);
+                }
+                const wake = await this.handlePrivateRuntimeWake((0, habit_private_wake_1.buildHabitPrivateWakeCommand)({
+                    agent: command.agent,
+                    habitName: command.habitName,
+                    trigger,
+                    sourceRef: { kind: "daemon-command", id: "habit.probe" },
+                    occurrenceId: resolution.occurrenceId,
+                    noSend: true,
+                }));
+                if (!wake.ok)
+                    return wake;
+                const denied = wake.data
+                    ?.decision?.executable === false;
+                const error = denied
+                    ? "non-RSVP habit probe was not executed because private-runtime policy denied execution"
+                    : "non-RSVP habit probe completion is asynchronous; zero-transport evidence is unverified";
+                return {
+                    ok: false,
+                    error,
+                    data: {
+                        ok: false,
+                        noSend: true,
+                        status: resolution.habit.status,
+                        transportInvocationCount: null,
+                        error,
+                    },
+                };
+            }
+            case "await.poke": {
+                return this.handlePrivateRuntimeWake(this.buildAwaitPrivateWakeCommand(command));
+            }
+            case "mcp.list": {
+                return (0, turn_execution_lease_1.withTurnExecutionLease)(async () => {
+                    (0, identity_1.setAgentName)(command.agent ?? "default");
+                    const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)();
+                    if (!mcpManager) {
+                        return { ok: true, data: [], message: "no MCP servers configured" };
+                    }
+                    return { ok: true, data: mcpManager.listAllTools() };
+                });
+            }
+            case "mcp.call": {
+                return (0, turn_execution_lease_1.withTurnExecutionLease)(async () => {
+                    (0, identity_1.setAgentName)(command.agent ?? "default");
+                    const mcpCallManager = await (0, mcp_manager_1.getSharedMcpManager)();
+                    if (!mcpCallManager) {
+                        return { ok: false, error: "no MCP servers configured" };
+                    }
+                    try {
+                        const parsedArgs = command.args ? JSON.parse(command.args) : {};
+                        const result = await mcpCallManager.callTool(command.server, command.tool, parsedArgs);
+                        return { ok: true, data: result };
+                    }
+                    catch (error) {
+                        /* v8 ignore next -- defensive: callTool errors are always Error instances @preserve */
+                        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+                    }
+                });
             }
             case "hatch.start":
                 return {
                     ok: true,
-                    message: "hatch flow is stubbed in Gate 3 and completed in Gate 6",
+                    message: "hatch flow is stubbed; the interactive implementation lands in a later milestone",
                 };
             default:
                 return {