@haaaiawd/second-nature 0.1.50 → 0.1.51

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

@@ -1,219 +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 { 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

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

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

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

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

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

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

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

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

@@ -1,223 +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 { 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

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