@ouro.bot/cli 0.1.0-alpha.192 → 0.1.0-alpha.194

package/changelog.json

@@ -1,10 +1,22 @@
 {
   "_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.194",
+      "changes": [
+        "fix(daemon): self-spawn restart \u2014 no longer relies on launchd KeepAlive for staged restarts",
+        "fix(daemon): error boundary with circuit breaker \u2014 uncaught exceptions logged and survived, exits only after 10+ in 60s",
+        "fix(daemon): EPIPE suppression in uncaughtException handler",
+        "fix(daemon): 5-second force-exit timeouts on all shutdown paths",
+        "feat: human-facing and agent-facing provider configs",
+        "fix(auth): always refresh codex OAuth token, responses API verification",
+        "feat: Outlook visibility \u2014 orientation, obligations, changes, self-fix, memory decisions, route migration to /"
+      ]
+    },
     {
       "version": "0.1.0-alpha.192",
       "changes": [
-        "refactor: canonical obligations — ActiveWorkFrame as single source of truth for prompt sections",
+        "refactor: canonical obligations \u2014 ActiveWorkFrame as single source of truth for prompt sections",
         "feat(mcp): dynamic server add/remove \u2014 agents can manage MCP servers without daemon restart"
       ]
     },
@@ -1198,4 +1210,4 @@
       ]
     }
   ]
-}
+}

package/dist/heart/daemon/auth-flow.js

@@ -235,7 +235,7 @@ function readCodexAccessToken(homeDir) {
         const raw = fs.readFileSync(authPath, "utf8");
         const parsed = JSON.parse(raw);
         const token = parsed?.tokens?.access_token;
-        return typeof token === "string" ? token.trim() : "";
+        return typeof token === "string" ? token.trim() : /* v8 ignore next -- defensive: codex login always writes a string token @preserve */ "";
     }
     catch {
         return "";
@@ -302,25 +302,25 @@ async function collectRuntimeAuthCredentials(input, deps) {
         return { githubToken: token, baseUrl };
     }
     if (input.provider === "openai-codex") {
-        let token = readCodexAccessToken(homeDir);
+        // Always run codex login when auth is explicitly requested — stale tokens
+        // are indistinguishable from valid ones without an API call, and the user
+        // is asking to re-authenticate.
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.auth_codex_login_start",
+            message: "starting codex login for runtime auth",
+            meta: { agentName: input.agentName },
+        });
+        const result = spawnSync("codex", ["login"], { stdio: "inherit" });
+        if (result.error) {
+            throw new Error(`Failed to run 'codex login': ${result.error.message}`);
+        }
+        if (result.status !== 0) {
+            throw new Error(`'codex login' exited with status ${result.status}.`);
+        }
+        const token = readCodexAccessToken(homeDir);
         if (!token) {
-            (0, runtime_1.emitNervesEvent)({
-                component: "daemon",
-                event: "daemon.auth_codex_login_start",
-                message: "starting codex login for runtime auth",
-                meta: { agentName: input.agentName },
-            });
-            const result = spawnSync("codex", ["login"], { stdio: "inherit" });
-            if (result.error) {
-                throw new Error(`Failed to run 'codex login': ${result.error.message}`);
-            }
-            if (result.status !== 0) {
-                throw new Error(`'codex login' exited with status ${result.status}.`);
-            }
-            token = readCodexAccessToken(homeDir);
-            if (!token) {
-                throw new Error("Codex login completed but no token was found in ~/.codex/auth.json. Re-run `codex login` and try again.");
-            }
+            throw new Error("Codex login completed but no token was found in ~/.codex/auth.json. Re-run `codex login` and try again.");
         }
         return { oauthAccessToken: token };
     }

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

@@ -170,11 +170,9 @@ void daemon.start().then(() => {
         scheduler.watchForChanges();
         habitSchedulers.push(scheduler);
     }
+    /* v8 ignore start -- startup failure + signal handlers: call process.exit, untestable in vitest @preserve */
 }).catch(async (err) => {
-    /* v8 ignore stop */
-    /* v8 ignore start — instanceof branch defensive; catch always receives Error in practice @preserve */
     const error = err instanceof Error ? err : new Error(String(err));
-    /* v8 ignore stop */
     (0, daemon_tombstone_1.writeDaemonTombstone)("startupFailure", error);
     (0, runtime_1.emitNervesEvent)({
         level: "error",
@@ -183,6 +181,7 @@ void daemon.start().then(() => {
         message: "daemon entrypoint failed",
         meta: { error: error.message },
     });
+    setTimeout(() => process.exit(1), 5_000).unref();
     await daemon.stop();
     process.exit(1);
 });
@@ -191,6 +190,7 @@ process.on("SIGINT", () => {
         s.stopWatching();
         s.stop();
     }
+    setTimeout(() => process.exit(1), 5_000).unref();
     void daemon.stop().then(() => process.exit(0));
 });
 process.on("SIGTERM", () => {
@@ -198,29 +198,46 @@ process.on("SIGTERM", () => {
         s.stopWatching();
         s.stop();
     }
+    setTimeout(() => process.exit(1), 5_000).unref();
     void daemon.stop().then(() => process.exit(0));
 });
+/* v8 ignore stop */
 // Suppress EPIPE on stdout/stderr — normal when detached daemon's parent exits
 /* v8 ignore start -- EPIPE suppression: only fires when parent process exits @preserve */
 process.stdout?.on?.("error", () => { });
 process.stderr?.on?.("error", () => { });
 /* v8 ignore stop */
 /* v8 ignore start -- global exception handlers: genuinely untestable in vitest; exercised by real daemon crashes @preserve */
+let _uncaughtCount = 0;
+const CIRCUIT_BREAKER_WINDOW_MS = 60_000;
+const CIRCUIT_BREAKER_MAX = 10;
 process.on("uncaughtException", (error) => {
     // EPIPE is normal for detached daemon processes — parent closed the pipe
     if (error.code === "EPIPE")
         return;
+    _uncaughtCount++;
+    setTimeout(() => { _uncaughtCount--; }, CIRCUIT_BREAKER_WINDOW_MS).unref();
     (0, daemon_tombstone_1.writeDaemonTombstone)("uncaughtException", error);
     (0, runtime_1.emitNervesEvent)({
         level: "error",
         component: "daemon",
         event: "daemon.uncaught_exception",
-        message: "uncaught exception in daemon process",
-        meta: { error: error.message, stack: error.stack ?? null },
+        message: "uncaught exception in daemon process (continuing)",
+        meta: { error: error.message, stack: error.stack ?? null, uncaughtCount: _uncaughtCount },
     });
-    // Graceful 5-second shutdown window
-    setTimeout(() => process.exit(1), 5_000).unref();
-    void daemon.stop().then(() => process.exit(1));
+    // Circuit breaker: if too many exceptions in a short window, the process
+    // is in a bad state — exit so launchd/self-spawn can restart fresh.
+    if (_uncaughtCount >= CIRCUIT_BREAKER_MAX) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.circuit_breaker_exit",
+            message: `daemon exiting: ${_uncaughtCount} uncaught exceptions in ${CIRCUIT_BREAKER_WINDOW_MS / 1000}s`,
+            meta: { uncaughtCount: _uncaughtCount },
+        });
+        setTimeout(() => process.exit(1), 5_000).unref();
+        void daemon.stop().then(() => process.exit(1));
+    }
 });
 process.on("unhandledRejection", (reason) => {
     (0, runtime_1.emitNervesEvent)({

package/dist/heart/daemon/daemon.js

@@ -208,7 +208,7 @@ class OuroDaemon {
                 daemon: "running",
                 health: workers.every((worker) => worker.status === "running") ? "ok" : "warn",
                 socketPath: this.socketPath,
-                outlookUrl: `${this.outlookServer?.origin ?? "http://127.0.0.1:0"}/outlook`,
+                outlookUrl: this.outlookServer?.origin ?? "http://127.0.0.1:0",
                 ...(0, runtime_metadata_1.getRuntimeMetadata)(),
                 workerCount: workers.length,
                 senseCount: senses.length,
@@ -236,6 +236,7 @@ class OuroDaemon {
         // Start periodic update checker (polls npm registry every 30 minutes)
         // Skip in dev mode — dev builds should not auto-update from npm
         const bundlesRoot = this.bundlesRoot;
+        const daemonSocketPath = this.socketPath;
         if (this.mode === "dev") {
             (0, runtime_1.emitNervesEvent)({
                 component: "daemon",
@@ -271,8 +272,19 @@ class OuroDaemon {
                             }
                         },
                         gracefulShutdown: () => daemon.stop(),
+                        spawnNewDaemon: (entryPath, sock) => {
+                            const outFd = fs.openSync(os.devNull, "w");
+                            const errFd = fs.openSync(os.devNull, "w");
+                            const child = (0, child_process_1.spawn)(process.execPath, [entryPath, "--socket", sock], {
+                                detached: true,
+                                stdio: ["ignore", outFd, errFd],
+                            });
+                            child.unref();
+                            return { pid: child.pid ?? null };
+                        },
                         nodePath: process.execPath,
                         bundlesRoot,
+                        socketPath: daemonSocketPath,
                     });
                 },
                 /* v8 ignore stop */

package/dist/heart/daemon/outlook-http.js

@@ -196,6 +196,12 @@ async function startOutlookHttpServer(options = {}) {
         readAgentBridges: options.readAgentBridges ?? ((agentName) => (0, outlook_read_1.readBridgeInventory)(agentRoot(agentName))),
         readAgentMemory: options.readAgentMemory ?? ((agentName) => (0, outlook_read_1.readMemoryView)(agentRoot(agentName))),
         readAgentFriends: options.readAgentFriends ?? ((agentName) => (0, outlook_read_1.readFriendView)(agentName, bundlesRoot ? { bundlesRoot } : undefined)),
+        readAgentContinuity: options.readAgentContinuity ?? ((agentName) => (0, outlook_read_1.readOutlookContinuity)(agentRoot(agentName), agentName)),
+        readAgentOrientation: options.readAgentOrientation ?? ((agentName) => (0, outlook_read_1.readOrientationView)(agentRoot(agentName), agentName)),
+        readAgentObligations: options.readAgentObligations ?? ((agentName) => (0, outlook_read_1.readObligationDetailView)(agentRoot(agentName))),
+        readAgentChanges: options.readAgentChanges ?? ((agentName) => (0, outlook_read_1.readChangesView)(agentRoot(agentName))),
+        readAgentSelfFix: options.readAgentSelfFix ?? ((agentName) => (0, outlook_read_1.readSelfFixView)(agentRoot(agentName))),
+        readAgentMemoryDecisions: options.readAgentMemoryDecisions ?? ((agentName) => (0, outlook_read_1.readMemoryDecisionView)(agentRoot(agentName))),
         readAgentHabits: options.readAgentHabits ?? ((agentName) => (0, outlook_read_1.readHabitView)(agentRoot(agentName))),
         readDaemonHealth: options.readDaemonHealth ?? (() => (0, outlook_read_1.readDaemonHealthDeep)(options.healthPath)),
         readLogs: options.readLogs ?? (() => (0, outlook_read_1.readLogView)(options.logPath ?? null)),
@@ -208,14 +214,8 @@ async function startOutlookHttpServer(options = {}) {
     }) : null;
     /* v8 ignore stop */
     const server = http.createServer((request, response) => {
-        const pathname = normalizePath(request.url);
+        let pathname = normalizePath(request.url);
         const origin = `http://${host}:${server.address().port}`;
-        if (pathname === "/outlook/api/events") {
-            response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", "connection": "keep-alive", "access-control-allow-origin": "*" });
-            response.write(":ok\n\n");
-            sse.add(response);
-            return;
-        }
         /* v8 ignore start — SPA static asset serving */
         // Serve built SPA static assets: /assets/*
         if (pathname.startsWith("/assets/")) {
@@ -235,23 +235,39 @@ async function startOutlookHttpServer(options = {}) {
             response.end();
             return;
         }
-        if (pathname === "/outlook/api/machine") {
+        // Compatibility alias: /outlook/api/* → /api/*
+        /* v8 ignore start -- legacy compat path: tested via integration @preserve */
+        if (pathname.startsWith("/outlook/api/")) {
+            pathname = pathname.slice("/outlook".length);
+        }
+        else if (pathname === "/outlook/api") {
+            pathname = "/api";
+        }
+        /* v8 ignore stop */
+        // SSE event stream
+        if (pathname === "/api/events") {
+            response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", "connection": "keep-alive", "access-control-allow-origin": "*" });
+            response.write(":ok\n\n");
+            sse.add(response);
+            return;
+        }
+        if (pathname === "/api/machine") {
             const machine = readMachineState();
             const machineView = readMachineView?.({ origin, machine });
             writeJson(response, 200, machineView ?? machine);
             return;
         }
-        if (pathname === "/outlook/api/machine/health") {
+        if (pathname === "/api/machine/health") {
             const health = hooks.readDaemonHealth();
             writeJson(response, 200, health ?? { status: "unavailable" });
             return;
         }
-        if (pathname === "/outlook/api/machine/logs") {
+        if (pathname === "/api/machine/logs") {
             writeJson(response, 200, hooks.readLogs());
             return;
         }
-        // Agent-level endpoints: /outlook/api/agents/:agent[/:surface[/:params...]]
-        const agentMatch = /^\/outlook\/api\/agents\/([^/]+)(?:\/(.+))?$/.exec(pathname);
+        // Agent-level endpoints: /api/agents/:agent[/:surface[/:params...]]
+        const agentMatch = /^\/api\/agents\/([^/]+)(?:\/(.+))?$/.exec(pathname);
         if (agentMatch) {
             const agent = decodeURIComponent(agentMatch[1]);
             const surface = agentMatch[2] ?? null;
@@ -306,6 +322,30 @@ async function startOutlookHttpServer(options = {}) {
                 writeJson(response, 200, hooks.readAgentFriends(agent));
                 return;
             }
+            if (surface === "continuity") {
+                writeJson(response, 200, hooks.readAgentContinuity(agent));
+                return;
+            }
+            if (surface === "orientation") {
+                writeJson(response, 200, hooks.readAgentOrientation(agent));
+                return;
+            }
+            if (surface === "obligations") {
+                writeJson(response, 200, hooks.readAgentObligations(agent));
+                return;
+            }
+            if (surface === "changes") {
+                writeJson(response, 200, hooks.readAgentChanges(agent));
+                return;
+            }
+            if (surface === "self-fix") {
+                writeJson(response, 200, hooks.readAgentSelfFix(agent));
+                return;
+            }
+            if (surface === "memory-decisions") {
+                writeJson(response, 200, hooks.readAgentMemoryDecisions(agent));
+                return;
+            }
             /* v8 ignore start — desk prefs write + reads */
             if (surface === "dismiss-obligation" && request.method === "POST") {
                 let body = "";

package/dist/heart/daemon/outlook-read.js

@@ -48,6 +48,11 @@ exports.readHabitView = readHabitView;
 exports.readNeedsMeView = readNeedsMeView;
 exports.readDeskPrefs = readDeskPrefs;
 exports.readOutlookContinuity = readOutlookContinuity;
+exports.readOrientationView = readOrientationView;
+exports.readObligationDetailView = readObligationDetailView;
+exports.readChangesView = readChangesView;
+exports.readSelfFixView = readSelfFixView;
+exports.readMemoryDecisionView = readMemoryDecisionView;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
@@ -1329,3 +1334,286 @@ function readOutlookContinuity(agentRoot, agentName) {
         },
     };
 }
+// ---------------------------------------------------------------------------
+// Orientation reader — daemon-side assembly of "where am I?"
+// ---------------------------------------------------------------------------
+function readOrientationView(agentRoot, agentName) {
+    // Read obligations for primary selection
+    let obligations = [];
+    try {
+        obligations = (0, obligations_1.readObligations)(agentRoot);
+    }
+    catch {
+        obligations = [];
+    }
+    const openObligations = obligations.filter(obligations_1.isOpenObligation);
+    // Select primary obligation (most advanced status, then most recent)
+    const statusPriority = {
+        returning: 0,
+        collaborating: 1,
+        in_progress: 2,
+        delegated: 3,
+        accepted: 4,
+        pending: 5,
+    };
+    const sorted = [...openObligations].sort((a, b) => {
+        const sp = (statusPriority[a.status] ?? 99) - (statusPriority[b.status] ?? 99);
+        if (sp !== 0)
+            return sp;
+        const aMs = new Date(a.updatedAt ?? a.createdAt).getTime();
+        const bMs = new Date(b.updatedAt ?? b.createdAt).getTime();
+        return bMs - aMs;
+    });
+    const primary = sorted[0] ?? null;
+    // Read session activity for current session and others
+    let sessions = [];
+    try {
+        sessions = (0, session_activity_1.listSessionActivity)({
+            sessionsDir: path.join(agentRoot, "state", "sessions"),
+            friendsDir: path.join(agentRoot, "friends"),
+            agentName,
+        });
+    }
+    catch {
+        sessions = [];
+    }
+    const sortedSessions = [...sessions].sort((a, b) => b.lastActivityMs - a.lastActivityMs);
+    const currentSession = sortedSessions.length > 0
+        ? {
+            friendId: sortedSessions[0].friendId,
+            channel: sortedSessions[0].channel,
+            key: sortedSessions[0].key,
+            lastActivityAt: sortedSessions[0].lastActivityAt,
+        }
+        : null;
+    const otherActiveSessions = sortedSessions.slice(1).map((s) => ({
+        friendId: s.friendId,
+        friendName: s.friendName,
+        channel: s.channel,
+        key: s.key,
+        lastActivityAt: s.lastActivityAt,
+    }));
+    // Derive center of gravity summary
+    const parts = [];
+    if (primary)
+        parts.push(primary.content);
+    if (openObligations.length > 1)
+        parts.push(`${openObligations.length} open obligations`);
+    if (sessions.length > 0)
+        parts.push(`${sessions.length} active sessions`);
+    const centerOfGravity = parts.length > 0 ? parts.join(" | ") : "idle";
+    const primaryObligation = primary
+        ? {
+            id: primary.id,
+            content: primary.content,
+            status: primary.status,
+            nextAction: primary.nextAction ?? null,
+            waitingOn: primary.meaning?.waitingOn?.detail ?? null,
+        }
+        : null;
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outlook_orientation_read",
+        message: `outlook orientation: ${openObligations.length} obligations, ${sessions.length} sessions`,
+        meta: { obligationCount: openObligations.length, sessionCount: sessions.length, primaryId: primary?.id ?? null },
+    });
+    return {
+        currentSession,
+        centerOfGravity,
+        primaryObligation,
+        resumeHandle: null,
+        otherActiveSessions,
+        rawState: null,
+    };
+}
+// ---------------------------------------------------------------------------
+// Obligation detail reader — richer view with primary selection context
+// ---------------------------------------------------------------------------
+function readObligationDetailView(agentRoot) {
+    let obligations = [];
+    try {
+        obligations = (0, obligations_1.readObligations)(agentRoot);
+    }
+    catch {
+        obligations = [];
+    }
+    const openObligations = obligations.filter(obligations_1.isOpenObligation);
+    // Select primary (same logic as orientation)
+    const statusPriority = {
+        returning: 0,
+        collaborating: 1,
+        in_progress: 2,
+        delegated: 3,
+        accepted: 4,
+        pending: 5,
+    };
+    const sorted = [...openObligations].sort((a, b) => {
+        const sp = (statusPriority[a.status] ?? 99) - (statusPriority[b.status] ?? 99);
+        if (sp !== 0)
+            return sp;
+        const aMs = new Date(a.updatedAt ?? a.createdAt).getTime();
+        const bMs = new Date(b.updatedAt ?? b.createdAt).getTime();
+        return bMs - aMs;
+    });
+    const primary = sorted[0] ?? null;
+    const items = openObligations.map((ob) => ({
+        id: ob.id,
+        status: ob.status,
+        content: ob.content,
+        updatedAt: ob.updatedAt ?? ob.createdAt,
+        nextAction: ob.nextAction ?? null,
+        origin: ob.origin ?? null,
+        currentSurface: ob.currentSurface ? { kind: ob.currentSurface.kind, label: ob.currentSurface.label } : null,
+        meaning: ob.meaning ? { waitingOn: ob.meaning.waitingOn?.detail ?? null } : null,
+        isPrimary: primary ? ob.id === primary.id : false,
+    }));
+    let primarySelectionReason = null;
+    if (primary) {
+        if (primary.status !== "pending") {
+            primarySelectionReason = `most advanced status: ${primary.status}`;
+        }
+        else {
+            primarySelectionReason = "most recent pending";
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outlook_obligations_read",
+        message: `outlook obligations: ${openObligations.length} open`,
+        meta: { openCount: openObligations.length, primaryId: primary?.id ?? null },
+    });
+    return {
+        openCount: openObligations.length,
+        primaryId: primary?.id ?? null,
+        primarySelectionReason,
+        items,
+    };
+}
+// ---------------------------------------------------------------------------
+// Changes reader — cross-session drift via snapshot comparison
+// ---------------------------------------------------------------------------
+const active_work_1 = require("../active-work");
+function readChangesView(agentRoot) {
+    const snapshotPath = path.join(agentRoot, "state", "outlook", "active-work-snapshot.json");
+    // Read prior snapshot
+    let previous = null;
+    try {
+        const raw = fs.readFileSync(snapshotPath, "utf-8");
+        previous = JSON.parse(raw);
+        if (!previous.obligationSnapshots || !previous.codingSnapshots)
+            previous = null;
+    }
+    catch {
+        previous = null;
+    }
+    // Build current snapshot from raw state
+    let obligations = [];
+    try {
+        obligations = (0, obligations_1.readObligations)(agentRoot);
+    }
+    catch {
+        obligations = [];
+    }
+    const openObligations = obligations.filter(obligations_1.isOpenObligation);
+    const current = {
+        obligationSnapshots: openObligations.map((ob) => ({
+            id: ob.id,
+            status: ob.status,
+            artifact: ob.currentArtifact?.trim() || null,
+            nextAction: ob.nextAction?.trim() || null,
+        })),
+        codingSnapshots: [],
+        timestamp: new Date().toISOString(),
+    };
+    // Persist current as the new snapshot
+    try {
+        fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+        fs.writeFileSync(snapshotPath, JSON.stringify(current, null, 2) + "\n", "utf-8");
+    }
+    catch {
+        // Best effort
+    }
+    if (!previous) {
+        return { changeCount: 0, items: [], snapshotAge: null, formatted: "" };
+    }
+    const changes = (0, active_work_1.detectActiveWorkChanges)(previous, current);
+    const formatted = (0, active_work_1.formatActiveWorkChanges)(changes);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outlook_changes_read",
+        message: `outlook changes: ${changes.length} detected`,
+        meta: { changeCount: changes.length, snapshotAge: previous.timestamp },
+    });
+    return {
+        changeCount: changes.length,
+        items: changes.map((c) => ({ kind: c.kind, id: c.id, from: c.from, to: c.to, summary: c.summary })),
+        snapshotAge: previous.timestamp,
+        formatted,
+    };
+}
+// ---------------------------------------------------------------------------
+// Self-fix workflow reader — derived from task board and coding state
+// ---------------------------------------------------------------------------
+function readSelfFixView(agentRoot) {
+    // Derive self-fix state from task scanner
+    let tasks = [];
+    try {
+        const scanned = (0, scanner_1.scanTasks)(path.join(agentRoot, "tasks"));
+        tasks = scanned.tasks.map((t) => ({ name: t.name, title: t.title, status: t.status }));
+    }
+    catch {
+        tasks = [];
+    }
+    // Look for self-fix-related tasks
+    const selfFixTasks = tasks.filter((t) => t.title.toLowerCase().includes("fix") || t.title.toLowerCase().includes("self-fix"));
+    if (selfFixTasks.length === 0) {
+        return { active: false, currentStep: null, steps: [] };
+    }
+    const steps = selfFixTasks.map((t) => ({
+        label: t.title,
+        status: t.status === "done" ? "done" : t.status === "processing" ? "active" : "pending",
+        detail: `task ${t.name}: ${t.status}`,
+    }));
+    const activeStep = steps.find((s) => s.status === "active");
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outlook_selffix_read",
+        message: `outlook self-fix: ${selfFixTasks.length} tasks`,
+        meta: { taskCount: selfFixTasks.length, active: !!activeStep },
+    });
+    return {
+        active: !!activeStep,
+        currentStep: activeStep?.label ?? null,
+        steps,
+    };
+}
+// ---------------------------------------------------------------------------
+// Memory decisions reader — append-only JSONL log
+// ---------------------------------------------------------------------------
+function readMemoryDecisionView(agentRoot, limit = 50) {
+    const logPath = path.join(agentRoot, "state", "outlook", "memory-decisions.jsonl");
+    let lines = [];
+    try {
+        const raw = fs.readFileSync(logPath, "utf-8");
+        lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    }
+    catch {
+        return { totalCount: 0, items: [] };
+    }
+    const items = [];
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.kind && parsed.decision && parsed.timestamp) {
+                items.push(parsed);
+            }
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    // Reverse chronological
+    items.reverse();
+    const limited = items.slice(0, limit);
+    return { totalCount: items.length, items: limited };
+}

package/dist/heart/daemon/staged-restart.js

@@ -90,25 +90,49 @@ async function performStagedRestart(version, deps) {
         });
         return { ok: false, error: `hook runner exited with code ${spawnResult.status}` };
     }
-    // Step 4: Graceful shutdown (launchd will restart with new code)
+    // Step 4: Graceful shutdown then self-spawn new daemon
+    // We can't rely on launchd KeepAlive — the plist may not be loaded.
+    // Instead: shut down (releases socket), spawn new daemon from updated code.
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.staged_restart_hooks_passed",
-        message: "hooks passed, shutting down for restart",
+        message: "hooks passed, shutting down and spawning new daemon",
         meta: { version },
     });
+    let shutdownError;
     try {
         await deps.gracefulShutdown();
     }
     catch (err) {
-        const shutdownError = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        shutdownError = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: "daemon.staged_restart_shutdown_error",
-            message: "graceful shutdown encountered error",
+            message: "graceful shutdown encountered error (continuing with spawn)",
             meta: { version, error: shutdownError },
         });
-        return { ok: true, shutdownError };
     }
-    return { ok: true };
+    // Spawn new daemon from updated code path
+    const newEntry = path.join(newCodePath, "dist", "heart", "daemon", "daemon-entry.js");
+    const socketArg = deps.socketPath ?? "/tmp/ouroboros-daemon.sock";
+    try {
+        const { pid } = deps.spawnNewDaemon(newEntry, socketArg);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_spawned",
+            message: "new daemon spawned successfully",
+            meta: { version, pid, entry: newEntry },
+        });
+    }
+    catch (err) {
+        const spawnError = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_respawn_failed",
+            message: "failed to spawn new daemon after shutdown",
+            meta: { version, error: spawnError, entry: newEntry },
+        });
+        return { ok: false, error: `shutdown succeeded but failed to spawn new daemon: ${spawnError}`, shutdownError };
+    }
+    return { ok: true, shutdownError };
 }