@bastani/atomic 0.5.14 → 0.5.15-0

package/src/sdk/runtime/executor.ts

@@ -33,7 +33,11 @@ import type {
   ProviderClient,
   ProviderSession,
 } from "../types.ts";
-import { isValidAgent } from "../../services/config/definitions.ts";
+import {
+  isValidAgent,
+  type ProviderOverrides,
+} from "../../services/config/definitions.ts";
+import { getProviderOverrides } from "../../services/config/atomic-config.ts";
 import { ensureDir } from "../../services/system/copy.ts";
 import type { SessionEvent } from "@github/copilot-sdk";
 import type { SessionPromptResponse } from "@opencode-ai/sdk/v2";
@@ -62,13 +66,7 @@ const AGENT_CLI: Record<
 > = {
   copilot: {
     cmd: "copilot",
-    chatFlags: [
-      "--add-dir",
-      ".",
-      "--yolo",
-      "--experimental",
-      "--no-auto-update",
-    ],
+    chatFlags: ["--add-dir", ".", "--yolo", "--experimental"],
     envVars: {
       COPILOT_ALLOW_ALL: "true",
     },
@@ -85,7 +83,6 @@ const AGENT_CLI: Record<
       // which the idle detection in claude.ts watches for to know when the
       // agent has finished processing a prompt.
       CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS: "1",
-      CLAUDE_CODE_NO_FLICKER: "1",
     },
   },
 };
@@ -110,7 +107,11 @@ export { errorMessage } from "../errors.ts";
 function isValidSavedMessage(msg: unknown): msg is SavedMessage {
   if (!msg || typeof msg !== "object") return false;
   const m = msg as Record<string, unknown>;
-  return m.provider === "copilot" || m.provider === "opencode" || m.provider === "claude";
+  return (
+    m.provider === "copilot" ||
+    m.provider === "opencode" ||
+    m.provider === "claude"
+  );
 }
 
 export interface WorkflowRunOptions {
@@ -184,15 +185,28 @@ async function getRandomPort(): Promise<number> {
 function buildPaneCommand(
   agent: AgentType,
   port: number,
+  overrides: ProviderOverrides = {},
 ): { command: string; envVars: Record<string, string> } {
-  const { cmd, chatFlags, envVars } = AGENT_CLI[agent];
+  const {
+    cmd,
+    chatFlags: defaultFlags,
+    envVars: defaultEnvVars,
+  } = AGENT_CLI[agent];
+  const chatFlags = overrides.chatFlags ?? defaultFlags;
+  const envVars = overrides.envVars
+    ? { ...defaultEnvVars, ...overrides.envVars }
+    : defaultEnvVars;
 
   switch (agent) {
     case "copilot":
       return {
-        command: [cmd, "--ui-server", "--port", String(port), ...chatFlags].join(
-          " ",
-        ),
+        command: [
+          cmd,
+          "--ui-server",
+          "--port",
+          String(port),
+          ...chatFlags,
+        ].join(" "),
         envVars,
       };
     case "opencode":
@@ -286,7 +300,9 @@ export function escPwsh(s: string): string {
  * structured inputs are optional, so a corrupt payload must never
  * prevent free-form workflows from running.
  */
-export function parseInputsEnv(raw: string | undefined): Record<string, string> {
+export function parseInputsEnv(
+  raw: string | undefined,
+): Record<string, string> {
   if (!raw) return {};
   try {
     const decoded = Buffer.from(raw, "base64").toString("utf-8");
@@ -487,8 +503,7 @@ function createTranscriptReader(
     const refName = resolveRef(ref);
     const prev = completedRegistry.get(refName);
     if (!prev) {
-      const available =
-        [...completedRegistry.keys()].join(", ") || "(none)";
+      const available = [...completedRegistry.keys()].join(", ") || "(none)";
       throw new Error(
         `No transcript for "${refName}". Available: ${available}`,
       );
@@ -510,11 +525,8 @@ function createMessagesReader(
     const refName = resolveRef(ref);
     const prev = completedRegistry.get(refName);
     if (!prev) {
-      const available =
-        [...completedRegistry.keys()].join(", ") || "(none)";
-      throw new Error(
-        `No messages for "${refName}". Available: ${available}`,
-      );
+      const available = [...completedRegistry.keys()].join(", ") || "(none)";
+      throw new Error(`No messages for "${refName}". Available: ${available}`);
     }
     const filePath = join(prev.sessionDir, "messages.json");
     const raw = await Bun.file(filePath).text();
@@ -542,6 +554,8 @@ interface SharedRunnerState {
    * specifically via `ctx.inputs.prompt` for the free-form case.
    */
   inputs: Record<string, string>;
+  /** User-configured provider overrides (global + local merged). */
+  providerOverrides: ProviderOverrides;
   panel: OrchestratorPanel;
   /** Sessions that have been spawned (for name uniqueness + cleanup). */
   activeRegistry: Map<string, ActiveSession>;
@@ -615,7 +629,10 @@ async function initProviderClientAndSession<A extends AgentType>(
       }
       const { createOpencodeClient } = await import("@opencode-ai/sdk/v2");
       const ocClientOpts = clientOpts as StageClientOptions<"opencode">;
-      const client = createOpencodeClient({ ...ocClientOpts, baseUrl: serverUrl });
+      const client = createOpencodeClient({
+        ...ocClientOpts,
+        baseUrl: serverUrl,
+      });
       const sessionResult = await client.session.create(ocSessionOpts);
       await client.tui.selectSession({ sessionID: sessionResult.data!.id });
       return { client, session: sessionResult.data! } as Result;
@@ -632,7 +649,11 @@ async function initProviderClientAndSession<A extends AgentType>(
       const claudeSessionOpts = sessionOpts as StageSessionOptions<"claude">;
       const client = new ClaudeClientWrapper(paneId, claudeClientOpts);
       await client.start();
-      const session = new ClaudeSessionWrapper(paneId, sessionId, claudeSessionOpts);
+      const session = new ClaudeSessionWrapper(
+        paneId,
+        sessionId,
+        claudeSessionOpts,
+      );
       return { client, session } as Result;
     }
     default:
@@ -661,12 +682,16 @@ async function cleanupProvider<A extends AgentType>(
       try {
         await session.disconnect();
       } catch (e) {
-        console.warn(`[cleanup] copilot session disconnect failed: ${errorMessage(e)}`);
+        console.warn(
+          `[cleanup] copilot session disconnect failed: ${errorMessage(e)}`,
+        );
       }
       try {
         await client.stop();
       } catch (e) {
-        console.warn(`[cleanup] copilot client stop failed: ${errorMessage(e)}`);
+        console.warn(
+          `[cleanup] copilot client stop failed: ${errorMessage(e)}`,
+        );
       }
       break;
     }
@@ -756,12 +781,12 @@ function createSessionRunner(
     let panelSessionAdded = false;
 
     try {
-
       // ── 6. Allocate port ──
       const port = await getRandomPort();
       const { command: paneCmd, envVars: paneEnvVars } = buildPaneCommand(
         shared.agent,
         port,
+        shared.providerOverrides,
       );
 
       // ── 7. Create tmux window or headless execution ──
@@ -818,16 +843,13 @@ function createSessionRunner(
         arg: SessionEvent[] | SessionPromptResponse | string,
       ): Promise<SavedMessage[]> {
         if (typeof arg === "string") {
-          const { getSessionMessages, listSessions } = await import(
-            "@anthropic-ai/claude-agent-sdk"
-          );
+          const { getSessionMessages, listSessions } =
+            await import("@anthropic-ai/claude-agent-sdk");
           const dir = process.cwd();
           const sessions = await listSessions({ dir });
 
           const newSessions = knownClaudeSessionIds
-            ? sessions.filter(
-                (s) => !knownClaudeSessionIds!.has(s.sessionId),
-              )
+            ? sessions.filter((s) => !knownClaudeSessionIds!.has(s.sessionId))
             : sessions.filter(
                 (s) => s.lastModified >= claudeSessionStartedAfter,
               );
@@ -890,16 +912,19 @@ function createSessionRunner(
       const getMessagesFn = createMessagesReader(shared.completedRegistry);
 
       // ── 12. Auto-create provider client and session ──
-      const { client: providerClient, session: providerSession, cleanup: providerCleanup } =
-        await initProviderClientAndSession(
-          shared.agent,
-          serverUrl,
-          paneId,
-          sessionId,
-          clientOpts,
-          sessionOpts,
-          isHeadless,
-        );
+      const {
+        client: providerClient,
+        session: providerSession,
+        cleanup: providerCleanup,
+      } = await initProviderClientAndSession(
+        shared.agent,
+        serverUrl,
+        paneId,
+        sessionId,
+        clientOpts,
+        sessionOpts,
+        isHeadless,
+      );
 
       // ── 12a. Copilot: wrap send() to await session.idle ──
       // Copilot's send() is fire-and-forget — it returns immediately after
@@ -924,7 +949,10 @@ function createSessionRunner(
           const idle = new Promise<void>((resolve, reject) => {
             let unsubIdle: (() => void) | undefined;
             let unsubError: (() => void) | undefined;
-            const cleanup = () => { unsubIdle?.(); unsubError?.(); };
+            const cleanup = () => {
+              unsubIdle?.();
+              unsubError?.();
+            };
             unsubIdle = copilotSession.on("session.idle", () => {
               cleanup();
               resolve();
@@ -984,16 +1012,18 @@ function createSessionRunner(
         callbackResult = await run(ctx);
         if (pendingSaves.length > 0) await Promise.all(pendingSaves);
       } catch (error) {
-        const message =
-          errorMessage(error);
-        await Bun.write(join(sessionDir, "error.txt"), message).catch(
-          () => {},
-        );
+        const message = errorMessage(error);
+        await Bun.write(join(sessionDir, "error.txt"), message).catch(() => {});
         if (!isHeadless) shared.panel.sessionError(name, message);
         throw error;
       } finally {
         // ── 14a. Auto-cleanup provider resources ──
-        await cleanupProvider(shared.agent, providerClient, providerSession, paneId);
+        await cleanupProvider(
+          shared.agent,
+          providerClient,
+          providerSession,
+          paneId,
+        );
         if (providerCleanup) {
           try {
             providerCleanup();
@@ -1067,7 +1097,9 @@ export async function runOrchestrator(): Promise<void> {
   const tmuxSessionName = process.env.ATOMIC_WF_TMUX!;
   const rawAgent = process.env.ATOMIC_WF_AGENT!;
   if (!isValidAgent(rawAgent)) {
-    throw new Error(`Invalid ATOMIC_WF_AGENT: "${rawAgent}". Expected one of: copilot, opencode, claude`);
+    throw new Error(
+      `Invalid ATOMIC_WF_AGENT: "${rawAgent}". Expected one of: copilot, opencode, claude`,
+    );
   }
   const agent: AgentType = rawAgent;
   // ATOMIC_WF_INPUTS carries the full input payload. Free-form
@@ -1084,6 +1116,7 @@ export async function runOrchestrator(): Promise<void> {
 
   process.chdir(cwd);
 
+  const providerOverrides = await getProviderOverrides(agent, cwd);
   const sessionsBaseDir = join(getSessionsBaseDir(), workflowRunId);
   await ensureDir(sessionsBaseDir);
 
@@ -1114,6 +1147,7 @@ export async function runOrchestrator(): Promise<void> {
     sessionsBaseDir,
     agent,
     inputs,
+    providerOverrides,
     panel,
     activeRegistry: new Map(),
     completedRegistry: new Map(),
@@ -1204,4 +1238,3 @@ export async function runOrchestrator(): Promise<void> {
     process.off("SIGINT", signalHandler);
   }
 }
-

package/src/sdk/workflows/builtin/deep-research-codebase/claude/index.ts

@@ -17,12 +17,15 @@
  *                     │
  *                     ▼
  *   ┌──────────────────────────────────────────────────┐
- *   │  explorer-1   explorer-2   ...   explorer-N      │   (Promise.all)
+ *   │  explorer-1   explorer-2   ...   explorer-N      │   (Promise.all, headless)
  *   └──────────────────────────────────────────────────┘
  *                     │
  *                     ▼
  *                aggregator
  *
+ * Explorers run headless (in-process, no tmux window) — they are transparent
+ * to the graph, so the visible topology is: [scout, history] → aggregator.
+ *
  * Stage 1a — codebase-scout
  *   Pure-TypeScript: lists files (git ls-files), counts LOC (batched wc -l),
  *   renders a depth-bounded ASCII tree, and bin-packs directories into N
@@ -211,9 +214,10 @@ export default defineWorkflow({
     const scoutOverview = (await ctx.transcript(scout)).content;
     const historyOverview = (await ctx.transcript(history)).content;
 
-    // ── Stage 2: parallel explorers ────────────────────────────────────────
-    // Each explorer is a separate tmux pane / Claude session, running
-    // concurrently via Promise.all. Each one receives:
+    // ── Stage 2: parallel headless explorers ─────────────────────────────────
+    // Each explorer runs headless (in-process, no tmux pane) via Promise.all.
+    // They are invisible in the workflow graph but tracked by the background
+    // task counter in the statusline. Each one receives:
     //   - the original research question (top + bottom of prompt)
     //   - the scout's architectural overview
     //   - its OWN partition (never the full file list)
@@ -232,6 +236,7 @@ export default defineWorkflow({
         return ctx.stage(
           {
             name: `explorer-${i}`,
+            headless: true,
             description: `Explore ${partition
               .map((u) => u.path)
               .join(

package/src/sdk/workflows/builtin/deep-research-codebase/copilot/index.ts

@@ -18,12 +18,15 @@
  *                     │
  *                     ▼
  *   ┌──────────────────────────────────────────────────┐
- *   │  explorer-1   explorer-2   ...   explorer-N      │   (Promise.all)
+ *   │  explorer-1   explorer-2   ...   explorer-N      │   (Promise.all, headless)
  *   └──────────────────────────────────────────────────┘
  *                     │
  *                     ▼
  *                aggregator
  *
+ * Explorers run headless (in-process, no tmux window) — they are transparent
+ * to the graph, so the visible topology is: [scout, history] → aggregator.
+ *
  * Copilot-specific concerns baked in:
  *
  *
@@ -177,12 +180,13 @@ export default defineWorkflow({
     const scoutOverview = (await ctx.transcript(scout)).content;
     const historyOverview = (await ctx.transcript(history)).content;
 
-    // ── Stage 2: parallel explorers ────────────────────────────────────────
-    // Each explorer is a separate Copilot session, running concurrently via
-    // Promise.all. Because the session is fresh (F5), every piece of context
-    // it needs — question, architectural orientation, historical context,
-    // partition assignment, scratch path — is injected into the first prompt
-    // via buildExplorerPromptGeneric.
+    // ── Stage 2: parallel headless explorers ─────────────────────────────────
+    // Each explorer runs headless (in-process, no tmux pane) via Promise.all.
+    // They are invisible in the workflow graph but tracked by the background
+    // task counter in the statusline. Because each session is fresh (F5),
+    // every piece of context it needs — question, architectural orientation,
+    // historical context, partition assignment, scratch path — is injected
+    // into the first prompt via buildExplorerPromptGeneric.
     const explorerHandles = await Promise.all(
       partitions.map((partition, idx) => {
         const i = idx + 1;
@@ -190,6 +194,7 @@ export default defineWorkflow({
         return ctx.stage(
           {
             name: `explorer-${i}`,
+            headless: true,
             description: `Explore ${partition
               .map((u) => u.path)
               .join(", ")} (${partition.reduce((s, u) => s + u.fileCount, 0)} files)`,

package/src/sdk/workflows/builtin/deep-research-codebase/opencode/index.ts

@@ -18,12 +18,15 @@
  *                     │
  *                     ▼
  *   ┌──────────────────────────────────────────────────┐
- *   │  explorer-1   explorer-2   ...   explorer-N      │   (Promise.all)
+ *   │  explorer-1   explorer-2   ...   explorer-N      │   (Promise.all, headless)
  *   └──────────────────────────────────────────────────┘
  *                     │
  *                     ▼
  *                aggregator
  *
+ * Explorers run headless (in-process, no tmux window) — they are transparent
+ * to the graph, so the visible topology is: [scout, history] → aggregator.
+ *
  * OpenCode-specific concerns baked in:
  *
  *  • F5 — every `ctx.stage()` call is a FRESH session with no memory of
@@ -196,12 +199,13 @@ export default defineWorkflow({
     const scoutOverview = (await ctx.transcript(scout)).content;
     const historyOverview = (await ctx.transcript(history)).content;
 
-    // ── Stage 2: parallel explorers ────────────────────────────────────────
-    // Each explorer is a separate OpenCode session, running concurrently via
-    // Promise.all. Because the session is fresh (F5), every piece of context
-    // it needs — question, architectural orientation, historical context,
-    // partition assignment, scratch path — is injected into the first prompt
-    // via buildExplorerPromptGeneric.
+    // ── Stage 2: parallel headless explorers ─────────────────────────────────
+    // Each explorer runs headless (in-process, no tmux pane) via Promise.all.
+    // They are invisible in the workflow graph but tracked by the background
+    // task counter in the statusline. Because each session is fresh (F5),
+    // every piece of context it needs — question, architectural orientation,
+    // historical context, partition assignment, scratch path — is injected
+    // into the first prompt via buildExplorerPromptGeneric.
     const explorerHandles = await Promise.all(
       partitions.map((partition, idx) => {
         const i = idx + 1;
@@ -209,6 +213,7 @@ export default defineWorkflow({
         return ctx.stage(
           {
             name: `explorer-${i}`,
+            headless: true,
             description: `Explore ${partition
               .map((u) => u.path)
               .join(", ")} (${partition.reduce((s, u) => s + u.fileCount, 0)} files)`,

package/src/services/config/atomic-config.ts

@@ -9,7 +9,7 @@
 
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
-import { type SourceControlType } from "./index.ts";
+import { type SourceControlType, type AgentKey, type ProviderOverrides } from "./index.ts";
 import { SETTINGS_SCHEMA_URL } from "./settings-schema.ts";
 import { ensureDir } from "../system/copy.ts";
 
@@ -26,6 +26,8 @@ export interface AtomicConfig {
   scm?: SourceControlType;
   /** Timestamp of last init */
   lastUpdated?: string;
+  /** Per-provider overrides for chatFlags and envVars */
+  providers?: Partial<Record<AgentKey, ProviderOverrides>>;
 }
 
 type JsonRecord = Record<string, unknown>;
@@ -47,6 +49,41 @@ async function readJsonFile(path: string): Promise<JsonRecord | null> {
   }
 }
 
+function pickProviderOverrides(raw: unknown): ProviderOverrides | null {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const obj = raw as Record<string, unknown>;
+  const result: ProviderOverrides = {};
+
+  if (Array.isArray(obj.chatFlags) && obj.chatFlags.every((f): f is string => typeof f === "string")) {
+    result.chatFlags = obj.chatFlags;
+  }
+  if (obj.envVars && typeof obj.envVars === "object" && !Array.isArray(obj.envVars)) {
+    const envVars: Record<string, string> = {};
+    for (const [k, v] of Object.entries(obj.envVars)) {
+      if (typeof v === "string") envVars[k] = v;
+    }
+    if (Object.keys(envVars).length > 0) result.envVars = envVars;
+  }
+
+  return Object.keys(result).length > 0 ? result : null;
+}
+
+const VALID_AGENT_KEYS = new Set<string>(["claude", "opencode", "copilot"]);
+
+function pickProviders(raw: unknown): Partial<Record<AgentKey, ProviderOverrides>> | null {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const obj = raw as Record<string, unknown>;
+  const result: Partial<Record<AgentKey, ProviderOverrides>> = {};
+
+  for (const [key, value] of Object.entries(obj)) {
+    if (!VALID_AGENT_KEYS.has(key)) continue;
+    const overrides = pickProviderOverrides(value);
+    if (overrides) result[key as AgentKey] = overrides;
+  }
+
+  return Object.keys(result).length > 0 ? result : null;
+}
+
 function pickAtomicConfig(record: JsonRecord | null): AtomicConfig | null {
   if (!record) return null;
 
@@ -59,9 +96,42 @@ function pickAtomicConfig(record: JsonRecord | null): AtomicConfig | null {
   if (typeof scm === "string") config.scm = scm as SourceControlType;
   if (typeof lastUpdated === "string") config.lastUpdated = lastUpdated;
 
+  const providers = pickProviders(record.providers);
+  if (providers) config.providers = providers;
+
   return Object.keys(config).length > 0 ? config : null;
 }
 
+/**
+ * Merge two ProviderOverrides, with `over` taking precedence.
+ * - chatFlags: later config replaces earlier
+ * - envVars: merged, later values win on conflict
+ */
+function mergeProviderOverrides(
+  base: ProviderOverrides | undefined,
+  over: ProviderOverrides | undefined,
+): ProviderOverrides | undefined {
+  if (!base && !over) return undefined;
+  if (!base) return over;
+  if (!over) return base;
+
+  const result: ProviderOverrides = {};
+
+  // chatFlags: later replaces earlier entirely
+  if (over.chatFlags !== undefined) {
+    result.chatFlags = over.chatFlags;
+  } else if (base.chatFlags !== undefined) {
+    result.chatFlags = base.chatFlags;
+  }
+
+  // envVars: merged, later wins on conflict
+  if (base.envVars || over.envVars) {
+    result.envVars = { ...base.envVars, ...over.envVars };
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 function mergeConfigs(...configs: Array<AtomicConfig | null>): AtomicConfig | null {
   const merged: AtomicConfig = {};
   for (const config of configs) {
@@ -69,6 +139,14 @@ function mergeConfigs(...configs: Array<AtomicConfig | null>): AtomicConfig | nu
     if (config.version !== undefined) merged.version = config.version;
     if (config.scm !== undefined) merged.scm = config.scm;
     if (config.lastUpdated !== undefined) merged.lastUpdated = config.lastUpdated;
+
+    if (config.providers) {
+      if (!merged.providers) merged.providers = {};
+      for (const [key, overrides] of Object.entries(config.providers)) {
+        const agentKey = key as AgentKey;
+        merged.providers[agentKey] = mergeProviderOverrides(merged.providers[agentKey], overrides);
+      }
+    }
   }
   return Object.keys(merged).length > 0 ? merged : null;
 }
@@ -121,3 +199,19 @@ export async function getSelectedScm(projectDir: string): Promise<SourceControlT
   const config = await readAtomicConfig(projectDir);
   return config?.scm ?? null;
 }
+
+/**
+ * Resolve provider overrides from global + local settings (local wins).
+ *
+ * Returns `{ chatFlags, envVars }` that are meant to be layered on top
+ * of the provider's hardcoded defaults:
+ * - `chatFlags`: when set, replaces the provider's default chat_flags entirely
+ * - `envVars`: merged on top of the provider's default env_vars (user values win)
+ */
+export async function getProviderOverrides(
+  agentKey: AgentKey,
+  projectDir: string,
+): Promise<ProviderOverrides> {
+  const config = await readAtomicConfig(projectDir);
+  return config?.providers?.[agentKey] ?? {};
+}

package/src/services/config/atomic-global-config.ts

@@ -1,10 +1,11 @@
-import { copyFile, lstat, readdir, rm, rmdir } from "node:fs/promises";
+import { lstat, readdir, rm, rmdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
 
 import { AGENT_CONFIG, getAgentKeys, type AgentKey } from "./index.ts";
-import { mergeJsonFile } from "../../lib/merge.ts";
-import { copyDir, ensureDir, pathExists } from "../system/copy.ts";
+import { syncJsonFile } from "../../lib/merge.ts";
+import { createCommonIgnoreFilter } from "../../lib/common-ignore.ts";
+import { copyDir, ensureDir, pathExists, shouldExclude } from "../system/copy.ts";
 
 
 const ATOMIC_HOME_DIR = join(homedir(), ".atomic");
@@ -117,15 +118,7 @@ async function collectManagedTreeEntries(
       ? join(relativeDir, entry.name)
       : entry.name;
 
-    if (exclude.includes(entry.name)) {
-      continue;
-    }
-
-    const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-    if (exclude.some((excluded) =>
-      normalizedRelativePath === excluded.replace(/\\/g, "/") ||
-      normalizedRelativePath.startsWith(`${excluded.replace(/\\/g, "/")}/`)
-    )) {
+    if (shouldExclude(relativePath, entry.name, [...exclude])) {
       continue;
     }
 
@@ -174,14 +167,7 @@ async function syncManagedGlobalFile(
   sourcePath: string,
   destinationPath: string,
 ): Promise<void> {
-  await ensureDir(resolve(destinationPath, ".."));
-
-  if (await pathExists(destinationPath)) {
-    await mergeJsonFile(sourcePath, destinationPath);
-    return;
-  }
-
-  await copyFile(sourcePath, destinationPath);
+  await syncJsonFile(sourcePath, destinationPath);
 }
 
 /**
@@ -264,10 +250,11 @@ export async function syncAtomicGlobalAgentConfigs(
     const destinationFolder = getAtomicManagedAgentDir(agentKey, baseDir);
     await ensureDir(destinationFolder);
 
+    const ignoreFilter = createCommonIgnoreFilter();
     for (const subdirectory of GLOBAL_SYNC_SUBDIRECTORIES) {
       const sourceSubdir = join(sourceFolder, subdirectory);
       if (await pathExists(sourceSubdir)) {
-        await copyDir(sourceSubdir, join(destinationFolder, subdirectory));
+        await copyDir(sourceSubdir, join(destinationFolder, subdirectory), { ignoreFilter });
       }
     }