Repository-level custom agents resolved relative to git root, but skills and .mcp.json relative to cwd

[NiceAsiv]

Describe the bug

The three repository-scoped customization sources are discovered using two
different base directories:

Source	Discovered at	Base directory
Custom agents	<git-root>/.github/agents/	git root
Skills	<cwd>/.github/skills/	cwd
MCP servers	<cwd>/.mcp.json	cwd

Because agents are bound to the git root while skills and MCP are bound to the
current working directory, it is impossible to keep all three together in a
subdirectory of a repository. In a monorepo (or any repo where you want to keep
Copilot config in a subfolder, e.g. agent/), you must either:

• put .github/agents/ at the git root (so the agent loads) — but then skills
  and .mcp.json must ALSO be at the git root, forcing you to run from the git
  root and scattering config across the tree; or
• copy the agent into the user-level ~/.copilot/agents/ directory, which is
  machine-global and not committed to the repo.

There is no cwd from which a subdirectory-local agent + skills + MCP all load
together.

Affected version

GitHub Copilot CLI 1.0.60-0 (Windows)

Steps to reproduce the behavior

1. In a git repo, create a subdirectory sub/ and place all three there:
   • sub/.github/agents/myagent.agent.md
   • sub/.github/skills/myskill/SKILL.md
   • sub/.mcp.json
2. cd sub and run copilot --agent myagent -p "...".
   • Skills and MCP from sub/ do load (cwd-relative).
   • The agent does not load: No such agent: myagent, available: (empty).
3. Run the same command from the git root — the agent still does not load,
   because <git-root>/.github/agents/ does not exist.
4. Move .github/ and .mcp.json up to the git root and run from the git root —
   now all three load. This is the only working layout, and it forces config to
   the git root.

A sharper probe: with an agent at <git-root>/.github/agents/A.agent.md AND a
different agent at <git-root>/sub/.github/agents/B.agent.md, running from
cwd=<git-root>/sub lists only A (the git-root one), never B. This shows the
loader goes straight to the git root rather than searching upward from cwd the
way skills do.

Expected behavior

Custom agents should be discoverable using the same base directory as skills and
MCP (cwd, ideally searching upward toward the git root), OR there should be a
configurable agentDirectories setting analogous to skillDirectories, so that
agents + skills + MCP can be co-located in a subdirectory and loaded together.

Additional context

• Related: Please add support for multiple agent directories like you do for skills #3505 (asymmetry — skills support multiple directories via
  skillDirectories, agents do not) and Organization-level custom agents not visible in Copilot CLI when no GitHub-hosted repository is in the working directory #3572 (agent discovery tied to the
  working directory's git remote). This report is specifically about the
  git-root vs cwd base-directory inconsistency between agents and
  skills/MCP, which neither of those covers directly.
• Our repo uses Azure DevOps for source control with config kept under a
  agent/ subfolder, which is what surfaced this.

[sigsegved]

This would be extremely helpful. Copilot has no way of working with specialized subagents from across multiple repos unless we copy all the agents into the git-root's agent dir, which is cumbersome, ugly hard to maintain.

[tamirdresher]

Adding a real-world data point — this asymmetry is biting our .NET Aspire integration for Squad multi-agent teams and forcing us to ship a workaround we'd rather not.

The shape of our use case

A Squad workspace is a folder with .squad/ config plus a .github/agents/squad.agent.md and (when we layer in the dashboard terminal) supporting MCP config:

my-aspire-app/                                  ← git root (the user's project)
├── .git/
├── .github/agents/...                          ← user's OUTER agents (unrelated)
├── AppHost/Program.cs                          ← AddSquad("research-squad", "./research-squad")
└── research-squad/                             ← squad workspace, NOT a git root
    ├── .squad/                                 ← team roster, decisions, history
    ├── .github/agents/squad.agent.md           ← the squad coordinator we want loaded
    └── .mcp.json                               ← (when present) squad-specific MCP servers

When the AppHost spawns copilot --agent squad --yolo with cwd=research-squad, the CLI walks up to my-aspire-app/.git and loads the OUTER .github/agents/ instead of the squad's own. The agent the user expected to talk to never loads.

Workaround we have to ship

At AppHost startup we scaffold a marker .git/ directory inside each squad folder so the CLI treats it as its own repo root:

// Aspire AppHost lifecycle hook
foreach (var squadFolder in squadFolders) {
    var fakeGit = Path.Combine(squadFolder, ".git");
    if (!Directory.Exists(fakeGit)) {
        Directory.CreateDirectory(fakeGit);
        File.WriteAllText(Path.Combine(fakeGit, "HEAD"), "ref: refs/heads/main\n");
    }
}

This works, but it's nasty: we're polluting the user's tree with directories that look like real git repos, racing with their actual git tooling, and we have to gate it carefully so we don't clobber a real .git/ if the squad folder ever does become its own repo.

We're now debating whether to bake the same workaround into Squad.Agents.AI (the NuGet that programmatically wraps the CLI), so every .NET consumer who points SquadAgent at a nested squad folder gets the same fix. We'd much rather not — it's strictly worse than the CLI just supporting the discovery model that VS Code and Copilot's own AGENTS.md / instructions / skills / .mcp.json loaders already use (cwd-relative).

Cluster of related issues

This is the same root cause as a few others — flagging the cluster so triage can score them together:

• Allow custom agent to be specified via full qualified file path #1747 — --agent <full-path> flag (escape hatch for programmatic callers like us)
• Support discovering custom agents from subdirectories in monorepos #2245 — discover agents from subdirectory .github/agents (9 👍, exact monorepo scenario)
• Feature: Discover custom agents from cwd, not just git root #2504 — align agent discovery with how custom-instructions discovery already works (cleanest fix IMO)
• Repository-level custom agents resolved relative to git root, but skills and .mcp.json relative to cwd #3688 (this issue) — articulates the asymmetry between agents (git-root) and skills/MCP (cwd) as a bug

Any of #2245 / #2504 / this one fix our scenario without us needing the marker-.git hack. #1747 alone would also work for programmatic .NET consumers. Strong preference for either an --agent-file <path> flag or cwd-relative discovery (matching skills/MCP) so the whole config travels together.

Happy to test an experimental build if it helps.