@ouro.bot/cli 0.1.0-alpha.66 → 0.1.0-alpha.661

package/dist/arc/flight-recorder.js

@@ -0,0 +1,369 @@
+"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.flightRecorderLatestPath = flightRecorderLatestPath;
+exports.readFlightRecorderResume = readFlightRecorderResume;
+exports.writeFlightRecorderResume = writeFlightRecorderResume;
+exports.recordFlightRecorderEvent = recordFlightRecorderEvent;
+exports.writeHabitRunReceipt = writeHabitRunReceipt;
+exports.formatFlightRecorderResume = formatFlightRecorderResume;
+exports.createHabitRunId = createHabitRunId;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const session_events_1 = require("../heart/session-events");
+const runtime_1 = require("../nerves/runtime");
+function flightRecorderDir(agentRoot) {
+    return path.join(agentRoot, "arc", "flight-recorder");
+}
+function eventsDir(agentRoot) {
+    return path.join(flightRecorderDir(agentRoot), "events");
+}
+function receiptsDir(agentRoot) {
+    return path.join(flightRecorderDir(agentRoot), "habit-receipts");
+}
+function flightRecorderLatestPath(agentRoot) {
+    return path.join(flightRecorderDir(agentRoot), "latest.json");
+}
+function eventDay(recordedAt) {
+    return recordedAt.slice(0, 10) || "unknown";
+}
+function atomicWriteJson(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tmpPath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+    fs.renameSync(tmpPath, filePath);
+}
+function cappedArray(values) {
+    return values.map((value) => (0, session_events_1.capStructuredRecordString)(value));
+}
+function normalizeEvent(input) {
+    const recordedAt = input.recordedAt ?? new Date().toISOString();
+    return {
+        schemaVersion: 1,
+        id: input.id ?? `fr-${(0, crypto_1.randomUUID)()}`,
+        kind: input.kind,
+        recordedAt,
+        ...(input.turnId ? { turnId: input.turnId } : {}),
+        ...(input.sessionRef ? { sessionRef: input.sessionRef } : {}),
+        summary: (0, session_events_1.capStructuredRecordString)(input.summary),
+        ...(input.currentAsk !== undefined ? { currentAsk: input.currentAsk ? (0, session_events_1.capStructuredRecordString)(input.currentAsk) : null } : {}),
+        ...(input.nextSafeAction !== undefined ? { nextSafeAction: input.nextSafeAction ? (0, session_events_1.capStructuredRecordString)(input.nextSafeAction) : null } : {}),
+        ...(input.stopBefore ? { stopBefore: cappedArray(input.stopBefore) } : {}),
+        ...(input.blockedBecause ? { blockedBecause: cappedArray(input.blockedBecause) } : {}),
+        ...(input.activeObligationIds ? { activeObligationIds: cappedArray(input.activeObligationIds) } : {}),
+        ...(input.activeReturnObligationIds ? { activeReturnObligationIds: cappedArray(input.activeReturnObligationIds) } : {}),
+        ...(input.activePacketIds ? { activePacketIds: cappedArray(input.activePacketIds) } : {}),
+        ...(input.openEvolutionCaseIds ? { openEvolutionCaseIds: cappedArray(input.openEvolutionCaseIds) } : {}),
+        ...(input.recentClaimIds ? { recentClaimIds: cappedArray(input.recentClaimIds) } : {}),
+        ...(input.unverifiedClaimIds ? { unverifiedClaimIds: cappedArray(input.unverifiedClaimIds) } : {}),
+        ...(input.producedRefs ? { producedRefs: input.producedRefs.map((ref) => ({ ...ref, locator: (0, session_events_1.capStructuredRecordString)(ref.locator) })) } : {}),
+        ...(input.meta ? { meta: (0, session_events_1.capStructuredRecordStringLeaves)(input.meta) } : {}),
+    };
+}
+function degradedResume(issues) {
+    return {
+        schemaVersion: 1,
+        hasCompleteState: false,
+        canContinue: false,
+        missing: ["currentAsk", "nextSafeAction"],
+        gaps: [],
+        currentAsk: { value: null, confidence: "unknown", sourceEventIds: [] },
+        nextSafeAction: { value: null, stopBefore: [], sourceEventIds: [] },
+        blockedBecause: [],
+        activeObligationIds: [],
+        activeReturnObligationIds: [],
+        activePacketIds: [],
+        openEvolutionCaseIds: [],
+        recentClaimIds: [],
+        unverifiedClaimIds: [],
+        lastSafeCheckpoint: { turnId: null, sessionRef: null, recordedAt: null, sourceEventIds: [] },
+        recorderHealth: {
+            status: "degraded",
+            issues,
+        },
+    };
+}
+/* v8 ignore start -- defensive schema guard fan-out; tests cover valid load and malformed-shape degradation @preserve */
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isNullableString(value) {
+    return value === null || typeof value === "string";
+}
+function isResumeCandidate(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    const currentAsk = record.currentAsk;
+    const nextSafeAction = record.nextSafeAction;
+    const lastSafeCheckpoint = record.lastSafeCheckpoint;
+    const recorderHealth = record.recorderHealth;
+    return record.schemaVersion === 1
+        && typeof record.hasCompleteState === "boolean"
+        && typeof record.canContinue === "boolean"
+        && isStringArray(record.missing)
+        && isStringArray(record.gaps)
+        && !!currentAsk
+        && typeof currentAsk === "object"
+        && !Array.isArray(currentAsk)
+        && isNullableString(currentAsk.value)
+        && (currentAsk.confidence === "current" || currentAsk.confidence === "stale_risky" || currentAsk.confidence === "unknown")
+        && isStringArray(currentAsk.sourceEventIds)
+        && !!nextSafeAction
+        && typeof nextSafeAction === "object"
+        && !Array.isArray(nextSafeAction)
+        && isNullableString(nextSafeAction.value)
+        && isStringArray(nextSafeAction.stopBefore)
+        && isStringArray(nextSafeAction.sourceEventIds)
+        && isStringArray(record.blockedBecause)
+        && isStringArray(record.activeObligationIds)
+        && isStringArray(record.activeReturnObligationIds)
+        && isStringArray(record.activePacketIds)
+        && isStringArray(record.openEvolutionCaseIds)
+        && isStringArray(record.recentClaimIds)
+        && isStringArray(record.unverifiedClaimIds)
+        && !!lastSafeCheckpoint
+        && typeof lastSafeCheckpoint === "object"
+        && !Array.isArray(lastSafeCheckpoint)
+        && isNullableString(lastSafeCheckpoint.turnId)
+        && isNullableString(lastSafeCheckpoint.sessionRef)
+        && isNullableString(lastSafeCheckpoint.recordedAt)
+        && isStringArray(lastSafeCheckpoint.sourceEventIds)
+        && !!recorderHealth
+        && typeof recorderHealth === "object"
+        && !Array.isArray(recorderHealth)
+        && (recorderHealth.status === "ok" || recorderHealth.status === "degraded" || recorderHealth.status === "unavailable")
+        && isStringArray(recorderHealth.issues);
+}
+/* v8 ignore stop */
+/* v8 ignore start -- semantic invariant fan-out is defensive; regression tests cover unsafe continuation normalization @preserve */
+function nonEmpty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+function normalizeResumeInvariants(resume) {
+    const hasCurrentAsk = nonEmpty(resume.currentAsk.value);
+    const hasNextSafeAction = nonEmpty(resume.nextSafeAction.value);
+    const hasCompleteState = hasCurrentAsk && hasNextSafeAction;
+    const missing = [
+        ...(hasCurrentAsk ? [] : ["currentAsk"]),
+        ...(hasNextSafeAction ? [] : ["nextSafeAction"]),
+    ];
+    const missingChanged = resume.missing.join("\n") !== missing.join("\n");
+    const issues = [
+        ...(resume.canContinue && !resume.hasCompleteState ? ["canContinue true while hasCompleteState false"] : []),
+        ...(resume.canContinue && !hasCurrentAsk ? ["canContinue true without currentAsk"] : []),
+        ...(resume.canContinue && !hasNextSafeAction ? ["canContinue true without nextSafeAction"] : []),
+        ...(resume.canContinue && resume.blockedBecause.length > 0 ? ["canContinue true while blocked"] : []),
+        ...(resume.canContinue && resume.recorderHealth.status !== "ok" ? ["canContinue true while recorder health is not ok"] : []),
+    ];
+    if (issues.length === 0 && resume.hasCompleteState === hasCompleteState && !missingChanged)
+        return resume;
+    return {
+        ...resume,
+        hasCompleteState,
+        canContinue: issues.length === 0 ? resume.canContinue : false,
+        missing,
+        currentAsk: {
+            ...resume.currentAsk,
+            confidence: hasCurrentAsk ? resume.currentAsk.confidence : "unknown",
+        },
+        recorderHealth: issues.length > 0
+            ? {
+                status: resume.recorderHealth.status === "unavailable" ? "unavailable" : "degraded",
+                issues: uniqueStrings([...resume.recorderHealth.issues, ...issues]),
+            }
+            : resume.recorderHealth,
+    };
+}
+/* v8 ignore stop */
+function latestFromEvent(event, previous) {
+    const currentAskValue = event.currentAsk !== undefined ? event.currentAsk : previous.currentAsk.value;
+    const nextSafeActionValue = event.nextSafeAction !== undefined ? event.nextSafeAction : previous.nextSafeAction.value;
+    const currentAskSourceEventIds = event.currentAsk !== undefined ? [event.id] : previous.currentAsk.sourceEventIds;
+    const nextSafeActionSourceEventIds = event.nextSafeAction !== undefined ? [event.id] : previous.nextSafeAction.sourceEventIds;
+    const hasCurrentAsk = typeof currentAskValue === "string" && currentAskValue.trim().length > 0;
+    const hasNextSafeAction = typeof nextSafeActionValue === "string" && nextSafeActionValue.trim().length > 0;
+    return {
+        ...previous,
+        hasCompleteState: hasCurrentAsk && hasNextSafeAction,
+        canContinue: hasCurrentAsk && hasNextSafeAction && (event.blockedBecause?.length ?? previous.blockedBecause.length) === 0,
+        missing: [
+            ...(hasCurrentAsk ? [] : ["currentAsk"]),
+            ...(hasNextSafeAction ? [] : ["nextSafeAction"]),
+        ],
+        currentAsk: {
+            value: currentAskValue,
+            confidence: hasCurrentAsk ? "current" : "unknown",
+            sourceEventIds: currentAskSourceEventIds,
+        },
+        nextSafeAction: {
+            value: nextSafeActionValue,
+            stopBefore: event.stopBefore ?? previous.nextSafeAction.stopBefore,
+            sourceEventIds: nextSafeActionSourceEventIds,
+        },
+        blockedBecause: event.blockedBecause ?? previous.blockedBecause,
+        activeObligationIds: event.activeObligationIds ?? previous.activeObligationIds,
+        activeReturnObligationIds: event.activeReturnObligationIds ?? previous.activeReturnObligationIds,
+        activePacketIds: event.activePacketIds ?? previous.activePacketIds,
+        openEvolutionCaseIds: event.openEvolutionCaseIds ?? previous.openEvolutionCaseIds,
+        recentClaimIds: event.recentClaimIds ?? previous.recentClaimIds,
+        unverifiedClaimIds: event.unverifiedClaimIds ?? previous.unverifiedClaimIds,
+        lastSafeCheckpoint: {
+            turnId: event.turnId ?? previous.lastSafeCheckpoint.turnId,
+            sessionRef: event.sessionRef ?? previous.lastSafeCheckpoint.sessionRef,
+            recordedAt: event.recordedAt,
+            sourceEventIds: [event.id],
+        },
+        recorderHealth: { status: "ok", issues: [] },
+    };
+}
+function readFlightRecorderResume(agentRoot) {
+    const latestPath = flightRecorderLatestPath(agentRoot);
+    try {
+        const parsed = JSON.parse(fs.readFileSync(latestPath, "utf-8"));
+        if (!isResumeCandidate(parsed)) {
+            throw new Error("latest.json has invalid flight-recorder resume shape");
+        }
+        const resume = normalizeResumeInvariants(parsed);
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.flight_recorder_resume_read",
+            message: "flight recorder resume read",
+            meta: { agentRoot, canContinue: resume.canContinue, hasCompleteState: resume.hasCompleteState },
+        });
+        return resume;
+    }
+    catch (error) {
+        const issue = fs.existsSync(latestPath)
+            ? `latest.json unreadable: ${error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error)}`
+            : "latest.json missing";
+        (0, runtime_1.emitNervesEvent)({
+            component: "mind",
+            event: "mind.flight_recorder_resume_read",
+            message: "flight recorder resume missing or degraded",
+            meta: { agentRoot, issue },
+        });
+        return degradedResume([issue]);
+    }
+}
+function writeFlightRecorderResume(agentRoot, resume) {
+    const safeResume = normalizeResumeInvariants(resume);
+    atomicWriteJson(flightRecorderLatestPath(agentRoot), safeResume);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.flight_recorder_resume_written",
+        message: "flight recorder resume written",
+        meta: { agentRoot, canContinue: safeResume.canContinue, hasCompleteState: safeResume.hasCompleteState },
+    });
+}
+function recordFlightRecorderEvent(agentRoot, input) {
+    const event = normalizeEvent(input);
+    fs.mkdirSync(eventsDir(agentRoot), { recursive: true });
+    fs.appendFileSync(path.join(eventsDir(agentRoot), `${eventDay(event.recordedAt)}.jsonl`), `${JSON.stringify(event)}\n`, "utf-8");
+    const latest = latestFromEvent(event, readFlightRecorderResume(agentRoot));
+    writeFlightRecorderResume(agentRoot, latest);
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.flight_recorder_event_recorded",
+        message: "flight recorder event recorded",
+        meta: { agentRoot, eventId: event.id, kind: event.kind },
+    });
+    return event;
+}
+function writeHabitRunReceipt(agentRoot, receipt) {
+    fs.mkdirSync(receiptsDir(agentRoot), { recursive: true });
+    const safeReceipt = {
+        ...receipt,
+        habitName: (0, session_events_1.capStructuredRecordString)(receipt.habitName),
+        producedRefs: receipt.producedRefs.map((ref) => ({ ...ref, locator: (0, session_events_1.capStructuredRecordString)(ref.locator) })),
+        surfaceAttempts: receipt.surfaceAttempts.map((attempt) => ({
+            ...attempt,
+            recipient: (0, session_events_1.capStructuredRecordString)(attempt.recipient),
+            channel: (0, session_events_1.capStructuredRecordString)(attempt.channel),
+        })),
+        errors: receipt.errors.map((error) => (0, session_events_1.capStructuredRecordString)(error)),
+    };
+    atomicWriteJson(path.join(receiptsDir(agentRoot), `${safeReceipt.runId}.json`), safeReceipt);
+    recordFlightRecorderEvent(agentRoot, {
+        kind: "habit_run",
+        recordedAt: safeReceipt.endedAt,
+        summary: `habit ${safeReceipt.habitName} finished with ${safeReceipt.outcome}`,
+        producedRefs: safeReceipt.producedRefs,
+        meta: { receiptPath: path.join("arc", "flight-recorder", "habit-receipts", `${safeReceipt.runId}.json`) },
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "mind",
+        event: "mind.flight_recorder_habit_receipt_written",
+        message: "flight recorder habit receipt written",
+        meta: { agentRoot, runId: safeReceipt.runId, habitName: safeReceipt.habitName, outcome: safeReceipt.outcome },
+    });
+}
+function formatFlightRecorderResume(resume) {
+    const lines = ["## Arc resume"];
+    lines.push(`can continue: ${resume.canContinue ? "yes" : "no"}`);
+    lines.push(`complete state: ${resume.hasCompleteState ? "yes" : "no"}`);
+    if (resume.currentAsk.value)
+        lines.push(`current ask: ${resume.currentAsk.value}`);
+    if (resume.nextSafeAction.value)
+        lines.push(`next safe action: ${resume.nextSafeAction.value}`);
+    if (resume.nextSafeAction.stopBefore.length > 0)
+        lines.push(`stop before: ${resume.nextSafeAction.stopBefore.join(", ")}`);
+    if (resume.blockedBecause.length > 0)
+        lines.push(`blocked: ${resume.blockedBecause.join("; ")}`);
+    if (resume.missing.length > 0)
+        lines.push(`missing: ${resume.missing.join(", ")}`);
+    if (resume.gaps.length > 0)
+        lines.push(`gaps: ${resume.gaps.join("; ")}`);
+    if (resume.activeObligationIds.length > 0)
+        lines.push(`obligations: ${resume.activeObligationIds.join(", ")}`);
+    if (resume.activeReturnObligationIds.length > 0)
+        lines.push(`return obligations: ${resume.activeReturnObligationIds.join(", ")}`);
+    if (resume.activePacketIds.length > 0)
+        lines.push(`packets: ${resume.activePacketIds.join(", ")}`);
+    if (resume.unverifiedClaimIds.length > 0)
+        lines.push(`unverified claims: ${resume.unverifiedClaimIds.join(", ")}`);
+    if (resume.recorderHealth.status !== "ok") {
+        lines.push(`recorder health: ${resume.recorderHealth.status} (${resume.recorderHealth.issues.join("; ")})`);
+    }
+    return lines.join("\n");
+}
+function createHabitRunId(habitName, now = new Date()) {
+    const safeName = habitName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "habit";
+    return `${now.toISOString().replace(/[:.]/g, "-")}-${safeName}-${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+}

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");
+}