@haaaiawd/second-nature 0.1.42 → 0.1.50

package/dist/tests/unit/body/affordance-context-scope.test.js

@@ -0,0 +1,73 @@
+/**
+ * AffordanceContextScope tests — T-BTS.C.2
+ *
+ * Coverage:
+ * - default allowedStatuses filters to safe + exploratory + needs_auth
+ * - blocked (unavailable) always excluded even if in allowedStatuses
+ * - platformIds whitelist
+ * - goalKind passive_sensing only exposes read-only intents
+ * - goalKind task_completion does not filter out read intents
+ * - empty platformIds = all platforms
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { applyAffordanceContextScope, } from "../../../src/core/second-nature/body/tool-affordance/affordance-context-scope.js";
+const baseItems = [
+    { platformId: "twitter", capabilityId: "cap-1", intent: "feed.read", status: "safe" },
+    { platformId: "twitter", capabilityId: "cap-2", intent: "post.publish", status: "safe" },
+    { platformId: "twitter", capabilityId: "cap-3", intent: "message.send", status: "exploratory" },
+    { platformId: "twitter", capabilityId: "cap-4", intent: "comment.reply", status: "painful" },
+    { platformId: "twitter", capabilityId: "cap-5", intent: "notification.list", status: "unavailable" },
+    { platformId: "github", capabilityId: "cap-6", intent: "work.discover", status: "safe" },
+    { platformId: "github", capabilityId: "cap-7", intent: "task.claim", status: "needs_auth" },
+];
+describe("applyAffordanceContextScope", () => {
+    it("default allowedStatuses keeps safe + exploratory + needs_auth", () => {
+        const result = applyAffordanceContextScope(baseItems);
+        assert.deepStrictEqual(result.map((i) => i.capabilityId), ["cap-1", "cap-2", "cap-3", "cap-6", "cap-7"]);
+    });
+    it("blocked (unavailable) always excluded even when allowedStatuses includes it", () => {
+        const result = applyAffordanceContextScope(baseItems, {
+            allowedStatuses: ["safe", "exploratory", "unavailable"],
+        });
+        assert.strictEqual(result.some((i) => i.capabilityId === "cap-5"), false);
+    });
+    it("platformIds whitelist filters to specified platforms", () => {
+        const result = applyAffordanceContextScope(baseItems, {
+            platformIds: ["github"],
+        });
+        assert.strictEqual(result.length, 2);
+        assert(result.every((item) => item.platformId === "github"));
+        assert.deepStrictEqual(result.map((item) => item.capabilityId), ["cap-6", "cap-7"]);
+    });
+    it("empty platformIds allows all platforms", () => {
+        const result = applyAffordanceContextScope(baseItems, {
+            platformIds: [],
+        });
+        // Default filter still applies (safe + exploratory + needs_auth)
+        assert.strictEqual(result.length, 5);
+    });
+    it("goalKind passive_sensing only exposes read-only intents", () => {
+        const result = applyAffordanceContextScope(baseItems, {
+            goalKind: "passive_sensing",
+            allowedStatuses: ["safe", "exploratory", "needs_auth", "painful"],
+        });
+        for (const item of result) {
+            assert(["feed.read", "notification.list", "work.discover"].includes(item.intent), `unexpected intent ${item.intent} in passive_sensing scope`);
+        }
+    });
+    it("goalKind task_completion keeps all intents (no extra filter)", () => {
+        const result = applyAffordanceContextScope(baseItems, {
+            goalKind: "task_completion",
+            allowedStatuses: ["safe", "exploratory", "needs_auth"],
+        });
+        assert(result.some((i) => i.intent === "post.publish"));
+        assert(result.some((i) => i.intent === "feed.read"));
+    });
+    it("custom allowedStatuses includes painful when specified", () => {
+        const result = applyAffordanceContextScope(baseItems, {
+            allowedStatuses: ["safe", "exploratory", "painful"],
+        });
+        assert(result.some((i) => i.capabilityId === "cap-4"));
+    });
+});

package/dist/tests/unit/body/behavior-promotion-loop.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * BehaviorPromotionLoop tests — T-BTS.C.3
+ *
+ * Coverage:
+ * - submitPromotion creates candidate
+ * - approvePromotion transitions candidate→approved
+ * - approvePromotion is idempotent
+ * - rejectPromotion transitions candidate→rejected with reason
+ * - rejected entry cannot be approved
+ * - loadPromotion round-trip
+ * - listPromotions filters by status
+ * - expireStaleCandidates transitions expired candidates
+ * - expired entry cannot be approved
+ */
+export {};

package/dist/tests/unit/body/behavior-promotion-loop.test.js

@@ -0,0 +1,130 @@
+/**
+ * BehaviorPromotionLoop tests — T-BTS.C.3
+ *
+ * Coverage:
+ * - submitPromotion creates candidate
+ * - approvePromotion transitions candidate→approved
+ * - approvePromotion is idempotent
+ * - rejectPromotion transitions candidate→rejected with reason
+ * - rejected entry cannot be approved
+ * - loadPromotion round-trip
+ * - listPromotions filters by status
+ * - expireStaleCandidates transitions expired candidates
+ * - expired entry cannot be approved
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createBehaviorPromotionLoop } from "../../../src/core/second-nature/body/behavior-promotion/behavior-promotion-loop.js";
+describe("BehaviorPromotionLoop", () => {
+    it("submitPromotion creates candidate", async () => {
+        const db = createStateDatabase(":memory:");
+        const loop = createBehaviorPromotionLoop(db);
+        const p = await loop.submitPromotion({
+            promotionId: "promo-1",
+            behaviorKind: "greeting_style",
+            description: "Use a warmer greeting",
+        });
+        assert.strictEqual(p.status, "candidate");
+        assert.strictEqual(p.behaviorKind, "greeting_style");
+        assert(p.expiresAt > p.submittedAt);
+    });
+    it("approvePromotion transitions candidate to approved", async () => {
+        const db = createStateDatabase(":memory:");
+        const loop = createBehaviorPromotionLoop(db);
+        await loop.submitPromotion({
+            promotionId: "promo-2",
+            behaviorKind: "tone",
+            description: "More casual",
+        });
+        const approved = await loop.approvePromotion("promo-2");
+        assert.strictEqual(approved.status, "approved");
+        assert(approved.decidedAt !== undefined);
+    });
+    it("approvePromotion is idempotent", async () => {
+        const db = createStateDatabase(":memory:");
+        const loop = createBehaviorPromotionLoop(db);
+        await loop.submitPromotion({
+            promotionId: "promo-3",
+            behaviorKind: "tone",
+            description: "More casual",
+        });
+        const first = await loop.approvePromotion("promo-3");
+        const second = await loop.approvePromotion("promo-3");
+        assert.strictEqual(second.status, "approved");
+        assert.strictEqual(second.decidedAt, first.decidedAt);
+    });
+    it("rejectPromotion transitions candidate to rejected", async () => {
+        const db = createStateDatabase(":memory:");
+        const loop = createBehaviorPromotionLoop(db);
+        await loop.submitPromotion({
+            promotionId: "promo-4",
+            behaviorKind: "emoji",
+            description: "Add emojis",
+        });
+        const rejected = await loop.rejectPromotion("promo-4", "not aligned with brand");
+        assert.strictEqual(rejected.status, "rejected");
+        assert.strictEqual(rejected.rejectReason, "not aligned with brand");
+    });
+    it("rejected entry cannot be approved", async () => {
+        const db = createStateDatabase(":memory:");
+        const loop = createBehaviorPromotionLoop(db);
+        await loop.submitPromotion({
+            promotionId: "promo-5",
+            behaviorKind: "emoji",
+            description: "Add emojis",
+        });
+        await loop.rejectPromotion("promo-5", "no");
+        await assert.rejects(loop.approvePromotion("promo-5"), /promotion_immutable/);
+    });
+    it("loadPromotion round-trip", async () => {
+        const db = createStateDatabase(":memory:");
+        const loop = createBehaviorPromotionLoop(db);
+        await loop.submitPromotion({
+            promotionId: "promo-6",
+            behaviorKind: "timing",
+            description: "Reply faster",
+        });
+        const loaded = await loop.loadPromotion("promo-6");
+        assert.strictEqual(loaded.status, "candidate");
+        assert.strictEqual(loaded.behaviorKind, "timing");
+    });
+    it("listPromotions filters by status", async () => {
+        const db = createStateDatabase(":memory:");
+        const loop = createBehaviorPromotionLoop(db);
+        await loop.submitPromotion({ promotionId: "a1", behaviorKind: "a", description: "a" });
+        await loop.submitPromotion({ promotionId: "a2", behaviorKind: "a", description: "a" });
+        await loop.approvePromotion("a1");
+        const approved = await loop.listPromotions("approved");
+        const candidates = await loop.listPromotions("candidate");
+        assert.strictEqual(approved.length, 1);
+        assert.strictEqual(candidates.length, 1);
+    });
+    it("expireStaleCandidates transitions expired candidates", async () => {
+        const db = createStateDatabase(":memory:");
+        const loop = createBehaviorPromotionLoop(db);
+        await loop.submitPromotion({
+            promotionId: "old-1",
+            behaviorKind: "x",
+            description: "x",
+        });
+        // Force expiration by backdating in DB
+        db.sqlite.run(`UPDATE behavior_promotion SET expires_at = ? WHERE promotion_id = ?`, ["2020-01-01T00:00:00Z", "old-1"]);
+        const count = await loop.expireStaleCandidates();
+        assert.strictEqual(count, 1);
+        const loaded = await loop.loadPromotion("old-1");
+        assert.strictEqual(loaded.status, "expired");
+    });
+    it("expired entry cannot be approved", async () => {
+        const db = createStateDatabase(":memory:");
+        const loop = createBehaviorPromotionLoop(db);
+        await loop.submitPromotion({
+            promotionId: "old-2",
+            behaviorKind: "x",
+            description: "x",
+        });
+        db.sqlite.run(`UPDATE behavior_promotion SET expires_at = ? WHERE promotion_id = ?`, ["2020-01-01T00:00:00Z", "old-2"]);
+        await loop.expireStaleCandidates();
+        await assert.rejects(loop.approvePromotion("old-2"), /promotion_immutable/);
+    });
+});

package/dist/tests/unit/body/circuit-breaker-manager.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CircuitBreakerManager tests — T-BTS.C.5
+ *
+ * Coverage:
+ * - evaluateFailure x3 → Open
+ * - Open cooldown elapsed → canExecute true, attemptReset → HalfOpen
+ * - HalfOpen + probe success → Closed + onClosed callback
+ * - HalfOpen + probe failure → Open
+ * - evaluateSuccess from HalfOpen → Closed
+ * - getState returns current state
+ * - persistence: new instance reads previous state
+ */
+export {};

package/dist/tests/unit/body/circuit-breaker-manager.test.js

@@ -0,0 +1,160 @@
+/**
+ * CircuitBreakerManager tests — T-BTS.C.5
+ *
+ * Coverage:
+ * - evaluateFailure x3 → Open
+ * - Open cooldown elapsed → canExecute true, attemptReset → HalfOpen
+ * - HalfOpen + probe success → Closed + onClosed callback
+ * - HalfOpen + probe failure → Open
+ * - evaluateSuccess from HalfOpen → Closed
+ * - getState returns current state
+ * - persistence: new instance reads previous state
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createCircuitBreakerManager } from "../../../src/core/second-nature/body/circuit-breaker/circuit-breaker-manager.js";
+import { CapabilityContractRegistryV7 } from "../../../src/connectors/base/manifest-v7.js";
+describe("CircuitBreakerManager", () => {
+    function buildAdapter(probeStatus) {
+        return {
+            async runAndRecordProbe() {
+                return {
+                    actualStatus: probeStatus.actualStatus,
+                    httpStatus: probeStatus.httpStatus,
+                    recorded: true,
+                    experienceRecorded: false,
+                };
+            },
+        };
+    }
+    function buildRegistry() {
+        const reg = new CapabilityContractRegistryV7();
+        reg.register({
+            platformId: "twitter",
+            capabilities: [
+                {
+                    capabilityId: "cap-1",
+                    intent: "feed.read",
+                    probeConfig: {
+                        safeEndpoint: "http://localhost:9000/health",
+                        idempotencyClass: "read_only",
+                    },
+                },
+            ],
+            channelPriority: ["api_rest"],
+            credentialTypes: ["token"],
+        });
+        return reg;
+    }
+    it("evaluateFailure 3 times opens breaker", async () => {
+        const db = createStateDatabase(":memory:");
+        const adapter = buildAdapter({ actualStatus: "unavailable", httpStatus: 503 });
+        const manager = createCircuitBreakerManager({
+            database: db,
+            probeAdapter: adapter,
+            registry: buildRegistry(),
+            failureThreshold: 3,
+            cooldownMs: 30_000,
+        });
+        assert.strictEqual(await manager.evaluateFailure("twitter", "cap-1"), "closed");
+        assert.strictEqual(await manager.evaluateFailure("twitter", "cap-1"), "closed");
+        assert.strictEqual(await manager.evaluateFailure("twitter", "cap-1"), "open");
+        assert.strictEqual(await manager.getState("twitter", "cap-1"), "open");
+    });
+    it("canExecute false when Open and cooldown not elapsed", async () => {
+        const db = createStateDatabase(":memory:");
+        const adapter = buildAdapter({ actualStatus: "unavailable", httpStatus: 503 });
+        const manager = createCircuitBreakerManager({
+            database: db,
+            probeAdapter: adapter,
+            registry: buildRegistry(),
+            failureThreshold: 1,
+            cooldownMs: 60_000,
+        });
+        await manager.evaluateFailure("twitter", "cap-1");
+        assert.strictEqual(await manager.canExecute("twitter", "cap-1"), false);
+    });
+    it("attemptReset transitions Open→HalfOpen after cooldown", async () => {
+        const db = createStateDatabase(":memory:");
+        const adapter = buildAdapter({ actualStatus: "available", httpStatus: 200 });
+        let closedCalled = false;
+        const manager = createCircuitBreakerManager({
+            database: db,
+            probeAdapter: adapter,
+            registry: buildRegistry(),
+            failureThreshold: 1,
+            cooldownMs: 0,
+            onClosed: () => {
+                closedCalled = true;
+            },
+        });
+        await manager.evaluateFailure("twitter", "cap-1");
+        assert.strictEqual(await manager.getState("twitter", "cap-1"), "open");
+        const state = await manager.attemptReset("twitter", "cap-1");
+        assert.strictEqual(state, "closed");
+        assert.strictEqual(closedCalled, true);
+        assert.strictEqual(await manager.getState("twitter", "cap-1"), "closed");
+    });
+    it("HalfOpen + probe failure → Open", async () => {
+        const db = createStateDatabase(":memory:");
+        const adapter = buildAdapter({ actualStatus: "unavailable", httpStatus: 503 });
+        const manager = createCircuitBreakerManager({
+            database: db,
+            probeAdapter: adapter,
+            registry: buildRegistry(),
+            failureThreshold: 1,
+            cooldownMs: 0,
+        });
+        await manager.evaluateFailure("twitter", "cap-1");
+        const state = await manager.attemptReset("twitter", "cap-1");
+        assert.strictEqual(state, "open");
+    });
+    it("evaluateSuccess from HalfOpen closes breaker", async () => {
+        const db = createStateDatabase(":memory:");
+        const adapter = buildAdapter({ actualStatus: "available", httpStatus: 200 });
+        let closedCalled = false;
+        const manager = createCircuitBreakerManager({
+            database: db,
+            probeAdapter: adapter,
+            registry: buildRegistry(),
+            failureThreshold: 1,
+            cooldownMs: 0,
+            onClosed: () => {
+                closedCalled = true;
+            },
+        });
+        await manager.evaluateFailure("twitter", "cap-1");
+        // Manually transition to half_open by resetting
+        await manager.attemptReset("twitter", "cap-1");
+        assert.strictEqual(await manager.getState("twitter", "cap-1"), "closed");
+        // Now test evaluateSuccess when already closed resets consecutive
+        await manager.evaluateFailure("twitter", "cap-1");
+        await manager.attemptReset("twitter", "cap-1");
+        const state = await manager.evaluateSuccess("twitter", "cap-1");
+        assert.strictEqual(state, "closed");
+    });
+    it("persistence: new manager instance reads saved state", async () => {
+        const db = createStateDatabase(":memory:");
+        const adapter = buildAdapter({ actualStatus: "available", httpStatus: 200 });
+        const manager1 = createCircuitBreakerManager({
+            database: db,
+            probeAdapter: adapter,
+            registry: buildRegistry(),
+            failureThreshold: 2,
+            cooldownMs: 30_000,
+        });
+        await manager1.evaluateFailure("twitter", "cap-1");
+        await manager1.evaluateFailure("twitter", "cap-1");
+        assert.strictEqual(await manager1.getState("twitter", "cap-1"), "open");
+        // Simulate process restart
+        const manager2 = createCircuitBreakerManager({
+            database: db,
+            probeAdapter: adapter,
+            registry: buildRegistry(),
+            failureThreshold: 2,
+            cooldownMs: 0,
+        });
+        assert.strictEqual(await manager2.getState("twitter", "cap-1"), "open");
+    });
+});

package/dist/tests/unit/body/experience-writer.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ExperienceWriter tests — T-BTS.C.4
+ *
+ * Coverage:
+ * - recordExperience maps success → outcome "success"
+ * - recordExperience maps terminal_failure → outcome "failure"
+ * - failureClass transcribed from ConnectorResult (DR-007)
+ * - triggerSource passed through (DR-010)
+ * - gate rejects payload with raw secret
+ */
+export {};

package/dist/tests/unit/body/experience-writer.test.js

@@ -0,0 +1,77 @@
+/**
+ * ExperienceWriter tests — T-BTS.C.4
+ *
+ * Coverage:
+ * - recordExperience maps success → outcome "success"
+ * - recordExperience maps terminal_failure → outcome "failure"
+ * - failureClass transcribed from ConnectorResult (DR-007)
+ * - triggerSource passed through (DR-010)
+ * - gate rejects payload with raw secret
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createToolExperienceStore } from "../../../src/storage/services/tool-experience-store.js";
+import { createExperienceWriter } from "../../../src/core/second-nature/body/tool-experience/experience-writer.js";
+describe("ExperienceWriter", () => {
+    it("records success with outcome success", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createToolExperienceStore(db);
+        const writer = createExperienceWriter(store);
+        const result = {
+            status: "success",
+            metadata: { platformId: "twitter", channel: "api_rest", latencyMs: 120 },
+        };
+        await writer.recordExperience({
+            connectorId: "twitter",
+            capabilityId: "cap-1",
+            result,
+            triggerSource: "heartbeat",
+        });
+        const rows = await store.listToolExperience({ connectorId: "twitter" });
+        assert.strictEqual(rows.length, 1);
+        assert.strictEqual(rows[0].outcome, "success");
+        assert.strictEqual(rows[0].triggerSource, "heartbeat");
+        assert.strictEqual(rows[0].latencyMs, 120);
+    });
+    it("records terminal_failure with outcome failure and failureClass", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createToolExperienceStore(db);
+        const writer = createExperienceWriter(store);
+        const result = {
+            status: "terminal_failure",
+            failureClass: "auth_failure",
+            metadata: { platformId: "twitter", channel: "api_rest", latencyMs: 50 },
+        };
+        await writer.recordExperience({
+            connectorId: "twitter",
+            capabilityId: "cap-1",
+            result,
+            triggerSource: "manual_run",
+        });
+        const rows = await store.listToolExperience({ connectorId: "twitter" });
+        assert.strictEqual(rows.length, 1);
+        assert.strictEqual(rows[0].outcome, "failure");
+        assert.strictEqual(rows[0].failureClass, "auth_failure");
+        assert.strictEqual(rows[0].triggerSource, "manual_run");
+    });
+    it("gate rejects if payload contains raw secret", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createToolExperienceStore(db);
+        const writer = createExperienceWriter(store);
+        const result = {
+            status: "success",
+            metadata: {
+                platformId: "twitter",
+                channel: "api_rest",
+                latencyMs: 120,
+            },
+        };
+        await assert.rejects(writer.recordExperience({
+            connectorId: "twitter",
+            capabilityId: "sk-abcdefghijklmnopqrstuvwxyz123456789",
+            result,
+            triggerSource: "heartbeat",
+        }), /write_validation_failed/);
+    });
+});

package/dist/tests/unit/body/pain-signal-query.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * PainSignal query tests — T-BTS.C.4
+ *
+ * Coverage:
+ * - getPainSignal returns undefined when no experiences
+ * - painLevel increases with failure rate and consecutive failures
+ * - cooldownRecommended when consecutive failures >= threshold
+ * - bounded to lookback limit
+ * - capabilityId optional (aggregate across capabilities)
+ */
+export {};

package/dist/tests/unit/body/pain-signal-query.test.js

@@ -0,0 +1,104 @@
+/**
+ * PainSignal query tests — T-BTS.C.4
+ *
+ * Coverage:
+ * - getPainSignal returns undefined when no experiences
+ * - painLevel increases with failure rate and consecutive failures
+ * - cooldownRecommended when consecutive failures >= threshold
+ * - bounded to lookback limit
+ * - capabilityId optional (aggregate across capabilities)
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createToolExperienceStore } from "../../../src/storage/services/tool-experience-store.js";
+import { createPainSignalQuery } from "../../../src/core/second-nature/body/tool-experience/pain-signal-query.js";
+describe("PainSignalQuery", () => {
+    it("returns undefined when empty", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createToolExperienceStore(db);
+        const query = createPainSignalQuery(store, { lookbackLimit: 5 });
+        const signal = await query.getPainSignal("twitter");
+        assert.strictEqual(signal, undefined);
+    });
+    it("painLevel rises with consecutive failures", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createToolExperienceStore(db);
+        const query = createPainSignalQuery(store, {
+            lookbackLimit: 10,
+            cooldownThreshold: 3,
+        });
+        for (let i = 0; i < 4; i++) {
+            await store.appendToolExperience({
+                experienceId: `exp-${i}`,
+                connectorId: "twitter",
+                capabilityId: "cap-1",
+                outcome: "failure",
+                latencyMs: 100,
+                evidenceQuality: 0,
+                sourceRefs: ["test:signal"],
+                triggerSource: "heartbeat",
+                createdAt: new Date(Date.now() - (3 - i) * 1000).toISOString(),
+            });
+        }
+        const signal = await query.getPainSignal("twitter", "cap-1");
+        assert(signal.painLevel > 0.3);
+        assert.strictEqual(signal.consecutiveFailures, 4);
+        assert.strictEqual(signal.cooldownRecommended, true);
+    });
+    it("cooldownRecommended false below threshold", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createToolExperienceStore(db);
+        const query = createPainSignalQuery(store, {
+            lookbackLimit: 10,
+            cooldownThreshold: 5,
+        });
+        for (let i = 0; i < 2; i++) {
+            await store.appendToolExperience({
+                experienceId: `exp-${i}`,
+                connectorId: "twitter",
+                capabilityId: "cap-1",
+                outcome: "failure",
+                latencyMs: 100,
+                evidenceQuality: 0,
+                sourceRefs: ["test:signal"],
+                triggerSource: "heartbeat",
+                createdAt: new Date(Date.now() - i * 1000).toISOString(),
+            });
+        }
+        const signal = await query.getPainSignal("twitter", "cap-1");
+        assert.strictEqual(signal.cooldownRecommended, false);
+    });
+    it("resets consecutiveFailures after success", async () => {
+        const db = createStateDatabase(":memory:");
+        const store = createToolExperienceStore(db);
+        const query = createPainSignalQuery(store, {
+            lookbackLimit: 10,
+            cooldownThreshold: 3,
+        });
+        await store.appendToolExperience({
+            experienceId: "e1",
+            connectorId: "twitter",
+            capabilityId: "cap-1",
+            outcome: "failure",
+            latencyMs: 100,
+            evidenceQuality: 0,
+            sourceRefs: ["test:signal"],
+            triggerSource: "heartbeat",
+            createdAt: new Date(Date.now() - 2000).toISOString(),
+        });
+        await store.appendToolExperience({
+            experienceId: "e2",
+            connectorId: "twitter",
+            capabilityId: "cap-1",
+            outcome: "success",
+            latencyMs: 100,
+            evidenceQuality: 1,
+            sourceRefs: ["test:signal"],
+            triggerSource: "heartbeat",
+            createdAt: new Date(Date.now() - 1000).toISOString(),
+        });
+        const signal = await query.getPainSignal("twitter", "cap-1");
+        assert.strictEqual(signal.consecutiveFailures, 0);
+    });
+});

package/dist/tests/unit/cli/connector-init-manifest.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Wave 83 — connector-init manifest generation tests
+ *
+ * Verifies that connectorInit generates correct manifest structure:
+ * - declarative_http → trust.status = declarative_trusted
+ * - baseUrl → placed in runner.config.baseUrl
+ * - custom_adapter → trust.status = custom_adapter_pending_trust
+ */
+export {};