@haaaiawd/second-nature 0.1.38 → 0.1.39

package/runtime/dream/dream-input-loader.d.ts

@@ -0,0 +1,37 @@
+/**
+ * DreamInputLoader — T-DQS.C.2 (DR-026: Idempotent Claim Loading)
+ *
+ * Core logic: Load unreferenced QuietClaims as Dream inputs.
+ *
+ * Idempotent mechanism (DR-026):
+ * - Queries daily_diary_index + life_evidence_index for candidate source refs.
+ * - Excludes refs already consumed by accepted dream_output_index projections.
+ * - When Dream lock is held, claims are queued; on next Dream run after lock release,
+ *   they are automatically included (no separate "skipped" tracking needed).
+ * - Subsequent Dream runs exclude already-accepted refs, preventing re-processing.
+ *
+ * Lock semantics:
+ * - Lock TTL is 35min (enforced by DreamScheduler, not this module).
+ * - This loader only reads; lock enforcement is upstream.
+ *
+ * ToolExperience summaries:
+ * - Loads recent tool_experience records aggregated by (connector_id, capability_id, outcome).
+ * - Provides frequency count and last recorded time for Dream insight extraction.
+ *
+ * Contract:
+ * - Returns empty evidenceRefs when no unreferenced claims exist.
+ * - Never fabricates inputs; only reads from existing DB state.
+ *
+ * Performance: O(n) where n = life_evidence_index rows (capped by LIMIT).
+ * Memory: O(m) where m = deduplicated ref count (typically < evidenceLimit).
+ *
+ * Test coverage: tests/unit/dream/dream-input-loader.test.ts
+ */
+import type { Database } from "sql.js";
+import type { DreamStatePort } from "./types.js";
+export interface DreamInputLoaderOptions {
+    database: {
+        sqlite: Database;
+    };
+}
+export declare function createDreamInputLoader(options: DreamInputLoaderOptions): Pick<DreamStatePort, "loadDreamInputs">;

package/runtime/dream/dream-input-loader.js

@@ -0,0 +1,155 @@
+/**
+ * DreamInputLoader — T-DQS.C.2 (DR-026: Idempotent Claim Loading)
+ *
+ * Core logic: Load unreferenced QuietClaims as Dream inputs.
+ *
+ * Idempotent mechanism (DR-026):
+ * - Queries daily_diary_index + life_evidence_index for candidate source refs.
+ * - Excludes refs already consumed by accepted dream_output_index projections.
+ * - When Dream lock is held, claims are queued; on next Dream run after lock release,
+ *   they are automatically included (no separate "skipped" tracking needed).
+ * - Subsequent Dream runs exclude already-accepted refs, preventing re-processing.
+ *
+ * Lock semantics:
+ * - Lock TTL is 35min (enforced by DreamScheduler, not this module).
+ * - This loader only reads; lock enforcement is upstream.
+ *
+ * ToolExperience summaries:
+ * - Loads recent tool_experience records aggregated by (connector_id, capability_id, outcome).
+ * - Provides frequency count and last recorded time for Dream insight extraction.
+ *
+ * Contract:
+ * - Returns empty evidenceRefs when no unreferenced claims exist.
+ * - Never fabricates inputs; only reads from existing DB state.
+ *
+ * Performance: O(n) where n = life_evidence_index rows (capped by LIMIT).
+ * Memory: O(m) where m = deduplicated ref count (typically < evidenceLimit).
+ *
+ * Test coverage: tests/unit/dream/dream-input-loader.test.ts
+ */
+function safeParseJson(json, fallback) {
+    try {
+        const parsed = JSON.parse(json);
+        return parsed ?? fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+/** Extract ref ids from JSON that may be string[] or {id?, sourceId?}[] */
+function extractRefIdsFromJson(json) {
+    const parsed = safeParseJson(json, []);
+    if (!Array.isArray(parsed))
+        return [];
+    const ids = [];
+    for (const item of parsed) {
+        if (typeof item === "string") {
+            ids.push(item);
+        }
+        else if (item && typeof item === "object" && !Array.isArray(item)) {
+            const obj = item;
+            if (typeof obj.id === "string")
+                ids.push(obj.id);
+            if (typeof obj.sourceId === "string")
+                ids.push(obj.sourceId);
+        }
+    }
+    return ids;
+}
+/** Extract consumed ref ids from canonical_entries_json (CanonicalMemoryEntry[]) */
+function extractConsumedRefIdsFromEntriesJson(json) {
+    const entries = safeParseJson(json, []);
+    if (!Array.isArray(entries))
+        return [];
+    const ids = [];
+    for (const entry of entries) {
+        if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+            const sourceRefs = entry.sourceRefs;
+            if (Array.isArray(sourceRefs)) {
+                for (const sr of sourceRefs) {
+                    if (typeof sr === "string") {
+                        ids.push(sr);
+                    }
+                    else if (sr && typeof sr === "object" && !Array.isArray(sr)) {
+                        const obj = sr;
+                        if (typeof obj.sourceId === "string")
+                            ids.push(obj.sourceId);
+                        if (typeof obj.id === "string")
+                            ids.push(obj.id);
+                    }
+                }
+            }
+        }
+    }
+    return ids;
+}
+export function createDreamInputLoader(options) {
+    const { sqlite } = options.database;
+    return {
+        // async aligns with DreamStatePort.loadDreamInputs signature (Promise<DreamInputBundle>).
+        // All current operations are synchronous (sql.js in-memory), but the contract
+        // reserves the right to use async DB drivers in the future.
+        async loadDreamInputs(query = {}) {
+            // Defaults from 05A_TASKS.md T-DQS.C.2 and dream-quiet-system.md §10.2
+            const timeWindowDays = query.timeWindowDays ?? 30;
+            const evidenceLimit = query.evidenceLimit ?? 1000;
+            const since = new Date(Date.now() - timeWindowDays * 24 * 60 * 60 * 1000).toISOString();
+            // ─── 1. Collect candidate ref ids from daily_diary_index ─────────────────
+            const candidateRefs = new Set();
+            const diaryResult = sqlite.exec(`SELECT source_refs_json FROM daily_diary_index WHERE created_at >= ? ORDER BY created_at DESC`, [since]);
+            for (const row of diaryResult[0]?.values ?? []) {
+                for (const id of extractRefIdsFromJson(String(row[0]))) {
+                    candidateRefs.add(id);
+                }
+            }
+            // ─── 2. Collect candidate ref ids from life_evidence_index ───────────────
+            const evidenceResult = sqlite.exec(`SELECT source_refs_json FROM life_evidence_index WHERE timestamp >= ? ORDER BY timestamp DESC LIMIT ?`, [since, evidenceLimit]);
+            for (const row of evidenceResult[0]?.values ?? []) {
+                for (const id of extractRefIdsFromJson(String(row[0]))) {
+                    candidateRefs.add(id);
+                }
+            }
+            // ─── 3. Collect consumed refs from accepted dream outputs ────────────────
+            const consumedRefs = new Set();
+            const acceptedResult = sqlite.exec(`SELECT canonical_entries_json FROM dream_output_index WHERE status = 'accepted'`);
+            for (const row of acceptedResult[0]?.values ?? []) {
+                for (const id of extractConsumedRefIdsFromEntriesJson(String(row[0]))) {
+                    consumedRefs.add(id);
+                }
+            }
+            // ─── 4. Filter: keep only refs not consumed by accepted projections ──────
+            const evidenceRefs = [...candidateRefs].filter((ref) => !consumedRefs.has(ref));
+            // ─── 5. Load ToolExperience summaries (aggregated by connector/capability/outcome) ─
+            const toolExpResult = sqlite.exec(`SELECT connector_id, capability_id, outcome, COUNT(*) as count, MAX(created_at) as last_recorded_at
+         FROM tool_experience
+         WHERE created_at >= ?
+         GROUP BY connector_id, capability_id, outcome
+         ORDER BY last_recorded_at DESC
+         LIMIT ?`, [since, evidenceLimit]);
+            const toolExperienceSummaries = [];
+            for (const row of toolExpResult[0]?.values ?? []) {
+                toolExperienceSummaries.push({
+                    connectorId: String(row[0]),
+                    capabilityId: String(row[1]),
+                    outcome: String(row[2]),
+                    count: Number(row[3]),
+                    lastRecordedAt: String(row[4]),
+                });
+            }
+            return {
+                evidenceRefs,
+                chronicleEntryIds: [],
+                activeMemoryStoreId: undefined,
+                narrativeSnapshotId: undefined,
+                relationshipSnapshotId: undefined,
+                goalSnapshotIds: [],
+                toolExperienceSummaries,
+                inputCounts: {
+                    evidence: evidenceRefs.length,
+                    chronicle: 0, // T-DQS.C.2 scope: evidence only; chronicle loaded separately
+                    memoryEntries: 0, // T-DQS.C.2 scope: evidence only; memory loaded separately
+                },
+            };
+        },
+    };
+}

package/runtime/dream/dream-scheduler.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Dream Scheduler
+ *
+ * Core logic: trigger Dream runs via cron schedule, evidence threshold, or manual
+ * request. Uses DreamRunLock to prevent concurrent runs on the same workspace/input
+ * window. Operator timeout is enforced via options in the engine call.
+ *
+ * - Cron: simplified — checks if a scheduled window is due (last run + interval).
+ * - Evidence threshold: triggers when evidence count exceeds threshold since last run.
+ * - Manual: always allowed if no active lock.
+ * - Lock: in-memory or port-backed; released after run completes or times out.
+ * Test coverage: tests/integration/dream/t7-1-2-dream-scheduler.test.ts
+ */
+import type { DreamEngineInput } from "./types.js";
+import type { DreamTriggerKind, DreamTracePort, DreamStatePort, DreamModelPort, DreamBudgetPort, ModelAssistPort } from "./types.js";
+export interface SchedulerInput {
+    triggerKind: DreamTriggerKind;
+    runId: string;
+    traceId: string;
+    statePort: DreamStatePort;
+    /** @deprecated Use modelAssistPort (DR-027). */
+    modelPort?: DreamModelPort;
+    modelAssistPort?: ModelAssistPort;
+    tracePort?: DreamTracePort;
+    budgetPort?: DreamBudgetPort;
+    options?: DreamEngineInput["options"];
+    lockPort?: DreamRunLockPort;
+    windowKey?: string;
+}
+export interface DreamRunLockPort {
+    acquireLock(input: {
+        runId: string;
+        windowKey: string;
+        ttlMs: number;
+    }): Promise<{
+        acquired: boolean;
+        existingRunId?: string;
+    }>;
+    releaseLock(input: {
+        runId: string;
+        windowKey: string;
+    }): Promise<void>;
+}
+export interface ScheduleResult {
+    runId: string;
+    status: "started" | "skipped" | "queued";
+    reason?: string;
+}
+export declare function memoryLockPort(): DreamRunLockPort;
+export declare function scheduleDream(input: SchedulerInput): Promise<ScheduleResult>;
+export interface CronPolicy {
+    type: "cron";
+    intervalHours: number;
+    lastRunAt?: string;
+}
+export interface EvidenceThresholdPolicy {
+    type: "evidence_threshold";
+    threshold: number;
+    currentEvidenceCount: number;
+    lastRunEvidenceCount: number;
+}
+export interface ManualPolicy {
+    type: "manual";
+}
+export interface QuietCompletionPolicy {
+    type: "quiet_completion";
+    quietCompletedAt: string;
+    windowStartHour: number;
+    windowEndHour: number;
+}
+export type TriggerPolicy = CronPolicy | EvidenceThresholdPolicy | ManualPolicy | QuietCompletionPolicy;
+export declare function shouldTrigger(policy: TriggerPolicy): {
+    shouldRun: boolean;
+    reason?: string;
+};

package/runtime/dream/dream-scheduler.js

@@ -0,0 +1,131 @@
+/**
+ * Dream Scheduler
+ *
+ * Core logic: trigger Dream runs via cron schedule, evidence threshold, or manual
+ * request. Uses DreamRunLock to prevent concurrent runs on the same workspace/input
+ * window. Operator timeout is enforced via options in the engine call.
+ *
+ * - Cron: simplified — checks if a scheduled window is due (last run + interval).
+ * - Evidence threshold: triggers when evidence count exceeds threshold since last run.
+ * - Manual: always allowed if no active lock.
+ * - Lock: in-memory or port-backed; released after run completes or times out.
+ * Test coverage: tests/integration/dream/t7-1-2-dream-scheduler.test.ts
+ */
+import { runDream } from "./dream-engine.js";
+const DEFAULT_LOCK_TTL_MS = 35 * 60 * 1000; // 35 min (covers 30 min operator timeout + buffer)
+// In-memory lock fallback when no lockPort is provided
+export function memoryLockPort() {
+    const locks = new Map();
+    return {
+        async acquireLock(input) {
+            const key = input.windowKey;
+            const existing = locks.get(key);
+            if (existing && existing.expiresAt > Date.now()) {
+                return { acquired: false, existingRunId: existing.runId };
+            }
+            locks.set(key, {
+                runId: input.runId,
+                expiresAt: Date.now() + input.ttlMs,
+            });
+            return { acquired: true };
+        },
+        async releaseLock(input) {
+            const key = input.windowKey;
+            const existing = locks.get(key);
+            if (existing && existing.runId === input.runId) {
+                locks.delete(key);
+            }
+        },
+    };
+}
+export async function scheduleDream(input) {
+    const lock = input.lockPort ?? memoryLockPort();
+    const windowKey = input.windowKey ?? "dream_lock:default";
+    // Acquire lock
+    const lockResult = await lock.acquireLock({
+        runId: input.runId,
+        windowKey,
+        ttlMs: DEFAULT_LOCK_TTL_MS,
+    });
+    if (!lockResult.acquired) {
+        const reason = input.triggerKind === "quiet_completion"
+            ? "skip:lock_held"
+            : `lock_held_by:${lockResult.existingRunId ?? "unknown"}`;
+        return {
+            runId: input.runId,
+            status: "skipped",
+            reason,
+        };
+    }
+    // Run Dream asynchronously; do not await so heartbeat is not blocked
+    runDream({
+        runId: input.runId,
+        traceId: input.traceId,
+        triggerKind: input.triggerKind,
+        statePort: input.statePort,
+        modelPort: input.modelPort,
+        modelAssistPort: input.modelAssistPort,
+        tracePort: input.tracePort,
+        budgetPort: input.budgetPort,
+        options: input.options,
+    })
+        .then(async (result) => {
+        await lock.releaseLock({ runId: input.runId, windowKey });
+        return result;
+    })
+        .catch(async (err) => {
+        console.error("[dream-scheduler] runDream failed:", err);
+        await lock.releaseLock({ runId: input.runId, windowKey });
+    });
+    return {
+        runId: input.runId,
+        status: "started",
+    };
+}
+function isHourInWindow(hour, start, end) {
+    if (start < end) {
+        return hour >= start && hour < end;
+    }
+    return hour >= start || hour < end;
+}
+export function shouldTrigger(policy) {
+    switch (policy.type) {
+        case "cron": {
+            if (!policy.lastRunAt) {
+                return { shouldRun: true, reason: "first_run" };
+            }
+            const last = new Date(policy.lastRunAt).getTime();
+            const next = last + policy.intervalHours * 60 * 60 * 1000;
+            if (Date.now() >= next) {
+                return { shouldRun: true, reason: "cron_due" };
+            }
+            return {
+                shouldRun: false,
+                reason: `next_run_at:${new Date(next).toISOString()}`,
+            };
+        }
+        case "evidence_threshold": {
+            const delta = policy.currentEvidenceCount - policy.lastRunEvidenceCount;
+            if (delta >= policy.threshold) {
+                return {
+                    shouldRun: true,
+                    reason: `threshold_reached:${delta}/${policy.threshold}`,
+                };
+            }
+            return {
+                shouldRun: false,
+                reason: `below_threshold:${delta}/${policy.threshold}`,
+            };
+        }
+        case "manual": {
+            return { shouldRun: true, reason: "manual_trigger" };
+        }
+        case "quiet_completion": {
+            const hour = new Date(policy.quietCompletedAt).getUTCHours();
+            if (isHourInWindow(hour, policy.windowStartHour, policy.windowEndHour)) {
+                return { shouldRun: true, reason: "quiet_completion_in_window" };
+            }
+            return { shouldRun: false, reason: "skip:out_of_window" };
+        }
+    }
+}

package/runtime/dream/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Dream System public API.
+ */
+export * from "./types.js";
+export { consolidateMemory } from "./memory-consolidator.js";
+export { sampleDreamInput } from "./sampler.js";
+export { redactDreamInput, redactBundle } from "./redaction-gate.js";
+export { validateDreamOutput } from "./output-validator.js";
+export { runDream } from "./dream-engine.js";
+export { scheduleDream, shouldTrigger, memoryLockPort } from "./dream-scheduler.js";
+export type { SchedulerInput, DreamRunLockPort, ScheduleResult, CronPolicy, EvidenceThresholdPolicy, ManualPolicy, QuietCompletionPolicy, TriggerPolicy } from "./dream-scheduler.js";
+export { extractInsights } from "./insight-extractor.js";
+export { draftNarrativeFromDream } from "./narrative-update-proposal.js";
+export { draftRelationshipFromDream } from "./relationship-update-proposal.js";
+export { createDreamInputLoader } from "./dream-input-loader.js";
+export type { DreamInputLoaderOptions } from "./dream-input-loader.js";

package/runtime/dream/index.js

@@ -0,0 +1,14 @@
+/**
+ * Dream System public API.
+ */
+export * from "./types.js";
+export { consolidateMemory } from "./memory-consolidator.js";
+export { sampleDreamInput } from "./sampler.js";
+export { redactDreamInput, redactBundle } from "./redaction-gate.js";
+export { validateDreamOutput } from "./output-validator.js";
+export { runDream } from "./dream-engine.js";
+export { scheduleDream, shouldTrigger, memoryLockPort } from "./dream-scheduler.js";
+export { extractInsights } from "./insight-extractor.js";
+export { draftNarrativeFromDream } from "./narrative-update-proposal.js";
+export { draftRelationshipFromDream } from "./relationship-update-proposal.js";
+export { createDreamInputLoader } from "./dream-input-loader.js";

package/runtime/dream/insight-extractor.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Insight Extractor
+ *
+ * Core logic: extract source-grounded insight candidates from sampled evidence.
+ * Rules-based (no LLM required) using keyword patterns, frequency counts, and
+ * temporal clustering. Each insight carries type, summary, sourceRefs, and confidence.
+ *
+ * - Pattern: recurring themes across multiple evidence entries.
+ * - Learning: new skills or behaviors observed over time.
+ * - Observation: one-off notable events.
+ * - Conflict: contradictory claims or repeated failures.
+ * Test coverage: tests/unit/dream/t7-1-3-insight-extraction.test.ts
+ */
+import type { DreamInsight } from "./types.js";
+export interface ExtractInsightsInput {
+    evidenceSummaries: Array<{
+        id: string;
+        summary: string;
+        createdAt: string;
+        kind?: string;
+    }>;
+    chronicleSummaries: Array<{
+        id: string;
+        summary: string;
+        createdAt: string;
+    }>;
+    redacted?: boolean;
+}
+export declare function extractInsights(input: ExtractInsightsInput): {
+    insights: DreamInsight[];
+    unsupportedClaims: string[];
+};

package/runtime/dream/insight-extractor.js

@@ -0,0 +1,135 @@
+/**
+ * Insight Extractor
+ *
+ * Core logic: extract source-grounded insight candidates from sampled evidence.
+ * Rules-based (no LLM required) using keyword patterns, frequency counts, and
+ * temporal clustering. Each insight carries type, summary, sourceRefs, and confidence.
+ *
+ * - Pattern: recurring themes across multiple evidence entries.
+ * - Learning: new skills or behaviors observed over time.
+ * - Observation: one-off notable events.
+ * - Conflict: contradictory claims or repeated failures.
+ * Test coverage: tests/unit/dream/t7-1-3-insight-extraction.test.ts
+ */
+// Keywords that indicate learning/development
+const LEARNING_KEYWORDS = [
+    "learned", "learn", "figured out", "discovered", "understood",
+    "new approach", "different way", "better method", "improved",
+];
+// Keywords that indicate recurring patterns
+const PATTERN_KEYWORDS = [
+    "again", "regularly", "routine", "habit", "consistently",
+    "every", "frequently", "pattern", "trend",
+];
+// Keywords that indicate conflict or failure
+const CONFLICT_KEYWORDS = [
+    "failed", "failure", "error", "bug", "broke", "broken",
+    "conflict", "contradict", "disagree", "mismatch", "unexpected",
+    "not working", "does not work", "issue", "problem",
+];
+function countKeywordMatches(text, keywords) {
+    const lower = text.toLowerCase();
+    return keywords.reduce((count, kw) => {
+        const regex = new RegExp(kw.replace(/\s+/g, "\\s+"), "g");
+        const matches = lower.match(regex);
+        return count + (matches ? matches.length : 0);
+    }, 0);
+}
+function groupByDay(items) {
+    const groups = new Map();
+    for (const item of items) {
+        const day = item.createdAt.slice(0, 10);
+        const existing = groups.get(day) ?? [];
+        existing.push(item.summary);
+        groups.set(day, existing);
+    }
+    return groups;
+}
+function findRecurringThemes(items) {
+    const themeCounts = new Map();
+    for (const item of items) {
+        const words = item.summary.toLowerCase().split(/\s+/).filter((w) => w.length > 4);
+        for (const word of words) {
+            const entry = themeCounts.get(word) ?? { count: 0, sourceIds: [] };
+            entry.count++;
+            if (!entry.sourceIds.includes(item.id)) {
+                entry.sourceIds.push(item.id);
+            }
+            themeCounts.set(word, entry);
+        }
+    }
+    return Array.from(themeCounts.entries())
+        .filter(([, v]) => v.count >= 3 && v.sourceIds.length >= 2)
+        .map(([theme, v]) => ({ theme, count: v.count, sourceIds: v.sourceIds }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 5);
+}
+export function extractInsights(input) {
+    const allItems = [
+        ...input.evidenceSummaries.map((e) => ({ ...e, origin: "evidence" })),
+        ...input.chronicleSummaries.map((c) => ({ ...c, origin: "chronicle" })),
+    ];
+    const insights = [];
+    const unsupportedClaims = [];
+    if (allItems.length === 0) {
+        return { insights: [], unsupportedClaims: ["no_evidence_for_insight"] };
+    }
+    // 1. Pattern insights — recurring themes
+    const themes = findRecurringThemes(allItems);
+    for (const theme of themes) {
+        insights.push({
+            id: `insight:pattern:${theme.theme}:${crypto.randomUUID()}`,
+            type: "pattern",
+            summary: `Recurring theme "${theme.theme}" observed across ${theme.sourceIds.length} entries`,
+            sourceRefs: theme.sourceIds.slice(0, 10),
+            confidence: Math.min(0.95, 0.5 + theme.count * 0.05),
+        });
+    }
+    // 2. Learning insights — entries with learning keywords
+    const learningItems = allItems.filter((item) => countKeywordMatches(item.summary, LEARNING_KEYWORDS) > 0);
+    if (learningItems.length > 0) {
+        insights.push({
+            id: `insight:learning:${crypto.randomUUID()}`,
+            type: "learning",
+            summary: `Learning observed in ${learningItems.length} entries: ${learningItems[0].summary.slice(0, 60)}...`,
+            sourceRefs: learningItems.map((i) => i.id).slice(0, 10),
+            confidence: Math.min(0.9, 0.4 + learningItems.length * 0.1),
+        });
+    }
+    // 3. Conflict insights — entries with conflict/failure keywords
+    const conflictItems = allItems.filter((item) => countKeywordMatches(item.summary, CONFLICT_KEYWORDS) > 0);
+    if (conflictItems.length >= 2) {
+        insights.push({
+            id: `insight:conflict:${crypto.randomUUID()}`,
+            type: "conflict",
+            summary: `Repeated issues observed in ${conflictItems.length} entries`,
+            sourceRefs: conflictItems.map((i) => i.id).slice(0, 10),
+            confidence: Math.min(0.85, 0.5 + conflictItems.length * 0.05),
+        });
+    }
+    // 4. Observation insights — notable one-off events (high-activity days)
+    const byDay = groupByDay(allItems);
+    let maxDay = "";
+    let maxCount = 0;
+    for (const [day, summaries] of byDay) {
+        if (summaries.length > maxCount) {
+            maxCount = summaries.length;
+            maxDay = day;
+        }
+    }
+    if (maxCount >= 3 && maxDay) {
+        const dayItems = allItems.filter((i) => i.createdAt.startsWith(maxDay));
+        insights.push({
+            id: `insight:observation:${crypto.randomUUID()}`,
+            type: "observation",
+            summary: `High activity day (${maxDay}): ${maxCount} notable events`,
+            sourceRefs: dayItems.map((i) => i.id).slice(0, 10),
+            confidence: Math.min(0.8, 0.4 + maxCount * 0.05),
+        });
+    }
+    // If no insights extracted, record unsupported claim
+    if (insights.length === 0) {
+        unsupportedClaims.push("no_insight_patterns_detected");
+    }
+    return { insights, unsupportedClaims };
+}

package/runtime/dream/memory-consolidator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Rules-based memory consolidation.
+ *
+ * Core logic: dedupe, merge, stale cleanup, and conflict marking on evidence,
+ * chronicle, and existing memory entries. No LLM required.
+ *
+ * - Deduplicate by sourceRef id + kind; keep the most recent.
+ * - Merge entries with same kind + similar summary (naive prefix match).
+ * - Mark entries older than 90 days as stale (retain but flag).
+ * - Mark entries with conflicting sourceRefs as conflict.
+ * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
+ */
+import type { CanonicalMemoryEntry, SourceRef } from "../storage/memory-store/memory-store-lifecycle.js";
+export interface ConsolidationInput {
+    evidenceSummaries: Array<{
+        id: string;
+        summary: string;
+        sourceRefs: SourceRef[];
+        createdAt: string;
+        sensitivity?: string;
+    }>;
+    chronicleSummaries: Array<{
+        id: string;
+        summary: string;
+        sourceRefs: SourceRef[];
+        createdAt: string;
+    }>;
+    toolExperienceSummaries?: Array<{
+        id: string;
+        summary: string;
+        sourceRefs: SourceRef[];
+        createdAt: string;
+    }>;
+    existingEntries: CanonicalMemoryEntry[];
+}
+export interface ConsolidationResult {
+    entries: CanonicalMemoryEntry[];
+    conflicts: Array<{
+        entryId: string;
+        reason: string;
+    }>;
+    staleCount: number;
+    dedupeCount: number;
+}
+export declare function consolidateMemory(input: ConsolidationInput): ConsolidationResult;