@ouro.bot/cli 0.1.0-alpha.70 → 0.1.0-alpha.701

package/dist/heart/autonomy-budget.js

@@ -0,0 +1,434 @@
+"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.AUTONOMY_BUDGET_DEFAULT_POLICY = void 0;
+exports.autonomyBudgetStatePath = autonomyBudgetStatePath;
+exports.autonomyReceiptsDir = autonomyReceiptsDir;
+exports.readAutonomyBudgetState = readAutonomyBudgetState;
+exports.readAutonomyStormBreakers = readAutonomyStormBreakers;
+exports.reserveAutonomyBudget = reserveAutonomyBudget;
+exports.recordAutonomyFailure = recordAutonomyFailure;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+const run_ledger_1 = require("./run-ledger");
+exports.AUTONOMY_BUDGET_DEFAULT_POLICY = {
+    agentProactivePaidTurnsPerHour: 6,
+    agentProactivePaidTurnsPerDay: 40,
+    senseRecoveryPaidTurnsPer15m: 3,
+    senseRecoveryPaidTurnsPerDay: 12,
+    habitPaidTurnsPerDay: 4,
+    duplicateRecoveryTtlMs: 10 * 60 * 1000,
+    duplicateHabitTtlMs: 24 * 60 * 60 * 1000,
+    stormFailureThreshold: 3,
+    stormFailureWindowMs: 10 * 60 * 1000,
+    stormBlockMs: 30 * 60 * 1000,
+};
+function autonomyRoot(agentRoot) {
+    return path.join(agentRoot, "state", "autonomy");
+}
+function autonomyBudgetStatePath(agentRoot) {
+    return path.join(autonomyRoot(agentRoot), "budgets.json");
+}
+function autonomyReceiptsDir(agentRoot) {
+    return path.join(autonomyRoot(agentRoot), "receipts");
+}
+function stormBreakersPath(agentRoot) {
+    return path.join(autonomyRoot(agentRoot), "storm-breakers.jsonl");
+}
+function nowIso(input) {
+    return input ?? new Date().toISOString();
+}
+function parseMs(value) {
+    return Date.parse(value);
+}
+function sameCivilDay(left, right) {
+    return left.slice(0, 10) === right.slice(0, 10);
+}
+function emptyState() {
+    return {
+        schemaVersion: 1,
+        updatedAt: new Date().toISOString(),
+        reservations: [],
+        failures: [],
+    };
+}
+function isReservation(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && typeof row.reservedAt === "string"
+        && (row.status === undefined || row.status === "reserved" || row.status === "failed")
+        && typeof row.agent === "string"
+        && typeof row.triggerType === "string"
+        && typeof row.sourceKind === "string"
+        && typeof row.senseOrHabit === "string"
+        && typeof row.targetHash === "string"
+        && typeof row.idempotencyKey === "string"
+        && row.contentStored === false;
+}
+function isFailure(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && typeof row.occurredAt === "string"
+        && typeof row.fingerprint === "string"
+        && typeof row.agent === "string"
+        && typeof row.triggerType === "string"
+        && typeof row.sourceKind === "string"
+        && typeof row.senseOrHabit === "string"
+        && typeof row.provider === "string"
+        && typeof row.targetHash === "string"
+        && typeof row.normalizedErrorName === "string"
+        && typeof row.normalizedErrorCode === "string"
+        && typeof row.codeLocation === "string"
+        && typeof row.idempotencyBucket === "string"
+        && row.contentStored === false;
+}
+function readAutonomyBudgetState(agentRoot) {
+    const filePath = autonomyBudgetStatePath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return emptyState();
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        return {
+            schemaVersion: 1,
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date().toISOString(),
+            reservations: Array.isArray(parsed.reservations) ? parsed.reservations.filter(isReservation) : [],
+            failures: Array.isArray(parsed.failures) ? parsed.failures.filter(isFailure) : [],
+        };
+    }
+    catch {
+        return emptyState();
+    }
+}
+function writeAutonomyBudgetState(agentRoot, state) {
+    const filePath = autonomyBudgetStatePath(agentRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+}
+function receiptIdFor(input) {
+    return `autr_${(0, run_ledger_1.runLedgerHash)(input).slice("sha256:".length, "sha256:".length + 32)}`;
+}
+function writeReceipt(agentRoot, decision) {
+    const receiptId = receiptIdFor(decision);
+    const receipt = {
+        schemaVersion: 1,
+        receiptId,
+        status: decision.status,
+        reason: decision.reason,
+        actor: decision.actor,
+        decidedAt: decision.decidedAt,
+        agent: decision.agent,
+        triggerType: decision.triggerType,
+        sourceKind: decision.sourceKind,
+        senseOrHabit: decision.senseOrHabit,
+        targetHash: decision.targetHash,
+        idempotencyKey: decision.idempotencyKey,
+        contentStored: false,
+    };
+    const filePath = path.join(autonomyReceiptsDir(agentRoot), `${receiptId}.json`);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(receipt, null, 2)}\n`, "utf-8");
+    return receipt;
+}
+function duplicateTtlMs(triggerType, policy) {
+    if (triggerType === "habit")
+        return policy.duplicateHabitTtlMs;
+    return policy.duplicateRecoveryTtlMs;
+}
+function paidAutonomyTrigger(triggerType) {
+    return triggerType === "proactive" || triggerType === "recovery" || triggerType === "habit" || triggerType === "reload";
+}
+function inWindow(at, now, windowMs) {
+    const atMs = parseMs(at);
+    const nowMs = parseMs(now);
+    return Number.isFinite(atMs) && Number.isFinite(nowMs) && nowMs - atMs >= 0 && nowMs - atMs <= windowMs;
+}
+function reservationFor(request, decidedAt) {
+    return {
+        schemaVersion: 1,
+        reservedAt: decidedAt,
+        status: "reserved",
+        agent: request.agent,
+        triggerType: request.triggerType,
+        sourceKind: request.sourceKind,
+        senseOrHabit: request.senseOrHabit,
+        targetHash: (0, run_ledger_1.runLedgerHash)(request.target),
+        idempotencyKey: request.idempotencyKey,
+        contentStored: false,
+    };
+}
+function stormFingerprint(input) {
+    return (0, run_ledger_1.runLedgerHash)({
+        agent: input.agent,
+        triggerType: input.triggerType,
+        sourceKind: input.sourceKind,
+        senseOrHabit: input.senseOrHabit,
+        provider: input.provider,
+        targetHash: (0, run_ledger_1.runLedgerHash)(input.target),
+        normalizedErrorName: input.normalizedErrorName,
+        normalizedErrorCode: input.normalizedErrorCode,
+        codeLocation: input.codeLocation,
+        idempotencyBucket: input.idempotencyBucket,
+    });
+}
+function failureRecord(input, occurredAt) {
+    return {
+        schemaVersion: 1,
+        occurredAt,
+        fingerprint: stormFingerprint(input),
+        agent: input.agent,
+        triggerType: input.triggerType,
+        sourceKind: input.sourceKind,
+        senseOrHabit: input.senseOrHabit,
+        provider: input.provider,
+        targetHash: (0, run_ledger_1.runLedgerHash)(input.target),
+        normalizedErrorName: input.normalizedErrorName,
+        normalizedErrorCode: input.normalizedErrorCode,
+        codeLocation: input.codeLocation,
+        idempotencyBucket: input.idempotencyBucket,
+        contentStored: false,
+    };
+}
+function readAutonomyStormBreakers(agentRoot) {
+    const filePath = stormBreakersPath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return [];
+    return fs.readFileSync(filePath, "utf-8")
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .flatMap((line) => {
+        try {
+            const parsed = JSON.parse(line);
+            return parsed.schemaVersion === 1 && parsed.contentStored === false ? [parsed] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+function appendStormBreaker(agentRoot, breaker) {
+    const filePath = stormBreakersPath(agentRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.appendFileSync(filePath, `${JSON.stringify(breaker)}\n`, "utf-8");
+}
+function activeStormBreaker(agentRoot, input, now) {
+    const fingerprint = stormFingerprint(input);
+    const nowMs = parseMs(now);
+    return readAutonomyStormBreakers(agentRoot)
+        .filter((breaker) => breaker.fingerprint === fingerprint)
+        .filter((breaker) => parseMs(breaker.blockedUntil) > nowMs)
+        .sort((left, right) => right.blockedAt.localeCompare(left.blockedAt))[0] ?? null;
+}
+function blockDecision(agentRoot, request, decidedAt, status, reason) {
+    const targetHash = (0, run_ledger_1.runLedgerHash)(request.target);
+    const base = {
+        status,
+        actor: "agent-runnable",
+        reason,
+        decidedAt,
+        agent: request.agent,
+        triggerType: request.triggerType,
+        sourceKind: request.sourceKind,
+        senseOrHabit: request.senseOrHabit,
+        targetHash,
+        idempotencyKey: request.idempotencyKey,
+    };
+    const receipt = writeReceipt(agentRoot, base);
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "heart",
+        event: "heart.autonomy_budget_blocked",
+        message: "autonomy trigger blocked before paid work",
+        meta: {
+            agent: request.agent,
+            triggerType: request.triggerType,
+            sourceKind: request.sourceKind,
+            senseOrHabit: request.senseOrHabit,
+            status,
+            reason,
+            receiptId: receipt.receiptId,
+        },
+    });
+    return { allowed: false, ...base, receiptId: receipt.receiptId };
+}
+function budgetBlockReason(state, request, now, policy) {
+    if (!paidAutonomyTrigger(request.triggerType))
+        return null;
+    const agentRecentHour = state.reservations.filter((row) => row.agent === request.agent
+        && paidAutonomyTrigger(row.triggerType)
+        && inWindow(row.reservedAt, now, 60 * 60 * 1000)).length;
+    if (agentRecentHour >= policy.agentProactivePaidTurnsPerHour)
+        return "agent proactive paid turn budget exceeded for rolling hour";
+    const agentToday = state.reservations.filter((row) => row.agent === request.agent
+        && paidAutonomyTrigger(row.triggerType)
+        && sameCivilDay(row.reservedAt, now)).length;
+    if (agentToday >= policy.agentProactivePaidTurnsPerDay)
+        return "agent proactive paid turn budget exceeded for day";
+    if (request.triggerType === "recovery" && request.sourceKind === "sense") {
+        const recentRecovery = state.reservations.filter((row) => row.agent === request.agent
+            && row.triggerType === "recovery"
+            && row.sourceKind === request.sourceKind
+            && row.senseOrHabit === request.senseOrHabit
+            && inWindow(row.reservedAt, now, 15 * 60 * 1000)).length;
+        if (recentRecovery >= policy.senseRecoveryPaidTurnsPer15m)
+            return "sense recovery paid turn budget exceeded for rolling 15 minutes";
+        const recoveryToday = state.reservations.filter((row) => row.agent === request.agent
+            && row.triggerType === "recovery"
+            && row.sourceKind === request.sourceKind
+            && row.senseOrHabit === request.senseOrHabit
+            && sameCivilDay(row.reservedAt, now)).length;
+        if (recoveryToday >= policy.senseRecoveryPaidTurnsPerDay)
+            return "sense recovery paid turn budget exceeded for day";
+    }
+    if (request.triggerType === "habit") {
+        const habitToday = state.reservations.filter((row) => row.agent === request.agent
+            && row.triggerType === "habit"
+            && row.senseOrHabit === request.senseOrHabit
+            && sameCivilDay(row.reservedAt, now)).length;
+        if (habitToday >= policy.habitPaidTurnsPerDay)
+            return "habit paid turn budget exceeded for day";
+    }
+    return null;
+}
+function reserveAutonomyBudget(agentRoot, request, policy = exports.AUTONOMY_BUDGET_DEFAULT_POLICY) {
+    const decidedAt = nowIso(request.now);
+    const state = readAutonomyBudgetState(agentRoot);
+    const targetHash = (0, run_ledger_1.runLedgerHash)(request.target);
+    const duplicate = state.reservations.find((row) => row.idempotencyKey === request.idempotencyKey
+        && row.status !== "failed"
+        && inWindow(row.reservedAt, decidedAt, duplicateTtlMs(request.triggerType, policy)));
+    if (duplicate)
+        return blockDecision(agentRoot, request, decidedAt, "duplicate", "duplicate trigger suppressed");
+    if (request.storm && activeStormBreaker(agentRoot, request.storm, decidedAt)) {
+        return blockDecision(agentRoot, request, decidedAt, "blocked", "storm breaker active for this trigger fingerprint");
+    }
+    const reason = budgetBlockReason(state, request, decidedAt, policy);
+    if (reason)
+        return blockDecision(agentRoot, request, decidedAt, "blocked", reason);
+    const reservation = reservationFor(request, decidedAt);
+    const nextState = {
+        schemaVersion: 1,
+        updatedAt: decidedAt,
+        reservations: [...state.reservations, reservation],
+        failures: state.failures,
+    };
+    writeAutonomyBudgetState(agentRoot, nextState);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.autonomy_budget_allowed",
+        message: "autonomy trigger reserved budget before paid work",
+        meta: {
+            agent: request.agent,
+            triggerType: request.triggerType,
+            sourceKind: request.sourceKind,
+            senseOrHabit: request.senseOrHabit,
+            targetHash,
+        },
+    });
+    return {
+        allowed: true,
+        status: "allowed",
+        actor: "agent-runnable",
+        reason: "budget reserved",
+        decidedAt,
+        agent: request.agent,
+        triggerType: request.triggerType,
+        sourceKind: request.sourceKind,
+        senseOrHabit: request.senseOrHabit,
+        targetHash,
+        idempotencyKey: request.idempotencyKey,
+    };
+}
+function recordAutonomyFailure(agentRoot, input, policy = exports.AUTONOMY_BUDGET_DEFAULT_POLICY) {
+    const occurredAt = nowIso(input.occurredAt);
+    const record = failureRecord(input, occurredAt);
+    const state = readAutonomyBudgetState(agentRoot);
+    const targetHash = (0, run_ledger_1.runLedgerHash)(input.target);
+    const reservations = state.reservations.map((row) => row.agent === input.agent
+        && row.triggerType === input.triggerType
+        && row.sourceKind === input.sourceKind
+        && row.senseOrHabit === input.senseOrHabit
+        && row.targetHash === targetHash
+        && row.status !== "failed"
+        ? { ...row, status: "failed" }
+        : row);
+    const nextFailures = [...state.failures, record];
+    writeAutonomyBudgetState(agentRoot, {
+        schemaVersion: 1,
+        updatedAt: occurredAt,
+        reservations,
+        failures: nextFailures,
+    });
+    const recent = nextFailures.filter((row) => row.fingerprint === record.fingerprint
+        && inWindow(row.occurredAt, occurredAt, policy.stormFailureWindowMs));
+    if (recent.length >= policy.stormFailureThreshold && !activeStormBreaker(agentRoot, input, occurredAt)) {
+        const breaker = {
+            schemaVersion: 1,
+            fingerprint: record.fingerprint,
+            agent: record.agent,
+            triggerType: record.triggerType,
+            sourceKind: record.sourceKind,
+            senseOrHabit: record.senseOrHabit,
+            provider: record.provider,
+            targetHash: record.targetHash,
+            normalizedErrorName: record.normalizedErrorName,
+            normalizedErrorCode: record.normalizedErrorCode,
+            codeLocation: record.codeLocation,
+            idempotencyBucket: record.idempotencyBucket,
+            blockedAt: occurredAt,
+            blockedUntil: new Date(parseMs(occurredAt) + policy.stormBlockMs).toISOString(),
+            failureCount: recent.length,
+            contentStored: false,
+        };
+        appendStormBreaker(agentRoot, breaker);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "heart",
+            event: "heart.autonomy_storm_breaker",
+            message: "autonomy storm breaker activated",
+            meta: {
+                agent: breaker.agent,
+                triggerType: breaker.triggerType,
+                sourceKind: breaker.sourceKind,
+                senseOrHabit: breaker.senseOrHabit,
+                blockedUntil: breaker.blockedUntil,
+                failureCount: breaker.failureCount,
+            },
+        });
+    }
+    return record;
+}

package/dist/heart/awaiting/await-alert.js

@@ -0,0 +1,146 @@
+"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.resolveAlertKey = resolveAlertKey;
+exports.buildAlertContent = buildAlertContent;
+exports.deliverAwaitAlert = deliverAwaitAlert;
+exports.buildAwaitDeliveryDeps = buildAwaitDeliveryDeps;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const cross_chat_delivery_1 = require("../cross-chat-delivery");
+function readNonEmpty(value) {
+    if (value === null)
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+/**
+ * Find a session key for (friendId, channel) by scanning the bundle's
+ * sessions directory. Prefers BlueBubbles DM keys (containing ";-;");
+ * for other channels, returns the first available session file stem.
+ *
+ * Returns null when nothing is available — caller decides whether to skip
+ * delivery or fall back to a default like "session".
+ */
+function resolveAlertKey(agentRoot, friendId, channel) {
+    const dir = path.join(agentRoot, "state", "sessions", friendId, channel);
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return null;
+    }
+    const jsonFiles = entries.filter((f) => f.endsWith(".json"));
+    if (jsonFiles.length === 0)
+        return null;
+    const dm = jsonFiles.find((f) => f.includes(";-;"));
+    const chosen = dm ?? jsonFiles[0];
+    return chosen.replace(/\.json$/, "");
+}
+function buildAlertContent(awaitFile, reason, observation) {
+    const condition = awaitFile.condition ?? awaitFile.name;
+    const obs = readNonEmpty(observation);
+    if (reason === "resolved") {
+        return obs ? `${condition} — ready. ${obs}` : `${condition} — ready.`;
+    }
+    return obs ? `${condition} — timed out. last seen: ${obs}` : `${condition} — timed out. last seen: never observed`;
+}
+async function deliverAwaitAlert(options) {
+    const { awaitFile, reason, observation, agentRoot, deliveryDeps } = options;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.await_alert_start",
+        message: "preparing await alert",
+        meta: { awaitName: awaitFile.name, reason },
+    });
+    const channel = readNonEmpty(awaitFile.alert);
+    const friendId = readNonEmpty(awaitFile.filed_for_friend_id);
+    if (!channel) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.await_alert_end",
+            message: "skipping alert — no alert channel configured",
+            meta: { awaitName: awaitFile.name, reason },
+        });
+        return { attempted: false, skipped: "no alert channel" };
+    }
+    if (!friendId) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.await_alert_end",
+            message: "skipping alert — no filed_for_friend_id",
+            meta: { awaitName: awaitFile.name, reason },
+        });
+        return { attempted: false, skipped: "no friend id" };
+    }
+    const key = resolveAlertKey(agentRoot, friendId, channel);
+    if (!key) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.await_alert_end",
+            message: "skipping alert — no resolvable session key",
+            meta: { awaitName: awaitFile.name, reason, friendId, channel },
+        });
+        return { attempted: false, skipped: "no session key" };
+    }
+    const content = buildAlertContent(awaitFile, reason, observation);
+    const delivery = await (0, cross_chat_delivery_1.deliverCrossChatMessage)({
+        friendId,
+        channel,
+        key,
+        content,
+        intent: "generic_outreach",
+    }, deliveryDeps);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.await_alert_end",
+        message: "await alert delivered",
+        meta: { awaitName: awaitFile.name, reason, status: delivery.status },
+    });
+    return { attempted: true, delivery };
+}
+function buildAwaitDeliveryDeps(options) {
+    return {
+        agentName: options.agentName,
+        queuePending: options.queuePending,
+        deliverers: options.deliverers,
+        now: options.now,
+    };
+}

package/dist/heart/awaiting/await-expiry.js

@@ -0,0 +1,108 @@
+"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.archiveAndAlertExpiredAwait = archiveAndAlertExpiredAwait;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const await_parser_1 = require("./await-parser");
+const await_runtime_state_1 = require("./await-runtime-state");
+const await_alert_1 = require("./await-alert");
+/**
+ * Daemon-side max_age expiry helper. Reads the pending await, moves it to
+ * `awaiting/.done/` with `status: expired`, writes `expired_at` and
+ * `last_observation_at_expiry`, then fires the alert via deliverAwaitAlert.
+ *
+ * Idempotent w.r.t. the alert path: if the file is gone (already archived
+ * by a concurrent path) it returns `archived: false` without alerting.
+ */
+async function archiveAndAlertExpiredAwait(options) {
+    const now = options.now ?? (() => new Date());
+    const source = path.join(options.agentRoot, "awaiting", `${options.awaitName}.md`);
+    const doneDir = path.join(options.agentRoot, "awaiting", ".done");
+    const target = path.join(doneDir, `${options.awaitName}.md`);
+    let content;
+    try {
+        content = fs.readFileSync(source, "utf-8");
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.await_expiry_skip",
+            message: "expired await file no longer present at archive time",
+            meta: { agent: options.agentName, awaitName: options.awaitName },
+        });
+        return { archived: false, alerted: false, reason: "file missing" };
+    }
+    const parsed = (0, await_parser_1.parseAwaitFile)(content, source);
+    const runtime = (0, await_runtime_state_1.readAwaitRuntimeState)(options.agentRoot, options.awaitName);
+    const lastObservation = runtime?.last_observation ?? null;
+    const expiredAt = now().toISOString();
+    const merged = {
+        condition: parsed.condition,
+        cadence: parsed.cadence,
+        alert: parsed.alert,
+        mode: parsed.mode,
+        max_age: parsed.max_age,
+        status: "expired",
+        created_at: parsed.created_at,
+        filed_from: parsed.filed_from,
+        filed_for_friend_id: parsed.filed_for_friend_id,
+        expired_at: expiredAt,
+        last_observation_at_expiry: lastObservation,
+    };
+    fs.mkdirSync(doneDir, { recursive: true });
+    fs.writeFileSync(target, (0, await_parser_1.renderAwaitFile)(merged, parsed.body), "utf-8");
+    fs.unlinkSync(source);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.await_expired_archived",
+        message: "expired await archived",
+        meta: { agent: options.agentName, awaitName: options.awaitName, expiredAt },
+    });
+    // Re-parse archived file to feed the alert with merged fields
+    const archivedContent = fs.readFileSync(target, "utf-8");
+    const archived = (0, await_parser_1.parseAwaitFile)(archivedContent, target);
+    const alertResult = await (0, await_alert_1.deliverAwaitAlert)({
+        awaitFile: archived,
+        reason: "expired",
+        observation: lastObservation,
+        agentRoot: options.agentRoot,
+        agentName: options.agentName,
+        deliveryDeps: options.deliveryDeps,
+    });
+    return { archived: true, alerted: alertResult.attempted };
+}