@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/integration/connectors/scriptable-node-e2e.test.js

@@ -0,0 +1,228 @@
+/**
+ * T-CS.C.12 — Scriptable Runner end-to-end integration test.
+ *
+ * Verifies the full path:
+ *   workspace manifest (scriptable_node) → scanner/registry recognition
+ *   → executor loads runner.mjs → ConnectorResult success
+ *   → mapLifeEvidence extracts sourceRefs → appendLifeEvidence writes DB + artifact
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { createConnectorExecutorAdapter } from "../../../src/connectors/services/connector-executor-adapter.js";
+import { mapLifeEvidence } from "../../../src/connectors/base/map-life-evidence.js";
+import { appendLifeEvidence } from "../../../src/storage/life-evidence/append-life-evidence.js";
+import { lifeEvidenceIndex } from "../../../src/storage/db/schema/life-evidence-index.js";
+import { scanConnectorManifests } from "../../../src/connectors/registry/manifest-scanner.js";
+import { parseConnectorManifestV6 } from "../../../src/connectors/manifest/manifest-parser.js";
+const ORIGINAL_KEY = process.env.SECOND_NATURE_ENCRYPTION_KEY;
+function tempWorkspaceWithScriptableRunner() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-scriptable-e2e-"));
+    const connectorDir = path.join(dir, ".second-nature", "connectors", "scriptable-social");
+    fs.mkdirSync(connectorDir, { recursive: true });
+    fs.writeFileSync(path.join(connectorDir, "manifest.yaml"), `schemaVersion: "sn.connector.v1"
+platformId: "scriptable-social"
+displayName: "Scriptable Social"
+family: "custom"
+capabilities:
+  - id: "feed.read"
+    description: "Read feed via scriptable runner"
+runner:
+  kind: "scriptable_node"
+  entrypoint: "runner.mjs"
+credentials:
+  - type: "api_key"
+    required: false
+sourceRefPolicy:
+  minSourceRefs: 1
+  rejectInlineSensitivePayload: true
+trust:
+  status: "declarative_trusted"
+  reason: "test_fixture"
+`, "utf-8");
+    fs.writeFileSync(path.join(connectorDir, "runner.mjs"), `export default async function handler(input) {
+  return {
+    success: true,
+    data: {
+      posts: [
+        { id: "sc-1", title: "Scriptable post 1", url: "https://example.com/1" },
+        { id: "sc-2", title: "Scriptable post 2", url: "https://example.com/2" },
+      ],
+    },
+  };
+}
+`, "utf-8");
+    return dir;
+}
+test.beforeEach(() => {
+    process.env.SECOND_NATURE_ENCRYPTION_KEY = "x".repeat(32);
+});
+test.afterEach(() => {
+    if (ORIGINAL_KEY === undefined)
+        delete process.env.SECOND_NATURE_ENCRYPTION_KEY;
+    else
+        process.env.SECOND_NATURE_ENCRYPTION_KEY = ORIGINAL_KEY;
+});
+test("T-CS.C.12-A: scanner recognizes scriptable_node manifest", async () => {
+    const workspaceRoot = tempWorkspaceWithScriptableRunner();
+    try {
+        const scanned = scanConnectorManifests(workspaceRoot);
+        assert.equal(scanned.length, 1, "scanner must find exactly 1 manifest");
+        const parsed = parseConnectorManifestV6(scanned[0].content);
+        assert.equal(parsed.ok, true, `manifest parse failed: ${JSON.stringify(parsed)}`);
+        const manifest = parsed.manifest;
+        assert.equal(manifest.platformId, "scriptable-social");
+        assert.equal(manifest.runner.kind, "scriptable_node");
+        assert.equal(manifest.runner.entrypoint, "runner.mjs");
+    }
+    finally {
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+});
+test("T-CS.C.12-B: executor loads runner.mjs and returns success", async () => {
+    const workspaceRoot = tempWorkspaceWithScriptableRunner();
+    try {
+        const stateDb = createStateDatabase(":memory:");
+        const observabilityDb = createObservabilityDatabase(":memory:");
+        const executor = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+            workspaceRoot,
+        });
+        const result = await executor.executeEffect({
+            intent: "feed.read",
+            platformId: "scriptable-social",
+            payload: {},
+            decisionId: "dec-sc-1",
+            intentId: "intent-sc-1",
+            idempotencyKey: "sc-feed-1",
+        });
+        assert.equal(result.status, "success", `expected success, got ${JSON.stringify(result)}`);
+        assert.ok(result.data, "result must contain data");
+        const payload = result.data;
+        const data = payload.data;
+        const posts = data.posts;
+        assert.equal(posts.length, 2);
+        assert.equal(posts[0].id, "sc-1");
+        assert.equal(posts[1].id, "sc-2");
+    }
+    finally {
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+});
+test("T-CS.C.12-C: mapLifeEvidence extracts sourceRefs from scriptable_node result", async () => {
+    const workspaceRoot = tempWorkspaceWithScriptableRunner();
+    try {
+        const stateDb = createStateDatabase(":memory:");
+        const observabilityDb = createObservabilityDatabase(":memory:");
+        const executor = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+            workspaceRoot,
+        });
+        const result = await executor.executeEffect({
+            intent: "feed.read",
+            platformId: "scriptable-social",
+            payload: {},
+            decisionId: "dec-sc-2",
+            intentId: "intent-sc-2",
+            idempotencyKey: "sc-feed-2",
+        });
+        assert.equal(result.status, "success");
+        const candidate = mapLifeEvidence({
+            platformId: "scriptable-social",
+            intent: "feed.read",
+            result,
+            observedAt: new Date().toISOString(),
+        });
+        assert.ok(candidate, "mapLifeEvidence must return candidate");
+        assert.equal(candidate.evidenceType, "platform_browse");
+        assert.equal(candidate.producer, "connector-system");
+        assert.equal(candidate.sensitivity, "public");
+        assert.equal(candidate.sourceRefs.length, 2);
+        assert.equal(candidate.sourceRefs[0].id, "sc-1");
+        assert.equal(candidate.sourceRefs[0].uri, "https://example.com/1");
+        assert.equal(candidate.sourceRefs[1].id, "sc-2");
+        assert.equal(candidate.sourceRefs[1].uri, "https://example.com/2");
+    }
+    finally {
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+});
+test("T-CS.C.12-D: full chain writes life_evidence_index row and artifact", async () => {
+    const workspaceRoot = tempWorkspaceWithScriptableRunner();
+    try {
+        const stateDb = createStateDatabase(":memory:");
+        const observabilityDb = createObservabilityDatabase(":memory:");
+        const beforeRows = await stateDb.db.select().from(lifeEvidenceIndex);
+        assert.equal(beforeRows.length, 0, "DB must be empty before test");
+        const executor = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+            workspaceRoot,
+        });
+        const result = await executor.executeEffect({
+            intent: "feed.read",
+            platformId: "scriptable-social",
+            payload: {},
+            decisionId: "dec-sc-3",
+            intentId: "intent-sc-3",
+            idempotencyKey: "sc-feed-3",
+        });
+        assert.equal(result.status, "success");
+        const candidate = mapLifeEvidence({
+            platformId: "scriptable-social",
+            intent: "feed.read",
+            result,
+            observedAt: new Date().toISOString(),
+        });
+        assert.ok(candidate);
+        const ack = await appendLifeEvidence(stateDb, workspaceRoot, candidate);
+        assert.ok(ack.evidenceId, "ack must contain evidenceId");
+        const afterRows = await stateDb.db.select().from(lifeEvidenceIndex);
+        assert.equal(afterRows.length, 1, "DB must contain exactly 1 new evidence row");
+        assert.equal(afterRows[0].platformId, "scriptable-social");
+        assert.equal(afterRows[0].evidenceType, "platform_browse");
+        assert.equal(afterRows[0].producer, "connector-system");
+        assert.ok(afterRows[0].sourceRefsJson.includes("sc-1"), "sourceRefsJson must contain sc-1");
+        assert.ok(afterRows[0].sourceRefsJson.includes("sc-2"), "sourceRefsJson must contain sc-2");
+        const artifactPath = path.join(workspaceRoot, afterRows[0].artifactPath);
+        assert.ok(fs.existsSync(artifactPath), "artifact file must exist on disk");
+        const artifactContent = JSON.parse(fs.readFileSync(artifactPath, "utf-8"));
+        assert.equal(artifactContent.platformId, "scriptable-social");
+        assert.equal(artifactContent.evidenceType, "platform_browse");
+        assert.equal(artifactContent.sourceRefs.length, 2);
+    }
+    finally {
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+});
+test("T-CS.C.12-E: optional credential (required:false) does not block execution when vault empty", async () => {
+    const workspaceRoot = tempWorkspaceWithScriptableRunner();
+    // Intentionally do NOT seed credential
+    try {
+        const stateDb = createStateDatabase(":memory:");
+        const observabilityDb = createObservabilityDatabase(":memory:");
+        const executor = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+            workspaceRoot,
+        });
+        const result = await executor.executeEffect({
+            intent: "feed.read",
+            platformId: "scriptable-social",
+            payload: {},
+            decisionId: "dec-sc-opt",
+            intentId: "intent-sc-opt",
+            idempotencyKey: "sc-opt-1",
+        });
+        assert.equal(result.status, "success", `expected success without credential, got ${JSON.stringify(result)}`);
+    }
+    finally {
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+});

package/dist/tests/integration/connectors/t3-3-1-real-connector-evidence.test.d.ts

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

package/dist/tests/integration/connectors/t3-3-1-real-connector-evidence.test.js

@@ -0,0 +1,171 @@
+/**
+ * T3.3.1 — Real connector evidence writeback integration.
+ *
+ * Acceptance:
+ * A. connector success with source-backed data → LifeEvidence artifact + index written.
+ * B. connector success with empty data → no evidence fabricated.
+ * C. connector failure → no evidence fabricated, honest attempt only.
+ * D. missing state/workspaceRoot → cycle completes without evidence write.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { resolveAllowedIntentResult } from "../../../src/core/second-nature/heartbeat/heartbeat-loop.js";
+import { loadLifeEvidenceSnapshot } from "../../../src/storage/snapshots/life-evidence-snapshot.js";
+function makeTempWorkspace() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-t3-3-1-"));
+    fs.mkdirSync(path.join(dir, ".second-nature", "evidence"), { recursive: true });
+    return dir;
+}
+function createCandidateIntent(overrides) {
+    return {
+        id: "intent-exploration-001",
+        kind: "exploration",
+        priority: 70,
+        source: "tick",
+        platformId: "moltbook",
+        summary: "scan platform opportunities",
+        effectClass: "connector_action",
+        sourceRefs: [{ id: "ref-1", kind: "workspace_artifact", uri: "workspace://test" }],
+        idempotencyKey: "exploration:scan",
+        goalInfluenceRefs: [],
+        ...overrides,
+    };
+}
+function createRuntimeSnapshot() {
+    const continuity = {
+        mode: "active",
+        currentWindowId: "default",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        budgets: { socialUsed: 0, socialLimit: 5 },
+    };
+    return {
+        continuity,
+        lifeEvidence: {
+            evidenceRefs: [],
+            platformEventCount: 0,
+            workEventCount: 0,
+        },
+        rhythmWindow: {
+            windowId: "default",
+            allowedIntentKinds: ["exploration", "work", "social", "quiet", "reflection", "outreach", "maintenance"],
+            quietBias: false,
+        },
+        hardGuards: {
+            hasDuplicateIntent: () => false,
+            isOutreachCooldownClear: () => true,
+        },
+    };
+}
+function createSnapshotInputs() {
+    return {
+        mode: "active",
+        currentWindowId: "default",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        budgets: { socialUsed: 0, socialLimit: 5 },
+    };
+}
+function createSignal() {
+    return {
+        trigger: "heartbeat_bridge",
+        payload: { timestamp: new Date().toISOString() },
+    };
+}
+function mockConnectorResult(status, data, failureClass) {
+    return {
+        status,
+        data,
+        failureClass,
+        metadata: {
+            platformId: "moltbook",
+            channel: "api_rest",
+            latencyMs: 120,
+        },
+    };
+}
+test("T3.3.1-A: connector success with sourceRefs writes life evidence artifact + index", async () => {
+    const workspaceRoot = makeTempWorkspace();
+    const stateDb = createStateDatabase(":memory:");
+    const result = await resolveAllowedIntentResult(createCandidateIntent(), createRuntimeSnapshot(), createSnapshotInputs(), createSignal(), {
+        connectorExecutor: {
+            executeEffect: async () => mockConnectorResult("success", {
+                items: [
+                    { id: "post-001", title: "Hello World" },
+                    { id: "post-002", title: "Second Post" },
+                ],
+            }),
+        },
+        state: stateDb,
+        workspaceRoot,
+    });
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.includes("connector_effect_executed"));
+    // Verify evidence was written to DB index
+    const snapshot = await loadLifeEvidenceSnapshot(stateDb, workspaceRoot, { limit: 10 }, { runRepairGate: false });
+    assert.ok(!snapshot.empty, "evidence snapshot must not be empty");
+    const totalCount = snapshot.platformEvents.length + snapshot.workEvents.length + snapshot.userInteractionEvents.length;
+    assert.ok(totalCount > 0, "at least one evidence row must exist");
+    assert.ok(snapshot.platformEvents.some((ev) => ev.sourceRefs.some((ref) => ref.id.includes("post-001") || ref.kind === "platform_item")), "evidence must contain platform item refs");
+    // Verify artifact file exists
+    const evidenceDir = path.join(workspaceRoot, ".second-nature", "evidence");
+    const files = fs.readdirSync(evidenceDir).filter((f) => f.endsWith(".json"));
+    assert.ok(files.length > 0, "artifact JSON must be written");
+    // Cleanup
+    fs.rmSync(workspaceRoot, { recursive: true, force: true });
+});
+test("T3.3.1-B: connector success with empty data does not fabricate evidence", async () => {
+    const workspaceRoot = makeTempWorkspace();
+    const stateDb = createStateDatabase(":memory:");
+    const result = await resolveAllowedIntentResult(createCandidateIntent(), createRuntimeSnapshot(), createSnapshotInputs(), createSignal(), {
+        connectorExecutor: {
+            executeEffect: async () => mockConnectorResult("success", { items: [] }),
+        },
+        state: stateDb,
+        workspaceRoot,
+    });
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.includes("connector_effect_executed"));
+    // Verify no evidence was written
+    const snapshot = await loadLifeEvidenceSnapshot(stateDb, workspaceRoot, { limit: 10 }, { runRepairGate: false });
+    assert.equal(snapshot.empty, true, "empty connector result must not produce evidence");
+    assert.equal(snapshot.platformEvents.length + snapshot.workEvents.length + snapshot.userInteractionEvents.length, 0);
+    // Cleanup
+    fs.rmSync(workspaceRoot, { recursive: true, force: true });
+});
+test("T3.3.1-C: connector failure does not fabricate evidence", async () => {
+    const workspaceRoot = makeTempWorkspace();
+    const stateDb = createStateDatabase(":memory:");
+    const result = await resolveAllowedIntentResult(createCandidateIntent(), createRuntimeSnapshot(), createSnapshotInputs(), createSignal(), {
+        connectorExecutor: {
+            executeEffect: async () => mockConnectorResult("terminal_failure", undefined, "transport_failure"),
+        },
+        state: stateDb,
+        workspaceRoot,
+    });
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.includes("connector_terminal_failure"));
+    // Verify no evidence was written
+    const snapshot = await loadLifeEvidenceSnapshot(stateDb, workspaceRoot, { limit: 10 }, { runRepairGate: false });
+    assert.equal(snapshot.empty, true, "failure must not produce fabricated evidence");
+    // Cleanup
+    fs.rmSync(workspaceRoot, { recursive: true, force: true });
+});
+test("T3.3.1-D: missing state/workspaceRoot does not crash cycle", async () => {
+    const result = await resolveAllowedIntentResult(createCandidateIntent(), createRuntimeSnapshot(), createSnapshotInputs(), createSignal(), {
+        connectorExecutor: {
+            executeEffect: async () => mockConnectorResult("success", {
+                items: [{ id: "post-003" }],
+            }),
+        },
+        // No state, no workspaceRoot
+    });
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.includes("connector_effect_executed"));
+});

package/dist/tests/integration/control-plane/_helpers/decision-cycle-harness.d.ts

@@ -0,0 +1,40 @@
+import { type ContinuitySnapshot, type RhythmPolicy } from "../../../../src/core/second-nature/index.js";
+import type { DecisionLedger } from "../../../../src/observability/services/decision-ledger.js";
+import type { EffectDispatcher } from "../../../../src/core/second-nature/orchestrator/effect-dispatcher.js";
+export interface TickSignal {
+    id: string;
+    source: "cron" | "heartbeat" | "platform_event" | "user_interrupt" | "resume";
+    receivedAt: string;
+}
+export interface DecisionCycleHarness {
+    ingestTick(signal: TickSignal, snapshot: ContinuitySnapshot): Promise<{
+        status: string;
+        decisionId?: string;
+        intentId?: string;
+    }>;
+}
+export declare function createDecisionCycleHarness(input: {
+    rhythmPolicy: RhythmPolicy;
+    decisionLedger: DecisionLedger;
+    effectDispatcher: EffectDispatcher;
+    outreachModel: {
+        evaluateOutreachCandidate(payload: {
+            candidateId: string;
+            summary: string;
+            sourceRefs: string[];
+            recentOutreachHashes: string[];
+            requiredUserHelp?: boolean;
+        }): Promise<{
+            valueScore: number;
+            novelty: number;
+            userRelevance: number;
+            actionability: number;
+            urgency: number;
+            requiredUserHelp: boolean;
+            isRoutineProgress: boolean;
+            minThreshold: number;
+            sourceRefs: string[];
+            explanation?: string;
+        }>;
+    };
+}): DecisionCycleHarness;

package/dist/tests/integration/control-plane/_helpers/decision-cycle-harness.js

@@ -0,0 +1,116 @@
+import { randomUUID } from "crypto";
+import { buildOutreachMessage, decideDecisionBasis, evaluateGuards, evaluateOutreach, planIntent, selectRhythmWindow, } from "../../../../src/core/second-nature/index.js";
+export function createDecisionCycleHarness(input) {
+    const { rhythmPolicy, decisionLedger, effectDispatcher, outreachModel } = input;
+    return {
+        async ingestTick(signal, snapshot) {
+            const window = selectRhythmWindow(signal.receivedAt, snapshot, rhythmPolicy);
+            const effectiveSnapshot = {
+                ...snapshot,
+                mode: window.topLevelMode,
+                currentWindowId: window.windowId,
+            };
+            const plannedIntents = planIntent(effectiveSnapshot);
+            const interruptIntent = signal.source === "user_interrupt" && window.topLevelMode === "paused_for_interrupt"
+                ? [{
+                        id: `intent-interrupt-${signal.id}`,
+                        kind: "maintenance",
+                        priority: 1000,
+                        source: "interrupt",
+                        summary: "handle high-value interrupt",
+                        effectClass: "maintenance",
+                        platformId: undefined,
+                        sourceRefs: [],
+                        idempotencyKey: `interrupt:${signal.id}`,
+                    }]
+                : [];
+            const intents = [...interruptIntent, ...plannedIntents];
+            for (const intent of intents) {
+                const guard = evaluateGuards(intent, effectiveSnapshot);
+                const decisionBasis = decideDecisionBasis(intent);
+                const decisionId = randomUUID();
+                const traceId = `trace:${decisionId}`;
+                const interruptDeferred = intent.source === "interrupt" && window.topLevelMode === "paused_for_interrupt";
+                const verdict = interruptDeferred ? "defer" : guard.verdict;
+                const reasonCodes = interruptDeferred
+                    ? ["interrupt_handling"]
+                    : guard.reasons.length > 0 ? guard.reasons : ["guard_clear"];
+                if (intent.kind === "outreach") {
+                    const gate = await evaluateOutreach(outreachModel, {
+                        candidateId: intent.id,
+                        summary: intent.summary,
+                        sourceRefs: [traceId],
+                        recentOutreachHashes: effectiveSnapshot.recentOutreachHashes,
+                        requiredUserHelp: true,
+                    });
+                    const outreachVerdict = gate.allowed ? "allow" : "deny";
+                    await decisionLedger.recordDecision({
+                        id: decisionId,
+                        tickId: signal.id,
+                        traceId,
+                        intentId: intent.id,
+                        platformId: intent.platformId,
+                        verdict: outreachVerdict,
+                        mode: window.topLevelMode,
+                        reasons: gate.reasonCodes.length > 0 ? gate.reasonCodes : ["outreach_gate_passed"],
+                        reasonCodes: gate.reasonCodes.length > 0 ? gate.reasonCodes : ["outreach_gate_passed"],
+                        decisionBasis,
+                        evidenceRefs: gate.evaluation.sourceRefs,
+                        createdAt: new Date().toISOString(),
+                    });
+                    await decisionLedger.recordOutreachDecision({
+                        id: `${decisionId}:outreach`,
+                        tickId: signal.id,
+                        eventType: gate.allowed ? "outreach.sent" : "outreach.denied",
+                        platformId: intent.platformId,
+                        valueScore: gate.evaluation.valueScore,
+                        suppressionReason: gate.reasonCodes.join(","),
+                        messagePreview: gate.allowed
+                            ? buildOutreachMessage({ summary: intent.summary, evaluation: gate.evaluation }).intent.coreMeaning
+                            : undefined,
+                        createdAt: new Date().toISOString(),
+                    });
+                    return { status: gate.allowed ? "outreach_allowed" : "outreach_denied", decisionId, intentId: intent.id };
+                }
+                await decisionLedger.recordDecision({
+                    id: decisionId,
+                    tickId: signal.id,
+                    traceId,
+                    intentId: intent.id,
+                    platformId: intent.platformId,
+                    verdict,
+                    mode: window.topLevelMode,
+                    reasons: reasonCodes,
+                    reasonCodes,
+                    decisionBasis,
+                    evidenceRefs: [traceId],
+                    createdAt: new Date().toISOString(),
+                });
+                if (interruptDeferred) {
+                    return { status: "interrupt_deferred", decisionId, intentId: intent.id };
+                }
+                if (guard.verdict === "allow") {
+                    const result = await effectDispatcher.dispatchEffect({
+                        id: intent.id,
+                        kind: intent.kind,
+                        summary: intent.summary,
+                        effectClass: intent.effectClass,
+                        platformId: intent.platformId,
+                        payload: { signalId: signal.id, mode: window.topLevelMode },
+                    }, {
+                        decisionId,
+                        intentId: intent.id,
+                        tickId: signal.id,
+                        checkpointId: `checkpoint:${intent.id}:${signal.id}`,
+                        traceId,
+                    });
+                    return { status: result.status, decisionId, intentId: intent.id };
+                }
+                if (guard.verdict === "escalate") {
+                    return { status: "escalated", decisionId, intentId: intent.id };
+                }
+            }
+            return { status: "idle" };
+        },
+    };
+}

package/dist/tests/integration/control-plane/decision-loop-validation.test.d.ts

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