@ouro.bot/cli 0.1.0-alpha.183 → 0.1.0-alpha.185

package/changelog.json

@@ -1,6 +1,21 @@
 {
   "_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.185",
+      "changes": [
+        "fix(hatch): pass model name to adoption specialist from discovered credentials",
+        "feat(continuity): wake packets, episodes, cares, intentions, peer presence, and temporal self",
+        "fix(continuity): deduplicate obligations in prompt, keep session summary, pass preloaded data",
+        "feat(continuity): 9 new modules — episodes, cares, agent-relationships, intentions, presence, tempo, temporal-view, wake-packet, obligation enrichment",
+        "feat(continuity): 8 new tools — query_episodes, capture_episode, query_presence, query_cares, care_manage, query_relationships, intention_capture, intention_manage",
+        "feat(continuity): 3-layer architecture — durable state, derived views, surfaces",
+        "feat(pipeline): continuity threading — tempo derivation, wake packet assembly, presence update, episode emission on every turn",
+        "feat(prompt): wake packet prompt section with token budget and truncation priority",
+        "feat(coding): coding context receives compact wake packet, coding completion emits episodes",
+        "feat(outlook): expose continuity data (presence, cares, episodes) to outlook surfaces"
+      ]
+    },
     {
       "version": "0.1.0-alpha.183",
       "changes": [

package/dist/heart/active-work.js

@@ -469,7 +469,7 @@ function buildActiveWorkFrame(input) {
     });
     return frame;
 }
-function formatActiveWorkFrame(frame) {
+function formatActiveWorkFrame(frame, options) {
     const lines = ["## what i'm holding"];
     lines.push("this is my top-level live world-state right now. inner work, coding lanes, other sessions, and return obligations all belong inside this picture.");
     lines.push("if older checkpoints elsewhere in the transcript disagree with this picture, this picture wins.");
@@ -577,16 +577,25 @@ function formatActiveWorkFrame(frame) {
         lines.push(targetCandidatesBlock);
     }
     if ((frame.pendingObligations ?? []).length > 0) {
-        lines.push("");
-        lines.push("## return obligations");
-        for (const obligation of frame.pendingObligations) {
-            if (!(0, obligations_1.isOpenObligationStatus)(obligation.status))
-                continue;
-            let obligationLine = `- [${obligation.status}] ${obligation.origin.friendId}/${obligation.origin.channel}/${obligation.origin.key}: ${obligation.content}${formatObligationSurface(obligation)}`;
-            if (obligation.latestNote?.trim()) {
-                obligationLine += `\n  latest: ${obligation.latestNote.trim()}`;
+        const openCount = frame.pendingObligations.filter((ob) => (0, obligations_1.isOpenObligationStatus)(ob.status)).length;
+        if (options?.hasWakePacket && openCount > 0) {
+            // Wake packet carries enriched obligations (with resumeHint, stalenessClass, waitingOn).
+            // Avoid duplicating the full list — just anchor the count here.
+            lines.push("");
+            lines.push(`return obligations: ${openCount} active (canonical details in **Owed** section of wake packet)`);
+        }
+        else if (openCount > 0) {
+            lines.push("");
+            lines.push("## return obligations");
+            for (const obligation of frame.pendingObligations) {
+                if (!(0, obligations_1.isOpenObligationStatus)(obligation.status))
+                    continue;
+                let obligationLine = `- [${obligation.status}] ${obligation.origin.friendId}/${obligation.origin.channel}/${obligation.origin.key}: ${obligation.content}${formatObligationSurface(obligation)}`;
+                if (obligation.latestNote?.trim()) {
+                    obligationLine += `\n  latest: ${obligation.latestNote.trim()}`;
+                }
+                lines.push(obligationLine);
             }
-            lines.push(obligationLine);
         }
     }
     if (frame.innerReturnObligations && frame.innerReturnObligations.length > 0) {

package/dist/heart/agent-relationships.js

@@ -0,0 +1,161 @@
+"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.recordInteraction = recordInteraction;
+exports.readRelationships = readRelationships;
+exports.readRelationship = readRelationship;
+exports.recordOutcome = recordOutcome;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function relationshipsDir(agentRoot) {
+    return path.join(agentRoot, "state", "relationships");
+}
+function relationshipFilePath(agentRoot, agentName) {
+    return path.join(relationshipsDir(agentRoot), `${agentName.toLowerCase()}.json`);
+}
+function readRelationshipFile(agentRoot, agentName) {
+    const filePath = relationshipFilePath(agentRoot, agentName);
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function writeRelationshipFile(agentRoot, rel) {
+    const dir = relationshipsDir(agentRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `${rel.agentName}.json`), JSON.stringify(rel, null, 2), "utf-8");
+}
+function recordInteraction(agentRoot, agentName, context) {
+    const normalizedName = agentName.toLowerCase();
+    const now = new Date().toISOString();
+    const existing = readRelationshipFile(agentRoot, normalizedName);
+    if (existing) {
+        existing.familiarity += 1;
+        existing.lastInteraction = now;
+        if (context.displayName) {
+            existing.displayName = context.displayName;
+        }
+        if (context.missionId && !existing.sharedMissions.includes(context.missionId)) {
+            existing.sharedMissions.push(context.missionId);
+        }
+        if (context.note) {
+            existing.notes.push(context.note);
+        }
+        writeRelationshipFile(agentRoot, existing);
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.relationship_updated",
+            message: `relationship updated: ${normalizedName}`,
+            meta: { agentName: normalizedName, familiarity: existing.familiarity },
+        });
+        return existing;
+    }
+    const rel = {
+        agentName: normalizedName,
+        displayName: context.displayName ?? normalizedName,
+        familiarity: 1,
+        trust: "neutral",
+        sharedMissions: context.missionId ? [context.missionId] : [],
+        lastInteraction: now,
+        outcomes: [],
+        notes: context.note ? [context.note] : [],
+    };
+    writeRelationshipFile(agentRoot, rel);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.relationship_created",
+        message: `relationship created: ${normalizedName}`,
+        meta: { agentName: normalizedName },
+    });
+    return rel;
+}
+function readRelationships(agentRoot) {
+    const dir = relationshipsDir(agentRoot);
+    if (!fs.existsSync(dir)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.relationships_read",
+            message: "read relationships: directory missing, returning empty",
+            meta: { count: 0 },
+        });
+        return [];
+    }
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    const relationships = [];
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(path.join(dir, file), "utf-8");
+            const rel = JSON.parse(content);
+            relationships.push(rel);
+        }
+        catch {
+            // Skip malformed JSON files
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.relationships_read",
+        message: `read ${relationships.length} relationships`,
+        meta: { count: relationships.length },
+    });
+    return relationships;
+}
+function readRelationship(agentRoot, agentName) {
+    const rel = readRelationshipFile(agentRoot, agentName);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.relationship_read",
+        message: rel ? `read relationship: ${agentName.toLowerCase()}` : `relationship not found: ${agentName.toLowerCase()}`,
+        meta: { agentName: agentName.toLowerCase(), found: !!rel },
+    });
+    return rel;
+}
+function recordOutcome(agentRoot, agentName, outcome) {
+    const normalizedName = agentName.toLowerCase();
+    const existing = readRelationshipFile(agentRoot, normalizedName);
+    if (!existing) {
+        throw new Error(`Agent relationship not found: ${normalizedName}`);
+    }
+    existing.outcomes.push(outcome);
+    writeRelationshipFile(agentRoot, existing);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outcome_recorded",
+        message: `outcome recorded for ${normalizedName}: ${outcome.result}`,
+        meta: { agentName: normalizedName, missionId: outcome.missionId, result: outcome.result },
+    });
+    return existing;
+}

package/dist/heart/cares.js

@@ -0,0 +1,174 @@
+"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.createCare = createCare;
+exports.readCares = readCares;
+exports.readActiveCares = readActiveCares;
+exports.updateCare = updateCare;
+exports.resolveCare = resolveCare;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function caresDir(agentRoot) {
+    return path.join(agentRoot, "state", "cares");
+}
+function careFilePath(agentRoot, id) {
+    return path.join(caresDir(agentRoot), `${id}.json`);
+}
+function generateId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).slice(2, 10);
+    return `care-${timestamp}-${random}`;
+}
+function createCare(agentRoot, input) {
+    const now = new Date().toISOString();
+    const id = generateId();
+    const care = {
+        id,
+        label: input.label,
+        why: input.why,
+        kind: input.kind,
+        status: input.status,
+        salience: input.salience,
+        steward: input.steward,
+        relatedFriendIds: input.relatedFriendIds,
+        relatedAgentIds: input.relatedAgentIds,
+        relatedObligationIds: input.relatedObligationIds,
+        relatedEpisodeIds: input.relatedEpisodeIds,
+        currentRisk: input.currentRisk,
+        nextCheckAt: input.nextCheckAt,
+        createdAt: now,
+        updatedAt: now,
+    };
+    const dir = caresDir(agentRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(careFilePath(agentRoot, id), JSON.stringify(care, null, 2), "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.care_created",
+        message: `care created: ${input.label}`,
+        meta: { careId: id, status: input.status, salience: input.salience },
+    });
+    return care;
+}
+function readCares(agentRoot) {
+    const dir = caresDir(agentRoot);
+    if (!fs.existsSync(dir)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.cares_read",
+            message: "read cares: directory missing, returning empty",
+            meta: { count: 0 },
+        });
+        return [];
+    }
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    const cares = [];
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(path.join(dir, file), "utf-8");
+            const care = JSON.parse(content);
+            cares.push(care);
+        }
+        catch {
+            // Skip malformed JSON files gracefully
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.cares_read",
+        message: `read ${cares.length} cares`,
+        meta: { count: cares.length },
+    });
+    return cares;
+}
+function readActiveCares(agentRoot) {
+    const all = readCares(agentRoot);
+    const active = all.filter((c) => c.status === "active" || c.status === "watching");
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.active_cares_read",
+        message: `read ${active.length} active cares`,
+        meta: { count: active.length, total: all.length },
+    });
+    return active;
+}
+function readCareFile(agentRoot, id) {
+    const filePath = careFilePath(agentRoot, id);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Care not found: ${id}`);
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function writeCareFile(agentRoot, care) {
+    fs.writeFileSync(careFilePath(agentRoot, care.id), JSON.stringify(care, null, 2), "utf-8");
+}
+function updateCare(agentRoot, id, updates) {
+    const care = readCareFile(agentRoot, id);
+    const now = new Date().toISOString();
+    const updated = {
+        ...care,
+        ...updates,
+        id: care.id, // protect ID from overwrite
+        createdAt: care.createdAt, // protect createdAt
+        updatedAt: now,
+    };
+    writeCareFile(agentRoot, updated);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.care_updated",
+        message: `care updated: ${updated.label}`,
+        meta: { careId: id, updates: Object.keys(updates) },
+    });
+    return updated;
+}
+function resolveCare(agentRoot, id) {
+    const care = readCareFile(agentRoot, id);
+    const now = new Date().toISOString();
+    const resolved = {
+        ...care,
+        status: "resolved",
+        resolvedAt: now,
+        updatedAt: now,
+    };
+    writeCareFile(agentRoot, resolved);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.care_resolved",
+        message: `care resolved: ${resolved.label}`,
+        meta: { careId: id },
+    });
+    return resolved;
+}

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

@@ -1491,12 +1491,13 @@ async function defaultRunAdoptionSpecialist() {
         // Load identity-specific spinner phrases (falls back to DEFAULT_AGENT_PHRASES)
         const { loadIdentityPhrases } = await Promise.resolve().then(() => __importStar(require("./specialist-orchestrator")));
         const phrases = loadIdentityPhrases(bundleSourceDir, identity.fileName);
+        const resolvedModel = providerConfig.model || providerConfig.deployment || "";
         setAgentConfigOverride({
             version: 2,
             enabled: true,
             provider: providerRaw,
-            humanFacing: { provider: providerRaw, model: "" },
-            agentFacing: { provider: providerRaw, model: "" },
+            humanFacing: { provider: providerRaw, model: resolvedModel },
+            agentFacing: { provider: providerRaw, model: resolvedModel },
             phrases,
         });
         patchRuntimeConfig({

package/dist/heart/daemon/outlook-read.js

@@ -47,6 +47,7 @@ exports.readLogView = readLogView;
 exports.readHabitView = readHabitView;
 exports.readNeedsMeView = readNeedsMeView;
 exports.readDeskPrefs = readDeskPrefs;
+exports.readOutlookContinuity = readOutlookContinuity;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
@@ -59,6 +60,9 @@ const agent_discovery_1 = require("./agent-discovery");
 const runtime_metadata_1 = require("./runtime-metadata");
 const thoughts_1 = require("./thoughts");
 const outlook_types_1 = require("./outlook-types");
+const presence_1 = require("../presence");
+const cares_1 = require("../cares");
+const episodes_1 = require("../../mind/episodes");
 const LIVE_TASK_STATUSES = ["processing", "validating", "collaborating", "blocked"];
 const ACTIVE_CODING_STATUSES = new Set(["spawning", "running", "waiting_input", "stalled"]);
 const BLOCKED_CODING_STATUSES = new Set(["waiting_input", "stalled"]);
@@ -1289,3 +1293,39 @@ function parseCadenceMs(cadence) {
     /* v8 ignore next */
     return null;
 }
+// ---------------------------------------------------------------------------
+// Continuity — presence, cares, episodes for outlook surfaces
+// ---------------------------------------------------------------------------
+function readOutlookContinuity(agentRoot, agentName) {
+    const self = (0, presence_1.readPresence)(agentRoot, agentName);
+    const peers = (0, presence_1.readPeerPresence)(agentRoot);
+    const cares = (0, cares_1.readActiveCares)(agentRoot);
+    const episodes = (0, episodes_1.readRecentEpisodes)(agentRoot, { limit: 10 });
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.outlook_continuity_read",
+        message: `outlook continuity: ${cares.length} cares, ${episodes.length} episodes`,
+        meta: { careCount: cares.length, episodeCount: episodes.length, hasSelf: self != null, peerCount: peers.length },
+    });
+    return {
+        presence: { self, peers },
+        cares: {
+            activeCount: cares.length,
+            items: cares.map((c) => ({
+                id: c.id,
+                label: c.label,
+                status: c.status,
+                salience: c.salience,
+            })),
+        },
+        episodes: {
+            recentCount: episodes.length,
+            items: episodes.map((ep) => ({
+                id: ep.id,
+                kind: ep.kind,
+                summary: ep.summary,
+                timestamp: ep.timestamp,
+            })),
+        },
+    };
+}

package/dist/heart/intentions.js

@@ -0,0 +1,168 @@
+"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 fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+function intentionsDir(agentRoot) {
+    return path.join(agentRoot, "state", "intentions");
+}
+function intentionFilePath(agentRoot, id) {
+    return path.join(intentionsDir(agentRoot), `${id}.json`);
+}
+function generateId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).slice(2, 10);
+    return `int-${timestamp}-${random}`;
+}
+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 = generateId();
+    const intention = {
+        id,
+        content: 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 } : {}),
+    };
+    const dir = intentionsDir(agentRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(intentionFilePath(agentRoot, id), JSON.stringify(intention, null, 2), "utf-8");
+    (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);
+    if (!fs.existsSync(dir)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "heart",
+            event: "heart.intentions_read",
+            message: "read intentions: directory missing, returning empty",
+            meta: { count: 0 },
+        });
+        return [];
+    }
+    const limit = options?.limit ?? 20;
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    const intentions = [];
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(path.join(dir, file), "utf-8");
+            const intention = JSON.parse(content);
+            if (intention.status === "open") {
+                intentions.push(intention);
+            }
+        }
+        catch {
+            // Skip malformed JSON files
+        }
+    }
+    // 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) {
+    const filePath = intentionFilePath(agentRoot, id);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Intention not found: ${id}`);
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function writeIntentionFile(agentRoot, intention) {
+    fs.writeFileSync(intentionFilePath(agentRoot, intention.id), JSON.stringify(intention, null, 2), "utf-8");
+}
+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/heart/obligations.js

@@ -41,6 +41,7 @@ exports.readPendingObligations = readPendingObligations;
 exports.advanceObligation = advanceObligation;
 exports.fulfillObligation = fulfillObligation;
 exports.findPendingObligationForOrigin = findPendingObligationForOrigin;
+exports.enrichObligation = enrichObligation;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../nerves/runtime");
@@ -195,3 +196,25 @@ function findPendingObligationForOrigin(agentRoot, origin) {
         && ob.origin.channel === origin.channel
         && ob.origin.key === origin.key);
 }
+function enrichObligation(agentRoot, id, meaning) {
+    const filePath = obligationFilePath(agentRoot, id);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Obligation not found: ${id}`);
+    }
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const obligation = JSON.parse(raw);
+    obligation.meaning = meaning;
+    obligation.updatedAt = new Date().toISOString();
+    fs.writeFileSync(filePath, JSON.stringify(obligation, null, 2), "utf-8");
+    (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;
+}