@langadventurellc/task-trellis-mcp 1.0.1 → 1.2.0

package/dist/__tests__/e2e/crud/listObjects.e2e.test.js

@@ -81,48 +81,44 @@ describe("E2E CRUD - listObjects", () => {
             }), { status: "open" });
         });
         it("should list only projects when type=project", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "project",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].id).toBe("P-test-project");
-            expect(objects[0].type).toBe("project");
+            expect(objects[0]).toBe("P-test-project");
         });
         it("should list only tasks when type=task", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].id).toBe("T-test-task");
-            expect(objects[0].type).toBe("task");
+            expect(objects[0]).toBe("T-test-task");
         });
         it("should list only epics when type=epic", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "epic",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].id).toBe("E-test-epic");
-            expect(objects[0].type).toBe("epic");
+            expect(objects[0]).toBe("E-test-epic");
         });
         it("should list only features when type=feature", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "feature",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].id).toBe("F-test-feature");
-            expect(objects[0].type).toBe("feature");
+            expect(objects[0]).toBe("F-test-feature");
         });
         it("should return empty array when no objects of specified type exist", async () => {
             // Test with a scope that doesn't exist to get empty results
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 scope: "E-nonexistent-epic",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toEqual([]);
         });
     });
@@ -141,41 +137,235 @@ describe("E2E CRUD - listObjects", () => {
             }
         });
         it("should filter objects by status", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 status: "in-progress",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].status).toBe("in-progress");
         });
         it("should exclude closed tasks by default", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
-            const closedTasks = objects.filter((o) => o.status === "done" || o.status === "wont-do");
-            expect(closedTasks).toHaveLength(0);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            // Note: Can't filter by status since only IDs are returned
+            // Expect only open objects to be returned by default (3 in this case)
+            expect(objects).toHaveLength(3);
         });
         it("should include closed tasks when includeClosed=true", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 includeClosed: true,
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(5);
-            const closedTasks = objects.filter((o) => o.status === "done" || o.status === "wont-do");
-            expect(closedTasks).toHaveLength(2);
+            // Note: Can't test individual object status since only IDs are returned
         });
         it("should filter open tasks correctly", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 status: "open",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].status).toBe("open");
-            expect(objects[0].id).toBe("T-open-task");
+            expect(objects[0]).toBe("T-open-task");
+        });
+    });
+    describe("includeClosed Flag with Different Object Types", () => {
+        beforeEach(async () => {
+            // Create projects with different statuses
+            const projectStatuses = [
+                { status: "open", folder: "open" },
+                { status: "done", folder: "closed" },
+                { status: "wont-do", folder: "closed" },
+            ];
+            for (const config of projectStatuses) {
+                await (0, utils_1.createObjectFile)(testEnv.projectRoot, "project", `P-${config.status}-project`, (0, utils_1.createObjectContent)({
+                    id: `P-${config.status}-project`,
+                    title: `${config.status} Project`,
+                    status: config.status,
+                }));
+            }
+            // Create a project first for epics to belong to
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "project", "P-epic-container", (0, utils_1.createObjectContent)({
+                id: "P-epic-container",
+                title: "Epic Container Project",
+                status: "open",
+            }));
+            // Create epics with different statuses within the project
+            const epicStatuses = [
+                { status: "open", folder: "open" },
+                { status: "in-progress", folder: "open" },
+                { status: "done", folder: "closed" },
+                { status: "wont-do", folder: "closed" },
+            ];
+            for (const config of epicStatuses) {
+                await (0, utils_1.createObjectFile)(testEnv.projectRoot, "epic", `E-${config.status}-epic`, (0, utils_1.createObjectContent)({
+                    id: `E-${config.status}-epic`,
+                    title: `${config.status} Epic`,
+                    status: config.status,
+                    parent: "P-epic-container",
+                }), { projectId: "P-epic-container" });
+            }
+            // Create features with different statuses
+            const featureStatuses = [
+                { status: "draft", folder: "open" },
+                { status: "open", folder: "open" },
+                { status: "done", folder: "closed" },
+                { status: "wont-do", folder: "closed" },
+            ];
+            for (const config of featureStatuses) {
+                await (0, utils_1.createObjectFile)(testEnv.projectRoot, "feature", `F-${config.status}-feature`, (0, utils_1.createObjectContent)({
+                    id: `F-${config.status}-feature`,
+                    title: `${config.status} Feature`,
+                    status: config.status,
+                }));
+            }
+            // Create tasks with different statuses (already covered in other tests, but adding for completeness)
+            const taskStatuses = [
+                { status: "draft", folder: "open" },
+                { status: "open", folder: "open" },
+                { status: "in-progress", folder: "open" },
+                { status: "done", folder: "closed" },
+                { status: "wont-do", folder: "closed" },
+            ];
+            for (const config of taskStatuses) {
+                await (0, utils_1.createObjectFile)(testEnv.projectRoot, "task", `T-${config.status}-includeclosed`, (0, utils_1.createObjectContent)({
+                    id: `T-${config.status}-includeclosed`,
+                    title: `${config.status} Task`,
+                    status: config.status,
+                }), { status: config.folder });
+            }
+        });
+        it("should exclude closed projects by default", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "project",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            // Filter to only the objects we created in this test (excluding the epic container)
+            const testObjects = objects.filter((id) => id.includes("-project") && !id.includes("epic-container"));
+            expect(testObjects).toHaveLength(1);
+            expect(testObjects).toContain("P-open-project");
+            expect(testObjects).not.toContain("P-done-project");
+            expect(testObjects).not.toContain("P-wont-do-project");
+        });
+        it("should include closed projects when includeClosed=true", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "project",
+                includeClosed: true,
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            // Filter to only the objects we created in this test (excluding the epic container)
+            const testObjects = objects.filter((id) => id.includes("-project") && !id.includes("epic-container"));
+            expect(testObjects).toHaveLength(3);
+            expect(testObjects).toContain("P-open-project");
+            expect(testObjects).toContain("P-done-project");
+            expect(testObjects).toContain("P-wont-do-project");
+        });
+        it("should exclude closed epics by default", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "epic",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toHaveLength(2);
+            expect(objects).toContain("E-open-epic");
+            expect(objects).toContain("E-in-progress-epic");
+            expect(objects).not.toContain("E-done-epic");
+            expect(objects).not.toContain("E-wont-do-epic");
+        });
+        it("should include closed epics when includeClosed=true", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "epic",
+                includeClosed: true,
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toHaveLength(4);
+            expect(objects).toContain("E-open-epic");
+            expect(objects).toContain("E-in-progress-epic");
+            expect(objects).toContain("E-done-epic");
+            expect(objects).toContain("E-wont-do-epic");
+        });
+        it("should exclude closed features by default", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "feature",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toHaveLength(2);
+            expect(objects).toContain("F-draft-feature");
+            expect(objects).toContain("F-open-feature");
+            expect(objects).not.toContain("F-done-feature");
+            expect(objects).not.toContain("F-wont-do-feature");
+        });
+        it("should include closed features when includeClosed=true", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "feature",
+                includeClosed: true,
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toHaveLength(4);
+            expect(objects).toContain("F-draft-feature");
+            expect(objects).toContain("F-open-feature");
+            expect(objects).toContain("F-done-feature");
+            expect(objects).toContain("F-wont-do-feature");
+        });
+        it("should exclude closed tasks by default", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "task",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            // Filter to only the objects we created in this test
+            const testObjects = objects.filter((id) => id.includes("includeclosed"));
+            expect(testObjects).toHaveLength(3);
+            expect(testObjects).toContain("T-draft-includeclosed");
+            expect(testObjects).toContain("T-open-includeclosed");
+            expect(testObjects).toContain("T-in-progress-includeclosed");
+            expect(testObjects).not.toContain("T-done-includeclosed");
+            expect(testObjects).not.toContain("T-wont-do-includeclosed");
+        });
+        it("should include closed tasks when includeClosed=true", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "task",
+                includeClosed: true,
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            // Filter to only the objects we created in this test
+            const testObjects = objects.filter((id) => id.includes("includeclosed"));
+            expect(testObjects).toHaveLength(5);
+            expect(testObjects).toContain("T-draft-includeclosed");
+            expect(testObjects).toContain("T-open-includeclosed");
+            expect(testObjects).toContain("T-in-progress-includeclosed");
+            expect(testObjects).toContain("T-done-includeclosed");
+            expect(testObjects).toContain("T-wont-do-includeclosed");
+        });
+        it("should work with includeClosed and status filters for projects", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "project",
+                status: "done",
+                includeClosed: true,
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toHaveLength(1);
+            expect(objects).toContain("P-done-project");
+        });
+        it("should work with includeClosed and status filters for epics", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "epic",
+                status: "wont-do",
+                includeClosed: true,
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toHaveLength(1);
+            expect(objects).toContain("E-wont-do-epic");
+        });
+        it("should return empty array when status filter requires closed objects but includeClosed=false", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "feature",
+                status: "done",
+                includeClosed: false,
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toEqual([]);
         });
     });
     describe("Priority Filtering", () => {
@@ -190,45 +380,43 @@ describe("E2E CRUD - listObjects", () => {
             }
         });
         it("should filter objects by priority", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "feature",
                 priority: "high",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].priority).toBe("high");
-            expect(objects[0].id).toBe("F-high-priority");
+            expect(objects[0]).toBe("F-high-priority");
         });
         it("should filter objects by medium priority", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "feature",
                 priority: "medium",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].priority).toBe("medium");
-            expect(objects[0].id).toBe("F-medium-priority");
+            expect(objects[0]).toBe("F-medium-priority");
         });
         it("should filter objects by low priority", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "feature",
                 priority: "low",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].priority).toBe("low");
-            expect(objects[0].id).toBe("F-low-priority");
+            expect(objects[0]).toBe("F-low-priority");
         });
         it("should return all priorities when no filter specified", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "feature",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(3);
-            const priorities = objects.map((o) => o.priority);
-            expect(priorities).toContain("high");
-            expect(priorities).toContain("medium");
-            expect(priorities).toContain("low");
+            // Note: Can't test individual priorities since only IDs are returned
+            // Just verify we have all the expected feature IDs
+            expect(objects).toContain("F-high-priority");
+            expect(objects).toContain("F-medium-priority");
+            expect(objects).toContain("F-low-priority");
         });
     });
     describe("Scope Filtering", () => {
@@ -262,39 +450,39 @@ describe("E2E CRUD - listObjects", () => {
             }));
         });
         it("should list objects within project scope", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "epic",
                 scope: "P-parent",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(2);
-            expect(objects.map((o) => o.id)).toContain("E-child-1");
-            expect(objects.map((o) => o.id)).toContain("E-child-2");
+            expect(objects).toContain("E-child-1");
+            expect(objects).toContain("E-child-2");
         });
         it("should list objects within epic scope", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "feature",
                 scope: "E-child-1",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].id).toBe("F-grandchild-1");
+            expect(objects[0]).toBe("F-grandchild-1");
         });
         it("should not include objects outside of scope", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "feature",
                 scope: "P-parent",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
-            expect(objects.map((o) => o.id)).toContain("F-grandchild-1");
-            expect(objects.map((o) => o.id)).not.toContain("F-standalone");
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toContain("F-grandchild-1");
+            expect(objects).not.toContain("F-standalone");
         });
         it("should return empty array for non-existent scope", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 scope: "P-nonexistent",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toEqual([]);
         });
     });
@@ -354,48 +542,48 @@ describe("E2E CRUD - listObjects", () => {
             }
         });
         it("should apply multiple filters simultaneously", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 status: "open",
                 priority: "high",
                 scope: "P-complex",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].id).toBe("T-high-open");
+            expect(objects[0]).toBe("T-high-open");
         });
         it("should combine includeClosed with other filters", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 priority: "high",
                 scope: "P-complex",
                 includeClosed: true,
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(2);
-            expect(objects.map((o) => o.id)).toContain("T-high-open");
-            expect(objects.map((o) => o.id)).toContain("T-high-done");
+            expect(objects).toContain("T-high-open");
+            expect(objects).toContain("T-high-done");
         });
         it("should return empty when combined filters match nothing", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 status: "draft",
                 priority: "high",
                 scope: "P-complex",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toEqual([]);
         });
         it("should combine status and priority filters", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 status: "in-progress",
                 priority: "medium",
                 scope: "P-complex",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].id).toBe("T-medium-progress");
+            expect(objects[0]).toBe("T-medium-progress");
         });
     });
     describe("Object Structure Validation", () => {
@@ -418,43 +606,26 @@ describe("E2E CRUD - listObjects", () => {
                 title: "Child Epic",
                 parent: "P-detailed",
             }), { projectId: "P-detailed" });
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "project",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            const project = objects[0];
-            expect(project).toMatchObject({
-                id: "P-detailed",
-                type: "project",
-                title: "Detailed Project",
-                status: "open",
-                priority: "high",
-                prerequisites: ["P-dep1", "P-dep2"],
-                log: ["Created", "Updated"],
-                schema: "1.1",
-                childrenIds: ["E-child"],
-                body: "Project description",
-            });
-            // Verify no parent field for projects
-            expect(project.parent).toBeUndefined();
+            // Note: Only object IDs are returned, not full objects
+            expect(objects[0]).toBe("P-detailed");
         });
         it("should handle objects with minimal fields", async () => {
             await (0, utils_1.createObjectFile)(testEnv.projectRoot, "task", "T-minimal", (0, utils_1.createObjectContent)({
                 id: "T-minimal",
                 title: "Minimal Task",
             }), { status: "open" });
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
-            const task = objects[0];
-            expect(task.id).toBe("T-minimal");
-            expect(task.title).toBe("Minimal Task");
-            expect(task.status).toBe("open");
-            expect(task.priority).toBe("medium");
-            expect(task.prerequisites).toEqual([]);
-            expect(task.body).toBe("");
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            // Note: Only object IDs are returned, not full objects
+            expect(objects[0]).toBe("T-minimal");
+            // Note: Only IDs returned, cannot test object properties
         });
         it("should preserve object hierarchy relationships", async () => {
             await (0, utils_1.createObjectFile)(testEnv.projectRoot, "project", "P-hierarchy", (0, utils_1.createObjectContent)({
@@ -481,13 +652,13 @@ describe("E2E CRUD - listObjects", () => {
                 featureId: "F-hierarchy",
                 status: "open",
             });
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 scope: "P-hierarchy",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(1);
-            expect(objects[0].parent).toBe("F-hierarchy");
+            // Note: Only object IDs are returned, not full objects with parent property
         });
     });
     describe("Large Dataset Handling", () => {
@@ -506,20 +677,19 @@ describe("E2E CRUD - listObjects", () => {
                 }), { status: folder });
             }
             const startTime = Date.now();
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 includeClosed: true,
             });
             const duration = Date.now() - startTime;
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(objects).toHaveLength(NUM_OBJECTS);
             // Performance check - should complete within reasonable time
             expect(duration).toBeLessThan(3000);
             // Verify all objects have correct structure
-            objects.forEach((obj) => {
-                expect(obj.id).toMatch(/^T-bulk-\d{3}$/);
-                expect(obj.type).toBe("task");
-                expect(obj.title).toMatch(/^Bulk Task \d+$/);
+            // Note: Only IDs returned, cannot test object properties
+            objects.forEach((id) => {
+                expect(id).toMatch(/^T-bulk-\d{3}$/);
             });
         });
         it("should filter large datasets correctly", async () => {
@@ -532,25 +702,25 @@ describe("E2E CRUD - listObjects", () => {
                     priority: priority,
                 }));
             }
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "feature",
                 priority: "high",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            // Note: Only IDs returned, cannot test object properties - just verify count
             expect(objects).toHaveLength(5);
-            expect(objects.every((o) => o.priority === "high")).toBe(true);
         });
     });
     describe("Error Handling", () => {
         it("should handle invalid type parameter", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "invalid-type",
             });
             expect(result.content[0].text).toContain("Error listing objects");
             expect(result.content[0].text).toContain("Invalid type value: invalid-type");
         });
         it("should handle invalid status parameter", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 status: "invalid-status",
             });
@@ -558,7 +728,7 @@ describe("E2E CRUD - listObjects", () => {
             expect(result.content[0].text).toContain("Invalid status value: invalid-status");
         });
         it("should handle invalid priority parameter", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
                 priority: "critical",
             });
@@ -573,21 +743,540 @@ describe("E2E CRUD - listObjects", () => {
             await fs.mkdir(path.dirname(invalidPath), { recursive: true });
             await fs.writeFile(invalidPath, "Invalid YAML content\n---\nBody", "utf-8");
             // Should skip invalid files and continue
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             // Should return empty array or only valid objects
             expect(Array.isArray(objects)).toBe(true);
         });
         it("should handle empty directories gracefully", async () => {
-            const result = await client.callTool("list_objects", {
+            const result = await client.callTool("list_issues", {
                 type: "task",
             });
-            const objects = (0, utils_1.parseListObjectsResponse)(result.content[0].text);
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
             expect(Array.isArray(objects)).toBe(true);
             expect(objects).toEqual([]);
         });
     });
+    describe("Multiple Value Filtering", () => {
+        beforeEach(async () => {
+            // Create diverse test objects for comprehensive filtering validation
+            // Projects with different priorities
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "project", "P-high-priority-multi", (0, utils_1.createObjectContent)({
+                id: "P-high-priority-multi",
+                title: "High Priority Project",
+                priority: "high",
+                status: "open",
+            }));
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "project", "P-medium-priority-multi", (0, utils_1.createObjectContent)({
+                id: "P-medium-priority-multi",
+                title: "Medium Priority Project",
+                priority: "medium",
+                status: "in-progress",
+            }));
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "project", "P-low-priority-multi", (0, utils_1.createObjectContent)({
+                id: "P-low-priority-multi",
+                title: "Low Priority Project",
+                priority: "low",
+                status: "done",
+            }));
+            // Epics with different statuses
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "epic", "E-open-multi", (0, utils_1.createObjectContent)({
+                id: "E-open-multi",
+                title: "Open Epic",
+                status: "open",
+                priority: "high",
+                parent: "P-high-priority-multi",
+            }), { projectId: "P-high-priority-multi" });
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "epic", "E-progress-multi", (0, utils_1.createObjectContent)({
+                id: "E-progress-multi",
+                title: "In Progress Epic",
+                status: "in-progress",
+                priority: "medium",
+                parent: "P-medium-priority-multi",
+            }), { projectId: "P-medium-priority-multi" });
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "epic", "E-done-multi", (0, utils_1.createObjectContent)({
+                id: "E-done-multi",
+                title: "Done Epic",
+                status: "done",
+                priority: "low",
+                parent: "P-low-priority-multi",
+            }), { projectId: "P-low-priority-multi" });
+            // Features with various combinations
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "feature", "F-high-open-multi", (0, utils_1.createObjectContent)({
+                id: "F-high-open-multi",
+                title: "High Priority Open Feature",
+                status: "open",
+                priority: "high",
+            }));
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "feature", "F-medium-progress-multi", (0, utils_1.createObjectContent)({
+                id: "F-medium-progress-multi",
+                title: "Medium Priority In Progress Feature",
+                status: "in-progress",
+                priority: "medium",
+            }));
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "feature", "F-low-draft-multi", (0, utils_1.createObjectContent)({
+                id: "F-low-draft-multi",
+                title: "Low Priority Draft Feature",
+                status: "draft",
+                priority: "low",
+            }));
+            // Tasks with different combinations
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "task", "T-open-high-multi", (0, utils_1.createObjectContent)({
+                id: "T-open-high-multi",
+                title: "Open High Priority Task",
+                status: "open",
+                priority: "high",
+            }), { status: "open" });
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "task", "T-progress-medium-multi", (0, utils_1.createObjectContent)({
+                id: "T-progress-medium-multi",
+                title: "In Progress Medium Priority Task",
+                status: "in-progress",
+                priority: "medium",
+            }), { status: "open" });
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "task", "T-done-low-multi", (0, utils_1.createObjectContent)({
+                id: "T-done-low-multi",
+                title: "Done Low Priority Task",
+                status: "done",
+                priority: "low",
+            }), { status: "closed" });
+        });
+        describe("Multiple Type Filtering", () => {
+            it("should filter for multiple types using array", async () => {
+                const result = await client.callTool("list_issues", {
+                    type: ["feature", "task"],
+                    includeClosed: true,
+                });
+                const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+                // Should include all features and tasks, but no projects or epics
+                const features = objects.filter((id) => id.startsWith("F-"));
+                const tasks = objects.filter((id) => id.startsWith("T-"));
+                const projects = objects.filter((id) => id.startsWith("P-"));
+                const epics = objects.filter((id) => id.startsWith("E-"));
+                expect(features.length).toBeGreaterThan(0);
+                expect(tasks.length).toBeGreaterThan(0);
+                expect(projects.length).toBe(0);
+                expect(epics.length).toBe(0);
+            });
+            it("should filter for project and epic types", async () => {
+                const result = await client.callTool("list_issues", {
+                    type: ["project", "epic"],
+                    includeClosed: true,
+                });
+                const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+                const projects = objects.filter((id) => id.startsWith("P-"));
+                const epics = objects.filter((id) => id.startsWith("E-"));
+                const features = objects.filter((id) => id.startsWith("F-"));
+                const tasks = objects.filter((id) => id.startsWith("T-"));
+                expect(projects.length).toBeGreaterThan(0);
+                expect(epics.length).toBeGreaterThan(0);
+                expect(features.length).toBe(0);
+                expect(tasks.length).toBe(0);
+            });
+            it("should handle single type in array format", async () => {
+                const result = await client.callTool("list_issues", {
+                    type: ["task"],
+                    includeClosed: true,
+                });
+                const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+                const tasks = objects.filter((id) => id.startsWith("T-"));
+                const nonTasks = objects.filter((id) => !id.startsWith("T-"));
+                expect(tasks.length).toBeGreaterThan(0);
+                expect(nonTasks.length).toBe(0);
+            });
+        });
+        describe("Multiple Status Filtering", () => {
+            it("should filter for multiple statuses using array", async () => {
+                const result = await client.callTool("list_issues", {
+                    type: "task",
+                    status: ["open", "in-progress"],
+                });
+                const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+                // Should include T-open-high-multi and T-progress-medium-multi
+                expect(objects).toContain("T-open-high-multi");
+                expect(objects).toContain("T-progress-medium-multi");
+                expect(objects).not.toContain("T-done-low-multi");
+            });
+            it("should filter for draft and open statuses", async () => {
+                const result = await client.callTool("list_issues", {
+                    type: "feature",
+                    status: ["draft", "open"],
+                });
+                const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+                expect(objects).toContain("F-high-open-multi");
+                expect(objects).toContain("F-low-draft-multi");
+                expect(objects).not.toContain("F-medium-progress-multi");
+            });
+            it("should handle closed statuses with includeClosed flag", async () => {
+                const result = await client.callTool("list_issues", {
+                    type: "task",
+                    status: ["done", "wont-do"],
+                    includeClosed: true,
+                });
+                const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+                expect(objects).toContain("T-done-low-multi");
+            });
+        });
+        describe("Multiple Priority Filtering", () => {
+            it("should filter for multiple priorities using array", async () => {
+                const result = await client.callTool("list_issues", {
+                    type: "feature",
+                    priority: ["high", "medium"],
+                });
+                const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+                expect(objects).toContain("F-high-open-multi");
+                expect(objects).toContain("F-medium-progress-multi");
+                expect(objects).not.toContain("F-low-draft-multi");
+            });
+            it("should filter for low priority across all types", async () => {
+                const result = await client.callTool("list_issues", {
+                    type: ["project", "epic", "feature", "task"],
+                    priority: ["low"],
+                    includeClosed: true,
+                });
+                const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+                expect(objects).toContain("P-low-priority-multi");
+                expect(objects).toContain("E-done-multi");
+                expect(objects).toContain("F-low-draft-multi");
+                expect(objects).toContain("T-done-low-multi");
+            });
+            it("should handle high and low priorities", async () => {
+                const result = await client.callTool("list_issues", {
+                    type: "task",
+                    priority: ["high", "low"],
+                    includeClosed: true,
+                });
+                const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+                expect(objects).toContain("T-open-high-multi");
+                expect(objects).toContain("T-done-low-multi");
+                expect(objects).not.toContain("T-progress-medium-multi");
+            });
+        });
+        describe("Combined Multiple Filters", () => {
+            it("should combine multiple type and status filters", async () => {
+                const result = await client.callTool("list_issues", {
+                    type: ["feature", "task"],
+                    status: ["open", "in-progress"],
+                });
+                const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+                expect(objects).toContain("F-high-open-multi");
+                expect(objects).toContain("F-medium-progress-multi");
+                expect(objects).toContain("T-open-high-multi");
+                expect(objects).toContain("T-progress-medium-multi");
+                expect(objects).not.toContain("F-low-draft-multi");
+                expect(objects).not.toContain("T-done-low-multi");
+            });
+            it("should combine multiple filters across all parameters", async () => {
+                const result = await client.callTool("list_issues", {
+                    type: ["feature", "task"],
+                    status: ["open", "in-progress"],
+                    priority: ["high", "medium"],
+                });
+                const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+                expect(objects).toContain("F-high-open-multi");
+                expect(objects).toContain("F-medium-progress-multi");
+                expect(objects).toContain("T-open-high-multi");
+                expect(objects).toContain("T-progress-medium-multi");
+                expect(objects).not.toContain("F-low-draft-multi");
+                expect(objects).not.toContain("T-done-low-multi");
+            });
+            it("should apply AND logic between different filter types", async () => {
+                const result = await client.callTool("list_issues", {
+                    type: ["task"],
+                    status: ["open"],
+                    priority: ["high"],
+                });
+                const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+                expect(objects).toContain("T-open-high-multi");
+                expect(objects).not.toContain("T-progress-medium-multi");
+                expect(objects).not.toContain("T-done-low-multi");
+            });
+        });
+    });
+    describe("Optional Type Parameter", () => {
+        beforeEach(async () => {
+            // Create objects of all types with same status/priority for testing
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "project", "P-optional-type", (0, utils_1.createObjectContent)({
+                id: "P-optional-type",
+                title: "Optional Type Project",
+                status: "open",
+                priority: "high",
+            }));
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "epic", "E-optional-type", (0, utils_1.createObjectContent)({
+                id: "E-optional-type",
+                title: "Optional Type Epic",
+                status: "open",
+                priority: "high",
+                parent: "P-optional-type",
+            }), { projectId: "P-optional-type" });
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "feature", "F-optional-type", (0, utils_1.createObjectContent)({
+                id: "F-optional-type",
+                title: "Optional Type Feature",
+                status: "open",
+                priority: "high",
+            }));
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "task", "T-optional-type", (0, utils_1.createObjectContent)({
+                id: "T-optional-type",
+                title: "Optional Type Task",
+                status: "open",
+                priority: "high",
+            }), { status: "open" });
+        });
+        it("should return all object types when type parameter is omitted", async () => {
+            const result = await client.callTool("list_issues", {
+                status: "open",
+                priority: "high",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toContain("P-optional-type");
+            expect(objects).toContain("E-optional-type");
+            expect(objects).toContain("F-optional-type");
+            expect(objects).toContain("T-optional-type");
+        });
+        it("should filter by status across all types when type is omitted", async () => {
+            // Add objects with different statuses
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "task", "T-different-status", (0, utils_1.createObjectContent)({
+                id: "T-different-status",
+                title: "Different Status Task",
+                status: "in-progress",
+                priority: "high",
+            }), { status: "open" });
+            const result = await client.callTool("list_issues", {
+                status: "open",
+                priority: "high",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toContain("P-optional-type");
+            expect(objects).toContain("E-optional-type");
+            expect(objects).toContain("F-optional-type");
+            expect(objects).toContain("T-optional-type");
+            expect(objects).not.toContain("T-different-status");
+        });
+        it("should filter by priority across all types when type is omitted", async () => {
+            // Add objects with different priorities
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "feature", "F-different-priority", (0, utils_1.createObjectContent)({
+                id: "F-different-priority",
+                title: "Different Priority Feature",
+                status: "open",
+                priority: "low",
+            }));
+            const result = await client.callTool("list_issues", {
+                status: "open",
+                priority: "high",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toContain("P-optional-type");
+            expect(objects).toContain("E-optional-type");
+            expect(objects).toContain("F-optional-type");
+            expect(objects).toContain("T-optional-type");
+            expect(objects).not.toContain("F-different-priority");
+        });
+    });
+    describe("Mixed Single and Multiple Value Tests", () => {
+        beforeEach(async () => {
+            // Create test objects for mixed filtering scenarios
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "task", "T-mixed-high-open", (0, utils_1.createObjectContent)({
+                id: "T-mixed-high-open",
+                title: "Mixed High Open Task",
+                status: "open",
+                priority: "high",
+            }), { status: "open" });
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "task", "T-mixed-high-progress", (0, utils_1.createObjectContent)({
+                id: "T-mixed-high-progress",
+                title: "Mixed High Progress Task",
+                status: "in-progress",
+                priority: "high",
+            }), { status: "open" });
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "task", "T-mixed-medium-open", (0, utils_1.createObjectContent)({
+                id: "T-mixed-medium-open",
+                title: "Mixed Medium Open Task",
+                status: "open",
+                priority: "medium",
+            }), { status: "open" });
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "feature", "F-mixed-high-open", (0, utils_1.createObjectContent)({
+                id: "F-mixed-high-open",
+                title: "Mixed High Open Feature",
+                status: "open",
+                priority: "high",
+            }));
+        });
+        it("should handle single type with multiple statuses", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "task",
+                status: ["open", "in-progress"],
+                priority: "high",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toContain("T-mixed-high-open");
+            expect(objects).toContain("T-mixed-high-progress");
+            expect(objects).not.toContain("T-mixed-medium-open");
+        });
+        it("should handle multiple types with single status", async () => {
+            const result = await client.callTool("list_issues", {
+                type: ["task", "feature"],
+                status: "open",
+                priority: "high",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toContain("T-mixed-high-open");
+            expect(objects).toContain("F-mixed-high-open");
+            expect(objects).not.toContain("T-mixed-high-progress");
+            expect(objects).not.toContain("T-mixed-medium-open");
+        });
+        it("should handle single type and status with multiple priorities", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "task",
+                status: "open",
+                priority: ["high", "medium"],
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toContain("T-mixed-high-open");
+            expect(objects).toContain("T-mixed-medium-open");
+            expect(objects).not.toContain("T-mixed-high-progress");
+        });
+        it("should handle mixed array and single value parameters", async () => {
+            const result = await client.callTool("list_issues", {
+                type: ["task", "feature"],
+                status: ["open", "in-progress"],
+                priority: "high",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toContain("T-mixed-high-open");
+            expect(objects).toContain("T-mixed-high-progress");
+            expect(objects).toContain("F-mixed-high-open");
+            expect(objects).not.toContain("T-mixed-medium-open");
+        });
+    });
+    describe("Backward Compatibility Validation", () => {
+        beforeEach(async () => {
+            // Create objects to test that existing single-value behavior is preserved
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "task", "T-compat-single", (0, utils_1.createObjectContent)({
+                id: "T-compat-single",
+                title: "Compatibility Single Task",
+                status: "open",
+                priority: "high",
+            }), { status: "open" });
+            await (0, utils_1.createObjectFile)(testEnv.projectRoot, "feature", "F-compat-single", (0, utils_1.createObjectContent)({
+                id: "F-compat-single",
+                title: "Compatibility Single Feature",
+                status: "in-progress",
+                priority: "medium",
+            }));
+        });
+        it("should preserve existing single value type filtering", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "task",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            const tasks = objects.filter((id) => id.startsWith("T-"));
+            const nonTasks = objects.filter((id) => !id.startsWith("T-"));
+            expect(tasks.length).toBeGreaterThan(0);
+            expect(nonTasks.length).toBe(0);
+        });
+        it("should preserve existing single value status filtering", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "task",
+                status: "open",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toContain("T-compat-single");
+        });
+        it("should preserve existing single value priority filtering", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "feature",
+                priority: "medium",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toContain("F-compat-single");
+        });
+        it("should preserve existing combined single value filters", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "task",
+                status: "open",
+                priority: "high",
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            expect(objects).toContain("T-compat-single");
+        });
+        it("should maintain existing error behavior for invalid single values", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "invalid-type",
+            });
+            expect(result.content[0].text).toContain("Error listing objects");
+            expect(result.content[0].text).toContain("Invalid type value: invalid-type");
+        });
+    });
+    describe("Error Handling for Array Inputs", () => {
+        it("should handle invalid array values for type parameter", async () => {
+            const result = await client.callTool("list_issues", {
+                type: ["invalid-type"],
+            });
+            expect(result.content[0].text).toContain("Error listing objects");
+            expect(result.content[0].text).toContain("Invalid type value: invalid-type");
+        });
+        it("should handle mixed valid and invalid values in type array", async () => {
+            const result = await client.callTool("list_issues", {
+                type: ["task", "invalid-type"],
+            });
+            expect(result.content[0].text).toContain("Error listing objects");
+            expect(result.content[0].text).toContain("Invalid type value: invalid-type");
+        });
+        it("should handle invalid array values for status parameter", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "task",
+                status: ["invalid-status"],
+            });
+            expect(result.content[0].text).toContain("Error listing objects");
+            expect(result.content[0].text).toContain("Invalid status value: invalid-status");
+        });
+        it("should handle mixed valid and invalid values in status array", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "task",
+                status: ["open", "invalid-status"],
+            });
+            expect(result.content[0].text).toContain("Error listing objects");
+            expect(result.content[0].text).toContain("Invalid status value: invalid-status");
+        });
+        it("should handle invalid array values for priority parameter", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "task",
+                priority: ["invalid-priority"],
+            });
+            expect(result.content[0].text).toContain("Error listing objects");
+            expect(result.content[0].text).toContain("Invalid priority value: invalid-priority");
+        });
+        it("should handle multiple invalid values in priority array", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "task",
+                priority: ["invalid1", "invalid2"],
+            });
+            expect(result.content[0].text).toContain("Error listing objects");
+            expect(result.content[0].text).toContain("Invalid priority value");
+        });
+        it("should handle empty arrays as no filter provided", async () => {
+            const result = await client.callTool("list_issues", {
+                type: "task",
+                status: [],
+            });
+            const objects = (0, utils_1.extractObjectIds)(result.content[0].text);
+            // Empty array should be treated as no filter, so all tasks should be returned
+            expect(Array.isArray(objects)).toBe(true);
+        });
+        it("should require at least one filter when type is omitted", async () => {
+            const result = await client.callTool("list_issues", {});
+            expect(result.content[0].text).toContain("Error listing objects");
+            expect(result.content[0].text).toContain("At least one filter parameter (type, status, priority, or scope) must be provided");
+        });
+        it("should handle empty arrays in all parameters", async () => {
+            const result = await client.callTool("list_issues", {
+                type: [],
+                status: [],
+                priority: [],
+            });
+            expect(result.content[0].text).toContain("Error listing objects");
+            expect(result.content[0].text).toContain("At least one filter parameter (type, status, priority, or scope) must be provided");
+        });
+    });
 });
 //# sourceMappingURL=listObjects.e2e.test.js.map