@haaaiawd/second-nature 0.1.50 → 0.1.51

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

@@ -1,41 +0,0 @@
-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

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,161 +0,0 @@
-/**
- * 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

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

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

@@ -1,31 +0,0 @@
-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

@@ -1,10 +0,0 @@
-/**
- * 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

@@ -1,81 +0,0 @@
-/**
- * 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

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

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

@@ -1,83 +0,0 @@
-/**
- * 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

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

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

@@ -1,112 +0,0 @@
-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

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

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

@@ -1,80 +0,0 @@
-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

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