@ouro.bot/cli 0.1.0-alpha.314 → 0.1.0-alpha.316

package/changelog.json

@@ -1,6 +1,18 @@
 {
   "_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.316",
+      "changes": [
+        "feat(daemon): unified progress TUI for ouro up lifecycle. New UpProgress accumulated-checklist renderer replaces disconnected writeStdout calls with a cohesive progress display showing completed phases with checkmarks and active phase with spinner. In-place ANSI overwrite in TTY mode, static lines in non-TTY (CI/pipes). Wired into daemon.up handler for all phases: update check, system setup, agent updates, bundle pruning, daemon start. Emits nerves events for each phase completion."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.315",
+      "changes": [
+        "fix(tui): fix startup TUI ANSI overwrite, daemon death detection, and log visibility. Resolves visual corruption from overlapping ANSI escape sequences, improves process death detection reliability, and ensures daemon log output is consistently visible during startup."
+      ]
+    },
     {
       "version": "0.1.0-alpha.314",
       "changes": [

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

@@ -75,6 +75,7 @@ const interactive_repair_1 = require("./interactive-repair");
 const agentic_repair_1 = require("./agentic-repair");
 const startup_tui_1 = require("./startup-tui");
 const stale_bundle_prune_1 = require("./stale-bundle-prune");
+const up_progress_1 = require("./up-progress");
 // ── ensureDaemonRunning ──
 async function ensureDaemonRunning(deps) {
     const alive = await deps.checkSocketAlive(deps.socketPath);
@@ -118,24 +119,38 @@ async function ensureDaemonRunning(deps) {
     const stability = await (0, startup_tui_1.pollDaemonStartup)({
         sendCommand: deps.sendCommand,
         socketPath: deps.socketPath,
-        writeStdout: deps.writeStdout,
+        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: reads real filesystem, tested via deployment @preserve */
+        /* v8 ignore start -- daemon log tail + pid check: reads real filesystem, tested via deployment @preserve */
         readLatestDaemonEvent: () => {
             try {
-                const agents = fs.readdirSync((0, identity_1.getAgentBundlesRoot)()).filter((d) => d.endsWith(".ouro"));
+                // 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((0, identity_1.getAgentBundlesRoot)(), agent, "state", "daemon", "logs", "daemon.ndjson");
+                    const logPath = path.join(bundlesRoot, agent, "state", "daemon", "logs", "daemon.ndjson");
                     if (!fs.existsSync(logPath))
                         continue;
-                    const buf = Buffer.alloc(2048);
+                    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 stat = fs.fstatSync(fd);
-                    const readFrom = Math.max(0, stat.size - 2048);
-                    fs.readSync(fd, buf, 0, 2048, readFrom);
+                    const readFrom = Math.max(0, stat.size - 4096);
+                    fs.readSync(fd, buf, 0, 4096, readFrom);
                     fs.closeSync(fd);
                     const lines = buf.toString("utf-8").trim().split("\n").filter(Boolean);
                     const last = lines[lines.length - 1];
@@ -800,19 +815,19 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             }
         }
         const linkedVersionBeforeUp = deps.getCurrentCliVersion?.() ?? null;
+        const progress = new up_progress_1.UpProgress({ write: deps.writeStdout, isTTY: false });
         // ── versioned CLI update check ──
         if (deps.checkForCliUpdate) {
-            deps.writeStdout("checking for updates...");
+            progress.startPhase("update check");
             let pendingReExec = false;
             try {
                 const updateResult = await deps.checkForCliUpdate();
                 if (updateResult.available && updateResult.latestVersion) {
-                    deps.writeStdout(`installing ${updateResult.latestVersion}...`);
                     /* v8 ignore next -- fallback: getCurrentCliVersion always injected in tests @preserve */
                     const currentVersion = linkedVersionBeforeUp ?? "unknown";
                     await deps.installCliVersion(updateResult.latestVersion);
                     deps.activateCliVersion(updateResult.latestVersion);
-                    deps.writeStdout(`ouro updated to ${updateResult.latestVersion} (was ${currentVersion})`);
+                    progress.completePhase("update check", `installed ${updateResult.latestVersion}`);
                     const changelogCommand = (0, ouro_version_manager_1.buildChangelogCommand)(currentVersion, updateResult.latestVersion);
                     /* v8 ignore next -- buildChangelogCommand is non-null when an actual newer version is installed @preserve */
                     if (changelogCommand) {
@@ -833,13 +848,16 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             }
             /* v8 ignore stop */
             if (pendingReExec) {
+                progress.end();
                 deps.reExecFromNewVersion(args);
             }
             else {
-                deps.writeStdout("up to date.");
+                progress.completePhase("update check", "up to date");
             }
         }
+        progress.startPhase("system setup");
         await performSystemSetup(deps);
+        progress.completePhase("system setup");
         // Track whether we've already printed the "ouro updated to" message
         // this turn so the bundle-meta-fallback path below doesn't double-print.
         // There are three independent paths that can detect "the binary just
@@ -905,15 +923,18 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             const to = updateSummary.updated[0].to;
             const fromStr = from ? ` (was ${from})` : "";
             const count = agents.length;
-            deps.writeStdout(`updated ${count} agent${count === 1 ? "" : "s"} to runtime ${to}${fromStr}`);
+            progress.startPhase("agent updates");
+            progress.completePhase("agent updates", `${count} agent${count === 1 ? "" : "s"} to runtime ${to}${fromStr}`);
         }
         // ── stale bundle pruning ──
         const prunedBundles = (0, stale_bundle_prune_1.pruneStaleEphemeralBundles)({ bundlesRoot: deps.bundlesRoot });
-        for (const name of prunedBundles) {
-            deps.writeStdout(`pruned stale bundle: ${name}`);
+        if (prunedBundles.length > 0) {
+            progress.startPhase("bundle cleanup");
+            progress.completePhase("bundle cleanup", `pruned ${prunedBundles.length} stale bundle${prunedBundles.length === 1 ? "" : "s"}`);
         }
-        deps.writeStdout("starting daemon...");
+        progress.startPhase("starting daemon");
         const daemonResult = await ensureDaemonRunning(deps);
+        progress.end();
         deps.writeStdout(daemonResult.message);
         // Interactive repair for degraded agents (Unit 5) — skipped by --no-repair (Unit 6)
         if (daemonResult.stability?.degraded && daemonResult.stability.degraded.length > 0) {

package/dist/heart/daemon/startup-tui.js

@@ -13,6 +13,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assessStability = assessStability;
 exports.renderStartupProgress = renderStartupProgress;
+exports.renderWaitingForDaemon = renderWaitingForDaemon;
 exports.pollDaemonStartup = pollDaemonStartup;
 const cli_render_1 = require("./cli-render");
 const runtime_1 = require("../../nerves/runtime");
@@ -66,19 +67,13 @@ function assessStability(payload, now) {
 /**
  * Build an ANSI string for in-place terminal display during polling.
  * Uses cursor-up and line-clear escapes to overwrite previous output.
- *
- * @param payload  Current daemon status
- * @param elapsed  Milliseconds since polling started
- * @param prevLineCount  Number of lines written in the previous render (0 on first)
  */
 function renderStartupProgress(payload, elapsed, prevLineCount = 0) {
     const frameIndex = Math.floor(elapsed / 100) % SPINNER_FRAMES.length;
     const spinner = SPINNER_FRAMES[frameIndex];
     const lines = [];
-    // Header line
     const elapsedSec = (elapsed / 1000).toFixed(1);
     lines.push(`${spinner} ${BOLD}waiting for agents${RESET} ${DIM}(${elapsedSec}s)${RESET}`);
-    // Per-worker status lines
     for (const worker of payload.workers) {
         const statusColor = worker.status === "running" ? GREEN
             : worker.status === "crashed" ? RED
@@ -86,7 +81,27 @@ function renderStartupProgress(payload, elapsed, prevLineCount = 0) {
         const statusText = `${statusColor}${worker.status}${RESET}`;
         lines.push(`  ${worker.agent}/${worker.worker}: ${statusText}`);
     }
-    // Build output with cursor-up to overwrite previous lines
+    let output = "";
+    if (prevLineCount > 0) {
+        output += `\x1b[${prevLineCount}A`;
+    }
+    for (const line of lines) {
+        output += `\x1b[2K${line}\n`;
+    }
+    return output;
+}
+/**
+ * Render a pre-socket status line showing what the daemon is doing.
+ */
+function renderWaitingForDaemon(elapsed, latestEvent, prevLineCount = 0) {
+    const elapsedSec = (elapsed / 1000).toFixed(1);
+    const frameIndex = Math.floor(elapsed / 100) % SPINNER_FRAMES.length;
+    const spinner = SPINNER_FRAMES[frameIndex];
+    const lines = [];
+    lines.push(`${spinner} ${BOLD}waiting for daemon${RESET} ${DIM}(${elapsedSec}s)${RESET}`);
+    if (latestEvent) {
+        lines.push(`  ${DIM}${latestEvent}${RESET}`);
+    }
     let output = "";
     if (prevLineCount > 0) {
         output += `\x1b[${prevLineCount}A`;
@@ -119,15 +134,19 @@ function renderFinalSummary(result) {
 /**
  * Poll the daemon's status socket until all agents are stable or definitively
  * failed, rendering real-time progress to the terminal.
+ *
+ * Detects daemon process death: if the spawned PID is no longer alive and the
+ * socket never came up, reports the failure immediately instead of spinning.
  */
 async function pollDaemonStartup(deps) {
     const startTime = deps.now();
     let prevLineCount = 0;
+    const isAlive = deps.isProcessAlive ?? defaultIsProcessAlive;
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.startup_poll_start",
         message: "beginning startup stability polling",
-        meta: { socketPath: deps.socketPath },
+        meta: { socketPath: deps.socketPath, daemonPid: deps.daemonPid },
     });
     while (true) {
         const now = deps.now();
@@ -138,39 +157,47 @@ async function pollDaemonStartup(deps) {
             payload = (0, cli_render_1.parseStatusPayload)(response.data);
         }
         catch {
-            // Socket not yet available — show what the daemon is doing from its log
-            const elapsedSec = (elapsed / 1000).toFixed(1);
-            const frameIndex = Math.floor(elapsed / 100) % SPINNER_FRAMES.length;
-            const spinner = SPINNER_FRAMES[frameIndex];
-            const latestEvent = deps.readLatestDaemonEvent?.() ?? null;
-            const lines = [];
-            lines.push(`${spinner} ${BOLD}waiting for daemon${RESET} ${DIM}(${elapsedSec}s)${RESET}`);
-            if (latestEvent) {
-                lines.push(`  ${DIM}${latestEvent}${RESET}`);
-            }
-            let output = "";
-            if (prevLineCount > 0) {
-                output += `\x1b[${prevLineCount}A`;
-            }
-            for (const line of lines) {
-                output += `\x1b[2K${line}\n`;
+            // Socket not yet available — check if the daemon process is still alive
+            if (deps.daemonPid !== null && !isAlive(deps.daemonPid)) {
+                const latestEvent = deps.readLatestDaemonEvent?.() ?? null;
+                const errorMsg = latestEvent ?? "daemon process died during startup";
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.startup_process_died",
+                    message: "daemon process died before socket came up",
+                    meta: { pid: deps.daemonPid, lastEvent: latestEvent },
+                });
+                // Clear the waiting line
+                if (prevLineCount > 0) {
+                    let clear = `\x1b[${prevLineCount}A`;
+                    for (let i = 0; i < prevLineCount; i++)
+                        clear += `\x1b[2K\n`;
+                    deps.writeRaw(clear);
+                }
+                return {
+                    stable: [],
+                    degraded: [{ agent: "daemon", errorReason: errorMsg, fixHint: "check daemon logs or run `ouro doctor`" }],
+                };
             }
-            deps.writeStdout(output);
-            prevLineCount = lines.length;
+            // Show what the daemon is doing from its log
+            const latestEvent = deps.readLatestDaemonEvent?.() ?? null;
+            const output = renderWaitingForDaemon(elapsed, latestEvent, prevLineCount);
+            deps.writeRaw(output);
+            prevLineCount = latestEvent ? 2 : 1;
         }
         if (payload) {
             const output = renderStartupProgress(payload, elapsed, prevLineCount);
-            deps.writeStdout(output);
-            prevLineCount = payload.workers.length + 1; // header + per-worker lines
+            deps.writeRaw(output);
+            prevLineCount = payload.workers.length + 1;
             const assessment = assessStability(payload, now);
             if (assessment.resolved) {
                 const result = {
                     stable: assessment.stable,
                     degraded: assessment.degraded,
                 };
-                // Clear progress lines and render final summary
                 const summary = renderFinalSummary(result);
-                deps.writeStdout(summary);
+                deps.writeRaw(summary);
                 (0, runtime_1.emitNervesEvent)({
                     component: "daemon",
                     event: "daemon.startup_poll_end",
@@ -187,3 +214,14 @@ async function pollDaemonStartup(deps) {
         await deps.sleep(POLL_INTERVAL_MS);
     }
 }
+/* v8 ignore start -- process liveness check: uses real process.kill(0), tested via deployment @preserve */
+function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/* v8 ignore stop */

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

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * UpProgress — accumulated-checklist progress renderer for `ouro up`.
+ *
+ * Displays completed phases with checkmarks, the current phase with a
+ * spinner and elapsed time, and pending phases as plain text. Uses ANSI
+ * cursor control for in-place overwriting in TTY mode, and falls back to
+ * static line-per-phase output in non-TTY mode.
+ *
+ * The caller drives animation by calling `render(now)` on a setInterval.
+ * This module owns no timers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpProgress = void 0;
+const runtime_1 = require("../../nerves/runtime");
+// ── ANSI constants (shared with startup-tui.ts pattern) ──
+const SPINNER_FRAMES = "\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F";
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[38;2;46;204;64m";
+// ── UpProgress class ──
+class UpProgress {
+    write;
+    isTTY;
+    completed = [];
+    currentPhase = null;
+    prevLineCount = 0;
+    ended = false;
+    constructor(options) {
+        /* v8 ignore next -- thin wrapper: raw process.stdout.write for ANSI cursor control @preserve */
+        this.write = options?.write ?? ((text) => process.stdout.write(text));
+        /* v8 ignore next -- thin wrapper: real isTTY check injected for testability @preserve */
+        this.isTTY = options?.isTTY ?? (process.stdout.isTTY === true);
+    }
+    /**
+     * Begin a new phase with spinner. If a phase is already active, it is
+     * auto-completed (no detail text).
+     */
+    startPhase(label) {
+        if (this.currentPhase) {
+            this.completePhase(this.currentPhase.label);
+        }
+        this.currentPhase = { label, startedAt: Date.now() };
+    }
+    /**
+     * Mark the current phase as done. In non-TTY mode, immediately writes
+     * a static line. Emits a nerves event for observability.
+     */
+    completePhase(label, detail) {
+        if (!this.currentPhase) {
+            return;
+        }
+        const elapsedMs = Date.now() - this.currentPhase.startedAt;
+        this.completed.push({ label, detail });
+        this.currentPhase = null;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.up_phase_complete",
+            message: `phase complete: ${label}`,
+            meta: { phase: label, detail: detail ?? null, elapsedMs },
+        });
+        if (!this.isTTY) {
+            const detailStr = detail ? ` \u2014 ${detail}` : "";
+            this.write(`  \u2713 ${label}${detailStr}\n`);
+        }
+    }
+    /**
+     * Build an ANSI string for in-place terminal display. Returns empty
+     * string in non-TTY mode (output is written eagerly in completePhase).
+     */
+    render(now) {
+        if (!this.isTTY) {
+            return "";
+        }
+        const lines = [];
+        // Completed phases
+        for (const phase of this.completed) {
+            const detailStr = phase.detail ? ` ${DIM}\u2014 ${phase.detail}${RESET}` : "";
+            lines.push(`  ${GREEN}\u2713${RESET} ${phase.label}${detailStr}`);
+        }
+        // Current phase with spinner
+        if (this.currentPhase) {
+            const elapsed = now - this.currentPhase.startedAt;
+            const elapsedSec = (elapsed / 1000).toFixed(1);
+            const frameIndex = Math.floor(elapsed / 80) % SPINNER_FRAMES.length;
+            const spinner = SPINNER_FRAMES[frameIndex];
+            lines.push(`  ${BOLD}${spinner}${RESET} ${this.currentPhase.label} ${DIM}(${elapsedSec}s)${RESET}`);
+        }
+        let output = "";
+        if (this.prevLineCount > 0) {
+            output += `\x1b[${this.prevLineCount}A`;
+        }
+        for (const line of lines) {
+            output += `\x1b[2K${line}\n`;
+        }
+        // Clear any leftover lines from previous render that are no longer needed
+        if (lines.length < this.prevLineCount) {
+            for (let i = 0; i < this.prevLineCount - lines.length; i++) {
+                output += `\x1b[2K\n`;
+            }
+        }
+        this.prevLineCount = lines.length;
+        return output;
+    }
+    /**
+     * Finalize the progress display. Clears the current phase (if any) and
+     * writes the final checklist state. Idempotent.
+     */
+    end() {
+        if (this.ended) {
+            return;
+        }
+        this.ended = true;
+        if (this.currentPhase) {
+            this.currentPhase = null;
+        }
+        if (this.isTTY) {
+            const output = this.render(Date.now());
+            if (output) {
+                this.write(output);
+            }
+        }
+    }
+}
+exports.UpProgress = UpProgress;

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

@@ -68,6 +68,7 @@ const outlook_types_1 = require("./outlook-types");
 const presence_1 = require("../../arc/presence");
 const cares_1 = require("../../arc/cares");
 const episodes_1 = require("../../arc/episodes");
+const session_events_1 = require("../session-events");
 const LIVE_TASK_STATUSES = ["processing", "validating", "collaborating", "blocked"];
 const ACTIVE_CODING_STATUSES = new Set(["spawning", "running", "waiting_input", "stalled"]);
 const BLOCKED_CODING_STATUSES = new Set(["waiting_input", "stalled"]);
@@ -378,14 +379,18 @@ function readOutlookMachineState(options = {}) {
         agents: agentStates.map(summarizeAgent),
     };
 }
+// ---------------------------------------------------------------------------
+// Session inventory — enumerate all sessions with summary metadata
+// ---------------------------------------------------------------------------
 /* v8 ignore start — session envelope parsing utilities */
 function parseSessionUsage(raw) {
-    if (!raw)
+    if (!raw || typeof raw !== "object")
         return null;
-    const inputTokens = typeof raw.input_tokens === "number" ? raw.input_tokens : 0;
-    const outputTokens = typeof raw.output_tokens === "number" ? raw.output_tokens : 0;
-    const reasoningTokens = typeof raw.reasoning_tokens === "number" ? raw.reasoning_tokens : 0;
-    const totalTokens = typeof raw.total_tokens === "number" ? raw.total_tokens : 0;
+    const record = raw;
+    const inputTokens = typeof record.input_tokens === "number" ? record.input_tokens : 0;
+    const outputTokens = typeof record.output_tokens === "number" ? record.output_tokens : 0;
+    const reasoningTokens = typeof record.reasoning_tokens === "number" ? record.reasoning_tokens : 0;
+    const totalTokens = typeof record.total_tokens === "number" ? record.total_tokens : 0;
     if (inputTokens === 0 && outputTokens === 0 && totalTokens === 0)
         return null;
     return { input_tokens: inputTokens, output_tokens: outputTokens, reasoning_tokens: reasoningTokens, total_tokens: totalTokens };
@@ -393,33 +398,29 @@ function parseSessionUsage(raw) {
 function parseSessionContinuity(raw) {
     if (!raw)
         return null;
-    return {
-        mustResolveBeforeHandoff: raw.mustResolveBeforeHandoff === true,
-        lastFriendActivityAt: typeof raw.lastFriendActivityAt === "string" ? raw.lastFriendActivityAt : null,
+    if (typeof raw !== "object")
+        return null;
+    const record = raw;
+    const continuity = {
+        mustResolveBeforeHandoff: record.mustResolveBeforeHandoff === true,
+        lastFriendActivityAt: typeof record.lastFriendActivityAt === "string" ? record.lastFriendActivityAt : null,
     };
+    if (!continuity.mustResolveBeforeHandoff && continuity.lastFriendActivityAt === null)
+        return null;
+    return continuity;
 }
-function extractContent(message) {
-    if (typeof message.content === "string")
-        return message.content;
-    return null;
+function extractContent(event) {
+    if (!event)
+        return null;
+    const text = (0, session_events_1.extractEventText)(event);
+    return text.length > 0 ? text : null;
 }
-function extractToolCallNames(message) {
-    const toolCalls = message.tool_calls;
-    if (!Array.isArray(toolCalls))
+function extractToolCallNames(event) {
+    if (!event)
         return [];
-    return toolCalls
-        .map((call) => {
-        if (call && typeof call === "object" && "function" in call) {
-            const fn = call.function;
-            if (fn && typeof fn === "object" && "name" in fn) {
-                return typeof fn.name === "string" ? fn.name : null;
-            }
-        }
-        /* v8 ignore start */
-        return null;
-        /* v8 ignore stop */
-    })
-        .filter((name) => name !== null);
+    return event.toolCalls
+        .map((call) => call.function.name)
+        .filter((name) => typeof name === "string" && name.length > 0);
 }
 /* v8 ignore stop */
 function estimateTokenCount(messages) {
@@ -428,21 +429,13 @@ function estimateTokenCount(messages) {
         const content = extractContent(msg);
         if (content)
             charCount += content.length;
-        const toolCalls = msg.tool_calls;
-        if (Array.isArray(toolCalls)) {
-            charCount += JSON.stringify(toolCalls).length;
-        }
+        if (msg.toolCalls.length > 0)
+            charCount += JSON.stringify(msg.toolCalls).length;
     }
     return Math.ceil(charCount / 4);
 }
 function readSessionEnvelope(sessionPath) {
-    try {
-        const raw = fs.readFileSync(sessionPath, "utf-8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
+    return (0, session_events_1.loadSessionEnvelopeFile)(sessionPath);
 }
 /* v8 ignore start — filesystem traversal with defensive isDirectory checks */
 function resolveAllSessionPaths(sessionsDir) {
@@ -516,18 +509,26 @@ function readSessionInventory(agentName, options = {}) {
         if (friendId === "self" && channel === "inner")
             continue;
         const envelope = readSessionEnvelope(sessionPath);
-        const messages = Array.isArray(envelope?.messages) ? envelope.messages : [];
+        const events = envelope?.events ?? [];
+        const chronology = (0, session_events_1.deriveSessionChronology)(events);
         const lastUsage = parseSessionUsage(envelope?.lastUsage);
         const continuity = parseSessionContinuity(envelope?.state);
-        const lastActivityAt = continuity?.lastFriendActivityAt ?? safeFileMtime(sessionPath) ?? now.toISOString();
-        const activitySource = continuity?.lastFriendActivityAt ? "friend-facing" : "mtime-fallback";
-        const userMessages = messages.filter((m) => m.role === "user");
-        const assistantMessages = messages.filter((m) => m.role === "assistant");
+        const hasObservedEventTiming = events.some((event) => event.time.authoredAt !== null || event.time.observedAt !== null);
+        const lastActivityAt = hasObservedEventTiming
+            ? (chronology.lastActivityAt ?? continuity?.lastFriendActivityAt ?? safeFileMtime(sessionPath) ?? now.toISOString())
+            : (continuity?.lastFriendActivityAt ?? safeFileMtime(sessionPath) ?? now.toISOString());
+        const activitySource = hasObservedEventTiming && chronology.lastActivityAt
+            ? "event-timeline"
+            : continuity?.lastFriendActivityAt
+                ? "friend-facing"
+                : "mtime-fallback";
+        const userMessages = events.filter((m) => m.role === "user");
+        const assistantMessages = events.filter((m) => m.role === "assistant");
         const lastUser = userMessages.length > 0 ? userMessages[userMessages.length - 1] : null;
         const lastAssistant = assistantMessages.length > 0 ? assistantMessages[assistantMessages.length - 1] : null;
         const latestToolCallNames = [];
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const names = extractToolCallNames(messages[i]);
+        for (let i = events.length - 1; i >= 0; i--) {
+            const names = extractToolCallNames(events[i]);
             if (names.length > 0) {
                 latestToolCallNames.push(...names);
                 break;
@@ -535,7 +536,7 @@ function readSessionInventory(agentName, options = {}) {
         }
         const friendName = resolveFriendName(friendsDir, friendId);
         // Derive reply state from message pattern
-        const lastMsg = messages.length > 0 ? messages[messages.length - 1] : null;
+        const lastMsg = events.length > 0 ? events[events.length - 1] : null;
         const mustResolve = continuity?.mustResolveBeforeHandoff === true;
         let replyState = "idle";
         if (mustResolve) {
@@ -544,7 +545,7 @@ function readSessionInventory(agentName, options = {}) {
         else if (lastMsg?.role === "user") {
             replyState = "needs-reply";
         }
-        else if (messages.length > 0) {
+        else if (events.length > 0) {
             replyState = "monitoring";
         }
         items.push({
@@ -556,13 +557,13 @@ function readSessionInventory(agentName, options = {}) {
             lastActivityAt,
             activitySource,
             replyState,
-            messageCount: messages.length,
+            messageCount: events.length,
             lastUsage,
             continuity,
-            latestUserExcerpt: truncateExcerpt(extractContent(lastUser ?? {})),
-            latestAssistantExcerpt: truncateExcerpt(extractContent(lastAssistant ?? {})),
+            latestUserExcerpt: truncateExcerpt(extractContent(lastUser)),
+            latestAssistantExcerpt: truncateExcerpt(extractContent(lastAssistant)),
             latestToolCallNames,
-            estimatedTokens: messages.length > 0 ? estimateTokenCount(messages) : null,
+            estimatedTokens: events.length > 0 ? estimateTokenCount(events) : null,
         });
     }
     items.sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt));
@@ -606,34 +607,10 @@ function readSessionTranscript(agentName, friendId, channel, key, options = {})
     const envelope = readSessionEnvelope(sessionPath);
     if (!envelope)
         return null;
-    const rawMessages = Array.isArray(envelope.messages) ? envelope.messages : [];
+    const rawMessages = envelope.events;
     const friendsDir = path.join(agentRoot, "friends");
     const friendName = resolveFriendName(friendsDir, friendId);
-    const messages = rawMessages.map((msg, index) => {
-        const role = typeof msg.role === "string" ? msg.role : "user";
-        const content = extractContent(msg);
-        const result = { index, role, content };
-        if (typeof msg.name === "string")
-            result.name = msg.name;
-        if (typeof msg.tool_call_id === "string")
-            result.tool_call_id = msg.tool_call_id;
-        if (Array.isArray(msg.tool_calls)) {
-            result.tool_calls = msg.tool_calls
-                .filter((call) => call != null && typeof call === "object")
-                .map((call) => {
-                const fn = call.function;
-                return {
-                    id: typeof call.id === "string" ? call.id : "",
-                    type: typeof call.type === "string" ? call.type : "function",
-                    function: {
-                        name: typeof fn?.name === "string" ? fn.name : "unknown",
-                        arguments: typeof fn?.arguments === "string" ? fn.arguments : JSON.stringify(fn?.arguments ?? ""),
-                    },
-                };
-            });
-        }
-        return result;
-    });
+    const messages = rawMessages;
     return {
         friendId,
         friendName,