@gethmy/agent 1.0.8 → 1.1.0

package/dist/__tests__/reconcile-heartbeat.test.js

@@ -0,0 +1,116 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+vi.mock("../worktree.js", () => ({
+    cleanupWorktree: vi.fn(),
+}));
+vi.mock("../board-helpers.js", () => ({
+    moveCardToColumn: vi.fn().mockResolvedValue(undefined),
+    addLabelByName: vi.fn().mockResolvedValue(undefined),
+    buildLabelMap: () => new Map(),
+    hasLabel: () => false,
+    resolveCardLabels: () => [],
+}));
+import { Reconciler } from "../reconcile.js";
+import { newRunId, StateStore } from "../state-store.js";
+import { DEFAULT_AGENT_CONFIG } from "../types.js";
+function makeRun(overrides = {}) {
+    return {
+        runId: newRunId(),
+        cardId: "card-z",
+        cardShortId: 7,
+        pipeline: "implement",
+        workerId: 0,
+        sessionId: null,
+        worktreePath: null,
+        branchName: null,
+        daemonPid: 999_999_999,
+        phase: "running",
+        startedAt: Date.now(),
+        lastHeartbeatAt: Date.now(),
+        endedAt: null,
+        status: "active",
+        costCents: 0,
+        ...overrides,
+    };
+}
+describe("Reconciler stale-heartbeat detection", () => {
+    let dir;
+    let store;
+    let pool;
+    let client;
+    beforeEach(() => {
+        dir = mkdtempSync(join(tmpdir(), "reconcile-"));
+        store = new StateStore(join(dir, "state.json"));
+        pool = {
+            knownCardIds: () => new Set(),
+            isCardActive: vi.fn().mockReturnValue(false),
+            isCardKnown: vi.fn().mockReturnValue(false),
+            enqueue: vi.fn().mockResolvedValue(undefined),
+            removeCard: vi.fn().mockResolvedValue(undefined),
+        };
+        client = {
+            getBoard: vi.fn().mockResolvedValue({
+                cards: [],
+                columns: [{ id: "col-todo", name: "To Do" }],
+                labels: [],
+            }),
+            endAgentSession: vi.fn().mockResolvedValue(undefined),
+            getCard: vi.fn().mockResolvedValue({
+                card: {
+                    id: "card-z",
+                    short_id: 7,
+                    project_id: "p",
+                    column_id: "col-todo",
+                    labelIds: [],
+                },
+            }),
+        };
+    });
+    afterEach(() => {
+        rmSync(dir, { recursive: true, force: true });
+    });
+    it("recovers foreign-daemon runs whose PID is dead", async () => {
+        await store.insertRun(makeRun({ daemonPid: 999_999_999 }));
+        const reconciler = new Reconciler(client, pool, "p", "agent-user", ["To Do"], [], "", 60_000, store, DEFAULT_AGENT_CONFIG);
+        // Exercise a single tick manually.
+        await reconciler.tick();
+        expect(client.endAgentSession).toHaveBeenCalledWith("card-z", expect.objectContaining({ status: "paused" }));
+        expect(store.getActiveRuns()).toHaveLength(0);
+    });
+    it("recovers our own runs whose worker lost track of the card", async () => {
+        // daemonPid === process.pid but pool does NOT have the card active
+        // and heartbeat is old. That's a zombie — should recover.
+        await store.insertRun(makeRun({
+            daemonPid: process.pid,
+            lastHeartbeatAt: Date.now() - 10 * 60_000, // 10 minutes ago
+        }));
+        const reconciler = new Reconciler(client, pool, "p", "agent-user", ["To Do"], [], "", 60_000, store, DEFAULT_AGENT_CONFIG);
+        await reconciler.tick();
+        expect(client.endAgentSession).toHaveBeenCalled();
+        expect(store.getActiveRuns()).toHaveLength(0);
+    });
+    it("does not touch our own runs that the pool still holds", async () => {
+        pool.isCardActive = vi.fn().mockReturnValue(true);
+        await store.insertRun(makeRun({
+            daemonPid: process.pid,
+            lastHeartbeatAt: Date.now() - 10 * 60_000,
+        }));
+        const reconciler = new Reconciler(client, pool, "p", "agent-user", ["To Do"], [], "", 60_000, store, DEFAULT_AGENT_CONFIG);
+        await reconciler.tick();
+        expect(client.endAgentSession).not.toHaveBeenCalled();
+        expect(store.getActiveRuns()).toHaveLength(1);
+    });
+    it("does not touch fresh runs even if foreign-pid checks match", async () => {
+        // Foreign daemon but pid is our own (alive) — not dead.
+        await store.insertRun(makeRun({
+            daemonPid: process.pid,
+            lastHeartbeatAt: Date.now(), // fresh
+        }));
+        pool.isCardActive = vi.fn().mockReturnValue(true);
+        const reconciler = new Reconciler(client, pool, "p", "agent-user", ["To Do"], [], "", 60_000, store, DEFAULT_AGENT_CONFIG);
+        await reconciler.tick();
+        expect(client.endAgentSession).not.toHaveBeenCalled();
+    });
+});

package/dist/__tests__/recovery.test.d.ts

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

package/dist/__tests__/recovery.test.js

@@ -0,0 +1,126 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { recoverOrphans } from "../recovery.js";
+import { newRunId, StateStore } from "../state-store.js";
+import { DEFAULT_AGENT_CONFIG } from "../types.js";
+// Mock worktree cleanup so tests don't shell out.
+vi.mock("../worktree.js", () => ({
+    cleanupWorktree: vi.fn(),
+}));
+// Mock board helpers so we can stub out network.
+vi.mock("../board-helpers.js", () => ({
+    moveCardToColumn: vi.fn().mockResolvedValue(undefined),
+    addLabelByName: vi.fn().mockResolvedValue(undefined),
+}));
+import { addLabelByName, moveCardToColumn } from "../board-helpers.js";
+import { cleanupWorktree } from "../worktree.js";
+function makeClient(overrides = {}) {
+    return {
+        endAgentSession: vi.fn().mockResolvedValue(undefined),
+        getCard: vi.fn().mockResolvedValue({
+            card: {
+                id: "card-1",
+                short_id: 42,
+                project_id: "proj-1",
+                title: "test",
+                column_id: "col-1",
+            },
+        }),
+        ...overrides,
+    };
+}
+function sampleRun(overrides = {}) {
+    return {
+        runId: newRunId(),
+        cardId: "card-1",
+        cardShortId: 42,
+        pipeline: "implement",
+        workerId: 0,
+        sessionId: null,
+        worktreePath: "/tmp/wt",
+        branchName: "agent/42-thing",
+        daemonPid: 999_999_999, // almost certainly not alive
+        phase: "running",
+        startedAt: Date.now(),
+        lastHeartbeatAt: Date.now(),
+        endedAt: null,
+        status: "active",
+        costCents: 0,
+        ...overrides,
+    };
+}
+describe("recoverOrphans", () => {
+    let dir;
+    let store;
+    beforeEach(() => {
+        dir = mkdtempSync(join(tmpdir(), "recovery-"));
+        store = new StateStore(join(dir, "state.json"));
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        rmSync(dir, { recursive: true, force: true });
+    });
+    it("no-ops when there are no active runs", async () => {
+        const client = makeClient();
+        const outcomes = await recoverOrphans(store, client, DEFAULT_AGENT_CONFIG);
+        expect(outcomes).toEqual([]);
+        expect(client.endAgentSession).not.toHaveBeenCalled();
+    });
+    it("ends session, moves implement card, labels, and cleans worktree", async () => {
+        const run = sampleRun();
+        await store.insertRun(run);
+        const client = makeClient();
+        const outcomes = await recoverOrphans(store, client, DEFAULT_AGENT_CONFIG);
+        expect(outcomes).toHaveLength(1);
+        expect(outcomes[0].errors).toEqual([]);
+        expect(client.endAgentSession).toHaveBeenCalledWith("card-1", expect.objectContaining({ status: "paused" }));
+        expect(moveCardToColumn).toHaveBeenCalledWith(client, expect.objectContaining({ id: "card-1" }), DEFAULT_AGENT_CONFIG.pickupColumns[0]);
+        expect(addLabelByName).toHaveBeenCalledWith(client, expect.objectContaining({ id: "card-1" }), "agent-recovered", expect.any(String));
+        expect(cleanupWorktree).toHaveBeenCalledWith("/tmp/wt", "agent/42-thing");
+        expect(store.getRun(run.runId).status).toBe("orphaned");
+    });
+    it("does not move review cards back to a pickup column", async () => {
+        const run = sampleRun({ pipeline: "review" });
+        await store.insertRun(run);
+        const client = makeClient();
+        await recoverOrphans(store, client, DEFAULT_AGENT_CONFIG);
+        expect(moveCardToColumn).not.toHaveBeenCalled();
+        expect(addLabelByName).toHaveBeenCalled();
+        expect(cleanupWorktree).toHaveBeenCalled();
+    });
+    it("still closes out state when the card is not reachable", async () => {
+        const run = sampleRun();
+        await store.insertRun(run);
+        const client = makeClient({
+            getCard: vi.fn().mockRejectedValue(new Error("404")),
+        });
+        const outcomes = await recoverOrphans(store, client, DEFAULT_AGENT_CONFIG);
+        expect(outcomes[0].actions).toContain("card not reachable — local cleanup only");
+        expect(cleanupWorktree).toHaveBeenCalled();
+        expect(store.getRun(run.runId).status).toBe("orphaned");
+    });
+    it("skips runs that claim a live daemon pid", async () => {
+        const run = sampleRun({ daemonPid: process.pid });
+        await store.insertRun(run);
+        const client = makeClient();
+        const outcomes = await recoverOrphans(store, client, DEFAULT_AGENT_CONFIG);
+        expect(outcomes[0].actions).toContain("skipped: daemon pid still alive");
+        expect(client.endAgentSession).not.toHaveBeenCalled();
+        expect(store.getRun(run.runId).status).toBe("active");
+    });
+    it("continues past individual API failures and records them", async () => {
+        const run = sampleRun();
+        await store.insertRun(run);
+        const client = makeClient({
+            endAgentSession: vi.fn().mockRejectedValue(new Error("boom")),
+        });
+        const outcomes = await recoverOrphans(store, client, DEFAULT_AGENT_CONFIG);
+        expect(outcomes[0].errors).toEqual([
+            expect.stringContaining("endAgentSession: boom"),
+        ]);
+        expect(cleanupWorktree).toHaveBeenCalled();
+        expect(store.getRun(run.runId).status).toBe("orphaned");
+    });
+});

package/dist/__tests__/review-parser.test.d.ts

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

package/dist/__tests__/review-parser.test.js

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { parseReviewOutput } from "../review-completion.js";
+describe("parseReviewOutput", () => {
+    it("parses verdict from ```json fenced block (strategy 1)", () => {
+        const out = `
+Some preamble text.
+
+\`\`\`json
+{
+  "verdict": "approved",
+  "summary": "All good",
+  "findings": []
+}
+\`\`\`
+`;
+        const r = parseReviewOutput(out);
+        expect(r.verdict).toBe("approved");
+        expect(r.summary).toBe("All good");
+    });
+    it("parses last fenced block when multiple are present", () => {
+        const out = `
+\`\`\`json
+{ "verdict": "rejected", "summary": "first" }
+\`\`\`
+
+Later correction:
+
+\`\`\`json
+{ "verdict": "approved", "summary": "final" }
+\`\`\`
+`;
+        const r = parseReviewOutput(out);
+        expect(r.verdict).toBe("approved");
+        expect(r.summary).toBe("final");
+    });
+    it("parses bare JSON object without fences (strategy 2)", () => {
+        const out = `Thinking...
+{ "unrelated": true }
+Result:
+{ "verdict": "rejected", "summary": "bugs", "findings": [{ "title": "x", "severity": "major" }] }
+`;
+        const r = parseReviewOutput(out);
+        expect(r.verdict).toBe("rejected");
+        expect(r.findings).toHaveLength(1);
+        expect(r.findings[0].title).toBe("x");
+    });
+    it("falls back to regex when JSON is malformed (strategy 3)", () => {
+        const out = `Claude rambling without proper JSON close
+    "verdict": "approved", "summary": "but missing braces everywhere
+    `;
+        const r = parseReviewOutput(out);
+        expect(r.verdict).toBe("approved");
+        expect(r.findings).toHaveLength(0);
+    });
+    it("returns error verdict when nothing parseable (strategy 4)", () => {
+        const out = "Just prose. No JSON. No verdict keyword.";
+        const r = parseReviewOutput(out);
+        expect(r.verdict).toBe("error");
+    });
+    it("handles empty output gracefully", () => {
+        const r = parseReviewOutput("");
+        expect(r.verdict).toBe("error");
+        expect(r.summary).toBe("");
+    });
+});

package/dist/__tests__/state-store.test.d.ts

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

package/dist/__tests__/state-store.test.js

@@ -0,0 +1,132 @@
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { newRunId, StateStore } from "../state-store.js";
+describe("StateStore", () => {
+    let dir;
+    let path;
+    beforeEach(() => {
+        dir = mkdtempSync(join(tmpdir(), "agent-state-"));
+        path = join(dir, "state.json");
+    });
+    afterEach(() => {
+        rmSync(dir, { recursive: true, force: true });
+    });
+    function sampleRun(overrides = {}) {
+        return {
+            runId: newRunId(),
+            cardId: "card-1",
+            cardShortId: 42,
+            pipeline: "implement",
+            workerId: 0,
+            sessionId: "sess-1",
+            worktreePath: "/tmp/wt",
+            branchName: "agent/42-thing",
+            daemonPid: process.pid,
+            phase: "preparing",
+            startedAt: Date.now(),
+            lastHeartbeatAt: Date.now(),
+            endedAt: null,
+            status: "active",
+            costCents: 0,
+            ...overrides,
+        };
+    }
+    it("loads empty state when file does not exist", () => {
+        const store = new StateStore(path);
+        expect(store.getActiveRuns()).toEqual([]);
+        expect(store.getDaemon()).toEqual({
+            daemonId: null,
+            daemonPid: null,
+            daemonStartedAt: null,
+        });
+    });
+    it("persists daemon metadata atomically", async () => {
+        const store = new StateStore(path);
+        await store.setDaemon("daemon-abc", 12345);
+        const raw = JSON.parse(readFileSync(path, "utf-8"));
+        expect(raw.daemonId).toBe("daemon-abc");
+        expect(raw.daemonPid).toBe(12345);
+    });
+    it("inserts, heartbeats, and ends a run", async () => {
+        const store = new StateStore(path);
+        const run = sampleRun();
+        await store.insertRun(run);
+        expect(store.getActiveRuns()).toHaveLength(1);
+        expect(store.getRun(run.runId)?.cardId).toBe("card-1");
+        const before = store.getRun(run.runId).lastHeartbeatAt;
+        await new Promise((r) => setTimeout(r, 5));
+        await store.heartbeat(run.runId);
+        expect(store.getRun(run.runId).lastHeartbeatAt).toBeGreaterThan(before);
+        await store.endRun(run.runId, "completed");
+        expect(store.getActiveRuns()).toHaveLength(0);
+        expect(store.getRun(run.runId).status).toBe("completed");
+        expect(store.getRun(run.runId).endedAt).not.toBeNull();
+    });
+    it("reloads persisted state after reopen", async () => {
+        const store = new StateStore(path);
+        await store.setDaemon("d1", 1);
+        await store.insertRun(sampleRun({ cardId: "card-7" }));
+        const reopened = new StateStore(path);
+        expect(reopened.getDaemon().daemonId).toBe("d1");
+        expect(reopened.getActiveRuns()[0].cardId).toBe("card-7");
+    });
+    it("tracks card attempts and resets on success", async () => {
+        const store = new StateStore(path);
+        expect(await store.incrementAttempt("c1")).toBe(1);
+        expect(await store.incrementAttempt("c1")).toBe(2);
+        await store.recordOutcome("c1", "failure");
+        expect(store.getCard("c1").attempts).toBe(2);
+        await store.recordOutcome("c1", "success");
+        expect(store.getCard("c1").attempts).toBe(0);
+    });
+    it("aggregates cost per card and per UTC day", async () => {
+        const store = new StateStore(path);
+        await store.addCost("c1", 100);
+        await store.addCost("c1", 250);
+        await store.addCost("c2", 50);
+        expect(store.getCard("c1").totalCostCents).toBe(350);
+        expect(store.getCard("c2").totalCostCents).toBe(50);
+        expect(store.getDailyCostCents()).toBe(400);
+    });
+    it("manages DLQ status", async () => {
+        const store = new StateStore(path);
+        expect(store.isDlq("c1")).toBe(false);
+        await store.markDlq("c1", "build failed 3x");
+        expect(store.isDlq("c1")).toBe(true);
+        expect(store.listDlq()).toHaveLength(1);
+        expect(store.getCard("c1").dlqReason).toBe("build failed 3x");
+        await store.clearDlq("c1");
+        expect(store.isDlq("c1")).toBe(false);
+        expect(store.listDlq()).toHaveLength(0);
+    });
+    it("serializes concurrent writes via the write queue", async () => {
+        const store = new StateStore(path);
+        const run = sampleRun();
+        await store.insertRun(run);
+        await Promise.all([
+            store.heartbeat(run.runId),
+            store.updateRun(run.runId, { phase: "running" }),
+            store.addCost(run.cardId, 10),
+            store.addCost(run.cardId, 20),
+        ]);
+        await store.flush();
+        const raw = JSON.parse(readFileSync(path, "utf-8"));
+        expect(raw.runs[0].phase).toBe("running");
+        expect(raw.cards.find((c) => c.cardId === run.cardId)
+            .totalCostCents).toBe(30);
+    });
+    it("handles corrupted state files by starting fresh", () => {
+        const brokenPath = join(dir, "broken.json");
+        require("node:fs").writeFileSync(brokenPath, "{not valid json", "utf-8");
+        const store = new StateStore(brokenPath);
+        expect(store.getActiveRuns()).toEqual([]);
+    });
+    it("migrates away from unknown schema versions", () => {
+        const future = join(dir, "future.json");
+        require("node:fs").writeFileSync(future, JSON.stringify({ version: 99, runs: [{}] }), "utf-8");
+        const store = new StateStore(future);
+        expect(store.getActiveRuns()).toEqual([]);
+    });
+});

package/dist/__tests__/transitions.test.d.ts

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

package/dist/__tests__/transitions.test.js

@@ -0,0 +1,130 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { runTransition, TransitionError } from "../transitions.js";
+function makeBoard() {
+    return {
+        columns: [
+            { id: "col-todo", name: "To Do" },
+            { id: "col-progress", name: "In Progress" },
+            { id: "col-review", name: "Review" },
+            { id: "col-done", name: "Done" },
+        ],
+        labels: [
+            { id: "lbl-agent", name: "agent" },
+            { id: "lbl-dlq", name: "dlq" },
+        ],
+    };
+}
+function makeCard(overrides = {}) {
+    return {
+        id: "card-1",
+        short_id: 42,
+        project_id: "proj",
+        title: "t",
+        column_id: "col-todo",
+        labelIds: [],
+        ...overrides,
+    };
+}
+function makeClient(overrides = {}) {
+    return {
+        getBoard: vi.fn().mockResolvedValue(makeBoard()),
+        moveCard: vi.fn().mockResolvedValue({}),
+        addLabelToCard: vi.fn().mockResolvedValue({}),
+        removeLabelFromCard: vi.fn().mockResolvedValue({}),
+        createLabel: vi.fn().mockResolvedValue({ label: { id: "lbl-new" } }),
+        updateCard: vi.fn().mockResolvedValue({}),
+        endAgentSession: vi.fn().mockResolvedValue({}),
+        ...overrides,
+    };
+}
+describe("runTransition", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("moves, labels, and ends session in order", async () => {
+        const client = makeClient();
+        const card = makeCard();
+        await runTransition(client, card, {
+            move: { columnName: "In Progress" },
+            addLabels: [{ name: "agent" }],
+            endSession: { status: "completed", progressPercent: 100 },
+        });
+        expect(client.moveCard).toHaveBeenCalledWith("card-1", "col-progress");
+        expect(client.addLabelToCard).toHaveBeenCalledWith("card-1", "lbl-agent");
+        expect(client.endAgentSession).toHaveBeenCalledWith("card-1", {
+            status: "completed",
+            progressPercent: 100,
+        });
+    });
+    it("is idempotent when the card is already in the target column", async () => {
+        const client = makeClient();
+        const card = makeCard({ column_id: "col-progress" });
+        await runTransition(client, card, { move: { columnName: "In Progress" } });
+        expect(client.moveCard).not.toHaveBeenCalled();
+    });
+    it("skips adding a label the card already has", async () => {
+        const client = makeClient();
+        const card = makeCard({ labelIds: ["lbl-agent"] });
+        await runTransition(client, card, { addLabels: [{ name: "agent" }] });
+        expect(client.addLabelToCard).not.toHaveBeenCalled();
+    });
+    it("creates missing labels on demand", async () => {
+        const client = makeClient();
+        const card = makeCard();
+        await runTransition(client, card, {
+            addLabels: [{ name: "agent-recovered", color: "#ff0000" }],
+        });
+        expect(client.createLabel).toHaveBeenCalledWith("proj", {
+            name: "agent-recovered",
+            color: "#ff0000",
+        });
+        expect(client.addLabelToCard).toHaveBeenCalledWith("card-1", "lbl-new");
+    });
+    it("removes labels idempotently", async () => {
+        const client = makeClient();
+        const card = makeCard({ labelIds: ["lbl-agent", "lbl-dlq"] });
+        await runTransition(client, card, { removeLabels: ["agent", "nope"] });
+        expect(client.removeLabelFromCard).toHaveBeenCalledTimes(1);
+        expect(client.removeLabelFromCard).toHaveBeenCalledWith("card-1", "lbl-agent");
+    });
+    it("retries a flaky step before giving up", async () => {
+        const moveCard = vi
+            .fn()
+            .mockRejectedValueOnce(new Error("502"))
+            .mockRejectedValueOnce(new Error("502"))
+            .mockResolvedValueOnce({});
+        const client = makeClient({ moveCard });
+        await runTransition(client, makeCard(), { move: { columnName: "Review" } }, { retries: 3, backoffMs: 1 });
+        expect(moveCard).toHaveBeenCalledTimes(3);
+    });
+    it("throws TransitionError with the failing step after retries exhausted", async () => {
+        const endAgentSession = vi
+            .fn()
+            .mockRejectedValue(new Error("upstream down"));
+        const client = makeClient({ endAgentSession });
+        await expect(runTransition(client, makeCard(), { endSession: { status: "paused" } }, { retries: 2, backoffMs: 1 })).rejects.toMatchObject({
+            name: "TransitionError",
+            step: "endSession",
+            attempts: 2,
+        });
+        expect(endAgentSession).toHaveBeenCalledTimes(2);
+    });
+    it("warns but continues when target column is missing in non-strict mode", async () => {
+        const client = makeClient();
+        await expect(runTransition(client, makeCard(), {
+            move: { columnName: "No Such Column" },
+        })).resolves.toBeUndefined();
+        expect(client.moveCard).not.toHaveBeenCalled();
+    });
+    it("throws when target column is missing in strict mode", async () => {
+        const client = makeClient();
+        await expect(runTransition(client, makeCard(), { move: { columnName: "No Such Column" } }, { strictColumn: true })).rejects.toBeInstanceOf(TransitionError);
+    });
+    it("heartbeats the state store when wired", async () => {
+        const client = makeClient();
+        const heartbeat = vi.fn().mockResolvedValue(undefined);
+        const store = { heartbeat };
+        await runTransition(client, makeCard(), { move: { columnName: "Done" } }, { store, runId: "r_1" });
+        expect(heartbeat).toHaveBeenCalledWith("r_1");
+    });
+});

package/dist/__tests__/worktree-gc.test.d.ts

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