diff --git a/bgworker_test.go b/bgworker_test.go
new file mode 100644
index 0000000000..e503edbc73
--- /dev/null
+++ b/bgworker_test.go
@@ -0,0 +1,473 @@
+package frankenphp_test
+
+import (
+	"bytes"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/dunglas/frankenphp"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// requireFileEventually asserts that `path` appears on disk before the
+// deadline. Wraps require.Eventually so call sites stay short.
+func requireFileEventually(t testing.TB, path string, msgAndArgs ...any) {
+	t.Helper()
+	require.Eventually(t, func() bool {
+		_, err := os.Stat(path)
+		return err == nil
+	}, 5*time.Second, 25*time.Millisecond, msgAndArgs...)
+}
+
+// requireFileContentEventually waits for `path` to appear with content and
+// returns it
+func requireFileContentEventually(t *testing.T, path string) string {
+	t.Helper()
+	require.Eventually(t, func() bool {
+		b, err := os.ReadFile(path)
+		return err == nil && len(b) > 0
+	}, 5*time.Second, 25*time.Millisecond, "file %q did not appear", path)
+	b, err := os.ReadFile(path)
+	require.NoError(t, err)
+
+	return string(b)
+}
+
+// TestBackgroundWorkerLifecycle boots a background worker that touches a
+// sentinel file then parks on its handle. It proves the bg worker runs
+// (sentinel appears) and that Shutdown returns within a reasonable time.
+// The test asserts on Shutdown timing, so it manages Shutdown itself
+// instead of using initServers' t.Cleanup hook.
+func TestBackgroundWorkerLifecycle(t *testing.T) {
+	tmp := t.TempDir()
+	sentinel := filepath.Join(tmp, "bg-lifecycle.sentinel")
+
+	require.NoError(t, frankenphp.Init(
+		frankenphp.WithWorkers("bg-lifecycle", "testdata/bgworker/basic.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerEnv(map[string]string{"BG_SENTINEL": sentinel}),
+		),
+		frankenphp.WithNumThreads(2),
+	))
+
+	requireFileEventually(t, sentinel, "background worker did not touch sentinel")
+
+	done := make(chan struct{})
+	go func() {
+		frankenphp.Shutdown()
+		close(done)
+	}()
+
+	select {
+	case <-done:
+	case <-time.After(10 * time.Second):
+		t.Fatalf("Shutdown did not return within 10s")
+	}
+}
+
+// TestBackgroundWorkerCrashRestarts boots a worker that exit(1)s on its
+// first run and touches a "restarted" sentinel on its second run. The
+// sentinel proves the crash-restart loop fired.
+func TestBackgroundWorkerCrashRestarts(t *testing.T) {
+	tmp := t.TempDir()
+	crashMarker := filepath.Join(tmp, "bg-crash.marker")
+	restarted := filepath.Join(tmp, "bg-crash.restarted")
+
+	initServers(t,
+		frankenphp.WithWorkers("bg-crash", "testdata/bgworker/crash.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerEnv(map[string]string{
+				"BG_CRASH_MARKER":       crashMarker,
+				"BG_RESTARTED_SENTINEL": restarted,
+			}),
+		),
+		frankenphp.WithNumThreads(2),
+	)
+
+	requireFileEventually(t, restarted, "background worker did not restart after crash")
+}
+
+// TestBackgroundWorkerOnServer scopes a background worker to a Server. It
+// proves that the worker inherits the server env (the sentinel directory is
+// declared on the server, not on the worker), that FRANKENPHP_WORKER holds
+// the worker name, and that the worker does not intercept HTTP requests
+// served by the same server.
+func TestBackgroundWorkerOnServer(t *testing.T) {
+	tmp := t.TempDir()
+
+	server, err := frankenphp.NewServer(
+		testDataDir,
+		frankenphp.WithServerName("sidekick-server"),
+		frankenphp.WithServerEnv(map[string]string{"BG_SENTINEL_DIR": tmp}),
+	)
+	require.NoError(t, err)
+
+	globalSentinel := filepath.Join(tmp, "global.sentinel")
+	initServers(t,
+		frankenphp.WithServer(server),
+		frankenphp.WithWorkers("jobs", "testdata/bgworker/named.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerServerScope(server),
+		),
+		// a global worker may reuse the name: names are scoped to their server
+		frankenphp.WithWorkers("jobs", "testdata/bgworker/basic.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerEnv(map[string]string{"BG_SENTINEL": globalSentinel}),
+		),
+		frankenphp.WithNumThreads(3),
+	)
+
+	// named.php touches "<BG_SENTINEL_DIR>/<FRANKENPHP_WORKER>": the script sees
+	// the declared name, not the server-qualified one used by metrics and logs
+	requireFileEventually(t, filepath.Join(tmp, "jobs"), "background worker did not touch its per-name sentinel")
+	requireFileEventually(t, globalSentinel, "the global worker sharing the name did not start")
+
+	body := serverGet(t, server, "http://example.com/index.php")
+	assert.Contains(t, body, "I am by birth a Genevese", "the server must still serve regular requests")
+}
+
+// TestBackgroundWorkerValidation covers the declaration-time errors.
+func TestBackgroundWorkerValidation(t *testing.T) {
+	t.Cleanup(frankenphp.Shutdown)
+
+	t.Run("name is required", func(t *testing.T) {
+		err := frankenphp.Init(
+			frankenphp.WithWorkers("", "testdata/bgworker/basic.php", 1, frankenphp.WithWorkerBackground()),
+			frankenphp.WithNumThreads(2),
+		)
+		require.ErrorContains(t, err, "must have an explicit name")
+	})
+
+	t.Run("num must be >= 1", func(t *testing.T) {
+		err := frankenphp.Init(
+			frankenphp.WithWorkers("bg-zero", "testdata/bgworker/basic.php", 0, frankenphp.WithWorkerBackground()),
+			frankenphp.WithNumThreads(2),
+		)
+		require.ErrorContains(t, err, "must declare num >= 1")
+	})
+
+	t.Run("names are unique within a server", func(t *testing.T) {
+		// a global and a server-scoped worker may share a name (see
+		// TestBackgroundWorkerOnServer), two workers of one server may not
+		server, err := frankenphp.NewServer(testDataDir)
+		require.NoError(t, err)
+		err = frankenphp.Init(
+			frankenphp.WithServer(server),
+			frankenphp.WithWorkers("bg-shared", "testdata/bgworker/basic.php", 1,
+				frankenphp.WithWorkerBackground(),
+				frankenphp.WithWorkerServerScope(server),
+			),
+			frankenphp.WithWorkers("bg-shared", "testdata/bgworker/named.php", 1,
+				frankenphp.WithWorkerBackground(),
+				frankenphp.WithWorkerServerScope(server),
+			),
+			frankenphp.WithNumThreads(3),
+		)
+		require.ErrorContains(t, err, "two workers in a server cannot have the same name")
+	})
+
+	t.Run("early return without the handle fails startup", func(t *testing.T) {
+		err := frankenphp.Init(
+			frankenphp.WithWorkers("bg-early", "testdata/bgworker/early-return.php", 1,
+				frankenphp.WithWorkerBackground(),
+				frankenphp.WithWorkerMaxFailures(2),
+			),
+			frankenphp.WithNumThreads(2),
+		)
+		require.ErrorContains(t, err, "frankenphp_get_worker_handle")
+	})
+
+	t.Run("fetching the handle without waiting on it fails startup", func(t *testing.T) {
+		err := frankenphp.Init(
+			frankenphp.WithWorkers("bg-no-wait", "testdata/bgworker/fetch-no-wait.php", 1,
+				frankenphp.WithWorkerBackground(),
+				frankenphp.WithWorkerMaxFailures(2),
+			),
+			frankenphp.WithNumThreads(2),
+		)
+		require.ErrorContains(t, err, "waiting on its handle")
+	})
+
+	t.Run("max_threads is rejected", func(t *testing.T) {
+		err := frankenphp.Init(
+			frankenphp.WithWorkers("bg-scaled", "testdata/bgworker/basic.php", 1,
+				frankenphp.WithWorkerBackground(),
+				frankenphp.WithWorkerMaxThreads(2),
+			),
+			frankenphp.WithNumThreads(2),
+		)
+		require.ErrorContains(t, err, "cannot set max_threads")
+	})
+
+	t.Run("an unregistered server scope is rejected", func(t *testing.T) {
+		unregistered, err := frankenphp.NewServer(testDataDir)
+		require.NoError(t, err)
+		err = frankenphp.Init(
+			frankenphp.WithWorkers("bg-orphan", "testdata/bgworker/basic.php", 1,
+				frankenphp.WithWorkerBackground(),
+				frankenphp.WithWorkerServerScope(unregistered),
+			),
+			frankenphp.WithNumThreads(2),
+		)
+		require.ErrorContains(t, err, "not passed to WithServer()")
+	})
+
+	t.Run("request matchers are rejected", func(t *testing.T) {
+		err := frankenphp.Init(
+			frankenphp.WithWorkers("bg-matched", "testdata/bgworker/basic.php", 1,
+				frankenphp.WithWorkerBackground(),
+				frankenphp.WithWorkerMatcher(func(*http.Request) bool { return true }),
+			),
+			frankenphp.WithNumThreads(2),
+		)
+		require.ErrorContains(t, err, "cannot match requests")
+	})
+}
+
+// TestBackgroundWorkerCannotHandleRequests checks that a request targeting a
+// background worker by name is refused rather than dispatched to it.
+func TestBackgroundWorkerCannotHandleRequests(t *testing.T) {
+	server, err := frankenphp.NewServer(testDataDir)
+	require.NoError(t, err)
+	initServers(t,
+		frankenphp.WithServer(server),
+		frankenphp.WithWorkers("jobs", "testdata/bgworker/basic.php", 1, frankenphp.WithWorkerBackground(), frankenphp.WithWorkerServerScope(server)),
+		frankenphp.WithNumThreads(2),
+	)
+
+	err = server.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "http://example.com/index.php", nil), frankenphp.WithWorkerName("jobs"))
+	require.ErrorContains(t, err, `background worker "jobs" cannot handle requests`)
+}
+
+// TestBackgroundWorkerParksOnRead checks that a blocking read on the handle
+// is a wait too: Init() returns only once the worker is ready, and the EOF
+// of the drain unblocks the read so Shutdown() returns promptly.
+func TestBackgroundWorkerParksOnRead(t *testing.T) {
+	tmp := t.TempDir()
+	sentinel := filepath.Join(tmp, "bg-read.sentinel")
+
+	require.NoError(t, frankenphp.Init(
+		frankenphp.WithWorkers("bg-read", "testdata/bgworker/read.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerEnv(map[string]string{"BG_SENTINEL": sentinel}),
+		),
+		frankenphp.WithNumThreads(2),
+	))
+	requireFileEventually(t, sentinel, "background worker parked on a read did not start")
+
+	done := make(chan struct{})
+	go func() {
+		frankenphp.Shutdown()
+		close(done)
+	}()
+	select {
+	case <-done:
+	case <-time.After(10 * time.Second):
+		t.Fatal("Shutdown did not return within 10s: the read did not observe EOF")
+	}
+}
+
+// TestBackgroundWorkerRestartDrainsParkedScript checks that RestartWorkers()
+// wakes a parked background script through the drain and re-runs it.
+func TestBackgroundWorkerRestartDrainsParkedScript(t *testing.T) {
+	tmp := t.TempDir()
+	countFile := filepath.Join(tmp, "bg-count.log")
+
+	initServers(t,
+		frankenphp.WithWorkers("bg-count", "testdata/bgworker/count.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerEnv(map[string]string{"BG_COUNT_FILE": countFile}),
+		),
+		frankenphp.WithNumThreads(2),
+	)
+	runs := func() int {
+		b, _ := os.ReadFile(countFile)
+		return bytes.Count(b, []byte("\n"))
+	}
+	require.Eventually(t, func() bool { return runs() == 1 }, 5*time.Second, 25*time.Millisecond, "background worker did not start")
+
+	frankenphp.RestartWorkers()
+
+	require.Eventually(t, func() bool { return runs() == 2 }, 5*time.Second, 25*time.Millisecond, "background worker was not re-run after the restart")
+}
+
+// TestGetWorkerHandleOutsideBackgroundWorker checks the function throws on a
+// regular request thread instead of handing out a stream.
+func TestGetWorkerHandleOutsideBackgroundWorker(t *testing.T) {
+	server, err := frankenphp.NewServer(testDataDir)
+	require.NoError(t, err)
+	initServers(t, frankenphp.WithServer(server), frankenphp.WithNumThreads(1))
+
+	body := serverGet(t, server, "http://example.com/handle-outside.php")
+
+	assert.Contains(t, body, "can only be called from a background worker")
+}
+
+// TestWorkerNameInServerVars checks that every worker sees its declared name
+// in FRANKENPHP_WORKER and that only background workers get the
+// FRANKENPHP_WORKER_BACKGROUND flag.
+func TestWorkerNameInServerVars(t *testing.T) {
+	sentinel := filepath.Join(t.TempDir(), "flag.txt")
+	server, err := frankenphp.NewServer(testDataDir)
+	require.NoError(t, err)
+	initServers(t,
+		frankenphp.WithServer(server),
+		frankenphp.WithWorkers("web", testDataDir+"worker-name.php", 1, frankenphp.WithWorkerServerScope(server)),
+		frankenphp.WithWorkers("jobs", "testdata/bgworker/flag.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerServerScope(server),
+			frankenphp.WithWorkerEnv(map[string]string{"BG_SENTINEL": sentinel}),
+		),
+		frankenphp.WithNumThreads(3),
+	)
+
+	assert.Equal(t, "web http", serverGet(t, server, "http://example.com/worker-name.php"))
+
+	flag := requireFileContentEventually(t, sentinel)
+	assert.Contains(t, flag, "'worker' => 'jobs'")
+	assert.Contains(t, flag, "'background' => '1'")
+}
+
+// TestBackgroundWorkerPool checks that num > 1 threads share the name, each
+// parks on its own handle, and one drain wakes them all.
+func TestBackgroundWorkerPool(t *testing.T) {
+	dir := t.TempDir()
+	initServers(t,
+		frankenphp.WithWorkers("pool", "testdata/bgworker/pool.php", 3,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerEnv(map[string]string{"BG_SENTINEL_DIR": dir}),
+		),
+		frankenphp.WithNumThreads(4),
+	)
+
+	require.Eventually(t, func() bool {
+		entries, _ := os.ReadDir(dir)
+		return len(entries) == 3
+	}, 5*time.Second, 25*time.Millisecond, "the three pool threads did not all start")
+
+	done := make(chan struct{})
+	go func() {
+		frankenphp.Shutdown()
+		close(done)
+	}()
+	select {
+	case <-done:
+	case <-time.After(10 * time.Second):
+		t.Fatal("Shutdown did not drain the whole pool within 10s")
+	}
+}
+
+// TestBackgroundWorkerMultiEntrypoint checks that two named background
+// workers of one server may share a script, since they are not matched by path.
+func TestBackgroundWorkerMultiEntrypoint(t *testing.T) {
+	tmp := t.TempDir()
+	first, second := filepath.Join(tmp, "first"), filepath.Join(tmp, "second")
+	server, err := frankenphp.NewServer(testDataDir)
+	require.NoError(t, err)
+	initServers(t,
+		frankenphp.WithServer(server),
+		frankenphp.WithWorkers("first", "testdata/bgworker/basic.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerServerScope(server),
+			frankenphp.WithWorkerEnv(map[string]string{"BG_SENTINEL": first}),
+		),
+		frankenphp.WithWorkers("second", "testdata/bgworker/basic.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerServerScope(server),
+			frankenphp.WithWorkerEnv(map[string]string{"BG_SENTINEL": second}),
+		),
+		frankenphp.WithNumThreads(3),
+	)
+
+	requireFileEventually(t, first, "the first worker on the shared script did not start")
+	requireFileEventually(t, second, "the second worker on the shared script did not start")
+}
+
+// TestBackgroundWorkerThreadsComeOnTop checks that background threads are
+// reserved on top of num_threads: one HTTP thread plus one background worker
+// starts with num_threads 1.
+func TestBackgroundWorkerThreadsComeOnTop(t *testing.T) {
+	sentinel := filepath.Join(t.TempDir(), "bg-only.sentinel")
+	initServers(t,
+		frankenphp.WithWorkers("bg-only", "testdata/bgworker/basic.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerEnv(map[string]string{"BG_SENTINEL": sentinel}),
+		),
+		frankenphp.WithNumThreads(1),
+	)
+
+	requireFileEventually(t, sentinel, "background worker did not start with num_threads 1")
+}
+
+// TestBackgroundWorkerBootFailuresThenSucceeds checks that boot failures below
+// max_consecutive_failures are retried with the backoff and Init() still
+// succeeds once a run reaches its ready point.
+func TestBackgroundWorkerBootFailuresThenSucceeds(t *testing.T) {
+	tmp := t.TempDir()
+	countFile, sentinel := filepath.Join(tmp, "boots"), filepath.Join(tmp, "ready")
+	initServers(t,
+		frankenphp.WithWorkers("bg-flaky", "testdata/bgworker/fail-then-succeed.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerEnv(map[string]string{"BG_COUNT_FILE": countFile, "BG_SENTINEL": sentinel, "BG_FAIL_UNTIL": "2"}),
+		),
+		frankenphp.WithNumThreads(2),
+	)
+
+	requireFileEventually(t, sentinel, "background worker did not recover from its boot failures")
+	boots, err := os.ReadFile(countFile)
+	require.NoError(t, err)
+	assert.Equal(t, "3", string(boots), "two boot failures then a success")
+}
+
+// TestBackgroundWorkerCrashAfterReadyRestarts checks that a crash after the
+// ready point restarts right away without counting toward
+// max_consecutive_failures, and that a zero-timeout stream_select() counts
+// as the wait.
+func TestBackgroundWorkerCrashAfterReadyRestarts(t *testing.T) {
+	countFile := filepath.Join(t.TempDir(), "runs")
+	initServers(t,
+		frankenphp.WithWorkers("bg-crashy", "testdata/bgworker/crash-after-ready.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerMaxFailures(2),
+			frankenphp.WithWorkerEnv(map[string]string{"BG_COUNT_FILE": countFile}),
+		),
+		frankenphp.WithNumThreads(2),
+	)
+
+	require.Eventually(t, func() bool {
+		b, _ := os.ReadFile(countFile)
+		return bytes.Count(b, []byte("\n")) >= 4
+	}, 5*time.Second, 25*time.Millisecond, "the worker was not restarted after crashing past its ready point")
+}
+
+// TestBackgroundWorkerRebootForceKillsStuckScript checks that a script
+// ignoring its handle does not stall RestartWorkers() past the reboot grace
+// period: the force-kill ends it and the next run parks normally.
+func TestBackgroundWorkerRebootForceKillsStuckScript(t *testing.T) {
+	if runtime.GOOS != "linux" && runtime.GOOS != "freebsd" {
+		t.Skipf("force-kill cannot interrupt a blocking syscall on %s", runtime.GOOS)
+	}
+
+	tmp := t.TempDir()
+	once, sentinel := filepath.Join(tmp, "once"), filepath.Join(tmp, "parked")
+	initServers(t,
+		frankenphp.WithWorkers("bg-stuck", "testdata/bgworker/stuck.php", 1,
+			frankenphp.WithWorkerBackground(),
+			frankenphp.WithWorkerEnv(map[string]string{"BG_ONCE": once, "BG_SENTINEL": sentinel}),
+		),
+		frankenphp.WithNumThreads(2),
+	)
+	requireFileEventually(t, once, "background worker never entered its sleep")
+
+	start := time.Now()
+	frankenphp.RestartWorkers()
+	assert.WithinDuration(t, start, time.Now(), 10*time.Second, "the reboot must force-kill the stuck script within its grace period")
+
+	requireFileEventually(t, sentinel, "the re-run script did not park")
+}
diff --git a/caddy/app.go b/caddy/app.go
index fcee129180..428223fe46 100644
--- a/caddy/app.go
+++ b/caddy/app.go
@@ -17,7 +17,6 @@ import (
 	"github.com/caddyserver/caddy/v2/caddyconfig/httpcaddyfile"
 	"github.com/caddyserver/caddy/v2/modules/caddyhttp"
 	"github.com/dunglas/frankenphp"
-	"github.com/dunglas/frankenphp/internal/fastabs"
 )
 
 var (
@@ -60,15 +59,14 @@ type FrankenPHPApp struct {
 	// EXPERIMENTAL: MaxRequests sets the maximum number of requests a PHP thread handles before restarting (0 = unlimited)
 	MaxRequests int `json:"max_requests,omitempty"`
 
-	opts            []frankenphp.Option
-	metrics         frankenphp.Metrics
-	ctx             context.Context
-	logger          *slog.Logger
-	modules         []*FrankenPHPModule
-	usedWorkerNames map[string]bool
-	httpApp         *caddyhttp.App
-	hasStarted      atomic.Bool
-	started         chan any
+	opts       []frankenphp.Option
+	metrics    frankenphp.Metrics
+	ctx        context.Context
+	logger     *slog.Logger
+	modules    []*FrankenPHPModule
+	httpApp    *caddyhttp.App
+	hasStarted atomic.Bool
+	started    chan any
 }
 
 var errIni = errors.New(`"php_ini" must be in the format: php_ini "<key>" "<value>"`)
@@ -133,7 +131,6 @@ func (f *FrankenPHPApp) Start() error {
 	// register global workers
 	for _, w := range f.Workers {
 		w.FileName = repl.ReplaceKnown(w.FileName, "")
-		w.Name = f.createUniqueWorkerName(w, "")
 		opts, err := w.toWorkerOptions()
 		if err != nil {
 			return err
@@ -224,7 +221,6 @@ func (f *FrankenPHPApp) registerModule(repl *caddy.Replacer, module *FrankenPHPM
 
 	for _, w := range module.Workers {
 		w.FileName = repl.ReplaceKnown(w.FileName, "")
-		w.Name = f.createUniqueWorkerName(w, serverName)
 		workerOptions, err := w.toWorkerOptions()
 		if err != nil {
 			return err
@@ -236,37 +232,6 @@ func (f *FrankenPHPApp) registerModule(repl *caddy.Replacer, module *FrankenPHPM
 	return nil
 }
 
-// avoid name collisions for workers
-// on collision, a name is first qualified with the server name
-// ("<serverName>:<name>") before falling back to a numeric postfix
-func (f *FrankenPHPApp) createUniqueWorkerName(wc workerConfig, serverName string) string {
-	if f.usedWorkerNames == nil {
-		f.usedWorkerNames = make(map[string]bool)
-	}
-
-	if wc.Name == "" {
-		wc.Name, _ = fastabs.FastAbs(wc.FileName)
-	}
-
-	name := wc.Name
-	suffix := 0
-	for {
-		if _, ok := f.usedWorkerNames[name]; !ok {
-			f.usedWorkerNames[name] = true
-			break
-		}
-		if serverName != "" {
-			name = serverName + ":" + wc.Name
-			serverName = ""
-			continue
-		}
-		suffix++
-		name = fmt.Sprintf("%s_%d", wc.Name, suffix)
-	}
-
-	return name
-}
-
 // UnmarshalCaddyfile implements caddyfile.Unmarshaler.
 func (f *FrankenPHPApp) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
 	for d.Next() {
diff --git a/caddy/caddy_test.go b/caddy/caddy_test.go
index b7d6c231eb..29004d10b7 100644
--- a/caddy/caddy_test.go
+++ b/caddy/caddy_test.go
@@ -757,6 +757,45 @@ func TestMetrics(t *testing.T) {
 	require.NoError(t, testutil.GatherAndCompare(ctx.GetMetricsRegistry(), strings.NewReader(expectedMetrics), "frankenphp_total_threads", "frankenphp_busy_threads"))
 }
 
+// TestBackgroundWorkerFromCaddyfile starts a background worker from a
+// Caddyfile and checks it runs: the sentinel its script touches appears
+func TestBackgroundWorkerFromCaddyfile(t *testing.T) {
+	sentinel := filepath.ToSlash(filepath.Join(t.TempDir(), "bg.sentinel"))
+	tester := caddytest.NewTester(t)
+	initServer(t, tester, `
+	{
+		skip_install_trust
+		admin localhost:2999
+		http_port `+testPort+`
+		https_port 9443
+
+		frankenphp {
+			worker {
+				file ../testdata/bgworker/basic.php
+				num 1
+				name bg-caddy
+				background
+				env BG_SENTINEL `+sentinel+`
+			}
+		}
+	}
+
+	localhost:`+testPort+` {
+		route {
+			php {
+				root ../testdata
+			}
+		}
+	}
+	`, "caddyfile")
+
+	require.Eventually(t, func() bool {
+		_, err := os.Stat(sentinel)
+
+		return err == nil
+	}, 5*time.Second, 25*time.Millisecond, "the background worker declared in the Caddyfile did not run")
+}
+
 func TestWorkerMetrics(t *testing.T) {
 	var wg sync.WaitGroup
 	tester := caddytest.NewTester(t)
@@ -839,7 +878,7 @@ func TestWorkerMetrics(t *testing.T) {
 	# TYPE frankenphp_worker_request_count counter
 	frankenphp_worker_request_count{worker="` + workerName + `"} 10
 
-	# HELP frankenphp_ready_workers Running workers that have successfully called frankenphp_handle_request at least once
+	# HELP frankenphp_ready_workers Running workers that have reached their ready point at least once: frankenphp_handle_request for HTTP workers, frankenphp_get_worker_handle for background workers
 	# TYPE frankenphp_ready_workers gauge
 	frankenphp_ready_workers{worker="` + workerName + `"} 2
 	`
@@ -996,7 +1035,7 @@ func TestNamedWorkerMetrics(t *testing.T) {
 	# TYPE frankenphp_worker_request_count counter
 	frankenphp_worker_request_count{worker="my_app"} 10
 
-	# HELP frankenphp_ready_workers Running workers that have successfully called frankenphp_handle_request at least once
+	# HELP frankenphp_ready_workers Running workers that have reached their ready point at least once: frankenphp_handle_request for HTTP workers, frankenphp_get_worker_handle for background workers
 	# TYPE frankenphp_ready_workers gauge
 	frankenphp_ready_workers{worker="my_app"} 2
 	`
@@ -1092,7 +1131,7 @@ func TestAutoWorkerConfig(t *testing.T) {
 	# TYPE frankenphp_worker_request_count counter
 	frankenphp_worker_request_count{worker="` + workerName + `"} 10
 
-	# HELP frankenphp_ready_workers Running workers that have successfully called frankenphp_handle_request at least once
+	# HELP frankenphp_ready_workers Running workers that have reached their ready point at least once: frankenphp_handle_request for HTTP workers, frankenphp_get_worker_handle for background workers
 	# TYPE frankenphp_ready_workers gauge
 	frankenphp_ready_workers{worker="` + workerName + `"} ` + workers + `
 	`
@@ -1460,7 +1499,7 @@ func TestMultiWorkersMetrics(t *testing.T) {
 	# TYPE frankenphp_worker_request_count counter
 	frankenphp_worker_request_count{worker="service1"} 10
 
-	# HELP frankenphp_ready_workers Running workers that have successfully called frankenphp_handle_request at least once
+	# HELP frankenphp_ready_workers Running workers that have reached their ready point at least once: frankenphp_handle_request for HTTP workers, frankenphp_get_worker_handle for background workers
 	# TYPE frankenphp_ready_workers gauge
 	frankenphp_ready_workers{worker="service1"} 2
 	frankenphp_ready_workers{worker="service2"} 3
@@ -1614,7 +1653,7 @@ func TestWorkerRestart(t *testing.T) {
 
 	// Check metrics
 	expectedMetrics := `
-	# HELP frankenphp_ready_workers Running workers that have successfully called frankenphp_handle_request at least once
+	# HELP frankenphp_ready_workers Running workers that have reached their ready point at least once: frankenphp_handle_request for HTTP workers, frankenphp_get_worker_handle for background workers
 	# TYPE frankenphp_ready_workers gauge
 	frankenphp_ready_workers{worker="service"} 1
 	# HELP frankenphp_total_workers Total number of PHP workers for this worker
@@ -1642,7 +1681,7 @@ func TestWorkerRestart(t *testing.T) {
 
 	// frankenphp_ready_workers should be back to 1 even after worker restarts
 	expectedMetrics = `
-	# HELP frankenphp_ready_workers Running workers that have successfully called frankenphp_handle_request at least once
+	# HELP frankenphp_ready_workers Running workers that have reached their ready point at least once: frankenphp_handle_request for HTTP workers, frankenphp_get_worker_handle for background workers
 	# TYPE frankenphp_ready_workers gauge
 	frankenphp_ready_workers{worker="service"} 1
 	# HELP frankenphp_total_workers Total number of PHP workers for this worker
@@ -2113,7 +2152,7 @@ func TestSymlinkWorkerBehavior(t *testing.T) {
 
 		// Accessing the worker script without worker configuration MUST fail
 		// The script checks $_SERVER['FRANKENPHP_WORKER'] and dies if not set
-		tester.AssertGetResponse("http://localhost:"+testPort+"/index.php", http.StatusOK, "Error: This script must be run in worker mode (FRANKENPHP_WORKER not set to '1')\n")
+		tester.AssertGetResponse("http://localhost:"+testPort+"/index.php", http.StatusOK, "Error: This script must be run in worker mode (FRANKENPHP_WORKER not set)\n")
 	})
 
 	t.Run("MultipleRequests", func(t *testing.T) {
diff --git a/caddy/config_test.go b/caddy/config_test.go
index 607051cbd8..c450ef0458 100644
--- a/caddy/config_test.go
+++ b/caddy/config_test.go
@@ -1,7 +1,6 @@
 package caddy
 
 import (
-	"path/filepath"
 	"testing"
 	"time"
 
@@ -249,38 +248,73 @@ func TestModuleWorkerWithCustomName(t *testing.T) {
 	require.Equal(t, "../testdata/worker-with-env.php", module.Workers[0].FileName, "Worker should have the correct filename")
 }
 
-func TestCreateUniqueWorkerNames(t *testing.T) {
-	app := &FrankenPHPApp{}
-	filename := "../testdata/worker-with-env.php"
-	absFileName, _ := filepath.Abs(filename)
-	names := make([]string, 6)
-	for i := range 3 {
-		names[i] = app.createUniqueWorkerName(workerConfig{
-			FileName: filename,
-			Name:     "custom-worker-name",
-		}, "")
-		names[i+3] = app.createUniqueWorkerName(workerConfig{
-			FileName: filename,
-		}, "")
-	}
-
-	require.Equal(t, "custom-worker-name", names[0])
-	require.Equal(t, "custom-worker-name_1", names[1])
-	require.Equal(t, "custom-worker-name_2", names[2])
-	require.Equal(t, absFileName, names[3])
-	require.Equal(t, absFileName+"_1", names[4])
-	require.Equal(t, absFileName+"_2", names[5])
+func TestWorkerBackgroundConfig(t *testing.T) {
+	d := caddyfile.NewTestDispenser(`
+	{
+		php_server {
+			worker {
+				name jobs
+				file ../testdata/worker-with-env.php
+				num 2
+				background
+			}
+		}
+	}`)
+	module := &FrankenPHPModule{}
+
+	require.NoError(t, module.UnmarshalCaddyfile(d))
+	require.Len(t, module.Workers, 1)
+	require.True(t, module.Workers[0].Background)
+	require.Equal(t, "jobs", module.Workers[0].Name)
+}
+
+func TestWorkerBackgroundRequiresName(t *testing.T) {
+	d := caddyfile.NewTestDispenser(`
+	{
+		php_server {
+			worker {
+				file ../testdata/worker-with-env.php
+				background
+			}
+		}
+	}`)
+	module := &FrankenPHPModule{}
+
+	err := module.UnmarshalCaddyfile(d)
+	require.ErrorContains(t, err, `background workers must have an explicit "name"`)
 }
 
-func TestCreateUniqueWorkerNamesQualifiedByServer(t *testing.T) {
-	app := &FrankenPHPApp{}
-	wc := workerConfig{FileName: "../testdata/worker-with-env.php", Name: "queue"}
-
-	require.Equal(t, "queue", app.createUniqueWorkerName(wc, "one.example.com"))
-	// on collision, the name is qualified with the server name
-	require.Equal(t, "two.example.com:queue", app.createUniqueWorkerName(wc, "two.example.com"))
-	// when the qualified name is also taken, fall back to the numeric postfix
-	require.Equal(t, "queue_1", app.createUniqueWorkerName(wc, "two.example.com"))
-	// workers without a server keep the numeric postfix behavior
-	require.Equal(t, "queue_2", app.createUniqueWorkerName(wc, ""))
+func TestWorkerBackgroundRequiresNum(t *testing.T) {
+	d := caddyfile.NewTestDispenser(`
+	{
+		php_server {
+			worker {
+				name jobs
+				file ../testdata/worker-with-env.php
+				background
+			}
+		}
+	}`)
+	module := &FrankenPHPModule{}
+
+	err := module.UnmarshalCaddyfile(d)
+	require.ErrorContains(t, err, `background workers must declare "num" >= 1`)
+}
+
+func TestWorkerBackgroundRejectsMatch(t *testing.T) {
+	d := caddyfile.NewTestDispenser(`
+	{
+		php_server {
+			worker {
+				name jobs
+				file ../testdata/worker-with-env.php
+				match /jobs/*
+				background
+			}
+		}
+	}`)
+	module := &FrankenPHPModule{}
+
+	err := module.UnmarshalCaddyfile(d)
+	require.ErrorContains(t, err, `"match" is not supported for background workers`)
 }
diff --git a/caddy/module.go b/caddy/module.go
index 20dcec9ee2..ff6e2db5ff 100644
--- a/caddy/module.go
+++ b/caddy/module.go
@@ -315,6 +315,10 @@ func (f *FrankenPHPModule) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
 	// Check if a worker with this filename already exists in this module
 	fileNames := make(map[string]struct{}, len(f.Workers))
 	for _, w := range f.Workers {
+		// background workers are keyed by name, several may share a script
+		if w.Background {
+			continue
+		}
 		if _, ok := fileNames[w.FileName]; ok {
 			return fmt.Errorf(`workers in a single "php" or "php_server" block must not have duplicate filenames: %q`, w.FileName)
 		}
diff --git a/caddy/workerconfig.go b/caddy/workerconfig.go
index b39eb731e0..7f5c15b253 100644
--- a/caddy/workerconfig.go
+++ b/caddy/workerconfig.go
@@ -22,7 +22,7 @@ import (
 type workerConfig struct {
 	mercureContext
 
-	// Name for the worker. Default: the absolute path of the worker file, postfixed with a number if the name is already used.
+	// Name for the worker, unique within its php_server (or among global workers). Default: the absolute path of the worker file.
 	Name string `json:"name,omitempty"`
 	// FileName sets the path to the worker script.
 	FileName string `json:"file_name,omitempty"`
@@ -38,6 +38,8 @@ type workerConfig struct {
 	MatchPath []string `json:"match_path,omitempty"`
 	// MaxConsecutiveFailures sets the maximum number of consecutive failures before panicking (defaults to 6, set to -1 to never panick)
 	MaxConsecutiveFailures int `json:"max_consecutive_failures,omitempty"`
+	// Background marks this worker as a background (non-HTTP) worker.
+	Background bool `json:"background,omitempty"`
 
 	options []frankenphp.WorkerOption
 }
@@ -139,8 +141,10 @@ func unmarshalWorker(d *caddyfile.Dispenser) (workerConfig, error) {
 			}
 
 			wc.MaxConsecutiveFailures = v
+		case "background":
+			wc.Background = true
 		default:
-			return wc, wrongSubDirectiveError("worker", "name, file, num, env, watch, match, max_consecutive_failures, max_threads", v)
+			return wc, wrongSubDirectiveError("worker", "name, file, num, env, watch, match, max_consecutive_failures, max_threads, background", v)
 		}
 	}
 
@@ -148,6 +152,18 @@ func unmarshalWorker(d *caddyfile.Dispenser) (workerConfig, error) {
 		return wc, d.Err(`the "file" argument must be specified`)
 	}
 
+	if wc.Background {
+		if wc.Name == "" {
+			return wc, d.Err(`background workers must have an explicit "name"`)
+		}
+		if len(wc.MatchPath) != 0 {
+			return wc, d.Err(`"match" is not supported for background workers`)
+		}
+		if wc.Num < 1 {
+			return wc, d.Err(`background workers must declare "num" >= 1`)
+		}
+	}
+
 	if frankenphp.EmbeddedAppPath != "" && filepath.IsLocal(wc.FileName) {
 		wc.FileName = filepath.Join(frankenphp.EmbeddedAppPath, wc.FileName)
 	}
@@ -166,6 +182,10 @@ func (wc *workerConfig) toWorkerOptions() ([]frankenphp.WorkerOption, error) {
 	// options collected while provisioning the module, e.g. the Mercure hub
 	opts = append(opts, wc.options...)
 
+	if wc.Background {
+		opts = append(opts, frankenphp.WithWorkerBackground())
+	}
+
 	// copy the caddy match logic and create a unique matcher function for this worker
 	// inject the matcher into frankenphp
 	if len(wc.MatchPath) > 0 {
diff --git a/docs/config.md b/docs/config.md
index 281f05dc75..553d707862 100644
--- a/docs/config.md
+++ b/docs/config.md
@@ -109,8 +109,9 @@ You can also explicitly configure FrankenPHP using the [global option](https://c
 			num <num> # Sets the number of PHP threads to start, defaults to 2x the number of available CPUs.
 			env <key> <value> # Sets an extra environment variable to the given value. Can be specified more than once for multiple environment variables.
 			watch <path> # Sets the path to watch for file changes. Can be specified more than once for multiple paths.
-			name <name> # Sets the name of the worker, used in logs and metrics. Default: absolute path of worker file
+			name <name> # Sets the name of the worker, used in logs and metrics and exposed as $_SERVER['FRANKENPHP_WORKER']. Must be unique among global workers. Default: absolute path of the worker file.
 			max_consecutive_failures <num> # Sets the maximum number of consecutive failures before the worker is considered unhealthy, -1 means the worker will always restart. Default: 6.
+			background # EXPERIMENTAL: marks this worker as a background (non-HTTP) worker; it runs the script in a loop without serving requests, "name" is required, "match" is not allowed. The script is ready once it waits on the stream returned by frankenphp_get_worker_handle() (stream_select() or a blocking read); an exit before that counts as a failure. $_SERVER['FRANKENPHP_WORKER_BACKGROUND'] is set in it. Its threads come on top of num_threads and max_threads, and max_threads is not allowed on it.
 		}
 	}
 }
@@ -187,17 +188,18 @@ php_server [<matcher>] {
 	root <directory> # Sets the root folder to the site. Default: `root` directive.
 	split_path <delim...> # Sets the substrings for splitting the URI into two parts. The first matching substring will be used to split the "path info" from the path. The first piece is suffixed with the matching substring and will be assumed as the actual resource (CGI script) name. The second piece will be set to PATH_INFO for the script to use. Default: `.php`
 	resolve_root_symlink false # Disables resolving the `root` directory to its actual value by evaluating a symbolic link, if one exists (enabled by default).
-	name <name> # Sets the name for this server, used to attribute workers, metrics and logs. Default: the first host matcher of the enclosing route, or the first listener address.
+	name <name> # Sets the name for this server, used to attribute workers, metrics and logs. Default: the first host matcher of the enclosing route, or the first listener address. Suffixed with a number if another php_server resolves to the same name.
 	env <key> <value> # Sets an extra environment variable to the given value. Can be specified more than once for multiple environment variables.
 	file_server off # Disables the built-in file_server directive.
 	request_body_timeout <duration> # Sets an idle timeout on request body reads: a stalled (slow POST) client is cut off while a steady upload of any size succeeds. Default: 60s. Set to 0 to disable.
 	worker { # Creates a worker specific to this server. Can be specified more than once for multiple workers.
 		file <path> # Sets the path to the worker script, can be relative to the php_server root
 		num <num> # Sets the number of PHP threads to start, defaults to 2x the number of available
-		name <name> # Sets the name for the worker, used in logs and metrics. Default: absolute path of worker file. Postfixed with a number if name is already in use.
+		name <name> # Sets the name for the worker, used in logs and metrics and exposed as $_SERVER['FRANKENPHP_WORKER']. Must be unique within this php_server. In logs and metrics, the worker is reported as "<server name>:<name>". Default: absolute path of the worker file.
 		watch <path> # Sets the path to watch for file changes. Can be specified more than once for multiple paths.
 		env <key> <value> # Sets an extra environment variable to the given value. Can be specified more than once for multiple environment variables. Environment variables for this worker are also inherited from the php_server parent, but can be overwritten here.
 		match <path> # match the worker to a path pattern. Overrides try_files and can only be used in the php_server directive.
+		background # EXPERIMENTAL: marks this worker as a background (non-HTTP) worker; it runs the script in a loop without serving requests, "name" is required, "match" is not allowed. The script is ready once it waits on the stream returned by frankenphp_get_worker_handle() (stream_select() or a blocking read); an exit before that counts as a failure. $_SERVER['FRANKENPHP_WORKER_BACKGROUND'] is set in it. Its threads come on top of num_threads and max_threads, and max_threads is not allowed on it.
 	}
 	worker <other_file> <num> # Can also use the short form like in the global frankenphp block.
 }
diff --git a/docs/library.md b/docs/library.md
index 7782f03182..03f0ef5898 100644
--- a/docs/library.md
+++ b/docs/library.md
@@ -60,6 +60,10 @@ err := frankenphp.Init(
 
 Workers declared without a server scope are global: they match by file path on any server. Since a global worker has no set of requests to match against, combining `WithWorkerMatcher()` with a global worker is a configuration error and `Init()` rejects it.
 
+Worker names are unique within their server (or among global workers), so two servers may each declare a worker named `queue`. The script sees the declared name, while metrics and logs report a server-scoped worker as `<server name>:<worker name>`; server names are made unique with a numeric suffix when needed. `WithWorkerName()` resolves a name within the request's server first, then among global workers.
+
+`WithWorkerBackground()` declares a [background worker](worker.md#background-workers), which runs outside the request cycle.
+
 ## Per-request options
 
 `Server.ServeHTTP()` accepts `RequestOption`s to override the server configuration for a single request, e.g. `WithRequestDocumentRoot()`, `WithRequestSplitPath()`, `WithRequestEnv()` or `WithRequestLogger()`.
diff --git a/docs/metrics.md b/docs/metrics.md
index 932707265a..6239ae8829 100644
--- a/docs/metrics.md
+++ b/docs/metrics.md
@@ -19,12 +19,12 @@ When [Caddy metrics](https://caddyserver.com/docs/metrics) are enabled, FrankenP
 - `frankenphp_busy_workers{worker="[worker_name]"}`: The number of workers currently processing a request.
 - `frankenphp_worker_request_time{worker="[worker_name]"}`: The time spent processing requests by all workers.
 - `frankenphp_worker_request_count{worker="[worker_name]"}`: The number of requests processed by all workers.
-- `frankenphp_ready_workers{worker="[worker_name]"}`: The number of workers that have called `frankenphp_handle_request` at least once.
+- `frankenphp_ready_workers{worker="[worker_name]"}`: The number of workers that have reached their ready point at least once: `frankenphp_handle_request()` for HTTP workers, `frankenphp_get_worker_handle()` for background workers.
 - `frankenphp_worker_crashes{worker="[worker_name]"}`: The number of times a worker has unexpectedly terminated.
 - `frankenphp_worker_restarts{worker="[worker_name]"}`: The number of times a worker has been deliberately restarted.
 - `frankenphp_worker_queue_depth{worker="[worker_name]"}`: The number of queued requests.
 
-For worker metrics, the `[worker_name]` placeholder is replaced by the worker name in the Caddyfile, otherwise the absolute path of the worker file will be used.
+`[worker_name]` is the worker name from the Caddyfile, or the absolute path of the worker file when it has none. Workers of a `php_server` block are prefixed with the name of that block: `<server name>:<worker name>`. They used to be reported under their bare name unless two blocks declared the same one, so dashboards and alerts built on those series need the prefix.
 
 ## Threads State Endpoint
 
diff --git a/docs/worker.md b/docs/worker.md
index 466c7cf684..aa5225ba13 100644
--- a/docs/worker.md
+++ b/docs/worker.md
@@ -199,6 +199,44 @@ frankenphp {
 }
 ```
 
+## Background workers
+
+This feature is experimental.
+
+A background worker runs its script in a loop outside the HTTP request cycle, on its own PHP thread. It is declared like any worker, with the `background` option; `name` is required and `num` must be at least 1:
+
+```caddyfile
+php_server {
+	worker {
+		file jobs.php
+		num 1
+		name jobs
+		background
+	}
+}
+```
+
+The script must wait on the stream returned by `frankenphp_get_worker_handle()`, which reaches EOF when FrankenPHP drains the worker on shutdown, reboot or restart. The first wait on it marks the worker ready: the server start waits for that point, and an exit before it counts as a failure. Polling `feof()` is not a wait, block in `stream_select()` or in a read:
+
+```php
+<?php
+
+$handle = frankenphp_get_worker_handle();
+
+while (true) {
+    $read = [$handle];
+    $write = $except = null;
+    if (stream_select($read, $write, $except, 1) > 0) {
+        // drained: return, FrankenPHP re-runs or stops the script
+        break;
+    }
+
+    doSomeWork();
+}
+```
+
+`$_SERVER['FRANKENPHP_WORKER']` holds the declared name, as it does in HTTP workers, and `$_SERVER['FRANKENPHP_WORKER_BACKGROUND']` is set, so a script serving both roles can tell them apart with `isset()`. In HTTP workers, `FRANKENPHP_WORKER` used to hold `1`: a script comparing it to that value must test its presence instead. Background threads come on top of `num_threads` and `max_threads`; they don't autoscale, so `max_threads` is not allowed on them. From Go, declare one with `WithWorkerBackground()`.
+
 ## Superglobals behavior
 
 [PHP superglobals](https://www.php.net/manual/language.variables.superglobals.php) (`$_SERVER`, `$_ENV`, `$_GET`...)
diff --git a/frankenphp.c b/frankenphp.c
index 2378ac8ff6..85d5fe2f04 100644
--- a/frankenphp.c
+++ b/frankenphp.c
@@ -13,11 +13,14 @@
 #include <php.h>
 #ifdef PHP_WIN32
 #include <config.w32.h>
+#include <win32/sockets.h>
 #else
 #include <php_config.h>
 #endif
+#include <main/php_streams.h>
 #include <php_ini.h>
 #include <php_main.h>
+#include <php_network.h>
 #include <php_output.h>
 #include <php_variables.h>
 #include <php_version.h>
@@ -28,6 +31,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #ifndef PHP_WIN32
+#include <fcntl.h>
 #include <unistd.h>
 #endif
 #if defined(__linux__)
@@ -126,6 +130,18 @@ HashTable *main_thread_env = NULL;
 
 static THREAD_LOCAL uintptr_t thread_index;
 static THREAD_LOCAL bool is_worker_thread = false;
+static THREAD_LOCAL bool is_background_worker = false;
+/* Stop socket pair of a background worker thread: [0] is the script's end,
+ * exposed via frankenphp_get_worker_handle(); [1] is transferred to the Go
+ * side, which closes it to signal a drain. */
+static THREAD_LOCAL php_socket_t worker_stop_socks[2] = {SOCK_ERR, SOCK_ERR};
+/* set on the first wait on the handle of the current run, see
+ * frankenphp_worker_handle_ops */
+static THREAD_LOCAL bool worker_handle_waited = false;
+/* the stream of the current run, see frankenphp_get_worker_handle(); the
+ * cache holds a ref, and the resource list of the run frees it at request
+ * shutdown, so the pointer is only reset, never released, between runs */
+static THREAD_LOCAL zend_resource *worker_handle_res = NULL;
 static THREAD_LOCAL HashTable *sandboxed_env = NULL;
 /* prepared_env holds entries from php(_server)'s `env KEY VAL`, exposed to
  * getenv() and merged into $_ENV when 'E' is in variables_order. Separate from
@@ -342,7 +358,126 @@ void frankenphp_release_thread_for_kill(force_kill_slot slot) {
 #endif
 }
 
+/* Stop channel of background workers: a socket pair. One end is exposed to
+ * the PHP script via frankenphp_get_worker_handle(), the other is handed to
+ * the Go side, which closes it on drain so the script's end reaches EOF and
+ * a stream_select() or a blocking read on it returns. A socket pair rather
+ * than a pipe because on Windows PHP's php_select() only really waits on
+ * sockets: before 8.5 it reports any other handle as always ready. */
+static void frankenphp_worker_close_sock(php_socket_t s) {
+  if (s == SOCK_ERR) {
+    return;
+  }
+#ifdef PHP_WIN32
+  closesocket(s);
+#else
+  close(s);
+#endif
+}
+
+/* keep the pair out of processes the script may spawn: a child holding the
+ * Go side's end would keep the script's end from ever reaching EOF */
+static void frankenphp_worker_sock_no_inherit(php_socket_t s) {
+#ifdef PHP_WIN32
+  SetHandleInformation((HANDLE)s, HANDLE_FLAG_INHERIT, 0);
+#else
+  fcntl(s, F_SETFD, FD_CLOEXEC);
+#endif
+}
+
+static void frankenphp_worker_close_stop_socks(void) {
+  for (int i = 0; i < 2; i++) {
+    frankenphp_worker_close_sock(worker_stop_socks[i]);
+    worker_stop_socks[i] = SOCK_ERR;
+  }
+}
+
+static int frankenphp_worker_open_stop_pair(void) {
+#ifdef PHP_WIN32
+  /* PHP's emulation, a loopback TCP pair; it only accepts AF_INET, listens
+   * on INADDR_ANY and accepts the first peer, so check the pair is ours */
+  if (socketpair(AF_INET, SOCK_STREAM, 0, worker_stop_socks) != 0) {
+    worker_stop_socks[0] = SOCK_ERR;
+    worker_stop_socks[1] = SOCK_ERR;
+
+    return -1;
+  }
+
+  struct sockaddr_in peer = {0}, local = {0};
+  int peer_len = sizeof(peer), local_len = sizeof(local);
+  if (getpeername(worker_stop_socks[0], (struct sockaddr *)&peer, &peer_len) !=
+          0 ||
+      getsockname(worker_stop_socks[1], (struct sockaddr *)&local,
+                  &local_len) != 0 ||
+      peer.sin_port != local.sin_port ||
+      peer.sin_addr.s_addr != local.sin_addr.s_addr) {
+    frankenphp_worker_close_stop_socks();
+
+    return -1;
+  }
+#else
+#ifdef SOCK_CLOEXEC
+  int type = SOCK_STREAM | SOCK_CLOEXEC;
+#else
+  int type = SOCK_STREAM;
+#endif
+  if (socketpair(AF_UNIX, type, 0, worker_stop_socks) != 0) {
+    worker_stop_socks[0] = SOCK_ERR;
+    worker_stop_socks[1] = SOCK_ERR;
+
+    return -1;
+  }
+#endif
+  /* redundant where SOCK_CLOEXEC applied; a fork()ed child (pcntl) still
+   * inherits both ends and delays the EOF until it exits */
+  frankenphp_worker_sock_no_inherit(worker_stop_socks[0]);
+  frankenphp_worker_sock_no_inherit(worker_stop_socks[1]);
+
+  return 0;
+}
+
+/* Marks the calling thread as a background worker, opens its stop socket
+ * pair and transfers the Go side's end to the caller (clearing the TLS slot
+ * so a later recycle won't double-close it). Returns -1 if the pair could
+ * not be created. max_execution_time is disarmed after php_request_startup()
+ * re-arms it, see php_thread(). */
+intptr_t frankenphp_set_background_worker_and_get_stop_sock(void) {
+  is_background_worker = true;
+  worker_handle_waited = false;
+  worker_handle_res = NULL;
+
+  frankenphp_worker_close_stop_socks();
+  if (frankenphp_worker_open_stop_pair() != 0) {
+    return -1;
+  }
+
+  intptr_t s = (intptr_t)worker_stop_socks[1];
+  worker_stop_socks[1] = SOCK_ERR;
+
+  return s;
+}
+
+/* Closes the Go side's end of a stop socket pair, which lands as EOF on the
+ * script's end so its stream_select() or blocking read returns promptly. */
+void frankenphp_worker_close_stop_sock(intptr_t s) {
+  if (s < 0) {
+    return;
+  }
+  frankenphp_worker_close_sock((php_socket_t)s);
+}
+
 void frankenphp_update_local_thread_context(bool is_worker) {
+  /* A thread that ran a background worker can be recycled into an HTTP
+   * worker or a regular request thread: reset the bg TLS so
+   * frankenphp_get_worker_handle() rejects callers again, and release the
+   * stop socket. The streams handed out by frankenphp_get_worker_handle()
+   * do not own it and were destroyed by request shutdown. */
+  if (is_background_worker) {
+    is_background_worker = false;
+    worker_handle_res = NULL;
+    frankenphp_worker_close_stop_socks();
+  }
+
   is_worker_thread = is_worker;
 
   /* workers should keep running if the user aborts the connection */
@@ -857,6 +992,15 @@ PHP_FUNCTION(frankenphp_handle_request) {
     RETURN_THROWS();
   }
 
+  if (is_background_worker) {
+    /* background workers never receive HTTP requests */
+    zend_throw_exception(
+        spl_ce_RuntimeException,
+        "frankenphp_handle_request() cannot be called from a background worker",
+        0);
+    RETURN_THROWS();
+  }
+
 #ifdef ZEND_MAX_EXECUTION_TIMERS
   /* Disable timeouts while waiting for a request to handle */
   zend_unset_timeout();
@@ -1017,6 +1161,100 @@ PHP_FUNCTION(frankenphp_log) {
   }
 }
 
+/* Ops of the streams returned by frankenphp_get_worker_handle(): the socket
+ * ops, except that the first wait on the handle, a select cast or a read,
+ * reports the worker ready, and that closing a stream leaves the socket
+ * alone: it belongs to the thread, every handle of a run shares it, and it
+ * is closed at the next run setup or on thread exit. Waiting is the
+ * background analog of an HTTP worker reaching frankenphp_handle_request():
+ * it comes after the script's bootstrap by construction, where merely
+ * fetching the handle does not. Initialized in MINIT. */
+static php_stream_ops frankenphp_worker_handle_ops;
+
+static void frankenphp_worker_handle_waited(void) {
+  if (!worker_handle_waited) {
+    worker_handle_waited = true;
+    go_frankenphp_background_worker_ready(frankenphp_thread_index());
+  }
+}
+
+static ssize_t frankenphp_worker_handle_read(php_stream *stream, char *buf,
+                                             size_t count) {
+  frankenphp_worker_handle_waited();
+
+  return php_stream_socket_ops.read(stream, buf, count);
+}
+
+static int frankenphp_worker_handle_cast(php_stream *stream, int castas,
+                                         void **ret) {
+  if (castas == PHP_STREAM_AS_FD_FOR_SELECT) {
+    frankenphp_worker_handle_waited();
+  }
+
+  return php_stream_socket_ops.cast(stream, castas, ret);
+}
+
+static int frankenphp_worker_handle_close(php_stream *stream,
+                                          int close_handle) {
+  (void)close_handle;
+
+  /* free the stream data only, never the shared socket */
+  return php_stream_socket_ops.close(stream, 0);
+}
+
+PHP_FUNCTION(frankenphp_get_worker_handle) {
+  ZEND_PARSE_PARAMETERS_NONE();
+
+  if (!is_background_worker) {
+    zend_throw_exception(spl_ce_RuntimeException,
+                         "frankenphp_get_worker_handle() can only be called "
+                         "from a background worker",
+                         0);
+    RETURN_THROWS();
+  }
+
+  if (worker_stop_socks[0] == SOCK_ERR) {
+    zend_throw_exception(spl_ce_RuntimeException,
+                         "the background worker stop socket is not available",
+                         0);
+    RETURN_THROWS();
+  }
+
+  /* One stream per run: the same resource is returned until the script
+   * closes it, so fetching the handle in a loop does not grow the resource
+   * list of a run that never ends. The stream does not own the socket (see
+   * frankenphp_worker_handle_ops), so closing it never affects a later one
+   * and the EOF of a drain reaches all. */
+  if (worker_handle_res != NULL) {
+    if (worker_handle_res->type == php_file_le_stream()) {
+      GC_ADDREF(worker_handle_res);
+      RETURN_RES(worker_handle_res);
+    }
+    /* closed by the script: drop the cache's ref */
+    zend_list_delete(worker_handle_res);
+    worker_handle_res = NULL;
+  }
+
+  php_stream *stream =
+      php_stream_sock_open_from_socket(worker_stop_socks[0], NULL);
+  if (stream == NULL) {
+    zend_throw_exception(spl_ce_RuntimeException,
+                         "failed to create a stream over the stop socket", 0);
+    RETURN_THROWS();
+  }
+
+  /* a blocking read is a valid way to park: wait without the
+   * default_socket_timeout wake-ups */
+  ((php_netstream_data_t *)stream->abstract)->timeout.tv_sec = -1;
+
+  /* report the worker ready on its first wait on the stream */
+  stream->ops = &frankenphp_worker_handle_ops;
+
+  php_stream_to_zval(stream, return_value);
+  worker_handle_res = Z_RES_P(return_value);
+  GC_ADDREF(worker_handle_res);
+}
+
 /* {{{ thread-safe opcache reset */
 PHP_FUNCTION(frankenphp_opcache_reset) {
   go_schedule_opcache_reset(frankenphp_thread_index());
@@ -1075,6 +1313,12 @@ static const zend_function_entry frankenphp_test_hook_functions[] = {
 #endif
 
 PHP_MINIT_FUNCTION(frankenphp) {
+  frankenphp_worker_handle_ops = php_stream_socket_ops;
+  frankenphp_worker_handle_ops.label = "FrankenPHP worker handle";
+  frankenphp_worker_handle_ops.read = frankenphp_worker_handle_read;
+  frankenphp_worker_handle_ops.cast = frankenphp_worker_handle_cast;
+  frankenphp_worker_handle_ops.close = frankenphp_worker_handle_close;
+
   register_frankenphp_symbols(module_number);
 #ifndef PHP_WIN32
   /* MINIT runs once per ZTS thread — guard the atfork registration */
@@ -1527,6 +1771,14 @@ static void *php_thread(void *arg) {
       frankenphp_override_opcache_reset();
 #endif
 
+#ifdef ZEND_MAX_EXECUTION_TIMERS
+      /* php_request_startup re-arms max_execution_time; background workers
+       * never enforce it, disarm again. */
+      if (is_background_worker) {
+        zend_unset_timeout();
+      }
+#endif
+
       zend_file_handle file_handle;
       zend_stream_init_filename(&file_handle, scriptName);
 
@@ -1598,6 +1850,15 @@ static void *php_thread(void *arg) {
   }
   zend_end_try();
 
+  /* The stop socket of a background worker is plain thread-local state that
+   * frankenphp_update_local_thread_context() only releases on recycle: close
+   * it here too so it does not outlive the thread on shutdown, reboot or an
+   * unhealthy exit. The Go side's end is closed by the Go side. */
+  if (is_background_worker) {
+    is_background_worker = false;
+    frankenphp_worker_close_stop_socks();
+  }
+
   /* Must precede ts_free_thread: that frees the TSRM storage backing
    * the slot's &EG() pointers. Clearing first means any concurrent
    * force-kill either ran before us or sees a zero slot. */
diff --git a/frankenphp.go b/frankenphp.go
index 8b19dd2285..7bad96781f 100644
--- a/frankenphp.go
+++ b/frankenphp.go
@@ -156,16 +156,46 @@ func Config() PHPConfig {
 	}
 }
 
-func calculateMaxThreads(opt *opt) (numWorkers int, _ error) {
+func calculateMaxThreads(opt *opt) (numWorkers int, err error) {
 	maxProcs := runtime.GOMAXPROCS(0) * 2
 	maxThreadsFromWorkers := 0
 
+	// background workers reserve their thread budget separately so they
+	// don't count against the HTTP-oriented admission checks below; the
+	// bump is applied on top of the calculated totals at the end
+	reservedThreads := 0
+	defer func() {
+		if err != nil {
+			return
+		}
+		opt.numThreads += reservedThreads
+		if opt.maxThreads > 0 {
+			// in auto mode (maxThreads < 0), the resolved value is floored
+			// to numThreads later, which already includes the reservation
+			opt.maxThreads += reservedThreads
+		}
+		numWorkers += reservedThreads
+	}()
+
 	for i, w := range opt.workers {
+		if w.isBackgroundWorker {
+			if w.num < 1 {
+				name := w.name
+				if name == "" {
+					name = w.fileName
+				}
+
+				return 0, fmt.Errorf("background worker %q must declare num >= 1", name)
+			}
+			reservedThreads += w.num
+
+			continue
+		}
+
 		if w.num <= 0 {
 			// https://github.com/php/frankenphp/issues/126
 			opt.workers[i].num = maxProcs
 		}
-		metrics.TotalWorkers(w.name, w.num)
 
 		numWorkers += opt.workers[i].num
 
@@ -307,6 +337,10 @@ func Init(options ...Option) error {
 		}
 	} else {
 		opt.numThreads = 1
+		if workerThreadCount > 1 {
+			shutdown()
+			return fmt.Errorf("%d worker threads are declared, but this PHP build is not ZTS and runs a single thread", workerThreadCount)
+		}
 
 		if globalLogger.Enabled(globalCtx, slog.LevelWarn) {
 			globalLogger.LogAttrs(globalCtx, slog.LevelWarn, `ZTS is not enabled, only 1 thread will be available, recompile PHP using the "--enable-zts" configuration option or performance will be degraded`)
@@ -467,7 +501,7 @@ func go_apache_request_headers(threadIndex C.uintptr_t) (*C.go_string, C.size_t)
 		// worker mode, not handling a request
 
 		if fc.logger.Enabled(fc.ctx, slog.LevelDebug) {
-			fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "apache_request_headers() called in non-HTTP context", slog.String("worker", fc.worker.name))
+			fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "apache_request_headers() called in non-HTTP context", slog.String("worker", fc.worker.qualifiedName))
 		}
 
 		return nil, 0
@@ -807,7 +841,7 @@ func resetGlobals() {
 	globalCtx = context.Background()
 	globalLogger = slog.Default()
 	workers = nil
-	workersByName = nil
+	globalWorkersByName = nil
 	globalWorkersByPath = nil
 	servers = nil
 	watcherIsEnabled = false
diff --git a/frankenphp.h b/frankenphp.h
index 99ac0ab7ec..e5612ee714 100644
--- a/frankenphp.h
+++ b/frankenphp.h
@@ -201,6 +201,10 @@ size_t frankenphp_get_thread_memory_usage(uintptr_t thread_index);
 void frankenphp_force_kill_thread(force_kill_slot slot);
 void frankenphp_release_thread_for_kill(force_kill_slot slot);
 
+/* Background worker primitives. */
+intptr_t frankenphp_set_background_worker_and_get_stop_sock(void);
+void frankenphp_worker_close_stop_sock(intptr_t s);
+
 void register_extensions(zend_module_entry **m, int len);
 
 #endif
diff --git a/frankenphp.stub.php b/frankenphp.stub.php
index d6c85aa05f..bf1587cc64 100644
--- a/frankenphp.stub.php
+++ b/frankenphp.stub.php
@@ -54,3 +54,16 @@ function mercure_publish(string|array $topics, string $data = '', bool $private
  * array<string, any> $context Values of the array will be converted to the corresponding Go type (if supported by FrankenPHP) and added to the context of the structured logs using https://pkg.go.dev/log/slog#Attr
  */
 function frankenphp_log(string $message, int $level = 0, array $context = []): void {}
+
+/**
+ * Returns a stop-signal stream for the current background worker. The
+ * stream reaches EOF when FrankenPHP drains the worker, so the script can
+ * park on stream_select() and exit its loop gracefully. Every call of a run
+ * returns the same stream, a fresh one over the same socket once the script
+ * closed it. The worker counts as ready, and its startup as successful, once
+ * it waits on the stream (stream_select() or a blocking read). Only callable
+ * from inside a background worker.
+ *
+ * @return resource
+ */
+function frankenphp_get_worker_handle() {}
diff --git a/frankenphp_arginfo.h b/frankenphp_arginfo.h
index 4f2707cbca..8223be08ba 100644
--- a/frankenphp_arginfo.h
+++ b/frankenphp_arginfo.h
@@ -1,5 +1,5 @@
-/* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 60f0d27c04f94d7b24c052e91ef294595a2bc421 */
+/* This is a generated file, edit frankenphp.stub.php instead.
+ * Stub hash: 2f36fc81e0981975adabf170febaaa863653817d */
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_frankenphp_handle_request, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, callback, IS_CALLABLE, 0)
@@ -41,6 +41,8 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_frankenphp_log, 0, 1, IS_VOID, 0
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, context, IS_ARRAY, 0, "[]")
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_INFO_EX(arginfo_frankenphp_get_worker_handle, 0, 0, 0)
+ZEND_END_ARG_INFO()
 
 ZEND_FUNCTION(frankenphp_handle_request);
 ZEND_FUNCTION(headers_send);
@@ -49,7 +51,7 @@ ZEND_FUNCTION(frankenphp_request_headers);
 ZEND_FUNCTION(frankenphp_response_headers);
 ZEND_FUNCTION(mercure_publish);
 ZEND_FUNCTION(frankenphp_log);
-
+ZEND_FUNCTION(frankenphp_get_worker_handle);
 
 static const zend_function_entry ext_functions[] = {
 	ZEND_FE(frankenphp_handle_request, arginfo_frankenphp_handle_request)
@@ -63,6 +65,7 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FALIAS(apache_response_headers, frankenphp_response_headers, arginfo_apache_response_headers)
 	ZEND_FE(mercure_publish, arginfo_mercure_publish)
 	ZEND_FE(frankenphp_log, arginfo_frankenphp_log)
+	ZEND_FE(frankenphp_get_worker_handle, arginfo_frankenphp_get_worker_handle)
 	ZEND_FE_END
 };
 
diff --git a/metrics.go b/metrics.go
index fc25816506..d51a3726a8 100644
--- a/metrics.go
+++ b/metrics.go
@@ -11,7 +11,7 @@ import (
 const (
 	StopReasonCrash = iota
 	StopReasonRestart
-	StopReasonBootFailure // worker crashed before reaching frankenphp_handle_request
+	StopReasonBootFailure // worker exited before reaching its ready point: frankenphp_handle_request, or frankenphp_get_worker_handle for background workers
 )
 
 type StopReason int
@@ -144,7 +144,7 @@ func (m *PrometheusMetrics) StopWorker(name string, reason StopReason) {
 
 	m.totalWorkers.WithLabelValues(name).Dec()
 
-	// only decrement readyWorkers if the worker actually reached frankenphp_handle_request
+	// only decrement readyWorkers if the worker actually reached its ready point
 	if reason != StopReasonBootFailure {
 		m.readyWorkers.WithLabelValues(name).Dec()
 	}
@@ -177,7 +177,7 @@ func (m *PrometheusMetrics) TotalWorkers(string, int) {
 		m.readyWorkers = prometheus.NewGaugeVec(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "ready_workers",
-			Help:      "Running workers that have successfully called frankenphp_handle_request at least once",
+			Help:      "Running workers that have reached their ready point at least once: frankenphp_handle_request for HTTP workers, frankenphp_get_worker_handle for background workers",
 		}, basicLabels)
 		m.mustRegister(m.readyWorkers)
 	}
diff --git a/metrics_test.go b/metrics_test.go
index 846a926569..e5ca5e3c71 100644
--- a/metrics_test.go
+++ b/metrics_test.go
@@ -185,7 +185,7 @@ func TestPrometheusMetrics_TestStopReasonCrash(t *testing.T) {
 			name: "Testing ReadyWorkers",
 			c:    m.readyWorkers,
 			metadata: `
-				# HELP frankenphp_ready_workers Running workers that have successfully called frankenphp_handle_request at least once
+				# HELP frankenphp_ready_workers Running workers that have reached their ready point at least once: frankenphp_handle_request for HTTP workers, frankenphp_get_worker_handle for background workers
 				# TYPE frankenphp_ready_workers gauge
 			`,
 			expect: `
diff --git a/options.go b/options.go
index e1eaeb7b55..930eb5d182 100644
--- a/options.go
+++ b/options.go
@@ -57,6 +57,7 @@ type workerOpt struct {
 	onServerStartup        func()
 	onServerShutdown       func()
 	server                 *Server
+	isBackgroundWorker     bool
 }
 
 // WithContext sets the main context to use.
@@ -239,6 +240,20 @@ func WithWorkerServerScope(s *Server) WorkerOption {
 	}
 }
 
+// EXPERIMENTAL: WithWorkerBackground marks this worker as a background
+// (non-HTTP) worker. Background workers run outside the request cycle:
+// they share the PHP runtime with HTTP threads but never receive HTTP
+// requests. The script can park on the stream returned by
+// frankenphp_get_worker_handle(), which reaches EOF when FrankenPHP
+// drains the worker, to exit gracefully on shutdown or restart.
+func WithWorkerBackground() WorkerOption {
+	return func(w *workerOpt) error {
+		w.isBackgroundWorker = true
+
+		return nil
+	}
+}
+
 // WithWorkerMaxFailures sets the maximum number of consecutive failures before panicking
 func WithWorkerMaxFailures(maxFailures int) WorkerOption {
 	return func(w *workerOpt) error {
diff --git a/phpmainthread.go b/phpmainthread.go
index 5e19c0fc75..0878762341 100644
--- a/phpmainthread.go
+++ b/phpmainthread.go
@@ -161,6 +161,10 @@ func (mainThread *phpMainThread) rebootAllThreads() bool {
 
 	for _, thread := range rebootingThreads {
 		rebootWg.Go(func() {
+			// wake up handlers parked in a blocking C call (background
+			// workers' stream_select on the stop socket) so they can yield
+			// for the reboot without waiting for the force-kill below
+			thread.handler.drain()
 			close(thread.drainChan)
 			if thread.state.WaitForStateWithTimeout(rebootGracePeriod, state.YieldingForReboot) {
 				return
diff --git a/phpmainthread_test.go b/phpmainthread_test.go
index 3ae65e68b9..a0ccfa8003 100644
--- a/phpmainthread_test.go
+++ b/phpmainthread_test.go
@@ -252,28 +252,26 @@ func TestFinishBootingAWorkerScript(t *testing.T) {
 
 func TestReturnAnErrorIf2WorkersHaveTheSameFileName(t *testing.T) {
 	resetGlobals()
-	workers = []*worker{}
-	workersByName = map[string]*worker{}
+	globalWorkersByName = map[string]*worker{}
 	globalWorkersByPath = map[string]*worker{}
-	w, err1 := newWorker(workerOpt{fileName: testDataPath + "/index.php"})
-	assert.NoError(t, err1)
-	workers = append(workers, w)
-	workersByName[w.name] = w
-	globalWorkersByPath[w.fileName] = w
-	_, err2 := newWorker(workerOpt{fileName: testDataPath + "/index.php"})
-	assert.Error(t, err2, "two workers cannot have the same filename")
+	w1, err := newWorker(workerOpt{fileName: testDataPath + "/index.php"})
+	assert.NoError(t, err)
+	assert.NoError(t, addGlobalWorker(w1))
+	w2, err := newWorker(workerOpt{fileName: testDataPath + "/index.php", name: "other"})
+	assert.NoError(t, err)
+	assert.ErrorContains(t, addGlobalWorker(w2), "two global workers cannot have the same filename")
 }
 
 func TestReturnAnErrorIf2ModuleWorkersHaveTheSameName(t *testing.T) {
 	resetGlobals()
-	workers = []*worker{}
-	workersByName = map[string]*worker{}
-	w, err1 := newWorker(workerOpt{fileName: testDataPath + "/index.php", name: "workername"})
-	assert.NoError(t, err1)
-	workers = append(workers, w)
-	workersByName[w.name] = w
-	_, err2 := newWorker(workerOpt{fileName: testDataPath + "/hello.php", name: "workername"})
-	assert.Error(t, err2, "two workers cannot have the same name")
+	globalWorkersByName = map[string]*worker{}
+	globalWorkersByPath = map[string]*worker{}
+	w1, err := newWorker(workerOpt{fileName: testDataPath + "/index.php", name: "workername"})
+	assert.NoError(t, err)
+	assert.NoError(t, addGlobalWorker(w1))
+	w2, err := newWorker(workerOpt{fileName: testDataPath + "/hello.php", name: "workername"})
+	assert.NoError(t, err)
+	assert.ErrorContains(t, addGlobalWorker(w2), "two global workers cannot have the same name")
 }
 
 func getDummyWorker(t *testing.T, fileName string) *worker {
diff --git a/phpthread.go b/phpthread.go
index 39ee24b5d4..4165da482a 100644
--- a/phpthread.go
+++ b/phpthread.go
@@ -39,11 +39,10 @@ type threadHandler interface {
 	beforeScriptExecution() string
 	afterScriptExecution(exitStatus int)
 	frankenPHPContext() *frankenPHPContext
-	// drain is a hook called by drainWorkerThreads right before drainChan is
-	// closed. Handlers that need to wake up a thread parked in a blocking C
-	// call (e.g. by closing a stop pipe) plug their signal in here. All
-	// current handlers are no-ops; this is the seam later handler types use
-	// without having to modify drainWorkerThreads.
+	// drain is a hook called right before drainChan is closed on shutdown
+	// and reboot. Handlers that need to wake up a thread parked in a
+	// blocking C call (background workers' stream_select on the stop socket)
+	// plug their signal in here; the other handlers are no-ops.
 	drain()
 }
 
@@ -119,6 +118,9 @@ func (thread *phpThread) shutdown() {
 		return
 	}
 
+	// wake up handlers parked in a blocking C call (background workers'
+	// stream_select on the stop socket); no-op for the other handlers
+	thread.handler.drain()
 	close(thread.drainChan)
 
 	// Arm force-kill after the grace period to wake any thread stuck in
@@ -157,6 +159,9 @@ func (thread *phpThread) setHandler(handler threadHandler) {
 		return
 	}
 
+	// wake up a handler parked in a blocking C call (background workers'
+	// stream_select on the stop socket) so it can yield for the transition
+	thread.handler.drain()
 	close(thread.drainChan)
 
 	thread.state.WaitFor(state.TransitionInProgress)
diff --git a/requestoptions.go b/requestoptions.go
index 962727562f..ad07f22d01 100644
--- a/requestoptions.go
+++ b/requestoptions.go
@@ -2,6 +2,7 @@ package frankenphp
 
 import (
 	"errors"
+	"fmt"
 	"log/slog"
 	"net/http"
 	"path/filepath"
@@ -206,12 +207,22 @@ func WithRequestBodyTimeout(timeout time.Duration) RequestOption {
 }
 
 // WithWorkerName sets the worker that should handle the request
+// the name is resolved among the workers of the request's server first, then among global workers
 func WithWorkerName(name string) RequestOption {
 	return func(o *frankenPHPContext) error {
-		if name != "" {
-			o.worker = workersByName[name]
+		if name == "" {
+			return nil
 		}
 
+		w := o.server.workersByName[name]
+		if w == nil {
+			w = globalWorkersByName[name]
+		}
+		if w != nil && w.isBackgroundWorker {
+			return fmt.Errorf("background worker %q cannot handle requests", name)
+		}
+		o.worker = w
+
 		return nil
 	}
 }
diff --git a/scaling.go b/scaling.go
index dd21a7e37c..c26465efbd 100644
--- a/scaling.go
+++ b/scaling.go
@@ -96,7 +96,7 @@ func scaleWorkerThread(worker *worker, done chan struct{}, mstate *state.ThreadS
 	thread, err := addWorkerThread(worker)
 	if err != nil {
 		if globalLogger.Enabled(globalCtx, slog.LevelWarn) {
-			globalLogger.LogAttrs(globalCtx, slog.LevelWarn, "could not increase max_threads, consider raising this limit", slog.String("worker", worker.name), slog.Any("error", err))
+			globalLogger.LogAttrs(globalCtx, slog.LevelWarn, "could not increase max_threads, consider raising this limit", slog.String("worker", worker.qualifiedName), slog.Any("error", err))
 		}
 
 		return
@@ -105,7 +105,7 @@ func scaleWorkerThread(worker *worker, done chan struct{}, mstate *state.ThreadS
 	autoScaledThreads = append(autoScaledThreads, thread)
 
 	if globalLogger.Enabled(globalCtx, slog.LevelInfo) {
-		globalLogger.LogAttrs(globalCtx, slog.LevelInfo, "upscaling worker thread", slog.String("worker", worker.name), slog.Int("thread", thread.threadIndex), slog.Int("num_threads", len(autoScaledThreads)))
+		globalLogger.LogAttrs(globalCtx, slog.LevelInfo, "upscaling worker thread", slog.String("worker", worker.qualifiedName), slog.Int("thread", thread.threadIndex), slog.Int("num_threads", len(autoScaledThreads)))
 	}
 }
 
@@ -177,7 +177,7 @@ func startUpscalingThreads(maxScaledThreads int, scale chan *frankenPHPContext,
 			// check for max worker threads here again in case requests overflowed while waiting
 			if fc.worker.isAtThreadLimit() {
 				if globalLogger.Enabled(globalCtx, slog.LevelInfo) {
-					globalLogger.LogAttrs(globalCtx, slog.LevelInfo, "cannot scale worker thread, max threads reached for worker", slog.String("worker", fc.worker.name))
+					globalLogger.LogAttrs(globalCtx, slog.LevelInfo, "cannot scale worker thread, max threads reached for worker", slog.String("worker", fc.worker.qualifiedName))
 				}
 
 				continue
diff --git a/server.go b/server.go
index 8274f23c54..ba3ae200f1 100644
--- a/server.go
+++ b/server.go
@@ -20,7 +20,7 @@ type Server struct {
 	root                      string
 	splitPath                 []string
 	env                       PreparedEnv
-	workers                   []*worker
+	workersByName             map[string]*worker
 	workersByPath             map[string]*worker
 	workersWithRequestMatcher []*worker
 
@@ -37,11 +37,11 @@ var (
 
 func newFallbackServer() *Server {
 	s := &Server{
-		idx:           -1,
-		workersByPath: make(map[string]*worker),
-		env:           make(map[string]string),
-		logger:        globalLogger,
+		idx:    -1,
+		env:    make(map[string]string),
+		logger: globalLogger,
 	}
+	s.resetWorkers()
 
 	return s
 }
@@ -54,12 +54,36 @@ func registerServers(newServers []*Server) {
 	fallbackServer.logger = globalLogger
 	fallbackServer.resetWorkers()
 
+	// several servers may resolve to the same name (e.g. the same host), but
+	// the name qualifies worker names in metrics and logs, so it must be
+	// unique: the first server keeps a name, the next ones get a numeric
+	// suffix that never takes a name another server configured
+	configured := make(map[string]struct{}, len(servers))
+	for _, s := range servers {
+		if s.configuredName != "" {
+			configured[s.configuredName] = struct{}{}
+		}
+	}
+
+	taken := make(map[string]struct{}, len(servers))
 	for i, s := range servers {
 		s.idx = i
-		s.name = s.configuredName
-		if s.name == "" {
-			s.name = "server_" + strconv.Itoa(i)
+		name := s.configuredName
+		if name == "" {
+			name = "server_" + strconv.Itoa(i)
+		}
+
+		for base, n := name, 1; ; n++ {
+			_, isTaken := taken[name]
+			_, isConfigured := configured[name]
+			if !isTaken && (!isConfigured || name == s.configuredName) {
+				break
+			}
+			name = base + "_" + strconv.Itoa(n)
 		}
+		taken[name] = struct{}{}
+
+		s.name = name
 		s.resetWorkers()
 	}
 }
@@ -83,7 +107,7 @@ func unregisterServers() {
 
 // resetWorkers drops the workers of a previous run; initWorkers() adds them back
 func (s *Server) resetWorkers() {
-	s.workers = nil
+	s.workersByName = make(map[string]*worker)
 	s.workersByPath = make(map[string]*worker)
 	s.workersWithRequestMatcher = nil
 }
@@ -99,9 +123,9 @@ func NewServer(root string, options ...ServerOption) (*Server, error) {
 	}
 
 	s := &Server{
-		root:          root,
-		workersByPath: make(map[string]*worker),
+		root: root,
 	}
+	s.resetWorkers()
 
 	for _, option := range options {
 		if err := option(s); err != nil {
@@ -125,19 +149,30 @@ func NewServer(root string, options ...ServerOption) (*Server, error) {
 }
 
 // Name returns the human-readable name of the server.
-// It is empty until registration if none was passed to NewServer().
+// It is empty until registration if none was passed to NewServer(), and gets
+// a numeric suffix if another registered server has the same name.
 func (s *Server) Name() string {
 	return s.name
 }
 
+// addWorker registers a worker scoped to this server
 func (s *Server) addWorker(w *worker) error {
-	s.workers = append(s.workers, w)
+	if s.workersByName[w.name] != nil {
+		return fmt.Errorf("two workers in a server cannot have the same name: %q", w.name)
+	}
+	s.workersByName[w.name] = w
+
+	// background workers never serve requests, so they are not matched at all
+	if w.isBackgroundWorker {
+		return nil
+	}
+
 	if w.matchRequest != nil {
 		s.workersWithRequestMatcher = append(s.workersWithRequestMatcher, w)
 		return nil
 	}
 
-	if _, exists := s.workersByPath[w.fileName]; exists {
+	if s.workersByPath[w.fileName] != nil {
 		return fmt.Errorf("two workers in a server cannot have the same filename: %q", w.fileName)
 	}
 	s.workersByPath[w.fileName] = w
diff --git a/server_test.go b/server_test.go
index f297db7c29..4bd078040c 100644
--- a/server_test.go
+++ b/server_test.go
@@ -59,12 +59,59 @@ func TestServer(t *testing.T) {
 	t.Run("name", func(t *testing.T) {
 		named, _ := frankenphp.NewServer(testDataDir, frankenphp.WithServerName("api"))
 		unnamed, _ := frankenphp.NewServer(testDataDir)
+		alsoNamed, _ := frankenphp.NewServer(testDataDir, frankenphp.WithServerName("api"))
+		explicit, _ := frankenphp.NewServer(testDataDir, frankenphp.WithServerName("api_1"))
 
-		initServers(t, frankenphp.WithServer(named), frankenphp.WithServer(unnamed))
+		initServers(t, frankenphp.WithServer(named), frankenphp.WithServer(unnamed), frankenphp.WithServer(alsoNamed), frankenphp.WithServer(explicit))
 
 		assert.Equal(t, "api", named.Name())
 		// an empty name defaults to the server index at registration
 		assert.Equal(t, "server_1", unnamed.Name())
+		// names qualify worker names in metrics, so they are made unique, and
+		// a generated suffix never takes a name another server configured
+		assert.Equal(t, "api_2", alsoNamed.Name())
+		assert.Equal(t, "api_1", explicit.Name())
+	})
+
+	t.Run("same_worker_name_in_two_servers", func(t *testing.T) {
+		server1, _ := frankenphp.NewServer(testDataDir, frankenphp.WithServerName("one"))
+		server2, _ := frankenphp.NewServer(testDataDir, frankenphp.WithServerName("two"))
+		initServers(
+			t,
+			frankenphp.WithServer(server1),
+			frankenphp.WithServer(server2),
+			frankenphp.WithWorkers("counter", testDataDir+"worker-with-counter.php", 1, frankenphp.WithWorkerServerScope(server1)),
+			frankenphp.WithWorkers("counter", testDataDir+"worker-with-counter.php", 1, frankenphp.WithWorkerServerScope(server2)),
+		)
+
+		// WithWorkerName resolves the name within the request's server
+		byName := func(server *frankenphp.Server) string {
+			t.Helper()
+			w := httptest.NewRecorder()
+			req := httptest.NewRequest(http.MethodGet, "http://example.com/index.php", nil)
+			require.NoError(t, server.ServeHTTP(w, req, frankenphp.WithWorkerName("counter")))
+			body, err := io.ReadAll(w.Result().Body)
+			require.NoError(t, err)
+
+			return string(body)
+		}
+
+		assert.Equal(t, "requests:1", byName(server1))
+		assert.Equal(t, "requests:1", byName(server2), "server 2 must get its own worker, not server 1's")
+		assert.Equal(t, "requests:2", byName(server1))
+	})
+
+	t.Run("error_on_duplicate_worker_names", func(t *testing.T) {
+		t.Cleanup(frankenphp.Shutdown)
+
+		server, _ := frankenphp.NewServer(testDataDir)
+		err := frankenphp.Init(
+			frankenphp.WithServer(server),
+			frankenphp.WithWorkers("same", testDataDir+"worker-with-counter.php", 1, frankenphp.WithWorkerServerScope(server)),
+			frankenphp.WithWorkers("same", testDataDir+"index.php", 1, frankenphp.WithWorkerServerScope(server)),
+		)
+
+		assert.ErrorContains(t, err, "two workers in a server cannot have the same name")
 	})
 
 	t.Run("root", func(t *testing.T) {
diff --git a/testdata/_executor.php b/testdata/_executor.php
index 61a5319f11..31b87c79cb 100644
--- a/testdata/_executor.php
+++ b/testdata/_executor.php
@@ -1,7 +1,7 @@
 <?php
 
 $fn = require $_SERVER['SCRIPT_FILENAME'];
-if ('1' !== ($_SERVER['FRANKENPHP_WORKER'] ?? null)) {
+if (!isset($_SERVER['FRANKENPHP_WORKER'])) {
     $fn();
     exit(0);
 }
diff --git a/testdata/bgworker/basic.php b/testdata/bgworker/basic.php
new file mode 100644
index 0000000000..6e779a11cb
--- /dev/null
+++ b/testdata/bgworker/basic.php
@@ -0,0 +1,20 @@
+<?php
+
+// Long-lived background worker: disable PHP max_execution_time so the
+// 30s default cannot interrupt the stream_select park. The C side calls
+// zend_unset_timeout() too, but the belt-and-suspenders here covers PHP
+// builds where that path does not fully disarm the timer.
+set_time_limit(0);
+
+// Touch the sentinel so the test can confirm the worker actually ran.
+if (!empty($_SERVER['BG_SENTINEL'])) {
+    @touch($_SERVER['BG_SENTINEL']);
+}
+
+// Park on the handle until FrankenPHP drains us (drain closes the other
+// end of the socket pair, which lands as EOF here).
+$stream = frankenphp_get_worker_handle();
+$read = [$stream];
+$write = null;
+$except = null;
+stream_select($read, $write, $except, null);
diff --git a/testdata/bgworker/count.php b/testdata/bgworker/count.php
new file mode 100644
index 0000000000..13937221e4
--- /dev/null
+++ b/testdata/bgworker/count.php
@@ -0,0 +1,13 @@
+<?php
+
+// Long-lived bg worker appending a line to $_SERVER['BG_COUNT_FILE'] on
+// every run, so a test can count how many times it was (re)started.
+set_time_limit(0);
+if (!empty($_SERVER['BG_COUNT_FILE'])) {
+    @file_put_contents($_SERVER['BG_COUNT_FILE'], "run\n", FILE_APPEND);
+}
+$stream = frankenphp_get_worker_handle();
+$read = [$stream];
+$write = null;
+$except = null;
+stream_select($read, $write, $except, null);
diff --git a/testdata/bgworker/crash-after-ready.php b/testdata/bgworker/crash-after-ready.php
new file mode 100644
index 0000000000..445932b388
--- /dev/null
+++ b/testdata/bgworker/crash-after-ready.php
@@ -0,0 +1,13 @@
+<?php
+
+// Reaches the ready point (a zero-timeout wait on the handle counts), then
+// exits non-zero: a crash after readiness restarts right away and does not
+// count toward max_consecutive_failures. Runs are counted in BG_COUNT_FILE.
+set_time_limit(0);
+file_put_contents($_SERVER['BG_COUNT_FILE'], "run\n", FILE_APPEND);
+$stream = frankenphp_get_worker_handle();
+$read = [$stream];
+$write = null;
+$except = null;
+stream_select($read, $write, $except, 0);
+exit(1);
diff --git a/testdata/bgworker/crash.php b/testdata/bgworker/crash.php
new file mode 100644
index 0000000000..1576f47b3c
--- /dev/null
+++ b/testdata/bgworker/crash.php
@@ -0,0 +1,29 @@
+<?php
+
+// Crash-and-recover fixture. On the first boot (no marker), creates the
+// marker and exit(1) so the bg worker thread observes a non-zero exit
+// status. On the second boot (marker present), touches a "restarted"
+// sentinel and parks on its handle. The test asserts the restarted
+// sentinel appears, proving the crash-restart loop ran.
+set_time_limit(0);
+
+$marker = $_SERVER['BG_CRASH_MARKER'] ?? '';
+$restarted = $_SERVER['BG_RESTARTED_SENTINEL'] ?? '';
+
+if ($marker === '' || $restarted === '') {
+    // Misconfigured: don't loop forever on a missing env.
+    exit(2);
+}
+
+if (!file_exists($marker)) {
+    file_put_contents($marker, '1');
+    exit(1);
+}
+
+@touch($restarted);
+
+$stream = frankenphp_get_worker_handle();
+$read = [$stream];
+$write = null;
+$except = null;
+stream_select($read, $write, $except, null);
diff --git a/testdata/bgworker/early-return.php b/testdata/bgworker/early-return.php
new file mode 100644
index 0000000000..410ce647d5
--- /dev/null
+++ b/testdata/bgworker/early-return.php
@@ -0,0 +1,5 @@
+<?php
+
+// Broken background worker: returns immediately without ever waiting on its
+// handle from frankenphp_get_worker_handle(). Without a guard this would
+// respawn in a tight loop; the guard treats it as a boot failure instead.
diff --git a/testdata/bgworker/fail-then-succeed.php b/testdata/bgworker/fail-then-succeed.php
new file mode 100644
index 0000000000..a38999102d
--- /dev/null
+++ b/testdata/bgworker/fail-then-succeed.php
@@ -0,0 +1,16 @@
+<?php
+
+// Crashes on its first BG_FAIL_UNTIL boots, then parks: the boot-failure
+// backoff up to a success. Boots are counted in BG_COUNT_FILE.
+set_time_limit(0);
+$count = (int) @file_get_contents($_SERVER['BG_COUNT_FILE']) + 1;
+file_put_contents($_SERVER['BG_COUNT_FILE'], (string) $count);
+if ($count <= (int) $_SERVER['BG_FAIL_UNTIL']) {
+    exit(1);
+}
+@touch($_SERVER['BG_SENTINEL']);
+$stream = frankenphp_get_worker_handle();
+$read = [$stream];
+$write = null;
+$except = null;
+stream_select($read, $write, $except, null);
diff --git a/testdata/bgworker/fetch-no-wait.php b/testdata/bgworker/fetch-no-wait.php
new file mode 100644
index 0000000000..7fa6f96ccf
--- /dev/null
+++ b/testdata/bgworker/fetch-no-wait.php
@@ -0,0 +1,7 @@
+<?php
+
+// Broken background worker: fetches its handle but returns without ever
+// waiting on it. Fetching is not the ready point, waiting is, so this counts
+// as a boot failure like early-return.php.
+set_time_limit(0);
+$stream = frankenphp_get_worker_handle();
diff --git a/testdata/bgworker/flag.php b/testdata/bgworker/flag.php
new file mode 100644
index 0000000000..4e05d55e2a
--- /dev/null
+++ b/testdata/bgworker/flag.php
@@ -0,0 +1,14 @@
+<?php
+
+// Bg worker writing the two server variables identifying it, so the test
+// can assert their exact values, then parking.
+set_time_limit(0);
+file_put_contents($_SERVER['BG_SENTINEL'], var_export([
+    'worker' => $_SERVER['FRANKENPHP_WORKER'] ?? null,
+    'background' => $_SERVER['FRANKENPHP_WORKER_BACKGROUND'] ?? null,
+], true));
+$stream = frankenphp_get_worker_handle();
+$read = [$stream];
+$write = null;
+$except = null;
+stream_select($read, $write, $except, null);
diff --git a/testdata/bgworker/named.php b/testdata/bgworker/named.php
new file mode 100644
index 0000000000..4b12f88961
--- /dev/null
+++ b/testdata/bgworker/named.php
@@ -0,0 +1,19 @@
+<?php
+
+// Long-lived bg worker that touches a per-name sentinel under
+// $_SERVER['BG_SENTINEL_DIR'] so tests can confirm the right instance
+// ran. The bg worker's $_SERVER['FRANKENPHP_WORKER'] value is the
+// declared name, so the same fixture serves multiple distinct names
+// across scopes.
+set_time_limit(0);
+
+$name = $_SERVER['FRANKENPHP_WORKER'] ?? 'unknown';
+if (!empty($_SERVER['BG_SENTINEL_DIR'])) {
+    @touch($_SERVER['BG_SENTINEL_DIR'] . DIRECTORY_SEPARATOR . $name);
+}
+
+$stream = frankenphp_get_worker_handle();
+$read = [$stream];
+$write = null;
+$except = null;
+stream_select($read, $write, $except, null);
diff --git a/testdata/bgworker/pool.php b/testdata/bgworker/pool.php
new file mode 100644
index 0000000000..9b5a9096da
--- /dev/null
+++ b/testdata/bgworker/pool.php
@@ -0,0 +1,11 @@
+<?php
+
+// Pool bg worker: num > 1 threads share the name; each touches a file of
+// its own under BG_SENTINEL_DIR, then parks on its own handle.
+set_time_limit(0);
+@touch($_SERVER['BG_SENTINEL_DIR'] . DIRECTORY_SEPARATOR . bin2hex(random_bytes(8)));
+$stream = frankenphp_get_worker_handle();
+$read = [$stream];
+$write = null;
+$except = null;
+stream_select($read, $write, $except, null);
diff --git a/testdata/bgworker/read.php b/testdata/bgworker/read.php
new file mode 100644
index 0000000000..c57e38b341
--- /dev/null
+++ b/testdata/bgworker/read.php
@@ -0,0 +1,11 @@
+<?php
+
+// Long-lived bg worker parking with a blocking read instead of
+// stream_select(): it counts as the wait that marks the worker ready too,
+// and returns on the EOF of a drain.
+set_time_limit(0);
+if (!empty($_SERVER['BG_SENTINEL'])) {
+    @touch($_SERVER['BG_SENTINEL']);
+}
+$stream = frankenphp_get_worker_handle();
+fgets($stream);
diff --git a/testdata/bgworker/stuck.php b/testdata/bgworker/stuck.php
new file mode 100644
index 0000000000..2c69599c21
--- /dev/null
+++ b/testdata/bgworker/stuck.php
@@ -0,0 +1,18 @@
+<?php
+
+// Reaches the ready point, then ignores its handle and sleeps on the first
+// run: only the force-kill can end that run, which is what the reboot test
+// proves. Later runs park properly so the shutdown stays quick.
+set_time_limit(0);
+$stream = frankenphp_get_worker_handle();
+$read = [$stream];
+$write = null;
+$except = null;
+stream_select($read, $write, $except, 0);
+if (!file_exists($_SERVER['BG_ONCE'])) {
+    @touch($_SERVER['BG_ONCE']);
+    sleep(60);
+}
+@touch($_SERVER['BG_SENTINEL']);
+$read = [$stream];
+stream_select($read, $write, $except, null);
diff --git a/testdata/handle-outside.php b/testdata/handle-outside.php
new file mode 100644
index 0000000000..52eb652b9b
--- /dev/null
+++ b/testdata/handle-outside.php
@@ -0,0 +1,8 @@
+<?php
+
+try {
+    frankenphp_get_worker_handle();
+    echo 'no exception';
+} catch (\RuntimeException $e) {
+    echo $e->getMessage();
+}
diff --git a/testdata/symlinks/test/index.php b/testdata/symlinks/test/index.php
index 15aa1a9cf1..9037dbe762 100644
--- a/testdata/symlinks/test/index.php
+++ b/testdata/symlinks/test/index.php
@@ -1,7 +1,7 @@
 <?php
 
 if (!isset($_SERVER['FRANKENPHP_WORKER'])) {
-    die("Error: This script must be run in worker mode (FRANKENPHP_WORKER not set to '1')\n");
+    die("Error: This script must be run in worker mode (FRANKENPHP_WORKER not set)\n");
 }
 
 $i = 0;
diff --git a/testdata/symlinks/test/nested/index.php b/testdata/symlinks/test/nested/index.php
index 3d07bc8d89..98622ba57f 100644
--- a/testdata/symlinks/test/nested/index.php
+++ b/testdata/symlinks/test/nested/index.php
@@ -1,7 +1,7 @@
 <?php
 
 if (!isset($_SERVER['FRANKENPHP_WORKER'])) {
-    die("Error: This script must be run in worker mode (FRANKENPHP_WORKER not set to '1')\n");
+    die("Error: This script must be run in worker mode (FRANKENPHP_WORKER not set)\n");
 }
 
 $i = 0;
diff --git a/testdata/worker-name.php b/testdata/worker-name.php
new file mode 100644
index 0000000000..b9760c8dfc
--- /dev/null
+++ b/testdata/worker-name.php
@@ -0,0 +1,11 @@
+<?php
+
+// HTTP worker echoing what identified it at boot: its name, and whether the
+// background flag was set.
+$name = $_SERVER['FRANKENPHP_WORKER'] ?? 'unset';
+$mode = isset($_SERVER['FRANKENPHP_WORKER_BACKGROUND']) ? 'background' : 'http';
+$handler = static function () use ($name, $mode) {
+    echo "$name $mode";
+};
+while (frankenphp_handle_request($handler)) {
+}
diff --git a/threadbackgroundworker.go b/threadbackgroundworker.go
new file mode 100644
index 0000000000..c291ad0cc0
--- /dev/null
+++ b/threadbackgroundworker.go
@@ -0,0 +1,289 @@
+package frankenphp
+
+// /* closesocket() lives in ws2_32: the PHP dll links it, a cgo build does not by itself */
+// #cgo windows LDFLAGS: -lws2_32
+// #include "frankenphp.h"
+import "C"
+import (
+	"fmt"
+	"log/slog"
+	"sync/atomic"
+	"time"
+
+	"github.com/dunglas/frankenphp/internal/state"
+)
+
+// backgroundWorkerThread is the threadHandler of background worker scripts.
+// It owns their lifecycle: boot the script, re-run it when it exits, restart
+// it with a quadratic backoff when it crashes. Background workers share the
+// PHP runtime with HTTP threads but never receive HTTP requests. The script
+// can park on the stream returned by frankenphp_get_worker_handle(), which
+// reaches EOF when the thread is drained, to exit gracefully on shutdown,
+// reboot or handler transition.
+type backgroundWorkerThread struct {
+	state                  *state.ThreadState
+	thread                 *phpThread
+	worker                 *worker
+	dummyFrankenPHPContext *frankenPHPContext
+	failureCount           int // number of consecutive failed runs
+
+	// isBootingScript is true until the current run waits on its handle, a
+	// stream_select() or a read on the stream returned by
+	// frankenphp_get_worker_handle(), the background analog of an HTTP
+	// worker reaching frankenphp_handle_request(). Only touched on the PHP
+	// thread (setup, the C callback during execution, teardown).
+	isBootingScript bool
+
+	// bootTimer warns when a run has not waited on its handle after
+	// backgroundBootWarnDelay; only touched on the PHP thread
+	bootTimer *time.Timer
+
+	// stopSock holds the Go side's end of this thread's stop socket pair
+	// (per thread so pool workers drain independently); the other end is
+	// exposed to the script via frankenphp_get_worker_handle(). Wide enough
+	// for a Windows SOCKET, -1 when not held. Atomic because drain() closes
+	// it from another goroutine.
+	stopSock atomic.Int64
+}
+
+// backgroundBootWarnDelay is how long a run may go without waiting on its
+// handle before a warning: Init() and Shutdown() wait for that point, so a
+// script that never gets there hangs both silently
+const backgroundBootWarnDelay = 10 * time.Second
+
+func convertToBackgroundWorkerThread(thread *phpThread, worker *worker) {
+	handler := &backgroundWorkerThread{
+		state:  thread.state,
+		thread: thread,
+		worker: worker,
+	}
+	handler.stopSock.Store(-1)
+	thread.setHandler(handler)
+	worker.attachThread(thread)
+}
+
+func (handler *backgroundWorkerThread) name() string {
+	return "Background Worker PHP Thread - " + handler.worker.fileName
+}
+
+func (handler *backgroundWorkerThread) frankenPHPContext() *frankenPHPContext {
+	return handler.dummyFrankenPHPContext
+}
+
+// drain closes the Go side's end of the stop socket pair so a script
+// parked on the other end wakes up with EOF and can exit its loop. Called
+// right before drainChan is closed on shutdown and reboot; also reused
+// internally to release the socket on the other exit paths.
+func (handler *backgroundWorkerThread) drain() {
+	if s := handler.stopSock.Swap(-1); s >= 0 {
+		C.frankenphp_worker_close_stop_sock(C.intptr_t(s))
+	}
+}
+
+// beforeScriptExecution returns the name of the script or an empty string on shutdown
+func (handler *backgroundWorkerThread) beforeScriptExecution() string {
+	switch handler.state.Get() {
+	case state.TransitionRequested:
+		if handler.worker.onThreadShutdown != nil {
+			handler.worker.onThreadShutdown(handler.thread.threadIndex)
+		}
+		handler.worker.detachThread(handler.thread)
+		return handler.thread.transitionToNewHandler()
+	case state.Ready, state.TransitionComplete:
+		handler.thread.updateContext(true)
+		if handler.worker.onThreadReady != nil {
+			handler.worker.onThreadReady(handler.thread.threadIndex)
+		}
+
+		for {
+			err := handler.setupScript()
+			if err == nil {
+				return handler.worker.fileName
+			}
+
+			if globalLogger.Enabled(globalCtx, slog.LevelError) {
+				globalLogger.LogAttrs(globalCtx, slog.LevelError, "failed to start background worker", slog.String("worker", handler.worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex), slog.Any("error", err))
+			}
+
+			// fail fast during startup so Init() surfaces the error to the
+			// operator; past startup, back off and retry like a crash
+			if startupFailChan != nil {
+				startupFailChan <- err
+				handler.thread.state.Set(state.ShuttingDown)
+				return handler.beforeScriptExecution()
+			}
+
+			handler.backoff()
+			if !handler.state.Is(state.Ready) && !handler.state.Is(state.TransitionComplete) {
+				// drained during the backoff (shutdown, reboot, transition)
+				return handler.beforeScriptExecution()
+			}
+		}
+	case state.Rebooting, state.ForceRebooting:
+		return ""
+	case state.RebootReady:
+		handler.state.Set(state.Ready)
+		return handler.beforeScriptExecution()
+	case state.ShuttingDown:
+		if handler.worker.onThreadShutdown != nil {
+			handler.worker.onThreadShutdown(handler.thread.threadIndex)
+		}
+		handler.worker.detachThread(handler.thread)
+
+		// signal to stop
+		return ""
+	default:
+		panic("unexpected state: " + handler.state.Name())
+	}
+}
+
+// setupScript marks the thread as a background worker on the C side and
+// takes ownership of the Go side's end of its stop socket pair.
+func (handler *backgroundWorkerThread) setupScript() error {
+	s := int64(C.frankenphp_set_background_worker_and_get_stop_sock())
+	if s < 0 {
+		return fmt.Errorf("failed to create the stop socket pair of background worker %q", handler.worker.qualifiedName)
+	}
+	handler.stopSock.Store(s)
+
+	switch handler.state.Get() {
+	case state.ShuttingDown, state.Rebooting, state.ForceRebooting, state.TransitionRequested:
+		// a concurrent drain may have run before the socket was published;
+		// close it now so the script observes EOF immediately
+		handler.drain()
+	}
+
+	fc, err := newWorkerDummyContext(handler.worker)
+	if err != nil {
+		handler.drain()
+		return err
+	}
+	handler.dummyFrankenPHPContext = fc
+
+	handler.isBootingScript = true
+	metrics.StartWorker(handler.worker.qualifiedName)
+	handler.bootTimer = time.AfterFunc(backgroundBootWarnDelay, func() {
+		if globalLogger.Enabled(globalCtx, slog.LevelWarn) {
+			globalLogger.LogAttrs(globalCtx, slog.LevelWarn, "background worker has not waited on its handle yet, Init() and Shutdown() wait for it, see frankenphp_get_worker_handle()", slog.String("worker", handler.worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex))
+		}
+	})
+
+	if fc.logger.Enabled(fc.ctx, slog.LevelDebug) {
+		fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "starting background worker", slog.String("worker", handler.worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex))
+	}
+
+	// the thread stays in TransitionComplete until the script waits on its
+	// handle, see go_frankenphp_background_worker_ready
+
+	return nil
+}
+
+func (handler *backgroundWorkerThread) afterScriptExecution(exitStatus int) {
+	// the Go side's end of the stop socket pair belongs to this thread;
+	// release it on every exit path so the next run gets a fresh pair
+	// (drain() already took it when the exit was drain-triggered)
+	handler.drain()
+	worker := handler.worker
+	handler.dummyFrankenPHPContext = nil
+
+	handler.stopBootTimer()
+	handler.state.MarkAsWaiting(false)
+
+	// cooperative exit: the script waited on its handle and returned cleanly,
+	// re-run it, unless the thread is being drained (beforeScriptExecution
+	// checks the state)
+	if exitStatus == 0 && !handler.isBootingScript {
+		metrics.StopWorker(worker.qualifiedName, StopReasonRestart)
+
+		if globalLogger.Enabled(globalCtx, slog.LevelDebug) {
+			globalLogger.LogAttrs(globalCtx, slog.LevelDebug, "restarting background worker", slog.String("worker", worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex))
+		}
+
+		return
+	}
+
+	// crash after the ready point: like an HTTP worker, restart right away;
+	// only boot failures count toward max_consecutive_failures
+	if !handler.isBootingScript {
+		metrics.StopWorker(worker.qualifiedName, StopReasonCrash)
+
+		if globalLogger.Enabled(globalCtx, slog.LevelWarn) {
+			globalLogger.LogAttrs(globalCtx, slog.LevelWarn, "background worker crashed, restarting", slog.String("worker", worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex), slog.Int("exit_status", exitStatus))
+		}
+
+		return
+	}
+
+	// boot failure: the script exited before waiting on its handle, a clean
+	// exit included, which would otherwise respawn in a tight loop.
+	// StopReasonBootFailure skips the ready-gauge decrement, matching the
+	// ReadyWorker call that never happened
+	metrics.StopWorker(worker.qualifiedName, StopReasonBootFailure)
+
+	// max_consecutive_failures only fails hard during startup, where it
+	// surfaces on startupFailChan so Init() returns the error to the
+	// operator. Past startup, a failing background worker keeps
+	// restarting with a louder log line: silently giving up would leave
+	// the server in a broken half-state with no clear way to recover.
+	pastCap := worker.maxConsecutiveFailures >= 0 && handler.failureCount >= worker.maxConsecutiveFailures
+	if pastCap && startupFailChan != nil && !watcherIsEnabled {
+		if exitStatus == 0 {
+			startupFailChan <- fmt.Errorf("background worker %s exits without waiting on its handle, see frankenphp_get_worker_handle()", worker.fileName)
+		} else {
+			startupFailChan <- fmt.Errorf("too many consecutive failures: background worker %s keeps crashing", worker.fileName)
+		}
+		handler.thread.state.Set(state.ShuttingDown)
+		return
+	}
+
+	logLevel := slog.LevelWarn
+	logMsg := "background worker failed before waiting on its handle, restarting"
+	if exitStatus == 0 {
+		logMsg = "background worker exited without waiting on its handle, restarting"
+	}
+	if pastCap {
+		logLevel = slog.LevelError
+		logMsg = "background worker exceeded max_consecutive_failures, still restarting"
+	}
+	if globalLogger.Enabled(globalCtx, logLevel) {
+		globalLogger.LogAttrs(globalCtx, logLevel, logMsg, slog.String("worker", worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex), slog.Int("failures", handler.failureCount), slog.Int("exit_status", exitStatus))
+	}
+
+	handler.backoff()
+}
+
+func (handler *backgroundWorkerThread) stopBootTimer() {
+	if handler.bootTimer != nil {
+		handler.bootTimer.Stop()
+		handler.bootTimer = nil
+	}
+}
+
+//export go_frankenphp_background_worker_ready
+func go_frankenphp_background_worker_ready(threadIndex C.uintptr_t) {
+	// called on the PHP thread on the first wait on the handle; the handler
+	// is a backgroundWorkerThread because frankenphp_get_worker_handle()
+	// throws on every other thread kind
+	if handler, ok := phpThreads[threadIndex].handler.(*backgroundWorkerThread); ok && handler.isBootingScript {
+		handler.isBootingScript = false
+		// the boot succeeded, only consecutive boot failures count
+		handler.failureCount = 0
+		handler.stopBootTimer()
+		metrics.ReadyWorker(handler.worker.qualifiedName)
+		// parked from now on as far as the threads state endpoint is concerned
+		handler.state.MarkAsWaiting(true)
+
+		// like an HTTP worker reaching frankenphp_handle_request(), the thread
+		// is ready only now: initWorkers() waits for this state, so a script
+		// that fails before waiting on its handle still fails Init()
+		if handler.state.Is(state.TransitionComplete) {
+			handler.state.Set(state.Ready)
+		}
+	}
+}
+
+// backoff waits before the next run of a crashed script, see restartBackoff
+func (handler *backgroundWorkerThread) backoff() {
+	time.Sleep(restartBackoff(handler.failureCount))
+	handler.failureCount++
+}
diff --git a/threadworker.go b/threadworker.go
index 8a308b4d87..a6a8d3062c 100644
--- a/threadworker.go
+++ b/threadworker.go
@@ -90,7 +90,7 @@ func (handler *workerThread) name() string {
 func (handler *workerThread) drain() {}
 
 func setupWorkerScript(handler *workerThread, worker *worker) {
-	metrics.StartWorker(worker.name)
+	metrics.StartWorker(worker.qualifiedName)
 
 	// Create a dummy request to set up the worker
 	fc, err := newWorkerDummyContext(worker)
@@ -103,7 +103,7 @@ func setupWorkerScript(handler *workerThread, worker *worker) {
 	handler.requestCount = 0
 
 	if fc.logger.Enabled(fc.ctx, slog.LevelDebug) {
-		fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "starting", slog.String("worker", worker.name), slog.Int("thread", handler.thread.threadIndex))
+		fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "starting", slog.String("worker", worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex))
 	}
 }
 
@@ -122,10 +122,10 @@ func tearDownWorkerScript(handler *workerThread, exitStatus int) {
 
 	// on exit status 0 we just run the worker script again
 	if exitStatus == 0 && !handler.isBootingScript {
-		metrics.StopWorker(worker.name, StopReasonRestart)
+		metrics.StopWorker(worker.qualifiedName, StopReasonRestart)
 
 		if globalLogger.Enabled(globalCtx, slog.LevelDebug) {
-			globalLogger.LogAttrs(globalCtx, slog.LevelDebug, "restarting", slog.String("worker", worker.name), slog.Int("thread", handler.thread.threadIndex), slog.Int("exit_status", exitStatus))
+			globalLogger.LogAttrs(globalCtx, slog.LevelDebug, "restarting", slog.String("worker", worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex), slog.Int("exit_status", exitStatus))
 		}
 
 		return
@@ -133,9 +133,9 @@ func tearDownWorkerScript(handler *workerThread, exitStatus int) {
 
 	// worker has thrown a fatal error or has not reached frankenphp_handle_request
 	if handler.isBootingScript {
-		metrics.StopWorker(worker.name, StopReasonBootFailure)
+		metrics.StopWorker(worker.qualifiedName, StopReasonBootFailure)
 	} else {
-		metrics.StopWorker(worker.name, StopReasonCrash)
+		metrics.StopWorker(worker.qualifiedName, StopReasonCrash)
 	}
 
 	if !handler.isBootingScript {
@@ -143,7 +143,7 @@ func tearDownWorkerScript(handler *workerThread, exitStatus int) {
 		// unlike a clean restart, this took down any in-flight request, so
 		// surface it above debug level, with the exit status needed to triage it
 		if globalLogger.Enabled(globalCtx, slog.LevelWarn) {
-			globalLogger.LogAttrs(globalCtx, slog.LevelWarn, "unexpected termination, restarting", slog.String("worker", worker.name), slog.Int("thread", handler.thread.threadIndex), slog.Int("exit_status", exitStatus))
+			globalLogger.LogAttrs(globalCtx, slog.LevelWarn, "unexpected termination, restarting", slog.String("worker", worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex), slog.Int("exit_status", exitStatus))
 		}
 
 		return
@@ -158,23 +158,26 @@ func tearDownWorkerScript(handler *workerThread, exitStatus int) {
 	if watcherIsEnabled {
 		// worker script has probably failed due to script changes while watcher is enabled
 		if globalLogger.Enabled(globalCtx, slog.LevelError) {
-			globalLogger.LogAttrs(globalCtx, slog.LevelError, "(watcher enabled) worker script has not reached frankenphp_handle_request()", slog.String("worker", worker.name), slog.Int("thread", handler.thread.threadIndex))
+			globalLogger.LogAttrs(globalCtx, slog.LevelError, "(watcher enabled) worker script has not reached frankenphp_handle_request()", slog.String("worker", worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex))
 		}
 	} else {
 		// rare case where worker script has failed on a restart during normal operation
 		// this can happen if startup success depends on external resources
 		if globalLogger.Enabled(globalCtx, slog.LevelWarn) {
-			globalLogger.LogAttrs(globalCtx, slog.LevelWarn, "worker script has failed on restart", slog.String("worker", worker.name), slog.Int("thread", handler.thread.threadIndex), slog.Int("failures", handler.failureCount))
+			globalLogger.LogAttrs(globalCtx, slog.LevelWarn, "worker script has failed on restart", slog.String("worker", worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex), slog.Int("failures", handler.failureCount))
 		}
 	}
 
-	// wait a bit and try again (exponential backoff)
-	backoffDuration := time.Duration(handler.failureCount*handler.failureCount*100) * time.Millisecond
-	if backoffDuration > time.Second {
-		backoffDuration = time.Second
-	}
+	// wait a bit and try again
+	time.Sleep(restartBackoff(handler.failureCount))
 	handler.failureCount++
-	time.Sleep(backoffDuration)
+}
+
+// restartBackoff is the wait before a worker script is re-run after a
+// failure: quadratic in the number of consecutive failures, capped at one
+// second; shared by HTTP and background workers
+func restartBackoff(failures int) time.Duration {
+	return min(time.Duration(failures*failures*100)*time.Millisecond, time.Second)
 }
 
 // waitForWorkerRequest is called during frankenphp_handle_request in the php worker script.
@@ -183,7 +186,7 @@ func (handler *workerThread) waitForWorkerRequest() (bool, any) {
 	handler.thread.Unpin()
 
 	if globalLogger.Enabled(globalCtx, slog.LevelDebug) {
-		globalLogger.LogAttrs(globalCtx, slog.LevelDebug, "waiting for request", slog.String("worker", handler.worker.name), slog.Int("thread", handler.thread.threadIndex))
+		globalLogger.LogAttrs(globalCtx, slog.LevelDebug, "waiting for request", slog.String("worker", handler.worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex))
 	}
 
 	// Clear the first dummy request created to initialize the worker
@@ -195,14 +198,14 @@ func (handler *workerThread) waitForWorkerRequest() (bool, any) {
 		}
 
 		// worker is truly ready only after reaching frankenphp_handle_request()
-		metrics.ReadyWorker(handler.worker.name)
+		metrics.ReadyWorker(handler.worker.qualifiedName)
 	}
 
 	// max_requests reached: signal reboot for full ZTS cleanup
 	if maxRequestsPerThread > 0 && handler.requestCount >= maxRequestsPerThread {
 		if globalLogger.Enabled(globalCtx, slog.LevelDebug) {
 			globalLogger.LogAttrs(globalCtx, slog.LevelDebug, "max requests reached, restarting",
-				slog.String("worker", handler.worker.name),
+				slog.String("worker", handler.worker.qualifiedName),
 				slog.Int("thread", handler.thread.threadIndex),
 				slog.Int("max_requests", maxRequestsPerThread),
 			)
@@ -223,7 +226,7 @@ func (handler *workerThread) waitForWorkerRequest() (bool, any) {
 	select {
 	case <-handler.thread.drainChan:
 		if globalLogger.Enabled(globalCtx, slog.LevelDebug) {
-			globalLogger.LogAttrs(globalCtx, slog.LevelDebug, "shutting down", slog.String("worker", handler.worker.name), slog.Int("thread", handler.thread.threadIndex))
+			globalLogger.LogAttrs(globalCtx, slog.LevelDebug, "shutting down", slog.String("worker", handler.worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex))
 		}
 
 		return false, nil
@@ -239,9 +242,9 @@ func (handler *workerThread) waitForWorkerRequest() (bool, any) {
 
 	if fc.logger.Enabled(fc.ctx, slog.LevelDebug) {
 		if handler.workerFrankenPHPContext.request == nil {
-			fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "request handling started", slog.String("worker", handler.worker.name), slog.Int("thread", handler.thread.threadIndex))
+			fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "request handling started", slog.String("worker", handler.worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex))
 		} else {
-			fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "request handling started", slog.String("worker", handler.worker.name), slog.Int("thread", handler.thread.threadIndex), slog.String("url", handler.workerFrankenPHPContext.request.RequestURI))
+			fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "request handling started", slog.String("worker", handler.worker.qualifiedName), slog.Int("thread", handler.thread.threadIndex), slog.String("url", handler.workerFrankenPHPContext.request.RequestURI))
 		}
 	}
 
@@ -298,9 +301,9 @@ func go_frankenphp_finish_worker_request(threadIndex C.uintptr_t, retval *C.zval
 
 	if fc.logger.Enabled(fc.ctx, slog.LevelDebug) {
 		if fc.request == nil {
-			fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "request handling finished", slog.String("worker", fc.worker.name), slog.Int("thread", thread.threadIndex))
+			fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "request handling finished", slog.String("worker", fc.worker.qualifiedName), slog.Int("thread", thread.threadIndex))
 		} else {
-			fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "request handling finished", slog.String("worker", fc.worker.name), slog.Int("thread", thread.threadIndex), slog.String("url", fc.request.RequestURI))
+			fc.logger.LogAttrs(fc.ctx, slog.LevelDebug, "request handling finished", slog.String("worker", fc.worker.qualifiedName), slog.Int("thread", thread.threadIndex), slog.String("url", fc.request.RequestURI))
 		}
 	}
 }
diff --git a/worker.go b/worker.go
index 388dfbd031..05e3de021d 100644
--- a/worker.go
+++ b/worker.go
@@ -8,6 +8,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"slices"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -20,7 +21,11 @@ import (
 type worker struct {
 	mercureContext
 
-	name                   string
+	// name as declared, unique within its server (or among global workers)
+	name string
+	// qualifiedName is unique across the process: "<server name>:<name>" for
+	// server-scoped workers, name otherwise; used for metrics and logs
+	qualifiedName          string
 	fileName               string
 	matchRequest           func(*http.Request) bool
 	num                    int
@@ -34,11 +39,13 @@ type worker struct {
 	onThreadShutdown       func(int)
 	queuedRequests         atomic.Int32
 	server                 *Server
+	// isBackgroundWorker marks this as a background (non-HTTP) worker
+	isBackgroundWorker bool
 }
 
 var (
 	workers             []*worker
-	workersByName       map[string]*worker
+	globalWorkersByName map[string]*worker
 	globalWorkersByPath map[string]*worker
 	watcherIsEnabled    bool
 	startupFailChan     chan error
@@ -55,7 +62,7 @@ func initWorkers(opts []workerOpt) error {
 	)
 
 	workers = make([]*worker, 0, len(opts))
-	workersByName = make(map[string]*worker, len(opts))
+	globalWorkersByName = make(map[string]*worker, len(opts))
 	globalWorkersByPath = make(map[string]*worker, len(opts))
 
 	for _, o := range opts {
@@ -66,10 +73,20 @@ func initWorkers(opts []workerOpt) error {
 
 		totalThreadsToStart += w.num
 		workers = append(workers, w)
-		workersByName[w.name] = w
+		// reported here rather than in calculateMaxThreads(), where the name is not resolved yet
+		metrics.TotalWorkers(w.qualifiedName, w.num)
+
+		if w.server != nil && !slices.Contains(servers, w.server) {
+			return fmt.Errorf("worker %q is scoped to a server that was not passed to WithServer()", w.name)
+		}
+
+		// names and paths are unique within a scope: the worker's server, or the global workers
 		if w.server == nil {
-			globalWorkersByPath[w.fileName] = w
-		} else if err := w.server.addWorker(w); err != nil {
+			err = addGlobalWorker(w)
+		} else {
+			err = w.server.addWorker(w)
+		}
+		if err != nil {
 			return err
 		}
 	}
@@ -79,7 +96,11 @@ func initWorkers(opts []workerOpt) error {
 	for _, w := range workers {
 		for range w.num {
 			thread := getInactivePHPThread()
-			convertToWorkerThread(thread, w)
+			if w.isBackgroundWorker {
+				convertToBackgroundWorkerThread(thread, w)
+			} else {
+				convertToWorkerThread(thread, w)
+			}
 
 			workersReady.Go(func() {
 				thread.state.WaitFor(state.Ready, state.ShuttingDown, state.Done)
@@ -119,23 +140,33 @@ func newWorker(o workerOpt) (*worker, error) {
 		return nil, fmt.Errorf("worker file not found %q: %w", absFileName, err)
 	}
 
+	if o.isBackgroundWorker {
+		// the name is the script's identity (exposed via FRANKENPHP_WORKER);
+		// empty names are reserved for the catch-all workers of a future build
+		if o.name == "" {
+			return nil, fmt.Errorf("background worker %q must have an explicit name", o.fileName)
+		}
+		if o.matchRequest != nil {
+			return nil, fmt.Errorf("background worker %q cannot match requests", o.name)
+		}
+		if o.maxThreads > 0 {
+			return nil, fmt.Errorf("background worker %q cannot set max_threads, it does not autoscale", o.name)
+		}
+	}
+
 	if o.name == "" {
 		o.name = absFileName
 	}
 
-	if o.server == nil {
-		if globalWorkersByPath[absFileName] != nil {
-			return nil, fmt.Errorf("two global workers cannot have the same filename: %q", absFileName)
-		}
-
-		// no server means no set of requests to match against, the matcher would never run
-		if o.matchRequest != nil {
-			return nil, fmt.Errorf("worker %q has a request matcher but no server scope, use WithWorkerServerScope()", o.name)
-		}
+	// no server means no set of requests to match against, the matcher would never run
+	if o.server == nil && o.matchRequest != nil {
+		return nil, fmt.Errorf("worker %q has a request matcher but no server scope, use WithWorkerServerScope()", o.name)
 	}
 
-	if workersByName[o.name] != nil {
-		return nil, fmt.Errorf("two workers cannot have the same name: %q", o.name)
+	// the same name may be declared in several servers, metrics and logs need a unique one
+	qualifiedName := o.name
+	if o.server != nil {
+		qualifiedName = o.server.name + ":" + o.name
 	}
 
 	// env should always contain FRANKENPHP_WORKER and the parent php_server env
@@ -152,10 +183,18 @@ func newWorker(o workerOpt) (*worker, error) {
 		}
 	}
 
-	o.env["FRANKENPHP_WORKER\x00"] = "1"
+	// $_SERVER['FRANKENPHP_WORKER'] carries the worker name; scripts are
+	// documented to test its presence, not its value, so HTTP workers moving
+	// from "1" to their name breaks nothing. FRANKENPHP_WORKER_BACKGROUND is
+	// the presence-only flag telling a script it runs as a background worker
+	o.env["FRANKENPHP_WORKER\x00"] = o.name
+	if o.isBackgroundWorker {
+		o.env["FRANKENPHP_WORKER_BACKGROUND\x00"] = "1"
+	}
 
 	w := &worker{
 		name:                   o.name,
+		qualifiedName:          qualifiedName,
 		fileName:               absFileName,
 		matchRequest:           o.matchRequest,
 		requestOptions:         o.requestOptions,
@@ -167,6 +206,7 @@ func newWorker(o workerOpt) (*worker, error) {
 		onThreadReady:          o.onThreadReady,
 		onThreadShutdown:       o.onThreadShutdown,
 		server:                 o.server,
+		isBackgroundWorker:     o.isBackgroundWorker,
 	}
 
 	w.configureMercure(&o)
@@ -184,6 +224,26 @@ func newWorker(o workerOpt) (*worker, error) {
 	return w, nil
 }
 
+// addGlobalWorker registers a worker that is not scoped to a server
+func addGlobalWorker(w *worker) error {
+	if globalWorkersByName[w.name] != nil {
+		return fmt.Errorf("two global workers cannot have the same name: %q", w.name)
+	}
+	globalWorkersByName[w.name] = w
+
+	// background workers never serve requests, so they are not matched by path
+	if w.isBackgroundWorker {
+		return nil
+	}
+
+	if globalWorkersByPath[w.fileName] != nil {
+		return fmt.Errorf("two global workers cannot have the same filename: %q", w.fileName)
+	}
+	globalWorkersByPath[w.fileName] = w
+
+	return nil
+}
+
 // RestartWorkers attempts to restart all workers gracefully.
 // All workers must be restarted at the same time to prevent issues with
 // opcache resetting. Blocks until every worker thread has yielded;
@@ -235,7 +295,7 @@ func (worker *worker) isAtThreadLimit() bool {
 }
 
 func (worker *worker) handleRequest(fc *frankenPHPContext) error {
-	metrics.StartWorkerRequest(worker.name)
+	metrics.StartWorkerRequest(worker.qualifiedName)
 
 	runtime.Gosched()
 
@@ -247,7 +307,7 @@ func (worker *worker) handleRequest(fc *frankenPHPContext) error {
 			case thread.requestChan <- fc:
 				worker.threadMutex.RUnlock()
 				<-fc.done
-				metrics.StopWorkerRequest(worker.name, time.Since(fc.startedAt))
+				metrics.StopWorkerRequest(worker.qualifiedName, time.Since(fc.startedAt))
 
 				return nil
 			default:
@@ -259,7 +319,7 @@ func (worker *worker) handleRequest(fc *frankenPHPContext) error {
 
 	// if no thread was available, mark the request as queued and apply the scaling strategy
 	worker.queuedRequests.Add(1)
-	metrics.QueuedWorkerRequest(worker.name)
+	metrics.QueuedWorkerRequest(worker.qualifiedName)
 
 	for {
 		workerScaleChan := scaleChan
@@ -270,9 +330,9 @@ func (worker *worker) handleRequest(fc *frankenPHPContext) error {
 		select {
 		case worker.requestChan <- fc:
 			worker.queuedRequests.Add(-1)
-			metrics.DequeuedWorkerRequest(worker.name)
+			metrics.DequeuedWorkerRequest(worker.qualifiedName)
 			<-fc.done
-			metrics.StopWorkerRequest(worker.name, time.Since(fc.startedAt))
+			metrics.StopWorkerRequest(worker.qualifiedName, time.Since(fc.startedAt))
 
 			return nil
 		case workerScaleChan <- fc:
@@ -280,8 +340,8 @@ func (worker *worker) handleRequest(fc *frankenPHPContext) error {
 		case <-timeoutChan(time.Duration(maxWaitTime.Load())):
 			// the request has timed out stalling
 			worker.queuedRequests.Add(-1)
-			metrics.DequeuedWorkerRequest(worker.name)
-			metrics.StopWorkerRequest(worker.name, time.Since(fc.startedAt))
+			metrics.DequeuedWorkerRequest(worker.qualifiedName)
+			metrics.StopWorkerRequest(worker.qualifiedName, time.Since(fc.startedAt))
 
 			fc.reject(ErrMaxWaitTimeExceeded)