@haaaiawd/second-nature 0.1.24 → 0.1.25

package/runtime/cli/read-models/index.js

@@ -11,6 +11,7 @@ import { queryExplain, } from "../../observability/query/explain-query.js";
 import { mapOperatorExplainToReadModel } from "./operator-explain-map.js";
 import { loadOperatorFallbackRow, toOperatorFallbackView, } from "../../storage/fallback/load-operator-fallback.js";
 import { loadRhythmPolicySnapshot, } from "../../storage/rhythm/rhythm-policy-snapshot.js";
+import { createNarrativeStateStore } from "../../storage/narrative/narrative-state-store.js";
 const INTERNAL_RUNTIME_PLATFORM_ID = "second-nature-runtime";
 const INTERNAL_RUNTIME_TRACE_PREFIX = "sn-runtime-";
 function toExplainQuery(subject) {
@@ -112,6 +113,117 @@ function mapConnectorStatus(attempt) {
     }
     return "healthy";
 }
+/**
+ * Derive groundingStatus from confidence and status.
+ *
+ * Rules (in priority order):
+ * 1. blocked: status === "awaiting_sources" OR confidence < 0.4
+ * 2. pass: confidence >= 0.7 AND status === "active"
+ * 3. degraded: all other cases (0.4 <= confidence < 0.7, or status is insufficient_sources)
+ */
+function deriveGroundingStatus(status, confidence) {
+    if (status === "awaiting_sources" || confidence < 0.4) {
+        return "blocked";
+    }
+    if (confidence >= 0.7 && status === "active") {
+        return "pass";
+    }
+    return "degraded";
+}
+/**
+ * Build the base StatusReadModel that is shared by loadStatus and loadV6Status.
+ * Centralising this logic eliminates the DRY violation identified in CR-01.
+ */
+async function buildBaseStatus(deps) {
+    let recentAttempts = [];
+    let recentDecisions = [];
+    let credentials = [];
+    try {
+        recentAttempts = await deps.observabilityDb.db
+            .select()
+            .from(executionAttempts)
+            .orderBy(desc(executionAttempts.startedAt), desc(executionAttempts.finishedAt))
+            .limit(50);
+    }
+    catch {
+        recentAttempts = [];
+    }
+    try {
+        recentDecisions = await deps.observabilityDb.db
+            .select()
+            .from(decisionLedger)
+            .orderBy(desc(decisionLedger.createdAt))
+            .limit(50);
+    }
+    catch {
+        recentDecisions = [];
+    }
+    try {
+        credentials = await deps.stateDb.db.query.credentialRecords.findMany();
+    }
+    catch {
+        credentials = [];
+    }
+    const latestRuntimeAttempt = recentAttempts.find((attempt) => attempt.platformId === INTERNAL_RUNTIME_PLATFORM_ID);
+    const latestConnectorAttempt = recentAttempts.find((attempt) => attempt.platformId !== INTERNAL_RUNTIME_PLATFORM_ID);
+    const latestRuntimeDecision = recentDecisions.find((decision) => decision.traceId.startsWith(INTERNAL_RUNTIME_TRACE_PREFIX));
+    const runtimeUpdatedAt = latestRuntimeAttempt?.finishedAt ??
+        latestRuntimeAttempt?.startedAt ??
+        latestRuntimeDecision?.createdAt ??
+        "";
+    const quietMode = latestRuntimeDecision?.mode === "quiet" ||
+        latestRuntimeDecision?.mode === "maintenance_only" ||
+        latestRuntimeDecision?.mode === "paused_for_interrupt"
+        ? latestRuntimeDecision.mode
+        : "unknown";
+    const riskFlags = [
+        latestRuntimeAttempt?.failureClass,
+        latestConnectorAttempt?.failureClass,
+    ].filter((value) => Boolean(value));
+    const connectorSummary = latestConnectorAttempt
+        ? [
+            {
+                platformId: latestConnectorAttempt.platformId,
+                status: mapConnectorStatus(latestConnectorAttempt),
+                channel: latestConnectorAttempt.channel,
+                failureClass: latestConnectorAttempt.failureClass ?? undefined,
+            },
+        ]
+        : [];
+    return {
+        runtime: {
+            host: "openclaw-plugin",
+            serviceStatus: mapRuntimeStatus(latestRuntimeAttempt),
+            updatedAt: runtimeUpdatedAt,
+        },
+        rhythm: {
+            mode: latestRuntimeDecision?.mode ?? "unknown",
+        },
+        quiet: {
+            mode: quietMode,
+            lastEvent: latestRuntimeDecision?.traceId,
+            interrupted: latestRuntimeDecision?.mode === "paused_for_interrupt"
+                ? true
+                : undefined,
+        },
+        connectors: connectorSummary,
+        credentials: credentials.map((item) => ({
+            platformId: item.platformId ??
+                item.platform_id,
+            status: item.status,
+            nextStep: buildCredentialNextStep(item.status),
+        })),
+        risk: {
+            level: riskFlags.length > 0 ? "medium" : "low",
+            flags: riskFlags,
+        },
+        deliveryPosture: {
+            verdict: "none",
+            source: "workspace_default_none",
+            reasonCode: "delivery_target_none",
+        },
+    };
+}
 export function createCliReadModels(deps) {
     const assetRepository = new AssetRepository(deps.stateDb);
     const credentialRepository = new CredentialRepository(deps.stateDb);
@@ -124,103 +236,7 @@ export function createCliReadModels(deps) {
     const auditStore = deps.livedExperienceAuditStore ?? new AppendOnlyAuditStore();
     return {
         async loadStatus(_scope) {
-            let recentAttempts = [];
-            let recentDecisions = [];
-            let credentials = [];
-            try {
-                recentAttempts = await deps.observabilityDb.db
-                    .select()
-                    .from(executionAttempts)
-                    .orderBy(desc(executionAttempts.startedAt), desc(executionAttempts.finishedAt))
-                    .limit(50);
-            }
-            catch {
-                recentAttempts = [];
-            }
-            try {
-                recentDecisions = await deps.observabilityDb.db
-                    .select()
-                    .from(decisionLedger)
-                    .orderBy(desc(decisionLedger.createdAt))
-                    .limit(50);
-            }
-            catch {
-                recentDecisions = [];
-            }
-            try {
-                credentials = await deps.stateDb.db.query.credentialRecords.findMany();
-            }
-            catch {
-                credentials = [];
-            }
-            const latestRuntimeAttempt = recentAttempts.find((attempt) => attempt.platformId === INTERNAL_RUNTIME_PLATFORM_ID);
-            // CH-15-04 (CH-14-03): latestConnectorAttempt is the most recent execution attempt whose
-            // platformId is NOT the internal sn-runtime sentinel — i.e. a real connector platform
-            // (Moltbook, EvoMap, etc.). The `connectors` array in StatusReadModel reflects this single
-            // most-recent non-runtime attempt, NOT the full connector manifest. An empty array means
-            // no connector attempt has been recorded yet, not that connectors are misconfigured.
-            const latestConnectorAttempt = recentAttempts.find((attempt) => attempt.platformId !== INTERNAL_RUNTIME_PLATFORM_ID);
-            const latestRuntimeDecision = recentDecisions.find((decision) => decision.traceId.startsWith(INTERNAL_RUNTIME_TRACE_PREFIX));
-            const runtimeUpdatedAt = latestRuntimeAttempt?.finishedAt ??
-                latestRuntimeAttempt?.startedAt ??
-                latestRuntimeDecision?.createdAt ??
-                "";
-            const quietMode = latestRuntimeDecision?.mode === "quiet" ||
-                latestRuntimeDecision?.mode === "maintenance_only" ||
-                latestRuntimeDecision?.mode === "paused_for_interrupt"
-                ? latestRuntimeDecision.mode
-                : "unknown";
-            const riskFlags = [
-                latestRuntimeAttempt?.failureClass,
-                latestConnectorAttempt?.failureClass,
-            ].filter((value) => Boolean(value));
-            const connectorSummary = latestConnectorAttempt
-                ? [
-                    {
-                        platformId: latestConnectorAttempt.platformId,
-                        status: mapConnectorStatus(latestConnectorAttempt),
-                        channel: latestConnectorAttempt.channel,
-                        failureClass: latestConnectorAttempt.failureClass ?? undefined,
-                    },
-                ]
-                : [];
-            return {
-                runtime: {
-                    host: "openclaw-plugin",
-                    serviceStatus: mapRuntimeStatus(latestRuntimeAttempt),
-                    updatedAt: runtimeUpdatedAt,
-                },
-                rhythm: {
-                    mode: latestRuntimeDecision?.mode ?? "unknown",
-                    windowId: undefined,
-                },
-                quiet: {
-                    mode: quietMode,
-                    lastEvent: latestRuntimeDecision?.traceId,
-                    interrupted: latestRuntimeDecision?.mode === "paused_for_interrupt"
-                        ? true
-                        : undefined,
-                },
-                connectors: connectorSummary,
-                credentials: credentials.map((item) => ({
-                    platformId: item.platformId ??
-                        item.platform_id,
-                    status: item.status,
-                    nextStep: buildCredentialNextStep(item.status),
-                })),
-                risk: {
-                    level: riskFlags.length > 0 ? "medium" : "low",
-                    flags: riskFlags,
-                },
-                // T1.2.5 (CH-14-04): default delivery posture is workspace_default_none because the
-                // workspace heartbeat hardcodes `deliveryCapability: { target: "none" }` until a host
-                // capability probe explicitly sets a valid target.
-                deliveryPosture: {
-                    verdict: "none",
-                    source: "workspace_default_none",
-                    reasonCode: "delivery_target_none",
-                },
-            };
+            return buildBaseStatus(deps);
         },
         async loadDailyReport(day) {
             let bundle;
@@ -387,5 +403,220 @@ export function createCliReadModels(deps) {
                 evidenceRefs: bundle.explanation.evidenceRefs,
             };
         },
+        // T1.2.2 — read recent DreamTrace events from audit store.
+        async loadDreamRecent(limit = 5) {
+            const events = auditStore.list().filter((e) => e.family === "dream.trace");
+            const recent = events
+                .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+                .slice(0, limit);
+            return {
+                runs: recent.map((e) => {
+                    const p = e.payload;
+                    return {
+                        traceId: p.traceId,
+                        runId: p.runId,
+                        durationMs: p.durationMs ?? 0,
+                        inputCounts: p.inputCounts ?? { evidence: 0, chronicle: 0, memoryEntries: 0 },
+                        fallbackReason: p.fallbackReason,
+                        lifecycleStatus: p.fallbackReason ? "partial" : "completed",
+                        insightsCount: 0, // would require deeper payload parsing
+                        createdAt: e.createdAt,
+                    };
+                }),
+                totalRuns: events.length,
+            };
+        },
+        // T1.2.5 — aggregate recent heartbeat, narrative, dream, delivery events into cycles.
+        async loadCycleRecent(limit = 5) {
+            const events = auditStore.list();
+            const decisions = events.filter((e) => e.family === "heartbeat.decision");
+            const narratives = events.filter((e) => e.family === "narrative.trace");
+            const dreams = events.filter((e) => e.family === "dream.trace");
+            const deliveries = events.filter((e) => e.family === "delivery");
+            const connectors = events.filter((e) => e.family === "connector.attempt");
+            // Group by time buckets (hourly)
+            const buckets = new Map();
+            for (const e of decisions) {
+                const hour = e.createdAt.slice(0, 13);
+                const b = buckets.get(hour) ?? { timestamp: `${hour}:00:00Z`, dimensions: [] };
+                if (!b.dimensions.includes("decision"))
+                    b.dimensions.push("decision");
+                const p = e.payload;
+                if (p.outcome)
+                    b.decisionOutcome = p.outcome;
+                buckets.set(hour, b);
+            }
+            for (const e of narratives) {
+                const hour = e.createdAt.slice(0, 13);
+                const b = buckets.get(hour) ?? { timestamp: `${hour}:00:00Z`, dimensions: [] };
+                if (!b.dimensions.includes("narrative"))
+                    b.dimensions.push("narrative");
+                const p = e.payload;
+                if (p.groundingStatus)
+                    b.narrativeGrounding = p.groundingStatus;
+                buckets.set(hour, b);
+            }
+            for (const e of dreams) {
+                const hour = e.createdAt.slice(0, 13);
+                const b = buckets.get(hour) ?? { timestamp: `${hour}:00:00Z`, dimensions: [] };
+                if (!b.dimensions.includes("dream"))
+                    b.dimensions.push("dream");
+                const p = e.payload;
+                if (p.fallbackReason)
+                    b.dreamFallback = p.fallbackReason;
+                buckets.set(hour, b);
+            }
+            for (const e of deliveries) {
+                const hour = e.createdAt.slice(0, 13);
+                const b = buckets.get(hour) ?? { timestamp: `${hour}:00:00Z`, dimensions: [] };
+                if (!b.dimensions.includes("delivery"))
+                    b.dimensions.push("delivery");
+                const p = e.payload;
+                if (p.status)
+                    b.deliveryStatus = p.status;
+                buckets.set(hour, b);
+            }
+            for (const e of connectors) {
+                const hour = e.createdAt.slice(0, 13);
+                const b = buckets.get(hour) ?? { timestamp: `${hour}:00:00Z`, dimensions: [] };
+                if (!b.dimensions.includes("connector"))
+                    b.dimensions.push("connector");
+                buckets.set(hour, b);
+            }
+            const cycles = Array.from(buckets.values())
+                .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+                .slice(0, limit);
+            return { cycles, totalCycles: buckets.size };
+        },
+        // T1.2.6 — v6 status aggregate: compose base status + narrative + dream + cycle sections.
+        // Each section returns a sentinel status (nothing_yet / has_runs / has_cycles) so operators
+        // always get a meaningful non-empty response, never a raw empty object.
+        async loadV6Status(scope) {
+            // Load NarrativeState asynchronously; audit events are synchronous reads from in-memory store.
+            const narrativeStore = createNarrativeStateStore(deps.stateDb);
+            let narrativeState;
+            try {
+                narrativeState = await narrativeStore.loadNarrativeState();
+            }
+            catch {
+                narrativeState = null;
+            }
+            const allAuditEvents = auditStore.list();
+            const dreamSection = allAuditEvents.filter((e) => e.family === "dream.trace");
+            const cycleSection = allAuditEvents;
+            const baseStatus = await buildBaseStatus(deps);
+            // Narrative section
+            let narrativeSectionOut;
+            if (!narrativeState) {
+                narrativeSectionOut = { status: "nothing_yet", focus: "", groundingStatus: "blocked", nextIntent: "", sourceRefCount: 0 };
+            }
+            else {
+                const groundingStatus = deriveGroundingStatus(narrativeState.status, narrativeState.confidence);
+                narrativeSectionOut = { status: narrativeState.status, focus: narrativeState.focus, groundingStatus, nextIntent: narrativeState.nextIntent, sourceRefCount: narrativeState.sourceRefs.length };
+            }
+            // Dream section — degraded when all recorded dream runs have a fallbackReason.
+            const dreamEvents = dreamSection;
+            let dreamSectionOut;
+            if (dreamEvents.length === 0) {
+                dreamSectionOut = { status: "nothing_yet", totalRuns: 0, recentRunCount: 0 };
+            }
+            else {
+                const recentDreams = dreamEvents.sort((a, b) => b.createdAt.localeCompare(a.createdAt)).slice(0, 3);
+                const lastFallback = recentDreams.map((e) => e.payload.fallbackReason).find(Boolean);
+                const allDegraded = dreamEvents.every((e) => !!e.payload.fallbackReason);
+                dreamSectionOut = {
+                    status: allDegraded ? "degraded" : "has_runs",
+                    totalRuns: dreamEvents.length,
+                    recentRunCount: recentDreams.length,
+                    lastFallbackReason: lastFallback,
+                };
+            }
+            // Cycle section — degraded when buckets exist but cover fewer than 3 dimensions.
+            const allEvents = cycleSection;
+            const decisionEvents = allEvents.filter((e) => e.family === "heartbeat.decision");
+            const narrativeEvents = allEvents.filter((e) => e.family === "narrative.trace");
+            const dreamEventsForCycle = allEvents.filter((e) => e.family === "dream.trace");
+            const deliveryEvents = allEvents.filter((e) => e.family === "delivery");
+            const connectorEvents = allEvents.filter((e) => e.family === "connector.attempt");
+            const hourBuckets = new Set();
+            const dimensionSet = new Set();
+            for (const e of decisionEvents) {
+                hourBuckets.add(e.createdAt.slice(0, 13));
+                dimensionSet.add("decision");
+            }
+            for (const e of narrativeEvents) {
+                hourBuckets.add(e.createdAt.slice(0, 13));
+                dimensionSet.add("narrative");
+            }
+            for (const e of dreamEventsForCycle) {
+                hourBuckets.add(e.createdAt.slice(0, 13));
+                dimensionSet.add("dream");
+            }
+            for (const e of deliveryEvents) {
+                hourBuckets.add(e.createdAt.slice(0, 13));
+                dimensionSet.add("delivery");
+            }
+            for (const e of connectorEvents) {
+                hourBuckets.add(e.createdAt.slice(0, 13));
+                dimensionSet.add("connector");
+            }
+            let cycleSectionOut;
+            if (hourBuckets.size === 0) {
+                cycleSectionOut = { status: "nothing_yet", totalCycles: 0, recentCycleCount: 0, dimensions: [] };
+            }
+            else if (dimensionSet.size < 3) {
+                cycleSectionOut = { status: "degraded", totalCycles: hourBuckets.size, recentCycleCount: Math.min(hourBuckets.size, 5), dimensions: Array.from(dimensionSet) };
+            }
+            else {
+                cycleSectionOut = { status: "has_cycles", totalCycles: hourBuckets.size, recentCycleCount: Math.min(hourBuckets.size, 5), dimensions: Array.from(dimensionSet) };
+            }
+            void scope; // scope param reserved for future scoping — not used in v6 aggregate yet
+            return { ...baseStatus, narrative: narrativeSectionOut, dream: dreamSectionOut, cycles: cycleSectionOut };
+        },
+        // T1.2.1 — read current NarrativeState and map to NarrativeReadModel.
+        // Returns `nothing_yet` status when no data exists — honest empty, not an error.
+        async loadNarrative(narrativeId) {
+            const narrativeStore = createNarrativeStateStore(deps.stateDb);
+            let state;
+            try {
+                state = await narrativeStore.loadNarrativeState(narrativeId);
+            }
+            catch {
+                state = null;
+            }
+            if (!state) {
+                return {
+                    narrativeId: narrativeId ?? "default",
+                    revision: 0,
+                    focus: "",
+                    progress: [],
+                    nextIntent: "",
+                    confidence: 0,
+                    sourceRefs: [],
+                    unsupportedClaims: [],
+                    groundingStatus: "blocked",
+                    status: "nothing_yet",
+                    updatedAt: "",
+                };
+            }
+            const groundingStatus = deriveGroundingStatus(state.status, state.confidence);
+            return {
+                narrativeId: state.narrativeId,
+                revision: state.revision,
+                focus: state.focus,
+                progress: state.progress,
+                nextIntent: state.nextIntent,
+                confidence: state.confidence,
+                sourceRefs: state.sourceRefs.map((r) => ({
+                    sourceId: r.sourceId,
+                    kind: r.kind,
+                    url: r.url,
+                })),
+                unsupportedClaims: state.unsupportedClaims,
+                groundingStatus,
+                status: state.status,
+                updatedAt: state.updatedAt,
+            };
+        },
     };
 }

package/runtime/cli/read-models/types.d.ts

@@ -73,6 +73,38 @@ export interface StatusReadModel {
      */
     deliveryPosture?: DeliveryPosture;
 }
+/**
+ * T1.2.6 — v6 status aggregate: extends StatusReadModel with narrative, dream recent,
+ * cycle recent, and per-section `nothing_yet` / `awaiting_sources` / `degraded` sentinels
+ * so operators always get a meaningful view even when individual data sources are empty.
+ */
+export interface StatusV6NarrativeSection {
+    status: "active" | "insufficient_sources" | "awaiting_sources" | "nothing_yet";
+    focus: string;
+    groundingStatus: "pass" | "degraded" | "blocked";
+    nextIntent: string;
+    sourceRefCount: number;
+}
+export interface StatusV6DreamSection {
+    status: "has_runs" | "degraded" | "nothing_yet";
+    totalRuns: number;
+    recentRunCount: number;
+    lastFallbackReason?: string;
+}
+export interface StatusV6CycleSection {
+    status: "has_cycles" | "degraded" | "nothing_yet";
+    totalCycles: number;
+    recentCycleCount: number;
+    dimensions: string[];
+}
+export interface StatusV6ReadModel extends StatusReadModel {
+    /** v6 narrative section; status is nothing_yet when no NarrativeState row exists. */
+    narrative: StatusV6NarrativeSection;
+    /** v6 dream recent section; status is nothing_yet when no DreamTrace events exist. */
+    dream: StatusV6DreamSection;
+    /** v6 cycle recent section; status is nothing_yet when no cycle events exist. */
+    cycles: StatusV6CycleSection;
+}
 export interface DailyReportReadModel {
     day: string;
     summary: string;
@@ -127,3 +159,51 @@ export interface AuditSummaryReadModel {
     totalEvents: number;
     events: AuditEventSummaryEntry[];
 }
+/** T1.2.2 — recent Dream run summary for operator `dream:recent` command. */
+export interface DreamRecentReadModel {
+    runs: Array<{
+        traceId: string;
+        runId: string;
+        durationMs: number;
+        inputCounts: {
+            evidence: number;
+            chronicle: number;
+            memoryEntries: number;
+        };
+        fallbackReason?: string;
+        lifecycleStatus: string;
+        insightsCount: number;
+        createdAt: string;
+    }>;
+    totalRuns: number;
+}
+/** T1.2.1 — NarrativeState read model for operator `narrative` command. */
+export interface NarrativeReadModel {
+    narrativeId: string;
+    revision: number;
+    focus: string;
+    progress: string[];
+    nextIntent: string;
+    confidence: number;
+    sourceRefs: Array<{
+        sourceId: string;
+        kind: string;
+        url?: string;
+    }>;
+    unsupportedClaims: string[];
+    groundingStatus: "pass" | "degraded" | "blocked";
+    status: "active" | "insufficient_sources" | "awaiting_sources" | "nothing_yet";
+    updatedAt: string;
+}
+/** T1.2.5 — recent cycle summary aggregating heartbeat, narrative, dream, delivery. */
+export interface CycleRecentReadModel {
+    cycles: Array<{
+        timestamp: string;
+        dimensions: Array<"decision" | "narrative" | "dream" | "delivery" | "connector">;
+        decisionOutcome?: string;
+        narrativeGrounding?: string;
+        dreamFallback?: string;
+        deliveryStatus?: string;
+    }>;
+    totalCycles: number;
+}

package/runtime/core/second-nature/heartbeat/heartbeat-loop.d.ts

@@ -21,6 +21,7 @@ import type { StateDatabase } from "../../../storage/db/index.js";
 import { type OpenClawDeliveryPort } from "../outreach/dispatch-user-outreach.js";
 import type { ConnectorExecutor } from "../../../connectors/base/contract.js";
 import type { NarrativeStateStore } from "../../../storage/narrative/narrative-state-store.js";
+import type { NarrativeTracePayload } from "../../../observability/services/lived-experience-audit.js";
 export interface HeartbeatDecisionTracePayload {
     scope: RuntimeScope;
     status: HeartbeatCycleStatus;
@@ -61,6 +62,8 @@ export interface HeartbeatDeps {
     connectorExecutor?: ConnectorExecutor;
     /** T2.1.5: when present, heartbeat writes a source-backed NarrativeState revision after each cycle. */
     narrativeStateStore?: NarrativeStateStore;
+    /** T5.1.2: when present, heartbeat records a NarrativeTrace after successful narrative state update. */
+    recordNarrativeTrace?: (payload: NarrativeTracePayload) => Promise<void>;
 }
 /**
  * Ingest a heartbeat rhythm signal and drive one full decision round.

package/runtime/core/second-nature/heartbeat/heartbeat-loop.js

@@ -91,7 +91,7 @@ export async function resolveAllowedIntentResult(intent, runtime, inputs, signal
  * is never blocked by a store failure. Store failures are optionally traced
  * via recordDecisionTrace so operators can monitor store health.
  */
-async function maybeUpdateNarrativeState(result, selectedIntent, runtime, store, recordTrace, signal) {
+async function maybeUpdateNarrativeState(result, selectedIntent, runtime, store, recordTrace, signal, recordNarrativeTrace) {
     if (!store)
         return;
     try {
@@ -103,6 +103,33 @@ async function maybeUpdateNarrativeState(result, selectedIntent, runtime, store,
             priorNarrative: prior,
         });
         await store.updateNarrativeState(update);
+        // T5.1.2: record NarrativeTrace on successful state update
+        if (recordNarrativeTrace) {
+            try {
+                await recordNarrativeTrace({
+                    traceId: `narrative_trace:${crypto.randomUUID()}`,
+                    narrativeId: update.narrativeId,
+                    revision: update.revision,
+                    updateSource: "heartbeat",
+                    sourceRefs: update.sourceRefs.map((r) => ({
+                        id: r.sourceId,
+                        kind: r.kind,
+                        uri: r.url,
+                    })),
+                    unsupportedClaims: update.unsupportedClaims,
+                    groundingStatus: update.unsupportedClaims.length > 0
+                        ? "degraded"
+                        : update.status === "insufficient_sources"
+                            ? "blocked"
+                            : "pass",
+                    goalInfluenceRefs: selectedIntent?.goalInfluenceRefs ?? [],
+                    createdAt: update.updatedAt,
+                });
+            }
+            catch {
+                // trace emission must not block the cycle
+            }
+        }
     }
     catch {
         // degrade silently; narrative update is best-effort
@@ -178,7 +205,7 @@ export async function ingestRhythmSignal(signal, deps) {
                 ? { ...resolved, reasons: evaluation.reasons }
                 : resolved;
             await emitTrace(result);
-            await maybeUpdateNarrativeState(result, intent, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
+            await maybeUpdateNarrativeState(result, intent, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
             return result;
         }
         if (evaluation.verdict === "defer") {
@@ -196,7 +223,7 @@ export async function ingestRhythmSignal(signal, deps) {
             reasons: ["silent_no_candidates"],
         };
         await emitTrace(result);
-        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
+        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
         return result;
     }
     if (!anyAllow && anyDefer && !anyDeny) {
@@ -206,7 +233,7 @@ export async function ingestRhythmSignal(signal, deps) {
             reasons: denyReasons.length > 0 ? denyReasons : ["all_candidates_deferred"],
         };
         await emitTrace(result);
-        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
+        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
         return result;
     }
     if (!anyAllow && denyReasons.length > 0) {
@@ -216,7 +243,7 @@ export async function ingestRhythmSignal(signal, deps) {
             reasons: denyReasons,
         };
         await emitTrace(result);
-        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
+        await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
         return result;
     }
     const result = {
@@ -225,7 +252,7 @@ export async function ingestRhythmSignal(signal, deps) {
         reasons: ["no_allow_verdict"],
     };
     await emitTrace(result);
-    await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal);
+    await maybeUpdateNarrativeState(result, undefined, runtime, deps.narrativeStateStore, deps.recordDecisionTrace, signal, deps.recordNarrativeTrace);
     return result;
 }
 /**

package/runtime/core/second-nature/orchestrator/goal-priority.d.ts

@@ -3,7 +3,8 @@
  *
  * `applyGoalPriority` adjusts candidate intent priorities based on accepted AgentGoals.
  * Priority order: user_task > accepted_goal > rhythm.
- * Only goals with status === "accepted" and origin !== "agent_proposed" are considered.
+ * Only goals with status === "accepted" are considered.
+ * Agent-proposed goals are included ONLY if policy-accepted (acceptedBy === "policy_allowlist").
  * All other statuses (proposal / rejected / completed / paused) are implicitly excluded.
  */
 import type { CandidateIntent } from "../types.js";