@ouro.bot/cli 0.1.0-alpha.674 → 0.1.0-alpha.675

package/dist/senses/inner-dialog.js

@@ -10,965 +10,14 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     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;
-    };
-})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadInnerDialogInstincts = loadInnerDialogInstincts;
-exports.buildInnerDialogBootstrapMessage = buildInnerDialogBootstrapMessage;
-exports.buildNonCanonicalCleanupNudge = buildNonCanonicalCleanupNudge;
-exports.buildInstinctUserMessage = buildInstinctUserMessage;
-exports.readTaskFile = readTaskFile;
-exports.buildTaskTriggeredMessage = buildTaskTriggeredMessage;
-exports.deriveResumeCheckpoint = deriveResumeCheckpoint;
-exports.innerDialogSessionPath = innerDialogSessionPath;
-exports.enrichDelegatedFromWithBridge = enrichDelegatedFromWithBridge;
-exports.routeDelegatedCompletion = routeDelegatedCompletion;
-exports.buildParseErrorNudge = buildParseErrorNudge;
-exports.buildHeldReturnWakeMessage = buildHeldReturnWakeMessage;
-exports.runInnerDialogTurn = runInnerDialogTurn;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const config_1 = require("../heart/config");
-const core_1 = require("../heart/core");
-const identity_1 = require("../heart/identity");
-const context_1 = require("../mind/context");
-const prompt_1 = require("../mind/prompt");
-const mcp_manager_1 = require("../repertoire/mcp-manager");
-const tools_1 = require("../repertoire/tools");
-const bundle_manifest_1 = require("../mind/bundle-manifest");
-const pending_1 = require("../mind/pending");
-const obligations_1 = require("../arc/obligations");
-const attention_queue_1 = require("./attention-queue");
-const packets_1 = require("../arc/packets");
-const friends_1 = require("@ouro.bot/friends");
-const trust_gate_1 = require("./trust-gate");
-const pipeline_1 = require("./pipeline");
-const nerves_1 = require("../nerves");
-const runtime_1 = require("../nerves/runtime");
-const manager_1 = require("../heart/bridges/manager");
-const session_activity_1 = require("../heart/session-activity");
-const bluebubbles_1 = require("./bluebubbles");
-const habit_turn_message_1 = require("./habit-turn-message");
-const await_turn_message_1 = require("./await-turn-message");
-const await_parser_1 = require("../heart/awaiting/await-parser");
-const await_runtime_state_1 = require("../heart/awaiting/await-runtime-state");
-const habit_parser_1 = require("../heart/habits/habit-parser");
-const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
-const cadence_1 = require("../heart/daemon/cadence");
-const daemon_health_1 = require("../heart/daemon/daemon-health");
-const flight_recorder_1 = require("../arc/flight-recorder");
-const desk_section_1 = require("../mind/desk-section");
-const DEFAULT_INNER_DIALOG_INSTINCTS = [
-    {
-        id: "heartbeat_checkin",
-        prompt: "...time passing. anything stirring?",
-        enabled: true,
-    },
-];
-function readAspirations(agentRoot) {
-    try {
-        return fs.readFileSync(path.join(agentRoot, "psyche", "ASPIRATIONS.md"), "utf8").trim();
-    }
-    catch {
-        return "";
-    }
-}
-function loadInnerDialogInstincts() {
-    return [...DEFAULT_INNER_DIALOG_INSTINCTS];
-}
-function buildInnerDialogBootstrapMessage(aspirations, stateSummary) {
-    const lines = ["waking up."];
-    if (aspirations) {
-        lines.push("", "## what matters to me", aspirations);
-    }
-    if (stateSummary) {
-        lines.push("", "## what i know so far", stateSummary);
-    }
-    lines.push("", "what needs my attention?");
-    return lines.join("\n");
-}
-function buildNonCanonicalCleanupNudge(nonCanonicalPaths) {
-    if (nonCanonicalPaths.length === 0)
-        return "";
-    const listed = nonCanonicalPaths.slice(0, 20).map((entry) => `- ${entry}`);
-    if (nonCanonicalPaths.length > 20) {
-        listed.push(`- ... (${nonCanonicalPaths.length - 20} more)`);
-    }
-    return [
-        "## canonical cleanup nudge",
-        "I found non-canonical files in my bundle. I should distill anything valuable into my diary and remove these files.",
-        ...listed,
-    ].join("\n");
-}
-function displayCheckpoint(checkpoint) {
-    const trimmed = checkpoint?.trim();
-    if (!trimmed || trimmed === "no prior checkpoint recorded") {
-        return undefined;
-    }
-    return trimmed;
-}
-function buildInstinctUserMessage(instincts, _reason, state) {
-    const active = instincts.find((instinct) => instinct.enabled !== false) ?? DEFAULT_INNER_DIALOG_INSTINCTS[0];
-    const checkpoint = displayCheckpoint(state.checkpoint);
-    const lines = [active.prompt];
-    if (checkpoint) {
-        lines.push(`\nlast checkpoint: ${checkpoint}`);
-    }
-    return lines.join("\n");
-}
-function readTaskFile(agentRoot, taskId) {
-    // Task files live in collection subdirectories (one-shots, ongoing).
-    // Try each collection, then fall back to root tasks/ for legacy layout.
-    // Habits are no longer in tasks/ — they live at bundle root habits/.
-    const collections = ["one-shots", "ongoing", ""];
-    for (const collection of collections) {
-        try {
-            return fs.readFileSync(path.join(agentRoot, "tasks", collection, `${taskId}.md`), "utf8").trim();
-        }
-        catch {
-            // not in this collection — try next
-        }
-    }
-    return "";
-}
-function buildTaskTriggeredMessage(taskId, taskContent, checkpoint) {
-    const lines = ["a task needs my attention."];
-    if (taskContent) {
-        lines.push("", `## task: ${taskId}`, taskContent);
-    }
-    else {
-        lines.push("", `## task: ${taskId}`, "(task file not found)");
-    }
-    const renderedCheckpoint = displayCheckpoint(checkpoint);
-    if (renderedCheckpoint) {
-        lines.push("", `last checkpoint: ${renderedCheckpoint}`);
-    }
-    return lines.join("\n");
-}
-function contentToText(content) {
-    if (typeof content === "string")
-        return content.trim();
-    if (!Array.isArray(content))
-        return "";
-    const text = content
-        .map((part) => {
-        if (typeof part === "string")
-            return part;
-        if (!part || typeof part !== "object")
-            return "";
-        if ("text" in part && typeof part.text === "string") {
-            return part.text;
-        }
-        return "";
-    })
-        .join("\n");
-    return text.trim();
-}
-function checkpointTextFromAssistantContent(content) {
-    const assistantText = contentToText(content);
-    if (!assistantText)
-        return null;
-    const cleanedLines = assistantText
-        .split("\n")
-        .map((line) => line.replace(/<\/?think>/gi, "").trim())
-        .filter((line) => line.length > 0);
-    const explicitCheckpoint = cleanedLines
-        .find((line) => /^checkpoint\s*:/i.test(line));
-    if (explicitCheckpoint) {
-        const parsed = explicitCheckpoint.replace(/^checkpoint\s*:\s*/i, "").trim();
-        return parsed || null;
-    }
-    const firstLine = cleanedLines[0];
-    return firstLine ?? null;
-}
-function truncateCheckpointText(text) {
-    if (text.length <= 220)
-        return text;
-    return `${text.slice(0, 217)}...`;
-}
-function parseToolArguments(argumentsValue) {
-    if (!argumentsValue)
-        return {};
-    try {
-        const parsed = JSON.parse(argumentsValue);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-            ? parsed
-            : {};
-    }
-    catch {
-        return {};
-    }
-}
-function toolArgumentText(args, keys) {
-    for (const key of keys) {
-        const value = args[key];
-        if (typeof value === "string" && value.trim()) {
-            return value.trim();
-        }
-    }
-    return "";
-}
-function summarizeToolAction(name, argumentsValue) {
-    if (!name)
-        return null;
-    const args = parseToolArguments(argumentsValue);
-    if (name === "surface") {
-        const message = toolArgumentText(args, ["message", "text", "content"]);
-        return message ? `surfaced: ${message}` : null;
-    }
-    if (name === "ponder") {
-        const thought = toolArgumentText(args, ["summary", "question", "topic", "prompt"]);
-        return thought ? `pondered: ${thought}` : null;
-    }
-    if (name === "diary_write") {
-        const note = toolArgumentText(args, ["text", "content", "note", "entry"]);
-        return note ? `diary: ${note}` : null;
-    }
-    if (name === "let_go") {
-        const reason = toolArgumentText(args, ["reason", "note", "status"]);
-        return reason ? `let go: ${reason}` : null;
-    }
-    if (name === "rest") {
-        const note = toolArgumentText(args, ["note", "status"]);
-        return note ? `rested: ${note}` : null;
-    }
-    return null;
-}
-function extractToolFunction(toolCall) {
-    if (!toolCall || typeof toolCall !== "object" || !("function" in toolCall))
-        return null;
-    const maybeFunction = toolCall.function;
-    if (!maybeFunction || typeof maybeFunction !== "object")
-        return null;
-    const name = "name" in maybeFunction && typeof maybeFunction.name === "string"
-        ? maybeFunction.name
-        : undefined;
-    const argumentsValue = "arguments" in maybeFunction && typeof maybeFunction.arguments === "string"
-        ? maybeFunction.arguments
-        : undefined;
-    return { name, arguments: argumentsValue };
-}
-function checkpointTextFromAssistantToolCalls(message) {
-    if (message.role !== "assistant" || !Array.isArray(message.tool_calls))
-        return null;
-    for (let i = message.tool_calls.length - 1; i >= 0; i--) {
-        const toolFunction = extractToolFunction(message.tool_calls[i]);
-        const summary = summarizeToolAction(toolFunction?.name, toolFunction?.arguments);
-        if (summary)
-            return summary;
-    }
-    return null;
-}
-function latestRestStatus(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const message = messages[i];
-        if (message.role !== "assistant" || !Array.isArray(message.tool_calls))
-            continue;
-        for (let j = message.tool_calls.length - 1; j >= 0; j--) {
-            const toolFunction = extractToolFunction(message.tool_calls[j]);
-            if (toolFunction?.name !== "rest")
-                continue;
-            const status = parseToolArguments(toolFunction.arguments).status;
-            return typeof status === "string" && status.trim() ? status.trim() : undefined;
-        }
-    }
-    return undefined;
-}
-function deriveResumeCheckpoint(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const message = messages[i];
-        if (message.role !== "assistant")
-            continue;
-        const textCheckpoint = checkpointTextFromAssistantContent(message.content);
-        if (textCheckpoint)
-            return truncateCheckpointText(textCheckpoint);
-        const toolCheckpoint = checkpointTextFromAssistantToolCalls(message);
-        if (toolCheckpoint)
-            return truncateCheckpointText(toolCheckpoint);
-    }
-    return "no prior checkpoint recorded";
-}
-function extractAssistantPreview(messages, maxLength = 120) {
-    const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
-    if (!lastAssistant)
-        return "";
-    const text = contentToText(lastAssistant.content);
-    if (!text)
-        return "";
-    /* v8 ignore next -- unreachable: contentToText().trim() guarantees a non-empty line @preserve */
-    const firstLine = text.split("\n").find((line) => line.trim().length > 0) ?? "";
-    if (firstLine.length <= maxLength)
-        return firstLine;
-    return `${firstLine.slice(0, maxLength - 3)}...`;
-}
-function extractToolCallNames(messages) {
-    const names = [];
-    for (const msg of messages) {
-        if (msg.role === "assistant" && "tool_calls" in msg && Array.isArray(msg.tool_calls)) {
-            for (const tc of msg.tool_calls) {
-                if ("function" in tc && tc.function?.name)
-                    names.push(tc.function.name);
-            }
-        }
-    }
-    return [...new Set(names)];
-}
-function createInnerDialogCallbacks() {
-    return {
-        onModelStart: () => { },
-        onModelStreamStart: () => { },
-        onTextChunk: () => { },
-        onReasoningChunk: () => { },
-        onToolStart: () => { },
-        onToolEnd: () => { },
-        onError: () => { },
-    };
-}
-function innerDialogSessionPath() {
-    return (0, config_1.sessionPath)(pending_1.INNER_DIALOG_PENDING.friendId, pending_1.INNER_DIALOG_PENDING.channel, pending_1.INNER_DIALOG_PENDING.key);
-}
-function innerDialogRuntimeStatePath(sessionFilePath) {
-    return path.join(path.dirname(sessionFilePath), "runtime.json");
-}
-function writeInnerDialogRuntimeState(sessionFilePath, state) {
-    const filePath = innerDialogRuntimeStatePath(sessionFilePath);
-    try {
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.writeFileSync(filePath, JSON.stringify(state, null, 2) + "\n", "utf8");
-    }
-    catch (error) {
-        (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            component: "senses",
-            event: "senses.inner_dialog_runtime_state_error",
-            message: "failed to write inner dialog runtime state",
-            meta: {
-                status: state.status,
-                reason: state.reason ?? null,
-                path: filePath,
-                /* v8 ignore next -- Node fs APIs throw Error objects for mkdirSync/writeFileSync failures @preserve */
-                error: error instanceof Error ? error.message : String(error),
-            },
-        });
-    }
-}
-/* v8 ignore start -- routing helpers: called from routing functions which are integration paths @preserve */
-function writePendingEnvelope(pendingDir, message) {
-    fs.mkdirSync(pendingDir, { recursive: true });
-    const fileName = `${message.timestamp}-${Math.random().toString(36).slice(2, 10)}.json`;
-    const filePath = path.join(pendingDir, fileName);
-    fs.writeFileSync(filePath, JSON.stringify(message, null, 2), "utf8");
-}
-function sessionMatchesActivity(activity, session) {
-    return activity.friendId === session.friendId
-        && activity.channel === session.channel
-        && activity.key === session.key;
-}
-/* v8 ignore stop */
-/* v8 ignore start -- routing: delivery now inline via surface tool; routing functions preserved for reuse @preserve */
-function resolveBridgePreferredSession(delegatedFrom, sessionActivity) {
-    if (!delegatedFrom.bridgeId)
-        return null;
-    const bridge = (0, manager_1.createBridgeManager)().getBridge(delegatedFrom.bridgeId);
-    if (!bridge || bridge.lifecycle === "completed" || bridge.lifecycle === "cancelled") {
-        return null;
-    }
-    return sessionActivity.find((activity) => activity.friendId === delegatedFrom.friendId
-        && activity.channel !== "inner"
-        && bridge.attachedSessions.some((session) => sessionMatchesActivity(activity, session))) ?? null;
-}
-async function tryDeliverDelegatedCompletion(target, outboundEnvelope) {
-    if (target.channel !== "bluebubbles") {
-        return false;
-    }
-    const result = await (0, bluebubbles_1.sendProactiveBlueBubblesMessageToSession)({
-        friendId: target.friendId,
-        sessionKey: target.key,
-        text: outboundEnvelope.content,
-        intent: "explicit_cross_chat",
-    });
-    return result.delivered;
-}
-function enrichDelegatedFromWithBridge(delegatedFrom) {
-    if (delegatedFrom.bridgeId) {
-        return delegatedFrom;
-    }
-    const bridgeManager = (0, manager_1.createBridgeManager)();
-    const originBridges = bridgeManager.findBridgesForSession({
-        friendId: delegatedFrom.friendId,
-        channel: delegatedFrom.channel,
-        key: delegatedFrom.key,
-    });
-    const activeBridge = originBridges.find((b) => b.lifecycle === "active");
-    if (activeBridge) {
-        return { ...delegatedFrom, bridgeId: activeBridge.id };
-    }
-    return delegatedFrom;
-}
-function advanceObligationQuietly(agentName, obligationId, update) {
-    if (!obligationId)
-        return;
-    try {
-        (0, obligations_1.advanceReturnObligation)(agentName, obligationId, update);
-        /* v8 ignore start -- best-effort: obligation fs errors must never block return routing @preserve */
-    }
-    catch {
-        // swallowed
-    }
-    /* v8 ignore stop */
-}
-async function routeDelegatedCompletion(agentRoot, agentName, completion, drainedPending, timestamp) {
-    const delegated = (drainedPending ?? []).find((message) => message.delegatedFrom);
-    if (!delegated?.delegatedFrom || !completion?.answer?.trim()) {
-        return;
-    }
-    const delegatedFrom = enrichDelegatedFromWithBridge(delegated.delegatedFrom);
-    const obligationId = delegated.obligationId;
-    // Advance any inner return obligations from queued -> running (they were drained this turn).
-    // drainedPending is guaranteed non-null here (we found delegated above).
-    for (const msg of drainedPending) {
-        if (msg.obligationId) {
-            advanceObligationQuietly(agentName, msg.obligationId, {
-                status: "running",
-                startedAt: timestamp,
-            });
-        }
-    }
-    if (delegated.obligationStatus === "pending") {
-        // Fulfill the persistent obligation in the store
-        try {
-            const pending = (0, obligations_1.findPendingObligationForOrigin)(agentRoot, {
-                friendId: delegatedFrom.friendId,
-                channel: delegatedFrom.channel,
-                key: delegatedFrom.key,
-            });
-            /* v8 ignore next 2 -- obligation fulfillment tested via obligations.test.ts; integration requires real disk state @preserve */
-            if (pending) {
-                (0, obligations_1.fulfillObligation)(agentRoot, pending.id);
-            }
-        }
-        catch {
-            /* v8 ignore next -- defensive: obligation store read failure should not break delivery @preserve */
-        }
-        (0, runtime_1.emitNervesEvent)({
-            event: "senses.obligation_fulfilled",
-            component: "senses",
-            message: "obligation fulfilled via delegated completion",
-            meta: {
-                friendId: delegatedFrom.friendId,
-                channel: delegatedFrom.channel,
-                key: delegatedFrom.key,
-            },
-        });
-    }
-    const outboundEnvelope = {
-        from: agentName,
-        friendId: delegatedFrom.friendId,
-        channel: delegatedFrom.channel,
-        key: delegatedFrom.key,
-        content: completion.answer.trim(),
-        timestamp,
-        delegatedFrom,
-        ...(obligationId ? { obligationId } : {}),
-    };
-    const sessionActivity = (0, session_activity_1.listSessionActivity)({
-        sessionsDir: path.join(agentRoot, "state", "sessions"),
-        friendsDir: path.join(agentRoot, "friends"),
-        agentName,
-    });
-    // Priority 1: Bridge-preferred session (if delegation was within a bridge).
-    const bridgeTarget = resolveBridgePreferredSession(delegatedFrom, sessionActivity);
-    if (bridgeTarget) {
-        if (await tryDeliverDelegatedCompletion(bridgeTarget, outboundEnvelope)) {
-            advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "bridge-session" });
-            return;
-        }
-        writePendingEnvelope((0, pending_1.getPendingDir)(agentName, bridgeTarget.friendId, bridgeTarget.channel, bridgeTarget.key), outboundEnvelope);
-        advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "bridge-session" });
-        return;
-    }
-    // Priority 1.5: Direct return to originating session (ponder without bridge).
-    // When delegatedFrom has specific channel+key, route directly there instead of searching for freshest.
-    if (delegatedFrom.channel && delegatedFrom.key && delegatedFrom.channel !== "inner") {
-        const directTarget = sessionActivity.find((a) => a.friendId === delegatedFrom.friendId && a.channel === delegatedFrom.channel && a.key === delegatedFrom.key);
-        if (directTarget) {
-            if (await tryDeliverDelegatedCompletion(directTarget, outboundEnvelope)) {
-                advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "direct-originator" });
-                return;
-            }
-        }
-        // Even if session isn't in activity list (might have ended), queue to its pending dir
-        writePendingEnvelope((0, pending_1.getPendingDir)(agentName, delegatedFrom.friendId, delegatedFrom.channel, delegatedFrom.key), outboundEnvelope);
-        advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "direct-originator" });
-        return;
-    }
-    // Priority 2: Freshest active friend session.
-    // For BB, prefer DM sessions (;-;) over group chats (;+;) — proactive outreach should never land in groups.
-    const allFriendSessions = (0, session_activity_1.listSessionActivity)({
-        sessionsDir: path.join(agentRoot, "state", "sessions"),
-        friendsDir: path.join(agentRoot, "friends"),
-        agentName,
-    }).filter((s) => s.friendId === delegatedFrom.friendId && s.channel !== "inner");
-    const bbDm = allFriendSessions.find((s) => s.channel === "bluebubbles" && s.key.includes(";-;"));
-    const freshest = bbDm ?? allFriendSessions.find((s) => s.channel !== "bluebubbles" || s.key.includes(";-;")) ?? allFriendSessions[0];
-    if (freshest) {
-        if (await tryDeliverDelegatedCompletion(freshest, outboundEnvelope)) {
-            advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "freshest-session" });
-            return;
-        }
-        writePendingEnvelope((0, pending_1.getPendingDir)(agentName, freshest.friendId, freshest.channel, freshest.key), outboundEnvelope);
-        advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "freshest-session" });
-        return;
-    }
-    // Priority 3: Deferred return queue.
-    writePendingEnvelope((0, pending_1.getDeferredReturnDir)(agentName, delegatedFrom.friendId), outboundEnvelope);
-    advanceObligationQuietly(agentName, obligationId, { status: "deferred", returnedAt: timestamp, returnTarget: "deferred" });
-}
-/* v8 ignore stop */
-// Self-referencing friend record for inner dialog (agent talking to itself).
-// No real friend to resolve -- this satisfies the pipeline's friend resolver contract.
-function createSelfFriend(agentName) {
-    return {
-        id: "self",
-        name: agentName,
-        trustLevel: "family",
-        externalIds: [],
-        tenantMemberships: [],
-        toolPreferences: {},
-        notes: {},
-        totalTokens: 0,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        schemaVersion: 1,
-    };
-}
-// No-op friend store for inner dialog. Inner dialog doesn't track token usage per-friend.
-function createNoOpFriendStore() {
-    return {
-        get: async () => null,
-        put: async () => { },
-        delete: async () => { },
-        findByExternalId: async () => null,
-    };
-}
-function buildParseErrorNudge(parseErrors) {
-    if (parseErrors.length === 0)
-        return "";
-    const lines = parseErrors.map((e) => `I noticed my habit file \`${e.file}\` has invalid frontmatter — I should fix it. (${e.error})`);
-    return lines.join("\n");
-}
-function buildHeldReturnWakeMessage() {
-    return [
-        "held return work arrived; use the current held-work frame above as the authority for this turn.",
-        "Older checkpoints, rest summaries, transcript memories, completed returns, and repeated probes are historical context, not evidence about what is waiting now.",
-        "Return only the requested result; do not add commentary about prior attempts, old loops, or completed probes.",
-        "Return each listed item with surface(delegationId=...) before resting or settling.",
-    ].join("\n");
-}
-function buildAlsoDueLine(agentRoot, currentHabitName, now) {
-    const habitsDir = path.join(agentRoot, "habits");
-    let files;
-    try {
-        files = fs.readdirSync(habitsDir);
-    }
-    catch {
-        return "";
-    }
-    const nowMs = now().getTime();
-    const alsoDue = [];
-    for (const file of files) {
-        if (!file.endsWith(".md"))
-            continue;
-        const stem = file.replace(/\.md$/, "");
-        if (stem === currentHabitName)
-            continue;
-        try {
-            const content = fs.readFileSync(path.join(habitsDir, file), "utf-8");
-            const habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(content, path.join(habitsDir, file)));
-            if (habit.status !== "active" || !habit.cadence)
-                continue;
-            const cadenceMs = (0, cadence_1.parseCadenceToMs)(habit.cadence);
-            if (cadenceMs === null)
-                continue;
-            if (habit.lastRun === null) {
-                alsoDue.push(stem);
-                continue;
-            }
-            const lastRunMs = new Date(habit.lastRun).getTime();
-            if (nowMs - lastRunMs >= cadenceMs) {
-                alsoDue.push(stem);
-            }
-        }
-        catch {
-            // skip unreadable habits
-        }
-    }
-    if (alsoDue.length === 0)
-        return "";
-    return `also due: ${alsoDue.join(", ")}`;
-}
-function buildHabitSurfacePolicy(origin, surface) {
-    const lines = ["## habit surface policy"];
-    lines.push("this habit runs privately, but it may message outward when it needs input, has a useful answer, is blocked, or should report status.");
-    if (surface.family)
-        lines.push("- family recipients are allowed by default.");
-    if (surface.originator && origin)
-        lines.push(`- the originator is allowed: ${origin.friendId} via ${origin.channel}/${origin.key}.`);
-    if (surface.originator && !origin)
-        lines.push("- originator messaging is enabled, but this habit has no origin metadata.");
-    if (surface.extra.length > 0)
-        lines.push(`- extra allowed recipients: ${surface.extra.join(", ")}.`);
-    lines.push("- use send_message for intentional contact; use surface only for a held return tied to an existing return obligation.");
-    return lines.join("\n");
-}
-async function runInnerDialogTurn(options) {
-    const now = options?.now ?? (() => new Date());
-    const reason = options?.reason ?? "instinct";
-    const sessionFilePath = options?.habitSession?.sessionPath ?? innerDialogSessionPath();
-    const agentName = (0, identity_1.getAgentName)();
-    writeInnerDialogRuntimeState(sessionFilePath, {
-        status: "running",
-        reason,
-        startedAt: now().toISOString(),
-    });
-    try {
-        const loaded = (0, context_1.loadSession)(sessionFilePath);
-        const existingMessages = loaded?.messages ? [...loaded.messages] : [];
-        const instincts = options?.instincts ?? loadInnerDialogInstincts();
-        const state = {
-            cycleCount: 1,
-            resting: false,
-            lastHeartbeatAt: now().toISOString(),
-        };
-        const pendingDir = options?.habitSession?.pendingDir ?? (0, pending_1.getInnerDialogPendingDir)(agentName);
-        const shouldUseHeldReturnWake = !options?.taskId && reason !== "habit" && reason !== "await"
-            ? (0, obligations_1.listActiveReturnObligations)(agentName).length > 0
-            : false;
-        // ── Adapter concern: build user message ──────────────────────────
-        let userContent;
-        let habitTools;
-        let habitParsedSuccessfully = false;
-        if (existingMessages.length === 0 && !(reason === "habit" && options?.habitName)) {
-            // Fresh session: bootstrap message with non-canonical cleanup nudge
-            const aspirations = readAspirations((0, identity_1.getAgentRoot)());
-            const nonCanonical = (0, bundle_manifest_1.findNonCanonicalBundlePaths)((0, identity_1.getAgentRoot)());
-            const cleanupNudge = buildNonCanonicalCleanupNudge(nonCanonical);
-            userContent = [
-                buildInnerDialogBootstrapMessage(aspirations, "No prior inner dialog session found."),
-                cleanupNudge,
-            ].filter(Boolean).join("\n\n");
-        }
-        else {
-            // Resumed session: task-triggered or instinct message with checkpoint context
-            const assistantTurns = existingMessages.filter((message) => message.role === "assistant").length;
-            state.cycleCount = assistantTurns + 1;
-            state.checkpoint = deriveResumeCheckpoint(existingMessages);
-            if (options?.taskId) {
-                const taskContent = readTaskFile((0, identity_1.getAgentRoot)(), options.taskId);
-                userContent = buildTaskTriggeredMessage(options.taskId, taskContent, state.checkpoint);
-            }
-            else if (reason === "habit" && options?.habitName) {
-                const agentRoot = (0, identity_1.getAgentRoot)();
-                const habitName = options.habitName;
-                const habitFilePath = path.join(agentRoot, "habits", `${habitName}.md`);
-                const preparedHabit = options.preparedHabit?.habit.name === habitName ? options.preparedHabit.habit : null;
-                // Read and parse the habit file
-                let habitBody;
-                let habitTitle = habitName;
-                let habitLastRun = null;
-                let habitOrigin = null;
-                let habitSurface = { family: true, originator: true, extra: [] };
-                if (preparedHabit) {
-                    habitBody = preparedHabit.body || undefined;
-                    habitTitle = preparedHabit.title || habitName;
-                    habitLastRun = preparedHabit.lastRun;
-                    habitTools = preparedHabit.tools;
-                    habitOrigin = preparedHabit.origin;
-                    habitSurface = preparedHabit.surface;
-                }
-                else {
-                    try {
-                        const habitContent = fs.readFileSync(habitFilePath, "utf-8");
-                        const parsed = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(habitContent, habitFilePath));
-                        habitBody = parsed.body || undefined;
-                        habitTitle = parsed.title || habitName;
-                        habitLastRun = parsed.lastRun;
-                        habitTools = parsed.tools;
-                        habitOrigin = parsed.origin;
-                        habitSurface = parsed.surface;
-                    }
-                    catch {
-                        // Habit file missing or unreadable
-                    }
-                }
-                // If the habit file couldn't be read at all (no body, no title parsed), error message
-                if (habitBody === undefined && habitTitle === habitName) {
-                    userContent = `habit "${habitName}" could not be read (file not found or unreadable). check habits/${habitName}.md exists.`;
-                }
-                else {
-                    habitParsedSuccessfully = true;
-                    // Unified path: gather context for ALL habits (heartbeat included)
-                    const obligations = (0, obligations_1.listActiveReturnObligations)(agentName);
-                    const nowMs = now().getTime();
-                    const staleObligations = obligations.map((o) => ({
-                        friendName: o.origin.friendId,
-                        content: o.delegatedContent,
-                        stalenessMs: nowMs - o.createdAt,
-                    }));
-                    const alsoDue = buildAlsoDueLine(agentRoot, habitName, now);
-                    const arcResume = (0, flight_recorder_1.formatFlightRecorderResume)((0, flight_recorder_1.readFlightRecorderResume)(agentRoot));
-                    const deskOrientation = (0, desk_section_1.deskRecordOrientationSection)(agentRoot, now());
-                    const surfacePolicy = buildHabitSurfacePolicy(habitOrigin, habitSurface);
-                    // Degraded state (best-effort: never crash)
-                    let degradedComponents = [];
-                    try {
-                        const health = (0, daemon_health_1.readHealth)((0, daemon_health_1.getDefaultHealthPath)());
-                        if (health && health.degraded.length > 0) {
-                            degradedComponents = health.degraded.map((d) => ({ component: d.component, reason: d.reason }));
-                        }
-                    }
-                    catch {
-                        // Best-effort: missing file or parse error -> empty array, no crash
-                    }
-                    userContent = (0, habit_turn_message_1.buildHabitTurnMessage)({
-                        habitName,
-                        habitTitle,
-                        habitBody,
-                        lastRun: habitLastRun,
-                        checkpoint: displayCheckpoint(state.checkpoint),
-                        alsoDue: alsoDue || undefined,
-                        staleObligations,
-                        parseErrors: options?.parseErrors ?? [],
-                        degradedComponents,
-                        arcResume,
-                        deskOrientation,
-                        surfacePolicy,
-                        priorSessionSummary: options.preparedHabit?.habit.name === habitName ? options.preparedHabit.priorSessionSummary : undefined,
-                        now,
-                    });
-                }
-            }
-            else if (reason === "await" && options?.awaitName) {
-                const agentRoot = (0, identity_1.getAgentRoot)();
-                const awaitName = options.awaitName;
-                const awaitFilePath = path.join(agentRoot, "awaiting", `${awaitName}.md`);
-                let awaitBody;
-                let condition = null;
-                let lastCheckedAt = null;
-                let lastObservation = null;
-                let checkedCount = 0;
-                let awaitFound = false;
-                try {
-                    const awaitContent = fs.readFileSync(awaitFilePath, "utf-8");
-                    const parsed = (0, await_runtime_state_1.applyAwaitRuntimeState)(agentRoot, (0, await_parser_1.parseAwaitFile)(awaitContent, awaitFilePath));
-                    awaitFound = true;
-                    awaitBody = parsed.body || undefined;
-                    condition = parsed.condition;
-                    lastCheckedAt = parsed.last_checked ?? null;
-                    lastObservation = parsed.last_observation ?? null;
-                    checkedCount = parsed.checked_count ?? 0;
-                }
-                catch {
-                    // file missing — fall through to error message
-                }
-                if (!awaitFound || !condition) {
-                    userContent = `await "${awaitName}" could not be read (file not found or no condition). check awaiting/${awaitName}.md.`;
-                }
-                else {
-                    userContent = (0, await_turn_message_1.buildAwaitTurnMessage)({
-                        awaitName,
-                        condition,
-                        body: awaitBody,
-                        lastCheckedAt,
-                        lastObservation,
-                        checkedCount,
-                        checkpoint: displayCheckpoint(state.checkpoint),
-                        now,
-                    });
-                }
-            }
-            else {
-                userContent = buildInstinctUserMessage(instincts, reason, state);
-            }
-        }
-        if (shouldUseHeldReturnWake) {
-            userContent = buildHeldReturnWakeMessage();
-        }
-        const userMessage = { role: "user", content: userContent };
-        // ── Session loader: wraps existing session logic ──────────────────
-        const innerCapabilities = (0, friends_1.getChannelCapabilities)("inner");
-        const selfFriend = createSelfFriend(agentName);
-        const selfContext = { friend: selfFriend, channel: innerCapabilities };
-        const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
-        // ── Habit tool enforcement ───────────────────────────────────────
-        let habitToolsResolved;
-        if (habitTools !== undefined) {
-            const fullTools = (0, tools_1.getToolsForChannel)(innerCapabilities);
-            habitToolsResolved = fullTools.filter((t) => habitTools.includes(t.function.name));
-            (0, runtime_1.emitNervesEvent)({
-                event: "habit.tools_restricted",
-                component: "senses",
-                message: "habit running with restricted tools",
-                meta: {
-                    habitName: options?.habitName,
-                    declared: habitTools,
-                    resolved: habitToolsResolved.map((t) => t.function.name),
-                },
-            });
-        }
-        else if (reason === "habit" && options?.habitName && habitParsedSuccessfully) {
-            (0, runtime_1.emitNervesEvent)({
-                event: "habit.tools_unrestricted",
-                component: "senses",
-                message: "habit running with full tool repertoire",
-                meta: { habitName: options.habitName },
-            });
-        }
-        const sessionLoader = {
-            loadOrCreate: async () => {
-                if (existingMessages.length > 0) {
-                    return {
-                        messages: existingMessages,
-                        sessionPath: sessionFilePath,
-                        structuredOutputs: loaded?.structuredOutputs,
-                    };
-                }
-                // Fresh session: build system prompt
-                const systemPrompt = await (0, prompt_1.buildSystem)("inner", {
-                    toolChoiceRequired: true,
-                    flightRecorderResume: (0, flight_recorder_1.readFlightRecorderResume)((0, identity_1.getAgentRoot)()),
-                });
-                return {
-                    messages: [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(systemPrompt) }],
-                    sessionPath: sessionFilePath,
-                    structuredOutputs: [],
-                };
-            },
-        };
-        // ── Call shared pipeline ──────────────────────────────────────────
-        const callbacks = createInnerDialogCallbacks();
-        const traceId = (0, nerves_1.createTraceId)();
-        // Attention queue: built when pending messages are drained, shared with tool context
-        let attentionQueue = [];
-        const result = await (0, pipeline_1.handleInboundTurn)({
-            channel: "inner",
-            sessionKey: "dialog",
-            capabilities: innerCapabilities,
-            messages: [userMessage],
-            continuityIngressTexts: [],
-            callbacks,
-            friendResolver: { resolve: () => Promise.resolve(selfContext) },
-            sessionLoader,
-            pendingDir,
-            friendStore: createNoOpFriendStore(),
-            enforceTrustGate: trust_gate_1.enforceTrustGate,
-            drainPending: pending_1.drainPending,
-            runAgent: core_1.runAgent,
-            postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
-                const prepared = (0, context_1.postTurnTrim)(turnMessages, usage, hooks);
-                return (0, context_1.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
-            },
-            accumulateFriendTokens: friends_1.accumulateFriendTokens,
-            signal: options?.signal,
-            /* v8 ignore start -- attention queue: callback invoked by pipeline during pending drain; tested via attention-queue unit tests @preserve */
-            onPendingDrained: (drained) => {
-                const outstandingObligations = (0, obligations_1.listActiveReturnObligations)(agentName);
-                const builtAttentionQueue = (0, attention_queue_1.buildAttentionQueue)({
-                    drainedPending: drained,
-                    outstandingObligations,
-                    friendNameResolver: (friendId) => {
-                        try {
-                            const raw = fs.readFileSync(path.join((0, identity_1.getAgentRoot)(agentName), "friends", friendId + ".json"), "utf-8");
-                            const parsed = JSON.parse(raw);
-                            return typeof parsed.name === "string" ? parsed.name : null;
-                        }
-                        catch {
-                            return null;
-                        }
-                    },
-                    packetResolver: (packetId) => {
-                        try {
-                            return (0, packets_1.readPonderPacket)((0, identity_1.getAgentRoot)(agentName), packetId);
-                        }
-                        catch {
-                            return null;
-                        }
-                    },
-                });
-                attentionQueue.splice(0, attentionQueue.length, ...builtAttentionQueue);
-                const attentionFrame = (0, attention_queue_1.buildAttentionQueueStatusFrame)(attentionQueue);
-                return attentionFrame ? [attentionFrame] : [];
-            },
-            /* v8 ignore stop */
-            runAgentOptions: {
-                traceId,
-                toolChoiceRequired: true,
-                mcpManager,
-                ...(habitToolsResolved !== undefined && { tools: habitToolsResolved }),
-                toolContext: {
-                    signin: async () => undefined,
-                    delegatedOrigins: attentionQueue,
-                    ...(options?.habitSession ? { habitSession: options.habitSession } : {}),
-                },
-                ...(options?.habitSession ? { habitSession: options.habitSession } : {}),
-            },
-        });
-        // Post-turn routeDelegatedCompletion removed: delivery is now inline via surface tool.
-        // settle in inner dialog produces no CompletionMetadata, so routeDelegatedCompletion
-        // would be a no-op. The routing infrastructure is reused by the surface handler.
-        const resultMessages = result.messages ?? [];
-        const assistantPreview = extractAssistantPreview(resultMessages);
-        const toolCalls = extractToolCallNames(resultMessages);
-        (0, runtime_1.emitNervesEvent)({
-            component: "senses",
-            event: "senses.inner_dialog_turn",
-            message: "inner dialog turn completed",
-            meta: {
-                reason,
-                session: sessionFilePath,
-                ...(options?.taskId && { taskId: options.taskId }),
-                ...(assistantPreview && { assistantPreview }),
-                ...(toolCalls.length > 0 && { toolCalls }),
-                ...(result.usage && {
-                    promptTokens: result.usage.input_tokens,
-                    completionTokens: result.usage.output_tokens,
-                    totalTokens: result.usage.total_tokens,
-                }),
-            },
-        });
-        return {
-            messages: resultMessages,
-            usage: result.usage,
-            sessionPath: result.sessionPath ?? sessionFilePath,
-            completion: result.completion,
-            turnOutcome: result.turnOutcome,
-            restStatus: latestRestStatus(resultMessages),
-        };
-    }
-    finally {
-        writeInnerDialogRuntimeState(sessionFilePath, {
-            status: "idle",
-            lastCompletedAt: now().toISOString(),
-        });
-    }
-}
+exports.runInnerDialogTurn = exports.innerDialogSessionPath = exports.loadInnerDialogInstincts = exports.buildInnerDialogBootstrapMessage = void 0;
+__exportStar(require("./private-runtime"), exports);
+var private_runtime_1 = require("./private-runtime");
+Object.defineProperty(exports, "buildInnerDialogBootstrapMessage", { enumerable: true, get: function () { return private_runtime_1.buildPrivateRuntimeBootstrapMessage; } });
+Object.defineProperty(exports, "loadInnerDialogInstincts", { enumerable: true, get: function () { return private_runtime_1.loadPrivateRuntimeInstincts; } });
+Object.defineProperty(exports, "innerDialogSessionPath", { enumerable: true, get: function () { return private_runtime_1.privateRuntimeSessionPath; } });
+Object.defineProperty(exports, "runInnerDialogTurn", { enumerable: true, get: function () { return private_runtime_1.runPrivateRuntimeTurn; } });