@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/integration/control-plane/quiet-reflection.test.js

@@ -0,0 +1,73 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { runQuietPipeline, runNarrativeReflection } from "../../../src/core/second-nature/index.js";
+test("quiet pipeline distinguishes daily memory curation from compaction/pruning", () => {
+    const output = runQuietPipeline({
+        quietState: {
+            mode: "quiet",
+            reflectionDebt: 1,
+            missedReflectionCount: 0,
+        },
+        bundle: {
+            journalEntries: [
+                { id: "j1", content: "browse", timestamp: "2026-03-25T01:00:00.000Z" },
+            ],
+            dailyReports: [
+                { id: "r1", summary: "daily report", highlights: ["h1"], sources: ["j1"] },
+            ],
+        },
+    });
+    assert.equal(output.shouldRunReflection, true);
+    assert.ok(output.curation.sourceRefs.includes("j1"));
+    assert.ok(output.curation.sourceRefs.includes("r1"));
+    assert.ok(output.curation.excludedCompactionArtifacts.includes("session_compaction"));
+    assert.ok(output.curation.excludedCompactionArtifacts.includes("context_pruning"));
+});
+test("narrative reflection enforces source-backed claim-level contract", async () => {
+    const result = await runNarrativeReflection({
+        async loadQuietInputs() {
+            return { sourceRefs: ["j1", "r1"] };
+        },
+        async generateNarrativeReflection() {
+            return {
+                summary: "reflection summary",
+                modelEvalRef: "eval-1",
+                claims: [
+                    { text: "claim-1", sourceRefs: ["j1"], claimType: "fact" },
+                    { text: "claim-2", sourceRefs: ["r1"], claimType: "inference" },
+                ],
+                proposedWrites: [
+                    { targetAssetId: "SOUL.md", content: "x", sourceRefs: ["j1"] },
+                    { targetAssetId: "USER.md", content: "y", sourceRefs: [] },
+                ],
+            };
+        },
+        filterAllowedWrites(writes) {
+            return writes;
+        },
+    }, { lookbackDays: 1 });
+    assert.equal(result.unsupportedClaimCount, 0);
+    assert.equal(result.sourceCoverageRatio, 1);
+    assert.equal(result.writes.length, 1);
+    assert.equal(result.writes[0]?.targetAssetId, "SOUL.md");
+});
+test("narrative reflection rejects unsupported claims", async () => {
+    await assert.rejects(() => runNarrativeReflection({
+        async loadQuietInputs() {
+            return { sourceRefs: ["j1"] };
+        },
+        async generateNarrativeReflection() {
+            return {
+                summary: "reflection summary",
+                modelEvalRef: "eval-2",
+                claims: [
+                    { text: "claim-unsupported", sourceRefs: [], claimType: "fact" },
+                ],
+                proposedWrites: [],
+            };
+        },
+        filterAllowedWrites(writes) {
+            return writes;
+        },
+    }, { lookbackDays: 1 }), /reflection_unsupported_claims/);
+});

package/dist/tests/integration/control-plane/rhythm-intent-guard.test.d.ts

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

package/dist/tests/integration/control-plane/rhythm-intent-guard.test.js

@@ -0,0 +1,99 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { decideDecisionBasis, evaluateGuards, planIntent, selectRhythmWindow, validateRhythmPolicy, } from "../../../src/core/second-nature/index.js";
+const baseSnapshot = {
+    mode: "active",
+    currentWindowId: "w-active",
+    pendingObligations: [],
+    recentOutreachHashes: [],
+    deniedIntents: [],
+    budgets: { socialUsed: 0, socialLimit: 10 },
+};
+const rhythmPolicy = {
+    timezone: "UTC",
+    quietSuppressionEnabled: true,
+    windows: [
+        { id: "w-active", startMinute: 0, endMinute: 1320, mode: "active" },
+        { id: "w-quiet", startMinute: 1320, endMinute: 1440, mode: "quiet" },
+    ],
+};
+test("rhythm policy model validates and window selection returns stable top-level mode", () => {
+    validateRhythmPolicy(rhythmPolicy);
+    const activeDecision = selectRhythmWindow("2026-03-25T10:00:00.000Z", baseSnapshot, rhythmPolicy);
+    assert.equal(activeDecision.windowId, "w-active");
+    assert.equal(activeDecision.topLevelMode, "active");
+    const quietDecision = selectRhythmWindow("2026-03-25T22:30:00.000Z", baseSnapshot, rhythmPolicy);
+    assert.equal(quietDecision.windowId, "w-quiet");
+    assert.equal(quietDecision.topLevelMode, "quiet");
+    const pausedDecision = selectRhythmWindow("2026-03-25T22:30:00.000Z", { ...baseSnapshot, mode: "paused_for_interrupt" }, rhythmPolicy);
+    assert.equal(pausedDecision.topLevelMode, "paused_for_interrupt");
+    const suppressedDecision = selectRhythmWindow("2026-03-25T10:00:00.000Z", { ...baseSnapshot, riskSuppressed: true }, rhythmPolicy);
+    assert.equal(suppressedDecision.topLevelMode, "maintenance_only");
+    const tokyoPolicy = {
+        ...rhythmPolicy,
+        timezone: "Asia/Tokyo",
+        windows: [
+            { id: "tokyo-active", startMinute: 0, endMinute: 480, mode: "active" },
+            { id: "tokyo-quiet", startMinute: 480, endMinute: 1440, mode: "quiet" },
+        ],
+    };
+    const tokyoDecision = selectRhythmWindow("2026-03-25T00:30:00.000Z", baseSnapshot, tokyoPolicy);
+    assert.equal(tokyoDecision.windowId, "tokyo-quiet");
+});
+test("intent planner produces layered candidates and stable ordering", () => {
+    const snapshot = {
+        ...baseSnapshot,
+        mode: "quiet",
+        pendingObligations: ["heartbeat"],
+    };
+    const intents = planIntent(snapshot);
+    assert.ok(intents.length > 0);
+    assert.equal(intents[0]?.kind, "work");
+    assert.ok(intents.some((intent) => intent.kind === "reflection"));
+    assert.ok(intents.some((intent) => intent.kind === "maintenance"));
+});
+test("guard layer applies duplicate budget quiet awaiting_user guards", () => {
+    const intents = planIntent({
+        ...baseSnapshot,
+        mode: "quiet",
+        budgets: { socialUsed: 10, socialLimit: 10 },
+    });
+    const social = intents.find((intent) => intent.kind === "social");
+    assert.ok(social);
+    const evaluation = evaluateGuards(social, {
+        ...baseSnapshot,
+        mode: "quiet",
+        budgets: { socialUsed: 10, socialLimit: 10 },
+        deniedIntents: [{ intentHash: social.idempotencyKey ?? `${social.kind}:${social.summary}`, reason: "duplicate_intent", at: "now" }],
+        awaitingUserInput: true,
+    });
+    assert.equal(evaluation.verdict, "defer", "duplicate_intent maps to defer before other deny reasons");
+    assert.ok(evaluation.reasons.includes("duplicate_intent"));
+    assert.ok(evaluation.reasons.includes("budget_exceeded"));
+    assert.ok(evaluation.reasons.includes("quiet_window_suppression"));
+    assert.ok(evaluation.reasons.includes("awaiting_user"));
+});
+test("decision basis stratification keeps rule_only/score_based/model_assisted paths", () => {
+    const activeDuty = planIntent({ ...baseSnapshot, mode: "active", pendingObligations: ["duty"] });
+    const exploration = activeDuty.find((item) => item.kind === "exploration");
+    const outreach = activeDuty.find((item) => item.kind === "outreach");
+    const obligation = activeDuty.find((item) => item.source === "obligation");
+    const quietLayered = planIntent({ ...baseSnapshot, mode: "quiet", pendingObligations: ["heartbeat"] });
+    const maintenance = quietLayered.find((item) => item.kind === "maintenance");
+    assert.ok(maintenance, "quiet window should still surface maintenance");
+    assert.ok(exploration && outreach && obligation, "active duty plan should surface exploration/outreach/obligation");
+    assert.equal(decideDecisionBasis(maintenance), "rule_only");
+    assert.equal(decideDecisionBasis(exploration), "score_based");
+    assert.equal(decideDecisionBasis(outreach), "model_assisted");
+    assert.equal(decideDecisionBasis(obligation), "rule_only");
+});
+test("rhythm policy validation rejects overlapping windows", () => {
+    assert.throws(() => validateRhythmPolicy({
+        timezone: "UTC",
+        quietSuppressionEnabled: true,
+        windows: [
+            { id: "a", startMinute: 0, endMinute: 600, mode: "active" },
+            { id: "b", startMinute: 500, endMinute: 700, mode: "quiet" },
+        ],
+    }), /overlapping_window_range/);
+});

package/dist/tests/integration/control-plane/run-heartbeat-cycle.test.d.ts

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

package/dist/tests/integration/control-plane/run-heartbeat-cycle.test.js

@@ -0,0 +1,80 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { runHeartbeatCycle, } from "../../../src/core/second-nature/heartbeat/index.js";
+test("T2.1.1 runtime unavailable returns runtime_carrier_only without lived loop", async () => {
+    const signal = {
+        trigger: "heartbeat_bridge",
+        scopeHint: "rhythm",
+        payload: { timestamp: "2026-05-02T10:00:00Z" },
+    };
+    const result = await runHeartbeatCycle({
+        signal,
+        runtimeAvailable: false,
+        deps: {
+            loadSnapshotInputs: async () => {
+                throw new Error("snapshot_should_not_load_when_runtime_unavailable");
+            },
+        },
+    });
+    assert.equal(result.status, "runtime_carrier_only");
+    assert.equal(result.scope, "rhythm");
+    assert.ok(result.reasons.includes("runtime_unavailable_no_lived_experience_loop"));
+});
+test("T2.1.1 user_task bypasses rhythm gate → heartbeat_ok", async () => {
+    const signal = {
+        trigger: "user_task",
+        payload: { timestamp: "2026-05-02T10:00:00Z" },
+    };
+    const result = await runHeartbeatCycle({
+        signal,
+        runtimeAvailable: true,
+        deps: {
+            loadSnapshotInputs: async () => {
+                throw new Error("snapshot_should_not_load_for_user_task_bypass");
+            },
+        },
+    });
+    assert.equal(result.scope, "user_task");
+    assert.equal(result.status, "heartbeat_ok");
+    assert.ok(result.reasons.includes("rhythm_gate_bypass_user_task"));
+});
+test("T2.1.1 user_reply returns light continuity skeleton", async () => {
+    const signal = {
+        trigger: "user_reply",
+        payload: { timestamp: "2026-05-02T10:00:00Z" },
+    };
+    const result = await runHeartbeatCycle({
+        signal,
+        runtimeAvailable: true,
+        deps: {
+            loadSnapshotInputs: async () => {
+                throw new Error("snapshot_should_not_load_for_user_reply_skeleton");
+            },
+        },
+    });
+    assert.equal(result.scope, "user_reply");
+    assert.equal(result.status, "heartbeat_ok");
+    assert.ok(result.reasons.some((r) => r.includes("user_reply")));
+});
+test("T2.1.1 rhythm path delegates to loop → silent_no_candidates when empty", async () => {
+    const signal = {
+        trigger: "heartbeat_bridge",
+        scopeHint: "rhythm",
+        payload: { timestamp: "2026-05-02T10:00:00Z" },
+    };
+    const deps = {
+        loadSnapshotInputs: async () => ({
+            mode: "maintenance_only",
+            currentWindowId: "window-default",
+            pendingObligations: [],
+            recentOutreachHashes: [],
+            deniedIntents: [],
+            budgets: { socialUsed: 0, socialLimit: 5 },
+            awaitingUserInput: false,
+        }),
+    };
+    const result = await runHeartbeatCycle({ signal, runtimeAvailable: true, deps });
+    assert.equal(result.scope, "rhythm");
+    assert.equal(result.status, "heartbeat_ok");
+    assert.ok(result.reasons.includes("silent_no_candidates"));
+});

package/dist/tests/integration/control-plane/t2-3-1-outreach-v6.test.d.ts

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

package/dist/tests/integration/control-plane/t2-3-1-outreach-v6.test.js

@@ -0,0 +1,208 @@
+/**
+ * Integration coverage for T2.3.1 — Outreach v6 judgment integration.
+ *
+ * Verifies:
+ * - judgment allow → draft request contains narrative/relationship context + source refs
+ * - judgment deny (value too low / missing interest) → no draft generated, only denied reason
+ * - judgment defer (cooldown / duplicate) → no draft generated, only deferred reason
+ * - delivery unavailable → draft is fallback_candidate with narrative context, operator fallback written
+ * - hard guard boundary: delivery policy and cooldown are respected
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { dispatchUserOutreachIntent } from "../../../src/core/second-nature/outreach/dispatch-user-outreach.js";
+import { createDraftOutreachMessagePort } from "../../../src/guidance/draft-outreach-message.js";
+import { createNarrativeStateStore } from "../../../src/storage/narrative/narrative-state-store.js";
+import { createRelationshipMemoryStore } from "../../../src/storage/relationship/relationship-memory-store.js";
+import { buildContinuitySnapshot } from "../../../src/core/second-nature/heartbeat/snapshot-builder.js";
+import { buildHeartbeatRuntimeSnapshot } from "../../../src/core/second-nature/heartbeat/runtime-snapshot.js";
+const ref = (id) => ({
+    id,
+    kind: "platform_item",
+    uri: `https://example.test/${id}`,
+});
+function makeSnapshot(ts) {
+    const inputs = {
+        mode: "active",
+        currentWindowId: "win_work_morning",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        lifeEvidenceRefs: [ref("ev-1")],
+        duplicateIntentKeys: [],
+        outreachCooldownKeys: [],
+    };
+    const continuity = buildContinuitySnapshot(inputs);
+    return buildHeartbeatRuntimeSnapshot(ts, inputs, continuity);
+}
+const candidate = {
+    id: "c-outreach-v6",
+    kind: "outreach",
+    priority: 5,
+    source: "tick",
+    summary: "platform direction check-in",
+    effectClass: "user_outreach",
+    sourceRefs: [ref("src-1")],
+};
+const judgeBase = {
+    userInterest: {
+        staleness: "fresh",
+        confidence: 0.9,
+        signals: [{ topic: "platform", confidence: 0.8, sourceRefs: [ref("int-1")] }],
+        sourceRefs: [ref("int-1")],
+    },
+    lifeEvidence: { empty: false, evidenceRefCount: 2 },
+    delivery: { target: "explicit", channel: "dm", recipient: "user-1" },
+};
+async function seedNarrativeAndRelationship(state) {
+    const narrativeStore = createNarrativeStateStore(state);
+    await narrativeStore.updateNarrativeState({
+        narrativeId: "default",
+        revision: 1,
+        focus: "Exploring platform integration",
+        progress: ["connected moltbook", "configured evomap"],
+        nextIntent: "reach out to owner about next steps",
+        confidence: 0.85,
+        sourceRefs: [{ sourceId: "ns-1", kind: "decision_record", url: "https://example.test/ns-1" }],
+        unsupportedClaims: [],
+        status: "active",
+        updatedAt: new Date().toISOString(),
+    });
+    const relStore = createRelationshipMemoryStore(state);
+    await relStore.upsertRelationshipMemory({
+        relationshipId: "default",
+        revision: 1,
+        tonePreference: "casual",
+        averageReplyDelayMinutes: 30,
+        noReplyCount: 0,
+        topicAffinities: [
+            { topic: "platform", affinity: 0.9 },
+            { topic: "work", affinity: 0.7 },
+        ],
+        lastInteractionAt: new Date().toISOString(),
+        sourceRefs: [{ sourceId: "rm-1", kind: "user_anchor", url: "https://example.test/rm-1" }],
+        updatedAt: new Date().toISOString(),
+    });
+}
+test("T2.3.1 allow + delivery available → draft contains narrative/relationship context", async () => {
+    const state = createStateDatabase(":memory:");
+    await seedNarrativeAndRelationship(state);
+    const guidance = createDraftOutreachMessagePort();
+    const delivery = {
+        sendDeliveryRequest: async () => ({
+            id: "attempt-1",
+            status: "sent",
+            messageId: "msg-1",
+        }),
+    };
+    const result = await dispatchUserOutreachIntent({
+        candidate,
+        snapshot: makeSnapshot("2026-05-16T10:00:00Z"),
+        judgeInput: { ...judgeBase, delivery: { target: "explicit", channel: "dm", recipient: "u1" } },
+        guidance,
+        delivery,
+        state,
+    });
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.some((r) => r === "outreach_sent"));
+    // T2.3.1: draft should carry narrative/relationship context (verified by guidance port)
+    // The deterministic guidance port embeds context into draft text when present.
+});
+test("T2.3.1 deny (value too low) → no draft, only denied reason", async () => {
+    const state = createStateDatabase(":memory:");
+    const guidance = createDraftOutreachMessagePort();
+    const delivery = {
+        sendDeliveryRequest: async () => ({ id: "a", status: "sent", messageId: "m" }),
+    };
+    const lowValueJudge = {
+        ...judgeBase,
+        userInterest: {
+            staleness: "insufficient",
+            confidence: 0.1,
+            signals: [],
+            sourceRefs: [],
+        },
+        lifeEvidence: { empty: true, evidenceRefCount: 0 },
+    };
+    const result = await dispatchUserOutreachIntent({
+        candidate: { ...candidate, sourceRefs: [] },
+        snapshot: makeSnapshot("2026-05-16T10:00:00Z"),
+        judgeInput: lowValueJudge,
+        guidance,
+        delivery,
+        state,
+    });
+    assert.equal(result.status, "denied");
+    assert.ok(result.reasons.some((r) => r === "value_score_too_low"));
+});
+test("T2.3.1 defer (cooldown) → no draft, only deferred reason", async () => {
+    const state = createStateDatabase(":memory:");
+    const guidance = createDraftOutreachMessagePort();
+    const delivery = {
+        sendDeliveryRequest: async () => ({ id: "a", status: "sent", messageId: "m" }),
+    };
+    const cooldownSnapshot = makeSnapshot("2026-05-16T10:00:00Z");
+    const inputs = {
+        mode: "active",
+        currentWindowId: "win_work_morning",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        lifeEvidenceRefs: [ref("ev-1")],
+        duplicateIntentKeys: [],
+        outreachCooldownKeys: [candidate.idempotencyKey ?? candidate.id],
+    };
+    const continuity = buildContinuitySnapshot(inputs);
+    const snapshot = buildHeartbeatRuntimeSnapshot("2026-05-16T10:00:00Z", inputs, continuity);
+    const result = await dispatchUserOutreachIntent({
+        candidate,
+        snapshot,
+        judgeInput: { ...judgeBase, cooldownBlocked: true },
+        guidance,
+        delivery,
+        state,
+    });
+    assert.equal(result.status, "deferred");
+    assert.ok(result.reasons.some((r) => r === "cooling_down"));
+});
+test("T2.3.1 delivery unavailable → fallback draft with narrative context + operator fallback", async () => {
+    const state = createStateDatabase(":memory:");
+    await seedNarrativeAndRelationship(state);
+    const guidance = createDraftOutreachMessagePort();
+    const delivery = {
+        sendDeliveryRequest: async () => ({ id: "a", status: "sent", messageId: "m" }),
+    };
+    const result = await dispatchUserOutreachIntent({
+        candidate,
+        snapshot: makeSnapshot("2026-05-16T10:00:00Z"),
+        judgeInput: { ...judgeBase, delivery: { target: "none" } },
+        guidance,
+        delivery,
+        state,
+    });
+    assert.equal(result.status, "delivery_unavailable");
+    assert.ok(result.fallbackRef);
+});
+test("T2.3.1 hard guard boundary: delivery policy blocks, no side effects attempted", async () => {
+    const state = createStateDatabase(":memory:");
+    await seedNarrativeAndRelationship(state);
+    let deliveryCalled = false;
+    const guidance = createDraftOutreachMessagePort();
+    const delivery = {
+        sendDeliveryRequest: async () => {
+            deliveryCalled = true;
+            return { id: "a", status: "sent", messageId: "m" };
+        },
+    };
+    const result = await dispatchUserOutreachIntent({
+        candidate,
+        snapshot: makeSnapshot("2026-05-16T10:00:00Z"),
+        judgeInput: { ...judgeBase, delivery: { target: "none" } },
+        guidance,
+        delivery,
+        state,
+    });
+    assert.equal(result.status, "delivery_unavailable");
+    assert.equal(deliveryCalled, false, "delivery.sendDeliveryRequest must not be called when delivery is unavailable");
+});

package/dist/tests/integration/control-plane/t2-4-1-heartbeat-platform-intent.test.d.ts

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

package/dist/tests/integration/control-plane/t2-4-1-heartbeat-platform-intent.test.js

@@ -0,0 +1,156 @@
+/**
+ * T2.4.1 — Platform-specific intent selection in heartbeat integration.
+ *
+ * Acceptance:
+ * A. accepted goal names platform → heartbeat selects intent with platformId.
+ * B. no registry / ambiguous capability → heartbeat still completes (platformId undefined).
+ * C. connector execution uses resolved platformId.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { ingestRhythmSignal } from "../../../src/core/second-nature/heartbeat/heartbeat-loop.js";
+import { CapabilityContractRegistry } from "../../../src/connectors/base/manifest.js";
+function createSignal() {
+    return {
+        trigger: "heartbeat_bridge",
+        payload: { timestamp: new Date().toISOString() },
+    };
+}
+function createSnapshotInputs(overrides) {
+    return {
+        mode: "active",
+        currentWindowId: "default",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        budgets: { socialUsed: 0, socialLimit: 5 },
+        lifeEvidenceRefs: [{ id: "base-ref", kind: "workspace_artifact", uri: "workspace://test" }],
+        platformEventCount: 1,
+        workEventCount: 0,
+        ...overrides,
+    };
+}
+function buildRegistry() {
+    const r = new CapabilityContractRegistry();
+    r.register({
+        platformId: "moltbook",
+        supportedCapabilities: ["feed.read", "comment.reply"],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["api_key"],
+        sourceRefPolicy: { minSourceRefs: 1 },
+    });
+    return r;
+}
+test("T2.4.1-A: goal names moltbook → heartbeat selects exploration intent with platformId=moltbook", async () => {
+    const result = await ingestRhythmSignal(createSignal(), {
+        loadSnapshotInputs: async () => createSnapshotInputs({
+            acceptedGoals: [
+                {
+                    goalId: "goal-001",
+                    description: "Explore opportunities on moltbook",
+                    completionCriteria: "scan feed daily",
+                    status: "accepted",
+                    origin: "owner_set",
+                    acceptedBy: "owner",
+                },
+            ],
+        }),
+        connectorRegistry: buildRegistry(),
+    });
+    assert.equal(result.status, "intent_selected");
+    // The selected intent should have platformId set by the planner.
+    // selectedIntentId encodes the platform (e.g. "intent-exploration-moltbook").
+    assert.ok(result.selectedIntentId?.includes("moltbook"), `expected selected intent to reference moltbook, got id=${result.selectedIntentId}`);
+});
+test("T2.4.1-A: goal names moltbook with connectorExecutor → executeEffect receives platformId=moltbook", async () => {
+    let capturedPlatformId;
+    const result = await ingestRhythmSignal(createSignal(), {
+        loadSnapshotInputs: async () => createSnapshotInputs({
+            acceptedGoals: [
+                {
+                    goalId: "goal-002",
+                    description: "Read moltbook feed",
+                    completionCriteria: "find 3 interesting posts",
+                    status: "accepted",
+                    origin: "owner_set",
+                    acceptedBy: "owner",
+                },
+            ],
+        }),
+        connectorRegistry: buildRegistry(),
+        connectorExecutor: {
+            executeEffect: async (req) => {
+                capturedPlatformId = req.platformId;
+                return {
+                    status: "success",
+                    data: { items: [{ id: "post-001" }] },
+                    metadata: {
+                        platformId: req.platformId,
+                        channel: "api_rest",
+                        latencyMs: 100,
+                    },
+                };
+            },
+        },
+    });
+    assert.equal(result.status, "intent_selected");
+    assert.equal(capturedPlatformId, "moltbook");
+    assert.ok(result.reasons.includes("connector_effect_executed"));
+});
+test("T2.4.1-B: no registry → heartbeat completes with platformId undefined (backward compat)", async () => {
+    const result = await ingestRhythmSignal(createSignal(), {
+        loadSnapshotInputs: async () => createSnapshotInputs(),
+        // No connectorRegistry
+    });
+    assert.equal(result.status, "intent_selected");
+    // With no registry, the planner still generates connector_action intents
+    // but without platformId — existing behavior preserved
+});
+test("T2.4.1-B: ambiguous platform without registry → intent selected without specific platform", async () => {
+    const result = await ingestRhythmSignal(createSignal(), {
+        loadSnapshotInputs: async () => createSnapshotInputs({
+            acceptedGoals: [
+                {
+                    goalId: "goal-003",
+                    description: "Explore new platforms",
+                    completionCriteria: "find opportunities",
+                    status: "accepted",
+                    origin: "owner_set",
+                    acceptedBy: "owner",
+                },
+            ],
+        }),
+    });
+    assert.equal(result.status, "intent_selected");
+});
+test("T2.4.1-C: goal priority boost still works when platformId is set", async () => {
+    const result = await ingestRhythmSignal(createSignal(), {
+        loadSnapshotInputs: async () => createSnapshotInputs({
+            acceptedGoals: [
+                {
+                    goalId: "goal-004",
+                    description: "moltbook exploration",
+                    completionCriteria: "scan moltbook",
+                    status: "accepted",
+                    origin: "owner_set",
+                    acceptedBy: "owner",
+                },
+            ],
+        }),
+        connectorRegistry: buildRegistry(),
+        connectorExecutor: {
+            executeEffect: async (req) => ({
+                status: "success",
+                data: { items: [] },
+                metadata: {
+                    platformId: req.platformId,
+                    channel: "api_rest",
+                    latencyMs: 100,
+                },
+            }),
+        },
+    });
+    assert.equal(result.status, "intent_selected");
+    // The goal should have boosted exploration to top priority
+    assert.ok(result.reasons.includes("connector_effect_executed"));
+});

package/dist/tests/integration/control-plane/t2-4-2-source-backed-outreach-loop.test.d.ts

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