@haaaiawd/second-nature 0.1.42 → 0.1.50

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

@@ -0,0 +1,165 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { runHeartbeatV7 } from "../../../src/core/second-nature/heartbeat/run-heartbeat-cycle-v7.js";
+import { createNoOpTraceEmitter } from "../../../src/core/second-nature/heartbeat/decision-trace-emitter.js";
+import { createDownstreamIntentOrchestrator } from "../../../src/core/second-nature/orchestrator/downstream-intent-orchestrator.js";
+import { evaluateHardGuards } from "../../../src/core/second-nature/orchestrator/hard-guard-evaluator.js";
+describe("runHeartbeatV7 unit", () => {
+    function makeSignal(overrides = {}) {
+        return {
+            trigger: "heartbeat_bridge",
+            payload: { timestamp: new Date().toISOString() },
+            ...overrides,
+        };
+    }
+    function makeBaseDeps() {
+        return {
+            assembler: {
+                assembleEmbodiedContext: async () => ({
+                    identity: {
+                        status: "loaded",
+                        data: {
+                            profileId: "p1",
+                            canonicalName: "test",
+                            platformHandles: [],
+                            updatedAt: new Date().toISOString(),
+                        },
+                    },
+                    goals: { status: "loaded", data: [] },
+                    recentInteractions: { status: "loaded", data: [] },
+                    toolExperience: { status: "loaded", data: [] },
+                    acceptedDream: { status: "loaded", data: [] },
+                    assembledAt: new Date().toISOString(),
+                }),
+            },
+            planner: {
+                planCandidates: () => [],
+            },
+            evaluateHardGuards,
+            buildGuardDeps: () => ({
+                hasDuplicateIntent: () => false,
+                isOutreachCooldownClear: () => true,
+            }),
+            downstreamOrchestrator: createDownstreamIntentOrchestrator(),
+            traceEmitter: createNoOpTraceEmitter(),
+        };
+    }
+    it("returns carrier_only when runtime unavailable", async () => {
+        const result = await runHeartbeatV7({
+            signal: makeSignal(),
+            runtimeAvailable: false,
+            deps: makeBaseDeps(),
+        });
+        assert.strictEqual(result.status, "runtime_carrier_only");
+    });
+    it("returns heartbeat_ok for user_task", async () => {
+        const result = await runHeartbeatV7({
+            signal: makeSignal({ trigger: "user_task" }),
+            runtimeAvailable: true,
+            deps: makeBaseDeps(),
+        });
+        assert.strictEqual(result.status, "heartbeat_ok");
+        assert.ok(result.reasons.includes("rhythm_gate_bypass_user_task"));
+    });
+    it("returns heartbeat_ok for user_reply", async () => {
+        const result = await runHeartbeatV7({
+            signal: makeSignal({ trigger: "user_reply" }),
+            runtimeAvailable: true,
+            deps: makeBaseDeps(),
+        });
+        assert.strictEqual(result.status, "heartbeat_ok");
+        assert.ok(result.reasons.includes("user_reply_light_continuity_skeleton"));
+    });
+    it("returns heartbeat_ok when no candidates", async () => {
+        const result = await runHeartbeatV7({
+            signal: makeSignal(),
+            runtimeAvailable: true,
+            deps: makeBaseDeps(),
+        });
+        assert.strictEqual(result.status, "heartbeat_ok");
+        assert.ok(result.reasons.includes("silent_no_candidates"));
+    });
+    it("selects first allowed intent", async () => {
+        const deps = makeBaseDeps();
+        deps.planner = {
+            planCandidates: () => [
+                {
+                    id: "intent-1",
+                    kind: "work",
+                    priority: 100,
+                    source: "tick",
+                    platformId: "moltbook",
+                    summary: "test work",
+                    effectClass: "connector_action",
+                    sourceRefs: [{ id: "ref-1", kind: "platform_item", uri: "uri://1" }],
+                    idempotencyKey: "key-1",
+                    capabilityIntent: "feed.read",
+                },
+            ],
+        };
+        deps.buildGuardDeps = () => ({
+            hasDuplicateIntent: () => false,
+            isOutreachCooldownClear: () => true,
+            affordanceMap: {
+                moltbook: [
+                    { platformId: "moltbook", capabilityId: "feed.read", intent: "feed.read", status: "safe" },
+                ],
+            },
+        });
+        const result = await runHeartbeatV7({
+            signal: makeSignal(),
+            runtimeAvailable: true,
+            deps,
+        });
+        assert.strictEqual(result.status, "intent_selected");
+        assert.strictEqual(result.selectedIntentId, "intent-1");
+        assert.ok(result.downstreamRequestId);
+    });
+    it("degrades when assembly exceeds P95", async () => {
+        const deps = makeBaseDeps();
+        deps.assembler = {
+            assembleEmbodiedContext: async () => {
+                await new Promise((r) => setTimeout(r, 2100));
+                return {
+                    identity: {
+                        status: "loaded",
+                        data: {
+                            profileId: "p1",
+                            canonicalName: "test",
+                            platformHandles: [],
+                            updatedAt: new Date().toISOString(),
+                        },
+                    },
+                    goals: { status: "loaded", data: [] },
+                    recentInteractions: { status: "loaded", data: [] },
+                    toolExperience: { status: "loaded", data: [] },
+                    acceptedDream: { status: "loaded", data: [] },
+                    assembledAt: new Date().toISOString(),
+                };
+            },
+        };
+        const result = await runHeartbeatV7({
+            signal: makeSignal(),
+            runtimeAvailable: true,
+            deps,
+        });
+        assert.strictEqual(result.status, "heartbeat_ok");
+        assert.ok(result.reasons.some((r) => r.includes("assembly_p95_exceeded")));
+    });
+    it("handles null payload gracefully", async () => {
+        const result = await runHeartbeatV7({
+            signal: { trigger: "heartbeat_bridge", payload: null },
+            runtimeAvailable: true,
+            deps: makeBaseDeps(),
+        });
+        assert.ok(result.status === "heartbeat_ok" || result.status === "runtime_carrier_only");
+    });
+    it("handles array payload gracefully", async () => {
+        const result = await runHeartbeatV7({
+            signal: { trigger: "heartbeat_bridge", payload: [] },
+            runtimeAvailable: true,
+            deps: makeBaseDeps(),
+        });
+        assert.ok(result.status === "heartbeat_ok" || result.status === "runtime_carrier_only");
+    });
+});

package/dist/tests/unit/control-plane/t2-1-4-goal-priority.test.d.ts

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

package/dist/tests/unit/control-plane/t2-1-4-goal-priority.test.js

@@ -0,0 +1,185 @@
+/**
+ * Unit coverage for `applyGoalPriority` (T2.1.4).
+ *
+ * Verifies accepted goal boost, user_task > accepted_goal > rhythm precedence,
+ * proposal/rejected goal no-op, and multi-goal cumulative boost.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { applyGoalPriority } from "../../../src/core/second-nature/orchestrator/goal-priority.js";
+function makeCandidate(overrides = {}) {
+    return {
+        id: "intent-test",
+        kind: "work",
+        priority: 50,
+        source: "tick",
+        summary: "test intent",
+        effectClass: "connector_action",
+        sourceRefs: [],
+        ...overrides,
+    };
+}
+function makeGoal(overrides = {}) {
+    return {
+        goalId: "goal-001",
+        kind: "short_term",
+        status: "accepted",
+        origin: "owner_set",
+        description: "improve EvoMap profile",
+        completionCriteria: "EvoMap connector fully configured",
+        risk: "low",
+        priorityHint: 1,
+        sourceRefs: [],
+        createdAt: "2026-05-16T00:00:00.000Z",
+        updatedAt: "2026-05-16T00:00:00.000Z",
+        ...overrides,
+    };
+}
+test("T2.1.4 accepted goal boosts related candidate priority", () => {
+    const candidates = [
+        makeCandidate({ id: "intent-evomap", platformId: "evomap", priority: 60 }),
+        makeCandidate({ id: "intent-moltbook", platformId: "moltbook", priority: 55 }),
+    ];
+    const goals = [makeGoal({ goalId: "g1", description: "improve EvoMap profile" })];
+    const result = applyGoalPriority(candidates, goals);
+    const evomap = result.candidates.find((c) => c.id === "intent-evomap");
+    const moltbook = result.candidates.find((c) => c.id === "intent-moltbook");
+    assert.ok(evomap.priority > 60, "EvoMap intent should be boosted");
+    assert.equal(moltbook.priority, 55, "Moltbook intent should not be boosted");
+    assert.deepEqual(evomap.goalInfluenceRefs, ["g1"]);
+    assert.ok(evomap.priorityReasons?.some((r) => r.includes("goal_boost")), "reason should reference goal");
+});
+test("T2.1.4 proposal goal does not boost priority", () => {
+    const candidates = [makeCandidate({ id: "intent-evomap", platformId: "evomap", priority: 60 })];
+    const goals = [makeGoal({ goalId: "g1", status: "proposal", description: "improve EvoMap profile" })];
+    const result = applyGoalPriority(candidates, goals);
+    assert.equal(result.candidates[0].priority, 60, "proposal goal must not boost");
+    assert.equal(result.candidates[0].goalInfluenceRefs, undefined);
+});
+test("T2.1.4 rejected goal does not boost priority", () => {
+    const candidates = [makeCandidate({ id: "intent-evomap", platformId: "evomap", priority: 60 })];
+    const goals = [makeGoal({ goalId: "g1", status: "rejected", description: "improve EvoMap profile" })];
+    const result = applyGoalPriority(candidates, goals);
+    assert.equal(result.candidates[0].priority, 60, "rejected goal must not boost");
+});
+test("T2.1.4 user_task scope precedes accepted_goal precedes rhythm", () => {
+    // This is implicitly tested by the priority ordering; user_task bypasses the rhythm planner entirely.
+    // Here we verify that goal-boosted candidates still respect the base priority ordering.
+    const candidates = [
+        makeCandidate({ id: "intent-a", platformId: "evomap", priority: 80 }),
+        makeCandidate({ id: "intent-b", platformId: "evomap", priority: 50 }),
+    ];
+    const goals = [makeGoal({ goalId: "g1", description: "improve EvoMap profile" })];
+    const result = applyGoalPriority(candidates, goals);
+    // Both get boosted, but intent-a should still outrank intent-b
+    const a = result.candidates.find((c) => c.id === "intent-a");
+    const b = result.candidates.find((c) => c.id === "intent-b");
+    assert.ok(a.priority > b.priority, "higher base priority must remain after goal boost");
+});
+test("T2.1.4 multiple accepted goals cumulative boost", () => {
+    const candidates = [makeCandidate({ id: "intent-evomap", platformId: "evomap", priority: 60 })];
+    const goals = [
+        makeGoal({ goalId: "g1", description: "improve EvoMap profile" }),
+        makeGoal({ goalId: "g2", description: "EvoMap onboarding complete" }),
+    ];
+    const result = applyGoalPriority(candidates, goals);
+    assert.equal(result.candidates[0].goalInfluenceRefs.length, 2);
+    assert.equal(result.goalInfluences[0].boost, 40, "two goals = 2 * 20 boost");
+});
+test("T2.1.4 empty goals returns candidates unchanged", () => {
+    const candidates = [makeCandidate({ id: "intent-a", priority: 50 })];
+    const result = applyGoalPriority(candidates, []);
+    assert.equal(result.candidates[0].priority, 50);
+    assert.equal(result.goalInfluences.length, 0);
+});
+test("T2.1.4 undefined goals returns candidates unchanged", () => {
+    const candidates = [makeCandidate({ id: "intent-a", priority: 50 })];
+    const result = applyGoalPriority(candidates, undefined);
+    assert.equal(result.candidates[0].priority, 50);
+});
+// Boundary tests for Wave 26 fix
+test("T2.1.4 boundary: plain agent_proposed goals are filtered out", () => {
+    const candidates = [makeCandidate({ id: "intent-evomap", platformId: "evomap", priority: 60 })];
+    const goals = [
+        makeGoal({ goalId: "g1", status: "accepted", origin: "agent_proposed", description: "improve EvoMap profile" }),
+        makeGoal({ goalId: "g2", status: "accepted", origin: "owner_set", description: "EvoMap onboarding" }),
+    ];
+    const result = applyGoalPriority(candidates, goals);
+    // Only non-agent-proposed accepted goal should boost
+    assert.equal(result.goalInfluences.length, 1);
+    assert.deepEqual(result.goalInfluences[0].goalIds, ["g2"]);
+    assert.ok(result.candidates[0].priority > 60, "should be boosted by owner_set goal only");
+});
+test("T2.1.4 boundary: policy-accepted agent_proposed goals are included", () => {
+    const candidates = [makeCandidate({ id: "intent-evomap", platformId: "evomap", priority: 60 })];
+    const goals = [
+        makeGoal({ goalId: "g1", status: "accepted", origin: "agent_proposed", acceptedBy: "policy_allowlist", description: "improve EvoMap profile" }),
+        makeGoal({ goalId: "g2", status: "accepted", origin: "owner_set", description: "EvoMap onboarding" }),
+    ];
+    const result = applyGoalPriority(candidates, goals);
+    // Both goals should boost because g1 is policy-accepted
+    assert.equal(result.goalInfluences.length, 1);
+    assert.deepEqual(result.goalInfluences[0].goalIds, ["g1", "g2"]);
+    assert.equal(result.goalInfluences[0].boost, 40, "two goals = 2 * 20 boost");
+});
+test("T2.1.4 boundary: completed goals are filtered out", () => {
+    const candidates = [makeCandidate({ id: "intent-evomap", platformId: "evomap", priority: 60 })];
+    const goals = [
+        makeGoal({ goalId: "g1", status: "completed", description: "improve EvoMap profile" }),
+        makeGoal({ goalId: "g2", status: "accepted", description: "EvoMap onboarding" }),
+    ];
+    const result = applyGoalPriority(candidates, goals);
+    // Only accepted goal should boost
+    assert.equal(result.goalInfluences.length, 1);
+    assert.deepEqual(result.goalInfluences[0].goalIds, ["g2"]);
+});
+test("T2.1.4 boundary: paused goals are filtered out", () => {
+    const candidates = [makeCandidate({ id: "intent-evomap", platformId: "evomap", priority: 60 })];
+    const goals = [
+        makeGoal({ goalId: "g1", status: "paused", description: "improve EvoMap profile" }),
+        makeGoal({ goalId: "g2", status: "accepted", description: "EvoMap onboarding" }),
+    ];
+    const result = applyGoalPriority(candidates, goals);
+    // Only accepted goal should boost
+    assert.equal(result.goalInfluences.length, 1);
+    assert.deepEqual(result.goalInfluences[0].goalIds, ["g2"]);
+});
+test("T2.1.4 boundary: case-insensitive platform matching", () => {
+    const candidates = [
+        makeCandidate({ id: "intent-evomap", platformId: "EvoMap", priority: 60 }),
+        makeCandidate({ id: "intent-moltbook", platformId: "MOLTBOOK", priority: 55 }),
+    ];
+    const goals = [
+        makeGoal({ goalId: "g1", description: "improve evomap profile", completionCriteria: "evomap profile done" }),
+        makeGoal({ goalId: "g2", description: "moltbook configuration", completionCriteria: "moltbook configured" }),
+    ];
+    const result = applyGoalPriority(candidates, goals);
+    const evomap = result.candidates.find((c) => c.id === "intent-evomap");
+    const moltbook = result.candidates.find((c) => c.id === "intent-moltbook");
+    assert.ok(evomap.priority > 60, "EvoMap should be boosted (case-insensitive)");
+    assert.ok(moltbook.priority > 55, "Moltbook should be boosted (case-insensitive)");
+    assert.deepEqual(evomap.goalInfluenceRefs, ["g1"]);
+    assert.deepEqual(moltbook.goalInfluenceRefs, ["g2"]);
+});
+test("T2.1.4 boundary: platformId overflow protection", () => {
+    const candidates = [
+        makeCandidate({
+            id: "intent-evomap",
+            platformId: "evomap",
+            priority: 60,
+            priorityReasons: ["base"]
+        }),
+    ];
+    // Create many goals to test overflow protection
+    const goals = Array.from({ length: 100 }, (_, i) => makeGoal({
+        goalId: `g${i}`,
+        description: `improve evomap profile ${i}`
+    }));
+    const result = applyGoalPriority(candidates, goals);
+    const evomap = result.candidates[0];
+    assert.ok(evomap.priority > 60, "should be boosted");
+    assert.equal(evomap.goalInfluenceRefs.length, 100, "should track all influences");
+    assert.ok(evomap.priorityReasons.length > 1, "should have boost reasons");
+    // Priority should be reasonable (not overflowed)
+    assert.ok(evomap.priority < 10000, "priority should not overflow");
+});

package/dist/tests/unit/control-plane/t2-1-5-narrative-update.test.d.ts

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

package/dist/tests/unit/control-plane/t2-1-5-narrative-update.test.js

@@ -0,0 +1,313 @@
+/**
+ * Unit coverage for `updateNarrativeAfterEffect` (T2.1.5).
+ *
+ * Verifies source-backed active revision, awaiting_sources on missing refs,
+ * prior-state preservation for no-action cycles, and heartbeat-loop integration.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { updateNarrativeAfterEffect } from "../../../src/core/second-nature/orchestrator/narrative-update.js";
+import { ingestRhythmSignal } from "../../../src/core/second-nature/heartbeat/heartbeat-loop.js";
+function makeCandidate(overrides = {}) {
+    return {
+        id: "intent-test",
+        kind: "work",
+        priority: 50,
+        source: "tick",
+        summary: "test intent",
+        effectClass: "connector_action",
+        sourceRefs: [],
+        ...overrides,
+    };
+}
+function makeResult(overrides = {}) {
+    return {
+        scope: "rhythm",
+        status: "heartbeat_ok",
+        reasons: ["test"],
+        ...overrides,
+    };
+}
+function makeLifeEvidence(overrides = {}) {
+    return {
+        evidenceRefs: [],
+        platformEventCount: 0,
+        workEventCount: 0,
+        ...overrides,
+    };
+}
+function makePriorState(overrides = {}) {
+    return {
+        narrativeId: "default",
+        revision: 3,
+        focus: "previous focus",
+        progress: ["step-1", "step-2"],
+        nextIntent: "continue",
+        confidence: 0.5,
+        sourceRefs: [{ sourceId: "ev-1", kind: "workspace_artifact" }],
+        unsupportedClaims: [],
+        status: "active",
+        updatedAt: "2026-05-15T00:00:00.000Z",
+        ...overrides,
+    };
+}
+// ── Pure function tests ─────────────────────────────────────────────────────
+test("T2.1.5 intent_selected with sources → active revision", () => {
+    const result = makeResult({ status: "intent_selected", selectedIntentId: "intent-test" });
+    const intent = makeCandidate({
+        summary: "EvoMap profile updated",
+        sourceRefs: [{ id: "ev-1", kind: "connector_result", uri: "evomap://profile" }],
+    });
+    const lifeEvidence = makeLifeEvidence({ evidenceRefs: [{ id: "ev-1", kind: "connector_result", uri: "evomap://profile" }] });
+    const update = updateNarrativeAfterEffect({
+        result,
+        selectedIntent: intent,
+        lifeEvidence,
+        priorNarrative: makePriorState(),
+    });
+    assert.equal(update.status, "active");
+    assert.equal(update.focus, "EvoMap profile updated");
+    assert.ok(update.progress.some((p) => p.startsWith("connector_action:")));
+    assert.equal(update.sourceRefs.length, 1);
+    assert.equal(update.sourceRefs[0].sourceId, "ev-1");
+    assert.equal(update.unsupportedClaims.length, 0);
+    assert.ok(update.confidence > 0);
+    assert.equal(update.revision, 4);
+});
+test("T2.1.5 intent_selected without sources → awaiting_sources", () => {
+    const result = makeResult({ status: "intent_selected", selectedIntentId: "intent-test" });
+    const intent = makeCandidate({ summary: " risky action" });
+    const lifeEvidence = makeLifeEvidence();
+    const update = updateNarrativeAfterEffect({
+        result,
+        selectedIntent: intent,
+        lifeEvidence,
+        priorNarrative: makePriorState(),
+    });
+    assert.equal(update.status, "awaiting_sources");
+    assert.equal(update.confidence, 0);
+    assert.equal(update.sourceRefs.length, 0);
+    assert.ok(update.unsupportedClaims.includes(" risky action"));
+    assert.equal(update.nextIntent, "await_sources");
+});
+test("T2.1.5 heartbeat_ok with prior state → preserve and bump revision", () => {
+    const prior = makePriorState();
+    const update = updateNarrativeAfterEffect({
+        result: makeResult(),
+        lifeEvidence: makeLifeEvidence(),
+        priorNarrative: prior,
+    });
+    assert.equal(update.revision, 4);
+    assert.equal(update.focus, prior.focus);
+    assert.deepEqual(update.progress, prior.progress);
+    assert.equal(update.status, prior.status);
+    assert.ok(update.updatedAt > prior.updatedAt);
+});
+test("T2.1.5 heartbeat_ok without prior state → seed awaiting_sources", () => {
+    const update = updateNarrativeAfterEffect({
+        result: makeResult(),
+        lifeEvidence: makeLifeEvidence(),
+        priorNarrative: null,
+    });
+    assert.equal(update.narrativeId, "default");
+    assert.equal(update.revision, 1);
+    assert.equal(update.status, "awaiting_sources");
+    assert.equal(update.focus, "awaiting_evidence");
+    assert.equal(update.progress.length, 0);
+    assert.equal(update.confidence, 0);
+});
+test("T2.1.5 denied with prior state → preserve state", () => {
+    const prior = makePriorState();
+    const update = updateNarrativeAfterEffect({
+        result: makeResult({ status: "denied" }),
+        lifeEvidence: makeLifeEvidence(),
+        priorNarrative: prior,
+    });
+    assert.equal(update.status, prior.status);
+    assert.equal(update.revision, 4);
+});
+test("T2.1.5 progress bounded to max entries", () => {
+    const prior = makePriorState({
+        progress: Array.from({ length: 15 }, (_, i) => `step-${i}`),
+    });
+    const result = makeResult({ status: "intent_selected", selectedIntentId: "intent-test" });
+    const intent = makeCandidate({
+        summary: "new action",
+        sourceRefs: [{ id: "ev-1", kind: "connector_result", uri: "evomap://x" }],
+    });
+    const update = updateNarrativeAfterEffect({
+        result,
+        selectedIntent: intent,
+        lifeEvidence: makeLifeEvidence({ evidenceRefs: [{ id: "ev-1", kind: "connector_result", uri: "evomap://x" }] }),
+        priorNarrative: prior,
+    });
+    assert.equal(update.progress.length, 10);
+    assert.ok(update.progress.some((p) => p.startsWith("connector_action:")));
+});
+test("T2.1.5 confidence based on source count", () => {
+    const result = makeResult({ status: "intent_selected", selectedIntentId: "intent-test" });
+    const intent = makeCandidate({
+        summary: "action",
+        sourceRefs: [
+            { id: "ev-1", kind: "connector_result", uri: "a" },
+            { id: "ev-2", kind: "connector_result", uri: "b" },
+            { id: "ev-3", kind: "connector_result", uri: "c" },
+        ],
+    });
+    const update = updateNarrativeAfterEffect({
+        result,
+        selectedIntent: intent,
+        lifeEvidence: makeLifeEvidence(),
+    });
+    assert.equal(update.confidence, 0.8); // 3 sources → 0.80 (tiered sigmoid)
+});
+// ── Integration: ingestRhythmSignal writes to store ─────────────────────────
+test("T2.1.5 heartbeat loop writes narrative update when store is wired", async () => {
+    const updates = [];
+    const mockStore = {
+        async updateNarrativeState(input) {
+            updates.push(input);
+            return { narrativeId: input.narrativeId, status: "acknowledged" };
+        },
+        async loadNarrativeState() {
+            return null;
+        },
+    };
+    const result = await ingestRhythmSignal({
+        trigger: "heartbeat_bridge",
+        payload: { timestamp: "2026-05-16T10:00:00.000Z" },
+    }, {
+        loadSnapshotInputs: async () => ({
+            mode: "active",
+            currentWindowId: "w-1",
+            pendingObligations: [],
+            recentOutreachHashes: [],
+            deniedIntents: [],
+            budgets: { socialUsed: 0, socialLimit: 5 },
+        }),
+        narrativeStateStore: mockStore,
+    });
+    // Cycle may be denied due to missing source refs; what matters is the store update.
+    assert.ok(["heartbeat_ok", "denied", "deferred", "intent_selected"].includes(result.status), `unexpected status: ${result.status}`);
+    assert.equal(updates.length, 1);
+    assert.equal(updates[0].narrativeId, "default");
+    assert.equal(updates[0].status, "awaiting_sources");
+});
+test("T2.1.5 heartbeat loop does not break when store load fails", async () => {
+    const mockStore = {
+        async updateNarrativeState() {
+            return { narrativeId: "default", status: "acknowledged" };
+        },
+        async loadNarrativeState() {
+            throw new Error("DB down");
+        },
+    };
+    const result = await ingestRhythmSignal({
+        trigger: "heartbeat_bridge",
+        payload: { timestamp: "2026-05-16T10:00:00.000Z" },
+    }, {
+        loadSnapshotInputs: async () => ({
+            mode: "active",
+            currentWindowId: "w-1",
+            pendingObligations: [],
+            recentOutreachHashes: [],
+            deniedIntents: [],
+            budgets: { socialUsed: 0, socialLimit: 5 },
+        }),
+        narrativeStateStore: mockStore,
+    });
+    assert.ok(["heartbeat_ok", "denied", "deferred", "intent_selected"].includes(result.status), `unexpected status: ${result.status}`);
+});
+// Boundary tests for Wave 26 fix
+test("T2.1.5 boundary: empty intent summary", () => {
+    const result = makeResult({ status: "intent_selected", selectedIntentId: "intent-test" });
+    const intent = makeCandidate({
+        summary: "",
+        sourceRefs: [{ id: "ev-1", kind: "connector_result", uri: "evomap://profile" }],
+    });
+    const lifeEvidence = makeLifeEvidence({ evidenceRefs: [{ id: "ev-1", kind: "connector_result", uri: "evomap://profile" }] });
+    const update = updateNarrativeAfterEffect({
+        result,
+        selectedIntent: intent,
+        lifeEvidence,
+        priorNarrative: makePriorState(),
+    });
+    assert.equal(update.status, "active");
+    assert.equal(update.focus, "");
+    assert.ok(update.progress.some((p) => p.startsWith("connector_action:")));
+});
+test("T2.1.5 boundary: very long intent summary", () => {
+    const longSummary = "a".repeat(10000);
+    const result = makeResult({ status: "intent_selected", selectedIntentId: "intent-test" });
+    const intent = makeCandidate({
+        summary: longSummary,
+        sourceRefs: [{ id: "ev-1", kind: "connector_result", uri: "evomap://profile" }],
+    });
+    const lifeEvidence = makeLifeEvidence({ evidenceRefs: [{ id: "ev-1", kind: "connector_result", uri: "evomap://profile" }] });
+    const update = updateNarrativeAfterEffect({
+        result,
+        selectedIntent: intent,
+        lifeEvidence,
+        priorNarrative: makePriorState(),
+    });
+    assert.equal(update.status, "active");
+    assert.equal(update.focus, longSummary);
+    assert.ok(update.progress.some((p) => p.startsWith("connector_action:")));
+});
+test("T2.1.5 boundary: maximum source refs for confidence calculation", () => {
+    const result = makeResult({ status: "intent_selected", selectedIntentId: "intent-test" });
+    const manyRefs = Array.from({ length: 1000 }, (_, i) => ({
+        id: `ev-${i}`,
+        kind: "connector_result",
+        uri: `evomap://profile-${i}`,
+    }));
+    const intent = makeCandidate({
+        summary: "bulk action",
+        sourceRefs: manyRefs,
+    });
+    const update = updateNarrativeAfterEffect({
+        result,
+        selectedIntent: intent,
+        lifeEvidence: makeLifeEvidence(),
+    });
+    assert.equal(update.status, "active");
+    assert.equal(update.confidence, 0.9); // 4+ sources → 0.90 (tiered sigmoid hard cap 0.95)
+    assert.equal(update.sourceRefs.length, 1000);
+});
+test("T2.1.5 boundary: undefined selected intent", () => {
+    const result = makeResult({ status: "intent_selected", selectedIntentId: "missing-intent" });
+    const lifeEvidence = makeLifeEvidence();
+    const update = updateNarrativeAfterEffect({
+        result,
+        selectedIntent: undefined,
+        lifeEvidence,
+        priorNarrative: makePriorState(),
+    });
+    // When no intent is selected but status is intent_selected, preserve prior state
+    assert.equal(update.status, "active");
+    assert.equal(update.confidence, 0.5);
+    assert.equal(update.revision, 4);
+});
+test("T2.1.5 boundary: prior state with malformed data", () => {
+    const malformedPrior = {
+        narrativeId: "default",
+        revision: -1,
+        focus: "",
+        progress: ["", null, undefined],
+        nextIntent: "",
+        confidence: -0.5,
+        sourceRefs: [],
+        unsupportedClaims: ["", "  "],
+        status: "active",
+        updatedAt: "invalid-date",
+    };
+    const update = updateNarrativeAfterEffect({
+        result: makeResult(),
+        lifeEvidence: makeLifeEvidence(),
+        priorNarrative: malformedPrior,
+    });
+    // Should handle malformed prior state gracefully - preserves what it can
+    assert.equal(update.revision, 0); // Negative revision clamped to 0 then +1
+    assert.equal(update.status, "active");
+    assert.ok(update.updatedAt > "2026-05-15T00:00:00.000Z");
+});

package/dist/tests/unit/control-plane/t2-4-1-credential-route.test.d.ts

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