@ouro.bot/cli 0.1.0-alpha.242 → 0.1.0-alpha.244

package/dist/senses/pipeline.js

@@ -106,454 +106,447 @@ function prependTurnSections(message, sections) {
 // ── Pipeline ──────────────────────────────────────────────────────
 let _lastSessionKey = null;
 async function handleInboundTurn(input) {
-    return (0, sync_1.runWithSyncContext)(async () => {
-        // Reset session-scoped state when the session changes
-        const sessionKey = `${input.channel}/${input.sessionKey ?? "session"}`;
-        if (sessionKey !== _lastSessionKey) {
-            _lastSessionKey = sessionKey;
-            // Reset file-state cache and scrutiny tracking for the new session
-            const { fileStateCache } = await Promise.resolve().then(() => __importStar(require("../mind/file-state")));
-            const { resetSessionModifiedFiles } = await Promise.resolve().then(() => __importStar(require("../mind/scrutiny")));
-            fileStateCache.clear();
-            resetSessionModifiedFiles();
-        }
-        // Step 0: Check for pending failover reply
-        if (input.failoverState?.pending) {
-            const userText = input.messages
-                .filter((m) => m.role === "user")
-                .map((m) => typeof m.content === "string" ? m.content : /* v8 ignore next -- defensive: multipart content fallback @preserve */ "")
-                .join(" ")
-                .trim();
-            const pendingContext = input.failoverState.pending;
-            const failoverAction = (0, provider_failover_1.handleFailoverReply)(userText, pendingContext);
-            const failoverAgentName = pendingContext.agentName;
-            input.failoverState.pending = null; // always clear before acting
-            if (failoverAction.action === "switch") {
-                let switchSucceeded = false;
-                try {
-                    (0, auth_flow_1.writeAgentProviderSelection)(failoverAgentName, "human", failoverAction.provider);
-                    (0, auth_flow_1.writeAgentProviderSelection)(failoverAgentName, "agent", failoverAction.provider);
-                    switchSucceeded = true;
-                    /* v8 ignore start -- defensive: write failure during provider switch @preserve */
-                }
-                catch (switchError) {
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "error",
-                        component: "senses",
-                        event: "senses.failover_switch_error",
-                        message: `failed to switch provider to ${failoverAction.provider}`,
-                        meta: { agentName: failoverAgentName, provider: failoverAction.provider, error: switchError instanceof Error ? switchError.message : String(switchError) },
-                    });
-                }
-                /* v8 ignore stop */
-                /* v8 ignore next -- false branch: write-failure fallthrough @preserve */
-                if (switchSucceeded) {
-                    (0, runtime_1.emitNervesEvent)({
-                        component: "senses",
-                        event: "senses.failover_switch",
-                        message: `switched provider to ${failoverAction.provider} via failover`,
-                        meta: { agentName: failoverAgentName, provider: failoverAction.provider },
-                    });
-                    // 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 newProviderSecrets = (() => {
-                        try {
-                            const { secrets } = (0, auth_flow_1.loadAgentSecrets)(failoverAgentName);
-                            const cfg = secrets.providers[failoverAction.provider];
-                            return cfg?.model ?? cfg?.modelName ?? "";
-                            /* v8 ignore next 2 -- defensive: secrets read failure @preserve */
-                        }
-                        catch {
-                            return "";
-                        }
-                    })();
-                    const newProviderLabel = newProviderSecrets ? `${failoverAction.provider} (${newProviderSecrets})` : failoverAction.provider;
-                    input.messages = [{
-                            role: "user",
-                            content: `[provider switch: ${pendingContext.errorSummary}. switched to ${newProviderLabel}. your conversation history is intact — respond to the user's last message.]`,
-                        }];
-                    input.switchedProvider = failoverAction.provider;
-                }
-                // Switch failed OR succeeded — either way, fall through to normal processing.
+    // Reset session-scoped state when the session changes
+    const sessionKey = `${input.channel}/${input.sessionKey ?? "session"}`;
+    if (sessionKey !== _lastSessionKey) {
+        _lastSessionKey = sessionKey;
+        // Reset file-state cache and scrutiny tracking for the new session
+        const { fileStateCache } = await Promise.resolve().then(() => __importStar(require("../mind/file-state")));
+        const { resetSessionModifiedFiles } = await Promise.resolve().then(() => __importStar(require("../mind/scrutiny")));
+        fileStateCache.clear();
+        resetSessionModifiedFiles();
+    }
+    // Step 0: Check for pending failover reply
+    if (input.failoverState?.pending) {
+        const userText = input.messages
+            .filter((m) => m.role === "user")
+            .map((m) => typeof m.content === "string" ? m.content : /* v8 ignore next -- defensive: multipart content fallback @preserve */ "")
+            .join(" ")
+            .trim();
+        const pendingContext = input.failoverState.pending;
+        const failoverAction = (0, provider_failover_1.handleFailoverReply)(userText, pendingContext);
+        const failoverAgentName = pendingContext.agentName;
+        input.failoverState.pending = null; // always clear before acting
+        if (failoverAction.action === "switch") {
+            let switchSucceeded = false;
+            try {
+                (0, auth_flow_1.writeAgentProviderSelection)(failoverAgentName, "human", failoverAction.provider);
+                (0, auth_flow_1.writeAgentProviderSelection)(failoverAgentName, "agent", failoverAction.provider);
+                switchSucceeded = true;
+                /* v8 ignore start -- defensive: write failure during provider switch @preserve */
             }
-        }
-        // 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);
+            catch (switchError) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.failover_switch_error",
+                    message: `failed to switch provider to ${failoverAction.provider}`,
+                    meta: { agentName: failoverAgentName, provider: failoverAction.provider, error: switchError instanceof Error ? switchError.message : String(switchError) },
+                });
+            }
+            /* v8 ignore stop */
+            /* v8 ignore next -- false branch: write-failure fallthrough @preserve */
+            if (switchSucceeded) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.failover_switch",
+                    message: `switched provider to ${failoverAction.provider} via failover`,
+                    meta: { agentName: failoverAgentName, provider: failoverAction.provider },
+                });
+                // 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 newProviderSecrets = (() => {
+                    try {
+                        const { secrets } = (0, auth_flow_1.loadAgentSecrets)(failoverAgentName);
+                        const cfg = secrets.providers[failoverAction.provider];
+                        return cfg?.model ?? cfg?.modelName ?? "";
+                        /* v8 ignore next 2 -- defensive: secrets read failure @preserve */
+                    }
+                    catch {
+                        return "";
                     }
-                    // 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,
-                    };
+                })();
+                const newProviderLabel = newProviderSecrets ? `${failoverAction.provider} (${newProviderSecrets})` : failoverAction.provider;
+                input.messages = [{
+                        role: "user",
+                        content: `[provider switch: ${pendingContext.errorSummary}. switched to ${newProviderLabel}. your conversation history is intact — respond to the user's last message.]`,
+                    }];
+                input.switchedProvider = failoverAction.provider;
+            }
+            // Switch failed OR succeeded — either way, fall through to normal processing.
+        }
+    }
+    // Step 0b: Slash command interception (before friend resolution / agent turn)
+    {
+        const firstUserMsg = input.messages.find((m) => m.role === "user");
+        const userText = firstUserMsg
+            ? (typeof firstUserMsg.content === "string"
+                ? firstUserMsg.content
+                : Array.isArray(firstUserMsg.content)
+                    ? firstUserMsg.content.find((p) => p.type === "text")?.text ?? ""
+                    : /* v8 ignore next -- defensive: content is always string or array @preserve */ "")
+            : "";
+        const parsed = (0, commands_1.parseSlashCommand)(userText);
+        if (parsed) {
+            const registry = (0, commands_1.getSharedCommandRegistry)();
+            const dispatchResult = registry.dispatch(parsed.command, { channel: input.channel });
+            if (dispatchResult.handled && dispatchResult.result) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.pipeline_command",
+                    message: `slash command intercepted: /${parsed.command}`,
+                    meta: { command: parsed.command, channel: input.channel },
+                });
+                if (dispatchResult.result.message) {
+                    input.callbacks.onTextChunk(dispatchResult.result.message);
                 }
+                // Return a minimal result — no agent turn, no session write
+                const resolvedContext = await input.friendResolver.resolve();
+                return {
+                    resolvedContext,
+                    gateResult: { allowed: true },
+                    turnOutcome: "command",
+                    commandAction: dispatchResult.result.action,
+                };
             }
         }
-        // Step 1: Resolve friend
-        const resolvedContext = await input.friendResolver.resolve();
+    }
+    // Step 1: Resolve friend
+    const resolvedContext = await input.friendResolver.resolve();
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.pipeline_start",
+        message: "inbound turn pipeline started",
+        meta: {
+            channel: input.channel,
+            friendId: resolvedContext.friend.id,
+            senseType: input.capabilities.senseType,
+        },
+    });
+    // Step 2: Trust gate
+    const gateInput = {
+        friend: resolvedContext.friend,
+        provider: input.provider ?? "local",
+        externalId: input.externalId ?? "",
+        tenantId: input.tenantId,
+        channel: input.channel,
+        senseType: input.capabilities.senseType,
+        isGroupChat: input.isGroupChat ?? false,
+        groupHasFamilyMember: input.groupHasFamilyMember ?? false,
+        hasExistingGroupWithFamily: input.hasExistingGroupWithFamily ?? false,
+    };
+    const gateResult = input.enforceTrustGate(gateInput);
+    // Gate rejection: return early, no agent turn
+    if (!gateResult.allowed) {
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
-            event: "senses.pipeline_start",
-            message: "inbound turn pipeline started",
+            event: "senses.pipeline_gate_reject",
+            message: "trust gate rejected inbound turn",
             meta: {
                 channel: input.channel,
                 friendId: resolvedContext.friend.id,
-                senseType: input.capabilities.senseType,
+                reason: gateResult.reason,
             },
         });
-        // Step 2: Trust gate
-        const gateInput = {
-            friend: resolvedContext.friend,
-            provider: input.provider ?? "local",
-            externalId: input.externalId ?? "",
-            tenantId: input.tenantId,
-            channel: input.channel,
-            senseType: input.capabilities.senseType,
-            isGroupChat: input.isGroupChat ?? false,
-            groupHasFamilyMember: input.groupHasFamilyMember ?? false,
-            hasExistingGroupWithFamily: input.hasExistingGroupWithFamily ?? false,
+        return {
+            resolvedContext,
+            gateResult,
         };
-        const gateResult = input.enforceTrustGate(gateInput);
-        // Gate rejection: return early, no agent turn
-        if (!gateResult.allowed) {
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.pipeline_gate_reject",
-                message: "trust gate rejected inbound turn",
-                meta: {
-                    channel: input.channel,
-                    friendId: resolvedContext.friend.id,
-                    reason: gateResult.reason,
-                },
-            });
-            return {
-                resolvedContext,
-                gateResult,
-            };
+    }
+    // Step 3: Load/create session
+    const session = await input.sessionLoader.loadOrCreate();
+    const sessionMessages = session.messages;
+    let mustResolveBeforeHandoff = (0, continuity_1.resolveMustResolveBeforeHandoff)(session.state?.mustResolveBeforeHandoff === true, input.continuityIngressTexts);
+    const lastFriendActivityAt = input.channel === "inner"
+        ? session.state?.lastFriendActivityAt
+        : new Date().toISOString();
+    const currentObligation = input.continuityIngressTexts
+        ?.map((text) => text.trim())
+        .filter((text) => text.length > 0)
+        .at(-1);
+    const currentSession = {
+        friendId: resolvedContext.friend.id,
+        channel: input.channel,
+        key: input.sessionKey ?? "session",
+        sessionPath: session.sessionPath,
+    };
+    // Step 3b: Pre-turn sync pull (opt-in) — MUST happen before any continuity state reads
+    // so that obligations, episodes, cares, etc. reflect the latest remote state.
+    let syncFailure;
+    let syncConfig = { enabled: false, remote: "origin" };
+    try {
+        syncConfig = (0, config_1.getSyncConfig)();
+    }
+    catch { /* config not available */ }
+    // Wrap the turn body in try/finally so postTurnPush always runs — even on
+    // error or early-return failover paths.
+    try {
+        /* v8 ignore start -- sync-enabled branches tested in sync.test.ts, pipeline tests mock at module boundary @preserve */
+        if (syncConfig.enabled) {
+            const pullResult = (0, sync_1.preTurnPull)((0, identity_1.getAgentRoot)(), syncConfig);
+            if (!pullResult.ok) {
+                syncFailure = pullResult.error;
+            }
+            // Check for pending-sync from a prior failed push
+            if (!syncFailure) {
+                const pendingSyncPath = path.join((0, identity_1.getAgentRoot)(), "state", "pending-sync.json");
+                try {
+                    if (fs.existsSync(pendingSyncPath)) {
+                        const pendingSync = JSON.parse(fs.readFileSync(pendingSyncPath, "utf-8"));
+                        syncFailure = `prior sync push failed: ${pendingSync.error ?? "unknown"}`;
+                        fs.unlinkSync(pendingSyncPath);
+                    }
+                }
+                catch {
+                    // Ignore read errors for pending-sync
+                }
+            }
         }
-        // Step 3: Load/create session
-        const session = await input.sessionLoader.loadOrCreate();
-        const sessionMessages = session.messages;
-        let mustResolveBeforeHandoff = (0, continuity_1.resolveMustResolveBeforeHandoff)(session.state?.mustResolveBeforeHandoff === true, input.continuityIngressTexts);
-        const lastFriendActivityAt = input.channel === "inner"
-            ? session.state?.lastFriendActivityAt
-            : new Date().toISOString();
-        const currentObligation = input.continuityIngressTexts
-            ?.map((text) => text.trim())
-            .filter((text) => text.length > 0)
-            .at(-1);
-        const currentSession = {
-            friendId: resolvedContext.friend.id,
+        /* v8 ignore stop */
+        // Build the turn context snapshot — centralizes all state reads
+        const ctx = await (0, turn_context_1.buildTurnContext)({
+            currentSession,
             channel: input.channel,
-            key: input.sessionKey ?? "session",
-            sessionPath: session.sessionPath,
-        };
-        // Step 3b: Pre-turn sync pull (opt-in) — MUST happen before any continuity state reads
-        // so that obligations, episodes, cares, etc. reflect the latest remote state.
-        let syncFailure;
-        let syncConfig = { enabled: false, remote: "origin" };
-        try {
-            syncConfig = (0, config_1.getSyncConfig)();
+            friendStore: input.friendStore,
+        });
+        // Propagate sync failure from pre-turn pull
+        ctx.syncFailure = syncFailure;
+        const { activeBridges, sessionActivity, pendingObligations, codingSessions, otherCodingSessions } = ctx;
+        const bridgeContext = (0, manager_1.formatBridgeContext)(activeBridges) || undefined;
+        const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
+            currentSession,
+            currentObligation,
+            mustResolveBeforeHandoff,
+            inner: ctx.innerWorkState,
+            bridges: activeBridges,
+            codingSessions,
+            otherCodingSessions,
+            pendingObligations,
+            taskBoard: ctx.taskBoard,
+            friendActivity: sessionActivity,
+            targetCandidates: ctx.targetCandidates,
+            innerReturnObligations: ctx.returnObligations,
+        });
+        const delegationDecision = (0, delegation_1.decideDelegation)({
+            channel: input.channel,
+            ingressTexts: input.continuityIngressTexts ?? [],
+            activeWork: activeWorkFrame,
+            mustResolveBeforeHandoff,
+        });
+        // Step 4: Drain deferred friend returns, then ordinary per-session pending.
+        const deferredReturns = input.channel === "inner"
+            ? []
+            : (input.drainDeferredReturns?.(resolvedContext.friend.id) ?? []);
+        const sessionPending = input.drainPending(input.pendingDir);
+        const pending = [...deferredReturns, ...sessionPending];
+        // Assemble messages: session messages + pending + inbound user messages
+        // NOTE: live world-state checkpoint and pending messages are rendered via buildSystem (system prompt sections)
+        const extraPrefixSections = input.onPendingDrained?.(pending) ?? [];
+        // extraPrefixSections from onPendingDrained still prepend to user message (e.g., inner dialog wakes)
+        if (extraPrefixSections.length > 0 && input.messages.length > 0) {
+            input.messages[0] = prependTurnSections(input.messages[0], extraPrefixSections);
+        }
+        // Append user messages from the inbound turn
+        for (const msg of input.messages) {
+            sessionMessages.push(msg);
         }
-        catch { /* config not available */ }
-        // Wrap the turn body in try/finally so drainSyncWrites always runs — even on
-        // error or early-return failover paths. This prevents writes from leaking into
-        // the next turn's accumulator.
+        // 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 {
-            /* v8 ignore start -- sync-enabled branches tested in sync.test.ts, pipeline tests mock at module boundary @preserve */
-            if (syncConfig.enabled) {
-                const pullResult = (0, sync_1.preTurnPull)((0, identity_1.getAgentRoot)(), syncConfig);
-                if (!pullResult.ok) {
-                    syncFailure = pullResult.error;
-                }
-                // Check for pending-sync from a prior failed push
-                if (!syncFailure) {
-                    const pendingSyncPath = path.join((0, identity_1.getAgentRoot)(), "state", "pending-sync.json");
-                    try {
-                        if (fs.existsSync(pendingSyncPath)) {
-                            const pendingSync = JSON.parse(fs.readFileSync(pendingSyncPath, "utf-8"));
-                            syncFailure = `prior sync push failed: ${pendingSync.error ?? "unknown"}`;
-                            fs.unlinkSync(pendingSyncPath);
-                        }
-                    }
-                    catch {
-                        // Ignore read errors for pending-sync
-                    }
-                }
-            }
-            /* v8 ignore stop */
-            // Build the turn context snapshot — centralizes all state reads
-            const ctx = await (0, turn_context_1.buildTurnContext)({
-                currentSession,
-                channel: input.channel,
-                friendStore: input.friendStore,
+            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,
             });
-            // Propagate sync failure from pre-turn pull
-            ctx.syncFailure = syncFailure;
-            const { activeBridges, sessionActivity, pendingObligations, codingSessions, otherCodingSessions } = ctx;
-            const bridgeContext = (0, manager_1.formatBridgeContext)(activeBridges) || undefined;
-            const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
-                currentSession,
-                currentObligation,
-                mustResolveBeforeHandoff,
-                inner: ctx.innerWorkState,
-                bridges: activeBridges,
-                codingSessions,
-                otherCodingSessions,
-                pendingObligations,
-                taskBoard: ctx.taskBoard,
-                friendActivity: sessionActivity,
-                targetCandidates: ctx.targetCandidates,
-                innerReturnObligations: ctx.returnObligations,
+            const temporalView = (0, temporal_view_1.buildTemporalView)(agentRoot, {
+                tempo: tempoState.mode,
+                preloaded: {
+                    recentEpisodes,
+                    activeObligations: pendingObligations,
+                    activeCares,
+                },
             });
-            const delegationDecision = (0, delegation_1.decideDelegation)({
-                channel: input.channel,
-                ingressTexts: input.continuityIngressTexts ?? [],
-                activeWork: activeWorkFrame,
-                mustResolveBeforeHandoff,
+            const startOfTurnPacket = (0, start_of_turn_packet_1.buildStartOfTurnPacket)(temporalView, {
+                canonicalObligations: {
+                    primary: activeWorkFrame.primaryObligation,
+                    all: activeWorkFrame.pendingObligations,
+                },
             });
-            // 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);
+            /* v8 ignore next 3 -- syncFailure propagation tested in sync.test.ts @preserve */
+            if (syncFailure) {
+                startOfTurnPacket.syncFailure = syncFailure;
             }
-            // Append user messages from the inbound turn
-            for (const msg of input.messages) {
-                sessionMessages.push(msg);
+            const capabilities = (0, start_of_turn_packet_1.buildCapabilitiesSection)(agentRoot);
+            if (capabilities) {
+                startOfTurnPacket.capabilities = capabilities;
             }
-            // 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}`));
+            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,
+            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 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,
-                    },
-                });
-                /* v8 ignore next 3 -- syncFailure propagation tested in sync.test.ts @preserve */
-                if (syncFailure) {
-                    startOfTurnPacket.syncFailure = syncFailure;
-                }
-                const capabilities = (0, start_of_turn_packet_1.buildCapabilitiesSection)(agentRoot);
-                if (capabilities) {
-                    startOfTurnPacket.capabilities = capabilities;
+                const agentConfig = (0, identity_1.loadAgentConfig)();
+                const currentProvider = agentConfig.humanFacing.provider;
+                /* v8 ignore next -- defensive: errorClassification always set when errored @preserve */
+                const classification = result.errorClassification ?? "unknown";
+                const inventory = await (0, provider_ping_1.runHealthInventory)(agentName, currentProvider);
+                const { secrets } = (0, auth_flow_1.loadAgentSecrets)(agentName);
+                const providerModels = {};
+                for (const [p, cfg] of Object.entries(secrets.providers)) {
+                    const model = cfg.model ?? cfg.modelName;
+                    if (typeof model === "string" && model)
+                        providerModels[p] = model;
                 }
-                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);
+                // Use agent.json model (source of truth), not secrets model (may be stale)
+                const currentModel = agentConfig.humanFacing.model;
+                const failoverContext = (0, provider_failover_1.buildFailoverContext)(
+                /* v8 ignore next -- defensive: error always set when errored @preserve */
+                result.error?.message ?? "unknown error", classification, currentProvider, currentModel, agentName, inventory, providerModels);
+                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 (continuityError) {
+            catch (failoverError) {
                 (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) },
+                    event: "senses.failover_error",
+                    message: "failover sequence failed, falling through",
+                    meta: { error: failoverError instanceof Error ? failoverError.message : String(failoverError) },
                 });
             }
-            // 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,
-                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 agentConfig = (0, identity_1.loadAgentConfig)();
-                    const currentProvider = agentConfig.humanFacing.provider;
-                    /* v8 ignore next -- defensive: errorClassification always set when errored @preserve */
-                    const classification = result.errorClassification ?? "unknown";
-                    const inventory = await (0, provider_ping_1.runHealthInventory)(agentName, currentProvider);
-                    const { secrets } = (0, auth_flow_1.loadAgentSecrets)(agentName);
-                    const providerModels = {};
-                    for (const [p, cfg] of Object.entries(secrets.providers)) {
-                        const model = cfg.model ?? cfg.modelName;
-                        if (typeof model === "string" && model)
-                            providerModels[p] = model;
-                    }
-                    // Use agent.json model (source of truth), not secrets model (may be stale)
-                    const currentModel = agentConfig.humanFacing.model;
-                    const failoverContext = (0, provider_failover_1.buildFailoverContext)(
-                    /* v8 ignore next -- defensive: error always set when errored @preserve */
-                    result.error?.message ?? "unknown error", classification, currentProvider, currentModel, agentName, inventory, providerModels);
-                    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
+            /* 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 {
-                const agentRoot = (0, identity_1.getAgentRoot)();
-                const postTurnObligations = (0, obligations_1.readPendingObligations)(agentRoot);
-                emitObligationTransitionEpisodes(agentRoot, preTurnObligationIds, postTurnObligations, pendingObligations);
-            }
-            catch {
-                // Episode emission is non-fatal
+                (0, socket_client_1.requestInnerWake)((0, identity_1.getAgentName)()).catch(/* v8 ignore next */ () => { });
             }
-            // 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 } : {}),
-            };
+            catch { /* getAgentName may fail in test environments */ }
         }
-        finally {
-            // Step 6b: Post-turn sync push (opt-in, turn-scoped writes only).
-            // In a finally block so writes are always drained — even on error or early-return
-            // failover paths. This prevents writes from leaking into the next turn.
-            const writtenPaths = (0, sync_1.drainSyncWrites)();
-            /* v8 ignore next 3 -- postTurnPush integration tested in sync.test.ts @preserve */
-            if (syncConfig.enabled && writtenPaths.length > 0) {
-                (0, sync_1.postTurnPush)((0, identity_1.getAgentRoot)(), syncConfig, writtenPaths);
-            }
+        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);
         }
-    }); // end runWithSyncContext
+    }
 }