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

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.109",
+      "changes": [
+        "Each inbound turn now carries a fresh live world-state checkpoint, so natural questions like 'what are you up to?' anchor on current sessions, obligations, coding lanes, and next actions instead of stale transcript history.",
+        "Active-work now serves as the agent's top-level center of gravity: material obligations are normalized, duplicate-origin noise is collapsed, and inner dialog is treated as one lane inside the live world-state instead of the whole self."
+      ]
+    },
+    {
+      "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": [

package/dist/heart/active-work.js

@@ -4,11 +4,13 @@ exports.formatOtherActiveSessionSummaries = formatOtherActiveSessionSummaries;
 exports.suggestBridgeForActiveWork = suggestBridgeForActiveWork;
 exports.buildActiveWorkFrame = buildActiveWorkFrame;
 exports.formatActiveWorkFrame = formatActiveWorkFrame;
+exports.formatLiveWorldStateCheckpoint = formatLiveWorldStateCheckpoint;
 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");
+const RECENT_ACTIVE_OBLIGATION_WINDOW_MS = 60 * 60 * 1000;
 function activityPriority(source) {
     return source === "friend-facing" ? 0 : 1;
 }
@@ -51,6 +53,49 @@ function describeCodingSessionScope(session, currentSession) {
 function activeObligationCount(obligations) {
     return (obligations ?? []).filter((ob) => (0, obligations_1.isOpenObligationStatus)(ob.status)).length;
 }
+function obligationOriginKey(obligation) {
+    return `${obligation.origin.friendId}/${obligation.origin.channel}/${(0, config_1.sanitizeKey)(obligation.origin.key)}`;
+}
+function buildLiveCodingLabelSet(codingSessions, otherCodingSessions) {
+    return new Set([
+        ...codingSessions.map(formatCodingLaneLabel),
+        ...otherCodingSessions.map(formatCodingLaneLabel),
+    ]);
+}
+function isMaterialActiveObligation(obligation, liveCodingLabels, nowMs) {
+    if (obligation.currentArtifact?.trim())
+        return true;
+    if (obligation.status === "waiting_for_merge" || obligation.status === "updating_runtime")
+        return true;
+    const surface = obligation.currentSurface;
+    if (surface?.kind === "merge" || surface?.kind === "runtime")
+        return true;
+    const recentlyTouched = (nowMs - obligationTimestampMs(obligation)) <= RECENT_ACTIVE_OBLIGATION_WINDOW_MS;
+    if (surface?.kind === "coding") {
+        const liveLabel = surface.label.trim();
+        return (liveLabel.length > 0 && liveCodingLabels.has(liveLabel)) || recentlyTouched;
+    }
+    return recentlyTouched;
+}
+function normalizePendingObligations(obligations, codingSessions, otherCodingSessions) {
+    const openObligations = (obligations ?? []).filter((obligation) => (0, obligations_1.isOpenObligationStatus)(obligation.status));
+    if (openObligations.length === 0)
+        return [];
+    const liveCodingLabels = buildLiveCodingLabelSet(codingSessions, otherCodingSessions);
+    const nowMs = Date.now();
+    const normalized = [];
+    const seenOrigins = new Set();
+    for (const obligation of [...openObligations].sort(newestObligationFirst)) {
+        if (!isMaterialActiveObligation(obligation, liveCodingLabels, nowMs))
+            continue;
+        const originKey = obligationOriginKey(obligation);
+        if (seenOrigins.has(originKey))
+            continue;
+        seenOrigins.add(originKey);
+        normalized.push(obligation);
+    }
+    return normalized;
+}
 function formatObligationSurface(obligation) {
     if (!obligation.currentSurface?.label)
         return "";
@@ -175,7 +220,8 @@ function codingSessionTimestampMs(session) {
     return Date.parse(session.lastActivityAt ?? session.startedAt);
 }
 function obligationTimestampMs(obligation) {
-    return Date.parse(obligation.updatedAt ?? obligation.createdAt);
+    const value = Date.parse(obligation.updatedAt ?? obligation.createdAt);
+    return Number.isFinite(value) ? value : 0;
 }
 function newestObligationFirst(left, right) {
     return obligationTimestampMs(right) - obligationTimestampMs(left);
@@ -348,11 +394,11 @@ function buildActiveWorkFrame(input) {
         : [];
     const liveTaskNames = summarizeLiveTasks(input.taskBoard);
     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 pendingObligations = normalizePendingObligations(input.pendingObligations, liveCodingSessions, otherCodingSessions);
+    const openObligations = activeObligationCount(pendingObligations);
     const centerOfGravity = activeBridgePresent
         ? "shared-work"
         : (input.inner.status === "running" || input.inner.hasPending || input.mustResolveBeforeHandoff || openObligations > 0 || liveCodingSessions.length > 0)
@@ -384,7 +430,7 @@ function buildActiveWorkFrame(input) {
             currentObligation: input.currentObligation,
             mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
             bridges: input.bridges,
-            pendingObligations: input.pendingObligations,
+            pendingObligations,
             taskBoard: input.taskBoard,
             targetCandidates: input.targetCandidates,
         }),
@@ -410,6 +456,8 @@ 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.");
+    lines.push("if older checkpoints elsewhere in the transcript disagree with this picture, this picture wins.");
     const primaryObligation = findPrimaryOpenObligation(frame);
     const currentSessionObligation = findCurrentSessionOpenObligation(frame);
     const activeLane = formatActiveLane(frame, primaryObligation);
@@ -537,3 +585,23 @@ function formatActiveWorkFrame(frame) {
     }
     return lines.join("\n");
 }
+function formatLiveWorldStateCheckpoint(frame) {
+    const primaryObligation = findPrimaryOpenObligation(frame);
+    const activeLane = formatActiveLane(frame, primaryObligation) ?? "no explicit live lane";
+    const currentArtifact = formatCurrentArtifact(frame, primaryObligation) ?? "no artifact yet";
+    const nextAction = formatNextAction(frame, primaryObligation) ?? "continue from the live world-state";
+    const otherActiveSessions = formatOtherActiveSessionSummaries(frame);
+    const lines = [
+        "## live world-state checkpoint",
+        "this is the freshest reality for this turn. if older transcript history disagrees, treat it as stale.",
+        `- live conversation: ${frame.currentSession ? formatSessionLabel(frame.currentSession) : "not in a live conversation"}`,
+        `- active lane: ${activeLane}`,
+        `- current artifact: ${currentArtifact}`,
+        `- next action: ${nextAction}`,
+    ];
+    if (otherActiveSessions.length > 0) {
+        lines.push("other active sessions:");
+        lines.push(...otherActiveSessions);
+    }
+    return lines.join("\n");
+}

package/dist/mind/prompt.js

@@ -465,6 +465,12 @@ 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 treat older checkpoints elsewhere in this transcript as stale history when they conflict with the active-work surface above.
+i do not repeat an old coding lane or old checkpoint as current just because it appeared earlier in the thread.
+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.
 when the live ask is about status, i widen before answering:
@@ -485,12 +491,15 @@ function centerOfGravitySteeringSection(channel, options, context) {
     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.\nwhen that world-state conflicts with older transcript history, the world-state wins."
+        : "";
     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}`;
         }
@@ -502,7 +511,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.`;
@@ -513,7 +522,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.`;
         }
@@ -537,7 +546,7 @@ 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}.${familyStatusClause}
+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.`;
         }
@@ -552,7 +561,7 @@ 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.`;
     }

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/dist/senses/pipeline.js

@@ -44,6 +44,24 @@ function isLiveCodingSessionStatus(status) {
         || status === "waiting_input"
         || status === "stalled";
 }
+function prependTurnSections(message, sections) {
+    if (message.role !== "user" || sections.length === 0)
+        return message;
+    const prefix = sections.join("\n\n");
+    if (typeof message.content === "string") {
+        return {
+            ...message,
+            content: `${prefix}\n\n${message.content}`,
+        };
+    }
+    return {
+        ...message,
+        content: [
+            { type: "text", text: `${prefix}\n\n` },
+            ...message.content,
+        ],
+    };
+}
 function readInnerWorkState() {
     const defaultJob = {
         status: "idle",
@@ -242,33 +260,16 @@ async function handleInboundTurn(input) {
         : (input.drainDeferredReturns?.(resolvedContext.friend.id) ?? []);
     const sessionPending = input.drainPending(input.pendingDir);
     const pending = [...deferredReturns, ...sessionPending];
-    // Assemble messages: session messages + pending (formatted) + inbound user messages
+    // Assemble messages: session messages + live world-state checkpoint + pending + inbound user messages
+    const prefixSections = [(0, active_work_1.formatLiveWorldStateCheckpoint)(activeWorkFrame)];
     if (pending.length > 0) {
-        // Format pending messages and prepend to the user content
         const pendingSection = pending
             .map((msg) => `[pending from ${msg.from}]: ${msg.content}`)
             .join("\n");
-        // If there are inbound user messages, prepend pending to the first one
-        if (input.messages.length > 0) {
-            const firstMsg = input.messages[0];
-            if (firstMsg.role === "user") {
-                if (typeof firstMsg.content === "string") {
-                    input.messages[0] = {
-                        ...firstMsg,
-                        content: `## pending messages\n${pendingSection}\n\n${firstMsg.content}`,
-                    };
-                }
-                else {
-                    input.messages[0] = {
-                        ...firstMsg,
-                        content: [
-                            { type: "text", text: `## pending messages\n${pendingSection}\n\n` },
-                            ...firstMsg.content,
-                        ],
-                    };
-                }
-            }
-        }
+        prefixSections.push(`## pending messages\n${pendingSection}`);
+    }
+    if (input.messages.length > 0) {
+        input.messages[0] = prependTurnSections(input.messages[0], prefixSections);
     }
     // Append user messages from the inbound turn
     for (const msg of input.messages) {

package/package.json

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