@haaaiawd/second-nature 0.2.0 → 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.0",
+  "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,

package/runtime/storage/db/index.js

@@ -176,6 +176,125 @@ const STATE_SCHEMA_SQL = `
   CREATE INDEX IF NOT EXISTS memory_store_created_at_idx ON memory_store(created_at);
   CREATE INDEX IF NOT EXISTS memory_store_input_idx ON memory_store(input_memory_store_id);
   CREATE INDEX IF NOT EXISTS memory_store_dream_run_idx ON memory_store(dream_run_id);
+  -- v8 Living Perception Loop entities
+  CREATE TABLE IF NOT EXISTS evidence_item (
+    id TEXT PRIMARY KEY,
+    created_at TEXT NOT NULL,
+    platform_id TEXT NOT NULL,
+    content_hash TEXT NOT NULL,
+    observed_at TEXT NOT NULL,
+    sensitivity_hint TEXT,
+    source_refs_json TEXT NOT NULL,
+    redaction_class TEXT NOT NULL DEFAULT 'none',
+    payload_json TEXT,
+    lifecycle_status TEXT NOT NULL DEFAULT 'pending'
+  );
+  CREATE TABLE IF NOT EXISTS perception_card (
+    id TEXT PRIMARY KEY,
+    created_at TEXT NOT NULL,
+    cycle_id TEXT NOT NULL,
+    topic TEXT,
+    entities_json TEXT,
+    novelty TEXT,
+    relevance REAL,
+    summary TEXT,
+    risk_flags_json TEXT,
+    confidence REAL,
+    review_priority TEXT,
+    source_refs_json TEXT NOT NULL,
+    redaction_class TEXT NOT NULL DEFAULT 'none',
+    payload_json TEXT,
+    lifecycle_status TEXT NOT NULL DEFAULT 'pending'
+  );
+  CREATE TABLE IF NOT EXISTS judgment_verdict (
+    id TEXT PRIMARY KEY,
+    created_at TEXT NOT NULL,
+    cycle_id TEXT NOT NULL,
+    perception_card_id TEXT NOT NULL,
+    action_kind TEXT NOT NULL,
+    confidence REAL,
+    reason TEXT,
+    risk_posture TEXT,
+    source_refs_json TEXT NOT NULL,
+    redaction_class TEXT NOT NULL DEFAULT 'none',
+    payload_json TEXT,
+    lifecycle_status TEXT NOT NULL DEFAULT 'pending'
+  );
+  CREATE TABLE IF NOT EXISTS action_closure_record (
+    id TEXT PRIMARY KEY,
+    created_at TEXT NOT NULL,
+    cycle_id TEXT NOT NULL,
+    proposal_id TEXT,
+    decision_id TEXT,
+    status TEXT NOT NULL,
+    reason TEXT,
+    next_state TEXT,
+    source_refs_json TEXT NOT NULL,
+    redaction_class TEXT NOT NULL DEFAULT 'none',
+    payload_json TEXT,
+    lifecycle_status TEXT NOT NULL DEFAULT 'closed'
+  );
+  CREATE TABLE IF NOT EXISTS quiet_daily_review (
+    id TEXT PRIMARY KEY,
+    created_at TEXT NOT NULL,
+    day TEXT NOT NULL,
+    closure_count INTEGER NOT NULL DEFAULT 0,
+    memory_candidate_count INTEGER NOT NULL DEFAULT 0,
+    source_refs_json TEXT NOT NULL,
+    redaction_class TEXT NOT NULL DEFAULT 'none',
+    payload_json TEXT,
+    lifecycle_status TEXT NOT NULL DEFAULT 'pending'
+  );
+  CREATE TABLE IF NOT EXISTS dream_consolidation_run (
+    id TEXT PRIMARY KEY,
+    created_at TEXT NOT NULL,
+    quiet_review_id TEXT NOT NULL,
+    status TEXT NOT NULL,
+    reason TEXT,
+    source_refs_json TEXT NOT NULL,
+    redaction_class TEXT NOT NULL DEFAULT 'none',
+    payload_json TEXT,
+    lifecycle_status TEXT NOT NULL DEFAULT 'pending'
+  );
+  CREATE TABLE IF NOT EXISTS long_term_memory_projection (
+    id TEXT PRIMARY KEY,
+    created_at TEXT NOT NULL,
+    candidate_id TEXT NOT NULL,
+    topic_key TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'candidate',
+    source_refs_json TEXT NOT NULL,
+    redaction_class TEXT NOT NULL DEFAULT 'none',
+    payload_json TEXT,
+    lifecycle_status TEXT NOT NULL DEFAULT 'candidate'
+  );
+  CREATE TABLE IF NOT EXISTS heartbeat_cycle_trace (
+    id TEXT PRIMARY KEY,
+    cycle_sequence INTEGER NOT NULL,
+    heartbeat_started_at TEXT NOT NULL,
+    heartbeat_completed_at TEXT,
+    input_count INTEGER NOT NULL DEFAULT 0,
+    output_count INTEGER NOT NULL DEFAULT 0,
+    expected_downstream_by_cycle INTEGER,
+    status TEXT NOT NULL,
+    source_refs_json TEXT,
+    redaction_class TEXT NOT NULL DEFAULT 'none',
+    payload_json TEXT,
+    lifecycle_status TEXT NOT NULL DEFAULT 'started'
+  );
+  CREATE TABLE IF NOT EXISTS loop_stage_event (
+    id TEXT PRIMARY KEY,
+    cycle_id TEXT NOT NULL,
+    cycle_sequence INTEGER NOT NULL,
+    stage TEXT NOT NULL,
+    status TEXT NOT NULL,
+    reason TEXT,
+    source_refs_json TEXT NOT NULL,
+    redaction_class TEXT NOT NULL DEFAULT 'none',
+    occurred_at TEXT NOT NULL,
+    expected_downstream_by_cycle INTEGER,
+    payload_json TEXT,
+    lifecycle_status TEXT NOT NULL DEFAULT 'started'
+  );
 `;
 function resolveDbPath(filename) {
     if (path.isAbsolute(filename) || filename === ":memory:") {

package/runtime/storage/db/migrations/index.js

@@ -5,9 +5,11 @@ import { V7_001_FOUNDATION } from "./v7-001-foundation.js";
 import { V7_002_EFFECT_COMMIT_LEDGER } from "./v7-002-effect-commit-ledger.js";
 import { V7_003_CIRCUIT_BREAKER } from "./v7-003-circuit-breaker.js";
 import { V7_004_BEHAVIOR_PROMOTION } from "./v7-004-behavior-promotion.js";
+import { V8_001_LIVING_PERCEPTION_LOOP } from "./v8-001-living-perception-loop.js";
 export const ALL_MIGRATIONS = [
     V7_001_FOUNDATION,
     V7_002_EFFECT_COMMIT_LEDGER,
     V7_003_CIRCUIT_BREAKER,
     V7_004_BEHAVIOR_PROMOTION,
+    V8_001_LIVING_PERCEPTION_LOOP,
 ];

package/runtime/storage/db/migrations/v8-001-living-perception-loop.d.ts

@@ -0,0 +1,10 @@
+/**
+ * v8-001 Living Perception Loop migration — adds v8 entity tables.
+ *
+ * Dependencies: v7-004 (behavior_promotion already exists).
+ */
+export declare const V8_001_LIVING_PERCEPTION_LOOP: {
+    version: number;
+    label: string;
+    sql: string;
+};

package/runtime/storage/db/migrations/v8-001-living-perception-loop.js

@@ -0,0 +1,129 @@
+/**
+ * v8-001 Living Perception Loop migration — adds v8 entity tables.
+ *
+ * Dependencies: v7-004 (behavior_promotion already exists).
+ */
+export const V8_001_LIVING_PERCEPTION_LOOP = {
+    version: 5,
+    label: "v8-living-perception-loop",
+    sql: `
+    CREATE TABLE IF NOT EXISTS evidence_item (
+      id TEXT PRIMARY KEY,
+      created_at TEXT NOT NULL,
+      platform_id TEXT NOT NULL,
+      content_hash TEXT NOT NULL,
+      observed_at TEXT NOT NULL,
+      sensitivity_hint TEXT,
+      source_refs_json TEXT NOT NULL,
+      redaction_class TEXT NOT NULL DEFAULT 'none',
+      payload_json TEXT,
+      lifecycle_status TEXT NOT NULL DEFAULT 'pending'
+    );
+    CREATE TABLE IF NOT EXISTS perception_card (
+      id TEXT PRIMARY KEY,
+      created_at TEXT NOT NULL,
+      cycle_id TEXT NOT NULL,
+      topic TEXT,
+      entities_json TEXT,
+      novelty TEXT,
+      relevance REAL,
+      summary TEXT,
+      risk_flags_json TEXT,
+      confidence REAL,
+      review_priority TEXT,
+      source_refs_json TEXT NOT NULL,
+      redaction_class TEXT NOT NULL DEFAULT 'none',
+      payload_json TEXT,
+      lifecycle_status TEXT NOT NULL DEFAULT 'pending'
+    );
+    CREATE TABLE IF NOT EXISTS judgment_verdict (
+      id TEXT PRIMARY KEY,
+      created_at TEXT NOT NULL,
+      cycle_id TEXT NOT NULL,
+      perception_card_id TEXT NOT NULL,
+      action_kind TEXT NOT NULL,
+      confidence REAL,
+      reason TEXT,
+      risk_posture TEXT,
+      source_refs_json TEXT NOT NULL,
+      redaction_class TEXT NOT NULL DEFAULT 'none',
+      payload_json TEXT,
+      lifecycle_status TEXT NOT NULL DEFAULT 'pending'
+    );
+    CREATE TABLE IF NOT EXISTS action_closure_record (
+      id TEXT PRIMARY KEY,
+      created_at TEXT NOT NULL,
+      cycle_id TEXT NOT NULL,
+      proposal_id TEXT,
+      decision_id TEXT,
+      status TEXT NOT NULL,
+      reason TEXT,
+      next_state TEXT,
+      source_refs_json TEXT NOT NULL,
+      redaction_class TEXT NOT NULL DEFAULT 'none',
+      payload_json TEXT,
+      lifecycle_status TEXT NOT NULL DEFAULT 'closed'
+    );
+    CREATE TABLE IF NOT EXISTS quiet_daily_review (
+      id TEXT PRIMARY KEY,
+      created_at TEXT NOT NULL,
+      day TEXT NOT NULL,
+      closure_count INTEGER NOT NULL DEFAULT 0,
+      memory_candidate_count INTEGER NOT NULL DEFAULT 0,
+      source_refs_json TEXT NOT NULL,
+      redaction_class TEXT NOT NULL DEFAULT 'none',
+      payload_json TEXT,
+      lifecycle_status TEXT NOT NULL DEFAULT 'pending'
+    );
+    CREATE TABLE IF NOT EXISTS dream_consolidation_run (
+      id TEXT PRIMARY KEY,
+      created_at TEXT NOT NULL,
+      quiet_review_id TEXT NOT NULL,
+      status TEXT NOT NULL,
+      reason TEXT,
+      source_refs_json TEXT NOT NULL,
+      redaction_class TEXT NOT NULL DEFAULT 'none',
+      payload_json TEXT,
+      lifecycle_status TEXT NOT NULL DEFAULT 'pending'
+    );
+    CREATE TABLE IF NOT EXISTS long_term_memory_projection (
+      id TEXT PRIMARY KEY,
+      created_at TEXT NOT NULL,
+      candidate_id TEXT NOT NULL,
+      topic_key TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'candidate',
+      source_refs_json TEXT NOT NULL,
+      redaction_class TEXT NOT NULL DEFAULT 'none',
+      payload_json TEXT,
+      lifecycle_status TEXT NOT NULL DEFAULT 'candidate'
+    );
+    CREATE TABLE IF NOT EXISTS heartbeat_cycle_trace (
+      id TEXT PRIMARY KEY,
+      cycle_sequence INTEGER NOT NULL,
+      heartbeat_started_at TEXT NOT NULL,
+      heartbeat_completed_at TEXT,
+      input_count INTEGER NOT NULL DEFAULT 0,
+      output_count INTEGER NOT NULL DEFAULT 0,
+      expected_downstream_by_cycle INTEGER,
+      status TEXT NOT NULL,
+      source_refs_json TEXT,
+      redaction_class TEXT NOT NULL DEFAULT 'none',
+      payload_json TEXT,
+      lifecycle_status TEXT NOT NULL DEFAULT 'started'
+    );
+    CREATE TABLE IF NOT EXISTS loop_stage_event (
+      id TEXT PRIMARY KEY,
+      cycle_id TEXT NOT NULL,
+      cycle_sequence INTEGER NOT NULL,
+      stage TEXT NOT NULL,
+      status TEXT NOT NULL,
+      reason TEXT,
+      source_refs_json TEXT NOT NULL,
+      redaction_class TEXT NOT NULL DEFAULT 'none',
+      occurred_at TEXT NOT NULL,
+      expected_downstream_by_cycle INTEGER,
+      payload_json TEXT,
+      lifecycle_status TEXT NOT NULL DEFAULT 'started'
+    );
+  `,
+};