@langadventurellc/task-trellis-mcp 1.1.0 → 1.2.1

package/dist/services/local/__tests__/pruneClosed.test.js

@@ -2,212 +2,472 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const models_1 = require("../../../models");
 const pruneClosed_1 = require("../pruneClosed");
-jest.mock("../../../models/isClosed", () => ({
-    isClosed: jest.fn(),
-}));
-const { isClosed } = require("../../../models/isClosed");
 describe("pruneClosed", () => {
     let mockRepository;
+    const mockDate = new Date("2025-01-15T12:00:00Z");
     beforeEach(() => {
         mockRepository = {
             getObjectById: jest.fn(),
             getObjects: jest.fn(),
             saveObject: jest.fn(),
             deleteObject: jest.fn(),
+            getChildrenOf: jest.fn(),
         };
-        isClosed.mockClear();
+        jest.clearAllMocks();
+        jest.useFakeTimers();
+        jest.setSystemTime(mockDate);
     });
-    const createMockObject = (id, status, updatedTime) => ({
-        id,
-        type: models_1.TrellisObjectType.TASK,
-        title: `Test ${id}`,
-        status,
-        priority: models_1.TrellisObjectPriority.MEDIUM,
-        parent: undefined,
-        prerequisites: [],
-        affectedFiles: new Map(),
-        log: [],
-        schema: "1.0",
-        childrenIds: [],
-        created: new Date().toISOString(),
-        updated: updatedTime,
-        body: "",
+    afterEach(() => {
+        jest.useRealTimers();
     });
-    it("should prune old closed objects", async () => {
-        const oldClosedObject = createMockObject("T-old-closed", models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString());
-        mockRepository.getObjects.mockResolvedValue([oldClosedObject]);
-        isClosed.mockReturnValue(true);
-        mockRepository.deleteObject.mockResolvedValue(undefined);
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 60); // 1 hour
-        expect(mockRepository.getObjects).toHaveBeenCalledWith(true, undefined);
-        expect(isClosed).toHaveBeenCalledWith(oldClosedObject, 0, [
-            oldClosedObject,
-        ]);
-        expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-old-closed", true);
-        expect(result.content[0].text).toContain("Pruned 1 closed objects older than 60 minutes");
-        expect(result.content[0].text).toContain("T-old-closed");
-    });
-    it("should not prune recent closed objects", async () => {
-        const recentClosedObject = createMockObject("T-recent-closed", models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 30 * 60 * 1000).toISOString());
-        mockRepository.getObjects.mockResolvedValue([recentClosedObject]);
-        isClosed.mockReturnValue(true);
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 60); // 1 hour
-        expect(mockRepository.getObjects).toHaveBeenCalledWith(true, undefined);
-        expect(isClosed).toHaveBeenCalledWith(recentClosedObject, 0, [
-            recentClosedObject,
-        ]);
-        expect(mockRepository.deleteObject).not.toHaveBeenCalled();
-        expect(result.content[0].text).toContain("Pruned 0 closed objects older than 60 minutes");
-    });
-    it("should not prune open objects", async () => {
-        const openObject = createMockObject("T-open", models_1.TrellisObjectStatus.IN_PROGRESS, new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString());
-        mockRepository.getObjects.mockResolvedValue([openObject]);
-        isClosed.mockReturnValue(false);
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 60); // 1 hour
-        expect(mockRepository.getObjects).toHaveBeenCalledWith(true, undefined);
-        expect(isClosed).toHaveBeenCalledWith(openObject, 0, [openObject]);
-        expect(mockRepository.deleteObject).not.toHaveBeenCalled();
-        expect(result.content[0].text).toContain("Pruned 0 closed objects older than 60 minutes");
-    });
-    it("should handle scope parameter", async () => {
-        const oldClosedObject = createMockObject("T-scoped-closed", models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString());
-        mockRepository.getObjects.mockResolvedValue([oldClosedObject]);
-        isClosed.mockReturnValue(true);
-        mockRepository.deleteObject.mockResolvedValue(undefined);
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 60, "F-test-feature");
-        expect(mockRepository.getObjects).toHaveBeenCalledWith(true, "F-test-feature");
-        expect(result.content[0].text).toContain("in scope F-test-feature");
-    });
-    it("should handle mixed object types and statuses", async () => {
-        const oldDoneTask = createMockObject("T-old-done", models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString());
-        const oldWontDoTask = createMockObject("T-old-wont-do", models_1.TrellisObjectStatus.WONT_DO, new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString());
-        const recentDoneTask = createMockObject("T-recent-done", models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 30 * 60 * 1000).toISOString());
-        const openTask = createMockObject("T-open", models_1.TrellisObjectStatus.IN_PROGRESS, new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString());
-        mockRepository.getObjects.mockResolvedValue([
-            oldDoneTask,
-            oldWontDoTask,
-            recentDoneTask,
-            openTask,
-        ]);
-        isClosed.mockImplementation((obj) => obj.status === models_1.TrellisObjectStatus.DONE ||
-            obj.status === models_1.TrellisObjectStatus.WONT_DO);
-        mockRepository.deleteObject.mockResolvedValue(undefined);
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 60);
-        expect(mockRepository.deleteObject).toHaveBeenCalledTimes(2);
-        expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-old-done", true);
-        expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-old-wont-do", true);
-        expect(result.content[0].text).toContain("Pruned 2 closed objects");
-        expect(result.content[0].text).toContain("T-old-done");
-        expect(result.content[0].text).toContain("T-old-wont-do");
-    });
-    it("should handle deletion failures gracefully", async () => {
-        const oldClosedObject1 = createMockObject("T-old-closed-1", models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString());
-        const oldClosedObject2 = createMockObject("T-old-closed-2", models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString());
-        mockRepository.getObjects.mockResolvedValue([
-            oldClosedObject1,
-            oldClosedObject2,
-        ]);
-        isClosed.mockReturnValue(true);
-        // First deletion fails, second succeeds
-        mockRepository.deleteObject
-            .mockRejectedValueOnce(new Error("Permission denied"))
-            .mockResolvedValueOnce(undefined);
-        // Mock console.error to check error logging
-        const consoleSpy = jest.spyOn(console, "error").mockImplementation();
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 60);
-        expect(mockRepository.deleteObject).toHaveBeenCalledTimes(2);
-        expect(consoleSpy).toHaveBeenCalledWith("Failed to delete object T-old-closed-1:", expect.any(Error));
-        expect(result.content[0].text).toContain("Pruned 1 closed objects");
-        expect(result.content[0].text).toContain("T-old-closed-2");
-        expect(result.content[0].text).not.toContain("T-old-closed-1");
-        consoleSpy.mockRestore();
-    });
-    it("should handle repository getObjects error", async () => {
-        const errorMessage = "Repository connection failed";
-        mockRepository.getObjects.mockRejectedValue(new Error(errorMessage));
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 60);
-        expect(result.content[0].text).toContain("Error pruning closed objects");
-        expect(result.content[0].text).toContain(errorMessage);
-    });
-    it("should handle empty object list", async () => {
-        mockRepository.getObjects.mockResolvedValue([]);
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 60);
-        expect(mockRepository.deleteObject).not.toHaveBeenCalled();
-        expect(result.content[0].text).toContain("Pruned 0 closed objects");
+    const createMockObject = (id, status, daysAgo) => {
+        const updatedTime = new Date(mockDate.getTime() - daysAgo * 24 * 60 * 60 * 1000);
+        return {
+            id,
+            type: models_1.TrellisObjectType.TASK,
+            title: `Test ${id}`,
+            status,
+            priority: models_1.TrellisObjectPriority.MEDIUM,
+            prerequisites: [],
+            affectedFiles: new Map(),
+            log: [],
+            schema: "v1.0",
+            childrenIds: [],
+            body: "",
+            created: updatedTime.toISOString(),
+            updated: updatedTime.toISOString(),
+        };
+    };
+    describe("day-based age calculation", () => {
+        it("should delete objects older than 1 day", async () => {
+            const objects = [
+                createMockObject("T-old", models_1.TrellisObjectStatus.DONE, 2), // 2 days old
+                createMockObject("T-recent", models_1.TrellisObjectStatus.DONE, 0), // Today
+            ];
+            mockRepository.getObjects.mockResolvedValue(objects);
+            mockRepository.getChildrenOf.mockResolvedValue([]);
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(1);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-old", true);
+            expect(result.content[0].text).toContain("Pruned 1 closed objects older than 1 days");
+            expect(result.content[0].text).toContain("Deleted objects: T-old");
+        });
+        it("should delete objects older than 7 days", async () => {
+            const objects = [
+                createMockObject("T-very-old", models_1.TrellisObjectStatus.DONE, 10), // 10 days old
+                createMockObject("T-old", models_1.TrellisObjectStatus.DONE, 5), // 5 days old
+                createMockObject("T-recent", models_1.TrellisObjectStatus.DONE, 1), // 1 day old
+            ];
+            mockRepository.getObjects.mockResolvedValue(objects);
+            mockRepository.getChildrenOf.mockResolvedValue([]);
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 7);
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(1);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-very-old", true);
+            expect(result.content[0].text).toContain("Pruned 1 closed objects older than 7 days");
+        });
+        it("should delete objects older than 30 days", async () => {
+            const objects = [
+                createMockObject("T-ancient", models_1.TrellisObjectStatus.DONE, 45), // 45 days old
+                createMockObject("T-old", models_1.TrellisObjectStatus.DONE, 20), // 20 days old
+            ];
+            mockRepository.getObjects.mockResolvedValue(objects);
+            mockRepository.getChildrenOf.mockResolvedValue([]);
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 30);
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(1);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-ancient", true);
+            expect(result.content[0].text).toContain("Pruned 1 closed objects older than 30 days");
+        });
     });
-    it("should handle zero age parameter", async () => {
-        const oldClosedObject = createMockObject("T-old-closed", models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 1000).toISOString());
-        mockRepository.getObjects.mockResolvedValue([oldClosedObject]);
-        isClosed.mockReturnValue(true);
-        mockRepository.deleteObject.mockResolvedValue(undefined);
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 0);
-        expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-old-closed", true);
-        expect(result.content[0].text).toContain("Pruned 1 closed objects older than 0 minutes");
+    describe("objects with no children", () => {
+        it("should delete closed objects with no children (existing behavior)", async () => {
+            const objects = [
+                createMockObject("T-done", models_1.TrellisObjectStatus.DONE, 5),
+                createMockObject("T-wont-do", models_1.TrellisObjectStatus.WONT_DO, 3),
+            ];
+            mockRepository.getObjects.mockResolvedValue(objects);
+            mockRepository.getChildrenOf.mockResolvedValue([]);
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(2);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-done", true);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-wont-do", true);
+            expect(result.content[0].text).toContain("Pruned 2 closed objects older than 1 days");
+            expect(result.content[0].text).toContain("Deleted objects: T-done, T-wont-do");
+        });
+        it("should not delete open objects", async () => {
+            const objects = [
+                createMockObject("T-open", models_1.TrellisObjectStatus.OPEN, 5),
+                createMockObject("T-in-progress", models_1.TrellisObjectStatus.IN_PROGRESS, 5),
+                createMockObject("T-done", models_1.TrellisObjectStatus.DONE, 5),
+            ];
+            mockRepository.getObjects.mockResolvedValue(objects);
+            mockRepository.getChildrenOf.mockResolvedValue([]);
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(1);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-done", true);
+            expect(result.content[0].text).toContain("Pruned 1 closed objects older than 1 days");
+        });
     });
-    it("should handle large age parameter", async () => {
-        const veryOldObject = createMockObject("T-ancient", models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString());
-        mockRepository.getObjects.mockResolvedValue([veryOldObject]);
-        isClosed.mockReturnValue(true);
-        mockRepository.deleteObject.mockResolvedValue(undefined);
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 999999);
-        expect(mockRepository.deleteObject).not.toHaveBeenCalled();
-        expect(result.content[0].text).toContain("Pruned 0 closed objects older than 999999 minutes");
+    describe("hierarchical child validation", () => {
+        it("should skip closed parent with open children", async () => {
+            const parentObject = createMockObject("F-parent", models_1.TrellisObjectStatus.DONE, 5);
+            const openChild = createMockObject("T-open-child", models_1.TrellisObjectStatus.OPEN, 1);
+            mockRepository.getObjects.mockResolvedValue([parentObject]);
+            mockRepository.getChildrenOf.mockResolvedValue([openChild]);
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            expect(mockRepository.getChildrenOf).toHaveBeenCalledWith("F-parent", true);
+            expect(mockRepository.deleteObject).not.toHaveBeenCalled();
+            expect(result.content[0].text).toContain("Pruned 0 closed objects older than 1 days");
+            expect(result.content[0].text).toContain("Skipped 1 objects with open children: F-parent");
+        });
+        it("should delete closed parent with only closed children", async () => {
+            const parentObject = createMockObject("F-parent", models_1.TrellisObjectStatus.DONE, 5);
+            const closedChild1 = createMockObject("T-done-child", models_1.TrellisObjectStatus.DONE, 3);
+            const closedChild2 = createMockObject("T-wont-do-child", models_1.TrellisObjectStatus.WONT_DO, 2);
+            mockRepository.getObjects.mockResolvedValue([parentObject]);
+            mockRepository.getChildrenOf.mockResolvedValue([
+                closedChild1,
+                closedChild2,
+            ]);
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            expect(mockRepository.getChildrenOf).toHaveBeenCalledWith("F-parent", true);
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(1);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("F-parent", true);
+            expect(result.content[0].text).toContain("Pruned 1 closed objects older than 1 days");
+            expect(result.content[0].text).toContain("Deleted objects: F-parent");
+        });
+        it("should handle mixed scenarios with some parents having open children and others not", async () => {
+            const parentWithOpenChild = createMockObject("F-parent-1", models_1.TrellisObjectStatus.DONE, 5);
+            const parentWithClosedChildren = createMockObject("F-parent-2", models_1.TrellisObjectStatus.DONE, 5);
+            const parentWithNoChildren = createMockObject("T-orphan", models_1.TrellisObjectStatus.DONE, 5);
+            const openChild = createMockObject("T-open", models_1.TrellisObjectStatus.OPEN, 1);
+            const closedChild = createMockObject("T-closed", models_1.TrellisObjectStatus.DONE, 1);
+            mockRepository.getObjects.mockResolvedValue([
+                parentWithOpenChild,
+                parentWithClosedChildren,
+                parentWithNoChildren,
+            ]);
+            mockRepository.getChildrenOf.mockImplementation((parentId) => {
+                if (parentId === "F-parent-1")
+                    return Promise.resolve([openChild]);
+                if (parentId === "F-parent-2")
+                    return Promise.resolve([closedChild]);
+                return Promise.resolve([]); // No children for T-orphan
+            });
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            // With recursive checking, we call getChildrenOf for each object and their descendants
+            expect(mockRepository.getChildrenOf).toHaveBeenCalledTimes(4);
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(2);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("F-parent-2", true);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-orphan", true);
+            expect(result.content[0].text).toContain("Pruned 2 closed objects older than 1 days");
+            expect(result.content[0].text).toContain("Deleted objects: F-parent-2, T-orphan");
+            expect(result.content[0].text).toContain("Skipped 1 objects with open children: F-parent-1");
+        });
     });
-    it("should handle non-Error exceptions", async () => {
-        const errorValue = "String error";
-        mockRepository.getObjects.mockRejectedValue(errorValue);
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 60);
-        expect(result.content[0].text).toContain("Error pruning closed objects");
-        expect(result.content[0].text).toContain(errorValue);
+    describe("multi-level hierarchies", () => {
+        it("should handle grandparent → parent → child hierarchy correctly", async () => {
+            const grandparent = createMockObject("E-grandparent", models_1.TrellisObjectStatus.DONE, 5);
+            const parent = createMockObject("F-parent", models_1.TrellisObjectStatus.DONE, 4);
+            const openChild = createMockObject("T-open-child", models_1.TrellisObjectStatus.OPEN, 1);
+            mockRepository.getObjects.mockResolvedValue([grandparent, parent]);
+            mockRepository.getChildrenOf.mockImplementation((parentId) => {
+                if (parentId === "E-grandparent")
+                    return Promise.resolve([parent]); // Parent is closed
+                if (parentId === "F-parent")
+                    return Promise.resolve([openChild]); // Child is open
+                return Promise.resolve([]);
+            });
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            // Both grandparent and parent should be skipped because they have open descendants
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(0);
+            expect(result.content[0].text).toContain("Pruned 0 closed objects older than 1 days");
+            expect(result.content[0].text).toContain("Skipped 2 objects with open children: E-grandparent, F-parent");
+        });
     });
-    it("should calculate cutoff time correctly for different age values", async () => {
-        const currentTime = Date.now();
-        const testCases = [
-            { age: 30, expectedCutoff: currentTime - 30 * 60 * 1000 },
-            { age: 120, expectedCutoff: currentTime - 120 * 60 * 1000 },
-            { age: 1440, expectedCutoff: currentTime - 1440 * 60 * 1000 }, // 24 hours
-        ];
-        for (const { age, expectedCutoff } of testCases) {
-            const objectBeforeCutoff = createMockObject(`T-before-${age}`, models_1.TrellisObjectStatus.DONE, new Date(expectedCutoff - 1000).toISOString());
-            const objectAfterCutoff = createMockObject(`T-after-${age}`, models_1.TrellisObjectStatus.DONE, new Date(expectedCutoff + 1000).toISOString());
+    describe("deep hierarchy recursive descendant checking", () => {
+        it("should protect ancestors when deep descendant is open (4+ levels)", async () => {
+            const project = createMockObject("P-project", models_1.TrellisObjectStatus.DONE, 10);
+            const epic = createMockObject("E-epic", models_1.TrellisObjectStatus.DONE, 8);
+            const feature = createMockObject("F-feature", models_1.TrellisObjectStatus.DONE, 6);
+            const task = createMockObject("T-task", models_1.TrellisObjectStatus.DONE, 4);
+            const subtask = createMockObject("ST-subtask", models_1.TrellisObjectStatus.OPEN, 2);
             mockRepository.getObjects.mockResolvedValue([
-                objectBeforeCutoff,
-                objectAfterCutoff,
+                project,
+                epic,
+                feature,
+                task,
             ]);
-            isClosed.mockReturnValue(true);
-            mockRepository.deleteObject.mockResolvedValue(undefined);
-            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, age);
+            mockRepository.getChildrenOf.mockImplementation((parentId) => {
+                if (parentId === "P-project")
+                    return Promise.resolve([epic]);
+                if (parentId === "E-epic")
+                    return Promise.resolve([feature]);
+                if (parentId === "F-feature")
+                    return Promise.resolve([task]);
+                if (parentId === "T-task")
+                    return Promise.resolve([subtask]);
+                return Promise.resolve([]);
+            });
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            // All ancestors should be protected due to the open subtask at the deepest level
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(0);
+            expect(result.content[0].text).toContain("Pruned 0 closed objects older than 1 days");
+            expect(result.content[0].text).toContain("Skipped 4 objects with open children: P-project, E-epic, F-feature, T-task");
+        });
+        it("should allow deletion when all deep descendants are closed", async () => {
+            const project = createMockObject("P-project", models_1.TrellisObjectStatus.DONE, 10);
+            const epic = createMockObject("E-epic", models_1.TrellisObjectStatus.DONE, 8);
+            const feature = createMockObject("F-feature", models_1.TrellisObjectStatus.DONE, 6);
+            const task1 = createMockObject("T-task1", models_1.TrellisObjectStatus.DONE, 4);
+            const task2 = createMockObject("T-task2", models_1.TrellisObjectStatus.WONT_DO, 3);
+            const subtask1 = createMockObject("ST-subtask1", models_1.TrellisObjectStatus.DONE, 2);
+            const subtask2 = createMockObject("ST-subtask2", models_1.TrellisObjectStatus.WONT_DO, 1);
+            mockRepository.getObjects.mockResolvedValue([
+                project,
+                epic,
+                feature,
+                task1,
+                task2,
+            ]);
+            mockRepository.getChildrenOf.mockImplementation((parentId) => {
+                if (parentId === "P-project")
+                    return Promise.resolve([epic]);
+                if (parentId === "E-epic")
+                    return Promise.resolve([feature]);
+                if (parentId === "F-feature")
+                    return Promise.resolve([task1, task2]);
+                if (parentId === "T-task1")
+                    return Promise.resolve([subtask1]);
+                if (parentId === "T-task2")
+                    return Promise.resolve([subtask2]);
+                return Promise.resolve([]);
+            });
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            // All objects should be deleted since all descendants are closed
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(5);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("P-project", true);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("E-epic", true);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("F-feature", true);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-task1", true);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-task2", true);
+            expect(result.content[0].text).toContain("Pruned 5 closed objects older than 1 days");
+        });
+        it("should handle mixed branches - some with open descendants, some without", async () => {
+            const epic = createMockObject("E-epic", models_1.TrellisObjectStatus.DONE, 8);
+            const feature1 = createMockObject("F-feature1", models_1.TrellisObjectStatus.DONE, 6);
+            const feature2 = createMockObject("F-feature2", models_1.TrellisObjectStatus.DONE, 6);
+            const task1 = createMockObject("T-task1", models_1.TrellisObjectStatus.OPEN, 4); // Open task
+            const task2 = createMockObject("T-task2", models_1.TrellisObjectStatus.DONE, 4); // Closed task
+            const subtask = createMockObject("ST-subtask", models_1.TrellisObjectStatus.DONE, 2);
+            mockRepository.getObjects.mockResolvedValue([
+                epic,
+                feature1,
+                feature2,
+                task2,
+            ]);
+            mockRepository.getChildrenOf.mockImplementation((parentId) => {
+                if (parentId === "E-epic")
+                    return Promise.resolve([feature1, feature2]);
+                if (parentId === "F-feature1")
+                    return Promise.resolve([task1]); // Branch with open task
+                if (parentId === "F-feature2")
+                    return Promise.resolve([task2]); // Branch with closed task
+                if (parentId === "T-task2")
+                    return Promise.resolve([subtask]);
+                return Promise.resolve([]);
+            });
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            // Epic and feature1 should be protected due to open task1
+            // Feature2 and task2 should be deleted (all descendants closed)
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(2);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("F-feature2", true);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-task2", true);
+            expect(result.content[0].text).toContain("Pruned 2 closed objects older than 1 days");
+            expect(result.content[0].text).toContain("Skipped 2 objects with open children: E-epic, F-feature1");
+        });
+        it("should handle circular reference protection gracefully", async () => {
+            const obj1 = createMockObject("T-obj1", models_1.TrellisObjectStatus.DONE, 5);
+            const obj2 = createMockObject("T-obj2", models_1.TrellisObjectStatus.DONE, 5);
+            mockRepository.getObjects.mockResolvedValue([obj1, obj2]);
+            // Create circular reference: obj1 -> obj2 -> obj1
+            mockRepository.getChildrenOf.mockImplementation((parentId) => {
+                if (parentId === "T-obj1")
+                    return Promise.resolve([obj2]);
+                if (parentId === "T-obj2")
+                    return Promise.resolve([obj1]);
+                return Promise.resolve([]);
+            });
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            // Should complete without infinite loop and delete both objects
+            // (since they're all closed, the circular reference shouldn't prevent deletion)
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(2);
+            expect(result.content[0].text).toContain("Pruned 2 closed objects older than 1 days");
+        });
+        it("should handle empty hierarchy levels gracefully", async () => {
+            const parent = createMockObject("F-parent", models_1.TrellisObjectStatus.DONE, 5);
+            const middleChild = createMockObject("T-middle", models_1.TrellisObjectStatus.DONE, 4);
+            const leafChild = createMockObject("ST-leaf", models_1.TrellisObjectStatus.OPEN, 2);
+            mockRepository.getObjects.mockResolvedValue([parent, middleChild]);
+            mockRepository.getChildrenOf.mockImplementation((parentId) => {
+                if (parentId === "F-parent")
+                    return Promise.resolve([middleChild]);
+                if (parentId === "T-middle")
+                    return Promise.resolve([leafChild]);
+                return Promise.resolve([]);
+            });
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            // Both parent and middle should be protected due to open leaf
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(0);
+            expect(result.content[0].text).toContain("Skipped 2 objects with open children: F-parent, T-middle");
+        });
+        it("should handle child query errors gracefully in recursive checking", async () => {
+            const parent = createMockObject("F-parent", models_1.TrellisObjectStatus.DONE, 5);
+            const failingChild = createMockObject("T-failing", models_1.TrellisObjectStatus.DONE, 4);
+            mockRepository.getObjects.mockResolvedValue([parent]);
+            mockRepository.getChildrenOf.mockImplementation((parentId) => {
+                if (parentId === "F-parent")
+                    return Promise.resolve([failingChild]);
+                if (parentId === "T-failing")
+                    return Promise.reject(new Error("Query failed"));
+                return Promise.resolve([]);
+            });
+            mockRepository.deleteObject.mockResolvedValue();
+            const consoleSpy = jest.spyOn(console, "error").mockImplementation();
+            const _result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            // Should handle error gracefully and proceed with deletion
+            // (when we can't check descendants, we err on the side of deletion)
+            expect(consoleSpy).toHaveBeenCalledWith("Error checking descendants for T-failing:", expect.any(Error));
             expect(mockRepository.deleteObject).toHaveBeenCalledTimes(1);
-            expect(mockRepository.deleteObject).toHaveBeenCalledWith(`T-before-${age}`, true);
-            expect(result.content[0].text).toContain("Pruned 1 closed objects");
-            // Reset mocks for next iteration
-            mockRepository.deleteObject.mockClear();
-        }
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("F-parent", true);
+            consoleSpy.mockRestore();
+        });
+    });
+    describe("error handling", () => {
+        it("should handle errors when child queries fail gracefully", async () => {
+            const objects = [
+                createMockObject("F-parent-1", models_1.TrellisObjectStatus.DONE, 5),
+                createMockObject("F-parent-2", models_1.TrellisObjectStatus.DONE, 5),
+            ];
+            mockRepository.getObjects.mockResolvedValue(objects);
+            mockRepository.getChildrenOf.mockImplementation((parentId) => {
+                if (parentId === "F-parent-1") {
+                    return Promise.reject(new Error("Failed to query children"));
+                }
+                return Promise.resolve([]); // No children for parent-2
+            });
+            mockRepository.deleteObject.mockResolvedValue();
+            const consoleSpy = jest.spyOn(console, "error").mockImplementation();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            // Should continue processing other objects even if one child query fails
+            // With recursive checking, parent-1 gets deleted too (error in descendant check is handled gracefully)
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(2);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("F-parent-1", true);
+            expect(mockRepository.deleteObject).toHaveBeenCalledWith("F-parent-2", true);
+            expect(consoleSpy).toHaveBeenCalledWith("Error checking descendants for F-parent-1:", expect.any(Error));
+            expect(result.content[0].text).toContain("Pruned 2 closed objects older than 1 days");
+            consoleSpy.mockRestore();
+        });
+        it("should handle repository deletion errors gracefully", async () => {
+            const objects = [
+                createMockObject("T-fail", models_1.TrellisObjectStatus.DONE, 5),
+                createMockObject("T-success", models_1.TrellisObjectStatus.DONE, 5),
+            ];
+            mockRepository.getObjects.mockResolvedValue(objects);
+            mockRepository.getChildrenOf.mockResolvedValue([]);
+            mockRepository.deleteObject.mockImplementation((id) => {
+                if (id === "T-fail") {
+                    return Promise.reject(new Error("Deletion failed"));
+                }
+                return Promise.resolve();
+            });
+            const consoleSpy = jest.spyOn(console, "error").mockImplementation();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            expect(mockRepository.deleteObject).toHaveBeenCalledTimes(2);
+            expect(consoleSpy).toHaveBeenCalledWith("Failed to delete object T-fail:", expect.any(Error));
+            expect(result.content[0].text).toContain("Pruned 1 closed objects older than 1 days");
+            expect(result.content[0].text).toContain("Deleted objects: T-success");
+            consoleSpy.mockRestore();
+        });
+        it("should handle repository getObjects error gracefully", async () => {
+            mockRepository.getObjects.mockRejectedValue(new Error("Failed to fetch objects"));
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            expect(result.content[0].text).toContain("Error pruning closed objects: Failed to fetch objects");
+            expect(mockRepository.deleteObject).not.toHaveBeenCalled();
+        });
     });
-    it("should handle objects with different timestamps", async () => {
-        const objects = [
-            createMockObject("T-1-hour-ago", models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 60 * 60 * 1000).toISOString()),
-            createMockObject("T-2-hours-ago", models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString()),
-            createMockObject("T-30-minutes-ago", models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 30 * 60 * 1000).toISOString()),
-        ];
-        mockRepository.getObjects.mockResolvedValue(objects);
-        isClosed.mockReturnValue(true);
-        mockRepository.deleteObject.mockResolvedValue(undefined);
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 90); // 1.5 hours
-        expect(mockRepository.deleteObject).toHaveBeenCalledTimes(1);
-        expect(mockRepository.deleteObject).toHaveBeenCalledWith("T-2-hours-ago", true);
-        expect(result.content[0].text).toContain("Pruned 1 closed objects");
-        expect(result.content[0].text).toContain("T-2-hours-ago");
+    describe("scope filtering", () => {
+        it("should include scope in message when provided", async () => {
+            const objects = [
+                createMockObject("T-scoped", models_1.TrellisObjectStatus.DONE, 5),
+            ];
+            mockRepository.getObjects.mockResolvedValue(objects);
+            mockRepository.getChildrenOf.mockResolvedValue([]);
+            mockRepository.deleteObject.mockResolvedValue();
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1, "P-test-project");
+            expect(mockRepository.getObjects).toHaveBeenCalledWith(true, "P-test-project");
+            expect(result.content[0].text).toContain("Pruned 1 closed objects older than 1 days in scope P-test-project");
+        });
+        it("should handle empty results with scope", async () => {
+            mockRepository.getObjects.mockResolvedValue([]);
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1, "P-empty-project");
+            expect(result.content[0].text).toContain("Pruned 0 closed objects older than 1 days in scope P-empty-project");
+        });
     });
-    it("should handle bulk deletion scenarios", async () => {
-        const objectCount = 50;
-        const objects = Array.from({ length: objectCount }, (_, i) => createMockObject(`T-bulk-${i}`, models_1.TrellisObjectStatus.DONE, new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString()));
-        mockRepository.getObjects.mockResolvedValue(objects);
-        isClosed.mockReturnValue(true);
-        mockRepository.deleteObject.mockResolvedValue(undefined);
-        const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 60);
-        expect(mockRepository.deleteObject).toHaveBeenCalledTimes(objectCount);
-        expect(result.content[0].text).toContain(`Pruned ${objectCount} closed objects`);
+    describe("edge cases", () => {
+        it("should handle objects with no updated timestamp gracefully", async () => {
+            const objectWithoutTimestamp = {
+                ...createMockObject("T-no-timestamp", models_1.TrellisObjectStatus.DONE, 0),
+                updated: "", // Invalid timestamp
+            };
+            mockRepository.getObjects.mockResolvedValue([objectWithoutTimestamp]);
+            mockRepository.getChildrenOf.mockResolvedValue([]);
+            mockRepository.deleteObject.mockResolvedValue();
+            const _result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            // Invalid date comparisons result in false, so object won't be considered old enough
+            expect(mockRepository.deleteObject).not.toHaveBeenCalled();
+        });
+        it("should return disabled message for zero age threshold", async () => {
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 0);
+            // Should return disabled message without calling any repository methods
+            expect(mockRepository.getObjects).not.toHaveBeenCalled();
+            expect(mockRepository.getChildrenOf).not.toHaveBeenCalled();
+            expect(mockRepository.deleteObject).not.toHaveBeenCalled();
+            expect(result.content[0].text).toBe("Auto-prune disabled (threshold: 0 days)");
+        });
+        it("should return disabled message for negative age threshold", async () => {
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, -1);
+            // Should return disabled message without calling any repository methods
+            expect(mockRepository.getObjects).not.toHaveBeenCalled();
+            expect(mockRepository.getChildrenOf).not.toHaveBeenCalled();
+            expect(mockRepository.deleteObject).not.toHaveBeenCalled();
+            expect(result.content[0].text).toBe("Auto-prune disabled (threshold: -1 days)");
+        });
+        it("should include scope in disabled message when provided", async () => {
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 0, "P-test-project");
+            expect(mockRepository.getObjects).not.toHaveBeenCalled();
+            expect(result.content[0].text).toBe("Auto-prune disabled (threshold: 0 days) in scope P-test-project");
+        });
+        it("should handle empty object list", async () => {
+            mockRepository.getObjects.mockResolvedValue([]);
+            const result = await (0, pruneClosed_1.pruneClosed)(mockRepository, 1);
+            expect(mockRepository.getChildrenOf).not.toHaveBeenCalled();
+            expect(mockRepository.deleteObject).not.toHaveBeenCalled();
+            expect(result.content[0].text).toContain("Pruned 0 closed objects older than 1 days");
+        });
     });
 });
 //# sourceMappingURL=pruneClosed.test.js.map