Commit 53a552e80d5783c1824a81dbe0d8e49302601e31 | the-knife

apps/server/src/git/Layers/GitCore.test.ts+2-1

 @@ -949,11 +949,12 @@ it.layer(TestLayer)("git integration", (it) => {
         yield* git(source, ["checkout", defaultBranch]);
         yield* git(source, ["branch", "-D", featureBranch]);
-        yield* (yield* GitCore).checkoutBranch({
+        const checkoutResult = yield* (yield* GitCore).checkoutBranch({
           cwd: source,
           branch: `${remoteName}/${featureBranch}`,
         });
+        expect(checkoutResult.branch).toBe("upstream/feature");
         expect(yield* git(source, ["branch", "--show-current"])).toBe("upstream/feature");
         const realGitCore = yield* GitCore;
         let fetchArgs: readonly string[] | null = null;

apps/server/src/git/Layers/GitCore.ts+32-9

 @@ -1177,9 +1177,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
     return branchLastCommit;
   });
-  const statusDetails: GitCoreShape["statusDetails"] = Effect.fn("statusDetails")(function* (cwd) {
+  const readStatusDetailsLocal = Effect.fn("readStatusDetailsLocal")(function* (cwd: string) {
-    yield* refreshStatusUpstreamIfStale(cwd).pipe(Effect.ignoreCause({ log: true }));
     const statusResult = yield* executeGit(
       "GitCore.statusDetails.status",
       cwd,
 @@ -1312,6 +1310,17 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
     };
   });
+  const statusDetailsLocal: GitCoreShape["statusDetailsLocal"] = Effect.fn("statusDetailsLocal")(
+    function* (cwd) {
+      return yield* readStatusDetailsLocal(cwd);
+    },
+  );
+  const statusDetails: GitCoreShape["statusDetails"] = Effect.fn("statusDetails")(function* (cwd) {
+    yield* refreshStatusUpstreamIfStale(cwd).pipe(Effect.ignoreCause({ log: true }));
+    return yield* readStatusDetailsLocal(cwd);
+  });
   const status: GitCoreShape["status"] = (input) =>
     statusDetails(input.cwd).pipe(
       Effect.map((details) => ({
 @@ -2000,12 +2009,6 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
     return { branch: targetBranch };
   });
-  const createBranch: GitCoreShape["createBranch"] = (input) =>
-    executeGit("GitCore.createBranch", input.cwd, ["branch", input.branch], {
-      timeoutMs: 10_000,
-      fallbackErrorMessage: "git branch create failed",
-    }).pipe(Effect.asVoid);
   const checkoutBranch: GitCoreShape["checkoutBranch"] = Effect.fn("checkoutBranch")(
     function* (input) {
       const [localInputExists, remoteExists] = yield* Effect.all(
 @@ -2078,9 +2081,28 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
         timeoutMs: 10_000,
         fallbackErrorMessage: "git checkout failed",
       });
+      const branch = yield* runGitStdout("GitCore.checkoutBranch.currentBranch", input.cwd, [
+        "branch",
+        "--show-current",
+      ]).pipe(Effect.map((stdout) => stdout.trim() || null));
+      return { branch };
     },
   );
+  const createBranch: GitCoreShape["createBranch"] = Effect.fn("createBranch")(function* (input) {
+    yield* executeGit("GitCore.createBranch", input.cwd, ["branch", input.branch], {
+      timeoutMs: 10_000,
+      fallbackErrorMessage: "git branch create failed",
+    });
+    if (input.checkout) {
+      yield* checkoutBranch({ cwd: input.cwd, branch: input.branch });
+    }
+    return { branch: input.branch };
+  });
   const initRepo: GitCoreShape["initRepo"] = (input) =>
     executeGit("GitCore.initRepo", input.cwd, ["init"], {
       timeoutMs: 10_000,
 @@ -2106,6 +2128,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {
     execute,
     status,
     statusDetails,
+    statusDetailsLocal,
     prepareCommitContext,
     commit,
     pushCurrentBranch,

apps/server/src/git/Layers/GitManager.ts+104-32

 @@ -8,9 +8,13 @@ import {
   GitCommandError,
   GitRunStackedActionResult,
   GitStackedAction,
+  type GitStatusLocalResult,
+  type GitStatusRemoteResult,
   ModelSelection,
 } from "@t3tools/contracts";
 import {
+  detectGitHostingProviderFromRemoteUrl,
+  mergeGitStatusParts,
   resolveAutoFeatureBranchName,
   sanitizeBranchFragment,
   sanitizeFeatureBranchName,
 @@ -695,26 +699,55 @@ export const makeGitManager = Effect.fn("makeGitManager")(function* () {
   const tempDir = process.env.TMPDIR ?? process.env.TEMP ?? process.env.TMP ?? "/tmp";
   const normalizeStatusCacheKey = (cwd: string) => canonicalizeExistingPath(cwd);
-  const readStatus = Effect.fn("readStatus")(function* (cwd: string) {
+  const nonRepositoryStatusDetails = {
-    const details = yield* gitCore.statusDetails(cwd).pipe(
+    isRepo: false,
-      Effect.catchIf(isNotGitRepositoryError, () =>
+    hasOriginRemote: false,
-        Effect.succeed({
+    isDefaultBranch: false,
-          isRepo: false,
+    branch: null,
-          hasOriginRemote: false,
+    upstreamRef: null,
-          isDefaultBranch: false,
+    hasWorkingTreeChanges: false,
-          branch: null,
+    workingTree: { files: [], insertions: 0, deletions: 0 },
-          upstreamRef: null,
+    hasUpstream: false,
-          hasWorkingTreeChanges: false,
+    aheadCount: 0,
-          workingTree: { files: [], insertions: 0, deletions: 0 },
+    behindCount: 0,
-          hasUpstream: false,
+  } satisfies GitStatusDetails;
-          aheadCount: 0,
+  const readLocalStatus = Effect.fn("readLocalStatus")(function* (cwd: string) {
-          behindCount: 0,
+    const details = yield* gitCore
-        } satisfies GitStatusDetails),
+      .statusDetailsLocal(cwd)
-      ),
+      .pipe(
-    );
+        Effect.catchIf(isNotGitRepositoryError, () => Effect.succeed(nonRepositoryStatusDetails)),
+      );
+    const hostingProvider = details.isRepo
+      ? yield* resolveHostingProvider(cwd, details.branch)
+      : null;
+    return {
+      isRepo: details.isRepo,
+      ...(hostingProvider ? { hostingProvider } : {}),
+      hasOriginRemote: details.hasOriginRemote,
+      isDefaultBranch: details.isDefaultBranch,
+      branch: details.branch,
+      hasWorkingTreeChanges: details.hasWorkingTreeChanges,
+      workingTree: details.workingTree,
+    } satisfies GitStatusLocalResult;
+  });
+  const localStatusResultCache = yield* Cache.makeWith({
+    capacity: STATUS_RESULT_CACHE_CAPACITY,
+    lookup: readLocalStatus,
+    timeToLive: (exit) => (Exit.isSuccess(exit) ? STATUS_RESULT_CACHE_TTL : Duration.zero),
+  });
+  const invalidateLocalStatusResultCache = (cwd: string) =>
+    Cache.invalidate(localStatusResultCache, normalizeStatusCacheKey(cwd));
+  const readRemoteStatus = Effect.fn("readRemoteStatus")(function* (cwd: string) {
+    const details = yield* gitCore
+      .statusDetails(cwd)
+      .pipe(Effect.catchIf(isNotGitRepositoryError, () => Effect.succeed(null)));
+    if (details === null || !details.isRepo) {
+      return null;
+    }
     const pr =
-      details.isRepo && details.branch !== null
+      details.branch !== null
         ? yield* findLatestPr(cwd, {
             branch: details.branch,
             upstreamRef: details.upstreamRef,
 @@ -725,29 +758,38 @@ export const makeGitManager = Effect.fn("makeGitManager")(function* () {
         : null;
     return {
-      isRepo: details.isRepo,
-      hasOriginRemote: details.hasOriginRemote,
-      isDefaultBranch: details.isDefaultBranch,
-      branch: details.branch,
-      hasWorkingTreeChanges: details.hasWorkingTreeChanges,
-      workingTree: details.workingTree,
       hasUpstream: details.hasUpstream,
       aheadCount: details.aheadCount,
       behindCount: details.behindCount,
       pr,
-    };
+    } satisfies GitStatusRemoteResult;
   });
-  const statusResultCache = yield* Cache.makeWith({
+  const remoteStatusResultCache = yield* Cache.makeWith({
     capacity: STATUS_RESULT_CACHE_CAPACITY,
-    lookup: readStatus,
+    lookup: readRemoteStatus,
     timeToLive: (exit) => (Exit.isSuccess(exit) ? STATUS_RESULT_CACHE_TTL : Duration.zero),
   });
-  const invalidateStatusResultCache = (cwd: string) =>
+  const invalidateRemoteStatusResultCache = (cwd: string) =>
-    Cache.invalidate(statusResultCache, normalizeStatusCacheKey(cwd));
+    Cache.invalidate(remoteStatusResultCache, normalizeStatusCacheKey(cwd));
   const readConfigValueNullable = (cwd: string, key: string) =>
     gitCore.readConfigValue(cwd, key).pipe(Effect.catch(() => Effect.succeed(null)));
+  const resolveHostingProvider = Effect.fn("resolveHostingProvider")(function* (
+    cwd: string,
+    branch: string | null,
+  ) {
+    const preferredRemoteName =
+      branch === null
+        ? "origin"
+        : ((yield* readConfigValueNullable(cwd, `branch.${branch}.remote`)) ?? "origin");
+    const remoteUrl =
+      (yield* readConfigValueNullable(cwd, `remote.${preferredRemoteName}.url`)) ??
+      (yield* readConfigValueNullable(cwd, "remote.origin.url"));
+    return remoteUrl ? detectGitHostingProviderFromRemoteUrl(remoteUrl) : null;
+  });
   const resolveRemoteRepositoryContext = Effect.fn("resolveRemoteRepositoryContext")(function* (
     cwd: string,
     remoteName: string | null,
 @@ -1311,9 +1353,34 @@ export const makeGitManager = Effect.fn("makeGitManager")(function* () {
     };
   });
+  const localStatus: GitManagerShape["localStatus"] = Effect.fn("localStatus")(function* (input) {
+    return yield* Cache.get(localStatusResultCache, normalizeStatusCacheKey(input.cwd));
+  });
+  const remoteStatus: GitManagerShape["remoteStatus"] = Effect.fn("remoteStatus")(
+    function* (input) {
+      return yield* Cache.get(remoteStatusResultCache, normalizeStatusCacheKey(input.cwd));
+    },
+  );
   const status: GitManagerShape["status"] = Effect.fn("status")(function* (input) {
-    return yield* Cache.get(statusResultCache, normalizeStatusCacheKey(input.cwd));
+    const [local, remote] = yield* Effect.all([localStatus(input), remoteStatus(input)]);
+    return mergeGitStatusParts(local, remote);
   });
+  const invalidateLocalStatus: GitManagerShape["invalidateLocalStatus"] = Effect.fn(
+    "invalidateLocalStatus",
+  )(function* (cwd) {
+    yield* invalidateLocalStatusResultCache(cwd);
+  });
+  const invalidateRemoteStatus: GitManagerShape["invalidateRemoteStatus"] = Effect.fn(
+    "invalidateRemoteStatus",
+  )(function* (cwd) {
+    yield* invalidateRemoteStatusResultCache(cwd);
+  });
+  const invalidateStatus: GitManagerShape["invalidateStatus"] = Effect.fn("invalidateStatus")(
+    function* (cwd) {
+      yield* invalidateLocalStatusResultCache(cwd);
+      yield* invalidateRemoteStatusResultCache(cwd);
+    },
+  );
   const resolvePullRequest: GitManagerShape["resolvePullRequest"] = Effect.fn("resolvePullRequest")(
     function* (input) {
 @@ -1488,7 +1555,7 @@ export const makeGitManager = Effect.fn("makeGitManager")(function* () {
         branch: worktree.worktree.branch,
         worktreePath: worktree.worktree.path,
       };
-    }).pipe(Effect.ensuring(invalidateStatusResultCache(input.cwd)));
+    }).pipe(Effect.ensuring(invalidateStatus(input.cwd)));
   });
   const runFeatureBranchStep = Effect.fn("runFeatureBranchStep")(function* (
 @@ -1692,7 +1759,7 @@ export const makeGitManager = Effect.fn("makeGitManager")(function* () {
       });
       return yield* runAction().pipe(
-        Effect.ensuring(invalidateStatusResultCache(input.cwd)),
+        Effect.ensuring(invalidateStatus(input.cwd)),
         Effect.tapError((error) =>
           Effect.flatMap(Ref.get(currentPhase), (phase) =>
             progress.emit({
 @@ -1707,7 +1774,12 @@ export const makeGitManager = Effect.fn("makeGitManager")(function* () {
   );
   return {
+    localStatus,
+    remoteStatus,
     status,
+    invalidateLocalStatus,
+    invalidateRemoteStatus,
+    invalidateStatus,
     resolvePullRequest,
     preparePullRequestThread,
     runStackedAction,

apps/server/src/git/Layers/GitStatusBroadcaster.test.ts created+276

...	@@ -0,0 +1,276 @@
1	import { assert, it } from "@effect/vitest";
2	import { Deferred, Effect, Exit, Layer, Option, Scope, Stream } from "effect";
3	import type {
4	GitStatusLocalResult,
5	GitStatusRemoteResult,
6	GitStatusResult,
7	GitStatusStreamEvent,
8	} from "@t3tools/contracts";
9	import { describe } from "vitest";
10
11	import { GitStatusBroadcaster } from "../Services/GitStatusBroadcaster.ts";
12	import { GitStatusBroadcasterLive } from "./GitStatusBroadcaster.ts";
13	import { type GitManagerShape, GitManager } from "../Services/GitManager.ts";
14
15	const baseLocalStatus: GitStatusLocalResult = {
16	isRepo: true,
17	hostingProvider: {
18	kind: "github",
19	name: "GitHub",
20	baseUrl: "https://github.com",
21	},
22	hasOriginRemote: true,
23	isDefaultBranch: false,
24	branch: "feature/status-broadcast",
25	hasWorkingTreeChanges: false,
26	workingTree: { files: [], insertions: 0, deletions: 0 },
27	};
28
29	const baseRemoteStatus: GitStatusRemoteResult = {
30	hasUpstream: true,
31	aheadCount: 0,
32	behindCount: 0,
33	pr: null,
34	};
35
36	const baseStatus: GitStatusResult = {
37	...baseLocalStatus,
38	...baseRemoteStatus,
39	};
40
41	function makeTestLayer(state: {
42	currentLocalStatus: GitStatusLocalResult;
43	currentRemoteStatus: GitStatusRemoteResult \| null;
44	localStatusCalls: number;
45	remoteStatusCalls: number;
46	localInvalidationCalls: number;
47	remoteInvalidationCalls: number;
48	}) {
49	const gitManager: GitManagerShape = {
50	localStatus: () =>
51	Effect.sync(() => {
52	state.localStatusCalls += 1;
53	return state.currentLocalStatus;
54	}),
55	remoteStatus: () =>
56	Effect.sync(() => {
57	state.remoteStatusCalls += 1;
58	return state.currentRemoteStatus;
59	}),
60	status: () => Effect.die("status should not be called in this test"),
61	invalidateLocalStatus: () =>
62	Effect.sync(() => {
63	state.localInvalidationCalls += 1;
64	}),
65	invalidateRemoteStatus: () =>
66	Effect.sync(() => {
67	state.remoteInvalidationCalls += 1;
68	}),
69	invalidateStatus: () => Effect.die("invalidateStatus should not be called in this test"),
70	resolvePullRequest: () => Effect.die("resolvePullRequest should not be called in this test"),
71	preparePullRequestThread: () =>
72	Effect.die("preparePullRequestThread should not be called in this test"),
73	runStackedAction: () => Effect.die("runStackedAction should not be called in this test"),
74	};
75
76	return GitStatusBroadcasterLive.pipe(Layer.provide(Layer.succeed(GitManager, gitManager)));
77	}
78
79	describe("GitStatusBroadcasterLive", () => {
80	it.effect("reuses the cached git status across repeated reads", () => {
81	const state = {
82	currentLocalStatus: baseLocalStatus,
83	currentRemoteStatus: baseRemoteStatus,
84	localStatusCalls: 0,
85	remoteStatusCalls: 0,
86	localInvalidationCalls: 0,
87	remoteInvalidationCalls: 0,
88	};
89
90	return Effect.gen(function* () {
91	const broadcaster = yield* GitStatusBroadcaster;
92
93	const first = yield* broadcaster.getStatus({ cwd: "/repo" });
94	const second = yield* broadcaster.getStatus({ cwd: "/repo" });
95
96	assert.deepStrictEqual(first, baseStatus);
97	assert.deepStrictEqual(second, baseStatus);
98	assert.equal(state.localStatusCalls, 1);
99	assert.equal(state.remoteStatusCalls, 1);
100	assert.equal(state.localInvalidationCalls, 0);
101	assert.equal(state.remoteInvalidationCalls, 0);
102	}).pipe(Effect.provide(makeTestLayer(state)));
103	});
104
105	it.effect("refreshes the cached snapshot after explicit invalidation", () => {
106	const state = {
107	currentLocalStatus: baseLocalStatus,
108	currentRemoteStatus: baseRemoteStatus,
109	localStatusCalls: 0,
110	remoteStatusCalls: 0,
111	localInvalidationCalls: 0,
112	remoteInvalidationCalls: 0,
113	};
114
115	return Effect.gen(function* () {
116	const broadcaster = yield* GitStatusBroadcaster;
117	const initial = yield* broadcaster.getStatus({ cwd: "/repo" });
118
119	state.currentLocalStatus = {
120	...baseLocalStatus,
121	branch: "feature/updated-status",
122	};
123	state.currentRemoteStatus = {
124	...baseRemoteStatus,
125	aheadCount: 2,
126	};
127	const refreshed = yield* broadcaster.refreshStatus("/repo");
128	const cached = yield* broadcaster.getStatus({ cwd: "/repo" });
129
130	assert.deepStrictEqual(initial, baseStatus);
131	assert.deepStrictEqual(refreshed, {
132	...state.currentLocalStatus,
133	...state.currentRemoteStatus,
134	});
135	assert.deepStrictEqual(cached, {
136	...state.currentLocalStatus,
137	...state.currentRemoteStatus,
138	});
139	assert.equal(state.localStatusCalls, 2);
140	assert.equal(state.remoteStatusCalls, 2);
141	assert.equal(state.localInvalidationCalls, 1);
142	assert.equal(state.remoteInvalidationCalls, 1);
143	}).pipe(Effect.provide(makeTestLayer(state)));
144	});
145
146	it.effect("streams a local snapshot first and remote updates later", () => {
147	const state = {
148	currentLocalStatus: baseLocalStatus,
149	currentRemoteStatus: baseRemoteStatus,
150	localStatusCalls: 0,
151	remoteStatusCalls: 0,
152	localInvalidationCalls: 0,
153	remoteInvalidationCalls: 0,
154	};
155
156	return Effect.gen(function* () {
157	const broadcaster = yield* GitStatusBroadcaster;
158	const snapshotDeferred = yield* Deferred.make<GitStatusStreamEvent>();
159	const remoteUpdatedDeferred = yield* Deferred.make<GitStatusStreamEvent>();
160	yield* Stream.runForEach(broadcaster.streamStatus({ cwd: "/repo" }), (event) => {
161	if (event._tag === "snapshot") {
162	return Deferred.succeed(snapshotDeferred, event).pipe(Effect.ignore);
163	}
164	if (event._tag === "remoteUpdated") {
165	return Deferred.succeed(remoteUpdatedDeferred, event).pipe(Effect.ignore);
166	}
167	return Effect.void;
168	}).pipe(Effect.forkScoped);
169
170	const snapshot = yield* Deferred.await(snapshotDeferred);
171	yield* broadcaster.refreshStatus("/repo");
172	const remoteUpdated = yield* Deferred.await(remoteUpdatedDeferred);
173
174	assert.deepStrictEqual(snapshot, {
175	_tag: "snapshot",
176	local: baseLocalStatus,
177	remote: null,
178	} satisfies GitStatusStreamEvent);
179	assert.deepStrictEqual(remoteUpdated, {
180	_tag: "remoteUpdated",
181	remote: baseRemoteStatus,
182	} satisfies GitStatusStreamEvent);
183	}).pipe(Effect.provide(makeTestLayer(state)));
184	});
185
186	it.effect("stops the remote poller after the last stream subscriber disconnects", () => {
187	const state = {
188	currentLocalStatus: baseLocalStatus,
189	currentRemoteStatus: baseRemoteStatus,
190	localStatusCalls: 0,
191	remoteStatusCalls: 0,
192	localInvalidationCalls: 0,
193	remoteInvalidationCalls: 0,
194	};
195	let remoteInterruptedDeferred: Deferred.Deferred<void, never> \| null = null;
196	let remoteStartedDeferred: Deferred.Deferred<void, never> \| null = null;
197	const testLayer = GitStatusBroadcasterLive.pipe(
198	Layer.provide(
199	Layer.succeed(GitManager, {
200	localStatus: () =>
201	Effect.sync(() => {
202	state.localStatusCalls += 1;
203	return state.currentLocalStatus;
204	}),
205	remoteStatus: () =>
206	Effect.sync(() => {
207	state.remoteStatusCalls += 1;
208	}).pipe(
209	Effect.andThen(
210	remoteStartedDeferred
211	? Deferred.succeed(remoteStartedDeferred, undefined).pipe(Effect.ignore)
212	: Effect.void,
213	),
214	Effect.andThen(Effect.never as Effect.Effect<GitStatusRemoteResult \| null, never>),
215	Effect.onInterrupt(() =>
216	remoteInterruptedDeferred
217	? Deferred.succeed(remoteInterruptedDeferred, undefined).pipe(Effect.ignore)
218	: Effect.void,
219	),
220	),
221	status: () => Effect.die("status should not be called in this test"),
222	invalidateLocalStatus: () =>
223	Effect.sync(() => {
224	state.localInvalidationCalls += 1;
225	}),
226	invalidateRemoteStatus: () =>
227	Effect.sync(() => {
228	state.remoteInvalidationCalls += 1;
229	}),
230	invalidateStatus: () => Effect.die("invalidateStatus should not be called in this test"),
231	resolvePullRequest: () =>
232	Effect.die("resolvePullRequest should not be called in this test"),
233	preparePullRequestThread: () =>
234	Effect.die("preparePullRequestThread should not be called in this test"),
235	runStackedAction: () => Effect.die("runStackedAction should not be called in this test"),
236	} satisfies GitManagerShape),
237	),
238	);
239
240	return Effect.gen(function* () {
241	const remoteInterrupted = yield* Deferred.make<void>();
242	const remoteStarted = yield* Deferred.make<void>();
243	remoteInterruptedDeferred = remoteInterrupted;
244	remoteStartedDeferred = remoteStarted;
245
246	const broadcaster = yield* GitStatusBroadcaster;
247	const firstSnapshot = yield* Deferred.make<GitStatusStreamEvent>();
248	const secondSnapshot = yield* Deferred.make<GitStatusStreamEvent>();
249	const firstScope = yield* Scope.make();
250	const secondScope = yield* Scope.make();
251	yield* Stream.runForEach(broadcaster.streamStatus({ cwd: "/repo" }), (event) =>
252	event._tag === "snapshot"
253	? Deferred.succeed(firstSnapshot, event).pipe(Effect.ignore)
254	: Effect.void,
255	).pipe(Effect.forkIn(firstScope));
256	yield* Stream.runForEach(broadcaster.streamStatus({ cwd: "/repo" }), (event) =>
257	event._tag === "snapshot"
258	? Deferred.succeed(secondSnapshot, event).pipe(Effect.ignore)
259	: Effect.void,
260	).pipe(Effect.forkIn(secondScope));
261
262	yield* Deferred.await(firstSnapshot);
263	yield* Deferred.await(secondSnapshot);
264	yield* Deferred.await(remoteStarted);
265
266	assert.equal(state.remoteStatusCalls, 1);
267
268	yield* Scope.close(firstScope, Exit.void);
269	assert.equal(Option.isNone(yield* Deferred.poll(remoteInterrupted)), true);
270
271	yield* Scope.close(secondScope, Exit.void).pipe(Effect.forkScoped);
272	yield* Deferred.await(remoteInterrupted);
273	assert.equal(Option.isSome(yield* Deferred.poll(remoteInterrupted)), true);
274	}).pipe(Effect.provide(testLayer));
275	});
276	});

apps/server/src/git/Layers/GitStatusBroadcaster.ts created+307

...	@@ -0,0 +1,307 @@
1	import { realpathSync } from "node:fs";
2
3	import {
4	Duration,
5	Effect,
6	Exit,
7	Fiber,
8	Layer,
9	PubSub,
10	Ref,
11	Scope,
12	Stream,
13	SynchronizedRef,
14	} from "effect";
15	import type {
16	GitStatusInput,
17	GitStatusLocalResult,
18	GitStatusRemoteResult,
19	GitStatusStreamEvent,
20	} from "@t3tools/contracts";
21	import { mergeGitStatusParts } from "@t3tools/shared/git";
22
23	import {
24	GitStatusBroadcaster,
25	type GitStatusBroadcasterShape,
26	} from "../Services/GitStatusBroadcaster.ts";
27	import { GitManager } from "../Services/GitManager.ts";
28
29	const GIT_STATUS_REFRESH_INTERVAL = Duration.seconds(30);
30
31	interface GitStatusChange {
32	readonly cwd: string;
33	readonly event: GitStatusStreamEvent;
34	}
35
36	interface CachedValue<T> {
37	readonly fingerprint: string;
38	readonly value: T;
39	}
40
41	interface CachedGitStatus {
42	readonly local: CachedValue<GitStatusLocalResult> \| null;
43	readonly remote: CachedValue<GitStatusRemoteResult \| null> \| null;
44	}
45
46	interface ActiveRemotePoller {
47	readonly fiber: Fiber.Fiber<void, never>;
48	readonly subscriberCount: number;
49	}
50
51	function normalizeCwd(cwd: string): string {
52	try {
53	return realpathSync.native(cwd);
54	} catch {
55	return cwd;
56	}
57	}
58
59	function fingerprintStatusPart(status: unknown): string {
60	return JSON.stringify(status);
61	}
62
63	export const GitStatusBroadcasterLive = Layer.effect(
64	GitStatusBroadcaster,
65	Effect.gen(function* () {
66	const gitManager = yield* GitManager;
67	const changesPubSub = yield* Effect.acquireRelease(
68	PubSub.unbounded<GitStatusChange>(),
69	(pubsub) => PubSub.shutdown(pubsub),
70	);
71	const broadcasterScope = yield* Effect.acquireRelease(Scope.make(), (scope) =>
72	Scope.close(scope, Exit.void),
73	);
74	const cacheRef = yield* Ref.make(new Map<string, CachedGitStatus>());
75	const pollersRef = yield* SynchronizedRef.make(new Map<string, ActiveRemotePoller>());
76
77	const getCachedStatus = Effect.fn("getCachedStatus")(function* (cwd: string) {
78	return yield* Ref.get(cacheRef).pipe(Effect.map((cache) => cache.get(cwd) ?? null));
79	});
80
81	const updateCachedLocalStatus = Effect.fn("updateCachedLocalStatus")(function* (
82	cwd: string,
83	local: GitStatusLocalResult,
84	options?: { publish?: boolean },
85	) {
86	const nextLocal = {
87	fingerprint: fingerprintStatusPart(local),
88	value: local,
89	} satisfies CachedValue<GitStatusLocalResult>;
90	const shouldPublish = yield* Ref.modify(cacheRef, (cache) => {
91	const previous = cache.get(cwd) ?? { local: null, remote: null };
92	const nextCache = new Map(cache);
93	nextCache.set(cwd, {
94	...previous,
95	local: nextLocal,
96	});
97	return [previous.local?.fingerprint !== nextLocal.fingerprint, nextCache] as const;
98	});
99
100	if (options?.publish && shouldPublish) {
101	yield* PubSub.publish(changesPubSub, {
102	cwd,
103	event: {
104	_tag: "localUpdated",
105	local,
106	},
107	});
108	}
109
110	return local;
111	});
112
113	const updateCachedRemoteStatus = Effect.fn("updateCachedRemoteStatus")(function* (
114	cwd: string,
115	remote: GitStatusRemoteResult \| null,
116	options?: { publish?: boolean },
117	) {
118	const nextRemote = {
119	fingerprint: fingerprintStatusPart(remote),
120	value: remote,
121	} satisfies CachedValue<GitStatusRemoteResult \| null>;
122	const shouldPublish = yield* Ref.modify(cacheRef, (cache) => {
123	const previous = cache.get(cwd) ?? { local: null, remote: null };
124	const nextCache = new Map(cache);
125	nextCache.set(cwd, {
126	...previous,
127	remote: nextRemote,
128	});
129	return [previous.remote?.fingerprint !== nextRemote.fingerprint, nextCache] as const;
130	});
131
132	if (options?.publish && shouldPublish) {
133	yield* PubSub.publish(changesPubSub, {
134	cwd,
135	event: {
136	_tag: "remoteUpdated",
137	remote,
138	},
139	});
140	}
141
142	return remote;
143	});
144
145	const loadLocalStatus = Effect.fn("loadLocalStatus")(function* (cwd: string) {
146	const local = yield* gitManager.localStatus({ cwd });
147	return yield* updateCachedLocalStatus(cwd, local);
148	});
149
150	const loadRemoteStatus = Effect.fn("loadRemoteStatus")(function* (cwd: string) {
151	const remote = yield* gitManager.remoteStatus({ cwd });
152	return yield* updateCachedRemoteStatus(cwd, remote);
153	});
154
155	const getOrLoadLocalStatus = Effect.fn("getOrLoadLocalStatus")(function* (cwd: string) {
156	const cached = yield* getCachedStatus(cwd);
157	if (cached?.local) {
158	return cached.local.value;
159	}
160	return yield* loadLocalStatus(cwd);
161	});
162
163	const getOrLoadRemoteStatus = Effect.fn("getOrLoadRemoteStatus")(function* (cwd: string) {
164	const cached = yield* getCachedStatus(cwd);
165	if (cached?.remote) {
166	return cached.remote.value;
167	}
168	return yield* loadRemoteStatus(cwd);
169	});
170
171	const getStatus: GitStatusBroadcasterShape["getStatus"] = Effect.fn("getStatus")(function* (
172	input: GitStatusInput,
173	) {
174	const normalizedCwd = normalizeCwd(input.cwd);
175	const [local, remote] = yield* Effect.all([
176	getOrLoadLocalStatus(normalizedCwd),
177	getOrLoadRemoteStatus(normalizedCwd),
178	]);
179	return mergeGitStatusParts(local, remote);
180	});
181
182	const refreshLocalStatus = Effect.fn("refreshLocalStatus")(function* (cwd: string) {
183	yield* gitManager.invalidateLocalStatus(cwd);
184	const local = yield* gitManager.localStatus({ cwd });
185	return yield* updateCachedLocalStatus(cwd, local, { publish: true });
186	});
187
188	const refreshRemoteStatus = Effect.fn("refreshRemoteStatus")(function* (cwd: string) {
189	yield* gitManager.invalidateRemoteStatus(cwd);
190	const remote = yield* gitManager.remoteStatus({ cwd });
191	return yield* updateCachedRemoteStatus(cwd, remote, { publish: true });
192	});
193
194	const refreshStatus: GitStatusBroadcasterShape["refreshStatus"] = Effect.fn("refreshStatus")(
195	function* (cwd) {
196	const normalizedCwd = normalizeCwd(cwd);
197	const [local, remote] = yield* Effect.all([
198	refreshLocalStatus(normalizedCwd),
199	refreshRemoteStatus(normalizedCwd),
200	]);
201	return mergeGitStatusParts(local, remote);
202	},
203	);
204
205	const makeRemoteRefreshLoop = (cwd: string) => {
206	const logRefreshFailure = (error: Error) =>
207	Effect.logWarning("git remote status refresh failed", {
208	cwd,
209	detail: error.message,
210	});
211
212	return refreshRemoteStatus(cwd).pipe(
213	Effect.catch(logRefreshFailure),
214	Effect.andThen(
215	Effect.forever(
216	Effect.sleep(GIT_STATUS_REFRESH_INTERVAL).pipe(
217	Effect.andThen(refreshRemoteStatus(cwd).pipe(Effect.catch(logRefreshFailure))),
218	),
219	),
220	),
221	);
222	};
223
224	const retainRemotePoller = Effect.fn("retainRemotePoller")(function* (cwd: string) {
225	yield* SynchronizedRef.modifyEffect(pollersRef, (activePollers) => {
226	const existing = activePollers.get(cwd);
227	if (existing) {
228	const nextPollers = new Map(activePollers);
229	nextPollers.set(cwd, {
230	...existing,
231	subscriberCount: existing.subscriberCount + 1,
232	});
233	return Effect.succeed([undefined, nextPollers] as const);
234	}
235
236	return makeRemoteRefreshLoop(cwd).pipe(
237	Effect.forkIn(broadcasterScope),
238	Effect.map((fiber) => {
239	const nextPollers = new Map(activePollers);
240	nextPollers.set(cwd, {
241	fiber,
242	subscriberCount: 1,
243	});
244	return [undefined, nextPollers] as const;
245	}),
246	);
247	});
248	});
249
250	const releaseRemotePoller = Effect.fn("releaseRemotePoller")(function* (cwd: string) {
251	const pollerToInterrupt = yield* SynchronizedRef.modify(pollersRef, (activePollers) => {
252	const existing = activePollers.get(cwd);
253	if (!existing) {
254	return [null, activePollers] as const;
255	}
256
257	if (existing.subscriberCount > 1) {
258	const nextPollers = new Map(activePollers);
259	nextPollers.set(cwd, {
260	...existing,
261	subscriberCount: existing.subscriberCount - 1,
262	});
263	return [null, nextPollers] as const;
264	}
265
266	const nextPollers = new Map(activePollers);
267	nextPollers.delete(cwd);
268	return [existing.fiber, nextPollers] as const;
269	});
270
271	if (pollerToInterrupt) {
272	yield* Fiber.interrupt(pollerToInterrupt).pipe(Effect.ignore);
273	}
274	});
275
276	const streamStatus: GitStatusBroadcasterShape["streamStatus"] = (input) =>
277	Stream.unwrap(
278	Effect.gen(function* () {
279	const normalizedCwd = normalizeCwd(input.cwd);
280	const subscription = yield* PubSub.subscribe(changesPubSub);
281	const initialLocal = yield* getOrLoadLocalStatus(normalizedCwd);
282	const initialRemote = (yield* getCachedStatus(normalizedCwd))?.remote?.value ?? null;
283	yield* retainRemotePoller(normalizedCwd);
284
285	const release = releaseRemotePoller(normalizedCwd).pipe(Effect.ignore, Effect.asVoid);
286
287	return Stream.concat(
288	Stream.make({
289	_tag: "snapshot" as const,
290	local: initialLocal,
291	remote: initialRemote,
292	}),
293	Stream.fromSubscription(subscription).pipe(
294	Stream.filter((event) => event.cwd === normalizedCwd),
295	Stream.map((event) => event.event),
296	),
297	).pipe(Stream.ensuring(release));
298	}),
299	);
300
301	return {
302	getStatus,
303	refreshStatus,
304	streamStatus,
305	} satisfies GitStatusBroadcasterShape;
306	}),
307	);

apps/server/src/git/Services/GitCore.ts+12-3

 @@ -7,10 +7,12 @@
  * @module GitCore
  */
 import { ServiceMap } from "effect";
-import type { Effect, Scope } from "effect";
+import type { Effect } from "effect";
 import type {
   GitCheckoutInput,
+  GitCheckoutResult,
   GitCreateBranchInput,
+  GitCreateBranchResult,
   GitCreateWorktreeInput,
   GitCreateWorktreeResult,
   GitInitInput,
 @@ -156,6 +158,11 @@ export interface GitCoreShape {
    */
   readonly statusDetails: (cwd: string) => Effect.Effect<GitStatusDetails, GitCommandError>;
+  /**
+   * Read detailed working tree / branch status without refreshing remote tracking refs.
+   */
+  readonly statusDetailsLocal: (cwd: string) => Effect.Effect<GitStatusDetails, GitCommandError>;
   /**
    * Build staged change context for commit generation.
    */
 @@ -278,14 +285,16 @@ export interface GitCoreShape {
   /**
    * Create a local branch.
    */
-  readonly createBranch: (input: GitCreateBranchInput) => Effect.Effect<void, GitCommandError>;
+  readonly createBranch: (
+    input: GitCreateBranchInput,
+  ) => Effect.Effect<GitCreateBranchResult, GitCommandError>;
   /**
    * Checkout an existing branch and refresh its upstream metadata in background.
    */
   readonly checkoutBranch: (
     input: GitCheckoutInput,
-  ) => Effect.Effect<void, GitCommandError, Scope.Scope>;
+  ) => Effect.Effect<GitCheckoutResult, GitCommandError>;
   /**
    * Initialize a repository in the provided directory.

apps/server/src/git/Services/GitManager.ts+31

...	@@ -14,6 +14,8 @@ import {	...	@@ -14,6 +14,8 @@ import {
14	GitResolvePullRequestResult,	14	GitResolvePullRequestResult,
15	GitRunStackedActionInput,	15	GitRunStackedActionInput,
16	GitRunStackedActionResult,	16	GitRunStackedActionResult,
		17	GitStatusLocalResult,
		18	GitStatusRemoteResult,
17	GitStatusInput,	19	GitStatusInput,
18	GitStatusResult,	20	GitStatusResult,
19	} from "@t3tools/contracts";	21	} from "@t3tools/contracts";
...	@@ -41,6 +43,35 @@ export interface GitManagerShape {	...	@@ -41,6 +43,35 @@ export interface GitManagerShape {
41	input: GitStatusInput,	43	input: GitStatusInput,
42	) => Effect.Effect<GitStatusResult, GitManagerServiceError>;	44	) => Effect.Effect<GitStatusResult, GitManagerServiceError>;
43		45
		46	/**
		47	* Read local repository status without remote hosting enrichment.
		48	*/
		49	readonly localStatus: (
		50	input: GitStatusInput,
		51	) => Effect.Effect<GitStatusLocalResult, GitManagerServiceError>;
		52
		53	/**
		54	* Read remote tracking / PR status for a repository.
		55	*/
		56	readonly remoteStatus: (
		57	input: GitStatusInput,
		58	) => Effect.Effect<GitStatusRemoteResult \| null, GitManagerServiceError>;
		59
		60	/**
		61	* Clear any cached local status snapshot for a repository.
		62	*/
		63	readonly invalidateLocalStatus: (cwd: string) => Effect.Effect<void, never>;
		64
		65	/**
		66	* Clear any cached remote status snapshot for a repository.
		67	*/
		68	readonly invalidateRemoteStatus: (cwd: string) => Effect.Effect<void, never>;
		69
		70	/**
		71	* Clear any cached status snapshot for a repository so the next read is fresh.
		72	*/
		73	readonly invalidateStatus: (cwd: string) => Effect.Effect<void, never>;
		74
44	/**	75	/**
45	* Resolve a pull request by URL/number against the current repository.	76	* Resolve a pull request by URL/number against the current repository.
46	*/	77	*/

apps/server/src/git/Services/GitStatusBroadcaster.ts created+23

...	@@ -0,0 +1,23 @@
1	import { ServiceMap } from "effect";
2	import type { Effect, Stream } from "effect";
3	import type {
4	GitManagerServiceError,
5	GitStatusInput,
6	GitStatusResult,
7	GitStatusStreamEvent,
8	} from "@t3tools/contracts";
9
10	export interface GitStatusBroadcasterShape {
11	readonly getStatus: (
12	input: GitStatusInput,
13	) => Effect.Effect<GitStatusResult, GitManagerServiceError>;
14	readonly refreshStatus: (cwd: string) => Effect.Effect<GitStatusResult, GitManagerServiceError>;
15	readonly streamStatus: (
16	input: GitStatusInput,
17	) => Stream.Stream<GitStatusStreamEvent, GitManagerServiceError>;
18	}
19
20	export class GitStatusBroadcaster extends ServiceMap.Service<
21	GitStatusBroadcaster,
22	GitStatusBroadcasterShape
23	>()("t3/git/Services/GitStatusBroadcaster") {}

apps/server/src/server.test.ts+376-13

...	@@ -22,7 +22,16 @@ import {	...	@@ -22,7 +22,16 @@ import {
22	} from "@t3tools/contracts";	22	} from "@t3tools/contracts";
23	import { assert, it } from "@effect/vitest";	23	import { assert, it } from "@effect/vitest";
24	import { assertFailure, assertInclude, assertTrue } from "@effect/vitest/utils";	24	import { assertFailure, assertInclude, assertTrue } from "@effect/vitest/utils";
25	import { Effect, FileSystem, Layer, ManagedRuntime, Path, Stream } from "effect";	25	import {
		26	Deferred,
		27	Duration,
		28	Effect,
		29	FileSystem,
		30	Layer,
		31	ManagedRuntime,
		32	Path,
		33	Stream,
		34	} from "effect";
26	import {	35	import {
27	FetchHttpClient,	36	FetchHttpClient,
28	HttpBody,	37	HttpBody,
...	@@ -44,6 +53,7 @@ import {	...	@@ -44,6 +53,7 @@ import {
44	} from "./checkpointing/Services/CheckpointDiffQuery.ts";	53	} from "./checkpointing/Services/CheckpointDiffQuery.ts";
45	import { GitCore, type GitCoreShape } from "./git/Services/GitCore.ts";	54	import { GitCore, type GitCoreShape } from "./git/Services/GitCore.ts";
46	import { GitManager, type GitManagerShape } from "./git/Services/GitManager.ts";	55	import { GitManager, type GitManagerShape } from "./git/Services/GitManager.ts";
		56	import { GitStatusBroadcasterLive } from "./git/Layers/GitStatusBroadcaster.ts";
47	import { Keybindings, type KeybindingsShape } from "./keybindings.ts";	57	import { Keybindings, type KeybindingsShape } from "./keybindings.ts";
48	import { Open, type OpenShape } from "./open.ts";	58	import { Open, type OpenShape } from "./open.ts";
49	import {	59	import {
...	@@ -294,6 +304,10 @@ const buildAppUnderTest = (options?: {	...	@@ -294,6 +304,10 @@ const buildAppUnderTest = (options?: {
294	...options?.config,	304	...options?.config,
295	};	305	};
296	const layerConfig = Layer.succeed(ServerConfig, config);	306	const layerConfig = Layer.succeed(ServerConfig, config);
		307	const gitManagerLayer = Layer.mock(GitManager)({
		308	...options?.layers?.gitManager,
		309	});
		310	const gitStatusBroadcasterLayer = GitStatusBroadcasterLive.pipe(Layer.provide(gitManagerLayer));
297		311
298	const appLayer = HttpRouter.serve(makeRoutesLayer, {	312	const appLayer = HttpRouter.serve(makeRoutesLayer, {
299	disableListenLog: true,	313	disableListenLog: true,
...	@@ -333,11 +347,8 @@ const buildAppUnderTest = (options?: {	...	@@ -333,11 +347,8 @@ const buildAppUnderTest = (options?: {
333	...options?.layers?.gitCore,	347	...options?.layers?.gitCore,
334	}),	348	}),
335	),	349	),
336	Layer.provide(	350	Layer.provide(gitManagerLayer),
337	Layer.mock(GitManager)({	351	Layer.provideMerge(gitStatusBroadcasterLayer),
338	...options?.layers?.gitManager,
339	}),
340	),
341	Layer.provide(	352	Layer.provide(
342	Layer.mock(ProjectSetupScriptRunner)({	353	Layer.mock(ProjectSetupScriptRunner)({
343	runForThread: () => Effect.succeed({ status: "no-script" as const }),	354	runForThread: () => Effect.succeed({ status: "no-script" as const }),
...	@@ -1260,6 +1271,25 @@ it.layer(NodeServices.layer)("server router seam", (it) => {	...	@@ -1260,6 +1271,25 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
1260	yield* buildAppUnderTest({	1271	yield* buildAppUnderTest({
1261	layers: {	1272	layers: {
1262	gitManager: {	1273	gitManager: {
		1274	invalidateLocalStatus: () => Effect.void,
		1275	invalidateRemoteStatus: () => Effect.void,
		1276	invalidateStatus: () => Effect.void,
		1277	localStatus: () =>
		1278	Effect.succeed({
		1279	isRepo: true,
		1280	hasOriginRemote: true,
		1281	isDefaultBranch: true,
		1282	branch: "main",
		1283	hasWorkingTreeChanges: false,
		1284	workingTree: { files: [], insertions: 0, deletions: 0 },
		1285	}),
		1286	remoteStatus: () =>
		1287	Effect.succeed({
		1288	hasUpstream: true,
		1289	aheadCount: 0,
		1290	behindCount: 0,
		1291	pr: null,
		1292	}),
1263	status: () =>	1293	status: () =>
1264	Effect.succeed({	1294	Effect.succeed({
1265	isRepo: true,	1295	isRepo: true,
...	@@ -1373,8 +1403,8 @@ it.layer(NodeServices.layer)("server router seam", (it) => {	...	@@ -1373,8 +1403,8 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
1373	worktree: { path: "/tmp/wt", branch: "feature/demo" },	1403	worktree: { path: "/tmp/wt", branch: "feature/demo" },
1374	}),	1404	}),
1375	removeWorktree: () => Effect.void,	1405	removeWorktree: () => Effect.void,
1376	createBranch: () => Effect.void,	1406	createBranch: (input) => Effect.succeed({ branch: input.branch }),
1377	checkoutBranch: () => Effect.void,	1407	checkoutBranch: (input) => Effect.succeed({ branch: input.branch }),
1378	initRepo: () => Effect.void,	1408	initRepo: () => Effect.void,
1379	},	1409	},
1380	},	1410	},
...	@@ -1382,16 +1412,18 @@ it.layer(NodeServices.layer)("server router seam", (it) => {	...	@@ -1382,16 +1412,18 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
1382		1412
1383	const wsUrl = yield* getWsServerUrl("/ws");	1413	const wsUrl = yield* getWsServerUrl("/ws");
1384		1414
1385	const status = yield* Effect.scoped(
1386	withWsRpcClient(wsUrl, (client) => client[WS_METHODS.gitStatus]({ cwd: "/tmp/repo" })),
1387	);
1388	assert.equal(status.branch, "main");
1389
1390	const pull = yield* Effect.scoped(	1415	const pull = yield* Effect.scoped(
1391	withWsRpcClient(wsUrl, (client) => client[WS_METHODS.gitPull]({ cwd: "/tmp/repo" })),	1416	withWsRpcClient(wsUrl, (client) => client[WS_METHODS.gitPull]({ cwd: "/tmp/repo" })),
1392	);	1417	);
1393	assert.equal(pull.status, "pulled");	1418	assert.equal(pull.status, "pulled");
1394		1419
		1420	const refreshedStatus = yield* Effect.scoped(
		1421	withWsRpcClient(wsUrl, (client) =>
		1422	client[WS_METHODS.gitRefreshStatus]({ cwd: "/tmp/repo" }),
		1423	),
		1424	);
		1425	assert.equal(refreshedStatus.isRepo, true);
		1426
1395	const stackedEvents = yield* Effect.scoped(	1427	const stackedEvents = yield* Effect.scoped(
1396	withWsRpcClient(wsUrl, (client) =>	1428	withWsRpcClient(wsUrl, (client) =>
1397	client[WS_METHODS.gitRunStackedAction]({	1429	client[WS_METHODS.gitRunStackedAction]({
...	@@ -1494,11 +1526,62 @@ it.layer(NodeServices.layer)("server router seam", (it) => {	...	@@ -1494,11 +1526,62 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
1494	cwd: "/tmp/repo",	1526	cwd: "/tmp/repo",
1495	detail: "upstream missing",	1527	detail: "upstream missing",
1496	});	1528	});
		1529	let invalidationCalls = 0;
		1530	let statusCalls = 0;
1497	yield* buildAppUnderTest({	1531	yield* buildAppUnderTest({
1498	layers: {	1532	layers: {
1499	gitCore: {	1533	gitCore: {
1500	pullCurrentBranch: () => Effect.fail(gitError),	1534	pullCurrentBranch: () => Effect.fail(gitError),
1501	},	1535	},
		1536	gitManager: {
		1537	invalidateLocalStatus: () =>
		1538	Effect.sync(() => {
		1539	invalidationCalls += 1;
		1540	}),
		1541	invalidateRemoteStatus: () =>
		1542	Effect.sync(() => {
		1543	invalidationCalls += 1;
		1544	}),
		1545	invalidateStatus: () =>
		1546	Effect.sync(() => {
		1547	invalidationCalls += 1;
		1548	}),
		1549	localStatus: () =>
		1550	Effect.succeed({
		1551	isRepo: true,
		1552	hasOriginRemote: true,
		1553	isDefaultBranch: true,
		1554	branch: "main",
		1555	hasWorkingTreeChanges: true,
		1556	workingTree: { files: [], insertions: 0, deletions: 0 },
		1557	}),
		1558	remoteStatus: () =>
		1559	Effect.sync(() => {
		1560	statusCalls += 1;
		1561	return {
		1562	hasUpstream: true,
		1563	aheadCount: 0,
		1564	behindCount: 0,
		1565	pr: null,
		1566	};
		1567	}),
		1568	status: () =>
		1569	Effect.sync(() => {
		1570	statusCalls += 1;
		1571	return {
		1572	isRepo: true,
		1573	hasOriginRemote: true,
		1574	isDefaultBranch: true,
		1575	branch: "main",
		1576	hasWorkingTreeChanges: true,
		1577	workingTree: { files: [], insertions: 0, deletions: 0 },
		1578	hasUpstream: true,
		1579	aheadCount: 0,
		1580	behindCount: 0,
		1581	pr: null,
		1582	};
		1583	}),
		1584	},
1502	},	1585	},
1503	});	1586	});
1504		1587
...	@@ -1510,9 +1593,289 @@ it.layer(NodeServices.layer)("server router seam", (it) => {	...	@@ -1510,9 +1593,289 @@ it.layer(NodeServices.layer)("server router seam", (it) => {
1510	);	1593	);
1511		1594
1512	assertFailure(result, gitError);	1595	assertFailure(result, gitError);
		1596	assert.equal(invalidationCalls, 0);
		1597	assert.equal(statusCalls, 0);
		1598	}).pipe(Effect.provide(NodeHttpServer.layerTest)),
		1599	);
		1600
		1601	it.effect("routes websocket rpc git.runStackedAction errors after refreshing git status", () =>
		1602	Effect.gen(function* () {
		1603	const gitError = new GitCommandError({
		1604	operation: "commit",
		1605	command: "git commit",
		1606	cwd: "/tmp/repo",
		1607	detail: "nothing to commit",
		1608	});
		1609	let invalidationCalls = 0;
		1610	let statusCalls = 0;
		1611	yield* buildAppUnderTest({
		1612	layers: {
		1613	gitManager: {
		1614	invalidateLocalStatus: () =>
		1615	Effect.sync(() => {
		1616	invalidationCalls += 1;
		1617	}),
		1618	invalidateRemoteStatus: () =>
		1619	Effect.sync(() => {
		1620	invalidationCalls += 1;
		1621	}),
		1622	invalidateStatus: () =>
		1623	Effect.sync(() => {
		1624	invalidationCalls += 1;
		1625	}),
		1626	localStatus: () =>
		1627	Effect.succeed({
		1628	isRepo: true,
		1629	hasOriginRemote: true,
		1630	isDefaultBranch: false,
		1631	branch: "feature/demo",
		1632	hasWorkingTreeChanges: true,
		1633	workingTree: { files: [], insertions: 0, deletions: 0 },
		1634	}),
		1635	remoteStatus: () =>
		1636	Effect.sync(() => {
		1637	statusCalls += 1;
		1638	return {
		1639	hasUpstream: true,
		1640	aheadCount: 0,
		1641	behindCount: 0,
		1642	pr: null,
		1643	};
		1644	}),
		1645	status: () =>
		1646	Effect.sync(() => {
		1647	statusCalls += 1;
		1648	return {
		1649	isRepo: true,
		1650	hasOriginRemote: true,
		1651	isDefaultBranch: false,
		1652	branch: "feature/demo",
		1653	hasWorkingTreeChanges: true,
		1654	workingTree: { files: [], insertions: 0, deletions: 0 },
		1655	hasUpstream: true,
		1656	aheadCount: 0,
		1657	behindCount: 0,
		1658	pr: null,
		1659	};
		1660	}),
		1661	runStackedAction: () => Effect.fail(gitError),
		1662	},
		1663	},
		1664	});
		1665
		1666	const wsUrl = yield* getWsServerUrl("/ws");
		1667	const result = yield* Effect.scoped(
		1668	withWsRpcClient(wsUrl, (client) =>
		1669	client[WS_METHODS.gitRunStackedAction]({
		1670	actionId: "action-1",
		1671	cwd: "/tmp/repo",
		1672	action: "commit",
		1673	}).pipe(Stream.runCollect, Effect.result),
		1674	),
		1675	);
		1676
		1677	assertFailure(result, gitError);
		1678	assert.equal(invalidationCalls, 0);
		1679	assert.equal(statusCalls, 0);
		1680	}).pipe(Effect.provide(NodeHttpServer.layerTest)),
		1681	);
		1682
		1683	it.effect("completes websocket rpc git.pull before background git status refresh finishes", () =>
		1684	Effect.gen(function* () {
		1685	yield* buildAppUnderTest({
		1686	layers: {
		1687	gitCore: {
		1688	pullCurrentBranch: () =>
		1689	Effect.succeed({
		1690	status: "pulled" as const,
		1691	branch: "main",
		1692	upstreamBranch: "origin/main",
		1693	}),
		1694	},
		1695	gitManager: {
		1696	invalidateLocalStatus: () => Effect.void,
		1697	invalidateRemoteStatus: () => Effect.void,
		1698	localStatus: () =>
		1699	Effect.succeed({
		1700	isRepo: true,
		1701	hasOriginRemote: true,
		1702	isDefaultBranch: true,
		1703	branch: "main",
		1704	hasWorkingTreeChanges: false,
		1705	workingTree: { files: [], insertions: 0, deletions: 0 },
		1706	}),
		1707	remoteStatus: () =>
		1708	Effect.sleep(Duration.seconds(2)).pipe(
		1709	Effect.as({
		1710	hasUpstream: true,
		1711	aheadCount: 0,
		1712	behindCount: 0,
		1713	pr: null,
		1714	}),
		1715	),
		1716	},
		1717	},
		1718	});
		1719
		1720	const wsUrl = yield* getWsServerUrl("/ws");
		1721	const startedAt = Date.now();
		1722	const result = yield* Effect.scoped(
		1723	withWsRpcClient(wsUrl, (client) => client[WS_METHODS.gitPull]({ cwd: "/tmp/repo" })),
		1724	);
		1725	const elapsedMs = Date.now() - startedAt;
		1726
		1727	assert.equal(result.status, "pulled");
		1728	assertTrue(elapsedMs < 1_000);
1513	}).pipe(Effect.provide(NodeHttpServer.layerTest)),	1729	}).pipe(Effect.provide(NodeHttpServer.layerTest)),
1514	);	1730	);
1515		1731
		1732	it.effect(
		1733	"completes websocket rpc git.runStackedAction before background git status refresh finishes",
		1734	() =>
		1735	Effect.gen(function* () {
		1736	yield* buildAppUnderTest({
		1737	layers: {
		1738	gitManager: {
		1739	invalidateLocalStatus: () => Effect.void,
		1740	invalidateRemoteStatus: () => Effect.void,
		1741	localStatus: () =>
		1742	Effect.succeed({
		1743	isRepo: true,
		1744	hasOriginRemote: true,
		1745	isDefaultBranch: false,
		1746	branch: "feature/demo",
		1747	hasWorkingTreeChanges: false,
		1748	workingTree: { files: [], insertions: 0, deletions: 0 },
		1749	}),
		1750	remoteStatus: () =>
		1751	Effect.sleep(Duration.seconds(2)).pipe(
		1752	Effect.as({
		1753	hasUpstream: true,
		1754	aheadCount: 0,
		1755	behindCount: 0,
		1756	pr: null,
		1757	}),
		1758	),
		1759	runStackedAction: () =>
		1760	Effect.succeed({
		1761	action: "commit" as const,
		1762	branch: { status: "skipped_not_requested" as const },
		1763	commit: {
		1764	status: "created" as const,
		1765	commitSha: "abc123",
		1766	subject: "feat: demo",
		1767	},
		1768	push: { status: "skipped_not_requested" as const },
		1769	pr: { status: "skipped_not_requested" as const },
		1770	toast: {
		1771	title: "Committed abc123",
		1772	description: "feat: demo",
		1773	cta: {
		1774	kind: "run_action" as const,
		1775	label: "Push",
		1776	action: {
		1777	kind: "push" as const,
		1778	},
		1779	},
		1780	},
		1781	}),
		1782	},
		1783	},
		1784	});
		1785
		1786	const wsUrl = yield* getWsServerUrl("/ws");
		1787	const startedAt = Date.now();
		1788	yield* Effect.scoped(
		1789	withWsRpcClient(wsUrl, (client) =>
		1790	client[WS_METHODS.gitRunStackedAction]({
		1791	actionId: "action-1",
		1792	cwd: "/tmp/repo",
		1793	action: "commit",
		1794	}).pipe(Stream.runCollect),
		1795	),
		1796	);
		1797	const elapsedMs = Date.now() - startedAt;
		1798
		1799	assertTrue(elapsedMs < 1_000);
		1800	}).pipe(Effect.provide(NodeHttpServer.layerTest)),
		1801	);
		1802
		1803	it.effect(
		1804	"starts a background local git status refresh after a successful git.runStackedAction",
		1805	() =>
		1806	Effect.gen(function* () {
		1807	const localRefreshStarted = yield* Deferred.make<void>();
		1808
		1809	yield* buildAppUnderTest({
		1810	layers: {
		1811	gitManager: {
		1812	invalidateLocalStatus: () => Effect.void,
		1813	invalidateRemoteStatus: () => Effect.void,
		1814	localStatus: () =>
		1815	Deferred.succeed(localRefreshStarted, undefined).pipe(
		1816	Effect.ignore,
		1817	Effect.andThen(
		1818	Effect.succeed({
		1819	isRepo: true,
		1820	hasOriginRemote: true,
		1821	isDefaultBranch: false,
		1822	branch: "feature/demo",
		1823	hasWorkingTreeChanges: false,
		1824	workingTree: { files: [], insertions: 0, deletions: 0 },
		1825	}),
		1826	),
		1827	),
		1828	remoteStatus: () =>
		1829	Effect.sleep(Duration.seconds(2)).pipe(
		1830	Effect.as({
		1831	hasUpstream: true,
		1832	aheadCount: 0,
		1833	behindCount: 0,
		1834	pr: null,
		1835	}),
		1836	),
		1837	runStackedAction: () =>
		1838	Effect.succeed({
		1839	action: "commit" as const,
		1840	branch: { status: "skipped_not_requested" as const },
		1841	commit: {
		1842	status: "created" as const,
		1843	commitSha: "abc123",
		1844	subject: "feat: demo",
		1845	},
		1846	push: { status: "skipped_not_requested" as const },
		1847	pr: { status: "skipped_not_requested" as const },
		1848	toast: {
		1849	title: "Committed abc123",
		1850	description: "feat: demo",
		1851	cta: {
		1852	kind: "run_action" as const,
		1853	label: "Push",
		1854	action: {
		1855	kind: "push" as const,
		1856	},
		1857	},
		1858	},
		1859	}),
		1860	},
		1861	},
		1862	});
		1863
		1864	const wsUrl = yield* getWsServerUrl("/ws");
		1865	yield* Effect.scoped(
		1866	withWsRpcClient(wsUrl, (client) =>
		1867	client[WS_METHODS.gitRunStackedAction]({
		1868	actionId: "action-1",
		1869	cwd: "/tmp/repo",
		1870	action: "commit",
		1871	}).pipe(Stream.runCollect),
		1872	),
		1873	);
		1874
		1875	yield* Deferred.await(localRefreshStarted);
		1876	}).pipe(Effect.provide(NodeHttpServer.layerTest)),
		1877	);
		1878
1516	it.effect("routes websocket rpc orchestration methods", () =>	1879	it.effect("routes websocket rpc orchestration methods", () =>
1517	Effect.gen(function* () {	1880	Effect.gen(function* () {
1518	const now = new Date().toISOString();	1881	const now = new Date().toISOString();

apps/server/src/server.ts+10-8

 @@ -30,6 +30,7 @@ import { OrchestrationProjectionSnapshotQueryLive } from "./orchestration/Layers
 import { CheckpointStoreLive } from "./checkpointing/Layers/CheckpointStore";
 import { GitCoreLive } from "./git/Layers/GitCore";
 import { GitHubCliLive } from "./git/Layers/GitHubCli";
+import { GitStatusBroadcasterLive } from "./git/Layers/GitStatusBroadcaster";
 import { RoutingTextGenerationLive } from "./git/Layers/RoutingTextGeneration";
 import { TerminalManagerLive } from "./terminal/Layers/Manager";
 import { GitManagerLive } from "./git/Layers/GitManager";
 @@ -161,15 +162,16 @@ const ProviderLayerLive = Layer.unwrap(
 const PersistenceLayerLive = Layer.empty.pipe(Layer.provideMerge(SqlitePersistenceLayerLive));
+const GitManagerLayerLive = GitManagerLive.pipe(
+  Layer.provideMerge(ProjectSetupScriptRunnerLive),
+  Layer.provideMerge(GitCoreLive),
+  Layer.provideMerge(GitHubCliLive),
+  Layer.provideMerge(RoutingTextGenerationLive),
+);
 const GitLayerLive = Layer.empty.pipe(
-  Layer.provideMerge(
+  Layer.provideMerge(GitManagerLayerLive),
-    GitManagerLive.pipe(
+  Layer.provideMerge(GitStatusBroadcasterLive.pipe(Layer.provide(GitManagerLayerLive))),
-      Layer.provideMerge(ProjectSetupScriptRunnerLive),
-      Layer.provideMerge(GitCoreLive),
-      Layer.provideMerge(GitHubCliLive),
-      Layer.provideMerge(RoutingTextGenerationLive),
-    ),
-  ),
   Layer.provideMerge(GitCoreLive),
 );

apps/server/src/ws.ts+62-21

 @@ -27,6 +27,7 @@ import { CheckpointDiffQuery } from "./checkpointing/Services/CheckpointDiffQuer
 import { ServerConfig } from "./config";
 import { GitCore } from "./git/Services/GitCore";
 import { GitManager } from "./git/Services/GitManager";
+import { GitStatusBroadcaster } from "./git/Services/GitStatusBroadcaster";
 import { Keybindings } from "./keybindings";
 import { Open, resolveAvailableEditors } from "./open";
 import { normalizeDispatchCommand } from "./orchestration/Normalizer";
 @@ -56,6 +57,7 @@ const WsRpcLayer = WsRpcGroup.toLayer(
     const open = yield* Open;
     const gitManager = yield* GitManager;
     const git = yield* GitCore;
+    const gitStatusBroadcaster = yield* GitStatusBroadcaster;
     const terminalManager = yield* TerminalManager;
     const providerRegistry = yield* ProviderRegistry;
     const config = yield* ServerConfig;
 @@ -65,7 +67,6 @@ const WsRpcLayer = WsRpcGroup.toLayer(
     const workspaceEntries = yield* WorkspaceEntries;
     const workspaceFileSystem = yield* WorkspaceFileSystem;
     const projectSetupScriptRunner = yield* ProjectSetupScriptRunner;
     const serverCommandId = (tag: string) =>
       CommandId.makeUnsafe(`server:${tag}:${crypto.randomUUID()}`);
 @@ -348,6 +349,11 @@ const WsRpcLayer = WsRpcGroup.toLayer(
       };
     });
+    const refreshGitStatus = (cwd: string) =>
+      gitStatusBroadcaster
+        .refreshStatus(cwd)
+        .pipe(Effect.ignoreCause({ log: true }), Effect.forkDetach, Effect.asVoid);
     return WsRpcGroup.of({
       [ORCHESTRATION_WS_METHODS.getSnapshot]: (_input) =>
         observeRpcEffect(
 @@ -559,14 +565,30 @@ const WsRpcLayer = WsRpcGroup.toLayer(
         observeRpcEffect(WS_METHODS.shellOpenInEditor, open.openInEditor(input), {
           "rpc.aggregate": "workspace",
         }),
-      [WS_METHODS.gitStatus]: (input) =>
+      [WS_METHODS.subscribeGitStatus]: (input) =>
-        observeRpcEffect(WS_METHODS.gitStatus, gitManager.status(input), {
+        observeRpcStream(WS_METHODS.subscribeGitStatus, gitStatusBroadcaster.streamStatus(input), {
           "rpc.aggregate": "git",
         }),
+      [WS_METHODS.gitRefreshStatus]: (input) =>
+        observeRpcEffect(
+          WS_METHODS.gitRefreshStatus,
+          gitStatusBroadcaster.refreshStatus(input.cwd),
+          {
+            "rpc.aggregate": "git",
+          },
+        ),
       [WS_METHODS.gitPull]: (input) =>
-        observeRpcEffect(WS_METHODS.gitPull, git.pullCurrentBranch(input.cwd), {
+        observeRpcEffect(
-          "rpc.aggregate": "git",
+          WS_METHODS.gitPull,
-        }),
+          git.pullCurrentBranch(input.cwd).pipe(
+            Effect.matchCauseEffect({
+              onFailure: (cause) => Effect.failCause(cause),
+              onSuccess: (result) =>
+                refreshGitStatus(input.cwd).pipe(Effect.ignore({ log: true }), Effect.as(result)),
+            }),
+          ),
+          { "rpc.aggregate": "git" },
+        ),
       [WS_METHODS.gitRunStackedAction]: (input) =>
         observeRpcStream(
           WS_METHODS.gitRunStackedAction,
 @@ -581,7 +603,10 @@ const WsRpcLayer = WsRpcGroup.toLayer(
               .pipe(
                 Effect.matchCauseEffect({
                   onFailure: (cause) => Queue.failCause(queue, cause),
-                  onSuccess: () => Queue.end(queue).pipe(Effect.asVoid),
+                  onSuccess: () =>
+                    refreshGitStatus(input.cwd).pipe(
+                      Effect.andThen(Queue.end(queue).pipe(Effect.asVoid)),
+                    ),
                 }),
               ),
           ),
 @@ -594,7 +619,9 @@ const WsRpcLayer = WsRpcGroup.toLayer(
       [WS_METHODS.gitPreparePullRequestThread]: (input) =>
         observeRpcEffect(
           WS_METHODS.gitPreparePullRequestThread,
-          gitManager.preparePullRequestThread(input),
+          gitManager
+            .preparePullRequestThread(input)
+            .pipe(Effect.tap(() => refreshGitStatus(input.cwd))),
           { "rpc.aggregate": "git" },
         ),
       [WS_METHODS.gitListBranches]: (input) =>
 @@ -602,23 +629,37 @@ const WsRpcLayer = WsRpcGroup.toLayer(
           "rpc.aggregate": "git",
         }),
       [WS_METHODS.gitCreateWorktree]: (input) =>
-        observeRpcEffect(WS_METHODS.gitCreateWorktree, git.createWorktree(input), {
+        observeRpcEffect(
-          "rpc.aggregate": "git",
+          WS_METHODS.gitCreateWorktree,
-        }),
+          git.createWorktree(input).pipe(Effect.tap(() => refreshGitStatus(input.cwd))),
+          { "rpc.aggregate": "git" },
+        ),
       [WS_METHODS.gitRemoveWorktree]: (input) =>
-        observeRpcEffect(WS_METHODS.gitRemoveWorktree, git.removeWorktree(input), {
+        observeRpcEffect(
-          "rpc.aggregate": "git",
+          WS_METHODS.gitRemoveWorktree,
-        }),
+          git.removeWorktree(input).pipe(Effect.tap(() => refreshGitStatus(input.cwd))),
+          { "rpc.aggregate": "git" },
+        ),
       [WS_METHODS.gitCreateBranch]: (input) =>
-        observeRpcEffect(WS_METHODS.gitCreateBranch, git.createBranch(input), {
+        observeRpcEffect(
-          "rpc.aggregate": "git",
+          WS_METHODS.gitCreateBranch,
-        }),
+          git.createBranch(input).pipe(Effect.tap(() => refreshGitStatus(input.cwd))),
+          { "rpc.aggregate": "git" },
+        ),
       [WS_METHODS.gitCheckout]: (input) =>
-        observeRpcEffect(WS_METHODS.gitCheckout, Effect.scoped(git.checkoutBranch(input)), {
+        observeRpcEffect(
-          "rpc.aggregate": "git",
+          WS_METHODS.gitCheckout,
-        }),
+          Effect.scoped(git.checkoutBranch(input)).pipe(
+            Effect.tap(() => refreshGitStatus(input.cwd)),
+          ),
+          { "rpc.aggregate": "git" },
+        ),
       [WS_METHODS.gitInit]: (input) =>
-        observeRpcEffect(WS_METHODS.gitInit, git.initRepo(input), { "rpc.aggregate": "git" }),
+        observeRpcEffect(
+          WS_METHODS.gitInit,
+          git.initRepo(input).pipe(Effect.tap(() => refreshGitStatus(input.cwd))),
+          { "rpc.aggregate": "git" },
+        ),
       [WS_METHODS.terminalOpen]: (input) =>
         observeRpcEffect(WS_METHODS.terminalOpen, terminalManager.open(input), {
           "rpc.aggregate": "terminal",

apps/web/src/components/BranchToolbarBranchSelector.tsx+28-42

 @@ -1,5 +1,5 @@
 import type { GitBranch } from "@t3tools/contracts";
-import { useInfiniteQuery, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useInfiniteQuery, useQueryClient } from "@tanstack/react-query";
 import { useVirtualizer } from "@tanstack/react-virtual";
 import { ChevronDownIcon } from "lucide-react";
 import {
 @@ -14,12 +14,8 @@ import {
   useTransition,
 } from "react";
-import {
+import { gitBranchSearchInfiniteQueryOptions, gitQueryKeys } from "../lib/gitReactQuery";
-  gitBranchSearchInfiniteQueryOptions,
+import { useGitStatus } from "../lib/gitStatusState";
-  gitQueryKeys,
-  gitStatusQueryOptions,
-  invalidateGitQueries,
-} from "../lib/gitReactQuery";
 import { readNativeApi } from "../nativeApi";
 import { parsePullRequestReference } from "../pullRequestReference";
 import {
 @@ -89,7 +85,7 @@ export function BranchToolbarBranchSelector({
   const [branchQuery, setBranchQuery] = useState("");
   const deferredBranchQuery = useDeferredValue(branchQuery);
-  const branchStatusQuery = useQuery(gitStatusQueryOptions(branchCwd));
+  const branchStatusQuery = useGitStatus(branchCwd);
   const trimmedBranchQuery = branchQuery.trim();
   const deferredTrimmedBranchQuery = deferredBranchQuery.trim();
 @@ -110,7 +106,6 @@ export function BranchToolbarBranchSelector({
     gitBranchSearchInfiniteQueryOptions({
       cwd: branchCwd,
       query: deferredTrimmedBranchQuery,
-      enabled: isBranchMenuOpen,
     }),
   );
   const branches = useMemo(
 @@ -188,7 +183,9 @@ export function BranchToolbarBranchSelector({
   const runBranchAction = (action: () => Promise<void>) => {
     startBranchActionTransition(async () => {
       await action().catch(() => undefined);
-      await invalidateGitQueries(queryClient).catch(() => undefined);
+      await queryClient
+        .invalidateQueries({ queryKey: gitQueryKeys.branches(branchCwd) })
+        .catch(() => undefined);
     });
   };
 @@ -226,29 +223,26 @@ export function BranchToolbarBranchSelector({
     onComposerFocusRequest?.();
     runBranchAction(async () => {
+      const previousBranch = resolvedActiveBranch;
       setOptimisticBranch(selectedBranchName);
       try {
-        await api.git.checkout({ cwd: selectionTarget.checkoutCwd, branch: branch.name });
+        const checkoutResult = await api.git.checkout({
-        await invalidateGitQueries(queryClient);
+          cwd: selectionTarget.checkoutCwd,
+          branch: branch.name,
+        });
+        const nextBranchName = branch.isRemote
+          ? (checkoutResult.branch ?? selectedBranchName)
+          : selectedBranchName;
+        setOptimisticBranch(nextBranchName);
+        onSetThreadBranch(nextBranchName, selectionTarget.nextWorktreePath);
       } catch (error) {
+        setOptimisticBranch(previousBranch);
         toastManager.add({
           type: "error",
           title: "Failed to checkout branch.",
           description: toBranchActionErrorMessage(error),
         });
-        return;
       }
-      let nextBranchName = selectedBranchName;
-      if (branch.isRemote) {
-        const status = await api.git.status({ cwd: selectionTarget.checkoutCwd }).catch(() => null);
-        if (status?.branch) {
-          nextBranchName = status.branch;
-        }
-      }
-      setOptimisticBranch(nextBranchName);
-      onSetThreadBranch(nextBranchName, selectionTarget.nextWorktreePath);
     });
   };
 @@ -261,32 +255,24 @@ export function BranchToolbarBranchSelector({
     onComposerFocusRequest?.();
     runBranchAction(async () => {
+      const previousBranch = resolvedActiveBranch;
       setOptimisticBranch(name);
       try {
-        await api.git.createBranch({ cwd: branchCwd, branch: name });
+        const createBranchResult = await api.git.createBranch({
-        try {
+          cwd: branchCwd,
-          await api.git.checkout({ cwd: branchCwd, branch: name });
+          branch: name,
-        } catch (error) {
+          checkout: true,
-          toastManager.add({
+        });
-            type: "error",
+        setOptimisticBranch(createBranchResult.branch);
-            title: "Failed to checkout branch.",
+        onSetThreadBranch(createBranchResult.branch, activeWorktreePath);
-            description: toBranchActionErrorMessage(error),
-          });
-          return;
-        }
       } catch (error) {
+        setOptimisticBranch(previousBranch);
         toastManager.add({
           type: "error",
-          title: "Failed to create branch.",
+          title: "Failed to create and checkout branch.",
           description: toBranchActionErrorMessage(error),
         });
-        return;
       }
-      setOptimisticBranch(name);
-      onSetThreadBranch(name, activeWorktreePath);
-      setBranchQuery("");
     });
   };

apps/web/src/components/ChatView.browser.tsx+43-28

 @@ -31,6 +31,8 @@ import {
 } from "../lib/terminalContext";
 import { isMacPlatform } from "../lib/utils";
 import { __resetNativeApiForTests } from "../nativeApi";
+import { AppAtomRegistryProvider } from "../rpc/atomRegistry";
+import { getServerConfig } from "../rpc/serverState";
 import { getRouter } from "../router";
 import { useStore } from "../store";
 import { useTerminalStateStore } from "../terminalStateStore";
 @@ -38,12 +40,19 @@ import { BrowserWsRpcHarness, type NormalizedWsRpcRequestBody } from "../../test
 import { estimateTimelineMessageHeight } from "./timelineHeight";
 import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts/settings";
+vi.mock("../lib/gitStatusState", () => ({
+  useGitStatus: () => ({ data: null, error: null, cause: null, isPending: false }),
+  useGitStatuses: () => new Map(),
+  refreshGitStatus: () => Promise.resolve(null),
+  resetGitStatusStateForTests: () => undefined,
+}));
 const THREAD_ID = "thread-browser-test" as ThreadId;
 const UUID_ROUTE_RE = /^\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 const PROJECT_ID = "project-1" as ProjectId;
 const NOW_ISO = "2026-03-04T12:00:00.000Z";
 const BASE_TIME_MS = Date.parse(NOW_ISO);
-const ATTACHMENT_SVG = "<svg xmlns='http://www.w3.org/2000/svg' width='120' height='300'></svg>";
+const ATTACHMENT_SVG = "<svg xmlns='http://www.w3.org/2000/svg' width='120' height='120'></svg>";
 interface TestFixture {
   snapshot: OrchestrationReadModel;
 @@ -93,9 +102,9 @@ const TEXT_VIEWPORT_MATRIX = [
   { name: "narrow", width: 320, height: 700, textTolerancePx: 84, attachmentTolerancePx: 56 },
 ] as const satisfies readonly ViewportSpec[];
 const ATTACHMENT_VIEWPORT_MATRIX = [
-  DEFAULT_VIEWPORT,
+  { ...DEFAULT_VIEWPORT, attachmentTolerancePx: 120 },
-  { name: "mobile", width: 430, height: 932, textTolerancePx: 56, attachmentTolerancePx: 56 },
+  { name: "mobile", width: 430, height: 932, textTolerancePx: 56, attachmentTolerancePx: 120 },
-  { name: "narrow", width: 320, height: 700, textTolerancePx: 84, attachmentTolerancePx: 56 },
+  { name: "narrow", width: 320, height: 700, textTolerancePx: 84, attachmentTolerancePx: 120 },
 ] as const satisfies readonly ViewportSpec[];
 interface UserRowMeasurement {
 @@ -224,6 +233,7 @@ function createSnapshotForTargetUser(options: {
             name: `attachment-${attachmentIndex + 1}.png`,
             mimeType: "image/png",
             sizeBytes: 128,
+            previewUrl: `/attachments/attachment-${attachmentIndex + 1}`,
           }))
         : undefined;
 @@ -397,6 +407,22 @@ async function waitForWsClient(): Promise<void> {
           (request) => request._tag === WS_METHODS.subscribeOrchestrationDomainEvents,
         ),
       ).toBe(true);
+      expect(
+        wsRequests.some((request) => request._tag === WS_METHODS.subscribeServerLifecycle),
+      ).toBe(true);
+      expect(wsRequests.some((request) => request._tag === WS_METHODS.subscribeServerConfig)).toBe(
+        true,
+      );
+    },
+    { timeout: 8_000, interval: 16 },
+  );
+}
+async function waitForAppBootstrap(): Promise<void> {
+  await vi.waitFor(
+    () => {
+      expect(getServerConfig()).not.toBeNull();
+      expect(useStore.getState().bootstrapComplete).toBe(true);
     },
     { timeout: 8_000, interval: 16 },
   );
 @@ -651,24 +677,6 @@ function resolveWsRpc(body: NormalizedWsRpcRequestBody): unknown {
       ],
     };
   }
-  if (tag === WS_METHODS.gitStatus) {
-    return {
-      isRepo: true,
-      hasOriginRemote: true,
-      isDefaultBranch: true,
-      branch: "main",
-      hasWorkingTreeChanges: false,
-      workingTree: {
-        files: [],
-        insertions: 0,
-        deletions: 0,
-      },
-      hasUpstream: true,
-      aheadCount: 0,
-      behindCount: 0,
-      pr: null,
-    };
-  }
   if (tag === WS_METHODS.projectsSearchEntries) {
     return {
       entries: [],
 @@ -1044,10 +1052,17 @@ async function mountChatView(options: {
     }),
   );
-  const screen = await render(<RouterProvider router={router} />, {
+  const screen = await render(
-    container: host,
+    <AppAtomRegistryProvider>
-  });
+      <RouterProvider router={router} />
+    </AppAtomRegistryProvider>,
+    {
+      container: host,
+    },
+  );
+  await waitForWsClient();
+  await waitForAppBootstrap();
   await waitForLayout();
   const cleanup = async () => {
 @@ -1138,7 +1153,7 @@ describe("ChatView timeline estimator parity (full app)", () => {
         return [];
       },
     });
-    __resetNativeApiForTests();
+    await __resetNativeApiForTests();
     await setViewport(DEFAULT_VIEWPORT);
     localStorage.clear();
     document.body.innerHTML = "";
 @@ -1299,7 +1314,7 @@ describe("ChatView timeline estimator parity (full app)", () => {
         snapshot: createSnapshotForTargetUser({
           targetMessageId,
           targetText: userText,
-          targetAttachmentCount: 3,
+          targetAttachmentCount: 2,
         }),
       });
 @@ -1313,7 +1328,7 @@ describe("ChatView timeline estimator parity (full app)", () => {
           {
             role: "user",
             text: userText,
-            attachments: [{ id: "attachment-1" }, { id: "attachment-2" }, { id: "attachment-3" }],
+            attachments: [{ id: "attachment-1" }, { id: "attachment-2" }],
           },
           { timelineWidthPx: timelineWidthMeasuredPx },
         );

apps/web/src/components/ChatView.tsx+2-2

apps/web/src/components/DiffPanel.tsx+2-2

apps/web/src/components/GitActionsControl.browser.tsx+58-20

...	@@ -10,7 +10,7 @@ const BRANCH_NAME = "feature/toast-scope";	...	@@ -10,7 +10,7 @@ const BRANCH_NAME = "feature/toast-scope";
10		10
11	const {	11	const {
12	invalidateGitQueriesSpy,	12	invalidateGitQueriesSpy,
13	invalidateGitStatusQuerySpy,	13	refreshGitStatusSpy,
14	runStackedActionMutateAsyncSpy,	14	runStackedActionMutateAsyncSpy,
15	setThreadBranchSpy,	15	setThreadBranchSpy,
16	toastAddSpy,	16	toastAddSpy,
...	@@ -19,7 +19,7 @@ const {	...	@@ -19,7 +19,7 @@ const {
19	toastUpdateSpy,	19	toastUpdateSpy,
20	} = vi.hoisted(() => ({	20	} = vi.hoisted(() => ({
21	invalidateGitQueriesSpy: vi.fn(() => Promise.resolve()),	21	invalidateGitQueriesSpy: vi.fn(() => Promise.resolve()),
22	invalidateGitStatusQuerySpy: vi.fn(() => Promise.resolve()),	22	refreshGitStatusSpy: vi.fn(() => Promise.resolve(null)),
23	runStackedActionMutateAsyncSpy: vi.fn(() => new Promise<never>(() => undefined)),	23	runStackedActionMutateAsyncSpy: vi.fn(() => new Promise<never>(() => undefined)),
24	setThreadBranchSpy: vi.fn(),	24	setThreadBranchSpy: vi.fn(),
25	toastAddSpy: vi.fn(() => "toast-1"),	25	toastAddSpy: vi.fn(() => "toast-1"),
...	@@ -57,21 +57,6 @@ vi.mock("@tanstack/react-query", async () => {	...	@@ -57,21 +57,6 @@ vi.mock("@tanstack/react-query", async () => {
57	};	57	};
58	}),	58	}),
59	useQuery: vi.fn((options: { queryKey?: string[] }) => {	59	useQuery: vi.fn((options: { queryKey?: string[] }) => {
60	if (options.queryKey?.[0] === "git-status") {
61	return {
62	data: {
63	branch: BRANCH_NAME,
64	hasWorkingTreeChanges: false,
65	workingTree: { files: [], insertions: 0, deletions: 0 },
66	hasUpstream: true,
67	aheadCount: 1,
68	behindCount: 0,
69	pr: null,
70	},
71	error: null,
72	};
73	}
74
75	if (options.queryKey?.[0] === "git-branches") {	60	if (options.queryKey?.[0] === "git-branches") {
76	return {	61	return {
77	data: {	62	data: {
...	@@ -110,7 +95,6 @@ vi.mock("~/editorPreferences", () => ({	...	@@ -110,7 +95,6 @@ vi.mock("~/editorPreferences", () => ({
110	}));	95	}));
111		96
112	vi.mock("~/lib/gitReactQuery", () => ({	97	vi.mock("~/lib/gitReactQuery", () => ({
113	gitBranchesQueryOptions: vi.fn(() => ({ queryKey: ["git-branches"] })),
114	gitInitMutationOptions: vi.fn(() => ({ __kind: "init" })),	98	gitInitMutationOptions: vi.fn(() => ({ __kind: "init" })),
115	gitMutationKeys: {	99	gitMutationKeys: {
116	pull: vi.fn(() => ["pull"]),	100	pull: vi.fn(() => ["pull"]),
...	@@ -118,9 +102,25 @@ vi.mock("~/lib/gitReactQuery", () => ({	...	@@ -118,9 +102,25 @@ vi.mock("~/lib/gitReactQuery", () => ({
118	},	102	},
119	gitPullMutationOptions: vi.fn(() => ({ __kind: "pull" })),	103	gitPullMutationOptions: vi.fn(() => ({ __kind: "pull" })),
120	gitRunStackedActionMutationOptions: vi.fn(() => ({ __kind: "run-stacked-action" })),	104	gitRunStackedActionMutationOptions: vi.fn(() => ({ __kind: "run-stacked-action" })),
121	gitStatusQueryOptions: vi.fn(() => ({ queryKey: ["git-status"] })),
122	invalidateGitQueries: invalidateGitQueriesSpy,	105	invalidateGitQueries: invalidateGitQueriesSpy,
123	invalidateGitStatusQuery: invalidateGitStatusQuerySpy,	106	}));
		107
		108	vi.mock("~/lib/gitStatusState", () => ({
		109	refreshGitStatus: refreshGitStatusSpy,
		110	resetGitStatusStateForTests: () => undefined,
		111	useGitStatus: vi.fn(() => ({
		112	data: {
		113	branch: BRANCH_NAME,
		114	hasWorkingTreeChanges: false,
		115	workingTree: { files: [], insertions: 0, deletions: 0 },
		116	hasUpstream: true,
		117	aheadCount: 1,
		118	behindCount: 0,
		119	pr: null,
		120	},
		121	error: null,
		122	isPending: false,
		123	})),
124	}));	124	}));
125		125
126	vi.mock("~/lib/utils", async () => {	126	vi.mock("~/lib/utils", async () => {
...	@@ -235,4 +235,42 @@ describe("GitActionsControl thread-scoped progress toast", () => {	...	@@ -235,4 +235,42 @@ describe("GitActionsControl thread-scoped progress toast", () => {
235	host.remove();	235	host.remove();
236	}	236	}
237	});	237	});
		238
		239	it("debounces focus-driven git status refreshes", async () => {
		240	vi.useFakeTimers();
		241
		242	const originalVisibilityState = Object.getOwnPropertyDescriptor(document, "visibilityState");
		243	let visibilityState: DocumentVisibilityState = "hidden";
		244	Object.defineProperty(document, "visibilityState", {
		245	configurable: true,
		246	get: () => visibilityState,
		247	});
		248
		249	const host = document.createElement("div");
		250	document.body.append(host);
		251	const screen = await render(<GitActionsControl gitCwd={GIT_CWD} activeThreadId={THREAD_A} />, {
		252	container: host,
		253	});
		254
		255	try {
		256	window.dispatchEvent(new Event("focus"));
		257	visibilityState = "visible";
		258	document.dispatchEvent(new Event("visibilitychange"));
		259
		260	expect(refreshGitStatusSpy).not.toHaveBeenCalled();
		261
		262	await vi.advanceTimersByTimeAsync(249);
		263	expect(refreshGitStatusSpy).not.toHaveBeenCalled();
		264
		265	await vi.advanceTimersByTimeAsync(1);
		266	expect(refreshGitStatusSpy).toHaveBeenCalledTimes(1);
		267	expect(refreshGitStatusSpy).toHaveBeenCalledWith(GIT_CWD);
		268	} finally {
		269	if (originalVisibilityState) {
		270	Object.defineProperty(document, "visibilityState", originalVisibilityState);
		271	}
		272	await screen.unmount();
		273	host.remove();
		274	}
		275	});
238	});	276	});

apps/web/src/components/GitActionsControl.tsx+41-5

...	@@ -5,7 +5,7 @@ import type {	...	@@ -5,7 +5,7 @@ import type {
5	GitStatusResult,	5	GitStatusResult,
6	ThreadId,	6	ThreadId,
7	} from "@t3tools/contracts";	7	} from "@t3tools/contracts";
8	import { useIsMutating, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";	8	import { useIsMutating, useMutation, useQueryClient } from "@tanstack/react-query";
9	import { useCallback, useEffect, useEffectEvent, useMemo, useRef, useState } from "react";	9	import { useCallback, useEffect, useEffectEvent, useMemo, useRef, useState } from "react";
10	import { ChevronDownIcon, CloudUploadIcon, GitCommitIcon, InfoIcon } from "lucide-react";	10	import { ChevronDownIcon, CloudUploadIcon, GitCommitIcon, InfoIcon } from "lucide-react";
11	import { GitHubIcon } from "./Icons";	11	import { GitHubIcon } from "./Icons";
...	@@ -45,9 +45,8 @@ import {	...	@@ -45,9 +45,8 @@ import {
45	gitMutationKeys,	45	gitMutationKeys,
46	gitPullMutationOptions,	46	gitPullMutationOptions,
47	gitRunStackedActionMutationOptions,	47	gitRunStackedActionMutationOptions,
48	gitStatusQueryOptions,
49	invalidateGitStatusQuery,
50	} from "~/lib/gitReactQuery";	48	} from "~/lib/gitReactQuery";
		49	import { refreshGitStatus, useGitStatus } from "~/lib/gitStatusState";
51	import { newCommandId, randomUUID } from "~/lib/utils";	50	import { newCommandId, randomUUID } from "~/lib/utils";
52	import { resolvePathLinkTarget } from "~/terminal-links";	51	import { resolvePathLinkTarget } from "~/terminal-links";
53	import { readNativeApi } from "~/nativeApi";	52	import { readNativeApi } from "~/nativeApi";
...	@@ -92,6 +91,8 @@ interface RunGitActionWithToastInput {	...	@@ -92,6 +91,8 @@ interface RunGitActionWithToastInput {
92	filePaths?: string[];	91	filePaths?: string[];
93	}	92	}
94		93
		94	const GIT_STATUS_WINDOW_REFRESH_DEBOUNCE_MS = 250;
		95
95	function formatElapsedDescription(startedAtMs: number \| null): string \| undefined {	96	function formatElapsedDescription(startedAtMs: number \| null): string \| undefined {
96	if (startedAtMs === null) {	97	if (startedAtMs === null) {
97	return undefined;	98	return undefined;
...	@@ -275,7 +276,7 @@ export default function GitActionsControl({ gitCwd, activeThreadId }: GitActions	...	@@ -275,7 +276,7 @@ export default function GitActionsControl({ gitCwd, activeThreadId }: GitActions
275	[persistThreadBranchSync],	276	[persistThreadBranchSync],
276	);	277	);
277		278
278	const { data: gitStatus = null, error: gitStatusError } = useQuery(gitStatusQueryOptions(gitCwd));	279	const { data: gitStatus = null, error: gitStatusError } = useGitStatus(gitCwd);
279	// Default to true while loading so we don't flash init controls.	280	// Default to true while loading so we don't flash init controls.
280	const isRepo = gitStatus?.isRepo ?? true;	281	const isRepo = gitStatus?.isRepo ?? true;
281	const hasOriginRemote = gitStatus?.hasOriginRemote ?? false;	282	const hasOriginRemote = gitStatus?.hasOriginRemote ?? false;
...	@@ -359,6 +360,39 @@ export default function GitActionsControl({ gitCwd, activeThreadId }: GitActions	...	@@ -359,6 +360,39 @@ export default function GitActionsControl({ gitCwd, activeThreadId }: GitActions
359	};	360	};
360	}, [updateActiveProgressToast]);	361	}, [updateActiveProgressToast]);
361		362
		363	useEffect(() => {
		364	if (gitCwd === null) {
		365	return;
		366	}
		367
		368	let refreshTimeout: number \| null = null;
		369	const scheduleRefreshCurrentGitStatus = () => {
		370	if (refreshTimeout !== null) {
		371	window.clearTimeout(refreshTimeout);
		372	}
		373	refreshTimeout = window.setTimeout(() => {
		374	refreshTimeout = null;
		375	void refreshGitStatus(gitCwd).catch(() => undefined);
		376	}, GIT_STATUS_WINDOW_REFRESH_DEBOUNCE_MS);
		377	};
		378	const handleVisibilityChange = () => {
		379	if (document.visibilityState === "visible") {
		380	scheduleRefreshCurrentGitStatus();
		381	}
		382	};
		383
		384	window.addEventListener("focus", scheduleRefreshCurrentGitStatus);
		385	document.addEventListener("visibilitychange", handleVisibilityChange);
		386
		387	return () => {
		388	if (refreshTimeout !== null) {
		389	window.clearTimeout(refreshTimeout);
		390	}
		391	window.removeEventListener("focus", scheduleRefreshCurrentGitStatus);
		392	document.removeEventListener("visibilitychange", handleVisibilityChange);
		393	};
		394	}, [gitCwd]);
		395
362	const openExistingPr = useCallback(async () => {	396	const openExistingPr = useCallback(async () => {
363	const api = readNativeApi();	397	const api = readNativeApi();
364	if (!api) {	398	if (!api) {
...	@@ -801,7 +835,9 @@ export default function GitActionsControl({ gitCwd, activeThreadId }: GitActions	...	@@ -801,7 +835,9 @@ export default function GitActionsControl({ gitCwd, activeThreadId }: GitActions
801	<GroupSeparator className="hidden @3xl/header-actions:block" />	835	<GroupSeparator className="hidden @3xl/header-actions:block" />
802	<Menu	836	<Menu
803	onOpenChange={(open) => {	837	onOpenChange={(open) => {
804	if (open) void invalidateGitStatusQuery(queryClient, gitCwd);	838	if (open) {
		839	void refreshGitStatus(gitCwd).catch(() => undefined);
		840	}
805	}}	841	}}
806	>	842	>
807	<MenuTrigger	843	<MenuTrigger

apps/web/src/components/KeybindingsToast.browser.tsx+41-16

 @@ -19,10 +19,19 @@ import { render } from "vitest-browser-react";
 import { useComposerDraftStore } from "../composerDraftStore";
 import { __resetNativeApiForTests } from "../nativeApi";
+import { AppAtomRegistryProvider } from "../rpc/atomRegistry";
+import { getServerConfig } from "../rpc/serverState";
 import { getRouter } from "../router";
 import { useStore } from "../store";
 import { BrowserWsRpcHarness } from "../../test/wsRpcHarness";
+vi.mock("../lib/gitStatusState", () => ({
+  useGitStatus: () => ({ data: null, error: null, cause: null, isPending: false }),
+  useGitStatuses: () => new Map(),
+  refreshGitStatus: () => Promise.resolve(null),
+  resetGitStatusStateForTests: () => undefined,
+}));
 const THREAD_ID = "thread-kb-toast-test" as ThreadId;
 const PROJECT_ID = "project-1" as ProjectId;
 const NOW_ISO = "2026-03-04T12:00:00.000Z";
 @@ -170,20 +179,6 @@ function resolveWsRpc(tag: string): unknown {
       branches: [{ name: "main", current: true, isDefault: true, worktreePath: null }],
     };
   }
-  if (tag === WS_METHODS.gitStatus) {
-    return {
-      isRepo: true,
-      hasOriginRemote: true,
-      isDefaultBranch: true,
-      branch: "main",
-      hasWorkingTreeChanges: false,
-      workingTree: { files: [], insertions: 0, deletions: 0 },
-      hasUpstream: true,
-      aheadCount: 0,
-      behindCount: 0,
-      pr: null,
-    };
-  }
   if (tag === WS_METHODS.projectsSearchEntries) {
     return { entries: [], truncated: false };
   }
 @@ -258,6 +253,29 @@ async function waitForNoToast(title: string): Promise<void> {
   );
 }
+async function waitForInitialWsSubscriptions(): Promise<void> {
+  await vi.waitFor(
+    () => {
+      expect(
+        rpcHarness.requests.some((request) => request._tag === WS_METHODS.subscribeServerLifecycle),
+      ).toBe(true);
+      expect(
+        rpcHarness.requests.some((request) => request._tag === WS_METHODS.subscribeServerConfig),
+      ).toBe(true);
+    },
+    { timeout: 8_000, interval: 16 },
+  );
+}
+async function waitForServerConfigSnapshot(): Promise<void> {
+  await vi.waitFor(
+    () => {
+      expect(getServerConfig()).not.toBeNull();
+    },
+    { timeout: 8_000, interval: 16 },
+  );
+}
 async function mountApp(): Promise<{ cleanup: () => Promise<void> }> {
   const host = document.createElement("div");
   host.style.position = "fixed";
 @@ -270,8 +288,15 @@ async function mountApp(): Promise<{ cleanup: () => Promise<void> }> {
   const router = getRouter(createMemoryHistory({ initialEntries: [`/${THREAD_ID}`] }));
-  const screen = await render(<RouterProvider router={router} />, { container: host });
+  const screen = await render(
+    <AppAtomRegistryProvider>
+      <RouterProvider router={router} />
+    </AppAtomRegistryProvider>,
+    { container: host },
+  );
   await waitForComposerEditor();
+  await waitForInitialWsSubscriptions();
+  await waitForServerConfigSnapshot();
   return {
     cleanup: async () => {
 @@ -322,7 +347,7 @@ describe("Keybindings update toast", () => {
         return [];
       },
     });
-    __resetNativeApiForTests();
+    await __resetNativeApiForTests();
     localStorage.clear();
     document.body.innerHTML = "";
     useComposerDraftStore.setState({

apps/web/src/components/Sidebar.tsx+18-53

 @@ -49,7 +49,6 @@ import {
   ThreadId,
   type GitStatusResult,
 } from "@t3tools/contracts";
-import { useQueries } from "@tanstack/react-query";
 import { Link, useLocation, useNavigate, useParams } from "@tanstack/react-router";
 import {
   type SidebarProjectSortOrder,
 @@ -70,7 +69,7 @@ import {
   threadJumpIndexFromCommand,
   threadTraversalDirectionFromCommand,
 } from "../keybindings";
-import { gitStatusQueryOptions } from "../lib/gitReactQuery";
+import { useGitStatus } from "../lib/gitStatusState";
 import { readNativeApi } from "../nativeApi";
 import { useComposerDraftStore } from "../composerDraftStore";
 import { useHandleNewThread } from "../hooks/useHandleNewThread";
 @@ -245,8 +244,20 @@ function prStatusIndicator(pr: ThreadPr): PrStatusIndicator | null {
   return null;
 }
+function resolveThreadPr(
+  threadBranch: string | null,
+  gitStatus: GitStatusResult | null,
+): ThreadPr | null {
+  if (threadBranch === null || gitStatus === null || gitStatus.branch !== threadBranch) {
+    return null;
+  }
+  return gitStatus.pr ?? null;
+}
 interface SidebarThreadRowProps {
   threadId: ThreadId;
+  projectCwd: string | null;
   orderedProjectThreadIds: readonly ThreadId[];
   routeThreadId: ThreadId | null;
   selectedThreadIds: ReadonlySet<ThreadId>;
 @@ -277,7 +288,6 @@ interface SidebarThreadRowProps {
   cancelRename: () => void;
   attemptArchiveThread: (threadId: ThreadId) => Promise<void>;
   openPrLink: (event: MouseEvent<HTMLElement>, prUrl: string) => void;
-  pr: ThreadPr | null;
 }
 function SidebarThreadRow(props: SidebarThreadRowProps) {
 @@ -287,6 +297,8 @@ function SidebarThreadRow(props: SidebarThreadRowProps) {
     (state) =>
       selectThreadTerminalState(state.terminalStateByThreadId, props.threadId).runningTerminalIds,
   );
+  const gitCwd = thread?.worktreePath ?? props.projectCwd;
+  const gitStatus = useGitStatus(thread?.branch != null ? gitCwd : null);
   if (!thread) {
     return null;
 @@ -303,7 +315,8 @@ function SidebarThreadRow(props: SidebarThreadRowProps) {
       lastVisitedAt,
     },
   });
-  const prStatus = prStatusIndicator(props.pr);
+  const pr = resolveThreadPr(thread.branch, gitStatus.data);
+  const prStatus = prStatusIndicator(pr);
   const terminalStatus = terminalStatusFromRunningIds(runningTerminalIds);
   const isConfirmingArchive = props.confirmingArchiveThreadId === thread.id && !isThreadRunning;
   const threadMetaClassName = isConfirmingArchive
 @@ -762,54 +775,6 @@ export default function Sidebar() {
     }),
     [platform, routeTerminalOpen],
   );
-  const threadGitTargets = useMemo(
-    () =>
-      sidebarThreads.map((thread) => ({
-        threadId: thread.id,
-        branch: thread.branch,
-        cwd: thread.worktreePath ?? projectCwdById.get(thread.projectId) ?? null,
-      })),
-    [projectCwdById, sidebarThreads],
-  );
-  const threadGitStatusCwds = useMemo(
-    () => [
-      ...new Set(
-        threadGitTargets
-          .filter((target) => target.branch !== null)
-          .map((target) => target.cwd)
-          .filter((cwd): cwd is string => cwd !== null),
-      ),
-    ],
-    [threadGitTargets],
-  );
-  const threadGitStatusQueries = useQueries({
-    queries: threadGitStatusCwds.map((cwd) => ({
-      ...gitStatusQueryOptions(cwd),
-      staleTime: 30_000,
-      refetchInterval: 60_000,
-    })),
-  });
-  const prByThreadId = useMemo(() => {
-    const statusByCwd = new Map<string, GitStatusResult>();
-    for (let index = 0; index < threadGitStatusCwds.length; index += 1) {
-      const cwd = threadGitStatusCwds[index];
-      if (!cwd) continue;
-      const status = threadGitStatusQueries[index]?.data;
-      if (status) {
-        statusByCwd.set(cwd, status);
-      }
-    }
-    const map = new Map<ThreadId, ThreadPr>();
-    for (const target of threadGitTargets) {
-      const status = target.cwd ? statusByCwd.get(target.cwd) : undefined;
-      const branchMatches =
-        target.branch !== null && status?.branch !== null && status?.branch === target.branch;
-      map.set(target.threadId, branchMatches ? (status?.pr ?? null) : null);
-    }
-    return map;
-  }, [threadGitStatusCwds, threadGitStatusQueries, threadGitTargets]);
   const openPrLink = useCallback((event: MouseEvent<HTMLElement>, prUrl: string) => {
     event.preventDefault();
     event.stopPropagation();
 @@ -1718,6 +1683,7 @@ export default function Sidebar() {
               <SidebarThreadRow
                 key={threadId}
                 threadId={threadId}
+                projectCwd={project.cwd}
                 orderedProjectThreadIds={orderedProjectThreadIds}
                 routeThreadId={routeThreadId}
                 selectedThreadIds={selectedThreadIds}
 @@ -1741,7 +1707,6 @@ export default function Sidebar() {
                 cancelRename={cancelRename}
                 attemptArchiveThread={attemptArchiveThread}
                 openPrLink={openPrLink}
-                pr={prByThreadId.get(threadId) ?? null}
               />
             ))}

apps/web/src/components/chat/MessagesTimeline.tsx+1-1

...	@@ -385,7 +385,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({	...	@@ -385,7 +385,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({
385	<img	385	<img
386	src={image.previewUrl}	386	src={image.previewUrl}
387	alt={image.name}	387	alt={image.name}
388	className="h-full max-h-[220px] w-full object-cover"	388	className="block h-auto max-h-[220px] w-full object-cover"
389	onLoad={onTimelineImageLoad}	389	onLoad={onTimelineImageLoad}
390	onError={onTimelineImageLoad}	390	onError={onTimelineImageLoad}
391	/>	391	/>

apps/web/src/components/settings/SettingsPanels.browser.tsx+4-4

...	@@ -30,16 +30,16 @@ function createBaseServerConfig(): ServerConfig {	...	@@ -30,16 +30,16 @@ function createBaseServerConfig(): ServerConfig {
30	}	30	}
31		31
32	describe("GeneralSettingsPanel observability", () => {	32	describe("GeneralSettingsPanel observability", () => {
33	beforeEach(() => {	33	beforeEach(async () => {
34	resetServerStateForTests();	34	resetServerStateForTests();
35	__resetNativeApiForTests();	35	await __resetNativeApiForTests();
36	localStorage.clear();	36	localStorage.clear();
37	document.body.innerHTML = "";	37	document.body.innerHTML = "";
38	});	38	});
39		39
40	afterEach(() => {	40	afterEach(async () => {
41	resetServerStateForTests();	41	resetServerStateForTests();
42	__resetNativeApiForTests();	42	await __resetNativeApiForTests();
43	document.body.innerHTML = "";	43	document.body.innerHTML = "";
44	});	44	});
45		45

apps/web/src/components/timelineHeight.test.ts+4-4

...	@@ -30,7 +30,7 @@ describe("estimateTimelineMessageHeight", () => {	...	@@ -30,7 +30,7 @@ describe("estimateTimelineMessageHeight", () => {
30	text: "hello",	30	text: "hello",
31	attachments: [{ id: "1" }],	31	attachments: [{ id: "1" }],
32	}),	32	}),
33	).toBe(346);	33	).toBe(234);
34		34
35	expect(	35	expect(
36	estimateTimelineMessageHeight({	36	estimateTimelineMessageHeight({
...	@@ -38,7 +38,7 @@ describe("estimateTimelineMessageHeight", () => {	...	@@ -38,7 +38,7 @@ describe("estimateTimelineMessageHeight", () => {
38	text: "hello",	38	text: "hello",
39	attachments: [{ id: "1" }, { id: "2" }],	39	attachments: [{ id: "1" }, { id: "2" }],
40	}),	40	}),
41	).toBe(346);	41	).toBe(234);
42	});	42	});
43		43
44	it("adds a second attachment row for three or four user attachments", () => {	44	it("adds a second attachment row for three or four user attachments", () => {
...	@@ -48,7 +48,7 @@ describe("estimateTimelineMessageHeight", () => {	...	@@ -48,7 +48,7 @@ describe("estimateTimelineMessageHeight", () => {
48	text: "hello",	48	text: "hello",
49	attachments: [{ id: "1" }, { id: "2" }, { id: "3" }],	49	attachments: [{ id: "1" }, { id: "2" }, { id: "3" }],
50	}),	50	}),
51	).toBe(574);	51	).toBe(350);
52		52
53	expect(	53	expect(
54	estimateTimelineMessageHeight({	54	estimateTimelineMessageHeight({
...	@@ -56,7 +56,7 @@ describe("estimateTimelineMessageHeight", () => {	...	@@ -56,7 +56,7 @@ describe("estimateTimelineMessageHeight", () => {
56	text: "hello",	56	text: "hello",
57	attachments: [{ id: "1" }, { id: "2" }, { id: "3" }, { id: "4" }],	57	attachments: [{ id: "1" }, { id: "2" }, { id: "3" }, { id: "4" }],
58	}),	58	}),
59	).toBe(574);	59	).toBe(350);
60	});	60	});
61		61
62	it("does not cap long user message estimates", () => {	62	it("does not cap long user message estimates", () => {

apps/web/src/components/timelineHeight.ts+3-2

 @@ -11,8 +11,9 @@ const ASSISTANT_LINE_HEIGHT_PX = 22.75;
 const ASSISTANT_BASE_HEIGHT_PX = 41;
 const USER_BASE_HEIGHT_PX = 96;
 const ATTACHMENTS_PER_ROW = 2;
-// Attachment thumbnails render with `max-h-[220px]` plus ~8px row gap.
+// Full-app browser measurements land closer to a ~116px attachment row once
-const USER_ATTACHMENT_ROW_HEIGHT_PX = 228;
+// the bubble shrinks to content width, so calibrate the estimate to that DOM.
+const USER_ATTACHMENT_ROW_HEIGHT_PX = 116;
 const USER_BUBBLE_WIDTH_RATIO = 0.8;
 const USER_BUBBLE_HORIZONTAL_PADDING_PX = 32;
 const ASSISTANT_MESSAGE_HORIZONTAL_PADDING_PX = 8;

apps/web/src/lib/gitReactQuery.test.ts-29

 @@ -15,12 +15,9 @@ import type { GitListBranchesResult } from "@t3tools/contracts";
 import {
   gitBranchSearchInfiniteQueryOptions,
   gitMutationKeys,
-  gitQueryKeys,
   gitPreparePullRequestThreadMutationOptions,
   gitPullMutationOptions,
   gitRunStackedActionMutationOptions,
-  invalidateGitStatusQuery,
-  gitStatusQueryOptions,
   invalidateGitQueries,
 } from "./gitReactQuery";
 @@ -84,7 +81,6 @@ describe("invalidateGitQueries", () => {
   it("can invalidate a single cwd without blasting other git query scopes", async () => {
     const queryClient = new QueryClient();
-    queryClient.setQueryData(gitQueryKeys.status("/repo/a"), { ok: "a" });
     queryClient.setQueryData(
       gitBranchSearchInfiniteQueryOptions({
         cwd: "/repo/a",
 @@ -92,7 +88,6 @@ describe("invalidateGitQueries", () => {
       }).queryKey,
       BRANCH_SEARCH_RESULT,
     );
-    queryClient.setQueryData(gitQueryKeys.status("/repo/b"), { ok: "b" });
     queryClient.setQueryData(
       gitBranchSearchInfiniteQueryOptions({
         cwd: "/repo/b",
 @@ -103,9 +98,6 @@ describe("invalidateGitQueries", () => {
     await invalidateGitQueries(queryClient, { cwd: "/repo/a" });
-    expect(
-      queryClient.getQueryState(gitStatusQueryOptions("/repo/a").queryKey)?.isInvalidated,
-    ).toBe(true);
     expect(
       queryClient.getQueryState(
         gitBranchSearchInfiniteQueryOptions({
 @@ -114,9 +106,6 @@ describe("invalidateGitQueries", () => {
         }).queryKey,
       )?.isInvalidated,
     ).toBe(true);
-    expect(
-      queryClient.getQueryState(gitStatusQueryOptions("/repo/b").queryKey)?.isInvalidated,
-    ).toBe(false);
     expect(
       queryClient.getQueryState(
         gitBranchSearchInfiniteQueryOptions({
 @@ -127,21 +116,3 @@ describe("invalidateGitQueries", () => {
     ).toBe(false);
   });
 });
-describe("invalidateGitStatusQuery", () => {
-  it("invalidates only status for the selected cwd", async () => {
-    const queryClient = new QueryClient();
-    queryClient.setQueryData(gitQueryKeys.status("/repo/a"), { ok: "a" });
-    queryClient.setQueryData(gitQueryKeys.status("/repo/b"), { ok: "b" });
-    await invalidateGitStatusQuery(queryClient, "/repo/a");
-    expect(
-      queryClient.getQueryState(gitStatusQueryOptions("/repo/a").queryKey)?.isInvalidated,
-    ).toBe(true);
-    expect(
-      queryClient.getQueryState(gitStatusQueryOptions("/repo/b").queryKey)?.isInvalidated,
-    ).toBe(false);
-  });
-});

apps/web/src/lib/gitReactQuery.ts+29-69

 @@ -12,15 +12,12 @@ import {
 import { ensureNativeApi } from "../nativeApi";
 import { getWsRpcClient } from "../wsRpcClient";
-const GIT_STATUS_STALE_TIME_MS = 5_000;
-const GIT_STATUS_REFETCH_INTERVAL_MS = 15_000;
 const GIT_BRANCHES_STALE_TIME_MS = 15_000;
 const GIT_BRANCHES_REFETCH_INTERVAL_MS = 60_000;
 const GIT_BRANCHES_PAGE_SIZE = 100;
 export const gitQueryKeys = {
   all: ["git"] as const,
-  status: (cwd: string | null) => ["git", "status", cwd] as const,
   branches: (cwd: string | null) => ["git", "branches", cwd] as const,
   branchSearch: (cwd: string | null, query: string) =>
     ["git", "branches", cwd, "search", query] as const,
 @@ -38,37 +35,18 @@ export const gitMutationKeys = {
 export function invalidateGitQueries(queryClient: QueryClient, input?: { cwd?: string | null }) {
   const cwd = input?.cwd ?? null;
   if (cwd !== null) {
-    return Promise.all([
+    return queryClient.invalidateQueries({ queryKey: gitQueryKeys.branches(cwd) });
-      queryClient.invalidateQueries({ queryKey: gitQueryKeys.status(cwd) }),
-      queryClient.invalidateQueries({ queryKey: gitQueryKeys.branches(cwd) }),
-    ]);
   }
   return queryClient.invalidateQueries({ queryKey: gitQueryKeys.all });
 }
-export function invalidateGitStatusQuery(queryClient: QueryClient, cwd: string | null) {
+function invalidateGitBranchQueries(queryClient: QueryClient, cwd: string | null) {
   if (cwd === null) {
     return Promise.resolve();
   }
-  return queryClient.invalidateQueries({ queryKey: gitQueryKeys.status(cwd) });
+  return queryClient.invalidateQueries({ queryKey: gitQueryKeys.branches(cwd) });
-}
-export function gitStatusQueryOptions(cwd: string | null) {
-  return queryOptions({
-    queryKey: gitQueryKeys.status(cwd),
-    queryFn: async () => {
-      const api = ensureNativeApi();
-      if (!cwd) throw new Error("Git status is unavailable.");
-      return api.git.status({ cwd });
-    },
-    enabled: cwd !== null,
-    staleTime: GIT_STATUS_STALE_TIME_MS,
-    refetchOnWindowFocus: "always",
-    refetchOnReconnect: "always",
-    refetchInterval: GIT_STATUS_REFETCH_INTERVAL_MS,
-  });
 }
 export function gitBranchSearchInfiniteQueryOptions(input: {
 @@ -128,8 +106,8 @@ export function gitInitMutationOptions(input: { cwd: string | null; queryClient:
       if (!input.cwd) throw new Error("Git init is unavailable.");
       return api.git.init({ cwd: input.cwd });
     },
-    onSuccess: async () => {
+    onSettled: async () => {
-      await invalidateGitQueries(input.queryClient);
+      await invalidateGitBranchQueries(input.queryClient, input.cwd);
     },
   });
 }
 @@ -145,8 +123,8 @@ export function gitCheckoutMutationOptions(input: {
       if (!input.cwd) throw new Error("Git checkout is unavailable.");
       return api.git.checkout({ cwd: input.cwd, branch });
     },
-    onSuccess: async () => {
+    onSettled: async () => {
-      await invalidateGitQueries(input.queryClient);
+      await invalidateGitBranchQueries(input.queryClient, input.cwd);
     },
   });
 }
 @@ -175,18 +153,18 @@ export function gitRunStackedActionMutationOptions(input: {
       if (!input.cwd) throw new Error("Git action is unavailable.");
       return getWsRpcClient().git.runStackedAction(
         {
+          action,
           actionId,
           cwd: input.cwd,
-          action,
           ...(commitMessage ? { commitMessage } : {}),
-          ...(featureBranch ? { featureBranch } : {}),
+          ...(featureBranch ? { featureBranch: true } : {}),
-          ...(filePaths ? { filePaths } : {}),
+          ...(filePaths && filePaths.length > 0 ? { filePaths } : {}),
         },
         ...(onProgress ? [{ onProgress }] : []),
       );
     },
-    onSettled: async () => {
+    onSuccess: async () => {
-      await invalidateGitQueries(input.queryClient);
+      await invalidateGitBranchQueries(input.queryClient, input.cwd);
     },
   });
 }
 @@ -199,31 +177,19 @@ export function gitPullMutationOptions(input: { cwd: string | null; queryClient:
       if (!input.cwd) throw new Error("Git pull is unavailable.");
       return api.git.pull({ cwd: input.cwd });
     },
-    onSettled: async () => {
+    onSuccess: async () => {
-      await invalidateGitQueries(input.queryClient);
+      await invalidateGitBranchQueries(input.queryClient, input.cwd);
     },
   });
 }
 export function gitCreateWorktreeMutationOptions(input: { queryClient: QueryClient }) {
   return mutationOptions({
-    mutationFn: async ({
-      cwd,
-      branch,
-      newBranch,
-      path,
-    }: {
-      cwd: string;
-      branch: string;
-      newBranch: string;
-      path?: string | null;
-    }) => {
-      const api = ensureNativeApi();
-      if (!cwd) throw new Error("Git worktree creation is unavailable.");
-      return api.git.createWorktree({ cwd, branch, newBranch, path: path ?? null });
-    },
     mutationKey: ["git", "mutation", "create-worktree"] as const,
-    onSettled: async () => {
+    mutationFn: (
+      args: Parameters<ReturnType<typeof ensureNativeApi>["git"]["createWorktree"]>[0],
+    ) => ensureNativeApi().git.createWorktree(args),
+    onSuccess: async () => {
       await invalidateGitQueries(input.queryClient);
     },
   });
 @@ -231,13 +197,11 @@ export function gitCreateWorktreeMutationOptions(input: { queryClient: QueryClie
 export function gitRemoveWorktreeMutationOptions(input: { queryClient: QueryClient }) {
   return mutationOptions({
-    mutationFn: async ({ cwd, path, force }: { cwd: string; path: string; force?: boolean }) => {
-      const api = ensureNativeApi();
-      if (!cwd) throw new Error("Git worktree removal is unavailable.");
-      return api.git.removeWorktree({ cwd, path, force });
-    },
     mutationKey: ["git", "mutation", "remove-worktree"] as const,
-    onSettled: async () => {
+    mutationFn: (
+      args: Parameters<ReturnType<typeof ensureNativeApi>["git"]["removeWorktree"]>[0],
+    ) => ensureNativeApi().git.removeWorktree(args),
+    onSuccess: async () => {
       await invalidateGitQueries(input.queryClient);
     },
   });
 @@ -248,11 +212,8 @@ export function gitPreparePullRequestThreadMutationOptions(input: {
   queryClient: QueryClient;
 }) {
   return mutationOptions({
-    mutationFn: async ({
+    mutationKey: gitMutationKeys.preparePullRequestThread(input.cwd),
-      reference,
+    mutationFn: async (args: {
-      mode,
-      threadId,
-    }: {
       reference: string;
       mode: "local" | "worktree";
       threadId?: ThreadId;
 @@ -261,14 +222,13 @@ export function gitPreparePullRequestThreadMutationOptions(input: {
       if (!input.cwd) throw new Error("Pull request thread preparation is unavailable.");
       return api.git.preparePullRequestThread({
         cwd: input.cwd,
-        reference,
+        reference: args.reference,
-        mode,
+        mode: args.mode,
-        ...(threadId ? { threadId } : {}),
+        ...(args.threadId ? { threadId: args.threadId } : {}),
       });
     },
-    mutationKey: gitMutationKeys.preparePullRequestThread(input.cwd),
+    onSuccess: async () => {
-    onSettled: async () => {
+      await invalidateGitBranchQueries(input.queryClient, input.cwd);
-      await invalidateGitQueries(input.queryClient);
     },
   });
 }

apps/web/src/lib/gitStatusState.test.ts created+112

...	@@ -0,0 +1,112 @@
1	import type { GitStatusResult } from "@t3tools/contracts";
2	import { afterEach, describe, expect, it, vi } from "vitest";
3
4	import {
5	getGitStatusSnapshot,
6	resetGitStatusStateForTests,
7	refreshGitStatus,
8	watchGitStatus,
9	} from "./gitStatusState";
10
11	function registerListener<T>(listeners: Set<(event: T) => void>, listener: (event: T) => void) {
12	listeners.add(listener);
13	return () => {
14	listeners.delete(listener);
15	};
16	}
17
18	const gitStatusListeners = new Set<(event: GitStatusResult) => void>();
19
20	const BASE_STATUS: GitStatusResult = {
21	isRepo: true,
22	hasOriginRemote: true,
23	isDefaultBranch: false,
24	branch: "feature/push-status",
25	hasWorkingTreeChanges: false,
26	workingTree: { files: [], insertions: 0, deletions: 0 },
27	hasUpstream: true,
28	aheadCount: 0,
29	behindCount: 0,
30	pr: null,
31	};
32
33	const gitClient = {
34	refreshStatus: vi.fn(async (input: { cwd: string }) => ({
35	...BASE_STATUS,
36	branch: `${input.cwd}-refreshed`,
37	})),
38	onStatus: vi.fn((input: { cwd: string }, listener: (event: GitStatusResult) => void) =>
39	registerListener(gitStatusListeners, listener),
40	),
41	};
42
43	function emitGitStatus(event: GitStatusResult) {
44	for (const listener of gitStatusListeners) {
45	listener(event);
46	}
47	}
48
49	afterEach(() => {
50	gitStatusListeners.clear();
51	gitClient.onStatus.mockClear();
52	gitClient.refreshStatus.mockClear();
53	resetGitStatusStateForTests();
54	});
55
56	describe("gitStatusState", () => {
57	it("starts fresh cwd state in a pending state", () => {
58	expect(getGitStatusSnapshot("/fresh")).toEqual({
59	data: null,
60	error: null,
61	cause: null,
62	isPending: true,
63	});
64	});
65
66	it("shares one live subscription per cwd and updates the per-cwd atom snapshot", () => {
67	const releaseA = watchGitStatus("/repo", gitClient);
68	const releaseB = watchGitStatus("/repo", gitClient);
69
70	expect(gitClient.onStatus).toHaveBeenCalledOnce();
71	expect(getGitStatusSnapshot("/repo")).toEqual({
72	data: null,
73	error: null,
74	cause: null,
75	isPending: true,
76	});
77
78	emitGitStatus(BASE_STATUS);
79
80	expect(getGitStatusSnapshot("/repo")).toEqual({
81	data: BASE_STATUS,
82	error: null,
83	cause: null,
84	isPending: false,
85	});
86
87	releaseA();
88	expect(gitStatusListeners.size).toBe(1);
89
90	releaseB();
91	expect(gitStatusListeners.size).toBe(0);
92	});
93
94	it("refreshes git status through the unary RPC without restarting the stream", async () => {
95	const release = watchGitStatus("/repo", gitClient);
96
97	emitGitStatus(BASE_STATUS);
98	const refreshed = await refreshGitStatus("/repo", gitClient);
99
100	expect(gitClient.onStatus).toHaveBeenCalledOnce();
101	expect(gitClient.refreshStatus).toHaveBeenCalledWith({ cwd: "/repo" });
102	expect(refreshed).toEqual({ ...BASE_STATUS, branch: "/repo-refreshed" });
103	expect(getGitStatusSnapshot("/repo")).toEqual({
104	data: BASE_STATUS,
105	error: null,
106	cause: null,
107	isPending: false,
108	});
109
110	release();
111	});
112	});

apps/web/src/lib/gitStatusState.ts created+223

...	@@ -0,0 +1,223 @@
1	import { useAtomValue } from "@effect/atom-react";
2	import { type GitManagerServiceError, type GitStatusResult } from "@t3tools/contracts";
3	import { Cause } from "effect";
4	import { Atom } from "effect/unstable/reactivity";
5	import { useEffect } from "react";
6
7	import { appAtomRegistry } from "../rpc/atomRegistry";
8	import { getWsRpcClient, type WsRpcClient } from "../wsRpcClient";
9
10	export type GitStatusStreamError = GitManagerServiceError;
11
12	export interface GitStatusState {
13	readonly data: GitStatusResult \| null;
14	readonly error: GitStatusStreamError \| null;
15	readonly cause: Cause.Cause<GitStatusStreamError> \| null;
16	readonly isPending: boolean;
17	}
18
19	type GitStatusClient = Pick<WsRpcClient["git"], "onStatus" \| "refreshStatus">;
20
21	interface WatchedGitStatus {
22	refCount: number;
23	unsubscribe: () => void;
24	}
25
26	const EMPTY_GIT_STATUS_STATE = Object.freeze<GitStatusState>({
27	data: null,
28	error: null,
29	cause: null,
30	isPending: false,
31	});
32	const INITIAL_GIT_STATUS_STATE = Object.freeze<GitStatusState>({
33	...EMPTY_GIT_STATUS_STATE,
34	isPending: true,
35	});
36	const EMPTY_GIT_STATUS_ATOM = Atom.make(EMPTY_GIT_STATUS_STATE).pipe(
37	Atom.keepAlive,
38	Atom.withLabel("git-status:null"),
39	);
40
41	const NOOP: () => void = () => undefined;
42	const watchedGitStatuses = new Map<string, WatchedGitStatus>();
43	const knownGitStatusCwds = new Set<string>();
44	const gitStatusRefreshInFlight = new Map<string, Promise<GitStatusResult>>();
45	const gitStatusLastRefreshAtByCwd = new Map<string, number>();
46
47	const GIT_STATUS_REFRESH_DEBOUNCE_MS = 1_000;
48
49	let sharedGitStatusClient: GitStatusClient \| null = null;
50
51	const gitStatusStateAtom = Atom.family((cwd: string) => {
52	knownGitStatusCwds.add(cwd);
53	return Atom.make(INITIAL_GIT_STATUS_STATE).pipe(
54	Atom.keepAlive,
55	Atom.withLabel(`git-status:${cwd}`),
56	);
57	});
58
59	export function getGitStatusSnapshot(cwd: string \| null): GitStatusState {
60	if (cwd === null) {
61	return EMPTY_GIT_STATUS_STATE;
62	}
63
64	return appAtomRegistry.get(gitStatusStateAtom(cwd));
65	}
66
67	export function watchGitStatus(
68	cwd: string \| null,
69	client: GitStatusClient = getWsRpcClient().git,
70	): () => void {
71	if (cwd === null) {
72	return NOOP;
73	}
74
75	ensureGitStatusClient(client);
76
77	const watched = watchedGitStatuses.get(cwd);
78	if (watched) {
79	watched.refCount += 1;
80	return () => unwatchGitStatus(cwd);
81	}
82
83	watchedGitStatuses.set(cwd, {
84	refCount: 1,
85	unsubscribe: subscribeToGitStatus(cwd),
86	});
87
88	return () => unwatchGitStatus(cwd);
89	}
90
91	export function refreshGitStatus(
92	cwd: string \| null,
93	client: GitStatusClient = getWsRpcClient().git,
94	): Promise<GitStatusResult \| null> {
95	if (cwd === null) {
96	return Promise.resolve(null);
97	}
98
99	ensureGitStatusClient(client);
100
101	const currentInFlight = gitStatusRefreshInFlight.get(cwd);
102	if (currentInFlight) {
103	return currentInFlight;
104	}
105
106	const lastRequestedAt = gitStatusLastRefreshAtByCwd.get(cwd) ?? 0;
107	if (Date.now() - lastRequestedAt < GIT_STATUS_REFRESH_DEBOUNCE_MS) {
108	return Promise.resolve(getGitStatusSnapshot(cwd).data);
109	}
110
111	gitStatusLastRefreshAtByCwd.set(cwd, Date.now());
112	const refreshPromise = client.refreshStatus({ cwd }).finally(() => {
113	gitStatusRefreshInFlight.delete(cwd);
114	});
115	gitStatusRefreshInFlight.set(cwd, refreshPromise);
116	return refreshPromise;
117	}
118
119	export function resetGitStatusStateForTests(): void {
120	for (const watched of watchedGitStatuses.values()) {
121	watched.unsubscribe();
122	}
123	watchedGitStatuses.clear();
124	gitStatusRefreshInFlight.clear();
125	gitStatusLastRefreshAtByCwd.clear();
126	sharedGitStatusClient = null;
127
128	for (const cwd of knownGitStatusCwds) {
129	appAtomRegistry.set(gitStatusStateAtom(cwd), INITIAL_GIT_STATUS_STATE);
130	}
131	knownGitStatusCwds.clear();
132	}
133
134	export function useGitStatus(cwd: string \| null): GitStatusState {
135	useEffect(() => watchGitStatus(cwd), [cwd]);
136
137	const state = useAtomValue(cwd !== null ? gitStatusStateAtom(cwd) : EMPTY_GIT_STATUS_ATOM);
138	return cwd === null ? EMPTY_GIT_STATUS_STATE : state;
139	}
140
141	function ensureGitStatusClient(client: GitStatusClient): void {
142	if (sharedGitStatusClient === client) {
143	return;
144	}
145
146	if (sharedGitStatusClient !== null) {
147	resetLiveGitStatusSubscriptions();
148	}
149
150	sharedGitStatusClient = client;
151	}
152
153	function resetLiveGitStatusSubscriptions(): void {
154	for (const watched of watchedGitStatuses.values()) {
155	watched.unsubscribe();
156	}
157	watchedGitStatuses.clear();
158	}
159
160	function unwatchGitStatus(cwd: string): void {
161	const watched = watchedGitStatuses.get(cwd);
162	if (!watched) {
163	return;
164	}
165
166	watched.refCount -= 1;
167	if (watched.refCount > 0) {
168	return;
169	}
170
171	watched.unsubscribe();
172	watchedGitStatuses.delete(cwd);
173	}
174
175	function subscribeToGitStatus(cwd: string): () => void {
176	const client = sharedGitStatusClient;
177	if (!client) {
178	return NOOP;
179	}
180
181	markGitStatusPending(cwd);
182	return client.onStatus(
183	{ cwd },
184	(status) => {
185	appAtomRegistry.set(gitStatusStateAtom(cwd), {
186	data: status,
187	error: null,
188	cause: null,
189	isPending: false,
190	});
191	},
192	{
193	onResubscribe: () => {
194	markGitStatusPending(cwd);
195	},
196	},
197	);
198	}
199
200	function markGitStatusPending(cwd: string): void {
201	const atom = gitStatusStateAtom(cwd);
202	const current = appAtomRegistry.get(atom);
203	const next =
204	current.data === null
205	? INITIAL_GIT_STATUS_STATE
206	: {
207	...current,
208	error: null,
209	cause: null,
210	isPending: true,
211	};
212
213	if (
214	current.data === next.data &&
215	current.error === next.error &&
216	current.cause === next.cause &&
217	current.isPending === next.isPending
218	) {
219	return;
220	}
221
222	appAtomRegistry.set(atom, next);
223	}

apps/web/src/nativeApi.ts+2-2

...	@@ -25,7 +25,7 @@ export function ensureNativeApi(): NativeApi {	...	@@ -25,7 +25,7 @@ export function ensureNativeApi(): NativeApi {
25	return api;	25	return api;
26	}	26	}
27		27
28	export function __resetNativeApiForTests() {	28	export async function __resetNativeApiForTests() {
29	cachedApi = undefined;	29	cachedApi = undefined;
30	__resetWsNativeApiForTests();	30	await __resetWsNativeApiForTests();
31	}	31	}

apps/web/src/wsNativeApi.test.ts+46-1

...	@@ -3,6 +3,7 @@ import {	...	@@ -3,6 +3,7 @@ import {
3	DEFAULT_SERVER_SETTINGS,	3	DEFAULT_SERVER_SETTINGS,
4	type DesktopBridge,	4	type DesktopBridge,
5	EventId,	5	EventId,
		6	type GitStatusResult,
6	ProjectId,	7	ProjectId,
7	type OrchestrationEvent,	8	type OrchestrationEvent,
8	type ServerConfig,	9	type ServerConfig,
...	@@ -31,6 +32,7 @@ function registerListener<T>(listeners: Set<(event: T) => void>, listener: (even	...	@@ -31,6 +32,7 @@ function registerListener<T>(listeners: Set<(event: T) => void>, listener: (even
31		32
32	const terminalEventListeners = new Set<(event: TerminalEvent) => void>();	33	const terminalEventListeners = new Set<(event: TerminalEvent) => void>();
33	const orchestrationEventListeners = new Set<(event: OrchestrationEvent) => void>();	34	const orchestrationEventListeners = new Set<(event: OrchestrationEvent) => void>();
		35	const gitStatusListeners = new Set<(event: GitStatusResult) => void>();
34		36
35	const rpcClientMock = {	37	const rpcClientMock = {
36	dispose: vi.fn(),	38	dispose: vi.fn(),
...	@@ -54,7 +56,10 @@ const rpcClientMock = {	...	@@ -54,7 +56,10 @@ const rpcClientMock = {
54	},	56	},
55	git: {	57	git: {
56	pull: vi.fn(),	58	pull: vi.fn(),
57	status: vi.fn(),	59	refreshStatus: vi.fn(),
		60	onStatus: vi.fn((input: { cwd: string }, listener: (event: GitStatusResult) => void) =>
		61	registerListener(gitStatusListeners, listener),
		62	),
58	runStackedAction: vi.fn(),	63	runStackedAction: vi.fn(),
59	listBranches: vi.fn(),	64	listBranches: vi.fn(),
60	createWorktree: vi.fn(),	65	createWorktree: vi.fn(),
...	@@ -168,12 +173,26 @@ const baseServerConfig: ServerConfig = {	...	@@ -168,12 +173,26 @@ const baseServerConfig: ServerConfig = {
168	settings: DEFAULT_SERVER_SETTINGS,	173	settings: DEFAULT_SERVER_SETTINGS,
169	};	174	};
170		175
		176	const baseGitStatus: GitStatusResult = {
		177	isRepo: true,
		178	hasOriginRemote: true,
		179	isDefaultBranch: false,
		180	branch: "feature/streamed",
		181	hasWorkingTreeChanges: false,
		182	workingTree: { files: [], insertions: 0, deletions: 0 },
		183	hasUpstream: true,
		184	aheadCount: 0,
		185	behindCount: 0,
		186	pr: null,
		187	};
		188
171	beforeEach(() => {	189	beforeEach(() => {
172	vi.resetModules();	190	vi.resetModules();
173	vi.clearAllMocks();	191	vi.clearAllMocks();
174	showContextMenuFallbackMock.mockReset();	192	showContextMenuFallbackMock.mockReset();
175	terminalEventListeners.clear();	193	terminalEventListeners.clear();
176	orchestrationEventListeners.clear();	194	orchestrationEventListeners.clear();
		195	gitStatusListeners.clear();
177	Reflect.deleteProperty(getWindowForTest(), "desktopBridge");	196	Reflect.deleteProperty(getWindowForTest(), "desktopBridge");
178	});	197	});
179		198
...	@@ -243,6 +262,32 @@ describe("wsNativeApi", () => {	...	@@ -243,6 +262,32 @@ describe("wsNativeApi", () => {
243	expect(onDomainEvent).toHaveBeenCalledWith(orchestrationEvent);	262	expect(onDomainEvent).toHaveBeenCalledWith(orchestrationEvent);
244	});	263	});
245		264
		265	it("forwards git status stream events", async () => {
		266	const { createWsNativeApi } = await import("./wsNativeApi");
		267
		268	const api = createWsNativeApi();
		269	const onStatus = vi.fn();
		270
		271	api.git.onStatus({ cwd: "/repo" }, onStatus);
		272
		273	const gitStatus = baseGitStatus;
		274	emitEvent(gitStatusListeners, gitStatus);
		275
		276	expect(rpcClientMock.git.onStatus).toHaveBeenCalledWith({ cwd: "/repo" }, onStatus, undefined);
		277	expect(onStatus).toHaveBeenCalledWith(gitStatus);
		278	});
		279
		280	it("forwards git status refreshes directly to the RPC client", async () => {
		281	rpcClientMock.git.refreshStatus.mockResolvedValue(baseGitStatus);
		282	const { createWsNativeApi } = await import("./wsNativeApi");
		283
		284	const api = createWsNativeApi();
		285
		286	await api.git.refreshStatus({ cwd: "/repo" });
		287
		288	expect(rpcClientMock.git.refreshStatus).toHaveBeenCalledWith({ cwd: "/repo" });
		289	});
		290
246	it("forwards orchestration stream subscription options to the RPC client", async () => {	291	it("forwards orchestration stream subscription options to the RPC client", async () => {
247	const { createWsNativeApi } = await import("./wsNativeApi");	292	const { createWsNativeApi } = await import("./wsNativeApi");
248		293

apps/web/src/wsNativeApi.ts+8-3

 @@ -1,6 +1,8 @@
 import { type ContextMenuItem, type NativeApi } from "@t3tools/contracts";
+import { resetGitStatusStateForTests } from "./lib/gitStatusState";
 import { showContextMenuFallback } from "./contextMenuFallback";
+import { __resetWsRpcAtomClientForTests } from "./rpc/client";
 import { resetRequestLatencyStateForTests } from "./rpc/requestLatencyState";
 import { resetServerStateForTests } from "./rpc/serverState";
 import { resetWsConnectionStateForTests } from "./rpc/wsConnectionState";
 @@ -8,9 +10,11 @@ import { __resetWsRpcClientForTests, getWsRpcClient } from "./wsRpcClient";
 let instance: { api: NativeApi } | null = null;
-export function __resetWsNativeApiForTests() {
+export async function __resetWsNativeApiForTests() {
   instance = null;
-  __resetWsRpcClientForTests();
+  await __resetWsRpcAtomClientForTests();
+  await __resetWsRpcClientForTests();
+  resetGitStatusStateForTests();
   resetRequestLatencyStateForTests();
   resetServerStateForTests();
   resetWsConnectionStateForTests();
 @@ -65,7 +69,8 @@ export function createWsNativeApi(): NativeApi {
     },
     git: {
       pull: rpcClient.git.pull,
-      status: rpcClient.git.status,
+      refreshStatus: rpcClient.git.refreshStatus,
+      onStatus: (input, callback, options) => rpcClient.git.onStatus(input, callback, options),
       listBranches: rpcClient.git.listBranches,
       createWorktree: rpcClient.git.createWorktree,
       removeWorktree: rpcClient.git.removeWorktree,

apps/web/src/wsRpcClient.test.ts created+94

...	@@ -0,0 +1,94 @@
1	import type {
2	GitStatusLocalResult,
3	GitStatusRemoteResult,
4	GitStatusStreamEvent,
5	} from "@t3tools/contracts";
6	import { describe, expect, it, vi } from "vitest";
7
8	import { createWsRpcClient } from "./wsRpcClient";
9	import { type WsTransport } from "./wsTransport";
10
11	const baseLocalStatus: GitStatusLocalResult = {
12	isRepo: true,
13	hasOriginRemote: true,
14	isDefaultBranch: false,
15	branch: "feature/demo",
16	hasWorkingTreeChanges: false,
17	workingTree: { files: [], insertions: 0, deletions: 0 },
18	};
19
20	const baseRemoteStatus: GitStatusRemoteResult = {
21	hasUpstream: true,
22	aheadCount: 0,
23	behindCount: 0,
24	pr: null,
25	};
26
27	describe("wsRpcClient", () => {
28	it("reduces git status stream events into flat status snapshots", () => {
29	const subscribe = vi.fn(<TValue>(_connect: unknown, listener: (value: TValue) => void) => {
30	for (const event of [
31	{
32	_tag: "snapshot",
33	local: baseLocalStatus,
34	remote: null,
35	},
36	{
37	_tag: "remoteUpdated",
38	remote: baseRemoteStatus,
39	},
40	{
41	_tag: "localUpdated",
42	local: {
43	...baseLocalStatus,
44	hasWorkingTreeChanges: true,
45	},
46	},
47	] satisfies GitStatusStreamEvent[]) {
48	listener(event as TValue);
49	}
50	return () => undefined;
51	});
52
53	const transport = {
54	dispose: vi.fn(async () => undefined),
55	reconnect: vi.fn(async () => undefined),
56	request: vi.fn(),
57	requestStream: vi.fn(),
58	subscribe,
59	} satisfies Pick<
60	WsTransport,
61	"dispose" \| "reconnect" \| "request" \| "requestStream" \| "subscribe"
62	>;
63
64	const client = createWsRpcClient(transport as unknown as WsTransport);
65	const listener = vi.fn();
66
67	client.git.onStatus({ cwd: "/repo" }, listener);
68
69	expect(listener.mock.calls).toEqual([
70	[
71	{
72	...baseLocalStatus,
73	hasUpstream: false,
74	aheadCount: 0,
75	behindCount: 0,
76	pr: null,
77	},
78	],
79	[
80	{
81	...baseLocalStatus,
82	...baseRemoteStatus,
83	},
84	],
85	[
86	{
87	...baseLocalStatus,
88	...baseRemoteStatus,
89	hasWorkingTreeChanges: true,
90	},
91	],
92	]);
93	});
94	});

apps/web/src/wsRpcClient.ts+22-2

 @@ -2,11 +2,14 @@ import {
   type GitActionProgressEvent,
   type GitRunStackedActionInput,
   type GitRunStackedActionResult,
+  type GitStatusResult,
+  type GitStatusStreamEvent,
   type NativeApi,
   ORCHESTRATION_WS_METHODS,
   type ServerSettingsPatch,
   WS_METHODS,
 } from "@t3tools/contracts";
+import { applyGitStatusStreamEvent } from "@t3tools/shared/git";
 import { Effect, Stream } from "effect";
 import { type WsRpcProtocolClient } from "./rpc/protocol";
 @@ -64,7 +67,12 @@ export interface WsRpcClient {
   };
   readonly git: {
     readonly pull: RpcUnaryMethod<typeof WS_METHODS.gitPull>;
-    readonly status: RpcUnaryMethod<typeof WS_METHODS.gitStatus>;
+    readonly refreshStatus: RpcUnaryMethod<typeof WS_METHODS.gitRefreshStatus>;
+    readonly onStatus: (
+      input: RpcInput<typeof WS_METHODS.subscribeGitStatus>,
+      listener: (status: GitStatusResult) => void,
+      options?: StreamSubscriptionOptions,
+    ) => () => void;
     readonly runStackedAction: (
       input: GitRunStackedActionInput,
       options?: GitRunStackedActionOptions,
 @@ -149,7 +157,19 @@ export function createWsRpcClient(transport = new WsTransport()): WsRpcClient {
     },
     git: {
       pull: (input) => transport.request((client) => client[WS_METHODS.gitPull](input)),
-      status: (input) => transport.request((client) => client[WS_METHODS.gitStatus](input)),
+      refreshStatus: (input) =>
+        transport.request((client) => client[WS_METHODS.gitRefreshStatus](input)),
+      onStatus: (input, listener, options) => {
+        let current: GitStatusResult | null = null;
+        return transport.subscribe(
+          (client) => client[WS_METHODS.subscribeGitStatus](input),
+          (event: GitStatusStreamEvent) => {
+            current = applyGitStatusStreamEvent(current, event);
+            listener(current);
+          },
+          options,
+        );
+      },
       runStackedAction: async (input, options) => {
         let result: GitRunStackedActionResult | null = null;

apps/web/test/wsRpcHarness.ts+2-1

...	@@ -24,6 +24,7 @@ interface BrowserWsRpcHarnessOptions {	...	@@ -24,6 +24,7 @@ interface BrowserWsRpcHarnessOptions {
24		24
25	const STREAM_METHODS = new Set<string>([	25	const STREAM_METHODS = new Set<string>([
26	WS_METHODS.gitRunStackedAction,	26	WS_METHODS.gitRunStackedAction,
		27	WS_METHODS.subscribeGitStatus,
27	WS_METHODS.subscribeOrchestrationDomainEvents,	28	WS_METHODS.subscribeOrchestrationDomainEvents,
28	WS_METHODS.subscribeTerminalEvents,	29	WS_METHODS.subscribeTerminalEvents,
29	WS_METHODS.subscribeServerConfig,	30	WS_METHODS.subscribeServerConfig,
...	@@ -108,7 +109,7 @@ export class BrowserWsRpcHarness {	...	@@ -108,7 +109,7 @@ export class BrowserWsRpcHarness {
108	async onMessage(rawData: string): Promise<void> {	109	async onMessage(rawData: string): Promise<void> {
109	const server = await this.serverReady;	110	const server = await this.serverReady;
110	if (!server) {	111	if (!server) {
111	throw new Error("RPC test server is not connected");	112	return;
112	}	113	}
113	const messages = this.parser.decode(rawData);	114	const messages = this.parser.decode(rawData);
114	for (const message of messages) {	115	for (const message of messages) {

packages/contracts/src/git.ts+49-1

...	@@ -44,6 +44,14 @@ const GitStatusPrState = Schema.Literals(["open", "closed", "merged"]);	...	@@ -44,6 +44,14 @@ const GitStatusPrState = Schema.Literals(["open", "closed", "merged"]);
44	const GitPullRequestReference = TrimmedNonEmptyStringSchema;	44	const GitPullRequestReference = TrimmedNonEmptyStringSchema;
45	const GitPullRequestState = Schema.Literals(["open", "closed", "merged"]);	45	const GitPullRequestState = Schema.Literals(["open", "closed", "merged"]);
46	const GitPreparePullRequestThreadMode = Schema.Literals(["local", "worktree"]);	46	const GitPreparePullRequestThreadMode = Schema.Literals(["local", "worktree"]);
		47	export const GitHostingProviderKind = Schema.Literals(["github", "gitlab", "unknown"]);
		48	export type GitHostingProviderKind = typeof GitHostingProviderKind.Type;
		49	export const GitHostingProvider = Schema.Struct({
		50	kind: GitHostingProviderKind,
		51	name: TrimmedNonEmptyStringSchema,
		52	baseUrl: Schema.String,
		53	});
		54	export type GitHostingProvider = typeof GitHostingProvider.Type;
47	export const GitRunStackedActionToastRunAction = Schema.Struct({	55	export const GitRunStackedActionToastRunAction = Schema.Struct({
48	kind: GitStackedAction,	56	kind: GitStackedAction,
49	});	57	});
...	@@ -161,9 +169,15 @@ export type GitRemoveWorktreeInput = typeof GitRemoveWorktreeInput.Type;	...	@@ -161,9 +169,15 @@ export type GitRemoveWorktreeInput = typeof GitRemoveWorktreeInput.Type;
161	export const GitCreateBranchInput = Schema.Struct({	169	export const GitCreateBranchInput = Schema.Struct({
162	cwd: TrimmedNonEmptyStringSchema,	170	cwd: TrimmedNonEmptyStringSchema,
163	branch: TrimmedNonEmptyStringSchema,	171	branch: TrimmedNonEmptyStringSchema,
		172	checkout: Schema.optional(Schema.Boolean),
164	});	173	});
165	export type GitCreateBranchInput = typeof GitCreateBranchInput.Type;	174	export type GitCreateBranchInput = typeof GitCreateBranchInput.Type;
166		175
		176	export const GitCreateBranchResult = Schema.Struct({
		177	branch: TrimmedNonEmptyStringSchema,
		178	});
		179	export type GitCreateBranchResult = typeof GitCreateBranchResult.Type;
		180
167	export const GitCheckoutInput = Schema.Struct({	181	export const GitCheckoutInput = Schema.Struct({
168	cwd: TrimmedNonEmptyStringSchema,	182	cwd: TrimmedNonEmptyStringSchema,
169	branch: TrimmedNonEmptyStringSchema,	183	branch: TrimmedNonEmptyStringSchema,
...	@@ -186,8 +200,9 @@ const GitStatusPr = Schema.Struct({	...	@@ -186,8 +200,9 @@ const GitStatusPr = Schema.Struct({
186	state: GitStatusPrState,	200	state: GitStatusPrState,
187	});	201	});
188		202
189	export const GitStatusResult = Schema.Struct({	203	const GitStatusLocalShape = {
190	isRepo: Schema.Boolean,	204	isRepo: Schema.Boolean,
		205	hostingProvider: Schema.optional(GitHostingProvider),
191	hasOriginRemote: Schema.Boolean,	206	hasOriginRemote: Schema.Boolean,
192	isDefaultBranch: Schema.Boolean,	207	isDefaultBranch: Schema.Boolean,
193	branch: Schema.NullOr(TrimmedNonEmptyStringSchema),	208	branch: Schema.NullOr(TrimmedNonEmptyStringSchema),
...	@@ -203,13 +218,41 @@ export const GitStatusResult = Schema.Struct({	...	@@ -203,13 +218,41 @@ export const GitStatusResult = Schema.Struct({
203	insertions: NonNegativeInt,	218	insertions: NonNegativeInt,
204	deletions: NonNegativeInt,	219	deletions: NonNegativeInt,
205	}),	220	}),
		221	};
		222
		223	const GitStatusRemoteShape = {
206	hasUpstream: Schema.Boolean,	224	hasUpstream: Schema.Boolean,
207	aheadCount: NonNegativeInt,	225	aheadCount: NonNegativeInt,
208	behindCount: NonNegativeInt,	226	behindCount: NonNegativeInt,
209	pr: Schema.NullOr(GitStatusPr),	227	pr: Schema.NullOr(GitStatusPr),
		228	};
		229
		230	export const GitStatusLocalResult = Schema.Struct(GitStatusLocalShape);
		231	export type GitStatusLocalResult = typeof GitStatusLocalResult.Type;
		232
		233	export const GitStatusRemoteResult = Schema.Struct(GitStatusRemoteShape);
		234	export type GitStatusRemoteResult = typeof GitStatusRemoteResult.Type;
		235
		236	export const GitStatusResult = Schema.Struct({
		237	...GitStatusLocalShape,
		238	...GitStatusRemoteShape,
210	});	239	});
211	export type GitStatusResult = typeof GitStatusResult.Type;	240	export type GitStatusResult = typeof GitStatusResult.Type;
212		241
		242	export const GitStatusStreamEvent = Schema.Union([
		243	Schema.TaggedStruct("snapshot", {
		244	local: GitStatusLocalResult,
		245	remote: Schema.NullOr(GitStatusRemoteResult),
		246	}),
		247	Schema.TaggedStruct("localUpdated", {
		248	local: GitStatusLocalResult,
		249	}),
		250	Schema.TaggedStruct("remoteUpdated", {
		251	remote: Schema.NullOr(GitStatusRemoteResult),
		252	}),
		253	]);
		254	export type GitStatusStreamEvent = typeof GitStatusStreamEvent.Type;
		255
213	export const GitListBranchesResult = Schema.Struct({	256	export const GitListBranchesResult = Schema.Struct({
214	branches: Schema.Array(GitBranch),	257	branches: Schema.Array(GitBranch),
215	isRepo: Schema.Boolean,	258	isRepo: Schema.Boolean,
...	@@ -236,6 +279,11 @@ export const GitPreparePullRequestThreadResult = Schema.Struct({	...	@@ -236,6 +279,11 @@ export const GitPreparePullRequestThreadResult = Schema.Struct({
236	});	279	});
237	export type GitPreparePullRequestThreadResult = typeof GitPreparePullRequestThreadResult.Type;	280	export type GitPreparePullRequestThreadResult = typeof GitPreparePullRequestThreadResult.Type;
238		281
		282	export const GitCheckoutResult = Schema.Struct({
		283	branch: Schema.NullOr(TrimmedNonEmptyStringSchema),
		284	});
		285	export type GitCheckoutResult = typeof GitCheckoutResult.Type;
		286
239	export const GitRunStackedActionResult = Schema.Struct({	287	export const GitRunStackedActionResult = Schema.Struct({
240	action: GitStackedAction,	288	action: GitStackedAction,
241	branch: Schema.Struct({	289	branch: Schema.Struct({

packages/contracts/src/ipc.ts+12-3

...	@@ -1,5 +1,6 @@	...	@@ -1,5 +1,6 @@
1	import type {	1	import type {
2	GitCheckoutInput,	2	GitCheckoutInput,
		3	GitCheckoutResult,
3	GitCreateBranchInput,	4	GitCreateBranchInput,
4	GitPreparePullRequestThreadInput,	5	GitPreparePullRequestThreadInput,
5	GitPreparePullRequestThreadResult,	6	GitPreparePullRequestThreadResult,
...	@@ -15,6 +16,7 @@ import type {	...	@@ -15,6 +16,7 @@ import type {
15	GitResolvePullRequestResult,	16	GitResolvePullRequestResult,
16	GitStatusInput,	17	GitStatusInput,
17	GitStatusResult,	18	GitStatusResult,
		19	GitCreateBranchResult,
18	} from "./git";	20	} from "./git";
19	import type {	21	import type {
20	ProjectSearchEntriesInput,	22	ProjectSearchEntriesInput,
...	@@ -148,8 +150,8 @@ export interface NativeApi {	...	@@ -148,8 +150,8 @@ export interface NativeApi {
148	listBranches: (input: GitListBranchesInput) => Promise<GitListBranchesResult>;	150	listBranches: (input: GitListBranchesInput) => Promise<GitListBranchesResult>;
149	createWorktree: (input: GitCreateWorktreeInput) => Promise<GitCreateWorktreeResult>;	151	createWorktree: (input: GitCreateWorktreeInput) => Promise<GitCreateWorktreeResult>;
150	removeWorktree: (input: GitRemoveWorktreeInput) => Promise<void>;	152	removeWorktree: (input: GitRemoveWorktreeInput) => Promise<void>;
151	createBranch: (input: GitCreateBranchInput) => Promise<void>;	153	createBranch: (input: GitCreateBranchInput) => Promise<GitCreateBranchResult>;
152	checkout: (input: GitCheckoutInput) => Promise<void>;	154	checkout: (input: GitCheckoutInput) => Promise<GitCheckoutResult>;
153	init: (input: GitInitInput) => Promise<void>;	155	init: (input: GitInitInput) => Promise<void>;
154	resolvePullRequest: (input: GitPullRequestRefInput) => Promise<GitResolvePullRequestResult>;	156	resolvePullRequest: (input: GitPullRequestRefInput) => Promise<GitResolvePullRequestResult>;
155	preparePullRequestThread: (	157	preparePullRequestThread: (
...	@@ -157,7 +159,14 @@ export interface NativeApi {	...	@@ -157,7 +159,14 @@ export interface NativeApi {
157	) => Promise<GitPreparePullRequestThreadResult>;	159	) => Promise<GitPreparePullRequestThreadResult>;
158	// Stacked action API	160	// Stacked action API
159	pull: (input: GitPullInput) => Promise<GitPullResult>;	161	pull: (input: GitPullInput) => Promise<GitPullResult>;
160	status: (input: GitStatusInput) => Promise<GitStatusResult>;	162	refreshStatus: (input: GitStatusInput) => Promise<GitStatusResult>;
		163	onStatus: (
		164	input: GitStatusInput,
		165	callback: (status: GitStatusResult) => void,
		166	options?: {
		167	onResubscribe?: () => void;
		168	},
		169	) => () => void;
161	};	170	};
162	contextMenu: {	171	contextMenu: {
163	show: <T extends string>(	172	show: <T extends string>(

packages/contracts/src/rpc.ts+18-4

 @@ -6,8 +6,10 @@ import { OpenError, OpenInEditorInput } from "./editor";
 import {
   GitActionProgressEvent,
   GitCheckoutInput,
+  GitCheckoutResult,
   GitCommandError,
   GitCreateBranchInput,
+  GitCreateBranchResult,
   GitCreateWorktreeInput,
   GitCreateWorktreeResult,
   GitInitInput,
 @@ -24,6 +26,7 @@ import {
   GitRunStackedActionInput,
   GitStatusInput,
   GitStatusResult,
+  GitStatusStreamEvent,
 } from "./git";
 import { KeybindingsConfigError } from "./keybindings";
 import {
 @@ -83,7 +86,7 @@ export const WS_METHODS = {
   // Git methods
   gitPull: "git.pull",
-  gitStatus: "git.status",
+  gitRefreshStatus: "git.refreshStatus",
   gitRunStackedAction: "git.runStackedAction",
   gitListBranches: "git.listBranches",
   gitCreateWorktree: "git.createWorktree",
 @@ -110,6 +113,7 @@ export const WS_METHODS = {
   serverUpdateSettings: "server.updateSettings",
   // Streaming subscriptions
+  subscribeGitStatus: "subscribeGitStatus",
   subscribeOrchestrationDomainEvents: "subscribeOrchestrationDomainEvents",
   subscribeTerminalEvents: "subscribeTerminalEvents",
   subscribeServerConfig: "subscribeServerConfig",
 @@ -162,10 +166,11 @@ export const WsShellOpenInEditorRpc = Rpc.make(WS_METHODS.shellOpenInEditor, {
   error: OpenError,
 });
-export const WsGitStatusRpc = Rpc.make(WS_METHODS.gitStatus, {
+export const WsSubscribeGitStatusRpc = Rpc.make(WS_METHODS.subscribeGitStatus, {
   payload: GitStatusInput,
-  success: GitStatusResult,
+  success: GitStatusStreamEvent,
   error: GitManagerServiceError,
+  stream: true,
 });
 export const WsGitPullRpc = Rpc.make(WS_METHODS.gitPull, {
 @@ -174,6 +179,12 @@ export const WsGitPullRpc = Rpc.make(WS_METHODS.gitPull, {
   error: GitCommandError,
 });
+export const WsGitRefreshStatusRpc = Rpc.make(WS_METHODS.gitRefreshStatus, {
+  payload: GitStatusInput,
+  success: GitStatusResult,
+  error: GitManagerServiceError,
+});
 export const WsGitRunStackedActionRpc = Rpc.make(WS_METHODS.gitRunStackedAction, {
   payload: GitRunStackedActionInput,
   success: GitActionProgressEvent,
 @@ -212,11 +223,13 @@ export const WsGitRemoveWorktreeRpc = Rpc.make(WS_METHODS.gitRemoveWorktree, {
 export const WsGitCreateBranchRpc = Rpc.make(WS_METHODS.gitCreateBranch, {
   payload: GitCreateBranchInput,
+  success: GitCreateBranchResult,
   error: GitCommandError,
 });
 export const WsGitCheckoutRpc = Rpc.make(WS_METHODS.gitCheckout, {
   payload: GitCheckoutInput,
+  success: GitCheckoutResult,
   error: GitCommandError,
 });
 @@ -330,8 +343,9 @@ export const WsRpcGroup = RpcGroup.make(
   WsProjectsSearchEntriesRpc,
   WsProjectsWriteFileRpc,
   WsShellOpenInEditorRpc,
-  WsGitStatusRpc,
+  WsSubscribeGitStatusRpc,
   WsGitPullRpc,
+  WsGitRefreshStatusRpc,
   WsGitRunStackedActionRpc,
   WsGitResolvePullRequestRpc,
   WsGitPreparePullRequestThreadRpc,

packages/shared/src/git.test.ts created+67

...	@@ -0,0 +1,67 @@
1	import type { GitStatusRemoteResult, GitStatusResult } from "@t3tools/contracts";
2	import { describe, expect, it } from "vitest";
3
4	import { applyGitStatusStreamEvent } from "./git";
5
6	describe("applyGitStatusStreamEvent", () => {
7	it("treats a remote-only update as a repository when local state is missing", () => {
8	const remote: GitStatusRemoteResult = {
9	hasUpstream: true,
10	aheadCount: 2,
11	behindCount: 1,
12	pr: null,
13	};
14
15	expect(applyGitStatusStreamEvent(null, { _tag: "remoteUpdated", remote })).toEqual({
16	isRepo: true,
17	hasOriginRemote: false,
18	isDefaultBranch: false,
19	branch: null,
20	hasWorkingTreeChanges: false,
21	workingTree: { files: [], insertions: 0, deletions: 0 },
22	hasUpstream: true,
23	aheadCount: 2,
24	behindCount: 1,
25	pr: null,
26	});
27	});
28
29	it("preserves local-only fields when applying a remote update", () => {
30	const current: GitStatusResult = {
31	isRepo: true,
32	hostingProvider: {
33	kind: "github",
34	name: "GitHub",
35	baseUrl: "https://github.com",
36	},
37	hasOriginRemote: true,
38	isDefaultBranch: false,
39	branch: "feature/demo",
40	hasWorkingTreeChanges: true,
41	workingTree: {
42	files: [{ path: "src/demo.ts", insertions: 1, deletions: 0 }],
43	insertions: 1,
44	deletions: 0,
45	},
46	hasUpstream: false,
47	aheadCount: 0,
48	behindCount: 0,
49	pr: null,
50	};
51
52	const remote: GitStatusRemoteResult = {
53	hasUpstream: true,
54	aheadCount: 2,
55	behindCount: 1,
56	pr: null,
57	};
58
59	expect(applyGitStatusStreamEvent(current, { _tag: "remoteUpdated", remote })).toEqual({
60	...current,
61	hasUpstream: true,
62	aheadCount: 2,
63	behindCount: 1,
64	pr: null,
65	});
66	});
67	});

packages/shared/src/git.ts+138-1

...	@@ -1,4 +1,11 @@	...	@@ -1,4 +1,11 @@
1	import type { GitBranch } from "@t3tools/contracts";	1	import type {
		2	GitBranch,
		3	GitHostingProvider,
		4	GitStatusLocalResult,
		5	GitStatusRemoteResult,
		6	GitStatusResult,
		7	GitStatusStreamEvent,
		8	} from "@t3tools/contracts";
2		9
3	/**	10	/**
4	* Sanitize an arbitrary string into a valid, lowercase git branch fragment.	11	* Sanitize an arbitrary string into a valid, lowercase git branch fragment.
...	@@ -119,3 +126,133 @@ export function dedupeRemoteBranchesWithLocalMatches(	...	@@ -119,3 +126,133 @@ export function dedupeRemoteBranchesWithLocalMatches(
119	return !localBranchCandidates.some((candidate) => localBranchNames.has(candidate));	126	return !localBranchCandidates.some((candidate) => localBranchNames.has(candidate));
120	});	127	});
121	}	128	}
		129
		130	function parseGitRemoteHost(remoteUrl: string): string \| null {
		131	const trimmed = remoteUrl.trim();
		132	if (trimmed.length === 0) {
		133	return null;
		134	}
		135
		136	if (trimmed.startsWith("git@")) {
		137	const hostWithPath = trimmed.slice("git@".length);
		138	const separatorIndex = hostWithPath.search(/[:/]/);
		139	if (separatorIndex <= 0) {
		140	return null;
		141	}
		142	return hostWithPath.slice(0, separatorIndex).toLowerCase();
		143	}
		144
		145	try {
		146	return new URL(trimmed).hostname.toLowerCase();
		147	} catch {
		148	return null;
		149	}
		150	}
		151
		152	function toBaseUrl(host: string): string {
		153	return `https://${host}`;
		154	}
		155
		156	function isGitHubHost(host: string): boolean {
		157	return host === "github.com" \|\| host.includes("github");
		158	}
		159
		160	function isGitLabHost(host: string): boolean {
		161	return host === "gitlab.com" \|\| host.includes("gitlab");
		162	}
		163
		164	export function detectGitHostingProviderFromRemoteUrl(
		165	remoteUrl: string,
		166	): GitHostingProvider \| null {
		167	const host = parseGitRemoteHost(remoteUrl);
		168	if (!host) {
		169	return null;
		170	}
		171
		172	if (isGitHubHost(host)) {
		173	return {
		174	kind: "github",
		175	name: host === "github.com" ? "GitHub" : "GitHub Self-Hosted",
		176	baseUrl: toBaseUrl(host),
		177	};
		178	}
		179
		180	if (isGitLabHost(host)) {
		181	return {
		182	kind: "gitlab",
		183	name: host === "gitlab.com" ? "GitLab" : "GitLab Self-Hosted",
		184	baseUrl: toBaseUrl(host),
		185	};
		186	}
		187
		188	return {
		189	kind: "unknown",
		190	name: host,
		191	baseUrl: toBaseUrl(host),
		192	};
		193	}
		194
		195	const EMPTY_GIT_STATUS_REMOTE: GitStatusRemoteResult = {
		196	hasUpstream: false,
		197	aheadCount: 0,
		198	behindCount: 0,
		199	pr: null,
		200	};
		201
		202	export function mergeGitStatusParts(
		203	local: GitStatusLocalResult,
		204	remote: GitStatusRemoteResult \| null,
		205	): GitStatusResult {
		206	return {
		207	...local,
		208	...(remote ?? EMPTY_GIT_STATUS_REMOTE),
		209	};
		210	}
		211
		212	function toRemoteStatusPart(status: GitStatusResult): GitStatusRemoteResult {
		213	return {
		214	hasUpstream: status.hasUpstream,
		215	aheadCount: status.aheadCount,
		216	behindCount: status.behindCount,
		217	pr: status.pr,
		218	};
		219	}
		220
		221	function toLocalStatusPart(status: GitStatusResult): GitStatusLocalResult {
		222	return {
		223	isRepo: status.isRepo,
		224	...(status.hostingProvider ? { hostingProvider: status.hostingProvider } : {}),
		225	hasOriginRemote: status.hasOriginRemote,
		226	isDefaultBranch: status.isDefaultBranch,
		227	branch: status.branch,
		228	hasWorkingTreeChanges: status.hasWorkingTreeChanges,
		229	workingTree: status.workingTree,
		230	};
		231	}
		232
		233	export function applyGitStatusStreamEvent(
		234	current: GitStatusResult \| null,
		235	event: GitStatusStreamEvent,
		236	): GitStatusResult {
		237	switch (event._tag) {
		238	case "snapshot":
		239	return mergeGitStatusParts(event.local, event.remote);
		240	case "localUpdated":
		241	return mergeGitStatusParts(event.local, current ? toRemoteStatusPart(current) : null);
		242	case "remoteUpdated":
		243	if (current === null) {
		244	return mergeGitStatusParts(
		245	{
		246	isRepo: true,
		247	hasOriginRemote: false,
		248	isDefaultBranch: false,
		249	branch: null,
		250	hasWorkingTreeChanges: false,
		251	workingTree: { files: [], insertions: 0, deletions: 0 },
		252	},
		253	event.remote,
		254	);
		255	}
		256	return mergeGitStatusParts(toLocalStatusPart(current), event.remote);
		257	}
		258	}

author	Julius Marminge <julius0216@outlook.com> 2026-04-06 09:26:29-07:00
committer	GitHub <noreply@github.com> 2026-04-06 09:26:29-07:00
log	53a552e80d5783c1824a81dbe0d8e49302601e31
tree	ddc70effa1f45eebff912321b22568c6bcfc2261
parent	cf2c628bc005f3c88911a6fcb957f56e6d1ce45f
signature	Signed by PGP key B5690EEEBB952194

...	@@ -27,7 +27,7 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } fr	...	@@ -27,7 +27,7 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } fr
27	import { useQuery } from "@tanstack/react-query";	27	import { useQuery } from "@tanstack/react-query";
28	import { useDebouncedValue } from "@tanstack/react-pacer";	28	import { useDebouncedValue } from "@tanstack/react-pacer";
29	import { useNavigate, useSearch } from "@tanstack/react-router";	29	import { useNavigate, useSearch } from "@tanstack/react-router";
30	import { gitStatusQueryOptions } from "~/lib/gitReactQuery";	30	import { useGitStatus } from "~/lib/gitStatusState";
31	import { projectSearchEntriesQueryOptions } from "~/lib/projectReactQuery";	31	import { projectSearchEntriesQueryOptions } from "~/lib/projectReactQuery";
32	import { isElectron } from "../env";	32	import { isElectron } from "../env";
33	import { parseDiffRouteSearch, stripDiffSearchParams } from "../diffRouteSearch";	33	import { parseDiffRouteSearch, stripDiffSearchParams } from "../diffRouteSearch";
...	@@ -1399,7 +1399,7 @@ export default function ChatView({ threadId }: ChatViewProps) {	...	@@ -1399,7 +1399,7 @@ export default function ChatView({ threadId }: ChatViewProps) {
1399	(debouncerState) => ({ isPending: debouncerState.isPending }),	1399	(debouncerState) => ({ isPending: debouncerState.isPending }),
1400	);	1400	);
1401	const effectivePathQuery = pathTriggerQuery.length > 0 ? debouncedPathQuery : "";	1401	const effectivePathQuery = pathTriggerQuery.length > 0 ? debouncedPathQuery : "";
1402	const gitStatusQuery = useQuery(gitStatusQueryOptions(gitCwd));	1402	const gitStatusQuery = useGitStatus(gitCwd);
1403	const keybindings = useServerKeybindings();	1403	const keybindings = useServerKeybindings();
1404	const availableEditors = useServerAvailableEditors();	1404	const availableEditors = useServerAvailableEditors();
1405	const modelOptionsByProvider = useMemo(	1405	const modelOptionsByProvider = useMemo(

...	@@ -19,7 +19,7 @@ import {	...	@@ -19,7 +19,7 @@ import {
19	useState,	19	useState,
20	} from "react";	20	} from "react";
21	import { openInPreferredEditor } from "../editorPreferences";	21	import { openInPreferredEditor } from "../editorPreferences";
22	import { gitStatusQueryOptions } from "~/lib/gitReactQuery";	22	import { useGitStatus } from "~/lib/gitStatusState";
23	import { checkpointDiffQueryOptions } from "~/lib/providerReactQuery";	23	import { checkpointDiffQueryOptions } from "~/lib/providerReactQuery";
24	import { cn } from "~/lib/utils";	24	import { cn } from "~/lib/utils";
25	import { readNativeApi } from "../nativeApi";	25	import { readNativeApi } from "../nativeApi";
...	@@ -189,7 +189,7 @@ export default function DiffPanel({ mode = "inline" }: DiffPanelProps) {	...	@@ -189,7 +189,7 @@ export default function DiffPanel({ mode = "inline" }: DiffPanelProps) {
189	activeProjectId ? store.projects.find((project) => project.id === activeProjectId) : undefined,	189	activeProjectId ? store.projects.find((project) => project.id === activeProjectId) : undefined,
190	);	190	);
191	const activeCwd = activeThread?.worktreePath ?? activeProject?.cwd;	191	const activeCwd = activeThread?.worktreePath ?? activeProject?.cwd;
192	const gitStatusQuery = useQuery(gitStatusQueryOptions(activeCwd ?? null));	192	const gitStatusQuery = useGitStatus(activeCwd ?? null);
193	const isGitRepo = gitStatusQuery.data?.isRepo ?? true;	193	const isGitRepo = gitStatusQuery.data?.isRepo ?? true;
194	const { turnDiffSummaries, inferredCheckpointTurnCountByTurnId } =	194	const { turnDiffSummaries, inferredCheckpointTurnCountByTurnId } =
195	useTurnDiffSummaries(activeThread);	195	useTurnDiffSummaries(activeThread);

Stream git status updates over WebSocket (#1763)