@join-pantheon/cli 0.25.3 → 0.26.1

package/README.md

@@ -404,22 +404,60 @@ with no human; the cap and lock governors under two workers per member.
 
 ### Which agent answers
 
-The worker runs whichever agent CLI this machine has — `--agent claude-code|codex|cursor|auto`
-(default auto: first one found on PATH). Each backend is driven the way it actually works, with
-the same "no shell unless you said so" rule spelled in its own dialect:
+The worker runs whichever agent CLI this machine has — `--agent claude-code|codex|cursor|copilot|auto`.
+With `auto` (the default) the order is: the agent a persona pins, then the one you chose at setup,
+then PATH order — and a candidate that is not signed in is skipped and named in the run log, so a
+run never fails on an expired session when another agent could have answered. If nothing is
+signed in, the first on PATH runs and the alert says exactly that, with the sign-in command.
+`pantheon doctor` shows the same choice (`worker agent`). Each backend is driven the way it
+actually works, with the same "no shell unless you said so" rule spelled in its own dialect:
 
 | backend | bash gated (default) | with `--allow-bash` |
 |---|---|---|
 | claude-code | `acceptEdits` + the six pantheon tools | `bypassPermissions` |
 | codex | `--sandbox read-only` (codex has no edits-without-shell mode) | `--sandbox workspace-write` |
 | cursor | proposes edits, never applies (`-p` without `--force`) | `--force` |
+| copilot | `--allow-tool=pantheon-worker --allow-tool=write` (edits without shell, Copilot's `write` kind) | `--allow-all-tools` |
 
-All three backends are verified with **real live woken runs** — an idle machine answering a
-peer's ASK end to end with Claude Code, Cursor, and Codex. Codex quirks the tooling handles for
+Claude Code, Cursor and Codex are verified with **real live woken runs** — an idle machine answering a
+peer's ASK end to end. Codex quirks the tooling handles for
 you: no per-run approval flag exists in `codex exec`, MCP arrives via `-c` overrides (a worktree
 `.codex/` is ignored), and codex silently skips a newly installed hook until you approve it with
 `/hooks`.
 
+Copilot runs in a `COPILOT_HOME` of its own for the run, outside the checkout. Copilot loads every
+MCP server and hook it finds in its home, so yours would ride along — your pantheon entry as a second
+server in the interactive role, your hooks, your folder approvals. The per-run home carries only the
+run's own server (named `pantheon-worker`; the repo's committed `pantheon` is disabled by name), trusts
+the worktree so `AGENTS.md` is read, and copies your `config.json` (trusted folders merged) and
+`settings.json` across so your sign-in and model choice still apply. Verified against copilot 1.0.86:
+a fresh home signs in through the system credential store, or through `gh` if that is where you are
+signed in.
+
+### Copilot
+
+GitHub Copilot is one backend covering two surfaces. **Copilot CLI** reads the repo's `.mcp.json`
+(the same file Claude Code reads) and `~/.copilot/mcp-config.json`; **Copilot in VS Code** reads
+`.vscode/mcp.json` and its own user `mcp.json`, in a different dialect (`servers`, `stdio`), so
+`pantheon install` writes both. The repo-level VS Code file is the one thing here written on
+evidence rather than by default: `.vscode/` is a directory teams curate and commit, so it appears
+only when the repo already has one or the machine running install has VS Code. A VS Code user on a
+repo with neither is covered by `pantheon install --user`, which writes their own profile's
+`mcp.json`. Hooks go in one file both read: `.github/hooks/pantheon.json` in the
+repo, or `~/.copilot/hooks/pantheon.json` for every project — `agentStop` holds a turn open the way
+Codex's Stop does, `userPromptSubmitted` and `sessionEnd` report busy and idle.
+
+Two things Copilot does differently. It has no allow-list file for MCP tools: it asks once per tool
+per folder and remembers your answer, so the first session says yes nine times. And it has no status
+command: `pantheon doctor` reports Copilot signed in when a token is in the environment or `gh` is
+signed in, and says "could not tell" otherwise rather than guessing — a run that fails on sign-in is
+named as that, with `copilot login` as the fix.
+
+**On a Copilot Business or Enterprise plan**, an organization owner has to switch on the
+"MCP servers in Copilot" policy before any MCP server, pantheon included, loads. Organizations can
+also restrict MCP servers to an approved registry; the server is called `pantheon` and its only job
+is moving messages between your teammates' agents — nothing here reads code or runs commands.
+
 ### Personas — telling the worker who to be
 
 A worker with no instructions escalates too much and trusts too much. A **persona** is one

package/bin/pantheon.js

@@ -9,7 +9,7 @@
  */
 import { existsSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const root = resolve(here, "..");
@@ -25,4 +25,9 @@ if (!existsSync(entry)) {
   process.exit(1);
 }
 
-await import(entry);
+// A path is not a URL, and on Windows that is fatal rather than pedantic: an
+// absolute POSIX path happens to work as an import specifier, while `D:\...`
+// is read as the scheme "d:" and Node refuses it — so `pantheon --version`,
+// the first command anyone runs, died with ERR_UNSUPPORTED_ESM_URL_SCHEME on
+// every Windows machine. A real Windows runner is what said so.
+await import(pathToFileURL(entry).href);

package/dist/agents.js

@@ -1,17 +1,34 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, dirname } from "node:path";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join, dirname, isAbsolute } from "node:path";
 import { launcher } from "./install.js";
+import { agentSpawn, which } from "./which.js";
 import { PANTHEON_TOOL_NAMES, PANTHEON_TOOLS } from "./tools.js";
 export function launchArgs(agent, prompt, name) {
-    return agent === "claude-code" ? ["--name", name, prompt] : [prompt];
+    if (agent === "claude-code")
+        return ["--name", name, prompt];
+    if (agent === "copilot")
+        return ["-n", name, "-i", prompt];
+    return [prompt];
 }
 export const AGENTS = [
     { id: "claude-code", label: "Claude Code", binaries: ["claude"] },
     { id: "codex", label: "Codex", binaries: ["codex"] },
     { id: "cursor", label: "Cursor", binaries: ["cursor-agent", "agent"] },
+    { id: "copilot", label: "Copilot", binaries: ["copilot"] },
 ];
+export function copilotHome(home = homedir(), env = process.env) {
+    return env.COPILOT_HOME || join(home, ".copilot");
+}
+export function hasCopilotExtension(home = homedir()) {
+    try {
+        return readdirSync(join(home, ".vscode", "extensions")).some((d) => d.startsWith("github.copilot"));
+    }
+    catch {
+        return false;
+    }
+}
 const sh = (cmd) => {
     try {
         return execFileSync("sh", ["-lc", cmd], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
@@ -22,7 +39,7 @@ const sh = (cmd) => {
 };
 export function cliOnPath(name) {
     if (!binaryCache.has(`path:${name}`))
-        binaryCache.set(`path:${name}`, sh(`command -v ${name}`));
+        binaryCache.set(`path:${name}`, which(name));
     return binaryCache.get(`path:${name}`) ?? null;
 }
 export function agentById(id) {
@@ -35,6 +52,11 @@ export function detectForHooks(projectDir = process.cwd()) {
             out.push(backend);
             continue;
         }
+        if (backend.id === "copilot") {
+            if (existsSync(copilotHome()) || hasCopilotExtension())
+                out.push(backend);
+            continue;
+        }
         const userDir = backend.id === "claude-code" ? join(homedir(), ".claude")
             : backend.id === "codex" ? join(homedir(), ".codex")
                 : join(homedir(), ".cursor");
@@ -66,7 +88,8 @@ const binaryCache = new Map();
 export function resolveBinary(backend) {
     for (const b of backend.binaries) {
         if (!binaryCache.has(b)) {
-            let found = sh(`command -v ${b}`) ? b : null;
+            const hit = which(b);
+            let found = hit ? (platform() === "win32" ? hit : b) : null;
             if (found && b === "agent") {
                 const v = `${sh("agent --version 2>/dev/null | head -1") ?? ""} ${sh("agent --help 2>/dev/null | head -3") ?? ""}`;
                 if (!/cursor/i.test(v))
@@ -79,21 +102,96 @@ export function resolveBinary(backend) {
     }
     return null;
 }
-export function resolveAgent(preferred) {
+export const SIGN_IN_CHECK = {
+    "claude-code": { args: ["auth", "status"], fix: "run `claude`, then /login" },
+    codex: { args: ["login", "status"], fix: "run `codex login`" },
+    cursor: { args: ["status"], fix: "run `cursor-agent login`" },
+    copilot: { args: [], fix: "run `copilot login` (or `gh auth login` — copilot uses gh's sign-in too)" },
+};
+export const COPILOT_TOKEN_VARS = ["COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"];
+export function copilotSignedIn(run = runStatus, env = process.env, gh = () => !!cliOnPath("gh")) {
+    if (COPILOT_TOKEN_VARS.some((k) => env[k]))
+        return { ok: true, detail: "signed in (token in the environment)" };
+    if (!gh())
+        return { ok: false, unknown: true, detail: "could not tell (copilot has no status command, and gh is not on PATH)" };
+    const r = run("gh", ["auth", "status"]);
+    if (r.status === 0)
+        return { ok: true, detail: "signed in (via gh)" };
+    return { ok: false, unknown: true, detail: "could not tell (gh is not signed in; a `copilot login` is not visible from outside)" };
+}
+const runStatus = (binary, args) => {
+    try {
+        const sp = agentSpawn(binary, args);
+        const out = execFileSync(sp.command, sp.args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 8_000, env: { ...process.env, NO_COLOR: "1" }, ...sp.options });
+        return { status: 0, out };
+    }
+    catch (e) {
+        const err = e;
+        if (err.killed)
+            return { status: null, out: "timed out" };
+        return { status: err.status ?? null, out: `${err.stdout ?? ""}${err.stderr ?? ""}`.trim() || (err.message ?? "") };
+    }
+};
+export const AGENT_HOME_DIR = { "claude-code": ".claude", codex: ".codex", cursor: ".cursor", copilot: ".copilot" };
+export function signedIn(backend, binary, run = runStatus, home = homedir()) {
+    if (backend.id === "copilot")
+        return copilotSignedIn(run);
+    if (!existsSync(join(home, AGENT_HOME_DIR[backend.id])))
+        return { ok: false, detail: "never signed in on this machine" };
+    const check = SIGN_IN_CHECK[backend.id];
+    const r = run(binary, check.args);
+    if (r.status === null)
+        return { ok: false, unknown: true, detail: `could not tell (${(r.out.split("\n")[0] ?? "").slice(0, 60) || "no answer"})` };
+    if (backend.id === "claude-code") {
+        try {
+            const j = JSON.parse(r.out);
+            if (typeof j.loggedIn === "boolean")
+                return j.loggedIn ? { ok: true, detail: "signed in" } : { ok: false, detail: "not signed in" };
+        }
+        catch { }
+    }
+    return r.status === 0 ? { ok: true, detail: "signed in" } : { ok: false, detail: "not signed in" };
+}
+export function chooseAgent(preferred, opts = {}) {
+    const available = opts.available ?? detectAvailable();
+    const check = opts.check === null ? null : (opts.check ?? ((b, bin) => signedIn(b, bin, undefined, opts.home)));
+    const state = (b, bin) => (check ? check(b, bin) : undefined);
     if (preferred && preferred !== "auto") {
         const backend = agentById(preferred);
         if (!backend)
-            throw new Error(`unknown agent ${preferred} — use claude-code, codex, cursor, or auto`);
-        const binary = resolveBinary(backend);
-        if (!binary)
+            throw new Error(`unknown agent ${preferred} — use claude-code, codex, cursor, copilot, or auto`);
+        const hit = available.find((a) => a.backend.id === backend.id);
+        if (!hit)
             throw new Error(`${backend.label} is not on PATH (looked for ${backend.binaries.join(", ")})`);
-        return { backend, binary };
+        return { backend, binary: hit.binary, signIn: state(backend, hit.binary), because: "pinned", skipped: [] };
     }
-    const found = detectOnPath();
-    if (!found)
-        throw new Error("no agent CLI on PATH — install claude, codex, or cursor-agent");
-    const binary = resolveBinary(found);
-    return { backend: found, binary };
+    if (!available.length)
+        throw new Error("no agent CLI on PATH — install claude, codex, cursor-agent, or copilot");
+    const order = [];
+    const wanted = opts.prefer ? agentById(opts.prefer) : undefined;
+    const chosen = wanted ? available.find((a) => a.backend.id === wanted.id) : undefined;
+    if (chosen)
+        order.push({ ...chosen, because: "chosen at setup" });
+    for (const a of available)
+        if (!order.some((o) => o.backend.id === a.backend.id))
+            order.push({ ...a, because: available.length === 1 ? "only one on PATH" : "first signed in on PATH" });
+    const skipped = [];
+    for (const c of order) {
+        const s = state(c.backend, c.binary);
+        if (!s || s.ok || s.unknown)
+            return { backend: c.backend, binary: c.binary, ...(s ? { signIn: s } : {}), because: c.because, skipped };
+        skipped.push({ backend: c.backend, why: `${s.detail} — ${SIGN_IN_CHECK[c.backend.id].fix}` });
+    }
+    const first = order[0];
+    return { backend: first.backend, binary: first.binary, signIn: state(first.backend, first.binary), because: `${first.because} (none signed in)`, skipped };
+}
+export function describeChoice(c) {
+    const head = `${c.backend.label}${c.signIn ? ` — ${c.signIn.detail}` : ""} (${c.because})`;
+    return c.skipped.length ? `${head}; skipped ${c.skipped.map((s) => `${s.backend.label} — ${s.why}`).join("; ")}` : head;
+}
+export function resolveAgent(preferred) {
+    const c = chooseAgent(preferred, { check: null });
+    return { backend: c.backend, binary: c.binary };
 }
 export { PANTHEON_TOOL_NAMES, PANTHEON_TOOLS } from "./tools.js";
 export function headlessSpawn(opts) {
@@ -159,6 +257,32 @@ export function headlessSpawn(opts) {
             env: procEnv,
         };
     }
+    if (opts.backend.id === "copilot") {
+        const home = opts.runHome ? join(opts.runHome, "copilot") : join(opts.worktree, ".pantheon-copilot-home");
+        const config = opts.runHome ? readCopilotConfig() : {};
+        const trusted = Array.isArray(config.trustedFolders) ? config.trustedFolders.filter((x) => typeof x === "string") : [];
+        if (!trusted.includes(opts.worktree))
+            trusted.push(opts.worktree);
+        const settings = join(copilotHome(), "settings.json");
+        return {
+            command: opts.binary,
+            args: [
+                "-p", opts.prompt, "-s",
+                "--no-auto-update", "--no-ask-user", "--disable-builtin-mcps",
+                "--disable-mcp-server", "pantheon",
+                ...(opts.allowBash ? ["--allow-all-tools"] : [`--allow-tool=${COPILOT_WORKER_SERVER}`, "--allow-tool=write"]),
+            ],
+            env: { ...procEnv, COPILOT_HOME: home },
+            writeFiles: [
+                {
+                    path: join(home, "mcp-config.json"),
+                    contents: JSON.stringify({ mcpServers: { [COPILOT_WORKER_SERVER]: { type: "local", command: l.command, args: l.args, env: fileEnv, tools: ["*"] } } }, null, 2),
+                },
+                { path: join(home, "config.json"), contents: JSON.stringify({ ...config, trustedFolders: trusted }, null, 2) },
+            ],
+            ...(opts.runHome && existsSync(settings) ? { copyFiles: [{ from: settings, to: join(home, "settings.json") }] } : {}),
+        };
+    }
     return {
         command: opts.binary,
         args: [
@@ -185,15 +309,32 @@ export function headlessSpawn(opts) {
         ],
     };
 }
+export const COPILOT_WORKER_SERVER = "pantheon-worker";
+function readCopilotConfig() {
+    try {
+        const doc = JSON.parse(readFileSync(join(copilotHome(), "config.json"), "utf8"));
+        return doc && typeof doc === "object" && !Array.isArray(doc) ? doc : {};
+    }
+    catch {
+        return {};
+    }
+}
 export function tomlInlineTable(kv) {
     return `{${Object.entries(kv).map(([k, v]) => `${k} = ${JSON.stringify(v)}`).join(", ")}}`;
 }
 export function materializeSpawnFiles(worktree, spawn) {
     for (const f of spawn.writeFiles ?? []) {
-        const p = join(worktree, f.path);
-        mkdirSync(dirname(p), { recursive: true });
+        const p = isAbsolute(f.path) ? f.path : join(worktree, f.path);
+        mkdirSync(dirname(p), { recursive: true, mode: 0o700 });
         writeFileSync(p, f.contents, { mode: 0o600 });
     }
+    for (const c of spawn.copyFiles ?? []) {
+        try {
+            mkdirSync(dirname(c.to), { recursive: true, mode: 0o700 });
+            copyFileSync(c.from, c.to);
+        }
+        catch { }
+    }
 }
 export function backendFromLabel(label) {
     if (!label)

package/dist/cli.js

@@ -10,6 +10,7 @@ import { randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { PantheonClient } from "./client.js";
+import { agentSpawn } from "./which.js";
 import { fromInvite, looksLikeInviteCode, resolveInviteCode, load, save, toInvite, toJoinLink, resolveFor, loadAll, repoInfo, bindRepo, findMembership, setDefaultSpace, removeMembership, configFor, CONFIG_DIR, CONFIG_PATH, DEFAULT_RELAY, resolveForHook } from "./config.js";
 import { fmtLimit } from "./plans.js";
 import { validEmail, validUsername } from "./accounts.js";
@@ -427,6 +428,8 @@ function printReady(tools) {
             oneTime.set("cursor", `cursor   enable the "pantheon" MCP server if it asks`);
         if (/codex/i.test(t.tool))
             oneTime.set("codex", `codex    run /hooks inside codex once to approve the wake-up hook`);
+        if (/copilot/i.test(t.tool))
+            oneTime.set("copilot", `copilot  say yes once when it asks to trust this folder; on a Copilot Business or Enterprise plan an org owner must have the "MCP servers in Copilot" policy on`);
     }
     if (oneTime.size) {
         console.error(`\n${B("Your agents may each ask once")} ${D("(their own security, not ours — one yes each):")}`);
@@ -484,7 +487,7 @@ ${B("control")}
   pantheon admit <who>        let someone in       (--may-wake to allow unattended work here)
   pantheon admit <who> --revoke     remove them
   pantheon worker             stay answerable while you are away
-                            (--agent claude-code|codex|cursor|auto, --persona <name>)
+                            (--agent claude-code|codex|cursor|copilot|auto, --persona <name>)
   pantheon policy             what this machine's worker may do, in one screen (grant/revoke self-upgrade)
   pantheon persona            how a woken worker should behave: list / init <name> / show <name>
   pantheon notifier           alert you when a task requires your decision
@@ -497,7 +500,7 @@ ${B("control")}
   pantheon approvals          decisions waiting on you; show or answer one
   pantheon stop [relay|worker|notifier|menubar|all]  stop it
   pantheon hook install       your agent keeps working when a peer is waiting on it
-                            (auto-detects claude / codex / cursor on this machine)
+                            (auto-detects claude / codex / cursor / copilot on this machine)
   pantheon spend              woken runs on this machine, and what pantheon cannot see
   pantheon leave              remove what pantheon put on this machine
   pantheon panic              cut off all unattended work on this machine, now
@@ -1314,6 +1317,15 @@ async function main() {
         case "hook": {
             const sub = argv[1] ?? "status";
             const hookCfg = resolveForHook();
+            const sessionOf = (raw) => {
+                try {
+                    const j = JSON.parse(raw);
+                    return j.session_id ?? j.sessionId ?? j.conversation_id ?? "unknown";
+                }
+                catch {
+                    return "unknown";
+                }
+            };
             const reportIdle = async (session, seen) => {
                 if (!hookCfg)
                     return true;
@@ -1334,11 +1346,7 @@ async function main() {
                         raw += chunk;
                 }
                 catch { }
-                let session = "unknown";
-                try {
-                    session = JSON.parse(raw).session_id ?? "unknown";
-                }
-                catch { }
+                const session = sessionOf(raw);
                 try {
                     if (hookCfg) {
                         const { reportActivity } = await import("./pending.js");
@@ -1366,11 +1374,7 @@ async function main() {
                         raw += chunk;
                 }
                 catch { }
-                let session = "unknown";
-                try {
-                    session = JSON.parse(raw).session_id ?? "unknown";
-                }
-                catch { }
+                const session = sessionOf(raw);
                 try {
                     const { cursorSeq } = await import("./pending.js");
                     await reportIdle(session, cursorSeq(`hook:${session}`));
@@ -1444,22 +1448,18 @@ async function main() {
                     process.exit(0);
                 }
             }
-            if (sub === "codex-stop") {
+            if (sub === "codex-stop" || sub === "copilot-stop") {
                 let raw = "";
                 try {
                     for await (const chunk of process.stdin)
                         raw += chunk;
                 }
                 catch { }
-                let stopSession = "unknown";
-                try {
-                    stopSession = JSON.parse(raw).session_id ?? "unknown";
-                }
-                catch { }
+                const stopSession = sessionOf(raw);
                 try {
                     const { pending: pendingFn } = await import("./pending.js");
                     const { load: loadCfg } = await import("./config.js");
-                    const d = await decideStop(raw, {
+                    const d = await decideStop(JSON.stringify({ session_id: stopSession }), {
                         pending: async (session) => (hookCfg ? pendingFn({ session, cfg: hookCfg }) : Promise.resolve(null)),
                         ...(loadCfg()?.member ? { me: loadCfg().member } : {}),
                     });
@@ -1557,7 +1557,7 @@ async function main() {
             }
             const states = agentHookStates();
             if (!states.length) {
-                console.log(`${D("not installed")}\n  Install with: ${C("pantheon hook install")} (auto-detects claude / codex / cursor on PATH)`);
+                console.log(`${D("not installed")}\n  Install with: ${C("pantheon hook install")} (auto-detects claude / codex / cursor / copilot on PATH)`);
                 return;
             }
             for (const s of states) {
@@ -2007,7 +2007,7 @@ async function main() {
                 const publicChange = name !== undefined || title !== undefined || responsibilities !== undefined ||
                     humanRequired !== undefined || agentCanDecide !== undefined || capabilities !== undefined || keywords !== undefined;
                 if (!surface && !publicChange) {
-                    die("usage: pantheon profile set [--surface codex|claude-code|cursor] [--name name] [--title title] [--responsibilities a,b] [--human-required a,b] [--agent-can-decide a,b] [--keywords 'domain=word|word;domain=word']");
+                    die("usage: pantheon profile set [--surface codex|claude-code|cursor|copilot] [--name name] [--title title] [--responsibilities a,b] [--human-required a,b] [--agent-can-decide a,b] [--keywords 'domain=word|word;domain=word']");
                 }
                 if (flag("space")) {
                     const pf = loadAll() ?? die("not configured");
@@ -2319,7 +2319,10 @@ async function main() {
                             const prompt = o ? dp(o.id, dt(o.body)) : `Read Pantheon act ${a.id}${goalId ? ` and the thread of goal ${goalId}` : ""}. Explain in plain words what happened and whether anything is owed by me, then give me numbered next steps. Do not act until I choose.`;
                             console.error(D(`opening ${agent.id}…`));
                             const { spawnSync } = await import("node:child_process");
-                            spawnSync(agent.binary, launchArgs(agent.id, prompt, sessionName(prompt)), { stdio: "inherit" });
+                            {
+                                const sp = agentSpawn(agent.binary, launchArgs(agent.id, prompt, sessionName(prompt)));
+                                spawnSync(sp.command, sp.args, { stdio: "inherit", ...sp.options });
+                            }
                             return;
                         }
                         if (choice === "2") {
@@ -2383,16 +2386,22 @@ async function main() {
                     const bin = cliOnPath("grok") ?? die("grok is not on PATH here");
                     console.error(D("opening grok…"));
                     const { spawnSync } = await import("node:child_process");
-                    spawnSync(bin, [hud.prompt], { stdio: "inherit" });
+                    {
+                        const sp = agentSpawn(bin, [hud.prompt]);
+                        spawnSync(sp.command, sp.args, { stdio: "inherit", ...sp.options });
+                    }
                     return;
                 }
                 if (hud.prompt) {
                     const agent = pickExplainAgent(hud.tool ?? p.agent.primary_surface, detectAvailable());
                     if (!agent)
-                        die("no agent CLI found on this machine (claude, cursor-agent, or codex)");
+                        die("no agent CLI found on this machine (claude, cursor-agent, codex, or copilot)");
                     console.error(D(`opening ${agent.id}…`));
                     const { spawnSync } = await import("node:child_process");
-                    spawnSync(agent.binary, launchArgs(agent.id, hud.prompt, sessionName(hud.prompt)), { stdio: "inherit" });
+                    {
+                        const sp = agentSpawn(agent.binary, launchArgs(agent.id, hud.prompt, sessionName(hud.prompt)));
+                        spawnSync(sp.command, sp.args, { stdio: "inherit", ...sp.options });
+                    }
                     return;
                 }
                 if (hud.decision)
@@ -2412,10 +2421,13 @@ async function main() {
             }
             const agent = pickExplainAgent(loadProfile(cfg).agent.primary_surface, detectAvailable());
             if (!agent)
-                die("no agent CLI found on this machine (claude, cursor-agent, or codex)");
+                die("no agent CLI found on this machine (claude, cursor-agent, codex, or copilot)");
             console.error(D(`opening ${agent.id} with the question…`));
             const { spawnSync } = await import("node:child_process");
-            spawnSync(agent.binary, launchArgs(agent.id, prompt, sessionName(prompt)), { stdio: "inherit" });
+            {
+                const sp = agentSpawn(agent.binary, launchArgs(agent.id, prompt, sessionName(prompt)));
+                spawnSync(sp.command, sp.args, { stdio: "inherit", ...sp.options });
+            }
             return;
         }
         case "approvals": {

package/dist/config.js

@@ -28,12 +28,37 @@ export function normalizeOrigin(url) {
         const p = new URL(u.includes("://") ? u : `ssh://${u}`);
         const host = p.hostname.toLowerCase();
         const path = p.pathname.replace(/^\/+/, "").replace(/\.git\/?$/, "").replace(/\/+$/, "").toLowerCase();
-        return host && path ? `${host}/${path}` : null;
+        if (!host || !path)
+            return null;
+        const [h, q] = sameRepo(host, path);
+        return `${h}/${q}`;
     }
     catch {
         return null;
     }
 }
+const PUBLIC_HOSTS = new Set(["github.com", "gitlab.com", "bitbucket.org"]);
+function sameRepo(host, path) {
+    let m;
+    if (host === "ssh.dev.azure.com" || host === "vs-ssh.visualstudio.com") {
+        if ((m = /^v3\/([^/]+)\/([^/]+)\/([^/]+)$/.exec(path)))
+            return ["dev.azure.com", `${m[1]}/${m[2]}/${m[3]}`];
+    }
+    else if (host === "dev.azure.com") {
+        if ((m = /^([^/]+)\/([^/]+)\/_git\/([^/]+)$/.exec(path)))
+            return [host, `${m[1]}/${m[2]}/${m[3]}`];
+    }
+    else if ((m = /^([^./]+)\.visualstudio\.com$/.exec(host))) {
+        const org = m[1];
+        if ((m = /^(?:defaultcollection\/)?([^/]+)\/_git\/([^/]+)$/.exec(path)))
+            return ["dev.azure.com", `${org}/${m[1]}/${m[2]}`];
+    }
+    else if (!PUBLIC_HOSTS.has(host)) {
+        if ((m = /^(?:[^/]+\/)*scm\/([^/]+\/[^/]+)$/.exec(path)))
+            return [host, m[1]];
+    }
+    return [host, path];
+}
 const repoCache = new Map();
 export function repoInfo(dir = process.cwd()) {
     const key = resolve(dir);

package/dist/doctor.js

@@ -13,6 +13,8 @@ import { approvalSummary, chosenApproval, onPath } from "./install.js";
 import { hookState, readIntent, agentHookStates } from "./notify.js";
 import { loadPersonas } from "./persona.js";
 import { workerProc, menubarProc, notifierProc } from "./machine.js";
+import { chooseAgent, describeChoice } from "./agents.js";
+import { onPathNamed } from "./which.js";
 import { VERSION } from "./version.js";
 import { serviceInstalled } from "./service.js";
 import { hostEnv } from "./host-env.js";
@@ -134,10 +136,28 @@ export async function doctor(projectDir) {
         if (branch)
             add("pass", "git branch", branch);
     }
-    const agents = ["claude", "codex", "cursor-agent"].filter((a) => sh(`command -v ${a}`));
+    const agents = ["claude", "codex", "cursor-agent", "copilot"].filter((a) => onPathNamed(a));
     agents.length
         ? add("pass", "agent cli", agents.join(", "), undefined, agents.join(", "))
-        : add("warn", "agent cli", "found none of claude / codex / cursor-agent on PATH", "fine if you only drive agents through a GUI (Conductor, Cursor), but `pantheon worker` needs a CLI to spawn", "none of claude / codex / cursor-agent on PATH");
+        : add("warn", "agent cli", "found none of claude / codex / cursor-agent / copilot on PATH", "fine if you only drive agents through a GUI (Conductor, Cursor, VS Code), but `pantheon worker` needs a CLI to spawn", "none of claude / codex / cursor-agent / copilot on PATH");
+    if (agents.length) {
+        try {
+            const choice = chooseAgent("auto", { prefer: prof.agent.primary_surface });
+            const line = describeChoice(choice);
+            const bad = choice.signIn && !choice.signIn.ok && !choice.signIn.unknown;
+            const fellBack = !!prof.agent.primary_surface && choice.backend.id !== prof.agent.primary_surface && agents.length > 0;
+            const shareLine = `${choice.backend.label} — ${choice.signIn?.detail ?? "not checked"}${choice.skipped.length ? `; ${choice.skipped.length} skipped (not signed in)` : ""}`;
+            if (bad)
+                add("warn", "worker agent", line, `nothing is signed in, so every woken run here fails until you sign in: ${choice.skipped.map((x) => x.why).join("; ") || "sign in to the agent CLI"}`, shareLine);
+            else if (fellBack)
+                add("warn", "worker agent", line, `you chose ${prof.agent.primary_surface} at setup; runs use ${choice.backend.label} until it is signed in again`, shareLine);
+            else
+                add("pass", "worker agent", line, undefined, shareLine);
+        }
+        catch (e) {
+            add("warn", "worker agent", e.message, "pantheon setup --agent <claude-code|codex|cursor|copilot> names one that is installed", "could not be chosen");
+        }
+    }
     const budget = instructionBudget(cfg);
     const budgetLine = `${budget.chars} chars (~${budget.tokens} tokens) of session instructions per turn; the ${budget.protocolChars}-char protocol arrives with the first tool call instead`;
     add(budget.chars > 1_200 ? "warn" : "pass", "mcp context", budgetLine, budget.chars > 1_200 ? "this used to be ~3,800 chars on every turn, and it competed with the work people asked for" : undefined, budgetLine);
@@ -259,7 +279,7 @@ export async function doctor(projectDir) {
         }
     }
     if (!hookStates.length && !hook.installed) {
-        add("warn", "wake-up hook", "not installed — your agent will not notice a peer's message until you ask it to", "pantheon hook install --user (auto-detects claude / codex / cursor on PATH)", "not installed");
+        add("warn", "wake-up hook", "not installed — your agent will not notice a peer's message until you ask it to", "pantheon hook install --user (auto-detects claude / codex / cursor / copilot on PATH)", "not installed");
     }
     else if (!reportsActivity) {
         add("warn", "wake-up hook", `installed (${hook.events?.join(", ")}) but predates the activity hook, so a worker cannot tell your idle editor from one you are using`, "re-run `pantheon hook install --user` to add the UserPromptSubmit half", `installed (${hook.events?.join(", ")}), predates the activity hook`);