@haaaiawd/second-nature 0.1.50 → 0.1.51

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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