@haaaiawd/second-nature 0.1.50 → 0.1.51

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

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

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

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

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

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

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

@@ -1,17 +0,0 @@
-/**
- * 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 {};