address copilot R1: auto-seed root into isDescendantOf cache

Copilot caught a footgun: when callers passed opts.cache without seeding
it with root, the parent walk would never terminate at root (the loop
checks known.has(cur), not cur === root) and would return false even
for true descendants.

Fix in Session.isDescendantOf: unconditionally known.add(root) at the
top of every call, regardless of whether the caller pre-seeded. JSDoc
updated to say a fresh empty Set is sufficient.

AutoReply now seeds with new Set() (no manual root pre-seed). Also
added a regression test that explicitly passes an empty cache and
asserts the call succeeds.

PR feedback: #16 (comment)

Author: tesdal

packages/opencode/src/session/auto-reply/auto-reply.ts

@@ -46,7 +46,10 @@ export const make = Effect.fn("SessionAutoReply.make")(function* (config: Config
     livelockWarned: false,
   }
 
-  const descendants = new Set<SessionID>([config.rootSessionID])
+  // Reused across calls so the parent walk is traversed at most once per
+  // descendant id. Session.isDescendantOf auto-seeds `rootSessionID` on every
+  // call, so an empty Set is the simplest seed.
+  const descendants = new Set<SessionID>()
 
   const isDescendant = (sid: SessionID) =>
     session.isDescendantOf(sid, config.rootSessionID, { maxDepth: MAX_LINEAGE_DEPTH, cache: descendants })

packages/opencode/src/session/session.ts

@@ -381,10 +381,11 @@ export interface Interface {
    * stops at any `NotFoundError` (returns false). When `opts.cache` is
    * provided, it is used both as a positive-hit short-circuit and as an
    * accumulator: every confirmed descendant in the walked chain is added to
-   * the set. Callers that issue many `isDescendantOf` calls against the same
-   * root (e.g. SessionAutoReply) should seed the cache with `new Set([root])`
-   * and reuse it across calls so the parent chain is traversed at most once
-   * per node.
+   * the set. The cache is auto-seeded with `root` on every call, so callers
+   * can pass a fresh `new Set()` and reuse it across calls without seeding.
+   * Callers that issue many `isDescendantOf` calls against the same root
+   * (e.g. SessionAutoReply) should reuse one cache so the parent chain is
+   * traversed at most once per node.
    */
   readonly isDescendantOf: (
     sid: SessionID,
@@ -693,7 +694,13 @@ export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service> =
       opts?: { maxDepth?: number; cache?: Set<SessionID> },
     ) {
       const maxDepth = opts?.maxDepth ?? 64
-      const known = opts?.cache ?? new Set<SessionID>([root])
+      const known = opts?.cache ?? new Set<SessionID>()
+      // Always seed `root` into the working set so the parent walk has a
+      // termination anchor regardless of whether the caller pre-seeded the
+      // cache. Without this, a caller-provided cache that happens to omit
+      // `root` would cause the walk to bottom out at a not-found parent and
+      // return false even for true descendants — a silent footgun.
+      known.add(root)
       if (sid === root) return true
       if (known.has(sid)) return true
       // Walk parent chain. Track the chain so we can promote every visited

packages/opencode/test/session/session.test.ts

@@ -296,4 +296,22 @@ describe("Session.isDescendantOf", () => {
       },
     })
   })
+
+  test("auto-seeds root into cache so callers can pass an empty Set", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const root = await create({ title: "root" })
+        const child = await create({ title: "child", parentID: root.id })
+        // Caller passes a fresh empty Set — root must still be reachable.
+        // Without the auto-seed in isDescendantOf this would walk past root,
+        // hit a not-found parent, and return false.
+        const cache = new Set<SessionID>()
+        expect(await isDescendantOf(child.id, root.id, { cache })).toBe(true)
+        expect(cache.has(root.id)).toBe(true)
+        await remove(root.id)
+      },
+    })
+  })
 })