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

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.102",
+      "changes": [
+        "Live obligations now persist a concrete current artifact and next action, so status answers can anchor on the actual active lane, artifact, and immediate step instead of drifting into broad mission statements.",
+        "Obligation-bound coding feedback now turns PR milestones into structured report-backs and lifecycle updates, which keeps the originating live conversation informed when child work opens a PR, waits for merge, or needs a runtime update."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.101",
+      "changes": [
+        "Live coding-session status now prefers active work from the current thread instead of resurfacing stale global history, so agents stop anchoring on ancient sessions like `coding-001` when newer coding lanes are already in flight.",
+        "Active-work rendering and prompt steering now surface same-thread live coding lanes explicitly, giving the agent a clearer center of gravity before it answers questions about ongoing work."
+      ]
+    },
     {
       "version": "0.1.0-alpha.100",
       "changes": [

package/dist/heart/active-work.js

@@ -32,6 +32,20 @@ function hasSharedObligationPressure(input) {
         && input.currentObligation.trim().length > 0) || input.mustResolveBeforeHandoff
         || summarizeLiveTasks(input.taskBoard).length > 0;
 }
+function formatCodingLaneLabel(session) {
+    return `${session.runner} ${session.id}`;
+}
+function describeCodingSessionScope(session, currentSession) {
+    if (!session.originSession)
+        return "";
+    if (currentSession
+        && session.originSession.friendId === currentSession.friendId
+        && session.originSession.channel === currentSession.channel
+        && session.originSession.key === currentSession.key) {
+        return " for this thread";
+    }
+    return ` for ${session.originSession.channel}/${session.originSession.key}`;
+}
 function activeObligationCount(obligations) {
     return (obligations ?? []).filter((ob) => (0, obligations_1.isOpenObligationStatus)(ob.status)).length;
 }
@@ -49,6 +63,62 @@ function formatObligationSurface(obligation) {
             return ` (${obligation.currentSurface.label})`;
     }
 }
+function findPrimaryOpenObligation(frame) {
+    return (frame.pendingObligations ?? []).find((ob) => ob.status !== "pending" && ob.status !== "fulfilled")
+        ?? (frame.pendingObligations ?? []).find(obligations_1.isOpenObligation)
+        ?? null;
+}
+function formatActiveLane(frame, obligation) {
+    const liveCodingSession = frame.codingSessions?.[0];
+    if (liveCodingSession) {
+        return `${formatCodingLaneLabel(liveCodingSession)}${describeCodingSessionScope(liveCodingSession, frame.currentSession)}`;
+    }
+    if (obligation?.currentSurface?.label) {
+        return obligation.currentSurface.label;
+    }
+    if (frame.inner?.job?.status === "running") {
+        return "inner dialog";
+    }
+    return null;
+}
+function formatCurrentArtifact(frame, obligation) {
+    if (obligation?.currentArtifact?.trim()) {
+        return obligation.currentArtifact.trim();
+    }
+    if (obligation?.currentSurface?.kind === "merge" && obligation.currentSurface.label.trim()) {
+        return obligation.currentSurface.label.trim();
+    }
+    if ((frame.codingSessions ?? []).length > 0) {
+        return "no PR or merge artifact yet";
+    }
+    return null;
+}
+function formatNextAction(frame, obligation) {
+    if (obligation?.nextAction?.trim()) {
+        return obligation.nextAction.trim();
+    }
+    const liveCodingSession = frame.codingSessions?.[0];
+    if (liveCodingSession?.status === "waiting_input") {
+        return `answer ${formatCodingLaneLabel(liveCodingSession)} and continue`;
+    }
+    if (liveCodingSession?.status === "stalled") {
+        return `unstick ${formatCodingLaneLabel(liveCodingSession)} and continue`;
+    }
+    if (liveCodingSession) {
+        return "finish the coding pass and bring the result back here";
+    }
+    if (obligation?.status === "waiting_for_merge") {
+        const artifact = formatCurrentArtifact(frame, obligation) ?? "the fix";
+        return `wait for checks, merge ${artifact}, then update runtime`;
+    }
+    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";
+    }
+    return null;
+}
 function suggestBridgeForActiveWork(input) {
     const targetCandidates = (input.targetCandidates ?? [])
         .filter((candidate) => {
@@ -106,9 +176,10 @@ function buildActiveWorkFrame(input) {
     const liveTaskNames = summarizeLiveTasks(input.taskBoard);
     const activeBridgePresent = input.bridges.some(isActiveBridge);
     const openObligations = activeObligationCount(input.pendingObligations);
+    const liveCodingSessions = input.codingSessions ?? [];
     const centerOfGravity = activeBridgePresent
         ? "shared-work"
-        : (input.inner.status === "running" || input.inner.hasPending || input.mustResolveBeforeHandoff || openObligations > 0)
+        : (input.inner.status === "running" || input.inner.hasPending || input.mustResolveBeforeHandoff || openObligations > 0 || liveCodingSessions.length > 0)
             ? "inward-work"
             : "local-turn";
     const frame = {
@@ -127,6 +198,7 @@ function buildActiveWorkFrame(input) {
             freshestForCurrentFriend: friendSessions[0] ?? null,
             otherLiveSessionsForCurrentFriend: friendSessions,
         },
+        codingSessions: liveCodingSessions,
         pendingObligations: input.pendingObligations ?? [],
         targetCandidates: input.targetCandidates ?? [],
         bridgeSuggestion: suggestBridgeForActiveWork({
@@ -148,6 +220,7 @@ function buildActiveWorkFrame(input) {
             bridges: frame.bridges.length,
             liveTasks: frame.taskPressure.liveTaskNames.length,
             liveSessions: frame.friendActivity.otherLiveSessionsForCurrentFriend.length,
+            codingSessions: frame.codingSessions.length,
             pendingObligations: openObligations,
             hasBridgeSuggestion: frame.bridgeSuggestion !== null,
         },
@@ -156,6 +229,10 @@ function buildActiveWorkFrame(input) {
 }
 function formatActiveWorkFrame(frame) {
     const lines = ["## what i'm holding"];
+    const primaryObligation = findPrimaryOpenObligation(frame);
+    const activeLane = formatActiveLane(frame, primaryObligation);
+    const currentArtifact = formatCurrentArtifact(frame, primaryObligation);
+    const nextAction = formatNextAction(frame, primaryObligation);
     // Session line
     if (frame.currentSession) {
         let sessionLine = `i'm in a conversation on ${formatSessionLabel(frame.currentSession)}.`;
@@ -172,6 +249,22 @@ function formatActiveWorkFrame(frame) {
         lines.push("");
         lines.push("i'm not in a conversation right now.");
     }
+    if (activeLane || currentArtifact || nextAction) {
+        lines.push("");
+        lines.push("## current concrete state");
+        if (frame.currentSession) {
+            lines.push(`- live conversation: ${formatSessionLabel(frame.currentSession)}`);
+        }
+        if (activeLane) {
+            lines.push(`- active lane: ${activeLane}`);
+        }
+        if (currentArtifact) {
+            lines.push(`- current artifact: ${currentArtifact}`);
+        }
+        if (nextAction) {
+            lines.push(`- next action: ${nextAction}`);
+        }
+    }
     // Inner status block
     const job = frame.inner?.job;
     if (job) {
@@ -205,6 +298,13 @@ function formatActiveWorkFrame(frame) {
         }
         // idle, returned, abandoned: omitted
     }
+    if ((frame.codingSessions ?? []).length > 0) {
+        lines.push("");
+        lines.push("## live coding work");
+        for (const session of frame.codingSessions) {
+            lines.push(`- [${session.status}] ${formatCodingLaneLabel(session)}${describeCodingSessionScope(session, frame.currentSession)}`);
+        }
+    }
     // Task pressure
     if ((frame.taskPressure?.liveTaskNames ?? []).length > 0) {
         lines.push("");

package/dist/heart/obligations.js

@@ -140,6 +140,12 @@ function advanceObligation(agentRoot, obligationId, update) {
     if (update.currentSurface) {
         obligation.currentSurface = update.currentSurface;
     }
+    if (typeof update.currentArtifact === "string") {
+        obligation.currentArtifact = update.currentArtifact;
+    }
+    if (typeof update.nextAction === "string") {
+        obligation.nextAction = update.nextAction;
+    }
     if (typeof update.latestNote === "string") {
         obligation.latestNote = update.latestNote;
     }

package/dist/mind/obligation-steering.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findActivePersistentObligation = findActivePersistentObligation;
 exports.renderActiveObligationSteering = renderActiveObligationSteering;
+exports.renderConcreteStatusGuidance = renderConcreteStatusGuidance;
 const runtime_1 = require("../nerves/runtime");
 function findActivePersistentObligation(frame) {
     if (!frame)
@@ -29,3 +30,58 @@ i'm already working on something i owe ${name}.${surfaceLine}
 
 i should close that loop before i act like this is a fresh blank turn.`;
 }
+function formatActiveLane(frame, obligation) {
+    const liveCodingSession = frame.codingSessions?.[0];
+    if (liveCodingSession) {
+        const sameThread = frame.currentSession
+            && liveCodingSession.originSession
+            && liveCodingSession.originSession.friendId === frame.currentSession.friendId
+            && liveCodingSession.originSession.channel === frame.currentSession.channel
+            && liveCodingSession.originSession.key === frame.currentSession.key;
+        return sameThread
+            ? `${liveCodingSession.runner} ${liveCodingSession.id} for this same thread`
+            : liveCodingSession.originSession
+                ? `${liveCodingSession.runner} ${liveCodingSession.id} for ${liveCodingSession.originSession.channel}/${liveCodingSession.originSession.key}`
+                : `${liveCodingSession.runner} ${liveCodingSession.id}`;
+    }
+    return obligation.currentSurface?.label || "this live loop";
+}
+function formatCurrentArtifact(frame, obligation) {
+    return obligation.currentArtifact
+        || (obligation.currentSurface?.kind === "merge" ? obligation.currentSurface.label : "")
+        || ((frame.codingSessions ?? []).length > 0 ? "no PR or merge artifact yet" : "no explicit artifact yet");
+}
+function formatNextAction(frame, obligation) {
+    if (obligation.nextAction)
+        return obligation.nextAction;
+    const liveCodingSession = frame.codingSessions?.[0];
+    if (liveCodingSession?.status === "waiting_input") {
+        return `answer ${liveCodingSession.runner} ${liveCodingSession.id} and continue`;
+    }
+    if (liveCodingSession?.status === "stalled") {
+        return `unstick ${liveCodingSession.runner} ${liveCodingSession.id} and continue`;
+    }
+    if (liveCodingSession) {
+        return "finish the coding pass and bring the result back here";
+    }
+    if (obligation.status === "waiting_for_merge") {
+        return `wait for checks, merge ${formatCurrentArtifact(frame, obligation)}, then update runtime`;
+    }
+    if (obligation.status === "updating_runtime") {
+        return "update runtime, verify version/changelog, then re-observe";
+    }
+    return "continue the active loop and bring the result back here";
+}
+function renderConcreteStatusGuidance(frame, obligation) {
+    if (!obligation)
+        return "";
+    const activeLane = formatActiveLane(frame, obligation);
+    const currentArtifact = formatCurrentArtifact(frame, obligation);
+    const nextAction = formatNextAction(frame, obligation);
+    return `if someone asks what i'm doing or for status, i answer from the concrete state:
+- active lane: ${activeLane}
+- current artifact: ${currentArtifact}
+- next action: ${nextAction}
+
+i don't replace that with a broad mission statement if this concrete state is available.`;
+}

package/dist/mind/prompt.js

@@ -470,7 +470,9 @@ function centerOfGravitySteeringSection(channel, options) {
     const activeObligation = (0, obligation_steering_1.findActivePersistentObligation)(frame);
     if (cog === "inward-work") {
         if (activeObligation) {
-            return (0, obligation_steering_1.renderActiveObligationSteering)(activeObligation);
+            return `${(0, obligation_steering_1.renderActiveObligationSteering)(activeObligation)}
+
+${(0, obligation_steering_1.renderConcreteStatusGuidance)(frame, activeObligation)}`;
         }
         if (job?.status === "queued" || job?.status === "running") {
             const originClause = job.origin
@@ -494,6 +496,23 @@ if it's separate, i can be fully present here -- my inner work will wait.`;
 i've been thinking privately and reached something.${originClause}
 
 i should bring my answer back to the conversation it came from.`;
+        }
+        const liveCodingSession = frame.codingSessions?.[0];
+        if (liveCodingSession) {
+            const sameThread = frame.currentSession
+                && liveCodingSession.originSession
+                && liveCodingSession.originSession.friendId === frame.currentSession.friendId
+                && liveCodingSession.originSession.channel === frame.currentSession.channel
+                && liveCodingSession.originSession.key === frame.currentSession.key;
+            const scopeClause = sameThread
+                ? " for this same thread"
+                : liveCodingSession.originSession
+                    ? ` for ${liveCodingSession.originSession.channel}/${liveCodingSession.originSession.key}`
+                    : "";
+            return `## where my attention is
+i already have coding work running in ${liveCodingSession.runner} ${liveCodingSession.id}${scopeClause}.
+
+i should orient around that live lane first, then decide what still needs to come back here.`;
         }
         return `## where my attention is
 i have unfinished work that needs attention before i move on.

package/dist/repertoire/coding/feedback.js

@@ -14,6 +14,8 @@ const OBLIGATION_WAKE_UPDATE_KINDS = new Set([
     "failed",
     "killed",
 ]);
+const PULL_REQUEST_NUMBER_PATTERN = /\bPR\s*#(\d+)\b/i;
+const PULL_REQUEST_URL_PATTERN = /\/pull\/(\d+)(?:\b|\/)?/i;
 function clip(text, maxLength = 280) {
     const trimmed = text.trim();
     if (trimmed.length <= maxLength)
@@ -57,6 +59,61 @@ function formatSessionLabel(session) {
         : "";
     return `${session.runner} ${session.id}${origin}`;
 }
+function extractPullRequestLabel(snippet) {
+    if (!snippet)
+        return null;
+    const numberMatch = snippet.match(PULL_REQUEST_NUMBER_PATTERN);
+    if (numberMatch)
+        return `PR #${numberMatch[1]}`;
+    const urlMatch = snippet.match(PULL_REQUEST_URL_PATTERN);
+    if (urlMatch)
+        return `PR #${urlMatch[1]}`;
+    return null;
+}
+function isMergedPullRequestSnippet(snippet) {
+    return /\bmerged\b/i.test(snippet) || /\blanded\b/i.test(snippet);
+}
+function deriveObligationMilestone(update) {
+    const snippet = pickUpdateSnippet(update);
+    const pullRequest = extractPullRequestLabel(snippet);
+    if (update.kind === "completed" && snippet && pullRequest && isMergedPullRequestSnippet(snippet)) {
+        return {
+            status: "updating_runtime",
+            currentSurface: { kind: "runtime", label: "ouro up" },
+            currentArtifact: pullRequest,
+            nextAction: "update runtime, verify version/changelog, then re-observe",
+        };
+    }
+    if (update.kind === "completed" && pullRequest) {
+        return {
+            status: "waiting_for_merge",
+            currentSurface: { kind: "merge", label: pullRequest },
+            currentArtifact: pullRequest,
+            nextAction: `wait for checks, merge ${pullRequest}, then update runtime`,
+        };
+    }
+    if (update.kind === "waiting_input") {
+        return {
+            status: "investigating",
+            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            nextAction: `answer ${update.session.runner} ${update.session.id} and continue`,
+        };
+    }
+    if (update.kind === "stalled") {
+        return {
+            status: "investigating",
+            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            nextAction: `unstick ${update.session.runner} ${update.session.id} and continue`,
+        };
+    }
+    if (update.kind === "progress" || update.kind === "spawned" || update.kind === "failed" || update.kind === "killed" || update.kind === "completed") {
+        return {
+            status: "investigating",
+            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+        };
+    }
+    return null;
+}
 function isSafeProgressSnippet(snippet) {
     const wordCount = snippet.split(/\s+/).filter(Boolean).length;
     return (snippet.length <= 80
@@ -94,6 +151,22 @@ function formatUpdateMessage(update) {
             return `${label} started`;
     }
 }
+function formatReportBackMessage(update, baseMessage) {
+    if (!baseMessage)
+        return null;
+    if (!update.session.obligationId || !update.session.originSession) {
+        return baseMessage;
+    }
+    const milestone = deriveObligationMilestone(update);
+    const extraLines = [];
+    if (milestone?.currentArtifact) {
+        extraLines.push(`current artifact: ${milestone.currentArtifact}`);
+    }
+    if (milestone?.nextAction) {
+        extraLines.push(`next: ${milestone.nextAction}`);
+    }
+    return extraLines.length > 0 ? `${baseMessage}\n${extraLines.join("\n")}` : baseMessage;
+}
 function obligationNoteFromUpdate(update) {
     const snippet = pickUpdateSnippet(update);
     switch (update.kind) {
@@ -121,10 +194,13 @@ function syncObligationFromUpdate(update) {
     const obligationId = update.session.obligationId;
     if (!obligationId)
         return;
+    const milestone = deriveObligationMilestone(update);
     try {
         (0, obligations_1.advanceObligation)((0, identity_1.getAgentRoot)(), obligationId, {
-            status: "investigating",
-            currentSurface: { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            status: milestone?.status ?? "investigating",
+            currentSurface: milestone?.currentSurface ?? { kind: "coding", label: `${update.session.runner} ${update.session.id}` },
+            currentArtifact: milestone?.currentArtifact,
+            nextAction: milestone?.nextAction,
             latestNote: obligationNoteFromUpdate(update) ?? undefined,
         });
     }
@@ -193,10 +269,10 @@ function attachCodingSessionFeedback(manager, session, target) {
     };
     const spawnedUpdate = { kind: "spawned", session };
     syncObligationFromUpdate(spawnedUpdate);
-    sendMessage(formatUpdateMessage(spawnedUpdate));
+    sendMessage(formatReportBackMessage(spawnedUpdate, formatUpdateMessage(spawnedUpdate)));
     unsubscribe = manager.subscribe(session.id, async (update) => {
         syncObligationFromUpdate(update);
-        sendMessage(formatUpdateMessage(update));
+        sendMessage(formatReportBackMessage(update, formatUpdateMessage(update)));
         await wakeInnerDialogForObligation(update);
         if (TERMINAL_UPDATE_KINDS.has(update.kind)) {
             closed = true;

package/dist/repertoire/coding/tools.js

@@ -60,6 +60,45 @@ function findReusableCodingSession(sessions, request) {
     const matches = sessions.filter((session) => matchesReusableCodingSession(session, request)).sort(latestSessionFirst);
     return matches[0] ?? null;
 }
+function isLiveCodingStatus(status) {
+    return status === "spawning" || status === "running" || status === "waiting_input" || status === "stalled";
+}
+function rankCodingStatusSession(session, currentSession) {
+    return sameOriginSession({
+        friendId: currentSession.friendId,
+        channel: currentSession.channel,
+        key: currentSession.key,
+    }, session.originSession)
+        ? 0
+        : 1;
+}
+function selectCodingStatusSessions(sessions, currentSession) {
+    if (sessions.length === 0)
+        return [];
+    if (!currentSession) {
+        return sessions;
+    }
+    const activeSessions = sessions.filter((session) => isLiveCodingStatus(session.status)).sort(latestSessionFirst);
+    if (activeSessions.length > 0) {
+        return activeSessions.sort((left, right) => {
+            const rankDelta = rankCodingStatusSession(left, currentSession) - rankCodingStatusSession(right, currentSession);
+            if (rankDelta !== 0)
+                return rankDelta;
+            return latestSessionFirst(left, right);
+        });
+    }
+    const matchingClosedSessions = sessions
+        .filter((session) => sameOriginSession({
+        friendId: currentSession.friendId,
+        channel: currentSession.channel,
+        key: currentSession.key,
+    }, session.originSession))
+        .sort(latestSessionFirst);
+    if (matchingClosedSessions.length > 0) {
+        return matchingClosedSessions;
+    }
+    return [...sessions].sort(latestSessionFirst);
+}
 const codingSpawnTool = {
     type: "function",
     function: {
@@ -218,12 +257,12 @@ exports.codingToolDefinitions = [
     },
     {
         tool: codingStatusTool,
-        handler: (args) => {
+        handler: (args, ctx) => {
             emitCodingToolEvent("coding_status");
             const manager = (0, index_1.getCodingSessionManager)();
             const sessionId = requireArg(args, "sessionId");
             if (!sessionId) {
-                return JSON.stringify(manager.listSessions());
+                return JSON.stringify(selectCodingStatusSessions(manager.listSessions(), ctx?.currentSession));
             }
             const session = manager.getSession(sessionId);
             if (!session)

package/dist/senses/pipeline.js

@@ -11,6 +11,7 @@ const continuity_1 = require("./continuity");
 const manager_1 = require("../heart/bridges/manager");
 const identity_1 = require("../heart/identity");
 const tasks_1 = require("../repertoire/tasks");
+const coding_1 = require("../repertoire/coding");
 const session_activity_1 = require("../heart/session-activity");
 const active_work_1 = require("../heart/active-work");
 const delegation_1 = require("../heart/delegation");
@@ -186,12 +187,32 @@ async function handleInboundTurn(input) {
     catch {
         pendingObligations = [];
     }
+    let codingSessions = [];
+    try {
+        codingSessions = (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;
+        });
+    }
+    catch {
+        codingSessions = [];
+    }
     const activeWorkFrame = (0, active_work_1.buildActiveWorkFrame)({
         currentSession,
         currentObligation,
         mustResolveBeforeHandoff,
         inner: readInnerWorkState(),
         bridges: activeBridges,
+        codingSessions,
         pendingObligations,
         taskBoard: (() => {
             try {

package/package.json

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