fix(core): restore parcel watch for git HEAD

packages/core/src/location-services.ts

@@ -15,7 +15,6 @@ import { FileSystemSearch } from "./filesystem/search"
 import { Generate } from "./generate"
 import { Form } from "./form"
 import { Image } from "./image"
-import { LocationWatcher } from "./filesystem/location-watcher"
 import { Integration } from "./integration"
 import { Location } from "./location"
 import { LocationMutation } from "./location-mutation"
@@ -99,8 +98,6 @@ const locationServiceNodes = [
   Snapshot.node,
   SessionRunnerLLM.node,
   Vcs.node,
-  // Start repository watches only after boot-critical filesystem and Git work.
-  LocationWatcher.node,
 ] as const satisfies readonly Node.LocationNode<unknown, unknown>[]
 
 export const locationServices = LayerNode.group<typeof locationServiceNodes>(locationServiceNodes)

packages/core/src/vcs.ts

@@ -3,14 +3,15 @@ export * as Vcs from "./vcs"
 import path from "path"
 import { Context, Effect, Layer, Stream } from "effect"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
-import { FileSystem } from "@opencode-ai/schema/filesystem"
 import { FileStatus, Info, Mode } from "@opencode-ai/schema/vcs"
 import { VcsEvent } from "@opencode-ai/schema/vcs-event"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "./location"
 import { AppProcess } from "@opencode-ai/util/process"
 import { Bus } from "./bus"
+import { Git } from "./git"
+import { Watcher } from "./filesystem/watcher"
 import { VcsGit } from "./vcs/git"
 import { VcsHg } from "./vcs/hg"
 
@@ -44,29 +45,36 @@ const layer = Layer.effect(
     const fs = yield* FSUtil.Service
     const location = yield* Location.Service
     const bus = yield* Bus.Service
+    const git = yield* Git.Service
+    const watcher = yield* Watcher.Service
     const impl = adapter(proc, fs, location)
     const vcs = location.vcs
     const state = { info: impl ? yield* impl.info() : ({ branch: {} } satisfies Info) }
 
     if (vcs && impl) {
-      const store = yield* fs.realPath(vcs.store).pipe(Effect.catch(() => Effect.succeed(vcs.store)))
-      const isBranchMetadata =
-        vcs.type === "git"
-          ? (file: string) => path.basename(file) === "HEAD" && FSUtil.contains(store, file)
-          : (file: string) => path.resolve(file) === path.join(store, "branch")
-      yield* bus.subscribe(FileSystem.Event.Changed).pipe(
-        Stream.filter((event) => isBranchMetadata(event.data.file)),
-        Stream.runForEach((event) =>
-          Effect.gen(function* () {
-            const next = yield* impl.info()
-            const changed = state.info.branch.current !== next.branch.current
-            state.info = next
-            if (!changed) return
-            yield* bus.publish(VcsEvent.BranchUpdated, { branch: next.branch.current })
-          }).pipe(Effect.withSpan("Vcs.refreshBranch", { attributes: { file: event.data.file } })),
-        ),
-        Effect.forkScoped({ startImmediately: true }),
-      )
+      yield* Effect.gen(function* () {
+        const discovered = vcs.type === "git" ? (yield* git.repo.discover(location.directory))?.gitDirectory : undefined
+        const target = discovered ?? vcs.store
+        const dir = yield* fs.realPath(target).pipe(Effect.catch(() => Effect.succeed(target)))
+        const keep = vcs.type === "git" ? ["HEAD", "HEAD.lock"] : ["branch"]
+        const ignore = (yield* fs.readDirectoryEntries(dir).pipe(Effect.catch(() => Effect.succeed([])))).flatMap(
+          (entry) => (keep.includes(entry.name) ? [] : [entry.name]),
+        )
+        const updates = yield* watcher.subscribe({ path: dir, type: "directory", ignore })
+        yield* updates.pipe(
+          Stream.filter((update) => keep.includes(path.basename(update.path))),
+          Stream.runForEach((update) =>
+            Effect.gen(function* () {
+              const next = yield* impl.info()
+              const changed = state.info.branch.current !== next.branch.current
+              state.info = next
+              if (!changed) return
+              yield* bus.publish(VcsEvent.BranchUpdated, { branch: next.branch.current })
+            }).pipe(Effect.withSpan("Vcs.refreshBranch", { attributes: { file: update.path } })),
+          ),
+          Effect.forkScoped({ startImmediately: true }),
+        )
+      }).pipe(Effect.catchCause((cause) => Effect.logError("failed to watch vcs metadata", { cause })))
     }
 
     return Service.of({
@@ -88,5 +96,5 @@ const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer: layer,
-  deps: [AppProcess.node, FSUtil.node, Location.node, Bus.node],
+  deps: [AppProcess.node, FSUtil.node, Location.node, Bus.node, Git.node, Watcher.node],
 })