@haaaiawd/second-nature 0.1.38 → 0.1.40

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;

package/runtime/dream/memory-consolidator.js

@@ -0,0 +1,140 @@
+/**
+ * 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
+ */
+const STALE_DAYS = 90;
+function isStale(createdAt) {
+    const then = new Date(createdAt).getTime();
+    const now = Date.now();
+    return now - then > STALE_DAYS * 24 * 60 * 60 * 1000;
+}
+function keyForSourceRefs(refs) {
+    return refs
+        .map((r) => `${r.sourceId}:${r.kind}`)
+        .sort()
+        .join("|");
+}
+function summariesSimilar(a, b) {
+    const norm = (s) => s
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, "")
+        .split(/\s+/)
+        .filter(Boolean)
+        .slice(0, 5)
+        .join(" ");
+    return norm(a) === norm(b);
+}
+export function consolidateMemory(input) {
+    const allRaw = [
+        ...input.evidenceSummaries.map((e) => ({
+            ...e,
+            origin: "evidence",
+        })),
+        ...input.chronicleSummaries.map((c) => ({
+            ...c,
+            origin: "chronicle",
+        })),
+        ...(input.toolExperienceSummaries ?? []).map((t) => ({
+            ...t,
+            origin: "tool_experience",
+        })),
+        ...input.existingEntries.map((e) => ({
+            id: e.entryId,
+            summary: e.summary,
+            sourceRefs: e.sourceRefs,
+            createdAt: e.createdAt,
+            origin: "memory",
+        })),
+    ];
+    // 1. Deduplicate by sourceRef key, keep most recent
+    const bySourceKey = new Map();
+    for (const item of allRaw) {
+        const key = keyForSourceRefs(item.sourceRefs);
+        const existing = bySourceKey.get(key);
+        if (!existing || item.createdAt > existing.createdAt) {
+            bySourceKey.set(key, item);
+        }
+    }
+    const deduped = Array.from(bySourceKey.values());
+    const dedupeCount = allRaw.length - deduped.length;
+    // 2. Merge similar summaries
+    const merged = [];
+    const used = new Set();
+    for (const item of deduped) {
+        if (used.has(item.id))
+            continue;
+        const group = [item];
+        for (const other of deduped) {
+            if (other.id === item.id || used.has(other.id))
+                continue;
+            if (summariesSimilar(item.summary, other.summary)) {
+                group.push(other);
+                used.add(other.id);
+            }
+        }
+        used.add(item.id);
+        const mergedRefs = [];
+        const seenRefKeys = new Set();
+        for (const g of group) {
+            for (const ref of g.sourceRefs) {
+                const rk = `${ref.sourceId}:${ref.kind}`;
+                if (!seenRefKeys.has(rk)) {
+                    seenRefKeys.add(rk);
+                    mergedRefs.push(ref);
+                }
+            }
+        }
+        const latestCreatedAt = group
+            .map((g) => g.createdAt)
+            .sort()
+            .at(-1);
+        merged.push({
+            entryId: `consolidated:${crypto.randomUUID()}`,
+            kind: group[0].origin,
+            summary: group[0].summary,
+            sourceRefs: mergedRefs,
+            createdAt: latestCreatedAt,
+        });
+    }
+    // 3. Stale marking
+    let staleCount = 0;
+    for (const entry of merged) {
+        if (isStale(entry.createdAt)) {
+            staleCount++;
+        }
+    }
+    // 4. Conflict detection: entries with overlapping sourceRefs but different summaries
+    const conflicts = [];
+    for (let i = 0; i < merged.length; i++) {
+        for (let j = i + 1; j < merged.length; j++) {
+            const a = merged[i];
+            const b = merged[j];
+            const aKeys = new Set(a.sourceRefs.map((r) => `${r.sourceId}:${r.kind}`));
+            const overlap = b.sourceRefs.some((r) => aKeys.has(`${r.sourceId}:${r.kind}`));
+            if (overlap && !summariesSimilar(a.summary, b.summary)) {
+                conflicts.push({
+                    entryId: a.entryId,
+                    reason: `conflict_with:${b.entryId}`,
+                });
+                conflicts.push({
+                    entryId: b.entryId,
+                    reason: `conflict_with:${a.entryId}`,
+                });
+            }
+        }
+    }
+    return {
+        entries: merged,
+        conflicts,
+        staleCount,
+        dedupeCount,
+    };
+}

package/runtime/dream/narrative-update-proposal.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Narrative Update Proposal
+ *
+ * Core logic: generate a narrative update proposal based on evidence and
+ * extracted insights. Claims must be source-backed; unsupported claims are
+ * flagged and the proposal is degraded or blocked.
+ *
+ * - Focus: most prominent theme from insights or evidence.
+ * - Progress: learning and observation insights mapped to progress entries.
+ * - NextIntent: inferred from unresolved conflicts or high-priority patterns.
+ * Test coverage: tests/unit/dream/t7-1-4-narrative-update.test.ts
+ */
+import type { DreamNarrativeUpdate } from "./types.js";
+export interface NarrativeProposalInput {
+    evidenceSummaries: Array<{
+        id: string;
+        summary: string;
+        createdAt: string;
+    }>;
+    insights: Array<{
+        id: string;
+        type: "pattern" | "learning" | "observation" | "conflict";
+        summary: string;
+        sourceRefs: string[];
+        confidence: number;
+    }>;
+    priorFocus?: string;
+}
+export interface NarrativeProposalResult {
+    proposal?: DreamNarrativeUpdate;
+    unsupportedClaims: string[];
+    blocked: boolean;
+}
+export declare function draftNarrativeFromDream(input: NarrativeProposalInput): NarrativeProposalResult;

package/runtime/dream/narrative-update-proposal.js

@@ -0,0 +1,83 @@
+/**
+ * Narrative Update Proposal
+ *
+ * Core logic: generate a narrative update proposal based on evidence and
+ * extracted insights. Claims must be source-backed; unsupported claims are
+ * flagged and the proposal is degraded or blocked.
+ *
+ * - Focus: most prominent theme from insights or evidence.
+ * - Progress: learning and observation insights mapped to progress entries.
+ * - NextIntent: inferred from unresolved conflicts or high-priority patterns.
+ * Test coverage: tests/unit/dream/t7-1-4-narrative-update.test.ts
+ */
+export function draftNarrativeFromDream(input) {
+    const unsupportedClaims = [];
+    if (input.evidenceSummaries.length === 0 && input.insights.length === 0) {
+        return {
+            unsupportedClaims: ["no_evidence_for_narrative"],
+            blocked: true,
+        };
+    }
+    // Focus: highest-confidence insight summary, or first evidence if no insights
+    let focus = input.priorFocus ?? "continue exploration";
+    const highConfidenceInsights = input.insights.filter((i) => i.confidence >= 0.6);
+    if (highConfidenceInsights.length > 0) {
+        // Pick the insight with highest confidence
+        const top = highConfidenceInsights.sort((a, b) => b.confidence - a.confidence)[0];
+        focus = top.summary.slice(0, 120);
+    }
+    else if (input.evidenceSummaries.length > 0) {
+        focus = input.evidenceSummaries[0].summary.slice(0, 120);
+    }
+    // Progress: learning + observation insights become progress entries
+    const progressAdditions = [];
+    for (const insight of input.insights) {
+        if (insight.type === "learning" || insight.type === "observation") {
+            progressAdditions.push(insight.summary.slice(0, 200));
+        }
+    }
+    if (progressAdditions.length === 0 && input.evidenceSummaries.length > 0) {
+        // Fallback: use most recent evidence as progress
+        const recent = [...input.evidenceSummaries].sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0];
+        if (recent) {
+            progressAdditions.push(recent.summary.slice(0, 200));
+        }
+    }
+    // NextIntent: if conflicts exist, intent is to resolve; otherwise continue
+    const hasConflict = input.insights.some((i) => i.type === "conflict");
+    const nextIntent = hasConflict
+        ? "resolve_conflicts_and_validate"
+        : "continue_current_focus";
+    // Source refs: collect all insight source refs + evidence ids
+    const sourceRefs = new Set();
+    for (const insight of input.insights) {
+        for (const ref of insight.sourceRefs) {
+            sourceRefs.add(ref);
+        }
+    }
+    for (const ev of input.evidenceSummaries) {
+        sourceRefs.add(ev.id);
+    }
+    // Confidence: average of insight confidences, or 0.5 fallback
+    const avgConfidence = input.insights.length > 0
+        ? input.insights.reduce((sum, i) => sum + i.confidence, 0) /
+            input.insights.length
+        : 0.5;
+    // Degrade if confidence too low
+    if (avgConfidence < 0.3) {
+        unsupportedClaims.push("low_average_confidence_for_narrative");
+    }
+    const blocked = unsupportedClaims.length > 0 && avgConfidence < 0.2;
+    return {
+        proposal: {
+            focus,
+            progressAdditions: progressAdditions.slice(0, 20),
+            nextIntent,
+            confidenceDelta: Number(avgConfidence.toFixed(2)),
+            sourceRefs: Array.from(sourceRefs).slice(0, 50),
+            unsupportedClaims,
+        },
+        unsupportedClaims,
+        blocked,
+    };
+}

package/runtime/dream/output-validator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Dream output validator.
+ *
+ * Core logic: schema, source grounding, sensitivity, and unsupported claim
+ * checks on candidate DreamOutput. Decides accepted eligibility or archive reason.
+ * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
+ */
+import type { DreamOutput, DreamOutputValidation } from "./types.js";
+export interface ValidationInput {
+    output: DreamOutput;
+    inputEvidenceIds: string[];
+    inputChronicleIds: string[];
+    inputToolExperienceIds?: string[];
+}
+export interface ValidationResult {
+    eligible: boolean;
+    validation: DreamOutputValidation;
+    archiveReasons: string[];
+}
+export declare function validateDreamOutput(input: ValidationInput): ValidationResult;