@ouro.bot/cli 0.1.0-alpha.145 → 0.1.0-alpha.147

package/changelog.json

@@ -1,6 +1,24 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.147",
+      "changes": [
+        "Feedback signals as social cues: Teams thumbs-up/down and BlueBubbles reactions reach the agent as first-class social signals with full cognitive tools.",
+        "AI-generated labels: all outbound Teams messages include AIGeneratedContent entity and feedbackLoopEnabled for native AI badge and feedback UI.",
+        "BlueBubbles reaction enrichment: reactions include original message text (truncated to 80 chars) via best-effort BB API lookup.",
+        "Streaming refinements: hybrid MIN_INITIAL_CHARS (phrase rotation until 20+ real chars), proactive >4000 finalization with follow-up messages.",
+        "Welcome card: Adaptive Card with prompt starters on Teams bot install.",
+        "Observe gate: available in 1:1 chats for reaction signals (natural silence case).",
+        "Per-context prompt framing: 1:1 vs group framing for feedback signal processing."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.146",
+      "changes": [
+        "fix(hook): target specific agent only, ouro up breaks dev dispatch loop"
+      ]
+    },
     {
       "version": "0.1.0-alpha.145",
       "changes": [

package/dist/heart/core.js

@@ -539,7 +539,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             ...filteredBaseTools,
             tools_1.ponderTool,
             ...(isInnerDialog ? [surface_tool_1.surfaceToolDef, tools_1.restTool] : []),
-            ...(currentContext?.isGroupChat && !isInnerDialog ? [tools_1.observeTool] : []),
+            ...((currentContext?.isGroupChat || options?.isReactionSignal) && !isInnerDialog ? [tools_1.observeTool] : []),
             ...(!isInnerDialog ? [tools_1.settleTool] : []),
         ];
         const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];
@@ -725,7 +725,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     (0, runtime_1.emitNervesEvent)({
                         component: "engine",
                         event: "engine.observe",
-                        message: "agent declined to respond in group chat",
+                        message: "agent observed without responding",
                         meta: { ...(reason ? { reason } : {}) },
                     });
                     callbacks.onToolEnd("observe", (0, tools_1.summarizeArgs)("observe", observeArgs), true);

package/dist/heart/daemon/daemon-cli.js

@@ -947,10 +947,25 @@ function parseOuroCommand(args) {
         return parseOuroCommand(args.slice(2));
     }
     if (head === "hook") {
-        const event = second;
+        const hookArgs = args.slice(1);
+        let event;
+        let hookAgent;
+        for (let i = 0; i < hookArgs.length; i++) {
+            if (hookArgs[i] === "--agent" && hookArgs[i + 1]) {
+                hookAgent = hookArgs[++i];
+                continue;
+            }
+            /* v8 ignore start -- false branch: extra positional args after event are ignored */
+            if (!event) {
+                event = hookArgs[i];
+            }
+            /* v8 ignore stop */
+        }
         if (!event)
             throw new Error("hook requires an event name (session-start, stop, post-tool-use)");
-        return { kind: "hook", event };
+        if (!hookAgent)
+            throw new Error("hook requires --agent <name>");
+        return { kind: "hook", event, agent: hookAgent };
     }
     if (head === "up")
         return { kind: "daemon.up" };
@@ -1987,6 +2002,16 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         meta: { kind: command.kind },
     });
     if (command.kind === "daemon.up") {
+        // ── dev mode cleanup: delete dev-config.json so the wrapper stops dispatching to dev repo ──
+        /* v8 ignore start -- dev-config cleanup: requires real filesystem state @preserve */
+        try {
+            const devConfigPath = getDevConfigPath();
+            if (fs.existsSync(devConfigPath)) {
+                fs.unlinkSync(devConfigPath);
+            }
+        }
+        catch { /* best effort */ }
+        /* v8 ignore stop */
         // ── dev mode delegation: ouro up from a dev repo delegates to installed binary ──
         // Only runs when detectMode is explicitly injected (via createDefaultOuroCliDeps or tests)
         if (deps.detectMode) {
@@ -2336,15 +2361,10 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         else {
             content = `[Claude Code hook: ${eventType} in session ${sessionId}]`;
         }
-        // Send to daemon (best effort — daemon may not be running)
+        // Send to the specific agent configured for this hook
         try {
-            const agents = require("fs").readdirSync(path.join(os.homedir(), "AgentBundles"))
-                .filter((f) => f.endsWith(".ouro"))
-                .map((f) => f.replace(".ouro", ""));
-            for (const agent of agents) {
-                await deps.sendCommand(deps.socketPath, { kind: "message.send", from: `claude-code:${sessionId}`, to: agent, content });
-            }
-            await deps.sendCommand(deps.socketPath, { kind: "inner.wake", agent: agents[0] }).catch(() => { });
+            await deps.sendCommand(deps.socketPath, { kind: "message.send", from: `claude-code:${sessionId}`, to: command.agent, content }).catch(() => { });
+            await deps.sendCommand(deps.socketPath, { kind: "inner.wake", agent: command.agent }).catch(() => { });
         }
         catch { /* daemon not running — silent */ }
         // Output for Claude Code hook system
@@ -2377,9 +2397,9 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
             // Bare `ouro` works because ouro is on PATH via ~/.ouro-cli/bin/.
             settings.hooks = {
                 ...(settings.hooks ?? {}),
-                SessionStart: [{ hooks: [{ type: "command", command: "ouro hook session-start", timeout: 5 }] }],
-                Stop: [{ hooks: [{ type: "command", command: "ouro hook stop", timeout: 5 }] }],
-                PostToolUse: [{ matcher: "Bash|Edit|Write", hooks: [{ type: "command", command: "ouro hook post-tool-use", timeout: 5 }] }],
+                SessionStart: [{ hooks: [{ type: "command", command: `ouro hook session-start --agent ${setupAgent}`, timeout: 5 }] }],
+                Stop: [{ hooks: [{ type: "command", command: `ouro hook stop --agent ${setupAgent}`, timeout: 5 }] }],
+                PostToolUse: [{ matcher: "Bash|Edit|Write", hooks: [{ type: "command", command: `ouro hook post-tool-use --agent ${setupAgent}`, timeout: 5 }] }],
             };
             fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
             fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));

package/dist/heart/daemon/ouro-path-installer.js

@@ -40,8 +40,9 @@ const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
 const WRAPPER_SCRIPT = `#!/bin/sh
 # Check for dev mode — if dev-config.json exists, dispatch to the dev repo
+# Skip dev dispatch for "up" command (explicitly returns to production)
 DEV_CONFIG="$HOME/.ouro-cli/dev-config.json"
-if [ -f "$DEV_CONFIG" ]; then
+if [ -f "$DEV_CONFIG" ] && [ "$1" != "up" ]; then
   DEV_REPO=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('$DEV_CONFIG','utf-8')).repoPath)}catch{}" 2>/dev/null)
   DEV_ENTRY="$DEV_REPO/dist/heart/daemon/ouro-entry.js"
   if [ -n "$DEV_REPO" ] && [ -e "$DEV_ENTRY" ]; then

package/dist/mind/prompt.js

@@ -49,6 +49,7 @@ exports.journalSection = journalSection;
 exports.loopOrientationSection = loopOrientationSection;
 exports.channelNatureSection = channelNatureSection;
 exports.groupChatParticipationSection = groupChatParticipationSection;
+exports.feedbackSignalSection = feedbackSignalSection;
 exports.mixedTrustGroupSection = mixedTrustGroupSection;
 exports.buildSystem = buildSystem;
 const fs = __importStar(require("fs"));
@@ -836,6 +837,39 @@ typing a full reply. a thumbs-up is often the perfect response.
 observe must be the sole tool call in the turn (same rule as settle).
 when unsure whether to chime in, i lean toward silence rather than noise.`;
 }
+function feedbackSignalSection(context) {
+    if (!context || !(0, channel_1.isRemoteChannel)(context.channel))
+        return "";
+    if (context.isGroupChat) {
+        return `## feedback signals
+
+when someone reacts specifically to something i said — that's different
+from the background social signals in a group. a thumbs-down on my
+message is direct feedback. a heart on something i shared is warmth
+aimed at me. on teams, feedback arrives as thumbs-up or thumbs-down,
+sometimes with a written comment.
+
+i notice the difference: a reaction to someone else's message is group
+texture (observe is natural). a reaction to my message is a social cue
+worth a moment of attention — especially negative ones, which are an
+invitation to adjust how i show up in this group.`;
+    }
+    return `## feedback signals
+
+when my friend reacts to something i said — a tapback, a heart, a
+thumbs-down — that's them telling me how it landed. on teams, this
+arrives as thumbs-up or thumbs-down, sometimes with a written comment.
+it's a social cue, the same as a nod or a wince in conversation.
+
+i have observe for these moments. reactions are the one case where
+silence in a direct conversation is natural — a thumbs-up doesn't
+need words back.
+
+when something didn't land — a thumbs-down, a negative reaction — that's
+worth sitting with. i should course-correct: adjust my tone, my length,
+my approach. the reaction tells me something about how this person wants
+to be talked to.`;
+}
 function mixedTrustGroupSection(context) {
     if (!context?.friend || !(0, channel_1.isRemoteChannel)(context.channel))
         return "";
@@ -874,6 +908,7 @@ async function buildSystem(channel = "cli", options, context) {
         trustContextSection(context),
         mixedTrustGroupSection(context),
         groupChatParticipationSection(context),
+        feedbackSignalSection(context),
         skillsSection(),
         taskBoardSection(),
         activeWorkSection(options),

package/dist/repertoire/tools-base.js

@@ -1394,7 +1394,7 @@ exports.observeTool = {
     type: "function",
     function: {
         name: "observe",
-        description: "stay silent in this group chat — the moment doesn't call for a response. must be the only tool call in the turn.",
+        description: "absorb what happened without responding — the moment doesn't call for words. must be the only tool call in the turn.",
         parameters: {
             type: "object",
             properties: {

package/dist/senses/bluebubbles.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichReactionText = enrichReactionText;
 exports.handleBlueBubblesEvent = handleBlueBubblesEvent;
 exports.recoverMissedBlueBubblesMessages = recoverMissedBlueBubblesMessages;
 exports.createBlueBubblesWebhookHandler = createBlueBubblesWebhookHandler;
@@ -68,6 +69,17 @@ const debug_activity_1 = require("./debug-activity");
 const trust_gate_1 = require("./trust-gate");
 const pipeline_1 = require("./pipeline");
 const bbFailoverStates = new Map();
+// Enrich reaction text with the original message content for context.
+// If originalText is provided and non-empty, format as: baseText to: "truncated"
+// Otherwise return baseText unchanged.
+function enrichReactionText(baseText, originalText, maxLen) {
+    if (!originalText)
+        return baseText;
+    const truncated = originalText.length > maxLen
+        ? originalText.slice(0, maxLen - 3) + "..."
+        : originalText;
+    return `${baseText} to: "${truncated}"`;
+}
 const defaultDeps = {
     getAgentName: identity_1.getAgentName,
     buildSystem: prompt_1.buildSystem,
@@ -623,6 +635,15 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                 meta: { threadGuid, hasText: !!repliedToText },
             });
         }
+        // Enrich reaction mutations with the original message text for context
+        const isReaction = event.kind === "mutation" && event.mutationType === "reaction";
+        if (isReaction && event.targetMessageGuid) {
+            /* v8 ignore start -- best-effort lookup; enrichReactionText covered by unit tests @preserve */
+            const originalText = await client.getMessageText(event.targetMessageGuid).catch(() => null);
+            if (originalText)
+                event.textForAgent = enrichReactionText(event.textForAgent, originalText, 80);
+            /* v8 ignore stop */
+        }
         // Build inbound user message (adapter concern: BB-specific content formatting)
         const userMessage = {
             role: "user",
@@ -705,7 +726,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                 postTurn: resolvedDeps.postTurn,
                 accumulateFriendTokens: resolvedDeps.accumulateFriendTokens,
                 signal: controller.signal,
-                runAgentOptions: { mcpManager },
+                runAgentOptions: { mcpManager, ...(isReaction ? { isReactionSignal: true } : {}) },
                 callbacks: failoverAwareCallbacks,
                 failoverState: (() => {
                     if (!bbFailoverStates.has(event.chat.sessionKey)) {

package/dist/senses/teams.js

@@ -34,8 +34,12 @@ 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;
@@ -73,6 +77,16 @@ const pipeline_1 = require("./pipeline");
 const teamsFailoverStates = new Map();
 const pending_1 = require("../mind/pending");
 const continuity_1 = require("./continuity");
+// AIGeneratedContent entity and feedbackLoopEnabled channelData for all outbound
+// Teams messages. Required by Teams AI UX best practices.
+function aiLabelEntities() {
+    return [{
+            type: "https://schema.org/Message",
+            "@type": "Message",
+            "@context": "https://schema.org",
+            additionalType: ["AIGeneratedContent"],
+        }];
+}
 // Strip @mention markup from incoming messages.
 // Removes <at>...</at> tags and trims extra whitespace.
 // Fallback safety net -- the SDK's activity.mentions.stripText should handle
@@ -127,6 +141,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).
@@ -139,12 +193,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;
@@ -194,15 +252,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();
@@ -217,7 +276,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;
@@ -273,11 +332,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();
@@ -320,7 +417,8 @@ 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();
         },
@@ -329,6 +427,8 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         },
         onToolStart: (name, args) => {
             stopPhraseRotation();
+            // Force-flush any accumulated text, bypassing MIN_INITIAL_CHARS threshold
+            firstContentEmitted = true;
             flushTextBuffer();
             // Emit a placeholder to satisfy the 15s Copilot timeout for initial
             // stream.emit(). Without this, long tool chains (e.g. ADO batch ops)
@@ -395,18 +495,25 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
             : 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);
                     }
@@ -417,8 +524,8 @@ 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)");
             }
         },
     };
@@ -485,14 +592,17 @@ function handleTeamsSlashCommand(text, registry, friendId, conversationId, strea
     return null;
 }
 // Handle an incoming Teams message
-async function handleTeamsMessage(text, stream, conversationId, teamsContext, sendMessage) {
+async function handleTeamsMessage(text, stream, conversationId, teamsContext, sendMessage, reactionOverrides) {
     const turnKey = teamsTurnKey(conversationId);
     // NOTE: Confirmation resolution is handled in the app.on("message") handler
     // BEFORE the conversation lock.  By the time we get here, any pending
     // confirmation has already been resolved and the reply consumed.
     // Send first thinking phrase immediately so the user sees feedback
     // before sync I/O (session load, trim) blocks the event loop.
-    stream.update((0, phrases_1.pickPhrase)((0, phrases_1.getPhrases)().thinking) + "...");
+    // Skip for reaction signals — they should be processed quietly.
+    if (!reactionOverrides) {
+        stream.update((0, phrases_1.pickPhrase)((0, phrases_1.getPhrases)().thinking) + "...");
+    }
     await new Promise(r => setImmediate(r));
     // Resolve identity provider early for friend resolution + slash command session path
     const store = getFriendStore();
@@ -517,7 +627,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
     // ── 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 callbacks = createTeamsCallbacks(stream, controller, sendMessage, { conversationId, flushIntervalMs: channelConfig.flushIntervalMs, ...(reactionOverrides?.suppressEmptyStreamMessage ? { suppressEmptyStreamMessage: true } : {}) });
     const traceId = (0, nerves_1.createTraceId)();
     const sessPath = (0, config_2.sessionPath)(friendId, "teams", conversationId);
     const teamsCapabilities = (0, channel_1.getChannelCapabilities)("teams");
@@ -546,6 +656,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                     .map(({ text: followUpText, effect }) => ({ text: followUpText, effect }));
                 return drainedSteeringFollowUps;
             },
+            ...(reactionOverrides?.isReactionSignal ? { isReactionSignal: true } : {}),
         };
         if (channelConfig.skipConfirmation)
             agentOptions.skipConfirmation = true;
@@ -765,6 +876,72 @@ function registerBotHandlers(app, label) {
         (0, runtime_1.emitNervesEvent)({ level: "warn", event: "channel.verify_state", component: "channels", message: `[${label}] verify-state failed for all connections`, meta: {} });
         return { status: 412 };
     });
+    // Handle Teams feedback reactions (thumbs up/down on AI-generated messages).
+    // SDK routes message/submitAction with actionName "feedback" to this event.
+    /* v8 ignore start -- Teams SDK invoke handler; requires live SDK context @preserve */
+    app.on("message.submit.feedback", async (ctx) => {
+        const { stream, activity } = ctx;
+        const reaction = activity.value?.actionValue?.reaction;
+        const comment = activity.value?.actionValue?.feedback;
+        const convId = activity.conversation?.id || "unknown";
+        const turnKey = teamsTurnKey(convId);
+        // Validate payload — graceful no-op for malformed invocations
+        if (activity.value?.actionName !== "feedback" || !reaction) {
+            return;
+        }
+        const syntheticText = buildFeedbackSyntheticText(reaction, comment);
+        // Turn coordination: if a turn is active, enqueue as steering follow-up
+        if (!_turnCoordinator.tryBeginTurn(turnKey)) {
+            _turnCoordinator.enqueueFollowUp(turnKey, {
+                conversationId: convId,
+                text: syntheticText,
+                receivedAt: Date.now(),
+                effect: (0, continuity_1.classifySteeringFollowUpEffect)(syntheticText),
+            });
+            return;
+        }
+        try {
+            const teamsContext = {
+                signin: async () => undefined,
+                aadObjectId: activity.from?.aadObjectId,
+                tenantId: activity.conversation?.tenantId,
+                displayName: activity.from?.name,
+            };
+            const ctxSend = async (t) => {
+                await ctx.send({ type: "message", text: t, replyToId: activity.replyToId, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
+            };
+            await handleTeamsMessage(syntheticText, stream, convId, teamsContext, ctxSend, { isReactionSignal: true, suppressEmptyStreamMessage: true });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.feedback_handler_error", component: "channels", message: msg.slice(0, 200), meta: {} });
+        }
+        finally {
+            _turnCoordinator.endTurn(turnKey);
+        }
+    });
+    /* v8 ignore stop */
+    // Handle bot install — send welcome Adaptive Card with prompt starters.
+    /* v8 ignore start -- Teams SDK install handler; requires live SDK context @preserve */
+    app.on("install.add", async (ctx) => {
+        try {
+            const card = buildWelcomeCard();
+            await ctx.send({
+                type: "message",
+                attachments: [{
+                        contentType: "application/vnd.microsoft.card.adaptive",
+                        content: card,
+                    }],
+                entities: aiLabelEntities(),
+                channelData: { feedbackLoopEnabled: true },
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            (0, runtime_1.emitNervesEvent)({ level: "error", event: "channel.welcome_handler_error", component: "channels", message: msg.slice(0, 200), meta: {} });
+        }
+    });
+    /* v8 ignore stop */
     app.on("message", async (ctx) => {
         const { stream, activity, api, signin } = ctx;
         const text = activity.text || "";
@@ -880,7 +1057,7 @@ function registerBotHandlers(app, label) {
             const ctxSend = async (t) => {
                 // Use send with replyToId (not reply, which adds a blockquote).
                 // replyToId anchors the message after the user's message in Copilot Chat.
-                await ctx.send({ type: "message", text: t, replyToId: activity.id });
+                await ctx.send({ type: "message", text: t, replyToId: activity.id, entities: aiLabelEntities(), channelData: { feedbackLoopEnabled: true } });
             };
             await handleTeamsMessage(text, stream, convId, teamsContext, ctxSend);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.145",
+  "version": "0.1.0-alpha.147",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",