@ouro.bot/cli 0.1.0-alpha.702 → 0.1.0-alpha.704

package/changelog.json

@@ -1,6 +1,20 @@
 {
   "_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.704",
+      "changes": [
+        "Restore RSVP notification copy and harden RSVP run ledgers.",
+        "Preserve loose RSVP spend-ledger history while adding cold-start state coverage."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.703",
+      "changes": [
+        "Let ouro up hand off when the daemon and enabled senses are healthy but only advisory health checks, such as context-loss-sentinel warnings, remain.",
+        "Keep final handoff blocking on degraded enabled senses and health checks that affect daemon, cron, or sense readiness."
+      ]
+    },
     {
       "version": "0.1.0-alpha.702",
       "changes": [

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

@@ -715,6 +715,32 @@ function finalDaemonFailureMessage(deps, reason) {
     lines.push("Run `ouro up` again or `ouro doctor` for a deeper diagnosis.");
     return lines.join("\n");
 }
+function finalHandoffBlockingHealthChecks(payload) {
+    return payload.healthChecks
+        .filter((check) => {
+        if (check.status === "ok")
+            return false;
+        if (check.status === "critical")
+            return true;
+        return check.name === "agent-processes"
+            || check.name === "cron-health"
+            || check.name === "sense-probes"
+            || check.name.startsWith("sense-probe:");
+    })
+        .map((check) => `${check.name}: ${check.status} - ${check.message}`);
+}
+function finalHandoffBlockingWorkers(payload) {
+    return payload.workers
+        .filter((worker) => !(worker.autoStart === false && worker.status === "stopped") && worker.status !== "running")
+        .map((worker) => {
+        const detail = [
+            worker.errorReason,
+            worker.fixHint ? `fix: ${worker.fixHint}` : null,
+        ].filter((part) => part !== null).join("; ");
+        const suffix = detail.length > 0 ? ` - ${detail}` : "";
+        return `${worker.agent}/${worker.worker}: ${worker.status}${suffix}`;
+    });
+}
 async function verifyDaemonReadyForHandoff(deps, options) {
     const settleTimeoutMs = options.settleTimeoutMs;
     const settlePollIntervalMs = options.settlePollIntervalMs;
@@ -772,16 +798,25 @@ async function verifyDaemonReadyForHandoffOnce(deps, options = {}) {
             };
         }
         if (payload.overview.health !== "ok") {
+            const blockingWorkers = finalHandoffBlockingWorkers(payload);
             const degradedSenses = payload.senses
                 .filter((sense) => sense.enabled && !["running", "interactive", "disabled", "not_attached"].includes(sense.status))
                 .map((sense) => `${sense.agent}/${sense.sense}: ${sense.status} - ${sense.detail}`);
-            const detail = degradedSenses.length > 0 ? `; ${degradedSenses.join("; ")}` : "";
+            const blockingHealthChecks = finalHandoffBlockingHealthChecks(payload);
+            const details = [...blockingWorkers, ...degradedSenses, ...blockingHealthChecks];
+            const detail = details.length > 0 ? `; ${details.join("; ")}` : "";
             if (options.allowDegradedHealth) {
                 return {
                     ok: true,
                     summary: `runtime health ${payload.overview.health}`,
                 };
             }
+            if (blockingWorkers.length === 0 && degradedSenses.length === 0 && blockingHealthChecks.length === 0) {
+                return {
+                    ok: true,
+                    summary: "daemon answered with advisory health warnings",
+                };
+            }
             const reason = `runtime health is ${payload.overview.health}${detail}`;
             return {
                 ok: false,

package/dist/rsvp/diff-renderer.js

@@ -4,7 +4,7 @@ exports.guestDisplayName = guestDisplayName;
 exports.computeRsvpDelta = computeRsvpDelta;
 exports.renderRsvpReport = renderRsvpReport;
 const runtime_1 = require("../nerves/runtime");
-const RSVP_REPORT_FOOTER = "🤖 Beep boop! Automated RSVP update from Slugger — no need to reply here!";
+const RSVP_REPORT_FOOTER = "🤖 Beep boop! I'm a script, not Slugger — no need to reply here!";
 function byId(left, right) {
     return left.id.localeCompare(right.id);
 }

package/dist/rsvp/habit-stage.js

@@ -38,6 +38,8 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const habit_parser_1 = require("../heart/habits/habit-parser");
 const runtime_1 = require("../nerves/runtime");
+const outbound_state_1 = require("./outbound-state");
+const spend_ledger_1 = require("./spend-ledger");
 const habit_policy_1 = require("./habit-policy");
 function defaultRsvpHabitMetadata(mode) {
     return {
@@ -62,17 +64,20 @@ function stagedHabitBody() {
 function stageRsvpHabit(input) {
     const habitPath = path.join(input.agentRoot, "habits", `${habit_policy_1.RSVP_HABIT_NAME}.md`);
     const rsvp = defaultRsvpHabitMetadata(input.mode);
+    const created = (input.now ?? new Date()).toISOString();
     const content = (0, habit_parser_1.renderHabitFile)({
         title: "RSVP Ari & Rachel",
         status: "active",
         cadence: input.cadence,
-        created: (input.now ?? new Date()).toISOString(),
+        created,
         tools: [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS],
         continuity: { mode: "stateful" },
         rsvp,
     }, stagedHabitBody());
     fs.mkdirSync(path.dirname(habitPath), { recursive: true });
     fs.writeFileSync(habitPath, content, "utf-8");
+    (0, outbound_state_1.ensureRsvpOutboundState)(input.agentRoot, created);
+    (0, spend_ledger_1.ensureRsvpSpendLedger)(input.agentRoot, created);
     (0, runtime_1.emitNervesEvent)({
         component: "rsvp",
         event: "rsvp.habit_staged",

package/dist/rsvp/outbound-state.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RSVP_OUTBOUND_STATE_POLICY_VERSION = void 0;
 exports.readRsvpOutboundState = readRsvpOutboundState;
+exports.ensureRsvpOutboundState = ensureRsvpOutboundState;
 exports.writeRsvpBaseline = writeRsvpBaseline;
 exports.decideRsvpOutboundReport = decideRsvpOutboundReport;
 exports.recordRsvpOutboundAttempt = recordRsvpOutboundAttempt;
@@ -135,6 +136,19 @@ function writeState(agentRoot, state) {
     fs.renameSync(tmp, filePath);
     return state;
 }
+function ensureRsvpOutboundState(agentRoot, now = new Date().toISOString()) {
+    const filePath = rsvpOutboundStatePath(agentRoot);
+    if (fs.existsSync(filePath))
+        return readRsvpOutboundState(agentRoot);
+    const state = writeState(agentRoot, emptyState(now));
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_state_initialized",
+        message: "initialized RSVP outbound state",
+        meta: { updatedAt: state.updatedAt },
+    });
+    return state;
+}
 function writeRsvpBaseline(input) {
     const current = readRsvpOutboundState(input.agentRoot);
     const state = writeState(input.agentRoot, {

package/dist/rsvp/spend-ledger.js

@@ -0,0 +1,175 @@
+"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.RSVP_SPEND_LEDGER_POLICY_VERSION = void 0;
+exports.readRsvpSpendLedger = readRsvpSpendLedger;
+exports.ensureRsvpSpendLedger = ensureRsvpSpendLedger;
+exports.recordRsvpSpendLedgerRun = recordRsvpSpendLedgerRun;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+exports.RSVP_SPEND_LEDGER_POLICY_VERSION = "rsvp-spend-ledger/v1";
+function ledgerPath(agentRoot) {
+    return path.join(agentRoot, "state", "rsvp", "spend-ledger.json");
+}
+function emptyLedger(now) {
+    return {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_SPEND_LEDGER_POLICY_VERSION,
+        createdAt: now,
+        updatedAt: now,
+        runs: [],
+    };
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function isRun(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && typeof row.runId === "string"
+        && typeof row.rootRunId === "string"
+        && typeof row.idempotencyKey === "string"
+        && typeof row.targetHash === "string"
+        && typeof row.habitName === "string"
+        && typeof row.trigger === "string"
+        && typeof row.lifecycle === "string"
+        && typeof row.startedAt === "string"
+        && typeof row.recordedAt === "string"
+        && row.contentStored === false;
+}
+function storedRun(value) {
+    if (isRun(value))
+        return value;
+    return isRecord(value) ? value : null;
+}
+function isLedger(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && row.policyVersion === exports.RSVP_SPEND_LEDGER_POLICY_VERSION
+        && typeof row.createdAt === "string"
+        && typeof row.updatedAt === "string"
+        && Array.isArray(row.runs);
+}
+function readRsvpSpendLedger(agentRoot) {
+    const filePath = ledgerPath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return emptyLedger(new Date().toISOString());
+    try {
+        const now = new Date().toISOString();
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        if (!isLedger(parsed)) {
+            if (!isRecord(parsed) || !Array.isArray(parsed.runs))
+                return emptyLedger(now);
+            return {
+                schemaVersion: 1,
+                policyVersion: exports.RSVP_SPEND_LEDGER_POLICY_VERSION,
+                createdAt: stringField(parsed, "createdAt") ?? now,
+                updatedAt: stringField(parsed, "updatedAt") ?? now,
+                runs: parsed.runs.map(storedRun).filter((run) => run !== null),
+            };
+        }
+        return {
+            schemaVersion: 1,
+            policyVersion: exports.RSVP_SPEND_LEDGER_POLICY_VERSION,
+            createdAt: parsed.createdAt,
+            updatedAt: parsed.updatedAt,
+            runs: parsed.runs.map(storedRun).filter((run) => run !== null),
+        };
+    }
+    catch {
+        return emptyLedger(new Date().toISOString());
+    }
+}
+function writeLedger(agentRoot, ledger) {
+    const filePath = ledgerPath(agentRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, `${JSON.stringify(ledger, null, 2)}\n`, "utf-8");
+    fs.renameSync(tmp, filePath);
+    return ledger;
+}
+function ensureRsvpSpendLedger(agentRoot, now = new Date().toISOString()) {
+    const filePath = ledgerPath(agentRoot);
+    if (fs.existsSync(filePath))
+        return readRsvpSpendLedger(agentRoot);
+    const ledger = writeLedger(agentRoot, emptyLedger(now));
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.spend_ledger_initialized",
+        message: "initialized RSVP spend ledger",
+        meta: { updatedAt: ledger.updatedAt },
+    });
+    return ledger;
+}
+function recordRsvpSpendLedgerRun(agentRoot, record) {
+    const current = readRsvpSpendLedger(agentRoot);
+    const run = {
+        schemaVersion: 1,
+        runId: record.runId,
+        rootRunId: record.rootRunId,
+        idempotencyKey: record.idempotencyKey,
+        targetHash: record.targetHash,
+        habitName: record.senseOrHabit,
+        trigger: record.triggerType,
+        lifecycle: record.lifecycle,
+        startedAt: record.startedAt,
+        recordedAt: record.recordedAt,
+        ...(record.endedAt ? { endedAt: record.endedAt } : {}),
+        ...(record.usage ? { usage: record.usage } : {}),
+        contentStored: false,
+    };
+    const withoutDuplicate = current.runs.filter((entry) => !(entry.runId === run.runId && entry.lifecycle === run.lifecycle));
+    const updated = writeLedger(agentRoot, {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_SPEND_LEDGER_POLICY_VERSION,
+        createdAt: current.createdAt,
+        updatedAt: run.recordedAt,
+        runs: [...withoutDuplicate, run],
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.spend_ledger_recorded",
+        message: "recorded RSVP spend ledger row",
+        meta: { runId: run.runId, lifecycle: run.lifecycle, habitName: run.habitName },
+    });
+    return updated;
+}

package/dist/senses/private-runtime-worker.js

@@ -52,6 +52,7 @@ const tools_base_1 = require("../repertoire/tools-base");
 const tools_surface_1 = require("../repertoire/tools-surface");
 const tools_1 = require("../repertoire/tools");
 const habit_policy_1 = require("../rsvp/habit-policy");
+const spend_ledger_1 = require("../rsvp/spend-ledger");
 const run_ledger_1 = require("../heart/run-ledger");
 const autonomy_budget_1 = require("../heart/autonomy-budget");
 function isUsageData(value) {
@@ -108,14 +109,29 @@ function habitRunLedgerBase(habitRun) {
 }
 function recordHabitRunLedger(habitRun, lifecycle, endedAt) {
     const usage = extractUsageFromHabitResults(habitRun.results);
-    (0, run_ledger_1.appendRunLedgerRecordNonFatal)(habitRun.agentRoot, (0, run_ledger_1.createRunLedgerRecord)({
+    const record = (0, run_ledger_1.createRunLedgerRecord)({
         ...habitRunLedgerBase(habitRun),
         lifecycle,
         ...(endedAt ? { endedAt } : {}),
         ...(lifecycle === "completed" || lifecycle === "error"
             ? { usage: (0, run_ledger_1.usageMetadataFromUsageData)(usage, usage ? "provider" : "none") }
             : {}),
-    }));
+    });
+    (0, run_ledger_1.appendRunLedgerRecordNonFatal)(habitRun.agentRoot, record);
+    if (habitRun.rsvpPolicy) {
+        try {
+            (0, spend_ledger_1.recordRsvpSpendLedgerRun)(habitRun.agentRoot, record);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "rsvp",
+                event: "rsvp.spend_ledger_record_error",
+                message: "failed to record RSVP spend ledger row",
+                meta: { runId: record.runId, lifecycle, error: String(error) },
+            });
+        }
+    }
 }
 function reserveHabitAutonomyBudget(habitRun, nowIso) {
     const target = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.702",
+  "version": "0.1.0-alpha.704",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",