@ouro.bot/cli 0.1.0-alpha.94 → 0.1.0-alpha.941

package/dist/senses/teams.js

@@ -34,12 +34,17 @@ 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.reasoningStatus = reasoningStatus;
 exports.withConversationLock = withConversationLock;
 exports.handleTeamsMessage = handleTeamsMessage;
+exports.createTeamsSdkLogger = createTeamsSdkLogger;
 exports.sendProactiveTeamsMessageToSession = sendProactiveTeamsMessageToSession;
 exports.drainAndSendPendingTeams = drainAndSendPendingTeams;
 exports.startTeamsApp = startTeamsApp;
@@ -48,7 +53,7 @@ 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 channel_1 = require("../mind/friends/channel");
+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");
@@ -58,20 +63,34 @@ 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 types_1 = require("../mind/friends/types");
-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 node_crypto_1 = require("node:crypto");
 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");
+const teams_image_1 = require("./teams-image");
+const feedback_reply_1 = require("./shepherd/feedback-reply");
+// 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
@@ -126,6 +145,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).
@@ -137,25 +196,49 @@ function splitMessage(text, maxLen) {
 // safeSend (ctx.send). Tool results, kicks, and errors use safeUpdate
 // (transient status) or safeSend (terminal errors). Reasoning is accumulated
 // and periodically pushed via safeUpdate on the same flush timer tick.
+function isTeamsSizeRejection(error) {
+    return typeof error === "object" && error !== null && "response" in error
+        && typeof error.response === "object" && error.response !== null && "status" in error.response
+        && error.response.status === 413;
+}
 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;
     const flushInterval = options?.flushIntervalMs ?? exports.DEFAULT_FLUSH_INTERVAL_MS;
+    // The SDK merges every chunk's entities into the final message, and Teams rejects a final
+    // message with more than one root message entity (400 BadSyntax), so only the first chunk
+    // carries the AI label.
+    let aiLabelAttached = false;
+    function streamChunk(text) {
+        if (aiLabelAttached)
+            return { type: "message", text, channelData: { feedbackLoopEnabled: true } };
+        aiLabelAttached = true;
+        return { type: "message", text, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } };
+    }
     // Track whether reasoning has changed since last flush (avoid redundant updates).
     let lastFlushedReasoningLen = 0;
+    let lastReasoningStatus = "";
     // Periodic tick: flush text buffer and push reasoning updates.
     function flushTick() {
         flushTextBuffer();
         if (reasoningBuf.length > lastFlushedReasoningLen) {
-            safeUpdate(reasoningBuf);
             lastFlushedReasoningLen = reasoningBuf.length;
+            const status = reasoningStatus(reasoningBuf);
+            if (status && status !== lastReasoningStatus) {
+                lastReasoningStatus = status;
+                safeUpdate(status);
+            }
         }
     }
     // Start the periodic flush timer. Idempotent -- no-op if already running.
@@ -172,9 +255,16 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         }
     }
     // Mark stream as broken and abort the agent loop.
-    function markStopped() {
+    function markStopped(where, err) {
         if (stopped)
             return;
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "teams.stream_stopped",
+            message: `teams stream stopped at ${where}`,
+            meta: { where, error: err instanceof Error ? err.message : err === undefined ? null : String(err), conversationId: options?.conversationId ?? null },
+        });
         stopped = true;
         stopPhraseRotation();
         stopFlushTimer();
@@ -190,21 +280,22 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
     // catch its rejection so we detect a dead stream and abort the agent loop.
     function catchAsync(result) {
         if (result && typeof result.catch === "function") {
-            result.catch(() => markStopped());
+            result.catch((err) => markStopped("stream-async", err));
         }
     }
-    // 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(streamChunk(text)));
             streamHasContent = true;
+            totalEmitted += text.length;
         }
-        catch {
-            markStopped();
+        catch (err) {
+            markStopped("safeEmit", err);
         }
     }
     // Awaitable emit — returns true if the emit succeeded, false if it failed.
@@ -213,18 +304,48 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         /* v8 ignore next -- defensive guard: stopped set by prior error; tested via flush abort path @preserve */
         if (stopped)
             return false;
+        let awaitingTransport = false;
         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(streamChunk(text));
             streamHasContent = true;
             if (result && typeof result.then === "function") {
+                awaitingTransport = true;
                 await result;
             }
             return true;
         }
-        catch {
-            markStopped();
+        catch (err) {
+            markStopped("tryEmit", err);
+            if (awaitingTransport && !isTeamsSizeRejection(err))
+                throw err;
+            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) {
+        let awaitingTransport = false;
+        try {
+            const result = stream.emit(streamChunk(text));
+            streamHasContent = true;
+            if (result && typeof result.then === "function") {
+                awaitingTransport = true;
+                await result;
+            }
+            return true;
+        }
+        catch (error) {
+            if (awaitingTransport && !isTeamsSizeRejection(error)) {
+                markStopped("speak-unknown", error);
+                throw error;
+            }
             return false;
         }
     }
@@ -236,8 +357,8 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         try {
             catchAsync(stream.update(text));
         }
-        catch {
-            markStopped();
+        catch (err) {
+            markStopped("safeUpdate", err);
         }
     }
     // Safely send a separate message via sendMessage (for content after first emit).
@@ -252,11 +373,11 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
             // Chain is idle -- start the send synchronously and mark busy
             sendChainBusy = true;
             try {
-                sendChain = sendMessage(text).catch(() => markStopped()).finally(() => { sendChainBusy = false; });
+                sendChain = sendMessage(text).catch((err) => markStopped("send", err)).finally(() => { sendChainBusy = false; });
             }
-            catch {
+            catch (err) {
                 sendChainBusy = false;
-                markStopped();
+                markStopped("send", err);
             }
         }
         else {
@@ -265,18 +386,56 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
                 if (stopped)
                     return;
                 return sendMessage(text);
-            }).catch(() => markStopped());
+            }).catch((err) => markStopped("send-queued", err));
         }
     }
     // Flush accumulated text buffer via safeEmit. The Teams SDK accumulates
     // 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();
@@ -293,6 +452,7 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         }
     }
     return {
+        settleOutputMode: "final_only",
         onModelStart: () => {
             if (hadRealOutput)
                 return; // real output already shown; don't overwrite with phrases
@@ -311,48 +471,112 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
             /* v8 ignore next -- defensive guard: stopped set by prior error @preserve */
             if (stopped)
                 return;
-            stopPhraseRotation();
-            hadRealOutput = true;
             reasoningBuf += text;
+            // Keep the friendly phrases until a reasoning heading can replace them.
+            if (reasoningStatus(reasoningBuf)) {
+                stopPhraseRotation();
+                hadRealOutput = true;
+            }
             startFlushTimer();
         },
         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((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-                scope: "shared-work",
-                phase: "processing",
-                objective: `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((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-                scope: "shared-work",
-                phase: "processing",
-                objective: 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("speak", lastError);
+                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 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();
+                    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)();
@@ -374,78 +598,135 @@ 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();
+                        markStopped("flush");
                 }
-                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);
                     }
-                    catch {
+                    catch (error) {
+                        // A lost acknowledgement is not a rejection. Only a definite size rejection permits a smaller retry.
+                        if (!isTeamsSizeRejection(error) || text.length <= RECOVERY_CHUNK_SIZE)
+                            throw error;
                         const chunks = splitMessage(text, RECOVERY_CHUNK_SIZE);
                         for (const chunk of chunks)
                             await sendMessage(chunk);
                     }
                 }
             }
-            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)");
             }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "teams.flush_done",
+                message: "teams end-of-turn flush finished",
+                meta: { stopped, streamHasContent, streamFinalized, conversationId: options?.conversationId ?? null },
+            });
         },
     };
 }
-// 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;
+// The status bubble shows the latest reasoning heading (models write "**Heading**"
+// before each reasoning step), never the raw reasoning text itself.
+function reasoningStatus(reasoning) {
+    const headings = [...reasoning.matchAll(/\*\*([^*\n]+)\*\*/g)];
+    const last = headings.at(-1)?.[1]?.trim();
+    return last ? `${last}…` : null;
 }
 const _turnCoordinator = (0, turn_coordinator_1.createTurnCoordinator)();
 function teamsTurnKey(conversationId) {
     return `teams:${conversationId}`;
 }
+function teamsAdmissionKey(conversationId) {
+    return `teams-admission:${conversationId}`;
+}
+const queuedTeamsTurns = new Map();
+const activeTeamsActors = new Map();
+const consumingTeamsSteering = new Set();
+function drainTeamsSteering(key) {
+    const followUps = _turnCoordinator.drainFollowUps(key);
+    const consumed = new Set(followUps);
+    const queue = queuedTeamsTurns.get(key);
+    if (queue)
+        queuedTeamsTurns.set(key, queue.filter(turn => !turn.steering || !consumed.has(turn.steering)));
+    return followUps;
+}
+/** Context-bearing replies cannot steer an already-running tool loop. Keep the
+ * original SDK context/transport alive until a fresh handleTeamsMessage lease.
+ * Ordinary same-actor steering still uses the existing coordinator buffer. */
+async function coordinateTeamsTurn(conversationId, text, identity, run) {
+    const key = teamsTurnKey(conversationId);
+    const actorKey = JSON.stringify([identity.aadObjectId || identity.userId || "", identity.tenantId ?? ""]);
+    if (!_turnCoordinator.tryBeginTurn(key)) {
+        if (!identity.replyToId && !/\bfeedback:/i.test(text) && consumingTeamsSteering.has(key) &&
+            activeTeamsActors.get(key) === actorKey && !queuedTeamsTurns.get(key)?.some(turn => !turn.steering)) {
+            const steering = { conversationId, text, receivedAt: Date.now(), effect: (0, continuity_1.classifySteeringFollowUpEffect)(text) };
+            _turnCoordinator.enqueueFollowUp(key, steering);
+            const queue = queuedTeamsTurns.get(key) ?? [];
+            queue.push({ actorKey, run, steering, resolve: () => { }, reject: () => { } });
+            queuedTeamsTurns.set(key, queue);
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            const queue = queuedTeamsTurns.get(key) ?? [];
+            queue.push({ actorKey, run, resolve, reject });
+            queuedTeamsTurns.set(key, queue);
+        });
+        return;
+    }
+    let next = { actorKey, run, resolve: () => { }, reject: () => { } };
+    let initialError;
+    let first = true;
+    try {
+        while (next) {
+            activeTeamsActors.set(key, next.actorKey);
+            if (next.steering) {
+                for (const followUp of _turnCoordinator.drainFollowUps(key)) {
+                    if (followUp !== next.steering)
+                        _turnCoordinator.enqueueFollowUp(key, followUp);
+                }
+            }
+            try {
+                await next.run();
+                next.resolve();
+            }
+            catch (error) {
+                if (first)
+                    initialError = error;
+                next.reject(error);
+            }
+            first = false;
+            // Preserve received order while identity/admission I/O finishes, without holding admission through a model turn.
+            await _turnCoordinator.withTurnLock(teamsAdmissionKey(conversationId), async () => { });
+            next = queuedTeamsTurns.get(key)?.shift();
+        }
+    }
+    finally {
+        queuedTeamsTurns.delete(key);
+        activeTeamsActors.delete(key);
+        _turnCoordinator.endTurn(key);
+    }
+    if (initialError !== undefined)
+        throw initialError;
+}
 async function withConversationLock(convId, fn) {
     await _turnCoordinator.withTurnLock(teamsTurnKey(convId), fn);
 }
@@ -453,13 +734,22 @@ 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 reportTeamsRequest(stage, conversationId, context, details = {}) {
+    if (!context?.inboundActivityId)
+        return;
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels", event: "channel.teams_request_stage", message: "Teams conversational request stage",
+        meta: { stage, inboundActivityId: context.inboundActivityId, conversationId, tenantId: context.tenantId, botId: context.botApi?.id, ...details },
+    });
 }
 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)
@@ -483,22 +773,21 @@ function handleTeamsSlashCommand(text, registry, friendId, conversationId, strea
     }
     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 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;
     // Build FriendResolver for the pipeline
-    const resolver = new resolver_1.FriendResolver(store, {
+    const resolver = new friends_1.FriendResolver(store, {
         provider,
         externalId,
         tenantId: teamsContext?.tenantId,
@@ -508,133 +797,245 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
     // 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;
-    const registry = createTeamsCommandRegistry();
-    // Check for slash commands (before pipeline -- these are transport-level concerns)
-    if (handleTeamsSlashCommand(text, registry, friendId, conversationId, stream)) {
-        return;
-    }
     // ── 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 });
     const traceId = (0, nerves_1.createTraceId)();
+    const observedStream = {
+        emit(activity) {
+            const result = stream.emit(activity);
+            reportTeamsRequest("reply_emitted", conversationId, teamsContext, { traceId, delivery: "unconfirmed_stream" });
+            return result;
+        },
+        update(text) { return stream.update(text); },
+        close: stream.close.bind(stream),
+    };
+    const callbacks = createTeamsCallbacks(observedStream, controller, sendMessage, { conversationId, flushIntervalMs: channelConfig.flushIntervalMs, ...(reactionOverrides?.suppressEmptyStreamMessage ? { suppressEmptyStreamMessage: true } : {}) });
     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,
-        summarize: (0, core_1.createSummarize)(),
-        tenantId: teamsContext.tenantId,
-        botApi: teamsContext.botApi,
-    } : {};
-    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;
-            },
-        };
-        if (channelConfig.skipConfirmation)
-            agentOptions.skipConfirmation = true;
-        // ── Call shared pipeline ──────────────────────────────────────────
-        const result = await (0, pipeline_1.handleInboundTurn)({
-            channel: "teams",
-            sessionKey: conversationId,
-            capabilities: teamsCapabilities,
-            messages: [{ role: "user", content: currentText }],
-            continuityIngressTexts: [currentText],
-            callbacks,
-            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", { mcpManager }, resolvedContext) }];
-                    (0, core_1.repairOrphanedToolCalls)(messages);
-                    return { messages, sessionPath: sessPath, state: existing?.state };
-                },
-            },
-            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)((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: context_1.postTurn,
-            accumulateFriendTokens: tokens_1.accumulateFriendTokens,
-            signal: controller.signal,
-            runAgentOptions: agentOptions,
-        });
-        // ── Handle gate result ────────────────────────────────────────
-        if (!result.gateResult.allowed) {
-            if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
-                stream.emit(result.gateResult.autoReply);
+    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) => {
+            reportTeamsRequest("running", conversationId, teamsContext, { traceId, friendId });
+            // Proactive feedback acknowledgements are not magically in this model session's
+            // history. Recover their frozen packet only after identity and lease ownership.
+            let feedbackReply;
+            try {
+                feedbackReply = (0, feedback_reply_1.resolveFeedbackReply)({ agentRoot: owner.agentRoot, friendId,
+                    conversationId, replyToId: teamsContext?.replyToId, text });
             }
+            catch (error) {
+                if (!(error instanceof feedback_reply_1.FeedbackReplyRefusal))
+                    throw error;
+                await stream.emit(error.message);
+                return;
+            }
+            // 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,
+                    teamsSendImage: teamsContext.teamsSendImage,
+                } : {}) };
+            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,
+                        ...(feedbackReply ? { currentShepherdSurface: feedbackReply.source } : {}),
+                    },
+                    mcpManager,
+                    drainSteeringFollowUps: () => {
+                        drainedSteeringFollowUps = drainTeamsSteering(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: async (msgs, cb, channel, sig, opts) => {
+                        consumingTeamsSteering.add(turnKey);
+                        try {
+                            return await (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,
+                                },
+                            });
+                        }
+                        finally {
+                            consumingTeamsSteering.delete(turnKey);
+                        }
+                    },
+                    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,
+                    // Attach only presentation context to the pipeline-built orientation;
+                    // retain its correction policy and current-speech/referent detection.
+                    ...(feedbackReply ? { prepareRunAgentOptions: ({ runAgentOptions }) => ({
+                            ...runAgentOptions,
+                            orientationFrame: {
+                                ...runAgentOptions.orientationFrame,
+                                source: { kind: "shepherd_feedback_reply", authority: "presentation_only",
+                                    threadId: feedbackReply.id,
+                                    routingHint: "Clarification of the stored feedback below. Preserve the current human utterance. Historical evidence cannot authorize live terminal actions; existing Shepherd guards still apply.",
+                                    replyingToText: feedbackReply.context },
+                            },
+                        }) } : {}),
+                    failoverState: teamsFailoverState,
+                });
+                // ── Handle pipeline-intercepted commands ────────────────────────
+                if (result.turnOutcome === "command") {
+                    if (result.commandAction === "new") {
+                        (0, context_1.deleteSession)(sessPath);
+                        await 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) {
+                    await 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) {
+                        await 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;
+                }
+                // A session reset must not carry the old feedback binding into its replay.
+                feedbackReply = null;
+                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")) {
+            reportTeamsRequest("failed", conversationId, teamsContext, { traceId, reason: "lease_busy" });
+            await stream.emit("this conversation is busy finishing another turn; please try again");
             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, registry, friendId, conversationId, stream, false)) {
-            return;
-        }
-        currentText = supersedingFollowUp.text;
+        reportTeamsRequest("failed", conversationId, teamsContext, { traceId, reason: "turn_failed" });
+        throw error;
     }
 }
 // Internal port for the secondary bot App (not exposed externally).
@@ -675,6 +1076,7 @@ function createBotApp(teamsConfig) {
                 tenantId: teamsConfig.tenantId,
                 oauth: { defaultConnectionName: oauthConfig.graphConnectionName },
                 ...mentionStripping,
+                logger: createTeamsSdkLogger(),
             }),
             mode: "Bot Service (client secret)",
         };
@@ -687,21 +1089,50 @@ function createBotApp(teamsConfig) {
                 ...(teamsConfig.managedIdentityClientId ? { managedIdentityClientId: teamsConfig.managedIdentityClientId } : {}),
                 oauth: { defaultConnectionName: oauthConfig.graphConnectionName },
                 ...mentionStripping,
+                logger: createTeamsSdkLogger(),
             }),
             mode: "Bot Service (managed identity)",
         };
     }
     else {
+        // With no credentials the Teams SDK validates no sender, so anyone who can reach the port can
+        // talk to the agent. That is only acceptable when a developer asks for it on their own machine.
+        if (process.env.OURO_TEAMS_DEVTOOLS !== "1") {
+            throw new Error("Teams bot credentials are missing (teams.clientId), so the Teams sense will not start: without them it would accept messages from anyone. Run `ouro connect teams`, or set OURO_TEAMS_DEVTOOLS=1 for local development with no real bot.");
+        }
         return {
             app: new teams_apps_1.App({
                 plugins: [new teams_dev_1.DevtoolsPlugin()],
                 ...mentionStripping,
+                logger: createTeamsSdkLogger(),
             }),
             mode: "DevtoolsPlugin",
         };
     }
 }
-/* v8 ignore stop */
+function createTeamsSdkLogger(name = "teams-sdk") {
+    const verbose = /stream/i.test(name);
+    const write = (level, msg) => {
+        if ((level === "debug" || level === "trace" || level === "info") && !verbose)
+            return;
+        (0, runtime_1.emitNervesEvent)({
+            level: level === "error" ? "error" : level === "warn" ? "warn" : "info",
+            component: "senses",
+            event: "teams.sdk_log",
+            message: `[${name}] ${msg.map((m) => (m instanceof Error ? m.message : typeof m === "string" ? m : JSON.stringify(m))).join(" ").slice(0, 300)}`,
+            meta: { logger: name, sdkLevel: level },
+        });
+    };
+    return {
+        debug: (...m) => write("debug", m),
+        info: (...m) => write("info", m),
+        warn: (...m) => write("warn", m),
+        error: (...m) => write("error", m),
+        trace: (...m) => write("trace", m),
+        log: (level, ...m) => write(level, m),
+        child: (child) => createTeamsSdkLogger(`${name}/${child}`),
+    };
+}
 // Register message, verify-state, and error handlers on an App instance.
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function registerBotHandlers(app, label) {
@@ -711,7 +1142,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 };
@@ -730,137 +1161,256 @@ 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";
+        // Validate payload — graceful no-op for malformed invocations
+        if (activity.value?.actionName !== "feedback" || !reaction) {
+            return undefined;
+        }
+        const syntheticText = buildFeedbackSyntheticText(reaction, comment);
+        await coordinateTeamsTurn(convId, syntheticText, {
+            aadObjectId: activity.from?.aadObjectId, userId: activity.from?.id,
+            tenantId: activity.conversation?.tenantId, replyToId: activity.replyToId,
+        }, async () => {
+            try {
+                const teamsContext = {
+                    replyToId: activity.replyToId,
+                    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: {} });
+            }
+        });
+        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 { activity, api, signin } = ctx;
         const text = activity.text || "";
         const convId = activity.conversation?.id || "unknown";
         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: `[${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;
+        const requestContext = {
+            inboundActivityId: activity.id, tenantId: activity.conversation?.tenantId,
+            botApi: app.id && api ? { id: app.id, conversations: api.conversations } : undefined,
+        };
+        const sendText = async (text) => {
+            try {
+                const receipt = await ctx.send({ type: "message", text, replyToId: activity.id, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
+                const messageId = receipt && typeof receipt === "object" && "id" in receipt && typeof receipt.id === "string" ? receipt.id : undefined;
+                reportTeamsRequest(messageId ? "replied" : "reply_emitted", convId, requestContext, { delivery: messageId ? "accepted" : "unconfirmed", ...(messageId ? { outboundActivityId: messageId } : {}) });
+            }
+            catch (error) {
+                reportTeamsRequest("failed", convId, requestContext, { reason: "send_unknown" });
+                throw error;
+            }
+        };
+        // HttpStream queues void emits and retries unknown HTTP failures internally.
+        // Use the SDK's single-attempt, awaitable send instead of that hidden retry loop.
+        const stream = {
+            emit: value => sendText(typeof value === "string" ? value : value.text),
+            update: async () => {
+                try {
+                    await ctx.send({ type: "typing" });
                 }
-                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,
+                catch (error) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn", component: "channels", event: "channel.teams_typing_failed",
+                        message: "Teams rejected an advisory typing update; the reply is still pending",
+                        meta: { conversationId: convId, inboundActivityId: activity.id,
+                            error: error instanceof Error ? error.message : String(error) },
+                    });
+                }
+            },
+            close: async () => undefined,
+        };
+        (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.message_received", component: "channels", message: `[${label}] incoming teams message`, meta: { stage: "received", inboundActivityId: activity.id, botId: app.id, tenantId: requestContext.tenantId, userId: userId.slice(0, 12), conversationId: convId } });
+        let work;
+        await _turnCoordinator.withTurnLock(teamsAdmissionKey(convId), async () => {
+            try {
+                if (process.env.OURO_TEAMS_DEVTOOLS !== "1" && [
+                    app.id, activity.id, activity.channelId, activity.conversation?.id,
+                    activity.conversation?.tenantId, activity.from?.aadObjectId || activity.from?.id,
+                ].some(value => typeof value !== "string" || !value.trim())) {
+                    throw new session_transaction_1.SessionTransactionError("Teams activity identity is incomplete");
+                }
+                if (activity.id) {
+                    const store = getFriendStore();
+                    const identity = await new friends_1.FriendResolver(store, {
+                        provider: activity.from?.aadObjectId ? "aad" : "teams-conversation",
+                        externalId: activity.from?.aadObjectId || convId,
                         tenantId: activity.conversation?.tenantId,
                         displayName: activity.from?.name || "Unknown",
                         channel: "teams",
+                    }).resolve();
+                    const admission = (0, session_transaction_1.admitSessionActivity)((0, config_2.sessionPath)(identity.friend.id, "teams", convId), {
+                        namespace: JSON.stringify(["teams.message", channelId, app.id?.toLowerCase() ?? null,
+                            activity.conversation?.tenantId?.toLowerCase() ?? null,
+                            activity.from?.aadObjectId?.toLowerCase() || userId, convId]),
+                        activityId: activity.id,
+                        payloadDigest: (0, node_crypto_1.createHash)("sha256").update(JSON.stringify([text, activity.replyToId ?? null])).digest("hex"),
                     });
-                    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",
-                        });
+                    if (admission.state === "duplicate") {
+                        reportTeamsRequest("duplicate_held", convId, requestContext, { receiptId: admission.receiptId, outcome: "not_replayed" });
+                        return;
                     }
-                    return;
                 }
+                reportTeamsRequest("admitted", convId, requestContext);
             }
-        }
-        // If this conversation already has an active turn, steer follow-up input
-        // into that turn and avoid starting a second concurrent turn.
-        if (!_turnCoordinator.tryBeginTurn(turnKey)) {
-            _turnCoordinator.enqueueFollowUp(turnKey, {
-                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: 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: tenantOAuth.adoConnectionName, channelId });
-                adoToken = adoRes?.token;
+            catch (error) {
+                reportTeamsRequest("failed", convId, requestContext, { reason: "activity_admission_failed" });
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error", component: "channels", event: "channel.activity_admission_error",
+                    message: "Teams activity was not safely admitted; no new turn or steering was started",
+                    meta: { conversationId: convId, inboundActivityId: activity.id, reason: "activity_admission_failed" },
+                });
+                throw error;
             }
-            catch { /* no token yet — tool handler will trigger signin */ }
-            try {
-                const githubRes = await api.users.token.get({ userId, connectionName: tenantOAuth.githubConnectionName, channelId });
-                githubToken = githubRes?.token;
+            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") {
+                        await 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));
+                        await stream.emit("session cleared");
+                        if (_turnCoordinator.isTurnActive(turnKey)) {
+                            _turnCoordinator.enqueueFollowUp(turnKey, {
+                                conversationId: convId,
+                                text,
+                                receivedAt: Date.now(),
+                                effect: "clear_and_supersede",
+                            });
+                        }
+                        return;
+                    }
+                }
             }
-            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, tenantId } });
-            const teamsContext = {
-                graphToken,
-                adoToken,
-                githubToken,
-                signin: async (cn) => {
+            work = coordinateTeamsTurn(convId, text, {
+                aadObjectId: activity.from?.aadObjectId, userId, tenantId: activity.conversation?.tenantId,
+                replyToId: activity.replyToId,
+            }, async () => {
+                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 result = await signin({ connectionName: cn });
-                        (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.signin_result", component: "channels", message: `signin(${cn}): ${result ? "token received" : "no token"}`, meta: { connectionName: cn, hasToken: !!result } });
-                        return result;
+                        const graphRes = await api.users.token.get({ userId, connectionName: tenantOAuth.graphConnectionName, channelId });
+                        graphToken = graphRes?.token;
                     }
-                    catch (e) {
-                        const msg = e instanceof Error ? e.message : String(e);
-                        (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.signin_error", component: "channels", message: `signin(${cn}) failed`, meta: { connectionName: cn, reason: msg.slice(0, 100) } });
-                        return undefined;
+                    catch { /* no token yet — tool handler will trigger signin */ }
+                    try {
+                        const adoRes = await api.users.token.get({ userId, connectionName: tenantOAuth.adoConnectionName, channelId });
+                        adoToken = adoRes?.token;
                     }
-                },
-                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 handleTeamsMessage(text, stream, convId, teamsContext, ctxSend);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.handler_error", component: "channels", message: msg.slice(0, 200), meta: {} });
-        }
-        finally {
-            _turnCoordinator.endTurn(turnKey);
-        }
+                    catch { /* no token yet — tool handler will trigger signin */ }
+                    try {
+                        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, tenantId } });
+                    const teamsContext = {
+                        inboundActivityId: activity.id,
+                        replyToId: activity.replyToId,
+                        graphToken,
+                        adoToken,
+                        githubToken,
+                        signin: async (cn) => {
+                            try {
+                                const result = await signin({ connectionName: cn });
+                                (0, runtime_1.emitNervesEvent)({ level: "info", event: "channel.signin_result", component: "channels", message: `signin(${cn}): ${result ? "token received" : "no token"}`, meta: { connectionName: cn, hasToken: !!result } });
+                                return result;
+                            }
+                            catch (e) {
+                                const msg = e instanceof Error ? e.message : String(e);
+                                (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.signin_error", component: "channels", message: `signin(${cn}) failed`, meta: { connectionName: cn, reason: msg.slice(0, 100) } });
+                                return undefined;
+                            }
+                        },
+                        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,
+                        teamsSendImage: (0, teams_image_1.createTeamsImageSender)((message) => ctx.send(message), activity.id, aiLabelEntities()),
+                    };
+                    await handleTeamsMessage(text, stream, convId, teamsContext, sendText);
+                }
+                catch (err) {
+                    reportTeamsRequest("failed", convId, requestContext, { reason: "handler_failed" });
+                    const msg = err instanceof Error ? err.message : String(err);
+                    (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.handler_error", component: "channels", message: msg.slice(0, 200), meta: { conversationId: convId, inboundActivityId: activity.id, botId: app.id } });
+                }
+            });
+        });
+        await work;
     });
     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: {} });
+        (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.app_error", component: "channels", message: `[${label}] ${msg}`, meta: { botId: app.id, label } });
     });
 }
 function findAadObjectId(friend) {
@@ -874,14 +1424,14 @@ function findAadObjectId(friend) {
 function resolveTeamsFriendStore(deps) {
     return deps.store
         ?? deps.createFriendStore?.()
-        ?? new store_file_1.FileFriendStore(path.join((0, identity_1.getAgentRoot)(), "friends"));
+        ?? 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"
-        && types_1.TRUSTED_LEVELS.has(params.authorizingSession?.trustLevel ?? "stranger");
+        && friends_1.TRUSTED_LEVELS.has(params.authorizingSession?.trustLevel ?? "stranger");
 }
 async function sendProactiveTeamsMessageToSession(params, deps) {
     const store = resolveTeamsFriendStore(deps);
@@ -903,7 +1453,7 @@ async function sendProactiveTeamsMessageToSession(params, deps) {
         });
         return { delivered: false, reason: "friend_not_found" };
     }
-    if (!hasExplicitCrossChatAuthorization(params) && !types_1.TRUSTED_LEVELS.has(friend.trustLevel ?? "stranger")) {
+    if (!hasExplicitCrossChatAuthorization(params) && !friends_1.TRUSTED_LEVELS.has(friend.trustLevel ?? "stranger")) {
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.teams_proactive_trust_skip",
@@ -928,6 +1478,18 @@ async function sendProactiveTeamsMessageToSession(params, deps) {
         });
         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" };
+    }
+    let conversationId;
+    let activityAttempted = false;
     try {
         const conversation = await conversations.create({
             bot: { id: deps.botApi.id },
@@ -935,9 +1497,12 @@ async function sendProactiveTeamsMessageToSession(params, deps) {
             tenantId: aadInfo.tenantId,
             isGroup: false,
         });
-        await conversations.activities(conversation.id).create({
+        conversationId = conversation.id;
+        activityAttempted = true;
+        const activity = await conversations.activities(conversation.id).create({
             type: "message",
             text: params.text,
+            ...(params.textFormat ? { textFormat: params.textFormat } : {}),
         });
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
@@ -945,7 +1510,11 @@ async function sendProactiveTeamsMessageToSession(params, deps) {
             message: "proactive teams message sent",
             meta: { friendId: params.friendId, aadObjectId: aadInfo.aadObjectId, sessionKey: params.sessionKey },
         });
-        return { delivered: true };
+        const messageId = activity && typeof activity === "object" && "id" in activity && typeof activity.id === "string" ? activity.id : undefined;
+        return {
+            delivered: true,
+            ...(params.captureReceipt ? { delivery: { state: "accepted", conversationId, ...(messageId ? { messageId } : {}) } } : {}),
+        };
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
@@ -960,7 +1529,19 @@ async function sendProactiveTeamsMessageToSession(params, deps) {
                 reason: error instanceof Error ? error.message : String(error),
             },
         });
-        return { delivered: false, reason: "send_error" };
+        let status;
+        if (error && typeof error === "object") {
+            if ("statusCode" in error)
+                status = error.statusCode;
+            else if ("status" in error)
+                status = error.status;
+        }
+        const rejected = typeof status === "number" && status >= 400 && status < 500 && status !== 408 && status !== 409;
+        const state = !activityAttempted || rejected ? "not_sent" : "unknown";
+        return {
+            delivered: false, reason: "send_error",
+            ...(params.captureReceipt ? { delivery: { state, ...(conversationId ? { conversationId } : {}) } } : {}),
+        };
     }
 }
 function scanPendingTeamsFiles(pendingRoot) {
@@ -1030,6 +1611,20 @@ async function drainAndSendPendingTeams(store, botApi, pendingRoot) {
             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,
@@ -1091,7 +1686,7 @@ function startTeamsApp() {
     const port = process.env.PORT ? Number(process.env.PORT) : (0, config_2.getTeamsChannelConfig)().port;
     app.start(port);
     // Diagnostic: log tool count at startup to verify deploy
-    const startupTools = (0, tools_1.getToolsForChannel)((0, channel_1.getChannelCapabilities)("teams"));
+    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) ---