@ouro.bot/cli 0.1.0-alpha.694 → 0.1.0-alpha.696

package/changelog.json

@@ -1,6 +1,19 @@
 {
   "_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.696",
+      "changes": [
+        "Prevent completed return-work packets from re-entering active Arc state."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.695",
+      "changes": [
+        "Prevent daemon-health context-loss Sentinel checks from treating Sentinel-authored flight-recorder cleanup as bundle dirt.",
+        "Clear daemon shutdown fallback timers after graceful SIGINT/SIGTERM and circuit-breaker stops."
+      ]
+    },
     {
       "version": "0.1.0-alpha.694",
       "changes": [

package/dist/arc/flight-recorder.js

@@ -51,6 +51,7 @@ const crypto_1 = require("crypto");
 const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 const obligations_1 = require("./obligations");
+const packets_1 = require("./packets");
 function isHabitRunTrigger(value) {
     return value === "cron"
         || value === "launchd"
@@ -235,10 +236,16 @@ function remainingArcWorkDescriptions(resume) {
         ...resume.openEvolutionCaseIds.map((id) => `evolution case ${id}`),
     ];
 }
-function nextSafeActionAfterObligationReconcile(resume, activeObligations, staleActiveObligationIds, unverifiableActiveObligationIds) {
+function nextSafeActionAfterObligationReconcile(resume, activeObligations, staleActiveObligationIds, unverifiableActiveObligationIds, staleActiveReturnObligationIds, unverifiableActiveReturnObligationIds, staleActivePacketIds, unverifiableActivePacketIds) {
     if (unverifiableActiveObligationIds.length > 0) {
         return (0, session_events_1.capStructuredRecordString)(`inspect unverifiable active obligations before acting: ${unverifiableActiveObligationIds.join(", ")}`);
     }
+    if (unverifiableActiveReturnObligationIds.length > 0) {
+        return (0, session_events_1.capStructuredRecordString)(`inspect unverifiable active return obligations before acting: ${unverifiableActiveReturnObligationIds.join(", ")}`);
+    }
+    if (unverifiableActivePacketIds.length > 0) {
+        return (0, session_events_1.capStructuredRecordString)(`inspect unverifiable active packets before acting: ${unverifiableActivePacketIds.join(", ")}`);
+    }
     const firstActive = activeObligations[0];
     if (firstActive) {
         const detail = firstActive.nextAction?.trim() || firstActive.content;
@@ -248,11 +255,56 @@ function nextSafeActionAfterObligationReconcile(resume, activeObligations, stale
     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(", ")}`);
+    if (staleActiveObligationIds.length > 0) {
+        return (0, session_events_1.capStructuredRecordString)(`wait for new input; reconciled completed or missing obligations: ${staleActiveObligationIds.join(", ")}`);
+    }
+    if (staleActiveReturnObligationIds.length > 0) {
+        return (0, session_events_1.capStructuredRecordString)(`wait for new input; reconciled completed or missing return obligations: ${staleActiveReturnObligationIds.join(", ")}`);
+    }
+    return (0, session_events_1.capStructuredRecordString)(`wait for new input; reconciled completed or missing packets: ${staleActivePacketIds.join(", ")}`);
+}
+function reconcileActiveReturnObligationIds(resume, returnObligations, activeReturnObligations) {
+    const canonicalIdSet = new Set(returnObligations.map((obligation) => obligation.id));
+    const activeIdSet = new Set(activeReturnObligations.map((obligation) => obligation.id));
+    const resumeIdSet = new Set(resume.activeReturnObligationIds);
+    const staleActiveReturnObligationIds = resume.activeReturnObligationIds.filter((id) => canonicalIdSet.has(id) && !activeIdSet.has(id));
+    const unverifiableActiveReturnObligationIds = resume.activeReturnObligationIds.filter((id) => !canonicalIdSet.has(id));
+    const missingActiveReturnObligationIds = activeReturnObligations
+        .map((obligation) => obligation.id)
+        .filter((id) => !resumeIdSet.has(id));
+    const activeReturnObligationIds = uniqueStrings([
+        ...resume.activeReturnObligationIds.filter((id) => !staleActiveReturnObligationIds.includes(id)),
+        ...missingActiveReturnObligationIds,
+    ]);
+    return {
+        activeReturnObligationIds,
+        staleActiveReturnObligationIds,
+        missingActiveReturnObligationIds,
+        unverifiableActiveReturnObligationIds,
+    };
+}
+function reconcileActivePacketIds(resume, packets, activePackets) {
+    const canonicalIdSet = new Set(packets.map((packet) => packet.id));
+    const activeIdSet = new Set(activePackets.map((packet) => packet.id));
+    const resumeIdSet = new Set(resume.activePacketIds);
+    const staleActivePacketIds = resume.activePacketIds.filter((id) => canonicalIdSet.has(id) && !activeIdSet.has(id));
+    const unverifiableActivePacketIds = resume.activePacketIds.filter((id) => !canonicalIdSet.has(id));
+    const missingActivePacketIds = activePackets
+        .map((packet) => packet.id)
+        .filter((id) => !resumeIdSet.has(id));
+    const activePacketIds = uniqueStrings([
+        ...resume.activePacketIds.filter((id) => !staleActivePacketIds.includes(id)),
+        ...missingActivePacketIds,
+    ]);
+    return { activePacketIds, staleActivePacketIds, missingActivePacketIds, unverifiableActivePacketIds };
 }
 function reconcileActiveObligations(agentRoot, resume) {
     const obligations = (0, obligations_1.readVerifiedObligations)(agentRoot);
     const activeObligations = (0, obligations_1.readVerifiedPendingObligations)(agentRoot);
+    const returnObligations = (0, obligations_1.listReturnObligationsForRoot)(agentRoot);
+    const activeReturnObligations = (0, obligations_1.listActiveReturnObligationsForRoot)(agentRoot);
+    const packets = (0, packets_1.listPonderPackets)(agentRoot);
+    const activePackets = (0, packets_1.listActivePonderPackets)(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);
@@ -261,33 +313,66 @@ function reconcileActiveObligations(agentRoot, resume) {
     const missingActiveObligationIds = activeObligations
         .map((obligation) => obligation.id)
         .filter((id) => !resumeIdSet.has(id));
+    const { activeReturnObligationIds, staleActiveReturnObligationIds, missingActiveReturnObligationIds, unverifiableActiveReturnObligationIds, } = reconcileActiveReturnObligationIds(resume, returnObligations, activeReturnObligations);
+    const { activePacketIds, staleActivePacketIds, missingActivePacketIds, unverifiableActivePacketIds, } = reconcileActivePacketIds(resume, packets, activePackets);
     if (staleActiveObligationIds.length === 0
         && missingActiveObligationIds.length === 0
-        && unverifiableActiveObligationIds.length === 0) {
-        return { resume, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds };
+        && unverifiableActiveObligationIds.length === 0
+        && staleActiveReturnObligationIds.length === 0
+        && missingActiveReturnObligationIds.length === 0
+        && unverifiableActiveReturnObligationIds.length === 0
+        && staleActivePacketIds.length === 0
+        && missingActivePacketIds.length === 0
+        && unverifiableActivePacketIds.length === 0) {
+        return {
+            resume,
+            staleActiveObligationIds,
+            missingActiveObligationIds,
+            unverifiableActiveObligationIds,
+            staleActiveReturnObligationIds,
+            missingActiveReturnObligationIds,
+            unverifiableActiveReturnObligationIds,
+            staleActivePacketIds,
+            missingActivePacketIds,
+            unverifiableActivePacketIds,
+        };
     }
     const activeObligationIds = uniqueStrings([
         ...resume.activeObligationIds.filter((id) => !staleActiveObligationIds.includes(id)),
         ...missingActiveObligationIds,
     ]);
     const hasActiveArcContinuation = activeObligationIds.length > 0
-        || resume.activeReturnObligationIds.length > 0
-        || resume.activePacketIds.length > 0
+        || activeReturnObligationIds.length > 0
+        || activePacketIds.length > 0
         || resume.openEvolutionCaseIds.length > 0;
-    const isTerminalWait = staleActiveObligationIds.length > 0 && !hasActiveArcContinuation;
+    const isTerminalWait = (staleActiveObligationIds.length > 0
+        || staleActiveReturnObligationIds.length > 0
+        || staleActivePacketIds.length > 0) && !hasActiveArcContinuation;
     const mustSynthesizeAction = staleActiveObligationIds.length > 0
         || unverifiableActiveObligationIds.length > 0
+        || staleActiveReturnObligationIds.length > 0
+        || unverifiableActiveReturnObligationIds.length > 0
+        || staleActivePacketIds.length > 0
+        || unverifiableActivePacketIds.length > 0
         || !nonEmpty(resume.nextSafeAction.value);
     const nextSafeActionValue = mustSynthesizeAction
-        ? nextSafeActionAfterObligationReconcile(resume, activeObligations, staleActiveObligationIds, unverifiableActiveObligationIds)
+        ? nextSafeActionAfterObligationReconcile({ ...resume, activeObligationIds, activeReturnObligationIds, activePacketIds }, activeObligations, staleActiveObligationIds, unverifiableActiveObligationIds, staleActiveReturnObligationIds, unverifiableActiveReturnObligationIds, staleActivePacketIds, unverifiableActivePacketIds)
         : resume.nextSafeAction.value;
-    const recorderHealth = unverifiableActiveObligationIds.length > 0
+    const unverifiableIssues = [
+        ...(unverifiableActiveObligationIds.length > 0
+            ? [`active obligation ids could not be verified in arc/obligations: ${unverifiableActiveObligationIds.join(", ")}`]
+            : []),
+        ...(unverifiableActiveReturnObligationIds.length > 0
+            ? [`active return obligation ids could not be verified in arc/obligations/inner: ${unverifiableActiveReturnObligationIds.join(", ")}`]
+            : []),
+        ...(unverifiableActivePacketIds.length > 0
+            ? [`active packet ids could not be verified in arc/packets: ${unverifiableActivePacketIds.join(", ")}`]
+            : []),
+    ];
+    const recorderHealth = unverifiableIssues.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(", ")}`,
-            ]),
+            issues: uniqueStrings([...resume.recorderHealth.issues, ...unverifiableIssues]),
         }
         : resume.recorderHealth;
     const canContinue = nonEmpty(resume.currentAsk.value)
@@ -302,6 +387,8 @@ function reconcileActiveObligations(agentRoot, resume) {
             canContinue,
             recorderHealth,
             activeObligationIds,
+            activeReturnObligationIds,
+            activePacketIds,
             nextSafeAction: {
                 ...resume.nextSafeAction,
                 value: nextSafeActionValue,
@@ -309,22 +396,41 @@ function reconcileActiveObligations(agentRoot, resume) {
                     ? [FLIGHT_RECORDER_RECONCILE_SOURCE_ID]
                     : resume.nextSafeAction.sourceEventIds,
                 stopBefore: unverifiableActiveObligationIds.length > 0
-                    ? uniqueStrings([...resume.nextSafeAction.stopBefore, "acting on unverifiable obligation state"])
+                    || unverifiableActiveReturnObligationIds.length > 0
+                    || unverifiableActivePacketIds.length > 0
+                    ? uniqueStrings([
+                        ...resume.nextSafeAction.stopBefore,
+                        ...(unverifiableActiveObligationIds.length > 0 ? ["acting on unverifiable obligation state"] : []),
+                        ...(unverifiableActiveReturnObligationIds.length > 0 ? ["acting on unverifiable return obligation state"] : []),
+                        ...(unverifiableActivePacketIds.length > 0 ? ["acting on unverifiable packet state"] : []),
+                    ])
                     : resume.nextSafeAction.stopBefore,
             },
         }),
         staleActiveObligationIds,
         missingActiveObligationIds,
         unverifiableActiveObligationIds,
+        staleActiveReturnObligationIds,
+        missingActiveReturnObligationIds,
+        unverifiableActiveReturnObligationIds,
+        staleActivePacketIds,
+        missingActivePacketIds,
+        unverifiableActivePacketIds,
     };
 }
 function normalizeResumeForAgentRoot(agentRoot, resume) {
     return reconcileActiveObligations(agentRoot, normalizeResumeInvariants(resume));
 }
-function emitFlightRecorderReconciled(agentRoot, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds) {
+function emitFlightRecorderReconciled(agentRoot, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds, staleActiveReturnObligationIds, missingActiveReturnObligationIds, unverifiableActiveReturnObligationIds, staleActivePacketIds, missingActivePacketIds, unverifiableActivePacketIds) {
     if (staleActiveObligationIds.length === 0
         && missingActiveObligationIds.length === 0
-        && unverifiableActiveObligationIds.length === 0)
+        && unverifiableActiveObligationIds.length === 0
+        && staleActiveReturnObligationIds.length === 0
+        && missingActiveReturnObligationIds.length === 0
+        && unverifiableActiveReturnObligationIds.length === 0
+        && staleActivePacketIds.length === 0
+        && missingActivePacketIds.length === 0
+        && unverifiableActivePacketIds.length === 0)
         return;
     (0, runtime_1.emitNervesEvent)({
         component: "mind",
@@ -335,6 +441,12 @@ function emitFlightRecorderReconciled(agentRoot, staleActiveObligationIds, missi
             staleActiveObligationIds,
             missingActiveObligationIds,
             unverifiableActiveObligationIds,
+            staleActiveReturnObligationIds,
+            missingActiveReturnObligationIds,
+            unverifiableActiveReturnObligationIds,
+            staleActivePacketIds,
+            missingActivePacketIds,
+            unverifiableActivePacketIds,
         },
     });
 }
@@ -390,11 +502,17 @@ function readFlightRecorderResume(agentRoot) {
         if (!isFlightRecorderResume(parsed)) {
             throw new Error("latest.json has invalid flight-recorder resume shape");
         }
-        const { resume, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds, } = normalizeResumeForAgentRoot(agentRoot, parsed);
+        const { resume, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds, staleActiveReturnObligationIds, missingActiveReturnObligationIds, unverifiableActiveReturnObligationIds, staleActivePacketIds, missingActivePacketIds, unverifiableActivePacketIds, } = normalizeResumeForAgentRoot(agentRoot, parsed);
         if (staleActiveObligationIds.length > 0
             || missingActiveObligationIds.length > 0
-            || unverifiableActiveObligationIds.length > 0) {
-            emitFlightRecorderReconciled(agentRoot, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds);
+            || unverifiableActiveObligationIds.length > 0
+            || staleActiveReturnObligationIds.length > 0
+            || missingActiveReturnObligationIds.length > 0
+            || unverifiableActiveReturnObligationIds.length > 0
+            || staleActivePacketIds.length > 0
+            || missingActivePacketIds.length > 0
+            || unverifiableActivePacketIds.length > 0) {
+            emitFlightRecorderReconciled(agentRoot, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds, staleActiveReturnObligationIds, missingActiveReturnObligationIds, unverifiableActiveReturnObligationIds, staleActivePacketIds, missingActivePacketIds, unverifiableActivePacketIds);
         }
         (0, runtime_1.emitNervesEvent)({
             component: "mind",
@@ -418,9 +536,9 @@ function readFlightRecorderResume(agentRoot) {
     }
 }
 function writeFlightRecorderResume(agentRoot, resume) {
-    const { resume: safeResume, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds, } = normalizeResumeForAgentRoot(agentRoot, resume);
+    const { resume: safeResume, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds, staleActiveReturnObligationIds, missingActiveReturnObligationIds, unverifiableActiveReturnObligationIds, staleActivePacketIds, missingActivePacketIds, unverifiableActivePacketIds, } = normalizeResumeForAgentRoot(agentRoot, resume);
     atomicWriteJson(flightRecorderLatestPath(agentRoot), safeResume);
-    emitFlightRecorderReconciled(agentRoot, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds);
+    emitFlightRecorderReconciled(agentRoot, staleActiveObligationIds, missingActiveObligationIds, unverifiableActiveObligationIds, staleActiveReturnObligationIds, missingActiveReturnObligationIds, unverifiableActiveReturnObligationIds, staleActivePacketIds, missingActivePacketIds, unverifiableActivePacketIds);
     (0, runtime_1.emitNervesEvent)({
         component: "mind",
         event: "mind.flight_recorder_resume_written",

package/dist/arc/obligations.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.readObligation = readObligation;
 exports.isOpenObligationStatus = isOpenObligationStatus;
 exports.isOpenObligation = isOpenObligation;
 exports.createObligation = createObligation;
@@ -49,7 +50,11 @@ exports.getReturnObligationsDir = getReturnObligationsDir;
 exports.getReturnObligationsDirForRoot = getReturnObligationsDirForRoot;
 exports.createReturnObligation = createReturnObligation;
 exports.readReturnObligation = readReturnObligation;
+exports.readReturnObligationForRoot = readReturnObligationForRoot;
 exports.advanceReturnObligation = advanceReturnObligation;
+exports.isActiveReturnObligationStatus = isActiveReturnObligationStatus;
+exports.listReturnObligationsForRoot = listReturnObligationsForRoot;
+exports.isActiveReturnObligationRecord = isActiveReturnObligationRecord;
 exports.listActiveReturnObligations = listActiveReturnObligations;
 exports.listActiveReturnObligationsForRoot = listActiveReturnObligationsForRoot;
 const path = __importStar(require("path"));
@@ -60,6 +65,9 @@ const json_store_1 = require("./json-store");
 function obligationsDir(agentRoot) {
     return path.join(agentRoot, "arc", "obligations");
 }
+function readObligation(agentRoot, obligationId) {
+    return (0, json_store_1.readJsonFile)(obligationsDir(agentRoot), obligationId);
+}
 function isOpenObligationStatus(status) {
     return status !== "fulfilled";
 }
@@ -256,6 +264,9 @@ function createReturnObligation(agentName, obligation) {
 function readReturnObligation(agentName, obligationId) {
     return (0, json_store_1.readJsonFile)(getReturnObligationsDir(agentName), obligationId);
 }
+function readReturnObligationForRoot(agentRoot, obligationId) {
+    return (0, json_store_1.readJsonFile)(getReturnObligationsDirForRoot(agentRoot), obligationId);
+}
 function advanceReturnObligation(agentName, obligationId, update) {
     const existing = readReturnObligation(agentName, obligationId);
     if (!existing)
@@ -295,6 +306,9 @@ const RETURN_OBLIGATION_INJECTION_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1000;
 // surface-tool boundary) is treated as terminal — i.e., we do not re-inject
 // it. This is a read-time defense; the underlying file is left as-is.
 const ACTIVE_RETURN_OBLIGATION_STATUSES = new Set(["queued", "running"]);
+function isActiveReturnObligationStatus(status) {
+    return ACTIVE_RETURN_OBLIGATION_STATUSES.has(status);
+}
 function isSelfInnerReturnObligation(obligation) {
     return obligation.origin?.friendId === "self" && obligation.origin.channel === "inner";
 }
@@ -311,16 +325,24 @@ function isReturnObligationRecord(value) {
         && typeof candidate.origin.channel === "string"
         && typeof candidate.origin.key === "string";
 }
+function listReturnObligationsForRoot(agentRoot) {
+    return (0, json_store_1.readJsonDir)(getReturnObligationsDirForRoot(agentRoot))
+        .filter(isReturnObligationRecord);
+}
+function isActiveReturnObligationRecord(value, options = {}) {
+    if (!isReturnObligationRecord(value))
+        return false;
+    const nowMs = (options.now ?? Date.now)();
+    return isActiveReturnObligationStatus(value.status)
+        && !isSelfInnerReturnObligation(value)
+        && nowMs - value.createdAt <= RETURN_OBLIGATION_INJECTION_MAX_AGE_MS;
+}
 function listActiveReturnObligations(agentName, options = {}) {
     return listActiveReturnObligationsForRoot((0, identity_1.getAgentRoot)(agentName), options);
 }
 function listActiveReturnObligationsForRoot(agentRoot, options = {}) {
-    const all = (0, json_store_1.readJsonDir)(getReturnObligationsDirForRoot(agentRoot));
     const nowMs = (options.now ?? Date.now)();
-    return all
-        .filter(isReturnObligationRecord)
-        .filter((parsed) => ACTIVE_RETURN_OBLIGATION_STATUSES.has(parsed.status))
-        .filter((parsed) => !isSelfInnerReturnObligation(parsed))
-        .filter((parsed) => nowMs - parsed.createdAt <= RETURN_OBLIGATION_INJECTION_MAX_AGE_MS)
+    return listReturnObligationsForRoot(agentRoot)
+        .filter((parsed) => isActiveReturnObligationRecord(parsed, { now: () => nowMs }))
         .sort((a, b) => a.createdAt - b.createdAt);
 }

package/dist/arc/packets.js

@@ -33,9 +33,16 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTIVE_PONDER_PACKET_STATUSES = void 0;
 exports.getPonderPacketArtifactsDir = getPonderPacketArtifactsDir;
+exports.isActivePonderPacketStatus = isActivePonderPacketStatus;
+exports.isActivePonderPacket = isActivePonderPacket;
 exports.listPonderPackets = listPonderPackets;
+exports.listActivePonderPackets = listActivePonderPackets;
 exports.readPonderPacket = readPonderPacket;
+exports.findPonderPacketByRelatedReturnObligationId = findPonderPacketByRelatedReturnObligationId;
+exports.listPonderPacketsByRelatedReturnObligationId = listPonderPacketsByRelatedReturnObligationId;
+exports.listPonderPacketsByRelatedObligationId = listPonderPacketsByRelatedObligationId;
 exports.createPonderPacket = createPonderPacket;
 exports.revisePonderPacket = revisePonderPacket;
 exports.advancePonderPacket = advancePonderPacket;
@@ -46,6 +53,7 @@ const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 const task_lifecycle_1 = require("./task-lifecycle");
 const json_store_1 = require("./json-store");
+const obligations_1 = require("./obligations");
 const evolution_1 = require("./evolution");
 function packetsDir(agentRoot) {
     return path.join(agentRoot, "arc", "packets");
@@ -82,6 +90,34 @@ function isPonderPacket(value) {
         && typeof packet.createdAt === "number"
         && typeof packet.updatedAt === "number";
 }
+exports.ACTIVE_PONDER_PACKET_STATUSES = new Set([
+    "drafting",
+    "processing",
+    "validating",
+    "collaborating",
+    "paused",
+    "blocked",
+]);
+function isActivePonderPacketStatus(status) {
+    return exports.ACTIVE_PONDER_PACKET_STATUSES.has(status);
+}
+function hasInactiveLinkedReturnObligation(agentRoot, packet, options = {}) {
+    if (!packet.relatedReturnObligationId)
+        return false;
+    const obligation = (0, obligations_1.readReturnObligationForRoot)(agentRoot, packet.relatedReturnObligationId);
+    return !(0, obligations_1.isActiveReturnObligationRecord)(obligation, options);
+}
+function hasFulfilledLinkedObligation(agentRoot, packet) {
+    if (!packet.relatedObligationId)
+        return false;
+    const obligation = (0, obligations_1.readObligation)(agentRoot, packet.relatedObligationId);
+    return obligation?.status === "fulfilled";
+}
+function isActivePonderPacket(agentRoot, packet, options = {}) {
+    return isActivePonderPacketStatus(packet.status)
+        && !hasInactiveLinkedReturnObligation(agentRoot, packet, options)
+        && !hasFulfilledLinkedObligation(agentRoot, packet);
+}
 function payloadString(payload, key) {
     const value = payload[key];
     return typeof value === "string" && value.trim().length > 0 ? value : null;
@@ -156,10 +192,22 @@ function listPonderPackets(agentRoot) {
         .filter(isPonderPacket)
         .sort((left, right) => left.createdAt - right.createdAt);
 }
+function listActivePonderPackets(agentRoot, options = {}) {
+    return listPonderPackets(agentRoot).filter((packet) => isActivePonderPacket(agentRoot, packet, options));
+}
 function readPonderPacket(agentRoot, packetId) {
     const packet = (0, json_store_1.readJsonFile)(packetsDir(agentRoot), packetId);
     return isPonderPacket(packet) ? packet : null;
 }
+function findPonderPacketByRelatedReturnObligationId(agentRoot, relatedReturnObligationId) {
+    return listPonderPacketsByRelatedReturnObligationId(agentRoot, relatedReturnObligationId)[0] ?? null;
+}
+function listPonderPacketsByRelatedReturnObligationId(agentRoot, relatedReturnObligationId) {
+    return listPonderPackets(agentRoot).filter((packet) => packet.relatedReturnObligationId === relatedReturnObligationId);
+}
+function listPonderPacketsByRelatedObligationId(agentRoot, relatedObligationId) {
+    return listPonderPackets(agentRoot).filter((packet) => packet.relatedObligationId === relatedObligationId);
+}
 function createPonderPacket(agentRoot, input) {
     const now = Date.now();
     const packet = bindHarnessFrictionEvolutionCase(agentRoot, {

package/dist/heart/context-loss-sentinel.js

@@ -48,6 +48,7 @@ const runtime_1 = require("../nerves/runtime");
 const context_loss_gauntlet_1 = require("./context-loss-gauntlet");
 const provider_visibility_1 = require("./provider-visibility");
 const CONTEXT_LOSS_SENTINEL_RECEIPT_FILE_LIMIT = 512;
+const CONTEXT_LOSS_SENTINEL_GIT_STATUS_TIMEOUT_MS = 5_000;
 const REQUIRED_LANES = ["outward", "inner"];
 function logicalLocator(...parts) {
     return path.posix.join(...parts);
@@ -524,7 +525,7 @@ function defaultGitStatus(agentRoot) {
             cwd: agentRoot,
             encoding: "utf-8",
             stdio: ["ignore", "pipe", "pipe"],
-            timeout: 1_000,
+            timeout: CONTEXT_LOSS_SENTINEL_GIT_STATUS_TIMEOUT_MS,
         });
         return { ok: true, porcelain };
     }
@@ -574,7 +575,167 @@ function isSentinelGitStatusEntry(entry) {
         return normalizedPath === sentinelRoot || normalizedPath.startsWith(`${sentinelRoot}/`);
     });
 }
-function bundleSignal(status, options = {}) {
+function isContextLossSentinelBlockerText(value) {
+    return value.startsWith("context-loss Sentinel blocked:");
+}
+function hasContextLossSentinelCheckpointEvents(agentRoot, resume) {
+    const events = readFlightRecorderEventsByIds(agentRoot, resume.lastSafeCheckpoint.sourceEventIds);
+    const foundEventIds = new Set(events.map((event) => event.id));
+    if (resume.lastSafeCheckpoint.sourceEventIds.some((eventId) => !foundEventIds.has(eventId)))
+        return false;
+    return resume.blockedBecause.length > 0
+        ? events.every(isContextLossSentinelBlockerEvent)
+        : events.every(isContextLossSentinelRecoveryEvent);
+}
+function isContextLossSentinelCheckpoint(agentRoot, resume) {
+    return resume.lastSafeCheckpoint.sourceEventIds.length > 0
+        && resume.lastSafeCheckpoint.sourceEventIds.every((eventId) => eventId.startsWith("fr-sentinel-"))
+        && resume.blockedBecause.every(isContextLossSentinelBlockerText)
+        && hasContextLossSentinelCheckpointEvents(agentRoot, resume);
+}
+function neutralizeSentinelCheckpoint(resume) {
+    return {
+        ...resume,
+        canContinue: true,
+        blockedBecause: [],
+        lastSafeCheckpoint: {
+            turnId: null,
+            sessionRef: null,
+            recordedAt: null,
+            sourceEventIds: [],
+        },
+        recorderHealth: { status: "ok", issues: [] },
+    };
+}
+function isContextLossSentinelProducedRef(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    if (record.kind !== "arc" || typeof record.locator !== "string")
+        return false;
+    const sentinelRoot = relativeSentinelRoot();
+    return record.locator === sentinelRoot || record.locator.startsWith(`${sentinelRoot}/`);
+}
+function isContextLossSentinelFlightRecorderEvent(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    const meta = record.meta;
+    const producedRefs = record.producedRefs;
+    return typeof record.id === "string"
+        && record.id.startsWith("fr-sentinel-")
+        && (record.kind === "blocker_detected" || record.kind === "agent_note")
+        && meta?.source === "context-loss-sentinel"
+        && Array.isArray(producedRefs)
+        && producedRefs.length > 0
+        && producedRefs.every(isContextLossSentinelProducedRef);
+}
+function isContextLossSentinelBlockerEvent(event) {
+    return isContextLossSentinelFlightRecorderEvent(event)
+        && event.kind === "blocker_detected"
+        && Array.isArray(event.blockedBecause)
+        && event.blockedBecause.length > 0
+        && event.blockedBecause.every(isContextLossSentinelBlockerText);
+}
+function isContextLossSentinelRecoveryEvent(event) {
+    return isContextLossSentinelFlightRecorderEvent(event)
+        && event.kind === "agent_note"
+        && Array.isArray(event.blockedBecause)
+        && event.blockedBecause.length === 0
+        && event.meta?.resolution === "blocked-signals-recovered";
+}
+function gitShowHeadFile(agentRoot, entryPath) {
+    try {
+        return (0, child_process_1.execFileSync)("git", ["show", `HEAD:${entryPath}`], {
+            cwd: agentRoot,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: CONTEXT_LOSS_SENTINEL_GIT_STATUS_TIMEOUT_MS,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function nonEmptyLines(text) {
+    return text.split(/\r?\n/).filter((line) => line.trim().length > 0);
+}
+function isFlightRecorderEventsPath(entryPath) {
+    return /^arc\/flight-recorder\/events\/[^/]+\.jsonl$/.test(entryPath);
+}
+function isFlightRecorderLatestPath(entryPath) {
+    return entryPath === "arc/flight-recorder/latest.json";
+}
+function isDeletedGitStatusEntry(entry) {
+    return entry.slice(0, 2).includes("D");
+}
+function isUntrackedGitStatusEntry(entry) {
+    return entry.startsWith("??");
+}
+function isWorktreeOnlyModifiedGitStatusEntry(entry) {
+    return entry.slice(0, 2) === " M";
+}
+function parseJsonLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function isContextLossSentinelEventFileDirty(agentRoot, entry, entryPath) {
+    if (isDeletedGitStatusEntry(entry))
+        return false;
+    const filePath = path.join(agentRoot, entryPath);
+    if (isUntrackedGitStatusEntry(entry)) {
+        const candidateLines = fs.existsSync(filePath) ? nonEmptyLines(fs.readFileSync(filePath, "utf-8")) : [];
+        return candidateLines.length > 0
+            && candidateLines.every((line) => isContextLossSentinelFlightRecorderEvent(parseJsonLine(line)));
+    }
+    if (!isWorktreeOnlyModifiedGitStatusEntry(entry) || !fs.existsSync(filePath))
+        return false;
+    const headText = gitShowHeadFile(agentRoot, entryPath);
+    if (headText === null)
+        return false;
+    const headLines = nonEmptyLines(headText);
+    const currentLines = nonEmptyLines(fs.readFileSync(filePath, "utf-8"));
+    if (currentLines.length <= headLines.length)
+        return false;
+    if (!headLines.every((line, index) => currentLines[index] === line))
+        return false;
+    const appendedLines = currentLines.slice(headLines.length);
+    return appendedLines.every((line) => isContextLossSentinelFlightRecorderEvent(parseJsonLine(line)));
+}
+function isContextLossSentinelLatestDirty(agentRoot, entry, entryPath) {
+    if (isDeletedGitStatusEntry(entry) || isUntrackedGitStatusEntry(entry))
+        return false;
+    if (!isWorktreeOnlyModifiedGitStatusEntry(entry))
+        return false;
+    const current = readJson(path.join(agentRoot, entryPath));
+    if (!current.ok || !(0, flight_recorder_1.isFlightRecorderResume)(current.value) || !isContextLossSentinelCheckpoint(agentRoot, current.value)) {
+        return false;
+    }
+    const headText = gitShowHeadFile(agentRoot, entryPath);
+    if (headText === null)
+        return false;
+    const head = parseJsonLine(headText);
+    if (!(0, flight_recorder_1.isFlightRecorderResume)(head))
+        return false;
+    return JSON.stringify(neutralizeSentinelCheckpoint(current.value))
+        === JSON.stringify(neutralizeSentinelCheckpoint(head));
+}
+function isContextLossSentinelFlightRecorderGitStatusEntry(agentRoot, entry) {
+    return gitStatusPaths(entry).every((entryPath) => (isFlightRecorderEventsPath(entryPath)
+        ? isContextLossSentinelEventFileDirty(agentRoot, entry, entryPath)
+        : isFlightRecorderLatestPath(entryPath)
+            ? isContextLossSentinelLatestDirty(agentRoot, entry, entryPath)
+            : false));
+}
+function isContextLossSentinelOwnedGitStatusEntry(entry, options) {
+    return isSentinelGitStatusEntry(entry)
+        || isContextLossSentinelFlightRecorderGitStatusEntry(options.agentRoot, entry);
+}
+function bundleSignal(status, options) {
     const gitStatusCommand = "git status --porcelain=v1 -uall";
     if (!status.ok) {
         return {
@@ -589,7 +750,7 @@ function bundleSignal(status, options = {}) {
         };
     }
     const dirtyEntries = gitStatusEntries(status.porcelain)
-        .filter((entry) => !(options.ignoreSentinelDirtyEntries && isSentinelGitStatusEntry(entry)));
+        .filter((entry) => !(options.ignoreSentinelDirtyEntries && isContextLossSentinelOwnedGitStatusEntry(entry, options)));
     if (dirtyEntries.length > 0) {
         return {
             id: "bundle:git",
@@ -723,6 +884,7 @@ function makeReceipt(agentName, agentRoot, options, generatedAt) {
         ...healthSignals(options.daemonHealthResults ?? []),
         bundleSignal((options.gitStatus ?? (() => defaultGitStatus(agentRoot)))(), {
             ignoreSentinelDirtyEntries: options.trigger === "daemon_health",
+            agentRoot,
         }),
     ];
     const verdict = sentinelVerdict(signals);

package/dist/heart/daemon/daemon-entry.js

@@ -687,9 +687,15 @@ void preloadProviderCredentialPools().then(() => daemon.start()).then(async () =
         message: "daemon entrypoint failed",
         meta: { error: error.message },
     });
-    setTimeout(() => process.exit(1), 5_000).unref();
-    await daemon.stop();
-    process.exit(1);
+    const forcedExit = setTimeout(() => process.exit(1), 5_000);
+    forcedExit.unref();
+    try {
+        await daemon.stop();
+    }
+    finally {
+        clearTimeout(forcedExit);
+        process.exit(1);
+    }
 });
 process.on("SIGINT", () => {
     // ALWAYS write a tombstone, even on signal-driven shutdown. The previous
@@ -702,15 +708,29 @@ process.on("SIGINT", () => {
     _tombstoneWritten = true;
     (0, daemon_tombstone_1.writeDaemonTombstone)("sigint", new Error("daemon received SIGINT"));
     stopEntryRuntime();
-    setTimeout(() => process.exit(1), 5_000).unref();
-    void daemon.stop().then(() => process.exit(0));
+    const forcedExit = setTimeout(() => process.exit(1), 5_000);
+    forcedExit.unref();
+    void daemon.stop().then(() => {
+        clearTimeout(forcedExit);
+        process.exit(0);
+    }, () => {
+        clearTimeout(forcedExit);
+        process.exit(1);
+    });
 });
 process.on("SIGTERM", () => {
     _tombstoneWritten = true;
     (0, daemon_tombstone_1.writeDaemonTombstone)("sigterm", new Error("daemon received SIGTERM"));
     stopEntryRuntime();
-    setTimeout(() => process.exit(1), 5_000).unref();
-    void daemon.stop().then(() => process.exit(0));
+    const forcedExit = setTimeout(() => process.exit(1), 5_000);
+    forcedExit.unref();
+    void daemon.stop().then(() => {
+        clearTimeout(forcedExit);
+        process.exit(0);
+    }, () => {
+        clearTimeout(forcedExit);
+        process.exit(1);
+    });
 });
 /* v8 ignore stop */
 // Suppress EPIPE on stdout/stderr — normal when detached daemon's parent exits
@@ -750,8 +770,12 @@ process.on("uncaughtException", (error) => {
             message: `daemon exiting: ${_uncaughtCount} uncaught exceptions in ${CIRCUIT_BREAKER_WINDOW_MS / 1000}s`,
             meta: { uncaughtCount: _uncaughtCount },
         });
-        setTimeout(() => process.exit(1), 5_000).unref();
-        void daemon.stop().then(() => process.exit(1));
+        const forcedExit = setTimeout(() => process.exit(1), 5_000);
+        forcedExit.unref();
+        void daemon.stop().finally(() => {
+            clearTimeout(forcedExit);
+            process.exit(1);
+        });
     }
 });
 process.on("unhandledRejection", (reason) => {

package/dist/heart/work-card.js

@@ -44,14 +44,6 @@ const evolution_1 = require("../arc/evolution");
 const obligations_1 = require("../arc/obligations");
 const packets_1 = require("../arc/packets");
 const flight_recorder_1 = require("../arc/flight-recorder");
-const ACTIVE_PACKET_STATUSES = new Set([
-    "drafting",
-    "processing",
-    "validating",
-    "collaborating",
-    "paused",
-    "blocked",
-]);
 function isoFromMs(ms) {
     return new Date(ms).toISOString();
 }
@@ -244,9 +236,7 @@ function buildWorkCard(agentName, agentRoot, options = {}) {
     const sourceIssues = scanArcSourceIssues(agentRoot);
     const owed = (0, obligations_1.readPendingObligations)(agentRoot).map(obligationItem);
     const returnObligations = (0, obligations_1.listActiveReturnObligationsForRoot)(agentRoot, { now: options.nowMs }).map(returnObligationItem);
-    const activePackets = (0, packets_1.listPonderPackets)(agentRoot)
-        .filter((packet) => ACTIVE_PACKET_STATUSES.has(packet.status))
-        .map(packetItem);
+    const activePackets = (0, packets_1.listActivePonderPackets)(agentRoot, { now: options.nowMs }).map(packetItem);
     const evolutionCases = (0, evolution_1.listOpenEvolutionCases)(agentRoot).map(evolutionItem);
     const activeWork = [...activePackets, ...evolutionCases];
     const waiting = waitingOnHuman([...owed, ...returnObligations, ...activeWork]);

package/dist/repertoire/tools-obligations.js

@@ -39,6 +39,7 @@ const identity_1 = require("../heart/identity");
 const runtime_1 = require("../nerves/runtime");
 const json_store_1 = require("../arc/json-store");
 const obligations_1 = require("../arc/obligations");
+const packets_1 = require("../arc/packets");
 /**
  * `let_go` lets the agent release a held work item from its attention loop.
  *
@@ -61,6 +62,40 @@ function outerObligationsDir(agentRoot) {
 function readOuterObligation(agentRoot, id) {
     return (0, json_store_1.readJsonFile)(outerObligationsDir(agentRoot), id) ?? null;
 }
+function completeRelatedPacket(agentRoot, packet, relation) {
+    try {
+        (0, packets_1.completePonderPacket)(agentRoot, packet.id);
+        (0, runtime_1.emitNervesEvent)({
+            component: "repertoire",
+            event: "repertoire.packet_completed_for_released_obligation",
+            message: "linked packet completed for released return obligation",
+            meta: { ...relation, packetId: packet.id },
+        });
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "repertoire",
+            event: "repertoire.packet_completion_for_released_obligation_failed",
+            message: "failed to complete linked packet for released return obligation",
+            meta: {
+                ...relation,
+                packetId: packet.id,
+                error: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}
+function completePacketsForReturnObligation(agentRoot, returnObligationId) {
+    for (const packet of (0, packets_1.listPonderPacketsByRelatedReturnObligationId)(agentRoot, returnObligationId)) {
+        completeRelatedPacket(agentRoot, packet, { returnObligationId });
+    }
+}
+function completePacketsForObligation(agentRoot, obligationId) {
+    for (const packet of (0, packets_1.listPonderPacketsByRelatedObligationId)(agentRoot, obligationId)) {
+        completeRelatedPacket(agentRoot, packet, { obligationId });
+    }
+}
 function letGo(args, agentRoot, agentName) {
     if (typeof args.id !== "string" || args.id.trim().length === 0) {
         return JSON.stringify({ error: "id is required" });
@@ -73,6 +108,7 @@ function letGo(args, agentRoot, agentName) {
     const ret = (0, obligations_1.readReturnObligation)(agentName, id);
     if (ret) {
         if (ret.status === "returned" || ret.status === "deferred") {
+            completePacketsForReturnObligation(agentRoot, id);
             return JSON.stringify({ kind: "return_obligation", id, already: ret.status });
         }
         (0, obligations_1.advanceReturnObligation)(agentName, id, {
@@ -80,6 +116,7 @@ function letGo(args, agentRoot, agentName) {
             returnedAt: Date.now(),
             returnTarget: "surface",
         });
+        completePacketsForReturnObligation(agentRoot, id);
         (0, runtime_1.emitNervesEvent)({
             component: "repertoire",
             event: "repertoire.obligation_let_go",
@@ -92,9 +129,11 @@ function letGo(args, agentRoot, agentName) {
     const outer = readOuterObligation(agentRoot, id);
     if (outer) {
         if (outer.status === "fulfilled") {
+            completePacketsForObligation(agentRoot, id);
             return JSON.stringify({ kind: "obligation", id, already: "fulfilled" });
         }
         (0, obligations_1.fulfillObligation)(agentRoot, id);
+        completePacketsForObligation(agentRoot, id);
         if (reason !== null) {
             // Persist the dismissal reason as the obligation's latestNote so future-me
             // can read why this was released (the nerves event also captures it).

package/dist/senses/pipeline.js

@@ -71,14 +71,6 @@ const orientation_frame_1 = require("../heart/orientation-frame");
 const flight_recorder_1 = require("../arc/flight-recorder");
 const context_loss_sentinel_1 = require("../heart/context-loss-sentinel");
 const VOICE_PENDING_MAX_AGE_MS = 15 * 60 * 1_000;
-const ACTIVE_FLIGHT_RECORDER_PACKET_STATUSES = new Set([
-    "drafting",
-    "processing",
-    "validating",
-    "collaborating",
-    "paused",
-    "blocked",
-]);
 function pendingExpirationReason(channel, message, now) {
     /* v8 ignore start -- pending expiry edge permutations are covered by the stale voice queue tests; this helper keeps defensive non-voice fallbacks @preserve */
     if (Number.isFinite(message.expiresAt) && Number(message.expiresAt) <= now)
@@ -224,9 +216,7 @@ function readPostTurnFlightRecorderArcSnapshot(agentRoot) {
     return {
         activeObligationIds: (0, obligations_1.readPendingObligations)(agentRoot).map((obligation) => obligation.id),
         activeReturnObligationIds: (0, obligations_1.listActiveReturnObligationsForRoot)(agentRoot).map((obligation) => obligation.id),
-        activePacketIds: (0, packets_1.listPonderPackets)(agentRoot)
-            .filter((packet) => ACTIVE_FLIGHT_RECORDER_PACKET_STATUSES.has(packet.status))
-            .map((packet) => packet.id),
+        activePacketIds: (0, packets_1.listActivePonderPackets)(agentRoot).map((packet) => packet.id),
         openEvolutionCaseIds: (0, evolution_1.listOpenEvolutionCases)(agentRoot).map((evolutionCase) => evolutionCase.id),
         recentClaimIds: latest.recentClaimIds,
         unverifiedClaimIds: latest.unverifiedClaimIds,

package/package.json

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