@ouro.bot/cli 0.1.0-alpha.153 → 0.1.0-alpha.154

package/changelog.json

@@ -1,6 +1,16 @@
 {
   "_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.154",
+      "changes": [
+        "feat: clean tool status messages \u2014 human-readable by default, /debug toggle",
+        "humanReadableToolDescription derives from tool name+args, not hardcoded map",
+        "Shared tool activity callbacks (DRY) \u2014 senses only provide render function",
+        "Slash command handling moved to pipeline \u2014 all senses get /debug for free",
+        "BlueBubbles: one clean iMessage per tool, not raw shared work: processing"
+      ]
+    },
     {
       "version": "0.1.0-alpha.153",
       "changes": [

package/dist/heart/tool-activity-callbacks.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolActivityCallbacks = createToolActivityCallbacks;
+const tool_description_1 = require("./tool-description");
+const runtime_1 = require("../nerves/runtime");
+function createToolActivityCallbacks(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.tool_activity_callbacks_created",
+        message: "tool activity callbacks initialized",
+        meta: { isDebug: options.isDebug },
+    });
+    return {
+        onToolStart(name, args) {
+            const description = (0, tool_description_1.humanReadableToolDescription)(name, args);
+            if (description === null)
+                return; // hidden tool (settle, rest)
+            options.onDescription(description);
+        },
+        onToolEnd(name, summary, success) {
+            if (!success) {
+                options.onFailure(`${name} failed: ${summary}`);
+                return;
+            }
+            if (options.isDebug) {
+                options.onResult(`${name}: ${summary}`);
+            }
+        },
+    };
+}

package/dist/heart/tool-description.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.humanReadableToolDescription = humanReadableToolDescription;
+const runtime_1 = require("../nerves/runtime");
+function basename(filePath) {
+    const idx = filePath.lastIndexOf("/");
+    return idx >= 0 ? filePath.slice(idx + 1) : filePath;
+}
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max - 1) + "\u2026";
+}
+const TOOL_DESCRIPTIONS = {
+    shell: (args) => {
+        const cmd = args.command;
+        if (!cmd)
+            return "running a command...";
+        return `running ${truncate(cmd, 50)}...`;
+    },
+    read_file: (args) => {
+        const fp = args.path || args.file_path;
+        if (!fp)
+            return "reading a file...";
+        return `reading ${basename(fp)}...`;
+    },
+    write_file: (args) => {
+        const fp = args.path || args.file_path;
+        if (!fp)
+            return "writing a file...";
+        return `writing ${basename(fp)}...`;
+    },
+    edit_file: (args) => {
+        const fp = args.path || args.file_path;
+        if (!fp)
+            return "editing a file...";
+        return `editing ${basename(fp)}...`;
+    },
+    recall: (args) => {
+        const q = args.query;
+        if (!q)
+            return "searching memory...";
+        return `searching memory for '${truncate(q, 40)}'...`;
+    },
+    grep: (args) => {
+        const p = args.pattern;
+        if (!p)
+            return "searching code...";
+        return `searching code for '${truncate(p, 40)}'...`;
+    },
+    glob: (args) => {
+        const p = args.pattern;
+        if (!p)
+            return "searching for files...";
+        return `searching for ${truncate(p, 40)}...`;
+    },
+    query_session: () => "checking session history...",
+    web_search: () => "searching the web...",
+    coding_spawn: () => "starting coding session...",
+    ponder: () => "thinking deeper...",
+    observe: () => "listening...",
+    diary_write: () => "noting something down...",
+    save_friend_note: () => "making a note...",
+    settle: () => null,
+    rest: () => null,
+};
+function humanReadableToolDescription(name, args) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.tool_description",
+        message: "generated human-readable tool description",
+        meta: { tool: name },
+    });
+    const builder = TOOL_DESCRIPTIONS[name];
+    if (builder)
+        return builder(args);
+    // MCP tools: mcp__server__toolname — extract last segment
+    if (name.startsWith("mcp__")) {
+        const parts = name.split("__");
+        const toolName = parts[parts.length - 1];
+        return `using ${toolName}...`;
+    }
+    return `using ${name}...`;
+}

package/dist/senses/bluebubbles.js

@@ -57,7 +57,7 @@ const channel_1 = require("../mind/friends/channel");
 const pending_1 = require("../mind/pending");
 const prompt_1 = require("../mind/prompt");
 const mcp_manager_1 = require("../repertoire/mcp-manager");
-const phrases_1 = require("../mind/phrases");
+// getPhrases removed — no longer needed after debug-activity cleanup
 const runtime_1 = require("../nerves/runtime");
 const bluebubbles_model_1 = require("./bluebubbles-model");
 const bluebubbles_client_1 = require("./bluebubbles-client");
@@ -65,7 +65,8 @@ const bluebubbles_inbound_log_1 = require("./bluebubbles-inbound-log");
 const bluebubbles_mutation_log_1 = require("./bluebubbles-mutation-log");
 const bluebubbles_runtime_state_1 = require("./bluebubbles-runtime-state");
 const bluebubbles_session_cleanup_1 = require("./bluebubbles-session-cleanup");
-const debug_activity_1 = require("./debug-activity");
+const tool_activity_callbacks_1 = require("../heart/tool-activity-callbacks");
+const commands_1 = require("./commands");
 const trust_gate_1 = require("./trust-gate");
 const pipeline_1 = require("./pipeline");
 const bbFailoverStates = new Map();
@@ -362,63 +363,58 @@ function emitBlueBubblesMarkReadWarning(chat, error) {
 }
 function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
     let textBuffer = "";
-    const phrases = (0, phrases_1.getPhrases)();
-    const activity = (0, debug_activity_1.createDebugActivityController)({
-        thinkingPhrases: phrases.thinking,
-        followupPhrases: phrases.followup,
-        startTypingOnModelStart: !isGroupChat,
-        startTypingOnFirstTextChunk: isGroupChat,
-        suppressInitialModelStatus: true,
-        suppressFollowupPhraseStatus: true,
-        transport: {
-            sendStatus: async (text) => {
-                const sent = await client.sendText({
-                    chat,
-                    text,
-                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                });
-                return sent.messageGuid;
-            },
-            editStatus: async (_messageGuid, text) => {
-                await client.sendText({
-                    chat,
-                    text,
-                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                });
-            },
-            setTyping: async (active) => {
-                if (!active) {
-                    await client.setTyping(chat, false);
-                    return;
-                }
-                const [markReadResult, typingResult] = await Promise.allSettled([
-                    client.markChatRead(chat),
-                    client.setTyping(chat, true),
-                ]);
-                if (markReadResult.status === "rejected") {
-                    emitBlueBubblesMarkReadWarning(chat, markReadResult.reason);
-                }
-                if (typingResult.status === "rejected") {
-                    throw typingResult.reason;
-                }
-            },
-        },
-        onTransportError: (operation, error) => {
+    let typingActive = false;
+    let queue = Promise.resolve();
+    function enqueue(operation, task) {
+        queue = queue.then(task).catch((error) => {
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "senses",
                 event: "senses.bluebubbles_activity_error",
                 message: "bluebubbles activity transport failed",
-                meta: {
-                    operation,
-                    reason: error instanceof Error ? error.message : String(error),
-                },
+                meta: { operation, reason: error instanceof Error ? error.message : String(error) },
             });
-        },
+        });
+    }
+    function startTypingNow() {
+        /* v8 ignore next -- defensive guard: callers already check typingActive @preserve */
+        if (typingActive)
+            return;
+        typingActive = true;
+        enqueue("typing_start", async () => {
+            const [markReadResult, typingResult] = await Promise.allSettled([
+                client.markChatRead(chat),
+                client.setTyping(chat, true),
+            ]);
+            if (markReadResult.status === "rejected") {
+                emitBlueBubblesMarkReadWarning(chat, markReadResult.reason);
+            }
+            if (typingResult.status === "rejected") {
+                throw typingResult.reason;
+            }
+        });
+    }
+    function sendStatus(text) {
+        enqueue("send_status", async () => {
+            await client.sendText({
+                chat,
+                text,
+                replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
+            });
+        });
+    }
+    const toolCallbacks = (0, tool_activity_callbacks_1.createToolActivityCallbacks)({
+        onDescription: (text) => sendStatus(text),
+        /* v8 ignore next -- onResult only called in debug mode; tested via tool-activity-callbacks.test.ts @preserve */
+        onResult: (text) => sendStatus(text),
+        /* v8 ignore next -- onFailure only called on tool failure; tested via tool-activity-callbacks.test.ts @preserve */
+        onFailure: (text) => sendStatus(`\u2717 ${text}`),
+        isDebug: (0, commands_1.getDebugMode)(),
     });
     return {
         onModelStart() {
-            activity.onModelStart();
+            if (!isGroupChat)
+                startTypingNow();
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_turn_start",
@@ -435,12 +431,16 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
             });
         },
         onTextChunk(text) {
-            activity.onTextChunk(text);
+            if (isGroupChat && !typingActive)
+                startTypingNow();
             textBuffer += text;
         },
         onReasoningChunk(_text) { },
         onToolStart(name, _args) {
-            activity.onToolStart(name, _args);
+            // Tool activity is a reply commitment — start typing if not already
+            if (!typingActive)
+                startTypingNow();
+            toolCallbacks.onToolStart(name, _args);
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_tool_start",
@@ -449,7 +449,7 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
             });
         },
         onToolEnd(name, summary, success) {
-            activity.onToolEnd(name, summary, success);
+            toolCallbacks.onToolEnd(name, summary, success);
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_tool_end",
@@ -458,7 +458,7 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
             });
         },
         onError(error, severity) {
-            activity.onError(error);
+            sendStatus(`\u2717 ${error.message}`);
             (0, runtime_1.emitNervesEvent)({
                 level: severity === "terminal" ? "error" : "warn",
                 component: "senses",
@@ -471,14 +471,23 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
             textBuffer = "";
         },
         async flush() {
-            await activity.drain();
+            await queue;
             const trimmed = textBuffer.trim();
             if (!trimmed) {
-                await activity.finish();
+                if (typingActive) {
+                    typingActive = false;
+                    enqueue("typing_stop", async () => { await client.setTyping(chat, false); });
+                    await queue;
+                }
                 return;
             }
             textBuffer = "";
-            await activity.finish();
+            /* v8 ignore next 4 -- branch: typing may already be stopped before flush @preserve */
+            if (typingActive) {
+                typingActive = false;
+                enqueue("typing_stop", async () => { await client.setTyping(chat, false); });
+                await queue;
+            }
             await client.sendText({
                 chat,
                 text: trimmed,
@@ -486,7 +495,13 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
             });
         },
         async finish() {
-            await activity.finish();
+            if (!typingActive) {
+                await queue;
+                return;
+            }
+            typingActive = false;
+            enqueue("typing_stop", async () => { await client.setTyping(chat, false); });
+            await queue;
         },
     };
 }

package/dist/senses/cli.js

@@ -660,28 +660,30 @@ async function runCliSession(options) {
                     continue;
                 }
             }
-            // Check for slash commands
-            const parsed = (0, commands_1.parseSlashCommand)(input);
-            if (parsed) {
-                const dispatchResult = registry.dispatch(parsed.command, { channel: "cli" });
-                if (dispatchResult.handled && dispatchResult.result) {
-                    if (dispatchResult.result.action === "exit") {
-                        break;
-                    }
-                    else if (dispatchResult.result.action === "new") {
-                        messages.length = 0;
-                        messages.push({ role: "system", content: await (0, prompt_1.buildSystem)("cli") });
-                        await options.onNewSession?.();
-                        // eslint-disable-next-line no-console -- terminal UX: session cleared
-                        console.log("session cleared");
-                        process.stdout.write(CLI_PROMPT);
-                        continue;
-                    }
-                    else if (dispatchResult.result.action === "response") {
-                        // eslint-disable-next-line no-console -- terminal UX: command dispatch result
-                        console.log(dispatchResult.result.message || "");
-                        process.stdout.write(CLI_PROMPT);
-                        continue;
+            // Check for slash commands (legacy path only — pipeline handles commands for runTurn path)
+            if (!options.runTurn) {
+                const parsed = (0, commands_1.parseSlashCommand)(input);
+                if (parsed) {
+                    const dispatchResult = registry.dispatch(parsed.command, { channel: "cli" });
+                    if (dispatchResult.handled && dispatchResult.result) {
+                        if (dispatchResult.result.action === "exit") {
+                            break;
+                        }
+                        else if (dispatchResult.result.action === "new") {
+                            messages.length = 0;
+                            messages.push({ role: "system", content: await (0, prompt_1.buildSystem)("cli") });
+                            await options.onNewSession?.();
+                            // eslint-disable-next-line no-console -- terminal UX: session cleared
+                            console.log("session cleared");
+                            process.stdout.write(CLI_PROMPT);
+                            continue;
+                        }
+                        else if (dispatchResult.result.action === "response") {
+                            // eslint-disable-next-line no-console -- terminal UX: command dispatch result
+                            console.log(dispatchResult.result.message || "");
+                            process.stdout.write(CLI_PROMPT);
+                            continue;
+                        }
                     }
                 }
             }
@@ -696,7 +698,27 @@ async function runCliSession(options) {
                 if (options.runTurn) {
                     // Pipeline-based turn: the runTurn callback handles user message assembly,
                     // pending drain, trust gate, runAgent, postTurn, and token accumulation.
+                    // Commands (e.g. /debug, /exit, /new) are intercepted in the pipeline.
                     result = await options.runTurn(messages, input, cliCallbacks, currentAbort.signal, effectiveToolContext);
+                    // Handle pipeline-intercepted commands with loop-control side effects
+                    if (result?.turnOutcome === "command") {
+                        if (result.commandAction === "exit") {
+                            break;
+                        }
+                        else if (result.commandAction === "new") {
+                            messages.length = 0;
+                            messages.push({ role: "system", content: await (0, prompt_1.buildSystem)("cli") });
+                            await options.onNewSession?.();
+                            // eslint-disable-next-line no-console -- terminal UX: session cleared
+                            console.log("session cleared");
+                            process.stdout.write(CLI_PROMPT);
+                            continue;
+                        }
+                        // For "response" commands: the pipeline already emitted the response via onTextChunk
+                        cliCallbacks.flushMarkdown();
+                        process.stdout.write(CLI_PROMPT);
+                        continue;
+                    }
                 }
                 else {
                     // Legacy path: inline runAgent (used by adoption specialist and tests)
@@ -898,7 +920,7 @@ async function main(agentName, options) {
                         process.stdout.write(`${result.gateResult.autoReply}\n`);
                     }
                 }
-                return { usage: result.usage };
+                return { usage: result.usage, turnOutcome: result.turnOutcome, commandAction: result.commandAction };
             },
             onNewSession: () => {
                 (0, context_1.deleteSession)(sessPath);

package/dist/senses/commands.js

@@ -3,7 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCommandRegistry = createCommandRegistry;
 exports.getToolChoiceRequired = getToolChoiceRequired;
 exports.resetToolChoiceRequired = resetToolChoiceRequired;
+exports.getDebugMode = getDebugMode;
+exports.resetDebugMode = resetDebugMode;
 exports.registerDefaultCommands = registerDefaultCommands;
+exports.getSharedCommandRegistry = getSharedCommandRegistry;
+exports.resetSharedCommandRegistry = resetSharedCommandRegistry;
 exports.parseSlashCommand = parseSlashCommand;
 const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
@@ -35,6 +39,14 @@ function getToolChoiceRequired() {
 function resetToolChoiceRequired() {
     _toolChoiceRequired = false;
 }
+// Module-level toggle for debug mode
+let _debugMode = false;
+function getDebugMode() {
+    return _debugMode;
+}
+function resetDebugMode() {
+    _debugMode = false;
+}
 function registerDefaultCommands(registry) {
     (0, runtime_1.emitNervesEvent)({
         event: "repertoire.load_start",
@@ -73,6 +85,15 @@ function registerDefaultCommands(registry) {
             return { action: "response", message: `tool-required mode: ${_toolChoiceRequired ? "ON" : "OFF"}` };
         },
     });
+    registry.register({
+        name: "debug",
+        description: "toggle debug mode (verbose tool output)",
+        channels: ["cli", "teams", "bluebubbles"],
+        handler: () => {
+            _debugMode = !_debugMode;
+            return { action: "response", message: `debug mode: ${_debugMode ? "ON" : "OFF"}` };
+        },
+    });
     (0, runtime_1.emitNervesEvent)({
         event: "repertoire.load_end",
         component: "repertoire",
@@ -80,6 +101,17 @@ function registerDefaultCommands(registry) {
         meta: {},
     });
 }
+let _sharedRegistry = null;
+function getSharedCommandRegistry() {
+    if (!_sharedRegistry) {
+        _sharedRegistry = createCommandRegistry();
+        registerDefaultCommands(_sharedRegistry);
+    }
+    return _sharedRegistry;
+}
+function resetSharedCommandRegistry() {
+    _sharedRegistry = null;
+}
 function parseSlashCommand(input) {
     const trimmed = input.trim();
     if (!trimmed.startsWith("/"))

package/dist/senses/pipeline.js

@@ -7,6 +7,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleInboundTurn = handleInboundTurn;
 const runtime_1 = require("../nerves/runtime");
+const commands_1 = require("./commands");
 const continuity_1 = require("./continuity");
 const manager_1 = require("../heart/bridges/manager");
 const identity_1 = require("../heart/identity");
@@ -167,6 +168,41 @@ async function handleInboundTurn(input) {
             // Switch failed OR succeeded — either way, fall through to normal processing.
         }
     }
+    // Step 0b: Slash command interception (before friend resolution / agent turn)
+    {
+        const firstUserMsg = input.messages.find((m) => m.role === "user");
+        const userText = firstUserMsg
+            ? (typeof firstUserMsg.content === "string"
+                ? firstUserMsg.content
+                : Array.isArray(firstUserMsg.content)
+                    ? firstUserMsg.content.find((p) => p.type === "text")?.text ?? ""
+                    : /* v8 ignore next -- defensive: content is always string or array @preserve */ "")
+            : "";
+        const parsed = (0, commands_1.parseSlashCommand)(userText);
+        if (parsed) {
+            const registry = (0, commands_1.getSharedCommandRegistry)();
+            const dispatchResult = registry.dispatch(parsed.command, { channel: input.channel });
+            if (dispatchResult.handled && dispatchResult.result) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.pipeline_command",
+                    message: `slash command intercepted: /${parsed.command}`,
+                    meta: { command: parsed.command, channel: input.channel },
+                });
+                if (dispatchResult.result.message) {
+                    input.callbacks.onTextChunk(dispatchResult.result.message);
+                }
+                // Return a minimal result — no agent turn, no session write
+                const resolvedContext = await input.friendResolver.resolve();
+                return {
+                    resolvedContext,
+                    gateResult: { allowed: true },
+                    turnOutcome: "command",
+                    commandAction: dispatchResult.result.action,
+                };
+            }
+        }
+    }
     // Step 1: Resolve friend
     const resolvedContext = await input.friendResolver.resolve();
     (0, runtime_1.emitNervesEvent)({

package/dist/senses/teams.js

@@ -70,6 +70,8 @@ const turn_coordinator_1 = require("../heart/turn-coordinator");
 const identity_1 = require("../heart/identity");
 const mcp_manager_1 = require("../repertoire/mcp-manager");
 const progress_story_1 = require("../heart/progress-story");
+const tool_activity_callbacks_1 = require("../heart/tool-activity-callbacks");
+const commands_2 = require("./commands");
 const http = __importStar(require("http"));
 const path = __importStar(require("path"));
 const trust_gate_1 = require("./trust-gate");
@@ -425,35 +427,37 @@ function createTeamsCallbacks(stream, controller, sendMessage, options) {
         onClearText: () => {
             textBuffer = "";
         },
-        onToolStart: (name, args) => {
-            stopPhraseRotation();
-            // Force-flush any accumulated text, bypassing MIN_INITIAL_CHARS threshold
-            firstContentEmitted = true;
-            flushTextBuffer();
-            // Emit a placeholder to satisfy the 15s Copilot timeout for initial
-            // stream.emit(). Without this, long tool chains (e.g. ADO batch ops)
-            // never emit before the timeout and the user sees "this response was
-            // stopped". The placeholder is replaced by actual content on next emit.
-            // https://learn.microsoft.com/en-us/answers/questions/2288017/m365-custom-engine-agents-timeout-message-after-15
-            if (!streamHasContent)
-                safeEmit("⏳");
-            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) => {
-            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,
-            })));
-        },
+        ...(() => {
+            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(`\u2717 ${text}`),
+                isDebug: (0, commands_2.getDebugMode)(),
+            });
+            return {
+                onToolStart: (name, args) => {
+                    stopPhraseRotation();
+                    // Force-flush any accumulated text, bypassing MIN_INITIAL_CHARS threshold
+                    firstContentEmitted = true;
+                    flushTextBuffer();
+                    // Emit a placeholder to satisfy the 15s Copilot timeout for initial
+                    // stream.emit(). Without this, long tool chains (e.g. ADO batch ops)
+                    // never emit before the timeout and the user sees "this response was
+                    // stopped". The placeholder is replaced by actual content on next emit.
+                    // https://learn.microsoft.com/en-us/answers/questions/2288017/m365-custom-engine-agents-timeout-message-after-15
+                    if (!streamHasContent)
+                        safeEmit("\u23f3");
+                    toolCbs.onToolStart(name, args);
+                    hadToolRun = true;
+                },
+                onToolEnd: (name, summary, success) => {
+                    stopPhraseRotation();
+                    toolCbs.onToolEnd(name, summary, success);
+                },
+            };
+        })(),
         onKick: () => {
             stopPhraseRotation();
             const msg = (0, format_1.formatKick)();
@@ -568,6 +572,7 @@ function createTeamsCommandRegistry() {
     (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)
@@ -591,6 +596,7 @@ 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, reactionOverrides) {
     const turnKey = teamsTurnKey(conversationId);
@@ -619,11 +625,6 @@ 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)();
@@ -729,6 +730,16 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
             runAgentOptions: agentOptions,
             failoverState: teamsFailoverState,
         });
+        // ── Handle pipeline-intercepted commands ────────────────────────
+        if (result.turnOutcome === "command") {
+            if (result.commandAction === "new") {
+                (0, context_1.deleteSession)(sessPath);
+                stream.emit("session cleared");
+            }
+            // For "response" commands: pipeline already emitted the response via onTextChunk
+            await callbacks.flush();
+            return;
+        }
         /* v8 ignore start -- failover display: tested via pipeline integration tests @preserve */
         if (result.failoverMessage) {
             stream.emit(result.failoverMessage);
@@ -776,7 +787,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
             currentText = replayTail;
             continue;
         }
-        if (handleTeamsSlashCommand(supersedingFollowUp.text, registry, friendId, conversationId, stream, false)) {
+        if (handleTeamsSlashCommand(supersedingFollowUp.text, createTeamsCommandRegistry(), friendId, conversationId, stream, false)) {
             return;
         }
         currentText = supersedingFollowUp.text;

package/package.json

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

package/dist/senses/debug-activity.js

@@ -1,154 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDebugActivityController = createDebugActivityController;
-const format_1 = require("../mind/format");
-const phrases_1 = require("../mind/phrases");
-const runtime_1 = require("../nerves/runtime");
-const progress_story_1 = require("../heart/progress-story");
-function createDebugActivityController(options) {
-    let queue = Promise.resolve();
-    let statusMessageGuid;
-    let typingActive = false;
-    let hadToolRun = false;
-    let followupShown = false;
-    let lastPhrase = "";
-    function reportTransportError(operation, error) {
-        (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            component: "senses",
-            event: "senses.debug_activity_transport_error",
-            message: "debug activity transport failed",
-            meta: {
-                operation,
-                reason: error instanceof Error ? error.message : String(error),
-            },
-        });
-        options.onTransportError?.(operation, error);
-    }
-    function enqueue(operation, task) {
-        queue = queue
-            .then(task)
-            .catch((error) => {
-            reportTransportError(operation, error);
-        });
-    }
-    function nextPhrase(pool) {
-        const phrase = (0, phrases_1.pickPhrase)(pool, lastPhrase);
-        lastPhrase = phrase;
-        return phrase;
-    }
-    function startTypingNow() {
-        if (typingActive) {
-            return;
-        }
-        typingActive = true;
-        enqueue("typing_start", async () => {
-            await options.transport.setTyping(true);
-        });
-    }
-    function setStatus(text) {
-        (0, runtime_1.emitNervesEvent)({
-            component: "senses",
-            event: "senses.debug_activity_update",
-            message: "debug activity status updated",
-            meta: {
-                hasStatusGuid: Boolean(statusMessageGuid),
-                textLength: text.length,
-            },
-        });
-        const shouldStartTyping = !typingActive;
-        if (shouldStartTyping) {
-            typingActive = true;
-        }
-        enqueue("status_update", async () => {
-            if (statusMessageGuid) {
-                await options.transport.editStatus(statusMessageGuid, text);
-            }
-            else {
-                statusMessageGuid = await options.transport.sendStatus(text);
-            }
-            if (shouldStartTyping) {
-                await options.transport.setTyping(true);
-            }
-        });
-    }
-    return {
-        onModelStart() {
-            const pool = hadToolRun ? options.followupPhrases : options.thinkingPhrases;
-            if (options.startTypingOnModelStart) {
-                startTypingNow();
-            }
-            if (options.suppressInitialModelStatus && !statusMessageGuid && !hadToolRun) {
-                nextPhrase(pool);
-                return;
-            }
-            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-                scope: "shared-work",
-                phase: "processing",
-                objective: `${nextPhrase(pool)}...`,
-            })));
-        },
-        onToolStart(name, args) {
-            hadToolRun = true;
-            followupShown = false;
-            const argSummary = Object.values(args).join(", ");
-            const detail = argSummary ? ` (${argSummary})` : "";
-            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-                scope: "shared-work",
-                phase: "processing",
-                objective: `running ${name}${detail}...`,
-            })));
-        },
-        onToolEnd(name, summary, success) {
-            hadToolRun = true;
-            followupShown = false;
-            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-                scope: "shared-work",
-                phase: "processing",
-                objective: (0, format_1.formatToolResult)(name, summary, success),
-            })));
-        },
-        onTextChunk(text) {
-            if (!text) {
-                return;
-            }
-            if (!hadToolRun && options.startTypingOnFirstTextChunk) {
-                startTypingNow();
-            }
-            if (!hadToolRun || followupShown) {
-                return;
-            }
-            followupShown = true;
-            if (options.suppressFollowupPhraseStatus) {
-                return;
-            }
-            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-                scope: "shared-work",
-                phase: "processing",
-                objective: `${nextPhrase(options.followupPhrases)}...`,
-            })));
-        },
-        onError(error) {
-            setStatus((0, progress_story_1.renderProgressStory)((0, progress_story_1.buildProgressStory)({
-                scope: "shared-work",
-                phase: "errored",
-                outcomeText: (0, format_1.formatError)(error),
-            })));
-            this.finish();
-        },
-        async drain() {
-            await queue;
-        },
-        async finish() {
-            if (!typingActive) {
-                await queue;
-                return;
-            }
-            typingActive = false;
-            enqueue("typing_stop", async () => {
-                await options.transport.setTyping(false);
-            });
-            await queue;
-        },
-    };
-}