@haaaiawd/second-nature 0.2.9 → 0.2.12

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

@@ -191,7 +191,7 @@ export async function runHeartbeatCycle(db, request) {
             reason: degradedReason,
             sourceRefs: degradedClosureRef ? [degradedClosureRef, cycleRef] : [cycleRef],
         });
-        const { rhythmState } = await advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now);
+        const { rhythmState, rhythmDegraded } = await advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now);
         return {
             cycleId,
             cycleSequence,
@@ -206,7 +206,8 @@ export async function runHeartbeatCycle(db, request) {
                     operatorNextAction: "Retry heartbeat after perception recovery",
                     retryable: true,
                 }
-                : undefined,
+                : rhythmDegraded,
+            rhythmDegraded,
             rhythmState,
         };
     }
@@ -245,12 +246,14 @@ export async function runHeartbeatCycle(db, request) {
             reason: "evidence_batch_empty",
             sourceRefs: emptyClosureRef ? [emptyClosureRef, cycleRef] : [cycleRef],
         });
-        const { rhythmState } = await advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now);
+        const { rhythmState, rhythmDegraded } = await advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now);
         return {
             cycleId,
             cycleSequence,
             closureRef: emptyClosureRef,
             noActionReason: "evidence_batch_empty",
+            degraded: rhythmDegraded,
+            rhythmDegraded,
             rhythmState,
         };
     }
@@ -365,7 +368,7 @@ export async function runHeartbeatCycle(db, request) {
             }
             else if (proposalResult.status === "remember_for_review") {
                 const remember = proposalResult;
-                const closureResult = await recordRememberClosure(db, cycleId, remember.memoryReviewCandidate, { now });
+                const closureResult = await recordRememberClosure(db, cycleId, remember.memoryReviewCandidate, { now, platformId: "heartbeat" });
                 if ("closureId" in closureResult) {
                     closureRef = {
                         uri: `sn://closure/${closureResult.closureId}`,
@@ -540,13 +543,14 @@ export async function runHeartbeatCycle(db, request) {
         noActionReason = "proposal_no_action";
     }
     // T-CP.R.3: Advance daily rhythm after closure/no-action
-    const { rhythmState } = await advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now);
+    const { rhythmState, rhythmDegraded } = await advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now);
     return {
         cycleId,
         cycleSequence,
         closureRef,
         noActionReason,
-        degraded: closureDegraded,
+        degraded: closureDegraded ?? rhythmDegraded,
+        rhythmDegraded,
         rhythmState,
     };
 }

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

@@ -31,5 +31,7 @@ export interface RealRuntimeSpineResult {
     noActionReason?: V8ReasonCode;
     degraded?: DegradedOperationResult;
     rhythmState?: DailyRhythmState;
+    rhythmDegraded?: DegradedOperationResult;
+    impulseContextArtifactId?: string;
 }
 export declare function runRealRuntimeHeartbeatCycle(options: RealRuntimeSpineOptions): Promise<RealRuntimeSpineResult | DegradedOperationResult>;

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

@@ -38,5 +38,6 @@ export async function runRealRuntimeHeartbeatCycle(options) {
         noActionReason: orchestrationResult.noActionReason,
         degraded: orchestrationResult.degraded,
         rhythmState: orchestrationResult.rhythmState,
+        rhythmDegraded: orchestrationResult.rhythmDegraded,
     };
 }

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

@@ -12,6 +12,7 @@ import { mapLifeEvidence } from "../../../connectors/base/map-life-evidence.js";
 import { appendLifeEvidence } from "../../../storage/life-evidence/append-life-evidence.js";
 import { normalizeConnectorEvidence } from "../../../connectors/evidence-normalizer.js";
 import { recordConnectorAttemptAudit } from "../../../observability/services/audit-closure-recorders.js";
+import { makeCanonicalSourceRef } from "../../../shared/source-ref-compat.js";
 /**
  * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
  * Exported for unit tests (CR-M1 wiring).
@@ -302,11 +303,11 @@ export async function ingestRhythmSignal(signal, deps) {
                         effectClass: "connector_action",
                         capabilityIntent: idleResult.candidate.capabilityId,
                         sourceRefs: [
-                            {
+                            makeCanonicalSourceRef({
                                 id: "idle_curiosity",
-                                kind: "workspace_artifact",
+                                family: "audit",
                                 uri: `idle://${idleResult.candidate.platformId}`,
-                            },
+                            }),
                         ],
                         idempotencyKey: `idle:${idleResult.candidate.platformId}:${idleResult.candidate.capabilityId}`,
                         goalInfluenceRefs: [],

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

@@ -1,13 +1,14 @@
 /**
  * HeartbeatRuntimeSnapshot assembly for candidate planner + hard guards (T2.1.3, T2.2.1).
  */
-import type { ContinuitySnapshot, ControlPlaneSourceRef } from "../types.js";
+import type { ContinuitySnapshot } from "../types.js";
+import type { SourceRef } from "../../../shared/types/v8-contracts.js";
 import type { RhythmPolicy } from "../rhythm/rhythm-policy.js";
 import { type PlannerRhythmWindowSlice } from "../rhythm/planner-rhythm-window.js";
 import type { SnapshotInputs } from "./snapshot-builder.js";
 import type { AffordanceMap } from "../../../shared/types/v7-entities.js";
 export interface PlannerLifeEvidenceSlice {
-    evidenceRefs: ControlPlaneSourceRef[];
+    evidenceRefs: SourceRef[];
     platformEventCount: number;
     workEventCount: number;
     emptyReason?: "no_sources" | "state_unavailable" | "redacted_only";

package/runtime/core/second-nature/heartbeat/snapshot-builder.d.ts

@@ -6,7 +6,8 @@
  *
  * Per design doc §4.2: SnapshotBuilder prepares inputs for the Rhythm Engine.
  */
-import type { ContinuitySnapshot, ControlPlaneSourceRef, TopLevelMode } from "../types.js";
+import type { ContinuitySnapshot, TopLevelMode } from "../types.js";
+import type { SourceRef } from "../../../shared/types/v8-contracts.js";
 import type { RhythmPolicy } from "../rhythm/rhythm-policy.js";
 import type { DeliveryCapabilitySnapshot } from "../outreach/delivery-target.js";
 import type { UserInterestSnapshot } from "../../../storage/user-interest/types.js";
@@ -30,7 +31,7 @@ export interface SnapshotInputs {
     awaitingUserInput?: boolean;
     riskSuppressed?: boolean;
     /** Evidence refs for source-backed planner/guards (T2.1.3 / T2.2.1). */
-    lifeEvidenceRefs?: ControlPlaneSourceRef[];
+    lifeEvidenceRefs?: SourceRef[];
     platformEventCount?: number;
     workEventCount?: number;
     lifeEvidenceEmptyReason?: "no_sources" | "state_unavailable" | "redacted_only";

package/runtime/core/second-nature/orchestrator/intent-planner.js

@@ -1,10 +1,11 @@
+import { makeCanonicalSourceRef } from "../../../shared/source-ref-compat.js";
 import { isLifeEvidenceSliceEmpty } from "../heartbeat/runtime-snapshot.js";
 import { buildHeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
 import { resolvePlatformForIntent, } from "./platform-capability-router.js";
 import { isGoalRelatedToCandidate } from "./goal-priority.js";
 const MAX_CANDIDATE_INTENTS = 6;
 const OBLIGATION_SOURCE = [
-    { id: "obligation-anchor", kind: "workspace_artifact", uri: "workspace://obligations/pending" },
+    makeCanonicalSourceRef({ id: "obligation-anchor", family: "audit", uri: "workspace://obligations/pending" }),
 ];
 function evidenceRefsForConnector(runtime) {
     if (!isLifeEvidenceSliceEmpty(runtime.lifeEvidence) && runtime.lifeEvidence.evidenceRefs.length > 0) {
@@ -253,8 +254,9 @@ export function planCandidateIntents(runtime, options) {
         if (intent.sourceRefs.length === 0 && related.length > 0) {
             intent.sourceRefs = related.slice(0, 4).map((g) => ({
                 id: g.goalId,
-                kind: "workspace_artifact",
+                family: "audit",
                 uri: `goal://${g.goalId}`,
+                redactionClass: "none",
             }));
         }
     }

package/runtime/core/second-nature/orchestrator/narrative-update.js

@@ -3,9 +3,8 @@ const DEFAULT_NARRATIVE_ID = "default";
 function mapControlPlaneRefToSourceRef(ref) {
     return {
         sourceId: ref.id,
-        kind: ref.kind,
+        kind: ref.family,
         url: ref.uri,
-        snippet: ref.excerptHash,
     };
 }
 /**

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,6 +22,7 @@
  * 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";
 // ───────────────────────────────────────────────────────────────
 // Config
@@ -42,17 +43,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) {
@@ -125,7 +115,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";

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

@@ -22,6 +22,7 @@
  * 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";
 // ───────────────────────────────────────────────────────────────
 // Config
 // ───────────────────────────────────────────────────────────────
@@ -29,15 +30,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;

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,7 +22,7 @@
  *   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";
@@ -112,7 +112,6 @@ async function executeStaleScheduledDreams(db, state, now) {
                 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,
@@ -226,18 +225,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;
                 }
             }
@@ -268,7 +266,6 @@ export async function checkDailyRhythm(db, options) {
                         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,

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

@@ -60,7 +60,6 @@ export async function scheduleDreamAfterQuiet(db, quietReviewId, options) {
                 },
             ],
             redactionClass: "none",
-            lifecycleStatus: "pending",
             payloadJson: JSON.stringify({ scheduledAt: now, blocked: true }),
         });
         if ("reason" in writeResult) {
@@ -90,7 +89,6 @@ export async function scheduleDreamAfterQuiet(db, quietReviewId, options) {
             },
         ],
         redactionClass: "none",
-        lifecycleStatus: "pending",
         payloadJson: JSON.stringify({ scheduledAt: now }),
     });
     if ("reason" in writeResult) {

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

@@ -65,7 +65,6 @@ export async function acceptMemoryProjection(db, candidateId, topicKey, memoryTe
         status: "active",
         sourceRefs,
         redactionClass: "none",
-        lifecycleStatus: "active",
         payloadJson: JSON.stringify({
             memoryText,
             acceptedAt: now,
@@ -111,17 +110,6 @@ export async function retireMemoryProjection(db, projectionId, _candidateId, _to
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
-function parseSourceRefs(json) {
-    if (!json)
-        return [];
-    try {
-        const parsed = JSON.parse(json);
-        return Array.isArray(parsed) ? parsed : [];
-    }
-    catch {
-        return [];
-    }
-}
 function parsePayloadJson(json) {
     if (!json)
         return {};

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

@@ -22,6 +22,7 @@
  * Test coverage: tests/unit/quiet/quiet-daily-review-builder.test.ts
  */
 import { readActionClosuresByDay, writeQuietDailyReview, readPerceptionCardById, readEvidenceItemsByDay, readPerceptionCardsByDay, } from "../../../storage/v8-state-stores.js";
+import { parseSourceRefs } from "../../../shared/serialization.js";
 // ───────────────────────────────────────────────────────────────
 // Config
 // ───────────────────────────────────────────────────────────────
@@ -52,17 +53,6 @@ function buildSourceRefFromClosure(closure) {
         resolveStatus: "resolvable",
     };
 }
-function parseSourceRefs(json) {
-    if (!json)
-        return [];
-    try {
-        const parsed = JSON.parse(json);
-        return Array.isArray(parsed) ? parsed : [];
-    }
-    catch {
-        return [];
-    }
-}
 function buildSourceRefFromEvidence(evidence) {
     const refs = parseSourceRefs(evidence.sourceRefsJson);
     return (refs[0] ?? {

package/runtime/core/second-nature/types.d.ts

@@ -1,16 +1,9 @@
+import type { SourceRef } from "../../shared/types/v8-contracts.js";
 export type TopLevelMode = "active" | "quiet" | "maintenance_only" | "paused_for_interrupt";
 /** Control-plane candidate kinds; includes `quiet` for quiet-window–biased intents (L0 alignment). */
 export type IntentKind = "work" | "exploration" | "social" | "quiet" | "reflection" | "outreach" | "maintenance";
 export type DecisionBasis = "rule_only" | "score_based" | "model_assisted";
 export type GuardVerdict = "allow" | "defer" | "deny" | "escalate";
-/** Minimal source ref for planner / guards (matches state-system `SourceRef` subset). */
-export interface ControlPlaneSourceRef {
-    id: string;
-    kind: "platform_item" | "workspace_artifact" | "decision_record" | "user_anchor" | "connector_result" | "host_report" | "fallback_artifact";
-    uri: string;
-    excerptHash?: string;
-    observedAt?: string;
-}
 export interface ContinuitySnapshot {
     mode: TopLevelMode;
     currentWindowId: string;
@@ -40,7 +33,7 @@ export interface CandidateIntent {
     summary: string;
     effectClass: CandidateEffectClass;
     /** Required for source-backed guard; may be empty when planner expects hard-guard deny. */
-    sourceRefs: ControlPlaneSourceRef[];
+    sourceRefs: SourceRef[];
     /** Dedupe / cooldown key; defaults to stable fingerprint in guard layer when omitted. */
     idempotencyKey?: string;
     /** T2.1.4: IDs of accepted AgentGoals that influenced this candidate's priority. */

package/runtime/dream/dream-engine.js

@@ -165,12 +165,19 @@ export async function runDream(input) {
                     });
                 }
                 if (!fallbackReason) {
+                    let timeoutHandle;
                     const timeoutPromise = new Promise((_, reject) => {
-                        setTimeout(() => reject(new Error("model_timeout")), operatorTimeoutMs);
+                        timeoutHandle = setTimeout(() => reject(new Error("model_timeout")), operatorTimeoutMs);
                     });
-                    modelResult = await Promise.race([modelPromise, timeoutPromise]);
-                    mode = "hybrid_llm";
-                    llmCostUsd = modelResult.costUsd;
+                    try {
+                        modelResult = await Promise.race([modelPromise, timeoutPromise]);
+                        mode = "hybrid_llm";
+                        llmCostUsd = modelResult.costUsd;
+                    }
+                    finally {
+                        if (timeoutHandle)
+                            clearTimeout(timeoutHandle);
+                    }
                 }
             }
             catch (err) {