@ouro.bot/cli 0.1.0-alpha.72 → 0.1.0-alpha.721

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

@@ -0,0 +1,490 @@
+"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");
+const flight_recorder_1 = require("../arc/flight-recorder");
+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,
+        habitName: input.habitName,
+        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 outboundAction(payload) {
+    const refresh = refreshRecord(payload);
+    const decision = refresh?.outboundDecision;
+    if (!decision || typeof decision !== "object" || Array.isArray(decision))
+        return "unknown";
+    return stringField(decision, "action") ?? "unknown";
+}
+function surfaceAttemptsFor(payload, requestedSend, errorMessage) {
+    if (payload.sendAllowed === true) {
+        const delivery = (refreshRecord(payload)?.delivery ?? {});
+        const rawStatus = stringField(delivery, "status") ?? stringField(delivery, "result");
+        if (rawStatus === "failed" || rawStatus === "error") {
+            return [{
+                    recipient: "rsvp",
+                    channel: "bluebubbles",
+                    reason: "status",
+                    result: "failed",
+                    rawStatus,
+                    error: stringField(delivery, "error") ?? stringField(delivery, "message") ?? rawStatus,
+                }];
+        }
+        return [{
+                recipient: "rsvp",
+                channel: "bluebubbles",
+                reason: "status",
+                result: "sent",
+                ...(rawStatus ? { rawStatus } : {}),
+            }];
+    }
+    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 traceStatusForSurfaceAttempt(attempt) {
+    if (!attempt)
+        return "skipped";
+    if (attempt.result === "failed")
+        return "failed";
+    if (attempt.result === "blocked" || attempt.result === "unavailable")
+        return "blocked";
+    return "succeeded";
+}
+function nativeRsvpTraceSteps(input) {
+    const refresh = refreshRecord(input.payload);
+    const snapshotId = stringField(refresh ?? {}, "snapshotId");
+    const reportText = stringField(refresh ?? {}, "reportText");
+    const action = outboundAction(input.payload);
+    const firstAttempt = input.surfaceAttempts[0];
+    const snapshotLocator = snapshotId ? `state/rsvp/snapshots/${snapshotId}.json` : null;
+    const decisions = [
+        `mode=${input.mode}`,
+        `sendAllowed=${String(input.sendAllowed)}`,
+        `outboundAction=${action}`,
+    ];
+    return [
+        {
+            schemaVersion: 1,
+            stepId: "trigger",
+            kind: "trigger",
+            status: "succeeded",
+            at: input.startedAt,
+            summary: `${input.trigger} triggered ${input.habitName}.`,
+        },
+        {
+            schemaVersion: 1,
+            stepId: "habit-definition",
+            kind: "habit_definition",
+            status: "succeeded",
+            at: input.startedAt,
+            summary: `Loaded habit definition for ${input.habitName}.`,
+            refs: [{ kind: "habit_definition", locator: `habits/${input.habitName}.md`, label: input.habitName }],
+        },
+        {
+            schemaVersion: 1,
+            stepId: "fetch-refresh",
+            kind: "fetch",
+            status: input.errors.length > 0 ? "failed" : "succeeded",
+            at: input.endedAt,
+            summary: `Ran RSVP refresh in ${input.mode} mode.`,
+            refs: [{ kind: "source", locator: `rsvp/${input.source}` }],
+        },
+        {
+            schemaVersion: 1,
+            stepId: "snapshot",
+            kind: "snapshot",
+            status: snapshotLocator ? "succeeded" : "skipped",
+            at: input.endedAt,
+            summary: snapshotLocator ? "Recorded the RSVP snapshot reference." : "No RSVP snapshot reference was returned.",
+            ...(snapshotLocator ? { refs: [{ kind: "snapshot", locator: snapshotLocator }] } : {}),
+        },
+        {
+            schemaVersion: 1,
+            stepId: "render",
+            kind: "render",
+            status: reportText ? "succeeded" : "skipped",
+            at: input.endedAt,
+            summary: reportText ? "Rendered RSVP update text." : "No rendered RSVP update text was returned.",
+        },
+        {
+            schemaVersion: 1,
+            stepId: "decision",
+            kind: "decision",
+            status: input.errors.length > 0 ? "blocked" : "succeeded",
+            at: input.endedAt,
+            summary: `RSVP outbound decision: ${action}.`,
+            decisions,
+        },
+        {
+            schemaVersion: 1,
+            stepId: "produced-ref",
+            kind: "produced_ref",
+            status: input.producedRefs.length > 0 ? "succeeded" : "skipped",
+            at: input.endedAt,
+            summary: input.producedRefs.length > 0 ? "Recorded produced RSVP refs." : "No separate produced refs were recorded.",
+            ...(input.producedRefs.length > 0 ? { producedRefs: input.producedRefs } : {}),
+        },
+        {
+            schemaVersion: 1,
+            stepId: "surface-attempt",
+            kind: "surface_attempt",
+            status: traceStatusForSurfaceAttempt(firstAttempt),
+            at: input.endedAt,
+            summary: firstAttempt ? `Surface attempt ${firstAttempt.result} via ${firstAttempt.channel}.` : "No surface attempt was needed.",
+            ...(firstAttempt ? { surfaceAttempt: firstAttempt } : {}),
+        },
+        {
+            schemaVersion: 1,
+            stepId: "send",
+            kind: "send",
+            status: input.sendAllowed
+                ? traceStatusForSurfaceAttempt(firstAttempt)
+                : "skipped",
+            at: input.endedAt,
+            summary: input.sendAllowed ? "Live send was allowed for this run." : "Live send was not allowed for this run.",
+            ...(firstAttempt ? { surfaceAttempt: firstAttempt } : {}),
+        },
+        {
+            schemaVersion: 1,
+            stepId: "ledger",
+            kind: "ledger",
+            status: "succeeded",
+            at: input.endedAt,
+            summary: "Recorded native RSVP run ledger evidence.",
+            refs: [
+                { kind: "ledger", locator: "state/run-ledger/runs.jsonl" },
+                { kind: "ledger", locator: "state/rsvp/spend-ledger.json" },
+            ],
+        },
+        {
+            schemaVersion: 1,
+            stepId: "error",
+            kind: "error",
+            status: input.errors.length > 0 ? "failed" : "skipped",
+            at: input.endedAt,
+            summary: input.errors.length > 0 ? "RSVP refresh returned an error." : "No RSVP error happened.",
+            ...(input.errors[0] ? { error: input.errors[0] } : {}),
+        },
+        {
+            schemaVersion: 1,
+            stepId: "complete",
+            kind: "complete",
+            status: input.lifecycle === "completed" ? "succeeded" : "failed",
+            at: input.endedAt,
+            summary: `Native RSVP habit ${input.lifecycle}.`,
+        },
+    ];
+}
+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] : [];
+    const producedRefs = producedRefsFor(payload);
+    recordNativeRunLedger({
+        agentRoot,
+        agent: input.agent,
+        habitName: input.habitName,
+        runId,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId,
+        startedAt,
+        endedAt,
+        lifecycle,
+    });
+    const traceSteps = nativeRsvpTraceSteps({
+        habitName: input.habitName,
+        trigger: input.trigger,
+        mode: habit.rsvp.mode,
+        source: habit.rsvp.source,
+        sendAllowed: policy.sendAllowed,
+        startedAt,
+        endedAt,
+        payload,
+        producedRefs,
+        surfaceAttempts,
+        errors,
+        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,
+        surfaceAttempts,
+        traceSteps,
+        errors,
+        summarySnapshot: {
+            summary: errorMessage
+                ? `Native RSVP habit failed: ${errorMessage}`
+                : "Native RSVP habit completed.",
+            decisions: (0, flight_recorder_1.decisionsFromHabitRunTraceSteps)(traceSteps),
+            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,
+    };
+}