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

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

@@ -1,1595 +1,28 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readOutlookAgentState = readOutlookAgentState;
-exports.readOutlookMachineState = readOutlookMachineState;
-exports.readSessionInventory = readSessionInventory;
-exports.readSessionTranscript = readSessionTranscript;
-exports.readCodingDeep = readCodingDeep;
-exports.readAttentionView = readAttentionView;
-exports.readBridgeInventory = readBridgeInventory;
-exports.readDaemonHealthDeep = readDaemonHealthDeep;
-exports.readMemoryView = readMemoryView;
-exports.readFriendView = readFriendView;
-exports.readLogView = readLogView;
-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");
-const identity_1 = require("../identity");
-const obligations_1 = require("../../arc/obligations");
-const session_activity_1 = require("../session-activity");
-const board_1 = require("../../repertoire/tasks/board");
-const scanner_1 = require("../../repertoire/tasks/scanner");
-const agent_discovery_1 = require("../daemon/agent-discovery");
-const runtime_metadata_1 = require("../daemon/runtime-metadata");
-const thoughts_1 = require("../daemon/thoughts");
-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"]);
-const STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
-function issue(code, detail) {
-    return { code, detail };
-}
-function emptyByStatus() {
-    return {
-        drafting: 0,
-        processing: 0,
-        validating: 0,
-        collaborating: 0,
-        paused: 0,
-        blocked: 0,
-        cancelled: 0,
-        done: 0,
-    };
-}
-function readAgentConfig(agentRoot) {
-    const configPath = path.join(agentRoot, "agent.json");
-    try {
-        const raw = fs.readFileSync(configPath, "utf-8");
-        const parsed = JSON.parse(raw);
-        const senses = Object.entries(parsed.senses ?? {})
-            .filter(([, value]) => value && typeof value.enabled === "boolean" && value.enabled)
-            .map(([name]) => name)
-            .sort((left, right) => left.localeCompare(right));
-        return {
-            summary: {
-                enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : true,
-                provider: typeof parsed.provider === "string" ? parsed.provider : null,
-                senses,
-            },
-            issues: [],
-        };
-    }
-    catch (error) {
-        return {
-            summary: {
-                enabled: false,
-                provider: null,
-                senses: [],
-            },
-            issues: [issue("agent-config-unreadable", `${configPath}: ${error instanceof Error ? error.message : String(error)}`)],
-        };
-    }
-}
-function readTaskSummary(agentRoot) {
-    const taskRoot = path.join(agentRoot, "tasks");
-    const index = (0, scanner_1.scanTasks)(taskRoot);
-    const board = (0, board_1.buildTaskBoard)(index);
-    const byStatus = emptyByStatus();
-    for (const status of Object.keys(byStatus)) {
-        byStatus[status] = board.byStatus[status].length;
-    }
-    const liveTaskNames = LIVE_TASK_STATUSES.flatMap((status) => board.byStatus[status]);
-    const issues = index.issues.map((taskIssue) => issue(taskIssue.code, `${taskIssue.target}: ${taskIssue.description}`));
-    return {
-        summary: {
-            totalCount: index.tasks.length,
-            liveCount: liveTaskNames.length,
-            blockedCount: board.byStatus.blocked.length,
-            byStatus,
-            liveTaskNames,
-            actionRequired: [...board.actionRequired],
-            activeBridges: [...board.activeBridges],
-        },
-        issues,
-    };
-}
-function readObligationSummary(agentRoot) {
-    const items = (0, obligations_1.readPendingObligations)(agentRoot)
-        .map((obligation) => ({
-        id: obligation.id,
-        status: obligation.status,
-        content: obligation.content,
-        updatedAt: obligation.updatedAt ?? obligation.createdAt,
-        nextAction: obligation.nextAction ?? null,
-        /* v8 ignore start */
-        origin: obligation.origin ?? null,
-        currentSurface: obligation.currentSurface ?? null,
-        /* v8 ignore stop */
-    }))
-        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-    return { items };
-}
-function readSessionSummary(agentName, agentRoot, now) {
-    const items = (0, session_activity_1.listSessionActivity)({
-        sessionsDir: path.join(agentRoot, "state", "sessions"),
-        friendsDir: path.join(agentRoot, "friends"),
-        agentName,
-        nowMs: now.getTime(),
-    })
-        .filter((session) => !(session.friendId === "self" && session.channel === "inner"))
-        .map((session) => ({
-        friendId: session.friendId,
-        friendName: session.friendName,
-        channel: session.channel,
-        key: session.key,
-        sessionPath: session.sessionPath,
-        lastActivityAt: session.lastActivityAt,
-        activitySource: session.activitySource,
-    }));
-    return { items };
-}
-function readInnerSummary(agentRoot) {
-    const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
-    const pendingDir = path.join(agentRoot, "state", "pending", "self", "inner", "dialog");
-    const { pendingMessages, turns, runtimeState } = (0, thoughts_1.readInnerDialogRawData)(sessionPath, pendingDir);
-    const job = (0, thoughts_1.deriveInnerJob)(pendingMessages, turns, runtimeState);
-    const surfacedSummary = job.surfacedResult ? (0, thoughts_1.formatSurfacedValue)(job.surfacedResult) : null;
-    const latestPendingTimestamp = pendingMessages.length > 0
-        ? new Date(Math.max(...pendingMessages.map((message) => message.timestamp))).toISOString()
-        : null;
-    const latestActivityAt = latestPendingTimestamp
-        ?? runtimeState?.startedAt
-        ?? runtimeState?.lastCompletedAt
-        ?? null;
-    return {
-        summary: {
-            visibility: outlook_types_1.OUTLOOK_DEFAULT_INNER_VISIBILITY,
-            status: job.status,
-            hasPending: pendingMessages.length > 0,
-            surfacedSummary,
-            origin: job.origin,
-            obligationStatus: job.obligationStatus,
-            latestActivityAt,
-        },
-        issues: [],
-        latestActivityAt,
-    };
-}
-function readCodingSummary(agentRoot) {
-    const stateFilePath = path.join(agentRoot, "state", "coding", "sessions.json");
-    const issues = [];
-    if (!fs.existsSync(stateFilePath)) {
-        return { items: [], issues };
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(stateFilePath, "utf-8"));
-    }
-    catch (error) {
-        issues.push(issue("coding-state-unreadable", `${stateFilePath}: ${error instanceof Error ? error.message : String(error)}`));
-        return { items: [], issues };
-    }
-    const items = Array.isArray(parsed.records)
-        ? parsed.records.flatMap((record) => {
-            const session = record?.session;
-            if (!session || typeof session.id !== "string" || typeof session.runner !== "string" || typeof session.status !== "string" || typeof session.workdir !== "string" || typeof session.lastActivityAt !== "string") {
-                return [];
-            }
-            const checkpoint = typeof session.checkpoint === "string"
-                ? session.checkpoint
-                : typeof session.stderrTail === "string" && session.stderrTail.trim().length > 0
-                    ? session.stderrTail.trim()
-                    : typeof session.stdoutTail === "string" && session.stdoutTail.trim().length > 0
-                        ? session.stdoutTail.trim()
-                        : null;
-            const originSession = session.originSession;
-            const normalizedOrigin = originSession
-                && typeof originSession.friendId === "string"
-                && typeof originSession.channel === "string"
-                && typeof originSession.key === "string"
-                ? {
-                    friendId: originSession.friendId,
-                    channel: originSession.channel,
-                    key: originSession.key,
-                }
-                : null;
-            return [{
-                    id: session.id,
-                    runner: session.runner,
-                    status: session.status,
-                    checkpoint,
-                    taskRef: typeof session.taskRef === "string" ? session.taskRef : null,
-                    workdir: session.workdir,
-                    originSession: normalizedOrigin,
-                    lastActivityAt: session.lastActivityAt,
-                }];
-        })
-        : [];
-    return { items, issues };
-}
-function collectLatestActivityTimestamps(input) {
-    const timestamps = [];
-    for (const item of input.obligations)
-        timestamps.push(item.updatedAt);
-    for (const item of input.sessions)
-        timestamps.push(item.lastActivityAt);
-    for (const item of input.coding)
-        timestamps.push(item.lastActivityAt);
-    if (input.innerLatestActivityAt)
-        timestamps.push(input.innerLatestActivityAt);
-    return timestamps
-        .filter((value) => Number.isFinite(Date.parse(value)));
-}
-function summarizeFreshness(latestActivityAt, now) {
-    if (!latestActivityAt) {
-        return {
-            status: "unknown",
-            latestActivityAt: null,
-            ageMs: null,
-        };
-    }
-    const ageMs = now.getTime() - Date.parse(latestActivityAt);
-    return {
-        status: ageMs > STALE_THRESHOLD_MS ? "stale" : "fresh",
-        latestActivityAt,
-        ageMs,
-    };
-}
-function summarizeDegraded(issues) {
-    return {
-        status: issues.length > 0 ? "degraded" : "ok",
-        issues,
-    };
-}
-function summarizeAgent(state) {
-    return {
-        agentName: state.agentName,
-        enabled: state.enabled,
-        freshness: state.freshness,
-        degraded: state.degraded,
-        tasks: {
-            liveCount: state.tasks.liveCount,
-            blockedCount: state.tasks.blockedCount,
-        },
-        obligations: {
-            openCount: state.obligations.openCount,
-        },
-        coding: {
-            activeCount: state.coding.activeCount,
-            blockedCount: state.coding.blockedCount,
-        },
-    };
-}
-function readOutlookAgentState(agentName, options = {}) {
-    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
-    const now = options.now?.() ?? new Date();
-    const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);
-    const issues = [];
-    const config = readAgentConfig(agentRoot);
-    issues.push(...config.issues);
-    const tasks = readTaskSummary(agentRoot);
-    issues.push(...tasks.issues);
-    const obligations = readObligationSummary(agentRoot);
-    const sessions = readSessionSummary(agentName, agentRoot, now);
-    const inner = readInnerSummary(agentRoot);
-    issues.push(...inner.issues);
-    const coding = readCodingSummary(agentRoot);
-    issues.push(...coding.issues);
-    const latestActivityAt = collectLatestActivityTimestamps({
-        obligations: obligations.items,
-        sessions: sessions.items,
-        innerLatestActivityAt: inner.latestActivityAt,
-        coding: coding.items,
-    }).sort((left, right) => right.localeCompare(left))[0] ?? null;
-    return {
-        productName: outlook_types_1.OUTLOOK_PRODUCT_NAME,
-        agentName,
-        agentRoot,
-        enabled: config.summary.enabled,
-        provider: config.summary.provider,
-        senses: config.summary.senses,
-        freshness: summarizeFreshness(latestActivityAt, now),
-        degraded: summarizeDegraded(issues),
-        tasks: tasks.summary,
-        obligations: {
-            openCount: obligations.items.length,
-            items: obligations.items,
-        },
-        sessions: {
-            liveCount: sessions.items.length,
-            items: sessions.items,
-        },
-        inner: inner.summary,
-        coding: {
-            totalCount: coding.items.length,
-            activeCount: coding.items.filter((item) => ACTIVE_CODING_STATUSES.has(item.status)).length,
-            blockedCount: coding.items.filter((item) => BLOCKED_CODING_STATUSES.has(item.status)).length,
-            items: coding.items,
-        },
-    };
-}
-function readOutlookMachineState(options = {}) {
-    /* v8 ignore next */
-    (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.outlook_read", message: "reading outlook machine state", meta: {} });
-    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
-    const now = options.now?.() ?? new Date();
-    const runtime = options.runtimeMetadata ?? (0, runtime_metadata_1.getRuntimeMetadata)({ bundlesRoot });
-    const agentNames = options.agentNames ?? (0, agent_discovery_1.listEnabledBundleAgents)({ bundlesRoot });
-    const agentStates = agentNames.map((agentName) => readOutlookAgentState(agentName, { ...options, bundlesRoot, now: () => now }));
-    const degradedIssues = agentStates
-        .flatMap((state) => state.degraded.issues.map((problem) => issue("agent-degraded", `${state.agentName}: ${problem.detail}`)));
-    const freshest = agentStates
-        .map((state) => state.freshness.latestActivityAt)
-        .filter((value) => typeof value === "string")
-        .sort((left, right) => right.localeCompare(left))[0] ?? null;
-    return {
-        productName: outlook_types_1.OUTLOOK_PRODUCT_NAME,
-        observedAt: now.toISOString(),
-        runtime,
-        agentCount: agentStates.length,
-        freshness: summarizeFreshness(freshest, now),
-        degraded: summarizeDegraded(degradedIssues),
-        agents: agentStates.map(summarizeAgent),
-    };
-}
-// ---------------------------------------------------------------------------
-// Session inventory — enumerate all sessions with summary metadata
-// ---------------------------------------------------------------------------
-/* v8 ignore start — session envelope parsing utilities */
-function parseSessionUsage(raw) {
-    if (!raw || typeof raw !== "object")
-        return null;
-    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 };
-}
-function parseSessionContinuity(raw) {
-    if (!raw)
-        return 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(event) {
-    if (!event)
-        return null;
-    const text = (0, session_events_1.extractEventText)(event);
-    return text.length > 0 ? text : null;
-}
-function extractToolCallNames(event) {
-    if (!event)
-        return [];
-    return event.toolCalls
-        .map((call) => call.function.name)
-        .filter((name) => typeof name === "string" && name.length > 0);
-}
-/* v8 ignore stop */
-function estimateTokenCount(messages) {
-    let charCount = 0;
-    for (const msg of messages) {
-        const content = extractContent(msg);
-        if (content)
-            charCount += content.length;
-        if (msg.toolCalls.length > 0)
-            charCount += JSON.stringify(msg.toolCalls).length;
-    }
-    return Math.ceil(charCount / 4);
-}
-function readSessionEnvelope(sessionPath) {
-    return (0, session_events_1.loadSessionEnvelopeFile)(sessionPath);
-}
-/* v8 ignore start — filesystem traversal with defensive isDirectory checks */
-function resolveAllSessionPaths(sessionsDir) {
-    const results = [];
-    if (!fs.existsSync(sessionsDir))
-        return results;
-    for (const friendId of safeReaddir(sessionsDir)) {
-        const friendDir = path.join(sessionsDir, friendId);
-        if (!safeIsDirectory(friendDir))
-            continue;
-        for (const channel of safeReaddir(friendDir)) {
-            const channelDir = path.join(friendDir, channel);
-            if (!safeIsDirectory(channelDir))
-                continue;
-            for (const file of safeReaddir(channelDir)) {
-                if (!file.endsWith(".json"))
-                    continue;
-                const key = file.slice(0, -5);
-                results.push({
-                    friendId,
-                    channel,
-                    key,
-                    sessionPath: path.join(channelDir, file),
-                });
-            }
-        }
-    }
-    return results;
-}
-/* v8 ignore stop */
-function safeReaddir(dir) {
-    try {
-        return fs.readdirSync(dir);
-    }
-    catch {
-        return [];
-    }
-}
-function safeIsDirectory(filePath) {
-    try {
-        return fs.statSync(filePath).isDirectory();
-        /* v8 ignore start */
-    }
-    catch {
-        return false;
-    }
-    /* v8 ignore stop */
-}
-/* v8 ignore start — defensive friend name resolution */
-function resolveFriendName(friendsDir, friendId) {
-    try {
-        const raw = fs.readFileSync(path.join(friendsDir, `${friendId}.json`), "utf-8");
-        const parsed = JSON.parse(raw);
-        return typeof parsed.name === "string" ? parsed.name : friendId;
-    }
-    catch {
-        return friendId;
-    }
-}
-/* v8 ignore stop */
-/* v8 ignore start — session inventory with defensive parsing */
-function readSessionInventory(agentName, options = {}) {
-    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
-    const now = options.now?.() ?? new Date();
-    const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);
-    const sessionsDir = path.join(agentRoot, "state", "sessions");
-    const friendsDir = path.join(agentRoot, "friends");
-    const allSessions = resolveAllSessionPaths(sessionsDir);
-    const items = [];
-    for (const { friendId, channel, key, sessionPath } of allSessions) {
-        if (friendId === "self" && channel === "inner")
-            continue;
-        const envelope = readSessionEnvelope(sessionPath);
-        const events = envelope?.events ?? [];
-        const chronology = (0, session_events_1.deriveSessionChronology)(events);
-        const lastUsage = parseSessionUsage(envelope?.lastUsage);
-        const continuity = parseSessionContinuity(envelope?.state);
-        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 = events.length - 1; i >= 0; i--) {
-            const names = extractToolCallNames(events[i]);
-            if (names.length > 0) {
-                latestToolCallNames.push(...names);
-                break;
-            }
-        }
-        const friendName = resolveFriendName(friendsDir, friendId);
-        // Derive reply state from message pattern
-        const lastMsg = events.length > 0 ? events[events.length - 1] : null;
-        const mustResolve = continuity?.mustResolveBeforeHandoff === true;
-        let replyState = "idle";
-        if (mustResolve) {
-            replyState = "on-hold";
-        }
-        else if (lastMsg?.role === "user") {
-            replyState = "needs-reply";
-        }
-        else if (events.length > 0) {
-            replyState = "monitoring";
-        }
-        items.push({
-            friendId,
-            friendName,
-            channel,
-            key,
-            sessionPath,
-            lastActivityAt,
-            activitySource,
-            replyState,
-            messageCount: events.length,
-            lastUsage,
-            continuity,
-            latestUserExcerpt: truncateExcerpt(extractContent(lastUser)),
-            latestAssistantExcerpt: truncateExcerpt(extractContent(lastAssistant)),
-            latestToolCallNames,
-            estimatedTokens: events.length > 0 ? estimateTokenCount(events) : null,
-        });
-    }
-    items.sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt));
-    const ageThreshold = now.getTime() - STALE_THRESHOLD_MS;
-    const activeCount = items.filter((item) => Date.parse(item.lastActivityAt) >= ageThreshold).length;
-    return {
-        totalCount: items.length,
-        activeCount,
-        staleCount: items.length - activeCount,
-        items,
-    };
-}
-/* v8 ignore start — utility helpers with defensive branches */
-function truncateExcerpt(content, maxLength = 200) {
-    if (!content)
-        return null;
-    if (content.length <= maxLength)
-        return content;
-    const truncated = content.slice(0, maxLength);
-    const lastSpace = truncated.lastIndexOf(" ");
-    return (lastSpace > maxLength * 0.6 ? truncated.slice(0, lastSpace) : truncated) + "…";
-}
-function safeFileMtime(filePath) {
-    try {
-        return fs.statSync(filePath).mtime.toISOString();
-    }
-    catch {
-        return null;
-    }
-}
-/* v8 ignore stop */
-// ---------------------------------------------------------------------------
-/* v8 ignore stop */
-// Session transcript — full x-ray of one session
-// ---------------------------------------------------------------------------
-/* v8 ignore start — defensive parsing */
-function readSessionTranscript(agentName, friendId, channel, key, options = {}) {
-    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
-    const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);
-    const sessionPath = path.join(agentRoot, "state", "sessions", friendId, channel, `${key}.json`);
-    const envelope = readSessionEnvelope(sessionPath);
-    if (!envelope)
-        return null;
-    const rawMessages = envelope.events;
-    const friendsDir = path.join(agentRoot, "friends");
-    const friendName = resolveFriendName(friendsDir, friendId);
-    const messages = rawMessages;
-    return {
-        friendId,
-        friendName,
-        channel,
-        key,
-        sessionPath,
-        messageCount: messages.length,
-        lastUsage: parseSessionUsage(envelope.lastUsage),
-        continuity: parseSessionContinuity(envelope.state),
-        messages,
-    };
-}
-// ---------------------------------------------------------------------------
-// Coding deep — full details for all coding sessions
-// ---------------------------------------------------------------------------
-/* v8 ignore start — defensive parsing of on-disk JSON, fallback branches are safety nets */
-function readCodingDeep(agentRoot) {
-    const stateFilePath = path.join(agentRoot, "state", "coding", "sessions.json");
-    if (!fs.existsSync(stateFilePath)) {
-        return { totalCount: 0, activeCount: 0, blockedCount: 0, items: [] };
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(stateFilePath, "utf-8"));
-    }
-    catch {
-        return { totalCount: 0, activeCount: 0, blockedCount: 0, items: [] };
-    }
-    const items = Array.isArray(parsed.records)
-        ? parsed.records.flatMap((record) => {
-            const s = record?.session;
-            if (!s || typeof s.id !== "string" || typeof s.status !== "string")
-                return [];
-            const checkpoint = typeof s.checkpoint === "string" ? s.checkpoint
-                : typeof s.stderrTail === "string" && s.stderrTail.trim().length > 0 ? s.stderrTail.trim()
-                    : typeof s.stdoutTail === "string" && s.stdoutTail.trim().length > 0 ? s.stdoutTail.trim()
-                        : null;
-            const originSession = s.originSession;
-            const normalizedOrigin = originSession
-                && typeof originSession.friendId === "string"
-                && typeof originSession.channel === "string"
-                && typeof originSession.key === "string"
-                ? { friendId: originSession.friendId, channel: originSession.channel, key: originSession.key }
-                : null;
-            const failure = s.failure;
-            const normalizedFailure = failure && typeof failure === "object"
-                ? {
-                    command: typeof failure.command === "string" ? failure.command : "",
-                    args: Array.isArray(failure.args) ? failure.args.map(String) : [],
-                    code: typeof failure.code === "number" ? failure.code : null,
-                    signal: typeof failure.signal === "string" ? failure.signal : null,
-                    stdoutTail: typeof failure.stdoutTail === "string" ? failure.stdoutTail : "",
-                    stderrTail: typeof failure.stderrTail === "string" ? failure.stderrTail : "",
-                }
-                : null;
-            return [{
-                    id: s.id,
-                    runner: (typeof s.runner === "string" ? s.runner : "claude"),
-                    status: s.status,
-                    checkpoint,
-                    taskRef: typeof s.taskRef === "string" ? s.taskRef : null,
-                    workdir: typeof s.workdir === "string" ? s.workdir : "",
-                    originSession: normalizedOrigin,
-                    obligationId: typeof s.obligationId === "string" ? s.obligationId : null,
-                    scopeFile: typeof s.scopeFile === "string" ? s.scopeFile : null,
-                    stateFile: typeof s.stateFile === "string" ? s.stateFile : null,
-                    artifactPath: typeof s.artifactPath === "string" ? s.artifactPath : null,
-                    pid: typeof s.pid === "number" ? s.pid : null,
-                    startedAt: typeof s.startedAt === "string" ? s.startedAt : "",
-                    lastActivityAt: typeof s.lastActivityAt === "string" ? s.lastActivityAt : "",
-                    endedAt: typeof s.endedAt === "string" ? s.endedAt : null,
-                    restartCount: typeof s.restartCount === "number" ? s.restartCount : 0,
-                    lastExitCode: typeof s.lastExitCode === "number" ? s.lastExitCode : null,
-                    lastSignal: typeof s.lastSignal === "string" ? s.lastSignal : null,
-                    stdoutTail: typeof s.stdoutTail === "string" ? s.stdoutTail : "",
-                    stderrTail: typeof s.stderrTail === "string" ? s.stderrTail : "",
-                    failure: normalizedFailure,
-                }];
-        })
-        : [];
-    return {
-        totalCount: items.length,
-        activeCount: items.filter((item) => ACTIVE_CODING_STATUSES.has(item.status)).length,
-        blockedCount: items.filter((item) => BLOCKED_CODING_STATUSES.has(item.status)).length,
-        items,
-    };
-}
-// ---------------------------------------------------------------------------
-// Attention / pending / inbox
-// ---------------------------------------------------------------------------
-/* v8 ignore stop */
-function scanPendingChannels(agentRoot) {
-    const pendingRoot = path.join(agentRoot, "state", "pending");
-    const channels = [];
-    for (const friendId of safeReaddir(pendingRoot)) {
-        if (friendId === "self")
-            continue;
-        const friendDir = path.join(pendingRoot, friendId);
-        if (!safeIsDirectory(friendDir))
-            continue;
-        for (const channel of safeReaddir(friendDir)) {
-            const channelDir = path.join(friendDir, channel);
-            if (!safeIsDirectory(channelDir))
-                continue;
-            for (const key of safeReaddir(channelDir)) {
-                const keyDir = path.join(channelDir, key);
-                if (!safeIsDirectory(keyDir))
-                    continue;
-                const files = safeReaddir(keyDir).filter((f) => f.endsWith(".json") || f.endsWith(".json.processing"));
-                if (files.length > 0) {
-                    channels.push({ friendId, channel, key, messageCount: files.length });
-                }
-            }
-        }
-    }
-    return channels;
-}
-function readPendingMessagesNonDestructive(pendingDir) {
-    const files = safeReaddir(pendingDir).filter((f) => f.endsWith(".json") || f.endsWith(".json.processing"));
-    const messages = [];
-    for (const file of files.sort()) {
-        try {
-            const raw = fs.readFileSync(path.join(pendingDir, file), "utf-8");
-            messages.push(JSON.parse(raw));
-        }
-        catch {
-            // skip unparseable pending messages
-        }
-    }
-    return messages;
-}
-/* v8 ignore stop */
-function readAttentionView(agentName, options = {}) {
-    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
-    const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);
-    const friendsDir = path.join(agentRoot, "friends");
-    const pendingChannels = scanPendingChannels(agentRoot);
-    // Build attention queue items from pending messages across all channels
-    const queueItems = [];
-    const pendingRoot = path.join(agentRoot, "state", "pending");
-    for (const pending of pendingChannels) {
-        const pendingDir = path.join(pendingRoot, pending.friendId, pending.channel, pending.key);
-        const messages = readPendingMessagesNonDestructive(pendingDir);
-        for (const msg of messages) {
-            const delegatedFrom = msg.delegatedFrom;
-            queueItems.push({
-                id: typeof msg.timestamp === "number" ? `${msg.timestamp}-${pending.friendId}` : `pending-${Date.now()}`,
-                friendId: pending.friendId,
-                friendName: resolveFriendName(friendsDir, pending.friendId),
-                channel: pending.channel,
-                key: pending.key,
-                bridgeId: delegatedFrom && typeof delegatedFrom.bridgeId === "string" ? delegatedFrom.bridgeId : null,
-                delegatedContent: typeof msg.content === "string" ? msg.content : "",
-                obligationId: typeof msg.obligationId === "string" ? msg.obligationId : null,
-                source: "pending",
-                timestamp: typeof msg.timestamp === "number" ? msg.timestamp : 0,
-            });
-        }
-    }
-    queueItems.sort((a, b) => a.timestamp - b.timestamp);
-    // Return obligations
-    const returnObligations = readObligationSummary(agentRoot).items;
-    return {
-        queueLength: queueItems.length,
-        queueItems,
-        pendingChannels,
-        returnObligations,
-    };
-}
-// ---------------------------------------------------------------------------
-// Bridge inventory — all bridge records
-// ---------------------------------------------------------------------------
-/* v8 ignore start — defensive parsing */
-function readBridgeInventory(agentRoot) {
-    const bridgesDir = path.join(agentRoot, "state", "bridges");
-    const items = [];
-    for (const file of safeReaddir(bridgesDir)) {
-        if (!file.endsWith(".json"))
-            continue;
-        try {
-            const raw = fs.readFileSync(path.join(bridgesDir, file), "utf-8");
-            const bridge = JSON.parse(raw);
-            if (typeof bridge.id !== "string")
-                continue;
-            const attachedSessions = Array.isArray(bridge.attachedSessions)
-                ? bridge.attachedSessions
-                    .filter((s) => typeof s.friendId === "string")
-                    .map((s) => ({
-                    friendId: s.friendId,
-                    channel: typeof s.channel === "string" ? s.channel : "",
-                    key: typeof s.key === "string" ? s.key : "",
-                    sessionPath: typeof s.sessionPath === "string" ? s.sessionPath : "",
-                    snapshot: typeof s.snapshot === "string" ? s.snapshot : null,
-                }))
-                : [];
-            const taskLink = bridge.task;
-            const normalizedTask = taskLink && typeof taskLink === "object" && typeof taskLink.taskName === "string"
-                ? {
-                    taskName: taskLink.taskName,
-                    path: typeof taskLink.path === "string" ? taskLink.path : "",
-                    mode: typeof taskLink.mode === "string" ? taskLink.mode : "bound",
-                    boundAt: typeof taskLink.boundAt === "string" ? taskLink.boundAt : "",
-                }
-                : null;
-            items.push({
-                id: bridge.id,
-                objective: typeof bridge.objective === "string" ? bridge.objective : "",
-                summary: typeof bridge.summary === "string" ? bridge.summary : "",
-                lifecycle: typeof bridge.lifecycle === "string" ? bridge.lifecycle : "unknown",
-                runtime: typeof bridge.runtime === "string" ? bridge.runtime : "unknown",
-                createdAt: typeof bridge.createdAt === "string" ? bridge.createdAt : "",
-                updatedAt: typeof bridge.updatedAt === "string" ? bridge.updatedAt : "",
-                attachedSessions,
-                task: normalizedTask,
-            });
-        }
-        catch {
-            // skip unparseable bridge files
-        }
-    }
-    items.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-    const activeCount = items.filter((item) => item.lifecycle === "active").length;
-    return {
-        totalCount: items.length,
-        activeCount,
-        items,
-    };
-}
-// ---------------------------------------------------------------------------
-// Daemon health deep
-// ---------------------------------------------------------------------------
-/* v8 ignore stop */
-/* v8 ignore start — defensive parsing */
-function readDaemonHealthDeep(healthPath) {
-    const resolvedPath = healthPath ?? path.join(process.env.HOME ?? "", ".ouro-cli", "daemon-health.json");
-    try {
-        const raw = fs.readFileSync(resolvedPath, "utf-8");
-        const health = JSON.parse(raw);
-        return {
-            status: typeof health.status === "string" ? health.status : "unknown",
-            mode: typeof health.mode === "string" ? health.mode : "unknown",
-            pid: typeof health.pid === "number" ? health.pid : 0,
-            startedAt: typeof health.startedAt === "string" ? health.startedAt : "",
-            uptimeSeconds: typeof health.uptimeSeconds === "number" ? health.uptimeSeconds : 0,
-            safeMode: health.safeMode && typeof health.safeMode === "object"
-                ? {
-                    active: health.safeMode.active === true,
-                    reason: typeof health.safeMode.reason === "string" ? health.safeMode.reason : "",
-                    enteredAt: typeof health.safeMode.enteredAt === "string" ? health.safeMode.enteredAt : "",
-                }
-                : null,
-            degradedComponents: Array.isArray(health.degraded)
-                ? health.degraded.map((c) => ({
-                    component: typeof c.component === "string" ? c.component : "",
-                    reason: typeof c.reason === "string" ? c.reason : "",
-                    since: typeof c.since === "string" ? c.since : "",
-                }))
-                : [],
-            agentHealth: health.agents && typeof health.agents === "object"
-                ? Object.fromEntries(Object.entries(health.agents).map(([name, entry]) => [
-                    name,
-                    {
-                        status: typeof entry.status === "string" ? entry.status : "unknown",
-                        pid: typeof entry.pid === "number" ? entry.pid : null,
-                        crashes: typeof entry.crashes === "number" ? entry.crashes : 0,
-                    },
-                ]))
-                : {},
-            habitHealth: health.habits && typeof health.habits === "object"
-                ? Object.fromEntries(Object.entries(health.habits).map(([name, entry]) => [
-                    name,
-                    {
-                        cronStatus: typeof entry.cronStatus === "string" ? entry.cronStatus : "unknown",
-                        lastFired: typeof entry.lastFired === "string" ? entry.lastFired : null,
-                        fallback: entry.fallback === true,
-                    },
-                ]))
-                : {},
-        };
-    }
-    catch {
-        return null;
-    }
-}
-// ---------------------------------------------------------------------------
-// Memory / journal inspection
-// ---------------------------------------------------------------------------
-/* v8 ignore stop */
-/* v8 ignore start — defensive parsing */
-function readMemoryView(agentRoot) {
-    // Read diary entries from facts.jsonl
-    const diaryRoot = path.join(agentRoot, "diary");
-    const effectiveDiaryRoot = fs.existsSync(diaryRoot) ? diaryRoot : null;
-    const diaryEntries = [];
-    if (effectiveDiaryRoot) {
-        const factsPath = path.join(effectiveDiaryRoot, "facts.jsonl");
-        try {
-            const raw = fs.readFileSync(factsPath, "utf-8");
-            for (const line of raw.split("\n")) {
-                if (!line.trim())
-                    continue;
-                try {
-                    const entry = JSON.parse(line);
-                    if (typeof entry.id === "string" && typeof entry.text === "string") {
-                        diaryEntries.push({
-                            id: entry.id,
-                            text: entry.text,
-                            source: typeof entry.source === "string" ? entry.source : "",
-                            createdAt: typeof entry.createdAt === "string" ? entry.createdAt : "",
-                        });
-                    }
-                }
-                catch {
-                    // skip unparseable lines
-                }
-            }
-        }
-        catch {
-            // no diary facts file
-        }
-    }
-    // Sort by createdAt descending, take recent
-    diaryEntries.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-    // Read journal index
-    const journalDir = path.join(agentRoot, "journal");
-    const journalEntries = [];
-    const indexPath = path.join(journalDir, ".index.json");
-    try {
-        const raw = fs.readFileSync(indexPath, "utf-8");
-        const index = JSON.parse(raw);
-        if (Array.isArray(index)) {
-            for (const entry of index) {
-                if (typeof entry.filename === "string") {
-                    journalEntries.push({
-                        filename: entry.filename,
-                        preview: typeof entry.preview === "string" ? entry.preview : "",
-                        mtime: typeof entry.mtime === "number" ? entry.mtime : 0,
-                    });
-                }
-            }
-        }
-    }
-    catch {
-        // no journal index
-    }
-    journalEntries.sort((a, b) => b.mtime - a.mtime);
-    return {
-        diaryEntryCount: diaryEntries.length,
-        recentDiaryEntries: diaryEntries.slice(0, 20),
-        journalEntryCount: journalEntries.length,
-        recentJournalEntries: journalEntries.slice(0, 20),
-    };
-}
-// ---------------------------------------------------------------------------
-// Friend / relationship economics
-// ---------------------------------------------------------------------------
-/* v8 ignore stop */
-function readFriendView(agentName, options = {}) {
-    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
-    const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);
-    const friendsDir = path.join(agentRoot, "friends");
-    const sessionsDir = path.join(agentRoot, "state", "sessions");
-    const friends = [];
-    for (const file of safeReaddir(friendsDir)) {
-        if (!file.endsWith(".json"))
-            continue;
-        const friendId = file.slice(0, -5);
-        try {
-            const raw = fs.readFileSync(path.join(friendsDir, file), "utf-8");
-            const record = JSON.parse(raw);
-            // Count sessions and channels for this friend
-            const friendSessionsDir = path.join(sessionsDir, friendId);
-            const channels = new Set();
-            let sessionCount = 0;
-            let latestActivity = null;
-            for (const channel of safeReaddir(friendSessionsDir)) {
-                const channelDir = path.join(friendSessionsDir, channel);
-                if (!safeIsDirectory(channelDir))
-                    continue;
-                for (const keyFile of safeReaddir(channelDir)) {
-                    if (!keyFile.endsWith(".json"))
-                        continue;
-                    channels.add(channel);
-                    sessionCount++;
-                    const mtime = safeFileMtime(path.join(channelDir, keyFile));
-                    if (mtime && (!latestActivity || mtime > latestActivity)) {
-                        latestActivity = mtime;
-                    }
-                }
-            }
-            friends.push({
-                friendId,
-                friendName: typeof record.name === "string" ? record.name : friendId,
-                totalTokens: typeof record.totalTokens === "number" ? record.totalTokens : 0,
-                sessionCount,
-                channels: [...channels].sort(),
-                lastActivityAt: latestActivity,
-            });
-        }
-        catch {
-            // skip unparseable friend records
-        }
-    }
-    friends.sort((a, b) => b.totalTokens - a.totalTokens);
-    return {
-        totalFriends: friends.length,
-        friends,
-    };
-}
-// ---------------------------------------------------------------------------
-// Log / event reading (NDJSON)
-// ---------------------------------------------------------------------------
-function readLogView(logPath, limit = 100) {
-    if (!logPath || !fs.existsSync(logPath)) {
-        return { logPath, totalLines: 0, entries: [] };
-    }
-    try {
-        const raw = fs.readFileSync(logPath, "utf-8");
-        const lines = raw.split("\n").filter((l) => l.trim().length > 0);
-        const totalLines = lines.length;
-        const recentLines = lines.slice(-limit);
-        const entries = [];
-        for (const line of recentLines) {
-            try {
-                const parsed = JSON.parse(line);
-                entries.push({
-                    ts: typeof parsed.ts === "string" ? parsed.ts : "",
-                    level: typeof parsed.level === "string" ? parsed.level : "info",
-                    event: typeof parsed.event === "string" ? parsed.event : "",
-                    component: typeof parsed.component === "string" ? parsed.component : "",
-                    message: typeof parsed.message === "string" ? parsed.message : "",
-                    trace_id: typeof parsed.trace_id === "string" ? parsed.trace_id : "",
-                    meta: parsed.meta && typeof parsed.meta === "object" ? parsed.meta : {},
-                });
-            }
-            catch {
-                // skip unparseable log lines
-            }
-        }
-        return { logPath, totalLines, entries };
-    }
-    catch { /* v8 ignore next */
-        return { logPath, totalLines: 0, entries: [] };
-    }
-}
-// ---------------------------------------------------------------------------
-// Habit inspection
-// ---------------------------------------------------------------------------
-function readHabitView(agentRoot, options = {}) {
-    const habitsDir = path.join(agentRoot, "habits");
-    const now = options.now?.() ?? new Date();
-    const items = [];
-    for (const file of safeReaddir(habitsDir)) {
-        if (!file.endsWith(".md"))
-            continue;
-        try {
-            const raw = fs.readFileSync(path.join(habitsDir, file), "utf-8");
-            const habit = parseHabitFrontmatter(raw);
-            if (!habit)
-                continue;
-            const cadenceMs = parseCadenceMs(habit.cadence);
-            let isOverdue = false;
-            let overdueMs = null;
-            if (habit.status === "active" && habit.lastRun && cadenceMs) {
-                const elapsed = now.getTime() - Date.parse(habit.lastRun);
-                if (elapsed > cadenceMs) {
-                    isOverdue = true;
-                    overdueMs = elapsed - cadenceMs;
-                }
-            }
-            items.push({
-                name: habit.name ?? file.slice(0, -3),
-                title: habit.title ?? file.slice(0, -3),
-                cadence: habit.cadence,
-                status: habit.status === "paused" ? "paused" : "active",
-                lastRun: habit.lastRun,
-                bodyExcerpt: truncateExcerpt(habit.body, 120),
-                isDegraded: false,
-                degradedReason: null,
-                isOverdue,
-                overdueMs,
-            });
-        }
-        catch {
-            // skip unparseable habit files
-        }
-    }
-    items.sort((a, b) => {
-        if (a.isOverdue && !b.isOverdue)
-            return -1;
-        if (!a.isOverdue && b.isOverdue)
-            return 1;
-        return a.name.localeCompare(b.name);
-    });
-    return {
-        totalCount: items.length,
-        activeCount: items.filter((h) => h.status === "active").length,
-        pausedCount: items.filter((h) => h.status === "paused").length,
-        degradedCount: items.filter((h) => h.isDegraded).length,
-        overdueCount: items.filter((h) => h.isOverdue).length,
-        items,
-    };
-}
-function parseHabitFrontmatter(content) {
-    const fmMatch = /^---\n([\s\S]*?)\n---/.exec(content);
-    if (!fmMatch)
-        return null;
-    const fm = fmMatch[1];
-    const body = content.slice(fmMatch[0].length).trim() || null;
-    function extract(key) {
-        const match = new RegExp(`^${key}:\\s*(.+)$`, "m").exec(fm);
-        return match ? match[1].trim() : null;
-    }
-    return {
-        name: extract("name"),
-        title: extract("title"),
-        cadence: extract("cadence"),
-        status: extract("status"),
-        lastRun: extract("lastRun") ?? extract("last_run"),
-        body,
-    };
-}
-// ---------------------------------------------------------------------------
-// "What needs me now" — aggregates across all surfaces
-// ---------------------------------------------------------------------------
-/* v8 ignore start — defensive parsing in needs-me aggregator */
-function readNeedsMeView(agentName, options = {}) {
-    const bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
-    const now = options.now?.() ?? new Date();
-    const agentRoot = path.join(bundlesRoot, `${agentName}.ouro`);
-    const items = [];
-    // Load dismissed obligations to filter them out
-    const prefs = readDeskPrefs(agentRoot);
-    const dismissed = new Set(prefs.dismissedObligations);
-    // 1. Sessions that need a reply (last message is from user)
-    const sessions = readSessionInventory(agentName, options);
-    for (const s of sessions.items) {
-        if (s.replyState === "needs-reply") {
-            items.push({
-                urgency: "owed-reply",
-                label: `${s.friendName} is waiting for a reply`,
-                detail: `via ${s.channel} · ${s.latestUserExcerpt ? truncateExcerpt(s.latestUserExcerpt, 80) ?? "" : ""}`,
-                ref: { tab: "sessions", focus: `${s.friendId}/${s.channel}/${s.key}` },
-                ageMs: now.getTime() - Date.parse(s.lastActivityAt),
-            });
-        }
-    }
-    // 2. Obligations that are blocking or stale
-    const obligations = readObligationSummary(agentRoot);
-    for (const o of obligations.items) {
-        if (dismissed.has(o.id))
-            continue;
-        const ageMs = now.getTime() - Date.parse(o.updatedAt);
-        const isStale = ageMs > 24 * 60 * 60 * 1000;
-        // Return-ready: obligation has a surface (result exists) but status is still open
-        const hasResult = o.currentSurface !== null;
-        const isOpen = o.status === "pending" || o.status === "investigating" || o.status === "waiting_for_merge" || o.status === "updating_runtime";
-        if (isOpen) {
-            items.push({
-                urgency: hasResult ? "return-ready" : isStale ? "stale-delegation" : "blocking-obligation",
-                label: truncateExcerpt(o.content, 80) ?? o.id,
-                detail: hasResult ? `result ready — ${o.currentSurface.kind}: ${o.currentSurface.label}` : `${o.status}${o.nextAction ? ` · next: ${o.nextAction}` : ""}`,
-                ref: { tab: "work", focus: o.id },
-                ageMs,
-            });
-        }
-    }
-    // 3. Pending attention queue items (someone delegated work that hasn't been picked up)
-    const pendingChannels = scanPendingChannels(agentRoot);
-    for (const p of pendingChannels) {
-        if (p.friendId === "self")
-            continue;
-        const friendName = resolveFriendName(path.join(agentRoot, "friends"), p.friendId);
-        items.push({
-            urgency: "stale-delegation",
-            label: `${p.messageCount} pending from ${friendName}`,
-            detail: `${p.channel}/${p.key}`,
-            ref: { tab: "connections" },
-            ageMs: null,
-        });
-    }
-    // 4. Overdue habits
-    const habits = readHabitView(agentRoot, options);
-    for (const h of habits.items) {
-        if (h.isOverdue) {
-            items.push({
-                urgency: "overdue-habit",
-                label: `${h.title} is overdue`,
-                detail: h.cadence ? `every ${h.cadence} · last ${h.lastRun ?? "never"}` : "no cadence set",
-                ref: { tab: "inner" },
-                ageMs: h.overdueMs,
-            });
-        }
-    }
-    // Sort: owed replies first, then blocking obligations, then stale, then habits
-    const urgencyOrder = {
-        "owed-reply": 0,
-        "blocking-obligation": 1,
-        "broken-return": 2,
-        "stale-delegation": 3,
-        "return-ready": 4,
-        "overdue-habit": 5,
-    };
-    items.sort((a, b) => (urgencyOrder[a.urgency] ?? 99) - (urgencyOrder[b.urgency] ?? 99));
-    return { items };
-}
-// ---------------------------------------------------------------------------
-// Agent desk preferences
-// ---------------------------------------------------------------------------
-/* v8 ignore stop */
-/* v8 ignore start — defensive JSON parsing in desk prefs reader */
-function readDeskPrefs(agentRoot) {
-    const prefsPath = path.join(agentRoot, "state", "outlook-prefs.json");
-    const defaults = {
-        carrying: null,
-        statusLine: null,
-        tabOrder: null,
-        starredFriends: [],
-        pinnedConstellations: [],
-        dismissedObligations: [],
-    };
-    try {
-        const raw = fs.readFileSync(prefsPath, "utf-8");
-        const parsed = JSON.parse(raw);
-        return {
-            carrying: typeof parsed.carrying === "string" ? parsed.carrying : null,
-            statusLine: typeof parsed.statusLine === "string" ? parsed.statusLine : null,
-            tabOrder: Array.isArray(parsed.tabOrder) ? parsed.tabOrder.filter((t) => typeof t === "string") : null,
-            starredFriends: Array.isArray(parsed.starredFriends) ? parsed.starredFriends.filter((f) => typeof f === "string") : [],
-            pinnedConstellations: Array.isArray(parsed.pinnedConstellations)
-                ? parsed.pinnedConstellations.map((c) => ({
-                    label: typeof c.label === "string" ? c.label : "",
-                    friendIds: Array.isArray(c.friendIds) ? c.friendIds.filter((f) => typeof f === "string") : [],
-                    taskRefs: Array.isArray(c.taskRefs) ? c.taskRefs.filter((t) => typeof t === "string") : [],
-                    bridgeIds: Array.isArray(c.bridgeIds) ? c.bridgeIds.filter((b) => typeof b === "string") : [],
-                    codingIds: Array.isArray(c.codingIds) ? c.codingIds.filter((c2) => typeof c2 === "string") : [],
-                }))
-                : [],
-            dismissedObligations: Array.isArray(parsed.dismissedObligations) ? parsed.dismissedObligations.filter((id) => typeof id === "string") : [],
-        };
-    }
-    catch {
-        return defaults;
-    }
-}
-/* v8 ignore stop */
-function parseCadenceMs(cadence) {
-    if (!cadence)
-        return null;
-    const match = /^(\d+)\s*(m|min|h|hr|d|day)s?$/i.exec(cadence.trim());
-    if (!match)
-        return null;
-    const value = parseInt(match[1], 10);
-    const unit = match[2].toLowerCase();
-    if (unit === "m" || unit === "min")
-        return value * 60 * 1000;
-    if (unit === "h" || unit === "hr")
-        return value * 60 * 60 * 1000;
-    if (unit === "d" || unit === "day")
-        return value * 24 * 60 * 60 * 1000;
-    /* v8 ignore next */
-    return null;
-}
-// ---------------------------------------------------------------------------
-// Continuity — presence, cares, episodes for outlook surfaces
-// ---------------------------------------------------------------------------
-function readOutlookContinuity(agentRoot, agentName) {
-    const self = (0, presence_1.readPresence)(agentRoot, agentName);
-    const peers = (0, presence_1.readPeerPresence)(agentRoot);
-    const cares = (0, cares_1.readActiveCares)(agentRoot);
-    const episodes = (0, episodes_1.readRecentEpisodes)(agentRoot, { limit: 10 });
-    (0, runtime_1.emitNervesEvent)({
-        component: "heart",
-        event: "heart.outlook_continuity_read",
-        message: `outlook continuity: ${cares.length} cares, ${episodes.length} episodes`,
-        meta: { careCount: cares.length, episodeCount: episodes.length, hasSelf: self != null, peerCount: peers.length },
-    });
-    return {
-        presence: { self, peers },
-        cares: {
-            activeCount: cares.length,
-            items: cares.map((c) => ({
-                id: c.id,
-                label: c.label,
-                status: c.status,
-                salience: c.salience,
-            })),
-        },
-        episodes: {
-            recentCount: episodes.length,
-            items: episodes.map((ep) => ({
-                id: ep.id,
-                kind: ep.kind,
-                summary: ep.summary,
-                timestamp: ep.timestamp,
-            })),
-        },
-    };
-}
-// ---------------------------------------------------------------------------
-// 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 };
-}
+exports.readSelfFixView = exports.readOutlookContinuity = exports.readOrientationView = exports.readObligationDetailView = exports.readMemoryDecisionView = exports.readChangesView = exports.readNeedsMeView = exports.readMemoryView = exports.readLogView = exports.readHabitView = exports.readFriendView = exports.readDeskPrefs = exports.readDaemonHealthDeep = exports.readCodingDeep = exports.readBridgeInventory = exports.readAttentionView = exports.readSessionTranscript = exports.readSessionInventory = exports.readOutlookMachineState = exports.readOutlookAgentState = exports.readObligationSummary = void 0;
+var agent_machine_1 = require("./readers/agent-machine");
+Object.defineProperty(exports, "readObligationSummary", { enumerable: true, get: function () { return agent_machine_1.readObligationSummary; } });
+Object.defineProperty(exports, "readOutlookAgentState", { enumerable: true, get: function () { return agent_machine_1.readOutlookAgentState; } });
+Object.defineProperty(exports, "readOutlookMachineState", { enumerable: true, get: function () { return agent_machine_1.readOutlookMachineState; } });
+var sessions_1 = require("./readers/sessions");
+Object.defineProperty(exports, "readSessionInventory", { enumerable: true, get: function () { return sessions_1.readSessionInventory; } });
+Object.defineProperty(exports, "readSessionTranscript", { enumerable: true, get: function () { return sessions_1.readSessionTranscript; } });
+var runtime_readers_1 = require("./readers/runtime-readers");
+Object.defineProperty(exports, "readAttentionView", { enumerable: true, get: function () { return runtime_readers_1.readAttentionView; } });
+Object.defineProperty(exports, "readBridgeInventory", { enumerable: true, get: function () { return runtime_readers_1.readBridgeInventory; } });
+Object.defineProperty(exports, "readCodingDeep", { enumerable: true, get: function () { return runtime_readers_1.readCodingDeep; } });
+Object.defineProperty(exports, "readDaemonHealthDeep", { enumerable: true, get: function () { return runtime_readers_1.readDaemonHealthDeep; } });
+Object.defineProperty(exports, "readDeskPrefs", { enumerable: true, get: function () { return runtime_readers_1.readDeskPrefs; } });
+Object.defineProperty(exports, "readFriendView", { enumerable: true, get: function () { return runtime_readers_1.readFriendView; } });
+Object.defineProperty(exports, "readHabitView", { enumerable: true, get: function () { return runtime_readers_1.readHabitView; } });
+Object.defineProperty(exports, "readLogView", { enumerable: true, get: function () { return runtime_readers_1.readLogView; } });
+Object.defineProperty(exports, "readMemoryView", { enumerable: true, get: function () { return runtime_readers_1.readMemoryView; } });
+Object.defineProperty(exports, "readNeedsMeView", { enumerable: true, get: function () { return runtime_readers_1.readNeedsMeView; } });
+var continuity_readers_1 = require("./readers/continuity-readers");
+Object.defineProperty(exports, "readChangesView", { enumerable: true, get: function () { return continuity_readers_1.readChangesView; } });
+Object.defineProperty(exports, "readMemoryDecisionView", { enumerable: true, get: function () { return continuity_readers_1.readMemoryDecisionView; } });
+Object.defineProperty(exports, "readObligationDetailView", { enumerable: true, get: function () { return continuity_readers_1.readObligationDetailView; } });
+Object.defineProperty(exports, "readOrientationView", { enumerable: true, get: function () { return continuity_readers_1.readOrientationView; } });
+Object.defineProperty(exports, "readOutlookContinuity", { enumerable: true, get: function () { return continuity_readers_1.readOutlookContinuity; } });
+Object.defineProperty(exports, "readSelfFixView", { enumerable: true, get: function () { return continuity_readers_1.readSelfFixView; } });