@haaaiawd/second-nature 0.2.1 → 0.2.4

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

@@ -68,6 +68,8 @@ export async function buildQuietDailyReview(db, options) {
         };
     }
     const sourceRefs = closures.map(buildSourceRefFromClosure);
+    // T-DQ.R.4: first-class closure refs — identical to sourceRefs here, but explicitly typed
+    const closureRefs = closures.map(buildSourceRefFromClosure);
     // Collect memory-review candidates from closure payloads
     const memoryCandidates = [];
     for (const closure of closures) {
@@ -96,6 +98,7 @@ export async function buildQuietDailyReview(db, options) {
         closureCount: closures.length,
         memoryCandidateCount: memoryCandidates.length,
         sourceRefs,
+        closureRefs,
         redactionClass: "none",
         lifecycleStatus: "pending",
         payloadJson: JSON.stringify({
@@ -115,6 +118,7 @@ export async function buildQuietDailyReview(db, options) {
             closureCount: closures.length,
             memoryCandidateCount: memoryCandidates.length,
             sourceRefs,
+            closureRefs,
             reviewSummary,
             importanceSignals,
             createdAt: now,

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

@@ -0,0 +1,45 @@
+/**
+ * LivingLoopHealthGate — Distinguish contract-smoke from real runtime activity.
+ *
+ * Core logic: Check for persisted ActionClosureRecord, QuietDailyReview,
+ * and DreamConsolidationRun to determine if the living loop has real
+ * evidence or is only passing contract smoke tests.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/observability-health-system.md §4.2`
+ * - `.anws/v8/04_SYSTEM_DESIGN/control-plane-system.md §4`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (readActionClosuresByDay, readDailyRhythmStateByDay)
+ *
+ * Boundary:
+ * - Read-only diagnostic; does not modify state.
+ * - Reports explicit absence reasons instead of silent zeros.
+ */
+import type { StateDatabase } from "../storage/db/index.js";
+import type { DegradedOperationResult } from "../shared/types/v8-contracts.js";
+export interface RealRunHealthGate {
+    /** Has at least one real ActionClosureRecord */
+    hasRealClosure: boolean;
+    /** Has a completed QuietDailyReview */
+    hasQuietArtifact: boolean;
+    /** Has a scheduled or completed DreamConsolidationRun */
+    hasDreamArtifact: 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 */
+    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";
+    missingReason?: string;
+}
+export type RealRunHealthResult = {
+    ok: true;
+    gate: RealRunHealthGate;
+} | {
+    ok: false;
+    degraded: DegradedOperationResult;
+};
+export declare function checkRealRunHealth(db: StateDatabase, day?: string): Promise<RealRunHealthResult>;

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

@@ -0,0 +1,94 @@
+/**
+ * LivingLoopHealthGate — Distinguish contract-smoke from real runtime activity.
+ *
+ * Core logic: Check for persisted ActionClosureRecord, QuietDailyReview,
+ * and DreamConsolidationRun to determine if the living loop has real
+ * evidence or is only passing contract smoke tests.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/observability-health-system.md §4.2`
+ * - `.anws/v8/04_SYSTEM_DESIGN/control-plane-system.md §4`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (readActionClosuresByDay, readDailyRhythmStateByDay)
+ *
+ * Boundary:
+ * - 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";
+// ───────────────────────────────────────────────────────────────
+// Public API
+// ───────────────────────────────────────────────────────────────
+export async function checkRealRunHealth(db, day) {
+    const targetDay = day ?? new Date().toISOString().slice(0, 10);
+    // Check closures
+    const closureResult = await readActionClosuresByDay(db, targetDay);
+    if (closureResult.degraded) {
+        return { ok: false, degraded: closureResult.degraded };
+    }
+    const hasRealClosure = closureResult.rows.length > 0;
+    // Check if closures are runtime-produced (backed by cycle trace + stage events)
+    let seededStateDetected = false;
+    if (hasRealClosure) {
+        const traces = await readHeartbeatCycleTraces(db, 1000);
+        if (traces.degraded) {
+            return { ok: false, degraded: traces.degraded };
+        }
+        for (const closure of closureResult.rows) {
+            const hasCycleTrace = traces.rows.some((t) => t.id === closure.cycleId);
+            if (!hasCycleTrace) {
+                seededStateDetected = true;
+                break;
+            }
+        }
+    }
+    // Check daily rhythm state for Quiet/Dream
+    const rhythmResult = await readDailyRhythmStateByDay(db, targetDay);
+    if (rhythmResult.degraded) {
+        return { ok: false, degraded: rhythmResult.degraded };
+    }
+    const rhythm = rhythmResult.row;
+    const hasQuietArtifact = rhythm?.quietStatus === "completed";
+    const hasDreamArtifact = rhythm?.dreamStatus === "scheduled" || rhythm?.dreamStatus === "completed";
+    // Determine if only contract smoke
+    const contractSmokeOnly = !hasRealClosure && !hasQuietArtifact && !hasDreamArtifact;
+    // Gate passes only when all real runtime stages have evidence
+    const gatePassed = !contractSmokeOnly && !seededStateDetected && hasRealClosure && hasQuietArtifact && hasDreamArtifact;
+    // Identify missing stage
+    let missingStage;
+    let missingReason;
+    if (!hasRealClosure) {
+        missingStage = "closure";
+        missingReason = "No ActionClosureRecord for today. Heartbeat may be running contract smoke without real action closure.";
+    }
+    else if (seededStateDetected) {
+        missingStage = "closure";
+        missingReason = "ActionClosureRecord exists but lacks runtime-produced cycle trace. Seeded state detected — not valid runtime proof.";
+    }
+    else if (!hasQuietArtifact) {
+        missingStage = "quiet";
+        missingReason = "ActionClosureRecord exists but no QuietDailyReview. Daily review may be due or skipped.";
+    }
+    else if (!hasDreamArtifact) {
+        missingStage = "dream";
+        missingReason = "QuietDailyReview completed but no DreamConsolidationRun. Dream scheduler may be unavailable.";
+    }
+    else {
+        missingStage = "none";
+        missingReason = "All living-loop stages have real artifacts.";
+    }
+    return {
+        ok: true,
+        gate: {
+            hasRealClosure,
+            hasQuietArtifact,
+            hasDreamArtifact,
+            contractSmokeOnly,
+            seededStateDetected,
+            gatePassed,
+            missingStage,
+            missingReason,
+        },
+    };
+}

package/runtime/observability/loop-status.d.ts

@@ -20,6 +20,16 @@
  */
 import type { StateDatabase } from "../storage/db/index.js";
 import type { DegradedOperationResult } from "../shared/types/v8-contracts.js";
+export interface RealRunHealthProjection {
+    gatePassed: boolean;
+    contractSmokeOnly: boolean;
+    seededStateDetected: boolean;
+    hasRealClosure: boolean;
+    hasQuietArtifact: boolean;
+    hasDreamArtifact: boolean;
+    missingStage?: string;
+    missingReason?: string;
+}
 export interface LoopStatusReadModel {
     ok: true;
     overallStatus: string;
@@ -29,6 +39,7 @@ export interface LoopStatusReadModel {
     stageSummaries: StageSummary[];
     policyDeniedCount: number;
     nextAction: string;
+    realRunHealth: RealRunHealthProjection;
 }
 export interface StageSummary {
     stage: string;

package/runtime/observability/loop-status.js

@@ -19,10 +19,15 @@
  * Test coverage: tests/unit/observability/loop-status.test.ts
  */
 import { assembleLoopStatus } from "./causal-loop-health.js";
+import { checkRealRunHealth } from "./living-loop-health-gate.js";
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
-function computeNextAction(overallStatus, stalledAt) {
+function computeNextAction(overallStatus, stalledAt, realRunMissingStage, realRunMissingReason) {
+    // Real-run health takes precedence over generic causal health
+    if (realRunMissingStage && realRunMissingStage !== "none") {
+        return `Real-run health degraded: ${realRunMissingReason ?? `missing stage: ${realRunMissingStage}`}. Run a real heartbeat cycle or verify daily rhythm state.`;
+    }
     if (overallStatus === "healthy") {
         return "No operator action required. Loop is progressing normally.";
     }
@@ -60,6 +65,46 @@ export async function readLoopStatus(db) {
         };
     }
     const snapshot = health;
+    // T-OBS.R.3: Consume real-run health gate
+    const realRunResult = await checkRealRunHealth(db);
+    let realRunHealth;
+    if (realRunResult.ok) {
+        realRunHealth = {
+            gatePassed: realRunResult.gate.gatePassed,
+            contractSmokeOnly: realRunResult.gate.contractSmokeOnly,
+            seededStateDetected: realRunResult.gate.seededStateDetected,
+            hasRealClosure: realRunResult.gate.hasRealClosure,
+            hasQuietArtifact: realRunResult.gate.hasQuietArtifact,
+            hasDreamArtifact: realRunResult.gate.hasDreamArtifact,
+            missingStage: realRunResult.gate.missingStage,
+            missingReason: realRunResult.gate.missingReason,
+        };
+    }
+    else {
+        realRunHealth = {
+            gatePassed: false,
+            contractSmokeOnly: false,
+            seededStateDetected: false,
+            hasRealClosure: false,
+            hasQuietArtifact: false,
+            hasDreamArtifact: false,
+            missingReason: "Real-run health check degraded",
+        };
+    }
+    // Override overallStatus based on real-run health parity
+    let overallStatus = snapshot.overallStatus;
+    let stalledAt = snapshot.stalledAt;
+    if (!realRunHealth.gatePassed) {
+        // Real-run gate fails → cannot report healthy
+        if (overallStatus === "healthy") {
+            overallStatus = "degraded";
+        }
+    }
+    else {
+        // Real-run gate passes → all stages have evidence, ignore staged-event-only stall
+        overallStatus = "healthy";
+        stalledAt = undefined;
+    }
     const stageSummaries = snapshot.stages.map((s) => ({
         stage: s.stage,
         eventCount: s.eventCount,
@@ -68,18 +113,19 @@ export async function readLoopStatus(db) {
     }));
     // Policy denied count is a placeholder; real implementation would query action closures
     const policyDeniedCount = 0;
-    const nextAction = computeNextAction(snapshot.overallStatus, snapshot.stalledAt);
+    const nextAction = computeNextAction(overallStatus, snapshot.stalledAt, realRunHealth.missingStage, realRunHealth.missingReason);
     return {
         ok: true,
         status: {
             ok: true,
-            overallStatus: snapshot.overallStatus,
+            overallStatus,
             stalledAt: snapshot.stalledAt,
             lastCycleSequence: snapshot.lastCycleSequence,
             lastHeartbeatAt: snapshot.lastHeartbeatAt,
             stageSummaries,
             policyDeniedCount,
             nextAction,
+            realRunHealth,
         },
     };
 }

package/runtime/observability/services/audit-closure-recorders.d.ts

@@ -0,0 +1,31 @@
+import type { ConnectorResult } from "../../connectors/base/contract.js";
+import type { QuietArtifactAck } from "../../storage/quiet/quiet-artifact-writer.js";
+import type { QuietArtifactWrite } from "../../storage/quiet/quiet-artifact-types.js";
+import type { AppendOnlyAuditStore } from "../audit/append-only-audit-store.js";
+export type ConnectorAttemptAuditOutcome = "success" | "failure" | "circuit_open" | "blocked";
+export interface RecordConnectorAttemptAuditInput {
+    auditStore?: AppendOnlyAuditStore;
+    platformId: string;
+    capability: string;
+    result: ConnectorResult<unknown>;
+    triggerSource: "manual_run" | "heartbeat";
+    decisionId?: string;
+    intentId?: string;
+    createdAt?: string;
+}
+export interface RecordQuietArtifactAuditInput {
+    auditStore?: AppendOnlyAuditStore;
+    day: string;
+    kind: QuietArtifactWrite["kind"];
+    status: "completed" | "empty" | "blocked" | "failed";
+    reasons: string[];
+    artifactAck?: QuietArtifactAck;
+    persistedRelativePath?: string;
+    createdAt?: string;
+}
+export declare function recordConnectorAttemptAudit(input: RecordConnectorAttemptAuditInput): {
+    eventId?: string;
+};
+export declare function recordQuietArtifactAudit(input: RecordQuietArtifactAuditInput): {
+    eventId?: string;
+};

package/runtime/observability/services/audit-closure-recorders.js

@@ -0,0 +1,87 @@
+/**
+ * Audit-backed closure recorders for connector attempts and Quiet artifacts.
+ *
+ * Core logic: write small redacted audit envelopes for runtime actions that
+ * heartbeat_digest depends on. Payloads contain outcome and source linkage only;
+ * raw connector payloads and credentials are deliberately excluded.
+ *
+ * Dependencies: AppendOnlyAuditStore and buildAuditEnvelope hash-chain helpers.
+ * Boundary: does not execute connectors, write Quiet artifacts, or mutate state.
+ *
+ * Test coverage: tests/unit/ops/manual-run-dispatcher.test.ts,
+ * tests/unit/observability/heartbeat-digest-assembler.test.ts.
+ */
+import { randomUUID } from "node:crypto";
+import { buildAuditEnvelope } from "../audit/audit-envelope.js";
+function mapConnectorOutcome(result) {
+    if (result.status === "success")
+        return "success";
+    if (result.failureClass === "cooldown_blocked")
+        return "blocked";
+    if (result.failureClass === "platform_unavailable")
+        return "circuit_open";
+    return "failure";
+}
+export function recordConnectorAttemptAudit(input) {
+    if (!input.auditStore)
+        return {};
+    const createdAt = input.createdAt ?? new Date().toISOString();
+    const family = "connector.attempt";
+    const envelope = buildAuditEnvelope({
+        family,
+        plane: "telemetry",
+        traceId: `connector_attempt:${input.triggerSource}:${randomUUID()}`,
+        sequence: input.auditStore.list().length + 1,
+        previousHash: input.auditStore.lastRecordHash(family),
+        createdAt,
+        payload: {
+            platformId: input.platformId,
+            capability: input.capability,
+            outcome: mapConnectorOutcome(input.result),
+            triggerSource: input.triggerSource,
+            status: input.result.status,
+            failureClass: input.result.failureClass,
+            channel: input.result.metadata.channel,
+            latencyMs: input.result.metadata.latencyMs,
+            degraded: Boolean(input.result.metadata.degraded),
+            decisionId: input.decisionId,
+            intentId: input.intentId,
+            createdAt,
+        },
+    });
+    input.auditStore.append(envelope);
+    return { eventId: envelope.eventId };
+}
+export function recordQuietArtifactAudit(input) {
+    if (!input.auditStore)
+        return {};
+    const createdAt = input.createdAt ?? new Date().toISOString();
+    const family = "source_coverage";
+    const sourceRefs = input.artifactAck ? [input.artifactAck.artifactRef] : [];
+    const envelope = buildAuditEnvelope({
+        family,
+        plane: "source_coverage",
+        traceId: `quiet_artifact:${input.day}:${randomUUID()}`,
+        sequence: input.auditStore.list().length + 1,
+        previousHash: input.auditStore.lastRecordHash(family),
+        createdAt,
+        payload: {
+            auditId: `quiet-audit:${input.day}:${randomUUID()}`,
+            traceId: `quiet_trace:${input.day}`,
+            subjectType: "quiet_artifact",
+            subjectRef: input.artifactAck?.artifactRef.uri ?? `quiet:${input.day}:${input.kind}`,
+            day: input.day,
+            kind: input.kind,
+            status: input.status,
+            usedSourceRefs: sourceRefs,
+            unresolvedRefs: [],
+            coverageRatio: input.artifactAck?.sourceCoverage.coverageRatio ?? 0,
+            unsupportedClaims: input.artifactAck?.sourceCoverage.unsupportedClaims ?? [],
+            persistedRelativePath: input.persistedRelativePath,
+            reasonCodes: input.reasons,
+            createdAt,
+        },
+    });
+    input.auditStore.append(envelope);
+    return { eventId: envelope.eventId };
+}

package/runtime/observability/services/heartbeat-digest-assembler.d.ts

@@ -68,6 +68,16 @@ export interface DeliveryProofRef {
     channelId: string;
     messageHash: string;
 }
+export interface RealRunHealthDigestProjection {
+    gatePassed: boolean;
+    contractSmokeOnly: boolean;
+    seededStateDetected: boolean;
+    hasRealClosure: boolean;
+    hasQuietArtifact: boolean;
+    hasDreamArtifact: boolean;
+    missingStage?: string;
+    missingReason?: string;
+}
 export interface HeartbeatDigest {
     date: string;
     generatedAt: string;
@@ -76,6 +86,8 @@ export interface HeartbeatDigest {
     goalSummary: GoalDaySummary;
     quietDreamSummary: QuietDreamDaySummary;
     healthSummary: HealthDaySummary;
+    /** Real-run health gate result (T-OBS.R.3) */
+    realRunHealth: RealRunHealthDigestProjection;
     /** Set when delivery succeeded */
     deliveredAt?: string;
     /** Proof of successful delivery (channel + message hash, no raw content) */

package/runtime/observability/services/heartbeat-digest-assembler.js

@@ -97,10 +97,21 @@ function aggregateHealthSummary(events, dateStr) {
 }
 function aggregateQuietDreamFromAudit(events, dateStr) {
     const dreamEvents = filterByDate(events, "dream.trace", dateStr);
+    const quietEvents = filterByDate(events, "source_coverage", dateStr)
+        .filter((ev) => ev.payload.subjectType === "quiet_artifact");
+    let quietRuns = 0;
+    let quietSucceeded = 0;
     let dreamRuns = 0;
     let dreamAccepted = 0;
     let dreamSkipped = 0;
     const dreamSkipReasons = [];
+    for (const ev of quietEvents) {
+        const payload = ev.payload;
+        quietRuns++;
+        if (payload.status === "completed" || payload.status === "empty") {
+            quietSucceeded++;
+        }
+    }
     for (const ev of dreamEvents) {
         const payload = ev.payload;
         if (payload.event === "dream_started")
@@ -113,10 +124,9 @@ function aggregateQuietDreamFromAudit(events, dateStr) {
                 dreamSkipReasons.push(payload.skipReason);
         }
     }
-    // Quiet stats not yet in audit (narrative.trace not fully wired) — default to 0
     return {
-        quietRuns: 0,
-        quietSucceeded: 0,
+        quietRuns,
+        quietSucceeded,
         dreamRuns,
         dreamAccepted,
         dreamSkipped,
@@ -217,6 +227,15 @@ export async function generateHeartbeatDigest(date, deps) {
         goalSummary,
         quietDreamSummary,
         healthSummary,
+        realRunHealth: {
+            gatePassed: false,
+            contractSmokeOnly: true,
+            seededStateDetected: false,
+            hasRealClosure: false,
+            hasQuietArtifact: false,
+            hasDreamArtifact: false,
+            missingReason: "Real-run health not evaluated — call checkRealRunHealth before digest generation",
+        },
     };
     // T-OBS.C.4: delivery hook — attempt delivery if adapter is provided
     if (deliveryAdapter) {

package/runtime/shared/types/v8-contracts.d.ts

@@ -25,7 +25,7 @@ export interface ActionKindMetadata {
     allowedDowngrades: PlatformNeutralActionKind[];
 }
 export type ConnectorCapabilitySideEffect = "external_read" | "external_write" | "local_state" | "unknown";
-export type SourceRefFamily = "evidence" | "perception" | "judgment" | "action_closure" | "quiet_review" | "dream_run" | "memory_projection" | "tool_experience" | "connector_result" | "audit";
+export type SourceRefFamily = "evidence" | "perception" | "judgment" | "action_closure" | "quiet_review" | "dream_run" | "memory_projection" | "projection" | "tool_experience" | "connector_result" | "audit";
 export type RedactionClass = "none" | "redacted" | "blocked";
 export type SensitivityClass = "public_technical" | "public_general" | "private_context" | "sensitive";
 export type SourceResolveStatus = "resolvable" | "missing" | "redacted" | "permission_denied";
@@ -82,5 +82,5 @@ export interface DegradedOperationResult {
     operatorNextAction: string;
     retryable: boolean;
 }
-export type V8ReasonCode = "quiet_completed" | "quiet_empty_input" | "quiet_state_unreadable" | "quiet_validation_failed" | "dream_scheduled" | "dream_scheduler_unavailable" | "dream_started" | "dream_completed" | "dream_failed" | "dream_blocked_redaction" | "projection_candidate_created" | "projection_accepted" | "projection_rejected" | "projection_superseded" | "proposal_created" | "proposal_no_action" | "proposal_missing_source_refs" | "proposal_risk_blocked" | "policy_allowed" | "policy_deferred_owner_confirmation" | "policy_downgraded_to_draft" | "policy_denied_missing_permission" | "policy_denied_high_risk" | "policy_denied_breaker_open" | "guidance_unavailable" | "closure_completed" | "closure_no_action" | "closure_denied" | "closure_deferred" | "closure_downgraded" | "closure_downgraded_without_draft" | "closure_failed" | "perception_rules_only" | "evidence_batch_empty" | "evidence_batch_truncated" | "judgment_low_confidence" | "judgment_missing_source_refs" | "source_refs_unresolved" | "state_unreadable" | "stage_event_missing" | "ingestion_no_data" | "ingestion_empty" | "ingestion_state_unreadable" | "ingestion_connector_failed" | "execution_completed" | "execution_failed" | "execution_timeout" | "execution_unavailable";
+export type V8ReasonCode = "quiet_completed" | "quiet_empty_input" | "quiet_state_unreadable" | "quiet_validation_failed" | "dream_scheduled" | "dream_scheduler_unavailable" | "dream_started" | "dream_completed" | "dream_failed" | "dream_blocked_redaction" | "projection_candidate_created" | "projection_accepted" | "projection_rejected" | "projection_superseded" | "projection_topic_matched" | "proposal_created" | "proposal_no_action" | "proposal_missing_source_refs" | "proposal_risk_blocked" | "policy_allowed" | "policy_deferred_owner_confirmation" | "policy_downgraded_to_draft" | "policy_denied_missing_permission" | "policy_denied_high_risk" | "policy_denied_breaker_open" | "guidance_unavailable" | "closure_completed" | "closure_no_action" | "closure_denied" | "closure_deferred" | "closure_downgraded" | "closure_downgraded_without_draft" | "closure_failed" | "perception_rules_only" | "evidence_batch_empty" | "evidence_batch_truncated" | "judgment_low_confidence" | "judgment_missing_source_refs" | "source_refs_unresolved" | "state_unreadable" | "stage_event_missing" | "ingestion_no_data" | "ingestion_empty" | "ingestion_state_unreadable" | "ingestion_connector_failed" | "execution_completed" | "execution_failed" | "execution_timeout" | "execution_unavailable";
 export declare const ACTION_KIND_REGISTRY: Readonly<Record<PlatformNeutralActionKind, ActionKindMetadata>>;

package/runtime/storage/db/index.js

@@ -197,6 +197,7 @@ const STATE_SCHEMA_SQL = `
     entities_json TEXT,
     novelty TEXT,
     relevance REAL,
+    relevance_class TEXT,
     summary TEXT,
     risk_flags_json TEXT,
     confidence REAL,
@@ -241,6 +242,7 @@ const STATE_SCHEMA_SQL = `
     closure_count INTEGER NOT NULL DEFAULT 0,
     memory_candidate_count INTEGER NOT NULL DEFAULT 0,
     source_refs_json TEXT NOT NULL,
+    closure_refs_json TEXT,
     redaction_class TEXT NOT NULL DEFAULT 'none',
     payload_json TEXT,
     lifecycle_status TEXT NOT NULL DEFAULT 'pending'
@@ -295,6 +297,38 @@ const STATE_SCHEMA_SQL = `
     payload_json TEXT,
     lifecycle_status TEXT NOT NULL DEFAULT 'started'
   );
+  CREATE TABLE IF NOT EXISTS impulse_context_artifact (
+    id TEXT PRIMARY KEY,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    scene_type TEXT NOT NULL,
+    capability_intent TEXT,
+    platform_id TEXT,
+    capability_class TEXT,
+    impulse_source TEXT NOT NULL,
+    impulse_text TEXT,
+    atmosphere_text TEXT,
+    expression_boundary_constraints_json TEXT,
+    expression_boundary_style TEXT,
+    freshness_version INTEGER NOT NULL DEFAULT 1,
+    source_refs_json TEXT NOT NULL,
+    redaction_class TEXT NOT NULL DEFAULT 'none',
+    payload_json TEXT,
+    lifecycle_status TEXT NOT NULL DEFAULT 'active'
+  );
+  CREATE TABLE IF NOT EXISTS daily_rhythm_state (
+    id TEXT PRIMARY KEY,
+    day TEXT NOT NULL,
+    quiet_status TEXT NOT NULL DEFAULT 'not_due',
+    dream_status TEXT NOT NULL DEFAULT 'not_due',
+    quiet_reason TEXT,
+    dream_reason TEXT,
+    quiet_completed_at TEXT,
+    dream_completed_at TEXT,
+    source_refs_json TEXT NOT NULL,
+    payload_json TEXT,
+    updated_at TEXT NOT NULL
+  );
 `;
 function resolveDbPath(filename) {
     if (path.isAbsolute(filename) || filename === ":memory:") {

package/runtime/storage/db/migrations/index.js

@@ -6,10 +6,14 @@ import { V7_002_EFFECT_COMMIT_LEDGER } from "./v7-002-effect-commit-ledger.js";
 import { V7_003_CIRCUIT_BREAKER } from "./v7-003-circuit-breaker.js";
 import { V7_004_BEHAVIOR_PROMOTION } from "./v7-004-behavior-promotion.js";
 import { V8_001_LIVING_PERCEPTION_LOOP } from "./v8-001-living-perception-loop.js";
+import { V8_002_PERCEPTION_CONTRACT_ALIGNMENT } from "./v8-002-perception-contract-alignment.js";
+import { V8_003_QUIET_CLOSURE_REFS } from "./v8-003-quiet-closure-refs.js";
 export const ALL_MIGRATIONS = [
     V7_001_FOUNDATION,
     V7_002_EFFECT_COMMIT_LEDGER,
     V7_003_CIRCUIT_BREAKER,
     V7_004_BEHAVIOR_PROMOTION,
     V8_001_LIVING_PERCEPTION_LOOP,
+    V8_002_PERCEPTION_CONTRACT_ALIGNMENT,
+    V8_003_QUIET_CLOSURE_REFS,
 ];