@haaaiawd/second-nature 0.2.12 → 0.2.13

package/runtime/core/second-nature/control-plane/heartbeat-orchestrator.js

@@ -31,6 +31,7 @@ import { evaluateActionPolicy } from "../action/autonomy-policy-evaluator.js";
 import { dispatchAllowedAction } from "../action/policy-bound-dispatch.js";
 import { recordNoActionClosure, recordRememberClosure, recordPolicyOutcomeClosure, recordExecutionClosure, } from "../action/action-closure-recorder.js";
 import { checkDailyRhythm } from "../quiet-dream/daily-rhythm-scheduler.js";
+import { classifyDegradedStatus } from "../../../shared/degraded-status-classifier.js";
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
@@ -84,7 +85,7 @@ async function advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef,
     catch (rhythmErr) {
         const errMsg = rhythmErr instanceof Error ? rhythmErr.message : String(rhythmErr);
         const degraded = {
-            status: "degraded",
+            status: classifyDegradedStatus("state_unreadable"),
             reason: "state_unreadable",
             ownerStage: "quiet",
             sourceRefs: [cycleRef],
@@ -130,7 +131,7 @@ export async function runHeartbeatCycle(db, request) {
     });
     if ("reason" in traceResult) {
         return {
-            status: "degraded",
+            status: classifyDegradedStatus("state_unreadable"),
             reason: "state_unreadable",
             ownerStage: "ingestion",
             sourceRefs: [cycleRef],
@@ -150,7 +151,7 @@ export async function runHeartbeatCycle(db, request) {
     });
     // ── Perception stage ──
     const perceptionResult = await buildPerceptionCards(db, { cycleId, now });
-    const perceptionDegraded = "status" in perceptionResult && perceptionResult.status === "degraded"
+    const perceptionDegraded = "ownerStage" in perceptionResult
         ? perceptionResult
         : null;
     await recordLoopStageEvent(db, {
@@ -199,8 +200,8 @@ export async function runHeartbeatCycle(db, request) {
             noActionReason: degradedReason,
             degraded: perceptionDegraded
                 ? {
-                    status: "degraded",
-                    reason: perceptionResult.reason ?? "state_unreadable",
+                    status: classifyDegradedStatus(degradedReason),
+                    reason: degradedReason,
                     ownerStage: "perception",
                     sourceRefs: [cycleRef],
                     operatorNextAction: "Retry heartbeat after perception recovery",
@@ -327,7 +328,7 @@ export async function runHeartbeatCycle(db, request) {
         else {
             // Build proposal for the actionable verdict
             const proposalResult = await buildActionProposal(db, actionableVerdict.id, { now });
-            if ("status" in proposalResult && proposalResult.status === "degraded") {
+            if ("operatorNextAction" in proposalResult) {
                 // Proposal build failed — still need a closure
                 closureDegraded = proposalResult;
                 const closureResult = await recordNoActionClosure(db, cycleId, closureDegraded.reason, { now });
@@ -398,7 +399,8 @@ export async function runHeartbeatCycle(db, request) {
                     status: "completed",
                     occurredAt: new Date().toISOString(),
                     reason: decision.decisionReason,
-                    sourceRefs: decision.proofRefs,
+                    sourceRefs: proposal.sourceRefs,
+                    proofRefs: decision.proofRefs,
                 });
                 // Record execution stage started
                 await recordLoopStageEvent(db, {
@@ -408,7 +410,8 @@ export async function runHeartbeatCycle(db, request) {
                     stage: "execution",
                     status: "started",
                     occurredAt: new Date().toISOString(),
-                    sourceRefs: decision.proofRefs,
+                    sourceRefs: proposal.sourceRefs,
+                    proofRefs: decision.proofRefs,
                 });
                 // Dispatch — no real external write in T-CP.R.2
                 const dispatchResult = dispatchAllowedAction(proposal, decision, { guidanceAvailable: false });
@@ -512,7 +515,8 @@ export async function runHeartbeatCycle(db, request) {
                     status: closureDegraded ? "failed" : "completed",
                     occurredAt: new Date().toISOString(),
                     reason: closureDegraded?.reason,
-                    sourceRefs: decision.proofRefs,
+                    sourceRefs: proposal.sourceRefs,
+                    proofRefs: decision.proofRefs,
                 });
             }
         }

package/runtime/core/second-nature/control-plane/real-runtime-spine.js

@@ -27,7 +27,7 @@ export async function runRealRuntimeHeartbeatCycle(options) {
     };
     const result = await runHeartbeatCycle(options.state, request);
     // Pass through degraded results directly
-    if ("status" in result && result.status === "degraded") {
+    if ("status" in result) {
         return result;
     }
     const orchestrationResult = result;

package/runtime/core/second-nature/guidance/guidance-proposal-consumer.d.ts

@@ -29,10 +29,11 @@ export interface GuidanceOutput {
     mode: "draft" | "notify";
     textRef: SourceRef;
     sourceRefs: SourceRef[];
+    proofRefs: SourceRef[];
     deliveryClaim: "not_delivered";
     decisionId: string;
     actionKind: PlatformNeutralActionKind;
-    ownerVisible: boolean;
+    ownerVisible: true;
 }
 export type GuidanceValidationResult = {
     ok: true;

package/runtime/core/second-nature/guidance/guidance-proposal-consumer.js

@@ -68,7 +68,8 @@ function buildGuidanceOutput(proposal, decision) {
         id: `guidance_${decision.id}_${Date.now()}`,
         mode,
         textRef,
-        sourceRefs: [...proposal.sourceRefs, ...decision.proofRefs],
+        sourceRefs: proposal.sourceRefs,
+        proofRefs: decision.proofRefs,
         deliveryClaim: "not_delivered",
         decisionId: decision.id,
         actionKind,
@@ -87,7 +88,8 @@ export function consumeGuidanceProposal(proposal, decision) {
                 status: "blocked",
                 reason: "policy_denied_high_risk",
                 ownerStage: "execution",
-                sourceRefs: decision.proofRefs,
+                sourceRefs: proposal.sourceRefs,
+                proofRefs: decision.proofRefs,
                 operatorNextAction: "Review policy decision before requesting guidance",
                 retryable: false,
             },

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

@@ -24,6 +24,7 @@
 import { readPerceptionCardById, writeJudgmentVerdict, } from "../../../storage/v8-state-stores.js";
 import { parseSourceRefs } from "../../../shared/serialization.js";
 import { ACTION_KIND_REGISTRY } from "../../../shared/types/v8-contracts.js";
+import { classifyDegradedStatus } from "../../../shared/degraded-status-classifier.js";
 // ───────────────────────────────────────────────────────────────
 // Config
 // ───────────────────────────────────────────────────────────────
@@ -107,7 +108,7 @@ export async function runAgentJudgment(db, perceptionCardId, options) {
     const card = readResult.row;
     if (!card) {
         return {
-            status: "degraded",
+            status: classifyDegradedStatus("state_unreadable"),
             reason: "state_unreadable",
             ownerStage: "judgment",
             sourceRefs: [],
@@ -194,9 +195,12 @@ export async function runAgentJudgment(db, perceptionCardId, options) {
     });
     if ("reason" in writeResult) {
         return {
-            status: "degraded",
-            verdicts: [],
+            status: classifyDegradedStatus(writeResult.reason),
             reason: writeResult.reason,
+            ownerStage: "judgment",
+            sourceRefs: [],
+            operatorNextAction: `Failed to persist JudgmentVerdict: ${writeResult.reason}`,
+            retryable: true,
         };
     }
     return {
@@ -218,7 +222,7 @@ export async function runAgentJudgments(db, perceptionCardIds, options) {
                 failed.push({
                     perceptionCardId,
                     degraded: {
-                        status: "degraded",
+                        status: classifyDegradedStatus(result.reason ?? "judgment_low_confidence"),
                         reason: result.reason ?? "judgment_low_confidence",
                         ownerStage: "judgment",
                         sourceRefs: [],

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

@@ -23,6 +23,7 @@
  */
 import { readEvidenceItemsByStatus, writePerceptionCard, updateEvidenceItemLifecycleStatus, } from "../../../storage/v8-state-stores.js";
 import { parseSourceRefs } from "../../../shared/serialization.js";
+import { classifyDegradedStatus } from "../../../shared/degraded-status-classifier.js";
 // ───────────────────────────────────────────────────────────────
 // Config
 // ───────────────────────────────────────────────────────────────
@@ -110,6 +111,14 @@ function inferRelevanceClass(score) {
 }
 function inferSummary(evidence) {
     const payload = parsePayload(evidence.payloadJson);
+    if (payload?.contentStatus === "content_missing") {
+        return {
+            summary: payload.contentMissingReason
+                ? `Content missing from ${evidence.platformId}: ${payload.contentMissingReason}`
+                : `Ref-only observation from ${evidence.platformId}: no readable content`,
+            contentMissing: true,
+        };
+    }
     if (payload?.summary && String(payload.summary).trim().length > 0) {
         return { summary: String(payload.summary), contentMissing: false };
     }
@@ -246,9 +255,12 @@ export async function buildPerceptionCards(db, options) {
         });
         if ("reason" in writeResult) {
             return {
-                status: "degraded",
-                cards,
+                status: classifyDegradedStatus(writeResult.reason),
                 reason: writeResult.reason,
+                ownerStage: "perception",
+                sourceRefs: card.evidenceRefs,
+                operatorNextAction: `Failed to persist PerceptionCard: ${writeResult.reason}`,
+                retryable: true,
             };
         }
         await updateEvidenceItemLifecycleStatus(db, evidence.id, "perceived");

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

@@ -26,6 +26,7 @@ import { writeDailyRhythmState, readDailyRhythmStateByDay, readActionClosuresByD
 import { buildQuietDailyReview } from "./quiet-daily-review-builder.js";
 import { scheduleDreamAfterQuiet } from "./dream-scheduler.js";
 import { runDreamConsolidation } from "./dream-consolidation-runner.js";
+import { acceptMemoryProjection } from "./memory-projection-lifecycle.js";
 // ───────────────────────────────────────────────────────────────
 // Config
 // ───────────────────────────────────────────────────────────────
@@ -106,7 +107,7 @@ async function executeStaleScheduledDreams(db, state, now) {
             continue;
         if ((run.status === "scheduled" || run.status === "started") && isStaleScheduled(run, now)) {
             const consolidateResult = await runDreamConsolidation(db, runId, { now });
-            if ("status" in consolidateResult && consolidateResult.status !== "degraded") {
+            if ("status" in consolidateResult && !("ownerStage" in consolidateResult)) {
                 const dreamResult = consolidateResult;
                 const finalStatus = dreamResult.status;
                 const finalReason = dreamResult.reason ?? undefined;
@@ -122,6 +123,20 @@ async function executeStaleScheduledDreams(db, state, now) {
                 if ("reason" in updateResult) {
                     return updateResult;
                 }
+                // T-DQ.R.10: Accept valid candidates as long-term memory projections.
+                // This step was moved out of the runner to separate candidate generation
+                // from acceptance, per design §4.2.
+                if (dreamResult.status === "completed") {
+                    for (const candidate of dreamResult.candidates.filter((c) => c.validationStatus === "valid")) {
+                        const acceptResult = await acceptMemoryProjection(db, candidate.id, `topic_${state.day}`, candidate.candidateText, candidate.sourceRefs, { now });
+                        if ("projectionId" in acceptResult) {
+                            candidate.acceptedProjectionId = acceptResult.projectionId;
+                        }
+                        else {
+                            return acceptResult;
+                        }
+                    }
+                }
                 lastResult = { completed: true, reason: finalReason ?? "dream_scheduled_stalled" };
             }
             else {
@@ -207,7 +222,7 @@ export async function checkDailyRhythm(db, options) {
         else if (state.dreamStatus === "scheduled") {
             // Stale scheduled run: try to execute consolidation now
             const staleResult = await executeStaleScheduledDreams(db, state, now);
-            if ("status" in staleResult && staleResult.status === "degraded") {
+            if ("status" in staleResult) {
                 return staleResult;
             }
             const { completed, reason } = staleResult;
@@ -262,7 +277,7 @@ export async function checkDailyRhythm(db, options) {
                     // Immediately execute the freshly scheduled dream so it does not sit
                     // pending forever (T-DQ.R.7).
                     const consolidateResult = await runDreamConsolidation(db, dreamResult.id, { now });
-                    if ("status" in consolidateResult && consolidateResult.status !== "degraded") {
+                    if ("status" in consolidateResult && !("ownerStage" in consolidateResult)) {
                         const dreamOutcome = consolidateResult;
                         const updateResult = await updateDreamConsolidationRunStatus(db, dreamResult.id, dreamOutcome.status, {
                             reason: dreamOutcome.reason ?? null,
@@ -278,6 +293,18 @@ export async function checkDailyRhythm(db, options) {
                         state.dreamReason = dreamOutcome.reason ?? (dreamOutcome.status === "completed" ? "dream_completed" : "dream_failed");
                         if (dreamOutcome.status === "completed") {
                             state.dreamCompletedAt = now;
+                            // T-DQ.R.10: Accept valid candidates as long-term memory projections.
+                            // This step was moved out of the runner to separate candidate generation
+                            // from acceptance, per design §4.2.
+                            for (const candidate of dreamOutcome.candidates.filter((c) => c.validationStatus === "valid")) {
+                                const acceptResult = await acceptMemoryProjection(db, candidate.id, `topic_${day}`, candidate.candidateText, candidate.sourceRefs, { now });
+                                if ("projectionId" in acceptResult) {
+                                    candidate.acceptedProjectionId = acceptResult.projectionId;
+                                }
+                                else {
+                                    return acceptResult;
+                                }
+                            }
                         }
                     }
                     else {

package/runtime/core/second-nature/quiet-dream/dream-consolidation-runner.d.ts

@@ -10,13 +10,17 @@
  * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.md §4.2`
  *
  * Dependencies:
- * - `src/storage/v8-state-stores.js` (readDreamConsolidationRunById, readQuietDailyReviewById, writeLongTermMemoryProjection)
+ * - `src/storage/v8-state-stores.js` (readDreamConsolidationRunById, readQuietDailyReviewById)
  * - `src/shared/types/v8-contracts.js` (SourceRef, DegradedOperationResult, V8ReasonCode)
  *
  * Boundary:
  * - Rules-only candidate generation; no model assist in this version.
  * - Does not accept/reject projections; only creates candidates.
  * - Redaction gate blocks sensitive private content, preserves public technical.
+ * - T-DQ.R.10: Does NOT call acceptMemoryProjection. Candidate acceptance is a
+ *   separate step owned by the caller (dream-scheduler or explicit accept API).
+ *   The runner only generates and validates candidates; it returns them for
+ *   the caller to accept via `acceptMemoryProjection(candidateId)`.
  *
  * Test coverage: tests/unit/dream/dream-consolidation-runner.test.ts
  */

package/runtime/core/second-nature/quiet-dream/dream-consolidation-runner.js

@@ -10,18 +10,22 @@
  * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.md §4.2`
  *
  * Dependencies:
- * - `src/storage/v8-state-stores.js` (readDreamConsolidationRunById, readQuietDailyReviewById, writeLongTermMemoryProjection)
+ * - `src/storage/v8-state-stores.js` (readDreamConsolidationRunById, readQuietDailyReviewById)
  * - `src/shared/types/v8-contracts.js` (SourceRef, DegradedOperationResult, V8ReasonCode)
  *
  * Boundary:
  * - Rules-only candidate generation; no model assist in this version.
  * - Does not accept/reject projections; only creates candidates.
  * - Redaction gate blocks sensitive private content, preserves public technical.
+ * - T-DQ.R.10: Does NOT call acceptMemoryProjection. Candidate acceptance is a
+ *   separate step owned by the caller (dream-scheduler or explicit accept API).
+ *   The runner only generates and validates candidates; it returns them for
+ *   the caller to accept via `acceptMemoryProjection(candidateId)`.
  *
  * Test coverage: tests/unit/dream/dream-consolidation-runner.test.ts
  */
 import { readDreamConsolidationRunById, readQuietDailyReviewById, } from "../../../storage/v8-state-stores.js";
-import { acceptMemoryProjection } from "./memory-projection-lifecycle.js";
+import { classifyDegradedStatus } from "../../../shared/degraded-status-classifier.js";
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
@@ -47,9 +51,13 @@ function buildSourceRefsFromReview(review) {
     ];
 }
 function redactSensitive(input) {
-    // Simple redaction: block credential-shaped patterns
+    // Credential-shaped patterns first — highest sensitivity.
     if (/\b(?:Bearer|token|secret|password|key)\s*[:=]\s*[a-zA-Z0-9+/=]{8,}\b/i.test(input)) {
-        return { text: "[redacted: credential shape detected]", blocked: true };
+        return { text: "[redacted: credential shape detected]", blocked: true, reason: "dream_blocked_credential" };
+    }
+    // Private context markers (names, addresses, phone numbers) — lower threshold than credential.
+    if (/\b(?:ssn|social.security|phone|address|email)\s*[:=]\s*[^\s]+/i.test(input)) {
+        return { text: "[redacted: private context]", blocked: true, reason: "dream_blocked_private_redacted" };
     }
     return { text: input, blocked: false };
 }
@@ -57,7 +65,7 @@ function generateCandidatesFromReview(runId, reviewId, reviewPayload) {
     const candidates = [];
     const summary = String(reviewPayload.reviewSummary ?? "");
     if (summary.length > 0) {
-        const { text, blocked } = redactSensitive(summary);
+        const { text, blocked, reason } = redactSensitive(summary);
         if (blocked) {
             candidates.push({
                 id: `cand_${runId}_summary`,
@@ -67,7 +75,7 @@ function generateCandidatesFromReview(runId, reviewId, reviewPayload) {
                 sourceRefs: buildSourceRefsFromReview({ id: reviewId, day: "" }),
                 confidence: 0.3,
                 validationStatus: "blocked",
-                validationReason: "redaction_blocked",
+                validationReason: reason,
             });
         }
         else {
@@ -84,7 +92,7 @@ function generateCandidatesFromReview(runId, reviewId, reviewPayload) {
     }
     const importanceSignals = reviewPayload.importanceSignals;
     if (importanceSignals && importanceSignals.length > 0) {
-        const { text, blocked } = redactSensitive(importanceSignals.join("; "));
+        const { text, blocked, reason } = redactSensitive(importanceSignals.join("; "));
         if (!blocked) {
             candidates.push({
                 id: `cand_${runId}_signals`,
@@ -96,9 +104,33 @@ function generateCandidatesFromReview(runId, reviewId, reviewPayload) {
                 validationStatus: "valid",
             });
         }
+        else {
+            candidates.push({
+                id: `cand_${runId}_signals`,
+                runId,
+                reviewId,
+                candidateText: text,
+                sourceRefs: buildSourceRefsFromReview({ id: reviewId, day: "" }),
+                confidence: 0.3,
+                validationStatus: "blocked",
+                validationReason: reason,
+            });
+        }
     }
     return candidates;
 }
+function validateCandidate(candidate) {
+    if (!candidate.candidateText || candidate.candidateText.trim().length === 0) {
+        return "dream_blocked_validation_failed";
+    }
+    if (!candidate.sourceRefs || candidate.sourceRefs.length === 0) {
+        return "dream_blocked_validation_failed";
+    }
+    if (candidate.confidence < 0.1) {
+        return "dream_blocked_validation_failed";
+    }
+    return undefined;
+}
 // ───────────────────────────────────────────────────────────────
 // Public API
 // ───────────────────────────────────────────────────────────────
@@ -111,7 +143,7 @@ export async function runDreamConsolidation(db, runId, options) {
     const run = runRead.row;
     if (!run) {
         return {
-            status: "degraded",
+            status: classifyDegradedStatus("state_unreadable"),
             reason: "state_unreadable",
             ownerStage: "dream",
             sourceRefs: [],
@@ -126,7 +158,7 @@ export async function runDreamConsolidation(db, runId, options) {
     const review = reviewRead.row;
     if (!review) {
         return {
-            status: "degraded",
+            status: classifyDegradedStatus("state_unreadable"),
             reason: "state_unreadable",
             ownerStage: "dream",
             sourceRefs: [],
@@ -135,34 +167,41 @@ export async function runDreamConsolidation(db, runId, options) {
         };
     }
     const reviewPayload = parsePayloadJson(review.payloadJson);
+    const contentStatus = String(reviewPayload.contentStatus ?? "");
+    // Block placeholder or empty Quiet reviews before candidate generation.
+    if (contentStatus === "placeholder_rejected" || contentStatus === "content_missing" || contentStatus === "empty") {
+        return {
+            runId,
+            status: "blocked",
+            candidates: [],
+            reason: "dream_blocked_no_content",
+        };
+    }
     const candidates = generateCandidatesFromReview(runId, run.quietReviewId, reviewPayload);
-    // If all candidates blocked → run blocked
+    // Run candidate validation; invalid candidates block the run with a precise reason.
+    for (const candidate of candidates) {
+        if (candidate.validationStatus === "valid") {
+            const validationReason = validateCandidate(candidate);
+            if (validationReason) {
+                candidate.validationStatus = "blocked";
+                candidate.validationReason = validationReason;
+            }
+        }
+    }
+    // If all candidates blocked → run blocked with the first precise reason.
     if (candidates.length > 0 && candidates.every((c) => c.validationStatus === "blocked")) {
+        const firstReason = candidates[0]?.validationReason;
         return {
             runId,
             status: "blocked",
             candidates,
-            reason: "dream_blocked_redaction",
+            reason: firstReason ?? "dream_blocked_private_redacted",
         };
     }
-    // Accept valid candidates as active long-term memory projections.
-    // This completes the Dream→memory lifecycle so accepted projections can be
-    // loaded by EmbodiedContext in subsequent heartbeats (T-DQ.R.3 followup).
-    const validCandidates = candidates.filter((c) => c.validationStatus === "valid");
-    for (const candidate of validCandidates) {
-        const acceptResult = await acceptMemoryProjection(db, candidate.id, `topic_${review.day}`, candidate.candidateText, candidate.sourceRefs, { now });
-        if ("projectionId" in acceptResult) {
-            candidate.acceptedProjectionId = acceptResult.projectionId;
-        }
-        else {
-            return {
-                runId,
-                status: "failed",
-                candidates,
-                reason: acceptResult.reason,
-            };
-        }
-    }
+    // T-DQ.R.10: Runner only generates and validates candidates.
+    // Acceptance is a separate step owned by the caller via acceptMemoryProjection.
+    // Valid candidates are returned with validationStatus="valid" for the caller
+    // to accept; the runner does NOT call acceptMemoryProjection here.
     return {
         runId,
         status: "completed",

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

@@ -21,6 +21,7 @@
  * Test coverage: tests/unit/dream/dream-scheduler-lifecycle.test.ts
  */
 import { readQuietDailyReviewById, writeDreamConsolidationRun, } from "../../../storage/v8-state-stores.js";
+import { classifyDegradedStatus } from "../../../shared/degraded-status-classifier.js";
 // ───────────────────────────────────────────────────────────────
 // Public API
 // ───────────────────────────────────────────────────────────────
@@ -33,7 +34,7 @@ export async function scheduleDreamAfterQuiet(db, quietReviewId, options) {
     const review = readResult.row;
     if (!review) {
         return {
-            status: "degraded",
+            status: classifyDegradedStatus("state_unreadable"),
             reason: "state_unreadable",
             ownerStage: "dream",
             sourceRefs: [],

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

@@ -21,6 +21,7 @@
  * Test coverage: tests/unit/dream/memory-projection-lifecycle.test.ts
  */
 import { readMemoryProjectionsByTopic, writeLongTermMemoryProjection, updateLongTermMemoryProjectionStatus, } from "../../../storage/v8-state-stores.js";
+import { classifyDegradedStatus } from "../../../shared/degraded-status-classifier.js";
 // ───────────────────────────────────────────────────────────────
 // Public API
 // ───────────────────────────────────────────────────────────────
@@ -28,7 +29,7 @@ export async function acceptMemoryProjection(db, candidateId, topicKey, memoryTe
     const now = options?.now ?? new Date().toISOString();
     if (sourceRefs.length === 0) {
         return {
-            status: "degraded",
+            status: classifyDegradedStatus("source_refs_unresolved"),
             reason: "source_refs_unresolved",
             ownerStage: "projection",
             sourceRefs: [],

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

@@ -62,4 +62,5 @@ export type BuildQuietDailyReviewOutput = {
     status: "empty";
     reason: V8ReasonCode;
 } | DegradedOperationResult;
+export type QuietReviewContentStatus = "content_present" | "empty" | "placeholder_rejected" | "content_missing";
 export declare function buildQuietDailyReview(db: StateDatabase, options?: BuildQuietDailyReviewOptions): Promise<BuildQuietDailyReviewOutput>;

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

@@ -107,6 +107,25 @@ function groupByStatus(entries) {
     }
     return groups;
 }
+// Placeholder/template detector: true when the review has no content-bearing
+// evidence or perception signals and no memory-review candidates. Closure-only
+// system text is not meaningful memory input.
+function isPlaceholderReview(notableSignals, memoryCandidates, evidenceRows, perceptionRows) {
+    if (memoryCandidates.length > 0)
+        return false;
+    if (notableSignals.length > 0)
+        return false;
+    const hasContentEvidence = evidenceRows.some((ev) => {
+        const payload = parsePayloadJson(ev.payloadJson);
+        return payload.contentStatus !== "content_missing";
+    });
+    if (hasContentEvidence)
+        return false;
+    const hasContentPerception = perceptionRows.some((p) => !!p.summary);
+    if (hasContentPerception)
+        return false;
+    return true;
+}
 // ───────────────────────────────────────────────────────────────
 // Public API
 // ───────────────────────────────────────────────────────────────
@@ -177,11 +196,18 @@ export async function buildQuietDailyReview(db, options) {
     }
     for (const perception of perceptionRows) {
         if (perception.summary) {
+            const perceptionPayload = parsePayloadJson(perception.payloadJson);
+            if (perceptionPayload.contentMissing) {
+                continue;
+            }
             notableSignals.push(`Perception: ${perception.summary}`);
         }
     }
     for (const evidence of evidenceRows) {
         const payload = parsePayloadJson(evidence.payloadJson);
+        if (payload.contentStatus === "content_missing") {
+            continue;
+        }
         if (payload.summary) {
             notableSignals.push(`${evidence.platformId}: ${String(payload.summary)}`);
         }
@@ -245,6 +271,12 @@ export async function buildQuietDailyReview(db, options) {
     const reviewSummary = firstTopic
         ? `Day ${day}: ${closures.length} closures around ${firstTopic}${notableSignals.length > 0 ? ` with ${notableSignals.length} notable signals` : ""}.`
         : `Day ${day}: ${closures.length} closures (${completedCount} completed, ${deniedCount} deferred/denied, ${failedCount} failed)`;
+    const isPlaceholder = isPlaceholderReview(notableSignals, memoryCandidates, evidenceRows, perceptionRows);
+    const contentStatus = isPlaceholder
+        ? "placeholder_rejected"
+        : (notableSignals.length > 0 || memoryCandidates.length > 0)
+            ? "content_present"
+            : "content_missing";
     const importanceSignals = [];
     if (memoryCandidates.length > 0) {
         importanceSignals.push(`${memoryCandidates.length} memory-review candidates`);
@@ -268,6 +300,7 @@ export async function buildQuietDailyReview(db, options) {
         lifecycleStatus: "pending",
         payloadJson: JSON.stringify({
             reviewSummary,
+            contentStatus,
             importanceSignals,
             memoryCandidates,
             sections,

package/runtime/observability/causal-loop-health.d.ts

@@ -21,7 +21,7 @@
  * Test coverage: tests/unit/observability/causal-loop-health.test.ts
  */
 import type { StateDatabase } from "../storage/db/index.js";
-import type { LoopStage, DegradedOperationResult } from "../shared/types/v8-contracts.js";
+import type { LoopStage, DegradedOperationResult, EvidenceLevel } from "../shared/types/v8-contracts.js";
 export interface StageHealth {
     stage: LoopStage;
     lastEventAt?: string;
@@ -36,6 +36,7 @@ export interface CausalLoopHealthSnapshot {
     lastHeartbeatAt?: string;
     stages: StageHealth[];
     reason?: string;
+    evidenceLevel: EvidenceLevel;
 }
 export interface AssembleLoopStatusOptions {
     stallThresholdCycles?: number;

package/runtime/observability/causal-loop-health.js

@@ -21,6 +21,7 @@
  * Test coverage: tests/unit/observability/causal-loop-health.test.ts
  */
 import { readHeartbeatCycleTraces, readLoopStageEventsByStage, } from "../storage/v8-state-stores.js";
+import { classifyEvidenceLevel } from "../shared/evidence-level-classifier.js";
 // ───────────────────────────────────────────────────────────────
 // Config
 // ───────────────────────────────────────────────────────────────
@@ -77,6 +78,7 @@ export async function assembleLoopStatus(db, options) {
             lastCycleSequence: 0,
             stages: [],
             reason: "no heartbeat cycles recorded",
+            evidenceLevel: classifyEvidenceLevel({ hasCarrierEnvelope: true }),
         };
     }
     const lastCycle = cycles[0];
@@ -114,5 +116,10 @@ export async function assembleLoopStatus(db, options) {
         lastHeartbeatAt: lastCycle.heartbeatStartedAt,
         stages,
         reason: stalledAt ? `stage ${stalledAt} stalled for >=${threshold} cycles` : undefined,
+        evidenceLevel: classifyEvidenceLevel({
+            hasCarrierEnvelope: true,
+            hasContractSmoke: true,
+            hasCycleExecution: stalledAt === undefined,
+        }),
     };
 }