@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/unit/guidance/capability-class.test.js

@@ -0,0 +1,96 @@
+/**
+ * capability-class.test.ts — T-V7C.C.4R
+ *
+ * Unit tests for inferCapabilityClass prefix-based classification.
+ * Verifies all known prefixes, agent.* exclusion, and custom capability defaults.
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { inferCapabilityClass, CAPABILITY_CLASS_SCENE_MAP, } from "../../../src/guidance/capability-class.js";
+describe("inferCapabilityClass", () => {
+    // ── consume ──────────────────────────────────────────────────────────────────
+    it("feed.read → consume", () => {
+        assert.strictEqual(inferCapabilityClass("feed.read"), "consume");
+    });
+    it("feed.list → consume", () => {
+        assert.strictEqual(inferCapabilityClass("feed.list"), "consume");
+    });
+    it("notification.list → consume", () => {
+        assert.strictEqual(inferCapabilityClass("notification.list"), "consume");
+    });
+    it("notification.read → consume", () => {
+        assert.strictEqual(inferCapabilityClass("notification.read"), "consume");
+    });
+    // ── discover ─────────────────────────────────────────────────────────────────
+    it("work.discover → discover", () => {
+        assert.strictEqual(inferCapabilityClass("work.discover"), "discover");
+    });
+    it("work.search → discover", () => {
+        assert.strictEqual(inferCapabilityClass("work.search"), "discover");
+    });
+    // ── broadcast ────────────────────────────────────────────────────────────────
+    it("post.publish → broadcast", () => {
+        assert.strictEqual(inferCapabilityClass("post.publish"), "broadcast");
+    });
+    it("post.create → broadcast", () => {
+        assert.strictEqual(inferCapabilityClass("post.create"), "broadcast");
+    });
+    // ── interact ─────────────────────────────────────────────────────────────────
+    it("comment.reply → interact", () => {
+        assert.strictEqual(inferCapabilityClass("comment.reply"), "interact");
+    });
+    it("comment.create → interact", () => {
+        assert.strictEqual(inferCapabilityClass("comment.create"), "interact");
+    });
+    it("message.send → interact", () => {
+        assert.strictEqual(inferCapabilityClass("message.send"), "interact");
+    });
+    it("message.reply → interact", () => {
+        assert.strictEqual(inferCapabilityClass("message.reply"), "interact");
+    });
+    // ── claim ────────────────────────────────────────────────────────────────────
+    it("task.claim → claim", () => {
+        assert.strictEqual(inferCapabilityClass("task.claim"), "claim");
+    });
+    it("task.assign → claim", () => {
+        assert.strictEqual(inferCapabilityClass("task.assign"), "claim");
+    });
+    // ── agent.* excluded (null) ───────────────────────────────────────────────────
+    it("agent.heartbeat → null (excluded from impulse system)", () => {
+        assert.strictEqual(inferCapabilityClass("agent.heartbeat"), null);
+    });
+    it("agent.status → null", () => {
+        assert.strictEqual(inferCapabilityClass("agent.status"), null);
+    });
+    // ── custom / unknown → broadcast (safe default) ───────────────────────────────
+    it("custom.action → broadcast (default for unrecognized)", () => {
+        assert.strictEqual(inferCapabilityClass("custom.action"), "broadcast");
+    });
+    it("unknown.xyz → broadcast", () => {
+        assert.strictEqual(inferCapabilityClass("unknown.xyz"), "broadcast");
+    });
+    // ── edge cases ───────────────────────────────────────────────────────────────
+    it("empty string → null", () => {
+        assert.strictEqual(inferCapabilityClass(""), null);
+    });
+    it("no dot (bare word) → broadcast default", () => {
+        assert.strictEqual(inferCapabilityClass("publish"), "broadcast");
+    });
+    it("uppercase prefix is normalized → feed.READ → consume", () => {
+        assert.strictEqual(inferCapabilityClass("FEED.READ"), "consume");
+    });
+});
+describe("CAPABILITY_CLASS_SCENE_MAP", () => {
+    const cases = [
+        ["consume", "explore"],
+        ["discover", "explore"],
+        ["broadcast", "social"],
+        ["interact", "reply"],
+        ["claim", "work"],
+    ];
+    for (const [capClass, expectedScene] of cases) {
+        it(`${capClass} → ${expectedScene}`, () => {
+            assert.strictEqual(CAPABILITY_CLASS_SCENE_MAP[capClass], expectedScene);
+        });
+    }
+});

package/dist/tests/unit/guidance/channel-feedback-ingestion.test.d.ts

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

package/dist/tests/unit/guidance/channel-feedback-ingestion.test.js

@@ -0,0 +1,163 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { ingestChannelFeedback, } from "../../../src/guidance/index.js";
+function makeFeedback(overrides) {
+    return {
+        messageId: "msg-001",
+        deliveryResult: "sent",
+        deliveryProof: { messageId: "msg-001" },
+        ownerReaction: "reply",
+        reactionContent: "Thanks for the update",
+        timestamp: new Date().toISOString(),
+        channelId: "email",
+        ...overrides,
+    };
+}
+function makeRelationshipPort(opts = {}) {
+    let callCount = 0;
+    const baseMemory = opts.memory ?? {
+        channelPreferences: [],
+        responsePatterns: [],
+        trustDelta: 0,
+    };
+    return {
+        async loadRelationshipMemory() {
+            return { ...baseMemory };
+        },
+        async updateRelationshipMemory() {
+            callCount++;
+            if (opts.failAfter !== undefined && callCount > opts.failAfter) {
+                return;
+            }
+            if (opts.failAfter !== undefined && callCount <= opts.failAfter) {
+                throw new Error("persist_failed");
+            }
+        },
+    };
+}
+function makeAuditPort() {
+    const logged = [];
+    return {
+        logged,
+        async recordFeedbackIngestionFailed(summary) {
+            logged.push(summary);
+        },
+    };
+}
+// ─── Success paths ──────────────────────────────────────────────────────────
+test("T-GVS.C.2 ingests reply feedback and updates trust positively", async () => {
+    const port = makeRelationshipPort();
+    const audit = makeAuditPort();
+    const result = await ingestChannelFeedback(makeFeedback(), {
+        relationshipPort: port,
+        auditPort: audit,
+    });
+    assert.equal(result.status, "ingested");
+    assert.ok(result.updatedTrust > 0);
+    assert.equal(result.relationshipUpdate?.deliverySuccess, true);
+    assert.equal(audit.logged.length, 0);
+});
+test("T-GVS.C.2 ingests ignore feedback and applies negative trust delta", async () => {
+    const port = makeRelationshipPort();
+    const audit = makeAuditPort();
+    const result = await ingestChannelFeedback(makeFeedback({ ownerReaction: "ignore", reactionContent: undefined }), { relationshipPort: port, auditPort: audit });
+    assert.equal(result.status, "ingested");
+    assert.ok(result.updatedTrust < 0);
+    assert.equal(result.relationshipUpdate?.responsePattern.reaction, "ignore");
+});
+test("T-GVS.C.2 block reaction triggers more_cautious tone adjustment", async () => {
+    const port = makeRelationshipPort();
+    const audit = makeAuditPort();
+    const result = await ingestChannelFeedback(makeFeedback({ ownerReaction: "block" }), { relationshipPort: port, auditPort: audit });
+    assert.equal(result.status, "ingested");
+    const toneAdj = result.strategyAdjustments?.find((a) => a.type === "tone");
+    assert.ok(toneAdj);
+    assert.equal(toneAdj.adjustment, "more_cautious");
+    assert.equal(toneAdj.reason, "user_blocked");
+});
+test("T-GVS.C.2 missing deliveryProof coerces sent to not_sent", async () => {
+    const port = makeRelationshipPort();
+    const audit = makeAuditPort();
+    const result = await ingestChannelFeedback(makeFeedback({ deliveryResult: "sent", deliveryProof: undefined }), { relationshipPort: port, auditPort: audit });
+    assert.equal(result.status, "ingested");
+    assert.equal(result.relationshipUpdate?.deliverySuccess, false);
+});
+test("T-GVS.C.2 reactionContent with email gets redacted", async () => {
+    const port = makeRelationshipPort();
+    const audit = makeAuditPort();
+    await ingestChannelFeedback(makeFeedback({ reactionContent: "Contact me at test@example.com" }), { relationshipPort: port, auditPort: audit });
+    // Redaction happens internally; we verify no crash and result is ingested
+    assert.equal(audit.logged.length, 0);
+});
+// ─── Rejection paths ────────────────────────────────────────────────────────
+test("T-GVS.C.2 feedback older than 30 days is rejected with errors", async () => {
+    const port = makeRelationshipPort();
+    const audit = makeAuditPort();
+    const oldDate = new Date(Date.now() - 31 * 24 * 60 * 60 * 1000).toISOString();
+    const result = await ingestChannelFeedback(makeFeedback({ timestamp: oldDate }), { relationshipPort: port, auditPort: audit });
+    assert.equal(result.status, "rejected");
+    assert.ok(result.errors?.includes("feedback_too_old"));
+    assert.equal(result.relationshipUpdate, undefined);
+});
+test("T-GVS.C.2 invalid timestamp is rejected", async () => {
+    const port = makeRelationshipPort();
+    const audit = makeAuditPort();
+    const result = await ingestChannelFeedback(makeFeedback({ timestamp: "not-a-date" }), { relationshipPort: port, auditPort: audit });
+    assert.equal(result.status, "rejected");
+    assert.ok(result.errors?.includes("invalid_timestamp"));
+});
+// ─── Retry / failure paths ──────────────────────────────────────────────────
+test("T-GVS.C.2 write failure retries 3 times then audits and returns failed_after_retries", async () => {
+    const port = makeRelationshipPort({ failAfter: 999 }); // always fails
+    const audit = makeAuditPort();
+    const start = Date.now();
+    const result = await ingestChannelFeedback(makeFeedback(), {
+        relationshipPort: port,
+        auditPort: audit,
+    });
+    const elapsed = Date.now() - start;
+    assert.equal(result.status, "failed_after_retries");
+    assert.ok(result.updatedTrust !== undefined);
+    assert.equal(audit.logged.length, 1);
+    assert.equal(audit.logged[0].retryCount, 3);
+    assert.equal(audit.logged[0].channelId, "email");
+    // Retry delays: 500 + 1000 + 2000 = 3500ms minimum
+    assert.ok(elapsed >= 3000, `expected at least 3000ms retry delay, got ${elapsed}ms`);
+});
+test("T-GVS.C.2 write succeeds on second retry", async () => {
+    let callCount = 0;
+    const port = {
+        async loadRelationshipMemory() {
+            return { channelPreferences: [], responsePatterns: [], trustDelta: 0 };
+        },
+        async updateRelationshipMemory() {
+            callCount++;
+            if (callCount < 2)
+                throw new Error("persist_failed");
+        },
+    };
+    const audit = makeAuditPort();
+    const start = Date.now();
+    const result = await ingestChannelFeedback(makeFeedback(), {
+        relationshipPort: port,
+        auditPort: audit,
+    });
+    const elapsed = Date.now() - start;
+    assert.equal(result.status, "ingested");
+    assert.equal(audit.logged.length, 0);
+    assert.ok(elapsed >= 400 && elapsed < 1500, `expected ~500ms delay, got ${elapsed}ms`);
+});
+// ─── Strategy adjustments ───────────────────────────────────────────────────
+test("T-GVS.C.2 negative trust triggers frequency decrease", async () => {
+    const port = makeRelationshipPort({
+        memory: { channelPreferences: [], responsePatterns: [], trustDelta: -2.0 },
+    });
+    const audit = makeAuditPort();
+    const result = await ingestChannelFeedback(makeFeedback(), {
+        relationshipPort: port,
+        auditPort: audit,
+    });
+    const freqAdj = result.strategyAdjustments?.find((a) => a.type === "frequency");
+    assert.ok(freqAdj);
+    assert.equal(freqAdj.adjustment, "decrease");
+});

package/dist/tests/unit/guidance/evidence-guidance.test.d.ts

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

package/dist/tests/unit/guidance/evidence-guidance.test.js

@@ -0,0 +1,40 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { buildEvidencePack, selectInterestBasis, buildQuietNarrativeGuidance, } from "../../../src/guidance/evidence-guidance.js";
+test("T6.1.2 buildEvidencePack strict rejects unresolved uri", () => {
+    const r = buildEvidencePack([{ id: "a", kind: "platform_item", uri: "" }], { policy: "strict" });
+    assert.equal(r.ok, false);
+    if (!r.ok)
+        assert.ok(r.reasons.includes("unresolved_source_refs"));
+});
+test("T6.1.2 buildEvidencePack lenient tolerates unresolved", () => {
+    const r = buildEvidencePack([
+        { id: "a", kind: "platform_item", uri: "https://x" },
+        { id: "b", kind: "platform_item", uri: "" },
+    ], { policy: "lenient" });
+    assert.equal(r.ok, true);
+    if (r.ok)
+        assert.ok(r.pack.unresolvedIds.includes("b"));
+});
+test("T6.1.2 selectInterestBasis insufficient → evidence_only or unavailable", () => {
+    assert.equal(selectInterestBasis({ staleness: "insufficient", confidence: 0, signalCount: 1 }), "evidence_only");
+    assert.equal(selectInterestBasis({ staleness: "insufficient", confidence: 0, signalCount: 0 }), "unavailable");
+});
+test("T6.1.2 buildQuietNarrativeGuidance blocks unsupported claims", () => {
+    const r = buildQuietNarrativeGuidance({
+        interestBasis: "evidence_only",
+        sourceCoverage: { coverageRatio: 1, unsupportedClaims: ["x"] },
+        outline: [],
+    });
+    assert.equal(r.status, "unavailable");
+});
+test("T6.1.2 buildQuietNarrativeGuidance ready path", () => {
+    const r = buildQuietNarrativeGuidance({
+        interestBasis: "evidence_only",
+        sourceCoverage: { coverageRatio: 0.9, unsupportedClaims: [] },
+        outline: ["a", "b"],
+    });
+    assert.equal(r.status, "ready");
+    if (r.status === "ready")
+        assert.ok(r.hints.some((h) => h.startsWith("hint:")));
+});

package/dist/tests/unit/guidance/guidance-draft-service.test.d.ts

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

package/dist/tests/unit/guidance/guidance-draft-service.test.js

@@ -0,0 +1,140 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { generateGuidanceDraft, validateDraftSources, } from "../../../src/guidance/index.js";
+function makeRequest(overrides) {
+    return {
+        requestId: "req-001",
+        sceneKind: "outreach",
+        evidencePackRef: "pack-001",
+        relationshipContextRef: "rel-001",
+        requestedAt: "2026-05-23T10:00:00Z",
+        ...overrides,
+    };
+}
+function makeSourceRef(id) {
+    return {
+        id,
+        kind: "platform_item",
+        uri: `https://example.com/item/${id}`,
+    };
+}
+// ─── generateGuidanceDraft ──────────────────────────────────────────────────
+test("T-GVS.C.1 generateGuidanceDraft produces DraftMessage with sourceRefs", async () => {
+    const evidencePort = {
+        async loadEvidencePack(ref) {
+            if (ref === "pack-001") {
+                return {
+                    claims: [
+                        { id: "c1", text: "Claim one", sourceRefs: [makeSourceRef("s1")] },
+                        { id: "c2", text: "Claim two", sourceRefs: [makeSourceRef("s2")] },
+                    ],
+                };
+            }
+            return undefined;
+        },
+    };
+    const result = await generateGuidanceDraft(makeRequest(), { evidencePort });
+    assert.ok(result.draft, "expected draft to be defined");
+    assert.equal(result.draft.sourceRefs.length, 2);
+    assert.equal(result.draft.sourceRefs[0].id, "s1");
+    assert.equal(result.draft.sourceRefs[1].id, "s2");
+    assert.equal(result.draft.deliveryWording, "sendable");
+    assert.ok(result.draft.text.includes("Claim one"));
+    assert.ok(result.draft.explanation.includes("relationshipContext=rel-001"));
+});
+test("T-GVS.C.1 generateGuidanceDraft returns error when evidence pack missing", async () => {
+    const evidencePort = {
+        async loadEvidencePack() {
+            return undefined;
+        },
+    };
+    const result = await generateGuidanceDraft(makeRequest(), { evidencePort });
+    assert.equal(result.error, "evidence_pack_unavailable");
+    assert.equal(result.draft, undefined);
+});
+test("T-GVS.C.1 generateGuidanceDraft returns error when claims have no sourceRefs", async () => {
+    const evidencePort = {
+        async loadEvidencePack() {
+            return {
+                claims: [{ id: "c1", text: "Claim without source", sourceRefs: [] }],
+            };
+        },
+    };
+    const result = await generateGuidanceDraft(makeRequest(), { evidencePort });
+    assert.equal(result.error, "draft_source_invalidated");
+});
+test("T-GVS.C.1 generateGuidanceDraft returns unsupported_scene_kind for invalid sceneKind", async () => {
+    const evidencePort = {
+        async loadEvidencePack() {
+            return {
+                claims: [{ id: "c1", text: "Claim one", sourceRefs: [makeSourceRef("s1")] }],
+            };
+        },
+    };
+    const result = await generateGuidanceDraft(makeRequest({ sceneKind: "invalid_scene" }), { evidencePort });
+    assert.equal(result.error, "unsupported_scene_kind");
+});
+test("T-GVS.C.1 generateGuidanceDraft uses inner-guide style per sceneKind", async () => {
+    const evidencePort = {
+        async loadEvidencePack() {
+            return {
+                claims: [{ id: "c1", text: "something interesting", sourceRefs: [makeSourceRef("s1")] }],
+            };
+        },
+    };
+    const outreach = await generateGuidanceDraft(makeRequest({ sceneKind: "outreach" }), { evidencePort });
+    assert.ok(outreach.draft.text.startsWith("有件事想跟你分享"));
+    const followUp = await generateGuidanceDraft(makeRequest({ sceneKind: "follow_up" }), { evidencePort });
+    assert.ok(followUp.draft.text.startsWith("接着上次聊的说一下"));
+    const reconnect = await generateGuidanceDraft(makeRequest({ sceneKind: "reconnect" }), { evidencePort });
+    assert.ok(reconnect.draft.text.startsWith("好久不见"));
+});
+// ─── validateDraftSources ────────────────────────────────────────────────────
+test("T-GVS.C.1 validateDraftSources passes when all sources available", async () => {
+    const validatorPort = {
+        async checkSourceAvailable() {
+            return true;
+        },
+    };
+    const draft = {
+        text: "Test draft",
+        deliveryWording: "sendable",
+        sourceRefs: [makeSourceRef("s1"), makeSourceRef("s2")],
+    };
+    const result = await validateDraftSources(draft, { validatorPort });
+    assert.equal(result.valid, true);
+    assert.equal(result.invalidated, undefined);
+    assert.equal(result.reason, undefined);
+});
+test("T-GVS.C.1 validateDraftSources fails when a source is redacted", async () => {
+    const validatorPort = {
+        async checkSourceAvailable(ref) {
+            return ref.id !== "s2";
+        },
+    };
+    const draft = {
+        text: "Test draft",
+        deliveryWording: "sendable",
+        sourceRefs: [makeSourceRef("s1"), makeSourceRef("s2")],
+    };
+    const result = await validateDraftSources(draft, { validatorPort });
+    assert.equal(result.valid, false);
+    assert.equal(result.invalidated, true);
+    assert.equal(result.reason, "draft_source_invalidated");
+});
+test("T-GVS.C.1 validateDraftSources fails when all sources deleted", async () => {
+    const validatorPort = {
+        async checkSourceAvailable() {
+            return false;
+        },
+    };
+    const draft = {
+        text: "Test draft",
+        deliveryWording: "sendable",
+        sourceRefs: [makeSourceRef("s1")],
+    };
+    const result = await validateDraftSources(draft, { validatorPort });
+    assert.equal(result.valid, false);
+    assert.equal(result.invalidated, true);
+    assert.equal(result.reason, "draft_source_invalidated");
+});

package/dist/tests/unit/guidance/impulse-assembler.test.d.ts

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

package/dist/tests/unit/guidance/impulse-assembler.test.js

@@ -0,0 +1,169 @@
+/**
+ * impulse-assembler.test.ts — T-V7C.C.4R
+ *
+ * Unit tests for ImpulseAssembler three-level fallback chain.
+ * Covers: platform-specific → capabilityClass → intentKind → none.
+ * Also verifies agent.* exclusion and explore/work pending-review fallthrough.
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { assembleImpulse, assembleImpulseSync, } from "../../../src/guidance/impulse-assembler.js";
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function makePlatformPort(overrides) {
+    return {
+        async loadPlatformImpulse({ platformId, capabilityClass }) {
+            return overrides.get(`${platformId}:${capabilityClass}`) ?? null;
+        },
+    };
+}
+const MOCK_PLATFORM_IMPULSE = {
+    kind: "social",
+    text: "moltbook platform specific impulse text",
+    reviewStatus: "approved",
+};
+// ─── assembleImpulseSync ──────────────────────────────────────────────────────
+describe("assembleImpulseSync — agent.* excluded", () => {
+    it("agent.heartbeat → null, source=none", () => {
+        const result = assembleImpulseSync({
+            sceneType: "social",
+            capabilityIntent: "agent.heartbeat",
+        });
+        assert.strictEqual(result.impulse, null);
+        assert.strictEqual(result.source, "none");
+        assert.strictEqual(result.capabilityClass, null);
+    });
+    it("agent.status → null", () => {
+        const result = assembleImpulseSync({
+            sceneType: "social",
+            capabilityIntent: "agent.status",
+        });
+        assert.strictEqual(result.impulse, null);
+        assert.strictEqual(result.source, "none");
+    });
+});
+describe("assembleImpulseSync — capabilityClass preset (explore/work approved)", () => {
+    it("post.publish + intentKind social → social impulse via intentKind fallback (broadcast has no cc template)", () => {
+        // capabilityClass=broadcast → CAPABILITY_CLASS_SCENE_MAP[broadcast]=social
+        // getCapabilityClassImpulseTemplate("social") — social is NOT a capability-class kind,
+        // so it falls through to intentKind
+        const result = assembleImpulseSync({
+            sceneType: "social",
+            capabilityIntent: "post.publish",
+        });
+        assert.ok(result.impulse !== null, "should have impulse");
+        assert.strictEqual(result.capabilityClass, "broadcast");
+        assert.ok(result.source === "capability_class" || result.source === "intent_kind", `expected capability_class or intent_kind, got ${result.source}`);
+    });
+    it("feed.read → capabilityClass=consume, returns explore impulse (approved)", () => {
+        // capabilityClass=consume → CAPABILITY_CLASS_SCENE_MAP[consume]=explore
+        // getCapabilityClassImpulseTemplate("explore") → approved impulse
+        const result = assembleImpulseSync({
+            sceneType: "social",
+            capabilityIntent: "feed.read",
+        });
+        assert.ok(result.impulse !== null, "should have explore capability_class impulse");
+        assert.strictEqual(result.capabilityClass, "consume");
+        assert.strictEqual(result.source, "capability_class");
+        assert.ok(result.impulse.text.length > 0);
+    });
+    it("task.claim → capabilityClass=claim, returns work impulse (approved)", () => {
+        const result = assembleImpulseSync({
+            sceneType: "social",
+            capabilityIntent: "task.claim",
+        });
+        assert.strictEqual(result.capabilityClass, "claim");
+        assert.strictEqual(result.source, "capability_class");
+        assert.ok(result.impulse !== null);
+    });
+});
+describe("assembleImpulseSync — explain/user_reply always no impulse", () => {
+    it("explain scene → no impulse regardless of capabilityIntent", () => {
+        const result = assembleImpulseSync({
+            sceneType: "explain",
+            capabilityIntent: "post.publish",
+        });
+        assert.strictEqual(result.impulse, null);
+        assert.strictEqual(result.source, "none");
+    });
+    it("user_reply scene → no impulse", () => {
+        const result = assembleImpulseSync({ sceneType: "user_reply" });
+        assert.strictEqual(result.impulse, null);
+        assert.strictEqual(result.source, "none");
+    });
+});
+describe("assembleImpulseSync — no capabilityIntent → intentKind only", () => {
+    it("social scene, no capability → social impulse via intentKind", () => {
+        const result = assembleImpulseSync({ sceneType: "social" });
+        assert.ok(result.impulse !== null);
+        assert.strictEqual(result.source, "intent_kind");
+        assert.strictEqual(result.capabilityClass, null);
+    });
+    it("reply scene, no capability → reply impulse", () => {
+        const result = assembleImpulseSync({ sceneType: "reply" });
+        assert.ok(result.impulse !== null);
+        assert.strictEqual(result.source, "intent_kind");
+        assert.ok(result.impulse.kind === "reply");
+    });
+    it("outreach scene → outreach impulse", () => {
+        const result = assembleImpulseSync({ sceneType: "outreach" });
+        assert.ok(result.impulse !== null);
+        assert.strictEqual(result.impulse.kind, "outreach");
+    });
+    it("quiet scene → quiet impulse", () => {
+        const result = assembleImpulseSync({ sceneType: "quiet" });
+        assert.ok(result.impulse !== null);
+        assert.strictEqual(result.impulse.kind, "quiet");
+    });
+});
+// ─── assembleImpulse (async — platform-specific) ─────────────────────────────
+describe("assembleImpulse — platform-specific priority", () => {
+    it("platform-specific impulse takes priority over capabilityClass and intentKind", async () => {
+        const overrides = new Map([["moltbook:broadcast", MOCK_PLATFORM_IMPULSE]]);
+        const port = makePlatformPort(overrides);
+        const result = await assembleImpulse({
+            sceneType: "social",
+            capabilityIntent: "post.publish",
+            platformId: "moltbook",
+        }, { platformImpulsePort: port });
+        assert.strictEqual(result.source, "platform_specific");
+        assert.strictEqual(result.impulse?.text, MOCK_PLATFORM_IMPULSE.text);
+        assert.strictEqual(result.capabilityClass, "broadcast");
+    });
+    it("no platform-specific → falls back to capabilityClass explore (approved)", async () => {
+        const port = makePlatformPort(new Map()); // no overrides
+        const result = await assembleImpulse({
+            sceneType: "social",
+            capabilityIntent: "feed.read",
+            platformId: "moltbook",
+        }, { platformImpulsePort: port });
+        // explore is approved → capability_class impulse (platform had no override)
+        assert.strictEqual(result.source, "capability_class");
+        assert.ok(result.impulse !== null);
+    });
+    it("agent.heartbeat → null even with platform port wired", async () => {
+        const overrides = new Map([["moltbook:broadcast", MOCK_PLATFORM_IMPULSE]]);
+        const port = makePlatformPort(overrides);
+        const result = await assembleImpulse({
+            sceneType: "social",
+            capabilityIntent: "agent.heartbeat",
+            platformId: "moltbook",
+        }, { platformImpulsePort: port });
+        assert.strictEqual(result.impulse, null);
+        assert.strictEqual(result.source, "none");
+    });
+    it("platform port throws → falls back gracefully to intentKind", async () => {
+        const faultyPort = {
+            loadPlatformImpulse: async () => {
+                throw new Error("port_error");
+            },
+        };
+        const result = await assembleImpulse({
+            sceneType: "social",
+            capabilityIntent: "post.publish",
+            platformId: "moltbook",
+        }, { platformImpulsePort: faultyPort });
+        // Should not throw; should fall back gracefully
+        assert.ok(result.source !== "platform_specific");
+        assert.ok(result.impulse !== null || result.source === "none");
+    });
+});

package/dist/tests/unit/guidance/outreach-draft-schema.test.d.ts

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