@ouro.bot/cli 0.1.0-alpha.723 → 0.1.0-alpha.725

package/dist/rsvp/cli.js

@@ -179,13 +179,49 @@ function reportCopyFromHabit(title, rsvp) {
     }
     return copy;
 }
+function explicitHabitLifecycleError(habitName, habit, prefix) {
+    const degradedReason = habit.status === "degraded" ? habit.degradedReason : null;
+    const degradedDetail = habit.status === "degraded" ? habit.degradedDetail : null;
+    const reasonText = degradedReason ? ` reason=${degradedReason}` : "";
+    const detailText = degradedDetail ? ` detail=${degradedDetail}` : "";
+    const message = prefix
+        ? `${prefix}; status=${habit.status}${reasonText}${detailText}`
+        : `RSVP habit ${habitName} lifecycle rejected: status=${habit.status}${reasonText}${detailText}`;
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "rsvp",
+        event: "rsvp.habit_lifecycle_rejected",
+        message,
+        meta: {
+            entryPoint: "explicit_refresh",
+            habitName,
+            status: habit.status,
+            degradedReason,
+            degradedDetail,
+        },
+    });
+    return new Error(message);
+}
 function requireRsvpHabitReportCopy(agentRoot, habitName) {
     const habitPath = path.join(agentRoot, "habits", `${habitName}.md`);
-    if (!fs.existsSync(habitPath))
-        throw new Error(`RSVP habit ${habitName} not found at ${habitPath}`);
-    const habit = (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath);
-    if (!habit.rsvp)
-        throw new Error(`RSVP habit ${habitName} metadata is required before explicit refresh`);
+    if (!fs.existsSync(habitPath)) {
+        const missing = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "read_error", "", "habit file not found");
+        throw explicitHabitLifecycleError(habitName, missing, `RSVP habit ${habitName} not found at ${habitPath}`);
+    }
+    let habit;
+    try {
+        habit = (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath);
+    }
+    catch (error) {
+        const unreadable = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "read_error", "", String(error));
+        throw explicitHabitLifecycleError(habitName, unreadable);
+    }
+    if (habit.status !== "active")
+        throw explicitHabitLifecycleError(habitName, habit);
+    if (!habit.rsvp) {
+        const untyped = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "invalid_metadata", habit.body, "RSVP habit metadata is required");
+        throw explicitHabitLifecycleError(habitName, untyped, `RSVP habit ${habitName} metadata is required before explicit refresh`);
+    }
     return reportCopyFromHabit(habit.title, habit.rsvp);
 }
 function activeRsvpHabitReportCopy(agentRoot) {
@@ -553,7 +589,7 @@ async function executeHabitStage(command, deps) {
             requires: "--agent",
         };
     }
-    const result = (0, habit_stage_1.stageRsvpHabit)({
+    const result = await (0, habit_stage_1.stageRsvpHabit)({
         agent: command.agent,
         agentRoot,
         ...(command.habitName ? { habitName: command.habitName } : {}),
@@ -566,7 +602,7 @@ async function executeHabitStage(command, deps) {
         habit: result,
     });
 }
-async function executeRefresh(command, deps) {
+async function executeRefreshInner(command, deps, transportCounter, hardNoSend) {
     const agentRoot = maybeAgentRoot(command, deps);
     if (!command.agent || !agentRoot) {
         return {
@@ -645,8 +681,9 @@ async function executeRefresh(command, deps) {
     const delta = (0, diff_renderer_1.computeRsvpDelta)(previousSnapshot, currentSnapshot);
     const reportText = (0, diff_renderer_1.renderRsvpReport)(delta, reportCopy);
     const outboundDecision = (0, outbound_state_1.decideRsvpOutboundReport)({ agentRoot, currentSnapshot, reportText });
-    const wantsLiveSend = command.mode === "live" && command.allowSend === true && outboundDecision.action === "send";
-    if (wantsLiveSend) {
+    const requestedLiveSend = command.mode === "live" && command.allowSend === true && outboundDecision.action === "send";
+    const sendAllowedBeforeCutover = requestedLiveSend && !hardNoSend;
+    if (sendAllowedBeforeCutover) {
         const cutover = await checkLiveSendCutover({
             agent: command.agent,
             config: configResult.config,
@@ -663,32 +700,90 @@ async function executeRefresh(command, deps) {
             });
         }
     }
-    const sendAllowed = wantsLiveSend;
+    const sendAllowed = requestedLiveSend && !hardNoSend;
     let delivery;
+    let sendBoundary;
+    let sendBoundaryMessage;
     if (sendAllowed) {
+        if (!command.habitName) {
+            return {
+                ...basePayload(command, false, "RSVP live refresh send requires --habit <name>", {
+                    allowSend: true,
+                    sendAllowed: false,
+                    requires: "--habit <name>",
+                    refresh: {
+                        snapshotId: currentSnapshot.snapshotId,
+                        reportText,
+                        outboundDecision: outboundDecision,
+                    },
+                }),
+                ok: false,
+            };
+        }
         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,
-        });
-        delivery = normalizeDelivery(sent);
+        const client = (0, client_1.createBlueBubblesClient)(bluebubbles.config, bluebubbles.channelConfig);
+        sendBoundary = await (0, outbound_state_1.executeRsvpSendBoundary)({
+            agentRoot,
+            habitId: command.habitName,
+            outboundIdempotencyKey: outboundDecision.idempotencyKey,
+            noSend: hardNoSend,
+            invokeTransport: async (markTransportInvoked) => client.sendText({
+                chat: blueBubblesChatFor(configResult.config),
+                text: reportText,
+                tempGuid: outboundDecision.idempotencyKey,
+                onTransportInvocation: () => {
+                    transportCounter.count += 1;
+                    markTransportInvoked();
+                },
+            }),
+        }, deps.rsvpSendBoundaryDeps);
+        const cleanupFailed = sendBoundary.errorCode === "lifecycle_lock_release_failed";
+        const acceptedProof = sendBoundary.boundaryState === "crossed" && !cleanupFailed;
+        sendBoundaryMessage = cleanupFailed
+            ? "RSVP transport crossed but lifecycle lock cleanup failed"
+            : sendBoundary.boundaryState === "crossed"
+                ? "RSVP refresh completed"
+                : sendBoundary.boundaryState === "not_crossed"
+                    ? "RSVP transport was definitively rejected"
+                    : "RSVP transport delivery is unknown";
+        delivery = acceptedProof
+            ? {
+                status: "accepted",
+                ...normalizeDelivery({ messageGuid: sendBoundary.transportResult.messageGuid }),
+            }
+            : cleanupFailed
+                ? {
+                    status: "failed",
+                    error: sendBoundaryMessage,
+                    ...normalizeDelivery({ messageGuid: sendBoundary.transportResult.messageGuid }),
+                }
+                : sendBoundary.boundaryState === "not_crossed"
+                    ? { status: "failed", error: sendBoundaryMessage }
+                    : { status: "pending-manual-verification", error: sendBoundaryMessage };
         (0, outbound_state_1.recordRsvpOutboundAttempt)({
             agentRoot,
             currentSnapshot,
             reportText,
             bluebubblesRecord: {
                 recordId: outboundDecision.idempotencyKey,
-                status: "accepted",
+                status: acceptedProof
+                    ? "accepted"
+                    : sendBoundary.boundaryState === "not_crossed" || cleanupFailed
+                        ? "failed"
+                        : "pending-manual-verification",
                 tempGuid: outboundDecision.idempotencyKey,
-                ...(delivery.guid ? { messageGuid: String(delivery.guid) } : {}),
+                ...(sendBoundary.transportResult.messageGuid
+                    ? { messageGuid: sendBoundary.transportResult.messageGuid }
+                    : {}),
             },
             recordedAt: new Date().toISOString(),
         });
     }
-    return basePayload(command, sendAllowed, "RSVP refresh completed", {
-        allowSend: sendAllowed,
+    const message = sendBoundaryMessage ?? "RSVP refresh completed";
+    const payload = basePayload(command, sendBoundary?.transportInvoked === true && sendBoundary.replayed === false, message, {
+        allowSend: command.mode === "live" && command.allowSend === true,
         sendAllowed,
+        ...(sendBoundary ? { sendBoundary: sendBoundary } : {}),
         refresh: {
             snapshotId: currentSnapshot.snapshotId,
             reportText,
@@ -696,6 +791,17 @@ async function executeRefresh(command, deps) {
             ...(delivery ? { delivery } : {}),
         },
     });
+    return sendBoundary && !sendBoundary.ok ? { ...payload, ok: false } : payload;
+}
+async function executeRefresh(command, deps) {
+    const transportCounter = { count: 0 };
+    const hardNoSend = command.noSend === true;
+    const payload = await executeRefreshInner(command, deps, transportCounter, hardNoSend);
+    return {
+        ...payload,
+        ...(hardNoSend ? { noSend: true } : {}),
+        transportInvocationCount: transportCounter.count,
+    };
 }
 async function executeCompare(command) {
     if (!fs.existsSync(command.nativePath) || !fs.existsSync(command.legacyPath)) {

package/dist/rsvp/diagnostics.js

@@ -118,15 +118,24 @@ function habitScheduleHealth(agentRoot, deps) {
     try {
         const rsvpHabits = deps.readdirSync(habitsDir)
             .filter((name) => name.endsWith(".md") && (0, habit_policy_1.isRsvpHabitName)(name.replace(/\.md$/, "")))
+            .sort((left, right) => left.localeCompare(right))
             .map((name) => {
             const filePath = path.join(habitsDir, name);
             return (0, habit_parser_1.parseHabitFile)(deps.readFileSync(filePath), filePath);
         });
+        const habitStates = rsvpHabits.map((habit) => ({
+            name: habit.name,
+            status: habit.status,
+            degradedReason: habit.status === "degraded" ? habit.degradedReason : null,
+        }));
+        if (rsvpHabits.some((habit) => habit.status === "degraded")) {
+            return { status: "fail", detail: "RSVP habit definitions degraded", habitStates };
+        }
         const active = rsvpHabits.find((habit) => habit.status === "active");
         if (!active)
-            return { status: "warn", detail: "no active RSVP habit found" };
+            return { status: "warn", detail: "no active RSVP habit found", habitStates };
         if (!active.rsvp)
-            return { status: "fail", detail: `activeHabit=${active.name}; typed RSVP habit metadata missing` };
+            return { status: "fail", detail: `activeHabit=${active.name}; typed RSVP habit metadata missing`, habitStates };
         const cadence = active.cadence ?? "unspecified";
         return {
             status: "pass",
@@ -147,6 +156,7 @@ function habitScheduleHealth(agentRoot, deps) {
             outboundStateRef: active.rsvp.outboundStateRef,
             budgetRef: active.rsvp.budgetRef,
             idempotencyRef: active.rsvp.idempotencyRef,
+            habitStates,
         };
     }
     catch (error) {

package/dist/rsvp/habit-policy.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RSVP_HABIT_ALLOWED_TOOLS = exports.DEFAULT_RSVP_HABIT_NAME = exports.RSVP_HABIT_POLICY_VERSION = void 0;
 exports.isRsvpHabitName = isRsvpHabitName;
+exports.rsvpHabitMetadataErrorDetail = rsvpHabitMetadataErrorDetail;
 exports.parseRsvpHabitMetadata = parseRsvpHabitMetadata;
 exports.rsvpHabitRuntimePolicy = rsvpHabitRuntimePolicy;
 const runtime_1 = require("../nerves/runtime");
@@ -35,6 +36,12 @@ function optionalString(record, key) {
 function isRsvpHabitName(name) {
     return name.startsWith("rsvp-");
 }
+function rsvpHabitMetadataErrorDetail(error) {
+    if (error instanceof Error && error.message.startsWith("RSVP habit metadata ")) {
+        return error.message;
+    }
+    return "RSVP habit metadata is invalid";
+}
 function parseRsvpHabitMetadata(raw) {
     if (raw === undefined || raw === null)
         return null;

package/dist/rsvp/habit-stage.js

@@ -33,14 +33,24 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RsvpHabitStageError = void 0;
 exports.stageRsvpHabit = stageRsvpHabit;
-const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const habit_lifecycle_1 = require("../heart/habits/habit-lifecycle");
 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");
+class RsvpHabitStageError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.name = "RsvpHabitStageError";
+        this.code = code;
+    }
+}
+exports.RsvpHabitStageError = RsvpHabitStageError;
 function defaultRsvpHabitMetadata(mode, reportTitle) {
     return {
         policyVersion: habit_policy_1.RSVP_HABIT_POLICY_VERSION,
@@ -69,7 +79,7 @@ function normalizeHabitName(name) {
     }
     return normalized;
 }
-function stageRsvpHabit(input) {
+async function stageRsvpHabit(input, deps = {}) {
     const habitName = normalizeHabitName(input.habitName);
     const title = input.title?.trim() || "RSVP Updates";
     const rsvp = defaultRsvpHabitMetadata(input.mode, input.reportTitle?.trim() || title);
@@ -84,8 +94,13 @@ function stageRsvpHabit(input) {
         continuity: { mode: "stateful" },
         rsvp,
     }, stagedHabitBody());
-    fs.mkdirSync(path.dirname(habitPath), { recursive: true });
-    fs.writeFileSync(habitPath, content, "utf-8");
+    const publication = (0, habit_lifecycle_1.publishNewHabitDefinition)({
+        agentRoot: input.agentRoot,
+        habitId: habitName,
+        bytes: content,
+    }, deps.lifecycle);
+    if (publication === "exists")
+        throw new RsvpHabitStageError("habit_stage_exists");
     (0, outbound_state_1.ensureRsvpOutboundState)(input.agentRoot, created);
     (0, spend_ledger_1.ensureRsvpSpendLedger)(input.agentRoot, created);
     (0, runtime_1.emitNervesEvent)({

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

@@ -61,6 +61,47 @@ function nativeRunId(input) {
     })).slice(0, 24);
     return `rsvp-${input.trigger}-${digest}`;
 }
+function rejectionErrorCode(habit) {
+    return habit.status === "degraded"
+        ? `habit_${habit.degradedReason}`
+        : `habit_status_${habit.status}`;
+}
+function rejectionMessage(habitName, habit) {
+    const reason = habit.status === "degraded" ? ` reason=${habit.degradedReason}` : "";
+    return `native RSVP habit ${habitName} rejected by lifecycle: status=${habit.status}${reason}`;
+}
+function resolveNativeRsvpHabit(agentRoot, habitPath, habitName) {
+    let habit;
+    if (!fs.existsSync(habitPath)) {
+        habit = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "read_error", "", "habit file not found");
+    }
+    else {
+        try {
+            habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
+        }
+        catch (error) {
+            habit = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "read_error", "", String(error));
+        }
+    }
+    if (habit.status !== "active") {
+        return {
+            kind: "rejected",
+            habit,
+            errorCode: rejectionErrorCode(habit),
+            message: rejectionMessage(habitName, habit),
+        };
+    }
+    if (!habit.rsvp) {
+        const degraded = (0, habit_parser_1.createDegradedHabitFile)(habitPath, "invalid_metadata", habit.body, "RSVP habit metadata is required");
+        return {
+            kind: "rejected",
+            habit: degraded,
+            errorCode: rejectionErrorCode(degraded),
+            message: rejectionMessage(habitName, degraded),
+        };
+    }
+    return { kind: "ready", habit: habit };
+}
 function noopCliDeps(input, agentRoot) {
     return {
         socketPath: "",
@@ -92,7 +133,8 @@ function refreshCommandFor(input, sendAllowed, mode) {
         habitName: input.habitName,
         mode,
         json: true,
-        ...(sendAllowed ? { allowSend: true } : { noSend: true }),
+        ...(sendAllowed ? { allowSend: true } : {}),
+        ...(input.noSend || !sendAllowed ? { noSend: true } : {}),
     };
 }
 function permissionEnvelope(sendAllowed) {
@@ -139,6 +181,16 @@ function surfaceAttemptsFor(payload, requestedSend, errorMessage) {
     if (payload.sendAllowed === true) {
         const delivery = (refreshRecord(payload)?.delivery ?? {});
         const rawStatus = stringField(delivery, "status") ?? stringField(delivery, "result");
+        if (rawStatus === "pending-manual-verification") {
+            return [{
+                    recipient: "rsvp",
+                    channel: "bluebubbles",
+                    reason: "status",
+                    result: "unavailable",
+                    rawStatus,
+                    error: "RSVP transport delivery is unknown",
+                }];
+        }
         if (rawStatus === "failed" || rawStatus === "error") {
             return [{
                     recipient: "rsvp",
@@ -327,6 +379,8 @@ function recordNativeRunLedger(input) {
         ...(input.lifecycle === "completed" || input.lifecycle === "error"
             ? { usage: (0, run_ledger_1.usageMetadataFromUsageData)(undefined, "none") }
             : {}),
+        ...(input.errorName ? { errorName: input.errorName } : {}),
+        ...(input.errorCode ? { errorCode: input.errorCode } : {}),
         target,
         idempotencyScope: target,
         sessionRef: {
@@ -365,12 +419,6 @@ async function runNativeRsvpHabit(input) {
             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,
@@ -381,11 +429,102 @@ async function runNativeRsvpHabit(input) {
         startedAt,
         lifecycle: "started",
     });
+    const resolution = resolveNativeRsvpHabit(agentRoot, habitPath, input.habitName);
+    if (resolution.kind === "rejected") {
+        const endedAt = nowIso(input.now);
+        const degradedReason = resolution.habit.status === "degraded"
+            ? resolution.habit.degradedReason
+            : null;
+        const degradedDetail = resolution.habit.status === "degraded"
+            ? resolution.habit.degradedDetail
+            : null;
+        const payload = {
+            ok: false,
+            command: "rsvp.refresh",
+            sideEffect: false,
+            agent: input.agent,
+            requires: "active RSVP habit",
+            message: resolution.message,
+            status: resolution.habit.status,
+            degradedReason,
+            degradedDetail,
+        };
+        recordNativeRunLedger({
+            agentRoot,
+            agent: input.agent,
+            habitName: input.habitName,
+            runId,
+            trigger: input.trigger,
+            occurrenceId: input.occurrenceId,
+            startedAt,
+            endedAt,
+            lifecycle: "error",
+            errorName: "HabitLifecycleRejected",
+            errorCode: resolution.errorCode,
+        });
+        const rejectionMeta = {
+            entryPoint: "native_runner",
+            agent: input.agent,
+            habitName: input.habitName,
+            trigger: input.trigger,
+            occurrenceId: input.occurrenceId ?? null,
+            runId,
+            status: resolution.habit.status,
+            degradedReason,
+            degradedDetail,
+            errorCode: resolution.errorCode,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "rsvp",
+            event: "rsvp.habit_lifecycle_rejected",
+            message: resolution.message,
+            meta: rejectionMeta,
+        });
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "rsvp",
+            event: "rsvp.native_habit_error",
+            message: resolution.message,
+            meta: {
+                ...rejectionMeta,
+                lifecycle: "error",
+                receiptWritten: false,
+                runtimeStateRecorded: false,
+            },
+        });
+        return {
+            ok: false,
+            message: resolution.message,
+            lifecycle: "error",
+            runId,
+            payload,
+        };
+    }
+    const habit = resolution.habit;
+    const policy = (0, habit_policy_1.rsvpHabitRuntimePolicy)(habit.rsvp);
+    const effectiveSendAllowed = policy.sendAllowed && input.noSend !== true;
+    const command = refreshCommandFor(input, policy.sendAllowed, habit.rsvp.mode);
+    const deps = noopCliDeps(input, agentRoot);
     let payload;
     let errorMessage = null;
     try {
         payload = parseRefreshPayload(await (input.runRefresh ?? defaultRunRefresh)(command, deps));
+        payload = { ...payload, status: habit.status };
         errorMessage = payloadError(payload);
+        if (input.noSend === true
+            && (payload.noSend !== true
+                || payload.transportInvocationCount !== 0
+                || payload.sendAllowed === true
+                || payload.sideEffect === true)) {
+            errorMessage = "RSVP refresh violated the immutable no-send result contract";
+            payload = {
+                ...payload,
+                ok: false,
+                status: habit.status,
+                message: errorMessage,
+            };
+        }
     }
     catch (error) {
         payload = {
@@ -394,13 +533,14 @@ async function runNativeRsvpHabit(input) {
             sideEffect: false,
             agent: input.agent,
             mode: habit.rsvp.mode,
+            status: habit.status,
             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 surfaceAttempts = surfaceAttemptsFor(payload, effectiveSendAllowed, errorMessage);
     const errors = errorMessage ? [errorMessage] : [];
     const producedRefs = producedRefsFor(payload);
     recordNativeRunLedger({
@@ -419,7 +559,7 @@ async function runNativeRsvpHabit(input) {
         trigger: input.trigger,
         mode: habit.rsvp.mode,
         source: habit.rsvp.source,
-        sendAllowed: policy.sendAllowed,
+        sendAllowed: effectiveSendAllowed,
         startedAt,
         endedAt,
         payload,
@@ -436,8 +576,8 @@ async function runNativeRsvpHabit(input) {
         startedAt,
         endedAt,
         operationId: `rsvp-native:${input.trigger}:${input.occurrenceId ?? runId}`,
-        permissionEnvelope: permissionEnvelope(policy.sendAllowed),
-        toolPolicy: toolPolicy(policy.sendAllowed),
+        permissionEnvelope: permissionEnvelope(effectiveSendAllowed),
+        toolPolicy: toolPolicy(effectiveSendAllowed),
         producedRefs,
         surfaceAttempts,
         traceSteps,