@ouro.bot/cli 0.1.0-alpha.62 → 0.1.0-alpha.637

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

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

@@ -0,0 +1,91 @@
+"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.loadPendingAwaitsForCommitments = loadPendingAwaitsForCommitments;
+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");
+/**
+ * Load the bundle's pending awaits, merged with runtime state, projected into
+ * the AwaitingCommitment shape consumed by the commitments / prompt pipeline.
+ *
+ * Reads only `<bundle>/awaiting/` (never `.done/`). Skips malformed files
+ * silently — those are surfaced via the scheduler's parseErrors path.
+ */
+function loadPendingAwaitsForCommitments(agentRoot) {
+    const dir = path.join(agentRoot, "awaiting");
+    let entries;
+    try {
+        const raw = fs.readdirSync(dir);
+        /* v8 ignore next -- defensive: real readdirSync returns string[]; this only fires when callers stub it to a non-array @preserve */
+        entries = Array.isArray(raw) ? raw : [];
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const entry of entries) {
+        if (!entry.endsWith(".md"))
+            continue;
+        const filePath = path.join(dir, entry);
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const merged = (0, await_runtime_state_1.applyAwaitRuntimeState)(agentRoot, (0, await_parser_1.parseAwaitFile)(content, filePath));
+            if (merged.status !== "pending")
+                continue;
+            if (!merged.condition)
+                continue;
+            out.push({
+                name: merged.name,
+                condition: merged.condition,
+                checkedCount: typeof merged.checked_count === "number" ? merged.checked_count : 0,
+                lastCheckedAt: merged.last_checked ?? null,
+                lastObservation: merged.last_observation ?? null,
+            });
+        }
+        catch {
+            // Skip unreadable/unparseable files — surfaced elsewhere
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.awaits_loaded_for_commitments",
+        message: "loaded pending awaits for commitments",
+        meta: { agentRoot, count: out.length },
+    });
+    return out;
+}

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

@@ -0,0 +1,141 @@
+"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.parseAwaitFile = parseAwaitFile;
+exports.renderAwaitFile = renderAwaitFile;
+const path = __importStar(require("path"));
+const frontmatter_1 = require("../../util/frontmatter");
+const runtime_1 = require("../../nerves/runtime");
+function isAwaitStatus(value) {
+    return value === "pending" || value === "resolved" || value === "expired" || value === "canceled";
+}
+function isAwaitMode(value) {
+    return value === "full" || value === "quick";
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function extractFrontmatterAndBody(content) {
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---")
+        return null;
+    const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (closing === -1)
+        return null;
+    const rawFrontmatter = lines.slice(1, closing).join("\n");
+    const body = lines.slice(closing + 1).join("\n").trim();
+    return { frontmatter: (0, frontmatter_1.parseFrontmatter)(rawFrontmatter), body };
+}
+function emptyAwait(stem, body) {
+    return {
+        name: stem,
+        condition: null,
+        cadence: null,
+        alert: null,
+        mode: "full",
+        max_age: null,
+        status: "pending",
+        created_at: null,
+        filed_from: null,
+        filed_for_friend_id: null,
+        body,
+        resolved_at: null,
+        resolution_observation: null,
+        expired_at: null,
+        last_observation_at_expiry: null,
+        canceled_at: null,
+        cancel_reason: null,
+    };
+}
+function parseAwaitFile(content, filePath) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.await_parse",
+        component: "daemon",
+        message: "parsing await file",
+        meta: { filePath },
+    });
+    const stem = path.basename(filePath, ".md");
+    const parsed = extractFrontmatterAndBody(content);
+    if (!parsed)
+        return { ...emptyAwait(stem, content.trim()) };
+    const { frontmatter, body } = parsed;
+    const rawStatus = frontmatter.status;
+    const status = typeof rawStatus === "string" && isAwaitStatus(rawStatus) ? rawStatus : "pending";
+    const rawMode = frontmatter.mode;
+    const mode = typeof rawMode === "string" && isAwaitMode(rawMode) ? rawMode : "full";
+    return {
+        name: stem,
+        condition: nonEmptyString(frontmatter.condition),
+        cadence: nonEmptyString(frontmatter.cadence),
+        alert: nonEmptyString(frontmatter.alert),
+        mode,
+        max_age: nonEmptyString(frontmatter.max_age),
+        status,
+        created_at: nonEmptyString(frontmatter.created_at),
+        filed_from: nonEmptyString(frontmatter.filed_from),
+        filed_for_friend_id: nonEmptyString(frontmatter.filed_for_friend_id),
+        body,
+        resolved_at: nonEmptyString(frontmatter.resolved_at),
+        resolution_observation: nonEmptyString(frontmatter.resolution_observation),
+        expired_at: nonEmptyString(frontmatter.expired_at),
+        last_observation_at_expiry: nonEmptyString(frontmatter.last_observation_at_expiry),
+        canceled_at: nonEmptyString(frontmatter.canceled_at),
+        cancel_reason: nonEmptyString(frontmatter.cancel_reason),
+    };
+}
+function formatFrontmatterValue(value) {
+    if (value === null || value === undefined)
+        return "null";
+    if (Array.isArray(value))
+        return `[${value.join(", ")}]`;
+    return String(value);
+}
+function renderAwaitFile(frontmatter, body) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.await_render",
+        component: "daemon",
+        message: "rendering await file",
+        meta: {},
+    });
+    const lines = ["---"];
+    for (const key of Object.keys(frontmatter)) {
+        lines.push(`${key}: ${formatFrontmatterValue(frontmatter[key])}`);
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(body.trim());
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/heart/awaiting/await-runtime-state.js

@@ -0,0 +1,100 @@
+"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.readAwaitRuntimeState = readAwaitRuntimeState;
+exports.applyAwaitRuntimeState = applyAwaitRuntimeState;
+exports.writeAwaitRuntimeState = writeAwaitRuntimeState;
+exports.recordAwaitCheck = recordAwaitCheck;
+const path = __importStar(require("path"));
+const json_store_1 = require("../../arc/json-store");
+const session_events_1 = require("../session-events");
+const runtime_1 = require("../../nerves/runtime");
+function awaitRuntimeStateDir(agentRoot) {
+    return path.join(agentRoot, "state", "awaits");
+}
+function readAwaitRuntimeState(agentRoot, name) {
+    const record = (0, json_store_1.readJsonFile)(awaitRuntimeStateDir(agentRoot), name);
+    if (!record)
+        return null;
+    return {
+        last_checked: typeof record.last_checked === "string" ? record.last_checked : null,
+        last_observation: typeof record.last_observation === "string" ? record.last_observation : null,
+        checked_count: typeof record.checked_count === "number" ? record.checked_count : 0,
+    };
+}
+function applyAwaitRuntimeState(agentRoot, awaitFile) {
+    const state = readAwaitRuntimeState(agentRoot, awaitFile.name);
+    if (state === null)
+        return awaitFile;
+    return {
+        ...awaitFile,
+        // Cast: runtime fields are merged onto the file for prompt/commitments consumers
+        ...state,
+    };
+}
+function writeAwaitRuntimeState(agentRoot, name, partial) {
+    const existing = readAwaitRuntimeState(agentRoot, name);
+    const merged = {
+        last_checked: partial.last_checked ?? existing?.last_checked ?? null,
+        last_observation: partial.last_observation != null
+            ? (0, session_events_1.capStructuredRecordString)(partial.last_observation)
+            : existing?.last_observation ?? null,
+        checked_count: partial.checked_count ?? existing?.checked_count ?? 0,
+    };
+    const record = {
+        schemaVersion: 1,
+        name,
+        last_checked: merged.last_checked,
+        last_observation: merged.last_observation,
+        checked_count: merged.checked_count,
+        updatedAt: new Date().toISOString(),
+    };
+    (0, json_store_1.writeJsonFile)(awaitRuntimeStateDir(agentRoot), name, record);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.await_runtime_state_write",
+        message: "wrote await runtime state",
+        meta: { agentRoot, name, last_checked: merged.last_checked, checked_count: merged.checked_count },
+    });
+}
+function recordAwaitCheck(agentRoot, name, observation, now) {
+    const existing = readAwaitRuntimeState(agentRoot, name);
+    const nextCount = (existing?.checked_count ?? 0) + 1;
+    writeAwaitRuntimeState(agentRoot, name, {
+        last_checked: now,
+        last_observation: observation,
+        checked_count: nextCount,
+    });
+}