@haaaiawd/second-nature 0.2.4 → 0.2.6

package/runtime/connectors/services/connector-executor-adapter.js

@@ -19,6 +19,7 @@ import { parseConnectorManifestV6 } from "../manifest/manifest-parser.js";
 import fs from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { createConnectorCooldownPort } from "./connector-cooldown-port.js";
 const DEFAULT_AGENT_WORLD_USERNAME = "nyx_ha";
 const DEFAULT_AGENT_WORLD_PROFILE_PATH_TEMPLATE = "/api/agents/profile/{username}";
 function readString(value) {
@@ -104,7 +105,7 @@ async function fetchAgentWorldJson(input) {
         body: input.body === undefined ? undefined : JSON.stringify(input.body),
     });
     if (!resp.ok) {
-        throw { code: "api_error", detail: `agent-world ${input.label}: ${resp.status}` };
+        throw { code: "api_error", status: resp.status, detail: `agent-world ${input.label}: ${resp.status}` };
     }
     return resp.json();
 }
@@ -147,7 +148,7 @@ async function fetchEvoMapJson(input) {
         body: input.body === undefined ? undefined : JSON.stringify(input.body),
     });
     if (!resp.ok) {
-        throw { code: "api_error", detail: `evomap ${input.label}: ${resp.status}` };
+        throw { code: "api_error", status: resp.status, detail: `evomap ${input.label}: ${resp.status}` };
     }
     return resp.json();
 }
@@ -256,6 +257,8 @@ function createDeclarativeHttpRunner(manifest, credential) {
                     body: method !== "GET" && request.payload ? JSON.stringify(request.payload) : undefined,
                 });
                 if (!resp.ok) {
+                    const status = resp.status;
+                    const body = await resp.text().catch(() => "");
                     return {
                         platformId: request.platformId,
                         channel: plan.channel,
@@ -263,7 +266,8 @@ function createDeclarativeHttpRunner(manifest, credential) {
                         success: false,
                         error: {
                             code: "api_error",
-                            detail: `HTTP ${resp.status}: ${await resp.text().catch(() => "")}`,
+                            status,
+                            detail: `HTTP ${status}${body ? `: ${body.slice(0, 200)}` : ""}`,
                         },
                     };
                 }
@@ -618,7 +622,8 @@ export function createConnectorExecutorAdapter(options) {
     registry.register({ ...agentWorldManifest });
     registry.register({ ...instreetManifest });
     registerWorkspaceManifests(registry, options.workspaceRoot);
-    const routeContextPort = createCredentialRouteContextPort(vault);
+    const cooldownPort = createConnectorCooldownPort(options.stateDb);
+    const routeContextPort = createCredentialRouteContextPort(vault, options.stateDb);
     const routePlanner = new ConnectorRoutePlanner(registry, routeContextPort, new ChannelHealthStore());
     const telemetry = new ExecutionTelemetry(options.observabilityDb);
     const executionRunner = createAdaptiveExecutionRunner(vault, options.workspaceRoot);
@@ -626,6 +631,7 @@ export function createConnectorExecutorAdapter(options) {
         routePlanner,
         executionRunner,
         telemetry,
+        cooldownPort,
         effectCommitLedger: new InMemoryEffectCommitLedger(),
         retryPolicy: { maxRetries: 2, jitter: true },
     });

package/runtime/connectors/services/credential-route-context.d.ts

@@ -3,8 +3,9 @@
  *
  * Loads decrypted credentials from state DB and maps them to the
  * CredentialContext shape expected by ConnectorRoutePlanner.
- * Cooldown is stubbed (always unblocked) until a cooldown ledger is modeled.
+ * Cooldown state is loaded from connector_cooldown_state table.
  */
 import type { RouteContextPort } from "../base/contract.js";
 import type { CredentialVault } from "../../storage/services/credential-vault.js";
-export declare function createCredentialRouteContextPort(vault: CredentialVault): RouteContextPort;
+import type { StateDatabase } from "../../storage/db/index.js";
+export declare function createCredentialRouteContextPort(vault: CredentialVault, db: StateDatabase): RouteContextPort;

package/runtime/connectors/services/credential-route-context.js

@@ -1,4 +1,5 @@
-export function createCredentialRouteContextPort(vault) {
+import { readConnectorCooldownState } from "../../storage/v8-state-stores.js";
+export function createCredentialRouteContextPort(vault, db) {
     return {
         async loadCredentialState(platformId) {
             const ctx = await vault.loadCredentialContext(platformId);
@@ -12,8 +13,23 @@ export function createCredentialRouteContextPort(vault) {
             }
             return ctx;
         },
-        async loadCooldownState() {
-            return { blocked: false };
+        async loadCooldownState(platformId, intent) {
+            const read = await readConnectorCooldownState(db, platformId, intent);
+            if (read.degraded) {
+                // Fail-closed on unreadable cooldown state
+                return { blocked: true, reason: "cooldown_state_unreadable" };
+            }
+            if (!read.row) {
+                return { blocked: false };
+            }
+            const now = new Date().toISOString();
+            const blocked = new Date(read.row.blockedUntil).getTime() > new Date(now).getTime();
+            return {
+                blocked,
+                retryAfterMs: blocked
+                    ? Math.max(0, new Date(read.row.blockedUntil).getTime() - new Date(now).getTime())
+                    : undefined,
+            };
         },
     };
 }

package/runtime/core/second-nature/action/action-closure-recorder.d.ts

@@ -56,6 +56,8 @@ export declare function recordRememberClosure(db: StateDatabase, cycleId: string
 export declare function recordPolicyOutcomeClosure(db: StateDatabase, cycleId: string, closureStatus: ClosureStatus, reason: V8ReasonCode, params: {
     proposalId?: string;
     decisionId?: string;
+    platformId?: string;
+    capabilityId?: string;
     downgradedActionKind?: string;
     postProcessing?: string[];
     nextState?: string;
@@ -63,6 +65,8 @@ export declare function recordPolicyOutcomeClosure(db: StateDatabase, cycleId: s
 export declare function recordExecutionClosure(db: StateDatabase, cycleId: string, closureStatus: "completed" | "failed", reason: V8ReasonCode, params: {
     proposalId: string;
     decisionId: string;
+    platformId?: string;
+    capabilityId?: string;
     executionResultRef?: string;
     outputSummary?: string;
     nextState?: string;

package/runtime/core/second-nature/action/action-closure-recorder.js

@@ -46,6 +46,7 @@ export async function recordNoActionClosure(db, cycleId, noActionReason, options
         id: closureId,
         createdAt: now,
         cycleId,
+        platformId: "heartbeat",
         status: "no_action",
         reason: noActionReason,
         nextState: "await_next_cycle",
@@ -122,6 +123,8 @@ export async function recordPolicyOutcomeClosure(db, cycleId, closureStatus, rea
         id: closureId,
         createdAt: now,
         cycleId,
+        platformId: params.platformId ?? "heartbeat",
+        capabilityId: params.capabilityId,
         proposalId: params.proposalId,
         decisionId: params.decisionId,
         status: closureStatus,
@@ -161,6 +164,8 @@ export async function recordExecutionClosure(db, cycleId, closureStatus, reason,
         id: closureId,
         createdAt: now,
         cycleId,
+        platformId: params.platformId ?? "heartbeat",
+        capabilityId: params.capabilityId,
         proposalId: params.proposalId,
         decisionId: params.decisionId,
         status: closureStatus,

package/runtime/core/second-nature/action/action-proposal-builder.js

@@ -136,6 +136,7 @@ export async function buildActionProposal(db, judgmentVerdictId, options) {
             id: closureId,
             createdAt: now,
             cycleId,
+            platformId: "heartbeat",
             status: "completed",
             reason: "remember_for_review",
             nextState: "pending_daily_review",

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

@@ -22,6 +22,7 @@
  * Test coverage: tests/unit/control-plane/heartbeat-cycle-trace.test.ts
  */
 import type { StateDatabase } from "../../../storage/db/index.js";
+import { type DailyRhythmState } from "../quiet-dream/daily-rhythm-scheduler.js";
 import type { SourceRef, DegradedOperationResult, V8ReasonCode } from "../../../shared/types/v8-contracts.js";
 export interface HeartbeatOrchestrationRequest {
     workspaceRoot: string;
@@ -34,5 +35,6 @@ export interface HeartbeatOrchestrationResult {
     closureRef?: SourceRef;
     noActionReason?: V8ReasonCode;
     degraded?: DegradedOperationResult;
+    rhythmState?: DailyRhythmState;
 }
 export declare function runHeartbeatCycle(db: StateDatabase, request: HeartbeatOrchestrationRequest): Promise<HeartbeatOrchestrationResult | DegradedOperationResult>;

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

@@ -30,6 +30,7 @@ import { buildActionProposal, } from "../action/action-proposal-builder.js";
 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";
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
@@ -43,6 +44,66 @@ async function nextCycleSequence(db) {
 function buildCycleId(sequence, now) {
     return `cyc_${now.replace(/[:.]/g, "")}_${sequence}`;
 }
+async function advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now) {
+    try {
+        const rhythmResult = await checkDailyRhythm(db, { now });
+        if ("status" in rhythmResult && rhythmResult.status === "checked") {
+            await recordLoopStageEvent(db, {
+                id: `evt_${cycleId}_daily_rhythm`,
+                cycleId,
+                cycleSequence,
+                stage: "quiet",
+                status: "completed",
+                occurredAt: new Date().toISOString(),
+                sourceRefs: [
+                    cycleRef,
+                    {
+                        uri: `sn://rhythm/${rhythmResult.state.day}`,
+                        family: "dream_run",
+                        id: `rhythm_${rhythmResult.state.day}`,
+                        redactionClass: "none",
+                        resolveStatus: "resolvable",
+                    },
+                ],
+            });
+            return { rhythmState: rhythmResult.state };
+        }
+        const degraded = rhythmResult;
+        await recordLoopStageEvent(db, {
+            id: `evt_${cycleId}_daily_rhythm`,
+            cycleId,
+            cycleSequence,
+            stage: "quiet",
+            status: "failed",
+            occurredAt: new Date().toISOString(),
+            reason: degraded.reason,
+            sourceRefs: [cycleRef],
+        });
+        return { rhythmDegraded: degraded };
+    }
+    catch (rhythmErr) {
+        const errMsg = rhythmErr instanceof Error ? rhythmErr.message : String(rhythmErr);
+        const degraded = {
+            status: "degraded",
+            reason: "state_unreadable",
+            ownerStage: "quiet",
+            sourceRefs: [cycleRef],
+            operatorNextAction: `Daily rhythm check failed: ${errMsg.slice(0, 120)}`,
+            retryable: true,
+        };
+        await recordLoopStageEvent(db, {
+            id: `evt_${cycleId}_daily_rhythm`,
+            cycleId,
+            cycleSequence,
+            stage: "quiet",
+            status: "failed",
+            occurredAt: new Date().toISOString(),
+            reason: degraded.reason,
+            sourceRefs: [cycleRef],
+        });
+        return { rhythmDegraded: degraded };
+    }
+}
 // ───────────────────────────────────────────────────────────────
 // Public API
 // ───────────────────────────────────────────────────────────────
@@ -130,6 +191,7 @@ export async function runHeartbeatCycle(db, request) {
             reason: degradedReason,
             sourceRefs: degradedClosureRef ? [degradedClosureRef, cycleRef] : [cycleRef],
         });
+        const { rhythmState } = await advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now);
         return {
             cycleId,
             cycleSequence,
@@ -145,6 +207,7 @@ export async function runHeartbeatCycle(db, request) {
                     retryable: true,
                 }
                 : undefined,
+            rhythmState,
         };
     }
     const cards = perceptionResult.cards;
@@ -182,11 +245,13 @@ export async function runHeartbeatCycle(db, request) {
             reason: "evidence_batch_empty",
             sourceRefs: emptyClosureRef ? [emptyClosureRef, cycleRef] : [cycleRef],
         });
+        const { rhythmState } = await advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now);
         return {
             cycleId,
             cycleSequence,
             closureRef: emptyClosureRef,
             noActionReason: "evidence_batch_empty",
+            rhythmState,
         };
     }
     // ── Context assembly: load accepted projections (T-DQ.R.3) ──
@@ -350,6 +415,8 @@ export async function runHeartbeatCycle(db, request) {
                     const closureResult = await recordPolicyOutcomeClosure(db, cycleId, closureStatus, decision.decisionReason, {
                         proposalId: proposal.id,
                         decisionId: decision.id,
+                        platformId: proposal.targetPlatformId,
+                        capabilityId: proposal.targetCapabilityId,
                         nextState: "await_next_cycle",
                     }, { now });
                     if ("closureId" in closureResult) {
@@ -369,6 +436,8 @@ export async function runHeartbeatCycle(db, request) {
                     const closureResult = await recordPolicyOutcomeClosure(db, cycleId, "downgraded", "guidance_unavailable", {
                         proposalId: proposal.id,
                         decisionId: decision.id,
+                        platformId: proposal.targetPlatformId,
+                        capabilityId: proposal.targetCapabilityId,
                         downgradedActionKind: dispatchResult.downgradedActionKind,
                         nextState: "await_guidance_recovery",
                     }, { now });
@@ -390,6 +459,8 @@ export async function runHeartbeatCycle(db, request) {
                     const closureResult = await recordExecutionClosure(db, cycleId, "completed", "policy_allowed", {
                         proposalId: proposal.id,
                         decisionId: decision.id,
+                        platformId: proposal.targetPlatformId,
+                        capabilityId: proposal.targetCapabilityId,
                         outputSummary: "Guidance draft dispatched (simulated)",
                         nextState: "await_next_cycle",
                     }, { now });
@@ -411,6 +482,8 @@ export async function runHeartbeatCycle(db, request) {
                     const closureResult = await recordExecutionClosure(db, cycleId, "completed", "policy_allowed", {
                         proposalId: proposal.id,
                         decisionId: decision.id,
+                        platformId: proposal.targetPlatformId,
+                        capabilityId: proposal.targetCapabilityId,
                         outputSummary: "Connector dispatch prepared (simulated — T-CP.R.2)",
                         nextState: "await_real_execution",
                     }, { now });
@@ -466,11 +539,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);
     return {
         cycleId,
         cycleSequence,
         closureRef,
         noActionReason,
         degraded: closureDegraded,
+        rhythmState,
     };
 }

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

@@ -17,6 +17,7 @@
  */
 import type { StateDatabase } from "../../../storage/db/index.js";
 import type { SourceRef, DegradedOperationResult, V8ReasonCode } from "../../../shared/types/v8-contracts.js";
+import type { DailyRhythmState } from "../quiet-dream/daily-rhythm-scheduler.js";
 export interface RealRuntimeSpineOptions {
     workspaceRoot: string;
     state: StateDatabase;
@@ -29,5 +30,6 @@ export interface RealRuntimeSpineResult {
     closureRef?: SourceRef;
     noActionReason?: V8ReasonCode;
     degraded?: DegradedOperationResult;
+    rhythmState?: DailyRhythmState;
 }
 export declare function runRealRuntimeHeartbeatCycle(options: RealRuntimeSpineOptions): Promise<RealRuntimeSpineResult | DegradedOperationResult>;

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

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

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

@@ -21,7 +21,7 @@
  */
 import type { StateDatabase } from "../../../storage/db/index.js";
 import type { DegradedOperationResult, V8ReasonCode } from "../../../shared/types/v8-contracts.js";
-export type RhythmStatus = "due" | "completed" | "skipped" | "blocked" | "not_due";
+export type RhythmStatus = "due" | "completed" | "scheduled" | "skipped" | "blocked" | "not_due";
 export interface DailyRhythmState {
     day: string;
     quietStatus: RhythmStatus;

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

@@ -71,7 +71,6 @@ export async function checkDailyRhythm(db, options) {
     else {
         // Closures exist but Quiet not completed → due
         state.quietStatus = "due";
-        state.quietReason = "quiet_empty_input";
         // Auto-run Quiet if forced or if not yet attempted
         if (options?.forceQuiet || state.quietStatus === "due") {
             const quietResult = await buildQuietDailyReview(db, { day, now });
@@ -93,8 +92,10 @@ export async function checkDailyRhythm(db, options) {
     }
     // Determine Dream status based on Quiet outcome
     if (state.quietStatus === "completed") {
-        if (state.dreamStatus === "completed" || state.dreamStatus === "blocked") {
-            // Already handled
+        if (state.dreamStatus === "completed" ||
+            state.dreamStatus === "scheduled" ||
+            state.dreamStatus === "blocked") {
+            // Already handled; do not re-schedule
         }
         else {
             state.dreamStatus = "due";
@@ -123,10 +124,14 @@ export async function checkDailyRhythm(db, options) {
         state.dreamStatus = "not_due";
         state.dreamReason = "quiet_empty_input";
     }
+    else if (state.quietStatus === "skipped") {
+        state.dreamStatus = "blocked";
+        state.dreamReason = state.quietReason ?? "quiet_empty_input";
+    }
     else {
-        // Quiet blocked/skipped → Dream cannot run
+        // Quiet blocked (degraded) → Dream cannot run
         state.dreamStatus = "blocked";
-        state.dreamReason = "dream_blocked_redaction";
+        state.dreamReason = state.quietReason ?? "dream_blocked_redaction";
     }
     // Persist state
     const writeResult = await writeDailyRhythmState(db, {

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

@@ -32,5 +32,5 @@ export interface AcceptMemoryProjectionOptions {
     now?: string;
 }
 export declare function acceptMemoryProjection(db: StateDatabase, candidateId: string, topicKey: string, memoryText: string, sourceRefs: SourceRef[], options?: AcceptMemoryProjectionOptions): Promise<ProjectionLifecycleResult | DegradedOperationResult>;
-export declare function rejectMemoryProjection(db: StateDatabase, projectionId: string, candidateId: string, topicKey: string, sourceRefs: SourceRef[], reason?: V8ReasonCode, options?: AcceptMemoryProjectionOptions): Promise<ProjectionLifecycleResult | DegradedOperationResult>;
-export declare function retireMemoryProjection(db: StateDatabase, projectionId: string, candidateId: string, topicKey: string, sourceRefs: SourceRef[], options?: AcceptMemoryProjectionOptions): Promise<ProjectionLifecycleResult | DegradedOperationResult>;
+export declare function rejectMemoryProjection(db: StateDatabase, projectionId: string, _candidateId: string, _topicKey: string, _sourceRefs: SourceRef[], reason?: V8ReasonCode, options?: AcceptMemoryProjectionOptions): Promise<ProjectionLifecycleResult | DegradedOperationResult>;
+export declare function retireMemoryProjection(db: StateDatabase, projectionId: string, _candidateId: string, _topicKey: string, _sourceRefs: SourceRef[], options?: AcceptMemoryProjectionOptions): Promise<ProjectionLifecycleResult | DegradedOperationResult>;

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

@@ -82,21 +82,12 @@ export async function acceptMemoryProjection(db, candidateId, topicKey, memoryTe
         supersedesProjectionId: supersedesId,
     };
 }
-export async function rejectMemoryProjection(db, projectionId, candidateId, topicKey, sourceRefs, reason = "projection_rejected", options) {
+export async function rejectMemoryProjection(db, projectionId, _candidateId, _topicKey, _sourceRefs, reason = "projection_rejected", options) {
     const now = options?.now ?? new Date().toISOString();
-    const writeResult = await writeLongTermMemoryProjection(db, {
-        id: projectionId,
-        createdAt: now,
-        candidateId,
-        topicKey,
-        status: "rejected",
-        sourceRefs,
-        redactionClass: "none",
-        lifecycleStatus: "rejected",
-        payloadJson: JSON.stringify({ rejectedAt: now, reason }),
-    });
-    if ("reason" in writeResult) {
-        return writeResult;
+    // F5: Use UPDATE instead of INSERT to avoid PK conflict on existing projections
+    const updateResult = await updateLongTermMemoryProjectionStatus(db, projectionId, "rejected", JSON.stringify({ rejectedAt: now, reason }));
+    if ("reason" in updateResult) {
+        return updateResult;
     }
     return {
         projectionId,
@@ -104,21 +95,12 @@ export async function rejectMemoryProjection(db, projectionId, candidateId, topi
         reason,
     };
 }
-export async function retireMemoryProjection(db, projectionId, candidateId, topicKey, sourceRefs, options) {
+export async function retireMemoryProjection(db, projectionId, _candidateId, _topicKey, _sourceRefs, options) {
     const now = options?.now ?? new Date().toISOString();
-    const writeResult = await writeLongTermMemoryProjection(db, {
-        id: projectionId,
-        createdAt: now,
-        candidateId,
-        topicKey,
-        status: "retired",
-        sourceRefs,
-        redactionClass: "none",
-        lifecycleStatus: "retired",
-        payloadJson: JSON.stringify({ retiredAt: now }),
-    });
-    if ("reason" in writeResult) {
-        return writeResult;
+    // F5: Use UPDATE instead of INSERT to avoid PK conflict on existing projections
+    const updateResult = await updateLongTermMemoryProjectionStatus(db, projectionId, "retired", JSON.stringify({ retiredAt: now }));
+    if ("reason" in updateResult) {
+        return updateResult;
     }
     return {
         projectionId,

package/runtime/observability/db/index.d.ts

@@ -5,6 +5,8 @@ export interface ObservabilityDatabase {
     sqlite: Database;
     db: ReturnType<typeof drizzle<typeof schema>>;
     schema: typeof schema;
+    /** Persist in-memory sql.js state to disk without closing the connection. */
+    flush(): void;
     close(): void;
 }
 export declare function createObservabilityDatabase(filename?: string): ObservabilityDatabase;

package/runtime/observability/db/index.js

@@ -126,6 +126,12 @@ export function createObservabilityDatabase(filename = "observability.db") {
         sqlite,
         db,
         schema,
+        flush() {
+            if (!isMemory) {
+                const data = sqlite.export();
+                fs.writeFileSync(dbPath, Buffer.from(data));
+            }
+        },
         close() {
             if (!isMemory) {
                 const data = sqlite.export();

package/runtime/observability/living-loop-health-gate.d.ts

@@ -25,14 +25,18 @@ export interface RealRunHealthGate {
     hasQuietArtifact: boolean;
     /** Has a scheduled or completed DreamConsolidationRun */
     hasDreamArtifact: boolean;
+    /** Has a fresh impulse context artifact (within 24h) */
+    hasFreshImpulseContext: boolean;
+    /** Has at least one accepted or active long-term memory projection */
+    hasProjectionFeedback: boolean;
     /** True if only contract smoke (cycle traces) but no real artifacts */
     contractSmokeOnly: boolean;
-    /** True if closure exists but no runtime-produced cycle trace backs it */
+    /** True if closure exists but no runtime-produced cycle trace + stage event backs it */
     seededStateDetected: boolean;
     /** True only when real runtime activity is proven (not seeded, not smoke-only) */
     gatePassed: boolean;
     /** Explicit missing stage reason */
-    missingStage?: "closure" | "quiet" | "dream" | "none";
+    missingStage?: "closure" | "quiet" | "dream" | "impulse" | "projection" | "none";
     missingReason?: string;
 }
 export type RealRunHealthResult = {

package/runtime/observability/living-loop-health-gate.js

@@ -16,7 +16,7 @@
  * - Read-only diagnostic; does not modify state.
  * - Reports explicit absence reasons instead of silent zeros.
  */
-import { readActionClosuresByDay, readDailyRhythmStateByDay, readHeartbeatCycleTraces, } from "../storage/v8-state-stores.js";
+import { readActionClosuresByDay, readDailyRhythmStateByDay, readHeartbeatCycleTraces, readLoopStageEventsByCycle, readImpulseContextArtifact, readMemoryProjectionsByStatus, } from "../storage/v8-state-stores.js";
 // ───────────────────────────────────────────────────────────────
 // Public API
 // ───────────────────────────────────────────────────────────────
@@ -28,7 +28,7 @@ export async function checkRealRunHealth(db, day) {
         return { ok: false, degraded: closureResult.degraded };
     }
     const hasRealClosure = closureResult.rows.length > 0;
-    // Check if closures are runtime-produced (backed by cycle trace + stage events)
+    // Check if closures are runtime-produced (backed by cycle trace + closure stage event + source refs)
     let seededStateDetected = false;
     if (hasRealClosure) {
         const traces = await readHeartbeatCycleTraces(db, 1000);
@@ -41,6 +41,29 @@ export async function checkRealRunHealth(db, day) {
                 seededStateDetected = true;
                 break;
             }
+            // F3: verify closure has corresponding loop_stage_event with stage="closure" and status="completed"
+            const stageEvents = await readLoopStageEventsByCycle(db, closure.cycleId);
+            if (stageEvents.degraded) {
+                return { ok: false, degraded: stageEvents.degraded };
+            }
+            const hasClosureStageEvent = stageEvents.rows.some((e) => e.stage === "closure" && e.status === "completed");
+            if (!hasClosureStageEvent) {
+                seededStateDetected = true;
+                break;
+            }
+            // F3: verify closure has non-empty source refs
+            const sourceRefsJson = closure.sourceRefsJson ?? "[]";
+            let sourceRefs = [];
+            try {
+                sourceRefs = JSON.parse(sourceRefsJson);
+            }
+            catch {
+                sourceRefs = [];
+            }
+            if (!Array.isArray(sourceRefs) || sourceRefs.length === 0) {
+                seededStateDetected = true;
+                break;
+            }
         }
     }
     // Check daily rhythm state for Quiet/Dream
@@ -51,10 +74,24 @@ export async function checkRealRunHealth(db, day) {
     const rhythm = rhythmResult.row;
     const hasQuietArtifact = rhythm?.quietStatus === "completed";
     const hasDreamArtifact = rhythm?.dreamStatus === "scheduled" || rhythm?.dreamStatus === "completed";
+    // Check impulse context artifact freshness
+    const impulseResult = await readImpulseContextArtifact(db, "heartbeat");
+    let hasFreshImpulseContext = false;
+    if (!impulseResult.degraded && impulseResult.row) {
+        const updatedAt = new Date(impulseResult.row.updatedAt).getTime();
+        const now = Date.now();
+        const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+        hasFreshImpulseContext = now - updatedAt <= ONE_DAY_MS;
+    }
+    // Check accepted/active memory projections
+    const activeProjections = await readMemoryProjectionsByStatus(db, "active");
+    const acceptedProjections = await readMemoryProjectionsByStatus(db, "accepted");
+    const hasProjectionFeedback = (!activeProjections.degraded && activeProjections.rows.length > 0) ||
+        (!acceptedProjections.degraded && acceptedProjections.rows.length > 0);
     // Determine if only contract smoke
-    const contractSmokeOnly = !hasRealClosure && !hasQuietArtifact && !hasDreamArtifact;
+    const contractSmokeOnly = !hasRealClosure && !hasQuietArtifact && !hasDreamArtifact && !hasFreshImpulseContext && !hasProjectionFeedback;
     // Gate passes only when all real runtime stages have evidence
-    const gatePassed = !contractSmokeOnly && !seededStateDetected && hasRealClosure && hasQuietArtifact && hasDreamArtifact;
+    const gatePassed = !contractSmokeOnly && !seededStateDetected && hasRealClosure && hasQuietArtifact && hasDreamArtifact && hasFreshImpulseContext && hasProjectionFeedback;
     // Identify missing stage
     let missingStage;
     let missingReason;
@@ -64,7 +101,7 @@ export async function checkRealRunHealth(db, day) {
     }
     else if (seededStateDetected) {
         missingStage = "closure";
-        missingReason = "ActionClosureRecord exists but lacks runtime-produced cycle trace. Seeded state detected — not valid runtime proof.";
+        missingReason = "ActionClosureRecord exists but lacks runtime-produced cycle trace, closure stage event, or source refs. Seeded state detected — not valid runtime proof.";
     }
     else if (!hasQuietArtifact) {
         missingStage = "quiet";
@@ -74,6 +111,14 @@ export async function checkRealRunHealth(db, day) {
         missingStage = "dream";
         missingReason = "QuietDailyReview completed but no DreamConsolidationRun. Dream scheduler may be unavailable.";
     }
+    else if (!hasFreshImpulseContext) {
+        missingStage = "impulse";
+        missingReason = "Heartbeat produces closure but impulse context artifact is missing or stale (>24h). Run guidance_payload to refresh.";
+    }
+    else if (!hasProjectionFeedback) {
+        missingStage = "projection";
+        missingReason = "Living loop active but no accepted/active memory projections. Quiet/Dream may not have produced accepted memory yet.";
+    }
     else {
         missingStage = "none";
         missingReason = "All living-loop stages have real artifacts.";
@@ -84,6 +129,8 @@ export async function checkRealRunHealth(db, day) {
             hasRealClosure,
             hasQuietArtifact,
             hasDreamArtifact,
+            hasFreshImpulseContext,
+            hasProjectionFeedback,
             contractSmokeOnly,
             seededStateDetected,
             gatePassed,