fix(server): finish a plugin's host work before disable returns

When a plugin's process had already exited, disable returned at once, even
while the exit was still ending that process's host calls. Disable now
waits for that, so their cleanup cannot overlap a re-enable or what runs
after the disable.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: github-actions[bot]

apps/server/src/plugins/PluginSettings.test.ts

@@ -726,6 +726,52 @@ it.layer(NodeServices.layer)("PluginSettings", (it) => {
       }),
     );
 
+    it.effect("waits for host work still ending when disabling a process that exited", () =>
+      Effect.gen(function* () {
+        const supervisor = yield* makeSupervisor(yield* Scope.Scope, BIN_PATH);
+        const started = yield* Deferred.make<void>();
+        const ending = yield* Deferred.make<void>();
+        const release = yield* Deferred.make<void>();
+        const order: Array<string> = [];
+        yield* supervisor.serveHostMethod("settings.get", () => Effect.succeed({ value: null }));
+        yield* supervisor.serveHostMethod("storage.get", () =>
+          Deferred.succeed(started, undefined).pipe(
+            Effect.andThen(Effect.never),
+            // Stands for cleanup that outlasts the process, such as releasing a lock.
+            Effect.onInterrupt(() =>
+              Deferred.succeed(ending, undefined).pipe(
+                Effect.andThen(Deferred.await(release)),
+                Effect.andThen(Effect.sync(() => order.push("host work ended"))),
+              ),
+            ),
+          ),
+        );
+        const registration = yield* loadPluginDirectory(yield* preparePlugin());
+        const pluginId = registration.manifest.id;
+        yield* supervisor.enable(registration);
+        yield* supervisor
+          .invoke(pluginId, "load", { key: "a" })
+          .pipe(Effect.ignore, Effect.forkChild({ startImmediately: true }));
+        yield* Deferred.await(started);
+        yield* supervisor
+          .invoke(pluginId, "exit", null)
+          .pipe(Effect.ignore, Effect.forkChild({ startImmediately: true }));
+        // The process has exited and its host work is ending.
+        yield* Deferred.await(ending);
+
+        const disabling = yield* supervisor
+          .disable(pluginId)
+          .pipe(
+            Effect.andThen(Effect.sync(() => order.push("disabled"))),
+            Effect.forkChild({ startImmediately: true }),
+          );
+        yield* Effect.yieldNow;
+        yield* Deferred.succeed(release, undefined);
+        yield* Fiber.join(disabling);
+        expect(order).toEqual(["host work ended", "disabled"]);
+      }),
+    );
+
     it.effect("drops a write that waited for the settings lock past its generation", () =>
       withDatabase(
         Effect.gen(function* () {

apps/server/src/plugins/PluginSupervisor.ts

@@ -278,6 +278,8 @@ interface Child {
   hostCalls: number;
   /** Owns the fibers serving this child's host calls; closed on revocation and exit. */
   readonly hostWork: Scope.Closeable;
+  /** Set once `hostWork` starts closing; done once it has closed. */
+  hostWorkEnded: Deferred.Deferred<void> | undefined;
   /** One host-call answer at a time waits for the child to read earlier messages. */
   readonly replies: Semaphore.Semaphore;
   /** Set while answers wait for the child to read; logged once per episode. */
@@ -639,14 +641,25 @@ export const make = Effect.fn("PluginSupervisor.make")(function* (
     }
   });
 
+  /** Closes a child's host work; a caller that comes while it is closing waits for the end. */
+  const endHostWork = (child: Child) =>
+    Effect.suspend(() => {
+      if (child.hostWorkEnded) return Deferred.await(child.hostWorkEnded);
+      const ended = Deferred.makeUnsafe<void>();
+      child.hostWorkEnded = ended;
+      return Scope.close(child.hostWork, Exit.void).pipe(
+        Effect.ensuring(Deferred.succeed(ended, undefined)),
+      );
+    });
+
   const handleExit = Effect.fnUntraced(function* (
     entry: Entry,
     child: Child,
     code: number | null,
     signal: string | null,
   ) {
     // Host work of a dead process ends before anything else can run for this plugin.
-    yield* Scope.close(child.hostWork, Exit.void);
+    yield* endHostWork(child);
     // Anything still unread from the dead process is discarded.
     child.channel.destroy();
     const reason = child.killReason ?? describeExit(child, code, signal, options.heapLimitMb);
@@ -701,6 +714,7 @@ export const make = Effect.fn("PluginSupervisor.make")(function* (
       outOfMemory: false,
       hostCalls: 0,
       hostWork: Scope.forkUnsafe(fibers, "parallel"),
+      hostWorkEnded: undefined,
       replies: Semaphore.makeUnsafe(1),
       backedUp: false,
     };
@@ -950,10 +964,12 @@ export const make = Effect.fn("PluginSupervisor.make")(function* (
     // Only reachable between claiming a start and spawning; the start then fails fast.
     if (!entry.child && entry.starting) yield* Deferred.await(entry.starting).pipe(Effect.ignore);
     const child = entry.child;
-    if (!child || Deferred.isDoneUnsafe(child.exited)) return;
+    if (!child) return;
+    // A process that already exited may still be ending its host work.
+    if (Deferred.isDoneUnsafe(child.exited)) return yield* endHostWork(child);
     revokeChild(entry, child);
     // The revoked generation's host work ends before its plugin is asked to deactivate.
-    yield* Scope.close(child.hostWork, Exit.void);
+    yield* endHostWork(child);
     write(child, { _tag: "Deactivate" });
     const exited = yield* Deferred.await(child.exited).pipe(Effect.timeoutOption(stopGrace));
     if (Option.isNone(exited)) {