@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/arc/intentions.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureIntention = captureIntention;
+exports.readOpenIntentions = readOpenIntentions;
+exports.resolveIntention = resolveIntention;
+exports.dismissIntention = dismissIntention;
+const path = __importStar(require("path"));
+const session_events_1 = require("../heart/session-events");
+const runtime_1 = require("../nerves/runtime");
+const json_store_1 = require("./json-store");
+function intentionsDir(agentRoot) {
+    return path.join(agentRoot, "arc", "intentions");
+}
+const SALIENCE_ORDER = {
+    high: 3,
+    medium: 2,
+    low: 1,
+};
+function salienceRank(salience) {
+    if (!salience)
+        return 0;
+    return SALIENCE_ORDER[salience] ?? 0;
+}
+function captureIntention(agentRoot, input) {
+    const now = new Date().toISOString();
+    const id = (0, json_store_1.generateTimestampId)("int");
+    const intention = {
+        id,
+        content: (0, session_events_1.capStructuredRecordString)(input.content),
+        status: "open",
+        createdAt: now,
+        updatedAt: now,
+        ...(input.salience ? { salience: input.salience } : {}),
+        source: input.source,
+        ...(input.relatedFriendId ? { relatedFriendId: input.relatedFriendId } : {}),
+        ...(input.relatedObligationId ? { relatedObligationId: input.relatedObligationId } : {}),
+        ...(input.relatedCareId ? { relatedCareId: input.relatedCareId } : {}),
+        ...(input.nudgeAfter ? { nudgeAfter: input.nudgeAfter } : {}),
+    };
+    (0, json_store_1.writeJsonFile)(intentionsDir(agentRoot), id, intention);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.intention_captured",
+        message: `intention captured: ${input.content.slice(0, 60)}`,
+        meta: { intentionId: id, source: input.source, salience: input.salience },
+    });
+    return intention;
+}
+function readOpenIntentions(agentRoot, options) {
+    const dir = intentionsDir(agentRoot);
+    const all = (0, json_store_1.readJsonDir)(dir);
+    const limit = options?.limit ?? 20;
+    const intentions = all.filter((i) => i.status === "open");
+    // Sort by salience descending, then createdAt descending
+    intentions.sort((a, b) => {
+        const salienceDiff = salienceRank(b.salience) - salienceRank(a.salience);
+        if (salienceDiff !== 0)
+            return salienceDiff;
+        return b.createdAt.localeCompare(a.createdAt);
+    });
+    const result = intentions.slice(0, limit);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.intentions_read",
+        message: `read ${result.length} open intentions`,
+        meta: { count: result.length, total: intentions.length, limit },
+    });
+    return result;
+}
+function readIntentionFile(agentRoot, id) {
+    return (0, json_store_1.readJsonFileOrThrow)(intentionsDir(agentRoot), id, "Intention");
+}
+function writeIntentionFile(agentRoot, intention) {
+    (0, json_store_1.writeJsonFile)(intentionsDir(agentRoot), intention.id, intention);
+}
+function resolveIntention(agentRoot, id) {
+    const intention = readIntentionFile(agentRoot, id);
+    intention.status = "done";
+    intention.updatedAt = new Date().toISOString();
+    writeIntentionFile(agentRoot, intention);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.intention_resolved",
+        message: `intention resolved: ${intention.content.slice(0, 60)}`,
+        meta: { intentionId: id },
+    });
+    return intention;
+}
+function dismissIntention(agentRoot, id) {
+    const intention = readIntentionFile(agentRoot, id);
+    intention.status = "dismissed";
+    intention.updatedAt = new Date().toISOString();
+    writeIntentionFile(agentRoot, intention);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.intention_dismissed",
+        message: `intention dismissed: ${intention.content.slice(0, 60)}`,
+        meta: { intentionId: id },
+    });
+    return intention;
+}

package/dist/arc/json-store.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Shared JSON file store helpers for arc/ modules.
+ *
+ * obligations.ts, cares.ts, and intentions.ts all use the same pattern:
+ * individual JSON files in a directory, with read-all / read-one / write-one
+ * operations. This module extracts those patterns.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTimestampId = generateTimestampId;
+exports.readJsonDir = readJsonDir;
+exports.readJsonFile = readJsonFile;
+exports.readJsonFileOrThrow = readJsonFileOrThrow;
+exports.writeJsonFile = writeJsonFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Generate a timestamped random ID.
+ * @param prefix Optional prefix (e.g. "care", "int"). Omit for plain timestamp IDs.
+ */
+function generateTimestampId(prefix) {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).slice(2, 10);
+    return prefix ? `${prefix}-${timestamp}-${random}` : `${timestamp}-${random}`;
+}
+/**
+ * Read all JSON files from a directory, parse each, and return an array.
+ * Silently skips malformed files. Returns empty array if directory is missing.
+ */
+function readJsonDir(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        /* v8 ignore next -- defensive: readdirSync race after existsSync @preserve */
+        return [];
+    }
+    const jsonFiles = entries.filter((entry) => entry.endsWith(".json")).sort();
+    const records = [];
+    for (const file of jsonFiles) {
+        try {
+            const raw = fs.readFileSync(path.join(dir, file), "utf-8");
+            records.push(JSON.parse(raw));
+        }
+        catch {
+            // Skip malformed JSON files
+        }
+    }
+    return records;
+}
+/**
+ * Read a single JSON file by ID from a directory.
+ * Returns null if the file doesn't exist or is unparseable.
+ */
+function readJsonFile(dir, id) {
+    try {
+        const raw = fs.readFileSync(path.join(dir, `${id}.json`), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read a single JSON file by ID, throwing if not found.
+ */
+function readJsonFileOrThrow(dir, id, label) {
+    const filePath = path.join(dir, `${id}.json`);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`${label} not found: ${id}`);
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+/**
+ * Write a record to a JSON file, creating the directory if needed.
+ */
+function writeJsonFile(dir, id, record) {
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, `${id}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(record, null, 2), "utf-8");
+}

package/dist/arc/obligations.js

@@ -0,0 +1,386 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readObligation = readObligation;
+exports.isOpenObligationStatus = isOpenObligationStatus;
+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.markObligationReturnReady = markObligationReturnReady;
+exports.findPendingObligationForOrigin = findPendingObligationForOrigin;
+exports.findPendingObligationForRequest = findPendingObligationForRequest;
+exports.enrichObligation = enrichObligation;
+exports.generateObligationId = generateObligationId;
+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"));
+const identity_1 = require("../heart/identity");
+const session_events_1 = require("../heart/session-events");
+const runtime_1 = require("../nerves/runtime");
+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";
+}
+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) {
+    if (input.sourceProvenance?.kind === "machine_evidence" && !input.owedTo) {
+        throw new Error("Machine evidence cannot create an obligation without a person owed a return");
+    }
+    const now = new Date().toISOString();
+    const id = (0, json_store_1.generateTimestampId)();
+    const obligation = {
+        id,
+        origin: input.origin,
+        sourceProvenance: input.sourceProvenance ?? {
+            kind: "human_request",
+            source: input.origin.channel,
+            ref: input.origin.key,
+        },
+        owedTo: input.owedTo ?? input.origin,
+        ...(input.requestId ? { requestId: (0, session_events_1.capStructuredRecordString)(input.requestId) } : {}),
+        ...(input.bridgeId ? { bridgeId: input.bridgeId } : {}),
+        content: (0, session_events_1.capStructuredRecordString)(input.content),
+        status: "pending",
+        createdAt: now,
+        updatedAt: now,
+    };
+    (0, json_store_1.writeJsonFile)(obligationsDir(agentRoot), id, obligation);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_created",
+        message: "obligation created",
+        meta: {
+            obligationId: id,
+            friendId: input.origin.friendId,
+            channel: input.origin.channel,
+            key: input.origin.key,
+        },
+    });
+    return obligation;
+}
+function readObligations(agentRoot) {
+    const all = (0, json_store_1.readJsonDir)(obligationsDir(agentRoot));
+    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);
+    if (!obligation)
+        return;
+    const previousStatus = obligation.status;
+    if (update.status) {
+        obligation.status = update.status;
+        if (update.status === "fulfilled") {
+            obligation.fulfilledAt = new Date().toISOString();
+        }
+    }
+    if (update.currentSurface) {
+        obligation.currentSurface = update.currentSurface;
+    }
+    if (typeof update.currentArtifact === "string") {
+        obligation.currentArtifact = (0, session_events_1.capStructuredRecordString)(update.currentArtifact);
+    }
+    if (typeof update.nextAction === "string") {
+        obligation.nextAction = (0, session_events_1.capStructuredRecordString)(update.nextAction);
+    }
+    if (typeof update.latestNote === "string") {
+        obligation.latestNote = (0, session_events_1.capStructuredRecordString)(update.latestNote);
+    }
+    obligation.updatedAt = new Date().toISOString();
+    (0, json_store_1.writeJsonFile)(dir, obligationId, obligation);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_advanced",
+        message: "obligation advanced",
+        meta: {
+            obligationId,
+            previousStatus,
+            status: obligation.status,
+            friendId: obligation.origin.friendId,
+            channel: obligation.origin.channel,
+            key: obligation.origin.key,
+            surfaceKind: obligation.currentSurface?.kind ?? null,
+            surfaceLabel: obligation.currentSurface?.label ?? null,
+        },
+    });
+}
+function fulfillObligation(agentRoot, obligationId) {
+    advanceObligation(agentRoot, obligationId, { status: "fulfilled" });
+    const obligation = (0, json_store_1.readJsonFile)(obligationsDir(agentRoot), obligationId);
+    if (!obligation)
+        return;
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_fulfilled",
+        message: "obligation fulfilled",
+        meta: {
+            obligationId,
+            friendId: obligation.origin.friendId,
+            channel: obligation.origin.channel,
+            key: obligation.origin.key,
+        },
+    });
+}
+function markObligationReturnReady(agentRoot, obligationId, evidenceRef) {
+    const dir = obligationsDir(agentRoot);
+    const obligation = (0, json_store_1.readJsonFile)(dir, obligationId);
+    if (!obligation || !isOpenObligation(obligation))
+        throw new Error(`Open obligation not found: ${obligationId}`);
+    const ref = (0, session_events_1.capStructuredRecordString)(evidenceRef).trim();
+    if (!ref)
+        throw new Error("Obligation return evidence is required");
+    if (obligation.returnReadyAt) {
+        if (obligation.returnEvidenceRef !== ref)
+            throw new Error(`Obligation return evidence is already bound: ${obligationId}`);
+        return obligation;
+    }
+    obligation.returnReadyAt = new Date().toISOString();
+    obligation.returnEvidenceRef = ref;
+    obligation.updatedAt = obligation.returnReadyAt;
+    (0, json_store_1.writeJsonFile)(dir, obligationId, obligation);
+    (0, runtime_1.emitNervesEvent)({ component: "engine", event: "engine.obligation_return_ready", message: "obligation is ready for an exact recorded return", meta: { obligationId, friendId: obligation.owedTo?.friendId ?? obligation.origin.friendId } });
+    return obligation;
+}
+function findPendingObligationForOrigin(agentRoot, origin) {
+    return readPendingObligations(agentRoot).find((ob) => ob.origin.friendId === origin.friendId
+        && ob.origin.channel === origin.channel
+        && ob.origin.key === origin.key);
+}
+function findPendingObligationForRequest(agentRoot, input) {
+    return readPendingObligations(agentRoot).find((obligation) => obligation.requestId === input.requestId
+        && obligation.owedTo?.friendId === input.owedTo.friendId
+        && obligation.owedTo.channel === input.owedTo.channel
+        && obligation.owedTo.key === input.owedTo.key);
+}
+function enrichObligation(agentRoot, id, meaning) {
+    const dir = obligationsDir(agentRoot);
+    const existing = (0, json_store_1.readJsonFile)(dir, id);
+    if (!existing) {
+        throw new Error(`Obligation not found: ${id}`);
+    }
+    const obligation = existing;
+    obligation.meaning = {
+        ...meaning,
+        ...(typeof meaning.careReason === "string" ? { careReason: (0, session_events_1.capStructuredRecordString)(meaning.careReason) } : {}),
+        ...(typeof meaning.resumeHint === "string" ? { resumeHint: (0, session_events_1.capStructuredRecordString)(meaning.resumeHint) } : {}),
+        ...(meaning.waitingOn
+            ? { waitingOn: { ...meaning.waitingOn, detail: (0, session_events_1.capStructuredRecordString)(meaning.waitingOn.detail) } }
+            : {}),
+    };
+    obligation.updatedAt = new Date().toISOString();
+    (0, json_store_1.writeJsonFile)(dir, id, obligation);
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.obligation_enriched",
+        message: "obligation enriched with meaning",
+        meta: {
+            obligationId: id,
+            salience: meaning.salience,
+            stalenessClass: meaning.stalenessClass,
+        },
+    });
+    return obligation;
+}
+function generateObligationId(timestamp) {
+    return `${timestamp}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function getReturnObligationsDir(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "arc", "obligations", "inner");
+}
+function getReturnObligationsDirForRoot(agentRoot) {
+    return path.join(agentRoot, "arc", "obligations", "inner");
+}
+function createReturnObligation(agentName, obligation) {
+    const dir = getReturnObligationsDir(agentName);
+    const cappedObligation = {
+        ...obligation,
+        delegatedContent: (0, session_events_1.capStructuredRecordString)(obligation.delegatedContent),
+    };
+    (0, json_store_1.writeJsonFile)(dir, obligation.id, cappedObligation);
+    const filePath = path.join(dir, `${obligation.id}.json`);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.obligation_created",
+        component: "mind",
+        message: "return obligation created",
+        meta: {
+            obligationId: obligation.id,
+            origin: `${obligation.origin.friendId}/${obligation.origin.channel}/${obligation.origin.key}`,
+            status: obligation.status,
+        },
+    });
+    return filePath;
+}
+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)
+        return null;
+    const updated = {
+        ...existing,
+        status: update.status,
+        ...(update.startedAt !== undefined ? { startedAt: update.startedAt } : {}),
+        ...(update.returnedAt !== undefined ? { returnedAt: update.returnedAt } : {}),
+        ...(update.returnTarget !== undefined ? { returnTarget: update.returnTarget } : {}),
+    };
+    (0, json_store_1.writeJsonFile)(getReturnObligationsDir(agentName), obligationId, updated);
+    (0, runtime_1.emitNervesEvent)({
+        event: "mind.obligation_advanced",
+        component: "mind",
+        message: `obligation advanced to ${update.status}`,
+        meta: {
+            obligationId,
+            status: update.status,
+            ...(update.returnTarget ? { returnTarget: update.returnTarget } : {}),
+        },
+    });
+    return updated;
+}
+// Private-runtime return obligations that have been sitting in queued/running state
+// longer than this are auto-pruned from the "held work items" injection.
+// Anything older is overwhelmingly noise: the agent has had many turns to
+// resolve them and has not, and reinjecting them every turn just burns
+// attention without producing progress. The file stays on disk and can
+// still be inspected or surfaced explicitly; it just no longer gets
+// re-piped into the active prompt.
+const RETURN_OBLIGATION_INJECTION_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1000;
+// Strict allow-list of statuses that should appear in the "held work items"
+// section. Anything else (including legacy/migrated `"fulfilled"` values left
+// over from before the ObligationStatus → ReturnObligationStatus split, plus
+// any future invalid value that slips past the `as any` casts at the
+// 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";
+}
+function isReturnObligationRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return typeof candidate.id === "string"
+        && typeof candidate.status === "string"
+        && typeof candidate.delegatedContent === "string"
+        && typeof candidate.createdAt === "number"
+        && !!candidate.origin
+        && typeof candidate.origin.friendId === "string"
+        && 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 nowMs = (options.now ?? Date.now)();
+    return listReturnObligationsForRoot(agentRoot)
+        .filter((parsed) => isActiveReturnObligationRecord(parsed, { now: () => nowMs }))
+        .sort((a, b) => a.createdAt - b.createdAt);
+}