@haaaiawd/second-nature 0.1.50 → 0.1.51

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

@@ -1,190 +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 integration", () => {
-    function buildBaseDeps() {
-        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: () => [
-                    {
-                        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",
-                    },
-                ],
-            },
-            evaluateHardGuards,
-            buildGuardDeps: () => ({
-                hasDuplicateIntent: () => false,
-                isOutreachCooldownClear: () => true,
-                affordanceMap: {
-                    moltbook: [
-                        {
-                            platformId: "moltbook",
-                            capabilityId: "feed.read",
-                            intent: "feed.read",
-                            status: "safe",
-                        },
-                    ],
-                },
-            }),
-            downstreamOrchestrator: createDownstreamIntentOrchestrator(),
-            traceEmitter: createNoOpTraceEmitter(),
-        };
-    }
-    function makeSignal(overrides = {}) {
-        return {
-            trigger: "heartbeat_bridge",
-            payload: { timestamp: new Date().toISOString() },
-            ...overrides,
-        };
-    }
-    it("returns carrier_only when runtime is unavailable", async () => {
-        const result = await runHeartbeatV7({
-            signal: makeSignal(),
-            runtimeAvailable: false,
-            deps: buildBaseDeps(),
-        });
-        assert.strictEqual(result.status, "runtime_carrier_only");
-        assert(result.reasons.includes("runtime_unavailable_no_lived_experience_loop"));
-    });
-    it("returns heartbeat_ok for user_task scope", async () => {
-        const result = await runHeartbeatV7({
-            signal: makeSignal({ trigger: "user_task" }),
-            runtimeAvailable: true,
-            deps: buildBaseDeps(),
-        });
-        assert.strictEqual(result.status, "heartbeat_ok");
-        assert(result.reasons.includes("rhythm_gate_bypass_user_task"));
-    });
-    it("returns heartbeat_ok for user_reply scope", async () => {
-        const result = await runHeartbeatV7({
-            signal: makeSignal({ trigger: "user_reply" }),
-            runtimeAvailable: true,
-            deps: buildBaseDeps(),
-        });
-        assert.strictEqual(result.status, "heartbeat_ok");
-        assert(result.reasons.includes("user_reply_light_continuity_skeleton"));
-    });
-    it("selects first allowed intent in rhythm scope", async () => {
-        const result = await runHeartbeatV7({
-            signal: makeSignal(),
-            runtimeAvailable: true,
-            deps: buildBaseDeps(),
-        });
-        assert.strictEqual(result.status, "intent_selected");
-        assert.strictEqual(result.selectedIntentId, "intent-1");
-        assert.ok(result.contextId);
-        assert.ok(result.downstreamRequestId);
-    });
-    it("defers when affordance is painful (circuit open)", async () => {
-        const deps = buildBaseDeps();
-        deps.buildGuardDeps = () => ({
-            hasDuplicateIntent: () => false,
-            isOutreachCooldownClear: () => true,
-            affordanceMap: {
-                moltbook: [
-                    {
-                        platformId: "moltbook",
-                        capabilityId: "feed.read",
-                        intent: "feed.read",
-                        status: "painful",
-                    },
-                ],
-            },
-        });
-        const result = await runHeartbeatV7({
-            signal: makeSignal(),
-            runtimeAvailable: true,
-            deps,
-        });
-        // When all candidates are deferred, final status is deferred.
-        // Per aggregate-decision semantics, final reasons contain "no_allow_verdict".
-        assert.strictEqual(result.status, "deferred");
-    });
-    it("defers when all candidates lack source refs", async () => {
-        const deps = buildBaseDeps();
-        deps.planner = {
-            planCandidates: () => [
-                {
-                    id: "intent-bad",
-                    kind: "work",
-                    priority: 100,
-                    source: "tick",
-                    platformId: "moltbook",
-                    summary: "no refs",
-                    effectClass: "connector_action",
-                    sourceRefs: [],
-                    idempotencyKey: "key-bad",
-                },
-            ],
-        };
-        const result = await runHeartbeatV7({
-            signal: makeSignal(),
-            runtimeAvailable: true,
-            deps,
-        });
-        assert.strictEqual(result.status, "deferred");
-    });
-    it("marks degraded when assembly exceeds P95 (simulated)", async () => {
-        const deps = buildBaseDeps();
-        // Empty candidates so status stays heartbeat_ok with degradation note
-        deps.planner = { planCandidates: () => [] };
-        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(result.reasons.some((r) => r.includes("assembly_p95_exceeded")));
-    });
-});

package/dist/tests/integration/control-plane/heartbeat-quiet-orchestration.test.d.ts

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

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

@@ -1,133 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { ingestRhythmSignal, } from "../../../src/core/second-nature/heartbeat/index.js";
-test("T2.3.3 quiet non-empty: unresolved evidence refs -> denied (low path)", async () => {
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "sn-quiet-low-"));
-    const signal = {
-        trigger: "heartbeat_bridge",
-        scopeHint: "rhythm",
-        payload: { timestamp: "2026-05-02T22:30:00.000Z" },
-    };
-    const snapshotInputs = {
-        mode: "quiet",
-        currentWindowId: "window-quiet",
-        pendingObligations: [],
-        recentOutreachHashes: [],
-        deniedIntents: [],
-        quietEnabledBridge: true,
-        lifeEvidenceRefs: [{ id: "bad", kind: "connector_result", uri: "" }],
-    };
-    const deps = {
-        loadSnapshotInputs: async () => snapshotInputs,
-        quietWorkflow: { workspaceRoot: tmp },
-    };
-    const result = await ingestRhythmSignal(signal, deps);
-    assert.equal(result.status, "denied");
-    assert.ok(result.reasons.some((x) => x.includes("unresolved_source_refs")));
-    fs.rmSync(tmp, { recursive: true, force: true });
-});
-test("T2.3.3 quiet non-empty: sensitive source refs are denied and not persisted", async () => {
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "sn-quiet-sensitive-"));
-    const signal = {
-        trigger: "heartbeat_bridge",
-        scopeHint: "rhythm",
-        payload: { timestamp: "2026-05-02T22:30:00.000Z" },
-    };
-    const snapshotInputs = {
-        mode: "quiet",
-        currentWindowId: "window-quiet",
-        pendingObligations: [],
-        recentOutreachHashes: [],
-        deniedIntents: [],
-        quietEnabledBridge: true,
-        lifeEvidenceRefs: [{ id: "secret-ref", kind: "connector_result", uri: "credential://github/token" }],
-    };
-    const deps = {
-        loadSnapshotInputs: async () => snapshotInputs,
-        quietWorkflow: { workspaceRoot: tmp },
-    };
-    const result = await ingestRhythmSignal(signal, deps);
-    assert.equal(result.status, "denied");
-    assert.ok(result.reasons.includes("quiet_guidance_sensitive_source_blocked"));
-    const quietDir = path.join(tmp, ".second-nature", "quiet", "2026-05-02");
-    assert.equal(fs.existsSync(quietDir), false);
-    fs.rmSync(tmp, { recursive: true, force: true });
-});
-test("T2.3.3 quiet non-empty: grounded evidence -> intent_selected with quiet artifact hints", async () => {
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "sn-quiet-ok-"));
-    const signal = {
-        trigger: "heartbeat_bridge",
-        scopeHint: "rhythm",
-        payload: { timestamp: "2026-05-02T22:30:00.000Z" },
-    };
-    const snapshotInputs = {
-        mode: "quiet",
-        currentWindowId: "window-quiet",
-        pendingObligations: [],
-        recentOutreachHashes: [],
-        deniedIntents: [],
-        quietEnabledBridge: true,
-        lifeEvidenceRefs: [{ id: "good", kind: "connector_result", uri: "https://example.com/evidence/1" }],
-        userInterestSnapshot: {
-            snapshotId: "snap-1",
-            generatedAt: "2026-05-02T22:00:00.000Z",
-            staleness: "fresh",
-            confidence: 0.9,
-            signals: [
-                {
-                    id: "sig1",
-                    topic: "project alpha",
-                    affinity: "positive",
-                    reason: "integration_fixture",
-                    confidence: 0.9,
-                    sourceRefs: [],
-                    updatedAt: "2026-05-02T22:00:00.000Z",
-                },
-            ],
-            sourceRefs: [],
-        },
-    };
-    const deps = {
-        loadSnapshotInputs: async () => snapshotInputs,
-        quietWorkflow: { workspaceRoot: tmp },
-    };
-    const result = await ingestRhythmSignal(signal, deps);
-    assert.equal(result.status, "intent_selected");
-    assert.ok(result.reasons.some((x) => x === "quiet_artifact_written"));
-    const day = "2026-05-02";
-    const quietDir = path.join(tmp, ".second-nature", "quiet", day);
-    assert.ok(fs.existsSync(quietDir), `expected quiet dir at ${quietDir}`);
-    fs.rmSync(tmp, { recursive: true, force: true });
-});
-test("T2.3.3 quiet mode + quietWorkflow persists empty_state artifact", async () => {
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "sn-quiet-"));
-    const signal = {
-        trigger: "heartbeat_bridge",
-        scopeHint: "rhythm",
-        payload: { timestamp: "2026-05-02T22:30:00.000Z" },
-    };
-    const snapshotInputs = {
-        mode: "quiet",
-        currentWindowId: "window-quiet",
-        pendingObligations: [],
-        recentOutreachHashes: [],
-        deniedIntents: [],
-        quietEnabledBridge: true,
-    };
-    const deps = {
-        loadSnapshotInputs: async () => snapshotInputs,
-        quietWorkflow: { workspaceRoot: tmp },
-    };
-    const result = await ingestRhythmSignal(signal, deps);
-    assert.equal(result.status, "intent_selected");
-    assert.ok(result.reasons.some((x) => x.includes("quiet_empty_state") || x.includes("no_fictional")));
-    const day = "2026-05-02";
-    const quietDir = path.join(tmp, ".second-nature", "quiet", day);
-    assert.ok(fs.existsSync(quietDir), `expected quiet dir at ${quietDir}`);
-    const files = fs.readdirSync(quietDir);
-    assert.ok(files.some((f) => f.endsWith(".json")));
-    fs.rmSync(tmp, { recursive: true, force: true });
-});

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

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

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

@@ -1,342 +0,0 @@
-import { afterEach, test } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { ingestRhythmSignal, routeScopedInput, } from "../../../src/core/second-nature/heartbeat/index.js";
-import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
-import { DecisionLedger } from "../../../src/observability/services/decision-ledger.js";
-const cleanupPaths = [];
-const openDbs = [];
-afterEach(() => {
-    while (openDbs.length > 0) {
-        const db = openDbs.pop();
-        if (db) {
-            try {
-                db.close();
-            }
-            catch { /* ignore */ }
-        }
-    }
-    while (cleanupPaths.length > 0) {
-        const target = cleanupPaths.pop();
-        if (target && fs.existsSync(target)) {
-            try {
-                fs.rmSync(target, { force: true });
-            }
-            catch { /* ignore */ }
-        }
-    }
-});
-function createTempDb() {
-    const dbPath = path.join(os.tmpdir(), `int-s2-${Date.now()}-${Math.random().toString(16).slice(2)}.db`);
-    cleanupPaths.push(dbPath);
-    const database = createObservabilityDatabase(dbPath);
-    database.sqlite.exec(`
-    CREATE TABLE IF NOT EXISTS decision_ledger (
-      id TEXT PRIMARY KEY,
-      tick_id TEXT NOT NULL,
-      trace_id TEXT NOT NULL,
-      intent_id TEXT,
-      platform_id TEXT,
-      verdict TEXT NOT NULL,
-      mode TEXT NOT NULL,
-      reasons TEXT NOT NULL,
-      reason_codes TEXT NOT NULL,
-      decision_basis TEXT NOT NULL,
-      evidence_refs TEXT NOT NULL,
-      model_eval_ref TEXT,
-      created_at TEXT NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS decision_tick_idx ON decision_ledger(tick_id);
-    CREATE UNIQUE INDEX IF NOT EXISTS decision_trace_idx ON decision_ledger(trace_id);
-
-    CREATE TABLE IF NOT EXISTS redaction_manifest (
-      id TEXT PRIMARY KEY,
-      event_id TEXT NOT NULL,
-      event_type TEXT NOT NULL,
-      field_name TEXT NOT NULL,
-      action TEXT NOT NULL,
-      original_value_hash TEXT,
-      created_at TEXT NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS redact_event_idx ON redaction_manifest(event_id);
-  `);
-    const ledger = new DecisionLedger(database);
-    openDbs.push(database);
-    return { db: database, ledger, dbPath };
-}
-// ─── INT-S2: Heartbeat Spine Integration Tests ──────────────────────────────
-/**
- * Full heartbeat spine simulation:
- * signal → scope routing → snapshot → decision → observability record
- */
-async function runHeartbeatSpine(signal, snapshotInputs, ledger) {
-    // Step 1: Scope routing
-    const scopedInput = {
-        trigger: signal.trigger,
-        scopeHint: signal.scopeHint,
-        payload: signal.payload,
-    };
-    const scopeResult = routeScopedInput(scopedInput);
-    // Step 2: Decision loop (includes snapshot building internally)
-    const decisionDeps = {
-        loadSnapshotInputs: async () => snapshotInputs,
-    };
-    const cycleResult = await ingestRhythmSignal(signal, decisionDeps);
-    // Step 3: Observability record
-    const decisionEvent = {
-        id: `hb-${cycleResult.status}-${Date.now()}`,
-        tickId: `tick-${Date.now()}`,
-        traceId: `trace-${cycleResult.status}-${Date.now()}`,
-        runtimeScope: scopeResult.scope,
-        triggerSource: signal.trigger,
-        decisionStatus: cycleResult.status,
-        reasons: cycleResult.reasons,
-        intentId: cycleResult.selectedIntentId,
-        mode: snapshotInputs.mode,
-        createdAt: new Date().toISOString(),
-    };
-    await ledger.recordHeartbeatDecision(decisionEvent);
-    return { scopeResult, cycleResult, recordedDecision: decisionEvent };
-}
-test("INT-S2 heartbeat spine: HEARTBEAT_OK path is observable and explainable", async () => {
-    const { ledger } = createTempDb();
-    const signal = {
-        trigger: "heartbeat_bridge",
-        scopeHint: "rhythm",
-        payload: {
-            timestamp: "2026-03-31T10:00:00Z",
-            sessionContext: "no pending work",
-        },
-    };
-    const snapshotInputs = {
-        mode: "active",
-        currentWindowId: "window-default",
-        pendingObligations: [],
-        recentOutreachHashes: [],
-        deniedIntents: [],
-        budgets: { socialUsed: 5, socialLimit: 5 },
-        awaitingUserInput: true,
-    };
-    const { scopeResult, cycleResult, recordedDecision } = await runHeartbeatSpine(signal, snapshotInputs, ledger);
-    // Verify scope routing
-    assert.equal(scopeResult.scope, "rhythm", "heartbeat signal should route to rhythm scope");
-    assert.equal(scopeResult.trigger, "heartbeat_bridge");
-    assert.equal(scopeResult.handled, true);
-    // Verify decision result
-    assert.equal(cycleResult.scope, "rhythm");
-    assert.equal(cycleResult.status, "denied"); // awaiting_user yields deny for each candidate; none allow
-    // Verify observability record
-    const records = await ledger.queryByTickId(recordedDecision.tickId);
-    assert.equal(records.length, 1);
-    const record = records[0];
-    assert.ok(record.evidenceRefs.some((r) => r.includes("scope:rhythm")), "record should show runtime scope");
-    assert.ok(record.evidenceRefs.some((r) => r.includes("trigger:heartbeat_bridge")), "record should show trigger source");
-    assert.ok(record.evidenceRefs.some((r) => r.includes("status:denied")), "record should show decision status");
-    assert.ok(Array.isArray(record.reasons), "reasons should be queryable array");
-});
-test("INT-S2 heartbeat spine: allow path produces intent_selected with observability record", async () => {
-    const { ledger } = createTempDb();
-    const signal = {
-        trigger: "heartbeat_bridge",
-        scopeHint: "rhythm",
-        payload: {
-            timestamp: "2026-03-31T11:00:00Z",
-        },
-    };
-    const snapshotInputs = {
-        mode: "active",
-        currentWindowId: "window-default",
-        pendingObligations: ["check-email"],
-        recentOutreachHashes: [],
-        deniedIntents: [],
-        budgets: { socialUsed: 0, socialLimit: 5 },
-        awaitingUserInput: false,
-    };
-    const { scopeResult, cycleResult, recordedDecision } = await runHeartbeatSpine(signal, snapshotInputs, ledger);
-    // Verify scope routing
-    assert.equal(scopeResult.scope, "rhythm");
-    // Verify decision result
-    assert.equal(cycleResult.status, "intent_selected");
-    assert.ok(cycleResult.selectedIntentId?.startsWith("intent-obligation"));
-    // Verify observability record
-    const records = await ledger.queryByTickId(recordedDecision.tickId);
-    assert.equal(records.length, 1);
-    const record = records[0];
-    assert.equal(record.verdict, "allow", "intent_selected should map to allow verdict");
-    assert.ok(record.evidenceRefs.some((r) => r.includes("status:intent_selected")), "status should be recoverable");
-    assert.ok(record.evidenceRefs.some((r) => r.includes("scope:rhythm")));
-    assert.ok(record.evidenceRefs.some((r) => r.includes("trigger:heartbeat_bridge")));
-});
-test("INT-S2 heartbeat spine: duplicate-intent path is deferred and observable", async () => {
-    const { ledger } = createTempDb();
-    const signal = {
-        trigger: "heartbeat_bridge",
-        scopeHint: "rhythm",
-        payload: {
-            timestamp: "2026-03-31T12:00:00Z",
-        },
-    };
-    const snapshotInputs = {
-        mode: "paused_for_interrupt",
-        currentWindowId: "window-default",
-        pendingObligations: [],
-        recentOutreachHashes: [],
-        deniedIntents: [],
-        budgets: { socialUsed: 0, socialLimit: 5 },
-        awaitingUserInput: false,
-        duplicateIntentKeys: ["maintenance:checks"],
-    };
-    const { scopeResult, cycleResult, recordedDecision } = await runHeartbeatSpine(signal, snapshotInputs, ledger);
-    // Verify scope routing
-    assert.equal(scopeResult.scope, "rhythm");
-    // Verify decision result (single maintenance candidate, duplicate hard-guard → defer-only)
-    assert.equal(cycleResult.status, "deferred");
-    // Verify observability record
-    const records = await ledger.queryByTickId(recordedDecision.tickId);
-    assert.equal(records.length, 1);
-    const record = records[0];
-    assert.equal(record.verdict, "defer", "deferred maps to defer verdict");
-    assert.ok(record.evidenceRefs.some((r) => r.includes("status:deferred")), "status should be distinguishable");
-    assert.ok(record.reasons.some((r) => r.includes("defer")), "reasons should mention duplicate defer chain");
-});
-test("INT-S2 heartbeat spine: full chain produces distinguishable records for all three paths", async () => {
-    const { ledger } = createTempDb();
-    // Run three different scenarios
-    const scenarios = [
-        {
-            name: "heartbeat_ok",
-            signal: {
-                trigger: "heartbeat_bridge",
-                scopeHint: "rhythm",
-                payload: { timestamp: "2026-03-31T10:00:00Z" },
-            },
-            snapshot: {
-                mode: "active",
-                currentWindowId: "w1",
-                pendingObligations: [],
-                recentOutreachHashes: [],
-                deniedIntents: [],
-                budgets: { socialUsed: 5, socialLimit: 5 },
-                awaitingUserInput: true,
-            },
-            expectedStatus: "denied",
-            expectedVerdict: "deny",
-        },
-        {
-            name: "allow",
-            signal: {
-                trigger: "heartbeat_bridge",
-                scopeHint: "rhythm",
-                payload: { timestamp: "2026-03-31T11:00:00Z" },
-            },
-            snapshot: {
-                mode: "active",
-                currentWindowId: "w2",
-                pendingObligations: ["check-email"],
-                recentOutreachHashes: [],
-                deniedIntents: [],
-                budgets: { socialUsed: 0, socialLimit: 5 },
-                awaitingUserInput: false,
-            },
-            expectedStatus: "intent_selected",
-            expectedVerdict: "allow",
-        },
-        {
-            name: "defer-duplicates",
-            signal: {
-                trigger: "heartbeat_bridge",
-                scopeHint: "rhythm",
-                payload: { timestamp: "2026-03-31T12:00:00Z" },
-            },
-            snapshot: {
-                mode: "paused_for_interrupt",
-                currentWindowId: "w3",
-                pendingObligations: [],
-                recentOutreachHashes: [],
-                deniedIntents: [],
-                budgets: { socialUsed: 0, socialLimit: 5 },
-                awaitingUserInput: false,
-                duplicateIntentKeys: ["maintenance:checks"],
-            },
-            expectedStatus: "deferred",
-            expectedVerdict: "defer",
-        },
-    ];
-    const results = [];
-    for (const scenario of scenarios) {
-        const { scopeResult, cycleResult, recordedDecision } = await runHeartbeatSpine(scenario.signal, scenario.snapshot, ledger);
-        // Verify decision status matches expectation
-        assert.equal(cycleResult.status, scenario.expectedStatus, `${scenario.name} should produce ${scenario.expectedStatus}`);
-        // Verify observability record
-        const records = await ledger.queryByTickId(recordedDecision.tickId);
-        assert.equal(records.length, 1, `${scenario.name} should have exactly one record`);
-        const record = records[0];
-        assert.equal(record.verdict, scenario.expectedVerdict, `${scenario.name} verdict should be ${scenario.expectedVerdict}`);
-        // Verify all four distinguishable fields are present
-        assert.ok(record.evidenceRefs.some((r) => r.startsWith("scope:")), `${scenario.name} should have runtimeScope`);
-        assert.ok(record.evidenceRefs.some((r) => r.startsWith("trigger:")), `${scenario.name} should have triggerSource`);
-        assert.ok(record.evidenceRefs.some((r) => r.startsWith("status:")), `${scenario.name} should have decisionStatus`);
-        assert.ok(Array.isArray(record.reasons), `${scenario.name} reasons should be array`);
-        results.push({
-            name: scenario.name,
-            status: cycleResult.status,
-            verdict: record.verdict,
-            scope: scopeResult.scope,
-            trigger: scopeResult.trigger,
-        });
-    }
-    // Verify all three paths are distinguishable
-    const statuses = results.map((r) => r.status);
-    const verdicts = results.map((r) => r.verdict);
-    assert.ok(statuses.includes("denied"), "should have denied path");
-    assert.ok(statuses.includes("intent_selected"), "should have allow path");
-    assert.ok(statuses.includes("deferred"), "should have deferred path");
-    assert.ok(verdicts.includes("allow"), "should have allow verdict");
-    assert.ok(verdicts.includes("deny"), "should have deny verdict");
-    assert.ok(verdicts.includes("defer"), "should have defer verdict");
-    // All should have same scope and trigger (rhythm / heartbeat_bridge)
-    assert.ok(results.every((r) => r.scope === "rhythm"), "all should route to rhythm");
-    assert.ok(results.every((r) => r.trigger === "heartbeat_bridge"), "all should have same trigger");
-});
-test("INT-S2 heartbeat spine: heartbeat_ok status is preserved in evidenceRefs despite verdict mapping", async () => {
-    const { ledger } = createTempDb();
-    // Create a scenario that produces heartbeat_ok (no candidates at all)
-    // This requires a snapshot where planIntent produces no candidates
-    // In quiet mode with no obligations and >3 outreach hashes, only maintenance/reflection are candidates
-    // But with awaitingUserInput=true, they get blocked → denied
-    // To get true heartbeat_ok (no_candidates), we need a different approach
-    // Actually, the current planIntent always produces exploration/social candidates
-    // So heartbeat_ok with no_candidates is hard to trigger in integration
-    // Let's verify the no_allow_verdict fallback path instead
-    const signal = {
-        trigger: "heartbeat_bridge",
-        scopeHint: "rhythm",
-        payload: { timestamp: "2026-03-31T13:00:00Z" },
-    };
-    const snapshotInputs = {
-        mode: "quiet",
-        currentWindowId: "window-quiet",
-        pendingObligations: [],
-        recentOutreachHashes: ["h1", "h2", "h3", "h4"],
-        deniedIntents: [],
-        budgets: { socialUsed: 0, socialLimit: 5 },
-        awaitingUserInput: true,
-    };
-    const { cycleResult, recordedDecision } = await runHeartbeatSpine(signal, snapshotInputs, ledger);
-    // Verify the decision status
-    assert.ok(cycleResult.status === "heartbeat_ok" || cycleResult.status === "denied", "should produce heartbeat_ok or denied");
-    // Verify observability record preserves the status
-    const records = await ledger.queryByTickId(recordedDecision.tickId);
-    assert.equal(records.length, 1);
-    const record = records[0];
-    const statusRef = record.evidenceRefs.find((r) => r.startsWith("status:"));
-    assert.ok(statusRef, "evidenceRefs should contain status reference");
-    assert.ok(statusRef?.includes("heartbeat_ok") || statusRef?.includes("denied"), "status should be preserved in evidenceRefs");
-    // Verify verdict mapping doesn't cause ambiguity
-    // heartbeat_ok → defer, denied → deny
-    // These are distinguishable via evidenceRefs
-    assert.ok(record.evidenceRefs.some((r) => r.startsWith("scope:rhythm")), "scope should be preserved");
-    assert.ok(record.evidenceRefs.some((r) => r.startsWith("trigger:heartbeat_bridge")), "trigger should be preserved");
-});

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

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