@haaaiawd/second-nature 0.2.6 → 0.2.7

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

@@ -1,7 +1,7 @@
 /**
  * PerceptionBuilder — Generate PerceptionCard records from EvidenceItem batches.
  *
- * Core logic: Read pending evidence, deduplicate by content hash, build
+ * Core logic: Read pending evidence, deduplicate by externalId/content hash, build
  * PerceptionCard with topic, entities, novelty, relevance, summary, risk
  * flags, confidence, and reviewPriority. Rules-only fallback when model
  * assist is unavailable.
@@ -21,7 +21,7 @@
  *
  * Test coverage: tests/unit/perception/perception-builder.test.ts
  */
-import { readEvidenceItemsByStatus, writePerceptionCard, } from "../../../storage/v8-state-stores.js";
+import { readEvidenceItemsByStatus, writePerceptionCard, updateEvidenceItemLifecycleStatus, } from "../../../storage/v8-state-stores.js";
 // ───────────────────────────────────────────────────────────────
 // Config
 // ───────────────────────────────────────────────────────────────
@@ -38,46 +38,64 @@ function parseSourceRefs(json) {
         return [];
     }
 }
-function extractTopic(evidence) {
-    if (evidence.payloadJson) {
-        try {
-            const payload = JSON.parse(evidence.payloadJson);
-            if (payload.topic)
-                return String(payload.topic);
-            if (payload.title)
-                return String(payload.title);
-            if (payload.subject)
-                return String(payload.subject);
+function parsePayload(json) {
+    if (!json)
+        return undefined;
+    try {
+        const parsed = JSON.parse(json);
+        if (parsed && typeof parsed === "object" && "schemaVersion" in parsed) {
+            return parsed;
         }
-        catch {
-            /* ignore */
+        if (parsed && typeof parsed === "object" && "summary" in parsed) {
+            // Legacy payload or direct summary object
+            return {
+                schemaVersion: 1,
+                sourceKind: "unknown",
+                platformId: "",
+                capabilityId: "",
+                summary: String(parsed.summary ?? ""),
+                observedAt: new Date().toISOString(),
+                summaryProducer: "connector_rules",
+                ...parsed,
+            };
         }
     }
+    catch {
+        /* ignore */
+    }
+    return undefined;
+}
+function extractTopic(evidence) {
+    const payload = parsePayload(evidence.payloadJson);
+    if (payload?.title)
+        return String(payload.title);
+    if (payload?.summary) {
+        const summary = String(payload.summary);
+        return summary.length > 60 ? `${summary.slice(0, 60)}…` : summary;
+    }
     return `${evidence.platformId}_observation`;
 }
 function extractEntities(evidence) {
     const entities = [evidence.platformId];
-    if (evidence.payloadJson) {
-        try {
-            const payload = JSON.parse(evidence.payloadJson);
-            if (payload.entities && Array.isArray(payload.entities)) {
-                entities.push(...payload.entities.map(String));
-            }
-            if (payload.tags && Array.isArray(payload.tags)) {
-                entities.push(...payload.tags.map(String));
-            }
-            if (payload.mentions && Array.isArray(payload.mentions)) {
-                entities.push(...payload.mentions.map(String));
-            }
-        }
-        catch {
-            /* ignore */
-        }
+    const payload = parsePayload(evidence.payloadJson);
+    if (payload?.entities && Array.isArray(payload.entities)) {
+        entities.push(...payload.entities.map(String));
     }
-    return [...new Set(entities)];
+    if (payload?.tags && Array.isArray(payload.tags)) {
+        entities.push(...payload.tags.map(String));
+    }
+    if (payload?.actor?.displayName) {
+        entities.push(payload.actor.displayName);
+    }
+    return [...new Set(entities.filter((e) => e.length > 0))];
 }
-function inferNoveltyClass(evidence) {
-    // Canonical novelty classification
+function inferNoveltyClass(evidence, duplicateKey, seenKeys) {
+    if (seenKeys.has(duplicateKey)) {
+        const firstObserved = seenKeys.get(duplicateKey);
+        const current = evidence.observedAt;
+        // If same calendar day, treat as duplicate; otherwise stale.
+        return firstObserved.slice(0, 10) === current.slice(0, 10) ? "duplicate" : "stale";
+    }
     if (evidence.sensitivityHint === "public_technical")
         return "changed";
     return "new";
@@ -99,9 +117,17 @@ function inferRelevanceClass(score) {
     return "low";
 }
 function inferSummary(evidence) {
-    const platform = evidence.platformId;
-    const topic = extractTopic(evidence);
-    return `Observation from ${platform}: ${topic}`;
+    const payload = parsePayload(evidence.payloadJson);
+    if (payload?.summary && String(payload.summary).trim().length > 0) {
+        return { summary: String(payload.summary), contentMissing: false };
+    }
+    if (payload?.title) {
+        return { summary: `Observation from ${evidence.platformId}: ${payload.title}`, contentMissing: false };
+    }
+    return {
+        summary: `Ref-only observation from ${evidence.platformId}: no readable content`,
+        contentMissing: true,
+    };
 }
 function inferPossibleIntents(evidence) {
     const intents = ["watch"];
@@ -130,25 +156,35 @@ function inferRiskFlags(evidence) {
     }
     return flags;
 }
-function buildCardFromEvidence(evidence, cycleId, now) {
+function duplicateKey(evidence) {
+    const payload = parsePayload(evidence.payloadJson);
+    if (payload?.externalId) {
+        return `${evidence.platformId}:${evidence.contentHash}:${payload.externalId}`;
+    }
+    return `${evidence.platformId}:${evidence.contentHash}`;
+}
+function buildCardFromEvidence(evidence, cycleId, now, seenKeys) {
     const sourceRefs = parseSourceRefs(evidence.sourceRefsJson);
     const relevanceScore = inferRelevanceScore(evidence);
+    const key = duplicateKey(evidence);
+    const { summary, contentMissing } = inferSummary(evidence);
     return {
         id: `per_${evidence.id}`,
         cycleId,
         topic: extractTopic(evidence),
         entities: extractEntities(evidence),
-        noveltyClass: inferNoveltyClass(evidence),
+        noveltyClass: inferNoveltyClass(evidence, key, seenKeys),
         relevanceScore,
         relevanceClass: inferRelevanceClass(relevanceScore),
-        summary: inferSummary(evidence),
+        summary,
         possibleIntents: inferPossibleIntents(evidence),
         reviewPriority: inferReviewPriority(evidence),
         sensitivityClass: evidence.sensitivityHint || "public_general",
         riskFlags: inferRiskFlags(evidence),
-        confidence: 0.6,
+        confidence: contentMissing ? 0.3 : 0.6,
         evidenceRefs: sourceRefs,
         createdAt: now,
+        contentMissing,
     };
 }
 export async function buildPerceptionCards(db, options) {
@@ -169,6 +205,7 @@ export async function buildPerceptionCards(db, options) {
     const truncated = evidenceItems.length > maxEvidence;
     const selectedEvidence = evidenceItems.slice(0, maxEvidence);
     const cards = [];
+    const seenKeys = new Map();
     for (const evidence of selectedEvidence) {
         const card = buildCardFromEvidence({
             id: evidence.id,
@@ -178,9 +215,21 @@ export async function buildPerceptionCards(db, options) {
             sensitivityHint: evidence.sensitivityHint ?? undefined,
             sourceRefsJson: evidence.sourceRefsJson,
             payloadJson: evidence.payloadJson,
-        }, options.cycleId, now);
+        }, options.cycleId, now, seenKeys);
         cards.push(card);
-        // Write card to state
+        // Track first observation timestamp for duplicate/stale classification
+        const key = duplicateKey({
+            id: evidence.id,
+            platformId: evidence.platformId,
+            contentHash: evidence.contentHash,
+            observedAt: evidence.observedAt,
+            sourceRefsJson: evidence.sourceRefsJson,
+            payloadJson: evidence.payloadJson,
+        });
+        if (!seenKeys.has(key)) {
+            seenKeys.set(key, evidence.observedAt);
+        }
+        // Write card to state and advance evidence lifecycle
         const writeResult = await writePerceptionCard(db, {
             id: card.id,
             createdAt: now,
@@ -200,6 +249,7 @@ export async function buildPerceptionCards(db, options) {
             payloadJson: JSON.stringify({
                 possibleIntents: card.possibleIntents,
                 sensitivityClass: card.sensitivityClass,
+                contentMissing: card.contentMissing,
             }),
         });
         if ("reason" in writeResult) {
@@ -209,11 +259,15 @@ export async function buildPerceptionCards(db, options) {
                 reason: writeResult.reason,
             };
         }
+        await updateEvidenceItemLifecycleStatus(db, evidence.id, "perceived");
     }
+    const hasContentMissing = cards.some((c) => c.contentMissing);
+    const allContentMissing = cards.length > 0 && cards.every((c) => c.contentMissing);
+    const status = allContentMissing ? "rules_only" : "completed";
     return {
-        status: "completed",
+        status,
         cards,
         truncated,
-        reason: truncated ? "evidence_batch_truncated" : undefined,
+        reason: status === "rules_only" ? "evidence_content_missing" : (truncated ? "evidence_batch_truncated" : undefined),
     };
 }

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

@@ -4,19 +4,22 @@
  * Core logic: Check if today's Quiet review is due (closures exist but no review
  * yet), schedule/run it, then check Dream status. Records durable states so
  * loop_status can report exact missing stages even when heartbeat does not
- * select a quiet intent.
+ * select a quiet intent. Also executes stale Dream consolidation runs that
+ * were left at "scheduled" because no runner picked them up.
  *
  * Design authority:
  * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.md §4`
  * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.detail.md §3.1-§3.4`
  *
  * Dependencies:
- * - `src/storage/v8-state-stores.js` (write/read DailyRhythmState)
+ * - `src/storage/v8-state-stores.js` (write/read DailyRhythmState, readDreamConsolidationRunById, writeDreamConsolidationRun)
  * - `src/core/second-nature/quiet-dream/quiet-daily-review-builder.js`
  * - `src/core/second-nature/quiet-dream/dream-scheduler.js`
+ * - `src/core/second-nature/quiet-dream/dream-consolidation-runner.js`
  *
  * Boundary:
- * - Does not run consolidation; only schedules and records lifecycle.
+ * - Schedules and records lifecycle; additionally executes stale scheduled runs
+ *   so `dreamStatus` reaches completed/blocked.
  * - Does not bypass Dream runner; only records due/completed/blocked.
  */
 import type { StateDatabase } from "../../../storage/db/index.js";

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

@@ -4,30 +4,138 @@
  * Core logic: Check if today's Quiet review is due (closures exist but no review
  * yet), schedule/run it, then check Dream status. Records durable states so
  * loop_status can report exact missing stages even when heartbeat does not
- * select a quiet intent.
+ * select a quiet intent. Also executes stale Dream consolidation runs that
+ * were left at "scheduled" because no runner picked them up.
  *
  * Design authority:
  * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.md §4`
  * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.detail.md §3.1-§3.4`
  *
  * Dependencies:
- * - `src/storage/v8-state-stores.js` (write/read DailyRhythmState)
+ * - `src/storage/v8-state-stores.js` (write/read DailyRhythmState, readDreamConsolidationRunById, writeDreamConsolidationRun)
  * - `src/core/second-nature/quiet-dream/quiet-daily-review-builder.js`
  * - `src/core/second-nature/quiet-dream/dream-scheduler.js`
+ * - `src/core/second-nature/quiet-dream/dream-consolidation-runner.js`
  *
  * Boundary:
- * - Does not run consolidation; only schedules and records lifecycle.
+ * - Schedules and records lifecycle; additionally executes stale scheduled runs
+ *   so `dreamStatus` reaches completed/blocked.
  * - Does not bypass Dream runner; only records due/completed/blocked.
  */
-import { writeDailyRhythmState, readDailyRhythmStateByDay, readActionClosuresByDay, } from "../../../storage/v8-state-stores.js";
+import { writeDailyRhythmState, readDailyRhythmStateByDay, readActionClosuresByDay, readDreamConsolidationRunById, readDreamConsolidationRunsByQuietId, updateDreamConsolidationRunStatus, } from "../../../storage/v8-state-stores.js";
 import { buildQuietDailyReview } from "./quiet-daily-review-builder.js";
 import { scheduleDreamAfterQuiet } from "./dream-scheduler.js";
+import { runDreamConsolidation } from "./dream-consolidation-runner.js";
+// ───────────────────────────────────────────────────────────────
+// Config
+// ───────────────────────────────────────────────────────────────
+const DREAM_DEFAULT_INTERVAL_DAYS = 7;
+const STALE_SCHEDULED_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
 function todayString(now) {
     return now.slice(0, 10);
 }
+function parsePayloadJson(json) {
+    if (!json)
+        return {};
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return {};
+    }
+}
+function isWithinDays(isoDate, now, days) {
+    const then = new Date(isoDate).getTime();
+    const current = new Date(now).getTime();
+    if (Number.isNaN(then) || Number.isNaN(current))
+        return false;
+    return current - then < days * 24 * 60 * 60 * 1000;
+}
+function isStaleScheduled(run, now) {
+    const created = new Date(run.createdAt).getTime();
+    const current = new Date(now).getTime();
+    if (Number.isNaN(created) || Number.isNaN(current))
+        return false;
+    return current - created > STALE_SCHEDULED_THRESHOLD_MS;
+}
+async function loadLatestDreamRunForQuiet(db, quietId) {
+    const runsRead = await readDreamConsolidationRunsByQuietId(db, quietId);
+    if (runsRead.degraded) {
+        return { degraded: runsRead.degraded };
+    }
+    return { row: runsRead.rows[0] };
+}
+async function executeStaleScheduledDreams(db, state, now) {
+    // Look for any scheduled dream runs for today and execute them.
+    const quietId = `quiet_${state.day}`;
+    const knownRunIds = [];
+    // Direct lookup by quiet review id is more reliable than rhythm payload cache.
+    const runsRead = await readDreamConsolidationRunsByQuietId(db, quietId);
+    if (runsRead.degraded) {
+        return runsRead.degraded;
+    }
+    for (const run of runsRead.rows) {
+        knownRunIds.push(run.id);
+    }
+    // Also read the rhythm payload for any ids that may have been recorded before.
+    const rhythmRead = await readDailyRhythmStateByDay(db, state.day);
+    if (!rhythmRead.degraded && rhythmRead.row?.payloadJson) {
+        const payload = parsePayloadJson(rhythmRead.row.payloadJson);
+        if (payload.dreamRunId) {
+            knownRunIds.push(String(payload.dreamRunId));
+        }
+        if (Array.isArray(payload.dreamRunIds)) {
+            knownRunIds.push(...payload.dreamRunIds);
+        }
+    }
+    const uniqueRunIds = [...new Set(knownRunIds)];
+    if (uniqueRunIds.length === 0) {
+        return { completed: false };
+    }
+    let lastResult = { completed: false };
+    for (const runId of uniqueRunIds) {
+        const runRead = await readDreamConsolidationRunById(db, runId);
+        if (runRead.degraded) {
+            return runRead.degraded;
+        }
+        const run = runRead.row;
+        if (!run)
+            continue;
+        if ((run.status === "scheduled" || run.status === "started") && isStaleScheduled(run, now)) {
+            const consolidateResult = await runDreamConsolidation(db, runId, { now });
+            if ("status" in consolidateResult && consolidateResult.status !== "degraded") {
+                const dreamResult = consolidateResult;
+                const finalStatus = dreamResult.status;
+                const finalReason = dreamResult.reason ?? undefined;
+                const updateResult = await updateDreamConsolidationRunStatus(db, runId, finalStatus, {
+                    reason: finalReason ?? null,
+                    lifecycleStatus: finalStatus === "completed" ? "completed" : "archived",
+                    payloadJson: JSON.stringify({
+                        ...parsePayloadJson(run.payloadJson),
+                        consolidatedAt: now,
+                        candidateCount: dreamResult.candidates.length,
+                        staleRepairedAt: now,
+                    }),
+                });
+                if ("reason" in updateResult) {
+                    return updateResult;
+                }
+                lastResult = { completed: true, reason: finalReason ?? "dream_scheduled_stalled" };
+            }
+            else {
+                const degraded = consolidateResult;
+                return degraded;
+            }
+        }
+        else if (run.status === "completed") {
+            lastResult = { completed: true, reason: run.reason ?? undefined };
+        }
+    }
+    return lastResult;
+}
 // ───────────────────────────────────────────────────────────────
 // Public API
 // ───────────────────────────────────────────────────────────────
@@ -90,33 +198,96 @@ export async function checkDailyRhythm(db, options) {
             }
         }
     }
+    // Track scheduled dream run ids across attempts
+    const dreamRunIds = [];
     // Determine Dream status based on Quiet outcome
     if (state.quietStatus === "completed") {
-        if (state.dreamStatus === "completed" ||
-            state.dreamStatus === "scheduled" ||
-            state.dreamStatus === "blocked") {
+        if (state.dreamStatus === "completed") {
+            // Already completed; nothing to do
+        }
+        else if (state.dreamStatus === "scheduled") {
+            // Stale scheduled run: try to execute consolidation now
+            const staleResult = await executeStaleScheduledDreams(db, state, now);
+            if ("status" in staleResult && staleResult.status === "degraded") {
+                return staleResult;
+            }
+            const { completed, reason } = staleResult;
+            if (completed) {
+                state.dreamStatus = "completed";
+                state.dreamReason = reason ?? "dream_completed";
+                state.dreamCompletedAt = now;
+            }
+            else {
+                // Still cannot locate/run scheduled dream; remain scheduled
+                state.dreamReason = state.dreamReason ?? "dream_scheduled";
+            }
+        }
+        else if (state.dreamStatus === "blocked") {
             // Already handled; do not re-schedule
         }
         else {
-            state.dreamStatus = "due";
-            state.dreamReason = "dream_scheduled";
-            // Schedule Dream
             const quietId = `quiet_${day}`;
-            const dreamResult = await scheduleDreamAfterQuiet(db, quietId, {
-                now,
-                schedulerAvailable: options?.schedulerAvailable ?? true,
-            });
-            if ("reason" in dreamResult) {
-                state.dreamStatus = "blocked";
-                state.dreamReason = dreamResult.reason;
+            const latestRun = await loadLatestDreamRunForQuiet(db, quietId);
+            if (latestRun.degraded) {
+                return latestRun.degraded;
             }
-            else if (dreamResult.status === "blocked") {
-                state.dreamStatus = "blocked";
-                state.dreamReason = dreamResult.reason ?? "dream_scheduler_unavailable";
+            // If a completed/blocked run already exists within the 7-day interval, honor it.
+            if (latestRun.row &&
+                (latestRun.row.status === "completed" || latestRun.row.status === "blocked") &&
+                isWithinDays(latestRun.row.createdAt, now, DREAM_DEFAULT_INTERVAL_DAYS)) {
+                state.dreamStatus = latestRun.row.status;
+                state.dreamReason = latestRun.row.reason ?? "dream_completed";
+                if (latestRun.row.status === "completed") {
+                    state.dreamCompletedAt = now;
+                }
             }
             else {
-                state.dreamStatus = "scheduled";
+                state.dreamStatus = "due";
                 state.dreamReason = "dream_scheduled";
+                // Schedule Dream
+                const dreamResult = await scheduleDreamAfterQuiet(db, quietId, {
+                    now,
+                    schedulerAvailable: options?.schedulerAvailable ?? true,
+                });
+                if ("reason" in dreamResult) {
+                    state.dreamStatus = "blocked";
+                    state.dreamReason = dreamResult.reason;
+                }
+                else if (dreamResult.status === "blocked") {
+                    state.dreamStatus = "blocked";
+                    state.dreamReason = dreamResult.reason ?? "dream_scheduler_unavailable";
+                }
+                else {
+                    state.dreamStatus = "scheduled";
+                    state.dreamReason = "dream_scheduled";
+                    dreamRunIds.push(dreamResult.id);
+                    // Immediately execute the freshly scheduled dream so it does not sit
+                    // pending forever (T-DQ.R.7).
+                    const consolidateResult = await runDreamConsolidation(db, dreamResult.id, { now });
+                    if ("status" in consolidateResult && consolidateResult.status !== "degraded") {
+                        const dreamOutcome = consolidateResult;
+                        const updateResult = await updateDreamConsolidationRunStatus(db, dreamResult.id, dreamOutcome.status, {
+                            reason: dreamOutcome.reason ?? null,
+                            lifecycleStatus: dreamOutcome.status === "completed" ? "completed" : "archived",
+                            payloadJson: JSON.stringify({
+                                consolidatedAt: now,
+                                candidateCount: dreamOutcome.candidates.length,
+                            }),
+                        });
+                        if ("reason" in updateResult) {
+                            return updateResult;
+                        }
+                        state.dreamStatus = dreamOutcome.status === "completed" ? "completed" : "blocked";
+                        state.dreamReason = dreamOutcome.reason ?? (dreamOutcome.status === "completed" ? "dream_completed" : "dream_failed");
+                        if (dreamOutcome.status === "completed") {
+                            state.dreamCompletedAt = now;
+                        }
+                    }
+                    else {
+                        const degraded = consolidateResult;
+                        return degraded;
+                    }
+                }
             }
         }
     }
@@ -134,6 +305,11 @@ export async function checkDailyRhythm(db, options) {
         state.dreamReason = state.quietReason ?? "dream_blocked_redaction";
     }
     // Persist state
+    const payload = { checkedAt: now, hasClosures: closuresRead.rows.length };
+    if (dreamRunIds.length > 0) {
+        payload.dreamRunId = dreamRunIds[0];
+        payload.dreamRunIds = dreamRunIds;
+    }
     const writeResult = await writeDailyRhythmState(db, {
         id: `rhythm_${day}`,
         day,
@@ -152,7 +328,7 @@ export async function checkDailyRhythm(db, options) {
                 resolveStatus: "resolvable",
             },
         ],
-        payloadJson: JSON.stringify({ checkedAt: now, hasClosures: closuresRead.rows.length }),
+        payloadJson: JSON.stringify(payload),
         updatedAt: now,
     });
     if ("reason" in writeResult) {

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

@@ -1,16 +1,17 @@
 /**
  * QuietDailyReviewBuilder — Aggregate daily closures, perceptions, and
- * memory-review candidates into a source-backed QuietDailyReview.
+ * memory-review candidates into a readable, source-backed QuietDailyReview.
  *
  * Core logic: Read ActionClosureRecords by day, collect memory-review
- * candidates, build summary, and write QuietDailyReview row.
+ * candidates and attached PerceptionCard summaries, build a human-readable
+ * review, and write QuietDailyReview row.
  *
  * Design authority:
  * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.detail.md §3.1`
  * - `.anws/v8/04_SYSTEM_DESIGN/dream-quiet-memory-system.md §4.2`
  *
  * Dependencies:
- * - `src/storage/v8-state-stores.js` (readActionClosuresByDay, writeQuietDailyReview)
+ * - `src/storage/v8-state-stores.js` (readActionClosuresByDay, readPerceptionCardById, writeQuietDailyReview)
  * - `src/shared/types/v8-contracts.js` (SourceRef, DegradedOperationResult, V8ReasonCode)
  *
  * Boundary:
@@ -22,6 +23,14 @@
  */
 import type { StateDatabase } from "../../../storage/db/index.js";
 import type { SourceRef, DegradedOperationResult, V8ReasonCode } from "../../../shared/types/v8-contracts.js";
+export interface QuietReviewEntry {
+    closureId: string;
+    platformId?: string;
+    actionKind?: string;
+    status: string;
+    summary?: string;
+    reason?: string;
+}
 export interface QuietDailyReviewResult {
     id: string;
     day: string;
@@ -32,9 +41,16 @@ export interface QuietDailyReviewResult {
     /** Explicit closure refs — first-class provenance for reviewed ActionClosureRecords */
     closureRefs: SourceRef[];
     reviewSummary: string;
+    /** Human-readable review sections */
+    sections: QuietReviewSection[];
     importanceSignals: string[];
     createdAt: string;
 }
+export interface QuietReviewSection {
+    kind: "headline" | "completed" | "deferred" | "failed" | "memory_candidates" | "observations";
+    title: string;
+    lines: string[];
+}
 export interface BuildQuietDailyReviewOptions {
     day?: string;
     now?: string;