@haaaiawd/second-nature 0.1.42 → 0.1.50

package/dist/tests/unit/shared/v7-entities.test.js

@@ -0,0 +1,306 @@
+/**
+ * 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)
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+// ───────────────────────────────────────────────────────────────
+// Compile-time guards — empty SourceRef must error
+// ───────────────────────────────────────────────────────────────
+// @ts-expect-error — SourceRef requires at least one string element (DR-025)
+const _emptySourceRef = [];
+const _validSourceRef = ["evidence:001", "audit:ref-42"];
+// ───────────────────────────────────────────────────────────────
+// Compile-time guards — AgentGoal.kind must be enum member
+// ───────────────────────────────────────────────────────────────
+// @ts-expect-error — "unknown_kind" is not a member of AgentGoalKind (DR-014)
+const _invalidKind = "unknown_kind";
+const _validKind = "passive_sensing";
+// ───────────────────────────────────────────────────────────────
+// Runtime structural tests
+// ───────────────────────────────────────────────────────────────
+describe("SourceRef compile contract", () => {
+    it("valid non-empty tuple compiles silently", () => {
+        const refs = ["src:a", "src:b"];
+        assert.strictEqual(refs.length, 2);
+        assert.strictEqual(refs[0], "src:a");
+    });
+});
+describe("AgentGoal shape and DR-014 kind enum", () => {
+    it("valid goal instance has all required fields", () => {
+        const goal = {
+            goalId: "goal-001",
+            kind: "exploration",
+            scope: "platform_specific",
+            status: "accepted",
+            origin: "agent_proposed",
+            description: "Explore connector capabilities",
+            completionCriteria: "List all supported capabilities",
+            risk: "low",
+            priorityHint: 3,
+            sourceRefs: ["evidence:001"],
+            createdAt: "2026-05-21T00:00:00Z",
+            updatedAt: "2026-05-21T00:00:00Z",
+        };
+        assert.strictEqual(goal.kind, "exploration");
+        assert.strictEqual(goal.scope, "platform_specific");
+        assert.ok(goal.sourceRefs.length >= 1);
+    });
+    it("kind enum covers all snake_case variants required by v7", () => {
+        const allKinds = [
+            "short_term",
+            "long_term",
+            "habit",
+            "maintenance",
+            "passive_sensing",
+            "outreach",
+            "exploration",
+        ];
+        assert.strictEqual(allKinds.length, 7);
+    });
+});
+describe("IdentityProfile cross-platform handles", () => {
+    it("supports canonical identity + per-platform handles (ADR-007)", () => {
+        const profile = {
+            profileId: "prof-001",
+            canonicalName: "Nyx",
+            canonicalBio: "Cognitive Orchestration Architect",
+            platformHandles: [
+                { platformId: "moltbook", handle: "nyx_ha" },
+                { platformId: "agent_world", handle: "haai-arch" },
+                { platformId: "instreet", handle: "haai_17949e" },
+            ],
+            updatedAt: "2026-05-21T00:00:00Z",
+        };
+        assert.strictEqual(profile.platformHandles.length, 3);
+        assert.strictEqual(profile.platformHandles[0]?.platformId, "moltbook");
+    });
+});
+describe("ToolExperience triggerSource and failureClass", () => {
+    it("records experience with mandatory triggerSource (DR-010)", () => {
+        const exp = {
+            experienceId: "exp-001",
+            connectorId: "moltbook",
+            capabilityId: "feed.read",
+            outcome: "failure",
+            failureClass: "http_404",
+            latencyMs: 120,
+            evidenceQuality: 0.0,
+            sourceRefs: ["probe:result-001"],
+            triggerSource: "probe",
+            createdAt: "2026-05-21T00:00:00Z",
+        };
+        assert.strictEqual(exp.triggerSource, "probe");
+        assert.strictEqual(exp.failureClass, "http_404");
+    });
+});
+describe("RestoreSnapshot entity whitelist (DR-017)", () => {
+    it("RestorableEntityKind contains exactly 6 allowed entities", () => {
+        const allowed = [
+            "identity_profile",
+            "agent_goal",
+            "tool_experience",
+            "daily_diary",
+            "dream_output",
+            "narrative_timeline",
+        ];
+        assert.strictEqual(allowed.length, 6);
+    });
+    it("SensitiveExcludedKind covers 5 prohibited categories", () => {
+        const excluded = [
+            "credential",
+            "raw_private_message",
+            "raw_prompt",
+            "encryption_key",
+            "session_token",
+        ];
+        assert.strictEqual(excluded.length, 5);
+    });
+    it("snapshot default excludedSensitiveKinds is populated", () => {
+        const snapshot = {
+            snapshotId: "snap-001",
+            entityWhitelist: ["identity_profile", "agent_goal"],
+            excludedSensitiveKinds: [
+                "credential",
+                "raw_private_message",
+                "raw_prompt",
+                "encryption_key",
+                "session_token",
+            ],
+            capturedAt: "2026-05-21T00:00:00Z",
+            payload: {},
+        };
+        assert.strictEqual(snapshot.excludedSensitiveKinds.length, 5);
+    });
+});
+describe("RuntimeSecretAnchor no-key-plaintext (ADR-007)", () => {
+    it("only stores locationRef and health, never raw key", () => {
+        const anchor = {
+            anchorId: "anchor-001",
+            locationRef: "env:SECOND_NATURE_ENCRYPTION_KEY",
+            health: "ok",
+            rotationPolicyRef: "policy:annual",
+            updatedAt: "2026-05-21T00:00:00Z",
+        };
+        assert.strictEqual(anchor.locationRef, "env:SECOND_NATURE_ENCRYPTION_KEY");
+        // Compile-time guarantee: RuntimeSecretAnchor interface has no `key` field.
+        assert.ok(!("key" in anchor));
+    });
+});
+describe("CapabilityProbeResult includes capabilityId (DR-001)", () => {
+    it("has capabilityId in probe result", () => {
+        const result = {
+            probeResultId: "probe-001",
+            capabilityId: "moltbook:feed.read",
+            connectorId: "moltbook",
+            actualStatus: "available",
+            httpStatus: 200,
+            probeConfigRef: "cfg-001",
+            createdAt: "2026-05-21T00:00:00Z",
+        };
+        assert.strictEqual(result.capabilityId, "moltbook:feed.read");
+    });
+});
+describe("DailyDiary three-segment structure", () => {
+    it("has observedToday, notableSignals, tomorrowDirection", () => {
+        const diary = {
+            diaryId: "diary-001",
+            day: "2026-05-21",
+            observedToday: ["connector moltbook returned 404"],
+            notableSignals: ["circuit breaker opened"],
+            tomorrowDirection: "probe recovery after cooldown",
+            sourceRefs: ["evidence:001", "audit:breaker-001"],
+            createdAt: "2026-05-21T00:00:00Z",
+        };
+        assert.strictEqual(diary.observedToday.length, 1);
+        assert.strictEqual(diary.notableSignals.length, 1);
+        assert.ok(diary.tomorrowDirection.length > 0);
+    });
+});
+describe("QuietClaim sourceRefs non-empty", () => {
+    it("requires at least one source ref (DR-025)", () => {
+        const claim = {
+            claimId: "claim-001",
+            kind: "observation",
+            text: "MoltBook feed endpoint returned 404 consistently",
+            sourceRefs: ["probe:result-001"],
+            confidence: 0.85,
+            createdAt: "2026-05-21T00:00:00Z",
+        };
+        assert.strictEqual(claim.sourceRefs.length, 1);
+    });
+});
+describe("EmbodiedContext 5-slice structure (ADR-002)", () => {
+    it("assembles with loaded status for all 5 core slices", () => {
+        const ctx = {
+            identity: {
+                status: "loaded",
+                data: {
+                    profileId: "prof-001",
+                    canonicalName: "Nyx",
+                    platformHandles: [],
+                    updatedAt: "2026-05-21T00:00:00Z",
+                },
+            },
+            goals: {
+                status: "loaded",
+                data: [],
+            },
+            recentInteractions: {
+                status: "loaded",
+                data: [],
+            },
+            toolExperience: {
+                status: "loaded",
+                data: [],
+            },
+            acceptedDream: {
+                status: "loaded",
+                data: [],
+            },
+            assembledAt: "2026-05-21T00:00:00Z",
+        };
+        assert.strictEqual(ctx.identity.status, "loaded");
+        assert.strictEqual(ctx.goals.status, "loaded");
+        assert.strictEqual(ctx.recentInteractions.status, "loaded");
+        assert.strictEqual(ctx.toolExperience.status, "loaded");
+        assert.strictEqual(ctx.acceptedDream.status, "loaded");
+    });
+    it("degraded slice carries reason without blocking others", () => {
+        const ctx = {
+            identity: {
+                status: "degraded",
+                data: {
+                    profileId: "prof-001",
+                    canonicalName: "Nyx",
+                    platformHandles: [],
+                    updatedAt: "2026-05-21T00:00:00Z",
+                },
+                reason: "identity_profile_degraded:moltbook",
+            },
+            goals: { status: "loaded", data: [] },
+            recentInteractions: { status: "loaded", data: [] },
+            toolExperience: { status: "loaded", data: [] },
+            acceptedDream: { status: "loaded", data: [] },
+            assembledAt: "2026-05-21T00:00:00Z",
+        };
+        assert.strictEqual(ctx.identity.reason, "identity_profile_degraded:moltbook");
+        assert.strictEqual(ctx.goals.status, "loaded");
+    });
+});
+describe("SelfHealthSnapshot dynamic dimensions", () => {
+    it("supports arbitrary dimension keys with status+reason", () => {
+        const health = {
+            snapshotId: "health-001",
+            dimensions: {
+                connector: { status: "ok" },
+                state_memory: { status: "degraded", reason: "migration_pending" },
+                circuit_breaker: { status: "ok" },
+            },
+            checkedAt: "2026-05-21T00:00:00Z",
+        };
+        assert.strictEqual(health.dimensions.state_memory.status, "degraded");
+        assert.strictEqual(health.dimensions.state_memory.reason, "migration_pending");
+    });
+});
+describe("HeartbeatDigest daily summary shape", () => {
+    it("has connector, goal, quiet, dream, breaker summaries", () => {
+        const digest = {
+            digestId: "digest-001",
+            day: "2026-05-21",
+            connectorSummary: [
+                { platformId: "moltbook", status: "degraded", attemptCount: 3 },
+            ],
+            goalSummary: [{ kind: "passive_sensing", activeCount: 1 }],
+            quietCount: 1,
+            dreamCount: 0,
+            breakerSummary: [{ connectorId: "moltbook", state: "open" }],
+            healthStatus: "degraded",
+            createdAt: "2026-05-21T00:00:00Z",
+        };
+        assert.strictEqual(digest.quietCount, 1);
+        assert.strictEqual(digest.dreamCount, 0);
+    });
+});
+describe("NarrativeTimelineEntry append-only hash chain", () => {
+    it("links previousHash to currentHash", () => {
+        const entry = {
+            timelineId: "tl-001",
+            entryType: "narrative.trace",
+            subjectId: "narrative-001",
+            delta: { focus: "connector health" },
+            previousHash: "sha256:abc...",
+            currentHash: "sha256:def...",
+            createdAt: "2026-05-21T00:00:00Z",
+        };
+        assert.notStrictEqual(entry.previousHash, entry.currentHash);
+    });
+});

package/dist/tests/unit/storage/delivery-attempt.test.d.ts

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

package/dist/tests/unit/storage/delivery-attempt.test.js

@@ -0,0 +1,72 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { writeDeliveryAttempt } from "../../../src/storage/delivery/write-delivery-attempt.js";
+import { listDeliveryAttemptsByDecisionId } from "../../../src/storage/delivery/query-delivery-attempts.js";
+test("T4.3.1 sent with messageId persists", async () => {
+    const state = createStateDatabase(":memory:");
+    await writeDeliveryAttempt(state, {
+        attemptId: "a1",
+        decisionId: "d1",
+        target: "explicit",
+        channel: "dm",
+        status: "sent",
+        messageId: "m-1",
+    });
+    const rows = await listDeliveryAttemptsByDecisionId(state, "d1");
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].status, "sent");
+    assert.equal(rows[0].messageId, "m-1");
+    state.close();
+});
+test("T4.3.1 sent with hostProofRef persists", async () => {
+    const state = createStateDatabase(":memory:");
+    await writeDeliveryAttempt(state, {
+        attemptId: "a2",
+        decisionId: "d2",
+        status: "sent",
+        hostProofRef: { id: "hp1", kind: "host_report", uri: "urn:host:proof:1" },
+    });
+    const rows = await listDeliveryAttemptsByDecisionId(state, "d2");
+    assert.equal(rows[0].hostProofRef?.id, "hp1");
+    state.close();
+});
+test("T4.3.1 sent without proof rejected", async () => {
+    const state = createStateDatabase(":memory:");
+    await assert.rejects(() => writeDeliveryAttempt(state, {
+        attemptId: "a3",
+        decisionId: "d3",
+        status: "sent",
+    }), /delivery_attempt_sent_requires/);
+    state.close();
+});
+test("T4.3.1 failed requires errorClass or fallbackRef", async () => {
+    const state = createStateDatabase(":memory:");
+    await assert.rejects(() => writeDeliveryAttempt(state, {
+        attemptId: "a4",
+        decisionId: "d4",
+        status: "failed",
+    }), /delivery_attempt_failed_requires/);
+    await writeDeliveryAttempt(state, {
+        attemptId: "a5",
+        decisionId: "d4",
+        status: "failed",
+        errorClass: "network",
+    });
+    const rows = await listDeliveryAttemptsByDecisionId(state, "d4");
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].errorClass, "network");
+    state.close();
+});
+test("T4.3.1 dropped_by_host_policy with fallbackRef", async () => {
+    const state = createStateDatabase(":memory:");
+    await writeDeliveryAttempt(state, {
+        attemptId: "a6",
+        decisionId: "d6",
+        status: "dropped_by_host_policy",
+        fallbackRef: "fb-1",
+    });
+    const rows = await listDeliveryAttemptsByDecisionId(state, "d6");
+    assert.equal(rows[0].fallbackRef, "fb-1");
+    state.close();
+});

package/dist/tests/unit/storage/diary-dream-store.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * DiaryDreamStore tests — T-SMS.C.7
+ *
+ * Coverage:
+ * - writeDailyDiary + loadDailyDiary round-trip
+ * - appendDreamOutput stores candidate output
+ * - transitionDreamOutputLifecycle candidate->accepted
+ * - transitionDreamOutputLifecycle rejected for invalid transition
+ * - loadAcceptedDreamProjection filters out candidate
+ * - listDreamOutputs returns all statuses
+ */
+export {};

package/dist/tests/unit/storage/diary-dream-store.test.js

@@ -0,0 +1,118 @@
+/**
+ * DiaryDreamStore tests — T-SMS.C.7
+ *
+ * Coverage:
+ * - writeDailyDiary + loadDailyDiary round-trip
+ * - appendDreamOutput stores candidate output
+ * - transitionDreamOutputLifecycle candidate->accepted
+ * - transitionDreamOutputLifecycle rejected for invalid transition
+ * - loadAcceptedDreamProjection filters out candidate
+ * - listDreamOutputs returns all statuses
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createDiaryDreamStore } from "../../../src/storage/services/diary-dream-store.js";
+describe("DiaryDreamStore", () => {
+    const baseValidation = {
+        schemaValid: true,
+        sourceGrounded: true,
+        sensitivityClean: true,
+        unsupportedClaims: [],
+        errors: [],
+        checkedAt: "2025-01-01T00:00:00Z",
+    };
+    it("writeDailyDiary round-trip", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createDiaryDreamStore(db);
+        await store.writeDailyDiary({
+            diaryId: "d1",
+            day: "2025-01-15",
+            observedToday: ["Woke early", "Read a chapter"],
+            notableSignals: ["Mood stable"],
+            tomorrowDirection: "Finish chapter 2",
+            sourceRefs: ["store:diary"],
+            createdAt: "2025-01-15T23:00:00Z",
+        });
+        const loaded = await store.loadDailyDiary("2025-01-15");
+        assert.strictEqual(loaded.day, "2025-01-15");
+        assert.strictEqual(loaded.observedToday.length, 2);
+        assert.strictEqual(loaded.tomorrowDirection, "Finish chapter 2");
+        db.close();
+    });
+    it("appendDreamOutput + listDreamOutputs", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createDiaryDreamStore(db);
+        const output = {
+            outputId: "out-1",
+            runId: "run-1",
+            status: "candidate",
+            canonicalEntries: [{ text: "Entry A" }],
+            insights: [{ note: "Insight 1" }],
+            validation: baseValidation,
+            createdAt: "2025-01-01T00:00:00Z",
+        };
+        await store.appendDreamOutput(output);
+        const list = await store.listDreamOutputs(10);
+        assert.strictEqual(list.length, 1);
+        assert.strictEqual(list[0].outputId, "out-1");
+        assert.strictEqual(list[0].status, "candidate");
+        db.close();
+    });
+    it("transitionDreamOutputLifecycle candidate->accepted", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createDiaryDreamStore(db);
+        await store.appendDreamOutput({
+            outputId: "out-2",
+            runId: "run-1",
+            status: "candidate",
+            canonicalEntries: [],
+            insights: [],
+            validation: baseValidation,
+            createdAt: "2025-01-01T00:00:00Z",
+        });
+        await store.transitionDreamOutputLifecycle("out-2", "accepted");
+        const accepted = await store.loadAcceptedDreamProjection(10);
+        assert.strictEqual(accepted.length, 1);
+        assert.strictEqual(accepted[0].outputId, "out-2");
+        assert.strictEqual(accepted[0].status, "accepted");
+        db.close();
+    });
+    it("loadAcceptedDreamProjection excludes candidate", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createDiaryDreamStore(db);
+        await store.appendDreamOutput({
+            outputId: "out-c",
+            runId: "run-1",
+            status: "candidate",
+            canonicalEntries: [],
+            insights: [],
+            validation: baseValidation,
+            createdAt: "2025-01-01T00:00:00Z",
+        });
+        const accepted = await store.loadAcceptedDreamProjection(10);
+        assert.strictEqual(accepted.length, 0);
+        db.close();
+    });
+    it("transitionDreamOutputLifecycle rejects invalid transition", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createDiaryDreamStore(db);
+        await store.appendDreamOutput({
+            outputId: "out-3",
+            runId: "run-1",
+            status: "archived",
+            canonicalEntries: [],
+            insights: [],
+            validation: baseValidation,
+            createdAt: "2025-01-01T00:00:00Z",
+        });
+        await assert.rejects(store.transitionDreamOutputLifecycle("out-3", "accepted"), /invalid_transition/);
+        db.close();
+    });
+    it("transitionDreamOutputLifecycle rejects missing output", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createDiaryDreamStore(db);
+        await assert.rejects(store.transitionDreamOutputLifecycle("missing", "accepted"), /dream_output_not_found/);
+        db.close();
+    });
+});

package/dist/tests/unit/storage/embodied-context-state-port.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * T-SMS.C.2 — EmbodiedContextStatePort 单元测试
+ */
+export {};

package/dist/tests/unit/storage/embodied-context-state-port.test.js

@@ -0,0 +1,77 @@
+/**
+ * T-SMS.C.2 — EmbodiedContextStatePort 单元测试
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createGoalLifecycleStore } from "../../../src/storage/services/goal-lifecycle-store.js";
+import { createIdentityProfileStore } from "../../../src/storage/services/identity-profile-store.js";
+import { createInteractionSnapshotProjector } from "../../../src/storage/services/interaction-snapshot-projector.js";
+import { createToolExperienceStore } from "../../../src/storage/services/tool-experience-store.js";
+import { createEmbodiedContextStatePort } from "../../../src/storage/services/embodied-context-state-port.js";
+describe("EmbodiedContextStatePort", () => {
+    it("loads identity profile with loaded status", async () => {
+        const db = createStateDatabase(":memory:");
+        const identityStore = createIdentityProfileStore(db);
+        const port = createEmbodiedContextStatePort({
+            database: db,
+            goalStore: createGoalLifecycleStore(db),
+            identityStore,
+            interactionProjector: createInteractionSnapshotProjector(db),
+            experienceStore: createToolExperienceStore(db),
+        });
+        await identityStore.upsertIdentityProfile({
+            profileId: "prof-1",
+            canonicalName: "Nyx",
+            platformHandles: [
+                { platformId: "moltbook", handle: "nyx_ha" },
+                { platformId: "agent_world", handle: "haai-arch" },
+                { platformId: "instreet", handle: "haai_17949e" },
+            ],
+            updatedAt: "2026-05-21T00:00:00Z",
+        });
+        const result = await port.loadIdentityProfile("prof-1");
+        assert.strictEqual(result.status, "loaded");
+        if (result.status === "loaded") {
+            assert.strictEqual(result.data.canonicalName, "Nyx");
+        }
+    });
+    it("lists active goals", async () => {
+        const db = createStateDatabase(":memory:");
+        const goalStore = createGoalLifecycleStore(db);
+        const port = createEmbodiedContextStatePort({
+            database: db,
+            goalStore,
+            identityStore: createIdentityProfileStore(db),
+            interactionProjector: createInteractionSnapshotProjector(db),
+            experienceStore: createToolExperienceStore(db),
+        });
+        const goal = {
+            goalId: "g-1", kind: "short_term", scope: "global", status: "accepted",
+            origin: "owner_set", description: "Test", completionCriteria: "Done",
+            risk: "low", priorityHint: 1, sourceRefs: ["ref:1"],
+            createdAt: "2026-05-21T00:00:00Z", updatedAt: "2026-05-21T00:00:00Z",
+        };
+        await goalStore.upsertAgentGoal(goal);
+        const result = await port.listActiveGoals(10);
+        assert.strictEqual(result.status, "loaded");
+        if (result.status === "loaded") {
+            assert.strictEqual(result.data.length, 1);
+        }
+    });
+    it("returns degraded reason when no accepted dream exists", async () => {
+        const db = createStateDatabase(":memory:");
+        const port = createEmbodiedContextStatePort({
+            database: db,
+            goalStore: createGoalLifecycleStore(db),
+            identityStore: createIdentityProfileStore(db),
+            interactionProjector: createInteractionSnapshotProjector(db),
+            experienceStore: createToolExperienceStore(db),
+        });
+        const result = await port.loadAcceptedDreamProjection(3);
+        assert.strictEqual(result.status, "degraded");
+        if (result.status === "degraded") {
+            assert.strictEqual(result.reason, "context_degraded:dream_projection_unavailable");
+        }
+    });
+});

package/dist/tests/unit/storage/goal-lifecycle-store.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * T-SMS.C.3 — GoalLifecycleStore 单元测试
+ */
+export {};