@ouro.bot/cli 0.1.0-alpha.105 → 0.1.0-alpha.107

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.107",
+      "changes": [
+        "Family-scoped 'what are you up to?' answers now widen to the full live world-state: the current conversation, live coding lanes, other active friend-facing sessions, and any active inner holding state, instead of collapsing to just the current lane.",
+        "The runtime no longer regex-polices an exact status-answer template; family status now rides on the same live obligation and session world-state the agent already uses everywhere else, which keeps cross-session answers truthful and natural."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.106",
+      "changes": [
+        "Family-scoped status answers now come from the live obligation/session world-state directly instead of a regex-triggered 'status question' mode, so agents can answer naturally while still seeing all material live work across sessions.",
+        "Raw inbound text no longer masquerades as a real commitment or next action; current lanes, artifacts, and next steps are now grounded in persistent obligations, live coding state, and concrete session activity."
+      ]
+    },
     {
       "version": "0.1.0-alpha.105",
       "changes": [

package/dist/heart/active-work.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOtherActiveSessionSummaries = formatOtherActiveSessionSummaries;
 exports.suggestBridgeForActiveWork = suggestBridgeForActiveWork;
 exports.buildActiveWorkFrame = buildActiveWorkFrame;
 exports.formatActiveWorkFrame = formatActiveWorkFrame;
@@ -7,6 +8,7 @@ const runtime_1 = require("../nerves/runtime");
 const state_machine_1 = require("./bridges/state-machine");
 const obligations_1 = require("./obligations");
 const target_resolution_1 = require("./target-resolution");
+const config_1 = require("./config");
 function activityPriority(source) {
     return source === "friend-facing" ? 0 : 1;
 }
@@ -28,9 +30,9 @@ function isActiveBridge(bridge) {
     return bridge.lifecycle === "active";
 }
 function hasSharedObligationPressure(input) {
-    return (typeof input.currentObligation === "string"
-        && input.currentObligation.trim().length > 0) || input.mustResolveBeforeHandoff
-        || summarizeLiveTasks(input.taskBoard).length > 0;
+    return input.mustResolveBeforeHandoff
+        || summarizeLiveTasks(input.taskBoard).length > 0
+        || activeObligationCount(input.pendingObligations) > 0;
 }
 function formatCodingLaneLabel(session) {
     return `${session.runner} ${session.id}`;
@@ -86,6 +88,16 @@ function findPrimaryOpenObligation(frame) {
         ?? (frame.pendingObligations ?? []).find(obligations_1.isOpenObligation)
         ?? null;
 }
+function matchesCurrentSession(frame, obligation) {
+    return Boolean(frame.currentSession
+        && obligation.origin.friendId === frame.currentSession.friendId
+        && obligation.origin.channel === frame.currentSession.channel
+        && (0, config_1.sanitizeKey)(obligation.origin.key) === (0, config_1.sanitizeKey)(frame.currentSession.key));
+}
+function findCurrentSessionOpenObligation(frame) {
+    return (frame.pendingObligations ?? []).find((obligation) => (0, obligations_1.isOpenObligationStatus)(obligation.status) && matchesCurrentSession(frame, obligation))
+        ?? null;
+}
 function formatActiveLane(frame, obligation) {
     const liveCodingSession = frame.codingSessions?.[0];
     if (liveCodingSession) {
@@ -94,12 +106,12 @@ function formatActiveLane(frame, obligation) {
     if (obligation?.currentSurface?.label) {
         return obligation.currentSurface.label;
     }
+    if (obligation && matchesCurrentSession(frame, obligation) && frame.currentSession) {
+        return "this same thread";
+    }
     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) {
@@ -112,13 +124,27 @@ 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) {
+    if (obligation) {
         return "no artifact yet";
     }
     return null;
 }
+function formatObligationContentNextAction(obligation) {
+    const content = obligation?.content?.trim();
+    if (!content)
+        return null;
+    return `work on "${content}" and bring back a concrete artifact`;
+}
 function formatNextAction(frame, obligation) {
-    if (obligation?.nextAction?.trim()) {
+    const obligationHasConcreteArtifact = Boolean(obligation?.currentArtifact?.trim())
+        || obligation?.currentSurface?.kind === "merge";
+    if (obligation?.status === "waiting_for_merge") {
+        return obligation.nextAction?.trim() || `wait for checks, merge ${formatMergeArtifact(obligation)}, then update runtime`;
+    }
+    if (obligation?.status === "updating_runtime") {
+        return obligation.nextAction?.trim() || "update runtime, verify version/changelog, then re-observe";
+    }
+    if (obligationHasConcreteArtifact && obligation?.nextAction?.trim()) {
         return obligation.nextAction.trim();
     }
     const liveCodingSession = frame.codingSessions?.[0];
@@ -131,19 +157,133 @@ function formatNextAction(frame, obligation) {
     if (liveCodingSession) {
         return "finish the coding pass and bring the result back here";
     }
+    if (obligation?.nextAction?.trim())
+        return obligation.nextAction.trim();
+    if (obligation) {
+        return formatObligationContentNextAction(obligation) || "continue the active loop and bring the result back here";
+    }
+    if (frame.mustResolveBeforeHandoff) {
+        return "finish what i started here before moving on";
+    }
+    return null;
+}
+const RECENT_OTHER_LIVE_SESSION_WINDOW_MS = 60 * 60 * 1000;
+function sessionOriginKey(origin) {
+    return `${origin.friendId}/${origin.channel}/${(0, config_1.sanitizeKey)(origin.key)}`;
+}
+function codingSessionTimestampMs(session) {
+    return Date.parse(session.lastActivityAt ?? session.startedAt);
+}
+function obligationTimestampMs(obligation) {
+    return Date.parse(obligation.updatedAt ?? obligation.createdAt);
+}
+function newestObligationFirst(left, right) {
+    return obligationTimestampMs(right) - obligationTimestampMs(left);
+}
+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 obligation ? "no artifact yet" : "no explicit 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 (obligation) {
-        return "continue the active loop and bring the result back here";
+    if (codingSession?.status === "waiting_input") {
+        return `answer ${formatCodingLaneLabel(codingSession)} and continue`;
     }
-    if (typeof frame.currentObligation === "string" && frame.currentObligation.trim().length > 0) {
-        return `work on "${frame.currentObligation.trim()}" and bring back a concrete artifact`;
+    if (codingSession?.status === "stalled") {
+        return `unstick ${formatCodingLaneLabel(codingSession)} and continue`;
     }
-    return null;
+    if (codingSession) {
+        return "finish the coding pass and bring the result back there";
+    }
+    if (obligation) {
+        return formatObligationContentNextAction(obligation) || "continue the active loop and bring the result back there";
+    }
+    return "check this session and bring back the latest concrete state";
+}
+function formatOtherSessionLine(label, status, activeLane, artifact, nextAction) {
+    return `- ${label}: [${status}] ${activeLane}; artifact ${artifact}; next ${nextAction}`;
+}
+function formatOtherActiveSessionSummaries(frame, nowMs = Date.now()) {
+    const originMap = new Map();
+    for (const session of frame.friendActivity?.allOtherLiveSessions ?? []) {
+        if (session.friendId === "self" || session.channel === "inner")
+            continue;
+        originMap.set(sessionOriginKey(session), {
+            friendId: session.friendId,
+            channel: session.channel,
+            key: session.key,
+        });
+    }
+    const orphanCodingSummaries = (frame.otherCodingSessions ?? [])
+        .filter((session) => !session.originSession)
+        .sort((left, right) => codingSessionTimestampMs(right) - codingSessionTimestampMs(left))
+        .map((session) => ({
+        timestampMs: codingSessionTimestampMs(session),
+        line: formatOtherSessionLine("another session", session.status, formatCodingLaneLabel(session), "no PR or merge artifact yet", formatOtherSessionNextAction(null, session)),
+    }));
+    for (const session of frame.otherCodingSessions ?? []) {
+        if (!session.originSession)
+            continue;
+        if (frame.currentSession
+            && session.originSession.friendId === frame.currentSession.friendId
+            && session.originSession.channel === frame.currentSession.channel
+            && (0, config_1.sanitizeKey)(session.originSession.key) === (0, config_1.sanitizeKey)(frame.currentSession.key)) {
+            continue;
+        }
+        originMap.set(sessionOriginKey(session.originSession), session.originSession);
+    }
+    for (const obligation of frame.pendingObligations ?? []) {
+        if (obligation.status === "fulfilled" || matchesCurrentSession(frame, obligation))
+            continue;
+        originMap.set(sessionOriginKey(obligation.origin), obligation.origin);
+    }
+    const summaries = [...originMap.values()].map((origin) => {
+        const originKey = sessionOriginKey(origin);
+        const obligation = [...(frame.pendingObligations ?? [])]
+            .filter((candidate) => candidate.status !== "fulfilled" && sessionOriginKey(candidate.origin) === originKey)
+            .sort(newestObligationFirst)[0] ?? null;
+        const codingSession = [...(frame.otherCodingSessions ?? [])]
+            .filter((candidate) => candidate.originSession && sessionOriginKey(candidate.originSession) === originKey)
+            .sort((left, right) => codingSessionTimestampMs(right) - codingSessionTimestampMs(left))[0] ?? null;
+        const liveSession = (frame.friendActivity?.allOtherLiveSessions ?? []).find((candidate) => sessionOriginKey(candidate) === originKey) ?? null;
+        const hasMaterialLiveSession = liveSession
+            ? ((nowMs - liveSession.lastActivityMs) <= RECENT_OTHER_LIVE_SESSION_WINDOW_MS
+                || (frame.currentSession != null
+                    && liveSession.friendId === frame.currentSession.friendId
+                    && liveSession.channel !== frame.currentSession.channel))
+            : false;
+        if (!obligation && !codingSession && !hasMaterialLiveSession) {
+            return 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 label = liveSession?.friendName ?? origin.friendId;
+        return {
+            timestampMs,
+            line: formatOtherSessionLine(`${label}/${origin.channel}/${origin.key}`, status, activeLane, artifact, nextAction),
+        };
+    }).filter((entry) => entry !== null)
+        .sort((left, right) => right.timestampMs - left.timestampMs);
+    const lines = summaries.map((entry) => entry.line);
+    return [...lines, ...orphanCodingSummaries.map((entry) => entry.line)];
 }
 function suggestBridgeForActiveWork(input) {
     const targetCandidates = (input.targetCandidates ?? [])
@@ -164,10 +304,17 @@ function suggestBridgeForActiveWork(input) {
         .sort((a, b) => {
         return b.lastActivityMs - a.lastActivityMs;
     });
-    if (!hasSharedObligationPressure(input) || targetCandidates.length === 0) {
+    if (!hasSharedObligationPressure({
+        mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
+        taskBoard: input.taskBoard,
+        pendingObligations: input.pendingObligations,
+    }) || targetCandidates.length === 0) {
         return null;
     }
     const targetSession = targetCandidates[0];
+    const objectiveHint = [...(input.pendingObligations ?? [])]
+        .find((obligation) => (0, obligations_1.isOpenObligationStatus)(obligation.status))
+        ?.content?.trim() || "keep this shared work aligned";
     const activeBridge = input.bridges.find(isActiveBridge) ?? null;
     if (activeBridge) {
         const alreadyAttached = activeBridge.attachedSessions.some((session) => session.friendId === targetSession.friendId
@@ -186,7 +333,7 @@ function suggestBridgeForActiveWork(input) {
     return {
         kind: "begin-new",
         targetSession,
-        objectiveHint: input.currentObligation?.trim() || "keep this shared work aligned",
+        objectiveHint,
         reason: "shared-work-candidate",
     };
 }
@@ -237,6 +384,7 @@ function buildActiveWorkFrame(input) {
             currentObligation: input.currentObligation,
             mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
             bridges: input.bridges,
+            pendingObligations: input.pendingObligations,
             taskBoard: input.taskBoard,
             targetCandidates: input.targetCandidates,
         }),
@@ -263,16 +411,16 @@ function buildActiveWorkFrame(input) {
 function formatActiveWorkFrame(frame) {
     const lines = ["## what i'm holding"];
     const primaryObligation = findPrimaryOpenObligation(frame);
+    const currentSessionObligation = findCurrentSessionOpenObligation(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 ?? [];
+    const otherActiveSessions = formatOtherActiveSessionSummaries(frame);
     // Session line
     if (frame.currentSession) {
         let sessionLine = `i'm in a conversation on ${formatSessionLabel(frame.currentSession)}.`;
-        if (typeof frame.currentObligation === "string" && frame.currentObligation.trim().length > 0) {
-            sessionLine += ` i told them i'd ${frame.currentObligation.trim()}.`;
+        if (currentSessionObligation?.content?.trim()) {
+            sessionLine += ` i still owe them: ${currentSessionObligation.content.trim()}.`;
         }
         else if (frame.mustResolveBeforeHandoff) {
             sessionLine += " i need to finish what i started here before moving on.";
@@ -340,22 +488,10 @@ 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) {
+    if (otherActiveSessions.length > 0) {
         lines.push("");
-        lines.push("## other live sessions");
-        for (const session of otherLiveSessions) {
-            lines.push(`- ${session.friendName}/${session.channel}/${session.key}`);
-        }
+        lines.push("## other active sessions");
+        lines.push(...otherActiveSessions);
     }
     // Task pressure
     if ((frame.taskPressure?.liveTaskNames ?? []).length > 0) {

package/dist/heart/commitments.js

@@ -34,10 +34,6 @@ function deriveCommitments(activeWorkFrame, innerJob, pendingObligations) {
             completionCriteria.push("close my active obligation loops");
         }
     }
-    // Obligation (from current turn -- kept for backward compat)
-    if (typeof activeWorkFrame.currentObligation === "string" && activeWorkFrame.currentObligation.trim().length > 0) {
-        committedTo.push(`i told them i'd ${activeWorkFrame.currentObligation.trim()}`);
-    }
     // Inner job
     if (innerJob.status === "queued" || innerJob.status === "running") {
         const contentSuffix = innerJob.content ? ` -- ${innerJob.content.slice(0, 60)}` : "";

package/dist/heart/core.js

@@ -27,7 +27,6 @@ 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");
@@ -273,45 +272,6 @@ 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; } });
@@ -591,7 +551,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 traceId,
                 toolChoiceRequired,
                 reasoningEffort: currentReasoningEffort,
-                eagerFinalAnswerStreaming: !options?.statusCheckRequested,
+                eagerFinalAnswerStreaming: true,
             });
             // Track usage from the latest API call
             if (result.usage)
@@ -640,21 +600,16 @@ 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 deliveredAnswer = answer;
                     const validDirectReply = mustResolveBeforeHandoffActive && intent === "direct_reply" && sawSteeringFollowUp;
                     const validTerminalIntent = intent === "complete" || intent === "blocked";
                     const validClosure = deliveredAnswer != null
-                        && (exactStatusReplyAccepted || !retryError)
-                        && !statusReplyRetryError
-                        && (exactStatusReplyAccepted || !mustResolveBeforeHandoffActive || validDirectReply || validTerminalIntent);
+                        && !retryError
+                        && (!mustResolveBeforeHandoffActive || validDirectReply || validTerminalIntent);
                     if (validClosure) {
                         completion = {
                             answer: deliveredAnswer,
-                            intent: validDirectReply && !exactStatusReplyAccepted ? "direct_reply" : intent === "blocked" ? "blocked" : "complete",
+                            intent: validDirectReply ? "direct_reply" : intent === "blocked" ? "blocked" : "complete",
                         };
                         if (result.finalAnswerStreamed) {
                             // The streaming layer already parsed and emitted the answer
@@ -669,7 +624,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                             callbacks.onTextChunk(deliveredAnswer);
                         }
                         messages.push(msg);
-                        if (validDirectReply && !exactStatusReplyAccepted) {
+                        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);
@@ -688,8 +643,7 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                         // assistant msg + error tool result and let the model try again.
                         callbacks.onClearText?.();
                         messages.push(msg);
-                        const toolRetryMessage = statusReplyRetryError
-                            ?? retryError
+                        const toolRetryMessage = 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);

package/dist/mind/obligation-steering.js

@@ -8,8 +8,8 @@ exports.renderLiveThreadStatusShape = renderLiveThreadStatusShape;
 exports.buildExactStatusReply = buildExactStatusReply;
 exports.renderExactStatusReplyContract = renderExactStatusReplyContract;
 const config_1 = require("../heart/config");
+const active_work_1 = require("../heart/active-work");
 const runtime_1 = require("../nerves/runtime");
-const RECENT_OTHER_LIVE_SESSION_WINDOW_MS = 60 * 60 * 1000;
 function findActivePersistentObligation(frame) {
     if (!frame)
         return null;
@@ -30,102 +30,6 @@ function matchesSessionOrigin(frame, origin) {
         && origin.channel === frame.currentSession.channel
         && (0, config_1.sanitizeKey)(origin.key) === (0, config_1.sanitizeKey)(frame.currentSession.key));
 }
-function sessionOriginKey(origin) {
-    return `${origin.friendId}/${origin.channel}/${(0, config_1.sanitizeKey)(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) => sessionOriginKey(entry) === sessionOriginKey(origin))?.friendName ?? origin.friendId;
-}
-function buildOtherActiveSessionLines(frame) {
-    const originMap = new Map();
-    for (const session of frame.friendActivity?.allOtherLiveSessions ?? []) {
-        if (session.friendId === "self" || session.channel === "inner")
-            continue;
-        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 hasFreshSessionActivity = liveSession
-            ? (Date.now() - liveSession.lastActivityMs) <= RECENT_OTHER_LIVE_SESSION_WINDOW_MS
-            : false;
-        if (!obligation && !codingSession && !hasFreshSessionActivity) {
-            return 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}`,
-        };
-    }).filter((entry) => entry !== null)
-        .sort((left, right) => right.timestampMs - left.timestampMs);
-    return summaries.length > 0 ? summaries.map((entry) => entry.line) : ["- none"];
-}
 function findStatusObligation(frame) {
     if (!frame)
         return null;
@@ -197,30 +101,29 @@ function formatActiveLane(frame, obligation) {
                 : `${liveCodingSession.runner} ${liveCodingSession.id}`;
     }
     return obligation.currentSurface?.label
-        || (frame.currentObligation?.trim() ? "this same thread" : "this live loop");
+        || (matchesCurrentSession(frame, obligation) ? "this same thread" : "this live loop");
 }
 function formatCurrentArtifact(frame, obligation) {
     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);
+    return obligation ? "no artifact yet" : "";
 }
 function formatNextAction(frame, obligation) {
-    if (obligation?.nextAction)
-        return obligation.nextAction;
-    const currentObligation = frame.currentObligation?.trim() ?? "";
-    const statusCheckPrompt = isStatusCheckPrompt(currentObligation);
+    const obligationHasConcreteArtifact = Boolean(obligation?.currentArtifact?.trim())
+        || obligation?.currentSurface?.kind === "merge";
+    if (obligation?.status === "waiting_for_merge") {
+        return obligation.nextAction?.trim() || `wait for checks, merge ${formatMergeArtifact(obligation)}, then update runtime`;
+    }
+    if (obligation?.status === "updating_runtime") {
+        return obligation.nextAction?.trim() || "update runtime, verify version/changelog, then re-observe";
+    }
+    if (obligationHasConcreteArtifact && obligation?.nextAction?.trim()) {
+        return obligation.nextAction.trim();
+    }
     const liveCodingSession = frame.codingSessions?.[0];
     if (liveCodingSession?.status === "waiting_input") {
         return `answer ${liveCodingSession.runner} ${liveCodingSession.id} and continue`;
@@ -231,19 +134,15 @@ 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 ${formatMergeArtifact(obligation)}, then update runtime`;
-    }
-    if (obligation?.status === "updating_runtime") {
-        return "update runtime, verify version/changelog, then re-observe";
-    }
-    if (currentObligation && !statusCheckPrompt) {
-        return `work on "${currentObligation}" and bring back a concrete artifact`;
+    if (obligation?.nextAction?.trim())
+        return obligation.nextAction.trim();
+    if (obligation?.content?.trim()) {
+        return `work on "${obligation.content.trim()}" and bring back a concrete artifact`;
     }
     return obligation ? "continue the active loop and bring the result back here" : "";
 }
 function renderConcreteStatusGuidance(frame, obligation) {
-    const activeLane = obligation ? formatActiveLane(frame, obligation) : (frame.currentObligation?.trim() ? "this same thread" : "");
+    const activeLane = obligation ? formatActiveLane(frame, obligation) : "";
     const currentArtifact = formatCurrentArtifact(frame, obligation);
     const nextAction = formatNextAction(frame, obligation);
     const liveConversation = frame.currentSession
@@ -258,7 +157,7 @@ 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.`;
+i answer naturally from those facts instead of forcing a canned status block.`;
 }
 function renderLiveThreadStatusShape(frame) {
     if (!frame.currentSession)
@@ -297,7 +196,8 @@ function buildExactStatusReply(frame, obligation, latestCheckpoint, statusCheckS
     ];
     if (statusCheckScope === "all-sessions-family") {
         lines.push("other active sessions:");
-        lines.push(...buildOtherActiveSessionLines(frame));
+        const summaries = (0, active_work_1.formatOtherActiveSessionSummaries)(frame);
+        lines.push(...(summaries.length > 0 ? summaries : ["- none"]));
     }
     return lines.join("\n");
 }

package/dist/mind/prompt.js

@@ -457,7 +457,24 @@ function activeWorkSection(options) {
         return "";
     return (0, active_work_1.formatActiveWorkFrame)(options.activeWorkFrame);
 }
-function centerOfGravitySteeringSection(channel, options) {
+function familyCrossSessionTruthSection(context, options) {
+    if (!options?.activeWorkFrame)
+        return "";
+    if (context?.friend?.trustLevel !== "family")
+        return "";
+    return `## cross-session truth
+if a family member asks what i'm up to or how things are going, that includes the material live work i can see across sessions, not just this thread.
+i answer naturally from the live world-state in this prompt.
+i do not rely on canned status-question modes or phrase matching.
+if part of the picture is still fuzzy, i say what i can see and what still needs checking.
+when the live ask is about status, i widen before answering:
+- where i am right now
+- any other material active sessions or coding lanes i can see
+- the freshest concrete checkpoint
+- the next concrete step
+i do not collapse down to only the current lane.`;
+}
+function centerOfGravitySteeringSection(channel, options, context) {
     if (channel === "inner")
         return "";
     const frame = options?.activeWorkFrame;
@@ -512,8 +529,15 @@ i should bring my answer back to the conversation it came from.`;
                 : liveCodingSession.originSession
                     ? ` for ${liveCodingSession.originSession.channel}/${liveCodingSession.originSession.key}`
                     : "";
+            const otherSessionLines = (0, active_work_1.formatOtherActiveSessionSummaries)(frame);
+            const familyStatusClause = context?.friend?.trustLevel === "family"
+                ? `\nif a family member asks what i'm up to, i treat this coding lane as one part of the visible picture, not the whole picture.
+after i name this lane, i widen back out with:
+other active sessions:
+${otherSessionLines.length > 0 ? otherSessionLines.join("\n") : "- none"}`
+                : "";
             return `## where my attention is
-i already have coding work running in ${liveCodingSession.runner} ${liveCodingSession.id}${scopeClause}.
+i already have coding work running in ${liveCodingSession.runner} ${liveCodingSession.id}${scopeClause}.${familyStatusClause}
 
 i should orient around that live lane first, then decide what still needs to come back here.`;
         }
@@ -535,17 +559,6 @@ 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 "";
@@ -753,8 +766,8 @@ async function buildSystem(channel = "cli", options, context) {
         skillsSection(),
         taskBoardSection(),
         activeWorkSection(options),
-        statusCheckSection(channel, options),
-        centerOfGravitySteeringSection(channel, options),
+        familyCrossSessionTruthSection(context, options),
+        centerOfGravitySteeringSection(channel, options, context),
         commitmentsSection(options),
         delegationHintSection(options),
         bridgeContextSection(options),

package/dist/senses/pipeline.js

@@ -38,23 +38,6 @@ 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"
@@ -293,10 +276,6 @@ 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,
@@ -304,9 +283,6 @@ 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.105",
+  "version": "0.1.0-alpha.107",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",