Merge remote-tracking branch 'origin/main' into feat/switch-worktree-profile

# Conflicts:
#	bin/src/completions.ts
#	bin/src/webmux.ts
#	bin/src/worktree-commands.ts
#	frontend/src/App.svelte
#	frontend/src/lib/WorktreeList.svelte

Author: diegoimbert

.gitignore

@@ -16,3 +16,5 @@ public/
 .env.local
 .webmux.local.yaml
 docs/useful-commands.txt
+.claude/settings.local.json
+.claude/worktrees/

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.39.0"
+  ".": "0.43.1"
 }

CHANGELOG.md

@@ -1,5 +1,70 @@
 # Changelog
 
+## [0.43.1](https://github.com/windmill-labs/webmux/compare/v0.43.0...v0.43.1) (2026-07-23)
+
+
+### Bug Fixes
+
+* **pr:** stop cancelled CI runs from masking the latest review status ([#298](https://github.com/windmill-labs/webmux/issues/298)) ([9001d9f](https://github.com/windmill-labs/webmux/commit/9001d9f92d94d151add9983dc32a7d1384fd3945))
+
+## [0.43.0](https://github.com/windmill-labs/webmux/compare/v0.42.0...v0.43.0) (2026-07-20)
+
+
+### Features
+
+* load global config env from ~/.config/webmux/.env ([#295](https://github.com/windmill-labs/webmux/issues/295)) ([d62612e](https://github.com/windmill-labs/webmux/commit/d62612e71e12c00664d3463d91f51f0acc9bf2c9))
+
+
+### Bug Fixes
+
+* **tmux:** force a UTF-8 locale for tmux control commands ([#293](https://github.com/windmill-labs/webmux/issues/293)) ([e725f3b](https://github.com/windmill-labs/webmux/commit/e725f3be7a0dd0bd7f960b7b2641a37b900e6fb8))
+
+## [0.42.0](https://github.com/windmill-labs/webmux/compare/v0.41.2...v0.42.0) (2026-07-17)
+
+
+### Features
+
+* order worktree list by session and pr state ([#289](https://github.com/windmill-labs/webmux/issues/289)) ([44bd900](https://github.com/windmill-labs/webmux/commit/44bd900efa85dae03cc0c3abd3c268cab2639b55))
+
+
+### Bug Fixes
+
+* **auto-remove:** sweep merged worktrees headlessly ([#291](https://github.com/windmill-labs/webmux/issues/291)) ([70c51e4](https://github.com/windmill-labs/webmux/commit/70c51e43e75b7208a7a9040bbf98762d6d22aa4a))
+
+## [0.41.2](https://github.com/windmill-labs/webmux/compare/v0.41.1...v0.41.2) (2026-07-16)
+
+
+### Bug Fixes
+
+* restore agent status by prefixing the runtime control URL ([d168301](https://github.com/windmill-labs/webmux/commit/d16830192fdcc5dfa81bff33df544f60bb136b25))
+* restore agent status by prefixing the runtime control URL ([d7fba24](https://github.com/windmill-labs/webmux/commit/d7fba241c00714d9d5e3cecd9e31c8c36d696001))
+
+## [0.41.1](https://github.com/windmill-labs/webmux/compare/v0.41.0...v0.41.1) (2026-07-14)
+
+
+### Bug Fixes
+
+* keep launch project .env secrets out of tmux global env ([#285](https://github.com/windmill-labs/webmux/issues/285)) ([153ce85](https://github.com/windmill-labs/webmux/commit/153ce85bfe7c99edd967d5cb75ef67b03fe7a78b))
+* **linear:** don't treat a linked github issue as a PR ([#287](https://github.com/windmill-labs/webmux/issues/287)) ([b8600a0](https://github.com/windmill-labs/webmux/commit/b8600a0091034edab3037472487b3cedf0c493fd))
+
+## [0.41.0](https://github.com/windmill-labs/webmux/compare/v0.40.0...v0.41.0) (2026-06-30)
+
+
+### Features
+
+* add create sub-worktree shortcut to worktree menu ([#269](https://github.com/windmill-labs/webmux/issues/269)) ([f40807f](https://github.com/windmill-labs/webmux/commit/f40807f2445c418be22ed12e959c11b9297a9309))
+* let webmux service run anywhere and add non-interactive install ([#282](https://github.com/windmill-labs/webmux/issues/282)) ([4013397](https://github.com/windmill-labs/webmux/commit/40133971ea3dce9d85ceb86c35d3d6a1074a3342))
+
+## [0.40.0](https://github.com/windmill-labs/webmux/compare/v0.39.0...v0.40.0) (2026-06-27)
+
+
+### Features
+
+* periodically save open sessions and add webmux restore ([a96f16d](https://github.com/windmill-labs/webmux/commit/a96f16d70bbc5cb700a015a578e9a6865d0adcee))
+* periodically save open sessions and add webmux restore ([0b41b19](https://github.com/windmill-labs/webmux/commit/0b41b199a911cfc60245305d4b0fd8f1ee13b2c4))
+* prune only closed worktrees instead of all ([0fa2da6](https://github.com/windmill-labs/webmux/commit/0fa2da67d05a705820a38643cb71f3a72cad2063))
+* prune only closed worktrees instead of all ([164e7fc](https://github.com/windmill-labs/webmux/commit/164e7fcbc1a699a94dace10b0d095f8896c497e1))
+
 ## [0.39.0](https://github.com/windmill-labs/webmux/compare/v0.38.0...v0.39.0) (2026-06-22)
 
 

README.md

@@ -52,6 +52,17 @@ Each issue is processed once while it stays in Todo + labeled. Remove the label
 
 When the auto-create watcher picks up a `webmux_oneshot` issue, it posts a structured comment on the Linear issue (prefix `` **Webmux pickup — branch `<branch>`** ``) so external automation can track when the autonomous run starts. (Regular `webmux` pickups are user-driven and skip the comment.)
 
+**Setup — `LINEAR_API_KEY`.** Everything above needs a [Linear API key](https://linear.app/settings/account/security) in the server's environment. webmux runs as a single machine-wide service started from your home directory, so put the key in `~/.config/webmux/.env` — a `KEY=value` file the server loads at startup regardless of which directory it runs from, so it survives `webmux update`:
+
+```bash
+mkdir -p ~/.config/webmux
+echo 'LINEAR_API_KEY=lin_api_...' >> ~/.config/webmux/.env
+chmod 600 ~/.config/webmux/.env
+webmux service restart
+```
+
+Your assigned issues appear in the dashboard once the service restarts.
+
 ## Quick Start
 
 ```bash

backend/src/__tests__/auto-remove-service.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it } from "bun:test";
+import type { GitGateway, GitWorktreeEntry } from "../adapters/git";
+import type { PrEntry } from "../domain/model";
+import {
+  runAutoRemove,
+  type AutoRemoveDependencies,
+} from "../services/auto-remove-service";
+
+const ROOT = "/repo";
+
+function worktree(branch: string): GitWorktreeEntry {
+  return { path: `/repo__wt/${branch}`, branch, bare: false } as GitWorktreeEntry;
+}
+
+/** Builds deps with fakes; records which branches got removed. */
+function makeDeps(opts: {
+  worktrees: GitWorktreeEntry[];
+  states: Map<string, PrEntry["state"][]> | null;
+  dirty?: Set<string>;
+}): { deps: AutoRemoveDependencies; removed: string[] } {
+  const removed: string[] = [];
+  const removing = new Set<string>();
+  const dirty = opts.dirty ?? new Set<string>();
+
+  const git = {
+    listLiveWorktrees: () => [{ path: ROOT, branch: "main", bare: false }, ...opts.worktrees],
+    readWorktreeStatus: (path: string) => ({
+      dirty: dirty.has(path),
+      aheadCount: 0,
+      currentCommit: null,
+    }),
+  } as unknown as GitGateway;
+
+  const deps: AutoRemoveDependencies = {
+    git,
+    projectRoot: ROOT,
+    lifecycleService: {
+      removeWorktree: async (branch: string) => {
+        removed.push(branch);
+      },
+    } as unknown as AutoRemoveDependencies["lifecycleService"],
+    notifications: { notify: () => {} } as unknown as AutoRemoveDependencies["notifications"],
+    isRemoving: (b) => removing.has(b),
+    markRemoving: (b) => removing.add(b),
+    unmarkRemoving: (b) => removing.delete(b),
+    getBranchPrStates: async () => opts.states,
+  };
+  return { deps, removed };
+}
+
+describe("runAutoRemove", () => {
+  it("removes a clean worktree whose PR is merged, without any prior open-state sync", async () => {
+    const wt = worktree("feature");
+    const { deps, removed } = makeDeps({
+      worktrees: [wt],
+      states: new Map([["feature", ["merged"]]]),
+    });
+    await runAutoRemove(deps);
+    expect(removed).toEqual(["feature"]);
+  });
+
+  it("keeps a worktree whose PR is still open", async () => {
+    const wt = worktree("feature");
+    const { deps, removed } = makeDeps({
+      worktrees: [wt],
+      states: new Map([["feature", ["open"]]]),
+    });
+    await runAutoRemove(deps);
+    expect(removed).toEqual([]);
+  });
+
+  it("keeps a worktree when any of its PRs across repos is not merged", async () => {
+    // Same branch has a merged PR in one repo and an open PR in a linked repo.
+    const wt = worktree("feature");
+    const { deps, removed } = makeDeps({
+      worktrees: [wt],
+      states: new Map([["feature", ["merged", "open"]]]),
+    });
+    await runAutoRemove(deps);
+    expect(removed).toEqual([]);
+  });
+
+  it("keeps a merged worktree that is dirty", async () => {
+    const wt = worktree("feature");
+    const { deps, removed } = makeDeps({
+      worktrees: [wt],
+      states: new Map([["feature", ["merged"]]]),
+      dirty: new Set([wt.path]),
+    });
+    await runAutoRemove(deps);
+    expect(removed).toEqual([]);
+  });
+
+  it("keeps a worktree that has no PR", async () => {
+    const wt = worktree("feature");
+    const { deps, removed } = makeDeps({ worktrees: [wt], states: new Map() });
+    await runAutoRemove(deps);
+    expect(removed).toEqual([]);
+  });
+
+  it("removes nothing when the PR state fetch is inconclusive", async () => {
+    // A failed repo query (null) must not be read as "merged with no other PRs":
+    // a transient gh failure on a linked repo could otherwise drop an open
+    // cross-repo PR and remove a still-live worktree.
+    const wt = worktree("feature");
+    const { deps, removed } = makeDeps({ worktrees: [wt], states: null });
+    await runAutoRemove(deps);
+    expect(removed).toEqual([]);
+  });
+});

backend/src/__tests__/domain-policies.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, it } from "bun:test";
 import {
   allocateServicePorts,
+  compareWorktreeOrder,
   deriveProjectPrefix,
   sanitizeProjectPrefix,
+  type WorktreeOrderFields,
 } from "../domain/policies";
 
 describe("allocateServicePorts", () => {
@@ -85,3 +87,58 @@ describe("deriveProjectPrefix", () => {
     expect(deriveProjectPrefix("/srv/assets", [])).toBe("assets-2");
   });
 });
+
+describe("compareWorktreeOrder", () => {
+  const worktree = (branch: string, fields: Partial<WorktreeOrderFields> = {}): WorktreeOrderFields => ({
+    branch,
+    open: false,
+    prStates: [],
+    ...fields,
+  });
+
+  it("ranks open worktrees above every closed one", () => {
+    const rows = [
+      worktree("closed-open-pr", { prStates: ["open"] }),
+      worktree("open-no-pr", { open: true }),
+    ];
+
+    expect([...rows].sort(compareWorktreeOrder).map((row) => row.branch)).toEqual([
+      "open-no-pr",
+      "closed-open-pr",
+    ]);
+  });
+
+  it("ranks closed worktrees by pr state, then no pr at all", () => {
+    const rows = [
+      worktree("no-pr"),
+      worktree("merged-pr", { prStates: ["merged"] }),
+      worktree("open-pr", { prStates: ["open"] }),
+      worktree("closed-pr", { prStates: ["closed"] }),
+    ];
+
+    expect([...rows].sort(compareWorktreeOrder).map((row) => row.branch)).toEqual([
+      "open-pr",
+      "closed-pr",
+      "merged-pr",
+      "no-pr",
+    ]);
+  });
+
+  it("promotes a worktree whose repos disagree on pr state if any pr is open", () => {
+    const rows = [
+      worktree("all-merged", { prStates: ["merged", "merged"] }),
+      worktree("one-open", { prStates: ["merged", "open"] }),
+    ];
+
+    expect([...rows].sort(compareWorktreeOrder).map((row) => row.branch)).toEqual([
+      "one-open",
+      "all-merged",
+    ]);
+  });
+
+  it("falls back to branch name within the same rank", () => {
+    const rows = [worktree("zulu", { open: true }), worktree("alpha", { open: true })];
+
+    expect([...rows].sort(compareWorktreeOrder).map((row) => row.branch)).toEqual(["alpha", "zulu"]);
+  });
+});

backend/src/__tests__/lifecycle-service.test.ts

@@ -299,6 +299,9 @@ function makeLifecycleService(
     onFinished?: (branch: string) => void | Promise<void>;
   } = {},
   sessionDiscovery: SessionDiscoveryGateway = { listSessionIds: async () => [] },
+  // `null` explicitly configures no control reporting (passing `undefined` would
+  // fall back to the default below).
+  controlBaseUrl: string | null = "http://127.0.0.1:5111",
 ): LifecycleService {
   const reconciliation = new ReconciliationService({
     config,
@@ -310,7 +313,7 @@ function makeLifecycleService(
 
   return new LifecycleService({
     projectRoot: repoRoot,
-    controlBaseUrl: "http://127.0.0.1:5111",
+    controlBaseUrl: controlBaseUrl ?? undefined,
     getControlToken: async () => "secret-token",
     config,
     archiveState: new ArchiveStateService(git.resolveWorktreeGitDir(repoRoot)),
@@ -422,6 +425,38 @@ describe("LifecycleService", () => {
     expect(state?.session.paneCount).toBe(2);
   });
 
+  it("writes no control.env when no control base URL is configured", async () => {
+    const repoRoot = await initRepo();
+    const runtime = new ProjectRuntime();
+    const tmux = new FakeTmuxGateway();
+    // The CLI leaves controlBaseUrl undefined when it can't resolve the project
+    // prefix (no server running). We'd rather write no control.env than one with
+    // a wrong (unrouted) URL — the dashboard rewrites it on next open/refresh.
+    const lifecycle = makeLifecycleService(
+      repoRoot,
+      tmux,
+      runtime,
+      new FakeDockerGateway(),
+      new FakeHookRunner(),
+      TEST_CONFIG,
+      new BunGitGateway(),
+      new FakeAutoNameService(),
+      {},
+      { listSessionIds: async () => [] },
+      null,
+    );
+
+    await lifecycle.createWorktree({ branch: "feature/search" });
+
+    const worktreePath = join(repoRoot, "__worktrees", "feature", "search");
+    const gitDir = new BunGitGateway().resolveWorktreeGitDir(worktreePath);
+    const paths = getWorktreeStoragePaths(gitDir);
+
+    expect(await Bun.file(paths.controlEnvPath).exists()).toBe(false);
+    // The runtime env (unrelated to control reporting) is still written.
+    expect(await Bun.file(paths.runtimeEnvPath).exists()).toBe(true);
+  });
+
   it("creates one managed worktree per selected agent from one task branch", async () => {
     const repoRoot = await initRepo();
     const runtime = new ProjectRuntime();
@@ -1859,7 +1894,7 @@ describe("LifecycleService", () => {
     expect(run(["git", "branch", "--list", "feature-ahead"], repoRoot)).toBe("");
   });
 
-  it("prunes all project worktrees", async () => {
+  it("prunes only closed worktrees, leaving open ones untouched", async () => {
     const repoRoot = await initRepo();
     const runtime = new ProjectRuntime();
     const tmux = new FakeTmuxGateway();
@@ -1869,24 +1904,38 @@ describe("LifecycleService", () => {
 
     await lifecycle.createWorktree({ branch: "feature-prune-host" });
     await lifecycle.createWorktree({ branch: "feature-prune-docker", profile: "sandbox" });
+    // feature-prune-host is closed (no tmux window); feature-prune-docker stays open.
     await lifecycle.closeWorktree("feature-prune-host");
 
     const result = await lifecycle.pruneWorktrees();
 
-    expect(result.removedBranches).toEqual([
-      "feature-prune-docker",
-      "feature-prune-host",
-    ]);
-    expect(hooks.calls.filter((call) => call.name === "preRemove").map((call) => call.cwd).sort()).toEqual([
-      join(repoRoot, "__worktrees", "feature-prune-docker"),
+    expect(result.removedBranches).toEqual(["feature-prune-host"]);
+    expect(hooks.calls.filter((call) => call.name === "preRemove").map((call) => call.cwd)).toEqual([
       join(repoRoot, "__worktrees", "feature-prune-host"),
     ]);
-    expect(docker.removed).toEqual(["feature-prune-docker"]);
-    expect(new BunGitGateway().listWorktrees(repoRoot).filter((entry) => entry.path !== repoRoot)).toEqual([]);
+    expect(docker.removed).toEqual([]);
+    expect(new BunGitGateway().listWorktrees(repoRoot).filter((entry) => entry.path !== repoRoot).map((entry) => entry.branch)).toEqual([
+      "feature-prune-docker",
+    ]);
     expect(run(["git", "branch", "--list", "feature-prune-host"], repoRoot)).toBe("");
-    expect(run(["git", "branch", "--list", "feature-prune-docker"], repoRoot)).toBe("");
-    expect(tmux.listWindows()).toEqual([]);
-    expect(runtime.listWorktrees()).toEqual([]);
+    expect(run(["git", "branch", "--list", "feature-prune-docker"], repoRoot)).not.toBe("");
+    expect(runtime.listWorktrees().map((entry) => entry.branch)).toEqual(["feature-prune-docker"]);
+  });
+
+  it("prunes nothing when all worktrees are open", async () => {
+    const repoRoot = await initRepo();
+    const runtime = new ProjectRuntime();
+    const tmux = new FakeTmuxGateway();
+    const docker = new FakeDockerGateway();
+    const hooks = new FakeHookRunner();
+    const lifecycle = makeLifecycleService(repoRoot, tmux, runtime, docker, hooks);
+
+    await lifecycle.createWorktree({ branch: "feature-open" });
+
+    const result = await lifecycle.pruneWorktrees();
+
+    expect(result.removedBranches).toEqual([]);
+    expect(runtime.listWorktrees().map((entry) => entry.branch)).toEqual(["feature-open"]);
   });
 
   it("removes the sandbox container before deleting a docker worktree", async () => {