@haaaiawd/second-nature 0.2.1 → 0.2.2

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "second-nature",
   "name": "Second Nature",
-  "version": "0.1.51",
+  "version": "0.2.2",
   "description": "OpenClaw native plugin with synchronous surface registration and bundled runtime spine. Set SECOND_NATURE_WORKSPACE_ROOT or tool workspaceRoot to the same path as the agent workspace. Agent inner guide is packaged as agent-inner-guide.md. v7 ops surface: self_health, tool_affordance, heartbeat_digest, snapshot:capture, narrative:diff, timeline, restore, runtime_secret_bootstrap, connector:run, guidance_payload.",
   "activation": {
     "onStartup": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/second-nature",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "OpenClaw native plugin with synchronous registration, a packaged runtime artifact, and operator-facing status/explain flows.",
   "keywords": [
     "openclaw",

package/runtime/cli/index.js

@@ -5,6 +5,7 @@ import { createActionBridge } from "./action-bridge.js";
 import { createCliCommands, } from "./commands/index.js";
 import { createOpsRouter } from "./ops/ops-router.js";
 import { createCliReadModels, } from "./read-models/index.js";
+import { AppendOnlyAuditStore } from "../observability/audit/append-only-audit-store.js";
 import { resolvePackagedRuntime } from "./runtime/runtime-artifact-boundary.js";
 import { createRestoreSnapshotStore, } from "../storage/services/restore-snapshot-store.js";
 import { createRuntimeDecisionRecorder, } from "../observability/services/runtime-decision-recorder.js";
@@ -221,12 +222,13 @@ export function createCliRuntimeDeps(overrides = {}) {
     const stateDb = overrides.stateDb ?? createStateDatabase();
     const observabilityDb = overrides.observabilityDb ?? createObservabilityDatabase();
     const stateApi = overrides.stateApi ?? createStateAPI(stateDb);
+    const auditStore = overrides.auditStore ?? overrides.livedExperienceAuditStore ?? new AppendOnlyAuditStore();
     const readModels = overrides.readModels ??
         createCliReadModels({
             stateDb,
             observabilityDb,
             workspaceRoot,
-            livedExperienceAuditStore: overrides.livedExperienceAuditStore,
+            livedExperienceAuditStore: auditStore,
         });
     const actionBridge = overrides.actionBridge ?? createActionBridge(stateApi);
     const runtimeRecorder = overrides.runtimeRecorder ?? createRuntimeDecisionRecorder(observabilityDb);
@@ -261,6 +263,7 @@ export function createCliRuntimeDeps(overrides = {}) {
         narrativeTimelineDeps,
         secretAnchorDeps,
         restoreSnapshotStore,
+        auditStore,
     };
 }
 export function createCommandRouter(options = {}) {
@@ -281,6 +284,7 @@ export function createCommandRouter(options = {}) {
         narrativeTimelineDeps: runtime.narrativeTimelineDeps,
         secretAnchorDeps: runtime.secretAnchorDeps,
         restoreSnapshotStore: runtime.restoreSnapshotStore,
+        auditStore: runtime.auditStore,
     });
     const commands = createCliCommands({
         readModels: runtime.readModels,

package/runtime/cli/ops/heartbeat-surface.d.ts

@@ -18,6 +18,7 @@ import type { HeartbeatDigestAssemblerDeps } from "../../observability/services/
 import type { GoalLifecyclePolicy } from "../../core/second-nature/heartbeat/goal-lifecycle-policy.js";
 import type { IdleCuriosityPolicy } from "../../core/second-nature/heartbeat/idle-curiosity-policy.js";
 import type { CircuitBreakerManager } from "../../core/second-nature/body/circuit-breaker/circuit-breaker-manager.js";
+import type { AppendOnlyAuditStore } from "../../observability/audit/append-only-audit-store.js";
 export type HeartbeatSurfaceStatus = "heartbeat_ok" | "intent_selected" | "denied" | "deferred" | "runtime_carrier_only" | "delivery_unavailable";
 export interface HeartbeatSurfaceResult {
     ok: boolean;
@@ -80,5 +81,7 @@ export interface HeartbeatCheckInput {
     idleCuriosityPolicy?: IdleCuriosityPolicy;
     /** v7 T-BTS.C.5: circuit breaker manager for connector execution health. */
     circuitBreakerManager?: CircuitBreakerManager;
+    /** T-OBS.R.1: shared audit sink for connector/Quiet events consumed by heartbeat_digest. */
+    auditStore?: AppendOnlyAuditStore;
 }
 export declare function heartbeatCheck(input: HeartbeatCheckInput): Promise<HeartbeatSurfaceResult>;

package/runtime/cli/ops/heartbeat-surface.js

@@ -82,6 +82,7 @@ export async function heartbeatCheck(input) {
         goalLifecyclePolicy: input.goalLifecyclePolicy,
         idleCuriosityPolicy: input.idleCuriosityPolicy,
         circuitBreakerManager: input.circuitBreakerManager,
+        auditStore: input.auditStore,
     });
     try {
         const cycle = await run(signal);

package/runtime/cli/ops/manual-run-dispatcher.d.ts

@@ -26,6 +26,7 @@ import type { ConnectorExecutor, ConnectorResult } from "../../connectors/base/c
 import type { ExperienceWriter } from "../../core/second-nature/body/tool-experience/experience-writer.js";
 import type { WetProbeRunner } from "../../connectors/base/wet-probe-runner.js";
 import type { CapabilityContractRegistryV7 } from "../../connectors/base/manifest-v7.js";
+import type { AppendOnlyAuditStore } from "../../observability/audit/append-only-audit-store.js";
 import { type HeartbeatCheckInput, type HeartbeatSurfaceResult } from "./heartbeat-surface.js";
 import type { RuntimeOpsEnvelope } from "./ops-router.js";
 export interface ManualTriggerContext {
@@ -75,5 +76,6 @@ export interface ManualRunDispatcherDeps {
     experienceWriter: ExperienceWriter;
     wetProbeRunner: WetProbeRunner;
     registryV7: CapabilityContractRegistryV7;
+    auditStore?: AppendOnlyAuditStore;
 }
 export declare function createManualRunDispatcher(deps: ManualRunDispatcherDeps): ManualRunDispatcher;

package/runtime/cli/ops/manual-run-dispatcher.js

@@ -23,6 +23,7 @@
  * Test coverage: tests/unit/ops/manual-run-dispatcher.test.ts
  */
 import * as crypto from "node:crypto";
+import { recordConnectorAttemptAudit } from "../../observability/services/audit-closure-recorders.js";
 import { heartbeatCheck, } from "./heartbeat-surface.js";
 function buildManualContext(input) {
     return {
@@ -54,6 +55,15 @@ export function createManualRunDispatcher(deps) {
                 result: connectorResult,
                 triggerSource: ctx.triggerSource,
             });
+            recordConnectorAttemptAudit({
+                auditStore: deps.auditStore,
+                platformId: input.platformId,
+                capability: input.capabilityId,
+                result: connectorResult,
+                triggerSource: ctx.triggerSource,
+                decisionId,
+                intentId,
+            });
             const runResult = {
                 connectorResult,
                 experienceId,

package/runtime/cli/ops/ops-router.js

@@ -441,6 +441,7 @@ export function createOpsRouter(deps) {
                         experienceWriter,
                         digestOpts,
                         dreamSchedulePort,
+                        auditStore: deps.auditStore,
                         goalLifecyclePolicy,
                         idleCuriosityPolicy,
                         circuitBreakerManager,
@@ -780,6 +781,7 @@ export function createOpsRouter(deps) {
                     experienceWriter,
                     wetProbeRunner,
                     registryV7,
+                    auditStore: deps.auditStore,
                 });
                 return dispatcher.runConnector({
                     platformId,

package/runtime/cli/ops/workspace-heartbeat-runner.d.ts

@@ -26,6 +26,7 @@ import { type HeartbeatDigestAssemblerDeps } from "../../observability/services/
 import type { GoalLifecyclePolicy } from "../../core/second-nature/heartbeat/goal-lifecycle-policy.js";
 import type { IdleCuriosityPolicy } from "../../core/second-nature/heartbeat/idle-curiosity-policy.js";
 import type { CircuitBreakerManager } from "../../core/second-nature/body/circuit-breaker/circuit-breaker-manager.js";
+import type { AppendOnlyAuditStore } from "../../observability/audit/append-only-audit-store.js";
 export interface WorkspaceHeartbeatRunnerOptions {
     /** When supplied, the runner persists the cycle so `loadStatus` can read it (T1.2.3). */
     runtimeRecorder?: RuntimeDecisionRecorder;
@@ -76,6 +77,8 @@ export interface WorkspaceHeartbeatRunnerOptions {
          */
         digestWindowHour?: number;
     };
+    /** T-OBS.R.1: shared audit sink for heartbeat connector and Quiet outcomes. */
+    auditStore?: AppendOnlyAuditStore;
 }
 export declare function loadSnapshotInputsForWorkspaceHeartbeat(readModels: CliReadModels, options?: {
     state?: StateDatabase;

package/runtime/cli/ops/workspace-heartbeat-runner.js

@@ -145,6 +145,7 @@ export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
                         workspaceRoot: options.workspaceRoot,
                         // v7 T-V7C.C.3: pass Dream schedule port so Quiet completion triggers Dream.
                         dreamSchedulePort: options.dreamSchedulePort,
+                        auditStore: options.auditStore,
                     }
                     : undefined,
                 connectorExecutor: options.connectorExecutor,
@@ -162,6 +163,7 @@ export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
                 idleCuriosityPolicy: options.idleCuriosityPolicy,
                 // v7 T-BTS.C.5: pass circuit breaker manager for execution health tracking.
                 circuitBreakerManager: options.circuitBreakerManager,
+                auditStore: options.auditStore,
             },
         });
         if (options.runtimeRecorder) {

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

@@ -25,6 +25,7 @@ import type { NarrativeStateStore } from "../../../storage/narrative/narrative-s
 import type { NarrativeTracePayload } from "../../../observability/services/lived-experience-audit.js";
 import type { ExperienceWriter } from "../body/tool-experience/experience-writer.js";
 import type { QuietDreamSchedulePort } from "../quiet/run-source-backed-quiet.js";
+import type { AppendOnlyAuditStore } from "../../../observability/audit/append-only-audit-store.js";
 import type { GoalLifecyclePolicy } from "./goal-lifecycle-policy.js";
 import type { IdleCuriosityPolicy } from "./idle-curiosity-policy.js";
 import type { CircuitBreakerManager } from "../body/circuit-breaker/circuit-breaker-manager.js";
@@ -50,12 +51,14 @@ export interface HeartbeatQuietWorkflowDeps {
     workspaceRoot: string;
     /** v7 T-V7C.C.3: when present, a successful Quiet write auto-triggers Dream scheduling. */
     dreamSchedulePort?: QuietDreamSchedulePort;
+    /** T-OBS.R.1: audit sink for Quiet outcomes consumed by heartbeat_digest. */
+    auditStore?: AppendOnlyAuditStore;
 }
 /**
  * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
  * Exported for unit tests (CR-M1 wiring).
  */
-export declare function resolveAllowedIntentResult(intent: CandidateIntent, runtime: HeartbeatRuntimeSnapshot, inputs: SnapshotInputs, signal: HeartbeatSignal, deps: Pick<HeartbeatDeps, "outreachDispatch" | "quietWorkflow" | "connectorExecutor" | "state" | "workspaceRoot" | "experienceWriter" | "circuitBreakerManager">): Promise<HeartbeatCycleResult>;
+export declare function resolveAllowedIntentResult(intent: CandidateIntent, runtime: HeartbeatRuntimeSnapshot, inputs: SnapshotInputs, signal: HeartbeatSignal, deps: Pick<HeartbeatDeps, "outreachDispatch" | "quietWorkflow" | "connectorExecutor" | "state" | "workspaceRoot" | "experienceWriter" | "circuitBreakerManager" | "auditStore">): Promise<HeartbeatCycleResult>;
 export interface HeartbeatDeps {
     /** Load snapshot inputs from state-system */
     loadSnapshotInputs: () => Promise<SnapshotInputs>;
@@ -86,6 +89,8 @@ export interface HeartbeatDeps {
     idleCuriosityPolicy?: IdleCuriosityPolicy;
     /** v7 T-BTS.C.5: when present, updates breaker state after connector execution. */
     circuitBreakerManager?: CircuitBreakerManager;
+    /** T-OBS.R.1: shared audit sink for connector attempts consumed by heartbeat_digest. */
+    auditStore?: AppendOnlyAuditStore;
 }
 /**
  * Ingest a heartbeat rhythm signal and drive one full decision round.

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

@@ -10,6 +10,7 @@ import { toCapabilityIntent } from "../orchestrator/effect-dispatcher.js";
 import { updateNarrativeAfterEffect } from "../orchestrator/narrative-update.js";
 import { mapLifeEvidence } from "../../../connectors/base/map-life-evidence.js";
 import { appendLifeEvidence } from "../../../storage/life-evidence/append-life-evidence.js";
+import { recordConnectorAttemptAudit } from "../../../observability/services/audit-closure-recorders.js";
 /**
  * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
  * Exported for unit tests (CR-M1 wiring).
@@ -40,6 +41,7 @@ export async function resolveAllowedIntentResult(intent, runtime, inputs, signal
             workspaceRoot: deps.quietWorkflow.workspaceRoot,
             // v7 T-V7C.C.3: pass Dream schedule port so Quiet completion triggers Dream.
             dreamSchedulePort: deps.quietWorkflow.dreamSchedulePort,
+            auditStore: deps.quietWorkflow.auditStore,
         });
         return quietRun.result;
     }
@@ -82,6 +84,15 @@ export async function resolveAllowedIntentResult(intent, runtime, inputs, signal
                 }
                 : undefined,
         });
+        recordConnectorAttemptAudit({
+            auditStore: deps.auditStore,
+            platformId: intent.platformId,
+            capability: toCapabilityIntent(intent),
+            result,
+            triggerSource: "heartbeat",
+            decisionId,
+            intentId: intent.id,
+        });
         // T3.3.1: on success, map connector result to life evidence and append.
         // On failure or empty result, no evidence is fabricated — attempt audit
         // is already recorded by the connector policy layer telemetry.

package/runtime/core/second-nature/quiet/run-source-backed-quiet.d.ts

@@ -10,6 +10,7 @@ import type { HeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js"
 import type { HeartbeatCycleResult } from "../heartbeat/signal.js";
 import { type QuietArtifactAck } from "../../../storage/quiet/quiet-artifact-writer.js";
 import type { UserInterestSnapshot } from "../../../storage/user-interest/types.js";
+import type { AppendOnlyAuditStore } from "../../../observability/audit/append-only-audit-store.js";
 /**
  * Minimal port for triggering Dream after Quiet completion (T-V7C.C.3).
  * Kept narrow so run-source-backed-quiet does not take a hard dependency on dream-scheduler.
@@ -32,6 +33,8 @@ export interface RunSourceBackedQuietParams {
     workspaceRoot?: string;
     /** v7 T-V7C.C.3: when present, a successful Quiet artifact write auto-triggers Dream scheduling. */
     dreamSchedulePort?: QuietDreamSchedulePort;
+    /** T-OBS.R.1: when present, Quiet outcomes write audit truth consumed by heartbeat_digest. */
+    auditStore?: AppendOnlyAuditStore;
 }
 export interface RunSourceBackedQuietResult {
     result: HeartbeatCycleResult;

package/runtime/core/second-nature/quiet/run-source-backed-quiet.js

@@ -2,6 +2,7 @@ import { isLifeEvidenceSliceEmpty } from "../heartbeat/runtime-snapshot.js";
 import { writeQuietArtifact } from "../../../storage/quiet/quiet-artifact-writer.js";
 import { persistQuietArtifactToWorkspace } from "../../../storage/quiet/persist-quiet-artifact.js";
 import { buildEvidencePack, buildQuietNarrativeGuidance, selectInterestBasis } from "../../../guidance/evidence-guidance.js";
+import { recordQuietArtifactAudit } from "../../../observability/services/audit-closure-recorders.js";
 function toGuidanceRef(r) {
     return {
         id: r.id,
@@ -37,7 +38,7 @@ async function maybeScheduleDreamAfterQuiet(dreamSchedulePort, day) {
     }
 }
 export async function runSourceBackedQuiet(params) {
-    const { candidate, runtime, day, userInterestSnapshot, workspaceRoot, dreamSchedulePort } = params;
+    const { candidate, runtime, day, userInterestSnapshot, workspaceRoot, dreamSchedulePort, auditStore } = params;
     const empty = isLifeEvidenceSliceEmpty(runtime.lifeEvidence);
     if (empty) {
         const input = {
@@ -54,6 +55,15 @@ export async function runSourceBackedQuiet(params) {
             const p = await persistQuietArtifactToWorkspace(workspaceRoot, ack, input);
             persistedRelativePath = p.relativePath;
         }
+        recordQuietArtifactAudit({
+            auditStore,
+            day,
+            kind: "empty_state",
+            status: "empty",
+            reasons: ["quiet_empty_state", "no_fictional_narrative"],
+            artifactAck: ack,
+            persistedRelativePath,
+        });
         return {
             result: {
                 scope: "rhythm",
@@ -68,6 +78,13 @@ export async function runSourceBackedQuiet(params) {
     const guidanceRefs = runtime.lifeEvidence.evidenceRefs.map(toGuidanceRef);
     const ep = buildEvidencePack(guidanceRefs);
     if (!ep.ok) {
+        recordQuietArtifactAudit({
+            auditStore,
+            day,
+            kind: "daily_report",
+            status: "blocked",
+            reasons: ep.reasons,
+        });
         return {
             result: {
                 scope: "rhythm",
@@ -78,6 +95,13 @@ export async function runSourceBackedQuiet(params) {
         };
     }
     if (ep.pack.sensitiveBlocked) {
+        recordQuietArtifactAudit({
+            auditStore,
+            day,
+            kind: "daily_report",
+            status: "blocked",
+            reasons: ["quiet_guidance_sensitive_source_blocked"],
+        });
         return {
             result: {
                 scope: "rhythm",
@@ -128,6 +152,14 @@ export async function runSourceBackedQuiet(params) {
         outline: claims.map((c) => c.text),
     });
     if (gq.status === "unavailable") {
+        recordQuietArtifactAudit({
+            auditStore,
+            day,
+            kind: "daily_report",
+            status: "blocked",
+            reasons: gq.reasons,
+            artifactAck: ack,
+        });
         return {
             result: {
                 scope: "rhythm",
@@ -147,6 +179,15 @@ export async function runSourceBackedQuiet(params) {
     const reasons = ["quiet_artifact_written", ...gq.hints.slice(0, 2)];
     if (dreamReason)
         reasons.push(dreamReason);
+    recordQuietArtifactAudit({
+        auditStore,
+        day,
+        kind: "daily_report",
+        status: "completed",
+        reasons,
+        artifactAck: ack,
+        persistedRelativePath,
+    });
     return {
         result: {
             scope: "rhythm",

package/runtime/observability/services/audit-closure-recorders.d.ts

@@ -0,0 +1,31 @@
+import type { ConnectorResult } from "../../connectors/base/contract.js";
+import type { QuietArtifactAck } from "../../storage/quiet/quiet-artifact-writer.js";
+import type { QuietArtifactWrite } from "../../storage/quiet/quiet-artifact-types.js";
+import type { AppendOnlyAuditStore } from "../audit/append-only-audit-store.js";
+export type ConnectorAttemptAuditOutcome = "success" | "failure" | "circuit_open" | "blocked";
+export interface RecordConnectorAttemptAuditInput {
+    auditStore?: AppendOnlyAuditStore;
+    platformId: string;
+    capability: string;
+    result: ConnectorResult<unknown>;
+    triggerSource: "manual_run" | "heartbeat";
+    decisionId?: string;
+    intentId?: string;
+    createdAt?: string;
+}
+export interface RecordQuietArtifactAuditInput {
+    auditStore?: AppendOnlyAuditStore;
+    day: string;
+    kind: QuietArtifactWrite["kind"];
+    status: "completed" | "empty" | "blocked" | "failed";
+    reasons: string[];
+    artifactAck?: QuietArtifactAck;
+    persistedRelativePath?: string;
+    createdAt?: string;
+}
+export declare function recordConnectorAttemptAudit(input: RecordConnectorAttemptAuditInput): {
+    eventId?: string;
+};
+export declare function recordQuietArtifactAudit(input: RecordQuietArtifactAuditInput): {
+    eventId?: string;
+};

package/runtime/observability/services/audit-closure-recorders.js

@@ -0,0 +1,87 @@
+/**
+ * Audit-backed closure recorders for connector attempts and Quiet artifacts.
+ *
+ * Core logic: write small redacted audit envelopes for runtime actions that
+ * heartbeat_digest depends on. Payloads contain outcome and source linkage only;
+ * raw connector payloads and credentials are deliberately excluded.
+ *
+ * Dependencies: AppendOnlyAuditStore and buildAuditEnvelope hash-chain helpers.
+ * Boundary: does not execute connectors, write Quiet artifacts, or mutate state.
+ *
+ * Test coverage: tests/unit/ops/manual-run-dispatcher.test.ts,
+ * tests/unit/observability/heartbeat-digest-assembler.test.ts.
+ */
+import { randomUUID } from "node:crypto";
+import { buildAuditEnvelope } from "../audit/audit-envelope.js";
+function mapConnectorOutcome(result) {
+    if (result.status === "success")
+        return "success";
+    if (result.failureClass === "cooldown_blocked")
+        return "blocked";
+    if (result.failureClass === "platform_unavailable")
+        return "circuit_open";
+    return "failure";
+}
+export function recordConnectorAttemptAudit(input) {
+    if (!input.auditStore)
+        return {};
+    const createdAt = input.createdAt ?? new Date().toISOString();
+    const family = "connector.attempt";
+    const envelope = buildAuditEnvelope({
+        family,
+        plane: "telemetry",
+        traceId: `connector_attempt:${input.triggerSource}:${randomUUID()}`,
+        sequence: input.auditStore.list().length + 1,
+        previousHash: input.auditStore.lastRecordHash(family),
+        createdAt,
+        payload: {
+            platformId: input.platformId,
+            capability: input.capability,
+            outcome: mapConnectorOutcome(input.result),
+            triggerSource: input.triggerSource,
+            status: input.result.status,
+            failureClass: input.result.failureClass,
+            channel: input.result.metadata.channel,
+            latencyMs: input.result.metadata.latencyMs,
+            degraded: Boolean(input.result.metadata.degraded),
+            decisionId: input.decisionId,
+            intentId: input.intentId,
+            createdAt,
+        },
+    });
+    input.auditStore.append(envelope);
+    return { eventId: envelope.eventId };
+}
+export function recordQuietArtifactAudit(input) {
+    if (!input.auditStore)
+        return {};
+    const createdAt = input.createdAt ?? new Date().toISOString();
+    const family = "source_coverage";
+    const sourceRefs = input.artifactAck ? [input.artifactAck.artifactRef] : [];
+    const envelope = buildAuditEnvelope({
+        family,
+        plane: "source_coverage",
+        traceId: `quiet_artifact:${input.day}:${randomUUID()}`,
+        sequence: input.auditStore.list().length + 1,
+        previousHash: input.auditStore.lastRecordHash(family),
+        createdAt,
+        payload: {
+            auditId: `quiet-audit:${input.day}:${randomUUID()}`,
+            traceId: `quiet_trace:${input.day}`,
+            subjectType: "quiet_artifact",
+            subjectRef: input.artifactAck?.artifactRef.uri ?? `quiet:${input.day}:${input.kind}`,
+            day: input.day,
+            kind: input.kind,
+            status: input.status,
+            usedSourceRefs: sourceRefs,
+            unresolvedRefs: [],
+            coverageRatio: input.artifactAck?.sourceCoverage.coverageRatio ?? 0,
+            unsupportedClaims: input.artifactAck?.sourceCoverage.unsupportedClaims ?? [],
+            persistedRelativePath: input.persistedRelativePath,
+            reasonCodes: input.reasons,
+            createdAt,
+        },
+    });
+    input.auditStore.append(envelope);
+    return { eventId: envelope.eventId };
+}

package/runtime/observability/services/heartbeat-digest-assembler.js

@@ -97,10 +97,21 @@ function aggregateHealthSummary(events, dateStr) {
 }
 function aggregateQuietDreamFromAudit(events, dateStr) {
     const dreamEvents = filterByDate(events, "dream.trace", dateStr);
+    const quietEvents = filterByDate(events, "source_coverage", dateStr)
+        .filter((ev) => ev.payload.subjectType === "quiet_artifact");
+    let quietRuns = 0;
+    let quietSucceeded = 0;
     let dreamRuns = 0;
     let dreamAccepted = 0;
     let dreamSkipped = 0;
     const dreamSkipReasons = [];
+    for (const ev of quietEvents) {
+        const payload = ev.payload;
+        quietRuns++;
+        if (payload.status === "completed" || payload.status === "empty") {
+            quietSucceeded++;
+        }
+    }
     for (const ev of dreamEvents) {
         const payload = ev.payload;
         if (payload.event === "dream_started")
@@ -113,10 +124,9 @@ function aggregateQuietDreamFromAudit(events, dateStr) {
                 dreamSkipReasons.push(payload.skipReason);
         }
     }
-    // Quiet stats not yet in audit (narrative.trace not fully wired) — default to 0
     return {
-        quietRuns: 0,
-        quietSucceeded: 0,
+        quietRuns,
+        quietSucceeded,
         dreamRuns,
         dreamAccepted,
         dreamSkipped,