@haaaiawd/second-nature 0.1.50 → 0.1.51

package/dist/tests/unit/quiet/claim-synthesizer.test.js

@@ -1,289 +0,0 @@
-/**
- * ClaimSynthesizer tests — T-DQS.C.1
- *
- * Coverage:
- * - EvidenceAggregator groups candidates by type and produces summary
- * - ClaimDeduplicator removes duplicate claims by sourceRef key
- * - ClaimSynthesizer:
- *   - single weak evidence → observation only
- *   - multiple evidence → fact
- *   - >=3 high-confidence evidence → pattern
- *   - empty slice → empty claims
- * - SourceValidator:
- *   - rejects fact claim with empty sourceRefs → claim_source_missing
- *   - accepts claim with non-empty sourceRefs
- *   - observation claims also require sourceRefs (DR-025)
- */
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { createEvidenceAggregator, createClaimDeduplicator, createClaimSynthesizer, createSourceValidator, } from "../../../src/core/second-nature/quiet/claim-synthesizer.js";
-function buildCandidate(overrides = {}) {
-    return {
-        id: `ev-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-        timestamp: new Date().toISOString(),
-        evidenceType: "platform_interaction",
-        summary: "test evidence",
-        sourceRefs: [{ id: "ref-1", kind: "platform_item", uri: "uri://1" }],
-        sensitivity: "public",
-        confidence: 0.8,
-        tags: [],
-        producer: "connector-system",
-        ...overrides,
-    };
-}
-describe("EvidenceAggregator", () => {
-    it("groups candidates by evidenceType in summary", () => {
-        const agg = createEvidenceAggregator();
-        const result = agg.aggregate([
-            buildCandidate({ evidenceType: "platform_interaction", summary: "A" }),
-            buildCandidate({ evidenceType: "platform_interaction", summary: "B" }),
-            buildCandidate({ evidenceType: "work_progress", summary: "C" }),
-        ]);
-        assert.strictEqual(result.items.length, 3);
-        assert.ok(result.summary.includes("2 platform_interaction"));
-        assert.ok(result.summary.includes("1 work_progress"));
-    });
-    it("returns empty summary for empty candidates", () => {
-        const agg = createEvidenceAggregator();
-        const result = agg.aggregate([]);
-        assert.strictEqual(result.summary, "empty");
-        assert.strictEqual(result.items.length, 0);
-    });
-});
-describe("ClaimDeduplicator", () => {
-    it("removes duplicate claims by sorted sourceRefs key", () => {
-        const dedup = createClaimDeduplicator();
-        const claims = [
-            {
-                claimId: "c1",
-                kind: "fact",
-                text: "same",
-                sourceRefs: ["a", "b"],
-                confidence: 0.9,
-                createdAt: "2025-01-01T00:00:00Z",
-            },
-            {
-                claimId: "c2",
-                kind: "fact",
-                text: "same",
-                sourceRefs: ["b", "a"], // same refs, different order
-                confidence: 0.9,
-                createdAt: "2025-01-01T00:00:00Z",
-            },
-            {
-                claimId: "c3",
-                kind: "observation",
-                text: "different",
-                sourceRefs: ["c"],
-                confidence: 0.5,
-                createdAt: "2025-01-01T00:00:00Z",
-            },
-        ];
-        const result = dedup.deduplicate(claims);
-        assert.strictEqual(result.length, 2);
-        assert.ok(result.some((c) => c.claimId === "c1" || c.claimId === "c2"));
-        assert.ok(result.some((c) => c.claimId === "c3"));
-    });
-    it("preserves unique claims", () => {
-        const dedup = createClaimDeduplicator();
-        const claims = [
-            {
-                claimId: "c1",
-                kind: "fact",
-                text: "one",
-                sourceRefs: ["a"],
-                confidence: 0.9,
-                createdAt: "2025-01-01T00:00:00Z",
-            },
-            {
-                claimId: "c2",
-                kind: "fact",
-                text: "two",
-                sourceRefs: ["b"],
-                confidence: 0.8,
-                createdAt: "2025-01-01T00:00:00Z",
-            },
-        ];
-        assert.strictEqual(dedup.deduplicate(claims).length, 2);
-    });
-});
-describe("ClaimSynthesizer", () => {
-    it("single weak evidence produces observation", () => {
-        const synth = createClaimSynthesizer();
-        const result = synth.synthesize({
-            items: [buildCandidate({ confidence: 0.3 })],
-            summary: "test",
-        });
-        assert.strictEqual(result.claims.length, 1);
-        assert.strictEqual(result.claims[0].kind, "observation");
-        assert.ok(result.claims[0].text.startsWith("Observed:"));
-    });
-    it("multiple evidence produces fact", () => {
-        const synth = createClaimSynthesizer();
-        const result = synth.synthesize({
-            items: [
-                buildCandidate({ evidenceType: "platform_interaction", confidence: 0.6 }),
-                buildCandidate({ evidenceType: "platform_interaction", confidence: 0.7 }),
-            ],
-            summary: "test",
-        });
-        assert.strictEqual(result.claims.length, 1);
-        assert.strictEqual(result.claims[0].kind, "fact");
-        assert.ok(result.claims[0].text.startsWith("Noted"));
-    });
-    it(">=3 high-confidence evidence produces pattern", () => {
-        const synth = createClaimSynthesizer();
-        const result = synth.synthesize({
-            items: [
-                buildCandidate({ evidenceType: "work_progress", confidence: 0.8 }),
-                buildCandidate({ evidenceType: "work_progress", confidence: 0.75 }),
-                buildCandidate({ evidenceType: "work_progress", confidence: 0.9 }),
-            ],
-            summary: "test",
-        });
-        assert.strictEqual(result.claims.length, 1);
-        assert.strictEqual(result.claims[0].kind, "pattern");
-        assert.ok(result.claims[0].text.startsWith("Pattern detected"));
-    });
-    it("empty slice returns empty claims", () => {
-        const synth = createClaimSynthesizer();
-        const result = synth.synthesize({ items: [], summary: "empty" });
-        assert.strictEqual(result.claims.length, 0);
-        assert.strictEqual(result.errors.length, 0);
-    });
-    it("groups by evidenceType and synthesizes per group", () => {
-        const synth = createClaimSynthesizer();
-        const result = synth.synthesize({
-            items: [
-                buildCandidate({ evidenceType: "platform_interaction", confidence: 0.8 }),
-                buildCandidate({ evidenceType: "work_progress", confidence: 0.8 }),
-            ],
-            summary: "test",
-        });
-        assert.strictEqual(result.claims.length, 2);
-        const kinds = result.claims.map((c) => c.kind);
-        assert.ok(kinds.every((k) => k === "fact"));
-    });
-    it("sourceRefs are non-empty tuples", () => {
-        const synth = createClaimSynthesizer();
-        const result = synth.synthesize({
-            items: [buildCandidate({ confidence: 0.8 })],
-            summary: "test",
-        });
-        assert.ok(result.claims[0].sourceRefs.length > 0);
-        assert.ok(typeof result.claims[0].sourceRefs[0] === "string");
-    });
-    it("weak evidence at confidence 0.5 produces fact (boundary >= 0.5)", () => {
-        const synth = createClaimSynthesizer();
-        const result = synth.synthesize({
-            items: [buildCandidate({ confidence: 0.5 })],
-            summary: "test",
-        });
-        assert.strictEqual(result.claims.length, 1);
-        assert.strictEqual(result.claims[0].kind, "fact");
-        assert.strictEqual(result.errors.length, 0);
-    });
-    it("3 items at avgConfidence 0.69 produces fact (boundary < 0.7)", () => {
-        const synth = createClaimSynthesizer();
-        const result = synth.synthesize({
-            items: [
-                buildCandidate({ evidenceType: "work_progress", confidence: 0.7 }),
-                buildCandidate({ evidenceType: "work_progress", confidence: 0.69 }),
-                buildCandidate({ evidenceType: "work_progress", confidence: 0.68 }),
-            ],
-            summary: "test",
-        });
-        assert.strictEqual(result.claims.length, 1);
-        assert.strictEqual(result.claims[0].kind, "fact");
-    });
-    it("3 items at avgConfidence 0.75 produces pattern", () => {
-        const synth = createClaimSynthesizer();
-        const result = synth.synthesize({
-            items: [
-                buildCandidate({ evidenceType: "work_progress", confidence: 0.75 }),
-                buildCandidate({ evidenceType: "work_progress", confidence: 0.75 }),
-                buildCandidate({ evidenceType: "work_progress", confidence: 0.75 }),
-            ],
-            summary: "test",
-        });
-        assert.strictEqual(result.claims.length, 1);
-        assert.strictEqual(result.claims[0].kind, "pattern");
-    });
-    it("records weak_evidence_downgrade error for single weak evidence", () => {
-        // Single evidence with confidence < 0.5: determineKind returns "fact",
-        // then downgrade logic forces "observation" and records the error.
-        const synth = createClaimSynthesizer();
-        const result = synth.synthesize({
-            items: [buildCandidate({ confidence: 0.3 })],
-            summary: "test",
-        });
-        assert.strictEqual(result.claims[0].kind, "observation");
-        assert.ok(result.errors.some((e) => e.includes("weak_evidence_downgrade")), "expected weak_evidence_downgrade error");
-    });
-});
-describe("SourceValidator", () => {
-    it("accepts fact claim with non-empty sourceRefs", () => {
-        const validator = createSourceValidator();
-        const result = validator.validate({
-            claimId: "c1",
-            kind: "fact",
-            text: "test",
-            sourceRefs: ["ref-a"],
-            confidence: 0.9,
-            createdAt: "2025-01-01T00:00:00Z",
-        });
-        assert.strictEqual(result.ok, true);
-    });
-    it("rejects fact claim with empty sourceRefs", () => {
-        const validator = createSourceValidator();
-        const result = validator.validate({
-            claimId: "c1",
-            kind: "fact",
-            text: "test",
-            sourceRefs: [],
-            confidence: 0.9,
-            createdAt: "2025-01-01T00:00:00Z",
-        });
-        assert.strictEqual(result.ok, false);
-        assert.strictEqual(result.reason, "claim_source_missing");
-    });
-    it("rejects observation claim with empty sourceRefs (DR-025)", () => {
-        const validator = createSourceValidator();
-        const result = validator.validate({
-            claimId: "c1",
-            kind: "observation",
-            text: "test",
-            sourceRefs: [],
-            confidence: 0.5,
-            createdAt: "2025-01-01T00:00:00Z",
-        });
-        assert.strictEqual(result.ok, false);
-        assert.strictEqual(result.reason, "claim_source_missing");
-    });
-    it("rejects claim with blank sourceRef string", () => {
-        const validator = createSourceValidator();
-        const result = validator.validate({
-            claimId: "c1",
-            kind: "fact",
-            text: "test",
-            sourceRefs: ["  "],
-            confidence: 0.9,
-            createdAt: "2025-01-01T00:00:00Z",
-        });
-        assert.strictEqual(result.ok, false);
-        assert.strictEqual(result.reason, "claim_source_missing");
-    });
-    it("rejects synthetic fallback ref", () => {
-        const validator = createSourceValidator();
-        const result = validator.validate({
-            claimId: "c1",
-            kind: "fact",
-            text: "test",
-            sourceRefs: ["synthetic://missing"],
-            confidence: 0.9,
-            createdAt: "2025-01-01T00:00:00Z",
-        });
-        assert.strictEqual(result.ok, false);
-        assert.strictEqual(result.reason, "claim_source_missing");
-    });
-});

package/dist/tests/unit/quiet/daily-diary-writer.test.d.ts

@@ -1,12 +0,0 @@
-/**
- * DailyDiaryWriter tests — T-DQS.C.1
- *
- * Coverage:
- * - observedToday populated from observation claims
- * - notableSignals populated from fact claims
- * - tomorrowDirection from pattern claims, fallback to facts, fallback to observations
- * - empty claims → "Nothing significant today." + diary_empty error
- * - sourceRefs aggregated from all claims (deduplicated)
- * - section limit: at most 5 entries per section
- */
-export {};

package/dist/tests/unit/quiet/daily-diary-writer.test.js

@@ -1,108 +0,0 @@
-/**
- * DailyDiaryWriter tests — T-DQS.C.1
- *
- * Coverage:
- * - observedToday populated from observation claims
- * - notableSignals populated from fact claims
- * - tomorrowDirection from pattern claims, fallback to facts, fallback to observations
- * - empty claims → "Nothing significant today." + diary_empty error
- * - sourceRefs aggregated from all claims (deduplicated)
- * - section limit: at most 5 entries per section
- */
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { createDailyDiaryWriter } from "../../../src/core/second-nature/quiet/daily-diary-writer.js";
-function buildClaim(kind, text, sourceRefs = ["ref-a"]) {
-    return {
-        claimId: `c-${Date.now()}-${Math.random().toString(36).slice(2, 5)}`,
-        kind,
-        text,
-        sourceRefs: sourceRefs,
-        confidence: 0.8,
-        createdAt: "2025-01-01T00:00:00Z",
-    };
-}
-describe("DailyDiaryWriter", () => {
-    it("produces three sections from mixed claims", () => {
-        const writer = createDailyDiaryWriter();
-        const result = writer.write([
-            buildClaim("observation", "Saw user post"),
-            buildClaim("fact", "User engagement up"),
-            buildClaim("pattern", "Weekly trend"),
-        ], "2025-01-01");
-        assert.strictEqual(result.errors.length, 0);
-        assert.ok(result.diary.observedToday.includes("Saw user post"));
-        assert.ok(result.diary.notableSignals.includes("User engagement up"));
-        assert.ok(result.diary.tomorrowDirection.includes("Continue watching"));
-        assert.ok(result.diary.tomorrowDirection.includes("Weekly trend"));
-        assert.strictEqual(result.diary.day, "2025-01-01");
-        assert.ok(result.diary.diaryId.startsWith("diary:2025-01-01"));
-    });
-    it("observedToday comes from observation claims only", () => {
-        const writer = createDailyDiaryWriter();
-        const result = writer.write([
-            buildClaim("observation", "Obs 1"),
-            buildClaim("observation", "Obs 2"),
-            buildClaim("fact", "Fact 1"),
-        ], "2025-01-02");
-        assert.strictEqual(result.diary.observedToday.length, 2);
-        assert.ok(result.diary.observedToday.every((t) => t.startsWith("Obs")));
-        assert.strictEqual(result.diary.notableSignals.length, 1);
-    });
-    it("notableSignals comes from fact claims only", () => {
-        const writer = createDailyDiaryWriter();
-        const result = writer.write([
-            buildClaim("fact", "Fact A"),
-            buildClaim("fact", "Fact B"),
-            buildClaim("pattern", "Pattern X"),
-        ], "2025-01-03");
-        assert.strictEqual(result.diary.notableSignals.length, 2);
-        assert.ok(result.diary.notableSignals.every((t) => t.startsWith("Fact")));
-    });
-    it("tomorrowDirection uses pattern when available", () => {
-        const writer = createDailyDiaryWriter();
-        const result = writer.write([buildClaim("pattern", "Rising interest")], "2025-01-04");
-        assert.ok(result.diary.tomorrowDirection.includes("Continue watching"));
-        assert.ok(result.diary.tomorrowDirection.includes("Rising interest"));
-    });
-    it("tomorrowDirection falls back to facts when no patterns", () => {
-        const writer = createDailyDiaryWriter();
-        const result = writer.write([buildClaim("fact", "Metric changed")], "2025-01-05");
-        assert.ok(result.diary.tomorrowDirection.includes("Follow up"));
-    });
-    it("tomorrowDirection falls back to observations when no facts/patterns", () => {
-        const writer = createDailyDiaryWriter();
-        const result = writer.write([buildClaim("observation", "Saw something")], "2025-01-06");
-        assert.ok(result.diary.tomorrowDirection.includes("Keep observing"));
-    });
-    it("empty claims produce empty sections with diary_empty error", () => {
-        const writer = createDailyDiaryWriter();
-        const result = writer.write([], "2025-01-07");
-        assert.deepStrictEqual(result.diary.observedToday, []);
-        assert.deepStrictEqual(result.diary.notableSignals, []);
-        assert.strictEqual(result.diary.tomorrowDirection, "Nothing significant today.");
-        assert.ok(result.errors.includes("diary_empty:no_claims"));
-    });
-    it("sourceRefs are deduplicated across all claims", () => {
-        const writer = createDailyDiaryWriter();
-        const result = writer.write([
-            buildClaim("observation", "O1", ["ref-a", "ref-b"]),
-            buildClaim("fact", "F1", ["ref-b", "ref-c"]),
-        ], "2025-01-08");
-        assert.strictEqual(result.diary.sourceRefs.length, 3);
-        assert.ok(result.diary.sourceRefs.includes("ref-a"));
-        assert.ok(result.diary.sourceRefs.includes("ref-b"));
-        assert.ok(result.diary.sourceRefs.includes("ref-c"));
-    });
-    it("sections limited to at most 5 entries", () => {
-        const writer = createDailyDiaryWriter();
-        const observations = Array.from({ length: 8 }, (_, i) => buildClaim("observation", `Obs ${i + 1}`));
-        const result = writer.write(observations, "2025-01-09");
-        assert.strictEqual(result.diary.observedToday.length, 5);
-    });
-    it("createdAt is ISO string", () => {
-        const writer = createDailyDiaryWriter();
-        const result = writer.write([buildClaim("fact", "Test")], "2025-01-10");
-        assert.ok(result.diary.createdAt > "2024-01-01");
-    });
-});

package/dist/tests/unit/shared/v7-entities.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * T-SMS.F.1 — v7 Shared Entity Types Compile-Time Verification
- *
- * Core logic: Type-level assertions enforced by `tsc --noEmit`.
- * Runtime tests assert structural correctness of valid instances.
- *
- * Verification types (05A / 05B):
- * - Compile check: `@ts-expect-error` guards for SourceRef, AgentGoal.kind
- * - Unit test: RestoreSnapshot whitelist completeness, valid entity shape
- *
- * Dependencies: `src/shared/types/*` (v7-entities, source-ref, goal)
- */
-export {};