@haaaiawd/second-nature 0.2.9 → 0.2.13

package/runtime/core/second-nature/orchestrator/platform-capability-router.d.ts

@@ -12,7 +12,7 @@
  * - Optional registry: when absent, resolution is best-effort from goals/evidence.
  */
 import type { IntentKind } from "../types.js";
-import type { ControlPlaneSourceRef } from "../types.js";
+import type { SourceRef } from "../../../shared/types/v8-contracts.js";
 import type { CapabilityContractRegistry } from "../../../connectors/base/manifest.js";
 /** Minimal goal shape accepted by the router to avoid coupling to AgentGoal. M-03 decoupling. */
 interface GoalRouterContext {
@@ -24,7 +24,7 @@ export interface PlatformResolutionContext {
     /** Accepted goals that may name a platform or capability. */
     acceptedGoals?: GoalRouterContext[];
     /** Evidence refs that may embed platform identity. */
-    evidenceRefs?: ControlPlaneSourceRef[];
+    evidenceRefs?: SourceRef[];
 }
 /**
  * Resolve an explicit platformId for a candidate intent kind.

package/runtime/core/second-nature/orchestrator/platform-capability-router.js

@@ -48,7 +48,7 @@ function extractPlatformIdsFromGoals(goals, kind, platformIds) {
 function extractPlatformIdsFromEvidence(refs, platformIds) {
     const results = new Set();
     for (const ref of refs) {
-        if (ref.kind === "connector_result" && ref.id) {
+        if (ref.family === "connector_result" && ref.id) {
             for (const pid of platformIds) {
                 if (ref.id.includes(pid)) {
                     results.add(pid);

package/runtime/core/second-nature/outreach/build-outreach-draft-request.js

@@ -3,6 +3,7 @@
  * Aligns with control-plane-system.detail §3.9 buildOutreachDraftRequest.
  */
 import * as crypto from "node:crypto";
+import { legacyKindFromSourceRef } from "../../../shared/source-ref-compat.js";
 function inferRhythmWindowKind(windowId) {
     const id = windowId.toLowerCase();
     if (id.includes("work"))
@@ -20,10 +21,8 @@ function inferRhythmWindowKind(windowId) {
 function toGuidanceRefs(refs) {
     return refs.map((r) => ({
         id: r.id,
-        kind: r.kind,
+        kind: legacyKindFromSourceRef(r),
         uri: r.uri,
-        excerptHash: r.excerptHash,
-        observedAt: r.observedAt,
     }));
 }
 function mapDeliveryVerdict(verdict) {

package/runtime/core/second-nature/outreach/dispatch-user-outreach.d.ts

@@ -7,7 +7,7 @@ import type { CandidateIntent } from "../types.js";
 import type { HeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
 import type { HeartbeatCycleResult } from "../heartbeat/signal.js";
 import type { StateDatabase } from "../../../storage/db/index.js";
-import type { SourceRef } from "../../../storage/life-evidence/types.js";
+import type { LifeEvidenceSourceRef } from "../../../storage/life-evidence/types.js";
 import { type JudgeOutreachInput } from "./judge-outreach.js";
 import { type DeliveryTargetResolution } from "./delivery-target.js";
 export interface OpenClawDeliverySendResult {
@@ -16,7 +16,7 @@ export interface OpenClawDeliverySendResult {
     errorClass?: string;
     messageId?: string;
     /** Host-reported delivery proof when messageId is absent (T4.3.1). */
-    hostProofRef?: SourceRef;
+    hostProofRef?: LifeEvidenceSourceRef;
 }
 export interface OpenClawDeliveryPort {
     sendDeliveryRequest(input: {

package/runtime/core/second-nature/outreach/dispatch-user-outreach.js

@@ -1,3 +1,4 @@
+import { legacyKindFromSourceRef } from "../../../shared/source-ref-compat.js";
 import { writeDeliveryAttempt } from "../../../storage/delivery/write-delivery-attempt.js";
 import { writeOperatorFallback } from "../../../storage/fallback/write-operator-fallback.js";
 import { judgeOutreach } from "./judge-outreach.js";
@@ -6,7 +7,11 @@ import { buildOutreachDraftRequest } from "./build-outreach-draft-request.js";
 import { createNarrativeStateStore } from "../../../storage/narrative/narrative-state-store.js";
 import { createRelationshipMemoryStore } from "../../../storage/relationship/relationship-memory-store.js";
 function toSourceRefs(refs) {
-    return refs.map((r) => ({ ...r }));
+    return refs.map((r) => ({
+        id: r.id,
+        kind: legacyKindFromSourceRef(r),
+        uri: r.uri,
+    }));
 }
 function hasDeliveryProof(attempt) {
     return Boolean(attempt.messageId?.trim()) || Boolean(attempt.hostProofRef);

package/runtime/core/second-nature/outreach/judge-input-from-snapshot.js

@@ -1,12 +1,7 @@
+import { toCanonicalSourceRef } from "../../../shared/source-ref-compat.js";
 import { isLifeEvidenceSliceEmpty } from "../heartbeat/runtime-snapshot.js";
 function toControlPlaneRefs(refs) {
-    return refs.map((r) => ({
-        id: r.id,
-        kind: r.kind,
-        uri: r.uri,
-        excerptHash: r.excerptHash,
-        observedAt: r.observedAt,
-    }));
+    return refs.map((r) => toCanonicalSourceRef(r));
 }
 export function userInterestSnapshotToJudge(snapshot) {
     if (!snapshot) {
@@ -18,13 +13,7 @@ export function userInterestSnapshotToJudge(snapshot) {
         signals: snapshot.signals.map((s) => ({
             topic: s.topic,
             confidence: s.confidence,
-            sourceRefs: s.sourceRefs.map((r) => ({
-                id: r.id,
-                kind: r.kind,
-                uri: r.uri,
-                excerptHash: r.excerptHash,
-                observedAt: r.observedAt,
-            })),
+            sourceRefs: s.sourceRefs.map((r) => toCanonicalSourceRef(r)),
         })),
         sourceRefs: toControlPlaneRefs(snapshot.sourceRefs),
     };

package/runtime/core/second-nature/outreach/judge-outreach.d.ts

@@ -1,4 +1,5 @@
-import type { CandidateIntent, ControlPlaneSourceRef } from "../types.js";
+import type { CandidateIntent } from "../types.js";
+import type { SourceRef } from "../../../shared/types/v8-contracts.js";
 import { type DeliveryCapabilitySnapshot, type DeliveryTargetResolution } from "./delivery-target.js";
 export type OutreachJudgmentVerdict = "allow" | "deny" | "defer";
 export type CooldownState = "clear" | "cooling_down" | "duplicate";
@@ -8,9 +9,9 @@ export interface JudgeOutreachUserInterest {
     signals: Array<{
         topic: string;
         confidence: number;
-        sourceRefs: ControlPlaneSourceRef[];
+        sourceRefs: SourceRef[];
     }>;
-    sourceRefs: ControlPlaneSourceRef[];
+    sourceRefs: SourceRef[];
 }
 export interface JudgeOutreachLifeEvidence {
     empty: boolean;
@@ -31,8 +32,8 @@ export interface OutreachJudgment {
     valueScore: number;
     userRelevance: number;
     actionability: number;
-    interestRefs: ControlPlaneSourceRef[];
-    sourceRefs: ControlPlaneSourceRef[];
+    interestRefs: SourceRef[];
+    sourceRefs: SourceRef[];
     cooldownState: CooldownState;
     deliveryVerdict: DeliveryTargetResolution["verdict"];
     reasons: string[];

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

@@ -22,7 +22,9 @@
  * Test coverage: tests/unit/judgment/judgment-engine.test.ts
  */
 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
 // ───────────────────────────────────────────────────────────────
@@ -42,17 +44,6 @@ function inferRiskPosture(sensitivityClass, riskFlags) {
     }
     return "low";
 }
-function parseCardSourceRefs(json) {
-    if (!json)
-        return [];
-    try {
-        const parsed = JSON.parse(json);
-        return Array.isArray(parsed) ? parsed : [];
-    }
-    catch {
-        return [];
-    }
-}
 function selectVerdict(relevance, confidence, riskPosture, hasSourceRefs, possibleIntents) {
     // Missing source refs → ignore/watch only
     if (!hasSourceRefs) {
@@ -117,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: [],
@@ -125,7 +116,7 @@ export async function runAgentJudgment(db, perceptionCardId, options) {
             retryable: false,
         };
     }
-    const sourceRefs = parseCardSourceRefs(card.sourceRefsJson);
+    const sourceRefs = parseSourceRefs(card.sourceRefsJson);
     const hasSourceRefs = sourceRefs.length > 0;
     // Parse sensitivity class from payload (stored there by perception-builder)
     let sensitivityClass = "public_general";
@@ -204,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 {
@@ -228,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

@@ -22,6 +22,8 @@
  * Test coverage: tests/unit/perception/perception-builder.test.ts
  */
 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
 // ───────────────────────────────────────────────────────────────
@@ -29,15 +31,6 @@ const PERCEPTION_MAX_EVIDENCE_PER_CYCLE = 50;
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
-function parseSourceRefs(json) {
-    try {
-        const parsed = JSON.parse(json);
-        return Array.isArray(parsed) ? parsed : [];
-    }
-    catch {
-        return [];
-    }
-}
 function parsePayload(json) {
     if (!json)
         return undefined;
@@ -118,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 };
     }
@@ -254,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/run-source-backed-quiet.js

@@ -3,13 +3,21 @@ import { writeQuietArtifact } from "../../../storage/quiet/quiet-artifact-writer
 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";
+import { legacyKindFromSourceRef } from "../../../shared/source-ref-compat.js";
 function toGuidanceRef(r) {
     return {
         id: r.id,
-        kind: r.kind,
+        kind: legacyKindFromSourceRef(r),
         uri: r.uri,
-        excerptHash: r.excerptHash,
-        observedAt: r.observedAt,
+    };
+}
+function toLifeEvidenceRef(ref) {
+    return {
+        id: ref.id,
+        kind: ref.kind,
+        uri: ref.uri,
+        excerptHash: ref.excerptHash,
+        observedAt: ref.observedAt,
     };
 }
 /**
@@ -116,24 +124,14 @@ export async function runSourceBackedQuiet(params) {
         confidence: userInterestSnapshot?.confidence ?? 0,
         signalCount: userInterestSnapshot?.signals.length ?? 0,
     });
-    const groundedSourceRefs = ep.pack.groundedRefs.map((g) => ({
-        id: g.id,
-        kind: g.kind,
-        uri: g.uri,
-        excerptHash: g.excerptHash,
-        observedAt: g.observedAt,
-    }));
+    const groundedSourceRefs = ep.pack.groundedRefs.map(toLifeEvidenceRef);
     const claims = ep.pack.groundedRefs.map((g, i) => ({
         id: `fact:${g.id}`,
         text: `Evidence-backed note ${i + 1}`,
         claimType: "fact",
         sourceRefs: [
             {
-                id: g.id,
-                kind: g.kind,
-                uri: g.uri,
-                excerptHash: g.excerptHash,
-                observedAt: g.observedAt,
+                ...toLifeEvidenceRef(g),
             },
         ],
     }));

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

@@ -22,10 +22,11 @@
  *   so `dreamStatus` reaches completed/blocked.
  * - Does not bypass Dream runner; only records due/completed/blocked.
  */
-import { writeDailyRhythmState, readDailyRhythmStateByDay, readActionClosuresByDay, readDreamConsolidationRunById, readDreamConsolidationRunsByQuietId, updateDreamConsolidationRunStatus, } from "../../../storage/v8-state-stores.js";
+import { writeDailyRhythmState, readDailyRhythmStateByDay, readActionClosuresByDay, readDreamConsolidationRunById, readDreamConsolidationRunsByQuietId, readLatestDreamConsolidationRunByStatus, updateDreamConsolidationRunStatus, } from "../../../storage/v8-state-stores.js";
 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,13 +107,12 @@ 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;
                 const updateResult = await updateDreamConsolidationRunStatus(db, runId, finalStatus, {
                     reason: finalReason ?? null,
-                    lifecycleStatus: finalStatus === "completed" ? "completed" : "archived",
                     payloadJson: JSON.stringify({
                         ...parsePayloadJson(run.payloadJson),
                         consolidatedAt: now,
@@ -123,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 {
@@ -208,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;
@@ -226,18 +240,17 @@ export async function checkDailyRhythm(db, options) {
             // Already handled; do not re-schedule
         }
         else {
+            // Global 7-day interval check: look across all quiet reviews, not just today's.
             const quietId = `quiet_${day}`;
-            const latestRun = await loadLatestDreamRunForQuiet(db, quietId);
-            if (latestRun.degraded) {
-                return latestRun.degraded;
+            const globalLatest = await readLatestDreamConsolidationRunByStatus(db, ["completed", "blocked"]);
+            if (globalLatest.degraded) {
+                return globalLatest.degraded;
             }
-            // If a completed/blocked run already exists within the 7-day interval, honor it.
-            if (latestRun.row &&
-                (latestRun.row.status === "completed" || latestRun.row.status === "blocked") &&
-                isWithinDays(latestRun.row.createdAt, now, DREAM_DEFAULT_INTERVAL_DAYS)) {
-                state.dreamStatus = latestRun.row.status;
-                state.dreamReason = latestRun.row.reason ?? "dream_completed";
-                if (latestRun.row.status === "completed") {
+            if (globalLatest.row &&
+                isWithinDays(globalLatest.row.createdAt, now, DREAM_DEFAULT_INTERVAL_DAYS)) {
+                state.dreamStatus = globalLatest.row.status;
+                state.dreamReason = "dream_interval_active";
+                if (globalLatest.row.status === "completed") {
                     state.dreamCompletedAt = now;
                 }
             }
@@ -264,11 +277,10 @@ 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,
-                            lifecycleStatus: dreamOutcome.status === "completed" ? "completed" : "archived",
                             payloadJson: JSON.stringify({
                                 consolidatedAt: now,
                                 candidateCount: dreamOutcome.candidates.length,
@@ -281,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",