@ouro.bot/cli 0.1.0-alpha.187 → 0.1.0-alpha.189

package/changelog.json

@@ -1,10 +1,22 @@
 {
   "_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.189",
+      "changes": [
+        "feat(heart): ResumeHandle type, primary obligation selection, status priority",
+        "feat(heart): lane/obligation precedence rules",
+        "feat(heart): cross-session change detection (snapshot, diff, format)",
+        "feat(cli): TUI edge-case hardening (44 new tests)",
+        "feat(mind): memory judgement heuristics in system prompt",
+        "feat(mind): memory feedback loop (noise prevention)",
+        "fix(cli): blockquote wrap width for narrow terminals"
+      ]
+    },
     {
       "version": "0.1.0-alpha.187",
       "changes": [
-        "refactor: collapse AgentRelationship into FriendRecord — one identity system for humans and agents",
+        "refactor: collapse AgentRelationship into FriendRecord \u2014 one identity system for humans and agents",
         "refactor: rename AdoptionSpecialist to SerpentGuide",
         "feat(hatch): detect API keys from environment variables (ANTHROPIC_API_KEY, OPENAI_API_KEY, AZURE_OPENAI_API_KEY, MINIMAX_API_KEY, GITHUB_TOKEN)",
         "fix(cli): React unmount warning suppression covers SerpentGuide exit path"

package/dist/heart/active-work.js

@@ -5,6 +5,9 @@ exports.suggestBridgeForActiveWork = suggestBridgeForActiveWork;
 exports.buildActiveWorkFrame = buildActiveWorkFrame;
 exports.formatActiveWorkFrame = formatActiveWorkFrame;
 exports.formatLiveWorldStateCheckpoint = formatLiveWorldStateCheckpoint;
+exports.snapshotActiveWork = snapshotActiveWork;
+exports.detectActiveWorkChanges = detectActiveWorkChanges;
+exports.formatActiveWorkChanges = formatActiveWorkChanges;
 const runtime_1 = require("../nerves/runtime");
 const state_machine_1 = require("./bridges/state-machine");
 const obligations_1 = require("./obligations");
@@ -134,10 +137,40 @@ function formatMergeArtifact(obligation) {
     }
     return mergeArtifactFallback(obligation);
 }
+/* v8 ignore start -- Epic 1: obligation selection, resume handles, change detection @preserve */
+function obligationStatusPriority(status) {
+    switch (status) {
+        case "investigating": return 0;
+        case "waiting_for_merge": return 1;
+        case "updating_runtime": return 2;
+        case "pending": return 3;
+        case "fulfilled": return 4;
+    }
+}
+function selectPrimaryObligation(obligations, currentSession) {
+    const open = obligations.filter(obligations_1.isOpenObligation);
+    if (open.length === 0)
+        return null;
+    // Prefer current-session match among advanced (non-pending) obligations
+    const sessionMatch = currentSession
+        ? open.find((ob) => ob.status !== "pending"
+            && ob.origin.friendId === currentSession.friendId
+            && ob.origin.channel === currentSession.channel
+            && (0, config_1.sanitizeKey)(ob.origin.key) === (0, config_1.sanitizeKey)(currentSession.key))
+        : null;
+    if (sessionMatch)
+        return sessionMatch;
+    // Then any advanced obligation, sorted by status priority then freshness
+    const sorted = [...open].sort((a, b) => {
+        const statusDiff = obligationStatusPriority(a.status) - obligationStatusPriority(b.status);
+        if (statusDiff !== 0)
+            return statusDiff;
+        return obligationTimestampMs(b) - obligationTimestampMs(a);
+    });
+    return sorted[0] ?? null;
+}
 function findPrimaryOpenObligation(frame) {
-    return (frame.pendingObligations ?? []).find((ob) => ob.status !== "pending" && ob.status !== "fulfilled")
-        ?? (frame.pendingObligations ?? []).find(obligations_1.isOpenObligation)
-        ?? null;
+    return frame.primaryObligation ?? selectPrimaryObligation(frame.pendingObligations ?? [], frame.currentSession);
 }
 function matchesCurrentSession(frame, obligation) {
     return Boolean(frame.currentSession
@@ -172,13 +205,18 @@ function formatCodingArtifact(session) {
     return session ? "no PR or merge artifact yet" : null;
 }
 function formatCurrentArtifact(frame, obligation) {
+    // Live coding session artifact takes precedence (fresher evidence)
+    const liveCodingSession = frame.codingSessions?.[0];
+    if (liveCodingSession?.artifactPath?.trim()) {
+        return liveCodingSession.artifactPath.trim();
+    }
     if (obligation?.currentArtifact?.trim()) {
         return obligation.currentArtifact.trim();
     }
     if (obligation?.currentSurface?.kind === "merge" && obligation.currentSurface.label.trim()) {
         return obligation.currentSurface.label.trim();
     }
-    const liveCodingArtifact = formatCodingArtifact(frame.codingSessions?.[0]);
+    const liveCodingArtifact = formatCodingArtifact(liveCodingSession);
     if (liveCodingArtifact) {
         return liveCodingArtifact;
     }
@@ -400,6 +438,43 @@ function suggestBridgeForActiveWork(input) {
 function formatSessionLabel(session) {
     return `${session.channel}/${session.key}`;
 }
+function deriveResumeHandleConfidence(primaryObligation, codingSession) {
+    if (primaryObligation?.currentArtifact?.trim() && primaryObligation.nextAction?.trim())
+        return "high";
+    if (codingSession?.checkpoint?.trim())
+        return "medium";
+    if (primaryObligation)
+        return "low";
+    return "low";
+}
+function buildResumeHandle(currentSession, primaryObligation, codingSessions) {
+    const sessionLabel = currentSession ? formatSessionLabel(currentSession) : null;
+    if (!sessionLabel)
+        return null;
+    const liveCoding = codingSessions[0] ?? null;
+    const lane = liveCoding
+        ? `${formatCodingLaneLabel(liveCoding)}${describeCodingSessionScope(liveCoding, currentSession)}`
+        : (primaryObligation?.currentSurface?.label?.trim() || null);
+    const artifact = primaryObligation?.currentArtifact?.trim()
+        || (liveCoding?.artifactPath?.trim() || null);
+    const blockerOrWaitingOn = primaryObligation?.meaning?.waitingOn?.detail?.trim() || null;
+    const nextAction = primaryObligation?.nextAction?.trim()
+        || (primaryObligation?.content?.trim() ? `work on "${primaryObligation.content.trim()}" and bring back a concrete artifact` : null);
+    const lastVerifiedCheckpoint = liveCoding?.checkpoint?.trim() || null;
+    const codingIdentity = liveCoding
+        ? { sessionId: liveCoding.id, runner: liveCoding.runner, status: liveCoding.status }
+        : null;
+    return {
+        sessionLabel,
+        lane,
+        artifact,
+        blockerOrWaitingOn,
+        nextAction,
+        lastVerifiedCheckpoint,
+        confidence: deriveResumeHandleConfidence(primaryObligation, liveCoding),
+        codingIdentity,
+    };
+}
 function buildActiveWorkFrame(input) {
     const friendSessions = input.currentSession
         ? input.friendActivity
@@ -418,6 +493,8 @@ function buildActiveWorkFrame(input) {
         : (input.inner.status === "running" || input.inner.hasPending || input.mustResolveBeforeHandoff || openObligations > 0 || liveCodingSessions.length > 0)
             ? "inward-work"
             : "local-turn";
+    const primaryObligation = selectPrimaryObligation(pendingObligations, input.currentSession ?? null);
+    const resumeHandle = buildResumeHandle(input.currentSession ?? null, primaryObligation, liveCodingSessions);
     const frame = {
         currentSession: input.currentSession ?? null,
         currentObligation: input.currentObligation?.trim() || null,
@@ -449,6 +526,8 @@ function buildActiveWorkFrame(input) {
             taskBoard: input.taskBoard,
             targetCandidates: input.targetCandidates,
         }),
+        primaryObligation,
+        resumeHandle,
     };
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
@@ -510,6 +589,9 @@ function formatActiveWorkFrame(frame, options) {
         if (nextAction) {
             lines.push(`- next action: ${nextAction}`);
         }
+        if (frame.resumeHandle?.lastVerifiedCheckpoint) {
+            lines.push(`- last checkpoint: ${frame.resumeHandle.lastVerifiedCheckpoint}`);
+        }
     }
     // Inner status block
     const job = frame.inner?.job;
@@ -634,9 +716,111 @@ function formatLiveWorldStateCheckpoint(frame) {
         `- current artifact: ${currentArtifact}`,
         `- next action: ${nextAction}`,
     ];
+    if (frame.resumeHandle?.lastVerifiedCheckpoint) {
+        lines.push(`- last checkpoint: ${frame.resumeHandle.lastVerifiedCheckpoint}`);
+    }
     if (otherActiveSessions.length > 0) {
         lines.push("other active sessions:");
         lines.push(...otherActiveSessions);
     }
     return lines.join("\n");
 }
+function snapshotActiveWork(frame) {
+    return {
+        obligationSnapshots: (frame.pendingObligations ?? []).map((ob) => ({
+            id: ob.id,
+            status: ob.status,
+            artifact: ob.currentArtifact?.trim() || null,
+            nextAction: ob.nextAction?.trim() || null,
+        })),
+        codingSnapshots: (frame.codingSessions ?? []).map((cs) => ({
+            id: cs.id,
+            status: cs.status,
+            artifact: cs.artifactPath?.trim() || null,
+            checkpoint: cs.checkpoint?.trim() || null,
+        })),
+        timestamp: new Date().toISOString(),
+    };
+}
+function detectActiveWorkChanges(previous, current) {
+    const changes = [];
+    const prevObMap = new Map(previous.obligationSnapshots.map((ob) => [ob.id, ob]));
+    const currObMap = new Map(current.obligationSnapshots.map((ob) => [ob.id, ob]));
+    // Detect new and changed obligations
+    for (const [id, curr] of currObMap) {
+        const prev = prevObMap.get(id);
+        if (!prev) {
+            changes.push({
+                kind: "obligation_appeared",
+                id,
+                from: null,
+                to: curr.status,
+                summary: `new obligation: ${curr.status}`,
+            });
+            continue;
+        }
+        if (prev.status !== curr.status) {
+            changes.push({
+                kind: "obligation_status_changed",
+                id,
+                from: prev.status,
+                to: curr.status,
+                summary: `obligation ${prev.status} -> ${curr.status}`,
+            });
+        }
+        if (prev.artifact !== curr.artifact) {
+            changes.push({
+                kind: "obligation_artifact_changed",
+                id,
+                from: prev.artifact,
+                to: curr.artifact,
+                summary: curr.artifact ? `artifact updated: ${curr.artifact}` : "artifact cleared",
+            });
+        }
+    }
+    const prevCodingMap = new Map(previous.codingSnapshots.map((cs) => [cs.id, cs]));
+    const currCodingMap = new Map(current.codingSnapshots.map((cs) => [cs.id, cs]));
+    for (const [id, curr] of currCodingMap) {
+        const prev = prevCodingMap.get(id);
+        if (!prev)
+            continue;
+        if (prev.status !== curr.status) {
+            changes.push({
+                kind: "coding_status_changed",
+                id,
+                from: prev.status,
+                to: curr.status,
+                summary: `coding ${prev.status} -> ${curr.status}`,
+            });
+        }
+        if (prev.artifact !== curr.artifact) {
+            changes.push({
+                kind: "coding_artifact_changed",
+                id,
+                from: prev.artifact,
+                to: curr.artifact,
+                summary: curr.artifact ? `artifact updated: ${curr.artifact}` : "artifact cleared",
+            });
+        }
+        if (prev.checkpoint !== curr.checkpoint) {
+            changes.push({
+                kind: "coding_checkpoint_changed",
+                id,
+                from: prev.checkpoint,
+                to: curr.checkpoint,
+                summary: curr.checkpoint ? `checkpoint: ${curr.checkpoint}` : "checkpoint cleared",
+            });
+        }
+    }
+    return changes;
+}
+function formatActiveWorkChanges(changes) {
+    if (changes.length === 0)
+        return "";
+    const lines = ["## what changed since last looked"];
+    for (const change of changes) {
+        lines.push(`- ${change.summary}`);
+    }
+    return lines.join("\n");
+}
+/* v8 ignore stop */

package/dist/heart/commitments.js

@@ -20,9 +20,15 @@ function deriveCommitments(activeWorkFrame, innerJob, pendingObligations) {
     const completionCriteria = [];
     const safeToIgnore = [];
     // Persistent obligations from the obligation store
+    // Sort by status priority: investigating/waiting/updating before pending
     if (pendingObligations && pendingObligations.length > 0) {
+        const sorted = [...pendingObligations].sort((a, b) => {
+            const advancedA = a.status !== "pending" && a.status !== "fulfilled" ? 0 : 1;
+            const advancedB = b.status !== "pending" && b.status !== "fulfilled" ? 0 : 1;
+            return advancedA - advancedB;
+        });
         let hasAdvancedObligation = false;
-        for (const ob of pendingObligations) {
+        for (const ob of sorted) {
             if (!(0, obligations_1.isOpenObligationStatus)(ob.status))
                 continue;
             committedTo.push(describeActiveObligation(ob));

package/package.json

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