@haaaiawd/second-nature 0.2.2 → 0.2.5

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

@@ -0,0 +1,49 @@
+/**
+ * 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;
+    /** 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 + 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" | "impulse" | "projection" | "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,141 @@
+/**
+ * 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, readLoopStageEventsByCycle, readImpulseContextArtifact, readMemoryProjectionsByStatus, } 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 + closure stage event + source refs)
+    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;
+            }
+            // 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
+    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";
+    // 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 && !hasFreshImpulseContext && !hasProjectionFeedback;
+    // Gate passes only when all real runtime stages have evidence
+    const gatePassed = !contractSmokeOnly && !seededStateDetected && hasRealClosure && hasQuietArtifact && hasDreamArtifact && hasFreshImpulseContext && hasProjectionFeedback;
+    // 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, closure stage event, or source refs. 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 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.";
+    }
+    return {
+        ok: true,
+        gate: {
+            hasRealClosure,
+            hasQuietArtifact,
+            hasDreamArtifact,
+            hasFreshImpulseContext,
+            hasProjectionFeedback,
+            contractSmokeOnly,
+            seededStateDetected,
+            gatePassed,
+            missingStage,
+            missingReason,
+        },
+    };
+}

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

@@ -20,6 +20,18 @@
  */
 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;
+    hasFreshImpulseContext: boolean;
+    hasProjectionFeedback: boolean;
+    missingStage?: string;
+    missingReason?: string;
+}
 export interface LoopStatusReadModel {
     ok: true;
     overallStatus: string;
@@ -28,7 +40,13 @@ export interface LoopStatusReadModel {
     lastHeartbeatAt?: string;
     stageSummaries: StageSummary[];
     policyDeniedCount: number;
+    hardGuardDeniedCount: number;
+    cooldownReplayCount: number;
+    sourceAbsenceCount: number;
+    quietSuppressionCount: number;
+    connectorTerminalCount: number;
     nextAction: string;
+    realRunHealth: RealRunHealthProjection;
 }
 export interface StageSummary {
     stage: string;
@@ -43,4 +61,16 @@ export type LoopStatusResult = {
     ok: false;
     degraded: DegradedOperationResult;
 };
+export interface DenialAttribution {
+    policyDeniedCount: number;
+    hardGuardDeniedCount: number;
+    cooldownReplayCount: number;
+    sourceAbsenceCount: number;
+    quietSuppressionCount: number;
+    connectorTerminalCount: number;
+}
+export declare function attributeDenials(db: StateDatabase, options?: {
+    day?: string;
+    cycleWindowHours?: number;
+}): Promise<DenialAttribution>;
 export declare function readLoopStatus(db: StateDatabase): Promise<LoopStatusResult>;

package/runtime/observability/loop-status.js

@@ -19,10 +19,16 @@
  * Test coverage: tests/unit/observability/loop-status.test.ts
  */
 import { assembleLoopStatus } from "./causal-loop-health.js";
+import { checkRealRunHealth } from "./living-loop-health-gate.js";
+import { readActionClosuresByDay, readConnectorCooldownState, } from "../storage/v8-state-stores.js";
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
-function computeNextAction(overallStatus, stalledAt) {
+function computeNextAction(overallStatus, stalledAt, realRunMissingStage, realRunMissingReason, attribution) {
+    // 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.";
     }
@@ -49,6 +55,110 @@ function computeNextAction(overallStatus, stalledAt) {
     return "Review loop stage events and state database health.";
 }
 // ───────────────────────────────────────────────────────────────
+// Denial / replay attribution (T-OBS.R.4)
+// ───────────────────────────────────────────────────────────────
+const CONNECTOR_TERMINAL_REASONS = new Set([
+    "auth_failure",
+    "credential_expired",
+    "verification_required",
+    "configuration_missing",
+    "platform_unavailable",
+    "transport_failure",
+    "rate_limited",
+    "timeout",
+    "script_error",
+    "parse_failure",
+    "protocol_mismatch",
+    "semantic_rejection",
+    "permanent_input_error",
+    "unknown_platform_change",
+]);
+function classifyReasonToTerminal(reason) {
+    return CONNECTOR_TERMINAL_REASONS.has(reason);
+}
+function emptyAttribution() {
+    return {
+        policyDeniedCount: 0,
+        hardGuardDeniedCount: 0,
+        cooldownReplayCount: 0,
+        sourceAbsenceCount: 0,
+        quietSuppressionCount: 0,
+        connectorTerminalCount: 0,
+    };
+}
+export async function attributeDenials(db, options) {
+    const targetDay = options?.day ?? new Date().toISOString().slice(0, 10);
+    const readResult = await readActionClosuresByDay(db, targetDay);
+    if (readResult.degraded) {
+        return emptyAttribution();
+    }
+    const attribution = emptyAttribution();
+    for (const closure of readResult.rows) {
+        const status = closure.status;
+        const reason = closure.reason ?? "";
+        // Cooldown/replay is determined from durable cooldown state per platform/capability.
+        if ((status === "denied" || status === "downgraded" || status === "deferred") &&
+            closure.platformId &&
+            closure.capabilityId) {
+            const cooldownResult = await readConnectorCooldownState(db, closure.platformId, closure.capabilityId);
+            if (cooldownResult.row?.blockedUntil && new Date(cooldownResult.row.blockedUntil) > new Date()) {
+                attribution.cooldownReplayCount += 1;
+                continue;
+            }
+        }
+        const terminalClass = classifyReasonToTerminal(reason);
+        const isCooldownReplay = reason === "cooldown_blocked" || reason === "replay_suppressed";
+        const isQuietSuppression = reason === "guidance_unavailable" || reason === "quiet_empty_input" || reason === "quiet_suppression";
+        if (isCooldownReplay) {
+            attribution.cooldownReplayCount += 1;
+            continue;
+        }
+        if (status === "denied") {
+            if (reason.startsWith("policy_denied")) {
+                attribution.policyDeniedCount += 1;
+            }
+            else if (terminalClass) {
+                attribution.connectorTerminalCount += 1;
+            }
+            else if (reason === "source_refs_missing" ||
+                reason === "affordance_unavailable" ||
+                reason === "awaiting_user" ||
+                reason === "permission_missing") {
+                attribution.hardGuardDeniedCount += 1;
+            }
+            else {
+                attribution.policyDeniedCount += 1;
+            }
+            continue;
+        }
+        if (status === "downgraded" || status === "deferred") {
+            if (isQuietSuppression) {
+                attribution.quietSuppressionCount += 1;
+            }
+            else if (terminalClass) {
+                attribution.connectorTerminalCount += 1;
+            }
+            continue;
+        }
+        if (status === "no_action") {
+            if (reason === "evidence_batch_empty" || reason === "quiet_empty_input") {
+                attribution.sourceAbsenceCount += 1;
+            }
+            else if (terminalClass) {
+                attribution.connectorTerminalCount += 1;
+            }
+            continue;
+        }
+        if (status === "completed" || status === "failed") {
+            if (terminalClass) {
+                attribution.connectorTerminalCount += 1;
+            }
+            continue;
+        }
+    }
+    return attribution;
+}
+// ───────────────────────────────────────────────────────────────
 // Public API
 // ───────────────────────────────────────────────────────────────
 export async function readLoopStatus(db) {
@@ -60,26 +170,76 @@ 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,
+            hasFreshImpulseContext: realRunResult.gate.hasFreshImpulseContext,
+            hasProjectionFeedback: realRunResult.gate.hasProjectionFeedback,
+            missingStage: realRunResult.gate.missingStage,
+            missingReason: realRunResult.gate.missingReason,
+        };
+    }
+    else {
+        realRunHealth = {
+            gatePassed: false,
+            contractSmokeOnly: false,
+            seededStateDetected: false,
+            hasRealClosure: false,
+            hasQuietArtifact: false,
+            hasDreamArtifact: false,
+            hasFreshImpulseContext: false,
+            hasProjectionFeedback: false,
+            missingReason: "Real-run health check degraded: " + (realRunResult.degraded.operatorNextAction || "unknown"),
+        };
+    }
+    // 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,
         stalled: s.stalled,
         lastEventAt: s.lastEventAt,
     }));
-    // Policy denied count is a placeholder; real implementation would query action closures
-    const policyDeniedCount = 0;
-    const nextAction = computeNextAction(snapshot.overallStatus, snapshot.stalledAt);
+    // T-OBS.R.4: Attribute denials and connector replay root causes
+    const attribution = await attributeDenials(db);
+    const nextAction = computeNextAction(overallStatus, stalledAt, realRunHealth.missingStage, realRunHealth.missingReason, attribution);
     return {
         ok: true,
         status: {
             ok: true,
-            overallStatus: snapshot.overallStatus,
-            stalledAt: snapshot.stalledAt,
+            overallStatus,
+            stalledAt,
             lastCycleSequence: snapshot.lastCycleSequence,
             lastHeartbeatAt: snapshot.lastHeartbeatAt,
             stageSummaries,
-            policyDeniedCount,
+            policyDeniedCount: attribution.policyDeniedCount,
+            hardGuardDeniedCount: attribution.hardGuardDeniedCount,
+            cooldownReplayCount: attribution.cooldownReplayCount,
+            sourceAbsenceCount: attribution.sourceAbsenceCount,
+            quietSuppressionCount: attribution.quietSuppressionCount,
+            connectorTerminalCount: attribution.connectorTerminalCount,
             nextAction,
+            realRunHealth,
         },
     };
 }

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

@@ -31,6 +31,7 @@
  *   tests/integration/observability/digest-delivery.test.ts (T-OBS.C.4)
  */
 import type { AppendOnlyAuditStore } from "../audit/append-only-audit-store.js";
+import type { StateDatabase } from "../../storage/db/index.js";
 export interface ConnectorDaySummary {
     platformId: string;
     capability: string;
@@ -68,6 +69,18 @@ export interface DeliveryProofRef {
     channelId: string;
     messageHash: string;
 }
+export interface RealRunHealthDigestProjection {
+    gatePassed: boolean;
+    contractSmokeOnly: boolean;
+    seededStateDetected: boolean;
+    hasRealClosure: boolean;
+    hasQuietArtifact: boolean;
+    hasDreamArtifact: boolean;
+    hasFreshImpulseContext: boolean;
+    hasProjectionFeedback: boolean;
+    missingStage?: string;
+    missingReason?: string;
+}
 export interface HeartbeatDigest {
     date: string;
     generatedAt: string;
@@ -76,6 +89,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) */
@@ -124,6 +139,12 @@ export interface StateMemoryDigestPort {
 export interface HeartbeatDigestAssemblerDeps {
     auditStore: AppendOnlyAuditStore;
     stateMemoryPort?: StateMemoryDigestPort;
+    /**
+     * Optional state database for real-run health evaluation (F6).
+     * When provided, generateHeartbeatDigest calls checkRealRunHealth automatically
+     * and embeds the result into digest.realRunHealth.
+     */
+    db?: StateDatabase;
     /**
      * Optional delivery adapter (T-OBS.C.4).
      * When provided, the assembled digest is passed to adapter.deliver() after assembly.

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

@@ -30,6 +30,7 @@
  *   tests/unit/observability/heartbeat-digest-assembler.test.ts (T-OBS.C.3)
  *   tests/integration/observability/digest-delivery.test.ts (T-OBS.C.4)
  */
+import { checkRealRunHealth } from "../living-loop-health-gate.js";
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 function isSameDayUtc(isoTimestamp, dateStr) {
     // dateStr: "YYYY-MM-DD"
@@ -219,6 +220,48 @@ export async function generateHeartbeatDigest(date, deps) {
         quietDreamSummary = aggregateQuietDreamFromAudit(events, date);
     }
     const nothingSignificant = isNothingSignificant(connectorSummary, goalSummary, quietDreamSummary, healthSummary);
+    // F6: Auto-evaluate real-run health when db is provided
+    let realRunHealth = {
+        gatePassed: false,
+        contractSmokeOnly: true,
+        seededStateDetected: false,
+        hasRealClosure: false,
+        hasQuietArtifact: false,
+        hasDreamArtifact: false,
+        hasFreshImpulseContext: false,
+        hasProjectionFeedback: false,
+        missingReason: "Real-run health not evaluated — no state DB wired to digest assembler",
+    };
+    if (deps.db) {
+        const realRunResult = await checkRealRunHealth(deps.db, date);
+        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,
+                hasFreshImpulseContext: realRunResult.gate.hasFreshImpulseContext,
+                hasProjectionFeedback: realRunResult.gate.hasProjectionFeedback,
+                missingStage: realRunResult.gate.missingStage,
+                missingReason: realRunResult.gate.missingReason,
+            };
+        }
+        else {
+            realRunHealth = {
+                gatePassed: false,
+                contractSmokeOnly: false,
+                seededStateDetected: false,
+                hasRealClosure: false,
+                hasQuietArtifact: false,
+                hasDreamArtifact: false,
+                hasFreshImpulseContext: false,
+                hasProjectionFeedback: false,
+                missingReason: "Real-run health check degraded: " + (realRunResult.degraded.operatorNextAction ?? "unknown"),
+            };
+        }
+    }
     const digest = {
         date,
         generatedAt,
@@ -227,6 +270,7 @@ export async function generateHeartbeatDigest(date, deps) {
         goalSummary,
         quietDreamSummary,
         healthSummary,
+        realRunHealth,
     };
     // 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" | "perception_contract_drift" | "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

@@ -220,12 +220,14 @@ const STATE_SCHEMA_SQL = `
     payload_json TEXT,
     lifecycle_status TEXT NOT NULL DEFAULT 'pending'
   );
-  CREATE TABLE IF NOT EXISTS action_closure_record (
-    id TEXT PRIMARY KEY,
-    created_at TEXT NOT NULL,
-    cycle_id TEXT NOT NULL,
-    proposal_id TEXT,
-    decision_id TEXT,
+  CREATE TABLE IF NOT EXISTS action_closure_record (
+    id TEXT PRIMARY KEY,
+    created_at TEXT NOT NULL,
+    cycle_id TEXT NOT NULL,
+    platform_id TEXT,
+    capability_id TEXT,
+    proposal_id TEXT,
+    decision_id TEXT,
     status TEXT NOT NULL,
     reason TEXT,
     next_state TEXT,
@@ -295,6 +297,54 @@ 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
+  );
+  CREATE TABLE IF NOT EXISTS connector_cooldown_state (
+    id TEXT PRIMARY KEY,
+    platform_id TEXT NOT NULL,
+    capability_id TEXT NOT NULL,
+    failure_class TEXT NOT NULL,
+    retry_after_ms INTEGER,
+    blocked_until TEXT NOT NULL,
+    failure_count INTEGER NOT NULL DEFAULT 1,
+    terminal_count INTEGER NOT NULL DEFAULT 0,
+    source_refs_json TEXT NOT NULL,
+    redaction_class TEXT NOT NULL DEFAULT 'none',
+    payload_json TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS connector_cooldown_state_platform_capability_idx ON connector_cooldown_state(platform_id, capability_id);
 `;
 function resolveDbPath(filename) {
     if (path.isAbsolute(filename) || filename === ":memory:") {
@@ -316,6 +366,10 @@ function bootstrapStateSchema(sqlite) {
 function applyStateSchemaMigrations(sqlite) {
     const migrations = [
         "ALTER TABLE policy_records ADD COLUMN outreach_daily_budget INTEGER NOT NULL DEFAULT 2",
+        "ALTER TABLE action_closure_record ADD COLUMN platform_id TEXT",
+        "ALTER TABLE action_closure_record ADD COLUMN capability_id TEXT",
+        "ALTER TABLE connector_cooldown_state ADD COLUMN terminal_count INTEGER NOT NULL DEFAULT 0",
+        "CREATE INDEX IF NOT EXISTS connector_cooldown_state_platform_capability_idx ON connector_cooldown_state(platform_id, capability_id)",
     ];
     for (const sql of migrations) {
         try {