@@ -2875,6 +2875,116 @@ it.layer(layerTest)("GitVcsDriver core integration", (it) => {
         }),
     );
 
+    it.effect.each([
+      "object format",
+      "configuration",
+      "initialization",
+      "read target",
+      "resolve",
+      "promote ref",
+      "read promoted target",
+      "shared budget",
+    ] as const)("bounds the complete status fetch when %s stalls", (stage) =>
+      Effect.gen(function* () {
+        const cwd = yield* makeTmpDir();
+        const remote = yield* makeTmpDir("git-vcs-driver-remote-");
+        const updater = yield* makeTmpDir("git-vcs-driver-updater-");
+        const { initialBranch } = yield* initRepoWithCommit(cwd);
+        const originalCommit = yield* git(cwd, ["rev-parse", "HEAD"]);
+        yield* git(remote, ["init", "--bare"]);
+        yield* git(cwd, ["remote", "add", "origin", remote]);
+        yield* git(cwd, ["push", "-u", "origin", initialBranch]);
+        yield* git(updater, ["clone", "--branch", initialBranch, remote, "."]);
+        yield* git(updater, ["config", "user.email", "[email protected]"]);
+        yield* git(updater, ["config", "user.name", "Test"]);
+        yield* writeTextFile(updater, "remote.txt", "remote update\n");
+        yield* git(updater, ["add", "remote.txt"]);
+        yield* git(updater, ["commit", "-m", "remote update"]);
+        yield* git(updater, ["push"]);
+
+        const delegate = yield* ChildProcessSpawner.ChildProcessSpawner;
+        const blocked = yield* Deferred.make<void>();
+        const release = yield* Deferred.make<void>();
+        const interrupted = yield* Deferred.make<void>();
+        const preparationBlocked = yield* Deferred.make<void>();
+        const releasePreparation = yield* Deferred.make<void>();
+        let targetReads = 0;
+        let attempts = 0;
+        const spawner = ChildProcessSpawner.make((command) =>
+          Effect.gen(function* () {
+            if (ChildProcess.isStandardCommand(command)) {
+              const args = command.args;
+              if (stage === "shared budget" && args.includes("extensions.objectFormat")) {
+                yield* Deferred.succeed(preparationBlocked, undefined);
+                yield* Deferred.await(releasePreparation);
+              }
+              const readsTarget =
+                args.includes("rev-parse") &&
+                args.at(-1) === `refs/remotes/origin/${initialBranch}`;
+              if (readsTarget) targetReads += 1;
+              if (stage === "read promoted target" && args.includes("update-ref")) {
+                return ChildProcessSpawner.makeHandle({
+                  ...makeSuccessfulHandle(""),
+                  exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(1)),
+                });
+              }
+              const shouldBlock =
+                (stage === "object format" && args.includes("extensions.objectFormat")) ||
+                (stage === "configuration" && args.includes("--show-scope")) ||
+                (stage === "initialization" && args[0] === "init" && args.includes("--bare")) ||
+                (stage === "read target" && readsTarget && targetReads === 1) ||
+                ((stage === "resolve" || stage === "shared budget") &&
+                  args.includes("rev-parse") &&
+                  command.options.env?.GIT_OBJECT_DIRECTORY !== undefined) ||
+                (stage === "promote ref" && args.includes("update-ref")) ||
+                (stage === "read promoted target" && readsTarget && targetReads === 2);
+              if (shouldBlock) {
+                attempts += 1;
+                yield* Deferred.succeed(blocked, undefined);
+                yield* Deferred.await(release).pipe(
+                  Effect.onInterrupt(() => Deferred.succeed(interrupted, undefined)),
+                );
+              }
+            }
+            return yield* delegate.spawn(command);
+          }),
+        );
+        const driver = yield* makeGitVcsDriverCore().pipe(
+          Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+          Effect.provide(layerServerConfig),
+        );
+        const refresh = yield* driver
+          .statusDetailsRemote(cwd)
+          .pipe(Effect.forkChild({ startImmediately: true }));
+        if (stage === "shared budget") {
+          yield* Deferred.await(preparationBlocked);
+          yield* TestClock.adjust("3 seconds");
+          yield* Deferred.succeed(releasePreparation, undefined);
+        }
+        yield* Deferred.await(blocked);
+        yield* TestClock.adjust(stage === "shared budget" ? "2 seconds" : "5 seconds");
+        const interruptedWithinDeadline = yield* Deferred.isDone(interrupted);
+        // Always release the injected stall so the pre-fix regression fails without leaking fibers.
+        yield* Deferred.succeed(release, undefined);
+        const status = yield* Fiber.join(refresh);
+        assert.isTrue(interruptedWithinDeadline);
+        assert.equal(status.behindCount, 0);
+        assert.equal(
+          yield* git(cwd, ["rev-parse", `refs/remotes/origin/${initialBranch}`]),
+          originalCommit,
+        );
+        assert.equal((yield* driver.statusDetailsRemote(cwd)).behindCount, 0);
+        assert.equal(attempts, 1);
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+        const isolatedRoot = path.join(cwd, ".git", "objects", "t3-status-fetch");
+        if (yield* fs.exists(isolatedRoot)) {
+          assert.deepStrictEqual(yield* fs.readDirectory(isolatedRoot), []);
+        }
+        yield* git(cwd, ["fsck", "--full", "--no-dangling"]);
+      }),
+    );
+
     it.effect("refreshes status without a second upload-pack process", () =>
       Effect.gen(function* () {
         const cwd = yield* makeTmpDir();
 
@@ -1714,7 +1714,21 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function*
           { concurrency: 1, discard: true },
         );
       }).pipe(Effect.ensuring(cleanupIsolatedFetch));
-    });
+    }).pipe(
+      Effect.timeoutOption(STATUS_UPSTREAM_REFRESH_TIMEOUT),
+      Effect.flatMap((result) =>
+        Effect.fromOption(
+          result,
+          () =>
+            new GitCommandError({
+              operation: "GitVcsDriver.fetchRemoteForStatus",
+              command: "git",
+              cwd: gitCommonDir,
+              detail: "Git status refresh timed out.",
+            }),
+        ),
+      ),
+    );
 
   const resolveRepositoryPathsUncached = Effect.fn("resolveRepositoryPathsUncached")(function* (
     cwd: string,