@ouro.bot/cli 0.1.0-alpha.720 → 0.1.0-alpha.722

package/dist/heart/daemon/freshness.js

@@ -0,0 +1,302 @@
+"use strict";
+/**
+ * Pipeline freshness — "is this pipe still moving?"
+ *
+ * Every outage this module exists to prevent had the same shape: a health
+ * check verified that something was *configured* or *connected*, and reported
+ * a green tick next to a pipe that had been dead for weeks.
+ *
+ *   - mail: `mail enabled` / `mail config ok` / `45479 messages` all passed
+ *     while zero mail had been ingested for 77 days after a vault key rotation
+ *     changed the mailbox keyIds. The message count is cumulative, so it can
+ *     only ever go up — it is not a liveness signal.
+ *   - bluebubbles: the upstream HTTP probe stayed `ok` for days while inbound
+ *     delivery was dead, because the server was POSTing its webhook to a
+ *     stale port. A reachable upstream does not prove inbound delivery.
+ *   - launchd: checks asserted a plist *file* existed rather than that the
+ *     job was loaded.
+ *
+ * The fix is to assert on *observed data flow*, with three rules baked into
+ * this primitive:
+ *
+ *   1. Age is always stated in the message, in human units, with the
+ *      timestamp it was derived from.
+ *   2. "Never observed any activity" and "could not observe" are distinct
+ *      states from "activity, but stale" — and none of them can read as
+ *      `pass`. An unobservable pipe is unverified, not healthy.
+ *   3. Every non-`pass` result carries a concrete remediation hint.
+ *
+ * Thresholds are always supplied by the caller so freshness policy lives with
+ * the pipe it describes, not in this file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CLOCK_SKEW_TOLERANCE_MS = exports.FRESHNESS_DAY_MS = exports.FRESHNESS_HOUR_MS = exports.FRESHNESS_MINUTE_MS = void 0;
+exports.formatFreshnessAge = formatFreshnessAge;
+exports.formatFreshnessTimestamp = formatFreshnessTimestamp;
+exports.evaluateFreshness = evaluateFreshness;
+exports.observeCreatePerEventStore = observeCreatePerEventStore;
+exports.observeAppendPerEventStore = observeAppendPerEventStore;
+exports.resolveFreshnessThresholds = resolveFreshnessThresholds;
+const runtime_1 = require("../../nerves/runtime");
+exports.FRESHNESS_MINUTE_MS = 60 * 1000;
+exports.FRESHNESS_HOUR_MS = 60 * exports.FRESHNESS_MINUTE_MS;
+exports.FRESHNESS_DAY_MS = 24 * exports.FRESHNESS_HOUR_MS;
+/** Small tolerance before a future timestamp is treated as clock skew. */
+exports.DEFAULT_CLOCK_SKEW_TOLERANCE_MS = exports.FRESHNESS_MINUTE_MS;
+/**
+ * Human-readable duration. Always rounds down so the age is never overstated:
+ * "77 days" means at least 77 days have elapsed.
+ */
+function formatFreshnessAge(ms) {
+    const clamped = Math.max(0, ms);
+    const seconds = Math.floor(clamped / 1000);
+    if (seconds < 60)
+        return `${seconds} second${seconds === 1 ? "" : "s"}`;
+    const minutes = Math.floor(clamped / exports.FRESHNESS_MINUTE_MS);
+    if (minutes < 60)
+        return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+    const hours = Math.floor(clamped / exports.FRESHNESS_HOUR_MS);
+    if (hours < 48)
+        return `${hours} hour${hours === 1 ? "" : "s"}`;
+    // The day bucket only starts at 48h, so it is always plural.
+    return `${Math.floor(clamped / exports.FRESHNESS_DAY_MS)} days`;
+}
+/** Minute-precision ISO instant — keeps the incident date visible and unambiguous. */
+function formatFreshnessTimestamp(ms) {
+    return new Date(ms).toISOString().replace(/:\d{2}\.\d{3}Z$/, "Z");
+}
+function joinDetail(parts) {
+    return parts.filter((part) => !!part && part.trim().length > 0).join("; ");
+}
+function statusForAge(ageMs, thresholds) {
+    if (ageMs >= thresholds.failAfterMs)
+        return "fail";
+    if (ageMs >= thresholds.warnAfterMs)
+        return "warn";
+    return "pass";
+}
+/**
+ * Severity for "readable store, nothing ever recorded".
+ *
+ * Floors at `warn` on purpose: a configured-but-never-delivered pipe is never
+ * healthy, but a pipe wired up minutes ago does not deserve a hard failure.
+ */
+function statusForNever(input) {
+    const since = input.configuredSinceMs;
+    if (typeof since !== "number" || !Number.isFinite(since)) {
+        return { status: "fail", configuredForMs: null };
+    }
+    const configuredForMs = Math.max(0, input.nowMs - since);
+    const escalated = statusForAge(configuredForMs, input.thresholds);
+    return { status: escalated === "pass" ? "warn" : escalated, configuredForMs };
+}
+function evaluateActivity(input, atMs) {
+    const tolerance = input.clockSkewToleranceMs ?? exports.DEFAULT_CLOCK_SKEW_TOLERANCE_MS;
+    const skewMs = atMs - input.nowMs;
+    const timestamp = formatFreshnessTimestamp(atMs);
+    if (skewMs > tolerance) {
+        return {
+            status: "warn",
+            state: "future",
+            ageMs: 0,
+            detail: joinDetail([
+                input.context,
+                `last ${input.unit} is timestamped ${timestamp}, ${formatFreshnessAge(skewMs)} in the future — clock skew means freshness cannot be trusted`,
+                input.provenance,
+                `fix: ${input.remediation}`,
+            ]),
+        };
+    }
+    const ageMs = Math.max(0, -skewMs);
+    const status = statusForAge(ageMs, input.thresholds);
+    if (status === "pass") {
+        return {
+            status,
+            state: "fresh",
+            ageMs,
+            detail: joinDetail([
+                input.context,
+                `${input.activity} ${formatFreshnessAge(ageMs)} ago (last ${input.unit} ${timestamp})`,
+                input.provenance,
+            ]),
+        };
+    }
+    return {
+        status,
+        state: "stale",
+        ageMs,
+        detail: joinDetail([
+            input.context,
+            `no ${input.activity} in ${formatFreshnessAge(ageMs)} — last ${input.unit} ${timestamp}`,
+            input.provenance,
+            `fix: ${input.remediation}`,
+        ]),
+    };
+}
+/**
+ * Turn a single observation into a status + actionable detail.
+ *
+ * The only path that can return `pass` is an observed activity timestamp
+ * inside the warn threshold. Everything else — no activity, unreadable store,
+ * skewed clock — is surfaced, never swallowed.
+ */
+function evaluateFreshness(input) {
+    const observation = input.observation;
+    if (observation.kind === "unknown") {
+        return {
+            status: "fail",
+            state: "unknown",
+            ageMs: null,
+            detail: joinDetail([
+                input.context,
+                `${input.activity}: last-activity time could not be determined — ${observation.reason}; unverified, not healthy`,
+                input.provenance,
+                `fix: ${input.remediation}`,
+            ]),
+        };
+    }
+    if (observation.kind === "none") {
+        const { status, configuredForMs } = statusForNever(input);
+        return {
+            status,
+            state: "never",
+            ageMs: null,
+            detail: joinDetail([
+                input.context,
+                configuredForMs === null
+                    ? `no ${input.activity} ever — the store is readable and empty`
+                    : `no ${input.activity} ever — the store is readable and empty, and this pipe has been configured for ${formatFreshnessAge(configuredForMs)}`,
+                input.provenance,
+                `fix: ${input.remediation}`,
+            ]),
+        };
+    }
+    if (!Number.isFinite(observation.atMs)) {
+        return evaluateFreshness({
+            ...input,
+            observation: { kind: "unknown", reason: `observed timestamp is not a finite epoch-ms value (${String(observation.atMs)})` },
+        });
+    }
+    return evaluateActivity(input, observation.atMs);
+}
+/**
+ * Last-write probe for **create-per-event** stores — one new file per event,
+ * such as the mailroom's `messages/<id>.json`.
+ *
+ * A directory's mtime advances whenever an entry is created or removed, so it
+ * is an exact answer to "when was a file last added here" for O(1) cost, with
+ * no per-entry stat. That matters: the production mailroom holds ~45k message
+ * files and must never be stat-walked by a health check.
+ *
+ * It is also the semantically *correct* signal here. A message's `receivedAt`
+ * is when the mail was sent, not when this machine ingested it — an mbox
+ * backfill writes month-old `receivedAt` values today — so parsing message
+ * bodies would answer a different question than "is the pipe moving?".
+ *
+ * `hasEntries` is supplied by the caller (which typically already lists the
+ * directory for a count) so an empty directory reports `none` rather than
+ * reporting its own creation time as activity.
+ */
+function observeCreatePerEventStore(dir, deps, options) {
+    const provenance = `derived from ${dir} directory mtime (O(1), no per-entry scan)`;
+    if (!deps.existsSync(dir)) {
+        return { observation: { kind: "none" }, provenance: `${dir} does not exist` };
+    }
+    if (!options.hasEntries) {
+        return { observation: { kind: "none" }, provenance: `${dir} is empty` };
+    }
+    try {
+        return { observation: { kind: "activity", atMs: deps.statSync(dir).mtimeMs }, provenance };
+    }
+    catch (error) {
+        return {
+            observation: { kind: "unknown", reason: `${dir} could not be stat'd: ${error instanceof Error ? error.message : String(error)}` },
+            provenance,
+        };
+    }
+}
+/**
+ * Last-write probe for **append-per-event** stores — a small set of long-lived
+ * logs appended in place, such as the BlueBubbles inbound ndjson (one file per
+ * chat).
+ *
+ * Directory mtime is the wrong signal here: appending to an existing file does
+ * not touch its parent directory, so a busy-but-not-growing log set would look
+ * frozen. This stats each matching entry and takes the newest.
+ *
+ * The scan is bounded by `maxEntries`. When the bound is hit the provenance
+ * says so explicitly — a bounded scan must never masquerade as exhaustive.
+ */
+function observeAppendPerEventStore(dir, deps, options) {
+    if (!deps.existsSync(dir)) {
+        return { observation: { kind: "none" }, provenance: `${dir} does not exist` };
+    }
+    let entries;
+    try {
+        entries = deps.readdirSync(dir).filter((name) => name.endsWith(options.suffix));
+    }
+    catch (error) {
+        return {
+            observation: { kind: "unknown", reason: `${dir} could not be listed: ${error instanceof Error ? error.message : String(error)}` },
+            provenance: `attempted directory listing of ${dir}`,
+        };
+    }
+    if (entries.length === 0) {
+        return { observation: { kind: "none" }, provenance: `${dir} holds no ${options.suffix} logs` };
+    }
+    const scanned = entries.slice(0, options.maxEntries);
+    const truncated = entries.length > scanned.length;
+    const provenance = truncated
+        ? `newest mtime across the first ${scanned.length} of ${entries.length} ${options.suffix} logs in ${dir} — scan bounded, newer activity may exist in the unscanned ${entries.length - scanned.length}`
+        : `newest mtime across ${scanned.length} ${options.suffix} log${scanned.length === 1 ? "" : "s"} in ${dir}`;
+    let newest = Number.NEGATIVE_INFINITY;
+    const failures = [];
+    for (const name of scanned) {
+        try {
+            const mtimeMs = deps.statSync(`${dir}/${name}`).mtimeMs;
+            if (mtimeMs > newest)
+                newest = mtimeMs;
+        }
+        catch (error) {
+            failures.push(`${name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (newest === Number.NEGATIVE_INFINITY) {
+        return {
+            observation: { kind: "unknown", reason: `none of the ${scanned.length} log(s) in ${dir} could be stat'd: ${failures.slice(0, 3).join("; ")}` },
+            provenance,
+        };
+    }
+    return {
+        observation: { kind: "activity", atMs: newest },
+        provenance: failures.length > 0 ? `${provenance} (${failures.length} unreadable and skipped)` : provenance,
+    };
+}
+/**
+ * Merge an `agent.json` override onto in-repo defaults.
+ *
+ * Configuration lives in a committed config file rather than an environment
+ * variable, per the repo configuration policy. Non-positive and non-finite
+ * values are ignored so a malformed override can never disable the check.
+ */
+function resolveFreshnessThresholds(defaults, override) {
+    const record = override && typeof override === "object" && !Array.isArray(override)
+        ? override
+        : null;
+    const hours = (key) => {
+        const value = record?.[key];
+        return typeof value === "number" && Number.isFinite(value) && value > 0 ? value * exports.FRESHNESS_HOUR_MS : null;
+    };
+    return {
+        warnAfterMs: hours("warnAfterHours") ?? defaults.warnAfterMs,
+        failAfterMs: hours("failAfterHours") ?? defaults.failAfterMs,
+    };
+}
+/* v8 ignore start -- module load observability event */
+(0, runtime_1.emitNervesEvent)({
+    component: "daemon",
+    event: "daemon.pipeline_freshness_loaded",
+    message: "pipeline freshness primitive loaded",
+    meta: {},
+});
+/* v8 ignore stop */

package/dist/heart/habits/habit-session.js

@@ -460,10 +460,11 @@ function computeNextRunAt(habit, endedAt) {
 }
 function defaultSummarySnapshot(input) {
     const errors = input.errors ?? [];
+    const decisions = (0, flight_recorder_1.decisionsFromHabitRunTraceSteps)(input.traceSteps);
     if (errors.length > 0) {
         return {
             summary: `Habit ${input.habit.name} finished with errors: ${errors.join("; ")}`,
-            decisions: [],
+            decisions,
             nextLikelyStep: null,
         };
     }
@@ -471,7 +472,7 @@ function defaultSummarySnapshot(input) {
     if (surfaced) {
         return {
             summary: `Habit ${input.habit.name} surfaced via ${surfaced.recipient}/${surfaced.channel}.`,
-            decisions: [],
+            decisions,
             nextLikelyStep: null,
         };
     }
@@ -479,13 +480,13 @@ function defaultSummarySnapshot(input) {
     if (produced) {
         return {
             summary: `Habit ${input.habit.name} produced ${produced.kind}: ${produced.locator}.`,
-            decisions: [],
+            decisions,
             nextLikelyStep: null,
         };
     }
     return {
         summary: `Habit ${input.habit.name} finished with ${input.outcome}.`,
-        decisions: [],
+        decisions,
         nextLikelyStep: null,
     };
 }
@@ -512,6 +513,7 @@ function buildHabitRunReceipt(input) {
         summarySnapshot: input.summarySnapshot ?? defaultSummarySnapshot(input),
         producedRefs: input.producedRefs ?? [],
         surfaceAttempts: input.surfaceAttempts ?? [],
+        traceSteps: input.traceSteps ?? [],
         errors: input.errors ?? [],
     };
     (0, runtime_1.emitNervesEvent)({
@@ -572,6 +574,7 @@ function completeHabitRun(input) {
             toolPolicy: input.toolPolicy,
             producedRefs,
             surfaceAttempts: input.surfaceAttempts,
+            traceSteps: input.traceSteps,
             errors: input.errors,
             summarySnapshot: input.summarySnapshot,
         });

package/dist/heart/mailbox/mailbox-http-hooks.js

@@ -86,6 +86,8 @@ function createMailboxHttpReadHooks(options) {
         readAgentHabitRun: options.readAgentHabitRun ?? ((agentName, runId) => (0, mailbox_read_1.readHabitRunReceiptView)(agentRoot(agentName), runId)),
         readAgentHabitRunSummaries: options.readAgentHabitRunSummaries ?? ((agentName, habitOptions) => (0, mailbox_read_1.readHabitSessionSummaryListView)(agentRoot(agentName), habitOptions)),
         readAgentHabitRunSummary: options.readAgentHabitRunSummary ?? ((agentName, selector) => (0, mailbox_read_1.readHabitSessionSummaryView)(agentRoot(agentName), selector)),
+        readAgentContextPackets: options.readAgentContextPackets ?? ((agentName, packetOptions) => (0, mailbox_read_1.readContextPacketListView)(agentRoot(agentName), packetOptions)),
+        readAgentContextPacket: options.readAgentContextPacket ?? ((agentName, packetId) => (0, mailbox_read_1.readContextPacketView)(agentRoot(agentName), packetId)),
         readAgentMail: options.readAgentMail ?? ((agentName) => (0, mailbox_read_1.readMailView)(agentName)),
         readAgentMailMessage: options.readAgentMailMessage ?? ((agentName, messageId) => (0, mailbox_read_1.readMailMessageView)(agentName, messageId)),
         readDaemonHealth: options.readDaemonHealth ?? (() => (0, mailbox_read_1.readDaemonHealthDeep)(options.healthPath)),

package/dist/heart/mailbox/mailbox-http-routes.js

@@ -321,6 +321,29 @@ async function handleAgentRoute(request, response, context) {
         (0, mailbox_http_response_1.writeJson)(response, 200, view);
         return;
     }
+    if (surface === "context-packets") {
+        const limit = parseHabitRunLimit(request.url);
+        if (limit === null) {
+            (0, mailbox_http_response_1.writeJson)(response, 400, { ok: false, error: "limit must be an integer between 1 and 100" });
+            return;
+        }
+        const view = limit === undefined
+            ? options.hooks.readAgentContextPackets(agent)
+            : options.hooks.readAgentContextPackets(agent, { limit });
+        (0, mailbox_http_response_1.writeJson)(response, 200, view);
+        return;
+    }
+    if (surface.startsWith("context-packets/")) {
+        const rawPacketId = surface.slice("context-packets/".length);
+        const packetId = decodePathSegment(rawPacketId);
+        const view = packetId ? options.hooks.readAgentContextPacket(agent, packetId) : null;
+        if (!view) {
+            (0, mailbox_http_response_1.writeJson)(response, 404, { ok: false, error: `context packet '${rawPacketId}' not found` });
+            return;
+        }
+        (0, mailbox_http_response_1.writeJson)(response, 200, view);
+        return;
+    }
     if (surface === "mail") {
         (0, mailbox_http_response_1.writeJson)(response, 200, await options.hooks.readAgentMail(agent));
         return;

package/dist/heart/mailbox/mailbox-read.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readSelfFixView = exports.readMailboxContinuity = exports.readOrientationView = exports.readObligationDetailView = exports.readNoteDecisionView = exports.readSentinelView = exports.readContextLossGauntletView = exports.readChangesView = exports.readNeedsMeView = exports.readNotesView = exports.readLogView = exports.readHabitView = exports.readHabitRunView = exports.readHabitRunReceiptView = exports.readHabitSessionSummaryView = exports.readHabitSessionSummaryListView = exports.readFriendView = exports.readDeskPrefs = exports.readDaemonHealthDeep = exports.readCodingDeep = exports.readBridgeInventory = exports.readAttentionView = exports.readMailView = exports.readMailMessageView = exports.readSessionTranscript = exports.readSessionInventory = exports.readMailboxMachineState = exports.readMailboxAgentState = exports.readObligationSummary = void 0;
+exports.readSelfFixView = exports.readMailboxContinuity = exports.readOrientationView = exports.readObligationDetailView = exports.readNoteDecisionView = exports.readSentinelView = exports.readContextLossGauntletView = exports.readChangesView = exports.readNeedsMeView = exports.readNotesView = exports.readLogView = exports.readContextPacketView = exports.readContextPacketListView = exports.readHabitView = exports.readHabitRunView = exports.readHabitRunReceiptView = exports.readHabitSessionSummaryView = exports.readHabitSessionSummaryListView = exports.readFriendView = exports.readDeskPrefs = exports.readDaemonHealthDeep = exports.readCodingDeep = exports.readBridgeInventory = exports.readAttentionView = exports.readMailView = exports.readMailMessageView = exports.readSessionTranscript = exports.readSessionInventory = exports.readMailboxMachineState = exports.readMailboxAgentState = exports.readObligationSummary = void 0;
 var agent_machine_1 = require("./readers/agent-machine");
 Object.defineProperty(exports, "readObligationSummary", { enumerable: true, get: function () { return agent_machine_1.readObligationSummary; } });
 Object.defineProperty(exports, "readMailboxAgentState", { enumerable: true, get: function () { return agent_machine_1.readMailboxAgentState; } });
@@ -23,6 +23,8 @@ Object.defineProperty(exports, "readHabitSessionSummaryView", { enumerable: true
 Object.defineProperty(exports, "readHabitRunReceiptView", { enumerable: true, get: function () { return runtime_readers_1.readHabitRunReceiptView; } });
 Object.defineProperty(exports, "readHabitRunView", { enumerable: true, get: function () { return runtime_readers_1.readHabitRunView; } });
 Object.defineProperty(exports, "readHabitView", { enumerable: true, get: function () { return runtime_readers_1.readHabitView; } });
+Object.defineProperty(exports, "readContextPacketListView", { enumerable: true, get: function () { return runtime_readers_1.readContextPacketListView; } });
+Object.defineProperty(exports, "readContextPacketView", { enumerable: true, get: function () { return runtime_readers_1.readContextPacketView; } });
 Object.defineProperty(exports, "readLogView", { enumerable: true, get: function () { return runtime_readers_1.readLogView; } });
 Object.defineProperty(exports, "readNotesView", { enumerable: true, get: function () { return runtime_readers_1.readNotesView; } });
 Object.defineProperty(exports, "readNeedsMeView", { enumerable: true, get: function () { return runtime_readers_1.readNeedsMeView; } });

package/dist/heart/mailbox/readers/runtime-readers.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readCodingDeep = readCodingDeep;
 exports.readAttentionView = readAttentionView;
+exports.readContextPacketListView = readContextPacketListView;
+exports.readContextPacketView = readContextPacketView;
 exports.readBridgeInventory = readBridgeInventory;
 exports.readDaemonHealthDeep = readDaemonHealthDeep;
 exports.readNotesView = readNotesView;
@@ -56,6 +58,7 @@ const habit_session_summary_1 = require("../../habits/habit-session-summary");
 const identity_1 = require("../../identity");
 const daemon_health_1 = require("../../daemon/daemon-health");
 const flight_recorder_1 = require("../../../arc/flight-recorder");
+const context_packet_ledger_1 = require("../../../senses/context-packet-ledger");
 const shared_1 = require("./shared");
 const agent_machine_1 = require("./agent-machine");
 const sessions_1 = require("./sessions");
@@ -217,6 +220,12 @@ function readAttentionView(agentName, options = {}) {
         returnObligations,
     };
 }
+function readContextPacketListView(agentRoot, options = {}) {
+    return (0, context_packet_ledger_1.listSenseContextPacketSummaries)(agentRoot, options);
+}
+function readContextPacketView(agentRoot, packetId) {
+    return (0, context_packet_ledger_1.readSenseContextPacketView)(agentRoot, packetId);
+}
 /* v8 ignore start — defensive parsing */
 function readBridgeInventory(agentRoot) {
     const bridgesDir = path.join(agentRoot, "state", "bridges");

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

@@ -44,6 +44,7 @@ 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");
 }
@@ -127,13 +128,33 @@ function producedRefsFor(payload) {
     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) {
@@ -153,6 +174,140 @@ function payloadError(payload) {
     }
     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,
@@ -247,6 +402,7 @@ async function runNativeRsvpHabit(input) {
     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,
@@ -258,6 +414,20 @@ async function runNativeRsvpHabit(input) {
         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,
@@ -268,17 +438,15 @@ async function runNativeRsvpHabit(input) {
         operationId: `rsvp-native:${input.trigger}:${input.occurrenceId ?? runId}`,
         permissionEnvelope: permissionEnvelope(policy.sendAllowed),
         toolPolicy: toolPolicy(policy.sendAllowed),
-        producedRefs: producedRefsFor(payload),
+        producedRefs,
         surfaceAttempts,
+        traceSteps,
         errors,
         summarySnapshot: {
             summary: errorMessage
                 ? `Native RSVP habit failed: ${errorMessage}`
                 : "Native RSVP habit completed.",
-            decisions: [
-                `mode=${habit.rsvp.mode}`,
-                `sendAllowed=${String(policy.sendAllowed)}`,
-            ],
+            decisions: (0, flight_recorder_1.decisionsFromHabitRunTraceSteps)(traceSteps),
             nextLikelyStep: null,
         },
     });