@ouro.bot/cli 0.1.0-alpha.106 → 0.1.0-alpha.108

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.108",
+      "changes": [
+        "Agents now have a first-class `query_active_work` tool that reads one top-level live world-state across the current conversation, other active sessions, live coding lanes, inner work, and return obligations instead of reconstructing status from side tools.",
+        "Family-facing status guidance now treats the active-work world-state as the agent's center of gravity, so 'what are you up to?' answers stay anchored in one coherent live picture instead of drifting into inner-dialog archaeology."
+      ]
+    },
+    {
+      "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": [

package/dist/heart/active-work.js

@@ -136,7 +136,15 @@ function formatObligationContentNextAction(obligation) {
     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];
@@ -149,12 +157,8 @@ 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 (obligation?.nextAction?.trim())
+        return obligation.nextAction.trim();
     if (obligation) {
         return formatObligationContentNextAction(obligation) || "continue the active loop and bring the result back here";
     }
@@ -255,10 +259,13 @@ function formatOtherActiveSessionSummaries(frame, nowMs = Date.now()) {
             .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 hasFreshSessionActivity = liveSession
-            ? (nowMs - liveSession.lastActivityMs) <= RECENT_OTHER_LIVE_SESSION_WINDOW_MS
+        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 && !hasFreshSessionActivity) {
+        if (!obligation && !codingSession && !hasMaterialLiveSession) {
             return null;
         }
         const timestampMs = Math.max(liveSession?.lastActivityMs ?? 0, codingSession ? codingSessionTimestampMs(codingSession) : 0, obligation ? obligationTimestampMs(obligation) : 0);
@@ -403,6 +410,7 @@ function buildActiveWorkFrame(input) {
 }
 function formatActiveWorkFrame(frame) {
     const lines = ["## what i'm holding"];
+    lines.push("this is my top-level live world-state right now. inner work, coding lanes, other sessions, and return obligations all belong inside this picture.");
     const primaryObligation = findPrimaryOpenObligation(frame);
     const currentSessionObligation = findCurrentSessionOpenObligation(frame);
     const activeLane = formatActiveLane(frame, primaryObligation);

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

@@ -113,8 +113,17 @@ function formatCurrentArtifact(frame, obligation) {
     return obligation ? "no artifact yet" : "";
 }
 function formatNextAction(frame, obligation) {
-    if (obligation?.nextAction)
-        return obligation.nextAction;
+    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`;
@@ -125,12 +134,8 @@ 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 (obligation?.nextAction?.trim())
+        return obligation.nextAction.trim();
     if (obligation?.content?.trim()) {
         return `work on "${obligation.content.trim()}" and bring back a concrete artifact`;
     }

package/dist/mind/prompt.js

@@ -465,10 +465,20 @@ function familyCrossSessionTruthSection(context, options) {
     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 treat the active-work section above as my reliable top-level surface for this.
+i do not claim i lack a top-level view when that surface is already present.
+i only reach for query_active_work when i want a fresh read of that same surface.
+i do not rebuild whole-self status from scratch with query_session and coding_status unless i need to verify a specific gap.
 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.`;
-}
-function centerOfGravitySteeringSection(channel, options) {
+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;
@@ -479,12 +489,15 @@ function centerOfGravitySteeringSection(channel, options) {
     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);
+    const liveWorldClause = context?.friend?.trustLevel === "family"
+        ? "\nmy center of gravity lives in the active-work world-state above. inner work is one lane inside it, not the whole picture."
+        : "";
     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)}
+            return `${(0, obligation_steering_1.renderActiveObligationSteering)(activeObligation)}${liveWorldClause}
 
 ${genericConcreteStatus}`;
         }
@@ -496,7 +509,7 @@ ${genericConcreteStatus}`;
                 ? "\ni still owe them an answer."
                 : "";
             return `## where my attention is
-i'm thinking through something privately right now.${originClause}${obligationClause}
+i'm thinking through something privately right now.${originClause}${obligationClause}${liveWorldClause}
 
 if this conversation connects to that inner work, i can weave them together.
 if it's separate, i can be fully present here -- my inner work will wait.`;
@@ -507,7 +520,7 @@ if it's separate, i can be fully present here -- my inner work will wait.`;
                 ? ` this started when ${job.origin.friendName ?? job.origin.friendId} asked about something.`
                 : "";
             return `## where my attention is
-i've been thinking privately and reached something.${originClause}
+i've been thinking privately and reached something.${originClause}${liveWorldClause}
 
 i should bring my answer back to the conversation it came from.`;
         }
@@ -523,8 +536,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}${liveWorldClause}
 
 i should orient around that live lane first, then decide what still needs to come back here.`;
         }
@@ -539,24 +559,13 @@ i can take it inward with go_inward to think privately, or address it directly h
     if (cog === "shared-work") {
         /* v8 ignore stop */
         return `## where my attention is
-this work touches multiple conversations -- i'm holding threads across sessions.
+this work touches multiple conversations -- i'm holding threads across sessions.${liveWorldClause}
 
 i should keep the different sides aligned. what i learn here may matter there, and vice versa.`;
     }
     /* 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 "";
@@ -765,8 +774,7 @@ async function buildSystem(channel = "cli", options, context) {
         taskBoardSection(),
         activeWorkSection(options),
         familyCrossSessionTruthSection(context, options),
-        statusCheckSection(channel, options),
-        centerOfGravitySteeringSection(channel, options),
+        centerOfGravitySteeringSection(channel, options, context),
         commitmentsSection(options),
         delegationHintSection(options),
         bridgeContextSection(options),

package/dist/repertoire/tools-base.js

@@ -48,8 +48,12 @@ const socket_client_1 = require("../heart/daemon/socket-client");
 const thoughts_1 = require("../heart/daemon/thoughts");
 const manager_1 = require("../heart/bridges/manager");
 const session_recall_1 = require("../heart/session-recall");
+const session_activity_1 = require("../heart/session-activity");
+const active_work_1 = require("../heart/active-work");
 const tools_1 = require("./coding/tools");
+const coding_1 = require("./coding");
 const memory_1 = require("../mind/memory");
+const tasks_1 = require("./tasks");
 const pending_1 = require("../mind/pending");
 const progress_story_1 = require("../heart/progress-story");
 const cross_chat_delivery_1 = require("../heart/cross-chat-delivery");
@@ -151,6 +155,155 @@ function renderCrossChatDeliveryStatus(target, result) {
         outcomeText: `${lead}\n${result.detail}`,
     }));
 }
+function emptyTaskBoard() {
+    return {
+        compact: "",
+        full: "",
+        byStatus: {
+            drafting: [],
+            processing: [],
+            validating: [],
+            collaborating: [],
+            paused: [],
+            blocked: [],
+            done: [],
+        },
+        actionRequired: [],
+        unresolvedDependencies: [],
+        activeSessions: [],
+        activeBridges: [],
+    };
+}
+function isLiveCodingSessionStatus(status) {
+    return status === "spawning"
+        || status === "running"
+        || status === "waiting_input"
+        || status === "stalled";
+}
+function readActiveWorkInnerState() {
+    const defaultJob = {
+        status: "idle",
+        content: null,
+        origin: null,
+        mode: "reflect",
+        obligationStatus: null,
+        surfacedResult: null,
+        queuedAt: null,
+        startedAt: null,
+        surfacedAt: null,
+    };
+    try {
+        const agentRoot = (0, identity_1.getAgentRoot)();
+        const pendingDir = (0, pending_1.getInnerDialogPendingDir)((0, identity_1.getAgentName)());
+        const sessionPath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
+        const { pendingMessages, turns, runtimeState } = (0, thoughts_1.readInnerDialogRawData)(sessionPath, pendingDir);
+        const dialogStatus = (0, thoughts_1.deriveInnerDialogStatus)(pendingMessages, turns, runtimeState);
+        const job = (0, thoughts_1.deriveInnerJob)(pendingMessages, turns, runtimeState);
+        const storeObligationPending = (0, obligations_1.readPendingObligations)(agentRoot).length > 0;
+        return {
+            status: dialogStatus.processing === "started" ? "running" : "idle",
+            hasPending: dialogStatus.queue !== "clear",
+            origin: dialogStatus.origin,
+            contentSnippet: dialogStatus.contentSnippet,
+            obligationPending: dialogStatus.obligationPending || storeObligationPending,
+            job,
+        };
+    }
+    catch {
+        return {
+            status: "idle",
+            hasPending: false,
+            job: defaultJob,
+        };
+    }
+}
+async function buildToolActiveWorkFrame(ctx) {
+    const currentSession = ctx?.currentSession
+        ? {
+            friendId: ctx.currentSession.friendId,
+            channel: ctx.currentSession.channel,
+            key: ctx.currentSession.key,
+            sessionPath: (0, config_1.resolveSessionPath)(ctx.currentSession.friendId, ctx.currentSession.channel, ctx.currentSession.key),
+        }
+        : null;
+    const agentRoot = (0, identity_1.getAgentRoot)();
+    const bridges = currentSession
+        ? (0, manager_1.createBridgeManager)().findBridgesForSession({
+            friendId: currentSession.friendId,
+            channel: currentSession.channel,
+            key: currentSession.key,
+        })
+        : [];
+    let friendActivity = [];
+    try {
+        friendActivity = (0, session_activity_1.listSessionActivity)({
+            sessionsDir: `${agentRoot}/state/sessions`,
+            friendsDir: `${agentRoot}/friends`,
+            agentName: (0, identity_1.getAgentName)(),
+            currentSession,
+        });
+    }
+    catch {
+        friendActivity = [];
+    }
+    const pendingObligations = (() => {
+        try {
+            return (0, obligations_1.readPendingObligations)(agentRoot);
+        }
+        catch {
+            return [];
+        }
+    })();
+    let codingSessions = [];
+    let otherCodingSessions = [];
+    try {
+        const liveCodingSessions = (0, coding_1.getCodingSessionManager)()
+            .listSessions()
+            .filter((session) => isLiveCodingSessionStatus(session.status) && Boolean(session.originSession));
+        if (currentSession) {
+            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));
+        }
+        else {
+            codingSessions = [];
+            otherCodingSessions = liveCodingSessions;
+        }
+    }
+    catch {
+        codingSessions = [];
+        otherCodingSessions = [];
+    }
+    const currentObligation = currentSession
+        ? pendingObligations.find((obligation) => obligation.status !== "fulfilled"
+            && obligation.origin.friendId === currentSession.friendId
+            && obligation.origin.channel === currentSession.channel
+            && obligation.origin.key === currentSession.key)?.content ?? null
+        : null;
+    return (0, active_work_1.buildActiveWorkFrame)({
+        currentSession,
+        currentObligation,
+        mustResolveBeforeHandoff: false,
+        inner: readActiveWorkInnerState(),
+        bridges,
+        codingSessions,
+        otherCodingSessions,
+        pendingObligations,
+        taskBoard: (() => {
+            try {
+                return (0, tasks_1.getTaskModule)().getBoard();
+            }
+            catch {
+                return emptyTaskBoard();
+            }
+        })(),
+        friendActivity,
+        targetCandidates: [],
+    });
+}
 function renderInnerProgressStatus(status) {
     if (status.processing === "pending") {
         return "i've queued this thought for private attention. it'll come up when my inner dialog is free.";
@@ -818,6 +971,23 @@ exports.baseToolDefinitions = [
             return `unknown bridge action: ${action}`;
         },
     },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "query_active_work",
+                description: "read the current live world-state across visible sessions, coding lanes, inner work, and return obligations. use this instead of piecing status together from separate session and coding tools.",
+                parameters: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        },
+        handler: async (_args, ctx) => {
+            const frame = await buildToolActiveWorkFrame(ctx);
+            return `this is my current top-level live world-state.\nanswer whole-self status questions from this before drilling into individual sessions.\n\n${(0, active_work_1.formatActiveWorkFrame)(frame)}`;
+        },
+    },
     {
         tool: {
             type: "function",

package/package.json

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