@haaaiawd/second-nature 0.1.38 → 0.1.40

package/runtime/dream/output-validator.js

@@ -0,0 +1,110 @@
+/**
+ * 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
+ */
+function hasUnsupportedClaims(output) {
+    const claims = [];
+    for (const insight of output.insights) {
+        if (insight.confidence < 0.3) {
+            claims.push(`insight_low_confidence:${insight.id}`);
+        }
+        if (insight.sourceRefs.length === 0) {
+            claims.push(`insight_no_source:${insight.id}`);
+        }
+    }
+    if (output.narrativeUpdate) {
+        if (output.narrativeUpdate.unsupportedClaims.length > 0) {
+            claims.push(...output.narrativeUpdate.unsupportedClaims);
+        }
+        if (output.narrativeUpdate.sourceRefs.length === 0) {
+            claims.push("narrative_update_no_source");
+        }
+    }
+    if (output.relationshipUpdate) {
+        if (output.relationshipUpdate.sourceRefs.length === 0) {
+            claims.push("relationship_update_no_source");
+        }
+    }
+    return claims;
+}
+function isSourceGrounded(output, inputEvidenceIds, inputChronicleIds, inputToolExperienceIds) {
+    const validSourceIds = new Set([
+        ...inputEvidenceIds,
+        ...inputChronicleIds,
+        ...(inputToolExperienceIds ?? []),
+    ]);
+    for (const entry of output.canonicalEntries) {
+        for (const ref of entry.sourceRefs) {
+            if (!validSourceIds.has(ref.sourceId)) {
+                return false;
+            }
+        }
+    }
+    for (const insight of output.insights) {
+        for (const refId of insight.sourceRefs) {
+            if (!validSourceIds.has(refId)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function hasSensitivityIssues(output) {
+    const issues = [];
+    for (const entry of output.canonicalEntries) {
+        const text = JSON.stringify(entry).toLowerCase();
+        if (text.includes("password") || text.includes("token") || text.includes("secret")) {
+            issues.push(`sensitivity_in_entry:${entry.entryId}`);
+        }
+    }
+    return issues;
+}
+export function validateDreamOutput(input) {
+    const errors = [];
+    const archiveReasons = [];
+    // Schema: basic structural checks
+    const schemaValid = typeof input.output.outputId === "string" &&
+        input.output.outputId.length > 0 &&
+        typeof input.output.runId === "string" &&
+        Array.isArray(input.output.canonicalEntries) &&
+        Array.isArray(input.output.insights);
+    if (!schemaValid) {
+        errors.push("schema_invalid");
+        archiveReasons.push("schema_invalid");
+    }
+    // Source grounding
+    const sourceGrounded = isSourceGrounded(input.output, input.inputEvidenceIds, input.inputChronicleIds, input.inputToolExperienceIds);
+    if (!sourceGrounded) {
+        errors.push("source_not_grounded");
+        archiveReasons.push("source_not_grounded");
+    }
+    // Sensitivity
+    const sensitivityIssues = hasSensitivityIssues(input.output);
+    const sensitivityClean = sensitivityIssues.length === 0;
+    if (!sensitivityClean) {
+        errors.push(...sensitivityIssues);
+        archiveReasons.push(...sensitivityIssues);
+    }
+    // Unsupported claims
+    const unsupportedClaims = hasUnsupportedClaims(input.output);
+    if (unsupportedClaims.length > 0) {
+        errors.push(...unsupportedClaims);
+        archiveReasons.push("unsupported_claims_present");
+    }
+    const eligible = schemaValid && sourceGrounded && sensitivityClean && unsupportedClaims.length === 0;
+    return {
+        eligible,
+        validation: {
+            schemaValid,
+            sourceGrounded,
+            sensitivityClean,
+            unsupportedClaims,
+            errors,
+            checkedAt: new Date().toISOString(),
+        },
+        archiveReasons,
+    };
+}

package/runtime/dream/redaction-gate.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Dream redaction gate.
+ *
+ * Core logic: before sending evidence to LLM, strip credential-like fields,
+ * PII patterns, and sensitive platform payload. If redaction fails or
+ * sensitivity is too high, block the LLM stage and record reason.
+ * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
+ */
+import type { RedactedEvidenceBundle } from "./types.js";
+export interface RedactionInput {
+    evidenceSummaries: string[];
+    chronicleSummaries: string[];
+    activeMemorySummaries?: string[];
+    sensitivityFlags?: string[];
+}
+export interface RedactionResult {
+    allowed: boolean;
+    redactedEvidence: string[];
+    redactedChronicle: string[];
+    redactedMemory: string[];
+    blockedReason?: string;
+    credentialHits: number;
+    piiHits: number;
+}
+/**
+ * Produce a RedactedEvidenceBundle brand type (DR-027).
+ * Must be called before passing evidence to ModelAssistPort.
+ * Returns null if redaction gate blocks the bundle.
+ */
+export declare function redactBundle(evidence: string[], chronicle: string[], memory?: string[]): RedactedEvidenceBundle | null;
+export declare function redactDreamInput(input: RedactionInput): RedactionResult;

package/runtime/dream/redaction-gate.js

@@ -0,0 +1,109 @@
+/**
+ * Dream redaction gate.
+ *
+ * Core logic: before sending evidence to LLM, strip credential-like fields,
+ * PII patterns, and sensitive platform payload. If redaction fails or
+ * sensitivity is too high, block the LLM stage and record reason.
+ * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
+ */
+const CREDENTIAL_PATTERNS = [
+    /password\s*[:=]\s*\S+/gi,
+    /token\s*[:=]\s*\S+/gi,
+    /api[_-]?key\s*[:=]\s*\S+/gi,
+    /secret\s*[:=]\s*\S+/gi,
+    /cookie\s*[:=]\s*\S+/gi,
+    /bearer\s+\S+/gi,
+];
+const PII_PATTERNS = [
+    /\b\d{3}-\d{2}-\d{4}\b/g, // SSN-like
+    /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g, // Credit card-like
+    /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, // Email
+];
+/**
+ * Produce a RedactedEvidenceBundle brand type (DR-027).
+ * Must be called before passing evidence to ModelAssistPort.
+ * Returns null if redaction gate blocks the bundle.
+ */
+export function redactBundle(evidence, chronicle, memory) {
+    const result = redactDreamInput({
+        evidenceSummaries: evidence,
+        chronicleSummaries: chronicle,
+        activeMemorySummaries: memory ?? [],
+    });
+    if (!result.allowed)
+        return null;
+    return {
+        _brand: "redacted",
+        evidence: Object.freeze(result.redactedEvidence),
+        chronicle: Object.freeze(result.redactedChronicle),
+        memory: result.redactedMemory.length > 0
+            ? Object.freeze(result.redactedMemory)
+            : undefined,
+    };
+}
+function redactText(text) {
+    let redacted = text;
+    let credentialHits = 0;
+    let piiHits = 0;
+    for (const pattern of CREDENTIAL_PATTERNS) {
+        const matches = redacted.match(pattern);
+        if (matches) {
+            credentialHits += matches.length;
+            redacted = redacted.replace(pattern, "[REDACTED_CREDENTIAL]");
+        }
+    }
+    for (const pattern of PII_PATTERNS) {
+        const matches = redacted.match(pattern);
+        if (matches) {
+            piiHits += matches.length;
+            redacted = redacted.replace(pattern, "[REDACTED_PII]");
+        }
+    }
+    return { redacted, credentialHits, piiHits };
+}
+export function redactDreamInput(input) {
+    let totalCredentialHits = 0;
+    let totalPiiHits = 0;
+    const redactList = (items) => items.map((item) => {
+        const result = redactText(item);
+        totalCredentialHits += result.credentialHits;
+        totalPiiHits += result.piiHits;
+        return result.redacted;
+    });
+    const redactedEvidence = redactList(input.evidenceSummaries);
+    const redactedChronicle = redactList(input.chronicleSummaries);
+    const redactedMemory = redactList(input.activeMemorySummaries ?? []);
+    // If any sensitivity flag is "credential" or "sensitive", block LLM stage
+    const hasHighSensitivity = (input.sensitivityFlags ?? []).some((f) => f === "credential" || f === "sensitive");
+    if (hasHighSensitivity) {
+        return {
+            allowed: false,
+            redactedEvidence,
+            redactedChronicle,
+            redactedMemory,
+            blockedReason: "sensitivity_flag_blocks_llm",
+            credentialHits: totalCredentialHits,
+            piiHits: totalPiiHits,
+        };
+    }
+    // If credential hits are excessive, also block
+    if (totalCredentialHits > 3) {
+        return {
+            allowed: false,
+            redactedEvidence,
+            redactedChronicle,
+            redactedMemory,
+            blockedReason: "excessive_credential_exposure",
+            credentialHits: totalCredentialHits,
+            piiHits: totalPiiHits,
+        };
+    }
+    return {
+        allowed: true,
+        redactedEvidence,
+        redactedChronicle,
+        redactedMemory,
+        credentialHits: totalCredentialHits,
+        piiHits: totalPiiHits,
+    };
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Relationship Update Proposal
+ *
+ * Core logic: generate relationship update proposal based on chronicle entries.
+ * Tone/timing/topic deltas include sourceRefs and confidence.
+ * Owner no-reply signal is recorded as cooldown without inventing preference.
+ * Prevents over-inference from single samples.
+ * Test coverage: tests/unit/dream/t7-1-5-relationship-update.test.ts
+ */
+import type { DreamRelationshipUpdate } from "./types.js";
+export interface RelationshipProposalInput {
+    chronicleEntries: Array<{
+        id: string;
+        summary: string;
+        createdAt: string;
+        kind?: string;
+    }>;
+    priorTone?: string;
+    priorTiming?: string;
+    priorTopic?: string;
+}
+export interface RelationshipProposalResult {
+    proposal?: DreamRelationshipUpdate;
+    unsupportedClaims: string[];
+    cooldown?: boolean;
+}
+export declare function draftRelationshipFromDream(input: RelationshipProposalInput): RelationshipProposalResult;

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

@@ -0,0 +1,119 @@
+/**
+ * Relationship Update Proposal
+ *
+ * Core logic: generate relationship update proposal based on chronicle entries.
+ * Tone/timing/topic deltas include sourceRefs and confidence.
+ * Owner no-reply signal is recorded as cooldown without inventing preference.
+ * Prevents over-inference from single samples.
+ * Test coverage: tests/unit/dream/t7-1-5-relationship-update.test.ts
+ */
+// Keywords for tone inference
+const POSITIVE_TONE = [
+    "agree", "thanks", "appreciate", "helpful", "good", "great",
+    "love", "like", "enjoy", "excited", "happy",
+];
+const NEGATIVE_TONE = [
+    "disagree", "frustrated", "annoying", "bad", "hate", "dislike",
+    "angry", "upset", "disappointed", "concerned",
+];
+const BUSY_TIMING = [
+    "busy", "swamped", "occupied", "tight schedule", "no time",
+];
+// Keywords for topic inference
+const TOPIC_PATTERNS = {
+    work: ["work", "project", "task", "job", "delivery", "deadline"],
+    personal: ["family", "life", "health", "weekend", "trip"],
+    tech: ["code", "system", "bug", "feature", "architecture", "design"],
+    social: ["friend", "community", "meetup", "event", "collaboration"],
+};
+function inferTone(text) {
+    const lower = text.toLowerCase();
+    const pos = POSITIVE_TONE.filter((w) => lower.includes(w)).length;
+    const neg = NEGATIVE_TONE.filter((w) => lower.includes(w)).length;
+    if (pos > neg && pos > 0)
+        return { tone: "positive", score: pos };
+    if (neg > pos && neg > 0)
+        return { tone: "negative", score: neg };
+    if (pos === neg && pos > 0)
+        return { tone: "mixed", score: pos };
+    return { tone: "neutral", score: 0 };
+}
+function inferTiming(text) {
+    const lower = text.toLowerCase();
+    const busy = BUSY_TIMING.filter((w) => lower.includes(w)).length;
+    if (busy > 0)
+        return { timing: "busy", score: busy };
+    // Check for quick replies (indicator in summary)
+    if (lower.includes("quick reply") || lower.includes("prompt response")) {
+        return { timing: "responsive", score: 1 };
+    }
+    return { timing: "normal", score: 0 };
+}
+function inferTopic(text) {
+    const lower = text.toLowerCase();
+    let bestTopic = "general";
+    let bestScore = 0;
+    for (const [topic, patterns] of Object.entries(TOPIC_PATTERNS)) {
+        const score = patterns.filter((p) => lower.includes(p)).length;
+        if (score > bestScore) {
+            bestScore = score;
+            bestTopic = topic;
+        }
+    }
+    return { topic: bestTopic, score: bestScore };
+}
+export function draftRelationshipFromDream(input) {
+    const unsupportedClaims = [];
+    const replyEntries = input.chronicleEntries.filter((e) => e.kind === "owner_reply" || e.kind === "user_interaction");
+    // No-reply signal: if no owner replies, record cooldown without inventing preference
+    if (replyEntries.length === 0) {
+        return {
+            unsupportedClaims: [],
+            cooldown: true,
+        };
+    }
+    // Prevent over-inference from single sample
+    if (replyEntries.length < 2) {
+        unsupportedClaims.push("single_sample_insufficient_for_relationship_inference");
+    }
+    // Aggregate tone/timing/topic across replies
+    const toneVotes = new Map();
+    const timingVotes = new Map();
+    const topicVotes = new Map();
+    const sourceRefs = [];
+    for (const entry of replyEntries) {
+        const tone = inferTone(entry.summary);
+        toneVotes.set(tone.tone, (toneVotes.get(tone.tone) ?? 0) + tone.score);
+        const timing = inferTiming(entry.summary);
+        timingVotes.set(timing.timing, (timingVotes.get(timing.timing) ?? 0) + timing.score);
+        const topic = inferTopic(entry.summary);
+        topicVotes.set(topic.topic, (topicVotes.get(topic.topic) ?? 0) + topic.score);
+        sourceRefs.push(entry.id);
+    }
+    const topTone = Array.from(toneVotes.entries()).sort((a, b) => b[1] - a[1])[0];
+    const topTiming = Array.from(timingVotes.entries()).sort((a, b) => b[1] - a[1])[0];
+    const topTopic = Array.from(topicVotes.entries()).sort((a, b) => b[1] - a[1])[0];
+    // Compute confidence based on sample size and signal strength
+    const sampleSize = replyEntries.length;
+    const signalStrength = Math.max(topTone?.[1] ?? 0, topTiming?.[1] ?? 0, topTopic?.[1] ?? 0);
+    const confidence = Math.min(0.9, 0.3 + sampleSize * 0.05 + signalStrength * 0.05);
+    const toneDelta = topTone && topTone[1] > 0
+        ? `tone_observed_${topTone[0]}`
+        : undefined;
+    const timingDelta = topTiming && topTiming[1] > 0
+        ? `timing_observed_${topTiming[0]}`
+        : undefined;
+    const topicDelta = topTopic && topTopic[1] > 0
+        ? `topic_observed_${topTopic[0]}`
+        : undefined;
+    return {
+        proposal: {
+            toneDelta,
+            timingDelta,
+            topicDelta,
+            sourceRefs: sourceRefs.slice(0, 20),
+            confidence: Number(confidence.toFixed(2)),
+        },
+        unsupportedClaims,
+    };
+}

package/runtime/dream/sampler.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Dream input sampler.
+ *
+ * Core logic: when evidence count exceeds threshold, sample recent 7 days
+ * plus key events (outreach, owner reply, goal milestone, high-confidence refs).
+ * Goal: prevent token/cost explosion before LLM stage.
+ * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
+ */
+export interface SamplerInput {
+    evidenceSummaries: Array<{
+        id: string;
+        summary: string;
+        createdAt: string;
+        kind?: string;
+        confidence?: number;
+    }>;
+    chronicleSummaries: Array<{
+        id: string;
+        summary: string;
+        createdAt: string;
+    }>;
+    evidenceLimit?: number;
+}
+export interface SamplerResult {
+    sampledEvidenceIds: string[];
+    sampledChronicleIds: string[];
+    droppedCount: number;
+    reason: string;
+}
+export declare function sampleDreamInput(input: SamplerInput): SamplerResult;

package/runtime/dream/sampler.js

@@ -0,0 +1,65 @@
+/**
+ * Dream input sampler.
+ *
+ * Core logic: when evidence count exceeds threshold, sample recent 7 days
+ * plus key events (outreach, owner reply, goal milestone, high-confidence refs).
+ * Goal: prevent token/cost explosion before LLM stage.
+ * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
+ */
+const DEFAULT_EVIDENCE_LIMIT = 1000;
+const RECENT_DAYS = 7;
+function isWithinDays(createdAt, days) {
+    const then = new Date(createdAt).getTime();
+    const now = Date.now();
+    return now - then <= days * 24 * 60 * 60 * 1000;
+}
+function isKeyEvent(item) {
+    if (!item.kind)
+        return false;
+    const keyKinds = [
+        "outreach",
+        "owner_reply",
+        "goal_milestone",
+        "delivery",
+        "quiet_reflection",
+    ];
+    return keyKinds.includes(item.kind);
+}
+function isHighConfidence(item) {
+    return (item.confidence ?? 0) >= 0.7;
+}
+export function sampleDreamInput(input) {
+    const limit = input.evidenceLimit ?? DEFAULT_EVIDENCE_LIMIT;
+    // Priority: recent 7 days + key events + high confidence
+    const withPriority = input.evidenceSummaries.map((e) => ({
+        ...e,
+        priority: (isWithinDays(e.createdAt, RECENT_DAYS) ? 4 : 0) +
+            (isKeyEvent(e) ? 2 : 0) +
+            (isHighConfidence(e) ? 1 : 0),
+    }));
+    // Sort by priority desc, then createdAt desc
+    withPriority.sort((a, b) => {
+        if (b.priority !== a.priority)
+            return b.priority - a.priority;
+        return b.createdAt.localeCompare(a.createdAt);
+    });
+    const sampledEvidence = withPriority.slice(0, limit);
+    const sampledEvidenceIds = sampledEvidence.map((e) => e.id);
+    const droppedCount = input.evidenceSummaries.length - sampledEvidence.length;
+    // Chronicle is usually small; keep all unless it also exceeds limit
+    let sampledChronicleIds = input.chronicleSummaries.map((c) => c.id);
+    if (sampledChronicleIds.length > limit) {
+        sampledChronicleIds = sampledChronicleIds
+            .sort((a, b) => b.localeCompare(a))
+            .slice(0, limit);
+    }
+    const reason = droppedCount > 0
+        ? `sampled_${sampledEvidenceIds.length}_of_${input.evidenceSummaries.length}_evidence;priority_recent+key+confidence`
+        : "no_sampling_needed";
+    return {
+        sampledEvidenceIds,
+        sampledChronicleIds,
+        droppedCount,
+        reason,
+    };
+}

package/runtime/dream/types.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Dream System core types.
+ *
+ * Dream is an async memory consolidation job. It reads source-backed life evidence,
+ * session chronicle, and existing memory store, then produces a candidate MemoryStore
+ * with canonical entries, insights, and optional narrative/relationship update proposals.
+ *
+ * Contract: input store is immutable; output is always candidate until validated and accepted.
+ * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
+ */
+import type { CanonicalMemoryEntry, DreamInsight } from "../storage/memory-store/memory-store-lifecycle.js";
+export type { DreamInsight };
+export type DreamTriggerKind = "scheduled" | "evidence_threshold" | "manual" | "maintenance" | "quiet_completion";
+export type DreamRunStatus = "queued" | "running" | "completed" | "skipped" | "failed";
+export type DreamOutputStatus = "candidate" | "accepted" | "archived" | "partial";
+export type DreamMode = "rules_only" | "hybrid_llm" | "model_skipped";
+export interface DreamRun {
+    runId: string;
+    traceId: string;
+    triggerKind: DreamTriggerKind;
+    status: DreamRunStatus;
+    mode: DreamMode;
+    startedAt: string;
+    finishedAt?: string;
+    inputMemoryStoreId?: string;
+    outputMemoryStoreId?: string;
+    fallbackReason?: string;
+}
+export interface ToolExperienceSummary {
+    connectorId: string;
+    capabilityId: string;
+    outcome: string;
+    count: number;
+    lastRecordedAt: string;
+}
+export interface DreamInputBundle {
+    evidenceRefs: string[];
+    chronicleEntryIds: string[];
+    activeMemoryStoreId?: string;
+    narrativeSnapshotId?: string;
+    relationshipSnapshotId?: string;
+    goalSnapshotIds: string[];
+    toolExperienceSummaries?: ToolExperienceSummary[];
+    inputCounts: {
+        evidence: number;
+        chronicle: number;
+        memoryEntries: number;
+    };
+}
+export interface DreamNarrativeUpdate {
+    focus: string;
+    progressAdditions: string[];
+    nextIntent: string;
+    confidenceDelta: number;
+    sourceRefs: string[];
+    unsupportedClaims: string[];
+}
+export interface DreamRelationshipUpdate {
+    toneDelta?: string;
+    timingDelta?: string;
+    topicDelta?: string;
+    sourceRefs: string[];
+    confidence: number;
+}
+export interface DreamOutputValidation {
+    schemaValid: boolean;
+    sourceGrounded: boolean;
+    sensitivityClean: boolean;
+    unsupportedClaims: string[];
+    errors: string[];
+    checkedAt: string;
+}
+export interface DreamOutput {
+    outputId: string;
+    runId: string;
+    status: DreamOutputStatus;
+    inputMemoryStoreId?: string;
+    canonicalEntries: CanonicalMemoryEntry[];
+    insights: DreamInsight[];
+    narrativeUpdate?: DreamNarrativeUpdate;
+    relationshipUpdate?: DreamRelationshipUpdate;
+    validation: DreamOutputValidation;
+}
+export interface DreamTrace {
+    traceId: string;
+    runId: string;
+    startedAt: string;
+    finishedAt: string;
+    durationMs: number;
+    llmCostUsd?: number;
+    inputCounts: DreamInputBundle["inputCounts"];
+    fallbackReason?: string;
+    validationErrors?: string[];
+    timeoutMs?: number;
+    sensitivityFailure?: boolean;
+}
+export interface DreamRunResult {
+    runId: string;
+    status: DreamRunStatus;
+    output?: DreamOutput;
+    trace: DreamTrace;
+    fallbackReason?: string;
+}
+export interface DreamStatePort {
+    loadDreamInputs(query: {
+        timeWindowDays?: number;
+        evidenceLimit?: number;
+    }): Promise<DreamInputBundle>;
+    writeDreamOutput(output: DreamOutput): Promise<{
+        outputId: string;
+        status: "acknowledged" | "degraded";
+    }>;
+    markDreamOutputLifecycle(input: {
+        outputId: string;
+        newStatus: DreamOutputStatus;
+        validation?: DreamOutputValidation;
+        updatedAt: string;
+    }): Promise<{
+        outputId: string;
+        status: "acknowledged" | "degraded";
+    }>;
+}
+/**
+ * Brand type: evidence bundle that has passed through RedactionGate.
+ * TypeScript prevents passing un-redacted data to ModelAssistPort.
+ */
+export interface RedactedEvidenceBundle {
+    readonly _brand: "redacted";
+    readonly evidence: readonly string[];
+    readonly chronicle: readonly string[];
+    readonly memory?: readonly string[];
+}
+export interface ModelAssistPort {
+    /** Only accepts RedactedEvidenceBundle — TypeScript enforces prior redaction (DR-027). */
+    extractInsights(input: RedactedEvidenceBundle): Promise<{
+        insights: DreamInsight[];
+        narrativeUpdate?: DreamNarrativeUpdate;
+        relationshipUpdate?: DreamRelationshipUpdate;
+        unsupportedClaims: string[];
+        costUsd?: number;
+    }>;
+}
+/** @deprecated Use ModelAssistPort with RedactedEvidenceBundle (DR-027). */
+export interface DreamModelPort {
+    extractInsights(input: {
+        sampledEvidence: string[];
+        chronicleSummary: string;
+        activeMemorySummary?: string;
+        redacted: boolean;
+    }): Promise<{
+        insights: DreamInsight[];
+        narrativeUpdate?: DreamNarrativeUpdate;
+        relationshipUpdate?: DreamRelationshipUpdate;
+        unsupportedClaims: string[];
+        costUsd?: number;
+    }>;
+}
+export interface DreamTracePort {
+    recordDreamTrace(trace: DreamTrace): Promise<void>;
+}
+export interface DreamBudgetPort {
+    checkBudget(costEstimateUsd: number): Promise<{
+        allowed: boolean;
+        remainingUsd: number;
+    }>;
+}
+export interface DreamEngineInput {
+    runId: string;
+    traceId: string;
+    triggerKind: DreamTriggerKind;
+    statePort: DreamStatePort;
+    /** @deprecated Use modelAssistPort with RedactedEvidenceBundle (DR-027). */
+    modelPort?: DreamModelPort;
+    /**
+     * v7 ModelAssistPort — requires RedactedEvidenceBundle (DR-027).
+     * If both modelAssistPort and modelPort are provided, modelAssistPort takes precedence.
+     */
+    modelAssistPort?: ModelAssistPort;
+    tracePort?: DreamTracePort;
+    budgetPort?: DreamBudgetPort;
+    options?: {
+        timeWindowDays?: number;
+        evidenceLimit?: number;
+        maxCanonicalEntries?: number;
+        operatorTimeoutMs?: number;
+    };
+}

package/runtime/dream/types.js

@@ -0,0 +1,11 @@
+/**
+ * Dream System core types.
+ *
+ * Dream is an async memory consolidation job. It reads source-backed life evidence,
+ * session chronicle, and existing memory store, then produces a candidate MemoryStore
+ * with canonical entries, insights, and optional narrative/relationship update proposals.
+ *
+ * Contract: input store is immutable; output is always candidate until validated and accepted.
+ * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
+ */
+export {};