@haaaiawd/second-nature 0.1.50 → 0.1.51

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

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

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

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

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

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

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

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