@ouro.bot/cli 0.1.0-alpha.9 → 0.1.0-alpha.900

package/dist/senses/teams.js

@@ -34,16 +34,24 @@ 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");
+const tools_1 = require("../repertoire/tools");
+const friends_1 = require("@ouro.bot/friends");
 const config_1 = require("../heart/config");
 const prompt_1 = require("../mind/prompt");
 const phrases_1 = require("../mind/phrases");
@@ -53,13 +61,31 @@ const context_1 = require("../mind/context");
 const commands_1 = require("./commands");
 const nerves_1 = require("../nerves");
 const runtime_1 = require("../nerves/runtime");
-const store_file_1 = require("../mind/friends/store-file");
-const resolver_1 = require("../mind/friends/resolver");
-const tokens_1 = require("../mind/friends/tokens");
+const proactive_content_guard_1 = require("./proactive-content-guard");
 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 session_transaction_1 = require("../mind/session-transaction");
+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
@@ -114,6 +140,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).
@@ -126,12 +192,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;
@@ -181,15 +251,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();
@@ -204,7 +275,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;
@@ -216,6 +287,26 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
             return false;
         }
     }
+    // Non-aborting awaitable emit — returns true on success, false on failure WITHOUT
+    // calling markStopped() / aborting the controller. Used by flushNow (speak) so a
+    // primary-stream failure followed by a successful sendMessage fallback does NOT
+    // poison the rest of the turn. tryEmit's abort-on-failure behavior is correct for
+    // end-of-turn flush() (no fallback path forward) but wrong for mid-turn speak,
+    // which has a sendMessage fallback that may still succeed. Caller (flushNow) is
+    // responsible for the `!stopped` precondition; no defensive guard here.
+    async function tryEmitNoAbort(text) {
+        try {
+            const result = stream.emit({ text, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
+            streamHasContent = true;
+            if (result && typeof result.then === "function") {
+                await result;
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     // Safely send a status update to the stream.
     // On error (e.g. 403 from Teams stop button), abort the controller.
     function safeUpdate(text) {
@@ -260,11 +351,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();
@@ -281,6 +410,7 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         }
     }
     return {
+        settleOutputMode: "final_only",
         onModelStart: () => {
             if (hadRealOutput)
                 return; // real output already shown; don't overwrite with phrases
@@ -307,25 +437,108 @@ 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();
-            const argSummary = Object.values(args).join(", ");
-            safeUpdate(`running ${name} (${argSummary})...`);
-            hadToolRun = true;
-        },
-        onToolEnd: (name, summary, success) => {
+        flushNow: async () => {
+            const trimmed = textBuffer.trim();
+            if (!trimmed)
+                return;
+            // Cancel pending periodic flush — we're delivering now.
+            stopFlushTimer();
+            // The actual speak message replaces any "thinking..." phrase cycling.
             stopPhraseRotation();
-            const msg = (0, format_1.formatToolResult)(name, summary, success);
-            safeUpdate(msg);
+            // Bypass MIN_INITIAL_CHARS threshold — speak delivers immediately.
+            firstContentEmitted = true;
+            textBuffer = "";
+            // Try the stream first via the NON-ABORTING variant; on failure, fall back
+            // to sendMessage. Critical: do NOT call markStopped() / abort the controller
+            // when only the primary stream fails — the sendMessage fallback may still
+            // deliver the speak, and a successful fallback must not poison the rest of
+            // the turn. Only abort when ALL delivery paths fail (handled below).
+            // Contract: throws if the message could not be delivered through any available path.
+            let delivered = false;
+            let lastError = null;
+            if (!stopped) {
+                const ok = await tryEmitNoAbort(trimmed);
+                if (ok)
+                    delivered = true;
+                else
+                    lastError = new Error("stream emit failed");
+            }
+            if (!delivered && sendMessage) {
+                try {
+                    await sendMessage(trimmed);
+                    delivered = true;
+                    lastError = null;
+                }
+                catch (err) {
+                    lastError = err instanceof Error ? err : new Error(String(err));
+                }
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "teams.speak_flush",
+                message: "teams flushed mid-turn speak",
+                meta: { messageLength: trimmed.length, delivered },
+            });
+            if (!delivered) {
+                // All delivery paths exhausted — now it is correct to abort the turn.
+                // markStopped() halts further stream activity and aborts the controller
+                // so the engine catches up and ends the turn cleanly.
+                markStopped();
+                throw new Error(`teams speak delivery failed: ${lastError?.message ?? "no fallback available"}`);
+            }
         },
+        ...(() => {
+            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) => {
+                    // speak is flow-control: its visible output is the message itself
+                    // (delivered via onTextChunk + flushNow). Do NOT stop phrase rotation
+                    // here, do NOT emit the \u23f3 placeholder, do NOT post a tool-activity
+                    // status update \u2014 all of those would create UI churn right before the
+                    // actual speak content arrives.
+                    if (name === "speak")
+                        return;
+                    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) => {
+                    // speak is flow-control: skip phrase-rotation stop and tool-activity end
+                    // callback (no safeUpdate for \u2713/\u2717). The flushNow call inside the engine
+                    // already emitted the actual message and stopped any rotation as part of
+                    // tryEmit's first-content-emitted flag.
+                    if (name === "speak")
+                        return;
+                    stopPhraseRotation();
+                    toolCbs.onToolEnd(name, summary, success);
+                },
+            };
+        })(),
         onKick: () => {
             stopPhraseRotation();
             const msg = (0, format_1.formatKick)();
@@ -335,7 +548,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);
             }
@@ -343,38 +560,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);
                     }
@@ -385,32 +591,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}`;
@@ -422,160 +608,330 @@ async function withConversationLock(convId, fn) {
 // are deleted while the process is alive.
 function getFriendStore() {
     const friendsPath = path.join((0, identity_1.getAgentRoot)(), "friends");
-    return new store_file_1.FileFriendStore(friendsPath);
+    return new friends_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, runtimeOverrides) {
     const turnKey = teamsTurnKey(conversationId);
+    const agentName = (0, identity_1.getAgentName)();
+    const owner = { agentName, agentRoot: (0, identity_1.getAgentRoot)(agentName) };
     // 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) + "...");
-    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 ? {
-        graphToken: teamsContext.graphToken,
-        adoToken: teamsContext.adoToken,
-        githubToken: teamsContext.githubToken,
-        signin: teamsContext.signin,
-        friendStore: store,
-        summarize: (0, core_1.createSummarize)(),
-    } : undefined;
-    if (toolContext) {
-        const resolver = new resolver_1.FriendResolver(store, {
-            provider,
-            externalId,
-            tenantId: teamsContext?.tenantId,
-            displayName: teamsContext?.displayName || "Unknown",
-            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,
-            provider,
-            externalId,
-            tenantId: teamsContext?.tenantId,
-            channel: "teams",
-        });
-        if (!trustGate.allowed) {
-            if (trustGate.reason === "stranger_first_reply") {
-                stream.emit(trustGate.autoReply);
+    // Build FriendResolver for the pipeline
+    const resolver = new friends_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, friends_1.getChannelCapabilities)("teams");
+    const pendingDir = (0, pending_1.getPendingDir)(agentName, friendId, "teams", conversationId);
+    const runWithLease = runtimeOverrides?._withSessionTurnLease ?? session_transaction_1.withSessionTurnLease;
+    try {
+        await runWithLease(sessPath, async (sessionTurnLease) => {
+            // Do not emit any activity until this turn owns the durable session.
+            if (!reactionOverrides) {
+                stream.update((0, phrases_1.pickPhrase)((0, phrases_1.getPhrases)().thinking) + "...");
+            }
+            await new Promise(r => setImmediate(r));
+            // Build Teams-specific toolContext fields for injection into the pipeline
+            const teamsToolContext = { ...owner, ...(teamsContext ? {
+                    graphToken: teamsContext.graphToken,
+                    adoToken: teamsContext.adoToken,
+                    githubToken: teamsContext.githubToken,
+                    signin: teamsContext.signin,
+                    summarize: (0, core_1.createSummarize)("human"),
+                    tenantId: teamsContext.tenantId,
+                    botApi: teamsContext.botApi,
+                } : {}) };
+            let currentText = text;
+            const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)(owner) ?? 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",
+                    sessionKey: conversationId,
+                    capabilities: teamsCapabilities,
+                    messages: [{ role: "user", content: currentText }],
+                    continuityIngressTexts: [currentText],
+                    callbacks: failoverAwareCallbacks,
+                    sessionTurnLease,
+                    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: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)("teams", {}, resolvedContext)) }];
+                            (0, core_1.repairOrphanedToolCalls)(messages);
+                            return {
+                                messages,
+                                sessionPath: sessPath,
+                                state: existing?.state,
+                                events: existing?.events,
+                                structuredOutputs: existing?.structuredOutputs,
+                            };
+                        },
+                    },
+                    pendingDir,
+                    friendStore: store,
+                    provider,
+                    externalId,
+                    tenantId: teamsContext?.tenantId,
+                    isGroupChat: false,
+                    groupHasFamilyMember: false,
+                    hasExistingGroupWithFamily: false,
+                    enforceTrustGate: trust_gate_1.enforceTrustGate,
+                    drainPending: pending_1.drainPending,
+                    drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(agentName, 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,
+                            ...owner,
+                            summarize: teamsToolContext.summarize,
+                        },
+                    }),
+                    postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
+                        const prepared = (0, context_1.postTurnTrim)(turnMessages, usage, hooks);
+                        return (0, context_1.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
+                    },
+                    accumulateFriendTokens: friends_1.accumulateFriendTokens,
+                    signal: controller.signal,
+                    runAgentOptions: agentOptions,
+                    failoverState: teamsFailoverState,
+                });
+                // ── Handle pipeline-intercepted commands ────────────────────────
+                if (result.turnOutcome === "command") {
+                    if (result.commandAction === "new") {
+                        (0, context_1.deleteSession)(sessPath);
+                        stream.emit("session cleared");
+                    }
+                    // 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;
             }
+        });
+    }
+    catch (error) {
+        if (error instanceof session_transaction_1.SessionTurnBusyError || (error instanceof Error && error.name === "SessionTurnBusyError")) {
+            stream.emit("this conversation is busy finishing another turn; please try again");
             return;
         }
+        throw error;
     }
-    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);
-                (0, context_1.deleteSession)(sessPath);
-                stream.emit("session cleared");
-                return;
-            }
-            else if (dispatchResult.result.action === "response") {
-                stream.emit(dispatchResult.result.message || "");
-                return;
-            }
+}
+// Internal port for the secondary bot App (not exposed externally).
+// The primary app proxies /api/messages-secondary → localhost:SECONDARY_PORT/api/messages.
+const SECONDARY_INTERNAL_PORT = 3979;
+// Collect all unique OAuth connection names across top-level config and tenant overrides.
+/* v8 ignore start -- runtime Teams SDK config; no unit-testable surface @preserve */
+function allOAuthConnectionNames() {
+    const oauthConfig = (0, config_1.getOAuthConfig)();
+    const names = new Set();
+    if (oauthConfig.graphConnectionName)
+        names.add(oauthConfig.graphConnectionName);
+    if (oauthConfig.adoConnectionName)
+        names.add(oauthConfig.adoConnectionName);
+    if (oauthConfig.githubConnectionName)
+        names.add(oauthConfig.githubConnectionName);
+    if (oauthConfig.tenantOverrides) {
+        for (const ov of Object.values(oauthConfig.tenantOverrides)) {
+            if (ov.graphConnectionName)
+                names.add(ov.graphConnectionName);
+            if (ov.adoConnectionName)
+                names.add(ov.adoConnectionName);
+            if (ov.githubConnectionName)
+                names.add(ov.githubConnectionName);
         }
     }
-    // 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) }];
-    // 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"))
-            await teamsContext.signin("graph");
-        if (allContent.includes("AUTH_REQUIRED:ado"))
-            await teamsContext.signin("ado");
-        if (allContent.includes("AUTH_REQUIRED:github"))
-            await teamsContext.signin("github");
-    }
-    // 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)
+    return [...names];
 }
-// 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).
-function startTeamsApp() {
+// Create an App instance from a TeamsConfig. Returns { app, mode }.
+function createBotApp(teamsConfig) {
     const mentionStripping = { activity: { mentions: { stripText: true } } };
-    const teamsConfig = (0, config_2.getTeamsConfig)();
-    let app;
-    let mode;
     const oauthConfig = (0, config_1.getOAuthConfig)();
-    if (teamsConfig.clientId) {
-        // Bot Service mode -- real Teams connection with SingleTenant credentials
-        app = new teams_apps_1.App({
-            clientId: teamsConfig.clientId,
-            clientSecret: teamsConfig.clientSecret,
-            tenantId: teamsConfig.tenantId,
-            oauth: { defaultConnectionName: oauthConfig.graphConnectionName },
-            ...mentionStripping,
-        });
-        mode = "Bot Service";
+    if (teamsConfig.clientId && teamsConfig.clientSecret) {
+        return {
+            app: new teams_apps_1.App({
+                clientId: teamsConfig.clientId,
+                clientSecret: teamsConfig.clientSecret,
+                tenantId: teamsConfig.tenantId,
+                oauth: { defaultConnectionName: oauthConfig.graphConnectionName },
+                ...mentionStripping,
+            }),
+            mode: "Bot Service (client secret)",
+        };
+    }
+    else if (teamsConfig.clientId) {
+        return {
+            app: new teams_apps_1.App({
+                clientId: teamsConfig.clientId,
+                tenantId: teamsConfig.tenantId,
+                ...(teamsConfig.managedIdentityClientId ? { managedIdentityClientId: teamsConfig.managedIdentityClientId } : {}),
+                oauth: { defaultConnectionName: oauthConfig.graphConnectionName },
+                ...mentionStripping,
+            }),
+            mode: "Bot Service (managed identity)",
+        };
     }
     else {
-        // DevtoolsPlugin mode -- local development with Teams DevtoolsPlugin UI
-        app = new teams_apps_1.App({
-            plugins: [new teams_dev_1.DevtoolsPlugin()],
-            ...mentionStripping,
-        });
-        mode = "DevtoolsPlugin";
+        return {
+            app: new teams_apps_1.App({
+                plugins: [new teams_dev_1.DevtoolsPlugin()],
+                ...mentionStripping,
+            }),
+            mode: "DevtoolsPlugin",
+        };
     }
+}
+/* v8 ignore stop */
+// Register message, verify-state, and error handlers on an App instance.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function registerBotHandlers(app, label) {
+    const connectionNames = allOAuthConnectionNames();
     // Override default OAuth verify-state handler.  The SDK's built-in handler
     // uses a single defaultConnectionName, which breaks multi-connection setups
     // (graph + ado + github).  The verifyState activity only carries a `state`
     // code with no connectionName, so we try each configured connection until
     // one succeeds.
-    const allConnectionNames = [
-        oauthConfig.graphConnectionName,
-        oauthConfig.adoConnectionName,
-        oauthConfig.githubConnectionName,
-    ].filter(Boolean);
-    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 };
-        for (const cn of allConnectionNames) {
+        for (const cn of connectionNames) {
             try {
                 await api.users.token.get({
                     channelId: activity.channelId,
@@ -583,14 +939,82 @@ function startTeamsApp() {
                     connectionName: cn,
                     code: activity.value.state,
                 });
-                (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.verify_state", component: "channels", message: `verify-state succeeded for connection "${cn}"`, meta: { connectionName: cn } });
+                (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.verify_state", component: "channels", message: `[${label}] verify-state succeeded for connection "${cn}"`, meta: { connectionName: cn } });
                 return { status: 200 };
             }
             catch { /* try next */ }
         }
-        (0, runtime_1.emitNervesEvent)({ level: "warn", event: "channel.verify_state", component: "channels", message: "verify-state failed for all connections", meta: {} });
+        (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 undefined;
+        }
+        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 undefined;
+        }
+        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);
+        }
+        return undefined;
+    });
+    /* 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: {} });
+        }
+        return undefined;
     });
+    /* v8 ignore stop */
     app.on("message", async (ctx) => {
         const { stream, activity, api, signin } = ctx;
         const text = activity.text || "";
@@ -598,17 +1022,41 @@ function startTeamsApp() {
         const turnKey = teamsTurnKey(convId);
         const userId = activity.from?.id || "";
         const channelId = activity.channelId || "msteams";
-        (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.message_received", component: "channels", message: "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)) {
-            // Don't emit on this stream — the original message's stream is still
-            // active.  Opening a second streaming response in the same conversation
-            // can corrupt the first.  The original stream will show tool progress
-            // once the confirmation Promise resolves.
-            return;
+        (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) } });
+        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 friends_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.
@@ -617,31 +1065,35 @@ function startTeamsApp() {
                 conversationId: convId,
                 text,
                 receivedAt: Date.now(),
+                effect: (0, continuity_1.classifySteeringFollowUpEffect)(text),
             });
             return;
         }
         try {
+            // Resolve OAuth connection names for this user's tenant (supports per-tenant overrides).
+            const tenantId = activity.conversation?.tenantId;
+            const tenantOAuth = (0, config_1.resolveOAuthForTenant)(tenantId);
             // Fetch tokens for both OAuth connections independently.
             // Failures are silently caught -- the tool handler will request signin if needed.
             let graphToken;
             let adoToken;
             let githubToken;
             try {
-                const graphRes = await api.users.token.get({ userId, connectionName: oauthConfig.graphConnectionName, channelId });
+                const graphRes = await api.users.token.get({ userId, connectionName: tenantOAuth.graphConnectionName, channelId });
                 graphToken = graphRes?.token;
             }
             catch { /* no token yet — tool handler will trigger signin */ }
             try {
-                const adoRes = await api.users.token.get({ userId, connectionName: oauthConfig.adoConnectionName, channelId });
+                const adoRes = await api.users.token.get({ userId, connectionName: tenantOAuth.adoConnectionName, channelId });
                 adoToken = adoRes?.token;
             }
             catch { /* no token yet — tool handler will trigger signin */ }
             try {
-                const githubRes = await api.users.token.get({ userId, connectionName: oauthConfig.githubConnectionName, channelId });
+                const githubRes = await api.users.token.get({ userId, connectionName: tenantOAuth.githubConnectionName, channelId });
                 githubToken = githubRes?.token;
             }
             catch { /* no token yet — tool handler will trigger signin */ }
-            (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.token_status", component: "channels", message: "oauth token availability", meta: { graph: !!graphToken, ado: !!adoToken, github: !!githubToken } });
+            (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.token_status", component: "channels", message: "oauth token availability", meta: { graph: !!graphToken, ado: !!adoToken, github: !!githubToken, tenantId } });
             const teamsContext = {
                 graphToken,
                 adoToken,
@@ -661,12 +1113,17 @@ function startTeamsApp() {
                 aadObjectId: activity.from?.aadObjectId,
                 tenantId: activity.conversation?.tenantId,
                 displayName: activity.from?.name,
+                graphConnectionName: tenantOAuth.graphConnectionName,
+                adoConnectionName: tenantOAuth.adoConnectionName,
+                githubConnectionName: tenantOAuth.githubConnectionName,
+                /* v8 ignore next -- bot API availability branch; requires live SDK context @preserve */
+                botApi: app.id && api ? { id: app.id, conversations: api.conversations } : undefined,
             };
             /* v8 ignore next 5 -- bot-framework integration callback; tested via handleTeamsMessage sendMessage path @preserve */
             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);
         }
@@ -678,6 +1135,251 @@ function startTeamsApp() {
             _turnCoordinator.endTurn(turnKey);
         }
     });
+    app.event("error", ({ error }) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        (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 friends_1.FileFriendStore(path.join((0, identity_1.getAgentRoot)(), "friends"));
+}
+function getTeamsConversations(botApi) {
+    return botApi.conversations;
+}
+function hasExplicitCrossChatAuthorization(params) {
+    return params.intent === "explicit_cross_chat"
+        && friends_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) && !friends_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).
+//
+// Dual-bot support: if teamsSecondary is configured with a clientId, a second App
+// instance starts on an internal port and the primary app proxies requests from
+// /api/messages-secondary to it. This lets a single App Service serve two bot
+// registrations (e.g. one per tenant) without SDK modifications.
+function startTeamsApp() {
+    const teamsConfig = (0, config_2.getTeamsConfig)();
+    const { app, mode } = createBotApp(teamsConfig);
+    registerBotHandlers(app, "primary");
     if (!process.listeners("unhandledRejection").some((l) => l.__agentHandler)) {
         const handler = (err) => {
             const msg = err instanceof Error ? err.message : String(err);
@@ -686,11 +1388,54 @@ function startTeamsApp() {
         handler.__agentHandler = true;
         process.on("unhandledRejection", handler);
     }
-    app.event("error", ({ error }) => {
-        const msg = error instanceof Error ? error.message : String(error);
-        (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.app_error", component: "channels", message: msg, meta: {} });
-    });
-    const port = (0, config_2.getTeamsChannelConfig)().port;
+    /* v8 ignore next -- PORT env branch; runtime-only @preserve */
+    const port = process.env.PORT ? Number(process.env.PORT) : (0, config_2.getTeamsChannelConfig)().port;
     app.start(port);
-    (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.app_started", component: "channels", message: `Teams bot started on port ${port} with ${mode} (chunked streaming)`, meta: { port, mode } });
+    // Diagnostic: log tool count at startup to verify deploy
+    const startupTools = (0, tools_1.getToolsForChannel)((0, friends_1.getChannelCapabilities)("teams"));
+    const toolNames = startupTools.map((t) => t.function.name);
+    (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.app_started", component: "channels", message: `Teams bot started on port ${port} with ${mode} (chunked streaming)`, meta: { port, mode, toolCount: toolNames.length, hasProactive: toolNames.includes("teams_send_message") } });
+    // --- Secondary bot (dual-bot support) ---
+    // If teamsSecondary has a clientId, start a second App on an internal port
+    // and proxy /api/messages-secondary on the primary app to it.
+    /* v8 ignore start -- dual-bot proxy wiring; requires live Teams SDK + HTTP @preserve */
+    const secondaryConfig = (0, config_1.getTeamsSecondaryConfig)();
+    if (secondaryConfig.clientId) {
+        const { app: secondaryApp, mode: secondaryMode } = createBotApp(secondaryConfig);
+        registerBotHandlers(secondaryApp, "secondary");
+        secondaryApp.start(SECONDARY_INTERNAL_PORT);
+        (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.app_started", component: "channels", message: `Secondary bot started on internal port ${SECONDARY_INTERNAL_PORT} with ${secondaryMode}`, meta: { port: SECONDARY_INTERNAL_PORT, mode: secondaryMode } });
+        // Proxy: forward /api/messages-secondary on the primary app's Express
+        // to localhost:SECONDARY_INTERNAL_PORT/api/messages.
+        // The SDK's HttpPlugin exposes .post() bound to its Express instance.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const httpPlugin = app.http;
+        httpPlugin.post("/api/messages-secondary", (req, res) => {
+            const body = JSON.stringify(req.body);
+            const proxyReq = http.request({
+                hostname: "127.0.0.1",
+                port: SECONDARY_INTERNAL_PORT,
+                path: "/api/messages",
+                method: "POST",
+                headers: {
+                    ...req.headers,
+                    "content-length": Buffer.byteLength(body).toString(),
+                },
+            }, (proxyRes) => {
+                res.writeHead(proxyRes.statusCode ?? 200, proxyRes.headers);
+                proxyRes.pipe(res);
+            });
+            proxyReq.on("error", (err) => {
+                (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.proxy_error", component: "channels", message: `secondary proxy error: ${err.message}`, meta: {} });
+                if (!res.headersSent) {
+                    res.writeHead(502);
+                    res.end("Bad Gateway");
+                }
+            });
+            proxyReq.write(body);
+            proxyReq.end();
+        });
+        (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.proxy_ready", component: "channels", message: "proxy /api/messages-secondary → secondary bot ready", meta: {} });
+    }
+    /* v8 ignore stop */
 }