@haaaiawd/second-nature 0.1.42 → 0.1.50

package/dist/tests/unit/observability/self-health-snapshot.test.js

@@ -0,0 +1,223 @@
+/**
+ * Tests for SelfHealthSnapshot — T-OBS.C.2
+ *
+ * Covers:
+ * - Minimum required dimensions present when all healthy → overall=healthy
+ * - Per-probe timeout (DR-036): individual timeout marks dimension unknown, others unaffected
+ * - DR-032: state_memory degraded → narrative_timeline + digest degraded, env/cron/delivery unaffected
+ * - All probes timeout → overall=unknown, reason=all_probes_timed_out
+ * - Dynamic probe registration
+ * - SelfHealthSnapshot schema: generatedAt, dimensions, diagnosticReasonCodes, degradedDimensions
+ */
+import assert from "node:assert/strict";
+import { describe, it, beforeEach } from "node:test";
+import { getSelfHealthSnapshot, registerHealthProbe, clearHealthProbeRegistry, ensureMinimumProbes, MINIMUM_REQUIRED_DIMENSIONS, } from "../../../src/observability/services/self-health-snapshot.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function makeHealthyProbe(dimensionId, timeoutMs = 200) {
+    registerHealthProbe({
+        dimensionId,
+        timeoutMs,
+        probe: async () => ({
+            status: "healthy",
+            checkedAt: new Date().toISOString(),
+        }),
+    });
+}
+function makeDegradedProbe(dimensionId, reason, timeoutMs = 200) {
+    registerHealthProbe({
+        dimensionId,
+        timeoutMs,
+        probe: async () => ({
+            status: "degraded",
+            reason,
+            checkedAt: new Date().toISOString(),
+        }),
+    });
+}
+function makeSlowProbe(dimensionId, delayMs, probeTimeoutMs) {
+    registerHealthProbe({
+        dimensionId,
+        timeoutMs: probeTimeoutMs,
+        probe: () => new Promise((resolve) => {
+            setTimeout(() => {
+                resolve({ status: "healthy", checkedAt: new Date().toISOString() });
+            }, delayMs);
+        }),
+    });
+}
+beforeEach(() => {
+    clearHealthProbeRegistry();
+});
+// ─── Minimum dimensions + healthy ────────────────────────────────────────────
+describe("getSelfHealthSnapshot — minimum dimensions + healthy", () => {
+    it("returns overall=healthy when all minimum probes return healthy", async () => {
+        ensureMinimumProbes(); // registers defaults for all minimum dimensions
+        const snapshot = await getSelfHealthSnapshot();
+        assert.equal(snapshot.overall, "healthy");
+        assert.ok(snapshot.generatedAt.length > 0);
+    });
+    it("snapshot dimensions include all minimum required dimensions", async () => {
+        ensureMinimumProbes();
+        const snapshot = await getSelfHealthSnapshot();
+        for (const dim of MINIMUM_REQUIRED_DIMENSIONS) {
+            assert.ok(dim in snapshot.dimensions, `Missing dimension: ${dim}. dimensions: ${JSON.stringify(Object.keys(snapshot.dimensions))}`);
+        }
+    });
+    it("P95 < 1s for healthy probe set (no real delay probes)", async () => {
+        ensureMinimumProbes();
+        const start = Date.now();
+        const snapshot = await getSelfHealthSnapshot();
+        const elapsed = Date.now() - start;
+        assert.ok(elapsed < 1000, `getSelfHealthSnapshot took ${elapsed}ms (expected < 1000ms)`);
+        assert.equal(snapshot.overall, "healthy");
+    });
+    it("SelfHealthView includes dimensions map with per-dimension status", async () => {
+        ensureMinimumProbes();
+        const snapshot = await getSelfHealthSnapshot();
+        // Each dimension should have status + checkedAt
+        for (const [, dimHealth] of Object.entries(snapshot.dimensions)) {
+            assert.ok(["healthy", "degraded", "unknown"].includes(dimHealth.status));
+            assert.ok(dimHealth.checkedAt.length > 0);
+        }
+    });
+});
+// ─── Per-probe timeout (DR-036) ───────────────────────────────────────────────
+describe("getSelfHealthSnapshot — per-probe timeout (DR-036)", () => {
+    it("probe timeout marks that dimension unknown, other dimensions unaffected", async () => {
+        // Register healthy probes for most dimensions
+        for (const dim of MINIMUM_REQUIRED_DIMENSIONS.filter((d) => d !== "secret")) {
+            makeHealthyProbe(dim);
+        }
+        // secret probe: intentionally slow (2s), timeout is 1000ms → should time out
+        makeSlowProbe("secret", 2000, 1000);
+        const snapshot = await getSelfHealthSnapshot();
+        assert.equal(snapshot.dimensions["secret"]?.status, "unknown");
+        assert.ok(snapshot.dimensions["secret"]?.reason?.includes("probe_timeout:secret"));
+        // env should still be healthy
+        assert.equal(snapshot.dimensions["env"]?.status, "healthy");
+        // delivery should still be healthy
+        assert.equal(snapshot.dimensions["delivery"]?.status, "healthy");
+    });
+    it("timed-out dimension reason contains probe_timeout:{dimensionId}", async () => {
+        makeSlowProbe("env", 500, 200); // 500ms delay but 200ms timeout
+        makeHealthyProbe("storage");
+        const snapshot = await getSelfHealthSnapshot({ dimensions: ["env", "storage"] });
+        assert.ok(snapshot.dimensions["env"]?.reason?.includes("probe_timeout:env"));
+        assert.equal(snapshot.dimensions["storage"]?.status, "healthy");
+    });
+    it("overall is degraded (not healthy) when any probe times out", async () => {
+        makeHealthyProbe("env");
+        makeSlowProbe("storage", 500, 200);
+        const snapshot = await getSelfHealthSnapshot({ dimensions: ["env", "storage"] });
+        assert.notEqual(snapshot.overall, "healthy");
+    });
+});
+// ─── DR-032: state_memory degraded ───────────────────────────────────────────
+describe("getSelfHealthSnapshot — DR-032 state_memory degraded cascade", () => {
+    it("state_memory degraded marks narrative_timeline as degraded", async () => {
+        for (const dim of MINIMUM_REQUIRED_DIMENSIONS.filter((d) => d !== "state_memory")) {
+            makeHealthyProbe(dim);
+        }
+        makeDegradedProbe("state_memory", "db_connection_failed");
+        makeHealthyProbe("narrative_timeline", 500);
+        const snapshot = await getSelfHealthSnapshot();
+        assert.equal(snapshot.dimensions["state_memory"]?.status, "degraded");
+        assert.equal(snapshot.dimensions["narrative_timeline"]?.status, "degraded");
+        assert.ok(snapshot.dimensions["narrative_timeline"]?.reason?.includes("state_memory_unavailable"));
+    });
+    it("state_memory degraded does not affect env/cron/delivery dimensions", async () => {
+        for (const dim of MINIMUM_REQUIRED_DIMENSIONS.filter((d) => d !== "state_memory")) {
+            makeHealthyProbe(dim);
+        }
+        makeDegradedProbe("state_memory", "storage_unavailable");
+        const snapshot = await getSelfHealthSnapshot();
+        assert.equal(snapshot.dimensions["env"]?.status, "healthy");
+        assert.equal(snapshot.dimensions["cron"]?.status, "healthy");
+        assert.equal(snapshot.dimensions["delivery"]?.status, "healthy");
+    });
+    it("state_memory degraded allows circuit_breaker to remain healthy", async () => {
+        for (const dim of MINIMUM_REQUIRED_DIMENSIONS) {
+            if (dim === "state_memory") {
+                makeDegradedProbe(dim, "db_unavailable");
+            }
+            else {
+                makeHealthyProbe(dim);
+            }
+        }
+        const snapshot = await getSelfHealthSnapshot();
+        assert.equal(snapshot.dimensions["circuit_breaker"]?.status, "healthy");
+    });
+});
+// ─── All probes timeout ───────────────────────────────────────────────────────
+describe("getSelfHealthSnapshot — all probes timeout", () => {
+    it("returns overall=unknown and reason=all_probes_timed_out when all timeout", async () => {
+        // Register probes that all take longer than their individual timeouts
+        for (const dim of ["env", "storage"]) {
+            makeSlowProbe(dim, 500, 200);
+        }
+        const snapshot = await getSelfHealthSnapshot({ dimensions: ["env", "storage"] });
+        assert.equal(snapshot.overall, "unknown");
+        assert.equal(snapshot.reason, "all_probes_timed_out");
+    });
+    it("lastKnownAt is preserved when all probes timeout", async () => {
+        makeSlowProbe("env", 500, 200);
+        const lastKnown = "2026-05-23T10:00:00.000Z";
+        const snapshot = await getSelfHealthSnapshot({ dimensions: ["env"] }, lastKnown);
+        assert.equal(snapshot.overall, "unknown");
+        assert.equal(snapshot.lastKnownAt, lastKnown);
+    });
+});
+// ─── Dynamic probe registration ───────────────────────────────────────────────
+describe("getSelfHealthSnapshot — dynamic dimension registration", () => {
+    it("dynamically registered probe is included in snapshot", async () => {
+        makeHealthyProbe("custom_db_probe");
+        const snapshot = await getSelfHealthSnapshot({ dimensions: ["custom_db_probe"] });
+        assert.ok("custom_db_probe" in snapshot.dimensions);
+        assert.equal(snapshot.dimensions["custom_db_probe"]?.status, "healthy");
+    });
+    it("probe registered after another still appears in results", async () => {
+        makeHealthyProbe("env");
+        makeHealthyProbe("extra_metric");
+        const snapshot = await getSelfHealthSnapshot({ dimensions: ["env", "extra_metric"] });
+        assert.equal(snapshot.dimensions["env"]?.status, "healthy");
+        assert.equal(snapshot.dimensions["extra_metric"]?.status, "healthy");
+    });
+});
+// ─── Scoped health check ──────────────────────────────────────────────────────
+describe("getSelfHealthSnapshot — scope filtering", () => {
+    it("scope.dimensions filters to only requested probes", async () => {
+        makeHealthyProbe("env");
+        makeHealthyProbe("cron");
+        makeHealthyProbe("secret");
+        const snapshot = await getSelfHealthSnapshot({ dimensions: ["env", "secret"] });
+        assert.ok("env" in snapshot.dimensions);
+        assert.ok("secret" in snapshot.dimensions);
+        assert.ok(!("cron" in snapshot.dimensions));
+    });
+});
+// ─── diagnosticReasonCodes + degradedDimensions ───────────────────────────────
+describe("getSelfHealthSnapshot — diagnosticReasonCodes + degradedDimensions", () => {
+    it("degradedDimensions lists all non-healthy dimensions", async () => {
+        makeHealthyProbe("env");
+        makeDegradedProbe("storage", "disk_full");
+        makeDegradedProbe("cron", "timer_drift");
+        const snapshot = await getSelfHealthSnapshot({ dimensions: ["env", "storage", "cron"] });
+        assert.ok(snapshot.degradedDimensions.includes("storage"));
+        assert.ok(snapshot.degradedDimensions.includes("cron"));
+        assert.ok(!snapshot.degradedDimensions.includes("env"));
+    });
+    it("diagnosticReasonCodes contains reasons from degraded dimensions", async () => {
+        makeHealthyProbe("env");
+        makeDegradedProbe("storage", "disk_full");
+        const snapshot = await getSelfHealthSnapshot({ dimensions: ["env", "storage"] });
+        assert.ok(snapshot.diagnosticReasonCodes.includes("disk_full"));
+    });
+    it("healthy snapshot has empty degradedDimensions and diagnosticReasonCodes", async () => {
+        makeHealthyProbe("env");
+        makeHealthyProbe("storage");
+        const snapshot = await getSelfHealthSnapshot({ dimensions: ["env", "storage"] });
+        assert.deepEqual(snapshot.degradedDimensions, []);
+        assert.deepEqual(snapshot.diagnosticReasonCodes, []);
+        assert.equal(snapshot.overall, "healthy");
+    });
+});

package/dist/tests/unit/observability/verify-audit-hash-chain.test.d.ts

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

package/dist/tests/unit/observability/verify-audit-hash-chain.test.js

@@ -0,0 +1,93 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { AppendOnlyAuditStore } from "../../../src/observability/audit/append-only-audit-store.js";
+import { buildAuditEnvelope } from "../../../src/observability/audit/audit-envelope.js";
+import { verifyAuditHashChain, createAppendOnlyAuditStoreRangeLoader, } from "../../../src/observability/audit/verify-audit-hash-chain.js";
+test("T5.2.2 verifyAuditHashChain — pass on valid chain", async () => {
+    const store = new AppendOnlyAuditStore();
+    const t0 = "2026-05-02T10:00:00.000Z";
+    const t1 = "2026-05-02T10:00:01.000Z";
+    const first = buildAuditEnvelope({
+        family: "heartbeat.decision",
+        plane: "decision",
+        traceId: "tr",
+        sequence: 1,
+        payload: { a: 1 },
+        createdAt: t0,
+    });
+    store.append(first);
+    const second = buildAuditEnvelope({
+        family: "heartbeat.decision",
+        plane: "decision",
+        traceId: "tr",
+        sequence: 2,
+        payload: { b: 2 },
+        previousHash: first.integrity.recordHash,
+        createdAt: t1,
+    });
+    store.append(second);
+    const deps = createAppendOnlyAuditStoreRangeLoader(store);
+    const report = await verifyAuditHashChain({ from: t0, to: t1 }, deps);
+    assert.equal(report.status, "pass");
+    assert.equal(report.checkedEventCount, 2);
+    assert.deepEqual(report.reasons, ["hash_chain_valid"]);
+});
+test("T5.2.2 recordHash mismatch → broken", async () => {
+    const store = new AppendOnlyAuditStore();
+    const t0 = "2026-05-02T11:00:00.000Z";
+    const env = buildAuditEnvelope({
+        family: "heartbeat.decision",
+        plane: "decision",
+        traceId: "tr2",
+        sequence: 1,
+        payload: { x: 1 },
+        createdAt: t0,
+    });
+    const tampered = {
+        ...env,
+        payload: { x: 999 },
+        integrity: { ...env.integrity },
+    };
+    store.append(tampered);
+    const report = await verifyAuditHashChain({ from: t0, to: t0 }, createAppendOnlyAuditStoreRangeLoader(store));
+    assert.equal(report.status, "broken");
+    assert.ok(report.brokenAtEventIds.includes(env.eventId));
+});
+test("T5.2.2 previousHash link broken in verified slice → broken", async () => {
+    const t0 = "2026-05-02T12:00:00.000Z";
+    const first = buildAuditEnvelope({
+        family: "heartbeat.decision",
+        plane: "decision",
+        traceId: "tr3",
+        sequence: 1,
+        payload: { ok: true },
+        createdAt: t0,
+    });
+    const second = buildAuditEnvelope({
+        family: "delivery",
+        plane: "delivery",
+        traceId: "tr3",
+        sequence: 2,
+        payload: { ok: true },
+        previousHash: first.integrity.recordHash,
+        createdAt: t0,
+    });
+    const brokenSecond = {
+        ...second,
+        integrity: { ...second.integrity, previousHash: "0".repeat(64) },
+    };
+    const report = await verifyAuditHashChain({ from: t0, to: t0 }, { loadRange: async () => [first, brokenSecond] });
+    assert.equal(report.status, "broken");
+    assert.ok(report.brokenAtEventIds.includes(second.eventId));
+});
+test("T5.2.2 empty range → incomplete", async () => {
+    const store = new AppendOnlyAuditStore();
+    const report = await verifyAuditHashChain({ from: "2026-05-02T20:00:00.000Z", to: "2026-05-02T20:59:59.000Z" }, createAppendOnlyAuditStoreRangeLoader(store));
+    assert.equal(report.status, "incomplete");
+    assert.deepEqual(report.reasons, ["range_empty"]);
+});
+test("T5.2.2 invalid from>to → incomplete", async () => {
+    const report = await verifyAuditHashChain({ from: "2026-05-03T00:00:00.000Z", to: "2026-05-02T00:00:00.000Z" }, { loadRange: async () => [] });
+    assert.equal(report.status, "incomplete");
+    assert.ok(report.reasons.includes("invalid_range_from_after_to"));
+});

package/dist/tests/unit/ops/manual-run-dispatcher.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * T-ROS.C.3 — ManualRunDispatcher unit tests.
+ *
+ * Verifies:
+ *   1. runConnector executes connector, records experience with triggerSource="manual_run"
+ *   2. runConnector returns envelope with affectsHeartbeatCadence=false
+ *   3. runWetProbe delegates to WetProbeRunner and annotates manual context
+ *   4. runHeartbeatProbe delegates to heartbeatCheck and annotates manual context
+ *   5. When connector fails, experience is still recorded with triggerSource="manual_run"
+ *
+ * Evidence: tests/unit/ops/manual-run-dispatcher.test.ts
+ */
+export {};

package/dist/tests/unit/ops/manual-run-dispatcher.test.js

@@ -0,0 +1,219 @@
+/**
+ * T-ROS.C.3 — ManualRunDispatcher unit tests.
+ *
+ * Verifies:
+ *   1. runConnector executes connector, records experience with triggerSource="manual_run"
+ *   2. runConnector returns envelope with affectsHeartbeatCadence=false
+ *   3. runWetProbe delegates to WetProbeRunner and annotates manual context
+ *   4. runHeartbeatProbe delegates to heartbeatCheck and annotates manual context
+ *   5. When connector fails, experience is still recorded with triggerSource="manual_run"
+ *
+ * Evidence: tests/unit/ops/manual-run-dispatcher.test.ts
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createManualRunDispatcher, } from "../../../src/cli/ops/manual-run-dispatcher.js";
+// ─── mocks ──────────────────────────────────────────────────────────────────
+function makeMockConnectorExecutor(result) {
+    return {
+        async executeEffect() {
+            return result;
+        },
+    };
+}
+function makeMockExperienceWriter() {
+    const calls = [];
+    return {
+        async recordExperience(input) {
+            calls.push(input);
+        },
+        calls,
+    };
+}
+function makeMockWetProbeRunner(overrides) {
+    return {
+        async runWetProbe() {
+            return {
+                probeResult: {
+                    probeResultId: "probe:test",
+                    capabilityId: "cap1",
+                    connectorId: "plat1",
+                    actualStatus: (overrides?.actualStatus ?? "available"),
+                    probeConfigRef: "http://test",
+                    createdAt: new Date().toISOString(),
+                },
+                httpStatus: overrides?.httpStatus ?? 200,
+            };
+        },
+    };
+}
+function makeMockRegistryV7() {
+    return {
+        register() {
+            return { ok: true, errors: [] };
+        },
+        loadManifest() {
+            return undefined;
+        },
+        listRegisteredPlatformIds() {
+            return [];
+        },
+        resolveCapability() {
+            return undefined;
+        },
+    };
+}
+// ─── tests ──────────────────────────────────────────────────────────────────
+test("T-ROS.C.3 AC-1 — runConnector records experience with triggerSource=manual_run", async () => {
+    const connectorResult = {
+        status: "success",
+        data: { ok: true },
+        metadata: { platformId: "plat1", channel: "api_rest", latencyMs: 42, degraded: false },
+    };
+    const mockExecutor = makeMockConnectorExecutor(connectorResult);
+    const mockWriter = makeMockExperienceWriter();
+    const deps = {
+        connectorExecutor: mockExecutor,
+        experienceWriter: mockWriter,
+        wetProbeRunner: makeMockWetProbeRunner(),
+        registryV7: makeMockRegistryV7(),
+    };
+    const dispatcher = createManualRunDispatcher(deps);
+    const envelope = await dispatcher.runConnector({
+        platformId: "plat1",
+        capabilityId: "cap1",
+        payload: { foo: "bar" },
+    });
+    assert.equal(envelope.ok, true);
+    assert.equal(envelope.data?.triggerSource, "manual_run");
+    assert.equal(envelope.data?.affectsHeartbeatCadence, false);
+    assert.equal(mockWriter.calls.length, 1);
+    assert.equal(mockWriter.calls[0].triggerSource, "manual_run");
+    assert.equal(mockWriter.calls[0].connectorId, "plat1");
+    assert.equal(mockWriter.calls[0].capabilityId, "cap1");
+});
+test("T-ROS.C.3 AC-1 — runConnector records experience even on failure", async () => {
+    const connectorResult = {
+        status: "terminal_failure",
+        failureClass: "auth_failure",
+        metadata: { platformId: "plat1", channel: "api_rest", latencyMs: 12, degraded: false },
+    };
+    const mockExecutor = makeMockConnectorExecutor(connectorResult);
+    const mockWriter = makeMockExperienceWriter();
+    const deps = {
+        connectorExecutor: mockExecutor,
+        experienceWriter: mockWriter,
+        wetProbeRunner: makeMockWetProbeRunner(),
+        registryV7: makeMockRegistryV7(),
+    };
+    const dispatcher = createManualRunDispatcher(deps);
+    const envelope = await dispatcher.runConnector({
+        platformId: "plat1",
+        capabilityId: "cap1",
+    });
+    assert.equal(envelope.ok, false);
+    assert.equal(envelope.data?.triggerSource, "manual_run");
+    assert.equal(envelope.data?.affectsHeartbeatCadence, false);
+    assert.equal(mockWriter.calls.length, 1);
+    assert.equal(mockWriter.calls[0].triggerSource, "manual_run");
+});
+test("T-ROS.C.3 AC-3 — runWetProbe returns manual_run triggerSource and cadence=false", async () => {
+    const mockWriter = makeMockExperienceWriter();
+    const deps = {
+        connectorExecutor: makeMockConnectorExecutor({
+            status: "success",
+            data: {},
+            metadata: { platformId: "p", channel: "api_rest", latencyMs: 0, degraded: false },
+        }),
+        experienceWriter: mockWriter,
+        wetProbeRunner: makeMockWetProbeRunner(),
+        registryV7: makeMockRegistryV7(),
+    };
+    const dispatcher = createManualRunDispatcher(deps);
+    const envelope = await dispatcher.runWetProbe({
+        platformId: "plat1",
+        capabilityId: "cap1",
+    });
+    assert.equal(envelope.ok, true);
+    assert.equal(envelope.data?.triggerSource, "manual_run");
+    assert.equal(envelope.data?.affectsHeartbeatCadence, false);
+});
+test("T-ROS.C.3 AC-3 — runWetProbe returns ok:false when probe degraded", async () => {
+    const mockWriter = makeMockExperienceWriter();
+    const deps = {
+        connectorExecutor: makeMockConnectorExecutor({
+            status: "success",
+            data: {},
+            metadata: { platformId: "p", channel: "api_rest", latencyMs: 0, degraded: false },
+        }),
+        experienceWriter: mockWriter,
+        wetProbeRunner: makeMockWetProbeRunner({
+            actualStatus: "unavailable",
+            httpStatus: 503,
+        }),
+        registryV7: makeMockRegistryV7(),
+    };
+    const dispatcher = createManualRunDispatcher(deps);
+    const envelope = await dispatcher.runWetProbe({
+        platformId: "plat1",
+        capabilityId: "cap1",
+    });
+    assert.equal(envelope.ok, false);
+    assert.equal(envelope.data?.triggerSource, "manual_run");
+    assert.equal(envelope.data?.affectsHeartbeatCadence, false);
+});
+test("T-ROS.C.3 AC-3 — runHeartbeatProbe annotates with manual_run context", async () => {
+    const mockWriter = makeMockExperienceWriter();
+    const deps = {
+        connectorExecutor: makeMockConnectorExecutor({
+            status: "success",
+            data: {},
+            metadata: { platformId: "p", channel: "api_rest", latencyMs: 0, degraded: false },
+        }),
+        experienceWriter: mockWriter,
+        wetProbeRunner: makeMockWetProbeRunner(),
+        registryV7: makeMockRegistryV7(),
+    };
+    const dispatcher = createManualRunDispatcher(deps);
+    const result = await dispatcher.runHeartbeatProbe({
+        deps: {
+            runtimeAvailable: false,
+        },
+        caller: "operator",
+        reason: "manual_probe",
+    });
+    assert.equal(result.triggerSource, "manual_run");
+    assert.equal(result.affectsHeartbeatCadence, false);
+    assert.equal(result.caller, "operator");
+    assert.equal(result.reason, "manual_probe");
+});
+test("T-ROS.C.3 — runConnector passes payload to connectorExecutor", async () => {
+    const calls = [];
+    const executor = {
+        async executeEffect(input) {
+            calls.push(input);
+            return {
+                status: "success",
+                data: {},
+                metadata: { platformId: input.platformId, channel: "api_rest", latencyMs: 10, degraded: false },
+            };
+        },
+    };
+    const mockWriter = makeMockExperienceWriter();
+    const dispatcherDeps = {
+        connectorExecutor: executor,
+        experienceWriter: mockWriter,
+        wetProbeRunner: makeMockWetProbeRunner(),
+        registryV7: makeMockRegistryV7(),
+    };
+    const dispatcher = createManualRunDispatcher(dispatcherDeps);
+    await dispatcher.runConnector({
+        platformId: "plat1",
+        capabilityId: "feed.read",
+        payload: { cursor: "abc" },
+    });
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].platformId, "plat1");
+    assert.equal(calls[0].intent, "feed.read");
+    assert.deepStrictEqual(calls[0].payload, { cursor: "abc" });
+});

package/dist/tests/unit/quiet/claim-synthesizer.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ClaimSynthesizer tests — T-DQS.C.1
+ *
+ * Coverage:
+ * - EvidenceAggregator groups candidates by type and produces summary
+ * - ClaimDeduplicator removes duplicate claims by sourceRef key
+ * - ClaimSynthesizer:
+ *   - single weak evidence → observation only
+ *   - multiple evidence → fact
+ *   - >=3 high-confidence evidence → pattern
+ *   - empty slice → empty claims
+ * - SourceValidator:
+ *   - rejects fact claim with empty sourceRefs → claim_source_missing
+ *   - accepts claim with non-empty sourceRefs
+ *   - observation claims also require sourceRefs (DR-025)
+ */
+export {};