@haaaiawd/second-nature 0.2.1 → 0.2.4

package/runtime/core/second-nature/guidance/impulse-context-writer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * ImpulseContextWriter — Persist assembled impulse + atmosphere as agent-facing artifact.
+ *
+ * Core logic: Convert impulse assembly result into a durable artifact that can be
+ * read during setup, heartbeat, and platform-scene entry without re-assembly.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/guidance-voice-system.md §1`
+ * - `docs/validation/openclaw-plugin-classification.md §5`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (writeImpulseContextArtifact)
+ * - `src/guidance/impulse-assembler.js` (ImpulseAssemblerResult)
+ *
+ * Boundary:
+ * - Does NOT register a fake OpenClaw context-engine.
+ * - Does NOT claim delivery or decision capability.
+ * - Overwrites existing artifact for same scene/capability combo (upsert behavior).
+ */
+import type { StateDatabase } from "../../../storage/db/index.js";
+import type { ImpulseAssemblerResult } from "../../../guidance/impulse-assembler.js";
+import type { SourceRef, DegradedOperationResult } from "../../../shared/types/v8-contracts.js";
+export interface ImpulseContextArtifactInput {
+    sceneType: string;
+    capabilityIntent?: string;
+    platformId?: string;
+    impulseResult: ImpulseAssemblerResult;
+    atmosphereText?: string;
+    expressionBoundaryConstraints: string[];
+    expressionBoundaryStyle?: string;
+}
+export interface WriteArtifactResult {
+    id: string;
+    freshnessVersion: number;
+}
+export declare function writeImpulseContext(db: StateDatabase, input: ImpulseContextArtifactInput, options?: {
+    now?: string;
+    sourceRefs?: SourceRef[];
+}): Promise<WriteArtifactResult | DegradedOperationResult>;

package/runtime/core/second-nature/guidance/impulse-context-writer.js

@@ -0,0 +1,70 @@
+/**
+ * ImpulseContextWriter — Persist assembled impulse + atmosphere as agent-facing artifact.
+ *
+ * Core logic: Convert impulse assembly result into a durable artifact that can be
+ * read during setup, heartbeat, and platform-scene entry without re-assembly.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/guidance-voice-system.md §1`
+ * - `docs/validation/openclaw-plugin-classification.md §5`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (writeImpulseContextArtifact)
+ * - `src/guidance/impulse-assembler.js` (ImpulseAssemblerResult)
+ *
+ * Boundary:
+ * - Does NOT register a fake OpenClaw context-engine.
+ * - Does NOT claim delivery or decision capability.
+ * - Overwrites existing artifact for same scene/capability combo (upsert behavior).
+ */
+import { writeImpulseContextArtifact } from "../../../storage/v8-state-stores.js";
+// ───────────────────────────────────────────────────────────────
+// Helpers
+// ───────────────────────────────────────────────────────────────
+function buildArtifactId(sceneType, capabilityIntent, platformId) {
+    const cap = capabilityIntent ?? "none";
+    const plat = platformId ?? "generic";
+    return `ica_${sceneType}_${cap}_${plat}`;
+}
+// ───────────────────────────────────────────────────────────────
+// Public API
+// ───────────────────────────────────────────────────────────────
+export async function writeImpulseContext(db, input, options) {
+    const now = options?.now ?? new Date().toISOString();
+    const id = buildArtifactId(input.sceneType, input.capabilityIntent, input.platformId);
+    const sourceRefs = options?.sourceRefs ?? [
+        {
+            uri: `sn://impulse-context/${id}`,
+            family: "projection",
+            id,
+            redactionClass: "none",
+            resolveStatus: "resolvable",
+        },
+    ];
+    const result = await writeImpulseContextArtifact(db, {
+        id,
+        createdAt: now,
+        updatedAt: now,
+        sceneType: input.sceneType,
+        capabilityIntent: input.capabilityIntent ?? null,
+        platformId: input.platformId ?? null,
+        capabilityClass: input.impulseResult.capabilityClass ?? null,
+        impulseSource: input.impulseResult.source,
+        impulseText: input.impulseResult.impulse?.text ?? null,
+        atmosphereText: input.atmosphereText ?? null,
+        expressionBoundaryConstraintsJson: JSON.stringify(input.expressionBoundaryConstraints),
+        expressionBoundaryStyle: input.expressionBoundaryStyle ?? null,
+        freshnessVersion: 1,
+        sourceRefs,
+        redactionClass: "none",
+        payloadJson: JSON.stringify({
+            impulseKind: input.impulseResult.impulse?.kind ?? null,
+            impulseReviewStatus: input.impulseResult.impulse?.reviewStatus ?? null,
+        }),
+        lifecycleStatus: "active",
+    });
+    if ("reason" in result) {
+        return result;
+    }
+    return { id, freshnessVersion: 1 };
+}

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/perception/judgment-engine.d.ts

@@ -23,6 +23,7 @@
  */
 import type { StateDatabase } from "../../../storage/db/index.js";
 import type { SourceRef, DegradedOperationResult, PlatformNeutralActionKind, V8ReasonCode } from "../../../shared/types/v8-contracts.js";
+import type { AcceptedProjection } from "../control-plane/accepted-projection-loader.js";
 export interface JudgmentVerdictResult {
     id: string;
     cycleId: string;
@@ -41,6 +42,7 @@ export interface RunAgentJudgmentResult {
 }
 export interface RunAgentJudgmentOptions {
     now?: string;
+    acceptedProjections?: AcceptedProjection[];
 }
 export declare function runAgentJudgment(db: StateDatabase, perceptionCardId: string, options?: RunAgentJudgmentOptions): Promise<RunAgentJudgmentResult | DegradedOperationResult>;
 export interface BatchJudgmentResult {

package/runtime/core/second-nature/perception/judgment-engine.js

@@ -153,7 +153,17 @@ export async function runAgentJudgment(db, perceptionCardId, options) {
             /* ignore */
         }
     }
-    const { actionKind, reason, finalConfidence } = selectVerdict(card.relevance ?? 0.3, card.confidence ?? 0.6, riskPosture, hasSourceRefs, possibleIntents);
+    let { actionKind, reason, finalConfidence } = selectVerdict(card.relevance ?? 0.3, card.confidence ?? 0.6, riskPosture, hasSourceRefs, possibleIntents);
+    // T-DQ.R.3: Boost verdict when accepted memory projection matches topic
+    const acceptedProjections = options?.acceptedProjections ?? [];
+    const matchingProjection = acceptedProjections.find((p) => p.topicKey.toLowerCase() === (card.topic ?? "").toLowerCase());
+    if (matchingProjection) {
+        finalConfidence = Math.min(0.95, finalConfidence + 0.1);
+        if (actionKind === "ignore") {
+            actionKind = "remember";
+            reason = "projection_topic_matched";
+        }
+    }
     const verdict = {
         id: `jud_${perceptionCardId}_${now.replace(/[:.]/g, "")}`,
         cycleId: card.cycleId,

package/runtime/core/second-nature/perception/perception-builder.d.ts

@@ -37,8 +37,12 @@ export interface PerceptionCardResult {
     cycleId: string;
     topic: string;
     entities: string[];
-    novelty: "new" | "recurring" | "update";
-    relevance: number;
+    /** Canonical novelty class: new | changed | duplicate | stale */
+    noveltyClass: "new" | "changed" | "duplicate" | "stale";
+    /** Numeric relevance score in [0, 1] */
+    relevanceScore: number;
+    /** Derived relevance class: low | medium | high */
+    relevanceClass: "low" | "medium" | "high";
     summary: string;
     possibleIntents: PlatformNeutralActionKind[];
     reviewPriority: "low" | "medium" | "high";

package/runtime/core/second-nature/perception/perception-builder.js

@@ -76,12 +76,13 @@ function extractEntities(evidence) {
     }
     return [...new Set(entities)];
 }
-function inferNovelty(evidence) {
+function inferNoveltyClass(evidence) {
+    // Canonical novelty classification
     if (evidence.sensitivityHint === "public_technical")
-        return "recurring";
+        return "changed";
     return "new";
 }
-function inferRelevance(evidence) {
+function inferRelevanceScore(evidence) {
     if (evidence.sensitivityHint === "sensitive")
         return 0.9;
     if (evidence.sensitivityHint === "public_technical")
@@ -90,6 +91,13 @@ function inferRelevance(evidence) {
         return 0.5;
     return 0.3;
 }
+function inferRelevanceClass(score) {
+    if (score >= 0.7)
+        return "high";
+    if (score >= 0.4)
+        return "medium";
+    return "low";
+}
 function inferSummary(evidence) {
     const platform = evidence.platformId;
     const topic = extractTopic(evidence);
@@ -124,13 +132,15 @@ function inferRiskFlags(evidence) {
 }
 function buildCardFromEvidence(evidence, cycleId, now) {
     const sourceRefs = parseSourceRefs(evidence.sourceRefsJson);
+    const relevanceScore = inferRelevanceScore(evidence);
     return {
         id: `per_${evidence.id}`,
         cycleId,
         topic: extractTopic(evidence),
         entities: extractEntities(evidence),
-        novelty: inferNovelty(evidence),
-        relevance: inferRelevance(evidence),
+        noveltyClass: inferNoveltyClass(evidence),
+        relevanceScore,
+        relevanceClass: inferRelevanceClass(relevanceScore),
         summary: inferSummary(evidence),
         possibleIntents: inferPossibleIntents(evidence),
         reviewPriority: inferReviewPriority(evidence),
@@ -177,8 +187,9 @@ export async function buildPerceptionCards(db, options) {
             cycleId: card.cycleId,
             topic: card.topic,
             entitiesJson: JSON.stringify(card.entities),
-            novelty: card.novelty,
-            relevance: card.relevance,
+            novelty: card.noveltyClass,
+            relevance: card.relevanceScore,
+            relevanceClass: card.relevanceClass,
             summary: card.summary,
             riskFlagsJson: JSON.stringify(card.riskFlags),
             confidence: card.confidence,

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/core/second-nature/quiet-dream/daily-rhythm-scheduler.d.ts

@@ -0,0 +1,43 @@
+/**
+ * DailyRhythmScheduler — Independent Quiet/Dream cadence with absence reasons.
+ *
+ * Core logic: Check if today's Quiet review is due (closures exist but no review
+ * yet), schedule/run it, then check Dream status. Records durable states so
+ * loop_status can report exact missing stages even when heartbeat does not
+ * select a quiet intent.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.md §4`
+ * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.detail.md §3.1-§3.4`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (write/read DailyRhythmState)
+ * - `src/core/second-nature/quiet-dream/quiet-daily-review-builder.js`
+ * - `src/core/second-nature/quiet-dream/dream-scheduler.js`
+ *
+ * Boundary:
+ * - Does not run consolidation; only schedules and records lifecycle.
+ * - Does not bypass Dream runner; only records due/completed/blocked.
+ */
+import type { StateDatabase } from "../../../storage/db/index.js";
+import type { DegradedOperationResult, V8ReasonCode } from "../../../shared/types/v8-contracts.js";
+export type RhythmStatus = "due" | "completed" | "skipped" | "blocked" | "not_due";
+export interface DailyRhythmState {
+    day: string;
+    quietStatus: RhythmStatus;
+    dreamStatus: RhythmStatus;
+    quietReason?: V8ReasonCode;
+    dreamReason?: V8ReasonCode;
+    quietCompletedAt?: string;
+    dreamCompletedAt?: string;
+}
+export interface CheckDailyRhythmOptions {
+    now?: string;
+    forceQuiet?: boolean;
+    schedulerAvailable?: boolean;
+}
+export type CheckDailyRhythmResult = {
+    status: "checked";
+    state: DailyRhythmState;
+} | DegradedOperationResult;
+export declare function checkDailyRhythm(db: StateDatabase, options?: CheckDailyRhythmOptions): Promise<CheckDailyRhythmResult>;

package/runtime/core/second-nature/quiet-dream/daily-rhythm-scheduler.js

@@ -0,0 +1,157 @@
+/**
+ * DailyRhythmScheduler — Independent Quiet/Dream cadence with absence reasons.
+ *
+ * Core logic: Check if today's Quiet review is due (closures exist but no review
+ * yet), schedule/run it, then check Dream status. Records durable states so
+ * loop_status can report exact missing stages even when heartbeat does not
+ * select a quiet intent.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.md §4`
+ * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.detail.md §3.1-§3.4`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (write/read DailyRhythmState)
+ * - `src/core/second-nature/quiet-dream/quiet-daily-review-builder.js`
+ * - `src/core/second-nature/quiet-dream/dream-scheduler.js`
+ *
+ * Boundary:
+ * - Does not run consolidation; only schedules and records lifecycle.
+ * - Does not bypass Dream runner; only records due/completed/blocked.
+ */
+import { writeDailyRhythmState, readDailyRhythmStateByDay, readActionClosuresByDay, } from "../../../storage/v8-state-stores.js";
+import { buildQuietDailyReview } from "./quiet-daily-review-builder.js";
+import { scheduleDreamAfterQuiet } from "./dream-scheduler.js";
+// ───────────────────────────────────────────────────────────────
+// Helpers
+// ───────────────────────────────────────────────────────────────
+function todayString(now) {
+    return now.slice(0, 10);
+}
+// ───────────────────────────────────────────────────────────────
+// Public API
+// ───────────────────────────────────────────────────────────────
+export async function checkDailyRhythm(db, options) {
+    const now = options?.now ?? new Date().toISOString();
+    const day = todayString(now);
+    // Read existing rhythm state
+    const existing = await readDailyRhythmStateByDay(db, day);
+    if (existing.degraded) {
+        return existing.degraded;
+    }
+    const state = existing.row
+        ? {
+            day: existing.row.day,
+            quietStatus: existing.row.quietStatus,
+            dreamStatus: existing.row.dreamStatus,
+            quietReason: existing.row.quietReason,
+            dreamReason: existing.row.dreamReason,
+            quietCompletedAt: existing.row.quietCompletedAt ?? undefined,
+            dreamCompletedAt: existing.row.dreamCompletedAt ?? undefined,
+        }
+        : {
+            day,
+            quietStatus: "not_due",
+            dreamStatus: "not_due",
+        };
+    // Check if closures exist for today
+    const closuresRead = await readActionClosuresByDay(db, day);
+    if (closuresRead.degraded) {
+        return closuresRead.degraded;
+    }
+    const hasClosures = closuresRead.rows.length > 0;
+    // Determine Quiet status
+    if (state.quietStatus === "completed" || state.quietStatus === "blocked") {
+        // Already handled; don't re-run
+    }
+    else if (!hasClosures) {
+        state.quietStatus = "not_due";
+        state.quietReason = "quiet_empty_input";
+    }
+    else {
+        // Closures exist but Quiet not completed → due
+        state.quietStatus = "due";
+        state.quietReason = "quiet_empty_input";
+        // Auto-run Quiet if forced or if not yet attempted
+        if (options?.forceQuiet || state.quietStatus === "due") {
+            const quietResult = await buildQuietDailyReview(db, { day, now });
+            if (quietResult.status === "completed") {
+                state.quietStatus = "completed";
+                state.quietReason = "quiet_completed";
+                state.quietCompletedAt = now;
+            }
+            else if (quietResult.status === "empty") {
+                state.quietStatus = "skipped";
+                state.quietReason = quietResult.reason ?? "quiet_empty_input";
+            }
+            else {
+                // Degraded
+                state.quietStatus = "blocked";
+                state.quietReason = quietResult.reason ?? "state_unreadable";
+            }
+        }
+    }
+    // Determine Dream status based on Quiet outcome
+    if (state.quietStatus === "completed") {
+        if (state.dreamStatus === "completed" || state.dreamStatus === "blocked") {
+            // Already handled
+        }
+        else {
+            state.dreamStatus = "due";
+            state.dreamReason = "dream_scheduled";
+            // Schedule Dream
+            const quietId = `quiet_${day}`;
+            const dreamResult = await scheduleDreamAfterQuiet(db, quietId, {
+                now,
+                schedulerAvailable: options?.schedulerAvailable ?? true,
+            });
+            if ("reason" in dreamResult) {
+                state.dreamStatus = "blocked";
+                state.dreamReason = dreamResult.reason;
+            }
+            else if (dreamResult.status === "blocked") {
+                state.dreamStatus = "blocked";
+                state.dreamReason = dreamResult.reason ?? "dream_scheduler_unavailable";
+            }
+            else {
+                state.dreamStatus = "scheduled";
+                state.dreamReason = "dream_scheduled";
+            }
+        }
+    }
+    else if (state.quietStatus === "not_due") {
+        state.dreamStatus = "not_due";
+        state.dreamReason = "quiet_empty_input";
+    }
+    else {
+        // Quiet blocked/skipped → Dream cannot run
+        state.dreamStatus = "blocked";
+        state.dreamReason = "dream_blocked_redaction";
+    }
+    // Persist state
+    const writeResult = await writeDailyRhythmState(db, {
+        id: `rhythm_${day}`,
+        day,
+        quietStatus: state.quietStatus,
+        dreamStatus: state.dreamStatus,
+        quietReason: state.quietReason ?? null,
+        dreamReason: state.dreamReason ?? null,
+        quietCompletedAt: state.quietCompletedAt ?? null,
+        dreamCompletedAt: state.dreamCompletedAt ?? null,
+        sourceRefs: [
+            {
+                uri: `sn://rhythm/${day}`,
+                family: "dream_run",
+                id: `rhythm_${day}`,
+                redactionClass: "none",
+                resolveStatus: "resolvable",
+            },
+        ],
+        payloadJson: JSON.stringify({ checkedAt: now, hasClosures: closuresRead.rows.length }),
+        updatedAt: now,
+    });
+    if ("reason" in writeResult) {
+        return writeResult;
+    }
+    return { status: "checked", state };
+}

package/runtime/core/second-nature/quiet-dream/memory-projection-lifecycle.js

@@ -20,7 +20,7 @@
  *
  * Test coverage: tests/unit/dream/memory-projection-lifecycle.test.ts
  */
-import { readMemoryProjectionsByTopic, writeLongTermMemoryProjection, } from "../../../storage/v8-state-stores.js";
+import { readMemoryProjectionsByTopic, writeLongTermMemoryProjection, updateLongTermMemoryProjectionStatus, } from "../../../storage/v8-state-stores.js";
 // ───────────────────────────────────────────────────────────────
 // Public API
 // ───────────────────────────────────────────────────────────────
@@ -44,21 +44,12 @@ export async function acceptMemoryProjection(db, candidateId, topicKey, memoryTe
     const activeProjection = existing.rows.find((r) => r.status === "active" || r.status === "accepted");
     let supersedesId;
     if (activeProjection) {
-        // Supersede existing active projection
-        const supersedeResult = await writeLongTermMemoryProjection(db, {
-            id: activeProjection.id,
-            createdAt: activeProjection.createdAt,
-            candidateId: activeProjection.candidateId,
-            topicKey: activeProjection.topicKey,
-            status: "superseded",
-            sourceRefs: parseSourceRefs(activeProjection.sourceRefsJson),
-            redactionClass: activeProjection.redactionClass,
-            lifecycleStatus: "superseded",
-            payloadJson: JSON.stringify({
-                supersededAt: now,
-                supersededBy: candidateId,
-            }),
-        });
+        // Supersede existing active projection — UPDATE instead of INSERT
+        const supersedeResult = await updateLongTermMemoryProjectionStatus(db, activeProjection.id, "superseded", JSON.stringify({
+            ...parsePayloadJson(activeProjection.payloadJson),
+            supersededAt: now,
+            supersededBy: candidateId,
+        }));
         if ("reason" in supersedeResult) {
             return supersedeResult;
         }
@@ -149,3 +140,13 @@ function parseSourceRefs(json) {
         return [];
     }
 }
+function parsePayloadJson(json) {
+    if (!json)
+        return {};
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return {};
+    }
+}

package/runtime/core/second-nature/quiet-dream/quiet-daily-review-builder.d.ts

@@ -27,7 +27,10 @@ export interface QuietDailyReviewResult {
     day: string;
     closureCount: number;
     memoryCandidateCount: number;
+    /** Generic source refs (closure + perception + other) */
     sourceRefs: SourceRef[];
+    /** Explicit closure refs — first-class provenance for reviewed ActionClosureRecords */
+    closureRefs: SourceRef[];
     reviewSummary: string;
     importanceSignals: string[];
     createdAt: string;