@@ -64,36 +64,48 @@ export const layer = (options?: Options) =>
       const bus = yield* Bus.Service
       const fs = yield* FSUtil.Service
       const scope = yield* Effect.scope
-      const lock = Semaphore.makeUnsafe(1)
+      const lock = yield* Semaphore.make(1)
       const locations = new Map<string, Map<string, Entry>>()
       const locationKey = (location: Location.Ref) => JSON.stringify([location.directory, location.workspaceID])
 
+      const remove = (key: string, file: string) => {
+        const files = locations.get(key)
+        const entry = files?.get(file)
+        if (!files || !entry) return
+        files.delete(file)
+        if (files.size === 0) locations.delete(key)
+        return entry
+      }
+
       const stop = (key: string, file: string) =>
         Effect.suspend(() => {
-          const files = locations.get(key)
-          const entry = files?.get(file)
-          if (!files || !entry) return Effect.void
-          files.delete(file)
-          if (files.size === 0) locations.delete(key)
+          const entry = remove(key, file)
+          if (!entry) return Effect.void
           return Scope.close(entry.scope, Exit.void)
         })
 
-      const start = Effect.fnUntraced(function* (input: Input) {
+      const start = Effect.fnUntraced(function* (key: string, input: Input) {
         const child = yield* Scope.fork(scope)
         yield* Effect.gen(function* () {
           const updates = yield* watcher.subscribe({ path: input.file, type: "file" })
           yield* Stream.runForEach(updates, () =>
-            fs
-              .existsSafe(input.file)
-              .pipe(
-                Effect.flatMap((exists) =>
-                  bus.publish(
-                    FileSystem.Event.Changed,
-                    { file: input.file, event: exists ? "change" : "unlink" },
-                    { location: input.location },
-                  ),
-                ),
-              ),
+            Effect.gen(function* () {
+              const exists = yield* fs.existsSafe(input.file)
+              yield* bus.publish(
+                FileSystem.Event.Changed,
+                { file: input.file, event: exists ? "change" : "unlink" },
+                { location: input.location },
+              )
+            }),
+          )
+          // The native watch ended (e.g. its directory vanished): forget it so the next watch starts a new one.
+          // The scope closes from another fiber because closing it interrupts this one.
+          yield* lock.withPermit(
+            Effect.suspend(() => {
+              if (locations.get(key)?.get(input.file)?.scope !== child) return Effect.void
+              remove(key, input.file)
+              return Scope.close(child, Exit.void).pipe(Effect.forkIn(scope), Effect.asVoid)
+            }),
           )
         }).pipe(
           Effect.catchCauseIf(
@@ -132,7 +144,7 @@ export const layer = (options?: Options) =>
                 const soonest = [...full].reduce((a, b) => (b[1].expires < a[1].expires ? b : a))
                 yield* stop(key, soonest[0])
               }
-              const entry = { expires, scope: yield* start(input) }
+              const entry = { expires, scope: yield* start(key, input) }
               const files = locations.get(key) ?? new Map<string, Entry>()
               files.set(input.file, entry)
               locations.set(key, files)
 
@@ -106,6 +106,35 @@ describe("FileWatch", () => {
   )
 })
 
+describe("FileWatch dead watches", () => {
+  const counts = { subscribes: 0 }
+  // A native watch that cannot start, like one on a directory that no longer exists.
+  const failing = testEffect(
+    FileWatch.layer().pipe(
+      Layer.provide(
+        Watcher.layer().pipe(
+          Layer.provide(
+            Layer.succeed(
+              Watcher.Native,
+              Watcher.Native.of({ subscribe: () => Effect.sync(() => void counts.subscribes++) }),
+            ),
+          ),
+        ),
+      ),
+      Layer.provide(services),
+    ),
+  )
+  failing.effect("starts a new watch when the previous one ended", () =>
+    Effect.gen(function* () {
+      const fileWatch = yield* FileWatch.Service
+      yield* fileWatch.watch(file("a.ts"))
+      yield* Effect.repeat(Effect.yieldNow, { times: 10 })
+      yield* fileWatch.watch(file("a.ts"))
+      expect(counts.subscribes).toBe(2)
+    }),
+  )
+})
+
 describe("FileWatch disabled", () => {
   const disabled = testEffect(
     FileWatch.layer({ enabled: false }).pipe(Layer.provide(Watcher.testLayer), Layer.provide(services)),
 
@@ -54,6 +54,16 @@ function countingNative() {
 }
 
 describe("Watcher lifecycle", () => {
+  it.live("ends the stream when the watched directory is missing", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const watcher = yield* Watcher.Service
+        const updates = yield* watcher.subscribe({ path: path.join(directory, "missing", "a.ts"), type: "file" })
+        expect(Option.isNone(yield* Stream.runHead(updates))).toBe(true)
+      }).pipe(Effect.provide(AppNodeBuilder.build(Watcher.node))),
+    ),
+  )
+
   it.effect("signals readiness after acquisition and buffers updates published by the ready callback", () =>
     Effect.gen(function* () {
       const publish = yield* Deferred.make<(update: Watcher.Update) => void>()