@ouro.bot/cli 0.1.0-alpha.657 → 0.1.0-alpha.658

package/dist/senses/habit-turn-message.js

@@ -11,8 +11,9 @@ function formatElapsed(ms) {
     return `${hours} ${hours === 1 ? "hour" : "hours"}`;
 }
 function buildHabitTurnMessage(options) {
-    const { habitName, habitTitle, habitBody, lastRun, checkpoint, alsoDue, staleObligations, parseErrors, degradedComponents, now, } = options;
+    const { habitName, habitTitle, habitBody, lastRun, checkpoint, alsoDue, staleObligations, parseErrors, degradedComponents, arcResume, deskOrientation, surfacePolicy, now, } = options;
     const hasBody = habitBody !== undefined && habitBody !== "";
+    const leadingSections = buildLeadingSections(arcResume, deskOrientation, surfacePolicy);
     // First beat: lastRun is null
     if (lastRun === null) {
         // Cold start: no checkpoint, no body — bare awareness
@@ -23,7 +24,7 @@ function buildHabitTurnMessage(options) {
                 message: "habit turn message built (cold start)",
                 meta: { habitName, coldStart: true },
             });
-            return "...time passing. anything stirring?";
+            return joinSections(leadingSections, ["...time passing. anything stirring?"]);
         }
         if (!hasBody) {
             // First beat with no body: nudge
@@ -37,7 +38,7 @@ function buildHabitTurnMessage(options) {
                 message: "habit turn message built (first beat, no body)",
                 meta: { habitName, firstBeat: true, hasBody: false },
             });
-            return sections.join("\n\n");
+            return joinSections(leadingSections, sections);
         }
         const sections = [
             `your ${habitTitle} is alive. this is its first breath.`,
@@ -50,7 +51,7 @@ function buildHabitTurnMessage(options) {
             message: "habit turn message built (first beat)",
             meta: { habitName, firstBeat: true },
         });
-        return sections.join("\n\n");
+        return joinSections(leadingSections, sections);
     }
     // Normal turn
     const sections = [];
@@ -83,7 +84,20 @@ function buildHabitTurnMessage(options) {
             staleObligationCount: staleObligations.length,
         },
     });
-    return sections.join("\n\n");
+    return joinSections(leadingSections, sections);
+}
+function buildLeadingSections(arcResume, deskOrientation, surfacePolicy) {
+    const sections = [];
+    if (arcResume?.trim())
+        sections.push(arcResume.trim());
+    if (deskOrientation?.trim())
+        sections.push(deskOrientation.trim());
+    if (surfacePolicy?.trim())
+        sections.push(surfacePolicy.trim());
+    return sections;
+}
+function joinSections(leadingSections, sections) {
+    return [...leadingSections, ...sections].filter((section) => section.trim().length > 0).join("\n\n");
 }
 function appendTrailingExtras(sections, alsoDue, staleObligations, parseErrors, degradedComponents) {
     // 4. Also-due

package/dist/senses/inner-dialog-worker.js

@@ -42,6 +42,7 @@ const runtime_1 = require("../nerves/runtime");
 const identity_1 = require("../heart/identity");
 const pending_1 = require("../mind/pending");
 const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
+const flight_recorder_1 = require("../arc/flight-recorder");
 /**
  * Cap on consecutive `instinct` follow-on turns triggered by `hasPendingWork()`
  * with no externally-queued work in between. Without this cap, a turn that
@@ -88,12 +89,52 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
     const lastFireByHabit = new Map();
     const recentHabitFires = [];
     let heartbeatOkRestedAt = null;
-    function recordHabitCompletion(habitName) {
+    function habitOutcomeForTurn(result, errors) {
+        if (errors.length > 0)
+            return { outcome: "error", producedRefs: [] };
+        const toolNames = new Set();
+        if (result && typeof result === "object" && Array.isArray(result.messages)) {
+            for (const message of result.messages) {
+                const toolCalls = message.tool_calls;
+                if (!Array.isArray(toolCalls))
+                    continue;
+                for (const call of toolCalls) {
+                    const functionName = call.function?.name;
+                    if (typeof functionName === "string")
+                        toolNames.add(functionName);
+                }
+            }
+        }
+        if (toolNames.has("send_message") || toolNames.has("surface")) {
+            return { outcome: "surfaced", producedRefs: [{ kind: "surface", locator: "tool:send_message_or_surface" }] };
+        }
+        if (toolNames.has("diary_write") || toolNames.has("note")) {
+            return { outcome: "wrote_record", producedRefs: [{ kind: "desk_record", locator: "desk/_record" }] };
+        }
+        if ([...toolNames].some((name) => name.startsWith("mcp__desk__"))) {
+            return { outcome: "updated_desk", producedRefs: [{ kind: "desk_task", locator: "desk/" }] };
+        }
+        return { outcome: "no_change", producedRefs: [] };
+    }
+    function recordHabitCompletion(habitName, startedAt = new Date(nowSource()).toISOString(), endedAt = startedAt, trigger = "overdue", result, errors = []) {
         try {
             const agentRoot = (0, identity_1.getAgentRoot)();
-            (0, habit_runtime_state_1.recordHabitRun)(agentRoot, habitName, new Date(nowSource()).toISOString(), {
+            (0, habit_runtime_state_1.recordHabitRun)(agentRoot, habitName, endedAt, {
                 definitionPath: path.join(agentRoot, "habits", `${habitName}.md`),
             });
+            const { outcome, producedRefs } = habitOutcomeForTurn(result, errors);
+            (0, flight_recorder_1.writeHabitRunReceipt)(agentRoot, {
+                schemaVersion: 1,
+                runId: (0, flight_recorder_1.createHabitRunId)(habitName, new Date(startedAt)),
+                habitName,
+                trigger,
+                startedAt,
+                endedAt,
+                outcome,
+                producedRefs,
+                surfaceAttempts: [],
+                errors,
+            });
         }
         catch {
             // Habit file/state may be unavailable during the turn — skip gracefully
@@ -114,7 +155,8 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
         return true;
     }
     function reuseHeartbeatOkRest(habitName) {
-        recordHabitCompletion(habitName);
+        const nowIso = new Date(nowSource()).toISOString();
+        recordHabitCompletion(habitName, nowIso, nowIso, "overdue", { turnOutcome: "rested", restStatus: "HEARTBEAT_OK" });
         (0, runtime_1.emitNervesEvent)({
             level: "info",
             component: "senses",
@@ -166,9 +208,9 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
             });
         }
     }
-    async function run(reason, taskId, habitName, awaitName) {
+    async function run(reason, taskId, habitName, awaitName, trigger) {
         if (running) {
-            queue.push({ reason, taskId, habitName, awaitName });
+            queue.push({ reason, taskId, habitName, awaitName, trigger });
             return;
         }
         running = true;
@@ -177,10 +219,14 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
             let nextTaskId = taskId;
             let nextHabitName = habitName;
             let nextAwaitName = awaitName;
+            let nextTrigger = trigger;
             let consecutiveInstinctTurns = reason === "instinct" ? 1 : 0;
             runLoop: do {
                 const currentReason = nextReason;
                 const currentHabitName = nextHabitName;
+                const currentTrigger = nextTrigger ?? "overdue";
+                const habitStartedAt = currentReason === "habit" && currentHabitName ? new Date(nowSource()).toISOString() : null;
+                const turnErrors = [];
                 if (!(currentReason === "habit" && currentHabitName === "heartbeat")) {
                     clearHeartbeatRestShield();
                 }
@@ -190,6 +236,7 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
                 }
                 catch (error) {
                     clearHeartbeatRestShield();
+                    turnErrors.push(error instanceof Error ? error.message : String(error));
                     (0, runtime_1.emitNervesEvent)({
                         level: "error",
                         component: "senses",
@@ -205,8 +252,8 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
                     heartbeatOkRestedAt = isHeartbeatOkRestResult(turnResult) ? nowSource() : null;
                 }
                 // Record lastRun after a habit turn without dirtying the tracked habit file.
-                if (nextReason === "habit" && nextHabitName) {
-                    recordHabitCompletion(nextHabitName);
+                if (currentReason === "habit" && currentHabitName && habitStartedAt) {
+                    recordHabitCompletion(currentHabitName, habitStartedAt, new Date(nowSource()).toISOString(), currentTrigger, turnResult, turnErrors);
                 }
                 // Drain queue first. Externally-queued work resets the instinct cap
                 // because a real outside trigger arrived between turns.
@@ -223,6 +270,7 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
                     nextTaskId = next.taskId;
                     nextHabitName = next.habitName;
                     nextAwaitName = next.awaitName;
+                    nextTrigger = next.trigger;
                     consecutiveInstinctTurns = nextReason === "instinct" ? consecutiveInstinctTurns + 1 : 0;
                     continue runLoop;
                 }
@@ -251,6 +299,7 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
                     nextTaskId = undefined;
                     nextHabitName = undefined;
                     nextAwaitName = undefined;
+                    nextTrigger = undefined;
                     continue;
                 }
                 break;
@@ -272,7 +321,7 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
                 return;
             }
             recordHabitFireForRecursion(habitName);
-            await run("habit", undefined, maybeMessage.habitName);
+            await run("habit", undefined, maybeMessage.habitName, undefined, maybeMessage.trigger ?? "overdue");
             return;
         }
         if (maybeMessage.type === "await") {
@@ -290,7 +339,7 @@ function createInnerDialogWorker(runTurn = (options) => (0, inner_dialog_1.runIn
                 return;
             }
             recordHabitFireForRecursion("heartbeat");
-            await run("habit", undefined, "heartbeat");
+            await run("habit", undefined, "heartbeat", undefined, "overdue");
             return;
         }
         if (maybeMessage.type === "poke") {

package/dist/senses/inner-dialog.js

@@ -73,11 +73,12 @@ const habit_turn_message_1 = require("./habit-turn-message");
 const await_turn_message_1 = require("./await-turn-message");
 const await_parser_1 = require("../heart/awaiting/await-parser");
 const await_runtime_state_1 = require("../heart/awaiting/await-runtime-state");
-const journal_index_1 = require("../mind/journal-index");
 const habit_parser_1 = require("../heart/habits/habit-parser");
 const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
 const cadence_1 = require("../heart/daemon/cadence");
 const daemon_health_1 = require("../heart/daemon/daemon-health");
+const flight_recorder_1 = require("../arc/flight-recorder");
+const desk_section_1 = require("../mind/desk-section");
 const DEFAULT_INNER_DIALOG_INSTINCTS = [
     {
         id: "heartbeat_checkin",
@@ -627,6 +628,20 @@ function buildAlsoDueLine(agentRoot, currentHabitName, now) {
         return "";
     return `also due: ${alsoDue.join(", ")}`;
 }
+function buildHabitSurfacePolicy(origin, surface) {
+    const lines = ["## habit surface policy"];
+    lines.push("this habit runs privately, but it may message outward when it needs input, has a useful answer, is blocked, or should report status.");
+    if (surface.family)
+        lines.push("- family recipients are allowed by default.");
+    if (surface.originator && origin)
+        lines.push(`- the originator is allowed: ${origin.friendId} via ${origin.channel}/${origin.key}.`);
+    if (surface.originator && !origin)
+        lines.push("- originator messaging is enabled, but this habit has no origin metadata.");
+    if (surface.extra.length > 0)
+        lines.push(`- extra allowed recipients: ${surface.extra.join(", ")}.`);
+    lines.push("- use send_message for intentional contact; use surface only for a held return tied to an existing return obligation.");
+    return lines.join("\n");
+}
 async function runInnerDialogTurn(options) {
     const now = options?.now ?? (() => new Date());
     const reason = options?.reason ?? "instinct";
@@ -681,6 +696,8 @@ async function runInnerDialogTurn(options) {
                 let habitBody;
                 let habitTitle = habitName;
                 let habitLastRun = null;
+                let habitOrigin = null;
+                let habitSurface = { family: true, originator: true, extra: [] };
                 try {
                     const habitContent = fs.readFileSync(habitFilePath, "utf-8");
                     const parsed = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(habitContent, habitFilePath));
@@ -688,6 +705,8 @@ async function runInnerDialogTurn(options) {
                     habitTitle = parsed.title || habitName;
                     habitLastRun = parsed.lastRun;
                     habitTools = parsed.tools;
+                    habitOrigin = parsed.origin;
+                    habitSurface = parsed.surface;
                 }
                 catch {
                     // Habit file missing or unreadable
@@ -707,6 +726,9 @@ async function runInnerDialogTurn(options) {
                         stalenessMs: nowMs - o.createdAt,
                     }));
                     const alsoDue = buildAlsoDueLine(agentRoot, habitName, now);
+                    const arcResume = (0, flight_recorder_1.formatFlightRecorderResume)((0, flight_recorder_1.readFlightRecorderResume)(agentRoot));
+                    const deskOrientation = (0, desk_section_1.deskRecordOrientationSection)(agentRoot, now());
+                    const surfacePolicy = buildHabitSurfacePolicy(habitOrigin, habitSurface);
                     // Degraded state (best-effort: never crash)
                     let degradedComponents = [];
                     try {
@@ -728,17 +750,11 @@ async function runInnerDialogTurn(options) {
                         staleObligations,
                         parseErrors: options?.parseErrors ?? [],
                         degradedComponents,
+                        arcResume,
+                        deskOrientation,
+                        surfacePolicy,
                         now,
                     });
-                    // Piggyback journal embedding indexing (best-effort, fire-and-forget)
-                    const journalDir = path.join(agentRoot, "journal");
-                    /* v8 ignore start -- journal indexing piggyback: embedding provider may not be available; tested via journal-index unit tests @preserve */
-                    void (0, journal_index_1.indexJournalFiles)(journalDir, path.join(journalDir, ".index.json"), {
-                        embed: async () => [],
-                    }).catch(() => {
-                        // swallowed: indexing failure must never block habit turn
-                    });
-                    /* v8 ignore stop */
                 }
             }
             else if (reason === "await" && options?.awaitName) {
@@ -827,7 +843,10 @@ async function runInnerDialogTurn(options) {
                     };
                 }
                 // Fresh session: build system prompt
-                const systemPrompt = await (0, prompt_1.buildSystem)("inner", { toolChoiceRequired: true });
+                const systemPrompt = await (0, prompt_1.buildSystem)("inner", {
+                    toolChoiceRequired: true,
+                    flightRecorderResume: (0, flight_recorder_1.readFlightRecorderResume)((0, identity_1.getAgentRoot)()),
+                });
                 return {
                     messages: [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(systemPrompt) }],
                     sessionPath: sessionFilePath,

package/dist/senses/pipeline.js

@@ -52,6 +52,8 @@ const socket_client_1 = require("../heart/daemon/socket-client");
 const active_work_1 = require("../heart/active-work");
 const delegation_1 = require("../heart/delegation");
 const obligations_1 = require("../arc/obligations");
+const packets_1 = require("../arc/packets");
+const evolution_1 = require("../arc/evolution");
 const provider_failover_1 = require("../heart/provider-failover");
 const openai_codex_token_1 = require("../heart/providers/openai-codex-token");
 const tempo_1 = require("../heart/tempo");
@@ -66,7 +68,16 @@ const episodes_1 = require("../arc/episodes");
 const turn_context_1 = require("../heart/turn-context");
 const provider_visibility_1 = require("../heart/provider-visibility");
 const orientation_frame_1 = require("../heart/orientation-frame");
+const flight_recorder_1 = require("../arc/flight-recorder");
 const VOICE_PENDING_MAX_AGE_MS = 15 * 60 * 1_000;
+const ACTIVE_FLIGHT_RECORDER_PACKET_STATUSES = new Set([
+    "drafting",
+    "processing",
+    "validating",
+    "collaborating",
+    "paused",
+    "blocked",
+]);
 function pendingExpirationReason(channel, message, now) {
     /* v8 ignore start -- pending expiry edge permutations are covered by the stale voice queue tests; this helper keeps defensive non-voice fallbacks @preserve */
     if (Number.isFinite(message.expiresAt) && Number(message.expiresAt) <= now)
@@ -198,6 +209,65 @@ function latestUserAuthoredText(messages, continuityIngressTexts) {
         .filter(Boolean);
     return userMessages[userMessages.length - 1];
 }
+function sessionRefForFlightRecorder(session) {
+    return `${session.friendId}/${session.channel}/${session.key}`;
+}
+function isTerminalWithoutContinuation(outcome, hasActiveContinuation) {
+    return !hasActiveContinuation && (outcome === "settled"
+        || outcome === "observed"
+        || outcome === "rested"
+        || outcome === "superseded");
+}
+function readPostTurnFlightRecorderArcSnapshot(agentRoot) {
+    const latest = (0, flight_recorder_1.readFlightRecorderResume)(agentRoot);
+    return {
+        activeObligationIds: (0, obligations_1.readPendingObligations)(agentRoot).map((obligation) => obligation.id),
+        activeReturnObligationIds: (0, obligations_1.listActiveReturnObligationsForRoot)(agentRoot).map((obligation) => obligation.id),
+        activePacketIds: (0, packets_1.listPonderPackets)(agentRoot)
+            .filter((packet) => ACTIVE_FLIGHT_RECORDER_PACKET_STATUSES.has(packet.status))
+            .map((packet) => packet.id),
+        openEvolutionCaseIds: (0, evolution_1.listOpenEvolutionCases)(agentRoot).map((evolutionCase) => evolutionCase.id),
+        recentClaimIds: latest.recentClaimIds,
+        unverifiedClaimIds: latest.unverifiedClaimIds,
+    };
+}
+function recordPostTurnFlightRecorderCheckpoint(input) {
+    const hasActiveContinuation = input.mustResolveBeforeHandoff
+        || input.activeObligationIds.length > 0
+        || input.activeReturnObligationIds.length > 0
+        || input.activePacketIds.length > 0
+        || input.openEvolutionCaseIds.length > 0;
+    const blockedBecause = [
+        ...(input.outcome === "blocked" ? ["agent reported a blocker in this turn"] : []),
+        ...(input.outcome === "errored" ? ["turn errored before a safe continuation was reached"] : []),
+        ...(input.outcome === "aborted" ? ["turn aborted before a safe continuation was reached"] : []),
+        ...(isTerminalWithoutContinuation(input.outcome, hasActiveContinuation) ? [`turn outcome ${input.outcome}; wait for new input before acting`] : []),
+    ];
+    const nextSafeAction = input.nextSafeAction
+        ?? (blockedBecause.length > 0
+            ? "inspect the latest session and wait for new input before acting"
+            : "continue the current held work and update Arc/Desk with the next checkpoint");
+    (0, flight_recorder_1.recordFlightRecorderEvent)(input.agentRoot, {
+        kind: "post_turn_persisted",
+        sessionRef: sessionRefForFlightRecorder(input.currentSession),
+        summary: `persisted ${input.currentSession.channel}/${input.currentSession.key} turn with outcome ${input.outcome}`,
+        currentAsk: input.currentAsk,
+        nextSafeAction,
+        blockedBecause,
+        stopBefore: blockedBecause.length > 0 ? ["acting on stale context"] : [],
+        activeObligationIds: input.activeObligationIds,
+        activeReturnObligationIds: input.activeReturnObligationIds,
+        activePacketIds: input.activePacketIds,
+        openEvolutionCaseIds: input.openEvolutionCaseIds,
+        recentClaimIds: input.recentClaimIds,
+        unverifiedClaimIds: input.unverifiedClaimIds,
+        meta: {
+            outcome: input.outcome,
+            mustResolveBeforeHandoff: input.mustResolveBeforeHandoff,
+            sessionPath: input.currentSession.sessionPath,
+        },
+    });
+}
 function resolveCurrentFailoverBinding(agentName, lane) {
     const agentRoot = (0, identity_1.getAgentRoot)();
     const { config: agentConfig } = (0, auth_flow_1.readAgentConfigForAgent)(agentName, path.dirname(agentRoot));
@@ -643,6 +713,7 @@ async function handleInboundTurn(input) {
                     all: activeWorkFrame.pendingObligations,
                 },
                 currentSessionTiming,
+                flightRecorderResume: ctx.flightRecorderResume,
             });
             /* v8 ignore next 3 -- syncFailure propagation tested in sync.test.ts @preserve */
             if (syncFailure) {
@@ -708,7 +779,7 @@ async function handleInboundTurn(input) {
             senseStatusLines: ctx.senseStatusLines,
             bundleMeta: ctx.bundleMeta,
             daemonHealth: ctx.daemonHealth,
-            journalFiles: ctx.journalFiles,
+            flightRecorderResume: ctx.flightRecorderResume,
             ...(ctx.providerVisibility ? { providerVisibility: ctx.providerVisibility } : {}),
             toolContext: {
                 /* v8 ignore next -- default no-op signin satisfies interface; real signin injected by sense adapter @preserve */
@@ -738,6 +809,36 @@ async function handleInboundTurn(input) {
                 result.error?.message ?? "unknown error", classification, currentProvider, currentBinding.model, agentName, inventory, {}, { currentLane });
                 input.failoverState.pending = failoverContext;
                 input.postTurn(sessionMessages, session.sessionPath, result.usage);
+                try {
+                    const postTurnArc = readPostTurnFlightRecorderArcSnapshot((0, identity_1.getAgentRoot)());
+                    recordPostTurnFlightRecorderCheckpoint({
+                        agentRoot: (0, identity_1.getAgentRoot)(),
+                        currentSession,
+                        currentAsk: currentObligation
+                            ?? activeWorkFrame.primaryObligation?.content?.trim()
+                            ?? currentUserMessage
+                            ?? null,
+                        nextSafeAction: failoverContext.userMessage,
+                        outcome: "errored",
+                        mustResolveBeforeHandoff,
+                        activeObligationIds: postTurnArc.activeObligationIds,
+                        activeReturnObligationIds: postTurnArc.activeReturnObligationIds,
+                        activePacketIds: postTurnArc.activePacketIds,
+                        openEvolutionCaseIds: postTurnArc.openEvolutionCaseIds,
+                        recentClaimIds: postTurnArc.recentClaimIds,
+                        unverifiedClaimIds: postTurnArc.unverifiedClaimIds,
+                    });
+                }
+                catch (checkpointError) {
+                    /* v8 ignore next -- best-effort recorder write must not hide provider-failover guidance @preserve */
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.flight_recorder_checkpoint_error",
+                        message: "failed to record provider-failover flight recorder checkpoint",
+                        meta: { error: checkpointError instanceof Error ? checkpointError.message : String(checkpointError) },
+                    });
+                }
                 return {
                     resolvedContext,
                     gateResult,
@@ -781,6 +882,39 @@ async function handleInboundTurn(input) {
                 : undefined)
             : (Object.keys(continuingState).length > 0 ? continuingState : undefined);
         input.postTurn(sessionMessages, session.sessionPath, result.usage, undefined, nextState);
+        try {
+            const agentRoot = (0, identity_1.getAgentRoot)();
+            const postTurnArc = readPostTurnFlightRecorderArcSnapshot(agentRoot);
+            recordPostTurnFlightRecorderCheckpoint({
+                agentRoot,
+                currentSession,
+                currentAsk: currentObligation
+                    ?? activeWorkFrame.primaryObligation?.content?.trim()
+                    ?? currentUserMessage
+                    ?? null,
+                nextSafeAction: activeWorkFrame.resumeHandle?.nextAction
+                    ?? activeWorkFrame.primaryObligation?.nextAction?.trim()
+                    ?? null,
+                outcome: result.outcome ?? "observed",
+                mustResolveBeforeHandoff,
+                activeObligationIds: postTurnArc.activeObligationIds,
+                activeReturnObligationIds: postTurnArc.activeReturnObligationIds,
+                activePacketIds: postTurnArc.activePacketIds,
+                openEvolutionCaseIds: postTurnArc.openEvolutionCaseIds,
+                recentClaimIds: postTurnArc.recentClaimIds,
+                unverifiedClaimIds: postTurnArc.unverifiedClaimIds,
+            });
+        }
+        catch (error) {
+            /* v8 ignore next -- defensive recorder failures are non-fatal to already-persisted user turns @preserve */
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.flight_recorder_checkpoint_error",
+                message: "failed to record post-turn flight recorder checkpoint",
+                meta: { error: error instanceof Error ? error.message : String(error) },
+            });
+        }
         // Step 7: Token accumulation
         await input.accumulateFriendTokens(input.friendStore, resolvedContext.friend.id, result.usage);
         (0, runtime_1.emitNervesEvent)({

package/dist/util/frontmatter.js

@@ -17,6 +17,10 @@ function parseScalar(raw) {
     const value = raw.trim();
     if (value === "null")
         return null;
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
     if (value === "[]")
         return [];
     if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
@@ -46,7 +50,19 @@ function parseFrontmatter(raw) {
             items.push(parseScalar(lines[cursor].replace(/^\s*-\s+/, "")));
             cursor += 1;
         }
-        frontmatter[key] = items;
+        if (items.length > 0) {
+            frontmatter[key] = items;
+            idx = cursor - 1;
+            continue;
+        }
+        const nested = {};
+        cursor = idx + 1;
+        while (cursor < lines.length && /^\s+[A-Za-z0-9_:-]+:\s*/.test(lines[cursor])) {
+            const child = /^\s+([A-Za-z0-9_:-]+):\s*(.*)$/.exec(lines[cursor]);
+            nested[child[1]] = parseScalar(child[2]);
+            cursor += 1;
+        }
+        frontmatter[key] = Object.keys(nested).length > 0 ? nested : items;
         idx = cursor - 1;
     }
     return frontmatter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.657",
+  "version": "0.1.0-alpha.658",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",
@@ -79,12 +79,12 @@
     "@types/mailparser": "^3.4.6",
     "@types/semver": "^7.7.1",
     "@types/smtp-server": "^3.5.13",
-    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/coverage-v8": "^4.1.8",
     "eslint": "^10.0.2",
     "jsdom": "^29.0.2",
     "typescript": "^5.7.0",
     "typescript-eslint": "^8.56.1",
-    "vitest": "^4.0.18"
+    "vitest": "^4.1.8"
   },
   "overrides": {
     "@microsoft/teams.apps": {

package/skills/configure-dev-tools.md

@@ -64,7 +64,7 @@ Once connected, these tools are available:
 - **status** -- Get agent's current status and activity
 - **catchup** -- Get recent activity summary
 - **get_context** -- Get agent's current working context
-- **search_notes** -- Read-only note search for specific topics; missing hits are not evidence that the agent has no belief or preference
+- **search_facts** -- Read-only Desk record fact search for specific topics; missing hits are not evidence that the agent has no belief or preference
 - **get_task** -- Get details of the agent's current task
 
 ## Troubleshooting

package/skills/travel-planning.md

@@ -92,7 +92,7 @@ an interactive sign-up flow.
 
 ### Post-Booking
 - Save confirmation details (confirmation number, dates, hotel name, airline, booking reference)
-- Save to diary/journal for future reference
+- Save durable travel facts to the Desk record diary or notes for future reference
 - Set reminders for check-in windows
 - Note cancellation deadlines