@ouro.bot/cli 0.1.0-alpha.667 → 0.1.0-alpha.668

package/changelog.json

@@ -1,6 +1,12 @@
 {
   "_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.668",
+      "changes": [
+        "Harden flight-recorder reconciliation so terminal fulfilled-only repairs are not continuable work, unverifiable active obligation ids are preserved and degraded, parseable-invalid obligation records are excluded from verified recovery state, synthesized recovery actions get fresh provenance, reads remain side-effect-free, and legacy obligation records stay visible in Mailbox, Workbench, and Work Card summaries."
+      ]
+    },
     {
       "version": "0.1.0-alpha.667",
       "changes": [

package/dist/arc/flight-recorder.js

@@ -50,6 +50,7 @@ const path = __importStar(require("path"));
 const crypto_1 = require("crypto");
 const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
+const obligations_1 = require("./obligations");
 function isHabitRunTrigger(value) {
     return value === "cron"
         || value === "launchd"
@@ -201,7 +202,7 @@ function normalizeResumeInvariants(resume) {
     ];
     const missingChanged = resume.missing.join("\n") !== missing.join("\n");
     const issues = [
-        ...(resume.canContinue && !resume.hasCompleteState ? ["canContinue true while hasCompleteState false"] : []),
+        ...(resume.canContinue && !hasCompleteState ? ["canContinue true while hasCompleteState false"] : []),
         ...(resume.canContinue && !hasCurrentAsk ? ["canContinue true without currentAsk"] : []),
         ...(resume.canContinue && !hasNextSafeAction ? ["canContinue true without nextSafeAction"] : []),
         ...(resume.canContinue && resume.blockedBecause.length > 0 ? ["canContinue true while blocked"] : []),
@@ -226,7 +227,117 @@ function normalizeResumeInvariants(resume) {
             : resume.recorderHealth,
     };
 }
-/* v8 ignore stop */
+const FLIGHT_RECORDER_RECONCILE_SOURCE_ID = "reconcile:active-obligations";
+function remainingArcWorkDescriptions(resume) {
+    return [
+        ...resume.activeReturnObligationIds.map((id) => `return obligation ${id}`),
+        ...resume.activePacketIds.map((id) => `packet ${id}`),
+        ...resume.openEvolutionCaseIds.map((id) => `evolution case ${id}`),
+    ];
+}
+function nextSafeActionAfterObligationReconcile(resume, activeObligations, staleActiveObligationIds, unverifiableActiveObligationIds) {
+    if (unverifiableActiveObligationIds.length > 0) {
+        return (0, session_events_1.capStructuredRecordString)(`inspect unverifiable active obligations before acting: ${unverifiableActiveObligationIds.join(", ")}`);
+    }
+    const firstActive = activeObligations[0];
+    if (firstActive) {
+        const detail = firstActive.nextAction?.trim() || firstActive.content;
+        return (0, session_events_1.capStructuredRecordString)(`continue open obligation ${firstActive.id}: ${detail}`);
+    }
+    const remainingWork = remainingArcWorkDescriptions(resume);
+    if (remainingWork.length > 0) {
+        return (0, session_events_1.capStructuredRecordString)(`continue remaining Arc work: ${remainingWork.slice(0, 5).join(", ")}`);
+    }
+    return (0, session_events_1.capStructuredRecordString)(`wait for new input; reconciled completed or missing obligations: ${staleActiveObligationIds.join(", ")}`);
+}
+function reconcileActiveObligations(agentRoot, resume) {
+    const obligations = (0, obligations_1.readVerifiedObligations)(agentRoot);
+    const activeObligations = (0, obligations_1.readVerifiedPendingObligations)(agentRoot);
+    const canonicalIdSet = new Set(obligations.map((obligation) => obligation.id));
+    const openIdSet = new Set(activeObligations.map((obligation) => obligation.id));
+    const resumeIdSet = new Set(resume.activeObligationIds);
+    const staleActiveObligationIds = resume.activeObligationIds.filter((id) => canonicalIdSet.has(id) && !openIdSet.has(id));
+    const unverifiableActiveObligationIds = resume.activeObligationIds.filter((id) => !canonicalIdSet.has(id));
+    const missingActiveObligationIds = activeObligations
+        .map((obligation) => obligation.id)
+        .filter((id) => !resumeIdSet.has(id));
+    if (staleActiveObligationIds.length === 0
+        && missingActiveObligationIds.length === 0
+        && unverifiableActiveObligationIds.length === 0) {
+        return { resume, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds };
+    }
+    const activeObligationIds = uniqueStrings([
+        ...resume.activeObligationIds.filter((id) => !staleActiveObligationIds.includes(id)),
+        ...missingActiveObligationIds,
+    ]);
+    const hasActiveArcContinuation = activeObligationIds.length > 0
+        || resume.activeReturnObligationIds.length > 0
+        || resume.activePacketIds.length > 0
+        || resume.openEvolutionCaseIds.length > 0;
+    const isTerminalWait = staleActiveObligationIds.length > 0 && !hasActiveArcContinuation;
+    const mustSynthesizeAction = staleActiveObligationIds.length > 0
+        || unverifiableActiveObligationIds.length > 0
+        || !nonEmpty(resume.nextSafeAction.value);
+    const nextSafeActionValue = mustSynthesizeAction
+        ? nextSafeActionAfterObligationReconcile(resume, activeObligations, staleActiveObligationIds, unverifiableActiveObligationIds)
+        : resume.nextSafeAction.value;
+    const recorderHealth = unverifiableActiveObligationIds.length > 0
+        ? {
+            status: resume.recorderHealth.status === "unavailable" ? "unavailable" : "degraded",
+            issues: uniqueStrings([
+                ...resume.recorderHealth.issues,
+                `active obligation ids could not be verified in arc/obligations: ${unverifiableActiveObligationIds.join(", ")}`,
+            ]),
+        }
+        : resume.recorderHealth;
+    const canContinue = nonEmpty(resume.currentAsk.value)
+        && nonEmpty(nextSafeActionValue)
+        && resume.blockedBecause.length === 0
+        && recorderHealth.status === "ok"
+        && hasActiveArcContinuation
+        && !isTerminalWait;
+    return {
+        resume: normalizeResumeInvariants({
+            ...resume,
+            canContinue,
+            recorderHealth,
+            activeObligationIds,
+            nextSafeAction: {
+                ...resume.nextSafeAction,
+                value: nextSafeActionValue,
+                sourceEventIds: mustSynthesizeAction
+                    ? [FLIGHT_RECORDER_RECONCILE_SOURCE_ID]
+                    : resume.nextSafeAction.sourceEventIds,
+                stopBefore: unverifiableActiveObligationIds.length > 0
+                    ? uniqueStrings([...resume.nextSafeAction.stopBefore, "acting on unverifiable obligation state"])
+                    : resume.nextSafeAction.stopBefore,
+            },
+        }),
+        staleActiveObligationIds,
+        missingActiveObligationIds,
+        unverifiableActiveObligationIds,
+    };
+}
+function normalizeResumeForAgentRoot(agentRoot, resume) {
+    return reconcileActiveObligations(agentRoot, normalizeResumeInvariants(resume));
+}
+function emitFlightRecorderReconciled(agentRoot, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds) {
+    if (staleActiveObligationIds.length === 0
+        && missingActiveObligationIds.length === 0
+        && unverifiableActiveObligationIds.length === 0)
+        return;
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.flight_recorder_resume_reconciled",
+        message: "flight recorder resume reconciled with canonical Arc state",
+        meta: {
+            agentRoot,
+            staleActiveObligationIds,
+            missingActiveObligationIds,
+            unverifiableActiveObligationIds,
+        },
+    });
+}
 function latestFromEvent(event, previous) {
     const currentAskValue = event.currentAsk !== undefined ? event.currentAsk : previous.currentAsk.value;
     const nextSafeActionValue = event.nextSafeAction !== undefined ? event.nextSafeAction : previous.nextSafeAction.value;
@@ -279,7 +390,12 @@ function readFlightRecorderResume(agentRoot) {
         if (!isFlightRecorderResume(parsed)) {
             throw new Error("latest.json has invalid flight-recorder resume shape");
         }
-        const resume = normalizeResumeInvariants(parsed);
+        const { resume, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds, } = normalizeResumeForAgentRoot(agentRoot, parsed);
+        if (staleActiveObligationIds.length > 0
+            || missingActiveObligationIds.length > 0
+            || unverifiableActiveObligationIds.length > 0) {
+            emitFlightRecorderReconciled(agentRoot, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds);
+        }
         (0, runtime_1.emitNervesEvent)({
             component: "mind",
             event: "mind.flight_recorder_resume_read",
@@ -302,8 +418,9 @@ function readFlightRecorderResume(agentRoot) {
     }
 }
 function writeFlightRecorderResume(agentRoot, resume) {
-    const safeResume = normalizeResumeInvariants(resume);
+    const { resume: safeResume, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds, } = normalizeResumeForAgentRoot(agentRoot, resume);
     atomicWriteJson(flightRecorderLatestPath(agentRoot), safeResume);
+    emitFlightRecorderReconciled(agentRoot, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds);
     (0, runtime_1.emitNervesEvent)({
         component: "mind",
         event: "mind.flight_recorder_resume_written",

package/dist/arc/obligations.js

@@ -38,6 +38,8 @@ exports.isOpenObligation = isOpenObligation;
 exports.createObligation = createObligation;
 exports.readObligations = readObligations;
 exports.readPendingObligations = readPendingObligations;
+exports.readVerifiedObligations = readVerifiedObligations;
+exports.readVerifiedPendingObligations = readVerifiedPendingObligations;
 exports.advanceObligation = advanceObligation;
 exports.fulfillObligation = fulfillObligation;
 exports.findPendingObligationForOrigin = findPendingObligationForOrigin;
@@ -64,6 +66,31 @@ function isOpenObligationStatus(status) {
 function isOpenObligation(obligation) {
     return isOpenObligationStatus(obligation.status);
 }
+function isReadableObligation(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const obligation = value;
+    return typeof obligation.id === "string"
+        && typeof obligation.content === "string";
+}
+function isVerifiedObligationStatus(value) {
+    return value === "pending"
+        || value === "investigating"
+        || value === "waiting_for_merge"
+        || value === "updating_runtime"
+        || value === "fulfilled";
+}
+function isVerifiedObligation(value) {
+    if (!isReadableObligation(value))
+        return false;
+    const obligation = value;
+    return isVerifiedObligationStatus(obligation.status)
+        && typeof obligation.createdAt === "string"
+        && !!obligation.origin
+        && typeof obligation.origin.friendId === "string"
+        && typeof obligation.origin.channel === "string"
+        && typeof obligation.origin.key === "string";
+}
 function createObligation(agentRoot, input) {
     const now = new Date().toISOString();
     const id = (0, json_store_1.generateTimestampId)();
@@ -92,11 +119,18 @@ function createObligation(agentRoot, input) {
 }
 function readObligations(agentRoot) {
     const all = (0, json_store_1.readJsonDir)(obligationsDir(agentRoot));
-    return all.filter((parsed) => typeof parsed.id === "string" && typeof parsed.content === "string");
+    return all.filter(isReadableObligation);
 }
 function readPendingObligations(agentRoot) {
     return readObligations(agentRoot).filter(isOpenObligation);
 }
+function readVerifiedObligations(agentRoot) {
+    const all = (0, json_store_1.readJsonDir)(obligationsDir(agentRoot));
+    return all.filter(isVerifiedObligation);
+}
+function readVerifiedPendingObligations(agentRoot) {
+    return readVerifiedObligations(agentRoot).filter(isOpenObligation);
+}
 function advanceObligation(agentRoot, obligationId, update) {
     const dir = obligationsDir(agentRoot);
     const obligation = (0, json_store_1.readJsonFile)(dir, obligationId);

package/dist/heart/mailbox/readers/agent-machine.js

@@ -127,14 +127,24 @@ function normalizeObligationCurrentSurface(currentSurface, updatedAt, liveCoding
         && (Date.now() - updatedAtMs) <= STALE_CODING_SURFACE_WINDOW_MS;
     return recentlyTouched ? currentSurface : null;
 }
+function legacyObligationTimestamp(obligation) {
+    if (typeof obligation.updatedAt === "string")
+        return obligation.updatedAt;
+    if (typeof obligation.createdAt === "string")
+        return obligation.createdAt;
+    return "";
+}
+function legacyObligationStatus(obligation) {
+    return typeof obligation.status === "string" ? obligation.status : "pending";
+}
 function readObligationSummary(agentRoot) {
     const liveCodingSurfaceLabels = buildLiveCodingSurfaceLabels(agentRoot);
     const items = (0, obligations_1.readPendingObligations)(agentRoot)
         .map((obligation) => {
-        const updatedAt = obligation.updatedAt ?? obligation.createdAt;
+        const updatedAt = legacyObligationTimestamp(obligation);
         return {
             id: obligation.id,
-            status: obligation.status,
+            status: legacyObligationStatus(obligation),
             content: obligation.content,
             updatedAt,
             nextAction: obligation.nextAction ?? null,

package/dist/heart/work-card.js

@@ -134,14 +134,18 @@ function scanArcSourceIssues(agentRoot) {
 }
 function obligationItem(obligation) {
     const freshness = obligation.meaning?.stalenessClass === "at-risk" ? "stale_risky" : "current";
+    const status = typeof obligation.status === "string" ? obligation.status : "pending";
+    const updatedAt = typeof obligation.updatedAt === "string"
+        ? obligation.updatedAt
+        : typeof obligation.createdAt === "string" ? obligation.createdAt : undefined;
     return {
         id: obligation.id,
         title: obligation.content,
-        status: obligation.status,
+        status,
         source: source("obligation", obligationLocator(obligation.id), freshness),
         ...(obligation.latestNote ? { summary: obligation.latestNote } : {}),
         ...(obligation.nextAction ? { nextAction: obligation.nextAction } : {}),
-        updatedAt: obligation.updatedAt ?? obligation.createdAt,
+        ...(updatedAt ? { updatedAt } : {}),
     };
 }
 function returnObligationItem(obligation) {

package/package.json

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