Fix git status bugs: double normalization, dead code, stale subscriptions, loose typing

- Remove redundant normalizeCwd calls in retainRemotePoller/releaseRemotePoller
  since callers already pass pre-normalized cwd values
- Remove unused enqueueRefreshStatus and associated refreshWorker/import
- Re-subscribe existing watchers when GitStatusClient changes to prevent
  stale UI after WebSocket reconnection
- Add toLocalStatusPart to extract only local fields from GitStatusResult
  in the remoteUpdated case for type-safe merging

Author: cursoragent

apps/server/src/git/Layers/GitStatusBroadcaster.ts

@@ -18,7 +18,6 @@ import type {
   GitStatusRemoteResult,
   GitStatusStreamEvent,
 } from "@t3tools/contracts";
-import { makeKeyedCoalescingWorker } from "@t3tools/shared/KeyedCoalescingWorker";
 import { mergeGitStatusParts } from "@t3tools/shared/git";
 
 import {
@@ -203,23 +202,6 @@ export const GitStatusBroadcasterLive = Layer.effect(
       },
     );
 
-    const refreshWorker = yield* makeKeyedCoalescingWorker<string, void, never, never>({
-      merge: () => undefined,
-      process: (cwd) =>
-        refreshStatus(cwd).pipe(
-          Effect.catchCause((cause) =>
-            Effect.logWarning("git status refresh failed", {
-              cwd,
-              cause,
-            }),
-          ),
-          Effect.asVoid,
-        ),
-    });
-
-    const enqueueRefreshStatus: GitStatusBroadcasterShape["enqueueRefreshStatus"] = (cwd) =>
-      refreshWorker.enqueue(normalizeCwd(cwd), undefined);
-
     const makeRemoteRefreshLoop = (cwd: string) => {
       const logRefreshFailure = (error: Error) =>
         Effect.logWarning("git remote status refresh failed", {
@@ -240,23 +222,22 @@ export const GitStatusBroadcasterLive = Layer.effect(
     };
 
     const retainRemotePoller = Effect.fn("retainRemotePoller")(function* (cwd: string) {
-      const normalizedCwd = normalizeCwd(cwd);
       yield* SynchronizedRef.modifyEffect(pollersRef, (activePollers) => {
-        const existing = activePollers.get(normalizedCwd);
+        const existing = activePollers.get(cwd);
         if (existing) {
           const nextPollers = new Map(activePollers);
-          nextPollers.set(normalizedCwd, {
+          nextPollers.set(cwd, {
             ...existing,
             subscriberCount: existing.subscriberCount + 1,
           });
           return Effect.succeed([undefined, nextPollers] as const);
         }
 
-        return makeRemoteRefreshLoop(normalizedCwd).pipe(
+        return makeRemoteRefreshLoop(cwd).pipe(
           Effect.forkIn(broadcasterScope),
           Effect.map((fiber) => {
             const nextPollers = new Map(activePollers);
-            nextPollers.set(normalizedCwd, {
+            nextPollers.set(cwd, {
               fiber,
               subscriberCount: 1,
             });
@@ -267,24 +248,23 @@ export const GitStatusBroadcasterLive = Layer.effect(
     });
 
     const releaseRemotePoller = Effect.fn("releaseRemotePoller")(function* (cwd: string) {
-      const normalizedCwd = normalizeCwd(cwd);
       const pollerToInterrupt = yield* SynchronizedRef.modify(pollersRef, (activePollers) => {
-        const existing = activePollers.get(normalizedCwd);
+        const existing = activePollers.get(cwd);
         if (!existing) {
           return [null, activePollers] as const;
         }
 
         if (existing.subscriberCount > 1) {
           const nextPollers = new Map(activePollers);
-          nextPollers.set(normalizedCwd, {
+          nextPollers.set(cwd, {
             ...existing,
             subscriberCount: existing.subscriberCount - 1,
           });
           return [null, nextPollers] as const;
         }
 
         const nextPollers = new Map(activePollers);
-        nextPollers.delete(normalizedCwd);
+        nextPollers.delete(cwd);
         return [existing.fiber, nextPollers] as const;
       });
 
@@ -320,7 +300,6 @@ export const GitStatusBroadcasterLive = Layer.effect(
 
     return {
       getStatus,
-      enqueueRefreshStatus,
       refreshStatus,
       streamStatus,
     } satisfies GitStatusBroadcasterShape;

apps/server/src/git/Services/GitStatusBroadcaster.ts

@@ -11,7 +11,6 @@ export interface GitStatusBroadcasterShape {
   readonly getStatus: (
     input: GitStatusInput,
   ) => Effect.Effect<GitStatusResult, GitManagerServiceError>;
-  readonly enqueueRefreshStatus: (cwd: string) => Effect.Effect<void>;
   readonly refreshStatus: (cwd: string) => Effect.Effect<GitStatusResult, GitManagerServiceError>;
   readonly streamStatus: (
     input: GitStatusInput,

apps/web/src/lib/gitStatusState.ts

@@ -147,10 +147,19 @@ function ensureGitStatusClient(client: GitStatusClient): void {
 }
 
 function resetLiveGitStatusSubscriptions(): void {
-  for (const watched of watchedGitStatuses.values()) {
+  const previousCwds = new Map<string, number>();
+  for (const [cwd, watched] of watchedGitStatuses) {
+    previousCwds.set(cwd, watched.refCount);
     watched.unsubscribe();
   }
   watchedGitStatuses.clear();
+
+  for (const [cwd, refCount] of previousCwds) {
+    watchedGitStatuses.set(cwd, {
+      refCount,
+      unsubscribe: subscribeToGitStatus(cwd),
+    });
+  }
 }
 
 function unwatchGitStatus(cwd: string): void {

packages/shared/src/git.ts

@@ -209,6 +209,18 @@ export function mergeGitStatusParts(
   };
 }
 
+function toLocalStatusPart(status: GitStatusResult): GitStatusLocalResult {
+  return {
+    isRepo: status.isRepo,
+    hostingProvider: status.hostingProvider,
+    hasOriginRemote: status.hasOriginRemote,
+    isDefaultBranch: status.isDefaultBranch,
+    branch: status.branch,
+    hasWorkingTreeChanges: status.hasWorkingTreeChanges,
+    workingTree: status.workingTree,
+  };
+}
+
 function toRemoteStatusPart(status: GitStatusResult): GitStatusRemoteResult {
   return {
     hasUpstream: status.hasUpstream,
@@ -241,6 +253,6 @@ export function applyGitStatusStreamEvent(
           event.remote,
         );
       }
-      return mergeGitStatusParts(current, event.remote);
+      return mergeGitStatusParts(toLocalStatusPart(current), event.remote);
   }
 }