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

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.105",
+      "changes": [
+        "Family-wide status answers now dedupe normalized session keys, drop inner/self noise, and ignore stale non-obligation lanes so 'what are you doing?' stays focused on real active work across all live sessions.",
+        "BlueBubbles and CLI lanes that refer to the same live thread now collapse into one clean status line, preventing duplicate session bullets when family asks for the full cross-session picture."
+      ]
+    },
+    {
+      "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": [

package/dist/heart/active-work.js

@@ -203,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)
@@ -223,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,
@@ -247,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,
         },
@@ -259,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)}.`;
@@ -331,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

@@ -273,24 +273,32 @@ function getFinalAnswerRetryError(mustResolveBeforeHandoff, intent, sawSteeringF
     }
     return null;
 }
-function hasExactStatusReplyShape(answer) {
+function hasExactStatusReplyShape(answer, statusCheckScope) {
     const lines = answer.trimEnd().split(/\r?\n/);
-    if (lines.length !== 5)
-        return false;
-    return (/^live conversation:\s+\S.+$/i.test(lines[0])
+    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) {
+function getStatusReplyRetryError(answer, statusCheckRequested, activeWorkFrame, statusCheckScope) {
     if (!statusCheckRequested || answer == null)
         return null;
-    if (hasExactStatusReplyShape(answer))
+    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:
@@ -301,8 +309,8 @@ 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))}
-call final_answer again using that exact five-line shape and nothing else.`;
+${(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");
@@ -632,10 +640,10 @@ 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);
+                    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))
+                        ? (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";

package/dist/mind/obligation-steering.js

@@ -7,7 +7,9 @@ exports.renderConcreteStatusGuidance = renderConcreteStatusGuidance;
 exports.renderLiveThreadStatusShape = renderLiveThreadStatusShape;
 exports.buildExactStatusReply = buildExactStatusReply;
 exports.renderExactStatusReplyContract = renderExactStatusReplyContract;
+const config_1 = require("../heart/config");
 const runtime_1 = require("../nerves/runtime");
+const RECENT_OTHER_LIVE_SESSION_WINDOW_MS = 60 * 60 * 1000;
 function findActivePersistentObligation(frame) {
     if (!frame)
         return null;
@@ -20,10 +22,109 @@ 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
-        && obligation.origin.friendId === frame.currentSession.friendId
-        && obligation.origin.channel === frame.currentSession.channel
-        && obligation.origin.key === frame.currentSession.key);
+        && origin.friendId === frame.currentSession.friendId
+        && 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)
@@ -36,6 +137,12 @@ function findStatusObligation(frame) {
         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",
@@ -168,25 +275,46 @@ 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) {
+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 = obligation
-        ? formatActiveLane(frame, obligation)
+    const activeLane = headerObligation
+        ? formatActiveLane(frame, headerObligation)
         : (frame.currentSession ? "this same thread" : "this live loop");
-    const currentArtifact = formatCurrentArtifact(frame, obligation) || 'no artifact yet';
-    const nextAction = formatNextAction(frame, obligation) || "continue the active loop and bring the result back here";
+    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>";
-    return [
+    const lines = [
         `live conversation: ${liveConversation}`,
         `active lane: ${activeLane}`,
         `current artifact: ${currentArtifact}`,
         `latest checkpoint: ${latest}`,
         `next action: ${nextAction}`,
-    ].join("\n");
+    ];
+    if (statusCheckScope === "all-sessions-family") {
+        lines.push("other active sessions:");
+        lines.push(...buildOtherActiveSessionLines(frame));
+    }
+    return lines.join("\n");
 }
-function renderExactStatusReplyContract(frame, obligation) {
+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

@@ -544,7 +544,7 @@ function statusCheckSection(channel, options) {
     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)}`;
+${(0, obligation_steering_1.renderExactStatusReplyContract)(frame, activeObligation, options.statusCheckScope)}`;
 }
 function commitmentsSection(options) {
     if (!options?.activeWorkFrame)

package/dist/senses/pipeline.js

@@ -55,6 +55,12 @@ function isStatusCheckRequested(ingressTexts) {
         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",
@@ -205,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,
@@ -230,6 +234,7 @@ async function handleInboundTurn(input) {
         inner: readInnerWorkState(),
         bridges: activeBridges,
         codingSessions,
+        otherCodingSessions,
         pendingObligations,
         taskBoard: (() => {
             try {
@@ -289,6 +294,9 @@ 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,
@@ -297,6 +305,7 @@ async function handleInboundTurn(input) {
         currentSessionKey: currentSession.key,
         currentObligation,
         statusCheckRequested,
+        statusCheckScope,
         toolChoiceRequired: statusCheckRequested ? true : input.runAgentOptions?.toolChoiceRequired,
         mustResolveBeforeHandoff,
         setMustResolveBeforeHandoff: (value) => {

package/package.json

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