@ouro.bot/cli 0.1.0-alpha.42 → 0.1.0-alpha.43

package/changelog.json

@@ -1,6 +1,13 @@
 {
   "_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.43",
+      "changes": [
+        "Continuity-aware onboarding now stays contextual: when an active task goes idle, onboarding guidance can reappear during genuine lulls instead of staying hidden just because no-handoff state was previously persisted.",
+        "Teams active-turn controls are safer: `/new` still clears the current session during long-running turns, and superseding follow-ups keep the user's replacement ask instead of dropping it."
+      ]
+    },
     {
       "version": "0.1.0-alpha.42",
       "changes": [

package/dist/heart/core.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasToolIntent = exports.buildSystem = exports.toResponsesTools = exports.toResponsesInput = exports.streamResponsesApi = exports.streamChatCompletion = exports.getToolsForChannel = exports.summarizeArgs = exports.execTool = exports.tools = void 0;
 exports.createProviderRegistry = createProviderRegistry;
 exports.resetProviderRuntime = resetProviderRuntime;
 exports.getModel = getModel;
@@ -110,6 +111,53 @@ function getProviderDisplayLabel() {
     };
     return providerLabelBuilders[getProvider()]();
 }
+// Re-export tools, execTool, summarizeArgs from ./tools for backward compat
+var tools_2 = require("../repertoire/tools");
+Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tools_2.tools; } });
+Object.defineProperty(exports, "execTool", { enumerable: true, get: function () { return tools_2.execTool; } });
+Object.defineProperty(exports, "summarizeArgs", { enumerable: true, get: function () { return tools_2.summarizeArgs; } });
+Object.defineProperty(exports, "getToolsForChannel", { enumerable: true, get: function () { return tools_2.getToolsForChannel; } });
+// Re-export streaming functions for backward compat
+var streaming_1 = require("./streaming");
+Object.defineProperty(exports, "streamChatCompletion", { enumerable: true, get: function () { return streaming_1.streamChatCompletion; } });
+Object.defineProperty(exports, "streamResponsesApi", { enumerable: true, get: function () { return streaming_1.streamResponsesApi; } });
+Object.defineProperty(exports, "toResponsesInput", { enumerable: true, get: function () { return streaming_1.toResponsesInput; } });
+Object.defineProperty(exports, "toResponsesTools", { enumerable: true, get: function () { return streaming_1.toResponsesTools; } });
+// Re-export prompt functions for backward compat
+var prompt_2 = require("../mind/prompt");
+Object.defineProperty(exports, "buildSystem", { enumerable: true, get: function () { return prompt_2.buildSystem; } });
+function parseFinalAnswerPayload(argumentsText) {
+    try {
+        const parsed = JSON.parse(argumentsText);
+        if (typeof parsed === "string") {
+            return { answer: parsed };
+        }
+        if (!parsed || typeof parsed !== "object") {
+            return {};
+        }
+        const answer = typeof parsed.answer === "string" ? parsed.answer : undefined;
+        const rawIntent = parsed.intent;
+        const intent = rawIntent === "complete" || rawIntent === "blocked" || rawIntent === "direct_reply"
+            ? rawIntent
+            : undefined;
+        return { answer, intent };
+    }
+    catch {
+        return {};
+    }
+}
+function getFinalAnswerRetryError(mustResolveBeforeHandoff, intent, sawSteeringFollowUp) {
+    if (mustResolveBeforeHandoff && !intent) {
+        return "your final_answer is missing required intent. when you must keep going until done or blocked, call final_answer again with answer plus intent=complete, blocked, or direct_reply.";
+    }
+    if (mustResolveBeforeHandoff && intent === "direct_reply" && !sawSteeringFollowUp) {
+        return "your final_answer used intent=direct_reply without a newer steering follow-up. continue the unresolved work, or call final_answer again with intent=complete or blocked when appropriate.";
+    }
+    return "your final_answer was incomplete or malformed. call final_answer again with your complete response.";
+}
+// Re-export kick utilities for backward compat
+var kicks_1 = require("./kicks");
+Object.defineProperty(exports, "hasToolIntent", { enumerable: true, get: function () { return kicks_1.hasToolIntent; } });
 function upsertSystemPrompt(messages, systemText) {
     const systemMessage = { role: "system", content: systemText };
     if (messages[0]?.role === "system") {
@@ -310,6 +358,9 @@ async function runAgent(messages, callbacks, channel, signal, options) {
     let lastUsage;
     let overflowRetried = false;
     let retryCount = 0;
+    let outcome = "complete";
+    let sawSteeringFollowUp = false;
+    let mustResolveBeforeHandoffActive = options?.mustResolveBeforeHandoff === true;
     // Prevent MaxListenersExceeded warning — each iteration adds a listener
     try {
         require("events").setMaxListeners(50, signal);
@@ -328,6 +379,18 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         const activeTools = toolChoiceRequired ? [...baseTools, tools_1.finalAnswerTool] : baseTools;
         const steeringFollowUps = options?.drainSteeringFollowUps?.() ?? [];
         if (steeringFollowUps.length > 0) {
+            const hasSupersedingFollowUp = steeringFollowUps.some((followUp) => followUp.effect === "clear_and_supersede");
+            if (hasSupersedingFollowUp) {
+                mustResolveBeforeHandoffActive = false;
+                options?.setMustResolveBeforeHandoff?.(false);
+                outcome = "superseded";
+                break;
+            }
+            if (steeringFollowUps.some((followUp) => followUp.effect === "set_no_handoff")) {
+                mustResolveBeforeHandoffActive = true;
+                options?.setMustResolveBeforeHandoff?.(true);
+            }
+            sawSteeringFollowUp = true;
             for (const followUp of steeringFollowUps) {
                 messages.push({ role: "user", content: followUp.text });
             }
@@ -335,8 +398,10 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         }
         // Yield so pending I/O (stdin Ctrl-C) can be processed between iterations
         await new Promise((r) => setImmediate(r));
-        if (signal?.aborted)
+        if (signal?.aborted) {
+            outcome = "aborted";
             break;
+        }
         try {
             callbacks.onModelStart();
             const result = await providerRuntime.streamTurn({
@@ -381,22 +446,13 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 const isSoleFinalAnswer = result.toolCalls.length === 1 && result.toolCalls[0].name === "final_answer";
                 if (isSoleFinalAnswer) {
                     // Extract answer from the tool call arguments.
-                    // Supports: {"answer":"text"}, "text" (JSON string), retry on failure.
-                    let answer;
-                    try {
-                        const parsed = JSON.parse(result.toolCalls[0].arguments);
-                        if (typeof parsed === "string") {
-                            answer = parsed;
-                        }
-                        else if (parsed.answer != null) {
-                            answer = parsed.answer;
-                        }
-                        // else: valid JSON but no answer field — answer stays undefined (retry)
-                    }
-                    catch {
-                        // JSON parsing failed (e.g. truncated output) — answer stays undefined (retry)
-                    }
-                    if (answer != null) {
+                    // Supports: {"answer":"text","intent":"..."} or "text" (JSON string).
+                    const { answer, intent } = parseFinalAnswerPayload(result.toolCalls[0].arguments);
+                    const validDirectReply = mustResolveBeforeHandoffActive && intent === "direct_reply" && sawSteeringFollowUp;
+                    const validTerminalIntent = intent === "complete" || intent === "blocked";
+                    const validClosure = answer != null
+                        && (!mustResolveBeforeHandoffActive || validDirectReply || validTerminalIntent);
+                    if (validClosure) {
                         if (result.finalAnswerStreamed) {
                             // The streaming layer already parsed and emitted the answer
                             // progressively via FinalAnswerParser. Skip clearing and
@@ -409,19 +465,26 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             // Never truncate -- channel adapters handle splitting long messages.
                             callbacks.onTextChunk(answer);
                         }
-                        // Keep the full assistant message (with tool_calls) for debuggability,
-                        // plus a synthetic tool response so the conversation stays valid on resume.
                         messages.push(msg);
-                        messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: "(delivered)" });
-                        providerRuntime.appendToolOutput(result.toolCalls[0].id, "(delivered)");
-                        done = true;
+                        if (validDirectReply) {
+                            const resumeWork = "direct reply delivered. resume the unresolved obligation now and keep working until you can finish or clearly report that you are blocked.";
+                            messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: resumeWork });
+                            providerRuntime.appendToolOutput(result.toolCalls[0].id, resumeWork);
+                        }
+                        else {
+                            const delivered = "(delivered)";
+                            messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: delivered });
+                            providerRuntime.appendToolOutput(result.toolCalls[0].id, delivered);
+                            outcome = intent === "blocked" ? "blocked" : "complete";
+                            done = true;
+                        }
                     }
                     else {
                         // Answer is undefined -- the model's final_answer was incomplete or
                         // malformed. Clear any partial streamed text or noise, then push the
                         // assistant msg + error tool result and let the model try again.
                         callbacks.onClearText?.();
-                        const retryError = "your final_answer was incomplete or malformed. call final_answer again with your complete response.";
+                        const retryError = getFinalAnswerRetryError(mustResolveBeforeHandoffActive, intent, sawSteeringFollowUp);
                         messages.push(msg);
                         messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: retryError });
                         providerRuntime.appendToolOutput(result.toolCalls[0].id, retryError);
@@ -485,6 +548,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
             // Abort is not an error — just stop cleanly
             if (signal?.aborted) {
                 stripLastToolCalls(messages);
+                outcome = "aborted";
                 break;
             }
             // Context overflow: trim aggressively and retry once
@@ -519,6 +583,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 });
                 if (aborted) {
                     stripLastToolCalls(messages);
+                    outcome = "aborted";
                     break;
                 }
                 providerRuntime.resetTurnState(messages);
@@ -534,6 +599,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 meta: {},
             });
             stripLastToolCalls(messages);
+            outcome = "errored";
             done = true;
         }
     }
@@ -544,5 +610,5 @@ async function runAgent(messages, callbacks, channel, signal, options) {
         message: "runAgent turn completed",
         meta: { done },
     });
-    return { usage: lastUsage };
+    return { usage: lastUsage, outcome };
 }

package/dist/mind/context.js

@@ -227,7 +227,7 @@ function repairSessionMessages(messages) {
     });
     return result;
 }
-function saveSession(filePath, messages, lastUsage) {
+function saveSession(filePath, messages, lastUsage, state) {
     const violations = validateSessionMessages(messages);
     if (violations.length > 0) {
         (0, runtime_1.emitNervesEvent)({
@@ -243,6 +243,9 @@ function saveSession(filePath, messages, lastUsage) {
     const envelope = { version: 1, messages };
     if (lastUsage)
         envelope.lastUsage = lastUsage;
+    if (state?.mustResolveBeforeHandoff === true) {
+        envelope.state = { mustResolveBeforeHandoff: true };
+    }
     fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
 }
 function loadSession(filePath) {
@@ -263,13 +266,18 @@ function loadSession(filePath) {
             });
             messages = repairSessionMessages(messages);
         }
-        return { messages, lastUsage: data.lastUsage };
+        const state = data?.state && typeof data.state === "object" && data.state !== null
+            && typeof data.state.mustResolveBeforeHandoff === "boolean"
+            && data.state.mustResolveBeforeHandoff === true
+            ? { mustResolveBeforeHandoff: true }
+            : undefined;
+        return { messages, lastUsage: data.lastUsage, state };
     }
     catch {
         return null;
     }
 }
-function postTurn(messages, sessPath, usage, hooks) {
+function postTurn(messages, sessPath, usage, hooks, state) {
     if (hooks?.beforeTrim) {
         try {
             hooks.beforeTrim([...messages]);
@@ -289,7 +297,7 @@ function postTurn(messages, sessPath, usage, hooks) {
     const { maxTokens, contextMargin } = (0, config_1.getContextConfig)();
     const trimmed = trimMessages(messages, maxTokens, contextMargin, usage?.input_tokens);
     messages.splice(0, messages.length, ...trimmed);
-    saveSession(sessPath, messages, usage);
+    saveSession(sessPath, messages, usage, state);
 }
 function deleteSession(filePath) {
     try {

package/dist/mind/first-impressions.js

@@ -11,9 +11,22 @@ exports.ONBOARDING_TOKEN_THRESHOLD = 100_000;
 function isOnboarding(friend) {
     return (friend.totalTokens ?? 0) < exports.ONBOARDING_TOKEN_THRESHOLD;
 }
-function getFirstImpressions(friend) {
+function hasLiveContinuityPressure(state) {
+    if (!state)
+        return false;
+    if (typeof state.currentObligation === "string" && state.currentObligation.trim().length > 0)
+        return true;
+    if (state.mustResolveBeforeHandoff === true)
+        return true;
+    if (state.hasQueuedFollowUp === true)
+        return true;
+    return false;
+}
+function getFirstImpressions(friend, state) {
     if (!isOnboarding(friend))
         return "";
+    if (hasLiveContinuityPressure(state))
+        return "";
     (0, runtime_1.emitNervesEvent)({
         component: "mind",
         event: "mind.first_impressions",

package/dist/mind/prompt.js

@@ -423,7 +423,7 @@ tool_choice is set to "required" -- i must call a tool on every turn.
 \`final_answer\` must be the ONLY tool call in that turn. do not combine it with other tool calls.
 do NOT call no-op tools just before \`final_answer\`. if i am done, i call \`final_answer\` directly.`;
 }
-function contextSection(context) {
+function contextSection(context, options) {
     if (!context)
         return "";
     const lines = ["## friend context"];
@@ -459,7 +459,7 @@ function contextSection(context) {
     lines.push("when i learn something that might invalidate an existing note, i check related notes and update or override any that are stale.");
     lines.push("i save ANYTHING i learn about my friend immediately with save_friend_note -- names, preferences, what they do, what they care about. when in doubt, save it. saving comes BEFORE responding: i call save_friend_note first, then final_answer on the next turn.");
     // Onboarding instructions (only below token threshold -- drop once exceeded)
-    const impressions = (0, first_impressions_1.getFirstImpressions)(friend);
+    const impressions = (0, first_impressions_1.getFirstImpressions)(friend, options);
     if (impressions) {
         lines.push(impressions);
     }
@@ -553,7 +553,7 @@ async function buildSystem(channel = "cli", options, context) {
         }),
         memoryFriendToolContractSection(),
         toolBehaviorSection(options),
-        contextSection(context),
+        contextSection(context, options),
     ]
         .filter(Boolean)
         .join("\n\n");

package/dist/repertoire/tools-base.js

@@ -690,7 +690,10 @@ exports.finalAnswerTool = {
         description: "respond to the user with your message. call this tool when you are ready to deliver your response.",
         parameters: {
             type: "object",
-            properties: { answer: { type: "string" } },
+            properties: {
+                answer: { type: "string" },
+                intent: { type: "string", enum: ["complete", "blocked", "direct_reply"] },
+            },
             required: ["answer"],
         },
     },

package/dist/senses/bluebubbles.js

@@ -147,6 +147,10 @@ function extractMessageText(content) {
         .filter(Boolean)
         .join("\n");
 }
+function isHistoricalLaneMetadataLine(line) {
+    return /^\[(conversation scope|recent active lanes|routing control):?/i.test(line)
+        || /^- (top_level|thread:[^:]+):/i.test(line);
+}
 function extractHistoricalLaneSummary(messages) {
     const seen = new Set();
     const summaries = [];
@@ -171,7 +175,7 @@ function extractHistoricalLaneSummary(messages) {
             .split("\n")
             .slice(1)
             .map((line) => line.trim())
-            .find(Boolean)
+            .find((line) => line.length > 0 && !isHistoricalLaneMetadataLine(line))
             ?.slice(0, 80) ?? "(no recent text)";
         summaries.push({
             key: laneKey,
@@ -230,6 +234,23 @@ function buildInboundContent(event, existingMessages) {
         ...event.inputPartsForAgent,
     ];
 }
+function getBlueBubblesContinuityIngressTexts(event) {
+    if (event.kind !== "message")
+        return [];
+    const text = event.textForAgent.trim();
+    if (text.length > 0)
+        return [text];
+    const fallbackText = (event.inputPartsForAgent ?? [])
+        .map((part) => {
+        if (part.type === "text" && typeof part.text === "string") {
+            return part.text.trim();
+        }
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+    return fallbackText ? [fallbackText] : [];
+}
 function createReplyTargetController(event) {
     const defaultTargetLabel = event.kind === "message" && event.threadOriginatorGuid?.trim() ? "current_lane" : "top_level";
     let selection = event.kind === "message" && event.threadOriginatorGuid?.trim()
@@ -510,9 +531,10 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
             channel: "bluebubbles",
             capabilities: bbCapabilities,
             messages: [userMessage],
+            continuityIngressTexts: getBlueBubblesContinuityIngressTexts(event),
             callbacks,
             friendResolver: { resolve: () => Promise.resolve(context) },
-            sessionLoader: { loadOrCreate: () => Promise.resolve({ messages: sessionMessages, sessionPath: sessPath }) },
+            sessionLoader: { loadOrCreate: () => Promise.resolve({ messages: sessionMessages, sessionPath: sessPath, state: existing?.state }) },
             pendingDir,
             friendStore: store,
             provider: "imessage-handle",

package/dist/senses/cli.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MarkdownStreamer = exports.InputController = exports.Spinner = void 0;
 exports.formatPendingPrefix = formatPendingPrefix;
+exports.getCliContinuityIngressTexts = getCliContinuityIngressTexts;
 exports.handleSigint = handleSigint;
 exports.addHistory = addHistory;
 exports.renderMarkdown = renderMarkdown;
@@ -80,6 +81,10 @@ function formatPendingPrefix(messages, agentName) {
         : `[message from ${msg.from}: ${msg.content}]`)
         .join("\n");
 }
+function getCliContinuityIngressTexts(input) {
+    const trimmed = input.trim();
+    return trimmed ? [trimmed] : [];
+}
 // spinner that only touches stderr, cleans up after itself
 // exported for direct testability (stop-without-start branch)
 class Spinner {
@@ -729,6 +734,7 @@ async function main(agentName, options) {
     }
     // Load existing session or start fresh
     const existing = (0, context_1.loadSession)(sessPath);
+    let sessionState = existing?.state;
     const sessionMessages = existing?.messages && existing.messages.length > 0
         ? existing.messages
         : [{ role: "system", content: await (0, prompt_1.buildSystem)("cli", undefined, resolvedContext) }];
@@ -748,9 +754,10 @@ async function main(agentName, options) {
                     channel: "cli",
                     capabilities: cliCapabilities,
                     messages: [{ role: "user", content: userInput }],
+                    continuityIngressTexts: getCliContinuityIngressTexts(userInput),
                     callbacks,
                     friendResolver: { resolve: () => Promise.resolve(resolvedContext) },
-                    sessionLoader: { loadOrCreate: () => Promise.resolve({ messages, sessionPath: sessPath }) },
+                    sessionLoader: { loadOrCreate: () => Promise.resolve({ messages, sessionPath: sessPath, state: sessionState }) },
                     pendingDir,
                     friendStore,
                     provider: "local",
@@ -766,7 +773,10 @@ async function main(agentName, options) {
                             summarize,
                         },
                     }),
-                    postTurn: context_1.postTurn,
+                    postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
+                        (0, context_1.postTurn)(turnMessages, sessionPathArg, usage, hooks, state);
+                        sessionState = state;
+                    },
                     accumulateFriendTokens: tokens_1.accumulateFriendTokens,
                     signal,
                     runAgentOptions: {

package/dist/senses/continuity.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeContinuityClauses = normalizeContinuityClauses;
+exports.resolveMustResolveBeforeHandoff = resolveMustResolveBeforeHandoff;
+exports.classifySteeringFollowUpEffect = classifySteeringFollowUpEffect;
+const runtime_1 = require("../nerves/runtime");
+const NO_HANDOFF_CLAUSES = new Set([
+    "dont return control until complete or blocked",
+    "do not return control until complete or blocked",
+    "dont hand back control until complete or blocked",
+    "do not hand back control until complete or blocked",
+    "keep going until youre done",
+    "keep going until you are done",
+    "keep working until youre done",
+    "keep working until you are done",
+    "dont stop until youre done",
+    "do not stop until youre done",
+    "only come back if blocked",
+    "only return if blocked",
+    "only respond if blocked",
+    "work autonomously on this",
+    "work on this autonomously",
+    "handle this autonomously",
+]);
+const CANCEL_SUPERSEDE_CLAUSES = new Set([
+    "stop",
+    "cancel that",
+    "cancel this",
+    "never mind",
+    "nevermind",
+    "forget it",
+    "ignore that",
+    "ignore this",
+    "hold off",
+    "ill take it from here",
+    "i will take it from here",
+    "lets do something else",
+    "stop working on that",
+    "stop working on this",
+    "dont do that",
+    "do not do that",
+]);
+function normalizeContinuityClauses(text) {
+    return text
+        .toLowerCase()
+        .split(/[\n.!?;]+/)
+        .map((clause) => clause.replace(/[^a-z\s]/g, "").replace(/\s+/g, " ").trim())
+        .filter(Boolean);
+}
+function resolveMustResolveBeforeHandoff(initialValue, ingressTexts) {
+    let current = initialValue;
+    for (const text of ingressTexts ?? []) {
+        for (const clause of normalizeContinuityClauses(text)) {
+            if (CANCEL_SUPERSEDE_CLAUSES.has(clause)) {
+                current = false;
+                continue;
+            }
+            if (NO_HANDOFF_CLAUSES.has(clause)) {
+                current = true;
+            }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.continuity_state_resolved",
+        message: "resolved continuity handoff state from ingress text",
+        meta: {
+            initialValue,
+            finalValue: current,
+            ingressCount: ingressTexts?.length ?? 0,
+        },
+    });
+    return current;
+}
+function classifySteeringFollowUpEffect(text) {
+    const clauses = normalizeContinuityClauses(text);
+    let effect = "none";
+    if (clauses.some((clause) => CANCEL_SUPERSEDE_CLAUSES.has(clause))) {
+        effect = "clear_and_supersede";
+    }
+    else if (clauses.some((clause) => NO_HANDOFF_CLAUSES.has(clause))) {
+        effect = "set_no_handoff";
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.continuity_follow_up_classified",
+        message: "classified steering follow-up continuity effect",
+        meta: {
+            effect,
+            clauseCount: clauses.length,
+        },
+    });
+    return effect;
+}

package/dist/senses/inner-dialog.js

@@ -248,6 +248,7 @@ async function runInnerDialogTurn(options) {
         channel: "inner",
         capabilities: innerCapabilities,
         messages: [userMessage],
+        continuityIngressTexts: [],
         callbacks,
         friendResolver: { resolve: () => Promise.resolve(selfContext) },
         sessionLoader,

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 continuity_1 = require("./continuity");
 // ── Pipeline ──────────────────────────────────────────────────────
 async function handleInboundTurn(input) {
     // Step 1: Resolve friend
@@ -54,6 +55,11 @@ async function handleInboundTurn(input) {
     // Step 3: Load/create session
     const session = await input.sessionLoader.loadOrCreate();
     const sessionMessages = session.messages;
+    let mustResolveBeforeHandoff = (0, continuity_1.resolveMustResolveBeforeHandoff)(session.state?.mustResolveBeforeHandoff === true, input.continuityIngressTexts);
+    const currentObligation = input.continuityIngressTexts
+        ?.map((text) => text.trim())
+        .filter((text) => text.length > 0)
+        .at(-1);
     // Step 4: Drain pending messages
     const pending = input.drainPending(input.pendingDir);
     // Assemble messages: session messages + pending (formatted) + inbound user messages
@@ -92,6 +98,11 @@ async function handleInboundTurn(input) {
     const existingToolContext = input.runAgentOptions?.toolContext;
     const runAgentOptions = {
         ...input.runAgentOptions,
+        currentObligation,
+        mustResolveBeforeHandoff,
+        setMustResolveBeforeHandoff: (value) => {
+            mustResolveBeforeHandoff = value;
+        },
         toolContext: {
             /* v8 ignore next -- default no-op signin satisfies interface; real signin injected by sense adapter @preserve */
             signin: async () => undefined,
@@ -102,7 +113,12 @@ async function handleInboundTurn(input) {
     };
     const result = await input.runAgent(sessionMessages, input.callbacks, input.channel, input.signal, runAgentOptions);
     // Step 6: postTurn
-    input.postTurn(sessionMessages, session.sessionPath, result.usage);
+    const nextState = result.outcome === "complete" || result.outcome === "blocked" || result.outcome === "superseded"
+        ? undefined
+        : mustResolveBeforeHandoff
+            ? { mustResolveBeforeHandoff: true }
+            : undefined;
+    input.postTurn(sessionMessages, session.sessionPath, result.usage, undefined, nextState);
     // Step 7: Token accumulation
     await input.accumulateFriendTokens(input.friendStore, resolvedContext.friend.id, result.usage);
     (0, runtime_1.emitNervesEvent)({
@@ -118,6 +134,7 @@ async function handleInboundTurn(input) {
         resolvedContext,
         gateResult,
         usage: result.usage,
+        turnOutcome: result.outcome,
         sessionPath: session.sessionPath,
         messages: sessionMessages,
     };

package/dist/senses/teams.js

@@ -68,6 +68,7 @@ const path = __importStar(require("path"));
 const trust_gate_1 = require("./trust-gate");
 const pipeline_1 = require("./pipeline");
 const pending_1 = require("../mind/pending");
+const continuity_1 = require("./continuity");
 // 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
@@ -439,6 +440,34 @@ function getFriendStore() {
     const friendsPath = path.join((0, identity_1.getAgentRoot)(), "friends");
     return new store_file_1.FileFriendStore(friendsPath);
 }
+function createTeamsCommandRegistry() {
+    const registry = (0, commands_1.createCommandRegistry)();
+    (0, commands_1.registerDefaultCommands)(registry);
+    return registry;
+}
+function handleTeamsSlashCommand(text, registry, friendId, conversationId, stream, emitResponse = true) {
+    const parsed = (0, commands_1.parseSlashCommand)(text);
+    if (!parsed)
+        return null;
+    const dispatchResult = registry.dispatch(parsed.command, { channel: "teams" });
+    if (!dispatchResult.handled || !dispatchResult.result) {
+        return null;
+    }
+    if (dispatchResult.result.action === "new") {
+        (0, context_1.deleteSession)((0, config_2.sessionPath)(friendId, "teams", conversationId));
+        if (emitResponse) {
+            stream.emit("session cleared");
+        }
+        return "new";
+    }
+    if (dispatchResult.result.action === "response") {
+        if (emitResponse) {
+            stream.emit(dispatchResult.result.message || "");
+        }
+        return "response";
+    }
+    return null;
+}
 // Handle an incoming Teams message
 async function handleTeamsMessage(text, stream, conversationId, teamsContext, sendMessage) {
     const turnKey = teamsTurnKey(conversationId);
@@ -464,24 +493,10 @@ 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 = (0, commands_1.createCommandRegistry)();
-    (0, commands_1.registerDefaultCommands)(registry);
+    const registry = createTeamsCommandRegistry();
     // Check for slash commands (before pipeline -- these are transport-level concerns)
-    const parsed = (0, commands_1.parseSlashCommand)(text);
-    if (parsed) {
-        const dispatchResult = registry.dispatch(parsed.command, { channel: "teams" });
-        if (dispatchResult.handled && dispatchResult.result) {
-            if (dispatchResult.result.action === "new") {
-                const sessPath = (0, config_2.sessionPath)(friendId, "teams", conversationId);
-                (0, context_1.deleteSession)(sessPath);
-                stream.emit("session cleared");
-                return;
-            }
-            else if (dispatchResult.result.action === "response") {
-                stream.emit(dispatchResult.result.message || "");
-                return;
-            }
-        }
+    if (handleTeamsSlashCommand(text, registry, friendId, conversationId, stream)) {
+        return;
     }
     // ── Teams adapter concerns: controller, callbacks, session path ──────────
     const controller = new AbortController();
@@ -501,76 +516,107 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
         tenantId: teamsContext.tenantId,
         botApi: teamsContext.botApi,
     } : {};
-    // Build runAgentOptions with Teams-specific fields
-    const agentOptions = {
-        traceId,
-        toolContext: teamsToolContext,
-        drainSteeringFollowUps: () => _turnCoordinator.drainFollowUps(turnKey).map((m) => ({ text: m.text })),
-    };
-    if (channelConfig.skipConfirmation)
-        agentOptions.skipConfirmation = true;
-    // ── Call shared pipeline ──────────────────────────────────────────
-    const result = await (0, pipeline_1.handleInboundTurn)({
-        channel: "teams",
-        capabilities: teamsCapabilities,
-        messages: [{ role: "user", content: text }],
-        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", undefined, resolvedContext) }];
-                (0, core_1.repairOrphanedToolCalls)(messages);
-                return { messages, sessionPath: sessPath };
+    let currentText = text;
+    while (true) {
+        let drainedSteeringFollowUps = [];
+        // Build runAgentOptions with Teams-specific fields
+        const agentOptions = {
+            traceId,
+            toolContext: teamsToolContext,
+            drainSteeringFollowUps: () => {
+                drainedSteeringFollowUps = _turnCoordinator.drainFollowUps(turnKey)
+                    .map(({ text: followUpText, effect }) => ({ text: followUpText, effect }));
+                return drainedSteeringFollowUps;
             },
-        },
-        pendingDir,
-        friendStore: store,
-        provider,
-        externalId,
-        tenantId: teamsContext?.tenantId,
-        isGroupChat: false,
-        groupHasFamilyMember: false,
-        hasExistingGroupWithFamily: false,
-        enforceTrustGate: trust_gate_1.enforceTrustGate,
-        drainPending: pending_1.drainPending,
-        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,
+        };
+        if (channelConfig.skipConfirmation)
+            agentOptions.skipConfirmation = true;
+        // ── Call shared pipeline ──────────────────────────────────────────
+        const result = await (0, pipeline_1.handleInboundTurn)({
+            channel: "teams",
+            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", undefined, resolvedContext) }];
+                    (0, core_1.repairOrphanedToolCalls)(messages);
+                    return { messages, sessionPath: sessPath, state: existing?.state };
+                },
             },
-        }),
-        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);
+            pendingDir,
+            friendStore: store,
+            provider,
+            externalId,
+            tenantId: teamsContext?.tenantId,
+            isGroupChat: false,
+            groupHasFamilyMember: false,
+            hasExistingGroupWithFamily: false,
+            enforceTrustGate: trust_gate_1.enforceTrustGate,
+            drainPending: pending_1.drainPending,
+            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);
+            }
+            return;
         }
-        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;
     }
-    // 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);
-    }
-    // SDK auto-closes the stream after our handler returns (app.process.js)
 }
 // Internal port for the secondary bot App (not exposed externally).
 // The primary app proxies /api/messages-secondary → localhost:SECONDARY_PORT/api/messages.
@@ -681,6 +727,41 @@ function registerBotHandlers(app, label) {
         if (resolvePendingConfirmation(convId, text)) {
             return;
         }
+        const commandRegistry = createTeamsCommandRegistry();
+        const parsedSlashCommand = (0, commands_1.parseSlashCommand)(text);
+        if (parsedSlashCommand) {
+            const dispatchResult = commandRegistry.dispatch(parsedSlashCommand.command, { channel: "teams" });
+            if (dispatchResult.handled && dispatchResult.result) {
+                if (dispatchResult.result.action === "response") {
+                    stream.emit(dispatchResult.result.message || "");
+                    return;
+                }
+                if (dispatchResult.result.action === "new") {
+                    const commandStore = getFriendStore();
+                    const commandProvider = activity.from?.aadObjectId ? "aad" : "teams-conversation";
+                    const commandExternalId = activity.from?.aadObjectId || convId;
+                    const commandResolver = new resolver_1.FriendResolver(commandStore, {
+                        provider: commandProvider,
+                        externalId: commandExternalId,
+                        tenantId: activity.conversation?.tenantId,
+                        displayName: activity.from?.name || "Unknown",
+                        channel: "teams",
+                    });
+                    const commandContext = await commandResolver.resolve();
+                    (0, context_1.deleteSession)((0, config_2.sessionPath)(commandContext.friend.id, "teams", convId));
+                    stream.emit("session cleared");
+                    if (_turnCoordinator.isTurnActive(turnKey)) {
+                        _turnCoordinator.enqueueFollowUp(turnKey, {
+                            conversationId: convId,
+                            text,
+                            receivedAt: Date.now(),
+                            effect: "clear_and_supersede",
+                        });
+                    }
+                    return;
+                }
+            }
+        }
         // If this conversation already has an active turn, steer follow-up input
         // into that turn and avoid starting a second concurrent turn.
         if (!_turnCoordinator.tryBeginTurn(turnKey)) {
@@ -688,6 +769,7 @@ function registerBotHandlers(app, label) {
                 conversationId: convId,
                 text,
                 receivedAt: Date.now(),
+                effect: (0, continuity_1.classifySteeringFollowUpEffect)(text),
             });
             return;
         }

package/package.json

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