@haaaiawd/second-nature 0.1.38 → 0.1.39

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;

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,
+    };
+}