@ouro.bot/cli 0.1.0-alpha.36 → 0.1.0-alpha.360

package/dist/senses/pipeline.js

@@ -0,0 +1,603 @@
+"use strict";
+// Shared per-turn pipeline for all senses.
+// Senses are thin transport adapters; this module owns the common lifecycle:
+//   resolve friend -> trust gate -> load session -> drain pending -> runAgent -> postTurn -> token accumulation.
+//
+// Transport-level concerns (BB API calls, Teams cards, readline) stay in sense adapters.
+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.emitObligationTransitionEpisodes = emitObligationTransitionEpisodes;
+exports.handleInboundTurn = handleInboundTurn;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const commands_1 = require("./commands");
+const continuity_1 = require("./continuity");
+const manager_1 = require("../heart/bridges/manager");
+const identity_1 = require("../heart/identity");
+const socket_client_1 = require("../heart/daemon/socket-client");
+const active_work_1 = require("../heart/active-work");
+const delegation_1 = require("../heart/delegation");
+const obligations_1 = require("../arc/obligations");
+const provider_failover_1 = require("../heart/provider-failover");
+const provider_state_1 = require("../heart/provider-state");
+const tempo_1 = require("../heart/tempo");
+const temporal_view_1 = require("../heart/temporal-view");
+const start_of_turn_packet_1 = require("../heart/start-of-turn-packet");
+const bundle_state_1 = require("../heart/bundle-state");
+const sync_1 = require("../heart/sync");
+const config_1 = require("../heart/config");
+const session_events_1 = require("../heart/session-events");
+const presence_1 = require("../arc/presence");
+const episodes_1 = require("../arc/episodes");
+const turn_context_1 = require("../heart/turn-context");
+const provider_visibility_1 = require("../heart/provider-visibility");
+/**
+ * Emit episodes for obligation state transitions detected during a turn.
+ * Exported for direct testability (avoids v8 coverage merge issues in multi-file test suites).
+ */
+function emitObligationTransitionEpisodes(agentRoot, preTurnObligationIds, postTurnObligations, preTurnObligations) {
+    const postTurnObligationIds = new Set(postTurnObligations.map((ob) => `${ob.id}:${ob.status}`));
+    for (const key of preTurnObligationIds) {
+        if (!postTurnObligationIds.has(key)) {
+            const [obId] = key.split(":");
+            const matchedOb = postTurnObligations.find((ob) => ob.id === obId) ?? preTurnObligations.find((ob) => ob.id === obId);
+            (0, episodes_1.emitEpisode)(agentRoot, {
+                kind: "obligation_shift",
+                summary: `obligation "${matchedOb?.content ?? obId}" status changed`,
+                whyItMattered: "obligation state transition detected during turn",
+                relatedEntities: [`obligation:${obId}`],
+                salience: "medium",
+            });
+        }
+    }
+}
+function providerLaneForChannel(channel) {
+    return channel === "inner" ? "inner" : "outward";
+}
+function resolveCurrentFailoverBinding(agentName, lane) {
+    const stateResult = (0, provider_state_1.readProviderState)((0, identity_1.getAgentRoot)(agentName));
+    if (stateResult.ok) {
+        const binding = stateResult.state.lanes[lane];
+        return { provider: binding.provider, model: binding.model };
+    }
+    const agentConfig = (0, identity_1.loadAgentConfig)();
+    const fallback = lane === "inner" ? agentConfig.agentFacing : agentConfig.humanFacing;
+    return { provider: fallback.provider, model: fallback.model };
+}
+function writeFailoverProviderStateSwitch(agentName, action) {
+    const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+    const stateResult = (0, provider_state_1.readProviderState)(agentRoot);
+    if (!stateResult.ok) {
+        throw new Error(`Cannot switch ${action.lane} lane for ${agentName}: ${stateResult.error}`);
+    }
+    const updatedAt = new Date().toISOString();
+    const lanes = { ...stateResult.state.lanes };
+    lanes[action.lane] = {
+        provider: action.provider,
+        model: action.model,
+        source: "local",
+        updatedAt,
+    };
+    const readiness = { ...stateResult.state.readiness };
+    readiness[action.lane] = {
+        status: "ready",
+        provider: action.provider,
+        model: action.model,
+        checkedAt: updatedAt,
+        ...(action.credentialRevision ? { credentialRevision: action.credentialRevision } : {}),
+    };
+    (0, provider_state_1.writeProviderState)(agentRoot, {
+        ...stateResult.state,
+        updatedAt,
+        lanes,
+        readiness,
+    });
+}
+function formatFailoverSwitchLabel(action) {
+    const provenance = (0, provider_failover_1.formatCredentialProvenanceLabel)(action);
+    return `${action.provider} (${action.model}${provenance ? `; ${provenance}` : ""})`;
+}
+function prependTurnSections(message, sections) {
+    /* v8 ignore next -- defensive: only user messages with non-empty sections reach here @preserve */
+    if (message.role !== "user" || sections.length === 0)
+        return message;
+    const prefix = sections.join("\n\n");
+    /* v8 ignore start -- defensive: multipart content branch; non-string user messages are rare @preserve */
+    if (typeof message.content === "string") {
+        return {
+            ...message,
+            content: `${prefix}\n\n${message.content}`,
+        };
+    }
+    return {
+        ...message,
+        content: [
+            { type: "text", text: `${prefix}\n\n` },
+            ...message.content,
+        ],
+    };
+    /* v8 ignore stop */
+}
+// ── Pipeline ──────────────────────────────────────────────────────
+let _lastSessionKey = null;
+async function handleInboundTurn(input) {
+    // Reset session-scoped state when the session changes
+    const sessionKey = `${input.channel}/${input.sessionKey ?? "session"}`;
+    if (sessionKey !== _lastSessionKey) {
+        _lastSessionKey = sessionKey;
+        // Reset file-state cache and scrutiny tracking for the new session
+        const { fileStateCache } = await Promise.resolve().then(() => __importStar(require("../mind/file-state")));
+        const { resetSessionModifiedFiles } = await Promise.resolve().then(() => __importStar(require("../mind/scrutiny")));
+        fileStateCache.clear();
+        resetSessionModifiedFiles();
+    }
+    // Step 0: Check for pending failover reply
+    if (input.failoverState?.pending) {
+        const userText = input.messages
+            .filter((m) => m.role === "user")
+            .map((m) => typeof m.content === "string" ? m.content : /* v8 ignore next -- defensive: multipart content fallback @preserve */ "")
+            .join(" ")
+            .trim();
+        const pendingContext = input.failoverState.pending;
+        const failoverAction = (0, provider_failover_1.handleFailoverReply)(userText, pendingContext);
+        const failoverAgentName = pendingContext.agentName;
+        input.failoverState.pending = null; // always clear before acting
+        if (failoverAction.action === "switch") {
+            let switchSucceeded = false;
+            try {
+                writeFailoverProviderStateSwitch(failoverAgentName, failoverAction);
+                switchSucceeded = true;
+                /* v8 ignore start -- defensive: write failure during provider switch @preserve */
+            }
+            catch (switchError) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.failover_switch_error",
+                    message: `failed to switch ${failoverAction.lane} provider lane to ${failoverAction.provider}`,
+                    meta: { agentName: failoverAgentName, lane: failoverAction.lane, provider: failoverAction.provider, model: failoverAction.model, error: switchError instanceof Error ? switchError.message : String(switchError) },
+                });
+            }
+            /* v8 ignore stop */
+            /* v8 ignore next -- false branch: write-failure fallthrough @preserve */
+            if (switchSucceeded) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.failover_switch",
+                    message: `switched ${failoverAction.lane} provider lane to ${failoverAction.provider} via failover`,
+                    meta: {
+                        agentName: failoverAgentName,
+                        lane: failoverAction.lane,
+                        provider: failoverAction.provider,
+                        model: failoverAction.model,
+                        credentialRevision: failoverAction.credentialRevision,
+                        source: failoverAction.source,
+                        contributedByAgent: failoverAction.contributedByAgent,
+                    },
+                });
+                // Replace "switch to <provider>" with a context message for the agent.
+                // The session already has the user's original question from the failed turn.
+                // The agent needs to know what happened so it can respond appropriately.
+                const newProviderLabel = formatFailoverSwitchLabel(failoverAction);
+                input.messages = [{
+                        role: "user",
+                        content: `[provider switch: ${pendingContext.errorSummary}. switched ${failoverAction.lane} lane to ${newProviderLabel}. your conversation history is intact — respond to the user's last message.]`,
+                    }];
+                input.switchedProvider = failoverAction.provider;
+            }
+            // Switch failed OR succeeded — either way, fall through to normal processing.
+        }
+    }
+    // Step 0b: Slash command interception (before friend resolution / agent turn)
+    {
+        const firstUserMsg = input.messages.find((m) => m.role === "user");
+        const userText = firstUserMsg
+            ? (typeof firstUserMsg.content === "string"
+                ? firstUserMsg.content
+                : Array.isArray(firstUserMsg.content)
+                    ? firstUserMsg.content.find((p) => p.type === "text")?.text ?? ""
+                    : /* v8 ignore next -- defensive: content is always string or array @preserve */ "")
+            : "";
+        const parsed = (0, commands_1.parseSlashCommand)(userText);
+        if (parsed) {
+            const registry = (0, commands_1.getSharedCommandRegistry)();
+            const dispatchResult = registry.dispatch(parsed.command, { channel: input.channel });
+            if (dispatchResult.handled && dispatchResult.result) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.pipeline_command",
+                    message: `slash command intercepted: /${parsed.command}`,
+                    meta: { command: parsed.command, channel: input.channel },
+                });
+                if (dispatchResult.result.message) {
+                    input.callbacks.onTextChunk(dispatchResult.result.message);
+                }
+                // Return a minimal result — no agent turn, no session write
+                const resolvedContext = await input.friendResolver.resolve();
+                return {
+                    resolvedContext,
+                    gateResult: { allowed: true },
+                    turnOutcome: "command",
+                    commandAction: dispatchResult.result.action,
+                };
+            }
+        }
+    }
+    // Step 1: Resolve friend
+    const resolvedContext = await input.friendResolver.resolve();
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.pipeline_start",
+        message: "inbound turn pipeline started",
+        meta: {
+            channel: input.channel,
+            friendId: resolvedContext.friend.id,
+            senseType: input.capabilities.senseType,
+        },
+    });
+    // Step 2: Trust gate
+    const gateInput = {
+        friend: resolvedContext.friend,
+        provider: input.provider ?? "local",
+        externalId: input.externalId ?? "",
+        tenantId: input.tenantId,
+        channel: input.channel,
+        senseType: input.capabilities.senseType,
+        isGroupChat: input.isGroupChat ?? false,
+        groupHasFamilyMember: input.groupHasFamilyMember ?? false,
+        hasExistingGroupWithFamily: input.hasExistingGroupWithFamily ?? false,
+    };
+    const gateResult = input.enforceTrustGate(gateInput);
+    // Gate rejection: return early, no agent turn
+    if (!gateResult.allowed) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.pipeline_gate_reject",
+            message: "trust gate rejected inbound turn",
+            meta: {
+                channel: input.channel,
+                friendId: resolvedContext.friend.id,
+                reason: gateResult.reason,
+            },
+        });
+        return {
+            resolvedContext,
+            gateResult,
+        };
+    }
+    // Step 3: Load/create session
+    const session = await input.sessionLoader.loadOrCreate();
+    const sessionMessages = session.messages;
+    const sessionEvents = session.events ?? [];
+    let mustResolveBeforeHandoff = (0, continuity_1.resolveMustResolveBeforeHandoff)(session.state?.mustResolveBeforeHandoff === true, input.continuityIngressTexts);
+    const lastFriendActivityAt = input.channel === "inner"
+        ? session.state?.lastFriendActivityAt
+        : new Date().toISOString();
+    const currentObligation = input.continuityIngressTexts
+        ?.map((text) => text.trim())
+        .filter((text) => text.length > 0)
+        .at(-1);
+    const currentSession = {
+        friendId: resolvedContext.friend.id,
+        channel: input.channel,
+        key: input.sessionKey ?? "session",
+        sessionPath: session.sessionPath,
+    };
+    const currentSessionTiming = (0, session_events_1.describeCurrentSessionTiming)(sessionEvents);
+    // Step 3b: Pre-turn sync pull (opt-in) — MUST happen before any continuity state reads
+    // so that obligations, episodes, cares, etc. reflect the latest remote state.
+    let syncFailure;
+    let syncConfig = { enabled: false, remote: "origin" };
+    try {
+        syncConfig = (0, config_1.getSyncConfig)();
+    }
+    catch { /* config not available */ }
+    // Wrap the turn body in try/finally so postTurnPush always runs — even on
+    // error or early-return failover paths.
+    try {
+        /* v8 ignore start -- sync-enabled branches tested in sync.test.ts, pipeline tests mock at module boundary @preserve */
+        if (syncConfig.enabled) {
+            const pullResult = (0, sync_1.preTurnPull)((0, identity_1.getAgentRoot)(), syncConfig);
+            if (!pullResult.ok) {
+                syncFailure = pullResult.error;
+            }
+            // Check for pending-sync from a prior failed push
+            if (!syncFailure) {
+                const pendingSyncPath = path.join((0, identity_1.getAgentRoot)(), "state", "pending-sync.json");
+                try {
+                    if (fs.existsSync(pendingSyncPath)) {
+                        const pendingSync = JSON.parse(fs.readFileSync(pendingSyncPath, "utf-8"));
+                        syncFailure = `prior sync push failed: ${pendingSync.error ?? "unknown"}`;
+                        fs.unlinkSync(pendingSyncPath);
+                    }
+                }
+                catch {
+                    // Ignore read errors for pending-sync
+                }
+            }
+        }
+        /* v8 ignore stop */
+        // Build the turn context snapshot — centralizes all state reads
+        const ctx = await (0, turn_context_1.buildTurnContext)({
+            currentSession,
+            channel: input.channel,
+            friendStore: input.friendStore,
+        });
+        // Propagate sync failure from pre-turn pull
+        ctx.syncFailure = syncFailure;
+        const { activeBridges, sessionActivity, pendingObligations, codingSessions, otherCodingSessions } = ctx;
+        const bridgeContext = (0, manager_1.formatBridgeContext)(activeBridges) || undefined;
+        const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
+            currentSession,
+            currentObligation,
+            mustResolveBeforeHandoff,
+            inner: ctx.innerWorkState,
+            bridges: activeBridges,
+            codingSessions,
+            otherCodingSessions,
+            pendingObligations,
+            taskBoard: ctx.taskBoard,
+            friendActivity: sessionActivity,
+            targetCandidates: ctx.targetCandidates,
+            innerReturnObligations: ctx.returnObligations,
+        });
+        const delegationDecision = (0, delegation_1.decideDelegation)({
+            channel: input.channel,
+            ingressTexts: input.continuityIngressTexts ?? [],
+            activeWork: activeWorkFrame,
+            mustResolveBeforeHandoff,
+        });
+        // Step 4: Drain deferred friend returns, then ordinary per-session pending.
+        const deferredReturns = input.channel === "inner"
+            ? []
+            : (input.drainDeferredReturns?.(resolvedContext.friend.id) ?? []);
+        const sessionPending = input.drainPending(input.pendingDir);
+        const pending = [...deferredReturns, ...sessionPending];
+        // Assemble messages: session messages + pending + inbound user messages
+        // NOTE: live world-state checkpoint and pending messages are rendered via buildSystem (system prompt sections)
+        const extraPrefixSections = input.onPendingDrained?.(pending) ?? [];
+        // extraPrefixSections from onPendingDrained still prepend to user message (e.g., inner dialog wakes)
+        if (extraPrefixSections.length > 0 && input.messages.length > 0) {
+            input.messages[0] = prependTurnSections(input.messages[0], extraPrefixSections);
+        }
+        // Append user messages from the inbound turn
+        for (const msg of input.messages) {
+            (0, session_events_1.stampIngressTime)(msg);
+            sessionMessages.push(msg);
+        }
+        // Step 4b: Continuity pipeline — derive tempo, build start-of-turn packet, snapshot obligations
+        let renderedStartOfTurnPacket;
+        const preTurnObligationIds = new Set(pendingObligations.map((ob) => `${ob.id}:${ob.status}`));
+        try {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const agentName = (0, identity_1.getAgentName)();
+            const { recentEpisodes, activeCares } = ctx;
+            const tempoState = (0, tempo_1.deriveTempo)({
+                activeSessions: sessionActivity.length + 1,
+                openObligations: pendingObligations.length,
+                recentEpisodeCount: recentEpisodes.length,
+                lastActivityAgeMs: sessionActivity.length > 0
+                    ? Date.now() - new Date(sessionActivity[0].lastActivityAt).getTime()
+                    : 0,
+                hasBlockers: false, // obligations use specific statuses, not "blocked"
+                highSalienceEpisodes: recentEpisodes.filter((ep) => ep.salience === "high" || ep.salience === "critical").length,
+                activeCareCount: activeCares.length,
+                atRiskCareCount: activeCares.filter((c) => c.currentRisk != null).length,
+            });
+            const temporalView = (0, temporal_view_1.buildTemporalView)(agentRoot, {
+                tempo: tempoState.mode,
+                preloaded: {
+                    recentEpisodes,
+                    activeObligations: pendingObligations,
+                    activeCares,
+                },
+            });
+            const startOfTurnPacket = (0, start_of_turn_packet_1.buildStartOfTurnPacket)(temporalView, {
+                canonicalObligations: {
+                    primary: activeWorkFrame.primaryObligation,
+                    all: activeWorkFrame.pendingObligations,
+                },
+                currentSessionTiming,
+            });
+            /* v8 ignore next 3 -- syncFailure propagation tested in sync.test.ts @preserve */
+            if (syncFailure) {
+                startOfTurnPacket.syncFailure = syncFailure;
+            }
+            if (ctx.providerVisibility) {
+                startOfTurnPacket.providerState = (0, provider_visibility_1.formatAgentProviderVisibilityForStartOfTurn)(ctx.providerVisibility);
+            }
+            // Structured bundle state detection — surfaces discrete issues the
+            // agent can remediate via the bundle_* tools. Runs independently of
+            // syncFailure so the two signals coexist during the transition away
+            // from the legacy free-form syncFailure string. Always assigned; the
+            // packet renderer's empty-filter handles the empty-array case without
+            // a separate branch here.
+            startOfTurnPacket.bundleState = (0, bundle_state_1.detectBundleState)(agentRoot);
+            const capabilities = (0, start_of_turn_packet_1.buildCapabilitiesSection)(agentRoot);
+            if (capabilities) {
+                startOfTurnPacket.capabilities = capabilities;
+            }
+            renderedStartOfTurnPacket = (0, start_of_turn_packet_1.renderStartOfTurnPacket)(startOfTurnPacket);
+            if (!renderedStartOfTurnPacket)
+                renderedStartOfTurnPacket = undefined;
+            // Update self-presence
+            const presence = (0, presence_1.derivePresence)(agentRoot, agentName, {
+                activeSessions: sessionActivity.length + 1,
+                openObligations: pendingObligations.length,
+                activeBridges: activeBridges.length,
+                codingLanes: codingSessions.length,
+                currentTempo: tempoState.mode,
+            });
+            (0, presence_1.writePresence)(agentRoot, agentName, presence);
+        }
+        catch (continuityError) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.continuity_error",
+                message: "continuity pipeline failed, continuing without start-of-turn packet",
+                meta: { error: continuityError instanceof Error ? continuityError.message : String(continuityError) },
+            });
+        }
+        // Step 5: runAgent
+        const existingToolContext = input.runAgentOptions?.toolContext;
+        const runAgentOptions = {
+            ...input.runAgentOptions,
+            bridgeContext,
+            activeWorkFrame,
+            delegationDecision,
+            startOfTurnPacket: renderedStartOfTurnPacket,
+            pendingMessages: pending.length > 0 ? pending.map((msg) => ({ from: msg.from, content: msg.content })) : undefined,
+            currentSessionKey: currentSession.key,
+            currentObligation,
+            mustResolveBeforeHandoff,
+            setMustResolveBeforeHandoff: (value) => {
+                mustResolveBeforeHandoff = value;
+            },
+            // Pre-read state from TurnContext for prompt assembly
+            daemonRunning: ctx.daemonRunning,
+            senseStatusLines: ctx.senseStatusLines,
+            bundleMeta: ctx.bundleMeta,
+            daemonHealth: ctx.daemonHealth,
+            journalFiles: ctx.journalFiles,
+            ...(ctx.providerVisibility ? { providerVisibility: ctx.providerVisibility } : {}),
+            toolContext: {
+                /* v8 ignore next -- default no-op signin satisfies interface; real signin injected by sense adapter @preserve */
+                signin: async () => undefined,
+                ...existingToolContext,
+                context: resolvedContext,
+                friendStore: input.friendStore,
+                currentSession,
+                activeBridges,
+            },
+        };
+        const result = await input.runAgent(sessionMessages, input.callbacks, input.channel, input.signal, runAgentOptions);
+        // Step 5b: Failover on terminal error
+        if (result.outcome === "errored" && input.failoverState) {
+            try {
+                const agentName = (0, identity_1.getAgentName)();
+                const currentLane = providerLaneForChannel(input.channel);
+                const currentBinding = resolveCurrentFailoverBinding(agentName, currentLane);
+                const currentProvider = currentBinding.provider;
+                /* v8 ignore next -- defensive: errorClassification always set when errored @preserve */
+                const classification = result.errorClassification ?? "unknown";
+                const inventory = await (0, provider_failover_1.runMachineProviderFailoverInventory)(agentName, currentProvider);
+                const failoverContext = (0, provider_failover_1.buildFailoverContext)(
+                /* v8 ignore next -- defensive: error always set when errored @preserve */
+                result.error?.message ?? "unknown error", classification, currentProvider, currentBinding.model, agentName, inventory, {}, { currentLane });
+                input.failoverState.pending = failoverContext;
+                input.postTurn(sessionMessages, session.sessionPath, result.usage);
+                return {
+                    resolvedContext,
+                    gateResult,
+                    usage: result.usage,
+                    turnOutcome: result.outcome,
+                    sessionPath: session.sessionPath,
+                    messages: sessionMessages,
+                    drainedPending: pending,
+                    failoverMessage: failoverContext.userMessage,
+                };
+                /* v8 ignore start -- failover catch: tested via pipeline failover sequence throws test but v8 under-reports catch coverage @preserve */
+            }
+            catch (failoverError) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.failover_error",
+                    message: "failover sequence failed, falling through",
+                    meta: { error: failoverError instanceof Error ? failoverError.message : String(failoverError) },
+                });
+            }
+            /* v8 ignore stop */
+        }
+        // Step 5c: Emit episodes for obligation state transitions
+        try {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const postTurnObligations = (0, obligations_1.readPendingObligations)(agentRoot);
+            emitObligationTransitionEpisodes(agentRoot, preTurnObligationIds, postTurnObligations, pendingObligations);
+        }
+        catch {
+            // Episode emission is non-fatal
+        }
+        // Step 6: postTurn
+        const continuingState = {
+            ...(mustResolveBeforeHandoff ? { mustResolveBeforeHandoff: true } : {}),
+            ...(typeof lastFriendActivityAt === "string" ? { lastFriendActivityAt } : {}),
+        };
+        const nextState = result.outcome === "settled" || result.outcome === "blocked" || result.outcome === "superseded" || result.outcome === "observed"
+            ? (typeof lastFriendActivityAt === "string"
+                ? { lastFriendActivityAt }
+                : undefined)
+            : (Object.keys(continuingState).length > 0 ? continuingState : undefined);
+        input.postTurn(sessionMessages, session.sessionPath, result.usage, undefined, nextState);
+        // Step 7: Token accumulation
+        await input.accumulateFriendTokens(input.friendStore, resolvedContext.friend.id, result.usage);
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.pipeline_end",
+            message: "inbound turn pipeline completed",
+            meta: {
+                channel: input.channel,
+                friendId: resolvedContext.friend.id,
+            },
+        });
+        // DRY cross-session awareness: notify inner dialog that activity happened on another channel
+        // Inner dialog's next checkpoint will include this session's state
+        if (input.channel !== "inner") {
+            try {
+                (0, socket_client_1.requestInnerWake)((0, identity_1.getAgentName)()).catch(/* v8 ignore next */ () => { });
+            }
+            catch { /* getAgentName may fail in test environments */ }
+        }
+        return {
+            resolvedContext,
+            gateResult,
+            usage: result.usage,
+            turnOutcome: result.outcome,
+            completion: result.completion,
+            sessionPath: session.sessionPath,
+            messages: sessionMessages,
+            drainedPending: pending,
+            ...(input.switchedProvider ? { switchedProvider: input.switchedProvider } : {}),
+        };
+    }
+    finally {
+        // Step 6b: Post-turn sync push (opt-in, git-status-based discovery).
+        if (syncConfig.enabled) {
+            (0, sync_1.postTurnPush)((0, identity_1.getAgentRoot)(), syncConfig);
+        }
+    }
+}

package/dist/senses/proactive-content-guard.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProactiveInternalContentBlockReason = getProactiveInternalContentBlockReason;
+exports.emitProactiveInternalContentBlocked = emitProactiveInternalContentBlocked;
+const runtime_1 = require("../nerves/runtime");
+// ── Patterns ────────────────────────────────────────────────────
+const PROACTIVE_INTERNAL_CONTENT_PATTERNS = [
+    // PR 447 patterns: raw meta markers
+    { reason: "raw_meta_marker", pattern: /<\s*\/?\s*(think|analysis|commentary)\b[^>]*>/i },
+    { reason: "raw_meta_marker", pattern: /\[\s*surfaced from inner dialog\s*\]/i },
+    // Inner dialog / attention / obligation references
+    { reason: "inner_dialog_reference", pattern: /\binner (dialog|dialogue)\b/i },
+    { reason: "attention_queue_reference", pattern: /\battention queues?\b/i },
+    { reason: "return_obligation_reference", pattern: /\b(return|held|heart|inner)\s+obligations?\b/i },
+    // Surfacing mechanics
+    { reason: "surfacing_mechanics_reference", pattern: /\b(surface tool|surfacing (mechanics|itself)|surfaced? outward|call `?surface`?|delegationId|delegation id)\b/i },
+    // Prompt references
+    { reason: "prompt_reference", pattern: /\b(system|developer|inner|tool|orientation)\s+prompts?\b|\bprompt\/orientation\b|\bprompt wording\b/i },
+    // Routing references
+    { reason: "routing_reference", pattern: /\b(routing target|reply target|route through surface|routed through surface|proactive bluebubbles delivery)\b/i },
+    // Heartbeat / status patterns
+    { reason: "heartbeat_status", pattern: /\bheartbeat\b/i },
+    { reason: "heartbeat_status", pattern: /\bcheck-in\b/i },
+    { reason: "heartbeat_status", pattern: /\btask board\b/i },
+    { reason: "heartbeat_status", pattern: /\ball else settled\b/i },
+    { reason: "heartbeat_status", pattern: /\bobligations?\s+showing\b/i },
+    { reason: "heartbeat_status", pattern: /\bsame state\b/i },
+];
+// ── Public API ──────────────────────────────────────────────────
+function getProactiveInternalContentBlockReason(text) {
+    for (const { reason, pattern } of PROACTIVE_INTERNAL_CONTENT_PATTERNS) {
+        if (pattern.test(text))
+            return reason;
+    }
+    return null;
+}
+function emitProactiveInternalContentBlocked(params) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.proactive_internal_content_blocked",
+        message: "proactive send blocked: internal content",
+        meta: {
+            friendId: params.friendId,
+            source: params.source,
+            reason: params.reason,
+            ...(params.sessionKey ? { sessionKey: params.sessionKey } : {}),
+            ...(params.intent ? { intent: params.intent } : {}),
+        },
+    });
+}