@ouro.bot/cli 0.1.0-alpha.15 → 0.1.0-alpha.150

package/dist/senses/pipeline.js

@@ -0,0 +1,463 @@
+"use strict";
+// Shared per-turn pipeline for all senses.
+// Senses are thin transport adapters; this module owns the common lifecycle:
+//   resolve friend -> trust gate -> load session -> drain pending -> runAgent -> postTurn -> token accumulation.
+//
+// Transport-level concerns (BB API calls, Teams cards, readline) stay in sense adapters.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleInboundTurn = handleInboundTurn;
+const runtime_1 = require("../nerves/runtime");
+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 coding_1 = require("../repertoire/coding");
+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 target_resolution_1 = require("../heart/target-resolution");
+const thoughts_1 = require("../heart/daemon/thoughts");
+const pending_1 = require("../mind/pending");
+const obligations_1 = require("../heart/obligations");
+const obligations_2 = require("../mind/obligations");
+const provider_failover_1 = require("../heart/provider-failover");
+const provider_ping_1 = require("../heart/provider-ping");
+const auth_flow_1 = require("../heart/daemon/auth-flow");
+function emptyTaskBoard() {
+    return {
+        compact: "",
+        full: "",
+        byStatus: {
+            drafting: [],
+            processing: [],
+            validating: [],
+            collaborating: [],
+            paused: [],
+            blocked: [],
+            done: [],
+        },
+        actionRequired: [],
+        unresolvedDependencies: [],
+        activeSessions: [],
+        activeBridges: [],
+    };
+}
+function isLiveCodingSessionStatus(status) {
+    return status === "spawning"
+        || status === "running"
+        || status === "waiting_input"
+        || status === "stalled";
+}
+function prependTurnSections(message, sections) {
+    if (message.role !== "user" || sections.length === 0)
+        return message;
+    const prefix = sections.join("\n\n");
+    if (typeof message.content === "string") {
+        return {
+            ...message,
+            content: `${prefix}\n\n${message.content}`,
+        };
+    }
+    return {
+        ...message,
+        content: [
+            { type: "text", text: `${prefix}\n\n` },
+            ...message.content,
+        ],
+    };
+}
+function readInnerWorkState() {
+    const defaultJob = {
+        status: "idle",
+        content: null,
+        origin: null,
+        mode: "reflect",
+        obligationStatus: null,
+        surfacedResult: null,
+        queuedAt: null,
+        startedAt: null,
+        surfacedAt: null,
+    };
+    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 { pendingMessages, turns, runtimeState } = (0, thoughts_1.readInnerDialogRawData)(sessionPath, pendingDir);
+        const dialogStatus = (0, thoughts_1.deriveInnerDialogStatus)(pendingMessages, turns, runtimeState);
+        const job = (0, thoughts_1.deriveInnerJob)(pendingMessages, turns, runtimeState);
+        // Derive obligationPending from both the pending message field and the obligation store
+        const storeObligationPending = (0, obligations_1.readPendingObligations)(agentRoot).length > 0;
+        return {
+            status: dialogStatus.processing === "started" ? "running" : "idle",
+            hasPending: dialogStatus.queue !== "clear",
+            origin: dialogStatus.origin,
+            contentSnippet: dialogStatus.contentSnippet,
+            obligationPending: dialogStatus.obligationPending || storeObligationPending,
+            job,
+        };
+    }
+    catch {
+        return {
+            status: "idle",
+            hasPending: false,
+            job: defaultJob,
+        };
+    }
+}
+// ── Pipeline ──────────────────────────────────────────────────────
+async function handleInboundTurn(input) {
+    // 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, 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.
+        }
+    }
+    // Step 1: Resolve friend
+    const resolvedContext = await input.friendResolver.resolve();
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.pipeline_start",
+        message: "inbound turn pipeline started",
+        meta: {
+            channel: input.channel,
+            friendId: resolvedContext.friend.id,
+            senseType: input.capabilities.senseType,
+        },
+    });
+    // Step 2: Trust gate
+    const gateInput = {
+        friend: resolvedContext.friend,
+        provider: input.provider ?? "local",
+        externalId: input.externalId ?? "",
+        tenantId: input.tenantId,
+        channel: input.channel,
+        senseType: input.capabilities.senseType,
+        isGroupChat: input.isGroupChat ?? false,
+        groupHasFamilyMember: input.groupHasFamilyMember ?? false,
+        hasExistingGroupWithFamily: input.hasExistingGroupWithFamily ?? false,
+    };
+    const gateResult = input.enforceTrustGate(gateInput);
+    // Gate rejection: return early, no agent turn
+    if (!gateResult.allowed) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.pipeline_gate_reject",
+            message: "trust gate rejected inbound turn",
+            meta: {
+                channel: input.channel,
+                friendId: resolvedContext.friend.id,
+                reason: gateResult.reason,
+            },
+        });
+        return {
+            resolvedContext,
+            gateResult,
+        };
+    }
+    // Step 3: Load/create session
+    const session = await input.sessionLoader.loadOrCreate();
+    const sessionMessages = session.messages;
+    let mustResolveBeforeHandoff = (0, continuity_1.resolveMustResolveBeforeHandoff)(session.state?.mustResolveBeforeHandoff === true, input.continuityIngressTexts);
+    const lastFriendActivityAt = input.channel === "inner"
+        ? session.state?.lastFriendActivityAt
+        : new Date().toISOString();
+    const currentObligation = input.continuityIngressTexts
+        ?.map((text) => text.trim())
+        .filter((text) => text.length > 0)
+        .at(-1);
+    const currentSession = {
+        friendId: resolvedContext.friend.id,
+        channel: input.channel,
+        key: input.sessionKey ?? "session",
+        sessionPath: session.sessionPath,
+    };
+    const 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 = [];
+    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 = [];
+    }
+    let targetCandidates = [];
+    try {
+        if (input.channel !== "inner") {
+            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,
+                },
+                friendStore: input.friendStore,
+            });
+        }
+    }
+    catch {
+        targetCandidates = [];
+    }
+    let pendingObligations = [];
+    try {
+        pendingObligations = (0, obligations_1.readPendingObligations)((0, identity_1.getAgentRoot)());
+    }
+    catch {
+        pendingObligations = [];
+    }
+    let codingSessions = [];
+    let otherCodingSessions = [];
+    try {
+        const liveCodingSessions = (0, coding_1.getCodingSessionManager)()
+            .listSessions()
+            .filter((session) => isLiveCodingSessionStatus(session.status) && Boolean(session.originSession));
+        codingSessions = liveCodingSessions.filter((session) => session.originSession?.friendId === currentSession.friendId
+            && session.originSession.channel === currentSession.channel
+            && session.originSession.key === currentSession.key);
+        otherCodingSessions = liveCodingSessions.filter((session) => !(session.originSession?.friendId === currentSession.friendId
+            && session.originSession.channel === currentSession.channel
+            && session.originSession.key === currentSession.key));
+    }
+    catch {
+        codingSessions = [];
+        otherCodingSessions = [];
+    }
+    const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
+        currentSession,
+        currentObligation,
+        mustResolveBeforeHandoff,
+        inner: readInnerWorkState(),
+        bridges: activeBridges,
+        codingSessions,
+        otherCodingSessions,
+        pendingObligations,
+        taskBoard: (() => {
+            try {
+                return (0, tasks_1.getTaskModule)().getBoard();
+            }
+            catch {
+                return emptyTaskBoard();
+            }
+        })(),
+        friendActivity: sessionActivity,
+        targetCandidates,
+        innerReturnObligations: (() => {
+            try {
+                return (0, obligations_2.listActiveObligations)((0, identity_1.getAgentName)());
+            }
+            catch {
+                return [];
+            }
+        })(),
+    });
+    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 + attention queue + live world-state checkpoint + pending + inbound user messages
+    const extraPrefixSections = input.onPendingDrained?.(pending) ?? [];
+    const prefixSections = [...extraPrefixSections, (0, active_work_1.formatLiveWorldStateCheckpoint)(activeWorkFrame)];
+    if (pending.length > 0) {
+        const pendingSection = pending
+            .map((msg) => `[pending from ${msg.from}]: ${msg.content}`)
+            .join("\n");
+        prefixSections.push(`## pending messages\n${pendingSection}`);
+    }
+    if (input.messages.length > 0) {
+        input.messages[0] = prependTurnSections(input.messages[0], prefixSections);
+    }
+    // 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,
+            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.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;
+            }
+            /* v8 ignore next -- defensive: current provider always in secrets @preserve */
+            const currentModel = providerModels[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, 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 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 } : {}),
+    };
+}

package/dist/senses/shared-turn.js

@@ -0,0 +1,196 @@
+"use strict";
+// Shared turn runner for non-interactive senses (MCP, future senses).
+// Follows the CLI pattern: resolves context, constructs InboundTurnInput,
+// calls handleInboundTurn, collects response text, detects ponder deferral.
+//
+// Does NOT refactor CLI — CLI is stable with 2280+ tests. This is a new
+// code path for new senses that follows the same pipeline pattern.
+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.runSenseTurn = runSenseTurn;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const core_1 = require("../heart/core");
+const identity_1 = require("../heart/identity");
+const config_1 = require("../heart/config");
+const context_1 = require("../mind/context");
+const prompt_1 = require("../mind/prompt");
+const channel_1 = require("../mind/friends/channel");
+const resolver_1 = require("../mind/friends/resolver");
+const store_file_1 = require("../mind/friends/store-file");
+const pending_1 = require("../mind/pending");
+const context_2 = require("../mind/context");
+const tokens_1 = require("../mind/friends/tokens");
+const trust_gate_1 = require("./trust-gate");
+const pipeline_1 = require("./pipeline");
+const runtime_1 = require("../nerves/runtime");
+const RESPONSE_CAP = 50_000;
+/**
+ * Run a single agent turn through the inbound pipeline.
+ * Caller provides channel, session key, friend, and message;
+ * this function handles all pipeline wiring.
+ */
+async function runSenseTurn(options) {
+    const { agentName, channel, sessionKey, friendId, userMessage } = options;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.shared_turn_start",
+        message: "shared turn runner starting",
+        meta: { agentName, channel, sessionKey, friendId },
+    });
+    // Resolve context
+    const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+    const friendsPath = path.join(agentRoot, "friends");
+    const friendStore = new store_file_1.FileFriendStore(friendsPath);
+    const capabilities = (0, channel_1.getChannelCapabilities)(channel);
+    // If friendId looks like a UUID, look up the friend record directly and use its identity.
+    // Otherwise, resolve as a local user (same pattern as CLI sense).
+    const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-/.test(friendId);
+    let resolverParams;
+    if (isUuid) {
+        const existingFriend = await friendStore.get(friendId);
+        if (existingFriend) {
+            // Use the friend's first external ID for resolver context
+            const ext = existingFriend.externalIds?.[0];
+            resolverParams = {
+                provider: (ext?.provider ?? "local"),
+                externalId: ext?.externalId ?? friendId,
+                displayName: existingFriend.name ?? friendId,
+                channel,
+            };
+        }
+        else {
+            resolverParams = { provider: "local", externalId: friendId, displayName: friendId, channel };
+        }
+    }
+    else {
+        // Treat as local user identity (username@hostname pattern)
+        const username = os.userInfo().username;
+        const hostname = os.hostname();
+        resolverParams = { provider: "local", externalId: `${username}@${hostname}`, displayName: username, channel };
+    }
+    const resolver = new resolver_1.FriendResolver(friendStore, resolverParams);
+    // Session path and loading
+    const sessPath = (0, config_1.sessionPath)(friendId, channel, sessionKey);
+    const existing = (0, context_1.loadSession)(sessPath);
+    let sessionState = existing?.state;
+    const sessionMessages = existing?.messages && existing.messages.length > 0
+        ? existing.messages
+        : [{ role: "system", content: await (0, prompt_1.buildSystem)(channel, {}, undefined) }];
+    // Pending dir
+    const pendingDir = (0, pending_1.getPendingDir)(agentName, friendId, channel, sessionKey);
+    // Accumulate response text via callbacks
+    let responseText = "";
+    /* v8 ignore start — no-op callback stubs; only onTextChunk does real work (covered via mock) */
+    const callbacks = {
+        onModelStart: () => { },
+        onModelStreamStart: () => { },
+        onTextChunk: (chunk) => { responseText += chunk; },
+        onReasoningChunk: () => { },
+        onToolStart: () => { },
+        onToolEnd: () => { },
+        onError: () => { },
+    };
+    /* v8 ignore stop */
+    // Run the pipeline
+    const result = await (0, pipeline_1.handleInboundTurn)({
+        channel,
+        sessionKey,
+        capabilities,
+        messages: [{ role: "user", content: userMessage }],
+        callbacks,
+        /* v8 ignore start — delegation wrappers; pipeline integration tested separately */
+        friendResolver: { resolve: () => resolver.resolve() },
+        sessionLoader: {
+            loadOrCreate: () => Promise.resolve({
+                messages: sessionMessages,
+                sessionPath: sessPath,
+                state: sessionState,
+            }),
+        },
+        /* v8 ignore stop */
+        pendingDir,
+        friendStore,
+        provider: "local",
+        externalId: friendId,
+        enforceTrustGate: trust_gate_1.enforceTrustGate,
+        drainPending: pending_1.drainPending,
+        /* v8 ignore start — delegation wrappers; these just forward to the real functions */
+        runAgent: (msgs, cb, ch, sig, opts) => (0, core_1.runAgent)(msgs, cb, ch, sig, opts),
+        postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
+            (0, context_2.postTurn)(turnMessages, sessionPathArg, usage, hooks, state);
+            sessionState = state;
+        },
+        /* v8 ignore stop */
+        accumulateFriendTokens: tokens_1.accumulateFriendTokens,
+    });
+    // Detect ponder deferral
+    const ponderDeferred = result.turnOutcome === "pondered";
+    // Build response
+    let finalResponse;
+    if (ponderDeferred) {
+        finalResponse = "the agent is pondering this — check back shortly via check_response.";
+    }
+    else if (responseText.length === 0) {
+        // Agent settled but no text came through callbacks — check session transcript for the settle answer
+        const postTurnSession = (0, context_1.loadSession)(sessPath);
+        if (postTurnSession?.messages) {
+            const lastAssistant = [...postTurnSession.messages].reverse().find(m => m.role === "assistant");
+            if (lastAssistant && typeof lastAssistant.content === "string" && lastAssistant.content.trim()) {
+                finalResponse = lastAssistant.content;
+            }
+            else {
+                finalResponse = "(agent responded but response was empty)";
+            }
+        }
+        else {
+            finalResponse = "(agent responded but response was empty)";
+        }
+    }
+    else {
+        finalResponse = responseText;
+    }
+    // Cap response length
+    if (finalResponse.length > RESPONSE_CAP) {
+        finalResponse = finalResponse.slice(0, RESPONSE_CAP) + "\n\n[truncated — response exceeded 50K characters]";
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.shared_turn_end",
+        message: "shared turn runner complete",
+        meta: { agentName, channel, sessionKey, friendId, ponderDeferred, responseLength: finalResponse.length },
+    });
+    return { response: finalResponse, ponderDeferred };
+}