@haaaiawd/second-nature 0.1.50 → 0.1.51

package/dist/tests/integration/dream/t7-1-1-dream-pipeline.test.js

@@ -1,378 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { runDream, consolidateMemory, sampleDreamInput, redactDreamInput, validateDreamOutput, } from "../../../src/dream/index.js";
-// ─── T7.1.1: Dream Pipeline Integration Tests ────────────────────────────────
-test("T7.1.1 rules-only path produces candidate with canonical entries", async () => {
-    const traces = [];
-    const outputs = [];
-    const statePort = {
-        async loadDreamInputs() {
-            return {
-                evidenceRefs: ["ev-1", "ev-2"],
-                chronicleEntryIds: ["ch-1"],
-                activeMemoryStoreId: "mem-001",
-                goalSnapshotIds: [],
-                inputCounts: { evidence: 2, chronicle: 1, memoryEntries: 0 },
-            };
-        },
-        async writeDreamOutput(output) {
-            outputs.push(output);
-            return { outputId: output.outputId, status: "acknowledged" };
-        },
-        async markDreamOutputLifecycle() {
-            return { outputId: "out-1", status: "acknowledged" };
-        },
-    };
-    const tracePort = {
-        async recordDreamTrace(trace) {
-            traces.push(trace);
-        },
-    };
-    const result = await runDream({
-        runId: "run-001",
-        traceId: "trace-001",
-        triggerKind: "manual",
-        statePort,
-        tracePort,
-    });
-    assert.equal(result.status, "completed");
-    assert.ok(result.output);
-    // DR-023: validation pass triggers accepted transition.
-    assert.equal(result.output.status, "accepted");
-    assert.ok(result.output.canonicalEntries.length > 0);
-    assert.equal(result.trace.fallbackReason, "model_port_unavailable");
-    assert.equal(traces.length, 1);
-});
-test("T7.1.1 budget exceeded falls back to rules-only with fallback reason", async () => {
-    const traces = [];
-    const outputs = [];
-    const statePort = {
-        async loadDreamInputs() {
-            return {
-                evidenceRefs: ["ev-1"],
-                chronicleEntryIds: ["ch-1"],
-                inputCounts: { evidence: 1, chronicle: 1, memoryEntries: 0 },
-                goalSnapshotIds: [],
-            };
-        },
-        async writeDreamOutput(output) {
-            outputs.push(output);
-            return { outputId: output.outputId, status: "acknowledged" };
-        },
-        async markDreamOutputLifecycle() {
-            return { outputId: "out-1", status: "acknowledged" };
-        },
-    };
-    const budgetPort = {
-        async checkBudget() {
-            return { allowed: false, remainingUsd: 0 };
-        },
-    };
-    const modelPort = {
-        async extractInsights() {
-            return { insights: [], unsupportedClaims: [] };
-        },
-    };
-    const tracePort = {
-        async recordDreamTrace(trace) {
-            traces.push(trace);
-        },
-    };
-    const result = await runDream({
-        runId: "run-002",
-        traceId: "trace-002",
-        triggerKind: "scheduled",
-        statePort,
-        modelPort,
-        budgetPort,
-        tracePort,
-    });
-    assert.equal(result.status, "completed");
-    assert.equal(result.fallbackReason, "budget_exceeded");
-    assert.equal(result.trace.fallbackReason, "budget_exceeded");
-    assert.equal(outputs.length, 1);
-});
-test("T7.1.1 no inputs returns skipped with no_inputs fallback", async () => {
-    const traces = [];
-    const statePort = {
-        async loadDreamInputs() {
-            return {
-                evidenceRefs: [],
-                chronicleEntryIds: [],
-                inputCounts: { evidence: 0, chronicle: 0, memoryEntries: 0 },
-                goalSnapshotIds: [],
-            };
-        },
-        async writeDreamOutput(output) {
-            return { outputId: output.outputId, status: "acknowledged" };
-        },
-        async markDreamOutputLifecycle() {
-            return { outputId: "out-1", status: "acknowledged" };
-        },
-    };
-    const tracePort = {
-        async recordDreamTrace(trace) {
-            traces.push(trace);
-        },
-    };
-    const result = await runDream({
-        runId: "run-003",
-        traceId: "trace-003",
-        triggerKind: "evidence_threshold",
-        statePort,
-        tracePort,
-    });
-    assert.equal(result.status, "skipped");
-    assert.equal(result.fallbackReason, "no_inputs");
-    assert.equal(traces.length, 1);
-    assert.equal(traces[0].fallbackReason, "no_inputs");
-});
-test("T7.1.1 redaction failure blocks LLM and records sensitivity failure", async () => {
-    const traces = [];
-    const outputs = [];
-    const statePort = {
-        async loadDreamInputs() {
-            return {
-                evidenceRefs: ["ev-1"],
-                chronicleEntryIds: ["ch-1"],
-                inputCounts: { evidence: 1, chronicle: 1, memoryEntries: 0 },
-                goalSnapshotIds: [],
-            };
-        },
-        async writeDreamOutput(output) {
-            outputs.push(output);
-            return { outputId: output.outputId, status: "acknowledged" };
-        },
-        async markDreamOutputLifecycle() {
-            return { outputId: "out-1", status: "acknowledged" };
-        },
-    };
-    const tracePort = {
-        async recordDreamTrace(trace) {
-            traces.push(trace);
-        },
-    };
-    const result = await runDream({
-        runId: "run-004",
-        traceId: "trace-004",
-        triggerKind: "manual",
-        statePort,
-        tracePort,
-    });
-    assert.equal(result.status, "completed");
-    // Redaction still allows because no sensitivity flags were passed
-    // This tests the normal path; redaction failure requires explicit flags
-    assert.equal(result.trace.sensitivityFailure, false);
-});
-test("T7.1.1 model timeout produces partial output with timeout trace", async () => {
-    const traces = [];
-    const outputs = [];
-    const statePort = {
-        async loadDreamInputs() {
-            return {
-                evidenceRefs: ["ev-1", "ev-2"],
-                chronicleEntryIds: ["ch-1"],
-                inputCounts: { evidence: 2, chronicle: 1, memoryEntries: 0 },
-                goalSnapshotIds: [],
-            };
-        },
-        async writeDreamOutput(output) {
-            outputs.push(output);
-            return { outputId: output.outputId, status: "acknowledged" };
-        },
-        async markDreamOutputLifecycle() {
-            return { outputId: "out-1", status: "acknowledged" };
-        },
-    };
-    const modelPort = {
-        async extractInsights() {
-            // Simulate model timeout
-            await new Promise((resolve) => setTimeout(resolve, 200));
-            return { insights: [], unsupportedClaims: [] };
-        },
-    };
-    const budgetPort = {
-        async checkBudget() {
-            return { allowed: true, remainingUsd: 10 };
-        },
-    };
-    const tracePort = {
-        async recordDreamTrace(trace) {
-            traces.push(trace);
-        },
-    };
-    const result = await runDream({
-        runId: "run-005",
-        traceId: "trace-005",
-        triggerKind: "scheduled",
-        statePort,
-        modelPort,
-        budgetPort,
-        tracePort,
-        options: { operatorTimeoutMs: 50 }, // Very short timeout to trigger
-    });
-    assert.equal(result.status, "completed");
-    assert.equal(result.fallbackReason, "model_timeout");
-    assert.equal(result.trace.timeoutMs, 50);
-});
-test("T7.1.1 validation failure archives output with unsupported claims", async () => {
-    const statePort = {
-        async loadDreamInputs() {
-            return {
-                evidenceRefs: ["ev-1"],
-                chronicleEntryIds: ["ch-1"],
-                inputCounts: { evidence: 1, chronicle: 1, memoryEntries: 0 },
-                goalSnapshotIds: [],
-            };
-        },
-        async writeDreamOutput(output) {
-            return { outputId: output.outputId, status: "acknowledged" };
-        },
-        async markDreamOutputLifecycle() {
-            return { outputId: "out-1", status: "acknowledged" };
-        },
-    };
-    const modelPort = {
-        async extractInsights() {
-            return {
-                insights: [
-                    {
-                        id: "ins-1",
-                        type: "pattern",
-                        summary: "test insight",
-                        sourceRefs: [], // no source refs → validation fail
-                        confidence: 0.2, // low confidence
-                    },
-                ],
-                unsupportedClaims: ["unverified claim"],
-            };
-        },
-    };
-    const budgetPort = {
-        async checkBudget() {
-            return { allowed: true, remainingUsd: 10 };
-        },
-    };
-    const result = await runDream({
-        runId: "run-006",
-        traceId: "trace-006",
-        triggerKind: "manual",
-        statePort,
-        modelPort,
-        budgetPort,
-    });
-    assert.equal(result.status, "completed");
-    assert.ok(result.output);
-    assert.equal(result.output.status, "archived");
-    assert.ok(result.output.validation.errors.some((e) => e.includes("insight_no_source") || e.includes("low_confidence")) || result.output.validation.unsupportedClaims.length > 0);
-});
-test("T7.1.1 input store hash is unchanged (immutability)", async () => {
-    const inputBundle = {
-        evidenceRefs: ["ev-1", "ev-2"],
-        chronicleEntryIds: ["ch-1"],
-        activeMemoryStoreId: "mem-001",
-        inputCounts: { evidence: 2, chronicle: 1, memoryEntries: 0 },
-        goalSnapshotIds: [],
-    };
-    const statePort = {
-        async loadDreamInputs() {
-            return { ...inputBundle };
-        },
-        async writeDreamOutput(output) {
-            return { outputId: output.outputId, status: "acknowledged" };
-        },
-        async markDreamOutputLifecycle() {
-            return { outputId: "out-1", status: "acknowledged" };
-        },
-    };
-    const result = await runDream({
-        runId: "run-007",
-        traceId: "trace-007",
-        triggerKind: "manual",
-        statePort,
-    });
-    assert.equal(result.status, "completed");
-    // The inputBundle object was spread; statePort never modifies it.
-    // This asserts the contract that Dream does not mutate inputs.
-    assert.deepEqual(inputBundle.evidenceRefs, ["ev-1", "ev-2"]);
-    assert.deepEqual(inputBundle.chronicleEntryIds, ["ch-1"]);
-    assert.equal(inputBundle.activeMemoryStoreId, "mem-001");
-});
-// ─── Unit-level contract tests for sub-components ──────────────────────────────
-test("T7.1.1 consolidateMemory deduplicates by sourceRef", () => {
-    const result = consolidateMemory({
-        evidenceSummaries: [
-            {
-                id: "ev-1",
-                summary: "same event",
-                sourceRefs: [{ sourceId: "s1", kind: "platform" }],
-                createdAt: "2026-05-10T10:00:00Z",
-            },
-            {
-                id: "ev-2",
-                summary: "same event",
-                sourceRefs: [{ sourceId: "s1", kind: "platform" }],
-                createdAt: "2026-05-10T11:00:00Z",
-            },
-        ],
-        chronicleSummaries: [],
-        existingEntries: [],
-    });
-    assert.equal(result.entries.length, 1);
-    assert.equal(result.dedupeCount, 1);
-});
-test("T7.1.1 sampleDreamInput drops exceeding limit", () => {
-    const evidence = Array.from({ length: 10 }, (_, i) => ({
-        id: `ev-${i}`,
-        summary: `event ${i}`,
-        createdAt: `2026-05-0${i + 1}T10:00:00Z`,
-    }));
-    const result = sampleDreamInput({
-        evidenceSummaries: evidence,
-        chronicleSummaries: [],
-        evidenceLimit: 5,
-    });
-    assert.equal(result.sampledEvidenceIds.length, 5);
-    assert.equal(result.droppedCount, 5);
-    assert.ok(result.reason.includes("sampled"));
-});
-test("T7.1.1 redactDreamInput blocks on sensitivity flag", () => {
-    const result = redactDreamInput({
-        evidenceSummaries: ["some text"],
-        chronicleSummaries: [],
-        sensitivityFlags: ["credential"],
-    });
-    assert.equal(result.allowed, false);
-    assert.equal(result.blockedReason, "sensitivity_flag_blocks_llm");
-});
-test("T7.1.1 validateDreamOutput rejects ungrounded source", () => {
-    const result = validateDreamOutput({
-        output: {
-            outputId: "out-1",
-            runId: "run-1",
-            status: "candidate",
-            canonicalEntries: [
-                {
-                    entryId: "e1",
-                    kind: "evidence",
-                    summary: "test",
-                    sourceRefs: [{ sourceId: "unknown-source", kind: "platform", url: undefined }],
-                    createdAt: "2026-05-10T10:00:00Z",
-                },
-            ],
-            insights: [],
-            validation: {
-                schemaValid: true,
-                sourceGrounded: true,
-                sensitivityClean: true,
-                unsupportedClaims: [],
-                errors: [],
-                checkedAt: "2026-05-10T10:00:00Z",
-            },
-        },
-        inputEvidenceIds: ["ev-1"],
-        inputChronicleIds: ["ch-1"],
-    });
-    assert.equal(result.eligible, false);
-    assert.ok(result.validation.errors.some((e) => e.includes("source_not_grounded")));
-});

package/dist/tests/integration/dream/t7-1-2-dream-scheduler.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/integration/dream/t7-1-2-dream-scheduler.test.js

@@ -1,124 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { scheduleDream, shouldTrigger, memoryLockPort, } from "../../../src/dream/index.js";
-test("T7.1.2 manual trigger starts Dream async and returns started", async () => {
-    const statePort = {
-        async loadDreamInputs() {
-            return {
-                evidenceRefs: ["ev-1"],
-                chronicleEntryIds: ["ch-1"],
-                inputCounts: { evidence: 1, chronicle: 1, memoryEntries: 0 },
-                goalSnapshotIds: [],
-            };
-        },
-        async writeDreamOutput(output) {
-            return { outputId: output.outputId, status: "acknowledged" };
-        },
-        async markDreamOutputLifecycle() {
-            return { outputId: "out-1", status: "acknowledged" };
-        },
-    };
-    const result = await scheduleDream({
-        runId: "run-sched-001",
-        traceId: "trace-sched-001",
-        triggerKind: "manual",
-        statePort,
-    });
-    assert.equal(result.status, "started");
-    assert.equal(result.runId, "run-sched-001");
-});
-test("T7.1.2 concurrent run on same window is skipped due to lock", async () => {
-    const lockPort = memoryLockPort();
-    const statePort = {
-        async loadDreamInputs() {
-            return {
-                evidenceRefs: ["ev-1"],
-                chronicleEntryIds: ["ch-1"],
-                inputCounts: { evidence: 1, chronicle: 1, memoryEntries: 0 },
-                goalSnapshotIds: [],
-            };
-        },
-        async writeDreamOutput(output) {
-            return { outputId: output.outputId, status: "acknowledged" };
-        },
-        async markDreamOutputLifecycle() {
-            return { outputId: "out-1", status: "acknowledged" };
-        },
-    };
-    // First schedule acquires lock
-    const first = await scheduleDream({
-        runId: "run-sched-002",
-        traceId: "trace-sched-002",
-        triggerKind: "manual",
-        statePort,
-        lockPort,
-    });
-    assert.equal(first.status, "started");
-    // Second schedule should be skipped
-    const second = await scheduleDream({
-        runId: "run-sched-003",
-        traceId: "trace-sched-003",
-        triggerKind: "manual",
-        statePort,
-        lockPort,
-    });
-    assert.equal(second.status, "skipped");
-    assert.ok(second.reason?.includes("lock_held_by"));
-});
-test("T7.1.2 cron policy triggers when due", () => {
-    const policy = {
-        type: "cron",
-        intervalHours: 24,
-        lastRunAt: "2026-05-14T10:00:00Z",
-    };
-    const result = shouldTrigger(policy);
-    assert.equal(result.shouldRun, true);
-    assert.equal(result.reason, "cron_due");
-});
-test("T7.1.2 cron policy does not trigger before due", () => {
-    const policy = {
-        type: "cron",
-        intervalHours: 24,
-        lastRunAt: new Date().toISOString(),
-    };
-    const result = shouldTrigger(policy);
-    assert.equal(result.shouldRun, false);
-    assert.ok(result.reason?.includes("next_run_at"));
-});
-test("T7.1.2 evidence threshold policy triggers when threshold reached", () => {
-    const policy = {
-        type: "evidence_threshold",
-        threshold: 5,
-        currentEvidenceCount: 12,
-        lastRunEvidenceCount: 6,
-    };
-    const result = shouldTrigger(policy);
-    assert.equal(result.shouldRun, true);
-    assert.ok(result.reason?.includes("threshold_reached"));
-});
-test("T7.1.2 evidence threshold policy does not trigger below threshold", () => {
-    const policy = {
-        type: "evidence_threshold",
-        threshold: 10,
-        currentEvidenceCount: 15,
-        lastRunEvidenceCount: 10,
-    };
-    const result = shouldTrigger(policy);
-    assert.equal(result.shouldRun, false);
-    assert.ok(result.reason?.includes("below_threshold"));
-});
-test("T7.1.2 manual policy always triggers", () => {
-    const policy = { type: "manual" };
-    const result = shouldTrigger(policy);
-    assert.equal(result.shouldRun, true);
-    assert.equal(result.reason, "manual_trigger");
-});
-test("T7.1.2 first cron run triggers immediately", () => {
-    const policy = {
-        type: "cron",
-        intervalHours: 24,
-    };
-    const result = shouldTrigger(policy);
-    assert.equal(result.shouldRun, true);
-    assert.equal(result.reason, "first_run");
-});

package/dist/tests/integration/dream/v7c-rhythm-loop.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * T-V7C.C.3 集成测试 — Rhythm Loop Closure
- *
- * 验收标准:
- *  - Quiet 后 Dream 自动触发或写 explicit skip reason
- *  - accepted Dream projection 可通过 DiaryDreamStore 读取（state already wired via assembler）
- *  - digest delivery target 可用时写 deliveredAt + proof
- *  - digest delivery target 不可用时写 fallbackReason
- */
-export {};