@haaaiawd/second-nature 0.1.50 → 0.1.51

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

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

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

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

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

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

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

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

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