@haaaiawd/second-nature 0.1.24 → 0.1.26

package/runtime/cli/read-models/index.js

@@ -11,6 +11,9 @@ import { queryExplain, } from "../../observability/query/explain-query.js";
 import { mapOperatorExplainToReadModel } from "./operator-explain-map.js";
 import { loadOperatorFallbackRow, toOperatorFallbackView, } from "../../storage/fallback/load-operator-fallback.js";
 import { loadRhythmPolicySnapshot, } from "../../storage/rhythm/rhythm-policy-snapshot.js";
+import { createNarrativeStateStore } from "../../storage/narrative/narrative-state-store.js";
+import { createRelationshipMemoryStore } from "../../storage/relationship/relationship-memory-store.js";
+import { probeCredentialHealth } from "../../storage/services/credential-vault.js";
 const INTERNAL_RUNTIME_PLATFORM_ID = "second-nature-runtime";
 const INTERNAL_RUNTIME_TRACE_PREFIX = "sn-runtime-";
 function toExplainQuery(subject) {
@@ -30,6 +33,8 @@ function toExplainQuery(subject) {
             return { kind: "delivery", auditId: subject.id };
         case "source_ref":
             return { kind: "source_ref", sourceRefId: subject.id };
+        case "relationship":
+            return { kind: "relationship", relationshipId: subject.id };
         default:
             return undefined;
     }
@@ -46,6 +51,8 @@ function buildCredentialNextStep(status) {
         return "submit_verification_answer";
     if (status === "expired" || status === "revoked" || status === "failed")
         return "refresh_credential_context";
+    if (status === "decrypt_failed")
+        return "verify_or_re_create_credential_then_re_import";
     return undefined;
 }
 /**
@@ -112,6 +119,133 @@ function mapConnectorStatus(attempt) {
     }
     return "healthy";
 }
+/**
+ * Derive groundingStatus from confidence and status.
+ *
+ * Rules (in priority order):
+ * 1. blocked: status === "awaiting_sources" OR confidence < 0.4
+ * 2. pass: confidence >= 0.7 AND status === "active"
+ * 3. degraded: all other cases (0.4 <= confidence < 0.7, or status is insufficient_sources)
+ */
+function deriveGroundingStatus(status, confidence) {
+    if (status === "awaiting_sources" || confidence < 0.4) {
+        return "blocked";
+    }
+    if (confidence >= 0.7 && status === "active") {
+        return "pass";
+    }
+    return "degraded";
+}
+/**
+ * Build the base StatusReadModel that is shared by loadStatus and loadV6Status.
+ * Centralising this logic eliminates the DRY violation identified in CR-01.
+ */
+async function buildBaseStatus(deps) {
+    let recentAttempts = [];
+    let recentDecisions = [];
+    let credentials = [];
+    try {
+        recentAttempts = await deps.observabilityDb.db
+            .select()
+            .from(executionAttempts)
+            .orderBy(desc(executionAttempts.startedAt), desc(executionAttempts.finishedAt))
+            .limit(50);
+    }
+    catch {
+        recentAttempts = [];
+    }
+    try {
+        recentDecisions = await deps.observabilityDb.db
+            .select()
+            .from(decisionLedger)
+            .orderBy(desc(decisionLedger.createdAt))
+            .limit(50);
+    }
+    catch {
+        recentDecisions = [];
+    }
+    try {
+        credentials = await deps.stateDb.db.query.credentialRecords.findMany();
+    }
+    catch {
+        credentials = [];
+    }
+    const latestRuntimeAttempt = recentAttempts.find((attempt) => attempt.platformId === INTERNAL_RUNTIME_PLATFORM_ID);
+    const latestConnectorAttempt = recentAttempts.find((attempt) => attempt.platformId !== INTERNAL_RUNTIME_PLATFORM_ID);
+    const latestRuntimeDecision = recentDecisions.find((decision) => decision.traceId.startsWith(INTERNAL_RUNTIME_TRACE_PREFIX));
+    const runtimeUpdatedAt = latestRuntimeAttempt?.finishedAt ??
+        latestRuntimeAttempt?.startedAt ??
+        latestRuntimeDecision?.createdAt ??
+        "";
+    const quietMode = latestRuntimeDecision?.mode === "quiet" ||
+        latestRuntimeDecision?.mode === "maintenance_only" ||
+        latestRuntimeDecision?.mode === "paused_for_interrupt"
+        ? latestRuntimeDecision.mode
+        : "unknown";
+    const riskFlags = [
+        latestRuntimeAttempt?.failureClass,
+        latestConnectorAttempt?.failureClass,
+    ].filter((value) => Boolean(value));
+    const connectorSummary = latestConnectorAttempt
+        ? [
+            {
+                platformId: latestConnectorAttempt.platformId,
+                status: mapConnectorStatus(latestConnectorAttempt),
+                channel: latestConnectorAttempt.channel,
+                failureClass: latestConnectorAttempt.failureClass ?? undefined,
+            },
+        ]
+        : [];
+    return {
+        runtime: {
+            host: "openclaw-plugin",
+            serviceStatus: mapRuntimeStatus(latestRuntimeAttempt),
+            updatedAt: runtimeUpdatedAt,
+        },
+        rhythm: {
+            mode: latestRuntimeDecision?.mode ?? "unknown",
+        },
+        quiet: {
+            mode: quietMode,
+            lastEvent: latestRuntimeDecision?.traceId,
+            interrupted: latestRuntimeDecision?.mode === "paused_for_interrupt"
+                ? true
+                : undefined,
+        },
+        connectors: connectorSummary,
+        credentials: credentials.map((item) => {
+            const platformId = item.platformId ??
+                item.platform_id;
+            const encryptedValue = item.encryptedValue ??
+                item.encrypted_value;
+            const baseUrl = item.baseUrl ??
+                item.base_url;
+            const health = probeCredentialHealth(platformId, encryptedValue, baseUrl);
+            const effectiveStatus = health.state === "decrypt_failed"
+                ? "decrypt_failed"
+                : item.status;
+            return {
+                platformId,
+                status: effectiveStatus,
+                nextStep: health.diagnosticCode === "missing_runtime_secret"
+                    ? "set_SECOND_NATURE_ENCRYPTION_KEY_then_re_probe"
+                    : health.diagnosticCode === "credential_recovery_required"
+                        ? "verify_or_re_create_credential_then_re_import"
+                        : buildCredentialNextStep(effectiveStatus),
+                keyHealth: health.keyHealth,
+            };
+        }),
+        risk: {
+            level: riskFlags.length > 0 ? "medium" : "low",
+            flags: riskFlags,
+        },
+        deliveryPosture: {
+            verdict: "none",
+            source: "workspace_default_none",
+            reasonCode: "delivery_target_none",
+        },
+    };
+}
 export function createCliReadModels(deps) {
     const assetRepository = new AssetRepository(deps.stateDb);
     const credentialRepository = new CredentialRepository(deps.stateDb);
@@ -124,103 +258,7 @@ export function createCliReadModels(deps) {
     const auditStore = deps.livedExperienceAuditStore ?? new AppendOnlyAuditStore();
     return {
         async loadStatus(_scope) {
-            let recentAttempts = [];
-            let recentDecisions = [];
-            let credentials = [];
-            try {
-                recentAttempts = await deps.observabilityDb.db
-                    .select()
-                    .from(executionAttempts)
-                    .orderBy(desc(executionAttempts.startedAt), desc(executionAttempts.finishedAt))
-                    .limit(50);
-            }
-            catch {
-                recentAttempts = [];
-            }
-            try {
-                recentDecisions = await deps.observabilityDb.db
-                    .select()
-                    .from(decisionLedger)
-                    .orderBy(desc(decisionLedger.createdAt))
-                    .limit(50);
-            }
-            catch {
-                recentDecisions = [];
-            }
-            try {
-                credentials = await deps.stateDb.db.query.credentialRecords.findMany();
-            }
-            catch {
-                credentials = [];
-            }
-            const latestRuntimeAttempt = recentAttempts.find((attempt) => attempt.platformId === INTERNAL_RUNTIME_PLATFORM_ID);
-            // CH-15-04 (CH-14-03): latestConnectorAttempt is the most recent execution attempt whose
-            // platformId is NOT the internal sn-runtime sentinel — i.e. a real connector platform
-            // (Moltbook, EvoMap, etc.). The `connectors` array in StatusReadModel reflects this single
-            // most-recent non-runtime attempt, NOT the full connector manifest. An empty array means
-            // no connector attempt has been recorded yet, not that connectors are misconfigured.
-            const latestConnectorAttempt = recentAttempts.find((attempt) => attempt.platformId !== INTERNAL_RUNTIME_PLATFORM_ID);
-            const latestRuntimeDecision = recentDecisions.find((decision) => decision.traceId.startsWith(INTERNAL_RUNTIME_TRACE_PREFIX));
-            const runtimeUpdatedAt = latestRuntimeAttempt?.finishedAt ??
-                latestRuntimeAttempt?.startedAt ??
-                latestRuntimeDecision?.createdAt ??
-                "";
-            const quietMode = latestRuntimeDecision?.mode === "quiet" ||
-                latestRuntimeDecision?.mode === "maintenance_only" ||
-                latestRuntimeDecision?.mode === "paused_for_interrupt"
-                ? latestRuntimeDecision.mode
-                : "unknown";
-            const riskFlags = [
-                latestRuntimeAttempt?.failureClass,
-                latestConnectorAttempt?.failureClass,
-            ].filter((value) => Boolean(value));
-            const connectorSummary = latestConnectorAttempt
-                ? [
-                    {
-                        platformId: latestConnectorAttempt.platformId,
-                        status: mapConnectorStatus(latestConnectorAttempt),
-                        channel: latestConnectorAttempt.channel,
-                        failureClass: latestConnectorAttempt.failureClass ?? undefined,
-                    },
-                ]
-                : [];
-            return {
-                runtime: {
-                    host: "openclaw-plugin",
-                    serviceStatus: mapRuntimeStatus(latestRuntimeAttempt),
-                    updatedAt: runtimeUpdatedAt,
-                },
-                rhythm: {
-                    mode: latestRuntimeDecision?.mode ?? "unknown",
-                    windowId: undefined,
-                },
-                quiet: {
-                    mode: quietMode,
-                    lastEvent: latestRuntimeDecision?.traceId,
-                    interrupted: latestRuntimeDecision?.mode === "paused_for_interrupt"
-                        ? true
-                        : undefined,
-                },
-                connectors: connectorSummary,
-                credentials: credentials.map((item) => ({
-                    platformId: item.platformId ??
-                        item.platform_id,
-                    status: item.status,
-                    nextStep: buildCredentialNextStep(item.status),
-                })),
-                risk: {
-                    level: riskFlags.length > 0 ? "medium" : "low",
-                    flags: riskFlags,
-                },
-                // T1.2.5 (CH-14-04): default delivery posture is workspace_default_none because the
-                // workspace heartbeat hardcodes `deliveryCapability: { target: "none" }` until a host
-                // capability probe explicitly sets a valid target.
-                deliveryPosture: {
-                    verdict: "none",
-                    source: "workspace_default_none",
-                    reasonCode: "delivery_target_none",
-                },
-            };
+            return buildBaseStatus(deps);
         },
         async loadDailyReport(day) {
             let bundle;
@@ -309,19 +347,40 @@ export function createCliReadModels(deps) {
                 record = undefined;
             }
             if (!record) {
+                // T1.4.1: even when no row exists, probe key health so status can surface
+                // missing_runtime_secret rather than a generic "missing".
+                const health = probeCredentialHealth(platformId, null, null);
                 return {
                     platformId,
-                    status: "missing",
-                    nextStep: "provide_credential_context",
+                    status: health.state,
+                    nextStep: health.diagnosticCode === "missing_runtime_secret"
+                        ? "set_SECOND_NATURE_ENCRYPTION_KEY_then_re_probe"
+                        : "provide_credential_context",
+                    keyHealth: health.keyHealth,
                 };
             }
+            // T1.4.1: attempt decryption to detect decrypt_failed / wrong_key.
+            const encryptedValue = record.encryptedValue ??
+                record.encrypted_value;
+            const baseUrl = record.baseUrl ??
+                record.base_url;
+            const health = probeCredentialHealth(platformId, encryptedValue, baseUrl);
+            // If decryption failed, surface the honest diagnostic; otherwise surface DB status.
+            const effectiveStatus = health.state === "decrypt_failed"
+                ? "decrypt_failed"
+                : record.status;
             return {
                 platformId: record.platformId ??
                     record.platform_id,
-                status: record.status,
+                status: effectiveStatus,
                 verificationDeadline: record.expiresAt ?? undefined,
                 attemptsRemaining: record.attemptsRemaining ?? undefined,
-                nextStep: buildCredentialNextStep(record.status),
+                nextStep: health.diagnosticCode === "missing_runtime_secret"
+                    ? "set_SECOND_NATURE_ENCRYPTION_KEY_then_re_probe"
+                    : health.diagnosticCode === "credential_recovery_required"
+                        ? "verify_or_re_create_credential_then_re_import"
+                        : buildCredentialNextStep(effectiveStatus),
+                keyHealth: health.keyHealth,
             };
         },
         async loadFallbackView(ref) {
@@ -374,6 +433,34 @@ export function createCliReadModels(deps) {
                     evidenceRefs: [],
                 };
             }
+            // T1.4.2: relationship explain reads RelationshipMemory store directly.
+            if (subject.kind === "relationship") {
+                const relationshipStore = createRelationshipMemoryStore(deps.stateDb);
+                const memory = await relationshipStore.loadRelationshipMemory(subject.id);
+                if (!memory) {
+                    return {
+                        subjectType: "relationship",
+                        conclusion: "nothing_yet",
+                        keyFactors: ["no_relationship_memory_recorded"],
+                        evidenceRefs: [],
+                        nextStep: "interact_with_agent_then_re_check",
+                    };
+                }
+                return {
+                    subjectType: "relationship",
+                    conclusion: `tone:${memory.tonePreference} replies:${memory.noReplyCount === 0 ? "responsive" : "cooldown"}`,
+                    keyFactors: [
+                        `tone_preference:${memory.tonePreference}`,
+                        ...(memory.averageReplyDelayMinutes
+                            ? [`avg_reply_delay_minutes:${memory.averageReplyDelayMinutes}`]
+                            : []),
+                        ...(memory.topicAffinities.length > 0
+                            ? [`topics:${memory.topicAffinities.map((t) => t.topic).join(",")}`]
+                            : ["insufficient_history"]),
+                    ],
+                    evidenceRefs: memory.sourceRefs.map((s) => s.sourceId),
+                };
+            }
             const query = subject.kind === "decision" ||
                 subject.kind === "platform-selection" ||
                 subject.kind === "outreach"
@@ -387,5 +474,220 @@ export function createCliReadModels(deps) {
                 evidenceRefs: bundle.explanation.evidenceRefs,
             };
         },
+        // T1.2.2 — read recent DreamTrace events from audit store.
+        async loadDreamRecent(limit = 5) {
+            const events = auditStore.list().filter((e) => e.family === "dream.trace");
+            const recent = events
+                .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+                .slice(0, limit);
+            return {
+                runs: recent.map((e) => {
+                    const p = e.payload;
+                    return {
+                        traceId: p.traceId,
+                        runId: p.runId,
+                        durationMs: p.durationMs ?? 0,
+                        inputCounts: p.inputCounts ?? { evidence: 0, chronicle: 0, memoryEntries: 0 },
+                        fallbackReason: p.fallbackReason,
+                        lifecycleStatus: p.fallbackReason ? "partial" : "completed",
+                        insightsCount: 0, // would require deeper payload parsing
+                        createdAt: e.createdAt,
+                    };
+                }),
+                totalRuns: events.length,
+            };
+        },
+        // T1.2.5 — aggregate recent heartbeat, narrative, dream, delivery events into cycles.
+        async loadCycleRecent(limit = 5) {
+            const events = auditStore.list();
+            const decisions = events.filter((e) => e.family === "heartbeat.decision");
+            const narratives = events.filter((e) => e.family === "narrative.trace");
+            const dreams = events.filter((e) => e.family === "dream.trace");
+            const deliveries = events.filter((e) => e.family === "delivery");
+            const connectors = events.filter((e) => e.family === "connector.attempt");
+            // Group by time buckets (hourly)
+            const buckets = new Map();
+            for (const e of decisions) {
+                const hour = e.createdAt.slice(0, 13);
+                const b = buckets.get(hour) ?? { timestamp: `${hour}:00:00Z`, dimensions: [] };
+                if (!b.dimensions.includes("decision"))
+                    b.dimensions.push("decision");
+                const p = e.payload;
+                if (p.outcome)
+                    b.decisionOutcome = p.outcome;
+                buckets.set(hour, b);
+            }
+            for (const e of narratives) {
+                const hour = e.createdAt.slice(0, 13);
+                const b = buckets.get(hour) ?? { timestamp: `${hour}:00:00Z`, dimensions: [] };
+                if (!b.dimensions.includes("narrative"))
+                    b.dimensions.push("narrative");
+                const p = e.payload;
+                if (p.groundingStatus)
+                    b.narrativeGrounding = p.groundingStatus;
+                buckets.set(hour, b);
+            }
+            for (const e of dreams) {
+                const hour = e.createdAt.slice(0, 13);
+                const b = buckets.get(hour) ?? { timestamp: `${hour}:00:00Z`, dimensions: [] };
+                if (!b.dimensions.includes("dream"))
+                    b.dimensions.push("dream");
+                const p = e.payload;
+                if (p.fallbackReason)
+                    b.dreamFallback = p.fallbackReason;
+                buckets.set(hour, b);
+            }
+            for (const e of deliveries) {
+                const hour = e.createdAt.slice(0, 13);
+                const b = buckets.get(hour) ?? { timestamp: `${hour}:00:00Z`, dimensions: [] };
+                if (!b.dimensions.includes("delivery"))
+                    b.dimensions.push("delivery");
+                const p = e.payload;
+                if (p.status)
+                    b.deliveryStatus = p.status;
+                buckets.set(hour, b);
+            }
+            for (const e of connectors) {
+                const hour = e.createdAt.slice(0, 13);
+                const b = buckets.get(hour) ?? { timestamp: `${hour}:00:00Z`, dimensions: [] };
+                if (!b.dimensions.includes("connector"))
+                    b.dimensions.push("connector");
+                buckets.set(hour, b);
+            }
+            const cycles = Array.from(buckets.values())
+                .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+                .slice(0, limit);
+            return { cycles, totalCycles: buckets.size };
+        },
+        // T1.2.6 — v6 status aggregate: compose base status + narrative + dream + cycle sections.
+        // Each section returns a sentinel status (nothing_yet / has_runs / has_cycles) so operators
+        // always get a meaningful non-empty response, never a raw empty object.
+        async loadV6Status(scope) {
+            // Load NarrativeState asynchronously; audit events are synchronous reads from in-memory store.
+            const narrativeStore = createNarrativeStateStore(deps.stateDb);
+            let narrativeState;
+            try {
+                narrativeState = await narrativeStore.loadNarrativeState();
+            }
+            catch {
+                narrativeState = null;
+            }
+            const allAuditEvents = auditStore.list();
+            const dreamSection = allAuditEvents.filter((e) => e.family === "dream.trace");
+            const cycleSection = allAuditEvents;
+            const baseStatus = await buildBaseStatus(deps);
+            // Narrative section
+            let narrativeSectionOut;
+            if (!narrativeState) {
+                narrativeSectionOut = { status: "nothing_yet", focus: "", groundingStatus: "blocked", nextIntent: "", sourceRefCount: 0 };
+            }
+            else {
+                const groundingStatus = deriveGroundingStatus(narrativeState.status, narrativeState.confidence);
+                narrativeSectionOut = { status: narrativeState.status, focus: narrativeState.focus, groundingStatus, nextIntent: narrativeState.nextIntent, sourceRefCount: narrativeState.sourceRefs.length };
+            }
+            // Dream section — degraded when all recorded dream runs have a fallbackReason.
+            const dreamEvents = dreamSection;
+            let dreamSectionOut;
+            if (dreamEvents.length === 0) {
+                dreamSectionOut = { status: "nothing_yet", totalRuns: 0, recentRunCount: 0 };
+            }
+            else {
+                const recentDreams = dreamEvents.sort((a, b) => b.createdAt.localeCompare(a.createdAt)).slice(0, 3);
+                const lastFallback = recentDreams.map((e) => e.payload.fallbackReason).find(Boolean);
+                const allDegraded = dreamEvents.every((e) => !!e.payload.fallbackReason);
+                dreamSectionOut = {
+                    status: allDegraded ? "degraded" : "has_runs",
+                    totalRuns: dreamEvents.length,
+                    recentRunCount: recentDreams.length,
+                    lastFallbackReason: lastFallback,
+                };
+            }
+            // Cycle section — degraded when buckets exist but cover fewer than 3 dimensions.
+            const allEvents = cycleSection;
+            const decisionEvents = allEvents.filter((e) => e.family === "heartbeat.decision");
+            const narrativeEvents = allEvents.filter((e) => e.family === "narrative.trace");
+            const dreamEventsForCycle = allEvents.filter((e) => e.family === "dream.trace");
+            const deliveryEvents = allEvents.filter((e) => e.family === "delivery");
+            const connectorEvents = allEvents.filter((e) => e.family === "connector.attempt");
+            const hourBuckets = new Set();
+            const dimensionSet = new Set();
+            for (const e of decisionEvents) {
+                hourBuckets.add(e.createdAt.slice(0, 13));
+                dimensionSet.add("decision");
+            }
+            for (const e of narrativeEvents) {
+                hourBuckets.add(e.createdAt.slice(0, 13));
+                dimensionSet.add("narrative");
+            }
+            for (const e of dreamEventsForCycle) {
+                hourBuckets.add(e.createdAt.slice(0, 13));
+                dimensionSet.add("dream");
+            }
+            for (const e of deliveryEvents) {
+                hourBuckets.add(e.createdAt.slice(0, 13));
+                dimensionSet.add("delivery");
+            }
+            for (const e of connectorEvents) {
+                hourBuckets.add(e.createdAt.slice(0, 13));
+                dimensionSet.add("connector");
+            }
+            let cycleSectionOut;
+            if (hourBuckets.size === 0) {
+                cycleSectionOut = { status: "nothing_yet", totalCycles: 0, recentCycleCount: 0, dimensions: [] };
+            }
+            else if (dimensionSet.size < 3) {
+                cycleSectionOut = { status: "degraded", totalCycles: hourBuckets.size, recentCycleCount: Math.min(hourBuckets.size, 5), dimensions: Array.from(dimensionSet) };
+            }
+            else {
+                cycleSectionOut = { status: "has_cycles", totalCycles: hourBuckets.size, recentCycleCount: Math.min(hourBuckets.size, 5), dimensions: Array.from(dimensionSet) };
+            }
+            void scope; // scope param reserved for future scoping — not used in v6 aggregate yet
+            return { ...baseStatus, narrative: narrativeSectionOut, dream: dreamSectionOut, cycles: cycleSectionOut };
+        },
+        // T1.2.1 — read current NarrativeState and map to NarrativeReadModel.
+        // Returns `nothing_yet` status when no data exists — honest empty, not an error.
+        async loadNarrative(narrativeId) {
+            const narrativeStore = createNarrativeStateStore(deps.stateDb);
+            let state;
+            try {
+                state = await narrativeStore.loadNarrativeState(narrativeId);
+            }
+            catch {
+                state = null;
+            }
+            if (!state) {
+                return {
+                    narrativeId: narrativeId ?? "default",
+                    revision: 0,
+                    focus: "",
+                    progress: [],
+                    nextIntent: "",
+                    confidence: 0,
+                    sourceRefs: [],
+                    unsupportedClaims: [],
+                    groundingStatus: "blocked",
+                    status: "nothing_yet",
+                    updatedAt: "",
+                };
+            }
+            const groundingStatus = deriveGroundingStatus(state.status, state.confidence);
+            return {
+                narrativeId: state.narrativeId,
+                revision: state.revision,
+                focus: state.focus,
+                progress: state.progress,
+                nextIntent: state.nextIntent,
+                confidence: state.confidence,
+                sourceRefs: state.sourceRefs.map((r) => ({
+                    sourceId: r.sourceId,
+                    kind: r.kind,
+                    url: r.url,
+                })),
+                unsupportedClaims: state.unsupportedClaims,
+                groundingStatus,
+                status: state.status,
+                updatedAt: state.updatedAt,
+            };
+        },
     };
 }

package/runtime/cli/read-models/types.d.ts

@@ -25,8 +25,10 @@ export interface ConnectorSummary {
 }
 export interface CredentialSummary {
     platformId: string;
-    status: "missing" | "pending_verification" | "active" | "expired" | "revoked" | "failed";
+    status: "missing" | "pending_verification" | "active" | "expired" | "revoked" | "failed" | "decrypt_failed";
     nextStep?: string;
+    /** T1.4.1 — diagnostic key health without leaking raw secret. */
+    keyHealth?: "missing_key" | "wrong_key" | "ok";
 }
 export interface RiskSummary {
     level: "low" | "medium" | "high";
@@ -73,6 +75,38 @@ export interface StatusReadModel {
      */
     deliveryPosture?: DeliveryPosture;
 }
+/**
+ * T1.2.6 — v6 status aggregate: extends StatusReadModel with narrative, dream recent,
+ * cycle recent, and per-section `nothing_yet` / `awaiting_sources` / `degraded` sentinels
+ * so operators always get a meaningful view even when individual data sources are empty.
+ */
+export interface StatusV6NarrativeSection {
+    status: "active" | "insufficient_sources" | "awaiting_sources" | "nothing_yet";
+    focus: string;
+    groundingStatus: "pass" | "degraded" | "blocked";
+    nextIntent: string;
+    sourceRefCount: number;
+}
+export interface StatusV6DreamSection {
+    status: "has_runs" | "degraded" | "nothing_yet";
+    totalRuns: number;
+    recentRunCount: number;
+    lastFallbackReason?: string;
+}
+export interface StatusV6CycleSection {
+    status: "has_cycles" | "degraded" | "nothing_yet";
+    totalCycles: number;
+    recentCycleCount: number;
+    dimensions: string[];
+}
+export interface StatusV6ReadModel extends StatusReadModel {
+    /** v6 narrative section; status is nothing_yet when no NarrativeState row exists. */
+    narrative: StatusV6NarrativeSection;
+    /** v6 dream recent section; status is nothing_yet when no DreamTrace events exist. */
+    dream: StatusV6DreamSection;
+    /** v6 cycle recent section; status is nothing_yet when no cycle events exist. */
+    cycles: StatusV6CycleSection;
+}
 export interface DailyReportReadModel {
     day: string;
     summary: string;
@@ -97,12 +131,17 @@ export interface SessionDetailReadModel {
 }
 export interface CredentialReadModel {
     platformId: string;
-    status: "missing" | "pending_verification" | "active" | "expired" | "revoked" | "failed";
+    status: "missing" | "pending_verification" | "active" | "expired" | "revoked" | "failed" | "decrypt_failed";
     verificationDeadline?: string;
     attemptsRemaining?: number;
     nextStep?: string;
+    /**
+     * T1.4.1 — redacted diagnostic: when true, the raw encrypted value could not be
+     * decrypted because SECOND_NATURE_ENCRYPTION_KEY is missing or wrong.
+     */
+    keyHealth?: "missing_key" | "wrong_key" | "ok";
 }
-export type ExplainSubjectKind = "decision" | "platform-selection" | "outreach" | "soul-change" | "fallback" | "probe" | "delivery" | "report" | "source_ref";
+export type ExplainSubjectKind = "decision" | "platform-selection" | "outreach" | "soul-change" | "fallback" | "probe" | "delivery" | "report" | "source_ref" | "relationship";
 export interface ExplainReadModel {
     subjectType: ExplainSubjectKind;
     conclusion: string;
@@ -127,3 +166,51 @@ export interface AuditSummaryReadModel {
     totalEvents: number;
     events: AuditEventSummaryEntry[];
 }
+/** T1.2.2 — recent Dream run summary for operator `dream:recent` command. */
+export interface DreamRecentReadModel {
+    runs: Array<{
+        traceId: string;
+        runId: string;
+        durationMs: number;
+        inputCounts: {
+            evidence: number;
+            chronicle: number;
+            memoryEntries: number;
+        };
+        fallbackReason?: string;
+        lifecycleStatus: string;
+        insightsCount: number;
+        createdAt: string;
+    }>;
+    totalRuns: number;
+}
+/** T1.2.1 — NarrativeState read model for operator `narrative` command. */
+export interface NarrativeReadModel {
+    narrativeId: string;
+    revision: number;
+    focus: string;
+    progress: string[];
+    nextIntent: string;
+    confidence: number;
+    sourceRefs: Array<{
+        sourceId: string;
+        kind: string;
+        url?: string;
+    }>;
+    unsupportedClaims: string[];
+    groundingStatus: "pass" | "degraded" | "blocked";
+    status: "active" | "insufficient_sources" | "awaiting_sources" | "nothing_yet";
+    updatedAt: string;
+}
+/** T1.2.5 — recent cycle summary aggregating heartbeat, narrative, dream, delivery. */
+export interface CycleRecentReadModel {
+    cycles: Array<{
+        timestamp: string;
+        dimensions: Array<"decision" | "narrative" | "dream" | "delivery" | "connector">;
+        decisionOutcome?: string;
+        narrativeGrounding?: string;
+        dreamFallback?: string;
+        deliveryStatus?: string;
+    }>;
+    totalCycles: number;
+}