@ouro.bot/cli 0.1.0-alpha.705 → 0.1.0-alpha.707

package/changelog.json

@@ -1,6 +1,18 @@
 {
   "_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.707",
+      "changes": [
+        "Build RSVP BlueBubbles send clients from explicit agent runtime config during native refresh and smoke runs."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.706",
+      "changes": [
+        "Route native RSVP habit checks through typed refresh execution instead of private-runtime wake policy."
+      ]
+    },
     {
       "version": "0.1.0-alpha.705",
       "changes": [

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

@@ -63,6 +63,7 @@ const pulse_1 = require("./pulse");
 const socket_client_1 = require("./socket-client");
 const await_private_wake_1 = require("./await-private-wake");
 const habit_private_wake_1 = require("./habit-private-wake");
+const habit_policy_1 = require("../../rsvp/habit-policy");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
 const mcp_canary_1 = require("./mcp-canary");
 const context_loss_sentinel_1 = require("../context-loss-sentinel");
@@ -629,6 +630,25 @@ void daemon.start().then(async () => {
                 habitsDir,
                 osCronManager,
                 onHabitFire: (habitName, trigger, context) => {
+                    if ((0, habit_policy_1.isRsvpHabitName)(habitName)) {
+                        (0, socket_client_1.sendDaemonCommand)(socketPath, {
+                            kind: "habit.poke",
+                            agent,
+                            habitName,
+                            trigger,
+                            ...(context?.occurrenceId ? { occurrenceId: context.occurrenceId } : {}),
+                        }).catch((error) => {
+                            emitHabitPrivateWakeDispatchError({
+                                agent,
+                                habitName,
+                                trigger,
+                                triggerSource: `habit-${trigger}`,
+                                socketPath,
+                                error,
+                            });
+                        });
+                        return;
+                    }
                     const command = (0, habit_private_wake_1.buildHabitPrivateWakeCommand)({
                         agent,
                         habitName,

package/dist/heart/daemon/daemon.js

@@ -567,6 +567,7 @@ class OuroDaemon {
     privateRuntimePolicyDeps;
     onStopCommandComplete;
     externalEventRoot;
+    rsvpHabitRunner;
     constructor(options) {
         this.socketPath = options.socketPath;
         this.processManager = options.processManager;
@@ -580,6 +581,7 @@ class OuroDaemon {
         this.privateRuntimePolicyDeps = options.privateRuntimePolicyDeps ?? {};
         this.onStopCommandComplete = options.onStopCommandComplete ?? null;
         this.externalEventRoot = options.externalEventRoot ?? null;
+        this.rsvpHabitRunner = options.rsvpHabitRunner;
     }
     /* v8 ignore start -- default mailbox server wiring: production-only path, tests inject mailboxServerFactory stub instead. startMailboxHttpServer itself has full coverage in mailbox-http.test.ts @preserve */
     createDefaultMailboxServer() {
@@ -1226,6 +1228,8 @@ class OuroDaemon {
         }
         if (trigger === "poke" || trigger === "manual")
             return undefined;
+        if (typeof command.occurrenceId === "string" && command.occurrenceId.trim().length > 0)
+            return command.occurrenceId.trim();
         if (!fs.existsSync(habitPath))
             return { skipReason: "habit file not found" };
         const habit = parsedHabit ?? (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
@@ -1236,6 +1240,24 @@ class OuroDaemon {
             return `${trigger}:first-run:${cadence}`;
         return `${trigger}:last-run:${habit.lastRun}:cadence:${cadence}`;
     }
+    async runNativeRsvpHabit(command, trigger, occurrenceId) {
+        const runner = this.rsvpHabitRunner ?? (async (input) => {
+            const { runNativeRsvpHabit } = await Promise.resolve().then(() => __importStar(require("../../rsvp/native-habit-runner")));
+            return runNativeRsvpHabit(input);
+        });
+        const result = await runner({
+            agent: command.agent,
+            bundlesRoot: this.bundlesRoot,
+            habitName: command.habitName,
+            trigger,
+            ...(occurrenceId ? { occurrenceId } : {}),
+        });
+        return {
+            ok: result.ok,
+            message: result.message,
+            data: result,
+        };
+    }
     buildPrivateRuntimeWorkerWakeMessage(command, decision) {
         const awaitName = (0, await_private_wake_1.awaitNameFromPrivateWakeCommand)(command);
         if (awaitName) {
@@ -1635,7 +1657,7 @@ class OuroDaemon {
                 if (!(0, flight_recorder_1.isHabitRunTrigger)(trigger)) {
                     return { ok: false, error: `invalid habit trigger: ${String(trigger)}` };
                 }
-                if (!this.hasManagedPrivateRuntime(command.agent)) {
+                if (!(0, habit_policy_1.isRsvpHabitName)(command.habitName) && !this.hasManagedPrivateRuntime(command.agent)) {
                     return {
                         ok: false,
                         error: `No managed agent '${command.agent}' is registered with daemon-managed private runtime.`,
@@ -1648,6 +1670,9 @@ class OuroDaemon {
                         message: `skipped scheduled habit ${command.habitName} for ${command.agent}: ${occurrenceId.skipReason}`,
                     };
                 }
+                if ((0, habit_policy_1.isRsvpHabitName)(command.habitName)) {
+                    return this.runNativeRsvpHabit(command, trigger, occurrenceId);
+                }
                 return this.handlePrivateRuntimeWake((0, habit_private_wake_1.buildHabitPrivateWakeCommand)({
                     agent: command.agent,
                     habitName: command.habitName,

package/dist/rsvp/cli.js

@@ -211,6 +211,50 @@ function blueBubblesChatFor(config) {
         participantHandles: [],
     };
 }
+function numberField(record, key, fallback) {
+    const value = record?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function stringArrayField(record, key) {
+    const value = record?.[key];
+    if (!Array.isArray(value))
+        return [];
+    return value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
+}
+function recordField(record, key) {
+    const value = record[key];
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function rsvpBlueBubblesClientConfig(nativeConfig, machineRuntimeConfig) {
+    if (!machineRuntimeConfig.ok) {
+        throw new Error(`BlueBubbles runtime config unavailable at ${machineRuntimeConfig.itemPath}: ${machineRuntimeConfig.error}`);
+    }
+    const bluebubbles = recordField(machineRuntimeConfig.config, "bluebubbles");
+    const bluebubblesChannel = recordField(machineRuntimeConfig.config, "bluebubblesChannel");
+    const serverUrl = localText(bluebubbles?.serverUrl);
+    const password = localText(bluebubbles?.password);
+    if (!serverUrl) {
+        throw new Error("bluebubbles.serverUrl is required in this machine's agent-vault runtime config. Run `ouro connect bluebubbles --agent <agent>`.");
+    }
+    if (!password) {
+        throw new Error("bluebubbles.password is required in this machine's agent-vault runtime config. Run `ouro connect bluebubbles --agent <agent>`.");
+    }
+    return {
+        config: {
+            serverUrl,
+            password,
+            accountId: localText(bluebubbles?.accountId) || localText(nativeConfig.bluebubblesRoute.accountId) || "default",
+            ownHandles: stringArrayField(bluebubbles, "ownHandles"),
+        },
+        channelConfig: {
+            port: numberField(bluebubblesChannel, "port", 18790),
+            webhookPath: localText(bluebubblesChannel?.webhookPath) || "/bluebubbles-webhook",
+            requestTimeoutMs: numberField(bluebubblesChannel, "requestTimeoutMs", 30_000),
+        },
+    };
+}
 function normalizeDelivery(value) {
     const record = value && typeof value === "object" && !Array.isArray(value) ? value : {};
     return {
@@ -552,7 +596,8 @@ async function executeRefresh(command, deps) {
     const sendAllowed = wantsLiveSend;
     let delivery;
     if (sendAllowed) {
-        const sent = await (0, client_1.createBlueBubblesClient)().sendText({
+        const bluebubbles = rsvpBlueBubblesClientConfig(configResult.config, machineRuntimeConfig);
+        const sent = await (0, client_1.createBlueBubblesClient)(bluebubbles.config, bluebubbles.channelConfig).sendText({
             chat: blueBubblesChatFor(configResult.config),
             text: reportText,
             tempGuid: outboundDecision.idempotencyKey,
@@ -658,7 +703,8 @@ async function executeSmoke(command, deps) {
     const sendAllowed = wantsLiveSend;
     let delivery;
     if (sendAllowed) {
-        const sent = await (0, client_1.createBlueBubblesClient)().sendText({
+        const bluebubbles = rsvpBlueBubblesClientConfig(configResult.config, await (0, runtime_credentials_1.refreshMachineRuntimeCredentialConfig)(command.agent, machineIdForCli(), { preserveCachedOnFailure: true }));
+        const sent = await (0, client_1.createBlueBubblesClient)(bluebubbles.config, bluebubbles.channelConfig).sendText({
             chat: blueBubblesChatFor(configResult.config),
             text: answer.text,
         });

package/dist/rsvp/native-habit-runner.js

@@ -0,0 +1,321 @@
+"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.runNativeRsvpHabit = runNativeRsvpHabit;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const habit_parser_1 = require("../heart/habits/habit-parser");
+const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
+const habit_session_1 = require("../heart/habits/habit-session");
+const run_ledger_1 = require("../heart/run-ledger");
+const spend_ledger_1 = require("./spend-ledger");
+const habit_policy_1 = require("./habit-policy");
+const runtime_1 = require("../nerves/runtime");
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function nowIso(now) {
+    const value = now ? now() : new Date();
+    return value instanceof Date ? value.toISOString() : value;
+}
+function nativeRunId(input) {
+    const digest = sha256Hex(JSON.stringify({
+        agent: input.agent,
+        habitName: input.habitName,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId ?? null,
+    })).slice(0, 24);
+    return `rsvp-${input.trigger}-${digest}`;
+}
+function noopCliDeps(input, agentRoot) {
+    return {
+        socketPath: "",
+        sendCommand: async () => ({ ok: false, error: "daemon socket unavailable in native RSVP habit runner" }),
+        startDaemonProcess: async () => ({ pid: null }),
+        writeStdout: () => undefined,
+        checkSocketAlive: async () => false,
+        cleanupStaleSocket: () => undefined,
+        fallbackPendingMessage: () => "daemon socket unavailable in native RSVP habit runner",
+        bundlesRoot: input.bundlesRoot,
+        agentBundleRoot: agentRoot,
+    };
+}
+async function defaultRunRefresh(command, deps) {
+    const { runRsvpCliCommand } = await Promise.resolve().then(() => __importStar(require("./cli")));
+    return runRsvpCliCommand(command, deps);
+}
+function parseRefreshPayload(text) {
+    const parsed = JSON.parse(text);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("RSVP refresh returned a non-object payload");
+    }
+    return parsed;
+}
+function refreshCommandFor(input, sendAllowed, mode) {
+    return {
+        kind: "rsvp.refresh",
+        agent: input.agent,
+        mode,
+        json: true,
+        ...(sendAllowed ? { allowSend: true } : { noSend: true }),
+    };
+}
+function permissionEnvelope(sendAllowed) {
+    return {
+        schemaVersion: 1,
+        canMessageOutward: sendAllowed,
+        returnRoutes: sendAllowed
+            ? [{ kind: "family", recipient: "family", status: "allowed" }]
+            : [],
+        deniedTools: sendAllowed ? [] : ["send_message", "surface"],
+        warnings: [],
+    };
+}
+function toolPolicy(sendAllowed) {
+    return {
+        requestedTools: [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS],
+        grantedTools: [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS],
+        deniedTools: [],
+        outwardMessagingAllowed: sendAllowed,
+    };
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function refreshRecord(payload) {
+    const value = payload.refresh;
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function producedRefsFor(payload) {
+    if (payload.sendAllowed === true)
+        return [];
+    const snapshotId = stringField(refreshRecord(payload) ?? {}, "snapshotId");
+    return snapshotId ? [{ kind: "none", locator: `state/rsvp/snapshots/${snapshotId}.json` }] : [];
+}
+function surfaceAttemptsFor(payload, requestedSend, errorMessage) {
+    if (payload.sendAllowed === true) {
+        return [{
+                recipient: "rsvp",
+                channel: "bluebubbles",
+                reason: "status",
+                result: "sent",
+            }];
+    }
+    if (requestedSend && errorMessage) {
+        return [{
+                recipient: "rsvp",
+                channel: "bluebubbles",
+                reason: "blocked",
+                result: "blocked",
+                error: errorMessage,
+            }];
+    }
+    return [];
+}
+function payloadError(payload) {
+    if (payload.ok === false || typeof payload.requires === "string") {
+        return stringField(payload, "message") ?? "RSVP refresh did not complete";
+    }
+    return null;
+}
+function recordNativeRunLedger(input) {
+    const target = {
+        habitName: input.habitName,
+        runId: input.runId,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId ?? null,
+        command: "rsvp.refresh",
+    };
+    const record = (0, run_ledger_1.createRunLedgerRecord)({
+        agent: input.agent,
+        triggerType: "habit",
+        sourceKind: "daemon",
+        senseOrHabit: input.habitName,
+        lifecycle: input.lifecycle,
+        startedAt: input.startedAt,
+        ...(input.endedAt ? { endedAt: input.endedAt } : {}),
+        ...(input.lifecycle === "completed" || input.lifecycle === "error"
+            ? { usage: (0, run_ledger_1.usageMetadataFromUsageData)(undefined, "none") }
+            : {}),
+        target,
+        idempotencyScope: target,
+        sessionRef: {
+            channel: "rsvp",
+            keyHash: `sha256:${sha256Hex(input.runId)}`,
+        },
+    });
+    (0, run_ledger_1.appendRunLedgerRecordNonFatal)(input.agentRoot, record);
+    try {
+        (0, spend_ledger_1.recordRsvpSpendLedgerRun)(input.agentRoot, record);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "rsvp",
+            event: "rsvp.native_habit_spend_ledger_error",
+            message: "failed to record native RSVP habit spend ledger row",
+            meta: { runId: input.runId, lifecycle: input.lifecycle, error: String(error) },
+        });
+    }
+}
+async function runNativeRsvpHabit(input) {
+    const agentRoot = path.join(input.bundlesRoot, `${input.agent}.ouro`);
+    const habitPath = path.join(agentRoot, "habits", `${input.habitName}.md`);
+    const startedAt = nowIso(input.now);
+    const runId = nativeRunId(input);
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.native_habit_start",
+        message: "native RSVP habit starting",
+        meta: {
+            agent: input.agent,
+            habitName: input.habitName,
+            trigger: input.trigger,
+            occurrenceId: input.occurrenceId ?? null,
+            runId,
+        },
+    });
+    const habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
+    if (!habit.rsvp)
+        throw new Error(`RSVP habit metadata is required before native execution: ${input.habitName}`);
+    const policy = (0, habit_policy_1.rsvpHabitRuntimePolicy)(habit.rsvp);
+    const command = refreshCommandFor(input, policy.sendAllowed, habit.rsvp.mode);
+    const deps = noopCliDeps(input, agentRoot);
+    recordNativeRunLedger({
+        agentRoot,
+        agent: input.agent,
+        habitName: input.habitName,
+        runId,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId,
+        startedAt,
+        lifecycle: "started",
+    });
+    let payload;
+    let errorMessage = null;
+    try {
+        payload = parseRefreshPayload(await (input.runRefresh ?? defaultRunRefresh)(command, deps));
+        errorMessage = payloadError(payload);
+    }
+    catch (error) {
+        payload = {
+            ok: false,
+            command: "rsvp.refresh",
+            sideEffect: false,
+            agent: input.agent,
+            mode: habit.rsvp.mode,
+            message: error instanceof Error ? error.message : String(error),
+        };
+        errorMessage = stringField(payload, "message") ?? "RSVP refresh failed";
+    }
+    const endedAt = nowIso(input.now);
+    const lifecycle = errorMessage ? "error" : "completed";
+    const surfaceAttempts = surfaceAttemptsFor(payload, policy.sendAllowed, errorMessage);
+    const errors = errorMessage ? [errorMessage] : [];
+    recordNativeRunLedger({
+        agentRoot,
+        agent: input.agent,
+        habitName: input.habitName,
+        runId,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId,
+        startedAt,
+        endedAt,
+        lifecycle,
+    });
+    const completion = (0, habit_session_1.completeHabitRun)({
+        agentRoot,
+        habit,
+        runId,
+        trigger: input.trigger,
+        startedAt,
+        endedAt,
+        operationId: `rsvp-native:${input.trigger}:${input.occurrenceId ?? runId}`,
+        permissionEnvelope: permissionEnvelope(policy.sendAllowed),
+        toolPolicy: toolPolicy(policy.sendAllowed),
+        producedRefs: producedRefsFor(payload),
+        surfaceAttempts,
+        errors,
+        summarySnapshot: {
+            summary: errorMessage
+                ? `Native RSVP habit failed: ${errorMessage}`
+                : "Native RSVP habit completed.",
+            decisions: [
+                `mode=${habit.rsvp.mode}`,
+                `sendAllowed=${String(policy.sendAllowed)}`,
+            ],
+            nextLikelyStep: null,
+        },
+    });
+    const ok = lifecycle === "completed" && completion.receiptWritten && completion.runtimeStateRecorded;
+    const message = ok
+        ? `native RSVP habit ${input.habitName} completed for ${input.agent}`
+        : `native RSVP habit ${input.habitName} failed for ${input.agent}: ${errorMessage ?? "runtime state was not recorded"}`;
+    const terminalEventMeta = {
+        agent: input.agent,
+        habitName: input.habitName,
+        trigger: input.trigger,
+        runId,
+        lifecycle,
+        receiptWritten: completion.receiptWritten,
+        runtimeStateRecorded: completion.runtimeStateRecorded,
+    };
+    if (lifecycle === "completed") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "rsvp",
+            event: "rsvp.native_habit_end",
+            message,
+            meta: terminalEventMeta,
+        });
+    }
+    else {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "rsvp",
+            event: "rsvp.native_habit_error",
+            message,
+            meta: terminalEventMeta,
+        });
+    }
+    return {
+        ok,
+        message,
+        lifecycle,
+        runId,
+        payload,
+    };
+}

package/package.json

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