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

package/dist/senses/teams.js

@@ -34,13 +34,19 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_FLUSH_INTERVAL_MS = void 0;
+exports.aiLabelEntities = aiLabelEntities;
 exports.stripMentions = stripMentions;
 exports.splitMessage = splitMessage;
+exports.sanitizeFeedbackComment = sanitizeFeedbackComment;
+exports.buildFeedbackSyntheticText = buildFeedbackSyntheticText;
+exports.buildWelcomeCard = buildWelcomeCard;
 exports.createTeamsCallbacks = createTeamsCallbacks;
-exports.resolvePendingConfirmation = resolvePendingConfirmation;
 exports.withConversationLock = withConversationLock;
 exports.handleTeamsMessage = handleTeamsMessage;
+exports.sendProactiveTeamsMessageToSession = sendProactiveTeamsMessageToSession;
+exports.drainAndSendPendingTeams = drainAndSendPendingTeams;
 exports.startTeamsApp = startTeamsApp;
+const fs = __importStar(require("fs"));
 const teams_apps_1 = require("@microsoft/teams.apps");
 const teams_dev_1 = require("@microsoft/teams.dev");
 const core_1 = require("../heart/core");
@@ -55,14 +61,34 @@ const context_1 = require("../mind/context");
 const commands_1 = require("./commands");
 const nerves_1 = require("../nerves");
 const runtime_1 = require("../nerves/runtime");
+const proactive_content_guard_1 = require("./proactive-content-guard");
 const store_file_1 = require("../mind/friends/store-file");
+const types_1 = require("../mind/friends/types");
 const resolver_1 = require("../mind/friends/resolver");
 const tokens_1 = require("../mind/friends/tokens");
 const turn_coordinator_1 = require("../heart/turn-coordinator");
 const identity_1 = require("../heart/identity");
+const mcp_manager_1 = require("../repertoire/mcp-manager");
+const progress_story_1 = require("../heart/progress-story");
+const tool_activity_callbacks_1 = require("../heart/tool-activity-callbacks");
+const commands_2 = require("./commands");
 const http = __importStar(require("http"));
 const path = __importStar(require("path"));
 const trust_gate_1 = require("./trust-gate");
+const pipeline_1 = require("./pipeline");
+const teamsFailoverStates = new Map();
+const pending_1 = require("../mind/pending");
+const continuity_1 = require("./continuity");
+// AIGeneratedContent entity and feedbackLoopEnabled channelData for all outbound
+// Teams messages. Required by Teams AI UX best practices.
+function aiLabelEntities() {
+    return [{
+            type: "https://schema.org/Message",
+            "@type": "Message",
+            "@context": "https://schema.org",
+            additionalType: ["AIGeneratedContent"],
+        }];
+}
 // Strip @mention markup from incoming messages.
 // Removes <at>...</at> tags and trims extra whitespace.
 // Fallback safety net -- the SDK's activity.mentions.stripText should handle
@@ -117,6 +143,46 @@ function splitMessage(text, maxLen) {
     }
     return chunks;
 }
+// Sanitize user-provided feedback comments: truncate, strip control chars and newlines.
+function sanitizeFeedbackComment(comment) {
+    const cleaned = comment.replace(/[\x00-\x1f\n\r]/g, "");
+    return cleaned.length > 200 ? cleaned.slice(0, 200) : cleaned;
+}
+// Build synthetic message text from a Teams feedback reaction.
+function buildFeedbackSyntheticText(reaction, comment) {
+    const emoji = reaction === "like" ? "thumbs-up" : "thumbs-down";
+    if (comment) {
+        const sanitized = sanitizeFeedbackComment(comment);
+        return `[reacted with ${emoji} to your message: "${sanitized}"]`;
+    }
+    return `[reacted with ${emoji} to your message]`;
+}
+// Build a welcome Adaptive Card with prompt starters for new bot installs.
+function buildWelcomeCard() {
+    const promptStarters = [
+        "What can you help me with?",
+        "Tell me about yourself",
+        "What's on my calendar today?",
+        "Summarize my recent emails",
+    ];
+    return {
+        type: "AdaptiveCard",
+        version: "1.5",
+        body: [
+            {
+                type: "TextBlock",
+                text: "Hey! I'm here and ready to help. Try one of these to get started, or just ask me anything.",
+                wrap: true,
+                size: "Medium",
+            },
+        ],
+        actions: promptStarters.map((prompt) => ({
+            type: "Action.Submit",
+            title: prompt,
+            data: { msteams: { type: "messageBack", text: prompt, displayText: prompt } },
+        })),
+    };
+}
 // Create Teams-specific callbacks for the agent loop.
 // The SDK handles cumulative text, debouncing (500ms), and the streaming
 // protocol (streamSequence, streamId, informative/streaming/final types).
@@ -129,12 +195,16 @@ function splitMessage(text, maxLen) {
 // (transient status) or safeSend (terminal errors). Reasoning is accumulated
 // and periodically pushed via safeUpdate on the same flush timer tick.
 function createTeamsCallbacks(stream, controller, sendMessage, options) {
+    const MIN_INITIAL_CHARS = 20;
     let stopped = false; // set when stream signals cancellation (403)
     let hadToolRun = false;
     let hadRealOutput = false; // true once reasoning/tool output shown; suppresses phrases
     let reasoningBuf = ""; // accumulated reasoning text for status display
+    let totalEmitted = 0; // cumulative chars emitted via safeEmit (for >4000 finalization)
+    let streamFinalized = false; // true after stream.close() — subsequent flushes go to safeSend
     let textBuffer = ""; // accumulated text output for chunked streaming
     let streamHasContent = false; // tracks whether primary output has received content
+    let firstContentEmitted = false; // true after first content push — disables MIN_INITIAL_CHARS threshold
     let phraseTimer = null;
     let lastPhrase = "";
     let flushTimer = null;
@@ -184,15 +254,16 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
             result.catch(() => markStopped());
         }
     }
-    // Safely emit a text delta to the stream.
+    // Safely emit a text delta to the stream with AI labels.
     // On error (e.g. 403 from Teams stop button), abort the controller.
     function safeEmit(text) {
         /* v8 ignore next -- defensive guard: stopped set by prior 403; tested via flush abort path @preserve */
         if (stopped)
             return;
         try {
-            catchAsync(stream.emit(text));
+            catchAsync(stream.emit({ text, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } }));
             streamHasContent = true;
+            totalEmitted += text.length;
         }
         catch {
             markStopped();
@@ -207,7 +278,7 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         try {
             // stream.emit() is typed as void but the Teams SDK returns a Promise
             // internally (async HTTP). Cast to capture the result for awaiting.
-            const result = stream.emit(text);
+            const result = stream.emit({ text, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
             streamHasContent = true;
             if (result && typeof result.then === "function") {
                 await result;
@@ -263,11 +334,49 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
     // emitted text into a single streaming message (cumulative), so every
     // periodic flush appends to the same response — not separate messages.
     // No preemptive splitting — sends full text. Error recovery happens in flush().
+    // Hybrid MIN_INITIAL_CHARS: hold back until >= MIN_INITIAL_CHARS accumulated
+    // before the first content emit, so phrase rotation shows while real content
+    // buffers. After first emit, flush normally (no threshold).
     function flushTextBuffer() {
         if (!textBuffer)
             return;
+        if (!firstContentEmitted && textBuffer.length < MIN_INITIAL_CHARS)
+            return;
+        // Proactive >4000 finalization: if cumulative emitted + buffer >= RECOVERY_CHUNK_SIZE,
+        // finalize the stream and send overflow via safeSend (follow-up message).
+        if (!streamFinalized && totalEmitted + textBuffer.length >= RECOVERY_CHUNK_SIZE) {
+            const remaining = RECOVERY_CHUNK_SIZE - totalEmitted;
+            /* v8 ignore next 2 -- defensive: remaining always > 0 because finalization runs once @preserve */
+            if (remaining > 0)
+                safeEmit(textBuffer.slice(0, remaining));
+            try {
+                stream.close();
+            }
+            catch { /* stream may already be dead */ }
+            streamFinalized = true;
+            /* v8 ignore next -- defensive ternary: remaining always > 0 at first finalization @preserve */
+            const overflow = textBuffer.slice(remaining > 0 ? remaining : 0);
+            textBuffer = "";
+            if (overflow)
+                safeSend(overflow);
+            if (!firstContentEmitted) {
+                firstContentEmitted = true;
+                stopPhraseRotation();
+            }
+            return;
+        }
+        if (streamFinalized) {
+            // After finalization, all content goes to safeSend (follow-up messages)
+            safeSend(textBuffer);
+            textBuffer = "";
+            return;
+        }
         safeEmit(textBuffer);
         textBuffer = "";
+        if (!firstContentEmitted) {
+            firstContentEmitted = true;
+            stopPhraseRotation();
+        }
     }
     function startPhraseRotation(pool) {
         stopPhraseRotation();
@@ -310,32 +419,45 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         onTextChunk: (text) => {
             if (stopped)
                 return;
-            stopPhraseRotation();
+            // Don't stop phrase rotation here — let it continue until first content
+            // emit (handled in flushTextBuffer when MIN_INITIAL_CHARS threshold met).
             textBuffer += text;
             startFlushTimer();
         },
         onClearText: () => {
             textBuffer = "";
         },
-        onToolStart: (name, args) => {
-            stopPhraseRotation();
-            flushTextBuffer();
-            // Emit a placeholder to satisfy the 15s Copilot timeout for initial
-            // stream.emit(). Without this, long tool chains (e.g. ADO batch ops)
-            // never emit before the timeout and the user sees "this response was
-            // stopped". The placeholder is replaced by actual content on next emit.
-            // https://learn.microsoft.com/en-us/answers/questions/2288017/m365-custom-engine-agents-timeout-message-after-15
-            if (!streamHasContent)
-                safeEmit("⏳");
-            const argSummary = (0, tools_1.summarizeArgs)(name, args) || Object.keys(args).join(", ");
-            safeUpdate(`running ${name} (${argSummary})...`);
-            hadToolRun = true;
-        },
-        onToolEnd: (name, summary, success) => {
-            stopPhraseRotation();
-            const msg = (0, format_1.formatToolResult)(name, summary, success);
-            safeUpdate(msg);
-        },
+        ...(() => {
+            const toolCbs = (0, tool_activity_callbacks_1.createToolActivityCallbacks)({
+                onDescription: (text) => safeUpdate(text),
+                /* v8 ignore next -- onResult only called in debug mode; tested via tool-activity-callbacks.test.ts @preserve */
+                onResult: (text) => safeUpdate(text),
+                /* v8 ignore next -- onFailure tested via onToolEnd failure test @preserve */
+                onFailure: (text) => safeUpdate(text),
+                isDebug: commands_2.getDebugMode,
+            });
+            return {
+                onToolStart: (name, args) => {
+                    stopPhraseRotation();
+                    // Force-flush any accumulated text, bypassing MIN_INITIAL_CHARS threshold
+                    firstContentEmitted = true;
+                    flushTextBuffer();
+                    // Emit a placeholder to satisfy the 15s Copilot timeout for initial
+                    // stream.emit(). Without this, long tool chains (e.g. ADO batch ops)
+                    // never emit before the timeout and the user sees "this response was
+                    // stopped". The placeholder is replaced by actual content on next emit.
+                    // https://learn.microsoft.com/en-us/answers/questions/2288017/m365-custom-engine-agents-timeout-message-after-15
+                    if (!streamHasContent)
+                        safeEmit("\u23f3");
+                    toolCbs.onToolStart(name, args);
+                    hadToolRun = true;
+                },
+                onToolEnd: (name, summary, success) => {
+                    stopPhraseRotation();
+                    toolCbs.onToolEnd(name, summary, success);
+                },
+            };
+        })(),
         onKick: () => {
             stopPhraseRotation();
             const msg = (0, format_1.formatKick)();
@@ -345,7 +467,11 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
             stopPhraseRotation();
             if (stopped)
                 return;
-            const msg = (0, format_1.formatError)(error);
+            const msg = (0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
+                scope: "shared-work",
+                phase: "errored",
+                outcomeText: (0, format_1.formatError)(error),
+            }));
             if (severity === "transient") {
                 safeUpdate(msg);
             }
@@ -353,38 +479,27 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
                 safeSend(msg);
             }
         },
-        onConfirmAction: options?.conversationId
-            ? async (name, args) => {
-                const convId = options.conversationId;
-                const argsDesc = Object.entries(args).map(([k, v]) => `${k}: ${v}`).join(", ");
-                safeUpdate(`Confirm action: ${name} (${argsDesc}) -- reply "yes" to confirm or "no" to cancel`);
-                return new Promise((resolve) => {
-                    _pendingConfirmations.set(convId, resolve);
-                    // Auto-deny after 2 minutes to prevent indefinite blocking
-                    // (e.g. when the stream dies and the user never sees the prompt).
-                    setTimeout(() => {
-                        if (_pendingConfirmations.has(convId)) {
-                            _pendingConfirmations.delete(convId);
-                            resolve("denied");
-                        }
-                    }, 120_000);
-                });
-            }
-            : undefined,
         flush: async () => {
             stopFlushTimer();
+            stopPhraseRotation();
             if (textBuffer) {
+                // Bypass MIN_INITIAL_CHARS threshold — flush delivers all remaining content
+                firstContentEmitted = true;
                 const text = textBuffer;
                 textBuffer = "";
-                if (!stopped) {
+                if (streamFinalized && sendMessage) {
+                    // Stream already finalized (>4000 path) — send remaining content as follow-up
+                    safeSend(text);
+                }
+                else if (!stopped) {
                     // Stream is alive — await the emit so we can catch async 413/failure
                     // and fall through to sendMessage recovery.
                     const ok = await tryEmit(text);
                     if (!ok)
                         markStopped();
                 }
-                if (stopped && sendMessage) {
-                    // Stream is dead — fall back to sendMessage; split on failure as recovery.
+                if (stopped && !streamFinalized && sendMessage) {
+                    // Stream is dead (not from finalization) — fall back to sendMessage; split on failure as recovery.
                     try {
                         await sendMessage(text);
                     }
@@ -395,32 +510,12 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
                     }
                 }
             }
-            else if (!streamHasContent) {
-                safeEmit("(completed with tool calls only \u2014 no text response)");
+            else if (!streamHasContent && !options?.suppressEmptyStreamMessage) {
+                safeEmit("(completed with tool calls only — no text response)");
             }
         },
     };
 }
-// Per-conversation pending confirmation resolvers.
-// When a mutate tool needs confirmation, the resolver is stored here.
-// The next message from the same conversation resolves it.
-const _pendingConfirmations = new Map();
-// Confirmation response words (case-insensitive)
-const CONFIRM_WORDS = new Set(["yes", "confirm", "go", "y", "ok", "approve", "proceed"]);
-function resolvePendingConfirmation(convId, text) {
-    const resolver = _pendingConfirmations.get(convId);
-    if (!resolver)
-        return false;
-    _pendingConfirmations.delete(convId);
-    const word = text.trim().toLowerCase();
-    if (CONFIRM_WORDS.has(word)) {
-        resolver("confirmed");
-    }
-    else {
-        resolver("denied");
-    }
-    return true;
-}
 const _turnCoordinator = (0, turn_coordinator_1.createTurnCoordinator)();
 function teamsTurnKey(conversationId) {
     return `teams:${conversationId}`;
@@ -434,118 +529,233 @@ function getFriendStore() {
     const friendsPath = path.join((0, identity_1.getAgentRoot)(), "friends");
     return new store_file_1.FileFriendStore(friendsPath);
 }
+function createTeamsCommandRegistry() {
+    const registry = (0, commands_1.createCommandRegistry)();
+    (0, commands_1.registerDefaultCommands)(registry);
+    return registry;
+}
+/* v8 ignore start -- superseding follow-up slash command handler; tested via startTeamsApp integration tests @preserve */
+function handleTeamsSlashCommand(text, registry, friendId, conversationId, stream, emitResponse = true) {
+    const parsed = (0, commands_1.parseSlashCommand)(text);
+    if (!parsed)
+        return null;
+    const dispatchResult = registry.dispatch(parsed.command, { channel: "teams" });
+    if (!dispatchResult.handled || !dispatchResult.result) {
+        return null;
+    }
+    if (dispatchResult.result.action === "new") {
+        (0, context_1.deleteSession)((0, config_2.sessionPath)(friendId, "teams", conversationId));
+        if (emitResponse) {
+            stream.emit("session cleared");
+        }
+        return "new";
+    }
+    if (dispatchResult.result.action === "response") {
+        if (emitResponse) {
+            stream.emit(dispatchResult.result.message || "");
+        }
+        return "response";
+    }
+    return null;
+}
+/* v8 ignore stop */
 // Handle an incoming Teams message
-async function handleTeamsMessage(text, stream, conversationId, teamsContext, sendMessage) {
+async function handleTeamsMessage(text, stream, conversationId, teamsContext, sendMessage, reactionOverrides) {
     const turnKey = teamsTurnKey(conversationId);
     // NOTE: Confirmation resolution is handled in the app.on("message") handler
     // BEFORE the conversation lock.  By the time we get here, any pending
     // confirmation has already been resolved and the reply consumed.
     // Send first thinking phrase immediately so the user sees feedback
     // before sync I/O (session load, trim) blocks the event loop.
-    stream.update((0, phrases_1.pickPhrase)((0, phrases_1.getPhrases)().thinking) + "...");
+    // Skip for reaction signals — they should be processed quietly.
+    if (!reactionOverrides) {
+        stream.update((0, phrases_1.pickPhrase)((0, phrases_1.getPhrases)().thinking) + "...");
+    }
     await new Promise(r => setImmediate(r));
-    // Resolve context kernel (identity + channel) early so we can use the friend UUID for session path
+    // Resolve identity provider early for friend resolution + slash command session path
     const store = getFriendStore();
     const provider = teamsContext?.aadObjectId ? "aad" : "teams-conversation";
     const externalId = teamsContext?.aadObjectId || conversationId;
-    const toolContext = teamsContext ? {
+    // Build FriendResolver for the pipeline
+    const resolver = new resolver_1.FriendResolver(store, {
+        provider,
+        externalId,
+        tenantId: teamsContext?.tenantId,
+        displayName: teamsContext?.displayName || "Unknown",
+        channel: "teams",
+    });
+    // Pre-resolve friend for session path + slash commands (pipeline will re-use the cached result)
+    const resolvedContext = await resolver.resolve();
+    const friendId = resolvedContext.friend.id;
+    // ── Teams adapter concerns: controller, callbacks, session path ──────────
+    const controller = new AbortController();
+    const channelConfig = (0, config_2.getTeamsChannelConfig)();
+    const callbacks = createTeamsCallbacks(stream, controller, sendMessage, { conversationId, flushIntervalMs: channelConfig.flushIntervalMs, ...(reactionOverrides?.suppressEmptyStreamMessage ? { suppressEmptyStreamMessage: true } : {}) });
+    const traceId = (0, nerves_1.createTraceId)();
+    const sessPath = (0, config_2.sessionPath)(friendId, "teams", conversationId);
+    const teamsCapabilities = (0, channel_1.getChannelCapabilities)("teams");
+    const pendingDir = (0, pending_1.getPendingDir)((0, identity_1.getAgentName)(), friendId, "teams", conversationId);
+    // Build Teams-specific toolContext fields for injection into the pipeline
+    const teamsToolContext = teamsContext ? {
         graphToken: teamsContext.graphToken,
         adoToken: teamsContext.adoToken,
         githubToken: teamsContext.githubToken,
         signin: teamsContext.signin,
-        friendStore: store,
-        summarize: (0, core_1.createSummarize)(),
+        summarize: (0, core_1.createSummarize)("human"),
         tenantId: teamsContext.tenantId,
         botApi: teamsContext.botApi,
-    } : undefined;
-    if (toolContext) {
-        const resolver = new resolver_1.FriendResolver(store, {
-            provider,
-            externalId,
-            tenantId: teamsContext?.tenantId,
-            displayName: teamsContext?.displayName || "Unknown",
+    } : {};
+    let currentText = text;
+    const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
+    while (true) {
+        let drainedSteeringFollowUps = [];
+        // Build runAgentOptions with Teams-specific fields
+        const agentOptions = {
+            traceId,
+            toolContext: teamsToolContext,
+            mcpManager,
+            drainSteeringFollowUps: () => {
+                drainedSteeringFollowUps = _turnCoordinator.drainFollowUps(turnKey)
+                    .map(({ text: followUpText, effect }) => ({ text: followUpText, effect }));
+                return drainedSteeringFollowUps;
+            },
+            ...(reactionOverrides?.isReactionSignal ? { isReactionSignal: true } : {}),
+        };
+        // ── Call shared pipeline ──────────────────────────────────────────
+        // Capture terminal errors — failover message replaces the error card if it triggers
+        let capturedTerminalError = null;
+        const teamsFailoverState = (() => {
+            if (!teamsFailoverStates.has(conversationId)) {
+                teamsFailoverStates.set(conversationId, { pending: null });
+            }
+            return teamsFailoverStates.get(conversationId);
+        })();
+        /* v8 ignore start -- failover-aware callback wrapper: tested via pipeline integration @preserve */
+        const failoverAwareCallbacks = {
+            ...callbacks,
+            onError: (error, severity) => {
+                if (severity === "terminal" && teamsFailoverState) {
+                    capturedTerminalError = error;
+                    return;
+                }
+                callbacks.onError(error, severity);
+            },
+        };
+        /* v8 ignore stop */
+        const result = await (0, pipeline_1.handleInboundTurn)({
             channel: "teams",
-        });
-        toolContext.context = await resolver.resolve();
-    }
-    const friendId = toolContext?.context?.friend?.id || "default";
-    if (toolContext?.context?.friend) {
-        const trustGate = (0, trust_gate_1.enforceTrustGate)({
-            friend: toolContext.context.friend,
+            sessionKey: conversationId,
+            capabilities: teamsCapabilities,
+            messages: [{ role: "user", content: currentText }],
+            continuityIngressTexts: [currentText],
+            callbacks: failoverAwareCallbacks,
+            friendResolver: { resolve: () => Promise.resolve(resolvedContext) },
+            sessionLoader: {
+                loadOrCreate: async () => {
+                    const existing = (0, context_1.loadSession)(sessPath);
+                    const messages = existing?.messages && existing.messages.length > 0
+                        ? existing.messages
+                        : [{ role: "system", content: await (0, prompt_1.buildSystem)("teams", {}, resolvedContext) }];
+                    (0, core_1.repairOrphanedToolCalls)(messages);
+                    return {
+                        messages,
+                        sessionPath: sessPath,
+                        state: existing?.state,
+                        events: existing?.events,
+                    };
+                },
+            },
+            pendingDir,
+            friendStore: store,
             provider,
             externalId,
             tenantId: teamsContext?.tenantId,
-            channel: "teams",
+            isGroupChat: false,
+            groupHasFamilyMember: false,
+            hasExistingGroupWithFamily: false,
+            enforceTrustGate: trust_gate_1.enforceTrustGate,
+            drainPending: pending_1.drainPending,
+            drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)((0, identity_1.getAgentName)(), deferredFriendId),
+            runAgent: (msgs, cb, channel, sig, opts) => (0, core_1.runAgent)(msgs, cb, channel, sig, {
+                ...opts,
+                toolContext: {
+                    /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
+                    signin: async () => undefined,
+                    ...opts?.toolContext,
+                    summarize: teamsToolContext.summarize,
+                },
+            }),
+            postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
+                const prepared = (0, context_1.postTurnTrim)(turnMessages, usage, hooks);
+                (0, context_1.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
+            },
+            accumulateFriendTokens: tokens_1.accumulateFriendTokens,
+            signal: controller.signal,
+            runAgentOptions: agentOptions,
+            failoverState: teamsFailoverState,
         });
-        if (!trustGate.allowed) {
-            if (trustGate.reason === "stranger_first_reply") {
-                stream.emit(trustGate.autoReply);
-            }
-            return;
-        }
-    }
-    const registry = (0, commands_1.createCommandRegistry)();
-    (0, commands_1.registerDefaultCommands)(registry);
-    // Check for slash commands
-    const parsed = (0, commands_1.parseSlashCommand)(text);
-    if (parsed) {
-        const dispatchResult = registry.dispatch(parsed.command, { channel: "teams" });
-        if (dispatchResult.handled && dispatchResult.result) {
-            if (dispatchResult.result.action === "new") {
-                const sessPath = (0, config_2.sessionPath)(friendId, "teams", conversationId);
+        // ── Handle pipeline-intercepted commands ────────────────────────
+        if (result.turnOutcome === "command") {
+            if (result.commandAction === "new") {
                 (0, context_1.deleteSession)(sessPath);
                 stream.emit("session cleared");
-                return;
             }
-            else if (dispatchResult.result.action === "response") {
-                stream.emit(dispatchResult.result.message || "");
-                return;
+            // For "response" commands: pipeline already emitted the response via onTextChunk
+            await callbacks.flush();
+            return;
+        }
+        /* v8 ignore start -- failover display: tested via pipeline integration tests @preserve */
+        if (result.failoverMessage) {
+            stream.emit(result.failoverMessage);
+        }
+        else if (capturedTerminalError) {
+            callbacks.onError(capturedTerminalError, "terminal");
+        }
+        /* v8 ignore stop */
+        // ── Handle gate result ────────────────────────────────────────
+        if (!result.gateResult.allowed) {
+            if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
+                stream.emit(result.gateResult.autoReply);
             }
+            return;
+        }
+        // Flush any remaining accumulated text at end of turn
+        await callbacks.flush();
+        // After the agent loop, check if any tool returned AUTH_REQUIRED and trigger signin.
+        // This must happen after the stream is done so the OAuth card renders properly.
+        if (teamsContext && result.messages) {
+            const allContent = result.messages.map(m => typeof m.content === "string" ? m.content : "").join("\n");
+            if (allContent.includes("AUTH_REQUIRED:graph") && teamsContext.graphConnectionName)
+                await teamsContext.signin(teamsContext.graphConnectionName);
+            if (allContent.includes("AUTH_REQUIRED:ado") && teamsContext.adoConnectionName)
+                await teamsContext.signin(teamsContext.adoConnectionName);
+            if (allContent.includes("AUTH_REQUIRED:github") && teamsContext.githubConnectionName)
+                await teamsContext.signin(teamsContext.githubConnectionName);
+        }
+        if (result.turnOutcome !== "superseded") {
+            return;
+        }
+        const supersedingIndex = drainedSteeringFollowUps
+            .map((followUp) => followUp.effect)
+            .lastIndexOf("clear_and_supersede");
+        if (supersedingIndex < 0) {
+            return;
+        }
+        const supersedingFollowUp = drainedSteeringFollowUps[supersedingIndex];
+        const replayTail = drainedSteeringFollowUps
+            .slice(supersedingIndex + 1)
+            .map((followUp) => followUp.text.trim())
+            .filter((followUpText) => followUpText.length > 0)
+            .join("\n");
+        if (replayTail) {
+            currentText = replayTail;
+            continue;
         }
+        if (handleTeamsSlashCommand(supersedingFollowUp.text, createTeamsCommandRegistry(), friendId, conversationId, stream, false)) {
+            return;
+        }
+        currentText = supersedingFollowUp.text;
     }
-    // Load or create session
-    const sessPath = (0, config_2.sessionPath)(friendId, "teams", conversationId);
-    const existing = (0, context_1.loadSession)(sessPath);
-    const messages = existing?.messages && existing.messages.length > 0
-        ? existing.messages
-        : [{ role: "system", content: await (0, prompt_1.buildSystem)("teams", undefined, toolContext?.context) }];
-    // Repair any orphaned tool calls from a previous aborted turn
-    (0, core_1.repairOrphanedToolCalls)(messages);
-    // Push user message
-    messages.push({ role: "user", content: text });
-    // Run agent
-    const controller = new AbortController();
-    const channelConfig = (0, config_2.getTeamsChannelConfig)();
-    const callbacks = createTeamsCallbacks(stream, controller, sendMessage, { conversationId, flushIntervalMs: channelConfig.flushIntervalMs });
-    const traceId = (0, nerves_1.createTraceId)();
-    const agentOptions = {};
-    agentOptions.traceId = traceId;
-    if (toolContext)
-        agentOptions.toolContext = toolContext;
-    if (channelConfig.skipConfirmation)
-        agentOptions.skipConfirmation = true;
-    agentOptions.drainSteeringFollowUps = () => _turnCoordinator.drainFollowUps(turnKey).map((m) => ({ text: m.text }));
-    const result = await (0, core_1.runAgent)(messages, callbacks, "teams", controller.signal, agentOptions);
-    // Flush any remaining accumulated text at end of turn
-    await callbacks.flush();
-    // After the agent loop, check if any tool returned AUTH_REQUIRED and trigger signin.
-    // This must happen after the stream is done so the OAuth card renders properly.
-    if (teamsContext) {
-        const allContent = messages.map(m => typeof m.content === "string" ? m.content : "").join("\n");
-        if (allContent.includes("AUTH_REQUIRED:graph") && teamsContext.graphConnectionName)
-            await teamsContext.signin(teamsContext.graphConnectionName);
-        if (allContent.includes("AUTH_REQUIRED:ado") && teamsContext.adoConnectionName)
-            await teamsContext.signin(teamsContext.adoConnectionName);
-        if (allContent.includes("AUTH_REQUIRED:github") && teamsContext.githubConnectionName)
-            await teamsContext.signin(teamsContext.githubConnectionName);
-    }
-    // Trim context and save session
-    (0, context_1.postTurn)(messages, sessPath, result.usage);
-    // Accumulate token usage on friend record
-    if (toolContext?.context?.friend?.id) {
-        await (0, tokens_1.accumulateFriendTokens)(store, toolContext.context.friend.id, result.usage);
-    }
-    // SDK auto-closes the stream after our handler returns (app.process.js)
 }
 // Internal port for the secondary bot App (not exposed externally).
 // The primary app proxies /api/messages-secondary → localhost:SECONDARY_PORT/api/messages.
@@ -621,7 +831,7 @@ function registerBotHandlers(app, label) {
     // (graph + ado + github).  The verifyState activity only carries a `state`
     // code with no connectionName, so we try each configured connection until
     // one succeeds.
-    app.on("signin.verify-state", async (ctx) => {
+    app.on("signin.verify-state", (async (ctx) => {
         const { api, activity } = ctx;
         if (!activity.value?.state)
             return { status: 404 };
@@ -640,7 +850,73 @@ function registerBotHandlers(app, label) {
         }
         (0, runtime_1.emitNervesEvent)({ level: "warn", event: "channel.verify_state", component: "channels", message: `[${label}] verify-state failed for all connections`, meta: {} });
         return { status: 412 };
+    }));
+    // Handle Teams feedback reactions (thumbs up/down on AI-generated messages).
+    // SDK routes message/submitAction with actionName "feedback" to this event.
+    /* v8 ignore start -- Teams SDK invoke handler; requires live SDK context @preserve */
+    app.on("message.submit.feedback", async (ctx) => {
+        const { stream, activity } = ctx;
+        const reaction = activity.value?.actionValue?.reaction;
+        const comment = activity.value?.actionValue?.feedback;
+        const convId = activity.conversation?.id || "unknown";
+        const turnKey = teamsTurnKey(convId);
+        // Validate payload — graceful no-op for malformed invocations
+        if (activity.value?.actionName !== "feedback" || !reaction) {
+            return;
+        }
+        const syntheticText = buildFeedbackSyntheticText(reaction, comment);
+        // Turn coordination: if a turn is active, enqueue as steering follow-up
+        if (!_turnCoordinator.tryBeginTurn(turnKey)) {
+            _turnCoordinator.enqueueFollowUp(turnKey, {
+                conversationId: convId,
+                text: syntheticText,
+                receivedAt: Date.now(),
+                effect: (0, continuity_1.classifySteeringFollowUpEffect)(syntheticText),
+            });
+            return;
+        }
+        try {
+            const teamsContext = {
+                signin: async () => undefined,
+                aadObjectId: activity.from?.aadObjectId,
+                tenantId: activity.conversation?.tenantId,
+                displayName: activity.from?.name,
+            };
+            const ctxSend = async (t) => {
+                await ctx.send({ type: "message", text: t, replyToId: activity.replyToId, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
+            };
+            await handleTeamsMessage(syntheticText, stream, convId, teamsContext, ctxSend, { isReactionSignal: true, suppressEmptyStreamMessage: true });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.feedback_handler_error", component: "channels", message: msg.slice(0, 200), meta: {} });
+        }
+        finally {
+            _turnCoordinator.endTurn(turnKey);
+        }
+    });
+    /* v8 ignore stop */
+    // Handle bot install — send welcome Adaptive Card with prompt starters.
+    /* v8 ignore start -- Teams SDK install handler; requires live SDK context @preserve */
+    app.on("install.add", async (ctx) => {
+        try {
+            const card = buildWelcomeCard();
+            await ctx.send({
+                type: "message",
+                attachments: [{
+                        contentType: "application/vnd.microsoft.card.adaptive",
+                        content: card,
+                    }],
+                entities: aiLabelEntities(),
+                channelData: { feedbackLoopEnabled: true },
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.welcome_handler_error", component: "channels", message: msg.slice(0, 200), meta: {} });
+        }
     });
+    /* v8 ignore stop */
     app.on("message", async (ctx) => {
         const { stream, activity, api, signin } = ctx;
         const text = activity.text || "";
@@ -649,12 +925,40 @@ function registerBotHandlers(app, label) {
         const userId = activity.from?.id || "";
         const channelId = activity.channelId || "msteams";
         (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.message_received", component: "channels", message: `[${label}] incoming teams message`, meta: { userId: userId.slice(0, 12), conversationId: convId.slice(0, 20) } });
-        // Resolve pending confirmations IMMEDIATELY — before token fetches or
-        // the conversation lock.  The original message holds the lock while
-        // awaiting confirmation, so acquiring it here would deadlock.  Token
-        // fetches are also unnecessary (and slow) for a simple yes/no reply.
-        if (resolvePendingConfirmation(convId, text)) {
-            return;
+        const commandRegistry = createTeamsCommandRegistry();
+        const parsedSlashCommand = (0, commands_1.parseSlashCommand)(text);
+        if (parsedSlashCommand) {
+            const dispatchResult = commandRegistry.dispatch(parsedSlashCommand.command, { channel: "teams" });
+            if (dispatchResult.handled && dispatchResult.result) {
+                if (dispatchResult.result.action === "response") {
+                    stream.emit(dispatchResult.result.message || "");
+                    return;
+                }
+                if (dispatchResult.result.action === "new") {
+                    const commandStore = getFriendStore();
+                    const commandProvider = activity.from?.aadObjectId ? "aad" : "teams-conversation";
+                    const commandExternalId = activity.from?.aadObjectId || convId;
+                    const commandResolver = new resolver_1.FriendResolver(commandStore, {
+                        provider: commandProvider,
+                        externalId: commandExternalId,
+                        tenantId: activity.conversation?.tenantId,
+                        displayName: activity.from?.name || "Unknown",
+                        channel: "teams",
+                    });
+                    const commandContext = await commandResolver.resolve();
+                    (0, context_1.deleteSession)((0, config_2.sessionPath)(commandContext.friend.id, "teams", convId));
+                    stream.emit("session cleared");
+                    if (_turnCoordinator.isTurnActive(turnKey)) {
+                        _turnCoordinator.enqueueFollowUp(turnKey, {
+                            conversationId: convId,
+                            text,
+                            receivedAt: Date.now(),
+                            effect: "clear_and_supersede",
+                        });
+                    }
+                    return;
+                }
+            }
         }
         // If this conversation already has an active turn, steer follow-up input
         // into that turn and avoid starting a second concurrent turn.
@@ -663,6 +967,7 @@ function registerBotHandlers(app, label) {
                 conversationId: convId,
                 text,
                 receivedAt: Date.now(),
+                effect: (0, continuity_1.classifySteeringFollowUpEffect)(text),
             });
             return;
         }
@@ -720,7 +1025,7 @@ function registerBotHandlers(app, label) {
             const ctxSend = async (t) => {
                 // Use send with replyToId (not reply, which adds a blockquote).
                 // replyToId anchors the message after the user's message in Copilot Chat.
-                await ctx.send({ type: "message", text: t, replyToId: activity.id });
+                await ctx.send({ type: "message", text: t, replyToId: activity.id, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
             };
             await handleTeamsMessage(text, stream, convId, teamsContext, ctxSend);
         }
@@ -737,6 +1042,234 @@ function registerBotHandlers(app, label) {
         (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.app_error", component: "channels", message: `[${label}] ${msg}`, meta: {} });
     });
 }
+function findAadObjectId(friend) {
+    for (const ext of friend.externalIds) {
+        if (ext.provider === "aad" && !ext.externalId.startsWith("group:")) {
+            return { aadObjectId: ext.externalId, tenantId: ext.tenantId };
+        }
+    }
+    return undefined;
+}
+function resolveTeamsFriendStore(deps) {
+    return deps.store
+        ?? deps.createFriendStore?.()
+        ?? new store_file_1.FileFriendStore(path.join((0, identity_1.getAgentRoot)(), "friends"));
+}
+function getTeamsConversations(botApi) {
+    return botApi.conversations;
+}
+function hasExplicitCrossChatAuthorization(params) {
+    return params.intent === "explicit_cross_chat"
+        && types_1.TRUSTED_LEVELS.has(params.authorizingSession?.trustLevel ?? "stranger");
+}
+async function sendProactiveTeamsMessageToSession(params, deps) {
+    const store = resolveTeamsFriendStore(deps);
+    const conversations = getTeamsConversations(deps.botApi);
+    let friend;
+    try {
+        friend = await store.get(params.friendId);
+    }
+    catch {
+        friend = null;
+    }
+    if (!friend) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.teams_proactive_no_friend",
+            message: "proactive send skipped: friend not found",
+            meta: { friendId: params.friendId, sessionKey: params.sessionKey },
+        });
+        return { delivered: false, reason: "friend_not_found" };
+    }
+    if (!hasExplicitCrossChatAuthorization(params) && !types_1.TRUSTED_LEVELS.has(friend.trustLevel ?? "stranger")) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.teams_proactive_trust_skip",
+            message: "proactive send skipped: trust level not allowed",
+            meta: {
+                friendId: params.friendId,
+                trustLevel: friend.trustLevel ?? "unknown",
+                intent: params.intent ?? "generic_outreach",
+                authorizingTrustLevel: params.authorizingSession?.trustLevel ?? null,
+            },
+        });
+        return { delivered: false, reason: "trust_skip" };
+    }
+    const aadInfo = findAadObjectId(friend);
+    if (!aadInfo) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.teams_proactive_no_aad_id",
+            message: "proactive send skipped: no AAD object ID found",
+            meta: { friendId: params.friendId, sessionKey: params.sessionKey },
+        });
+        return { delivered: false, reason: "missing_target" };
+    }
+    const internalContentBlockReason = (0, proactive_content_guard_1.getProactiveInternalContentBlockReason)(params.text);
+    if (internalContentBlockReason) {
+        (0, proactive_content_guard_1.emitProactiveInternalContentBlocked)({
+            friendId: params.friendId,
+            sessionKey: params.sessionKey,
+            reason: internalContentBlockReason,
+            source: "session_send",
+        });
+        return { delivered: false, reason: "internal_content_blocked" };
+    }
+    try {
+        const conversation = await conversations.create({
+            bot: { id: deps.botApi.id },
+            members: [{ id: aadInfo.aadObjectId, role: "user", name: friend.name || aadInfo.aadObjectId }],
+            tenantId: aadInfo.tenantId,
+            isGroup: false,
+        });
+        await conversations.activities(conversation.id).create({
+            type: "message",
+            text: params.text,
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.teams_proactive_sent",
+            message: "proactive teams message sent",
+            meta: { friendId: params.friendId, aadObjectId: aadInfo.aadObjectId, sessionKey: params.sessionKey },
+        });
+        return { delivered: true };
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.teams_proactive_send_error",
+            message: "proactive teams send failed",
+            meta: {
+                friendId: params.friendId,
+                aadObjectId: aadInfo.aadObjectId,
+                sessionKey: params.sessionKey,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return { delivered: false, reason: "send_error" };
+    }
+}
+function scanPendingTeamsFiles(pendingRoot) {
+    const results = [];
+    let friendIds;
+    try {
+        friendIds = fs.readdirSync(pendingRoot);
+    }
+    catch {
+        return results;
+    }
+    for (const friendId of friendIds) {
+        const teamsDir = path.join(pendingRoot, friendId, "teams");
+        let keys;
+        try {
+            keys = fs.readdirSync(teamsDir);
+        }
+        catch {
+            continue;
+        }
+        for (const key of keys) {
+            const keyDir = path.join(teamsDir, key);
+            let files;
+            try {
+                files = fs.readdirSync(keyDir);
+            }
+            catch {
+                continue;
+            }
+            for (const file of files.filter((f) => f.endsWith(".json")).sort()) {
+                const filePath = path.join(keyDir, file);
+                try {
+                    const content = fs.readFileSync(filePath, "utf-8");
+                    results.push({ friendId, key, filePath, content });
+                }
+                catch {
+                    // skip unreadable files
+                }
+            }
+        }
+    }
+    return results;
+}
+async function drainAndSendPendingTeams(store, botApi, pendingRoot) {
+    const root = pendingRoot ?? path.join((0, identity_1.getAgentRoot)(), "state", "pending");
+    const pendingFiles = scanPendingTeamsFiles(root);
+    const result = { sent: 0, skipped: 0, failed: 0 };
+    for (const { friendId, key, filePath, content } of pendingFiles) {
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            result.failed++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        const messageText = typeof parsed.content === "string" ? parsed.content : "";
+        if (!messageText.trim()) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        const internalBlockReason = (0, proactive_content_guard_1.getProactiveInternalContentBlockReason)(messageText);
+        if (internalBlockReason) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, proactive_content_guard_1.emitProactiveInternalContentBlocked)({
+                friendId,
+                reason: internalBlockReason,
+                source: "pending_drain",
+            });
+            continue;
+        }
+        const sendResult = await sendProactiveTeamsMessageToSession({
+            friendId,
+            sessionKey: key,
+            text: messageText,
+            intent: "generic_outreach",
+        }, {
+            botApi,
+            store,
+        });
+        if (sendResult.delivered) {
+            result.sent++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        if (sendResult.reason === "friend_not_found" || sendResult.reason === "trust_skip" || sendResult.reason === "missing_target") {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        result.failed++;
+    }
+    if (result.sent > 0 || result.skipped > 0 || result.failed > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.teams_proactive_drain_complete",
+            message: "teams proactive drain complete",
+            meta: { sent: result.sent, skipped: result.skipped, failed: result.failed },
+        });
+    }
+    return result;
+}
 // Start the Teams app in DevtoolsPlugin mode (local dev) or Bot Service mode (real Teams).
 // Mode is determined by getTeamsConfig().clientId.
 // Text is always accumulated in textBuffer and flushed periodically (chunked streaming).