@haaaiawd/second-nature 0.1.43 → 0.1.50

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

@@ -0,0 +1,65 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createRelationshipMemoryStore, } from "../../../src/storage/relationship/relationship-memory-store.js";
+function makeUpdate(overrides = {}) {
+    return {
+        relationshipId: "default",
+        revision: 1,
+        tonePreference: "casual",
+        averageReplyDelayMinutes: 15,
+        noReplyCount: 0,
+        topicAffinities: [{ topic: "coding", affinity: 0.9 }],
+        lastInteractionAt: new Date().toISOString(),
+        sourceRefs: [{ sourceId: "reply-1", kind: "owner_reply" }],
+        updatedAt: new Date().toISOString(),
+        ...overrides,
+    };
+}
+test("upsertRelationshipMemory writes and load returns complete memory", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createRelationshipMemoryStore(db);
+    const update = makeUpdate();
+    const ack = await store.upsertRelationshipMemory(update);
+    assert.equal(ack.relationshipId, "default");
+    const loaded = await store.loadRelationshipMemory();
+    assert.ok(loaded);
+    assert.equal(loaded.tonePreference, "casual");
+    assert.equal(loaded.averageReplyDelayMinutes, 15);
+    assert.equal(loaded.topicAffinities[0].topic, "coding");
+    assert.equal(loaded.sourceRefs[0].sourceId, "reply-1");
+});
+test("noReplyCount increment records cooldown without invented preference", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createRelationshipMemoryStore(db);
+    await store.upsertRelationshipMemory(makeUpdate({ noReplyCount: 0 }));
+    await store.upsertRelationshipMemory(makeUpdate({ noReplyCount: 1, averageReplyDelayMinutes: undefined }));
+    const loaded = await store.loadRelationshipMemory();
+    assert.ok(loaded);
+    assert.equal(loaded.noReplyCount, 1);
+    assert.equal(loaded.averageReplyDelayMinutes, undefined);
+    // tonePreference should still be what was recorded, not invented
+    assert.equal(loaded.tonePreference, "casual");
+});
+test("unknown tonePreference when insufficient history", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createRelationshipMemoryStore(db);
+    await store.upsertRelationshipMemory(makeUpdate({ tonePreference: "unknown", topicAffinities: [] }));
+    const loaded = await store.loadRelationshipMemory();
+    assert.equal(loaded.tonePreference, "unknown");
+});
+test("upsert bumps revision and updates topicAffinities", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createRelationshipMemoryStore(db);
+    await store.upsertRelationshipMemory(makeUpdate({ revision: 1, topicAffinities: [{ topic: "a", affinity: 0.5 }] }));
+    await store.upsertRelationshipMemory(makeUpdate({ revision: 2, topicAffinities: [{ topic: "a", affinity: 0.8 }, { topic: "b", affinity: 0.3 }] }));
+    const loaded = await store.loadRelationshipMemory();
+    assert.equal(loaded.revision, 2);
+    assert.equal(loaded.topicAffinities.length, 2);
+});
+test("loadRelationshipMemory returns null when nothing written", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createRelationshipMemoryStore(db);
+    const loaded = await store.loadRelationshipMemory("missing");
+    assert.equal(loaded, null);
+});

package/dist/tests/unit/storage/t4-1-4-agent-goal.test.d.ts

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

package/dist/tests/unit/storage/t4-1-4-agent-goal.test.js

@@ -0,0 +1,166 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createAgentGoalStore, } from "../../../src/storage/goal/agent-goal-store.js";
+function makeGoal(overrides = {}) {
+    return {
+        goalId: `goal-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+        kind: "short_term",
+        status: "proposal",
+        origin: "agent_proposed",
+        description: "Improve connector onboarding",
+        completionCriteria: "Manifest scan passes all tests",
+        risk: "low",
+        priorityHint: 5,
+        sourceRefs: [{ sourceId: "dream-1", kind: "insight" }],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        ...overrides,
+    };
+}
+test("owner-set goal is accepted on write", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createAgentGoalStore(db);
+    const goal = makeGoal({ origin: "owner_set", status: "accepted", acceptedBy: "owner" });
+    const ack = await store.upsertAgentGoal(goal);
+    assert.equal(ack.goalId, goal.goalId);
+    const loaded = await store.loadAgentGoal(goal.goalId);
+    assert.ok(loaded);
+    assert.equal(loaded.status, "accepted");
+    assert.equal(loaded.acceptedBy, "owner");
+    assert.equal(loaded.origin, "owner_set");
+});
+test("agent-proposed goal remains proposal by default", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createAgentGoalStore(db);
+    const goal = makeGoal({ origin: "agent_proposed", status: "proposal" });
+    await store.upsertAgentGoal(goal);
+    const loaded = await store.loadAgentGoal(goal.goalId);
+    assert.equal(loaded.status, "proposal");
+    assert.equal(loaded.acceptedBy, undefined);
+});
+test("transitionGoalStatus from proposal to accepted with policy_allowlist", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createAgentGoalStore(db);
+    const goal = makeGoal({ origin: "agent_proposed", status: "proposal" });
+    await store.upsertAgentGoal(goal);
+    const transition = {
+        goalId: goal.goalId,
+        newStatus: "accepted",
+        acceptedBy: "policy_allowlist",
+        updatedAt: new Date().toISOString(),
+    };
+    const ack = await store.transitionGoalStatus(transition);
+    assert.equal(ack.status, "acknowledged");
+    const loaded = await store.loadAgentGoal(goal.goalId);
+    assert.equal(loaded.status, "accepted");
+    assert.equal(loaded.acceptedBy, "policy_allowlist");
+});
+test("transitionGoalStatus rejects proposal back to rejected", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createAgentGoalStore(db);
+    const goal = makeGoal({ origin: "agent_proposed", status: "proposal" });
+    await store.upsertAgentGoal(goal);
+    await store.transitionGoalStatus({
+        goalId: goal.goalId,
+        newStatus: "rejected",
+        updatedAt: new Date().toISOString(),
+    });
+    const loaded = await store.loadAgentGoal(goal.goalId);
+    assert.equal(loaded.status, "rejected");
+});
+test("listAgentGoals filters by status", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createAgentGoalStore(db);
+    const g1 = makeGoal({ status: "accepted", origin: "owner_set", scope: "global" });
+    const g2 = makeGoal({ status: "proposal", origin: "agent_proposed", scope: "moltbook" });
+    const g3 = makeGoal({ status: "completed", origin: "owner_set", scope: "instreet" });
+    await store.upsertAgentGoal(g1);
+    await store.upsertAgentGoal(g2);
+    await store.upsertAgentGoal(g3);
+    const accepted = await store.listAgentGoals({ statuses: ["accepted"] });
+    assert.equal(accepted.length, 1);
+    assert.equal(accepted[0].goalId, g1.goalId);
+    const active = await store.listAgentGoals({ statuses: ["accepted", "proposal"] });
+    assert.equal(active.length, 2);
+});
+test("listAgentGoals filters by origin", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createAgentGoalStore(db);
+    const g1 = makeGoal({ origin: "owner_set" });
+    const g2 = makeGoal({ origin: "agent_proposed" });
+    await store.upsertAgentGoal(g1);
+    await store.upsertAgentGoal(g2);
+    const ownerSet = await store.listAgentGoals({ origins: ["owner_set"] });
+    assert.equal(ownerSet.length, 1);
+    assert.equal(ownerSet[0].origin, "owner_set");
+});
+test("loadAgentGoal returns null for missing goal", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createAgentGoalStore(db);
+    const loaded = await store.loadAgentGoal("missing");
+    assert.equal(loaded, null);
+});
+test("goal update preserves createdAt and changes updatedAt", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createAgentGoalStore(db);
+    const created = new Date(Date.now() - 86400000).toISOString();
+    const goal = makeGoal({ createdAt: created, updatedAt: created });
+    await store.upsertAgentGoal(goal);
+    const updated = new Date().toISOString();
+    await store.upsertAgentGoal({ ...goal, description: "Updated", updatedAt: updated });
+    const loaded = await store.loadAgentGoal(goal.goalId);
+    assert.equal(loaded.createdAt, created);
+    assert.equal(loaded.updatedAt, updated);
+    assert.equal(loaded.description, "Updated");
+});
+// ─── T-V7C.C.4: goal dedupe ────────────────────────────────────────────────
+test("upsert accepted goal marks old same-kind-scope as replaced", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createAgentGoalStore(db);
+    const oldGoal = makeGoal({ status: "accepted", origin: "owner_set", scope: "global", acceptedBy: "owner" });
+    const newGoal = makeGoal({ status: "accepted", origin: "owner_set", scope: "global", acceptedBy: "owner" });
+    await store.upsertAgentGoal(oldGoal);
+    await store.upsertAgentGoal(newGoal);
+    const oldLoaded = await store.loadAgentGoal(oldGoal.goalId);
+    assert.equal(oldLoaded.status, "replaced");
+    const newLoaded = await store.loadAgentGoal(newGoal.goalId);
+    assert.equal(newLoaded.status, "accepted");
+});
+test("upsert accepted goal does NOT replace different scope", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createAgentGoalStore(db);
+    const globalGoal = makeGoal({ status: "accepted", scope: "global", acceptedBy: "owner" });
+    const platformGoal = makeGoal({ status: "accepted", scope: "moltbook", acceptedBy: "owner" });
+    await store.upsertAgentGoal(globalGoal);
+    await store.upsertAgentGoal(platformGoal);
+    const globalLoaded = await store.loadAgentGoal(globalGoal.goalId);
+    assert.equal(globalLoaded.status, "accepted");
+    const platformLoaded = await store.loadAgentGoal(platformGoal.goalId);
+    assert.equal(platformLoaded.status, "accepted");
+});
+test("listAgentGoals dedupes by kind+scope keeping newest", async () => {
+    const db = createStateDatabase(":memory:");
+    const store = createAgentGoalStore(db);
+    const now = Date.now();
+    const oldGoal = makeGoal({
+        status: "accepted", scope: "global", acceptedBy: "owner",
+        updatedAt: new Date(now - 1000).toISOString(),
+    });
+    const newGoal = makeGoal({
+        status: "accepted", scope: "global", acceptedBy: "owner",
+        updatedAt: new Date(now).toISOString(),
+    });
+    // Insert old as "replaced" manually to simulate a race condition where DB still has both accepted
+    await store.upsertAgentGoal(oldGoal);
+    await store.upsertAgentGoal(newGoal);
+    // Force old back to accepted to test listAgentGoals dedupe
+    await store.transitionGoalStatus({
+        goalId: oldGoal.goalId,
+        newStatus: "accepted",
+        updatedAt: oldGoal.updatedAt,
+    });
+    const listed = await store.listAgentGoals({ statuses: ["accepted"] });
+    assert.equal(listed.length, 1);
+    assert.equal(listed[0].goalId, newGoal.goalId);
+});

package/dist/tests/unit/storage/tool-experience-store.test.d.ts

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

package/dist/tests/unit/storage/tool-experience-store.test.js

@@ -0,0 +1,92 @@
+/**
+ * T-SMS.C.5 — ToolExperienceStore + CapabilityProbeResultStore 单元测试
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createToolExperienceStore, createCapabilityProbeResultStore, } from "../../../src/storage/services/tool-experience-store.js";
+describe("ToolExperienceStore", () => {
+    it("appends and lists tool experience", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createToolExperienceStore(db);
+        await store.appendToolExperience({
+            experienceId: "exp-1",
+            connectorId: "moltbook",
+            capabilityId: "feed.read",
+            outcome: "failure",
+            failureClass: "http_404",
+            latencyMs: 120,
+            evidenceQuality: 0,
+            sourceRefs: ["probe:result-1"],
+            triggerSource: "probe",
+            createdAt: "2026-05-21T00:00:00Z",
+        });
+        const rows = await store.listToolExperience({ connectorId: "moltbook" });
+        assert.strictEqual(rows.length, 1);
+        assert.strictEqual(rows[0].failureClass, "http_404");
+        assert.strictEqual(rows[0].triggerSource, "probe");
+    });
+    it("rejects raw payload through gate", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createToolExperienceStore(db);
+        await assert.rejects(store.appendToolExperience({
+            experienceId: "exp-bad",
+            connectorId: "x",
+            capabilityId: "x",
+            outcome: "success",
+            latencyMs: 0,
+            evidenceQuality: 0,
+            sourceRefs: ["ref:1"],
+            triggerSource: "heartbeat",
+            createdAt: "2026-05-21T00:00:00Z",
+            credential: "secret", // sensitive field
+        }));
+    });
+});
+describe("CapabilityProbeResultStore", () => {
+    it("appends and lists probe results", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createCapabilityProbeResultStore(db);
+        await store.appendProbeResult({
+            probeResultId: "probe-1",
+            capabilityId: "moltbook:feed.read",
+            connectorId: "moltbook",
+            actualStatus: "available",
+            httpStatus: 200,
+            sampleResponseRef: "ref:1",
+            probeConfigRef: "cfg:1",
+            createdAt: "2026-05-21T00:00:00Z",
+        });
+        const rows = await store.listProbeResults("moltbook");
+        assert.strictEqual(rows.length, 1);
+        assert.strictEqual(rows[0].actualStatus, "available");
+        assert.strictEqual(rows[0].httpStatus, 200);
+    });
+    it("upserts duplicate probe result ids instead of crashing", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createCapabilityProbeResultStore(db);
+        await store.appendProbeResult({
+            probeResultId: "probe-repeat",
+            capabilityId: "moltbook:feed.read",
+            connectorId: "moltbook",
+            actualStatus: "degraded",
+            httpStatus: 503,
+            probeConfigRef: "cfg:old",
+            createdAt: "2026-05-21T00:00:00Z",
+        });
+        await store.appendProbeResult({
+            probeResultId: "probe-repeat",
+            capabilityId: "moltbook:feed.read",
+            connectorId: "moltbook",
+            actualStatus: "available",
+            httpStatus: 200,
+            probeConfigRef: "cfg:new",
+            createdAt: "2026-05-21T00:01:00Z",
+        });
+        const rows = await store.listProbeResults("moltbook");
+        assert.strictEqual(rows.length, 1);
+        assert.strictEqual(rows[0].actualStatus, "available");
+        assert.strictEqual(rows[0].httpStatus, 200);
+        assert.strictEqual(rows[0].probeConfigRef, "cfg:new");
+    });
+});

package/dist/tests/unit/storage/user-interest-snapshot.test.d.ts

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

package/dist/tests/unit/storage/user-interest-snapshot.test.js

@@ -0,0 +1,48 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { loadUserInterestSnapshot } from "../../../src/storage/user-interest/load-user-interest-snapshot.js";
+const anchorBody = "# Profile\n" + "x".repeat(40);
+test("T4.2.2 missing anchors and curated → insufficient + missing_user_interest_model", async () => {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "sn-interest-"));
+    const snap = await loadUserInterestSnapshot(dir);
+    assert.equal(snap.staleness, "insufficient");
+    assert.equal(snap.confidence, 0);
+    assert.ok(snap.missingReasons?.includes("missing_user_interest_model"));
+    assert.equal(snap.signals.length, 0);
+    await fs.rm(dir, { recursive: true, force: true });
+});
+test("T4.2.2 USER.md + MEMORY.md anchors yield fresh snapshot with source-backed signals", async () => {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "sn-interest-"));
+    await fs.writeFile(path.join(dir, "USER.md"), anchorBody, "utf-8");
+    await fs.writeFile(path.join(dir, "MEMORY.md"), anchorBody, "utf-8");
+    const snap = await loadUserInterestSnapshot(dir);
+    assert.equal(snap.staleness, "fresh");
+    assert.ok(snap.confidence > 0);
+    assert.ok(snap.signals.length >= 2);
+    assert.ok(snap.signals.every((s) => s.sourceRefs.length > 0));
+    assert.ok(snap.sourceRefs.length > 0);
+    await fs.rm(dir, { recursive: true, force: true });
+});
+test("T4.2.2 stale mtime on anchors yields staleness stale", async () => {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "sn-interest-"));
+    const userPath = path.join(dir, "USER.md");
+    await fs.writeFile(userPath, anchorBody, "utf-8");
+    const old = new Date("2020-01-01T00:00:00Z");
+    await fs.utimes(userPath, old, old);
+    const snap = await loadUserInterestSnapshot(dir);
+    assert.equal(snap.staleness, "stale");
+    assert.ok(snap.signals.length >= 1);
+    await fs.rm(dir, { recursive: true, force: true });
+});
+test("T4.2.2 curated memory file alone can produce signals", async () => {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "sn-interest-"));
+    await fs.mkdir(path.join(dir, "memory", "curated"), { recursive: true });
+    await fs.writeFile(path.join(dir, "memory", "curated", "note.md"), anchorBody, "utf-8");
+    const snap = await loadUserInterestSnapshot(dir);
+    assert.equal(snap.staleness, "fresh");
+    assert.ok(snap.signals.some((s) => s.topic.startsWith("curated:")));
+    await fs.rm(dir, { recursive: true, force: true });
+});

package/dist/tests/unit/storage/write-queue.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * T-SMS.F.3 — Write Queue unit tests.
+ *
+ * Verification (05A / 05B):
+ * - Concurrent writes serialize correctly
+ * - Flush failure writes to stderr, read path unblocked
+ * - triggerSource preserved through pipeline
+ * - Retry on busy errors
+ *
+ * Dependencies: sql.js, src/storage/db/write-queue.ts
+ */
+export {};

package/dist/tests/unit/storage/write-queue.test.js

@@ -0,0 +1,177 @@
+/**
+ * T-SMS.F.3 — Write Queue unit tests.
+ *
+ * Verification (05A / 05B):
+ * - Concurrent writes serialize correctly
+ * - Flush failure writes to stderr, read path unblocked
+ * - triggerSource preserved through pipeline
+ * - Retry on busy errors
+ *
+ * Dependencies: sql.js, src/storage/db/write-queue.ts
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import initSqlJs from "sql.js";
+import { createWriteQueue, } from "../../../src/storage/db/write-queue.js";
+async function createMemoryDb() {
+    const SQL = await initSqlJs();
+    const db = new SQL.Database();
+    db.exec(`
+    CREATE TABLE test_writes (
+      id TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      trigger_source TEXT NOT NULL
+    );
+  `);
+    return db;
+}
+describe("write-queue", () => {
+    it("serializes concurrent write requests", async () => {
+        const sqlite = await createMemoryDb();
+        const queue = createWriteQueue(sqlite);
+        const order = [];
+        const req1 = {
+            label: "write-1",
+            triggerSource: "heartbeat",
+            execute: (db) => {
+                db.exec("INSERT INTO test_writes (id, value, trigger_source) VALUES ('w1', 'first', 'heartbeat')");
+                order.push(1);
+            },
+        };
+        const req2 = {
+            label: "write-2",
+            triggerSource: "manual_run",
+            execute: (db) => {
+                db.exec("INSERT INTO test_writes (id, value, trigger_source) VALUES ('w2', 'second', 'manual_run')");
+                order.push(2);
+            },
+        };
+        // Enqueue both simultaneously
+        const [r1, r2] = await Promise.all([
+            queue.enqueue(req1),
+            queue.enqueue(req2),
+        ]);
+        assert.equal(r1.ok, true);
+        assert.equal(r2.ok, true);
+        // Both writes should be present
+        const rows = sqlite.exec("SELECT id FROM test_writes ORDER BY id");
+        assert.equal(rows[0].values.length, 2);
+        assert.deepEqual(rows[0].values.map((r) => r[0]), ["w1", "w2"]);
+        // Order should be sequential (1 then 2)
+        assert.deepEqual(order, [1, 2]);
+        sqlite.close();
+    });
+    it("preserves triggerSource through the pipeline", async () => {
+        const sqlite = await createMemoryDb();
+        const queue = createWriteQueue(sqlite);
+        const sources = ["heartbeat", "manual_run", "probe", "idle_curiosity"];
+        for (const source of sources) {
+            const result = await queue.enqueue({
+                label: `write-${source}`,
+                triggerSource: source,
+                execute: (db) => {
+                    db.exec(`INSERT INTO test_writes (id, value, trigger_source) VALUES ('${source}', 'val', '${source}')`);
+                    return source;
+                },
+            });
+            assert.equal(result.ok, true);
+            assert.equal(result.triggerSource, source);
+            assert.equal(result.value, source);
+        }
+        // Verify stored trigger sources
+        for (const source of sources) {
+            const rows = sqlite.exec(`SELECT trigger_source FROM test_writes WHERE id = '${source}'`);
+            assert.equal(rows[0].values[0][0], source);
+        }
+        sqlite.close();
+    });
+    it("manual_run triggerSource is not overwritten", async () => {
+        const sqlite = await createMemoryDb();
+        const queue = createWriteQueue(sqlite);
+        const result = await queue.enqueue({
+            label: "manual-write",
+            triggerSource: "manual_run",
+            execute: (db) => {
+                db.exec("INSERT INTO test_writes (id, value, trigger_source) VALUES ('m1', 'manual', 'manual_run')");
+            },
+        });
+        assert.equal(result.ok, true);
+        assert.equal(result.triggerSource, "manual_run");
+        const rows = sqlite.exec("SELECT trigger_source FROM test_writes WHERE id = 'm1'");
+        assert.equal(rows[0].values[0][0], "manual_run");
+        sqlite.close();
+    });
+    it("write failure sends error to stderr without blocking reads", async () => {
+        const sqlite = await createMemoryDb();
+        const queue = createWriteQueue(sqlite);
+        const result = await queue.enqueue({
+            label: "bad-write",
+            triggerSource: "heartbeat",
+            execute: () => {
+                throw new Error("simulated write failure");
+            },
+        });
+        assert.equal(result.ok, false);
+        assert.ok(result.error);
+        assert.ok(result.error.includes("simulated write failure"));
+        // Read path still works
+        const rows = sqlite.exec("SELECT COUNT(*) FROM test_writes");
+        assert.equal(rows[0].values[0][0], 0);
+        sqlite.close();
+    });
+    it("failed write does not block subsequent writes", async () => {
+        const sqlite = await createMemoryDb();
+        const queue = createWriteQueue(sqlite);
+        // First write fails
+        await queue.enqueue({
+            label: "fail",
+            triggerSource: "heartbeat",
+            execute: () => {
+                throw new Error("first failure");
+            },
+        });
+        // Second write succeeds
+        const result = await queue.enqueue({
+            label: "succeed",
+            triggerSource: "heartbeat",
+            execute: (db) => {
+                db.exec("INSERT INTO test_writes (id, value, trigger_source) VALUES ('s1', 'ok', 'heartbeat')");
+            },
+        });
+        assert.equal(result.ok, true);
+        const rows = sqlite.exec("SELECT id FROM test_writes");
+        assert.equal(rows[0].values.length, 1);
+        assert.equal(rows[0].values[0][0], "s1");
+        sqlite.close();
+    });
+    it("returns value from successful write execution", async () => {
+        const sqlite = await createMemoryDb();
+        const queue = createWriteQueue(sqlite);
+        const result = await queue.enqueue({
+            label: "return-val",
+            triggerSource: "probe",
+            execute: (db) => {
+                db.exec("INSERT INTO test_writes (id, value, trigger_source) VALUES ('r1', 'ret', 'probe')");
+                return { inserted: "r1" };
+            },
+        });
+        assert.equal(result.ok, true);
+        assert.deepEqual(result.value, { inserted: "r1" });
+        sqlite.close();
+    });
+    it("pending count reflects queue state", async () => {
+        const sqlite = await createMemoryDb();
+        const queue = createWriteQueue(sqlite);
+        assert.equal(queue.pending, 0);
+        // Quick sequential writes to verify pending doesn't grow unexpectedly
+        await queue.enqueue({
+            label: "p1",
+            triggerSource: "heartbeat",
+            execute: (db) => {
+                db.exec("INSERT INTO test_writes (id, value, trigger_source) VALUES ('p1', 'v', 'heartbeat')");
+            },
+        });
+        assert.equal(queue.pending, 0);
+        sqlite.close();
+    });
+});

package/dist/tests/unit/storage/write-validation-gate.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * T-SMS.C.1 — WriteValidationGate 单元测试
+ *
+ * Verification types (05A / 05B):
+ * - 单元测试: 4 类拒绝条件；gate 不可绕过；敏感字段检测
+ *
+ * Dependencies: `src/storage/services/write-validation-gate.ts`
+ */
+export {};