feat(core): add directory projects

packages/client/src/promise/generated/types.ts

@@ -974,7 +974,7 @@ export type WorktreeResolved = {
   type: "worktree.resolved"
   durable: { aggregateID: string; seq: number; version: 1 }
   location?: LocationRef
-  data: { projectID: string; directory: string; previous: string }
+  data: { projectID: string; directory: string; previous: string; adopted?: Array<string> }
 }
 
 export type CommandUpdated = {

packages/client/src/solid/data.ts

@@ -617,7 +617,22 @@ export function createData(config: CreateDataInput) {
       }
       case "worktree.resolved": {
         for (const [sessionID, info] of Object.entries(store.session.info)) {
-          const adopted = Worktree.adopt({ projectID: info.projectID, directory: info.location.directory }, event.data)
+          const explicit = event.data.adopted?.includes(info.projectID)
+          const directory = explicit ? store.project.info[info.projectID]?.canonical : info.location.directory
+          if (!directory) {
+            if (info.location.workspaceID) continue
+            result.session.invalidate(sessionID)
+            void result.session.sync(sessionID)
+            continue
+          }
+          const adopted = Worktree.adopt(
+            {
+              projectID: info.projectID,
+              directory,
+              workspaceID: info.location.workspaceID,
+            },
+            event.data,
+          )
           if (!adopted) continue
           setStore("session", "info", sessionID, "projectID", adopted.projectID)
           setStore("session", "info", sessionID, "subpath", adopted.subpath)

packages/client/test/solid-data.test.ts

@@ -154,6 +154,106 @@ test("updates authoritative cached project metadata from live events", async ()
   }
 })
 
+test("adopts cached directory-project sessions when their repository is resolved", async () => {
+  const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
+  const refreshed: SessionInfo = {
+    ...session(0),
+    id: "ses_uncached",
+    projectID: "repository",
+    location: { directory: "/unknown-alias" },
+    subpath: "app",
+  }
+  const api = OpenCode.make({
+    baseUrl: "http://opencode.local",
+    fetch: async (input, init) => {
+      const request = input instanceof Request ? input : new Request(input, init)
+      if (!request.url.endsWith("/api/session/ses_uncached")) throw new Error(`Unexpected request: ${request.url}`)
+      return Response.json({ data: refreshed })
+    },
+  })
+  const setup = createRoot((dispose) => ({
+    data: createData({
+      api: () => api,
+      directory: "/repo",
+      event: {
+        on: () => () => {},
+        listen(handler) {
+          listeners.add(handler)
+          return () => listeners.delete(handler)
+        },
+      },
+    }),
+    dispose,
+  }))
+
+  try {
+    const sessions: SessionInfo[] = [
+      { ...session(0), id: "ses_root", projectID: "directory-root", location: { directory: "/repo" } },
+      { ...session(0), id: "ses_nested", projectID: "directory-nested", location: { directory: "/repo/app" } },
+      {
+        ...session(0),
+        id: "ses_alias",
+        projectID: "directory-nested",
+        location: { directory: "/repo/alias/../app" },
+      },
+      { ...session(0), id: "ses_symlink", projectID: "directory-nested", location: { directory: "/shortcut" } },
+      { ...refreshed, projectID: "directory-uncached" },
+      { ...session(0), id: "ses_global", projectID: "global", location: { directory: "/repo/legacy" } },
+      { ...session(0), id: "ses_escaped", projectID: "global", location: { directory: "/repo/../other" } },
+      { ...session(0), id: "ses_other", projectID: "other-repository", location: { directory: "/repo/vendor" } },
+      { ...session(0), id: "ses_sibling", projectID: "global", location: { directory: "/repo-other" } },
+      {
+        ...session(0),
+        id: "ses_remote",
+        projectID: "directory-root",
+        location: { directory: "/repo", workspaceID: "workspace-remote" },
+      },
+    ]
+    sessions.forEach((item) => setup.data.session.remember(item))
+    for (const project of [
+      { id: "directory-root", canonical: "/repo" },
+      { id: "directory-nested", canonical: "/repo/app" },
+    ]) {
+      const updated: OpenCodeEvent = {
+        id: `evt_${project.id}`,
+        created: 0,
+        type: "project.updated",
+        data: { ...project, time: { created: 0, updated: 0 }, sandboxes: [] },
+      }
+      listeners.forEach((listener) => listener({ name: updated.type, details: updated }))
+    }
+
+    const resolved: OpenCodeEvent = {
+      id: "evt_repository_resolved",
+      created: 1,
+      type: "worktree.resolved",
+      durable: { aggregateID: "repository", seq: 0, version: 1 },
+      data: {
+        projectID: "repository",
+        directory: "/repo",
+        previous: "global",
+        adopted: ["directory-root", "directory-nested", "directory-uncached"],
+      },
+    }
+    listeners.forEach((listener) => listener({ name: resolved.type, details: resolved }))
+
+    expect(setup.data.session.get("ses_root")?.projectID).toBe("repository")
+    expect(setup.data.session.get("ses_root")?.subpath).toBeUndefined()
+    expect(setup.data.session.get("ses_nested")).toMatchObject({ projectID: "repository", subpath: "app" })
+    expect(setup.data.session.get("ses_alias")).toMatchObject({ projectID: "repository", subpath: "app" })
+    expect(setup.data.session.get("ses_symlink")).toMatchObject({ projectID: "repository", subpath: "app" })
+    expect(setup.data.session.get("ses_global")).toMatchObject({ projectID: "repository", subpath: "legacy" })
+    expect(setup.data.session.get("ses_escaped")?.projectID).toBe("global")
+    expect(setup.data.session.get("ses_other")?.projectID).toBe("other-repository")
+    expect(setup.data.session.get("ses_sibling")?.projectID).toBe("global")
+    expect(setup.data.session.get("ses_remote")?.projectID).toBe("directory-root")
+    await wait(() => setup.data.session.get("ses_uncached")?.projectID === "repository")
+    expect(setup.data.session.get("ses_uncached")?.subpath).toBe("app")
+  } finally {
+    setup.dispose()
+  }
+})
+
 test("refreshes global credential events across every loaded location and workspace", async () => {
   const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
   const requests: URL[] = []

packages/client/test/worktree.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test } from "bun:test"
+import { Schema } from "effect"
+import { Worktree } from "@opencode-ai/schema/worktree"
+
+describe("Worktree.adopt", () => {
+  const event = {
+    projectID: "repository",
+    directory: "/repo",
+    previous: "previous",
+    adopted: ["directory-root", "directory-nested"],
+  }
+
+  test("adopts explicitly superseded directory projects", () => {
+    expect(Worktree.adopt({ projectID: "directory-root", directory: "/repo" }, event)).toEqual({
+      projectID: "repository",
+      subpath: undefined,
+    })
+    expect(Worktree.adopt({ projectID: "directory-nested", directory: "/repo/packages/app" }, event)).toEqual({
+      projectID: "repository",
+      subpath: "packages/app",
+    })
+  })
+
+  test("preserves existing previous-project and global adoption", () => {
+    expect(Worktree.adopt({ projectID: "previous", directory: "/repo/packages/app" }, event)).toEqual({
+      projectID: "repository",
+      subpath: "packages/app",
+    })
+    expect(Worktree.adopt({ projectID: "global", directory: "/repo/packages/app" }, event)).toEqual({
+      projectID: "repository",
+      subpath: "packages/app",
+    })
+  })
+
+  test("leaves unrelated projects, sibling directories, and workspaces unchanged", () => {
+    expect(Worktree.adopt({ projectID: "other", directory: "/repo/vendor" }, event)).toBeUndefined()
+    expect(Worktree.adopt({ projectID: "global", directory: "/repo-other" }, event)).toBeUndefined()
+    expect(Worktree.adopt({ projectID: "repository", directory: "/repo" }, event)).toBeUndefined()
+    expect(
+      Worktree.adopt({ projectID: "directory-root", directory: "/repo", workspaceID: "remote" }, event),
+    ).toBeUndefined()
+  })
+
+  test("normalizes Windows directory separators", () => {
+    expect(
+      Worktree.adopt(
+        { projectID: "directory-nested", directory: "C:\\repo\\packages\\app" },
+        { ...event, directory: "C:\\repo" },
+      ),
+    ).toEqual({ projectID: "repository", subpath: "packages/app" })
+    expect(
+      Worktree.adopt(
+        { projectID: "directory-nested", directory: "c:/Repo/packages/App" },
+        { ...event, directory: "C:\\repo" },
+      ),
+    ).toEqual({ projectID: "repository", subpath: "packages/App" })
+  })
+
+  test("normalizes aliases and rejects paths that leave the repository", () => {
+    expect(Worktree.adopt({ projectID: "directory-nested", directory: "/repo/alias/../packages/app" }, event)).toEqual({
+      projectID: "repository",
+      subpath: "packages/app",
+    })
+    expect(Worktree.adopt({ projectID: "global", directory: "/repo/../other" }, event)).toBeUndefined()
+    expect(Worktree.adopt({ projectID: "global", directory: "/app" }, { ...event, directory: "/" })).toEqual({
+      projectID: "repository",
+      subpath: "app",
+    })
+  })
+
+  test("decodes existing durable events without adopted project IDs", () => {
+    expect(
+      Schema.decodeUnknownSync(Worktree.Event.Resolved.data)({
+        projectID: "repository",
+        directory: "/repo",
+        previous: "global",
+      }),
+    ).toEqual({ projectID: "repository", directory: "/repo", previous: "global" })
+  })
+})

packages/core/src/project.ts

@@ -2,7 +2,7 @@ export * as Project from "./project.js"
 
 import { Context, Effect, Layer, Schema } from "effect"
 import { ChildProcess } from "effect/unstable/process"
-import { and, asc, desc, eq } from "drizzle-orm"
+import { and, asc, desc, eq, gte, isNull, lte } from "drizzle-orm"
 import path from "path"
 import { AbsolutePath } from "./schema.js"
 import { Bus } from "./bus.js"
@@ -104,7 +104,12 @@ const layer = Layer.effect(
         .pipe(Effect.orDie)
       yield* upsertProject(db, project).pipe(Effect.orDie)
       if (previous && previous.canonical !== project.canonical) {
-        const row = yield* db.select().from(ProjectTable).where(eq(ProjectTable.id, project.id)).get().pipe(Effect.orDie)
+        const row = yield* db
+          .select()
+          .from(ProjectTable)
+          .where(eq(ProjectTable.id, project.id))
+          .get()
+          .pipe(Effect.orDie)
         if (row) yield* bus.publish(ProjectSchema.Event.Updated, fromRow(row))
       }
       if (!project.vcs) return project
@@ -135,9 +140,38 @@ const layer = Layer.effect(
             .get()
             .pipe(Effect.orDie)
           if (stored) return
+          const directory = AbsolutePath.make(yield* fs.resolve(item.directory))
+          const markerless = yield* db
+            .select({ id: ProjectTable.id, directory: ProjectTable.worktree })
+            .from(ProjectTable)
+            .where(
+              and(
+                isNull(ProjectTable.vcs),
+                gte(ProjectTable.worktree, directory),
+                lte(ProjectTable.worktree, AbsolutePath.make(directory + "\uffff")),
+              ),
+            )
+            .all()
+            .pipe(Effect.orDie)
+          const adopted = yield* Effect.filter(markerless, (candidate) =>
+            Effect.gen(function* () {
+              if (candidate.id === item.projectID) return false
+              if (!FSUtil.contains(directory, candidate.directory)) return false
+              const markers = yield* fs
+                .up({ targets: [".git", ".hg"], start: candidate.directory, stop: directory, mode: "first" })
+                .pipe(Effect.orElseSucceed(() => []))
+              if (!markers[0]) return false
+              return (yield* fs.resolve(path.dirname(markers[0]))) === directory
+            }),
+          )
           yield* bus.publish(
             Worktree.Event.Resolved,
-            { projectID: item.projectID, directory: item.directory, previous: project.previous ?? ID.global },
+            {
+              projectID: item.projectID,
+              directory: item.directory,
+              previous: project.previous ?? ID.global,
+              ...(adopted.length ? { adopted: adopted.map((candidate) => candidate.id) } : {}),
+            },
             {
               commit: () =>
                 db
@@ -256,12 +290,7 @@ const layer = Layer.effect(
       return node ? ID.make(node) : undefined
     })
 
-    const hgDiscover = Effect.fnUntraced(function* (input: AbsolutePath) {
-      const dotHg = yield* fs.up({ targets: [".hg"], start: input, mode: "first" }).pipe(
-        Effect.map((matches) => matches[0]),
-        Effect.orElseSucceed(() => undefined),
-      )
-      if (!dotHg) return undefined
+    const hgDiscover = Effect.fnUntraced(function* (dotHg: AbsolutePath) {
       const worktree = AbsolutePath.make(path.dirname(dotHg))
       const store = AbsolutePath.make(dotHg)
       const previous = yield* cached(store)
@@ -275,7 +304,15 @@ const layer = Layer.effect(
     })
 
     const resolve = Effect.fn("Project.resolve")(function* (input: AbsolutePath) {
-      const repo = yield* git.repo.discover(input)
+      const directory = AbsolutePath.make(yield* fs.resolve(input))
+      const marker = yield* fs.up({ targets: [".git", ".hg"], start: directory, mode: "first" }).pipe(
+        Effect.map((matches) => matches[0]),
+        Effect.orElseSucceed(() => undefined),
+      )
+      const repo =
+        marker && path.basename(marker) === ".git"
+          ? yield* git.repo.discover(AbsolutePath.make(path.dirname(marker)))
+          : undefined
       if (repo) {
         const previous = yield* cached(repo.commonDirectory)
         const id = (yield* remote(repo)) ?? previous ?? (yield* rootCommit(repo))
@@ -295,10 +332,14 @@ const layer = Layer.effect(
         })
       }
 
-      const hg = yield* hgDiscover(input)
+      const hg = marker && path.basename(marker) === ".hg" ? yield* hgDiscover(AbsolutePath.make(marker)) : undefined
       if (hg) return yield* persist({ ...hg, canonical: hg.directory })
-      const directory = AbsolutePath.make(path.parse(input).root)
-      return yield* persist({ id: ID.global, directory, canonical: directory, vcs: undefined })
+      return yield* persist({
+        id: ID.make(Hash.fast(`directory:${directory}`)),
+        directory,
+        canonical: directory,
+        vcs: undefined,
+      })
     })
 
     return Service.of({ list, update, resolve })