claude-code-swarm 0.3.3 → 0.3.5

package/src/__tests__/bootstrap.test.mjs

@@ -32,9 +32,13 @@ vi.mock("../paths.mjs", async () => {
     PID_PATH: path.join(tmpDir, "sidecar.pid"),
     MAP_DIR: path.join(tmpDir, "map"),
     SIDECAR_LOG_PATH: path.join(tmpDir, "sidecar.log"),
+    OPENTASKS_DIR: path.join(tmpDir, "opentasks"),
     teamDir: vi.fn((name) => `${tmpDir}/.swarm/claude-swarm/tmp/teams/${name}`),
     ensureSwarmDir: vi.fn(),
     ensureMapDir: vi.fn(),
+    ensureOpentasksDir: vi.fn(),
+    ensureSessionDir: vi.fn(),
+    listSessionDirs: vi.fn().mockReturnValue([]),
     pluginDir: vi.fn(() => tmpDir),
   };
 });
@@ -54,6 +58,12 @@ const mockSwarmkit = {
   initProjectPackage: vi.fn().mockResolvedValue({ package: "openteams", success: true }),
 };
 
+vi.mock("../opentasks-client.mjs", () => ({
+  findSocketPath: vi.fn(() => "/tmp/test-daemon.sock"),
+  isDaemonAlive: vi.fn().mockResolvedValue(false),
+  ensureDaemon: vi.fn().mockResolvedValue(true),
+}));
+
 vi.mock("../swarmkit-resolver.mjs", () => ({
   resolveSwarmkit: vi.fn().mockResolvedValue(mockSwarmkit),
   configureNodePath: vi.fn(),
@@ -63,7 +73,8 @@ const { bootstrap } = await import("../bootstrap.mjs");
 const { readConfig } = await import("../config.mjs");
 const { killSidecar, startSidecar } = await import("../sidecar-client.mjs");
 const { checkSessionlogStatus, syncSessionlog } = await import("../sessionlog.mjs");
-const { pluginDir } = await import("../paths.mjs");
+const { pluginDir, ensureOpentasksDir, ensureSessionDir, listSessionDirs } = await import("../paths.mjs");
+const { findSocketPath, isDaemonAlive, ensureDaemon } = await import("../opentasks-client.mjs");
 const { resolveSwarmkit, configureNodePath } = await import("../swarmkit-resolver.mjs");
 
 describe("bootstrap", () => {
@@ -350,4 +361,116 @@ describe("bootstrap", () => {
       expect(ensureSwarmDir).toHaveBeenCalled();
     });
   });
+
+  describe("opentasks", () => {
+    it("returns opentasksStatus 'disabled' when not enabled", async () => {
+      readConfig.mockReturnValue(makeConfig({ opentasksEnabled: false }));
+      const result = await bootstrap();
+      expect(result.opentasksStatus).toBe("disabled");
+    });
+
+    it("calls ensureOpentasksDir when enabled", async () => {
+      readConfig.mockReturnValue(makeConfig({ opentasksEnabled: true }));
+      await bootstrap();
+      expect(ensureOpentasksDir).toHaveBeenCalled();
+    });
+
+    it("calls ensureDaemon when enabled with autoStart", async () => {
+      readConfig.mockReturnValue(makeConfig({ opentasksEnabled: true, opentasksAutoStart: true }));
+      await bootstrap();
+      expect(ensureDaemon).toHaveBeenCalled();
+    });
+
+    it("returns 'connected' when ensureDaemon succeeds", async () => {
+      readConfig.mockReturnValue(makeConfig({ opentasksEnabled: true }));
+      ensureDaemon.mockResolvedValue(true);
+      const result = await bootstrap();
+      expect(result.opentasksStatus).toBe("connected");
+    });
+
+    it("returns 'starting' when ensureDaemon fails", async () => {
+      readConfig.mockReturnValue(makeConfig({ opentasksEnabled: true }));
+      ensureDaemon.mockResolvedValue(false);
+      const result = await bootstrap();
+      expect(result.opentasksStatus).toBe("starting");
+    });
+
+    it("calls isDaemonAlive when autoStart is false", async () => {
+      readConfig.mockReturnValue(makeConfig({ opentasksEnabled: true, opentasksAutoStart: false }));
+      isDaemonAlive.mockResolvedValue(true);
+      await bootstrap();
+      expect(isDaemonAlive).toHaveBeenCalled();
+      expect(ensureDaemon).not.toHaveBeenCalled();
+    });
+
+    it("returns 'connected' when daemon is already alive (autoStart false)", async () => {
+      readConfig.mockReturnValue(makeConfig({ opentasksEnabled: true, opentasksAutoStart: false }));
+      isDaemonAlive.mockResolvedValue(true);
+      const result = await bootstrap();
+      expect(result.opentasksStatus).toBe("connected");
+    });
+
+    it("returns 'not running' when daemon is not alive (autoStart false)", async () => {
+      readConfig.mockReturnValue(makeConfig({ opentasksEnabled: true, opentasksAutoStart: false }));
+      isDaemonAlive.mockResolvedValue(false);
+      const result = await bootstrap();
+      expect(result.opentasksStatus).toContain("not running");
+    });
+
+    it("checks opentasks package via swarmkit when enabled", async () => {
+      readConfig.mockReturnValue(makeConfig({ opentasksEnabled: true }));
+      mockSwarmkit.getInstalledVersion.mockResolvedValue("1.0.0");
+      await bootstrap();
+      expect(mockSwarmkit.getInstalledVersion).toHaveBeenCalledWith("opentasks");
+    });
+
+    it("does not check opentasks package when disabled", async () => {
+      readConfig.mockReturnValue(makeConfig({ opentasksEnabled: false }));
+      mockSwarmkit.getInstalledVersion.mockResolvedValue("1.0.0");
+      await bootstrap();
+      const calls = mockSwarmkit.getInstalledVersion.mock.calls.map((c) => c[0]);
+      expect(calls).not.toContain("opentasks");
+    });
+  });
+
+  describe("per-session sidecar", () => {
+    it("calls ensureSessionDir when sessionId provided and MAP enabled", async () => {
+      readConfig.mockReturnValue(makeConfig({ mapEnabled: true }));
+      await bootstrap(undefined, "session-abc");
+      expect(ensureSessionDir).toHaveBeenCalledWith("session-abc");
+    });
+
+    it("passes sessionId to killSidecar and startSidecar", async () => {
+      readConfig.mockReturnValue(makeConfig({ mapEnabled: true, sidecar: "session" }));
+      await bootstrap(undefined, "session-xyz");
+      expect(killSidecar).toHaveBeenCalledWith("session-xyz");
+      expect(startSidecar).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.anything(),
+        "session-xyz"
+      );
+    });
+
+    it("passes sessionId to syncSessionlog", async () => {
+      readConfig.mockReturnValue(makeConfig({ mapEnabled: true, sessionlogSync: "full" }));
+      await bootstrap(undefined, "session-sync");
+      expect(syncSessionlog).toHaveBeenCalledWith(expect.anything(), "session-sync");
+    });
+
+    it("returns sessionId in result", async () => {
+      const result = await bootstrap(undefined, "session-ret");
+      expect(result.sessionId).toBe("session-ret");
+    });
+
+    it("returns null sessionId when not provided", async () => {
+      const result = await bootstrap();
+      expect(result.sessionId).toBeUndefined();
+    });
+
+    it("calls listSessionDirs during cleanup (session sidecar mode)", async () => {
+      readConfig.mockReturnValue(makeConfig({ mapEnabled: true, sidecar: "session" }));
+      await bootstrap(undefined, "session-cleanup");
+      expect(listSessionDirs).toHaveBeenCalled();
+    });
+  });
 });

package/src/__tests__/config.test.mjs

@@ -16,7 +16,11 @@ describe("config", () => {
 
   describe("readConfig", () => {
     let tmpDir;
-    beforeEach(() => { tmpDir = makeTmpDir(); });
+    let noGlobal;
+    beforeEach(() => {
+      tmpDir = makeTmpDir();
+      noGlobal = path.join(tmpDir, "no-global.json");
+    });
     afterEach(() => { cleanupTmpDir(tmpDir); });
 
     it("reads and parses a valid config file", () => {
@@ -24,7 +28,7 @@ describe("config", () => {
         template: "gsd",
         map: { enabled: true, server: "ws://example.com:9090" },
       }));
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
       expect(config.template).toBe("gsd");
       expect(config.map.enabled).toBe(true);
       expect(config.map.server).toBe("ws://example.com:9090");
@@ -35,7 +39,7 @@ describe("config", () => {
         template: "test",
         map: { enabled: true },
       }));
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
       expect(config.map.server).toBe(DEFAULTS.mapServer);
       expect(config.map.scope).toBe("");
       expect(config.map.systemId).toBe(DEFAULTS.mapSystemId);
@@ -44,13 +48,38 @@ describe("config", () => {
 
     it("normalizes sessionlog fields with defaults", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({ template: "test" }));
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
       expect(config.sessionlog.enabled).toBe(false);
       expect(config.sessionlog.sync).toBe("off");
     });
 
+    it("normalizes opentasks fields with defaults", () => {
+      const configPath = writeFile(tmpDir, "config.json", JSON.stringify({ template: "test" }));
+      const config = readConfig(configPath, noGlobal);
+      expect(config.opentasks.enabled).toBe(false);
+      expect(config.opentasks.autoStart).toBe(true);
+    });
+
+    it("reads opentasks.enabled from config file", () => {
+      const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
+        template: "test",
+        opentasks: { enabled: true },
+      }));
+      const config = readConfig(configPath, noGlobal);
+      expect(config.opentasks.enabled).toBe(true);
+    });
+
+    it("reads opentasks.autoStart false from config file", () => {
+      const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
+        template: "test",
+        opentasks: { enabled: true, autoStart: false },
+      }));
+      const config = readConfig(configPath, noGlobal);
+      expect(config.opentasks.autoStart).toBe(false);
+    });
+
     it("returns defaults when file does not exist", () => {
-      const config = readConfig(path.join(tmpDir, "nonexistent.json"));
+      const config = readConfig(path.join(tmpDir, "nonexistent.json"), noGlobal);
       expect(config.template).toBe("");
       expect(config.map.enabled).toBe(false);
       expect(config.sessionlog.enabled).toBe(false);
@@ -58,20 +87,20 @@ describe("config", () => {
 
     it("returns defaults when file contains invalid JSON", () => {
       const configPath = writeFile(tmpDir, "config.json", "not json{{{");
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
       expect(config.template).toBe("");
       expect(config.map.enabled).toBe(false);
     });
 
     it("returns defaults when file is empty", () => {
       const configPath = writeFile(tmpDir, "config.json", "");
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
       expect(config.template).toBe("");
     });
 
     it("handles config with only template field", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({ template: "my-team" }));
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
       expect(config.template).toBe("my-team");
       expect(config.map.enabled).toBe(false);
     });
@@ -81,7 +110,7 @@ describe("config", () => {
         template: "test",
         map: { enabled: true, scope: "custom:scope" },
       }));
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
       expect(config.map.scope).toBe("custom:scope");
     });
 
@@ -89,7 +118,7 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
         map: { server: "ws://example.com:9090" },
       }));
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
       expect(config.map.enabled).toBe(true);
     });
 
@@ -97,8 +126,114 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
         template: "test",
       }));
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
+      expect(config.map.enabled).toBe(false);
+    });
+  });
+
+  describe("global config fallthrough", () => {
+    let tmpDir;
+    beforeEach(() => { tmpDir = makeTmpDir(); });
+    afterEach(() => { cleanupTmpDir(tmpDir); });
+
+    it("uses global config values when project config is missing", () => {
+      const globalPath = writeFile(tmpDir, "global.json", JSON.stringify({
+        map: { server: "ws://global-server:9090", sidecar: "persistent" },
+        sessionlog: { sync: "full" },
+      }));
+      const projectPath = path.join(tmpDir, "nonexistent.json");
+      const config = readConfig(projectPath, globalPath);
+      expect(config.map.server).toBe("ws://global-server:9090");
+      expect(config.map.sidecar).toBe("persistent");
+      expect(config.sessionlog.sync).toBe("full");
+    });
+
+    it("project config overrides global config", () => {
+      const globalPath = writeFile(tmpDir, "global.json", JSON.stringify({
+        map: { server: "ws://global-server:9090", sidecar: "persistent" },
+        sessionlog: { sync: "full" },
+      }));
+      const projectPath = writeFile(tmpDir, "project.json", JSON.stringify({
+        map: { server: "ws://project-server:8080" },
+        sessionlog: { sync: "lifecycle" },
+      }));
+      const config = readConfig(projectPath, globalPath);
+      expect(config.map.server).toBe("ws://project-server:8080");
+      expect(config.map.sidecar).toBe("persistent"); // falls through from global
+      expect(config.sessionlog.sync).toBe("lifecycle");
+    });
+
+    it("project template overrides global template", () => {
+      const globalPath = writeFile(tmpDir, "global.json", JSON.stringify({
+        template: "global-template",
+      }));
+      const projectPath = writeFile(tmpDir, "project.json", JSON.stringify({
+        template: "project-template",
+      }));
+      const config = readConfig(projectPath, globalPath);
+      expect(config.template).toBe("project-template");
+    });
+
+    it("global template is used when project has no template", () => {
+      const globalPath = writeFile(tmpDir, "global.json", JSON.stringify({
+        template: "global-template",
+      }));
+      const projectPath = writeFile(tmpDir, "project.json", JSON.stringify({}));
+      const config = readConfig(projectPath, globalPath);
+      expect(config.template).toBe("global-template");
+    });
+
+    it("global map.enabled enables MAP when project has no map config", () => {
+      const globalPath = writeFile(tmpDir, "global.json", JSON.stringify({
+        map: { enabled: true, server: "ws://global-server:9090" },
+      }));
+      const projectPath = path.join(tmpDir, "nonexistent.json");
+      const config = readConfig(projectPath, globalPath);
+      expect(config.map.enabled).toBe(true);
+      expect(config.map.server).toBe("ws://global-server:9090");
+    });
+
+    it("global map.server implicitly enables MAP when project has no config", () => {
+      const globalPath = writeFile(tmpDir, "global.json", JSON.stringify({
+        map: { server: "ws://global-server:9090" },
+      }));
+      const projectPath = path.join(tmpDir, "nonexistent.json");
+      const config = readConfig(projectPath, globalPath);
+      expect(config.map.enabled).toBe(true);
+    });
+
+    it("global sessionlog.enabled is used when project has no sessionlog config", () => {
+      const globalPath = writeFile(tmpDir, "global.json", JSON.stringify({
+        sessionlog: { enabled: true, sync: "metrics" },
+      }));
+      const projectPath = path.join(tmpDir, "nonexistent.json");
+      const config = readConfig(projectPath, globalPath);
+      expect(config.sessionlog.enabled).toBe(true);
+      expect(config.sessionlog.sync).toBe("metrics");
+    });
+
+    it("falls back to defaults when both configs are missing", () => {
+      const globalPath = path.join(tmpDir, "nonexistent-global.json");
+      const projectPath = path.join(tmpDir, "nonexistent-project.json");
+      const config = readConfig(projectPath, globalPath);
+      expect(config.template).toBe("");
       expect(config.map.enabled).toBe(false);
+      expect(config.map.server).toBe(DEFAULTS.mapServer);
+      expect(config.sessionlog.enabled).toBe(false);
+      expect(config.sessionlog.sync).toBe(DEFAULTS.sessionlogSync);
+    });
+
+    it("per-field fallthrough: project scope + global server", () => {
+      const globalPath = writeFile(tmpDir, "global.json", JSON.stringify({
+        map: { server: "ws://global-server:9090", systemId: "global-system" },
+      }));
+      const projectPath = writeFile(tmpDir, "project.json", JSON.stringify({
+        map: { scope: "my-project" },
+      }));
+      const config = readConfig(projectPath, globalPath);
+      expect(config.map.scope).toBe("my-project");
+      expect(config.map.server).toBe("ws://global-server:9090");
+      expect(config.map.systemId).toBe("global-system");
     });
   });
 
@@ -122,10 +257,12 @@ describe("config", () => {
 
   describe("env var overrides", () => {
     let tmpDir;
+    let noGlobal;
     const savedEnv = {};
 
     beforeEach(() => {
       tmpDir = makeTmpDir();
+      noGlobal = path.join(tmpDir, "no-global.json");
       for (const key of Object.keys(process.env)) {
         if (key.startsWith("SWARM_")) {
           savedEnv[key] = process.env[key];
@@ -152,7 +289,7 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
         template: "file-template",
       }));
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
       expect(config.template).toBe("env-template");
     });
 
@@ -161,7 +298,7 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
         map: { enabled: false },
       }));
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
       expect(config.map.enabled).toBe(true);
     });
 
@@ -169,13 +306,13 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({}));
 
       process.env.SWARM_MAP_ENABLED = "1";
-      expect(readConfig(configPath).map.enabled).toBe(true);
+      expect(readConfig(configPath, noGlobal).map.enabled).toBe(true);
 
       process.env.SWARM_MAP_ENABLED = "yes";
-      expect(readConfig(configPath).map.enabled).toBe(true);
+      expect(readConfig(configPath, noGlobal).map.enabled).toBe(true);
 
       process.env.SWARM_MAP_ENABLED = "YES";
-      expect(readConfig(configPath).map.enabled).toBe(true);
+      expect(readConfig(configPath, noGlobal).map.enabled).toBe(true);
     });
 
     it("SWARM_MAP_ENABLED=false overrides true in config", () => {
@@ -183,7 +320,7 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
         map: { enabled: true },
       }));
-      expect(readConfig(configPath).map.enabled).toBe(false);
+      expect(readConfig(configPath, noGlobal).map.enabled).toBe(false);
     });
 
     it("SWARM_MAP_ENABLED=false disables even when server is configured", () => {
@@ -191,13 +328,13 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
         map: { server: "ws://example.com:9090" },
       }));
-      expect(readConfig(configPath).map.enabled).toBe(false);
+      expect(readConfig(configPath, noGlobal).map.enabled).toBe(false);
     });
 
     it("SWARM_MAP_SERVER implicitly enables MAP", () => {
       process.env.SWARM_MAP_SERVER = "ws://env-server:9090";
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({}));
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
       expect(config.map.enabled).toBe(true);
       expect(config.map.server).toBe("ws://env-server:9090");
     });
@@ -207,7 +344,7 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
         map: { server: "ws://file-server:8080" },
       }));
-      expect(readConfig(configPath).map.server).toBe("ws://env-server:9090");
+      expect(readConfig(configPath, noGlobal).map.server).toBe("ws://env-server:9090");
     });
 
     it("SWARM_MAP_SCOPE overrides config file", () => {
@@ -215,7 +352,7 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
         map: { scope: "custom:file-scope" },
       }));
-      expect(readConfig(configPath).map.scope).toBe("custom:env-scope");
+      expect(readConfig(configPath, noGlobal).map.scope).toBe("custom:env-scope");
     });
 
     it("SWARM_MAP_SYSTEM_ID overrides config file", () => {
@@ -223,7 +360,7 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
         map: { systemId: "file-system" },
       }));
-      expect(readConfig(configPath).map.systemId).toBe("env-system");
+      expect(readConfig(configPath, noGlobal).map.systemId).toBe("env-system");
     });
 
     it("SWARM_MAP_SIDECAR overrides config file", () => {
@@ -231,7 +368,7 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
         map: { sidecar: "session" },
       }));
-      expect(readConfig(configPath).map.sidecar).toBe("persistent");
+      expect(readConfig(configPath, noGlobal).map.sidecar).toBe("persistent");
     });
 
     it("SWARM_SESSIONLOG_ENABLED overrides config file", () => {
@@ -239,7 +376,7 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
         sessionlog: { enabled: false },
       }));
-      expect(readConfig(configPath).sessionlog.enabled).toBe(true);
+      expect(readConfig(configPath, noGlobal).sessionlog.enabled).toBe(true);
     });
 
     it("SWARM_SESSIONLOG_SYNC overrides config file", () => {
@@ -247,13 +384,27 @@ describe("config", () => {
       const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
         sessionlog: { sync: "off" },
       }));
-      expect(readConfig(configPath).sessionlog.sync).toBe("full");
+      expect(readConfig(configPath, noGlobal).sessionlog.sync).toBe("full");
+    });
+
+    it("SWARM_OPENTASKS_ENABLED overrides config file", () => {
+      process.env.SWARM_OPENTASKS_ENABLED = "true";
+      const configPath = writeFile(tmpDir, "config.json", JSON.stringify({
+        opentasks: { enabled: false },
+      }));
+      expect(readConfig(configPath, noGlobal).opentasks.enabled).toBe(true);
+    });
+
+    it("SWARM_OPENTASKS_AUTOSTART overrides default", () => {
+      process.env.SWARM_OPENTASKS_AUTOSTART = "false";
+      const configPath = writeFile(tmpDir, "config.json", JSON.stringify({}));
+      expect(readConfig(configPath, noGlobal).opentasks.autoStart).toBe(false);
     });
 
     it("env vars override defaults when no config file exists", () => {
       process.env.SWARM_MAP_SERVER = "ws://env-server:9090";
       process.env.SWARM_MAP_SYSTEM_ID = "env-system";
-      const config = readConfig(path.join(tmpDir, "nonexistent.json"));
+      const config = readConfig(path.join(tmpDir, "nonexistent.json"), noGlobal);
       expect(config.map.enabled).toBe(true);
       expect(config.map.server).toBe("ws://env-server:9090");
       expect(config.map.systemId).toBe("env-system");
@@ -264,10 +415,32 @@ describe("config", () => {
         template: "file-template",
         map: { server: "ws://file-server:8080" },
       }));
-      const config = readConfig(configPath);
+      const config = readConfig(configPath, noGlobal);
       expect(config.template).toBe("file-template");
       expect(config.map.server).toBe("ws://file-server:8080");
     });
+
+    it("env vars override global config values", () => {
+      process.env.SWARM_MAP_SERVER = "ws://env-server:9090";
+      const globalPath = writeFile(tmpDir, "global.json", JSON.stringify({
+        map: { server: "ws://global-server:8080" },
+      }));
+      const projectPath = path.join(tmpDir, "nonexistent.json");
+      const config = readConfig(projectPath, globalPath);
+      expect(config.map.server).toBe("ws://env-server:9090");
+    });
+
+    it("env vars override both project and global config", () => {
+      process.env.SWARM_MAP_SIDECAR = "persistent";
+      const globalPath = writeFile(tmpDir, "global.json", JSON.stringify({
+        map: { sidecar: "session" },
+      }));
+      const projectPath = writeFile(tmpDir, "project.json", JSON.stringify({
+        map: { sidecar: "session" },
+      }));
+      const config = readConfig(projectPath, globalPath);
+      expect(config.map.sidecar).toBe("persistent");
+    });
   });
 
   describe("resolveTeamName", () => {