@ouro.bot/cli 0.1.0-alpha.61 → 0.1.0-alpha.612

package/dist/heart/kicks.js

@@ -5,7 +5,7 @@ exports.detectKick = detectKick;
 const runtime_1 = require("../nerves/runtime");
 const KICK_MESSAGES = {
     empty: "I sent an empty message by accident — let me try again.",
-    narration: "I narrated instead of acting. Using the tool now -- if done, calling final_answer.",
+    narration: "I narrated instead of acting. Using the tool now -- if done, calling settle.",
     tool_required: "tool-required is on — I need to call a tool. use /tool-required to turn it off.",
 };
 const TOOL_INTENT_PATTERNS = [

package/dist/heart/machine-identity.js

@@ -0,0 +1,161 @@
+"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.getMachineIdentityPath = getMachineIdentityPath;
+exports.loadOrCreateMachineIdentity = loadOrCreateMachineIdentity;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function nowIso(deps) {
+    return (deps.now?.() ?? new Date()).toISOString();
+}
+function currentHostname(deps) {
+    return (deps.hostname?.() ?? os.hostname()).trim();
+}
+function defaultRandomId() {
+    return `machine_${crypto.randomUUID()}`;
+}
+function normalizeAliases(value) {
+    if (!Array.isArray(value))
+        return [];
+    const aliases = [];
+    for (const alias of value) {
+        if (typeof alias !== "string")
+            continue;
+        const trimmed = alias.trim();
+        if (trimmed && !aliases.includes(trimmed))
+            aliases.push(trimmed);
+    }
+    return aliases;
+}
+function parseMachineIdentity(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const aliases = normalizeAliases(record.hostnameAliases);
+    if (record.schemaVersion !== 1 ||
+        typeof record.machineId !== "string" ||
+        record.machineId.trim().length === 0 ||
+        typeof record.createdAt !== "string" ||
+        record.createdAt.trim().length === 0 ||
+        typeof record.updatedAt !== "string" ||
+        record.updatedAt.trim().length === 0) {
+        return null;
+    }
+    return {
+        schemaVersion: 1,
+        machineId: record.machineId,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        hostnameAliases: aliases,
+    };
+}
+function writeMachineIdentity(machinePath, identity) {
+    fs.mkdirSync(path.dirname(machinePath), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(machinePath, `${JSON.stringify(identity, null, 2)}\n`, { encoding: "utf-8", mode: 0o600 });
+}
+function getMachineIdentityPath(homeDir = os.homedir()) {
+    return path.join(homeDir, ".ouro-cli", "machine.json");
+}
+function loadOrCreateMachineIdentity(deps = {}) {
+    const homeDir = deps.homeDir ?? os.homedir();
+    const machinePath = getMachineIdentityPath(homeDir);
+    const hostname = currentHostname(deps);
+    let existing = null;
+    let hadInvalidFile = false;
+    try {
+        existing = parseMachineIdentity(JSON.parse(fs.readFileSync(machinePath, "utf-8")));
+        if (!existing)
+            hadInvalidFile = true;
+    }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error
+            ? error.code
+            : undefined;
+        if (code !== "ENOENT")
+            hadInvalidFile = true;
+    }
+    if (hadInvalidFile) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "config/identity",
+            event: "config.machine_identity_invalid",
+            message: "machine identity file is invalid; replacing it",
+            meta: { path: machinePath },
+        });
+    }
+    if (existing) {
+        if (hostname && !existing.hostnameAliases.includes(hostname)) {
+            const updated = {
+                ...existing,
+                updatedAt: nowIso(deps),
+                hostnameAliases: [...existing.hostnameAliases, hostname],
+            };
+            writeMachineIdentity(machinePath, updated);
+            (0, runtime_1.emitNervesEvent)({
+                component: "config/identity",
+                event: "config.machine_identity_alias_added",
+                message: "recorded hostname alias for stable machine identity",
+                meta: { machineId: updated.machineId, hostname },
+            });
+            return updated;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "config/identity",
+            event: "config.machine_identity_loaded",
+            message: "loaded stable machine identity",
+            meta: { machineId: existing.machineId },
+        });
+        return existing;
+    }
+    const timestamp = nowIso(deps);
+    const identity = {
+        schemaVersion: 1,
+        machineId: (deps.randomId?.() ?? defaultRandomId()).trim() || defaultRandomId(),
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        hostnameAliases: hostname ? [hostname] : [],
+    };
+    writeMachineIdentity(machinePath, identity);
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config.machine_identity_created",
+        message: "created stable machine identity",
+        meta: { machineId: identity.machineId },
+    });
+    return identity;
+}

package/dist/heart/mail-import-discovery.js

@@ -0,0 +1,353 @@
+"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.defaultMailImportDiscoveryDirs = defaultMailImportDiscoveryDirs;
+exports.listDiscoveredMboxCandidates = listDiscoveredMboxCandidates;
+exports.rankDiscoveredMboxCandidates = rankDiscoveredMboxCandidates;
+exports.discoverMailImportFilePath = discoverMailImportFilePath;
+exports.listAmbientMailImportOperations = listAmbientMailImportOperations;
+exports.listVisibleBackgroundOperations = listVisibleBackgroundOperations;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const background_operations_1 = require("./background-operations");
+const identity = __importStar(require("./identity"));
+const DEFAULT_RECENT_IMPORT_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+const DEFAULT_VISIBLE_BACKGROUND_OPERATION_LIMIT = 5;
+const DEFAULT_VISIBLE_IMPORT_CANDIDATE_LIMIT = 3;
+const DEFAULT_WORKTREE_POOL_SEARCH_DEPTH = 2;
+const DEFAULT_AGENT_WORKSPACE_SCAN_LIMIT = 20;
+const SKIPPED_HOME_SCAN_DIRS = new Set([
+    ".Trash",
+    "Applications",
+    "Library",
+    "Movies",
+    "Music",
+    "Pictures",
+    "Public",
+    "node_modules",
+]);
+function sortBackgroundOperationsNewestFirst(left, right) {
+    return Date.parse(right.updatedAt) - Date.parse(left.updatedAt);
+}
+function recentImportFingerprint(candidates) {
+    return candidates
+        .map((candidate) => `${candidate.path}:${candidate.mtimeMs}`)
+        .sort((left, right) => left.localeCompare(right))
+        .join("|");
+}
+function specText(spec, key) {
+    const value = spec?.[key];
+    return typeof value === "string" ? value.trim() : "";
+}
+function latestComparableOperationTimestamp(record) {
+    const fileModifiedAt = specText(record.spec, "fileModifiedAt");
+    if (fileModifiedAt) {
+        const parsed = Date.parse(fileModifiedAt);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    const candidates = [record.finishedAt, record.updatedAt];
+    for (const candidate of candidates) {
+        if (typeof candidate !== "string")
+            continue;
+        const parsed = Date.parse(candidate);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return null;
+}
+function candidateAlreadyCoveredByOperation(candidate, operation) {
+    if (operation.kind !== "mail.import-mbox")
+        return false;
+    if (specText(operation.spec, "filePath") !== candidate.path)
+        return false;
+    if (operation.status !== "succeeded")
+        return false;
+    const operationTimestamp = latestComparableOperationTimestamp(operation);
+    return operationTimestamp !== null && candidate.mtimeMs <= operationTimestamp;
+}
+function listChildDirs(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(dir, entry.name));
+    }
+    catch {
+        return [];
+    }
+}
+function classifyDiscoveredMboxOrigin(dir) {
+    const normalizedDir = path.resolve(dir);
+    const parts = normalizedDir.split(path.sep).filter(Boolean);
+    if (parts.includes(".playwright-mcp")) {
+        return {
+            originKind: "playwright-sandbox",
+            originLabel: "browser sandbox (.playwright-mcp)",
+        };
+    }
+    if (path.basename(normalizedDir) === "Downloads") {
+        return {
+            originKind: "downloads",
+            originLabel: "Downloads",
+        };
+    }
+    return {
+        originKind: "filesystem",
+        originLabel: "filesystem",
+    };
+}
+function findWorktreePools(rootDir, maxDepth) {
+    const seen = new Set();
+    const found = [];
+    function visit(currentDir, depth) {
+        if (depth > maxDepth || seen.has(currentDir))
+            return;
+        seen.add(currentDir);
+        let entries;
+        try {
+            entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith(".") && entry.name !== ".playwright-mcp")
+                continue;
+            if (SKIPPED_HOME_SCAN_DIRS.has(entry.name))
+                continue;
+            const childDir = path.join(currentDir, entry.name);
+            if (entry.name === "_worktrees") {
+                found.push(childDir);
+                continue;
+            }
+            visit(childDir, depth + 1);
+        }
+    }
+    visit(rootDir, 0);
+    return found;
+}
+function listAgentWorkspaceSandboxDirs(agentName) {
+    if (!agentName)
+        return [];
+    const getAgentRepoWorkspacesRoot = Object.getOwnPropertyDescriptor(identity, "getAgentRepoWorkspacesRoot")?.value;
+    const workspacesRoot = typeof getAgentRepoWorkspacesRoot === "function"
+        ? getAgentRepoWorkspacesRoot(agentName)
+        : "";
+    if (!workspacesRoot)
+        return [];
+    return listChildDirs(workspacesRoot)
+        .slice(0, DEFAULT_AGENT_WORKSPACE_SCAN_LIMIT)
+        .map((workspaceDir) => path.join(workspaceDir, ".playwright-mcp"));
+}
+function listWorktreePoolSandboxDirs(homeDir) {
+    return findWorktreePools(homeDir, DEFAULT_WORKTREE_POOL_SEARCH_DEPTH)
+        .flatMap((poolDir) => listChildDirs(poolDir))
+        .map((worktreeDir) => path.join(worktreeDir, ".playwright-mcp"));
+}
+function defaultMailImportDiscoveryDirs(input = {}) {
+    const repoRoot = path.resolve(input.repoRoot ?? process.cwd());
+    const homeDir = path.resolve(input.homeDir ?? os.homedir());
+    return [...new Set([
+            path.join(repoRoot, ".playwright-mcp"),
+            ...listAgentWorkspaceSandboxDirs(input.agentName),
+            ...listWorktreePoolSandboxDirs(homeDir),
+            path.join(homeDir, ".playwright-mcp"),
+            path.join(homeDir, "Downloads"),
+        ].map((dir) => path.resolve(dir)))];
+}
+function listDiscoveredMboxCandidates(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    try {
+        const origin = classifyDiscoveredMboxOrigin(dir);
+        return fs.readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".mbox"))
+            .map((entry) => {
+            const candidatePath = path.join(dir, entry.name);
+            const stat = fs.statSync(candidatePath);
+            return {
+                path: candidatePath,
+                name: entry.name,
+                mtimeMs: stat.mtimeMs,
+                originKind: origin.originKind,
+                originLabel: origin.originLabel,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeMboxDiscoveryText(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim();
+}
+function tokenizeMboxDiscoveryHint(value) {
+    if (!value)
+        return [];
+    return normalizeMboxDiscoveryText(value)
+        .split(" ")
+        .filter((token) => token.length > 0);
+}
+function scoreDiscoveredMboxCandidate(fileName, mtimeMs, ownerEmail, source) {
+    const normalized = normalizeMboxDiscoveryText(fileName);
+    const ownerTokens = tokenizeMboxDiscoveryHint(ownerEmail);
+    const sourceTokens = tokenizeMboxDiscoveryHint(source);
+    const ownerScore = ownerTokens.reduce((score, token) => score + (normalized.includes(token) ? 50 : 0), 0);
+    const sourceScore = sourceTokens.reduce((score, token) => score + (normalized.includes(token) ? 20 : 0), 0);
+    const recencyScore = Math.floor(mtimeMs / 1000);
+    return ownerScore + sourceScore + recencyScore;
+}
+function rankDiscoveredMboxCandidates(candidates, ownerEmail, source) {
+    return candidates
+        .map((candidate) => ({
+        path: candidate.path,
+        score: scoreDiscoveredMboxCandidate(candidate.name, candidate.mtimeMs, ownerEmail, source),
+    }))
+        .sort((left, right) => right.score - left.score);
+}
+function discoverMailImportFilePath(input) {
+    const searchDirs = defaultMailImportDiscoveryDirs({
+        agentName: input.agentName,
+        repoRoot: input.repoRoot,
+        homeDir: input.homeDir,
+    });
+    const candidates = searchDirs.flatMap((dir) => listDiscoveredMboxCandidates(dir));
+    const ranked = rankDiscoveredMboxCandidates(candidates, input.ownerEmail, input.source);
+    if (ranked.length === 0) {
+        throw new Error(`could not discover an MBOX file in ${searchDirs.join(", ")}`);
+    }
+    const topScore = ranked[0].score;
+    const topCandidates = ranked.filter((candidate) => candidate.score === topScore);
+    if (topCandidates.length > 1) {
+        throw new Error(`multiple candidate MBOX files found: ${topCandidates.map((candidate) => candidate.path).join(", ")}`);
+    }
+    return topCandidates[0].path;
+}
+function summarizeAmbientImportCandidates(candidates, candidateLimit) {
+    const visibleCandidates = candidates.slice(0, candidateLimit);
+    const hiddenCount = Math.max(0, candidates.length - visibleCandidates.length);
+    const summary = visibleCandidates.length === 1
+        ? "recent MBOX archive ready for import"
+        : `${visibleCandidates.length} recent MBOX archives ready for import`;
+    const detailLines = [
+        "recent candidates:",
+        ...visibleCandidates.map((candidate) => `- [${candidate.originLabel}] ${candidate.path}`),
+        ...(hiddenCount > 0 ? [`- ...and ${hiddenCount} more recent archive${hiddenCount === 1 ? "" : "s"}`] : []),
+        "next: if one matches an outstanding mail backfill, run `ouro mail import-mbox --discover` with owner/source hints so Ouro can select the right archive or report ambiguity.",
+    ];
+    return {
+        summary,
+        detail: detailLines.join("\n"),
+        spec: {
+            fingerprint: recentImportFingerprint(candidates),
+            candidatePaths: visibleCandidates.map((candidate) => candidate.path),
+            candidateDescriptors: visibleCandidates.map((candidate) => ({
+                path: candidate.path,
+                originKind: candidate.originKind,
+                originLabel: candidate.originLabel,
+                modifiedAt: new Date(candidate.mtimeMs).toISOString(),
+            })),
+            newestCandidatePath: visibleCandidates[0]?.path ?? null,
+            newestCandidateMtime: visibleCandidates[0] ? new Date(visibleCandidates[0].mtimeMs).toISOString() : null,
+            newestCandidateOriginKind: visibleCandidates[0]?.originKind ?? null,
+            newestCandidateOriginLabel: visibleCandidates[0]?.originLabel ?? null,
+        },
+    };
+}
+function listAmbientMailImportOperations(input) {
+    const existingOperations = input.existingOperations ?? [];
+    const hasLiveImport = existingOperations.some((operation) => operation.kind === "mail.import-mbox"
+        && (operation.status === "queued" || operation.status === "running"));
+    if (hasLiveImport)
+        return [];
+    const nowMs = input.nowMs ?? Date.now();
+    const recentWindowMs = input.recentWindowMs ?? DEFAULT_RECENT_IMPORT_WINDOW_MS;
+    const candidateLimit = input.candidateLimit ?? DEFAULT_VISIBLE_IMPORT_CANDIDATE_LIMIT;
+    const recentCandidates = defaultMailImportDiscoveryDirs({
+        agentName: input.agentName,
+        repoRoot: input.repoRoot,
+        homeDir: input.homeDir,
+    })
+        .flatMap((dir) => listDiscoveredMboxCandidates(dir))
+        .filter((candidate) => (nowMs - candidate.mtimeMs) <= recentWindowMs)
+        .filter((candidate) => !existingOperations.some((operation) => candidateAlreadyCoveredByOperation(candidate, operation)))
+        .sort((left, right) => right.mtimeMs - left.mtimeMs);
+    if (recentCandidates.length === 0)
+        return [];
+    const newestCandidate = recentCandidates[0];
+    const rendered = summarizeAmbientImportCandidates(recentCandidates, candidateLimit);
+    return [{
+            schemaVersion: 1,
+            id: "ambient_mail_import_ready",
+            agentName: input.agentName,
+            kind: "mail.import-discovered",
+            title: "mail import ready",
+            status: "queued",
+            summary: rendered.summary,
+            detail: rendered.detail,
+            createdAt: new Date(newestCandidate.mtimeMs).toISOString(),
+            updatedAt: new Date(newestCandidate.mtimeMs).toISOString(),
+            spec: rendered.spec,
+        }];
+}
+function listVisibleBackgroundOperations(input) {
+    const limit = input.limit ?? DEFAULT_VISIBLE_BACKGROUND_OPERATION_LIMIT;
+    const persisted = (0, background_operations_1.listBackgroundOperations)({
+        agentName: input.agentName,
+        agentRoot: input.agentRoot,
+        limit,
+    });
+    const ambient = listAmbientMailImportOperations({
+        agentName: input.agentName,
+        agentRoot: input.agentRoot,
+        existingOperations: persisted,
+        repoRoot: input.repoRoot,
+        homeDir: input.homeDir,
+        nowMs: input.nowMs,
+        recentWindowMs: input.recentWindowMs,
+        candidateLimit: input.candidateLimit,
+    });
+    return [...persisted, ...ambient]
+        .sort(sortBackgroundOperationsNewestFirst)
+        .slice(0, limit);
+}

package/dist/heart/mailbox/mailbox-http-hooks.js

@@ -0,0 +1,66 @@
+"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.createMailboxHttpReadHooks = createMailboxHttpReadHooks;
+const path = __importStar(require("path"));
+const mailbox_read_1 = require("./mailbox-read");
+function createMailboxHttpReadHooks(options) {
+    const bundlesRoot = options.bundlesRoot;
+    const readOptions = bundlesRoot ? { bundlesRoot } : undefined;
+    const agentRoot = (agentName) => path.join(bundlesRoot ?? "", `${agentName}.ouro`);
+    return {
+        agentRoot,
+        readAgentSessions: options.readAgentSessions ?? ((agentName) => (0, mailbox_read_1.readSessionInventory)(agentName, readOptions)),
+        readAgentTranscript: options.readAgentTranscript ?? ((agentName, friendId, channel, key) => (0, mailbox_read_1.readSessionTranscript)(agentName, friendId, channel, key, readOptions)),
+        readAgentCoding: options.readAgentCoding ?? ((agentName) => (0, mailbox_read_1.readCodingDeep)(agentRoot(agentName))),
+        readAgentAttention: options.readAgentAttention ?? ((agentName) => (0, mailbox_read_1.readAttentionView)(agentName, readOptions)),
+        readAgentBridges: options.readAgentBridges ?? ((agentName) => (0, mailbox_read_1.readBridgeInventory)(agentRoot(agentName))),
+        readAgentNotes: options.readAgentNotes ?? ((agentName) => (0, mailbox_read_1.readNotesView)(agentRoot(agentName))),
+        readAgentFriends: options.readAgentFriends ?? ((agentName) => (0, mailbox_read_1.readFriendView)(agentName, readOptions)),
+        readAgentContinuity: options.readAgentContinuity ?? ((agentName) => (0, mailbox_read_1.readMailboxContinuity)(agentRoot(agentName), agentName)),
+        readAgentOrientation: options.readAgentOrientation ?? ((agentName) => (0, mailbox_read_1.readOrientationView)(agentRoot(agentName), agentName)),
+        readAgentObligations: options.readAgentObligations ?? ((agentName) => (0, mailbox_read_1.readObligationDetailView)(agentRoot(agentName))),
+        readAgentChanges: options.readAgentChanges ?? ((agentName) => (0, mailbox_read_1.readChangesView)(agentRoot(agentName))),
+        readAgentSelfFix: options.readAgentSelfFix ?? ((agentName) => (0, mailbox_read_1.readSelfFixView)(agentRoot(agentName))),
+        readAgentNoteDecisions: options.readAgentNoteDecisions ?? ((agentName) => (0, mailbox_read_1.readNoteDecisionView)(agentRoot(agentName))),
+        readAgentHabits: options.readAgentHabits ?? ((agentName) => (0, mailbox_read_1.readHabitView)(agentRoot(agentName))),
+        readAgentMail: options.readAgentMail ?? ((agentName) => (0, mailbox_read_1.readMailView)(agentName)),
+        readAgentMailMessage: options.readAgentMailMessage ?? ((agentName, messageId) => (0, mailbox_read_1.readMailMessageView)(agentName, messageId)),
+        readDaemonHealth: options.readDaemonHealth ?? (() => (0, mailbox_read_1.readDaemonHealthDeep)(options.healthPath)),
+        readLogs: options.readLogs ?? (() => (0, mailbox_read_1.readLogView)(options.logPath ?? null)),
+        readDeskPrefs: (agentName) => (0, mailbox_read_1.readDeskPrefs)(agentRoot(agentName)),
+        readNeedsMe: (agentName) => (0, mailbox_read_1.readNeedsMeView)(agentName, readOptions),
+    };
+}

package/dist/heart/mailbox/mailbox-http-response.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeJson = writeJson;
+function writeJson(response, statusCode, payload) {
+    response.writeHead(statusCode, { "content-type": "application/json; charset=utf-8" });
+    response.end(`${JSON.stringify(payload, null, 2)}\n`);
+}