fix(server): complete the settle-threads adoption

Three follow-ups the cherry-pick did not carry.

#8600 rewrites isUnpublishedBranch to treat a preserved branch.<name>.remote
and .merge pair as evidence the branch was published. That hunk applied to
neither a conflict nor a type error — it simply did not land, leaving the old
remote-refs-only check. Its own test caught it.

With the rewrite in place, Pylon's pruned-branch skip is no longer the right
answer: prune removes the tracking ref but leaves the config, so the branch is
now distinguishable from one that was never published and the lookup should run
rather than fall back to the last-known PR. Pylon's test asserted the saved API
call; it now asserts the live one.

ws.ts keeps upstream's narrowing from parkingCommand back to archiveCommand.
That is not a lost Pylon feature — upstream had parkingCommand too, and #8600
moves settle cleanup into ProviderCommandReactor's thread.settled handler, which
dispatches the same onlyIfSettled stop and also covers settlements with no
client attached.

Author: rynfar

apps/server/src/git/GitManager.test.ts

@@ -1523,6 +1523,19 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => {
                 updatedAt: "2026-04-02T10:00:00Z",
               },
             ]),
+            // @effect-diagnostics-next-line preferSchemaOverJson:off
+            JSON.stringify([
+              {
+                number: 512,
+                title: "Merged then pruned",
+                url: "https://github.com/pingdotgg/t3code/pull/512",
+                baseRefName: "main",
+                headRefName: "feature/merged-then-pruned",
+                state: "MERGED",
+                mergedAt: "2026-04-02T10:00:00Z",
+                updatedAt: "2026-04-02T10:00:00Z",
+              },
+            ]),
           ],
         },
       });
@@ -1532,11 +1545,11 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => {
       expect(first.pr?.state).toBe("merged");
 
       // Merging on the host deletes the remote head, and a prune drops the
-      // remote-tracking ref along with `@{upstream}`. From remote refs alone
-      // that is indistinguishable from a branch that was never published, so
-      // the unpublished-branch skip fires here. Skipping means "we did not
-      // ask", not "there is no PR": blanking the badge would also deny
-      // auto-settle the merged state it waits for.
+      // remote-tracking ref along with `@{upstream}`. #8600 made that
+      // distinguishable from a never-published branch: prune leaves
+      // `branch.<name>.remote` and `.merge` behind as evidence the branch was
+      // published, so the lookup runs instead of skipping and the badge comes
+      // from live state rather than the last-known fallback.
       yield* runGit(repoDir, ["push", "origin", "--delete", "feature/merged-then-pruned"]);
       yield* runGit(repoDir, ["fetch", "--prune", "origin"]);
 
@@ -1545,8 +1558,8 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => {
 
       expect(second.pr?.number).toBe(512);
       expect(second.pr?.state).toBe("merged");
-      // The saved API call is the point of the skip, so it must still be saved.
-      expect(ghCalls.filter((call) => call.startsWith("pr list "))).toHaveLength(1);
+      // The branch is now identifiable as published, so asking again is correct.
+      expect(ghCalls.filter((call) => call.startsWith("pr list "))).toHaveLength(2);
     }),
   );
 

apps/server/src/git/GitManager.ts

@@ -1406,7 +1406,7 @@ export const make = Effect.gen(function* () {
    */
   const isUnpublishedBranch = Effect.fn("isUnpublishedBranch")(function* (
     cwd: string,
-    headContext: Pick<BranchHeadContext, "headBranch">,
+    headContext: Pick<BranchHeadContext, "headBranch" | "localBranch">,
   ) {
     if (headContext.headBranch.length === 0) {
       return false;
@@ -1421,13 +1421,24 @@ export const make = Effect.gen(function* () {
         })
         .pipe(Effect.map((result) => result.stdout.trim().length > 0));
 
-    return yield* Effect.all(
-      [matchesRef("refs/remotes"), matchesRef(`refs/remotes/*/${headContext.headBranch}`)],
-      { concurrency: "unbounded" },
-    ).pipe(
-      Effect.map(([tracksAnyRemote, tracksThisBranch]) => tracksAnyRemote && !tracksThisBranch),
-      Effect.orElseSucceed(() => false),
-    );
+    return yield* Effect.gen(function* () {
+      const [configuredRemote, configuredMerge] = yield* Effect.all(
+        [
+          gitCore.readConfigValue(cwd, `branch.${headContext.localBranch}.remote`),
+          gitCore.readConfigValue(cwd, `branch.${headContext.localBranch}.merge`),
+        ],
+        { concurrency: "unbounded" },
+      );
+      if (configuredRemote !== null && configuredMerge !== null) {
+        return false;
+      }
+
+      const [tracksAnyRemote, tracksThisBranch] = yield* Effect.all(
+        [matchesRef("refs/remotes"), matchesRef(`refs/remotes/*/${headContext.headBranch}`)],
+        { concurrency: "unbounded" },
+      );
+      return tracksAnyRemote && !tracksThisBranch;
+    }).pipe(Effect.orElseSucceed(() => false));
   });
 
   const findOpenPr = Effect.fn("findOpenPr")(function* (

docs/user/thread-sidebar.md

@@ -15,7 +15,7 @@ Each environment owns its automatic settlement settings. The server checks them
 desktop, or mobile client is connected. By default, it settles threads after three days without
 activity and when their pull request merges. An eligible idle thread also settles when its pull
 request closes. An open pull request blocks inactivity settlement. Active work, pending input, and
-live background work keep the thread active. T3 Code settles from a closed or merged pull request
+live background work keep the thread active. Pylon settles from a closed or merged pull request
 only when its timestamp is not older than the user's latest activity. If that timestamp is not
 available, the inactivity rule still applies. A manual un-settle also keeps the thread active.
 Change these rules in **Settings > General** for the environment. A settings change affects future