@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/repertoire/tools-session.js

@@ -0,0 +1,1133 @@
+"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.sessionToolDefinitions = void 0;
+exports.readButlerOperationalVisibility = readButlerOperationalVisibility;
+exports.formatButlerOperationalVisibility = formatButlerOperationalVisibility;
+exports.renderInnerProgressStatus = renderInnerProgressStatus;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const config_1 = require("../heart/config");
+const identity_1 = require("../heart/identity");
+const session_events_1 = require("../heart/session-events");
+const runtime_1 = require("../nerves/runtime");
+const socket_client_1 = require("../heart/daemon/socket-client");
+const thoughts_1 = require("../heart/daemon/thoughts");
+const manager_1 = require("../heart/bridges/manager");
+const session_transcript_1 = require("../heart/session-transcript");
+const session_activity_1 = require("../heart/session-activity");
+const active_work_1 = require("../heart/active-work");
+const coding_1 = require("./coding");
+const pending_1 = require("../mind/pending");
+const obligations_1 = require("../arc/obligations");
+const progress_story_1 = require("../heart/progress-story");
+const habit_session_summary_1 = require("../heart/habits/habit-session-summary");
+const cross_chat_delivery_1 = require("../heart/cross-chat-delivery");
+const tool_arguments_1 = require("./tool-arguments");
+const mail_import_discovery_1 = require("../heart/mail-import-discovery");
+const outbound_1 = require("../senses/voice/outbound");
+const router_1 = require("../heart/external-events/router");
+const steward_policy_1 = require("../heart/steward-policy");
+const await_parser_1 = require("../heart/awaiting/await-parser");
+const daemon_health_1 = require("../heart/daemon/daemon-health");
+const turn_context_1 = require("../heart/turn-context");
+const telegram_effect_adapter_1 = require("../senses/telegram-effect-adapter");
+const telegram_admission_1 = require("../senses/telegram-admission");
+const sanctuary_health_1 = require("../senses/sanctuary-health");
+const run_ledger_1 = require("../heart/run-ledger");
+const NO_SESSION_FOUND_MESSAGE = "no session found for that friend/channel/key combination.";
+const EMPTY_SESSION_MESSAGE = "session exists but has no non-system messages.";
+const VALID_HABIT_SUMMARY_WHICH = new Set(["latest", "previous", "latest-success", "latest-failure"]);
+async function summarizeSessionTailSafely(options) {
+    try {
+        return await (0, session_transcript_1.summarizeSessionTail)(options);
+    }
+    catch (error) {
+        if (options.summarize) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.session_tail_summary_summary_fallback",
+                message: "session tail summarization failed; using raw transcript",
+                meta: {
+                    friendId: options.friendId,
+                    channel: options.channel,
+                    key: options.key,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+            try {
+                return await (0, session_transcript_1.summarizeSessionTail)({
+                    ...options,
+                    summarize: undefined,
+                });
+                /* v8 ignore start -- defensive: session tail fallback @preserve */
+            }
+            catch {
+                return { kind: "missing" };
+            }
+            /* v8 ignore stop */
+        }
+        return { kind: "missing" };
+    }
+}
+function optionalArg(args, key) {
+    const value = args[key];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function validateSessionSummarySelector(args) {
+    const runId = optionalArg(args, "runId");
+    const habitName = optionalArg(args, "habitName");
+    const operationId = optionalArg(args, "operationId");
+    const which = optionalArg(args, "which");
+    if (runId === null || habitName === null || operationId === null || which === null) {
+        return {
+            ok: false,
+            code: which === null ? "invalid_which" : "selector_required",
+            message: which === null
+                ? "which must be latest, previous, latest-success, or latest-failure"
+                : "selector fields must be strings",
+        };
+    }
+    if (runId !== undefined) {
+        if (habitName !== undefined || operationId !== undefined || which !== undefined) {
+            return {
+                ok: false,
+                code: "run_id_exclusive",
+                message: "runId cannot be combined with habitName, operationId, or which",
+            };
+        }
+        return { ok: true, selector: { runId } };
+    }
+    if (habitName === undefined && operationId === undefined) {
+        return {
+            ok: false,
+            code: "selector_required",
+            message: "provide runId, habitName, or operationId",
+        };
+    }
+    if (which !== undefined && !VALID_HABIT_SUMMARY_WHICH.has(which)) {
+        return {
+            ok: false,
+            code: "invalid_which",
+            message: "which must be latest, previous, latest-success, or latest-failure",
+        };
+    }
+    return {
+        ok: true,
+        selector: {
+            ...(habitName !== undefined ? { habitName } : {}),
+            ...(operationId !== undefined ? { operationId } : {}),
+            ...(which !== undefined ? { which } : {}),
+        },
+    };
+}
+function renderSessionSummaryText(summary) {
+    const lines = [
+        `habit ${summary.habitName} run ${summary.runId} finished with ${summary.status}.`,
+        summary.operationId ? `operation: ${summary.operationId}` : null,
+        summary.summary,
+        summary.nextLikelyStep ? `next: ${summary.nextLikelyStep}` : null,
+        summary.decisions.length > 0 ? `decisions: ${summary.decisions.join("; ")}` : null,
+        summary.pending.count > 0 ? `pending: ${summary.pending.count} file(s) (${summary.pending.files.join(", ")})` : "pending: none",
+        summary.messagesSent.length > 0 ? `messages: ${summary.messagesSent.length}` : "messages: none",
+        summary.toolsUsed.length > 0 ? `tools: ${summary.toolsUsed.join(", ")}` : "tools: none",
+        summary.errors.length > 0 ? `errors: ${summary.errors.join("; ")}` : null,
+        summary.warnings.length > 0 ? `warnings: ${summary.warnings.join("; ")}` : null,
+        `receipt: ${summary.sources.receipt}`,
+        `session: ${summary.sources.session}`,
+    ];
+    return lines.filter((line) => Boolean(line)).join("\n");
+}
+function writePendingEnvelope(queueDir, message) {
+    fs.mkdirSync(queueDir, { recursive: true });
+    const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
+    const filePath = path.join(queueDir, fileName);
+    fs.writeFileSync(filePath, JSON.stringify({ ...message, content: (0, session_events_1.capStructuredRecordString)(message.content) }, null, 2));
+    return fileName.replace(/\.json$/, "");
+}
+function renderCrossChatDeliveryStatus(target, result) {
+    const phase = result.status === "delivered_now"
+        ? "completed"
+        : result.status === "queued_for_later"
+            ? "queued"
+            : result.status === "blocked"
+                ? "blocked"
+                : "errored";
+    const lead = result.status === "delivered_now"
+        ? "delivered now"
+        : result.status === "queued_for_later"
+            ? "queued for later"
+            : result.status === "blocked"
+                ? "blocked"
+                : "failed";
+    return (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+        scope: "shared-work",
+        phase,
+        objective: `message to ${target}`,
+        outcomeText: `${lead}\n${result.detail}`,
+    }));
+}
+function normalizeHabitSendStatus(status) {
+    return status === "queued_for_later" ? "queued" : status;
+}
+function recordHabitSendAttempt(ctx, args, result) {
+    ctx?.habitSession?.recordSurfaceAttempt?.({
+        recipient: args.friendId,
+        channel: args.channel,
+        reason: result.status === "blocked" ? "blocked" : result.status === "failed" ? "other" : "status",
+        result: normalizeHabitSendStatus(result.status),
+        rawStatus: result.rawStatus ?? result.status,
+        ...(result.status === "blocked" || result.status === "failed" ? { error: result.detail } : {}),
+    });
+}
+async function deliverVoiceChannelMessage(request, agentName, initialAudio) {
+    const result = await (0, outbound_1.placeTrustedFriendVoiceOutboundCall)({
+        agentName,
+        agentRoot: (0, identity_1.getAgentRoot)(),
+        friendId: request.friendId,
+        reason: request.content,
+        ...(initialAudio ? { initialAudio } : {}),
+    });
+    if (result.status === "placed") {
+        return {
+            status: "delivered_now",
+            detail: result.detail,
+        };
+    }
+    return {
+        status: result.status,
+        detail: result.detail,
+    };
+}
+/* v8 ignore start -- voice initial-audio parsing is exercised by voice transport tests; session tool keeps a thin argument adapter @preserve */
+function parseVoiceInitialAudio(args) {
+    const source = args.voiceAudioSource === "url" || args.voiceAudioSource === "file" || args.voiceAudioSource === "tone"
+        ? args.voiceAudioSource
+        : undefined;
+    const hasAudioHint = Boolean(source
+        || args.voiceAudioUrl?.trim()
+        || args.voiceAudioPath?.trim()
+        || args.voiceAudioLabel?.trim()
+        || args.voiceAudioToneHz?.trim()
+        || args.voiceAudioDurationMs?.trim());
+    if (!hasAudioHint)
+        return undefined;
+    const toneHz = args.voiceAudioToneHz?.trim() ? Number(args.voiceAudioToneHz) : undefined;
+    const durationMs = args.voiceAudioDurationMs?.trim() ? Number(args.voiceAudioDurationMs) : undefined;
+    return {
+        source: source ?? "tone",
+        ...(args.voiceAudioUrl?.trim() ? { url: args.voiceAudioUrl.trim() } : {}),
+        ...(args.voiceAudioPath?.trim() ? { path: args.voiceAudioPath.trim() } : {}),
+        ...(args.voiceAudioLabel?.trim() ? { label: args.voiceAudioLabel.trim() } : {}),
+        ...(Number.isFinite(toneHz) ? { toneHz } : {}),
+        ...(Number.isFinite(durationMs) ? { durationMs } : {}),
+    };
+}
+/* v8 ignore stop */
+function isLiveCodingSessionStatus(status) {
+    return status === "spawning"
+        || status === "running"
+        || status === "waiting_input"
+        || status === "stalled";
+}
+function readActiveWorkInnerState() {
+    const defaultJob = {
+        status: "idle",
+        content: null,
+        origin: null,
+        mode: "reflect",
+        obligationStatus: null,
+        surfacedResult: null,
+        queuedAt: null,
+        startedAt: null,
+        surfacedAt: null,
+    };
+    try {
+        const agentRoot = (0, identity_1.getAgentRoot)();
+        const pendingDir = (0, pending_1.getPrivateRuntimePendingDir)((0, identity_1.getAgentName)());
+        const sessionPath = (0, thoughts_1.getPrivateRuntimeSessionPath)(agentRoot);
+        const { pendingMessages, turns, runtimeState } = (0, thoughts_1.readPrivateRuntimeRawData)(sessionPath, pendingDir);
+        const dialogStatus = (0, thoughts_1.derivePrivateRuntimeStatus)(pendingMessages, turns, runtimeState);
+        const job = (0, thoughts_1.deriveInnerJob)(pendingMessages, turns, runtimeState);
+        const storeObligationPending = (0, obligations_1.readPendingObligations)(agentRoot).length > 0;
+        return {
+            status: dialogStatus.processing === "started" ? "running" : "idle",
+            hasPending: dialogStatus.queue !== "clear",
+            origin: dialogStatus.origin,
+            contentSnippet: dialogStatus.contentSnippet,
+            obligationPending: dialogStatus.obligationPending || storeObligationPending,
+            job,
+        };
+    }
+    catch {
+        return {
+            status: "idle",
+            hasPending: false,
+            job: defaultJob,
+        };
+    }
+}
+async function buildToolActiveWorkFrame(ctx) {
+    const currentSession = ctx?.currentSession
+        ? {
+            friendId: ctx.currentSession.friendId,
+            channel: ctx.currentSession.channel,
+            key: ctx.currentSession.key,
+            sessionPath: (0, config_1.resolveSessionPath)(ctx.currentSession.friendId, ctx.currentSession.channel, ctx.currentSession.key),
+        }
+        : null;
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    const bridges = currentSession
+        ? (0, manager_1.createBridgeManager)().findBridgesForSession({
+            friendId: currentSession.friendId,
+            channel: currentSession.channel,
+            key: currentSession.key,
+        })
+        : [];
+    let friendActivity = [];
+    try {
+        friendActivity = (0, session_activity_1.listSessionActivity)({
+            sessionsDir: `${agentRoot}/state/sessions`,
+            friendsDir: `${agentRoot}/friends`,
+            agentName: (0, identity_1.getAgentName)(),
+            currentSession,
+        });
+    }
+    catch {
+        friendActivity = [];
+    }
+    const pendingObligations = (() => {
+        try {
+            return (0, obligations_1.readPendingObligations)(agentRoot);
+        }
+        catch {
+            return [];
+        }
+    })();
+    let codingSessions = [];
+    let otherCodingSessions = [];
+    try {
+        const liveCodingSessions = (0, coding_1.getCodingSessionManager)()
+            .listSessions()
+            .filter((session) => isLiveCodingSessionStatus(session.status) && Boolean(session.originSession));
+        if (currentSession) {
+            codingSessions = liveCodingSessions.filter((session) => session.originSession?.friendId === currentSession.friendId
+                && session.originSession.channel === currentSession.channel
+                && session.originSession.key === currentSession.key);
+            otherCodingSessions = liveCodingSessions.filter((session) => !(session.originSession?.friendId === currentSession.friendId
+                && session.originSession.channel === currentSession.channel
+                && session.originSession.key === currentSession.key));
+        }
+        else {
+            codingSessions = [];
+            otherCodingSessions = liveCodingSessions;
+        }
+    }
+    catch {
+        codingSessions = [];
+        otherCodingSessions = [];
+    }
+    const currentObligation = currentSession
+        ? pendingObligations.find((obligation) => obligation.status !== "fulfilled"
+            && obligation.origin.friendId === currentSession.friendId
+            && obligation.origin.channel === currentSession.channel
+            && obligation.origin.key === currentSession.key)?.content ?? null
+        : null;
+    const backgroundOperations = (0, mail_import_discovery_1.listVisibleBackgroundOperations)({
+        agentName: (0, identity_1.getAgentName)(),
+        agentRoot,
+        repoRoot: process.cwd(),
+        homeDir: process.env.HOME,
+        nowMs: Date.now(),
+        limit: 5,
+    });
+    return (0, active_work_1.buildActiveWorkFrame)({
+        currentSession,
+        currentObligation,
+        mustResolveBeforeHandoff: false,
+        inner: readActiveWorkInnerState(),
+        bridges,
+        codingSessions,
+        backgroundOperations,
+        otherCodingSessions,
+        pendingObligations,
+        friendActivity,
+        targetCandidates: [],
+    });
+}
+function boundedStatusText(value, max = 180) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length <= max ? normalized : `${normalized.slice(0, max - 3)}...`;
+}
+function readButlerOperationalVisibility(agentRoot = (0, identity_1.getAgentRoot)(), agentName = (0, identity_1.getAgentName)()) {
+    const sourceErrors = {};
+    const read = (source, operation, fallback) => {
+        try {
+            return operation();
+        }
+        catch (error) {
+            sourceErrors[source] = boundedStatusText(error instanceof Error ? error.message : String(error)) || "unknown read failure";
+            return fallback;
+        }
+    };
+    const awaitsDir = path.join(agentRoot, "awaiting");
+    const awaits = read("awaits", () => fs.existsSync(awaitsDir) ? fs.readdirSync(awaitsDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".md"))
+        .map((entry) => {
+        const filePath = path.join(awaitsDir, entry.name);
+        return (0, await_parser_1.parseAwaitFile)(fs.readFileSync(filePath, "utf8"), filePath);
+    })
+        .filter((entry) => entry.status === "pending") : [], []);
+    const effectsRoot = path.join(agentRoot, "state", "telegram", "effects");
+    const telegramEffects = read("telegram_effects", () => {
+        if (!fs.existsSync(effectsRoot))
+            throw new Error("Telegram effect journal has not been created yet");
+        const journal = new telegram_effect_adapter_1.FileTelegramEffectJournal(effectsRoot);
+        try {
+            return journal.list().map((artifact) => ({
+                id: artifact.id,
+                authorClass: artifact.authorClass,
+                targetKind: artifact.target.kind,
+                state: artifact.parts.some((part) => part.state === "indeterminate") ? "indeterminate"
+                    : artifact.parts.some((part) => part.state === "attempting") ? "attempting"
+                        : artifact.parts.every((part) => part.state === "session_recorded") ? "session_recorded"
+                            : artifact.parts.some((part) => part.state === "accepted") ? "accepted"
+                                : "prepared",
+                acceptedAt: artifact.parts.flatMap((part) => part.acceptedAt ? [part.acceptedAt] : []).sort().at(-1) ?? null,
+                sessionRecordedAt: artifact.parts.flatMap((part) => part.sessionRecordedAt ? [part.sessionRecordedAt] : []).sort().at(-1) ?? null,
+                messageIds: artifact.parts.flatMap((part) => part.messageId ? [part.messageId] : []),
+                sessionEventIds: artifact.parts.flatMap((part) => part.sessionEventId ? [part.sessionEventId] : []),
+                updatedAt: artifact.updatedAt,
+            }));
+        }
+        finally {
+            journal.close();
+        }
+    }, []);
+    const admissionsRoot = path.join(agentRoot, "state", "senses", "telegram", "admissions");
+    const telegramAdmissions = read("telegram_admissions", () => {
+        if (!fs.existsSync(admissionsRoot))
+            throw new Error("Telegram admission store has not been created yet");
+        const store = new telegram_admission_1.FileTelegramAdmissionStore(admissionsRoot);
+        try {
+            return store.list().map((record) => ({ id: record.id, status: record.status, displayCode: record.displayCode, createdAt: record.createdAt, expiresAt: record.expiresAt }));
+        }
+        finally {
+            store.close();
+        }
+    }, []);
+    return {
+        agentName,
+        externalEvents: read("external_events", () => (0, router_1.listExternalEventStatus)((0, router_1.getExternalEventRoot)()).filter((event) => event.agent === agentName), []),
+        stewardPolicy: read("steward_policy", () => (0, steward_policy_1.readStewardPolicy)(agentRoot), { schemaVersion: 1, version: 0, desiredStates: {}, routineActionGrants: {}, updatedAt: null }),
+        awaits,
+        telegramEffects,
+        telegramAdmissions,
+        daemonHealth: read("daemon_health", () => {
+            const health = (0, daemon_health_1.readHealth)((0, daemon_health_1.getDefaultHealthPath)());
+            if (!health)
+                throw new Error("daemon health is missing or invalid");
+            return health;
+        }, null),
+        healthState: read("health_state", () => (0, sanctuary_health_1.readSanctuaryHealthState)(path.join(agentRoot, "state", "health", "sanctuary-health.json")), undefined),
+        routineActions: read("routine_actions", () => (0, steward_policy_1.readRoutineActionReceipts)(agentRoot), []),
+        providerLanes: read("provider", () => {
+            const config = (0, identity_1.loadAgentConfig)();
+            if (!config.humanFacing || !config.agentFacing)
+                throw new Error("provider lanes are unavailable");
+            return { outward: config.humanFacing, inner: config.agentFacing };
+        }, null),
+        lastAutomatedEventRun: read("run_ledger", () => (0, run_ledger_1.readRunLedger)(agentRoot)
+            .filter((row) => row.sourceKind === "private-runtime" && row.senseOrHabit === "external-event" && row.lifecycle === "completed")
+            .sort((left, right) => (right.endedAt ?? right.recordedAt).localeCompare(left.endedAt ?? left.recordedAt))[0] ?? null, null),
+        senseStatusLines: read("senses", () => (0, turn_context_1.readSenseStatusLines)(), []),
+        sourceErrors,
+    };
+}
+function formatButlerOperationalVisibility(status, options = {}) {
+    const section = options.section ?? "all";
+    const offset = Math.max(0, options.offset ?? 0);
+    const limit = Math.min(20, Math.max(1, options.limit ?? 10));
+    const show = (wanted) => section === "all" || section === wanted;
+    const page = (rows) => rows.slice(offset, offset + limit);
+    const more = (label, total) => total > offset + limit ? `  - ${total - offset - limit} more ${label}; call query_active_work with section=${label}, offset=${offset + limit}, limit=${limit}` : null;
+    const daemon = status.daemonHealth;
+    const agentHealth = daemon?.agents[status.agentName];
+    const lines = ["## butler operational visibility"];
+    const error = (source) => status.sourceErrors[source] ? `unavailable (${status.sourceErrors[source]})` : null;
+    if (show("health")) {
+        lines.push(`- daemon: ${error("daemon_health") ?? daemon?.status ?? "unavailable"}${daemon ? `; mode ${daemon.mode}; pid ${daemon.pid}` : ""}`);
+        lines.push(`- butler: ${agentHealth ? `${agentHealth.status}; pid ${agentHealth.pid ?? "none"}; crashes ${agentHealth.crashes}` : "unavailable"}`);
+        lines.push("- senses:");
+        lines.push(...(error("senses") ? [`  - ${error("senses")}`] : status.senseStatusLines.length > 0 ? status.senseStatusLines.map((line) => `  ${line}`) : ["  - unavailable"]));
+        const health = status.healthState;
+        lines.push(`- health sweeps: ${error("health_state") ?? health?.sweepReceipts.length ?? 0}; delivered ${health?.deliveredReceipts.length ?? 0}; indeterminate ${health?.indeterminateDeliveries.length ?? 0}; outbox ${health?.outbox ? `${health.outbox.status}:${health.outbox.id}` : "clear"}; open incidents ${health ? Object.keys(health.incidents).length : 0}; updated ${health?.updatedAt ?? "unavailable"}`);
+        const healthRows = [
+            ...(health?.sweepReceipts ?? []).map((sweep) => ({ at: sweep.completedAt, text: `sweep ${sweep.sweepId}: opened ${sweep.opened}; recovered ${sweep.recovered}; completed ${sweep.completedAt}${sweep.deliveryId ? `; delivery ${sweep.deliveryId}` : ""}` })),
+            ...(health?.deliveredReceipts ?? []).map((delivery) => ({ at: delivery.deliveredAt, text: `delivered ${delivery.deliveryId}: ${delivery.kind}; messages ${delivery.messageIds.join(",")}; at ${delivery.deliveredAt}` })),
+            ...(health?.indeterminateDeliveries ?? []).map((delivery) => ({ at: delivery.createdAt, text: `indeterminate ${delivery.id}: ${delivery.kind}; ${delivery.status}; created ${delivery.createdAt}` })),
+        ].sort((a, b) => b.at.localeCompare(a.at));
+        for (const row of page(healthRows))
+            lines.push(`  - ${row.text}`);
+        const overflow = more("health", healthRows.length);
+        if (overflow)
+            lines.push(overflow);
+    }
+    if (show("provider"))
+        lines.push(`- provider lanes: ${error("provider") ?? (status.providerLanes ? `outward ${status.providerLanes.outward.provider}/${status.providerLanes.outward.model}; inner ${status.providerLanes.inner.provider}/${status.providerLanes.inner.model}` : "unavailable")}`);
+    if (show("policy")) {
+        lines.push(`- steward policy: ${error("steward_policy") ?? `version ${status.stewardPolicy.version}; ${Object.keys(status.stewardPolicy.desiredStates).length} desired states; ${Object.keys(status.stewardPolicy.routineActionGrants).length} routine grants`}`);
+        const entries = [...Object.entries(status.stewardPolicy.desiredStates).map(([key, value]) => ({ key, kind: "desired", value })), ...Object.entries(status.stewardPolicy.routineActionGrants).map(([key, value]) => ({ key, kind: "grant", value }))];
+        for (const entry of page(entries)) {
+            const expiry = entry.value.expiresAt;
+            const active = !expiry || Date.parse(expiry) > Date.now();
+            lines.push(entry.kind === "desired" ? `  - ${entry.key} = ${boundedStatusText(entry.value.value)}; ${active ? "active" : "expired"}; ${entry.value.provenance}; source ${boundedStatusText(entry.value.source)}; v${entry.value.version}${expiry ? `; expires ${expiry}` : ""}` : `  - ${entry.key}: ${entry.value.action} on ${entry.value.targets.join(", ")}; ${active ? "active" : "expired"}; max ${entry.value.maxCount}/${entry.value.windowMs}ms; ${entry.value.verificationRequired ? "verification required" : "no verification"}; v${entry.value.version}${expiry ? `; expires ${expiry}` : ""}`);
+        }
+        const overflow = more("policy", entries.length);
+        if (overflow)
+            lines.push(overflow);
+    }
+    if (show("actions")) {
+        const actions = [...(status.routineActions ?? [])].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        lines.push(`- routine action receipts: ${error("routine_actions") ?? actions.length}`);
+        for (const action of page(actions)) {
+            const verification = action.state === "verified" ? `verified ${action.verifiedAfterState ?? "state unavailable"}` : action.state === "failed" ? "failed" : action.state === "indeterminate" ? "indeterminate; manual inspection required" : action.state === "recovered_no_effect" ? "no effect occurred" : "pending";
+            lines.push(`  - ${action.id}: ${action.action} ${action.target}; ${action.state}; updated ${action.updatedAt}; verification ${verification}`);
+        }
+        const overflow = more("actions", actions.length);
+        if (overflow)
+            lines.push(overflow);
+    }
+    if (show("awaits")) {
+        lines.push(`- pending awaits: ${status.awaits.length}`);
+        if (error("awaits"))
+            lines.push(`  - ${error("awaits")}`);
+        for (const pending of page(status.awaits))
+            lines.push(`  - ${pending.name}: ${boundedStatusText(pending.condition ?? (pending.body || "condition unavailable"))}${pending.wake_at ? `; wake ${pending.wake_at}` : ""}`);
+        const overflow = more("awaits", status.awaits.length);
+        if (overflow)
+            lines.push(overflow);
+    }
+    if (show("telegram")) {
+        const acceptedTimes = status.telegramEffects.flatMap((effect) => effect.acceptedAt ? [effect.acceptedAt] : []).sort().reverse();
+        const recordedTimes = status.telegramEffects.flatMap((effect) => effect.sessionRecordedAt ? [effect.sessionRecordedAt] : []).sort().reverse();
+        const legacyAccepted = status.telegramEffects.some((effect) => !effect.acceptedAt && (effect.state === "accepted" || effect.state === "session_recorded"));
+        const legacyRecorded = status.telegramEffects.some((effect) => !effect.sessionRecordedAt && effect.state === "session_recorded");
+        lines.push(`- latest Telegram accepted: ${acceptedTimes[0] ?? (legacyAccepted ? "timestamp unavailable (legacy artifacts present)" : "none")}; latest session recorded: ${recordedTimes[0] ?? (legacyRecorded ? "timestamp unavailable (legacy artifacts present)" : "none")}`);
+        lines.push(`- Telegram effects: ${error("telegram_effects") ?? status.telegramEffects.length}`);
+        lines.push(`- Telegram admissions: ${error("telegram_admissions") ?? status.telegramAdmissions.length}`);
+        const telegramRows = [
+            ...status.telegramEffects.map((effect) => ({ at: effect.updatedAt, effect })),
+            ...status.telegramAdmissions.map((admission) => ({ at: new Date(admission.createdAt).toISOString(), admission })),
+        ].sort((a, b) => b.at.localeCompare(a.at));
+        for (const row of page(telegramRows)) {
+            if ("admission" in row) {
+                const admission = row.admission;
+                lines.push(`  - admission ${admission.id}: ${admission.status}; code ${admission.displayCode}; expires ${new Date(admission.expiresAt).toISOString()}`);
+                continue;
+            }
+            const effect = row.effect;
+            const accepted = effect.acceptedAt ?? ((effect.state === "accepted" || effect.state === "session_recorded") ? "timestamp unavailable (legacy)" : "not accepted");
+            const recorded = effect.sessionRecordedAt ?? (effect.state === "session_recorded" ? "timestamp unavailable (legacy)" : "not recorded");
+            lines.push(`  - ${effect.id}: ${effect.state}; ${effect.authorClass}; ${effect.targetKind}; accepted ${accepted}; session recorded ${recorded}; message ids ${effect.messageIds?.join(",") || "none"}; session events ${effect.sessionEventIds?.join(",") || "none"}; updated ${effect.updatedAt}`);
+        }
+        const overflow = more("telegram", telegramRows.length);
+        if (overflow)
+            lines.push(overflow);
+    }
+    if (show("events")) {
+        const events = [...status.externalEvents].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+        const completedRun = status.lastAutomatedEventRun;
+        lines.push(`- external issues: ${events.length}; last successful automated event turn ${error("run_ledger") ?? (completedRun ? `${completedRun.endedAt ?? completedRun.recordedAt}; run ${completedRun.runId}; target ${completedRun.targetHash}` : "none")}`);
+        if (error("external_events"))
+            lines.push(`  - ${error("external_events")}`);
+        for (const event of page(events)) {
+            const policy = event.stewardPolicy?.kind === "current" ? `${event.stewardPolicy.key}@${event.stewardPolicy.version}` : "none";
+            lines.push(`  - ${event.source}/${event.eventType}/${event.eventId}: ${event.executionState}; disposition ${event.classification ?? "pending"}/${event.decision ?? "pending"}; reason ${boundedStatusText(event.reason ?? event.lastError ?? "not yet recorded")}; silence/wake ${event.nextWake ? JSON.stringify(event.nextWake) : "pending"}; steward ${policy}${event.awaitId ? `; await ${event.awaitId}` : ""}${event.careId ? `; care ${event.careId}` : ""}`);
+        }
+        const overflow = more("events", events.length);
+        if (overflow)
+            lines.push(overflow);
+    }
+    return lines.join("\n");
+}
+function findDelegatingBridgeId(ctx) {
+    const currentSession = ctx?.currentSession;
+    if (!currentSession)
+        return undefined;
+    return ctx?.activeBridges?.find((bridge) => bridge.lifecycle === "active"
+        && bridge.attachedSessions.some((session) => session.friendId === currentSession.friendId
+            && session.channel === currentSession.channel
+            && session.key === currentSession.key))?.id;
+}
+function sendMessageRiskProfile(args) {
+    if (args.friendId?.trim() === "self") {
+        return {
+            mutates: "private_attention_write",
+            risk: "high",
+            reason: "queues private-runtime attention without contacting an external session",
+        };
+    }
+    return {
+        mutates: ["durable_state_write", "external_side_effect"],
+        risk: "high",
+        reason: "queues or delivers messages across sessions/channels",
+    };
+}
+function renderInnerProgressStatus(status) {
+    if (status.processing === "pending") {
+        return "i've queued this thought for private attention. it'll come up when my private runtime is free.";
+    }
+    if (status.processing === "started") {
+        return "i'm working through this privately right now.";
+    }
+    // processed / completed
+    if (status.surfaced && status.surfaced !== "nothing recent" && status.surfaced !== "no outward result") {
+        return `i thought about this privately and came to something: ${status.surfaced}`;
+    }
+    return "i thought about this privately. i'll bring it back when the time is right.";
+}
+exports.sessionToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_active_work",
+                description: "read the current live world-state across visible sessions, coding lanes, private-runtime work, and return obligations. Sanctuary operational details support bounded section/offset/limit paging.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        section: { type: "string", enum: ["all", "health", "policy", "awaits", "telegram", "events", "actions", "provider"], description: "Sanctuary detail section; defaults to all" },
+                        offset: { type: "string", description: "zero-based detail offset; defaults to 0" },
+                        limit: { type: "string", description: "detail rows per section, 1-20; defaults to 10" },
+                    },
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            const frame = await buildToolActiveWorkFrame(ctx);
+            const activeWork = `this is my current top-level live world-state.\nanswer whole-self status questions from this before drilling into individual sessions.\n\n${(0, active_work_1.formatActiveWorkFrame)(frame)}`;
+            const numeric = (value, fallback, min, max) => value === undefined ? fallback : /^\d+$/u.test(value) ? Math.min(max, Math.max(min, Number(value))) : fallback;
+            return (0, identity_1.getAgentName)() === "sanctuary"
+                ? `${activeWork}\n\n${formatButlerOperationalVisibility(readButlerOperationalVisibility(), { section: args.section, offset: numeric(args.offset, 0, 0, 10_000), limit: numeric(args.limit, 10, 1, 20) })}`
+                : activeWork;
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "session_summary",
+                description: "read-only orientation for habit runs. returns a structured live summary from habit receipts, session files, pending dirs, and runtime cursors without writing state.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        runId: { type: "string", description: "exact habit run id; cannot be combined with habitName, operationId, or which" },
+                        habitName: { type: "string", description: "habit name to select from" },
+                        operationId: { type: "string", description: "operation id for stateful habit run groups, such as habit:heartbeat" },
+                        which: {
+                            type: "string",
+                            enum: ["latest", "previous", "latest-success", "latest-failure"],
+                            description: "which matching run to read; defaults to latest",
+                        },
+                    },
+                },
+            },
+        },
+        handler: (args, ctx) => {
+            const validation = validateSessionSummarySelector(args);
+            if (!validation.ok) {
+                return JSON.stringify({
+                    kind: "invalid_selector",
+                    code: validation.code,
+                    message: validation.message,
+                }, null, 2);
+            }
+            (0, tool_arguments_1.assertRelationshipToolOwner)(ctx);
+            const summary = (0, habit_session_summary_1.readHabitSessionSummary)(ctx?.agentRoot ?? (0, identity_1.getAgentRoot)(ctx?.agentName), validation.selector);
+            if (!summary) {
+                return JSON.stringify({
+                    kind: "not_found",
+                    message: "no habit run matched selector",
+                    selector: validation.selector,
+                }, null, 2);
+            }
+            return JSON.stringify({
+                kind: "habit_session_summary",
+                text: renderSessionSummaryText(summary),
+                summary,
+            }, null, 2);
+        },
+        riskProfile: {
+            mutates: "none",
+            risk: "low",
+            reason: "reads habit run summaries from local receipts and session artifacts",
+        },
+        summaryKeys: ["runId", "habitName", "operationId", "which"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_session",
+                description: "inspect another session. use transcript for recent context or status for self/private-runtime progress. deprecated search invocations should use search_facts, consult_diary, or consult_notes instead.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        friendId: { type: "string", description: "the friend UUID (or 'self')" },
+                        channel: { type: "string", description: "the channel: cli, teams, bluebubbles, voice, mcp, or legacy inner for private-runtime compatibility" },
+                        key: { type: "string", description: "session key (defaults to 'session')" },
+                        messageCount: { type: "string", description: "how many recent messages to return (default 20)" },
+                        mode: {
+                            type: "string",
+                            enum: ["transcript", "status", "search"],
+                            description: "transcript (default), lightweight status for self/private-runtime checks, or deprecated search; use search_facts, consult_diary, or consult_notes instead",
+                        },
+                        query: { type: "string", description: "deprecated when mode=search; use search_facts, consult_diary, or consult_notes instead" },
+                    },
+                    required: ["friendId", "channel"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            let friendId = args.friendId;
+            const channel = args.channel;
+            const key = args.key || "session";
+            const count = parseInt(args.messageCount || "20", 10);
+            const mode = args.mode || "transcript";
+            if (!(0, config_1.isValidSessionCoordinate)(friendId) || !(0, config_1.isValidSessionCoordinate)(channel)) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn", component: "tools", event: "tool.session_path_rejected",
+                    message: "session query rejected invalid coordinates", meta: { reason: "invalid friend or channel" },
+                });
+                return NO_SESSION_FOUND_MESSAGE;
+            }
+            (0, tool_arguments_1.assertRelationshipToolOwner)(ctx);
+            // Resolve friend name -> UUID if not already a UUID or "self"
+            if (friendId && friendId !== "self" && !/^[0-9a-f]{8}-[0-9a-f]{4}-/.test(friendId) && ctx?.friendStore?.listAll) {
+                const allFriends = await ctx.friendStore.listAll();
+                const match = allFriends.find(f => f.name.toLowerCase() === friendId.toLowerCase());
+                if (match) {
+                    friendId = match.id;
+                }
+            }
+            if (mode === "status") {
+                if (friendId !== "self" || channel !== "inner") {
+                    return "status mode is only available for self/private runtime.";
+                }
+                const agentRoot = ctx?.agentRoot ?? (0, identity_1.getAgentRoot)(ctx?.agentName);
+                const sessionPath = (0, thoughts_1.getPrivateRuntimeSessionPath)(agentRoot);
+                const pendingDir = (0, pending_1.getPrivateRuntimePendingDir)(ctx?.agentName ?? (0, identity_1.getAgentName)(), agentRoot);
+                return renderInnerProgressStatus((0, thoughts_1.readPrivateRuntimeStatus)(sessionPath, pendingDir));
+            }
+            if (mode === "search") {
+                return JSON.stringify({
+                    kind: "deprecated",
+                    message: "query_session mode=search is no longer available; use search_facts, consult_diary, or consult_notes instead.",
+                    removalCycle: "alpha.616",
+                });
+            }
+            let sessFile;
+            try {
+                sessFile = (0, config_1.resolveSessionPath)(friendId, channel, key, {
+                    agentRoot: ctx?.agentRoot ?? (0, identity_1.getAgentRoot)(ctx?.agentName), confined: true,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof config_1.InvalidSessionPathError))
+                    throw error;
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn", component: "tools", event: "tool.session_path_rejected",
+                    message: "session query rejected an unconfined path", meta: { reason: error.message },
+                });
+                return NO_SESSION_FOUND_MESSAGE;
+            }
+            const sessionTail = await summarizeSessionTailSafely({
+                sessionPath: sessFile,
+                friendId,
+                channel,
+                key,
+                messageCount: count,
+                trustLevel: ctx?.context?.friend?.trustLevel,
+                summarize: ctx?.summarize,
+            });
+            if (sessionTail.kind === "missing") {
+                return NO_SESSION_FOUND_MESSAGE;
+            }
+            if (sessionTail.kind === "empty") {
+                return EMPTY_SESSION_MESSAGE;
+            }
+            return sessionTail.summary;
+        },
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "send_message",
+                description: "send a message to a friend's session. when the request is explicitly authorized from a trusted live chat, the harness will try to deliver immediately; otherwise it reports truthful queued/block/failure state. do not use friendId=self for user-requested private-return work; use ponder so the typed return contract can be tracked and surfaced once.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        friendId: { type: "string", description: "the friend UUID (or 'self')" },
+                        channel: { type: "string", description: "the channel: cli, teams, bluebubbles, voice, mcp, or legacy inner for private-runtime compatibility. channel=voice intentionally starts a live phone call to a trusted friend through the Voice sense." },
+                        key: { type: "string", description: "session key (defaults to 'session')" },
+                        content: { type: "string", description: "the message content to send" },
+                        voiceAudioSource: { type: "string", enum: ["tone", "url", "file"], description: "optional initial non-speech audio to play after the opening greeting when channel=voice" },
+                        voiceAudioUrl: { type: "string", description: "short audio URL for voiceAudioSource=url" },
+                        voiceAudioPath: { type: "string", description: "local audio file path for voiceAudioSource=file" },
+                        voiceAudioLabel: { type: "string", description: "short label for the initial voice audio" },
+                        voiceAudioToneHz: { type: "number", description: "tone frequency for voiceAudioSource=tone" },
+                        voiceAudioDurationMs: { type: "number", description: "initial audio duration in milliseconds" },
+                    },
+                    required: ["friendId", "channel", "content"],
+                },
+            },
+        },
+        handler: async (args, ctx) => {
+            let friendId = args.friendId;
+            const channel = args.channel;
+            const key = args.key || "session";
+            const content = args.content;
+            const voiceInitialAudio = channel === "voice" ? parseVoiceInitialAudio(args) : undefined;
+            const now = Date.now();
+            const agentName = (0, identity_1.getAgentName)();
+            // Resolve friend name → UUID if needed
+            /* v8 ignore start -- name resolution: reads real filesystem, tested via live integration @preserve */
+            if (friendId !== "self") {
+                const originalFriendId = friendId;
+                try {
+                    const agentRoot = (0, identity_1.getAgentRoot)();
+                    const sessionsDir = path.join(agentRoot, "state", "sessions");
+                    const friendsDir = path.join(agentRoot, "friends");
+                    const sessionDirExists = fs.existsSync(path.join(sessionsDir, friendId));
+                    if (!sessionDirExists) {
+                        const friendFiles = fs.readdirSync(friendsDir).filter((f) => f.endsWith(".json"));
+                        for (const file of friendFiles) {
+                            const raw = fs.readFileSync(path.join(friendsDir, file), "utf-8");
+                            const record = JSON.parse(raw);
+                            if (record.name?.toLowerCase() === friendId.toLowerCase() && record.id) {
+                                friendId = record.id;
+                                break;
+                            }
+                        }
+                        (0, runtime_1.emitNervesEvent)({
+                            component: "repertoire",
+                            event: "repertoire.send_message_name_resolve",
+                            message: friendId !== originalFriendId ? "resolved friend name to UUID" : "friend name resolution failed",
+                            meta: { original: originalFriendId, resolved: friendId, friendsDir, fileCount: friendFiles.length },
+                        });
+                    }
+                }
+                catch (err) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "repertoire",
+                        event: "repertoire.send_message_name_resolve_error",
+                        message: "friend name resolution threw",
+                        meta: { friendId: originalFriendId, error: err instanceof Error ? err.message : String(err) },
+                    });
+                }
+            }
+            /* v8 ignore stop */
+            // Self-routing: messages to "self" always go to the private-runtime pending dir,
+            // regardless of the channel or key the agent specified.
+            const isSelf = friendId === "self";
+            const pendingDir = isSelf
+                ? (0, pending_1.getPrivateRuntimePendingDir)(agentName)
+                : (0, pending_1.getPendingDir)(agentName, friendId, channel, key);
+            const delegatingBridgeId = findDelegatingBridgeId(ctx);
+            const delegatedFrom = isSelf
+                && ctx?.currentSession
+                && !(ctx.currentSession.friendId === "self" && ctx.currentSession.channel === "inner")
+                ? {
+                    friendId: ctx.currentSession.friendId,
+                    channel: ctx.currentSession.channel,
+                    key: ctx.currentSession.key,
+                    ...(delegatingBridgeId ? { bridgeId: delegatingBridgeId } : {}),
+                }
+                : undefined;
+            const obligationId = delegatedFrom ? (0, obligations_1.generateObligationId)(now) : undefined;
+            const envelope = {
+                from: agentName,
+                friendId,
+                channel,
+                key,
+                content,
+                timestamp: now,
+                ...(delegatedFrom ? { delegatedFrom, obligationStatus: "pending" } : {}),
+                ...(obligationId ? { obligationId } : {}),
+            };
+            if (isSelf) {
+                const pendingMessageId = writePendingEnvelope(pendingDir, envelope);
+                if (delegatedFrom) {
+                    try {
+                        (0, obligations_1.createObligation)((0, identity_1.getAgentRoot)(), {
+                            origin: {
+                                friendId: delegatedFrom.friendId,
+                                channel: delegatedFrom.channel,
+                                key: delegatedFrom.key,
+                            },
+                            ...(delegatedFrom.bridgeId ? { bridgeId: delegatedFrom.bridgeId } : {}),
+                            content,
+                        });
+                    }
+                    catch {
+                        /* v8 ignore next -- defensive: obligation store write failure should not break send_message @preserve */
+                    }
+                    /* v8 ignore next -- obligationId always set when delegatedFrom is set (see generateObligationId above) @preserve */
+                    if (obligationId) {
+                        (0, obligations_1.createReturnObligation)(agentName, {
+                            id: obligationId,
+                            origin: delegatedFrom,
+                            status: "queued",
+                            delegatedContent: content.length > 120 ? `${content.slice(0, 117)}...` : content,
+                            createdAt: now,
+                        });
+                    }
+                    (0, runtime_1.emitNervesEvent)({
+                        event: "repertoire.obligation_created",
+                        component: "repertoire",
+                        message: "obligation created for private-runtime delegation",
+                        meta: {
+                            friendId: delegatedFrom.friendId,
+                            channel: delegatedFrom.channel,
+                            key: delegatedFrom.key,
+                        },
+                    });
+                }
+                try {
+                    await (0, socket_client_1.requestPrivateWake)(agentName, ctx?.daemonSocketPath, {
+                        reason: "send_message self-route private attention",
+                        triggerSource: "send-message-self-route",
+                        budgetClass: "interactive",
+                        idempotencyKey: `send-message-self-route:${agentName}:${pendingMessageId}`,
+                        originRefs: [
+                            { kind: "tool", id: "send_message" },
+                            { kind: "pending-queue", id: "self/inner/dialog" },
+                            { kind: "pending-message", id: pendingMessageId },
+                        ],
+                    });
+                }
+                catch {
+                    // Queue-first self routing must not inline-run private work when the daemon is unavailable.
+                }
+                return renderInnerProgressStatus({
+                    queue: "queued to private runtime",
+                    wake: "daemon requested",
+                    processing: "pending",
+                    surfaced: "nothing yet",
+                });
+            }
+            // Resolve BB session key if using default — agents don't know the real session key
+            /* v8 ignore start -- BB session key resolution: reads real filesystem @preserve */
+            let resolvedKey = key;
+            if (channel === "bluebubbles" && key === "session") {
+                try {
+                    const agentRoot = (0, identity_1.getAgentRoot)();
+                    const bbDir = path.join(agentRoot, "state", "sessions", friendId, "bluebubbles");
+                    if (fs.existsSync(bbDir)) {
+                        const files = fs.readdirSync(bbDir).filter((f) => f.endsWith(".json"));
+                        // Only use DM sessions (;-;) for proactive delivery — never group chats (;+;)
+                        const dmFile = files.find((f) => f.includes(";-;"));
+                        if (dmFile) {
+                            resolvedKey = dmFile.replace(/\.json$/, "");
+                        }
+                    }
+                }
+                catch { /* continue with default key */ }
+            }
+            /* v8 ignore stop */
+            const deliveryResult = await (0, cross_chat_delivery_1.deliverCrossChatMessage)({
+                friendId,
+                channel,
+                key: resolvedKey,
+                content,
+                intent: ctx?.currentSession && ctx.currentSession.friendId !== "self"
+                    ? "explicit_cross_chat"
+                    : "generic_outreach",
+                ...(ctx?.currentSession && ctx.currentSession.friendId !== "self"
+                    ? {
+                        authorizingSession: {
+                            friendId: ctx.currentSession.friendId,
+                            channel: ctx.currentSession.channel,
+                            key: ctx.currentSession.key,
+                            trustLevel: ctx?.context?.friend?.trustLevel,
+                        },
+                    }
+                    : {}),
+            }, {
+                agentName,
+                queuePending: (message) => writePendingEnvelope(pendingDir, message),
+                deliverers: {
+                    bluebubbles: async (request) => {
+                        const { sendProactiveBlueBubblesMessageToSession } = await Promise.resolve().then(() => __importStar(require("../senses/bluebubbles")));
+                        const result = await sendProactiveBlueBubblesMessageToSession({
+                            friendId: request.friendId,
+                            sessionKey: request.key,
+                            text: request.content,
+                            intent: request.intent,
+                            authorizingSession: request.authorizingSession,
+                        });
+                        if (result.delivered) {
+                            return {
+                                status: "delivered_now",
+                                detail: "sent to the active bluebubbles chat now",
+                            };
+                        }
+                        if (result.reason === "missing_target") {
+                            return {
+                                status: "blocked",
+                                detail: "bluebubbles could not resolve a routable target for that session",
+                            };
+                        }
+                        if (result.reason === "blocked_meta_content") {
+                            return {
+                                status: "blocked",
+                                detail: "blocked: contains internal meta markers",
+                            };
+                        }
+                        if (result.reason === "send_error") {
+                            return {
+                                status: "failed",
+                                detail: "bluebubbles send failed",
+                            };
+                        }
+                        return {
+                            status: "unavailable",
+                            detail: "live delivery unavailable right now; queued for the next active turn",
+                        };
+                    },
+                    teams: async (request) => {
+                        if (!ctx?.botApi) {
+                            return {
+                                status: "unavailable",
+                                detail: "live delivery unavailable right now; queued for the next active turn",
+                            };
+                        }
+                        const { sendProactiveTeamsMessageToSession } = await Promise.resolve().then(() => __importStar(require("../senses/teams")));
+                        const result = await sendProactiveTeamsMessageToSession({
+                            friendId: request.friendId,
+                            sessionKey: request.key,
+                            text: request.content,
+                            intent: request.intent,
+                            authorizingSession: request.authorizingSession,
+                        }, {
+                            botApi: ctx.botApi,
+                        });
+                        if (result.delivered) {
+                            return {
+                                status: "delivered_now",
+                                detail: "sent to the active teams chat now",
+                            };
+                        }
+                        if (result.reason === "missing_target") {
+                            return {
+                                status: "blocked",
+                                detail: "teams could not resolve a routable target for that session",
+                            };
+                        }
+                        if (result.reason === "send_error") {
+                            return {
+                                status: "failed",
+                                detail: "teams send failed",
+                            };
+                        }
+                        return {
+                            status: "unavailable",
+                            detail: "live delivery unavailable right now; queued for the next active turn",
+                        };
+                    },
+                    telegram: async (request) => {
+                        const key = (0, config_1.canonicalizeTelegramSessionKey)(request.key);
+                        const hash = (0, crypto_1.createHash)("sha256").update(`${request.friendId}\0${key}\0${request.content}`).digest("hex");
+                        const { sendTelegramAwaitFollowUp } = await Promise.resolve().then(() => __importStar(require("../senses/telegram")));
+                        return sendTelegramAwaitFollowUp(agentName, {
+                            ...request,
+                            key,
+                            requestId: request.requestId ?? `send-message:${hash}`,
+                            deliveryId: request.deliveryId ?? `send-message:${hash}`,
+                        });
+                    },
+                    voice: async (request) => deliverVoiceChannelMessage(request, agentName, voiceInitialAudio),
+                },
+            });
+            recordHabitSendAttempt(ctx, { friendId, channel, key }, deliveryResult);
+            return renderCrossChatDeliveryStatus(`${friendId} on ${channel}/${key}`, deliveryResult);
+        },
+        riskProfile: sendMessageRiskProfile,
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "set_reasoning_effort",
+                description: "adjust your own reasoning depth for subsequent turns. use higher effort for complex analysis, lower for simple tasks.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        level: { type: "string", description: "the reasoning effort level to set" },
+                    },
+                    required: ["level"],
+                },
+            },
+        },
+        handler: (args, ctx) => {
+            if (!ctx?.supportedReasoningEfforts || !ctx.setReasoningEffort) {
+                return "reasoning effort adjustment is not available in this context.";
+            }
+            const level = (args.level || "").trim();
+            if (!ctx.supportedReasoningEfforts.includes(level)) {
+                return `invalid reasoning effort level "${level}". accepted levels: ${ctx.supportedReasoningEfforts.join(", ")}`;
+            }
+            ctx.setReasoningEffort(level);
+            (0, runtime_1.emitNervesEvent)({
+                component: "repertoire",
+                event: "repertoire.reasoning_effort_changed",
+                message: `reasoning effort set to ${level}`,
+                meta: { level },
+            });
+            return `reasoning effort set to "${level}".`;
+        },
+        requiredCapability: "reasoning-effort",
+        summaryKeys: ["level"],
+    },
+];