core: add comprehensive test coverage for Session.list() filters

Adds test cases for filtering sessions by directory, root sessions only,

start time, search terms, and result limits to ensure the listing

functionality works correctly for all filter combinations.

1 files changed, 62 insertions, 11 deletions

diff --git a/packages/opencode/test/server/session-list.test.ts b/packages/opencode/test/server/session-list.test.ts
index 623c16a81..675a89011 100644
--- a/packages/opencode/test/server/session-list.test.ts
+++ b/packages/opencode/test/server/session-list.test.ts
@@ -1,20 +1,17 @@
 import { describe, expect, test } from "bun:test"
 import path from "path"
 import { Instance } from "../../src/project/instance"
-import { Server } from "../../src/server/server"
 import { Session } from "../../src/session"
 import { Log } from "../../src/util/log"
 
 const projectRoot = path.join(__dirname, "../..")
 Log.init({ print: false })
 
-describe("session.list", () => {
+describe("Session.list", () => {
   test("filters by directory", async () => {
     await Instance.provide({
       directory: projectRoot,
       fn: async () => {
-        const app = Server.App()
-
         const first = await Session.create({})
 
         const otherDir = path.join(projectRoot, "..", "__session_list_other")
@@ -23,17 +20,71 @@ describe("session.list", () => {
           fn: async () => Session.create({}),
         })
 
-        const response = await app.request(`/session?directory=${encodeURIComponent(projectRoot)}`)
-        expect(response.status).toBe(200)
-
-        const body = (await response.json()) as unknown[]
-        const ids = body
-          .map((s) => (typeof s === "object" && s && "id" in s ? (s as { id: string }).id : undefined))
-          .filter((x): x is string => typeof x === "string")
+        const sessions = [...Session.list({ directory: projectRoot })]
+        const ids = sessions.map((s) => s.id)
 
         expect(ids).toContain(first.id)
         expect(ids).not.toContain(second.id)
       },
     })
   })
+
+  test("filters root sessions", async () => {
+    await Instance.provide({
+      directory: projectRoot,
+      fn: async () => {
+        const root = await Session.create({ title: "root-session" })
+        const child = await Session.create({ title: "child-session", parentID: root.id })
+
+        const sessions = [...Session.list({ roots: true })]
+        const ids = sessions.map((s) => s.id)
+
+        expect(ids).toContain(root.id)
+        expect(ids).not.toContain(child.id)
+      },
+    })
+  })
+
+  test("filters by start time", async () => {
+    await Instance.provide({
+      directory: projectRoot,
+      fn: async () => {
+        const session = await Session.create({ title: "new-session" })
+        const futureStart = Date.now() + 86400000
+
+        const sessions = [...Session.list({ start: futureStart })]
+        expect(sessions.length).toBe(0)
+      },
+    })
+  })
+
+  test("filters by search term", async () => {
+    await Instance.provide({
+      directory: projectRoot,
+      fn: async () => {
+        await Session.create({ title: "unique-search-term-abc" })
+        await Session.create({ title: "other-session-xyz" })
+
+        const sessions = [...Session.list({ search: "unique-search" })]
+        const titles = sessions.map((s) => s.title)
+
+        expect(titles).toContain("unique-search-term-abc")
+        expect(titles).not.toContain("other-session-xyz")
+      },
+    })
+  })
+
+  test("respects limit parameter", async () => {
+    await Instance.provide({
+      directory: projectRoot,
+      fn: async () => {
+        await Session.create({ title: "session-1" })
+        await Session.create({ title: "session-2" })
+        await Session.create({ title: "session-3" })
+
+        const sessions = [...Session.list({ limit: 2 })]
+        expect(sessions.length).toBe(2)
+      },
+    })
+  })
 })