@haaaiawd/second-nature 0.1.42 → 0.1.50

package/dist/tests/unit/control-plane/embodied-context-assembler.test.js

@@ -0,0 +1,182 @@
+/**
+ * EmbodiedContextAssembler tests — T-CP.C.1
+ *
+ * Coverage:
+ * - assembleEmbodiedContext loads all 5 state slices + affordance + selfHealth
+ * - all slices status = loaded when data present
+ * - degraded slice when DB unavailable, others remain loaded
+ * - recentInteractions LIFO trimmed to 10
+ * - toolExperience LIFO trimmed to 10
+ * - candidate dream outputs excluded (accepted only)
+ * - P95 < 400ms benchmark
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createGoalLifecycleStore } from "../../../src/storage/services/goal-lifecycle-store.js";
+import { createIdentityProfileStore } from "../../../src/storage/services/identity-profile-store.js";
+import { createInteractionSnapshotProjector } from "../../../src/storage/services/interaction-snapshot-projector.js";
+import { createToolExperienceStore } from "../../../src/storage/services/tool-experience-store.js";
+import { createEmbodiedContextStatePort } from "../../../src/storage/services/embodied-context-state-port.js";
+import { createAffordanceAssembler } from "../../../src/core/second-nature/body/tool-affordance/affordance-assembler.js";
+import { CapabilityContractRegistryV7 } from "../../../src/connectors/base/manifest-v7.js";
+import { createEmbodiedContextAssembler } from "../../../src/core/second-nature/heartbeat/embodied-context-assembler.js";
+describe("EmbodiedContextAssembler", () => {
+    function buildFixture() {
+        const db = createStateDatabase(":memory:");
+        const goalStore = createGoalLifecycleStore(db);
+        const identityStore = createIdentityProfileStore(db);
+        const projector = createInteractionSnapshotProjector(db);
+        const experienceStore = createToolExperienceStore(db);
+        const statePort = createEmbodiedContextStatePort({
+            database: db,
+            goalStore,
+            identityStore,
+            interactionProjector: projector,
+            experienceStore,
+        });
+        const registry = new CapabilityContractRegistryV7();
+        registry.register({
+            platformId: "twitter",
+            capabilities: [
+                {
+                    capabilityId: "cap-1",
+                    intent: "feed.read",
+                    probeConfig: {
+                        safeEndpoint: "http://localhost:9000/health",
+                        idempotencyClass: "read_only",
+                    },
+                },
+            ],
+            channelPriority: ["api_rest"],
+            credentialTypes: ["token"],
+        });
+        const affordanceAssembler = createAffordanceAssembler({
+            registry,
+            probeReader: {
+                getLatestProbeResult() {
+                    return { actualStatus: "available", createdAt: new Date().toISOString() };
+                },
+            },
+            credentialRequired: () => true,
+        });
+        return { db, statePort, affordanceAssembler, goalStore, identityStore, projector, experienceStore };
+    }
+    it("assembles all slices as loaded with fixture data", async () => {
+        const { db, statePort, affordanceAssembler, goalStore, identityStore, projector, experienceStore } = buildFixture();
+        // Seed identity
+        await identityStore.upsertIdentityProfile({
+            profileId: "default",
+            canonicalName: "Test Agent",
+            platformHandles: [
+                { platformId: "moltbook", handle: "@test" },
+                { platformId: "agent_world", handle: "@test" },
+                { platformId: "instreet", handle: "@test" },
+            ],
+            updatedAt: "2025-01-01T00:00:00Z",
+        });
+        // Seed goals
+        await goalStore.upsertAgentGoal({
+            goalId: "g1", kind: "short_term", scope: "global", status: "accepted", origin: "owner_set",
+            description: "Test goal", completionCriteria: "done", risk: "low",
+            priorityHint: 1, sourceRefs: ["system:seed"], createdAt: "2025-01-01T00:00:00Z",
+            updatedAt: "2025-01-01T00:00:00Z",
+        });
+        // Seed interactions via session_chronicle
+        db.sqlite.run(`INSERT INTO session_chronicle (entry_id, event_kind, actor, occurred_at, summary, result, source_refs_json)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`, ["e1", "interaction", "user", "2025-01-01T00:00:00Z", "Hello", "ok", "[]"]);
+        // Seed experiences
+        await experienceStore.appendToolExperience({
+            experienceId: "exp-1", connectorId: "twitter", capabilityId: "cap-1",
+            outcome: "success", latencyMs: 100, evidenceQuality: 1,
+            sourceRefs: ["test:exp"], triggerSource: "heartbeat", createdAt: "2025-01-01T00:00:00Z",
+        });
+        const assembler = createEmbodiedContextAssembler({
+            statePort,
+            affordanceAssembler,
+            selfHealthProvider: {
+                async loadSelfHealth() {
+                    return {
+                        status: "loaded",
+                        data: { snapshotId: "h1", dimensions: {}, checkedAt: "2025-01-01T00:00:00Z" },
+                    };
+                },
+            },
+            options: { profileId: "default" },
+        });
+        const ctx = await assembler.assembleEmbodiedContext();
+        assert.strictEqual(ctx.identity.status, "loaded");
+        assert.strictEqual(ctx.goals.status, "loaded");
+        assert.strictEqual(ctx.recentInteractions.status, "loaded");
+        assert.strictEqual(ctx.toolExperience.status, "loaded");
+        assert.strictEqual(ctx.acceptedDream.status, "degraded"); // no accepted dreams seeded
+        assert.strictEqual(ctx.affordanceMap.status, "loaded");
+        assert.strictEqual(ctx.selfHealth.status, "loaded");
+        assert(ctx.assembledAt > "2024-01-01");
+        db.close();
+    });
+    it("degraded slice when identity missing, others loaded", async () => {
+        const { db, statePort, affordanceAssembler } = buildFixture();
+        const assembler = createEmbodiedContextAssembler({
+            statePort,
+            affordanceAssembler,
+            options: { profileId: "missing" },
+        });
+        const ctx = await assembler.assembleEmbodiedContext();
+        assert.strictEqual(ctx.identity.status, "degraded");
+        assert.strictEqual(ctx.identity.reason, "identity_profile_degraded:missing");
+        assert.strictEqual(ctx.goals.status, "loaded"); // goals can still be loaded (empty)
+        db.close();
+    });
+    it("trims recentInteractions to LIFO 10", async () => {
+        const { db, statePort, affordanceAssembler, projector } = buildFixture();
+        for (let i = 0; i < 15; i++) {
+            db.sqlite.run(`INSERT INTO session_chronicle (entry_id, event_kind, actor, occurred_at, summary, result, source_refs_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`, [`e${i}`, "interaction", "user", new Date(Date.now() - i * 1000).toISOString(), `msg-${i}`, "ok", "[]"]);
+        }
+        const assembler = createEmbodiedContextAssembler({
+            statePort,
+            affordanceAssembler,
+            options: { profileId: "default", interactionLimit: 10 },
+        });
+        const ctx = await assembler.assembleEmbodiedContext();
+        assert.strictEqual(ctx.recentInteractions.data.length, 10);
+        db.close();
+    });
+    it("trims toolExperience to LIFO 10", async () => {
+        const { db, statePort, affordanceAssembler, experienceStore } = buildFixture();
+        for (let i = 0; i < 15; i++) {
+            await experienceStore.appendToolExperience({
+                experienceId: `exp-${i}`,
+                connectorId: "twitter",
+                capabilityId: "cap-1",
+                outcome: i % 2 === 0 ? "success" : "failure",
+                latencyMs: 100,
+                evidenceQuality: 1,
+                sourceRefs: ["test:exp"],
+                triggerSource: "heartbeat",
+                createdAt: new Date(Date.now() - i * 1000).toISOString(),
+            });
+        }
+        const assembler = createEmbodiedContextAssembler({
+            statePort,
+            affordanceAssembler,
+            options: { experienceLimit: 10 },
+        });
+        const ctx = await assembler.assembleEmbodiedContext();
+        assert.strictEqual(ctx.toolExperience.data.length, 10);
+        db.close();
+    });
+    it("P95 assembly under 400ms", async () => {
+        const { db, statePort, affordanceAssembler } = buildFixture();
+        const assembler = createEmbodiedContextAssembler({
+            statePort,
+            affordanceAssembler,
+        });
+        const start = performance.now();
+        await assembler.assembleEmbodiedContext();
+        const elapsed = performance.now() - start;
+        assert(elapsed < 400, `assembleEmbodiedContext took ${elapsed}ms, exceeds 400ms target`);
+        db.close();
+    });
+});

package/dist/tests/unit/control-plane/goal-lifecycle-policy.test.d.ts

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

package/dist/tests/unit/control-plane/goal-lifecycle-policy.test.js

@@ -0,0 +1,75 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createGoalLifecyclePolicy } from "../../../src/core/second-nature/heartbeat/goal-lifecycle-policy.js";
+function makeGoal(overrides = {}) {
+    return {
+        goalId: "g-1",
+        kind: "task_completion",
+        scope: "global",
+        status: "accepted",
+        origin: "owner",
+        description: "test goal",
+        completionCriteria: "done",
+        risk: "low",
+        priorityHint: 1,
+        sourceRefs: ["ref-1"],
+        createdAt: "2026-05-01T00:00:00Z",
+        updatedAt: "2026-05-01T00:00:00Z",
+        ...overrides,
+    };
+}
+describe("createGoalLifecyclePolicy", () => {
+    it("keeps single active goal without transitions", () => {
+        const policy = createGoalLifecyclePolicy();
+        const goals = [makeGoal()];
+        const result = policy.evaluate(goals);
+        assert.strictEqual(result.activeGoals.length, 1);
+        assert.strictEqual(result.transitionRequests.length, 0);
+    });
+    it("emits replace request for older same kind+scope goal", () => {
+        const policy = createGoalLifecyclePolicy();
+        const goals = [
+            makeGoal({ goalId: "g-old", updatedAt: "2026-05-01T00:00:00Z" }),
+            makeGoal({ goalId: "g-new", updatedAt: "2026-05-02T00:00:00Z" }),
+        ];
+        const result = policy.evaluate(goals);
+        assert.strictEqual(result.activeGoals.length, 1);
+        assert.strictEqual(result.activeGoals[0].goalId, "g-new");
+        assert.strictEqual(result.transitionRequests.length, 1);
+        assert.strictEqual(result.transitionRequests[0].newStatus, "replaced");
+        assert.strictEqual(result.transitionRequests[0].goalId, "g-old");
+        assert.ok(result.transitionRequests[0].reason.includes("same_kind_scope_replace"));
+    });
+    it("emits expire request for expired goal", () => {
+        const policy = createGoalLifecyclePolicy();
+        const goals = [
+            makeGoal({ expiresAt: "2020-01-01T00:00:00Z" }),
+        ];
+        const result = policy.evaluate(goals);
+        assert.strictEqual(result.transitionRequests.length, 1);
+        assert.strictEqual(result.transitionRequests[0].newStatus, "expired");
+        assert.strictEqual(result.transitionRequests[0].reason, "expires_at_reached");
+    });
+    it("ignores non-accepted goals", () => {
+        const policy = createGoalLifecyclePolicy();
+        const goals = [
+            makeGoal({ status: "completed" }),
+            makeGoal({ status: "rejected" }),
+        ];
+        const result = policy.evaluate(goals);
+        assert.strictEqual(result.activeGoals.length, 0);
+        assert.strictEqual(result.transitionRequests.length, 0);
+    });
+    it("handles multiple kind+scope groups independently", () => {
+        const policy = createGoalLifecyclePolicy();
+        const goals = [
+            makeGoal({ goalId: "g-a1", kind: "short_term", updatedAt: "2026-05-01T00:00:00Z" }),
+            makeGoal({ goalId: "g-a2", kind: "short_term", updatedAt: "2026-05-02T00:00:00Z" }),
+            makeGoal({ goalId: "g-b1", kind: "passive_sensing", updatedAt: "2026-05-01T00:00:00Z" }),
+            makeGoal({ goalId: "g-b2", kind: "passive_sensing", updatedAt: "2026-05-02T00:00:00Z" }),
+        ];
+        const result = policy.evaluate(goals);
+        assert.strictEqual(result.activeGoals.length, 2);
+        assert.strictEqual(result.transitionRequests.length, 2);
+    });
+});

package/dist/tests/unit/control-plane/hard-guard-evaluator.test.d.ts

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

package/dist/tests/unit/control-plane/hard-guard-evaluator.test.js

@@ -0,0 +1,113 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { evaluateHardGuards } from "../../../src/core/second-nature/orchestrator/hard-guard-evaluator.js";
+function makeIntent(overrides = {}) {
+    return {
+        id: "intent-test",
+        kind: "work",
+        priority: 100,
+        source: "tick",
+        platformId: "moltbook",
+        summary: "test intent",
+        effectClass: "connector_action",
+        sourceRefs: [{ id: "ref-1", kind: "platform_item", uri: "uri://1" }],
+        idempotencyKey: "test-key",
+        capabilityIntent: "feed.read",
+        ...overrides,
+    };
+}
+describe("evaluateHardGuards", () => {
+    const baseDeps = {
+        hasDuplicateIntent: () => false,
+        isOutreachCooldownClear: () => true,
+        affordanceMap: {
+            moltbook: [
+                { platformId: "moltbook", capabilityId: "feed.read", intent: "feed.read", status: "safe" },
+            ],
+        },
+    };
+    it("allows healthy connector_action with source refs and healthy affordance", () => {
+        const result = evaluateHardGuards(makeIntent(), baseDeps);
+        assert.strictEqual(result.verdict, "allow");
+        assert.deepStrictEqual(result.reasons, []);
+    });
+    it("defers connector_action when affordance status is painful (circuit open)", () => {
+        const intent = makeIntent();
+        const deps = {
+            ...baseDeps,
+            affordanceMap: {
+                moltbook: [
+                    { platformId: "moltbook", capabilityId: "feed.read", intent: "feed.read", status: "painful" },
+                ],
+            },
+        };
+        const result = evaluateHardGuards(intent, deps);
+        assert.strictEqual(result.verdict, "defer");
+        assert(result.reasons.includes("connector_circuit_open"));
+    });
+    it("defers connector_action when affordance status is unavailable", () => {
+        const intent = makeIntent();
+        const deps = {
+            ...baseDeps,
+            affordanceMap: {
+                moltbook: [
+                    { platformId: "moltbook", capabilityId: "feed.read", intent: "feed.read", status: "unavailable" },
+                ],
+            },
+        };
+        const result = evaluateHardGuards(intent, deps);
+        assert.strictEqual(result.verdict, "defer");
+        assert(result.reasons.includes("affordance_unavailable"));
+    });
+    it("denies when sourceRefs are missing for connector_action", () => {
+        const intent = makeIntent({ sourceRefs: [] });
+        const result = evaluateHardGuards(intent, baseDeps);
+        assert.strictEqual(result.verdict, "deny");
+        assert(result.reasons.includes("missing_source_refs"));
+    });
+    it("allows maintenance intent even without source refs", () => {
+        const intent = makeIntent({ effectClass: "maintenance", sourceRefs: [] });
+        const result = evaluateHardGuards(intent, baseDeps);
+        assert.strictEqual(result.verdict, "allow");
+    });
+    it("defers on duplicate intent", () => {
+        const deps = { ...baseDeps, hasDuplicateIntent: () => true };
+        const result = evaluateHardGuards(makeIntent(), deps);
+        assert.strictEqual(result.verdict, "defer");
+        assert(result.reasons.includes("duplicate_intent"));
+    });
+    it("defers on outreach cooldown", () => {
+        const intent = makeIntent({ effectClass: "user_outreach" });
+        const deps = { ...baseDeps, isOutreachCooldownClear: () => false };
+        const result = evaluateHardGuards(intent, deps);
+        assert.strictEqual(result.verdict, "defer");
+        assert(result.reasons.includes("outreach_cooldown"));
+    });
+    it("denies on budget exceeded", () => {
+        const intent = makeIntent({ kind: "social" });
+        const deps = { ...baseDeps, budgetExceeded: true };
+        const result = evaluateHardGuards(intent, deps);
+        assert.strictEqual(result.verdict, "deny");
+        assert(result.reasons.includes("budget_exceeded"));
+    });
+    it("denies on risk suppressed for exploration", () => {
+        const intent = makeIntent({ kind: "exploration" });
+        const deps = { ...baseDeps, riskSuppressed: true };
+        const result = evaluateHardGuards(intent, deps);
+        assert.strictEqual(result.verdict, "deny");
+        assert(result.reasons.includes("risk_suppressed"));
+    });
+    it("defers quiet suppression for outreach", () => {
+        const intent = makeIntent({ kind: "outreach" });
+        const deps = { ...baseDeps, quietBias: true };
+        const result = evaluateHardGuards(intent, deps);
+        assert.strictEqual(result.verdict, "defer");
+        assert(result.reasons.includes("quiet_window_suppression"));
+    });
+    it("defers when platform not found in affordance map", () => {
+        const intent = makeIntent({ platformId: "unknown_platform" });
+        const result = evaluateHardGuards(intent, baseDeps);
+        assert.strictEqual(result.verdict, "defer");
+        assert(result.reasons.includes("affordance_unavailable"));
+    });
+});

package/dist/tests/unit/control-plane/idle-curiosity-policy.test.d.ts

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

package/dist/tests/unit/control-plane/idle-curiosity-policy.test.js

@@ -0,0 +1,69 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createIdleCuriosityPolicy } from "../../../src/core/second-nature/heartbeat/idle-curiosity-policy.js";
+describe("createIdleCuriosityPolicy", () => {
+    const baseMap = {
+        moltbook: [
+            { platformId: "moltbook", capabilityId: "feed.read", intent: "feed.read", status: "safe" },
+        ],
+        evomap: [
+            { platformId: "evomap", capabilityId: "work.discover", intent: "work.discover", status: "exploratory" },
+        ],
+    };
+    it("selects a read-only healthy capability", () => {
+        const policy = createIdleCuriosityPolicy();
+        const result = policy.select(baseMap, []);
+        assert.ok(result.candidate);
+        assert.strictEqual(result.candidate.platformId, "evomap");
+        assert.strictEqual(result.reason, "idle_sensing_selected");
+    });
+    it("returns no_eligible_connector when no read-only capabilities exist", () => {
+        const policy = createIdleCuriosityPolicy();
+        const map = {
+            moltbook: [
+                { platformId: "moltbook", capabilityId: "post.write", intent: "post.write", status: "safe" },
+            ],
+        };
+        const result = policy.select(map, []);
+        assert.strictEqual(result.candidate, undefined);
+        assert.strictEqual(result.reason, "idle_policy_no_eligible_connector");
+    });
+    it("returns no_eligible_connector when all capabilities are painful", () => {
+        const policy = createIdleCuriosityPolicy();
+        const map = {
+            moltbook: [
+                { platformId: "moltbook", capabilityId: "feed.read", intent: "feed.read", status: "painful" },
+            ],
+        };
+        const result = policy.select(map, []);
+        assert.strictEqual(result.candidate, undefined);
+        assert.strictEqual(result.reason, "idle_policy_no_eligible_connector");
+    });
+    it("returns no_eligible_connector when all capabilities are unavailable", () => {
+        const policy = createIdleCuriosityPolicy();
+        const map = {
+            moltbook: [
+                { platformId: "moltbook", capabilityId: "feed.read", intent: "feed.read", status: "unavailable" },
+            ],
+        };
+        const result = policy.select(map, []);
+        assert.strictEqual(result.candidate, undefined);
+        assert.strictEqual(result.reason, "idle_policy_no_eligible_connector");
+    });
+    it("respects 1-hour cooldown per platform", () => {
+        const policy = createIdleCuriosityPolicy();
+        const history = [{ platformId: "evomap", at: new Date().toISOString() }];
+        const result = policy.select(baseMap, history);
+        // evomap is on cooldown, moltbook should be selected
+        assert.ok(result.candidate);
+        assert.strictEqual(result.candidate.platformId, "moltbook");
+    });
+    it("ignores expired cooldown entries", () => {
+        const policy = createIdleCuriosityPolicy();
+        const twoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
+        const history = [{ platformId: "evomap", at: twoHoursAgo }];
+        const result = policy.select(baseMap, history);
+        assert.ok(result.candidate);
+        assert.strictEqual(result.candidate.platformId, "evomap");
+    });
+});

package/dist/tests/unit/control-plane/intent-planner-source-ref-fallback.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Wave 80 — SourceRefs Goal-Bound Fallback tests
+ *
+ * When lifeEvidence is empty, exploration/social/outreach/reflection intents
+ * should derive sourceRefs from accepted goals so hard guard does not deny.
+ */
+export {};

package/dist/tests/unit/control-plane/intent-planner-source-ref-fallback.test.js

@@ -0,0 +1,124 @@
+/**
+ * Wave 80 — SourceRefs Goal-Bound Fallback tests
+ *
+ * When lifeEvidence is empty, exploration/social/outreach/reflection intents
+ * should derive sourceRefs from accepted goals so hard guard does not deny.
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { planCandidateIntents } from "../../../src/core/second-nature/orchestrator/intent-planner.js";
+import { buildHeartbeatRuntimeSnapshot } from "../../../src/core/second-nature/heartbeat/runtime-snapshot.js";
+import { buildContinuitySnapshot } from "../../../src/core/second-nature/heartbeat/snapshot-builder.js";
+function makeRuntime(ts, opts) {
+    const inputs = {
+        mode: opts?.mode ?? "active",
+        currentWindowId: "win_work_morning",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        lifeEvidenceRefs: opts?.evidenceCount && opts.evidenceCount > 0
+            ? Array.from({ length: opts.evidenceCount }, (_, i) => ({
+                id: `ev-${i}`,
+                kind: "connector_result",
+                uri: `platform://moltbook/item/ev-${i}`,
+            }))
+            : [],
+        platformEventCount: opts?.evidenceCount ?? 0,
+        workEventCount: 0,
+        duplicateIntentKeys: [],
+        outreachCooldownKeys: [],
+    };
+    const continuity = buildContinuitySnapshot(inputs);
+    return buildHeartbeatRuntimeSnapshot(ts, inputs, continuity);
+}
+describe("intent-planner sourceRefs fallback (W80)", () => {
+    it("fills empty sourceRefs from accepted goals for exploration intent", () => {
+        const runtime = makeRuntime("2026-05-27T10:00:00Z", { evidenceCount: 0 });
+        const candidates = planCandidateIntents(runtime, {
+            acceptedGoals: [
+                {
+                    goalId: "goal-explore-1",
+                    description: "Explore MoltBook integration opportunities",
+                    status: "accepted",
+                    origin: "owner_set",
+                },
+            ],
+        });
+        const exploration = candidates.find((c) => c.kind === "exploration");
+        assert.ok(exploration, "exploration candidate must be planned");
+        assert.ok(exploration.sourceRefs.length > 0, "exploration must have sourceRefs when accepted goals exist");
+        assert.ok(exploration.sourceRefs.some((r) => r.uri.startsWith("goal://")), "sourceRefs must contain goal-based refs");
+    });
+    it("fills empty sourceRefs from accepted goals for social intent", () => {
+        const runtime = makeRuntime("2026-05-27T10:00:00Z", { evidenceCount: 0 });
+        const candidates = planCandidateIntents(runtime, {
+            acceptedGoals: [
+                {
+                    goalId: "goal-social-1",
+                    description: "Engage community on social platforms",
+                    status: "accepted",
+                    origin: "owner_set",
+                },
+            ],
+        });
+        const social = candidates.find((c) => c.kind === "social");
+        assert.ok(social, "social candidate must be planned");
+        assert.ok(social.sourceRefs.length > 0, "social must have sourceRefs when accepted goals exist");
+    });
+    it("fills empty sourceRefs from accepted goals for outreach intent", () => {
+        const runtime = makeRuntime("2026-05-27T10:00:00Z", { evidenceCount: 0 });
+        const candidates = planCandidateIntents(runtime, {
+            acceptedGoals: [
+                {
+                    goalId: "goal-outreach-1",
+                    description: "Reach out to users about new features",
+                    status: "accepted",
+                    origin: "owner_set",
+                },
+            ],
+        });
+        const outreach = candidates.find((c) => c.kind === "outreach");
+        assert.ok(outreach, "outreach candidate must be planned");
+        assert.ok(outreach.sourceRefs.length > 0, "outreach must have sourceRefs when accepted goals exist");
+    });
+    it("prefers lifeEvidence refs over goal refs when both exist", () => {
+        const runtime = makeRuntime("2026-05-27T10:00:00Z", { evidenceCount: 3 });
+        const candidates = planCandidateIntents(runtime, {
+            acceptedGoals: [
+                {
+                    goalId: "goal-explore-1",
+                    description: "Explore MoltBook integration opportunities",
+                    status: "accepted",
+                    origin: "owner_set",
+                },
+            ],
+        });
+        const exploration = candidates.find((c) => c.kind === "exploration");
+        assert.ok(exploration, "exploration candidate must be planned");
+        assert.ok(exploration.sourceRefs.some((r) => r.id.startsWith("ev-")), "sourceRefs should prefer evidence refs over goal refs");
+    });
+    it("does not modify sourceRefs when no accepted goals relate to intent", () => {
+        const runtime = makeRuntime("2026-05-27T10:00:00Z", { evidenceCount: 0 });
+        const candidates = planCandidateIntents(runtime, {
+            acceptedGoals: [],
+        });
+        const exploration = candidates.find((c) => c.kind === "exploration");
+        if (exploration) {
+            assert.strictEqual(exploration.sourceRefs.length, 0, "sourceRefs remain empty when no goals and no evidence");
+        }
+    });
+    it("limits goal-based sourceRefs to max 4 per intent", () => {
+        const runtime = makeRuntime("2026-05-27T10:00:00Z", { evidenceCount: 0 });
+        const candidates = planCandidateIntents(runtime, {
+            acceptedGoals: Array.from({ length: 6 }, (_, i) => ({
+                goalId: `goal-${i}`,
+                description: `Goal ${i}`,
+                status: "accepted",
+                origin: "owner_set",
+            })),
+        });
+        const exploration = candidates.find((c) => c.kind === "exploration");
+        assert.ok(exploration, "exploration candidate must be planned");
+        assert.ok(exploration.sourceRefs.length <= 4, "goal-based sourceRefs must be capped at 4");
+    });
+});

package/dist/tests/unit/control-plane/rhythm-policy-snapshot-window.test.d.ts

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

package/dist/tests/unit/control-plane/rhythm-policy-snapshot-window.test.js

@@ -0,0 +1,64 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { PolicyRepository } from "../../../src/storage/repositories/policy-repository.js";
+import { loadRhythmPolicySnapshot } from "../../../src/storage/rhythm/rhythm-policy-snapshot.js";
+import { assertRhythmPolicySnapshotContract, rhythmPolicySnapshotToRhythmPolicy, } from "../../../src/core/second-nature/rhythm/policy-bridge.js";
+import { selectRhythmWindow } from "../../../src/core/second-nature/rhythm/select-window.js";
+const baseSnapshot = {
+    mode: "active",
+    currentWindowId: "w-active",
+    pendingObligations: [],
+    recentOutreachHashes: [],
+    deniedIntents: [],
+    budgets: { socialUsed: 0, socialLimit: 10 },
+};
+test("T2.1.2 RhythmPolicySnapshot from state has no allowedIntentKinds", async () => {
+    const state = createStateDatabase(":memory:");
+    const snap = await loadRhythmPolicySnapshot(state);
+    assert.equal("allowedIntentKinds" in snap, false);
+    state.close();
+});
+test("T2.1.2 field drift on snapshot object is rejected before window selection", () => {
+    assert.throws(() => assertRhythmPolicySnapshotContract({
+        quietEnabled: true,
+        allowedIntentKinds: [],
+    }), /rhythm_policy_snapshot_field_drift:allowedIntentKinds/);
+});
+test("T2.1.2 snapshot → bridge policy → selectRhythmWindow yields control-plane decision only", async () => {
+    const state = createStateDatabase(":memory:");
+    const policies = new PolicyRepository(state);
+    await policies.upsert({
+        platformId: "workspace",
+        socialDailyLimit: 3,
+        quietEnabled: true,
+        outreachDailyBudget: 2,
+        updatedAt: new Date().toISOString(),
+    });
+    const snap = await loadRhythmPolicySnapshot(state);
+    const rhythmPolicy = rhythmPolicySnapshotToRhythmPolicy(snap);
+    const quietTime = selectRhythmWindow("2026-03-25T23:00:00.000Z", baseSnapshot, rhythmPolicy);
+    assert.equal(quietTime.windowId, "w-quiet");
+    assert.equal(quietTime.topLevelMode, "quiet");
+    const workTime = selectRhythmWindow("2026-03-25T04:00:00.000Z", baseSnapshot, rhythmPolicy);
+    assert.equal(workTime.windowId, "w-work");
+    assert.equal(workTime.topLevelMode, "active");
+    assert.equal("allowedIntentKinds" in quietTime, false);
+    state.close();
+});
+test("T2.1.2 quietDisabled snapshot maps to single open window (maintenance bias via riskSuppressed)", async () => {
+    const state = createStateDatabase(":memory:");
+    const policies = new PolicyRepository(state);
+    await policies.upsert({
+        platformId: "workspace",
+        socialDailyLimit: 3,
+        quietEnabled: false,
+        outreachDailyBudget: 2,
+        updatedAt: new Date().toISOString(),
+    });
+    const snap = await loadRhythmPolicySnapshot(state);
+    const rhythmPolicy = rhythmPolicySnapshotToRhythmPolicy(snap);
+    const decision = selectRhythmWindow("2026-03-25T12:00:00.000Z", { ...baseSnapshot, riskSuppressed: true }, rhythmPolicy);
+    assert.equal(decision.topLevelMode, "maintenance_only");
+    state.close();
+});

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

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