@ouro.bot/cli 0.1.0-alpha.51 → 0.1.0-alpha.510

package/dist/senses/pipeline.js

@@ -4,57 +4,319 @@
 //   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 socket_client_1 = require("../heart/daemon/socket-client");
 const active_work_1 = require("../heart/active-work");
 const delegation_1 = require("../heart/delegation");
-const thoughts_1 = require("../heart/daemon/thoughts");
-const pending_1 = require("../mind/pending");
-function emptyTaskBoard() {
-    return {
-        compact: "",
-        full: "",
-        byStatus: {
-            drafting: [],
-            processing: [],
-            validating: [],
-            collaborating: [],
-            paused: [],
-            blocked: [],
-            done: [],
-        },
-        actionRequired: [],
-        unresolvedDependencies: [],
-        activeSessions: [],
-        activeBridges: [],
-    };
+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 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 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 };
     }
-    catch {
+    const agentConfig = (0, identity_1.loadAgentConfig)();
+    const fallback = lane === "inner" ? agentConfig.agentFacing : agentConfig.humanFacing;
+    return { provider: fallback.provider, model: fallback.model };
+}
+/**
+ * Apply an agent-driven failover switch to provider state, 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 writeFailoverProviderStateSwitch(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 };
+    }
+    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,
+    });
+    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. Slugger-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 writeFailoverProviderStateSwitch(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.
+        }
+    }
+    // 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)({
@@ -100,6 +362,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
@@ -114,143 +377,289 @@ 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" };
     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)();
     }
-    const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
-        currentSession,
-        currentObligation,
-        mustResolveBeforeHandoff,
-        inner: readInnerWorkState(),
-        bridges: activeBridges,
-        taskBoard: (() => {
-            try {
-                return (0, tasks_1.getTaskModule)().getBoard();
-            }
-            catch {
-                return emptyTaskBoard();
+    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;
             }
-        })(),
-        friendActivity: sessionActivity,
-    });
-    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}`,
-                    };
+            // 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);
+                    }
                 }
-                else {
-                    input.messages[0] = {
-                        ...firstMsg,
-                        content: [
-                            { type: "text", text: `## pending messages\n${pendingSection}\n\n` },
-                            ...firstMsg.content,
-                        ],
-                    };
+                catch {
+                    // Ignore read errors for pending-sync
                 }
             }
         }
-    }
-    // Append user messages from the inbound turn
-    for (const msg of input.messages) {
-        sessionMessages.push(msg);
-    }
-    // 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,
+        /* 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,
-            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: {
+            currentObligation,
+            mustResolveBeforeHandoff,
+            inner: ctx.innerWorkState,
+            bridges: activeBridges,
+            codingSessions,
+            backgroundOperations,
+            otherCodingSessions,
+            pendingObligations,
+            taskBoard: ctx.taskBoard,
+            friendActivity: sessionActivity,
+            targetCandidates: ctx.targetCandidates,
+            innerReturnObligations: ctx.returnObligations,
+        });
+        const delegationDecision = (0, delegation_1.decideDelegation)({
             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,
-    };
+            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);
+        }
+    }
 }