@haaaiawd/second-nature 0.1.42 → 0.1.50

package/dist/tests/integration/observability/evidence-query-engine.test.js

@@ -0,0 +1,219 @@
+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 { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { EvidenceQueryEngine } from "../../../src/observability/query/evidence-query-engine.js";
+import { decisionLedger, executionAttempts, governanceAudit } from "../../../src/observability/db/schema/index.js";
+const cleanupPaths = [];
+afterEach(() => {
+    while (cleanupPaths.length > 0) {
+        const target = cleanupPaths.pop();
+        if (target && fs.existsSync(target)) {
+            fs.rmSync(target, { force: true });
+        }
+    }
+});
+function createTempDb() {
+    const dbPath = path.join(os.tmpdir(), `observability-evidence-${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 TABLE IF NOT EXISTS execution_attempts (
+      id TEXT PRIMARY KEY,
+      trace_id TEXT NOT NULL,
+      decision_id TEXT NOT NULL,
+      intent_id TEXT NOT NULL,
+      platform_id TEXT NOT NULL,
+      capability TEXT NOT NULL,
+      channel TEXT NOT NULL,
+      status TEXT NOT NULL,
+      commit_state TEXT,
+      failure_class TEXT,
+      retry_policy TEXT,
+      idempotency_key TEXT,
+      started_at TEXT,
+      finished_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS governance_audit (
+      id TEXT PRIMARY KEY,
+      event_type TEXT NOT NULL,
+      proposal_id TEXT,
+      target_asset_id TEXT,
+      asset_path TEXT,
+      status_from TEXT,
+      status_to TEXT NOT NULL,
+      before_hash TEXT,
+      after_hash TEXT,
+      supporting_sources TEXT,
+      reason TEXT,
+      verification_deadline TEXT,
+      attempts_remaining INTEGER,
+      created_at TEXT NOT NULL
+    );
+  `);
+    return database;
+}
+test("queryEvidence by decisionId only returns decision and attempts bound to that decision", async () => {
+    const db = createTempDb();
+    const engine = new EvidenceQueryEngine(db);
+    await db.db.insert(decisionLedger).values({
+        id: "decision-1",
+        tickId: "tick-1",
+        traceId: "trace-1",
+        intentId: "intent-1",
+        platformId: "instreet",
+        verdict: "allow",
+        mode: "active",
+        reasons: JSON.stringify(["policy_ok"]),
+        reasonCodes: JSON.stringify(["policy_ok"]),
+        decisionBasis: "rule_only",
+        evidenceRefs: JSON.stringify(["content_ref:day/1"]),
+        modelEvalRef: null,
+        createdAt: new Date().toISOString(),
+    });
+    await db.db.insert(executionAttempts).values({
+        id: "attempt-1",
+        traceId: "trace-1",
+        decisionId: "decision-1",
+        intentId: "intent-1",
+        platformId: "instreet",
+        capability: "feed.read",
+        channel: "api",
+        status: "succeeded",
+        commitState: "committed",
+        failureClass: null,
+        retryPolicy: null,
+        idempotencyKey: null,
+        startedAt: new Date().toISOString(),
+        finishedAt: new Date().toISOString(),
+    });
+    await db.db.insert(executionAttempts).values({
+        id: "attempt-2",
+        traceId: "trace-2",
+        decisionId: "decision-2",
+        intentId: "intent-2",
+        platformId: "evomap",
+        capability: "agent.heartbeat",
+        channel: "api",
+        status: "failed",
+        commitState: "aborted",
+        failureClass: "timeout",
+        retryPolicy: null,
+        idempotencyKey: null,
+        startedAt: new Date().toISOString(),
+        finishedAt: new Date().toISOString(),
+    });
+    await db.db.insert(governanceAudit).values({
+        id: "gov-1",
+        eventType: "anchor.applied",
+        proposalId: "proposal-1",
+        targetAssetId: "SOUL.md",
+        assetPath: "workspace/SOUL.md",
+        statusFrom: "approved",
+        statusTo: "applied",
+        beforeHash: "h1",
+        afterHash: "h2",
+        supportingSources: JSON.stringify(["content_ref:day/1"]),
+        reason: "approved",
+        verificationDeadline: null,
+        attemptsRemaining: null,
+        createdAt: new Date().toISOString(),
+    });
+    await db.db.insert(governanceAudit).values({
+        id: "gov-2",
+        eventType: "anchor.applied",
+        proposalId: "proposal-2",
+        targetAssetId: "OTHER.md",
+        assetPath: "workspace/OTHER.md",
+        statusFrom: "approved",
+        statusTo: "applied",
+        beforeHash: "x1",
+        afterHash: "x2",
+        supportingSources: JSON.stringify(["content_ref:other"]),
+        reason: "other",
+        verificationDeadline: null,
+        attemptsRemaining: null,
+        createdAt: new Date().toISOString(),
+    });
+    const bundle = await engine.queryEvidence({ decisionId: "decision-1" });
+    assert.deepEqual(bundle.plan.path, ["decision", "attempts"]);
+    assert.equal(bundle.decisions.length, 1);
+    assert.equal(bundle.attempts.length, 1);
+    assert.equal(bundle.attempts[0]?.decisionId, "decision-1");
+    assert.equal(bundle.governance.length, 0);
+    assert.ok(bundle.explanation.evidenceRefs.includes("content_ref:day/1"));
+    db.close();
+});
+test("queryEvidence by proposalId and assetId only returns matching governance records", async () => {
+    const db = createTempDb();
+    const engine = new EvidenceQueryEngine(db);
+    await db.db.insert(governanceAudit).values({
+        id: "gov-3",
+        eventType: "anchor.applied",
+        proposalId: "proposal-2",
+        targetAssetId: "SOUL.md",
+        assetPath: "workspace/SOUL.md",
+        statusFrom: "approved",
+        statusTo: "applied",
+        beforeHash: "hb",
+        afterHash: "ha",
+        supportingSources: JSON.stringify(["content_ref:day/2"]),
+        reason: "apply ok",
+        verificationDeadline: null,
+        attemptsRemaining: null,
+        createdAt: new Date().toISOString(),
+    });
+    await db.db.insert(governanceAudit).values({
+        id: "gov-4",
+        eventType: "anchor.rejected",
+        proposalId: "proposal-3",
+        targetAssetId: "OTHER.md",
+        assetPath: "workspace/OTHER.md",
+        statusFrom: "requires_review",
+        statusTo: "rejected",
+        beforeHash: "o1",
+        afterHash: null,
+        supportingSources: JSON.stringify(["content_ref:day/3"]),
+        reason: "rejected",
+        verificationDeadline: null,
+        attemptsRemaining: null,
+        createdAt: new Date().toISOString(),
+    });
+    const byProposal = await engine.queryEvidence({ proposalId: "proposal-2" });
+    assert.deepEqual(byProposal.plan.path, ["anchor_audit"]);
+    assert.equal(byProposal.governance.length, 1);
+    assert.equal(byProposal.governance[0]?.proposalId, "proposal-2");
+    const byAsset = await engine.queryEvidence({ assetId: "SOUL.md" });
+    assert.deepEqual(byAsset.plan.path, ["anchor_audit"]);
+    assert.equal(byAsset.governance.length, 1);
+    assert.equal(byAsset.governance[0]?.targetAssetId, "SOUL.md");
+    assert.equal(byAsset.decisions.length, 0);
+    assert.equal(byAsset.attempts.length, 0);
+    db.close();
+});
+test("queryEvidence with sessionId is explicitly unsupported", async () => {
+    const db = createTempDb();
+    const engine = new EvidenceQueryEngine(db);
+    await assert.rejects(() => engine.queryEvidence({ sessionId: "session-1" }), /evidence_query_sessionId_unsupported/);
+    await assert.rejects(() => engine.queryEvidence({}), /evidence_query_requires_index_key/);
+    db.close();
+});

package/dist/tests/integration/observability/explain-query-export.test.d.ts

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

package/dist/tests/integration/observability/explain-query-export.test.js

@@ -0,0 +1,92 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { AppendOnlyAuditStore } from "../../../src/observability/audit/append-only-audit-store.js";
+import { createAppendOnlyAuditStoreRangeLoader } from "../../../src/observability/audit/verify-audit-hash-chain.js";
+import { queryExplain } from "../../../src/observability/query/explain-query.js";
+import { exportAuditBundle } from "../../../src/observability/query/export-audit-bundle.js";
+import { createLivedExperienceAuditRecorder } from "../../../src/observability/services/lived-experience-audit.js";
+const now = () => "2026-05-03T10:00:00.000Z";
+test("T5.3.1 queryExplain fallbackRef → warning no user-visible contact", () => {
+    const store = new AppendOnlyAuditStore();
+    const rec = createLivedExperienceAuditRecorder(store);
+    const decisionId = "dec-s4";
+    const traceId = "tr-s4";
+    rec.recordDeliveryAudit({
+        auditId: "da-fb",
+        decisionId,
+        traceId,
+        status: "not_sent_fallback",
+        fallbackRef: "fallback:abc-123",
+        reasonCodes: ["operator_fallback"],
+        createdAt: now(),
+    });
+    const op = queryExplain({ kind: "fallback", fallbackRef: "fallback:abc-123" }, store);
+    assert.ok(op.warnings.includes("no_user_visible_contact_claim_prohibited"));
+    assert.equal(op.deliveryStatus, "not_sent_fallback");
+});
+test("T5.3.1 queryExplain decisionId + delivery auditId + source_ref", () => {
+    const store = new AppendOnlyAuditStore();
+    const rec = createLivedExperienceAuditRecorder(store);
+    const decisionId = "dec-multi";
+    const traceId = "tr-multi";
+    const srcId = "src-ref-99";
+    rec.recordDecisionTrace({
+        decisionId,
+        traceId,
+        runtimeScope: "rhythm",
+        outcome: "heartbeat_ok",
+        reasonCodes: [],
+        sourceRefs: [{ id: srcId, kind: "platform_item", uri: "https://example.test/r" }],
+        createdAt: now(),
+    });
+    rec.recordDeliveryAudit({
+        auditId: "da-99",
+        decisionId,
+        traceId,
+        status: "failed",
+        reasonCodes: ["x"],
+        createdAt: now(),
+    });
+    const byDecision = queryExplain({ kind: "decision", decisionId }, store);
+    assert.equal(byDecision.relatedEventIds.length, 2);
+    const byDelivery = queryExplain({ kind: "delivery", auditId: "da-99" }, store);
+    assert.equal(byDelivery.relatedEventIds.length, 1);
+    const bySource = queryExplain({ kind: "source_ref", sourceRefId: srcId }, store);
+    assert.ok(bySource.relatedEventIds.length >= 1);
+});
+test("T5.3.1 queryExplain reportId matches envelope eventId", () => {
+    const store = new AppendOnlyAuditStore();
+    const rec = createLivedExperienceAuditRecorder(store);
+    rec.recordSourceCoverage({
+        auditId: "sc-1",
+        traceId: "trep",
+        subjectType: "quiet_artifact",
+        subjectRef: "quiet/day",
+        usedSourceRefs: [],
+        unresolvedRefs: [],
+        coverageRatio: 1,
+        unsupportedClaims: [],
+        status: "pass",
+        reasonCodes: [],
+        createdAt: now(),
+    });
+    const op = queryExplain({ kind: "report", reportId: "sc-1" }, store);
+    assert.equal(op.relatedEventIds.length, 1);
+});
+test("T5.3.1 exportAuditBundle returns redaction summary for range", async () => {
+    const store = new AppendOnlyAuditStore();
+    const rec = createLivedExperienceAuditRecorder(store);
+    rec.recordDecisionTrace({
+        decisionId: "d1",
+        traceId: "t1",
+        runtimeScope: "rhythm",
+        outcome: "heartbeat_ok",
+        reasonCodes: [],
+        sourceRefs: [],
+        createdAt: "2026-05-03T11:00:00.000Z",
+    });
+    const bundle = await exportAuditBundle({ from: "2026-05-03T00:00:00.000Z", to: "2026-05-03T23:59:59.000Z" }, createAppendOnlyAuditStoreRangeLoader(store));
+    assert.equal(bundle.events.length, 1);
+    assert.equal(bundle.redactionSummary.eventCount, 1);
+    assert.ok(bundle.redactionSummary.manifestIds.length >= 1);
+});

package/dist/tests/integration/observability/guidance-audit.test.d.ts

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

package/dist/tests/integration/observability/guidance-audit.test.js

@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { projectGuidanceParticipationAudit } from "../../../src/observability/projections/guidance-audit.js";
+test("guidance participation projection keeps guidance facts distinct from hard veto semantics", () => {
+    const projection = projectGuidanceParticipationAudit({
+        id: "guidance-1",
+        usedFallback: false,
+        sceneContext: {
+            sceneType: "outreach",
+            mode: "active",
+            riskLevel: "low",
+        },
+        payload: {
+            scene: {
+                sceneType: "outreach",
+                mode: "active",
+                riskLevel: "low",
+            },
+            atmosphere: {
+                kind: "atmosphere",
+                text: "atm",
+                openness: "open",
+                pressureLabels: ["active"],
+                reviewStatus: "pending_human_review",
+            },
+            impulses: [{ kind: "outreach", text: "impulse", reviewStatus: "pending_human_review" }],
+            personaReinforcement: [{ candidateId: "p1", source: "USER", text: "snippet", rationale: "因为和当前用户关系直接相关" }],
+            outputGuard: { kind: "output_guard", constraints: ["avoid customer service tone"], hardGuardPriority: true },
+        },
+    });
+    assert.equal(projection.eventId, "guidance-1");
+    assert.equal(projection.guidanceAvailable, true);
+    assert.equal(projection.usedFallback, false);
+    assert.ok(projection.blockSummary.includes("output_guard"));
+    assert.ok(projection.snippetRationales[0]?.includes("当前用户关系"));
+});
+test("guidance participation projection keeps unavailable path explainable", () => {
+    const projection = projectGuidanceParticipationAudit({
+        id: "guidance-2",
+        usedFallback: true,
+        sceneContext: {
+            sceneType: "reply",
+            mode: "active",
+            riskLevel: "high",
+        },
+        payload: {
+            available: false,
+            reason: "missing_template",
+        },
+    });
+    assert.equal(projection.guidanceAvailable, false);
+    assert.equal(projection.usedFallback, true);
+    assert.deepEqual(projection.snippetRationales, []);
+    assert.ok(projection.blockSummary.includes("unavailable:missing_template"));
+});

package/dist/tests/integration/observability/heartbeat-decision-record.test.d.ts

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

package/dist/tests/integration/observability/heartbeat-decision-record.test.js

@@ -0,0 +1,223 @@
+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 { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { DecisionLedger } from "../../../src/observability/services/decision-ledger.js";
+const cleanupPaths = [];
+const openDbs = [];
+afterEach(() => {
+    // Close all open database connections first
+    while (openDbs.length > 0) {
+        const db = openDbs.pop();
+        if (db) {
+            try {
+                db.close();
+            }
+            catch {
+                // Ignore close errors
+            }
+        }
+    }
+    // Then clean up files
+    while (cleanupPaths.length > 0) {
+        const target = cleanupPaths.pop();
+        if (target && fs.existsSync(target)) {
+            try {
+                fs.rmSync(target, { force: true });
+            }
+            catch {
+                // Ignore cleanup errors on Windows
+            }
+        }
+    }
+});
+function createTempDb() {
+    const dbPath = path.join(os.tmpdir(), `observability-${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 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
+    );
+  `);
+    const ledger = new DecisionLedger(database);
+    openDbs.push(database);
+    return { db: database, ledger, dbPath };
+}
+afterEach(() => {
+    while (cleanupPaths.length > 0) {
+        const target = cleanupPaths.pop();
+        if (target && fs.existsSync(target)) {
+            try {
+                fs.rmSync(target, { force: true });
+            }
+            catch {
+                // Ignore cleanup errors on Windows
+            }
+        }
+    }
+});
+// ─── T5.1.1: Heartbeat Decision Record Tests ────────────────────────────────
+test("T5.1.1 heartbeat_ok leaves a queryable record", async () => {
+    const { ledger } = createTempDb();
+    const event = {
+        id: "hb-ok-1",
+        tickId: "tick-1",
+        traceId: "trace-hb-ok-1",
+        runtimeScope: "rhythm",
+        triggerSource: "heartbeat_bridge",
+        decisionStatus: "heartbeat_ok",
+        reasons: ["silent_no_candidates"],
+        mode: "active",
+        createdAt: "2026-03-31T10:00:00Z",
+    };
+    await ledger.recordHeartbeatDecision(event);
+    const records = await ledger.queryByTickId("tick-1");
+    assert.equal(records.length, 1);
+    const record = records[0];
+    assert.equal(record.verdict, "defer");
+    assert.ok(record.reasons.includes("silent_no_candidates"));
+    assert.ok(record.evidenceRefs.some((r) => r.includes("scope:rhythm")));
+    assert.ok(record.evidenceRefs.some((r) => r.includes("trigger:heartbeat_bridge")));
+    assert.ok(record.evidenceRefs.some((r) => r.includes("status:heartbeat_ok")));
+});
+test("T5.1.1 denied leaves a queryable record", async () => {
+    const { ledger } = createTempDb();
+    const event = {
+        id: "hb-deny-1",
+        tickId: "tick-2",
+        traceId: "trace-hb-deny-1",
+        runtimeScope: "rhythm",
+        triggerSource: "heartbeat_bridge",
+        decisionStatus: "denied",
+        reasons: ["intent-obligation:deny(awaiting_user)"],
+        mode: "active",
+        createdAt: "2026-03-31T10:30:00Z",
+    };
+    await ledger.recordHeartbeatDecision(event);
+    const records = await ledger.queryByTickId("tick-2");
+    assert.equal(records.length, 1);
+    const record = records[0];
+    assert.equal(record.verdict, "deny");
+    assert.ok(record.reasons.includes("intent-obligation:deny(awaiting_user)"));
+    assert.ok(record.evidenceRefs.some((r) => r.includes("status:denied")));
+});
+test("T5.1.1 intent_selected (allow) leaves a queryable record", async () => {
+    const { ledger } = createTempDb();
+    const event = {
+        id: "hb-allow-1",
+        tickId: "tick-3",
+        traceId: "trace-hb-allow-1",
+        runtimeScope: "rhythm",
+        triggerSource: "heartbeat_bridge",
+        decisionStatus: "intent_selected",
+        reasons: [],
+        intentId: "intent-obligation-0",
+        mode: "active",
+        createdAt: "2026-03-31T11:00:00Z",
+    };
+    await ledger.recordHeartbeatDecision(event);
+    const records = await ledger.queryByTickId("tick-3");
+    assert.equal(records.length, 1);
+    const record = records[0];
+    assert.equal(record.verdict, "allow");
+    assert.equal(record.intentId, "intent-obligation-0");
+    assert.ok(record.evidenceRefs.some((r) => r.includes("status:intent_selected")));
+});
+test("T5.1.1 record distinguishes runtimeScope, triggerSource, decisionStatus, reasons", async () => {
+    const { ledger } = createTempDb();
+    await ledger.recordHeartbeatDecision({
+        id: "hb-multi-ok",
+        tickId: "tick-multi",
+        traceId: "trace-hb-multi-ok",
+        runtimeScope: "rhythm",
+        triggerSource: "heartbeat_bridge",
+        decisionStatus: "heartbeat_ok",
+        reasons: ["silent_no_candidates"],
+        mode: "quiet",
+        createdAt: "2026-03-31T12:00:00Z",
+    });
+    await ledger.recordHeartbeatDecision({
+        id: "hb-multi-deny",
+        tickId: "tick-multi",
+        traceId: "trace-hb-multi-deny",
+        runtimeScope: "rhythm",
+        triggerSource: "heartbeat_bridge",
+        decisionStatus: "denied",
+        reasons: ["budget_exceeded", "awaiting_user"],
+        mode: "active",
+        createdAt: "2026-03-31T12:30:00Z",
+    });
+    await ledger.recordHeartbeatDecision({
+        id: "hb-multi-allow",
+        tickId: "tick-multi",
+        traceId: "trace-hb-multi-allow",
+        runtimeScope: "rhythm",
+        triggerSource: "heartbeat_bridge",
+        decisionStatus: "intent_selected",
+        reasons: [],
+        intentId: "intent-social-0",
+        mode: "active",
+        createdAt: "2026-03-31T13:00:00Z",
+    });
+    const records = await ledger.queryByTickId("tick-multi");
+    assert.equal(records.length, 3);
+    const okRecord = records.find((r) => r.evidenceRefs.some((e) => e.includes("status:heartbeat_ok")));
+    const denyRecord = records.find((r) => r.evidenceRefs.some((e) => e.includes("status:denied")));
+    const allowRecord = records.find((r) => r.evidenceRefs.some((e) => e.includes("status:intent_selected")));
+    assert.ok(okRecord, "heartbeat_ok record should exist");
+    assert.ok(denyRecord, "denied record should exist");
+    assert.ok(allowRecord, "intent_selected record should exist");
+    for (const record of records) {
+        assert.ok(record.evidenceRefs.some((e) => e.startsWith("scope:")), "should have runtimeScope");
+        assert.ok(record.evidenceRefs.some((e) => e.startsWith("trigger:")), "should have triggerSource");
+        assert.ok(record.evidenceRefs.some((e) => e.startsWith("status:")), "should have decisionStatus");
+    }
+    assert.ok(Array.isArray(denyRecord?.reasons), "reasons should be an array");
+    assert.ok(denyRecord?.reasons.includes("budget_exceeded"), "reasons should contain budget_exceeded");
+    assert.ok(denyRecord?.reasons.includes("awaiting_user"), "reasons should contain awaiting_user");
+});
+test("T5.1.1 deferred verdict leaves a queryable record", async () => {
+    const { ledger } = createTempDb();
+    const event = {
+        id: "hb-defer-1",
+        tickId: "tick-4",
+        traceId: "trace-hb-defer-1",
+        runtimeScope: "rhythm",
+        triggerSource: "heartbeat_bridge",
+        decisionStatus: "deferred",
+        reasons: ["lease_unavailable"],
+        mode: "active",
+        createdAt: "2026-03-31T13:30:00Z",
+    };
+    await ledger.recordHeartbeatDecision(event);
+    const records = await ledger.queryByTickId("tick-4");
+    assert.equal(records.length, 1);
+    const record = records[0];
+    assert.equal(record.verdict, "defer");
+    assert.ok(record.evidenceRefs.some((r) => r.includes("status:deferred")));
+});

package/dist/tests/integration/observability/heartbeat-narrative-trace.test.d.ts

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