perf(server): port #13673 to V2 — settling a thread closes its idle shells

Main's fix closed a settled thread's idle terminals from the V1
ProviderCommandReactor, which V2 deleted. V2's settle only detached the
provider session, so idle shells kept holding the worktree. The merge
already brought TerminalManager.closeIdle and the setup-script cleanup
(ProjectSetupScriptRunner is shared).

ThreadSettlementServiceV2 already consumes V2 domain events, so it now
handles thread.settled: it re-reads the thread and, if it is still
settled, calls closeIdle. A terminal running a command stays open.
Covers manual and automatic settlement, which both emit thread.settled.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: juliusmarminge

apps/server/src/orchestration-v2/ThreadSettlementService.test.ts

@@ -3,10 +3,13 @@ import * as DateTime from "effect/DateTime";
 import {
   DEFAULT_SERVER_SETTINGS,
   ProjectId,
+  EventId,
   ProviderInstanceId,
   ThreadId,
   type OrchestrationProjectShell,
+  type OrchestrationV2AppThread,
   type OrchestrationV2Command,
+  type OrchestrationV2DomainEvent,
   type OrchestrationV2ShellSnapshot,
   type OrchestrationV2ThreadShell,
   type PullRequestSummary,
@@ -32,6 +35,7 @@ import {
 } from "../pullRequest/PullRequestService.ts";
 import { ServerActivation } from "../serverActivation.ts";
 import { ServerSettingsService } from "../serverSettings.ts";
+import { TerminalManager } from "../terminal/Manager.ts";
 import { ProjectionSnapshotQuery } from "../orchestration/Services/ProjectionSnapshotQuery.ts";
 import { OrchestratorV2, type OrchestratorV2Shape } from "./Orchestrator.ts";
 import { ProjectionStoreV2 } from "./ProjectionStore.ts";
@@ -410,6 +414,8 @@ interface HarnessOptions {
   readonly pullRequestSummary?: PullRequestService["Service"]["summary"];
   readonly existingWorktreePaths?: ReadonlyArray<string>;
   readonly onDispatch?: (command: AutoSettleCommand) => Effect.Effect<void>;
+  /** Threads `getThread` returns when a `thread.settled` event is handled. */
+  readonly currentThreads?: ReadonlyArray<OrchestrationV2AppThread>;
 }
 
 const makeHarness = Effect.fn("makeThreadSettlementHarness")(function* (options: HarnessOptions) {
@@ -433,6 +439,8 @@ const makeHarness = Effect.fn("makeThreadSettlementHarness")(function* (options:
   >([]);
   const summaryRecovery = yield* Ref.make<ReadonlyArray<boolean | undefined>>([]);
   const invalidatedCwds = yield* Ref.make<ReadonlyArray<string>>([]);
+  const domainEvents = yield* PubSub.unbounded<OrchestrationV2DomainEvent>();
+  const closedIdle = yield* Queue.unbounded<{ readonly threadId: string }>();
 
   const updateSettings = (patch: ServerSettingsPatch) =>
     Effect.gen(function* () {
@@ -499,11 +507,20 @@ const makeHarness = Effect.fn("makeThreadSettlementHarness")(function* (options:
           Effect.andThen(Ref.get(snapshots)),
           Effect.map((snapshot) => snapshot.threads),
         ),
+      getThread: (threadId) => {
+        const thread = options.currentThreads?.find((candidate) => candidate.id === threadId);
+        return thread
+          ? Effect.succeed(thread)
+          : Effect.die(new Error(`Unexpected thread read: ${threadId}`));
+      },
     }),
     Layer.mock(OrchestratorV2)({
-      streamDomainEvents: Stream.empty,
+      streamDomainEvents: Stream.fromPubSub(domainEvents),
       dispatch,
     }),
+    Layer.mock(TerminalManager)({
+      closeIdle: (input) => Queue.offer(closedIdle, input).pipe(Effect.asVoid),
+    }),
     Layer.mock(GitManager)({
       branchPullRequest,
       invalidateStatus: (cwd) => Ref.update(invalidatedCwds, (cwds) => [...cwds, cwd]),
@@ -532,6 +549,8 @@ const makeHarness = Effect.fn("makeThreadSettlementHarness")(function* (options:
     summaryCalls,
     summaryRecovery,
     invalidatedCwds,
+    closedIdle,
+    publishEvent: (event: OrchestrationV2DomainEvent) => PubSub.publish(domainEvents, event),
     updateSettings,
     publishMerge: PubSub.publish(mergedPullRequests, {
       projectId: PROJECT_ID,
@@ -905,3 +924,85 @@ describe("ThreadSettlementServiceV2 worker", () => {
     ),
   );
 });
+
+describe("ThreadSettlementServiceV2 terminals", () => {
+  const appThread = (
+    id: string,
+    settledOverride: OrchestrationV2AppThread["settledOverride"],
+  ): OrchestrationV2AppThread => {
+    const threadId = ThreadId.make(id);
+    return {
+      createdBy: "user",
+      creationSource: "web",
+      id: threadId,
+      projectId: PROJECT_ID,
+      title: id,
+      providerInstanceId: ProviderInstanceId.make("codex"),
+      modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5" },
+      runtimeMode: "full-access",
+      interactionMode: "default",
+      branch: null,
+      worktreePath: null,
+      activeProviderThreadId: null,
+      lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
+      forkedFrom: null,
+      createdAt: DateTime.makeUnsafe(NOW),
+      updatedAt: DateTime.makeUnsafe(NOW),
+      archivedAt: null,
+      settledOverride,
+      settledAt: settledOverride === "settled" ? DateTime.makeUnsafe(NOW) : null,
+      lastVisitedAt: null,
+      deletedAt: null,
+    };
+  };
+  const settledEvent = (thread: OrchestrationV2AppThread): OrchestrationV2DomainEvent => ({
+    type: "thread.settled",
+    id: EventId.make(`event:settled:${thread.id}`),
+    threadId: thread.id,
+    occurredAt: DateTime.makeUnsafe(NOW),
+    payload: thread,
+  });
+
+  it.effect("closes the thread's idle terminals when it settles", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const thread = appThread("settled-thread", "settled");
+        const fixture = yield* makeHarness({
+          snapshot: makeSnapshot([]),
+          currentThreads: [thread],
+        });
+
+        yield* Effect.gen(function* () {
+          const service = yield* ThreadSettlementService.ThreadSettlementServiceV2;
+          yield* startHarness(service, fixture.activation, fixture.snapshotReads);
+          yield* fixture.publishEvent(settledEvent(thread));
+          assert.deepStrictEqual(yield* Queue.take(fixture.closedIdle), { threadId: thread.id });
+        }).pipe(Effect.provide(fixture.layer));
+      }),
+    ),
+  );
+
+  it.effect("keeps the terminals of a thread re-engaged before the event ran", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const settled = appThread("reengaged-thread", "settled");
+        const reengaged = appThread("reengaged-thread", "active");
+        const marker = appThread("marker-thread", "settled");
+        const fixture = yield* makeHarness({
+          snapshot: makeSnapshot([]),
+          currentThreads: [reengaged, marker],
+        });
+
+        yield* Effect.gen(function* () {
+          const service = yield* ThreadSettlementService.ThreadSettlementServiceV2;
+          yield* startHarness(service, fixture.activation, fixture.snapshotReads);
+          yield* fixture.publishEvent(settledEvent(settled));
+          // Events run in order, so the first close belongs to the later
+          // event only if the re-engaged thread was skipped.
+          yield* fixture.publishEvent(settledEvent(marker));
+          assert.deepStrictEqual(yield* Queue.take(fixture.closedIdle), { threadId: marker.id });
+        }).pipe(Effect.provide(fixture.layer));
+      }),
+    ),
+  );
+});

apps/server/src/orchestration-v2/ThreadSettlementService.ts

@@ -22,6 +22,7 @@ import * as GitManager from "../git/GitManager.ts";
 import * as PullRequestService from "../pullRequest/PullRequestService.ts";
 import * as ServerSettings from "../serverSettings.ts";
 import { forkParked } from "../serverActivation.ts";
+import * as TerminalManager from "../terminal/Manager.ts";
 import * as ProjectionSnapshotQuery from "../orchestration/Services/ProjectionSnapshotQuery.ts";
 import { OrchestratorV2 } from "./Orchestrator.ts";
 import { ProjectionStoreV2, type ProjectionSettlementCandidate } from "./ProjectionStore.ts";
@@ -257,6 +258,7 @@ export const make = Effect.gen(function* () {
   const pullRequests = yield* PullRequestService.PullRequestService;
   const crypto = yield* Crypto.Crypto;
   const fileSystem = yield* FileSystem.FileSystem;
+  const terminals = yield* TerminalManager.TerminalManager;
 
   const sweep = Effect.fn("ThreadSettlementServiceV2.sweep")(function* (
     mergedPullRequest: PullRequestService.PullRequestMergeEvent | null,
@@ -506,8 +508,33 @@ export const make = Effect.gen(function* () {
     runSweep(null, threadId),
   );
 
+  // Settling closes the thread's shells that sit at an idle prompt, so they stop
+  // holding the worktree. A terminal running a command (a dev server, an
+  // editor) stays for the user to close.
+  const closeIdleTerminals = Effect.fn("ThreadSettlementServiceV2.closeIdleTerminals")(
+    function* (threadId: ThreadId) {
+      // A thread re-engaged before this event ran keeps its shells.
+      const thread = yield* projections.getThread(threadId);
+      if (thread.settledOverride !== "settled") return;
+      yield* terminals.closeIdle({ threadId });
+    },
+    (effect, threadId) =>
+      effect.pipe(
+        Effect.catchCause((cause) =>
+          Cause.hasInterruptsOnly(cause)
+            ? Effect.failCause(cause)
+            : Effect.logWarning("closing idle terminals after settlement failed", {
+                threadId,
+                cause: Cause.pretty(cause),
+              }),
+        ),
+      ),
+  );
+
   const processEvent = (event: OrchestrationV2DomainEvent) => {
     switch (event.type) {
+      case "thread.settled":
+        return closeIdleTerminals(event.threadId);
       case "thread.pull-request-synced":
       case "provider-session.detached":
         return worker.enqueue(event.threadId);