Auto-settle on merge: give the user time to read the agent's final reply when the agent merged the PR itself

[cardene777]

Summary

When the agent merges (or closes) the thread's pull request during its own turn, PR-driven auto-settlement fires the moment that turn completes. The thread drops into Settled and ProviderCommandReactor stops its provider session on thread.settled, usually within a second of the agent's final reply and before the user has read it.

I'd like to propose a grace period for that one case. A tested patch is included below.

What happens

Version: T3 Code 0.0.44 (desktop, macOS), Claude provider. The same code is on main @ 54084ae.

1. The agent opens a PR and links it with the t3-code MCP link_pull_request tool. T3 Code's agent instructions ask the agent to link every PR it creates or works on, so in agent-driven workflows almost every thread has a linked PR.
2. In the same turn, the agent merges the PR (gh pr merge) and ends the turn with a summary and a question such as "Should I continue with X next?".
3. turn.completed → the session leaves running → ThreadSettlementReactor sweeps → thread.auto-settle → thread.settled → session-stop-for-settle:server:auto-settle:<thread>:<uuid> stops the session.

Over one afternoon, 8 threads were auto-settled this way. I inspected 6 of them. In each, the agent had merged the PR during the turn and ended the turn by proposing the next step, in 4 of them as an explicit question to the user. thread.settled followed turn.completed by less than one second in 5 threads, and by 25 seconds in the sixth, which was waiting for the PR sync.

From the user's side, the thread they were just talking to disappears into the collapsed Settled group and its session is stopped. It looks as if the session closed on its own.

Why the current rule settles immediately

pullRequestSettles anchors on the user's latest request (latestTurn.requestedAt), so a PR merged during the turn counts as newer than the user's last activity. This is intentional (see the test "uses user request time instead of completion time as the PR anchor"). It is the right call when a human merges after reading the reply. It is not right when the agent did the merge itself and is still waiting for an answer.

Turning off "Auto-settle merged threads" avoids the problem, but it also removes settlement when a human merges later, which is still useful.

Proposal

Hold PR-driven settlement for a grace period when the PR became terminal inside the latest turn (requestedAt <= mergedAt/closedAt <= completedAt). Everything else stays the same:

• A PR merged or closed after the turn completed (a human acting after reading) still settles immediately.
• Inactivity settlement, snooze, pins and the candidate checks are untouched.
• No new scheduling is needed. The reactor's existing one-minute sweep settles the thread once the grace has elapsed, with the same settledAt as today.

The patch uses 30 minutes to match ProviderSessionReaper's default inactivity threshold, so merge settlement never stops a session earlier than the idle reaper would. The exact value is your call.

Patch

apps/server/src/orchestration/ThreadSettlementPolicy.ts and its tests (+114 / −1)

diff --git a/apps/server/src/orchestration/ThreadSettlementPolicy.ts b/apps/server/src/orchestration/ThreadSettlementPolicy.ts
index 113d6820..05fb53e2 100644
--- a/apps/server/src/orchestration/ThreadSettlementPolicy.ts
+++ b/apps/server/src/orchestration/ThreadSettlementPolicy.ts
@@ -11,6 +11,11 @@ export interface SettlementPullRequest {
 const DAY_MS = 24 * 60 * 60 * 1_000;
 const QUEUED_TURN_START_GRACE_MS = 2 * 60 * 1_000;
 
+/** When an agent merges or closes a pull request during its latest turn, its final reply is unread.
+ * Thirty minutes matches ProviderSessionReaper's default inactivity threshold, so settlement
+ * never stops the session before the idle reaper would. */
+export const AGENT_TERMINAL_PULL_REQUEST_GRACE_MS = 30 * 60 * 1_000;
+
 function latestTimestamp(values: ReadonlyArray<string | null | undefined>): string | null {
   let latest: string | null = null;
   let latestMs = Number.NEGATIVE_INFINITY;
@@ -52,7 +57,7 @@ function pullRequestSettles(
   if (pullRequest.state !== "closed" && (pullRequest.state !== "merged" || !autoSettleOnMerge)) {
     return false;
   }
-  const terminalAt = pullRequest.state === "merged" ? pullRequest.mergedAt : pullRequest.closedAt;
+  const terminalAt = pullRequestTerminalAt(pullRequest);
   if (terminalAt == null) return false;
   const userAnchor = latestTimestamp([
     thread.createdAt,
@@ -66,6 +71,10 @@ function pullRequestSettles(
   return pullRequestAt >= userAnchorAt;
 }
 
+function pullRequestTerminalAt(pullRequest: SettlementPullRequest): string | null | undefined {
+  return pullRequest.state === "merged" ? pullRequest.mergedAt : pullRequest.closedAt;
+}
+
 export function resolveAutoSettlementAt(input: {
   readonly thread: OrchestrationThreadShell;
   readonly pullRequest: SettlementPullRequest | null;
@@ -105,6 +114,23 @@ export function resolveAutoSettlementAt(input: {
   ]);
   if (pullRequest !== null) {
     if (pullRequestSettles(thread, pullRequest, input.autoSettleOnMerge)) {
+      const terminalAt = pullRequestTerminalAt(pullRequest);
+      const latestTurn = thread.latestTurn;
+      if (latestTurn?.requestedAt != null && latestTurn.completedAt != null && terminalAt != null) {
+        const requestedAtMs = Date.parse(latestTurn.requestedAt);
+        const completedAtMs = Date.parse(latestTurn.completedAt);
+        const terminalAtMs = Date.parse(terminalAt);
+        if (
+          !Number.isNaN(requestedAtMs) &&
+          !Number.isNaN(completedAtMs) &&
+          !Number.isNaN(terminalAtMs) &&
+          terminalAtMs >= requestedAtMs &&
+          terminalAtMs <= completedAtMs &&
+          Date.parse(input.now) < completedAtMs + AGENT_TERMINAL_PULL_REQUEST_GRACE_MS
+        ) {
+          return null;
+        }
+      }
       return activityAt ?? thread.createdAt;
     }
   }
diff --git a/apps/server/src/orchestration/ThreadSettlementPolicy.test.ts b/apps/server/src/orchestration/ThreadSettlementPolicy.test.ts
index 8a1588b1..888191f2 100644
--- a/apps/server/src/orchestration/ThreadSettlementPolicy.test.ts
+++ b/apps/server/src/orchestration/ThreadSettlementPolicy.test.ts
@@ -169,6 +169,93 @@ describe("resolveAutoSettlementAt", () => {
     expect(decide(thread, { state: "merged", mergedAt: "2026-08-26T00:00:00.000Z" })).toBe(true);
   });
 
+  it("keeps a recent agent-merged thread active during the reply grace period", () => {
+    const thread = makeThread({
+      latestTurn: {
+        turnId: TurnId.make("turn-agent-merge"),
+        state: "completed",
+        requestedAt: "2026-08-28T11:45:00.000Z",
+        startedAt: "2026-08-28T11:46:00.000Z",
+        completedAt: "2026-08-28T11:55:00.000Z",
+        assistantMessageId: null,
+      },
+    });
+    expect(
+      decide(thread, { state: "merged", mergedAt: "2026-08-28T11:50:00.000Z" }, { days: null }),
+    ).toBe(false);
+  });
+
+  it("settles an agent-merged thread after the reply grace period", () => {
+    const completedAt = "2026-08-28T11:29:00.000Z";
+    const thread = makeThread({
+      latestTurn: {
+        turnId: TurnId.make("turn-expired-agent-merge"),
+        state: "completed",
+        requestedAt: "2026-08-28T11:20:00.000Z",
+        startedAt: "2026-08-28T11:21:00.000Z",
+        completedAt,
+        assistantMessageId: null,
+      },
+    });
+    expect(
+      resolveAutoSettlementAt({
+        thread,
+        pullRequest: { state: "merged", mergedAt: "2026-08-28T11:25:00.000Z" },
+        now: NOW,
+        autoSettleAfterDays: null,
+        autoSettleOnMerge: true,
+      }),
+    ).toBe(completedAt);
+  });
+
+  it("keeps a recent agent-closed thread active during the reply grace period", () => {
+    const thread = makeThread({
+      latestTurn: {
+        turnId: TurnId.make("turn-agent-close"),
+        state: "completed",
+        requestedAt: "2026-08-28T11:45:00.000Z",
+        startedAt: "2026-08-28T11:46:00.000Z",
+        completedAt: "2026-08-28T11:55:00.000Z",
+        assistantMessageId: null,
+      },
+    });
+    expect(
+      decide(thread, { state: "closed", closedAt: "2026-08-28T11:50:00.000Z" }, { days: null }),
+    ).toBe(false);
+  });
+
+  it("settles immediately when a human merges after the latest turn", () => {
+    const thread = makeThread({
+      latestTurn: {
+        turnId: TurnId.make("turn-before-human-merge"),
+        state: "completed",
+        requestedAt: "2026-08-28T11:45:00.000Z",
+        startedAt: "2026-08-28T11:46:00.000Z",
+        completedAt: "2026-08-28T11:55:00.000Z",
+        assistantMessageId: null,
+      },
+    });
+    expect(
+      decide(thread, { state: "merged", mergedAt: "2026-08-28T11:56:00.000Z" }, { days: null }),
+    ).toBe(true);
+  });
+
+  it("settles at the exact reply grace period boundary", () => {
+    const thread = makeThread({
+      latestTurn: {
+        turnId: TurnId.make("turn-agent-merge-boundary"),
+        state: "completed",
+        requestedAt: "2026-08-28T11:20:00.000Z",
+        startedAt: "2026-08-28T11:21:00.000Z",
+        completedAt: "2026-08-28T11:30:00.000Z",
+        assistantMessageId: null,
+      },
+    });
+    expect(
+      decide(thread, { state: "merged", mergedAt: "2026-08-28T11:25:00.000Z" }, { days: null }),
+    ).toBe(true);
+  });
+
   it("blocks pins, snooze, pending work, live sessions, and queued starts", () => {
     expect(decide(makeThread({ settledOverride: "active" }))).toBe(false);
   });

Verification

On main @ 54084ae, from apps/server:

• vp test run src/orchestration/ThreadSettlementPolicy.test.ts: 25 passed (20 existing and 5 new).
• vp test run src/orchestration/ThreadSettlementReactor.test.ts: identical results before and after the patch, with no newly failing tests. 37 storage-cleanup and worktree tests fail in my local environment on the unmodified checkout as well.
• tsc --noEmit -p .: the same 56 errors before and after the patch, none in the changed files.
• vp fmt --check passes for both files.

Feel free to take the patch as-is or adapt it.

[BenWortley]

Another data point, from 0.0.46-nightly.20261005.2667 (Linux server, Claude provider, orchestrator V2).

The agent opens a PR, links it with link_pull_request, waits for a delegated review task, merges, then reports. The merge happened in a run the user didn't start:

Time (UTC)	Event
09:56:03	User message starts run 1
09:57:54	Run 1 completes
09:59:36	Delegated task's completion notification starts run 2
10:00:24	Agent merges the PR
10:00:35.5	Run 2 completes. The final reply ends with a question for the user
10:00:36.7	thread.settled from server:auto-settle

In older events on the same machine, at least 7 more threads settled while their last reply asked the user something.

The grace rule proposed here covers this case, because the merge falls inside the latest turn. PR #16292 doesn't, because it only waits for runs that carry a user message. For now we have our agents end with AskUserQuestion, since a pending request already blocks settlement.