@ouro.bot/cli 0.1.0-alpha.319 → 0.1.0-alpha.320

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.320",
+      "changes": [
+        "fix(daemon): make `ouro up` wait for real startup stability before reporting success. The CLI now stays attached through ordered startup phases, requires sustained socket liveness plus fresh current-boot health evidence, retries once when startup loses the socket, and surfaces recent daemon log context on failure instead of claiming the daemon started.",
+        "fix(daemon): harden socket ownership and recoverable bootstrap behavior. An older daemon shutdown no longer unlinks a newer daemon's rebound socket path, and recoverable habit bootstrap failures now degrade with actionable `habit_setup_error` and `bootstrap_degraded` guidance instead of taking the whole daemon down.",
+        "fix(testing): declare @testing-library/dom in outlook-ui devDependencies so coverage-gate installs match the package's actual React Testing Library requirements."
+      ]
+    },
     {
       "version": "0.1.0-alpha.319",
       "changes": [

package/dist/heart/daemon/cli-defaults.js

@@ -64,6 +64,8 @@ const agent_discovery_1 = require("./agent-discovery");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
 const ouro_bot_global_installer_1 = require("../versioning/ouro-bot-global-installer");
 const logs_prune_1 = require("./logs-prune");
+const daemon_health_1 = require("./daemon-health");
+const log_tailer_1 = require("./log-tailer");
 const launchd_1 = require("./launchd");
 const socket_client_1 = require("./socket-client");
 const session_activity_1 = require("../session-activity");
@@ -121,6 +123,25 @@ function defaultCleanupStaleSocket(socketPath) {
         fs.unlinkSync(socketPath);
     }
 }
+function defaultReadHealthUpdatedAt(healthPath) {
+    try {
+        return fs.statSync(healthPath).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+function defaultReadRecentDaemonLogLines(lines = 10) {
+    const files = (0, log_tailer_1.discoverLogFiles)({});
+    const recentLines = [];
+    for (const file of files) {
+        recentLines.push(...(0, log_tailer_1.readLastLines)(file, lines, fs.readFileSync));
+    }
+    return recentLines.slice(-lines).map((line) => (0, log_tailer_1.formatLogLine)(line));
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function defaultFallbackPendingMessage(command) {
     const inboxDir = path.join((0, identity_1.getAgentBundlesRoot)(), `${command.to}.ouro`, "inbox");
     const pendingPath = path.join(inboxDir, "pending.jsonl");
@@ -466,6 +487,16 @@ function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SO
         checkSocketAlive: socket_client_1.checkDaemonSocketAlive,
         cleanupStaleSocket: defaultCleanupStaleSocket,
         fallbackPendingMessage: defaultFallbackPendingMessage,
+        healthFilePath: (0, daemon_health_1.getDefaultHealthPath)(),
+        readHealthState: daemon_health_1.readHealth,
+        readHealthUpdatedAt: defaultReadHealthUpdatedAt,
+        readRecentDaemonLogLines: defaultReadRecentDaemonLogLines,
+        sleep: defaultSleep,
+        now: () => Date.now(),
+        startupPollIntervalMs: 250,
+        startupStabilityWindowMs: 1_500,
+        startupTimeoutMs: 10_000,
+        startupRetryLimit: 1,
         listDiscoveredAgents: defaultListDiscoveredAgents,
         runHatchFlow: hatch_flow_1.runHatchFlow,
         promptInput: defaultPromptInput,

package/dist/heart/daemon/cli-exec.js

@@ -77,6 +77,11 @@ const startup_tui_1 = require("./startup-tui");
 const stale_bundle_prune_1 = require("./stale-bundle-prune");
 const up_progress_1 = require("./up-progress");
 // ── ensureDaemonRunning ──
+const DEFAULT_DAEMON_STARTUP_TIMEOUT_MS = 10_000;
+const DEFAULT_DAEMON_STARTUP_POLL_INTERVAL_MS = 500;
+const DEFAULT_DAEMON_STARTUP_STABILITY_WINDOW_MS = 1_500;
+const DEFAULT_DAEMON_STARTUP_RETRY_LIMIT = 1;
+const DEFAULT_DAEMON_STARTUP_LOG_LINES = 10;
 async function ensureDaemonRunning(deps) {
     const alive = await deps.checkSocketAlive(deps.socketPath);
     if (alive) {
@@ -111,66 +116,192 @@ async function ensureDaemonRunning(deps) {
             checkSocketAlive: deps.checkSocketAlive,
         });
     }
-    deps.cleanupStaleSocket(deps.socketPath);
-    const started = await deps.startDaemonProcess(deps.socketPath);
-    const pid = started.pid ?? "unknown";
-    // Poll daemon status with real-time TUI progress until all agents
-    // are either stable (running 5s+) or definitively failed (crashed).
-    const stability = await (0, startup_tui_1.pollDaemonStartup)({
-        sendCommand: deps.sendCommand,
-        socketPath: deps.socketPath,
-        daemonPid: started.pid ?? null,
-        /* v8 ignore next -- thin wrapper: raw process.stdout.write for ANSI cursor control @preserve */
-        writeRaw: (text) => process.stdout.write(text),
-        /* v8 ignore next -- thin wrapper: real Date.now() injected for testability @preserve */
-        now: () => Date.now(),
-        /* v8 ignore next -- thin wrapper: real setTimeout injected for testability @preserve */
-        sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
-        /* v8 ignore start -- daemon log tail + pid check: reads real filesystem, tested via deployment @preserve */
-        readLatestDaemonEvent: () => {
-            try {
-                // The daemon writes structured events to daemon.ndjson in the first
-                // agent bundle's state/daemon/logs/ directory. Read the last line to
-                // surface what it's currently doing (e.g., "starting auto-start agents").
-                const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
-                if (!fs.existsSync(bundlesRoot))
-                    return null;
-                const agents = fs.readdirSync(bundlesRoot).filter((d) => d.endsWith(".ouro"));
-                for (const agent of agents) {
-                    const logPath = path.join(bundlesRoot, agent, "state", "daemon", "logs", "daemon.ndjson");
-                    if (!fs.existsSync(logPath))
-                        continue;
-                    const stat = fs.statSync(logPath);
-                    if (stat.size === 0)
-                        continue;
-                    // Only read logs from the last 30 seconds (daemon just started)
-                    const mtime = stat.mtimeMs;
-                    if (Date.now() - mtime > 30_000)
-                        continue;
-                    const buf = Buffer.alloc(4096);
-                    const fd = fs.openSync(logPath, "r");
+    const retryLimit = deps.startupRetryLimit ?? DEFAULT_DAEMON_STARTUP_RETRY_LIMIT;
+    let lastFailure = {
+        reason: "daemon failed before the startup monitor recorded a failure",
+        retryable: false,
+    };
+    let lastPid = null;
+    const readLatestDaemonStartupEvent = () => {
+        try {
+            // The daemon writes structured events to daemon.ndjson in the first
+            // agent bundle's state/daemon/logs/ directory. Read the last line to
+            // surface what it's currently doing (e.g., "starting auto-start agents").
+            const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
+            if (!fs.existsSync(bundlesRoot))
+                return null;
+            const agents = fs.readdirSync(bundlesRoot).filter((d) => d.endsWith(".ouro"));
+            for (const agent of agents) {
+                const logPath = path.join(bundlesRoot, agent, "state", "daemon", "logs", "daemon.ndjson");
+                if (!fs.existsSync(logPath))
+                    continue;
+                const stat = fs.statSync(logPath);
+                if (stat.size === 0)
+                    continue;
+                // Only read logs from the last 30 seconds (daemon just started)
+                const mtime = stat.mtimeMs;
+                if (Date.now() - mtime > 30_000)
+                    continue;
+                const buf = Buffer.alloc(4096);
+                const fd = fs.openSync(logPath, "r");
+                let bytesRead = 0;
+                try {
                     const readFrom = Math.max(0, stat.size - 4096);
-                    fs.readSync(fd, buf, 0, 4096, readFrom);
+                    bytesRead = fs.readSync(fd, buf, 0, 4096, readFrom);
+                }
+                finally {
                     fs.closeSync(fd);
-                    const lines = buf.toString("utf-8").trim().split("\n").filter(Boolean);
-                    const last = lines[lines.length - 1];
-                    if (!last)
-                        continue;
-                    const parsed = JSON.parse(last);
-                    return parsed.message ?? null;
                 }
+                const lines = buf.subarray(0, bytesRead).toString("utf-8").trim().split("\n").filter(Boolean);
+                const last = lines[lines.length - 1];
+                if (!last)
+                    continue;
+                const parsed = JSON.parse(last);
+                return parsed.message ?? null;
             }
-            catch { /* best effort */ }
-            return null;
-        },
-        /* v8 ignore stop */
-    });
+        }
+        catch {
+            // Best effort only.
+        }
+        return null;
+    };
+    for (let attempt = 0; attempt <= retryLimit; attempt += 1) {
+        deps.reportDaemonStartupPhase?.("starting daemon...");
+        deps.reportDaemonStartupPhase?.("waiting for daemon socket...");
+        deps.cleanupStaleSocket(deps.socketPath);
+        const bootStartedAtMs = (deps.now ?? Date.now)();
+        const started = await deps.startDaemonProcess(deps.socketPath);
+        lastPid = started.pid ?? null;
+        const startupFailure = await waitForDaemonStartup(deps, {
+            bootStartedAtMs,
+            pid: lastPid,
+        });
+        if (!startupFailure) {
+            const stability = await (0, startup_tui_1.pollDaemonStartup)({
+                sendCommand: deps.sendCommand,
+                socketPath: deps.socketPath,
+                daemonPid: lastPid,
+                /* v8 ignore next -- thin wrapper: raw process.stdout.write for ANSI cursor control @preserve */
+                writeRaw: (text) => process.stdout.write(text),
+                /* v8 ignore next -- thin wrapper: real Date.now() injected for testability @preserve */
+                now: () => Date.now(),
+                /* v8 ignore next -- thin wrapper: real setTimeout injected for testability @preserve */
+                sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+                /* v8 ignore start -- daemon log tail + pid check: reads real filesystem, tested via deployment @preserve */
+                readLatestDaemonEvent: readLatestDaemonStartupEvent,
+                /* v8 ignore stop */
+            });
+            return {
+                alreadyRunning: false,
+                message: `daemon started (pid ${lastPid ?? "unknown"})`,
+                stability,
+            };
+        }
+        lastFailure = startupFailure;
+        if (!startupFailure.retryable || attempt >= retryLimit) {
+            break;
+        }
+        deps.reportDaemonStartupPhase?.("daemon startup lost stability; cleaning up and retrying once...");
+    }
     return {
         alreadyRunning: false,
-        message: `daemon started (pid ${pid})`,
-        stability,
+        message: formatDaemonStartupFailureMessage(lastPid, lastFailure, deps),
     };
 }
+function hasStartupHealthMonitor(deps) {
+    return !!deps.healthFilePath && !!deps.readHealthState && !!deps.readHealthUpdatedAt;
+}
+function hasFreshCurrentBootHealthSignal(deps, bootStartedAtMs, pid) {
+    const healthState = deps.readHealthState(deps.healthFilePath);
+    if (!healthState)
+        return false;
+    const healthUpdatedAt = deps.readHealthUpdatedAt(deps.healthFilePath);
+    if (healthUpdatedAt === null || healthUpdatedAt < bootStartedAtMs) {
+        return false;
+    }
+    const healthStartedAtMs = Date.parse(healthState.startedAt);
+    if (!Number.isFinite(healthStartedAtMs) || healthStartedAtMs < bootStartedAtMs) {
+        return false;
+    }
+    if (pid !== null && healthState.pid !== pid) {
+        return false;
+    }
+    return true;
+}
+function formatDaemonStartupFailureMessage(pid, failure, deps) {
+    const lines = [
+        `daemon spawned (pid ${pid ?? "unknown"}) but failed to stabilize: ${failure.reason}`,
+    ];
+    const recentLogLines = deps.readRecentDaemonLogLines?.(DEFAULT_DAEMON_STARTUP_LOG_LINES) ?? [];
+    if (recentLogLines.length > 0) {
+        lines.push("recent daemon logs:");
+        lines.push(...recentLogLines.map((line) => `  ${line}`));
+    }
+    lines.push("fix hint for daemon: check daemon logs or run `ouro doctor`");
+    return lines.join("\n");
+}
+async function waitForDaemonStartup(deps, options) {
+    const now = deps.now ?? Date.now;
+    const sleep = deps.sleep ?? defaultSleep;
+    const timeoutMs = deps.startupTimeoutMs ?? DEFAULT_DAEMON_STARTUP_TIMEOUT_MS;
+    const pollIntervalMs = deps.startupPollIntervalMs ?? DEFAULT_DAEMON_STARTUP_POLL_INTERVAL_MS;
+    const stabilityWindowMs = deps.startupStabilityWindowMs ?? DEFAULT_DAEMON_STARTUP_STABILITY_WINDOW_MS;
+    const deadline = options.bootStartedAtMs + timeoutMs;
+    const useHealthMonitor = hasStartupHealthMonitor(deps);
+    let stableSinceMs = null;
+    let sawSocket = false;
+    if (!useHealthMonitor) {
+        const verified = await verifyDaemonAlive(deps.checkSocketAlive, deps.socketPath, timeoutMs, pollIntervalMs, sleep, now);
+        return verified
+            ? null
+            : {
+                reason: `daemon failed to respond within ${Math.ceil(timeoutMs / 1000)}s`,
+                retryable: false,
+            };
+    }
+    while (now() < deadline) {
+        await sleep(pollIntervalMs);
+        const aliveNow = await deps.checkSocketAlive(deps.socketPath);
+        if (!aliveNow) {
+            if (sawSocket) {
+                return {
+                    reason: "daemon socket disappeared during startup",
+                    retryable: true,
+                };
+            }
+            continue;
+        }
+        if (!sawSocket) {
+            sawSocket = true;
+            stableSinceMs = now();
+            deps.reportDaemonStartupPhase?.("verifying daemon health...");
+        }
+        if (!hasFreshCurrentBootHealthSignal(deps, options.bootStartedAtMs, options.pid)) {
+            continue;
+        }
+        if (stableSinceMs !== null && now() - stableSinceMs >= stabilityWindowMs) {
+            return null;
+        }
+    }
+    return {
+        reason: sawSocket
+            ? "daemon did not publish fresh health for the current boot attempt"
+            : `daemon failed to respond within ${Math.ceil(timeoutMs / 1000)}s`,
+        retryable: sawSocket,
+    };
+}
+async function verifyDaemonAlive(checkSocketAlive, socketPath, maxWaitMs = 10_000, pollIntervalMs = 500, sleep = defaultSleep, now = Date.now) {
+    const deadline = now() + maxWaitMs;
+    while (now() < deadline) {
+        await sleep(pollIntervalMs);
+        if (await checkSocketAlive(socketPath))
+            return true;
+    }
+    return false;
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 // ── GitHub Copilot model helpers ──
 async function listGithubCopilotModels(baseUrl, token, fetchImpl = fetch) {
     const url = `${baseUrl.replace(/\/+$/, "")}/models`;
@@ -933,7 +1064,13 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             progress.completePhase("bundle cleanup", `pruned ${prunedBundles.length} stale bundle${prunedBundles.length === 1 ? "" : "s"}`);
         }
         progress.startPhase("starting daemon");
-        const daemonResult = await ensureDaemonRunning(deps);
+        const daemonResult = await ensureDaemonRunning({
+            ...deps,
+            reportDaemonStartupPhase: (label) => {
+                ;
+                progress.announceStep?.(label);
+            },
+        });
         progress.end();
         deps.writeStdout(daemonResult.message);
         // Interactive repair for degraded agents (Unit 5) — skipped by --no-repair (Unit 6)

package/dist/heart/daemon/daemon-entry.js

@@ -169,19 +169,62 @@ const daemon = new daemon_1.OuroDaemon({
     router,
     mode,
 });
+const daemonStartedAt = new Date().toISOString();
+const degradedComponents = [];
+function buildDaemonHealthState() {
+    return {
+        status: degradedComponents.length > 0 ? "degraded" : "ok",
+        mode,
+        pid: process.pid,
+        startedAt: daemonStartedAt,
+        uptimeSeconds: Math.floor(process.uptime()),
+        safeMode: null,
+        degraded: degradedComponents.map((entry) => ({ ...entry })),
+        agents: {},
+        habits: {},
+    };
+}
+function recordRecoverableBootstrapFailure(options) {
+    const errorMessage = options.error instanceof Error ? options.error.message : String(options.error);
+    const existing = degradedComponents.find((entry) => entry.component === options.component);
+    const reason = `${errorMessage}. ${options.guidance}`;
+    if (existing) {
+        existing.reason = reason;
+    }
+    else {
+        degradedComponents.push({
+            component: options.component,
+            reason,
+            since: new Date().toISOString(),
+        });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "daemon",
+        event: "daemon.bootstrap_degraded",
+        message: "recoverable daemon bootstrap failure; daemon remains available in degraded mode",
+        meta: {
+            agent: options.agent,
+            component: options.component,
+            habitsDir: options.habitsDir,
+            error: errorMessage,
+            guidance: options.guidance,
+        },
+    });
+}
+function emitHabitSetupError(agent, error) {
+    const normalized = error instanceof Error ? error : new Error(String(error));
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.habit_setup_error",
+        message: `habit setup failed for agent ${agent}`,
+        meta: { agent, error: normalized.message },
+    });
+}
 /* v8 ignore start — daemon health writer wiring, tested via daemon-health.test.ts @preserve */
 const healthWriter = new daemon_health_1.DaemonHealthWriter((0, daemon_health_1.getDefaultHealthPath)());
-const healthSink = (0, daemon_health_1.createHealthNervesSink)(healthWriter, () => ({
-    status: "ok",
-    mode,
-    pid: process.pid,
-    startedAt: new Date().toISOString(),
-    uptimeSeconds: Math.floor(process.uptime()),
-    safeMode: null,
-    degraded: [],
-    agents: {},
-    habits: {},
-}));
+const healthSink = (0, daemon_health_1.createHealthNervesSink)(healthWriter, buildDaemonHealthState);
 (0, index_1.registerGlobalLogSink)(healthSink);
 /* v8 ignore stop */
 const habitSchedulers = [];
@@ -191,9 +234,10 @@ void daemon.start().then(() => {
     const ouroPath = (0, os_cron_deps_1.resolveOuroBinaryPath)();
     const osCronDeps = (0, os_cron_deps_1.createRealOsCronDeps)();
     for (const agent of managedAgents) {
+        const bundleRoot = path.join(bundlesRoot, `${agent}.ouro`);
+        const habitsDir = path.join(bundleRoot, "habits");
+        const degradedComponent = `habits:${agent}`;
         try {
-            const bundleRoot = path.join(bundlesRoot, `${agent}.ouro`);
-            const habitsDir = path.join(bundleRoot, "habits");
             // Migrate old tasks/habits/ to habits/ at bundle root
             (0, habit_migration_1.migrateHabitsFromTaskSystem)(bundleRoot);
             const osCronManager = new os_cron_1.LaunchdCronManager(osCronDeps);
@@ -214,19 +258,39 @@ void daemon.start().then(() => {
                     watch: (dir, cb) => fs.watch(dir, cb),
                 },
             });
-            scheduler.start();
-            scheduler.startPeriodicReconciliation();
-            scheduler.watchForChanges();
-            habitSchedulers.push(scheduler);
+            try {
+                scheduler.start();
+                scheduler.startPeriodicReconciliation();
+                scheduler.watchForChanges();
+                habitSchedulers.push(scheduler);
+            }
+            catch (error) {
+                try {
+                    scheduler.stopWatching();
+                    scheduler.stop();
+                }
+                catch {
+                    // Cleanup is best-effort for partially initialized schedulers.
+                }
+                emitHabitSetupError(agent, error);
+                recordRecoverableBootstrapFailure({
+                    agent,
+                    component: degradedComponent,
+                    habitsDir,
+                    error,
+                    guidance: `fix ${agent} habits or cron setup and rerun ouro up to restore habit automation`,
+                });
+            }
         }
         catch (err) {
             const error = err instanceof Error ? err : new Error(String(err));
-            (0, runtime_1.emitNervesEvent)({
-                level: "error",
-                component: "daemon",
-                event: "daemon.habit_setup_error",
-                message: `habit setup failed for agent ${agent}`,
-                meta: { agent, error: error.message },
+            emitHabitSetupError(agent, error);
+            recordRecoverableBootstrapFailure({
+                agent,
+                component: degradedComponent,
+                habitsDir,
+                error,
+                guidance: `fix ${agent} habits or cron setup and rerun ouro up to restore habit automation`,
             });
         }
     }

package/dist/heart/daemon/daemon-health.js

@@ -78,6 +78,7 @@ exports.HEALTH_TRACKED_EVENTS = new Set([
     "daemon.agent_restart_exhausted",
     "daemon.agent_permanent_failure",
     "daemon.agent_cooldown_recovery",
+    "daemon.bootstrap_degraded",
     "daemon.safe_mode_entered",
     "daemon.habit_scheduler_start",
 ]);

package/dist/heart/daemon/daemon.js

@@ -271,6 +271,24 @@ function writePidfile(extraPids = []) {
     }
     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,
@@ -355,6 +373,7 @@ class OuroDaemon {
     mode;
     server = null;
     outlookServer = null;
+    socketIdentity = null;
     outlookServerFactory;
     constructor(options) {
         this.socketPath = options.socketPath;
@@ -625,6 +644,7 @@ class OuroDaemon {
             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)({
@@ -827,9 +847,31 @@ class OuroDaemon {
             await this.outlookServer.stop();
             this.outlookServer = null;
         }
-        if (fs.existsSync(this.socketPath)) {
+        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;
     }
     async handleRawPayload(raw) {
         try {

package/dist/heart/daemon/up-progress.js

@@ -43,6 +43,15 @@ class UpProgress {
         }
         this.currentPhase = { label, startedAt: Date.now() };
     }
+    /**
+     * Emit a one-line status breadcrumb in non-TTY mode without affecting the
+     * accumulated checklist state. Used for daemon startup sub-steps.
+     */
+    announceStep(label) {
+        if (this.isTTY)
+            return;
+        this.write(label);
+    }
     /**
      * Mark the current phase as done. In non-TTY mode, immediately writes
      * a static line. Emits a nerves event for observability.