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

package/dist/heart/outlook/readers/agent-machine.js

@@ -0,0 +1,355 @@
+"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.readObligationSummary = readObligationSummary;
+exports.readOutlookAgentState = readOutlookAgentState;
+exports.readOutlookMachineState = readOutlookMachineState;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../../nerves/runtime");
+const obligations_1 = require("../../../arc/obligations");
+const board_1 = require("../../../repertoire/tasks/board");
+const scanner_1 = require("../../../repertoire/tasks/scanner");
+const session_activity_1 = require("../../session-activity");
+const identity_1 = require("../../identity");
+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 shared_1 = require("./shared");
+const LIVE_TASK_STATUSES = ["processing", "validating", "collaborating", "blocked"];
+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: [(0, shared_1.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) => (0, shared_1.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((0, shared_1.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 > shared_1.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) => shared_1.ACTIVE_CODING_STATUSES.has(item.status)).length,
+            blockedCount: coding.items.filter((item) => shared_1.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) => (0, shared_1.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),
+    };
+}

package/dist/heart/outlook/readers/continuity-readers.js

@@ -0,0 +1,332 @@
+"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.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 cares_1 = require("../../../arc/cares");
+const episodes_1 = require("../../../arc/episodes");
+const obligations_1 = require("../../../arc/obligations");
+const presence_1 = require("../../../arc/presence");
+const scanner_1 = require("../../../repertoire/tasks/scanner");
+const active_work_1 = require("../../active-work");
+const session_activity_1 = require("../../session-activity");
+function sortOpenObligations(obligations) {
+    const statusPriority = {
+        returning: 0,
+        collaborating: 1,
+        in_progress: 2,
+        delegated: 3,
+        accepted: 4,
+        pending: 5,
+    };
+    return obligations
+        .map((obligation) => ({
+        obligation,
+        priority: statusPriority[obligation.status] ?? 99,
+        updatedMs: new Date(obligation.updatedAt ?? obligation.createdAt).getTime(),
+    }))
+        .sort((a, b) => {
+        if (a.priority !== b.priority)
+            return a.priority - b.priority;
+        return b.updatedMs - a.updatedMs;
+    })
+        .map((entry) => entry.obligation);
+}
+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,
+            })),
+        },
+    };
+}
+function readOrientationView(agentRoot, agentName) {
+    let obligations = [];
+    try {
+        obligations = (0, obligations_1.readObligations)(agentRoot);
+    }
+    catch {
+        obligations = [];
+    }
+    const openObligations = obligations.filter(obligations_1.isOpenObligation);
+    const sorted = sortOpenObligations(openObligations);
+    const primary = sorted[0] ?? null;
+    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,
+    }));
+    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,
+    };
+}
+function readObligationDetailView(agentRoot) {
+    let obligations = [];
+    try {
+        obligations = (0, obligations_1.readObligations)(agentRoot);
+    }
+    catch {
+        obligations = [];
+    }
+    const openObligations = obligations.filter(obligations_1.isOpenObligation);
+    const sorted = sortOpenObligations(openObligations);
+    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: ob.id === primary.id,
+    }));
+    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,
+    };
+}
+function readChangesView(agentRoot) {
+    const snapshotPath = path.join(agentRoot, "state", "outlook", "active-work-snapshot.json");
+    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;
+    }
+    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(),
+    };
+    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,
+    };
+}
+function readSelfFixView(agentRoot) {
+    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 = [];
+    }
+    const selfFixTasks = tasks.filter((t) => t.title.toLowerCase().includes("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,
+    };
+}
+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
+        }
+    }
+    items.reverse();
+    const limited = items.slice(0, limit);
+    return { totalCount: items.length, items: limited };
+}