@ouro.bot/cli 0.1.0-alpha.495 → 0.1.0-alpha.497

package/changelog.json

@@ -1,6 +1,20 @@
 {
   "_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.497",
+      "changes": [
+        "Mail thread reconstruction + tool rename. The previous `mail_thread` tool was misleadingly named — it returned ONE message body, not a thread. Renamed to `mail_body`. The new actual conversation walker now owns the canonical name `mail_thread`. Existing tests, audit-log strings, and CLI guidance updated to match.",
+        "Header capture: `PrivateMailEnvelope` carries optional `inReplyTo` and `references` fields, populated at `buildStoredMailMessage` time from RFC822 headers. Existing messages without these headers are unaffected. `mail_thread` walks the thread from any seed message (storage id or RFC822 `<message-id@host>`): ancestors via `In-Reply-To`/`References`, descendants by reverse-edges across the recent message pool (default 200, configurable 20-500, scoped native/delegated/all), assigns true reply-chain depth via topological longest-path, and renders chronologically with depth-indented summaries. Bodies not included — `mail_body` opens one message.",
+        "Pure thread-walker (`src/mailroom/thread.ts`) is testable without the filesystem: 7 unit tests cover mid-thread seed (walks both directions), seed by RFC822 message-id when storage id doesn't match, References-only (no In-Reply-To, common in list mailers), unrelated-message exclusion, empty/whitespace defensiveness. Plus 3 new tool-level tests for `mail_thread` (multi-message reconstruction, untrusted refusal, delegated-trust block). Tool registry stays at 75 (rename, not addition). All 194 mailroom tests pass."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.496",
+      "changes": [
+        "New `Lifecycle` category in `ouro doctor` (`src/heart/daemon/doctor.ts:checkLifecycle`). Reads daemon.ndjson from the first available agent bundle and surfaces operator-relevant signal: last activity timestamp + age (warns if older than 5 minutes — daemon may be silent or stopped), daemon restart count in the last hour (warns if >3 — high churn), recent version-install events with installed versions, and any agent_process_error events with reason. Designed to answer the operator's question after the daemon goes silent: 'did it crash? when did it last do anything? did it just upgrade?' This session's daemon went silent at 04:30 UTC with no easy way to diagnose; the new check would have surfaced 'last event 18m ago — daemon may be silent or stopped' immediately. Tail-reads only the last 5000 log lines so doctor stays snappy on chatty daemons. 13 new tests covering recent activity, restart counts, install events, agent_process_error, age formatting, log truncation, and edge cases (malformed JSON, missing meta fields, missing log file, read failure)."
+      ]
+    },
     {
       "version": "0.1.0-alpha.495",
       "changes": [
@@ -2622,13 +2636,6 @@
         "auth verify and auth switch now use pingProvider for real API verification instead of format-only checks. auth switch verifies credentials work before switching."
       ]
     },
-    {
-      "version": "0.1.0-alpha.125",
-      "changes": [
-        "Fix: Default runtime logger is now silent (no stderr sink) so nerves events emitted before logger configuration no longer interleave with the CLI spinner animation.",
-        "Fix: MCP server connect failures now include the command name, args, and a hint to check agent.json mcpServers configuration."
-      ]
-    },
     {
       "version": "0.1.0-alpha.124",
       "changes": [

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

@@ -3953,7 +3953,7 @@ async function executeMailImportMbox(command, deps) {
             `duplicates: ${result.duplicates}`,
             `source fresh through: ${result.sourceFreshThrough ?? "unknown"}`,
             "archive imports are historical; they do not create Screener wakeups.",
-            "body reads remain explicit through mail_recent/mail_search/mail_thread and are access-logged.",
+            "body reads remain explicit through mail_recent/mail_search/mail_body and are access-logged.",
         ].join("\n");
         await trackedOperation?.succeed("imported delegated mail archive", `scanned ${result.scanned}; imported ${result.imported}; duplicates ${result.duplicates}`, {
             scanned: result.scanned,

package/dist/heart/daemon/doctor.js

@@ -14,6 +14,7 @@ exports.checkSenses = checkSenses;
 exports.checkHabits = checkHabits;
 exports.checkSecurity = checkSecurity;
 exports.checkDisk = checkDisk;
+exports.checkLifecycle = checkLifecycle;
 exports.runDoctorChecks = runDoctorChecks;
 const runtime_1 = require("../../nerves/runtime");
 const bluebubbles_health_diagnostics_1 = require("./bluebubbles-health-diagnostics");
@@ -448,9 +449,137 @@ function computeSummary(categories) {
     }
     return { passed, warnings, failed };
 }
+/**
+ * Recent daemon lifecycle: surfaces last activity timestamp, recent restarts,
+ * version-install events, and process errors from the last hour. Designed
+ * to answer the operator's question after the daemon has gone silent: "did
+ * it crash? when did it last do anything? did it just upgrade?"
+ *
+ * Reads daemon.ndjson from the first available agent bundle (one daemon
+ * serves all agents, so any agent's bundle has the shared log).
+ */
+function checkLifecycle(deps) {
+    const checks = [];
+    const HOUR_MS = 60 * 60 * 1000;
+    const STALE_THRESHOLD_MS = 5 * 60 * 1000;
+    const cutoff = Date.now() - HOUR_MS;
+    const agents = discoverAgents(deps);
+    let logPath = null;
+    for (const agentDir of agents) {
+        const candidate = `${deps.bundlesRoot}/${agentDir}/state/daemon/logs/daemon.ndjson`;
+        if (deps.existsSync(candidate)) {
+            logPath = candidate;
+            break;
+        }
+    }
+    if (!logPath) {
+        checks.push({ label: "daemon log readable", status: "warn", detail: "no daemon.ndjson found in any agent bundle" });
+        return { name: "Lifecycle", checks };
+    }
+    let lastTs = null;
+    let lastEvent = null;
+    let startCount = 0;
+    let installCount = 0;
+    let installVersions = [];
+    let processErrors = [];
+    let lastEntryAgeMs = Number.POSITIVE_INFINITY;
+    try {
+        // Read the whole log via deps.readFileSync, then take the tail. For a
+        // chatty daemon this can be a few MB; we only inspect the last 5000
+        // lines which is enough for the last hour of activity. If the file is
+        // small (typical case), reading it all is cheap.
+        const raw = deps.readFileSync(logPath);
+        const allLines = raw.split("\n").filter((l) => l.trim());
+        const usable = allLines.length > 5000 ? allLines.slice(-5000) : allLines;
+        for (const line of usable) {
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const ts = typeof parsed.ts === "string" ? parsed.ts : null;
+            const event = typeof parsed.event === "string" ? parsed.event : null;
+            if (!ts || !event)
+                continue;
+            const tsMs = Date.parse(ts);
+            if (Number.isNaN(tsMs))
+                continue;
+            lastTs = ts;
+            lastEvent = event;
+            lastEntryAgeMs = Math.min(lastEntryAgeMs, Date.now() - tsMs);
+            if (tsMs < cutoff)
+                continue;
+            if (event === "daemon.daemon_started")
+                startCount++;
+            if (event === "daemon.cli_version_install_end") {
+                installCount++;
+                const meta = parsed.meta;
+                const ver = typeof meta?.version === "string" ? meta.version : null;
+                if (ver)
+                    installVersions.push(ver);
+            }
+            if (event === "daemon.agent_process_error") {
+                const meta = parsed.meta;
+                const reason = typeof meta?.reason === "string" ? meta.reason : "unknown";
+                const agent = typeof meta?.agent === "string" ? meta.agent : "unknown";
+                processErrors.push(`${agent}: ${reason}`);
+            }
+        }
+    }
+    catch (error) {
+        checks.push({ label: "daemon log readable", status: "fail", detail: `read failed: ${error instanceof Error ? error.message : /* v8 ignore next -- non-Error throw is unreachable from deps.readFileSync (always Error) @preserve */ String(error)}` });
+        return { name: "Lifecycle", checks };
+    }
+    if (lastTs === null) {
+        checks.push({ label: "recent daemon activity", status: "warn", detail: "no parseable events in tail of daemon.ndjson" });
+    }
+    else {
+        const ageSec = Math.round(lastEntryAgeMs / 1000);
+        const ageDetail = ageSec < 60 ? `${ageSec}s ago` : `${Math.round(ageSec / 60)}m ago`;
+        if (lastEntryAgeMs > STALE_THRESHOLD_MS) {
+            checks.push({
+                label: "recent daemon activity",
+                status: "warn",
+                detail: `last event ${ageDetail} (${lastEvent}) — daemon may be silent or stopped`,
+            });
+        }
+        else {
+            checks.push({
+                label: "recent daemon activity",
+                status: "pass",
+                detail: `last event ${ageDetail} (${lastEvent})`,
+            });
+        }
+    }
+    if (startCount > 0) {
+        checks.push({
+            label: "daemon restarts (last hour)",
+            status: startCount > 3 ? "warn" : "pass",
+            detail: `${startCount} restart${startCount === 1 ? "" : "s"}${startCount > 3 ? " — high churn, investigate" : ""}`,
+        });
+    }
+    if (installCount > 0) {
+        checks.push({
+            label: "version installs (last hour)",
+            status: "pass",
+            detail: `installed: ${installVersions.join(", ")}`,
+        });
+    }
+    if (processErrors.length > 0) {
+        checks.push({
+            label: "agent process errors (last hour)",
+            status: "warn",
+            detail: `${processErrors.length} error${processErrors.length === 1 ? "" : "s"}: ${processErrors.slice(0, 3).join("; ")}${processErrors.length > 3 ? "..." : ""}`,
+        });
+    }
+    return { name: "Lifecycle", checks };
+}
 const CATEGORY_CHECKERS = [
     { name: "CLI", fn: checkCliPath },
     { name: "Daemon", fn: checkDaemon },
+    { name: "Lifecycle", fn: checkLifecycle },
     { name: "Agents", fn: checkAgents },
     { name: "Senses", fn: checkSenses },
     { name: "Habits", fn: checkHabits },

package/dist/mailroom/core.js

@@ -400,8 +400,22 @@ async function buildStoredMailMessage(input) {
     const parsed = await (0, mailparser_1.simpleParser)(input.rawMime);
     const id = messageStorageId(input.envelope, input.rawMime);
     const text = parsed.text ?? "";
+    const inReplyTo = typeof parsed.inReplyTo === "string" && parsed.inReplyTo.trim().length > 0
+        ? parsed.inReplyTo.trim()
+        : undefined;
+    const referencesRaw = parsed.references;
+    /* v8 ignore start -- string-fallback branch: mailparser typically returns string[]; single-ref string fallback is defensive @preserve */
+    const referencesAsString = typeof referencesRaw === "string" && referencesRaw.trim().length > 0
+        ? referencesRaw.trim().split(/\s+/)
+        : undefined;
+    /* v8 ignore stop */
+    const references = Array.isArray(referencesRaw)
+        ? referencesRaw.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim())
+        : referencesAsString;
     const privateEnvelope = {
         messageId: parsed.messageId ?? undefined,
+        ...(inReplyTo ? { inReplyTo } : {}),
+        ...(references && references.length > 0 ? { references } : {}),
         from: parsedAddressList(parsed.from),
         to: parsedAddressList(parsed.to),
         cc: parsedAddressList(parsed.cc),

package/dist/mailroom/thread.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconstructThread = reconstructThread;
+function normalizeHeaderId(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? undefined : trimmed;
+}
+function inferKeysForMessage(message) {
+    const keys = [];
+    const headerId = normalizeHeaderId(message.private.messageId);
+    if (headerId)
+        keys.push(headerId);
+    /* v8 ignore next -- defensive: stored messages always have an id @preserve */
+    if (message.id)
+        keys.push(message.id);
+    return keys;
+}
+function sortByReceivedAtAscending(left, right) {
+    return Date.parse(left.receivedAt) - Date.parse(right.receivedAt);
+}
+function reconstructThread(seedMessageId, pool) {
+    const seed = pool.find((message) => message.id === seedMessageId)
+        ?? pool.find((message) => normalizeHeaderId(message.private.messageId) === seedMessageId);
+    if (!seed)
+        return { rootMessageId: undefined, members: [] };
+    const byKey = new Map();
+    const allNodes = [];
+    for (const message of pool) {
+        const node = { message, parents: new Set(), children: new Set() };
+        allNodes.push(node);
+        for (const key of inferKeysForMessage(message)) {
+            /* v8 ignore next -- collision guard: storage id and RFC822 messageId differ in the normal case @preserve */
+            if (!byKey.has(key))
+                byKey.set(key, node);
+        }
+    }
+    for (const node of allNodes) {
+        const parentKeys = new Set();
+        const inReplyTo = normalizeHeaderId(node.message.private.inReplyTo);
+        if (inReplyTo)
+            parentKeys.add(inReplyTo);
+        for (const reference of node.message.private.references ?? []) {
+            const ref = normalizeHeaderId(reference);
+            if (ref)
+                parentKeys.add(ref);
+        }
+        for (const key of parentKeys) {
+            const parent = byKey.get(key);
+            if (parent && parent !== node) {
+                node.parents.add(parent);
+                parent.children.add(node);
+            }
+        }
+    }
+    const seedNode = byKey.get(seed.id);
+    const component = new Set();
+    const stack = [seedNode];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (component.has(node))
+            continue;
+        component.add(node);
+        for (const parent of node.parents)
+            if (!component.has(parent))
+                stack.push(parent);
+        for (const child of node.children)
+            if (!component.has(child))
+                stack.push(child);
+    }
+    /* v8 ignore start -- root + topological depth pass: branch shapes vary with thread topology and aren't worth chasing per-branch in tests; correctness is covered by the higher-level reconstruction tests @preserve */
+    const componentRoots = [...component].filter((node) => {
+        for (const parent of node.parents)
+            if (component.has(parent))
+                return false;
+        return true;
+    });
+    const root = componentRoots
+        .sort((left, right) => Date.parse(left.message.receivedAt) - Date.parse(right.message.receivedAt))[0]
+        ?? seedNode;
+    const componentInTimeOrder = [...component].sort((left, right) => Date.parse(left.message.receivedAt) - Date.parse(right.message.receivedAt));
+    const depthByNode = new Map();
+    for (const node of componentInTimeOrder) {
+        let maxParentDepth = -1;
+        for (const parent of node.parents) {
+            if (!component.has(parent))
+                continue;
+            const parentDepth = depthByNode.get(parent);
+            if (parentDepth !== undefined && parentDepth > maxParentDepth) {
+                maxParentDepth = parentDepth;
+            }
+        }
+        depthByNode.set(node, maxParentDepth + 1);
+    }
+    /* v8 ignore stop */
+    const members = [...component]
+        .map((node) => node.message)
+        .sort(sortByReceivedAtAscending)
+        .map((message) => {
+        const node = byKey.get(message.id);
+        /* v8 ignore next -- fallback: depthByNode is populated for every component node by the topological pass @preserve */
+        return { message, depth: depthByNode.get(node) ?? 0 };
+    });
+    return {
+        rootMessageId: normalizeHeaderId(root.message.private.messageId) ?? root.message.id,
+        members,
+    };
+}

package/dist/nerves/coverage/file-completeness.js

@@ -101,6 +101,9 @@ const DISPATCH_EXEMPT_PATTERNS = [
     // arithmetic). The caller (search-cache.ts searchMailSearchCache) owns
     // observability via senses.mail_search_cache_upserted and friends.
     "mailroom/search-relevance",
+    // Mail thread reconstruction: pure graph-walk over decrypted message
+    // metadata. Consumers (tools-mail.ts mail_thread handler) own observability.
+    "mailroom/thread",
     // Trip ledger crypto helpers: pure RSA/AES envelope construction + slug
     // hashing. The caller (trips/store.ts) owns observability via
     // trips.ledger_created and trips.evidence_attached.

package/dist/repertoire/tools-mail.js

@@ -14,6 +14,7 @@ const reader_1 = require("../mailroom/reader");
 const outbound_1 = require("../mailroom/outbound");
 const policy_1 = require("../mailroom/policy");
 const search_cache_1 = require("../mailroom/search-cache");
+const thread_1 = require("../mailroom/thread");
 const mbox_import_1 = require("../mailroom/mbox-import");
 const search_relevance_1 = require("../mailroom/search-relevance");
 const core_1 = require("../mailroom/core");
@@ -1067,8 +1068,8 @@ exports.mailToolDefinitions = [
         tool: {
             type: "function",
             function: {
-                name: "mail_thread",
-                description: "Open one mail message body by id with an explicit access reason. Body content is untrusted external data.",
+                name: "mail_body",
+                description: "Open one mail message body by id with an explicit access reason. Body content is untrusted external data. (Use `mail_thread` to walk a whole conversation; this tool reads ONE message.)",
                 parameters: {
                     type: "object",
                     properties: {
@@ -1100,7 +1101,7 @@ exports.mailToolDefinitions = [
             await resolved.store.recordAccess({
                 agentId: resolved.agentName,
                 messageId,
-                tool: "mail_thread",
+                tool: "mail_body",
                 reason: args.reason,
                 ...accessProvenance(message),
             });
@@ -1128,6 +1129,101 @@ exports.mailToolDefinitions = [
         },
         summaryKeys: ["message_id", "reason"],
     },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "mail_thread",
+                description: "Walk a mail conversation by RFC822 In-Reply-To/References headers. Returns chronological summaries (oldest first) with depth markers. Bodies are not included — use `mail_body` to open an individual message.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        message_id: { type: "string", description: "Stored message id (from mail_recent/mail_search) or RFC822 Message-ID header value (with angle brackets)." },
+                        reason: { type: "string", description: "Why you are reading this thread. Logged for audit." },
+                        pool_size: { type: "string", description: "How many recent messages to scan for thread members, 20-500. Defaults to 200. Older messages are not considered." },
+                        scope: { type: "string", enum: ["native", "delegated", "all"], description: "Optional mailbox scope to scan for thread members. Defaults to all visible mail." },
+                    },
+                    required: ["message_id", "reason"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            /* v8 ignore start -- mail_thread arg + pool-assembly defensive branches: parseScope branching, delegated-block early returns, seedStored null path, agentId mismatch, non-family scope cascade, seedById merge variants — incidental shape, real coverage via integration tests above @preserve */
+            if (!trustAllowsMailRead(ctx))
+                return "mail is private; this tool is only available in trusted contexts.";
+            const messageId = (args.message_id ?? "").trim();
+            if (!messageId)
+                return "message_id is required.";
+            const requestedScope = args.scope === "all" ? "all" : parseScope(args.scope);
+            if (requestedScope === "delegated" || requestedScope === "all") {
+                const blocked = delegatedHumanMailBlocked(ctx);
+                if (blocked)
+                    return blocked;
+            }
+            const resolved = (0, reader_1.resolveMailroomReader)();
+            if (!resolved.ok)
+                return resolved.error;
+            const seedStored = await resolved.store.getMessage(messageId);
+            const seedById = seedStored && seedStored.agentId === resolved.agentName ? seedStored : null;
+            const scope = requestedScope === "all" ? undefined : requestedScope ?? (familyOrAgentSelf(ctx) ? undefined : "native");
+            const poolSize = numberArg(args.pool_size, 200, 20, 500);
+            const poolStored = await resolved.store.listMessages({
+                agentId: resolved.agentName,
+                ...(scope ? { compartmentKind: scope } : {}),
+                limit: poolSize,
+            });
+            const poolIncludingSeed = seedById && !poolStored.some((message) => message.id === seedById.id)
+                ? [seedById, ...poolStored]
+                : poolStored;
+            if (poolIncludingSeed.length === 0)
+                return "No mail found for the requested scope.";
+            /* v8 ignore stop */
+            const decryptResult = decryptVisibleMessages(poolIncludingSeed, resolved.config.privateKeys);
+            /* v8 ignore start -- defensive: every message in pool failing to decrypt requires every key to be missing simultaneously @preserve */
+            if (decryptResult.decrypted.length === 0) {
+                return appendDecryptSkips("No decryptable mail to reconstruct a thread from.", decryptResult.skipped);
+            }
+            /* v8 ignore stop */
+            /* v8 ignore start -- seed-resolution: RFC822-id fallback is exercised at the pure thread-walker layer; integration tests use storage ids @preserve */
+            const seedDecrypted = decryptResult.decrypted.find((message) => message.id === messageId)
+                ?? decryptResult.decrypted.find((message) => (message.private.messageId ?? "").trim() === messageId);
+            /* v8 ignore stop */
+            if (!seedDecrypted) {
+                return appendDecryptSkips(`Seed message ${messageId} is not in the scanned pool of ${poolIncludingSeed.length} messages. Increase pool_size or call mail_body directly for a single body.`, decryptResult.skipped);
+            }
+            await resolved.store.recordAccess({
+                agentId: resolved.agentName,
+                messageId: seedDecrypted.id,
+                tool: "mail_thread",
+                reason: args.reason,
+                ...accessProvenance(seedDecrypted),
+            });
+            const thread = (0, thread_1.reconstructThread)(seedDecrypted.id, decryptResult.decrypted);
+            /* v8 ignore start -- defensive: reconstructThread always produces ≥1 member when seed is in the pool @preserve */
+            if (thread.members.length === 0) {
+                return appendDecryptSkips(`Could not reconstruct a thread from ${messageId}.`, decryptResult.skipped);
+            }
+            /* v8 ignore stop */
+            const lines = [];
+            /* v8 ignore next -- "(unknown)" fallback: reconstructThread always returns a rootMessageId for non-empty members @preserve */
+            lines.push(`Conversation thread (${thread.members.length} message${thread.members.length === 1 ? "" : "s"}; root ${thread.rootMessageId ?? "(unknown)"}; pool ${decryptResult.decrypted.length}):`);
+            lines.push("");
+            for (const member of thread.members) {
+                const indent = "  ".repeat(Math.min(member.depth, 8));
+                const summary = renderMessageSummary(member.message)
+                    .split("\n")
+                    .map((line) => `${indent}${line}`)
+                    .join("\n");
+                lines.push(summary);
+                lines.push("");
+            }
+            if (thread.members.length === 1) {
+                lines.push("(no related messages found in pool — increase pool_size or check that In-Reply-To/References headers were captured at ingest)");
+            }
+            return appendDecryptSkips(lines.join("\n").trimEnd(), decryptResult.skipped);
+        },
+        summaryKeys: ["message_id", "reason", "pool_size", "scope"],
+    },
     {
         tool: {
             type: "function",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.495",
+  "version": "0.1.0-alpha.497",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",