@ouro.bot/cli 0.1.0-alpha.102 → 0.1.0-alpha.104

package/changelog.json

@@ -1,6 +1,20 @@
 {
   "_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.104",
+      "changes": [
+        "Family-scoped status checks now keep the five-line header anchored on the current live conversation while appending an `other active sessions:` block for every other live lane the agent is actively working.",
+        "The inbound pipeline, active-work frame, prompt steering, and status retry logic now preserve non-current live coding lanes and obligations so family status answers stop hiding parallel work in other sessions."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.103",
+      "changes": [
+        "Status-check turns now answer in a fixed live-state shape that names the current conversation, active lane, artifact, latest checkpoint, and next action instead of drifting into broad mission summaries.",
+        "Those status turns now hold final streaming until the exact reply is ready and turn report-backs into same-thread obligation updates, so 'I'll report back here' comes back as a real in-thread follow-up instead of hidden background work."
+      ]
+    },
     {
       "version": "0.1.0-alpha.102",
       "changes": [

package/dist/heart/active-work.js

@@ -63,6 +63,24 @@ function formatObligationSurface(obligation) {
             return ` (${obligation.currentSurface.label})`;
     }
 }
+function mergeArtifactFallback(obligation) {
+    const trimmed = obligation.content.trim();
+    if (!trimmed)
+        return "the fix";
+    const stripped = trimmed.replace(/^merge(?:\s+|$)/i, "").trim();
+    return stripped || "the fix";
+}
+function formatMergeArtifact(obligation) {
+    const currentArtifact = obligation.currentArtifact?.trim();
+    if (currentArtifact)
+        return currentArtifact;
+    if (obligation.currentSurface?.kind === "merge") {
+        const surfaceLabel = obligation.currentSurface.label.trim();
+        if (surfaceLabel)
+            return surfaceLabel;
+    }
+    return mergeArtifactFallback(obligation);
+}
 function findPrimaryOpenObligation(frame) {
     return (frame.pendingObligations ?? []).find((ob) => ob.status !== "pending" && ob.status !== "fulfilled")
         ?? (frame.pendingObligations ?? []).find(obligations_1.isOpenObligation)
@@ -79,6 +97,9 @@ function formatActiveLane(frame, obligation) {
     if (frame.inner?.job?.status === "running") {
         return "inner dialog";
     }
+    if (typeof frame.currentObligation === "string" && frame.currentObligation.trim().length > 0 && frame.currentSession) {
+        return "this same thread";
+    }
     return null;
 }
 function formatCurrentArtifact(frame, obligation) {
@@ -91,6 +112,9 @@ function formatCurrentArtifact(frame, obligation) {
     if ((frame.codingSessions ?? []).length > 0) {
         return "no PR or merge artifact yet";
     }
+    if (typeof frame.currentObligation === "string" && frame.currentObligation.trim().length > 0) {
+        return "no artifact yet";
+    }
     return null;
 }
 function formatNextAction(frame, obligation) {
@@ -108,8 +132,7 @@ function formatNextAction(frame, obligation) {
         return "finish the coding pass and bring the result back here";
     }
     if (obligation?.status === "waiting_for_merge") {
-        const artifact = formatCurrentArtifact(frame, obligation) ?? "the fix";
-        return `wait for checks, merge ${artifact}, then update runtime`;
+        return `wait for checks, merge ${formatMergeArtifact(obligation)}, then update runtime`;
     }
     if (obligation?.status === "updating_runtime") {
         return "update runtime, verify version/changelog, then re-observe";
@@ -117,6 +140,9 @@ function formatNextAction(frame, obligation) {
     if (obligation) {
         return "continue the active loop and bring the result back here";
     }
+    if (typeof frame.currentObligation === "string" && frame.currentObligation.trim().length > 0) {
+        return `work on "${frame.currentObligation.trim()}" and bring back a concrete artifact`;
+    }
     return null;
 }
 function suggestBridgeForActiveWork(input) {
@@ -177,6 +203,9 @@ function buildActiveWorkFrame(input) {
     const activeBridgePresent = input.bridges.some(isActiveBridge);
     const openObligations = activeObligationCount(input.pendingObligations);
     const liveCodingSessions = input.codingSessions ?? [];
+    const allOtherLiveSessions = [...input.friendActivity].sort(compareActivity);
+    const otherCodingSessions = input.otherCodingSessions ?? [];
+    const pendingObligations = input.pendingObligations ?? [];
     const centerOfGravity = activeBridgePresent
         ? "shared-work"
         : (input.inner.status === "running" || input.inner.hasPending || input.mustResolveBeforeHandoff || openObligations > 0 || liveCodingSessions.length > 0)
@@ -197,9 +226,11 @@ function buildActiveWorkFrame(input) {
         friendActivity: {
             freshestForCurrentFriend: friendSessions[0] ?? null,
             otherLiveSessionsForCurrentFriend: friendSessions,
+            allOtherLiveSessions,
         },
         codingSessions: liveCodingSessions,
-        pendingObligations: input.pendingObligations ?? [],
+        otherCodingSessions,
+        pendingObligations,
         targetCandidates: input.targetCandidates ?? [],
         bridgeSuggestion: suggestBridgeForActiveWork({
             currentSession: input.currentSession,
@@ -221,6 +252,8 @@ function buildActiveWorkFrame(input) {
             liveTasks: frame.taskPressure.liveTaskNames.length,
             liveSessions: frame.friendActivity.otherLiveSessionsForCurrentFriend.length,
             codingSessions: frame.codingSessions.length,
+            otherLiveSessions: allOtherLiveSessions.length,
+            otherCodingSessions: otherCodingSessions.length,
             pendingObligations: openObligations,
             hasBridgeSuggestion: frame.bridgeSuggestion !== null,
         },
@@ -233,6 +266,8 @@ function formatActiveWorkFrame(frame) {
     const activeLane = formatActiveLane(frame, primaryObligation);
     const currentArtifact = formatCurrentArtifact(frame, primaryObligation);
     const nextAction = formatNextAction(frame, primaryObligation);
+    const otherCodingSessions = frame.otherCodingSessions ?? [];
+    const otherLiveSessions = frame.friendActivity?.allOtherLiveSessions ?? [];
     // Session line
     if (frame.currentSession) {
         let sessionLine = `i'm in a conversation on ${formatSessionLabel(frame.currentSession)}.`;
@@ -305,6 +340,23 @@ function formatActiveWorkFrame(frame) {
             lines.push(`- [${session.status}] ${formatCodingLaneLabel(session)}${describeCodingSessionScope(session, frame.currentSession)}`);
         }
     }
+    if (otherCodingSessions.length > 0) {
+        lines.push("");
+        lines.push("## other live coding work");
+        for (const session of otherCodingSessions) {
+            const origin = session.originSession
+                ? `${session.originSession.friendId}/${session.originSession.channel}/${session.originSession.key}`
+                : "another session";
+            lines.push(`- [${session.status}] ${formatCodingLaneLabel(session)} for ${origin}`);
+        }
+    }
+    if (otherLiveSessions.length > 0) {
+        lines.push("");
+        lines.push("## other live sessions");
+        for (const session of otherLiveSessions) {
+            lines.push(`- ${session.friendName}/${session.channel}/${session.key}`);
+        }
+    }
     // Task pressure
     if ((frame.taskPressure?.liveTaskNames ?? []).length > 0) {
         lines.push("");

package/dist/heart/core.js

@@ -27,6 +27,7 @@ const azure_1 = require("./providers/azure");
 const minimax_1 = require("./providers/minimax");
 const openai_codex_1 = require("./providers/openai-codex");
 const github_copilot_1 = require("./providers/github-copilot");
+const obligation_steering_1 = require("../mind/obligation-steering");
 const pending_1 = require("../mind/pending");
 const identity_2 = require("./identity");
 const socket_client_1 = require("./daemon/socket-client");
@@ -272,6 +273,45 @@ function getFinalAnswerRetryError(mustResolveBeforeHandoff, intent, sawSteeringF
     }
     return null;
 }
+function hasExactStatusReplyShape(answer, statusCheckScope) {
+    const lines = answer.trimEnd().split(/\r?\n/);
+    const hasFiveLineHeader = (/^live conversation:\s+\S.+$/i.test(lines[0])
+        && /^active lane:\s+\S.+$/i.test(lines[1])
+        && /^current artifact:\s+\S.+$/i.test(lines[2])
+        && /^latest checkpoint:\s+\S.+$/i.test(lines[3])
+        && /^next action:\s+\S.+$/i.test(lines[4]));
+    if (!hasFiveLineHeader)
+        return false;
+    if (statusCheckScope !== "all-sessions-family") {
+        return lines.length === 5;
+    }
+    if (lines.length < 7)
+        return false;
+    if (!/^other active sessions:\s*$/i.test(lines[5]))
+        return false;
+    return lines.slice(6).every((line) => /^-\s+\S.+$/i.test(line));
+}
+function extractLatestCheckpoint(answer) {
+    const latestLine = answer.trimEnd().split(/\r?\n/)[3];
+    return latestLine.replace(/^latest checkpoint:\s*/i, "").trim();
+}
+function getStatusReplyRetryError(answer, statusCheckRequested, activeWorkFrame, statusCheckScope) {
+    if (!statusCheckRequested || answer == null)
+        return null;
+    if (hasExactStatusReplyShape(answer, statusCheckScope))
+        return null;
+    if (!activeWorkFrame) {
+        return `the user asked for current status. call final_answer again using exactly these five non-empty lines and nothing else:
+live conversation: ...
+active lane: ...
+current artifact: ...
+latest checkpoint: ...
+next action: ...`;
+    }
+    return `the user asked for current status right now.
+${(0, obligation_steering_1.renderExactStatusReplyContract)(activeWorkFrame, (0, obligation_steering_1.findStatusObligation)(activeWorkFrame), statusCheckScope)}
+call final_answer again using that exact status shape and nothing else.`;
+}
 // Re-export kick utilities for backward compat
 var kicks_1 = require("./kicks");
 Object.defineProperty(exports, "hasToolIntent", { enumerable: true, get: function () { return kicks_1.hasToolIntent; } });
@@ -551,6 +591,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 traceId,
                 toolChoiceRequired,
                 reasoningEffort: currentReasoningEffort,
+                eagerFinalAnswerStreaming: !options?.statusCheckRequested,
             });
             // Track usage from the latest API call
             if (result.usage)
@@ -599,15 +640,21 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                     // Supports: {"answer":"text","intent":"..."} or "text" (JSON string).
                     const { answer, intent } = parseFinalAnswerPayload(result.toolCalls[0].arguments);
                     const retryError = getFinalAnswerRetryError(mustResolveBeforeHandoffActive, intent, sawSteeringFollowUp, options?.delegationDecision, sawSendMessageSelf, sawGoInward, sawQuerySession, options?.currentObligation ?? null, options?.activeWorkFrame?.inner?.job, sawExternalStateQuery);
+                    const statusReplyRetryError = getStatusReplyRetryError(answer, options?.statusCheckRequested, options?.activeWorkFrame, options?.statusCheckScope);
+                    const exactStatusReplyAccepted = Boolean(options?.statusCheckRequested) && !statusReplyRetryError && answer != null;
+                    const deliveredAnswer = exactStatusReplyAccepted && options?.activeWorkFrame
+                        ? (0, obligation_steering_1.buildExactStatusReply)(options.activeWorkFrame, (0, obligation_steering_1.findStatusObligation)(options.activeWorkFrame), extractLatestCheckpoint(answer), options?.statusCheckScope)
+                        : answer;
                     const validDirectReply = mustResolveBeforeHandoffActive && intent === "direct_reply" && sawSteeringFollowUp;
                     const validTerminalIntent = intent === "complete" || intent === "blocked";
-                    const validClosure = answer != null
-                        && !retryError
-                        && (!mustResolveBeforeHandoffActive || validDirectReply || validTerminalIntent);
+                    const validClosure = deliveredAnswer != null
+                        && (exactStatusReplyAccepted || !retryError)
+                        && !statusReplyRetryError
+                        && (exactStatusReplyAccepted || !mustResolveBeforeHandoffActive || validDirectReply || validTerminalIntent);
                     if (validClosure) {
                         completion = {
-                            answer,
-                            intent: validDirectReply ? "direct_reply" : intent === "blocked" ? "blocked" : "complete",
+                            answer: deliveredAnswer,
+                            intent: validDirectReply && !exactStatusReplyAccepted ? "direct_reply" : intent === "blocked" ? "blocked" : "complete",
                         };
                         if (result.finalAnswerStreamed) {
                             // The streaming layer already parsed and emitted the answer
@@ -619,10 +666,10 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             callbacks.onClearText?.();
                             // Emit the answer through the callback pipeline so channels receive it.
                             // Never truncate -- channel adapters handle splitting long messages.
-                            callbacks.onTextChunk(answer);
+                            callbacks.onTextChunk(deliveredAnswer);
                         }
                         messages.push(msg);
-                        if (validDirectReply) {
+                        if (validDirectReply && !exactStatusReplyAccepted) {
                             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);
@@ -641,8 +688,11 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         // assistant msg + error tool result and let the model try again.
                         callbacks.onClearText?.();
                         messages.push(msg);
-                        messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: retryError ?? "your final_answer was incomplete or malformed. call final_answer again with your complete response." });
-                        providerRuntime.appendToolOutput(result.toolCalls[0].id, retryError ?? "your final_answer was incomplete or malformed. call final_answer again with your complete response.");
+                        const toolRetryMessage = statusReplyRetryError
+                            ?? retryError
+                            ?? "your final_answer was incomplete or malformed. call final_answer again with your complete response.";
+                        messages.push({ role: "tool", tool_call_id: result.toolCalls[0].id, content: toolRetryMessage });
+                        providerRuntime.appendToolOutput(result.toolCalls[0].id, toolRetryMessage);
                     }
                     continue;
                 }

package/dist/heart/providers/anthropic.js

@@ -238,7 +238,7 @@ async function streamAnthropicMessages(client, model, request) {
     const toolCalls = new Map();
     const thinkingBlocks = new Map();
     const redactedBlocks = new Map();
-    const answerStreamer = new streaming_1.FinalAnswerStreamer(request.callbacks);
+    const answerStreamer = new streaming_1.FinalAnswerStreamer(request.callbacks, request.eagerFinalAnswerStreaming);
     try {
         for await (const event of response) {
             if (request.signal?.aborted)

package/dist/heart/providers/azure.js

@@ -136,7 +136,7 @@ function createAzureProviderRuntime() {
                 params.metadata = { trace_id: request.traceId };
             if (request.toolChoiceRequired)
                 params.tool_choice = "required";
-            const result = await (0, streaming_1.streamResponsesApi)(this.client, params, request.callbacks, request.signal);
+            const result = await (0, streaming_1.streamResponsesApi)(this.client, params, request.callbacks, request.signal, request.eagerFinalAnswerStreaming);
             for (const item of result.outputItems)
                 nativeInput.push(item);
             return result;

package/dist/heart/providers/github-copilot.js

@@ -88,7 +88,7 @@ function createGithubCopilotProviderRuntime() {
                 if (request.toolChoiceRequired)
                     params.tool_choice = "required";
                 try {
-                    return await (0, streaming_1.streamChatCompletion)(this.client, params, request.callbacks, request.signal);
+                    return await (0, streaming_1.streamChatCompletion)(this.client, params, request.callbacks, request.signal, request.eagerFinalAnswerStreaming);
                 }
                 catch (error) {
                     throw withAuthGuidance(error);
@@ -135,7 +135,7 @@ function createGithubCopilotProviderRuntime() {
             if (request.toolChoiceRequired)
                 params.tool_choice = "required";
             try {
-                const result = await (0, streaming_1.streamResponsesApi)(this.client, params, request.callbacks, request.signal);
+                const result = await (0, streaming_1.streamResponsesApi)(this.client, params, request.callbacks, request.signal, request.eagerFinalAnswerStreaming);
                 for (const item of result.outputItems)
                     nativeInput.push(item);
                 return result;

package/dist/heart/providers/minimax.js

@@ -51,7 +51,7 @@ function createMinimaxProviderRuntime() {
                 params.metadata = { trace_id: request.traceId };
             if (request.toolChoiceRequired)
                 params.tool_choice = "required";
-            return (0, streaming_1.streamChatCompletion)(this.client, params, request.callbacks, request.signal);
+            return (0, streaming_1.streamChatCompletion)(this.client, params, request.callbacks, request.signal, request.eagerFinalAnswerStreaming);
         },
     };
 }

package/dist/heart/providers/openai-codex.js

@@ -158,7 +158,7 @@ function createOpenAICodexProviderRuntime() {
             if (request.toolChoiceRequired)
                 params.tool_choice = "required";
             try {
-                const result = await (0, streaming_1.streamResponsesApi)(this.client, params, request.callbacks, request.signal);
+                const result = await (0, streaming_1.streamResponsesApi)(this.client, params, request.callbacks, request.signal, request.eagerFinalAnswerStreaming);
                 for (const item of result.outputItems)
                     nativeInput.push(item);
                 return result;

package/dist/heart/streaming.js

@@ -84,13 +84,17 @@ class FinalAnswerStreamer {
     parser = new FinalAnswerParser();
     _detected = false;
     callbacks;
-    constructor(callbacks) {
+    enabled;
+    constructor(callbacks, enabled = true) {
         this.callbacks = callbacks;
+        this.enabled = enabled;
     }
     get detected() { return this._detected; }
     get streamed() { return this.parser.active; }
     /** Mark final_answer as detected. Calls onClearText on the callbacks. */
     activate() {
+        if (!this.enabled)
+            return;
         if (this._detected)
             return;
         this._detected = true;
@@ -98,6 +102,8 @@ class FinalAnswerStreamer {
     }
     /** Feed an argument delta through the parser. Emits text via onTextChunk. */
     processDelta(delta) {
+        if (!this.enabled)
+            return;
         if (!this._detected)
             return;
         const text = this.parser.process(delta);
@@ -227,7 +233,7 @@ function toResponsesTools(ccTools) {
         strict: false,
     }));
 }
-async function streamChatCompletion(client, createParams, callbacks, signal) {
+async function streamChatCompletion(client, createParams, callbacks, signal, eagerFinalAnswerStreaming = true) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.stream_start",
@@ -241,7 +247,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
     let toolCalls = {};
     let streamStarted = false;
     let usage;
-    const answerStreamer = new FinalAnswerStreamer(callbacks);
+    const answerStreamer = new FinalAnswerStreamer(callbacks, eagerFinalAnswerStreaming);
     // State machine for parsing inline <think> tags (MiniMax pattern)
     let contentBuf = "";
     let inThinkTag = false;
@@ -387,7 +393,7 @@ async function streamChatCompletion(client, createParams, callbacks, signal) {
         finalAnswerStreamed: answerStreamer.streamed,
     };
 }
-async function streamResponsesApi(client, createParams, callbacks, signal) {
+async function streamResponsesApi(client, createParams, callbacks, signal, eagerFinalAnswerStreaming = true) {
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.stream_start",
@@ -402,7 +408,7 @@ async function streamResponsesApi(client, createParams, callbacks, signal) {
     const outputItems = [];
     let currentToolCall = null;
     let usage;
-    const answerStreamer = new FinalAnswerStreamer(callbacks);
+    const answerStreamer = new FinalAnswerStreamer(callbacks, eagerFinalAnswerStreaming);
     let functionCallCount = 0;
     for await (const event of response) {
         if (signal?.aborted)

package/dist/mind/obligation-steering.js

@@ -1,14 +1,139 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findActivePersistentObligation = findActivePersistentObligation;
+exports.findStatusObligation = findStatusObligation;
 exports.renderActiveObligationSteering = renderActiveObligationSteering;
 exports.renderConcreteStatusGuidance = renderConcreteStatusGuidance;
+exports.renderLiveThreadStatusShape = renderLiveThreadStatusShape;
+exports.buildExactStatusReply = buildExactStatusReply;
+exports.renderExactStatusReplyContract = renderExactStatusReplyContract;
 const runtime_1 = require("../nerves/runtime");
 function findActivePersistentObligation(frame) {
     if (!frame)
         return null;
     return (frame.pendingObligations ?? []).find((ob) => ob.status !== "pending" && ob.status !== "fulfilled") ?? null;
 }
+function obligationTimestampMs(obligation) {
+    return Date.parse(obligation.updatedAt ?? obligation.createdAt);
+}
+function newestObligationFirst(left, right) {
+    return obligationTimestampMs(right) - obligationTimestampMs(left);
+}
+function matchesCurrentSession(frame, obligation) {
+    return matchesSessionOrigin(frame, obligation.origin);
+}
+function matchesSessionOrigin(frame, origin) {
+    return Boolean(frame.currentSession
+        && origin.friendId === frame.currentSession.friendId
+        && origin.channel === frame.currentSession.channel
+        && origin.key === frame.currentSession.key);
+}
+function sessionOriginKey(origin) {
+    return `${origin.friendId}/${origin.channel}/${origin.key}`;
+}
+function codingSessionTimestampMs(session) {
+    return Date.parse(session.lastActivityAt ?? session.startedAt);
+}
+function formatCodingLaneLabel(session) {
+    return `${session.runner} ${session.id}`;
+}
+function formatOtherSessionArtifact(obligation, codingSession) {
+    if (obligation?.currentArtifact?.trim())
+        return obligation.currentArtifact.trim();
+    if (obligation?.currentSurface?.kind === "merge" && obligation.currentSurface.label.trim()) {
+        return obligation.currentSurface.label.trim();
+    }
+    if (codingSession)
+        return "no PR or merge artifact yet";
+    return "no artifact yet";
+}
+function formatOtherSessionNextAction(obligation, codingSession) {
+    if (obligation?.nextAction?.trim())
+        return obligation.nextAction.trim();
+    if (obligation?.status === "waiting_for_merge") {
+        return `wait for checks, merge ${formatMergeArtifact(obligation)}, then update runtime`;
+    }
+    if (obligation?.status === "updating_runtime") {
+        return "update runtime, verify version/changelog, then re-observe";
+    }
+    if (codingSession?.status === "waiting_input") {
+        return `answer ${formatCodingLaneLabel(codingSession)} and continue`;
+    }
+    if (codingSession?.status === "stalled") {
+        return `unstick ${formatCodingLaneLabel(codingSession)} and continue`;
+    }
+    if (codingSession) {
+        return "finish the coding pass and bring the result back there";
+    }
+    if (obligation) {
+        return "continue the active loop and bring the result back there";
+    }
+    return "check this session and bring back the latest concrete state";
+}
+function findFriendNameForOrigin(frame, origin) {
+    return (frame.friendActivity?.allOtherLiveSessions ?? []).find((entry) => entry.friendId === origin.friendId
+        && entry.channel === origin.channel
+        && entry.key === origin.key)?.friendName ?? origin.friendId;
+}
+function buildOtherActiveSessionLines(frame) {
+    const originMap = new Map();
+    for (const session of frame.friendActivity?.allOtherLiveSessions ?? []) {
+        originMap.set(sessionOriginKey(session), {
+            friendId: session.friendId,
+            channel: session.channel,
+            key: session.key,
+        });
+    }
+    for (const session of frame.otherCodingSessions ?? []) {
+        if (!session.originSession || matchesSessionOrigin(frame, session.originSession))
+            continue;
+        originMap.set(sessionOriginKey(session.originSession), session.originSession);
+    }
+    for (const obligation of frame.pendingObligations ?? []) {
+        if (obligation.status === "fulfilled" || matchesSessionOrigin(frame, obligation.origin))
+            continue;
+        originMap.set(sessionOriginKey(obligation.origin), obligation.origin);
+    }
+    const summaries = [...originMap.values()].map((origin) => {
+        const obligation = [...(frame.pendingObligations ?? [])]
+            .filter((candidate) => candidate.status !== "fulfilled" && sessionOriginKey(candidate.origin) === sessionOriginKey(origin))
+            .sort(newestObligationFirst)[0] ?? null;
+        const codingSession = [...(frame.otherCodingSessions ?? [])]
+            .filter((candidate) => candidate.originSession && sessionOriginKey(candidate.originSession) === sessionOriginKey(origin))
+            .sort((left, right) => codingSessionTimestampMs(right) - codingSessionTimestampMs(left))[0] ?? null;
+        const liveSession = (frame.friendActivity?.allOtherLiveSessions ?? []).find((candidate) => sessionOriginKey(candidate) === sessionOriginKey(origin)) ?? null;
+        const timestampMs = Math.max(liveSession?.lastActivityMs ?? 0, codingSession ? codingSessionTimestampMs(codingSession) : 0, obligation ? obligationTimestampMs(obligation) : 0);
+        const activeLane = codingSession
+            ? formatCodingLaneLabel(codingSession)
+            : obligation?.currentSurface?.label?.trim() || "this live thread";
+        const artifact = formatOtherSessionArtifact(obligation, codingSession);
+        const nextAction = formatOtherSessionNextAction(obligation, codingSession);
+        const status = obligation?.status ?? codingSession?.status ?? "active";
+        const friendName = findFriendNameForOrigin(frame, origin);
+        return {
+            timestampMs,
+            line: `- ${friendName}/${origin.channel}/${origin.key}: [${status}] ${activeLane}; artifact ${artifact}; next ${nextAction}`,
+        };
+    }).sort((left, right) => right.timestampMs - left.timestampMs);
+    return summaries.length > 0 ? summaries.map((entry) => entry.line) : ["- none"];
+}
+function findStatusObligation(frame) {
+    if (!frame)
+        return null;
+    const openObligations = [...(frame.pendingObligations ?? [])]
+        .filter((obligation) => obligation.status !== "fulfilled")
+        .sort(newestObligationFirst);
+    const sameSession = openObligations.find((obligation) => matchesCurrentSession(frame, obligation));
+    if (sameSession)
+        return sameSession;
+    return openObligations[0] ?? null;
+}
+function findCurrentSessionStatusObligation(frame) {
+    const openObligations = [...(frame.pendingObligations ?? [])]
+        .filter((obligation) => obligation.status !== "fulfilled")
+        .sort(newestObligationFirst);
+    return openObligations.find((obligation) => matchesCurrentSession(frame, obligation)) ?? null;
+}
 function renderActiveObligationSteering(obligation) {
     (0, runtime_1.emitNervesEvent)({
         component: "mind",
@@ -30,6 +155,24 @@ i'm already working on something i owe ${name}.${surfaceLine}
 
 i should close that loop before i act like this is a fresh blank turn.`;
 }
+function mergeArtifactFallback(obligation) {
+    const trimmed = obligation.content.trim();
+    if (!trimmed)
+        return "the fix";
+    const stripped = trimmed.replace(/^merge(?:\s+|$)/i, "").trim();
+    return stripped || "the fix";
+}
+function formatMergeArtifact(obligation) {
+    const currentArtifact = obligation.currentArtifact?.trim();
+    if (currentArtifact)
+        return currentArtifact;
+    if (obligation.currentSurface?.kind === "merge") {
+        const surfaceLabel = obligation.currentSurface.label.trim();
+        if (surfaceLabel)
+            return surfaceLabel;
+    }
+    return mergeArtifactFallback(obligation);
+}
 function formatActiveLane(frame, obligation) {
     const liveCodingSession = frame.codingSessions?.[0];
     if (liveCodingSession) {
@@ -44,16 +187,31 @@ function formatActiveLane(frame, obligation) {
                 ? `${liveCodingSession.runner} ${liveCodingSession.id} for ${liveCodingSession.originSession.channel}/${liveCodingSession.originSession.key}`
                 : `${liveCodingSession.runner} ${liveCodingSession.id}`;
     }
-    return obligation.currentSurface?.label || "this live loop";
+    return obligation.currentSurface?.label
+        || (frame.currentObligation?.trim() ? "this same thread" : "this live loop");
 }
 function formatCurrentArtifact(frame, obligation) {
-    return obligation.currentArtifact
-        || (obligation.currentSurface?.kind === "merge" ? obligation.currentSurface.label : "")
-        || ((frame.codingSessions ?? []).length > 0 ? "no PR or merge artifact yet" : "no explicit artifact yet");
+    if (obligation?.currentArtifact)
+        return obligation.currentArtifact;
+    if (obligation?.currentSurface?.kind === "merge")
+        return obligation.currentSurface.label;
+    if (frame.currentObligation?.trim())
+        return "no artifact yet";
+    if ((frame.codingSessions ?? []).length > 0)
+        return "no PR or merge artifact yet";
+    return obligation ? "no explicit artifact yet" : "";
+}
+function isStatusCheckPrompt(text) {
+    const trimmed = text?.trim();
+    if (!trimmed)
+        return false;
+    return /^(what are you doing|what(?:'|’)s your status|status|status update|what changed|where are you at|where things stand)\??$/i.test(trimmed);
 }
 function formatNextAction(frame, obligation) {
-    if (obligation.nextAction)
+    if (obligation?.nextAction)
         return obligation.nextAction;
+    const currentObligation = frame.currentObligation?.trim() ?? "";
+    const statusCheckPrompt = isStatusCheckPrompt(currentObligation);
     const liveCodingSession = frame.codingSessions?.[0];
     if (liveCodingSession?.status === "waiting_input") {
         return `answer ${liveCodingSession.runner} ${liveCodingSession.id} and continue`;
@@ -64,24 +222,91 @@ function formatNextAction(frame, obligation) {
     if (liveCodingSession) {
         return "finish the coding pass and bring the result back here";
     }
-    if (obligation.status === "waiting_for_merge") {
-        return `wait for checks, merge ${formatCurrentArtifact(frame, obligation)}, then update runtime`;
+    if (obligation?.status === "waiting_for_merge") {
+        return `wait for checks, merge ${formatMergeArtifact(obligation)}, then update runtime`;
     }
-    if (obligation.status === "updating_runtime") {
+    if (obligation?.status === "updating_runtime") {
         return "update runtime, verify version/changelog, then re-observe";
     }
-    return "continue the active loop and bring the result back here";
+    if (currentObligation && !statusCheckPrompt) {
+        return `work on "${currentObligation}" and bring back a concrete artifact`;
+    }
+    return obligation ? "continue the active loop and bring the result back here" : "";
 }
 function renderConcreteStatusGuidance(frame, obligation) {
-    if (!obligation)
-        return "";
-    const activeLane = formatActiveLane(frame, obligation);
+    const activeLane = obligation ? formatActiveLane(frame, obligation) : (frame.currentObligation?.trim() ? "this same thread" : "");
     const currentArtifact = formatCurrentArtifact(frame, obligation);
     const nextAction = formatNextAction(frame, obligation);
-    return `if someone asks what i'm doing or for status, i answer from the concrete state:
-- active lane: ${activeLane}
-- current artifact: ${currentArtifact}
-- next action: ${nextAction}
+    const liveConversation = frame.currentSession
+        ? `${frame.currentSession.channel}/${frame.currentSession.key}`
+        : "";
+    if (!activeLane && !currentArtifact && !nextAction)
+        return "";
+    return `if someone asks what i'm doing or for status mid-task, i answer from these live facts instead of copying a canned block.
+the live conversation is ${liveConversation || "not in a live conversation"}.
+the active lane is ${activeLane}.
+the current artifact is ${currentArtifact}.
+if i just finished or verified something concrete in this live lane, i name that as the latest checkpoint.
+the next action is ${nextAction}.
+
+i use those facts to answer naturally unless this turn is an explicit direct status check, where the separate exact five-line contract applies.`;
+}
+function renderLiveThreadStatusShape(frame) {
+    if (!frame.currentSession)
+        return "";
+    return `if someone asks what i'm doing or for status mid-task in this live thread, i answer in these exact lines, in order, with no intro paragraph:
+live conversation: ${frame.currentSession.channel}/${frame.currentSession.key}
+active lane: this same thread
+current artifact: <actual artifact or "no artifact yet">
+latest checkpoint: <freshest concrete thing i just finished or verified>
+next action: <smallest concrete next step i'm taking now>
 
-i don't replace that with a broad mission statement if this concrete state is available.`;
+no recap paragraph before those lines.
+no option list.
+present tense only.
+if a finished step matters, i label it "just finished" instead of presenting it as current work.`;
+}
+function buildExactStatusReply(frame, obligation, latestCheckpoint, statusCheckScope) {
+    const headerObligation = statusCheckScope === "all-sessions-family"
+        ? findCurrentSessionStatusObligation(frame)
+        : obligation;
+    const liveConversation = frame.currentSession
+        ? `${frame.currentSession.channel}/${frame.currentSession.key}`
+        : "not in a live conversation";
+    const activeLane = headerObligation
+        ? formatActiveLane(frame, headerObligation)
+        : (frame.currentSession ? "this same thread" : "this live loop");
+    const currentArtifact = formatCurrentArtifact(frame, headerObligation) || "no artifact yet";
+    const nextAction = formatNextAction(frame, headerObligation) || "continue the active loop and bring the result back here";
+    const latest = latestCheckpoint.trim() || "<freshest concrete thing i just finished or verified>";
+    const lines = [
+        `live conversation: ${liveConversation}`,
+        `active lane: ${activeLane}`,
+        `current artifact: ${currentArtifact}`,
+        `latest checkpoint: ${latest}`,
+        `next action: ${nextAction}`,
+    ];
+    if (statusCheckScope === "all-sessions-family") {
+        lines.push("other active sessions:");
+        lines.push(...buildOtherActiveSessionLines(frame));
+    }
+    return lines.join("\n");
+}
+function renderExactStatusReplyContract(frame, obligation, statusCheckScope) {
+    const headerObligation = statusCheckScope === "all-sessions-family"
+        ? findCurrentSessionStatusObligation(frame)
+        : obligation;
+    if (statusCheckScope === "all-sessions-family") {
+        return `reply using exactly this status shape and nothing else:
+live conversation: ${frame.currentSession ? `${frame.currentSession.channel}/${frame.currentSession.key}` : "not in a live conversation"}
+active lane: ${headerObligation ? formatActiveLane(frame, headerObligation) : (frame.currentSession ? "this same thread" : "this live loop")}
+current artifact: ${formatCurrentArtifact(frame, headerObligation) || "no artifact yet"}
+latest checkpoint: <freshest concrete thing i just finished or verified>
+next action: ${formatNextAction(frame, headerObligation) || "continue the active loop and bring the result back here"}
+other active sessions:
+- <session label>: <what i'm doing there right now>`;
+    }
+    return `reply using exactly these five lines and nothing else:
+${buildExactStatusReply(frame, obligation, "<freshest concrete thing i just finished or verified>")}
+`;
 }

package/dist/mind/prompt.js

@@ -464,15 +464,18 @@ function centerOfGravitySteeringSection(channel, options) {
     if (!frame)
         return "";
     const cog = frame.centerOfGravity;
-    if (cog === "local-turn")
-        return "";
     const job = frame.inner?.job;
     const activeObligation = (0, obligation_steering_1.findActivePersistentObligation)(frame);
+    const statusObligation = (0, obligation_steering_1.findStatusObligation)(frame);
+    const genericConcreteStatus = (0, obligation_steering_1.renderConcreteStatusGuidance)(frame, statusObligation);
+    if (cog === "local-turn") {
+        return genericConcreteStatus || (0, obligation_steering_1.renderLiveThreadStatusShape)(frame);
+    }
     if (cog === "inward-work") {
         if (activeObligation) {
             return `${(0, obligation_steering_1.renderActiveObligationSteering)(activeObligation)}
 
-${(0, obligation_steering_1.renderConcreteStatusGuidance)(frame, activeObligation)}`;
+${genericConcreteStatus}`;
         }
         if (job?.status === "queued" || job?.status === "running") {
             const originClause = job.origin
@@ -514,6 +517,9 @@ i already have coding work running in ${liveCodingSession.runner} ${liveCodingSe
 
 i should orient around that live lane first, then decide what still needs to come back here.`;
         }
+        if (genericConcreteStatus) {
+            return genericConcreteStatus;
+        }
         return `## where my attention is
 i have unfinished work that needs attention before i move on.
 
@@ -529,6 +535,17 @@ i should keep the different sides aligned. what i learn here may matter there, a
     /* v8 ignore next -- unreachable: all center-of-gravity modes covered above @preserve */
     return "";
 }
+function statusCheckSection(channel, options) {
+    if (channel === "inner" || !options?.statusCheckRequested)
+        return "";
+    const frame = options.activeWorkFrame;
+    if (!frame)
+        return "";
+    const activeObligation = (0, obligation_steering_1.findStatusObligation)(frame);
+    return `## status question on this turn
+the user is asking for current status right now.
+${(0, obligation_steering_1.renderExactStatusReplyContract)(frame, activeObligation, options.statusCheckScope)}`;
+}
 function commitmentsSection(options) {
     if (!options?.activeWorkFrame)
         return "";
@@ -736,6 +753,7 @@ async function buildSystem(channel = "cli", options, context) {
         skillsSection(),
         taskBoardSection(),
         activeWorkSection(options),
+        statusCheckSection(channel, options),
         centerOfGravitySteeringSection(channel, options),
         commitmentsSection(options),
         delegationHintSection(options),

package/dist/repertoire/coding/feedback.js

@@ -115,16 +115,20 @@ function deriveObligationMilestone(update) {
     return null;
 }
 function isSafeProgressSnippet(snippet) {
+    const normalized = snippet.trim();
     const wordCount = snippet.split(/\s+/).filter(Boolean).length;
-    return (snippet.length <= 80
+    return (normalized.length <= 80
+        && wordCount >= 2
         && wordCount <= 8
-        && !snippet.includes(":")
-        && !snippet.startsWith("**")
-        && !/^Respond with\b/i.test(snippet)
-        && !/^Coding session metadata\b/i.test(snippet)
-        && !/^sessionId\b/i.test(snippet)
-        && !/^taskRef\b/i.test(snippet)
-        && !/^parentAgent\b/i.test(snippet));
+        && /[A-Za-z]{3,}/.test(normalized)
+        && !normalized.includes(":")
+        && !/[{}\[\]();]/.test(normalized)
+        && !normalized.startsWith("**")
+        && !/^Respond with\b/i.test(normalized)
+        && !/^Coding session metadata\b/i.test(normalized)
+        && !/^sessionId\b/i.test(normalized)
+        && !/^taskRef\b/i.test(normalized)
+        && !/^parentAgent\b/i.test(normalized));
 }
 function pickUpdateSnippet(update) {
     return (lastMeaningfulLine(update.text)

package/dist/repertoire/coding/tools.js

@@ -99,6 +99,9 @@ function selectCodingStatusSessions(sessions, currentSession) {
     }
     return [...sessions].sort(latestSessionFirst);
 }
+function buildCodingObligationContent(taskRef) {
+    return `finish ${taskRef} and bring the result back`;
+}
 const codingSpawnTool = {
     type: "function",
     function: {
@@ -231,6 +234,13 @@ exports.codingToolDefinitions = [
                 }
                 return JSON.stringify({ ...existingSession, reused: true });
             }
+            if (request.originSession && !request.obligationId) {
+                const created = (0, obligations_1.createObligation)((0, identity_1.getAgentRoot)(), {
+                    origin: request.originSession,
+                    content: buildCodingObligationContent(taskRef),
+                });
+                request.obligationId = created.id;
+            }
             const session = await manager.spawnSession(request);
             if (session.obligationId) {
                 (0, obligations_1.advanceObligation)((0, identity_1.getAgentRoot)(), session.obligationId, {

package/dist/senses/pipeline.js

@@ -38,6 +38,29 @@ function emptyTaskBoard() {
         activeBridges: [],
     };
 }
+const STATUS_CHECK_PATTERNS = [
+    /^\s*what are you doing\??\s*$/i,
+    /^\s*what'?s your status\??\s*$/i,
+    /^\s*status\??\s*$/i,
+    /^\s*status update\??\s*$/i,
+    /^\s*what changed\??\s*$/i,
+    /^\s*where (?:are you at|things stand)\??\s*$/i,
+];
+function isStatusCheckRequested(ingressTexts) {
+    const latest = ingressTexts
+        ?.map((text) => text.trim())
+        .filter((text) => text.length > 0)
+        .at(-1);
+    if (!latest)
+        return false;
+    return STATUS_CHECK_PATTERNS.some((pattern) => pattern.test(latest));
+}
+function isLiveCodingSessionStatus(status) {
+    return status === "spawning"
+        || status === "running"
+        || status === "waiting_input"
+        || status === "stalled";
+}
 function readInnerWorkState() {
     const defaultJob = {
         status: "idle",
@@ -188,23 +211,21 @@ async function handleInboundTurn(input) {
         pendingObligations = [];
     }
     let codingSessions = [];
+    let otherCodingSessions = [];
     try {
-        codingSessions = (0, coding_1.getCodingSessionManager)()
+        const liveCodingSessions = (0, coding_1.getCodingSessionManager)()
             .listSessions()
-            .filter((session) => {
-            if (session.status !== "spawning" && session.status !== "running" && session.status !== "waiting_input" && session.status !== "stalled") {
-                return false;
-            }
-            if (!session.originSession) {
-                return false;
-            }
-            return session.originSession.friendId === currentSession.friendId
-                && session.originSession.channel === currentSession.channel
-                && session.originSession.key === currentSession.key;
-        });
+            .filter((session) => isLiveCodingSessionStatus(session.status) && Boolean(session.originSession));
+        codingSessions = liveCodingSessions.filter((session) => session.originSession?.friendId === currentSession.friendId
+            && session.originSession.channel === currentSession.channel
+            && session.originSession.key === currentSession.key);
+        otherCodingSessions = liveCodingSessions.filter((session) => !(session.originSession?.friendId === currentSession.friendId
+            && session.originSession.channel === currentSession.channel
+            && session.originSession.key === currentSession.key));
     }
     catch {
         codingSessions = [];
+        otherCodingSessions = [];
     }
     const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
         currentSession,
@@ -213,6 +234,7 @@ async function handleInboundTurn(input) {
         inner: readInnerWorkState(),
         bridges: activeBridges,
         codingSessions,
+        otherCodingSessions,
         pendingObligations,
         taskBoard: (() => {
             try {
@@ -271,6 +293,10 @@ async function handleInboundTurn(input) {
     }
     // Step 5: runAgent
     const existingToolContext = input.runAgentOptions?.toolContext;
+    const statusCheckRequested = isStatusCheckRequested(input.continuityIngressTexts);
+    const statusCheckScope = statusCheckRequested && resolvedContext.friend.trustLevel === "family"
+        ? "all-sessions-family"
+        : undefined;
     const runAgentOptions = {
         ...input.runAgentOptions,
         bridgeContext,
@@ -278,6 +304,9 @@ async function handleInboundTurn(input) {
         delegationDecision,
         currentSessionKey: currentSession.key,
         currentObligation,
+        statusCheckRequested,
+        statusCheckScope,
+        toolChoiceRequired: statusCheckRequested ? true : input.runAgentOptions?.toolChoiceRequired,
         mustResolveBeforeHandoff,
         setMustResolveBeforeHandoff: (value) => {
             mustResolveBeforeHandoff = value;

package/package.json

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