@haaaiawd/second-nature 0.1.42 → 0.1.50

package/dist/tests/unit/storage/repair-gate.test.js

@@ -0,0 +1,41 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { eq } from "drizzle-orm";
+import { appendLifeEvidence, repairStateIndexes } from "../../../src/storage/index.js";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { lifeEvidenceIndex } from "../../../src/storage/db/schema/life-evidence-index.js";
+test("T4.1.3 repairStateIndexes backfills missing life_evidence_index rows", async () => {
+    const state = createStateDatabase(":memory:");
+    const ws = fs.mkdtempSync(path.join(os.tmpdir(), "sn-repair-"));
+    await appendLifeEvidence(state, ws, {
+        timestamp: new Date().toISOString(),
+        evidenceType: "platform_browse",
+        summary: "x",
+        sourceRefs: [{ id: "s1", kind: "platform_item", uri: "p://1" }],
+        sensitivity: "public",
+        producer: "connector-system",
+    });
+    const idRows = await state.db.select().from(lifeEvidenceIndex);
+    const evidenceId = idRows[0].id;
+    await state.db.delete(lifeEvidenceIndex).where(eq(lifeEvidenceIndex.id, evidenceId));
+    const repair = await repairStateIndexes(state, { startupGate: true, workspaceRoot: ws });
+    assert.equal(repair.status, "ok");
+    assert.ok(repair.repairedEvidenceIndexRows >= 1);
+    const again = await state.db.select().from(lifeEvidenceIndex).where(eq(lifeEvidenceIndex.id, evidenceId));
+    assert.equal(again.length, 1);
+    state.close();
+});
+test("T4.1.3 startupGate returns repair_required on corrupt evidence json", async () => {
+    const state = createStateDatabase(":memory:");
+    const ws = fs.mkdtempSync(path.join(os.tmpdir(), "sn-repair-bad-"));
+    const dir = path.join(ws, ".second-nature", "evidence");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "bad.json"), "{ not json", "utf-8");
+    const repair = await repairStateIndexes(state, { startupGate: true, workspaceRoot: ws });
+    assert.equal(repair.status, "repair_required");
+    assert.ok(repair.repairNotes.some((n) => n.startsWith("corrupt_evidence_json")));
+    state.close();
+});

package/dist/tests/unit/storage/restore-snapshot-store.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * RestoreSnapshotStore tests — T-SMS.C.6
+ *
+ * Coverage:
+ * - captureSnapshot with default whitelist
+ * - captureSnapshot filters out sensitive kinds
+ * - retention: only 3 most recent snapshots kept
+ * - loadLatestSnapshot returns most recent
+ * - listSnapshots orders by captured_at descending
+ */
+export {};

package/dist/tests/unit/storage/restore-snapshot-store.test.js

@@ -0,0 +1,161 @@
+/**
+ * RestoreSnapshotStore tests — T-SMS.C.6
+ *
+ * Coverage:
+ * - captureSnapshot with default whitelist
+ * - captureSnapshot filters out sensitive kinds
+ * - retention: only 3 most recent snapshots kept
+ * - loadLatestSnapshot returns most recent
+ * - listSnapshots orders by captured_at descending
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createRestoreSnapshotStore } from "../../../src/storage/services/restore-snapshot-store.js";
+describe("RestoreSnapshotStore", () => {
+    it("captureSnapshot with default whitelist includes all 6 kinds", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRestoreSnapshotStore(db, { retentionCount: 3 });
+        const snap = await store.captureSnapshot({
+            snapshotId: "snap-1",
+            payload: { foo: "bar" },
+        });
+        assert.strictEqual(snap.entityWhitelist.length, 6);
+        assert(snap.entityWhitelist.includes("identity_profile"));
+        assert(snap.entityWhitelist.includes("narrative_timeline"));
+        db.close();
+    });
+    it("captureSnapshot with custom whitelist filters to restorable kinds only", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRestoreSnapshotStore(db, { retentionCount: 3 });
+        const custom = ["identity_profile", "agent_goal"];
+        const snap = await store.captureSnapshot({
+            snapshotId: "snap-2",
+            entityWhitelist: custom,
+            payload: { test: true },
+        });
+        assert.deepStrictEqual(snap.entityWhitelist, custom);
+        db.close();
+    });
+    it("captureSnapshot excludes sensitive kinds by default", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRestoreSnapshotStore(db, { retentionCount: 3 });
+        const snap = await store.captureSnapshot({
+            snapshotId: "snap-3",
+            payload: {},
+        });
+        assert(snap.excludedSensitiveKinds.includes("credential"));
+        assert(snap.excludedSensitiveKinds.includes("encryption_key"));
+        assert(snap.excludedSensitiveKinds.includes("session_token"));
+        db.close();
+    });
+    it("retention trims oldest when exceeding limit", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRestoreSnapshotStore(db, { retentionCount: 3 });
+        for (let i = 1; i <= 4; i++) {
+            await store.captureSnapshot({
+                snapshotId: `snap-${i}`,
+                payload: { idx: i },
+                capturedAt: new Date(Date.now() + i * 1000).toISOString(),
+            });
+        }
+        const all = await store.listSnapshots(10);
+        assert.strictEqual(all.length, 3);
+        assert.deepStrictEqual(all.map((s) => s.snapshotId), ["snap-4", "snap-3", "snap-2"]);
+        db.close();
+    });
+    it("loadLatestSnapshot returns the most recent", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRestoreSnapshotStore(db, { retentionCount: 3 });
+        await store.captureSnapshot({
+            snapshotId: "snap-a",
+            payload: { v: 1 },
+            capturedAt: "2025-01-01T00:00:00Z",
+        });
+        await store.captureSnapshot({
+            snapshotId: "snap-b",
+            payload: { v: 2 },
+            capturedAt: "2025-01-02T00:00:00Z",
+        });
+        const latest = await store.loadLatestSnapshot();
+        assert.strictEqual(latest?.snapshotId, "snap-b");
+        assert.deepStrictEqual(latest?.payload, { v: 2 });
+        db.close();
+    });
+    it("loadLatestSnapshot returns undefined when empty", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRestoreSnapshotStore(db, { retentionCount: 3 });
+        const latest = await store.loadLatestSnapshot();
+        assert.strictEqual(latest, undefined);
+        db.close();
+    });
+    it("listSnapshots respects limit", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRestoreSnapshotStore(db, { retentionCount: 3 });
+        for (let i = 1; i <= 5; i++) {
+            await store.captureSnapshot({
+                snapshotId: `snap-${i}`,
+                payload: { idx: i },
+            });
+        }
+        const limited = await store.listSnapshots(2);
+        assert.strictEqual(limited.length, 2);
+        db.close();
+    });
+    it("applyBoundedRestore returns failure when no snapshot exists", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRestoreSnapshotStore(db, { retentionCount: 3 });
+        const result = await store.applyBoundedRestore({
+            restoreTarget: "missing-snap",
+            fromVersion: "v1",
+            toVersion: "v2",
+        });
+        assert.strictEqual(result.ok, false);
+        assert.deepStrictEqual(result.failedEntities, ["missing-snap"]);
+        assert(result.warnings.includes("snapshot_not_found"));
+        db.close();
+    });
+    it("applyBoundedRestore restores payload entities and excludes sensitive kinds", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRestoreSnapshotStore(db, { retentionCount: 3 });
+        // Seed identity_profile table so we can verify restore
+        db.sqlite.run(`INSERT INTO identity_profile (profile_id, canonical_name, platform_handles_json, updated_at)
+       VALUES (?, ?, ?, ?)`, ["p1", "Before", "[]", "2025-01-01T00:00:00Z"]);
+        await store.captureSnapshot({
+            snapshotId: "snap-restore-1",
+            payload: {
+                identity_profile: [
+                    { profile_id: "p1", canonical_name: "After", platform_handles_json: "[]", updated_at: "2025-06-01T00:00:00Z" },
+                ],
+                credential: [{ id: "c1", secret: "should-not-restore" }],
+            },
+        });
+        const result = await store.applyBoundedRestore({
+            restoreTarget: "snap-restore-1",
+            fromVersion: "v1",
+            toVersion: "v2",
+        });
+        assert.strictEqual(result.ok, true);
+        assert(result.completedEntities.includes("identity_profile"));
+        // Verify DB state was actually restored
+        const check = db.sqlite.exec(`SELECT canonical_name FROM identity_profile WHERE profile_id = 'p1'`);
+        assert.strictEqual(check[0].values[0][0], "After");
+        db.close();
+    });
+    it("applyBoundedRestore falls back to latest snapshot when exact id not found", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRestoreSnapshotStore(db, { retentionCount: 3 });
+        await store.captureSnapshot({
+            snapshotId: "latest-snap",
+            payload: { identity_profile: [{ profile_id: "p2", canonical_name: "Latest", platform_handles_json: "[]", updated_at: "2025-01-01T00:00:00Z" }] },
+        });
+        const result = await store.applyBoundedRestore({
+            restoreTarget: "nonexistent-id",
+            fromVersion: "v1",
+            toVersion: "v2",
+        });
+        assert.strictEqual(result.ok, true);
+        assert(result.completedEntities.includes("identity_profile"));
+        db.close();
+    });
+});

package/dist/tests/unit/storage/rhythm-policy-snapshot.test.d.ts

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

package/dist/tests/unit/storage/rhythm-policy-snapshot.test.js

@@ -0,0 +1,31 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { PolicyRepository } from "../../../src/storage/repositories/policy-repository.js";
+import { loadRhythmPolicySnapshot } from "../../../src/storage/rhythm/rhythm-policy-snapshot.js";
+test("loadRhythmPolicySnapshot returns defaults when no policy row exists", async () => {
+    const state = createStateDatabase(":memory:");
+    const snap = await loadRhythmPolicySnapshot(state);
+    assert.equal(typeof snap.quietEnabled, "boolean");
+    assert.equal(typeof snap.socialDailyLimit, "number");
+    assert.equal(typeof snap.outreachDailyBudget, "number");
+    assert.equal("allowedIntentKinds" in snap, false);
+    state.close();
+});
+test("loadRhythmPolicySnapshot reads workspace policy without decision fields", async () => {
+    const state = createStateDatabase(":memory:");
+    const policies = new PolicyRepository(state);
+    await policies.upsert({
+        platformId: "workspace",
+        socialDailyLimit: 3,
+        quietEnabled: false,
+        outreachDailyBudget: 4,
+        updatedAt: new Date().toISOString(),
+    });
+    const snap = await loadRhythmPolicySnapshot(state);
+    assert.equal(snap.socialDailyLimit, 3);
+    assert.equal(snap.quietEnabled, false);
+    assert.equal(snap.outreachDailyBudget, 4);
+    assert.equal("allowedIntentKinds" in snap, false);
+    state.close();
+});

package/dist/tests/unit/storage/runtime-secret-anchor-store.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * RuntimeSecretAnchorStore tests — T-SMS.C.6
+ *
+ * Coverage:
+ * - upsertAnchor stores locationRef/health/rotationPolicyRef
+ * - upsertAnchor rejects payload with key plaintext (gate)
+ * - loadAnchor returns stored record
+ * - listAnchors returns all ordered by updated_at DESC
+ */
+export {};

package/dist/tests/unit/storage/runtime-secret-anchor-store.test.js

@@ -0,0 +1,81 @@
+/**
+ * RuntimeSecretAnchorStore tests — T-SMS.C.6
+ *
+ * Coverage:
+ * - upsertAnchor stores locationRef/health/rotationPolicyRef
+ * - upsertAnchor rejects payload with key plaintext (gate)
+ * - loadAnchor returns stored record
+ * - listAnchors returns all ordered by updated_at DESC
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createRuntimeSecretAnchorStore } from "../../../src/storage/services/runtime-secret-anchor-store.js";
+describe("RuntimeSecretAnchorStore", () => {
+    it("upsertAnchor stores and updates", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRuntimeSecretAnchorStore(db);
+        await store.upsertAnchor({
+            anchorId: "anchor-1",
+            locationRef: "vault://secret-a",
+            health: "ok",
+            rotationPolicyRef: "policy://rotate-30d",
+            updatedAt: "2025-01-01T00:00:00Z",
+        });
+        const loaded = await store.loadAnchor("anchor-1");
+        assert.strictEqual(loaded.locationRef, "vault://secret-a");
+        assert.strictEqual(loaded.health, "ok");
+        assert.strictEqual(loaded.rotationPolicyRef, "policy://rotate-30d");
+        // Update
+        await store.upsertAnchor({
+            anchorId: "anchor-1",
+            locationRef: "vault://secret-a-v2",
+            health: "rotation_needed",
+            updatedAt: "2025-02-01T00:00:00Z",
+        });
+        const updated = await store.loadAnchor("anchor-1");
+        assert.strictEqual(updated.locationRef, "vault://secret-a-v2");
+        assert.strictEqual(updated.health, "rotation_needed");
+        assert.strictEqual(updated.rotationPolicyRef, undefined);
+        db.close();
+    });
+    it("upsertAnchor rejects key plaintext via gate", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRuntimeSecretAnchorStore(db);
+        await assert.rejects(store.upsertAnchor({
+            anchorId: "anchor-bad",
+            locationRef: "vault://sk-abcdefghijklmnopqrstuvwxyz123456",
+            health: "ok",
+            updatedAt: "2025-01-01T00:00:00Z",
+        }), /write_validation_failed/);
+        db.close();
+    });
+    it("loadAnchor returns undefined for missing", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRuntimeSecretAnchorStore(db);
+        const loaded = await store.loadAnchor("missing");
+        assert.strictEqual(loaded, undefined);
+        db.close();
+    });
+    it("listAnchors returns all", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createRuntimeSecretAnchorStore(db);
+        await store.upsertAnchor({
+            anchorId: "a1",
+            locationRef: "vault://1",
+            health: "ok",
+            updatedAt: "2025-01-01T00:00:00Z",
+        });
+        await store.upsertAnchor({
+            anchorId: "a2",
+            locationRef: "vault://2",
+            health: "missing",
+            updatedAt: "2025-01-02T00:00:00Z",
+        });
+        const list = await store.listAnchors();
+        assert.strictEqual(list.length, 2);
+        assert.strictEqual(list[0].anchorId, "a2");
+        assert.strictEqual(list[1].anchorId, "a1");
+        db.close();
+    });
+});

package/dist/tests/unit/storage/t1-4-1-credential-health-mapper.test.d.ts

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

package/dist/tests/unit/storage/t1-4-1-credential-health-mapper.test.js

@@ -0,0 +1,83 @@
+/**
+ * T1.4.1 — Credential health mapper unit tests.
+ *
+ * Covers probeCredentialHealth boundary behaviours:
+ * - missing key + no encrypted value → missing / missing_key
+ * - missing key + encrypted value → decrypt_failed / missing_key
+ * - valid key + correct ciphertext → active / ok
+ * - valid key + wrong ciphertext → decrypt_failed / wrong_key
+ * - valid key + no encrypted value → missing / ok
+ * - baseUrl presence tracking
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { probeCredentialHealth } from "../../../src/storage/services/credential-vault.js";
+import { encryptCredentialAtRest } from "../../../src/storage/services/credential-vault.js";
+const ORIGINAL_KEY = process.env.SECOND_NATURE_ENCRYPTION_KEY;
+function setKey(key) {
+    if (key === undefined) {
+        delete process.env.SECOND_NATURE_ENCRYPTION_KEY;
+    }
+    else {
+        process.env.SECOND_NATURE_ENCRYPTION_KEY = key;
+    }
+}
+test.afterEach(() => {
+    setKey(ORIGINAL_KEY);
+});
+test("T1.4.1-A: missing key + no encrypted value → missing / missing_key", () => {
+    setKey(undefined);
+    const probe = probeCredentialHealth("moltbook", undefined, "https://example.com");
+    assert.equal(probe.state, "missing");
+    assert.equal(probe.keyHealth, "missing_key");
+    assert.equal(probe.diagnosticCode, "missing_runtime_secret");
+    assert.equal(probe.hasBaseUrl, true);
+});
+test("T1.4.1-B: missing key + encrypted value → decrypt_failed / missing_key", () => {
+    // Encrypt with a valid key first, then remove the key to simulate missing-key scenario.
+    setKey("z".repeat(32));
+    const encrypted = encryptCredentialAtRest("secret");
+    setKey(undefined);
+    const probe = probeCredentialHealth("moltbook", encrypted, undefined);
+    assert.equal(probe.state, "decrypt_failed");
+    assert.equal(probe.keyHealth, "missing_key");
+    assert.equal(probe.diagnosticCode, "missing_runtime_secret");
+    assert.equal(probe.hasBaseUrl, false);
+});
+test("T1.4.1-C: valid key + correct ciphertext → active / ok", () => {
+    setKey("a".repeat(32));
+    const encrypted = encryptCredentialAtRest("secret");
+    const probe = probeCredentialHealth("moltbook", encrypted, "https://example.com");
+    assert.equal(probe.state, "active");
+    assert.equal(probe.keyHealth, "ok");
+    assert.equal(probe.diagnosticCode, "ok");
+    assert.equal(probe.hasBaseUrl, true);
+});
+test("T1.4.1-D: valid key + wrong ciphertext → decrypt_failed / wrong_key", () => {
+    setKey("a".repeat(32));
+    // Encrypt with one key, then change to another
+    const encrypted = encryptCredentialAtRest("secret");
+    setKey("b".repeat(32));
+    const probe = probeCredentialHealth("moltbook", encrypted, "https://example.com");
+    assert.equal(probe.state, "decrypt_failed");
+    assert.equal(probe.keyHealth, "wrong_key");
+    assert.equal(probe.diagnosticCode, "credential_recovery_required");
+});
+test("T1.4.1-E: valid key + no encrypted value → missing / ok", () => {
+    setKey("a".repeat(32));
+    const probe = probeCredentialHealth("moltbook", undefined, undefined);
+    assert.equal(probe.state, "missing");
+    assert.equal(probe.keyHealth, "ok");
+    assert.equal(probe.diagnosticCode, "ok");
+    assert.equal(probe.hasBaseUrl, false);
+});
+test("T1.4.1-F: baseUrl missing tracked independently", () => {
+    setKey("a".repeat(32));
+    const encrypted = encryptCredentialAtRest("secret");
+    const probeWithBase = probeCredentialHealth("moltbook", encrypted, "https://example.com");
+    const probeWithoutBase = probeCredentialHealth("moltbook", encrypted, undefined);
+    assert.equal(probeWithBase.hasBaseUrl, true);
+    assert.equal(probeWithoutBase.hasBaseUrl, false);
+    assert.equal(probeWithBase.state, "active");
+    assert.equal(probeWithoutBase.state, "active");
+});

package/dist/tests/unit/storage/t4-1-1-session-chronicle.test.d.ts

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

package/dist/tests/unit/storage/t4-1-1-session-chronicle.test.js

@@ -0,0 +1,112 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createSessionChronicleStore, } from "../../../src/storage/chronicle/session-chronicle-store.js";
+function makeEntry(overrides = {}) {
+    return {
+        entryId: `entry-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+        eventKind: "heartbeat",
+        actor: "agent",
+        occurredAt: new Date().toISOString(),
+        summary: "test summary",
+        result: "succeeded",
+        sourceRefs: [{ sourceId: "src-1", kind: "test" }],
+        ...overrides,
+    };
+}
+test("appendSessionChronicle writes and returns ack", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createSessionChronicleStore(db);
+    const entry = makeEntry();
+    const ack = await store.appendSessionChronicle(entry);
+    assert.equal(ack.entryId, entry.entryId);
+    assert.equal(ack.status, "acknowledged");
+});
+test("loadSessionChronicle returns appended entries", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createSessionChronicleStore(db);
+    const entry = makeEntry({ eventKind: "connector_action", summary: "action A" });
+    await store.appendSessionChronicle(entry);
+    const results = await store.loadSessionChronicle({});
+    assert.equal(results.length, 1);
+    assert.equal(results[0].entryId, entry.entryId);
+    assert.equal(results[0].eventKind, "connector_action");
+    assert.equal(results[0].summary, "action A");
+    assert.equal(results[0].sourceRefs.length, 1);
+    assert.equal(results[0].sourceRefs[0].sourceId, "src-1");
+});
+test("loadSessionChronicle filters by eventKind", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createSessionChronicleStore(db);
+    await store.appendSessionChronicle(makeEntry({ eventKind: "heartbeat" }));
+    await store.appendSessionChronicle(makeEntry({ eventKind: "outreach" }));
+    await store.appendSessionChronicle(makeEntry({ eventKind: "dream_run" }));
+    const results = await store.loadSessionChronicle({ eventKinds: ["heartbeat", "outreach"] });
+    assert.equal(results.length, 2);
+    assert.ok(results.some((r) => r.eventKind === "heartbeat"));
+    assert.ok(results.some((r) => r.eventKind === "outreach"));
+    assert.ok(!results.some((r) => r.eventKind === "dream_run"));
+});
+test("loadSessionChronicle filters by actor", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createSessionChronicleStore(db);
+    await store.appendSessionChronicle(makeEntry({ actor: "agent" }));
+    await store.appendSessionChronicle(makeEntry({ actor: "owner" }));
+    const results = await store.loadSessionChronicle({ actor: "owner" });
+    assert.equal(results.length, 1);
+    assert.equal(results[0].actor, "owner");
+});
+test("loadSessionChronicle respects limit", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createSessionChronicleStore(db);
+    for (let i = 0; i < 5; i++) {
+        await store.appendSessionChronicle(makeEntry({ occurredAt: new Date(Date.now() + i * 1000).toISOString() }));
+    }
+    const results = await store.loadSessionChronicle({ limit: 2 });
+    assert.equal(results.length, 2);
+});
+test("loadSessionChronicle orders by occurredAt descending", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createSessionChronicleStore(db);
+    const t1 = new Date(Date.now() - 2000).toISOString();
+    const t2 = new Date(Date.now() - 1000).toISOString();
+    const t3 = new Date(Date.now()).toISOString();
+    await store.appendSessionChronicle(makeEntry({ occurredAt: t1 }));
+    await store.appendSessionChronicle(makeEntry({ occurredAt: t3 }));
+    await store.appendSessionChronicle(makeEntry({ occurredAt: t2 }));
+    const results = await store.loadSessionChronicle({});
+    assert.equal(results.length, 3);
+    assert.equal(results[0].occurredAt, t3);
+    assert.equal(results[1].occurredAt, t2);
+    assert.equal(results[2].occurredAt, t1);
+});
+test("loadSessionChronicle filters by date range", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createSessionChronicleStore(db);
+    await store.appendSessionChronicle(makeEntry({ occurredAt: "2026-05-10T00:00:00Z" }));
+    await store.appendSessionChronicle(makeEntry({ occurredAt: "2026-05-15T00:00:00Z" }));
+    await store.appendSessionChronicle(makeEntry({ occurredAt: "2026-05-20T00:00:00Z" }));
+    const results = await store.loadSessionChronicle({
+        from: "2026-05-12T00:00:00Z",
+        to: "2026-05-18T00:00:00Z",
+    });
+    assert.equal(results.length, 1);
+    assert.equal(results[0].occurredAt, "2026-05-15T00:00:00Z");
+});
+test("ownerReply and related ids survive roundtrip", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createSessionChronicleStore(db);
+    const entry = makeEntry({
+        eventKind: "owner_reply",
+        actor: "owner",
+        relatedDecisionId: "dec-1",
+        relatedDreamRunId: "dream-1",
+        ownerReply: { tone: "casual", delayMinutes: 30, topics: ["dev"], explicitPreference: "quiet" },
+    });
+    await store.appendSessionChronicle(entry);
+    const results = await store.loadSessionChronicle({});
+    assert.equal(results.length, 1);
+    assert.equal(results[0].relatedDecisionId, "dec-1");
+    assert.equal(results[0].relatedDreamRunId, "dream-1");
+    assert.deepEqual(results[0].ownerReply, entry.ownerReply);
+});

package/dist/tests/unit/storage/t4-1-2-narrative-state.test.d.ts

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

package/dist/tests/unit/storage/t4-1-2-narrative-state.test.js

@@ -0,0 +1,80 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createNarrativeStateStore, } from "../../../src/storage/narrative/narrative-state-store.js";
+function makeUpdate(overrides = {}) {
+    return {
+        narrativeId: "default",
+        revision: 1,
+        focus: "Building connector ecosystem",
+        progress: ["T3.1.1 registry"],
+        nextIntent: "T3.1.2 capability registry",
+        confidence: 0.85,
+        sourceRefs: [{ sourceId: "evidence-1", kind: "heartbeat" }],
+        unsupportedClaims: [],
+        status: "active",
+        updatedAt: new Date().toISOString(),
+        ...overrides,
+    };
+}
+test("updateNarrativeState writes and load returns complete state", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createNarrativeStateStore(db);
+    const update = makeUpdate();
+    const ack = await store.updateNarrativeState(update);
+    assert.equal(ack.narrativeId, "default");
+    assert.equal(ack.status, "acknowledged");
+    const loaded = await store.loadNarrativeState();
+    assert.ok(loaded);
+    assert.equal(loaded.focus, "Building connector ecosystem");
+    assert.equal(loaded.status, "active");
+    assert.equal(loaded.progress.length, 1);
+    assert.equal(loaded.sourceRefs[0].sourceId, "evidence-1");
+});
+test("unsupportedClaims non-empty retains status", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createNarrativeStateStore(db);
+    const update = makeUpdate({
+        unsupportedClaims: ["claim without source"],
+        status: "insufficient_sources",
+    });
+    await store.updateNarrativeState(update);
+    const loaded = await store.loadNarrativeState();
+    assert.ok(loaded);
+    assert.equal(loaded.status, "insufficient_sources");
+    assert.equal(loaded.unsupportedClaims.length, 1);
+});
+test("awaiting_sources status survives roundtrip", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createNarrativeStateStore(db);
+    const update = makeUpdate({ status: "awaiting_sources" });
+    await store.updateNarrativeState(update);
+    const loaded = await store.loadNarrativeState();
+    assert.equal(loaded.status, "awaiting_sources");
+});
+test("update bumps revision and changes fields", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createNarrativeStateStore(db);
+    await store.updateNarrativeState(makeUpdate({ revision: 1, focus: "A" }));
+    await store.updateNarrativeState(makeUpdate({ revision: 2, focus: "B", nextIntent: "C" }));
+    const loaded = await store.loadNarrativeState();
+    assert.equal(loaded.revision, 2);
+    assert.equal(loaded.focus, "B");
+    assert.equal(loaded.nextIntent, "C");
+});
+test("loadNarrativeState returns null when nothing written", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createNarrativeStateStore(db);
+    const loaded = await store.loadNarrativeState("missing");
+    assert.equal(loaded, null);
+});
+test("updateNarrativeState with custom narrativeId", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createNarrativeStateStore(db);
+    await store.updateNarrativeState(makeUpdate({ narrativeId: "custom-1", focus: "Custom" }));
+    const loadedDefault = await store.loadNarrativeState("default");
+    const loadedCustom = await store.loadNarrativeState("custom-1");
+    assert.equal(loadedDefault, null);
+    assert.ok(loadedCustom);
+    assert.equal(loadedCustom.focus, "Custom");
+});

package/dist/tests/unit/storage/t4-1-3-relationship-memory.test.d.ts

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