@ouro.bot/cli 0.1.0-alpha.66 → 0.1.0-alpha.660

package/dist/senses/pipeline.js

@@ -4,58 +4,525 @@
 //   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 tasks_1 = require("../repertoire/tasks");
-const session_activity_1 = require("../heart/session-activity");
+const auth_flow_1 = require("../heart/auth/auth-flow");
+const socket_client_1 = require("../heart/daemon/socket-client");
 const active_work_1 = require("../heart/active-work");
 const delegation_1 = require("../heart/delegation");
-const target_resolution_1 = require("../heart/target-resolution");
-const thoughts_1 = require("../heart/daemon/thoughts");
-const pending_1 = require("../mind/pending");
-function emptyTaskBoard() {
+const obligations_1 = require("../arc/obligations");
+const packets_1 = require("../arc/packets");
+const evolution_1 = require("../arc/evolution");
+const provider_failover_1 = require("../heart/provider-failover");
+const openai_codex_token_1 = require("../heart/providers/openai-codex-token");
+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");
+const orientation_frame_1 = require("../heart/orientation-frame");
+const flight_recorder_1 = require("../arc/flight-recorder");
+const VOICE_PENDING_MAX_AGE_MS = 15 * 60 * 1_000;
+const ACTIVE_FLIGHT_RECORDER_PACKET_STATUSES = new Set([
+    "drafting",
+    "processing",
+    "validating",
+    "collaborating",
+    "paused",
+    "blocked",
+]);
+function pendingExpirationReason(channel, message, now) {
+    /* v8 ignore start -- pending expiry edge permutations are covered by the stale voice queue tests; this helper keeps defensive non-voice fallbacks @preserve */
+    if (Number.isFinite(message.expiresAt) && Number(message.expiresAt) <= now)
+        return "explicit_expiry";
+    if (channel !== "voice")
+        return null;
+    if (!Number.isFinite(message.timestamp))
+        return null;
+    return now - message.timestamp > VOICE_PENDING_MAX_AGE_MS ? "voice_freshness_window" : null;
+    /* v8 ignore stop */
+}
+function archiveExpiredPendingMessages(input) {
+    /* v8 ignore start -- archive path edge cases are defensive filesystem hygiene; stale voice expiry tests cover the normal archive path @preserve */
+    if (input.expired.length === 0)
+        return;
+    const pendingRoot = path.join(input.agentRoot, "state", "pending");
+    const relativePendingDir = path.relative(pendingRoot, input.pendingDir);
+    const archiveDir = relativePendingDir && !relativePendingDir.startsWith("..") && !path.isAbsolute(relativePendingDir)
+        ? path.join(input.agentRoot, "state", "pending-expired", relativePendingDir)
+        : path.join(input.agentRoot, "state", "pending-expired", input.channel);
+    try {
+        fs.mkdirSync(archiveDir, { recursive: true });
+        input.expired.forEach(({ message, reason }, index) => {
+            const stamp = Number.isFinite(message.timestamp) ? message.timestamp : input.now;
+            const filePath = path.join(archiveDir, `${stamp}-${index}.json`);
+            fs.writeFileSync(filePath, `${JSON.stringify({
+                ...message,
+                expiredAt: input.now,
+                expirationReason: reason,
+                originalPendingDir: input.pendingDir,
+            }, null, 2)}\n`, "utf-8");
+        });
+        /* v8 ignore stop */
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.pending_expired",
+            message: "expired stale pending sense messages before model injection",
+            meta: {
+                channel: input.channel,
+                pendingDir: input.pendingDir,
+                archiveDir,
+                count: String(input.expired.length),
+            },
+        });
+    }
+    catch (error) {
+        /* v8 ignore next -- filesystem archive failures are defensive; stale voice expiry success path is covered @preserve */
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.pending_expire_archive_error",
+            message: "failed to archive expired pending sense messages",
+            meta: {
+                channel: input.channel,
+                pendingDir: input.pendingDir,
+                count: String(input.expired.length),
+                error: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}
+function filterDeliverablePendingMessages(input) {
+    if (input.messages.length === 0)
+        return input.messages;
+    const now = input.now ?? Date.now();
+    const deliverable = [];
+    const expired = [];
+    for (const message of input.messages) {
+        const reason = pendingExpirationReason(input.channel, message, now);
+        if (reason) {
+            expired.push({ message, reason });
+        }
+        else {
+            deliverable.push(message);
+        }
+    }
+    if (expired.length > 0) {
+        try {
+            archiveExpiredPendingMessages({ ...input, agentRoot: (0, identity_1.getAgentRoot)(), expired, now });
+        }
+        catch (error) {
+            /* v8 ignore next -- getAgentRoot failure is only reachable under broken runtime identity state @preserve */
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.pending_expire_archive_error",
+                message: "failed to resolve agent root for expired pending sense message archive",
+                meta: {
+                    channel: input.channel,
+                    pendingDir: input.pendingDir,
+                    count: String(expired.length),
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    return deliverable;
+}
+/**
+ * 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 latestUserAuthoredText(messages, continuityIngressTexts) {
+    const ingress = continuityIngressTexts?.map((entry) => entry.trim()).filter(Boolean);
+    if (ingress?.length)
+        return ingress[ingress.length - 1];
+    const userMessages = messages
+        .filter((message) => message.role === "user")
+        .map((message) => typeof message.content === "string" ? message.content.trim() : "")
+        .filter(Boolean);
+    return userMessages[userMessages.length - 1];
+}
+function sessionRefForFlightRecorder(session) {
+    return `${session.friendId}/${session.channel}/${session.key}`;
+}
+function isTerminalWithoutContinuation(outcome, hasActiveContinuation) {
+    return !hasActiveContinuation && (outcome === "settled"
+        || outcome === "observed"
+        || outcome === "rested"
+        || outcome === "superseded");
+}
+function readPostTurnFlightRecorderArcSnapshot(agentRoot) {
+    const latest = (0, flight_recorder_1.readFlightRecorderResume)(agentRoot);
     return {
-        compact: "",
-        full: "",
-        byStatus: {
-            drafting: [],
-            processing: [],
-            validating: [],
-            collaborating: [],
-            paused: [],
-            blocked: [],
-            done: [],
-        },
-        actionRequired: [],
-        unresolvedDependencies: [],
-        activeSessions: [],
-        activeBridges: [],
+        activeObligationIds: (0, obligations_1.readPendingObligations)(agentRoot).map((obligation) => obligation.id),
+        activeReturnObligationIds: (0, obligations_1.listActiveReturnObligationsForRoot)(agentRoot).map((obligation) => obligation.id),
+        activePacketIds: (0, packets_1.listPonderPackets)(agentRoot)
+            .filter((packet) => ACTIVE_FLIGHT_RECORDER_PACKET_STATUSES.has(packet.status))
+            .map((packet) => packet.id),
+        openEvolutionCaseIds: (0, evolution_1.listOpenEvolutionCases)(agentRoot).map((evolutionCase) => evolutionCase.id),
+        recentClaimIds: latest.recentClaimIds,
+        unverifiedClaimIds: latest.unverifiedClaimIds,
     };
 }
-function readInnerWorkState() {
-    try {
-        const agentRoot = (0, identity_1.getAgentRoot)();
-        const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
-        const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
-        const status = (0, thoughts_1.readInnerDialogStatus)(sessionPath, pendingDir);
-        return {
-            status: status.processing === "started" ? "running" : "idle",
-            hasPending: status.queue !== "clear",
-        };
+function recordPostTurnFlightRecorderCheckpoint(input) {
+    const hasActiveContinuation = input.mustResolveBeforeHandoff
+        || input.activeObligationIds.length > 0
+        || input.activeReturnObligationIds.length > 0
+        || input.activePacketIds.length > 0
+        || input.openEvolutionCaseIds.length > 0;
+    const blockedBecause = [
+        ...(input.outcome === "blocked" ? ["agent reported a blocker in this turn"] : []),
+        ...(input.outcome === "errored" ? ["turn errored before a safe continuation was reached"] : []),
+        ...(input.outcome === "aborted" ? ["turn aborted before a safe continuation was reached"] : []),
+        ...(isTerminalWithoutContinuation(input.outcome, hasActiveContinuation) ? [`turn outcome ${input.outcome}; wait for new input before acting`] : []),
+    ];
+    const nextSafeAction = input.nextSafeAction
+        ?? (blockedBecause.length > 0
+            ? "inspect the latest session and wait for new input before acting"
+            : "continue the current held work and update Arc/Desk with the next checkpoint");
+    (0, flight_recorder_1.recordFlightRecorderEvent)(input.agentRoot, {
+        kind: "post_turn_persisted",
+        sessionRef: sessionRefForFlightRecorder(input.currentSession),
+        summary: `persisted ${input.currentSession.channel}/${input.currentSession.key} turn with outcome ${input.outcome}`,
+        currentAsk: input.currentAsk,
+        nextSafeAction,
+        blockedBecause,
+        stopBefore: blockedBecause.length > 0 ? ["acting on stale context"] : [],
+        activeObligationIds: input.activeObligationIds,
+        activeReturnObligationIds: input.activeReturnObligationIds,
+        activePacketIds: input.activePacketIds,
+        openEvolutionCaseIds: input.openEvolutionCaseIds,
+        recentClaimIds: input.recentClaimIds,
+        unverifiedClaimIds: input.unverifiedClaimIds,
+        meta: {
+            outcome: input.outcome,
+            mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
+            sessionPath: input.currentSession.sessionPath,
+        },
+    });
+}
+function resolveCurrentFailoverBinding(agentName, lane) {
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    const { config: agentConfig } = (0, auth_flow_1.readAgentConfigForAgent)(agentName, path.dirname(agentRoot));
+    const fallback = lane === "inner" ? agentConfig.agentFacing : agentConfig.humanFacing;
+    return { provider: fallback.provider, model: fallback.model };
+}
+/**
+ * Apply an agent-driven failover switch to agent.json, but only after
+ * re-pinging the candidate. The inventory ping that produced the candidate
+ * may be stale by the time the agent replies — without this preflight, a
+ * "switch to <provider>" reply can move the lane onto an unreachable provider.
+ *
+ * Returns:
+ *   { ok: true }              — preflight passed, state mutated
+ *   { ok: false, refused }    — preflight failed, state untouched, caller should
+ *                                surface the refusal to the agent
+ * Throws on disk errors only (caught by caller as before).
+ */
+async function writeFailoverAgentConfigSwitch(agentName, action) {
+    const validation = await (0, provider_failover_1.validateFailoverSwitchCandidate)(agentName, { provider: action.provider, model: action.model });
+    if (!validation.ok) {
+        return { ok: false, refused: true, classification: validation.classification, message: validation.message };
     }
-    catch {
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    const { configPath, config } = (0, auth_flow_1.readAgentConfigForAgent)(agentName, path.dirname(agentRoot));
+    const facingKey = action.lane === "inner" ? "agentFacing" : "humanFacing";
+    const nextConfig = {
+        ...config,
+        [facingKey]: {
+            ...config[facingKey],
+            provider: action.provider,
+            model: action.model,
+        },
+    };
+    fs.writeFileSync(configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf-8");
+    return { ok: true };
+}
+function formatFailoverSwitchLabel(action) {
+    const provenance = (0, provider_failover_1.formatCredentialProvenanceLabel)(action);
+    return `${action.provider} (${action.model}${provenance ? `; ${provenance}` : ""})`;
+}
+/**
+ * Build the operational refusal context message handed back to the agent when
+ * a failover switch is rejected by the preflight ping. Field-tested format:
+ * lead with the refusal + reason, restate the lane that's still standing, then
+ * list remaining ready alternatives so the next turn doesn't have to re-enter
+ * discovery mode.
+ */
+function buildFailoverSwitchRefusedMessage(pendingContext, refusedAction, refusal) {
+    const refusedLabel = formatFailoverSwitchLabel(refusedAction);
+    const remaining = pendingContext.readyProviders.filter((candidate) => candidate.provider !== refusedAction.provider);
+    const alternativesLine = remaining.length > 0
+        ? `available verified alternatives right now: ${remaining.map((c) => `${c.provider} (${c.model})`).join(", ")}.`
+        : "no other verified alternatives are ready right now.";
+    const nextMove = remaining.length > 0
+        ? `next move: reply "switch to <provider>" picking one of the alternatives above, or tell the user you cannot continue and why.`
+        : `next move: ask the operator to repair credentials for ${refusedAction.provider} (or another provider), or tell the user you cannot continue and why.`;
+    return [
+        `[provider switch refused: tried to switch ${refusedAction.lane} lane to ${refusedLabel}.`,
+        `reason: preflight ping failed (${refusal.classification}: ${refusal.message}).`,
+        `current lane unchanged: ${pendingContext.currentProvider} / ${pendingContext.currentModel} on the ${pendingContext.currentLane} lane.`,
+        alternativesLine,
+        nextMove + "]",
+    ].join(" ");
+}
+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 {
-            status: "idle",
-            hasPending: false,
+            ...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 switchOutcome = null;
+            try {
+                switchOutcome = await writeFailoverAgentConfigSwitch(failoverAgentName, failoverAction);
+                /* 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 */
+            if (switchOutcome?.ok) {
+                (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,
+                    },
+                });
+                // 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;
+            }
+            else if (switchOutcome && !switchOutcome.ok) {
+                // Preflight refused the switch — the candidate provider is not actually
+                // reachable right now. Keep the existing lane intact and tell the agent
+                // what happened so it can pick something else next turn.
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.failover_switch_refused",
+                    message: `refused failover switch of ${failoverAction.lane} lane to ${failoverAction.provider}: ${switchOutcome.message}`,
+                    meta: {
+                        agentName: failoverAgentName,
+                        lane: failoverAction.lane,
+                        provider: failoverAction.provider,
+                        model: failoverAction.model,
+                        classification: switchOutcome.classification,
+                        error: switchOutcome.message,
+                    },
+                });
+                input.messages = [{
+                        role: "user",
+                        content: buildFailoverSwitchRefusedMessage(pendingContext, failoverAction, switchOutcome),
+                    }];
+            }
+            // Switch failed OR succeeded — either way, fall through to normal processing.
+        }
+        else if (failoverAction.action === "refresh") {
+            const refresh = failoverAction.provider === "openai-codex"
+                ? await (0, openai_codex_token_1.refreshOpenAICodexProviderCredentials)(failoverAgentName, {
+                    force: true,
+                    reason: "failover-reply",
+                })
+                : { ok: false, actor: "human-required", message: `provider ${failoverAction.provider} does not support chat-driven refresh` };
+            if (refresh.ok) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.failover_refresh",
+                    message: `refreshed ${failoverAction.provider} provider credentials via failover`,
+                    meta: {
+                        agentName: failoverAgentName,
+                        lane: failoverAction.lane,
+                        provider: failoverAction.provider,
+                        refreshed: refresh.refreshed,
+                    },
+                });
+                input.messages = [{
+                        role: "user",
+                        content: `[provider refresh: ${pendingContext.errorSummary}. refreshed ${failoverAction.provider} credentials for the ${failoverAction.lane} lane. your conversation history is intact — respond to the user's last message.]`,
+                    }];
+            }
+            else {
+                (0, runtime_1.emitNervesEvent)({
+                    level: refresh.actor === "human-required" ? "warn" : "error",
+                    component: "senses",
+                    event: "senses.failover_refresh_error",
+                    message: `failed to refresh ${failoverAction.provider} provider credentials via failover`,
+                    meta: {
+                        agentName: failoverAgentName,
+                        lane: failoverAction.lane,
+                        provider: failoverAction.provider,
+                        actor: refresh.actor,
+                        error: refresh.message,
+                    },
+                });
+                input.messages = [{
+                        role: "user",
+                        content: `[provider refresh failed: tried to refresh ${failoverAction.provider} for the ${failoverAction.lane} lane. actor: ${refresh.actor}. reason: ${refresh.message}. current lane unchanged: ${pendingContext.currentProvider} / ${pendingContext.currentModel}. If ready alternatives are listed in the prior failover message, switch to one; otherwise tell the user the concrete human-required auth step.]`,
+                    }];
+            }
+        }
+    }
+    // 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)({
@@ -101,6 +568,7 @@ async function handleInboundTurn(input) {
     // 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
@@ -115,164 +583,373 @@ async function handleInboundTurn(input) {
         key: input.sessionKey ?? "session",
         sessionPath: session.sessionPath,
     };
-    const activeBridges = (0, manager_1.createBridgeManager)().findBridgesForSession({
-        friendId: currentSession.friendId,
-        channel: currentSession.channel,
-        key: currentSession.key,
-    });
-    const bridgeContext = (0, manager_1.formatBridgeContext)(activeBridges) || undefined;
-    let sessionActivity = [];
+    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" };
+    const liveLatencyMode = input.latencyMode === "live";
     try {
-        const agentRoot = (0, identity_1.getAgentRoot)();
-        sessionActivity = (0, session_activity_1.listSessionActivity)({
-            sessionsDir: `${agentRoot}/state/sessions`,
-            friendsDir: `${agentRoot}/friends`,
-            agentName: (0, identity_1.getAgentName)(),
-            currentSession: {
-                friendId: currentSession.friendId,
-                channel: currentSession.channel,
-                key: currentSession.key,
-            },
-        });
-    }
-    catch {
-        sessionActivity = [];
+        syncConfig = (0, config_1.getSyncConfig)();
     }
-    let targetCandidates = [];
+    catch { /* config not available */ }
+    // Wrap the turn body in try/finally so postTurnPush always runs — even on
+    // error or early-return failover paths.
     try {
-        if (input.channel !== "inner") {
+        /* v8 ignore start -- sync-enabled branches tested in sync.test.ts, pipeline tests mock at module boundary @preserve */
+        if (syncConfig.enabled && !liveLatencyMode) {
+            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, backgroundOperations } = 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,
+            backgroundOperations,
+            otherCodingSessions,
+            pendingObligations,
+            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 = filterDeliverablePendingMessages({
+            pendingDir: input.pendingDir,
+            channel: input.channel,
+            messages: [...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);
+        }
+        const currentUserMessages = input.messages.filter((message) => message.role === "user");
+        const orientationFrame = input.runAgentOptions?.orientationFrame
+            ?? (currentUserMessages.length > 0
+                ? (0, orientation_frame_1.buildOrientationFrame)({
+                    channel: input.channel,
+                    messages: sessionMessages,
+                    currentUserMessages,
+                    structuredOutputs: session.structuredOutputs ?? [],
+                })
+                : undefined);
+        // 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)();
-            targetCandidates = await (0, target_resolution_1.listTargetSessionCandidates)({
-                sessionsDir: `${agentRoot}/state/sessions`,
-                friendsDir: `${agentRoot}/friends`,
-                agentName: (0, identity_1.getAgentName)(),
-                currentSession: {
-                    friendId: currentSession.friendId,
-                    channel: currentSession.channel,
-                    key: currentSession.key,
+            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,
                 },
-                friendStore: input.friendStore,
             });
-        }
-    }
-    catch {
-        targetCandidates = [];
-    }
-    const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
-        currentSession,
-        currentObligation,
-        mustResolveBeforeHandoff,
-        inner: readInnerWorkState(),
-        bridges: activeBridges,
-        taskBoard: (() => {
-            try {
-                return (0, tasks_1.getTaskModule)().getBoard();
+            const startOfTurnPacket = (0, start_of_turn_packet_1.buildStartOfTurnPacket)(temporalView, {
+                canonicalObligations: {
+                    primary: activeWorkFrame.primaryObligation,
+                    all: activeWorkFrame.pendingObligations,
+                },
+                currentSessionTiming,
+                flightRecorderResume: ctx.flightRecorderResume,
+            });
+            /* v8 ignore next 3 -- syncFailure propagation tested in sync.test.ts @preserve */
+            if (syncFailure) {
+                startOfTurnPacket.syncFailure = syncFailure;
             }
-            catch {
-                return emptyTaskBoard();
+            if (ctx.providerVisibility) {
+                startOfTurnPacket.providerSelection = (0, provider_visibility_1.formatAgentProviderVisibilityForStartOfTurn)(ctx.providerVisibility);
             }
-        })(),
-        friendActivity: sessionActivity,
-        targetCandidates,
-    });
-    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 (formatted) + inbound user messages
-    if (pending.length > 0) {
-        // Format pending messages and prepend to the user content
-        const pendingSection = pending
-            .map((msg) => `[pending from ${msg.from}]: ${msg.content}`)
-            .join("\n");
-        // If there are inbound user messages, prepend pending to the first one
-        if (input.messages.length > 0) {
-            const firstMsg = input.messages[0];
-            if (firstMsg.role === "user") {
-                if (typeof firstMsg.content === "string") {
-                    input.messages[0] = {
-                        ...firstMsg,
-                        content: `## pending messages\n${pendingSection}\n\n${firstMsg.content}`,
-                    };
+            // 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 currentUserMessage = existingToolContext?.currentUserMessage
+            ?? latestUserAuthoredText(input.messages, input.continuityIngressTexts);
+        const runAgentOptions = {
+            ...input.runAgentOptions,
+            ...(orientationFrame ? { orientationFrame } : {}),
+            ...(liveLatencyMode ? { skipKeptNotes: true } : {}),
+            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,
+            flightRecorderResume: ctx.flightRecorderResume,
+            ...(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,
+                ...(currentUserMessage ? { currentUserMessage } : {}),
+                context: resolvedContext,
+                friendStore: input.friendStore,
+                currentSession,
+                activeBridges,
+                ...(orientationFrame ? { orientationFrame } : {}),
+            },
+        };
+        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);
+                try {
+                    const postTurnArc = readPostTurnFlightRecorderArcSnapshot((0, identity_1.getAgentRoot)());
+                    recordPostTurnFlightRecorderCheckpoint({
+                        agentRoot: (0, identity_1.getAgentRoot)(),
+                        currentSession,
+                        currentAsk: currentObligation
+                            ?? activeWorkFrame.primaryObligation?.content?.trim()
+                            ?? currentUserMessage
+                            ?? null,
+                        nextSafeAction: failoverContext.userMessage,
+                        outcome: "errored",
+                        mustResolveBeforeHandoff,
+                        activeObligationIds: postTurnArc.activeObligationIds,
+                        activeReturnObligationIds: postTurnArc.activeReturnObligationIds,
+                        activePacketIds: postTurnArc.activePacketIds,
+                        openEvolutionCaseIds: postTurnArc.openEvolutionCaseIds,
+                        recentClaimIds: postTurnArc.recentClaimIds,
+                        unverifiedClaimIds: postTurnArc.unverifiedClaimIds,
+                    });
                 }
-                else {
-                    input.messages[0] = {
-                        ...firstMsg,
-                        content: [
-                            { type: "text", text: `## pending messages\n${pendingSection}\n\n` },
-                            ...firstMsg.content,
-                        ],
-                    };
+                catch (checkpointError) {
+                    /* v8 ignore next -- best-effort recorder write must not hide provider-failover guidance @preserve */
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.flight_recorder_checkpoint_error",
+                        message: "failed to record provider-failover flight recorder checkpoint",
+                        meta: { error: checkpointError instanceof Error ? checkpointError.message : String(checkpointError) },
+                    });
                 }
+                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);
+        try {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const postTurnArc = readPostTurnFlightRecorderArcSnapshot(agentRoot);
+            recordPostTurnFlightRecorderCheckpoint({
+                agentRoot,
+                currentSession,
+                currentAsk: currentObligation
+                    ?? activeWorkFrame.primaryObligation?.content?.trim()
+                    ?? currentUserMessage
+                    ?? null,
+                nextSafeAction: activeWorkFrame.resumeHandle?.nextAction
+                    ?? activeWorkFrame.primaryObligation?.nextAction?.trim()
+                    ?? null,
+                outcome: result.outcome ?? "observed",
+                mustResolveBeforeHandoff,
+                activeObligationIds: postTurnArc.activeObligationIds,
+                activeReturnObligationIds: postTurnArc.activeReturnObligationIds,
+                activePacketIds: postTurnArc.activePacketIds,
+                openEvolutionCaseIds: postTurnArc.openEvolutionCaseIds,
+                recentClaimIds: postTurnArc.recentClaimIds,
+                unverifiedClaimIds: postTurnArc.unverifiedClaimIds,
+            });
+        }
+        catch (error) {
+            /* v8 ignore next -- defensive recorder failures are non-fatal to already-persisted user turns @preserve */
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.flight_recorder_checkpoint_error",
+                message: "failed to record post-turn flight recorder checkpoint",
+                meta: { error: error instanceof Error ? error.message : String(error) },
+            });
+        }
+        // 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)(), existingToolContext?.daemonSocketPath).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 } : {}),
+        };
     }
-    // Append user messages from the inbound turn
-    for (const msg of input.messages) {
-        sessionMessages.push(msg);
+    finally {
+        // Step 6b: Post-turn sync push (opt-in, git-status-based discovery).
+        if (syncConfig.enabled && !liveLatencyMode) {
+            (0, sync_1.postTurnPush)((0, identity_1.getAgentRoot)(), syncConfig);
+        }
     }
-    // Step 5: runAgent
-    const existingToolContext = input.runAgentOptions?.toolContext;
-    const runAgentOptions = {
-        ...input.runAgentOptions,
-        bridgeContext,
-        activeWorkFrame,
-        delegationDecision,
-        currentSessionKey: currentSession.key,
-        currentObligation,
-        mustResolveBeforeHandoff,
-        setMustResolveBeforeHandoff: (value) => {
-            mustResolveBeforeHandoff = value;
-        },
-        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 6: postTurn
-    const continuingState = {
-        ...(mustResolveBeforeHandoff ? { mustResolveBeforeHandoff: true } : {}),
-        ...(typeof lastFriendActivityAt === "string" ? { lastFriendActivityAt } : {}),
-    };
-    const nextState = result.outcome === "complete" || result.outcome === "blocked" || result.outcome === "superseded"
-        ? (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,
-        },
-    });
-    return {
-        resolvedContext,
-        gateResult,
-        usage: result.usage,
-        turnOutcome: result.outcome,
-        completion: result.completion,
-        sessionPath: session.sessionPath,
-        messages: sessionMessages,
-        drainedPending: pending,
-    };
 }