@join-pantheon/cli 0.25.3 → 0.26.0

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/dist/agents.js

@@ -1,17 +1,33 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, dirname } from "node:path";
+import { join, dirname, isAbsolute } from "node:path";
 import { launcher } from "./install.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;
@@ -35,6 +51,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");
@@ -79,21 +100,95 @@ 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 out = execFileSync(binary, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 8_000, env: { ...process.env, NO_COLOR: "1" } });
+        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 +254,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 +306,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

@@ -427,6 +427,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 +486,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 +499,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 +1316,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 +1345,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 +1373,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 +1447,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 +1556,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 +2006,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");
@@ -2389,7 +2388,7 @@ async function main() {
                 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" });
@@ -2412,7 +2411,7 @@ 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" });

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,7 @@ 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 { VERSION } from "./version.js";
 import { serviceInstalled } from "./service.js";
 import { hostEnv } from "./host-env.js";
@@ -134,10 +135,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) => sh(`command -v ${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 +278,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`);

package/dist/hooks-install.js

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync } from "node
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { HOOK_MARKER, MAX_CONSECUTIVE_BLOCKS } from "./notify.js";
+import { copilotHome } from "./agents.js";
 function ours(cmd) {
     return !!cmd?.includes(HOOK_MARKER);
 }
@@ -189,4 +190,61 @@ export function removeCursorHooks(projectDir = process.cwd()) {
     }
     return out;
 }
+export function copilotHooksPath(scope, projectDir = process.cwd()) {
+    return scope === "user"
+        ? join(copilotHome(), "hooks", "pantheon.json")
+        : join(projectDir, ".github", "hooks", "pantheon.json");
+}
+function copilotEvents(bin) {
+    return {
+        agentStop: `${bin} hook copilot-stop`,
+        userPromptSubmitted: `${bin} hook prompt`,
+        sessionEnd: `${bin} hook end`,
+    };
+}
+export function copilotHookState(scope, projectDir = process.cwd()) {
+    const file = copilotHooksPath(scope, projectDir);
+    const doc = readJson(file);
+    if (!doc?.hooks)
+        return { agent: "copilot", label: "Copilot", installed: false };
+    const events = [];
+    for (const [event, entries] of Object.entries(doc.hooks)) {
+        if ((entries ?? []).some((h) => ours(h.command) || ours(h.bash)))
+            events.push(event);
+    }
+    return events.length
+        ? { agent: "copilot", label: "Copilot", installed: true, scope, file, events }
+        : { agent: "copilot", label: "Copilot", installed: false };
+}
+export function installCopilotHooks(bin, scope, projectDir = process.cwd()) {
+    const file = copilotHooksPath(scope, projectDir);
+    const existed = existsSync(file);
+    const events = copilotEvents(bin);
+    const doc = { version: 1, hooks: {} };
+    for (const [event, cmd] of Object.entries(events)) {
+        doc.hooks[event] = [{ type: "command", command: cmd, timeoutSec: 10, timeout: 10 }];
+    }
+    writeJson(file, doc);
+    return [
+        `  ${existed ? "updated" : "installed"}  ${file}`,
+        `  runs       ${events.agentStop}`,
+        `             ${events.userPromptSubmitted}`,
+        `             ${events.sessionEnd}`,
+        `  ${""}(read by Copilot CLI and by Copilot in VS Code${scope === "project" ? "; repo-level hooks run once the folder is trusted" : ""})`,
+    ];
+}
+export function removeCopilotHooks(projectDir = process.cwd()) {
+    const out = [];
+    for (const scope of ["project", "user"]) {
+        const file = copilotHooksPath(scope, projectDir);
+        if (!copilotHookState(scope, projectDir).installed)
+            continue;
+        try {
+            rmSync(file, { force: true });
+            out.push(`  removed ${file}`);
+        }
+        catch { }
+    }
+    return out;
+}
 //# sourceMappingURL=hooks-install.js.map

package/dist/install.js

@@ -1,6 +1,6 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { execFileSync } from "node:child_process";
-import { homedir } from "node:os";
+import { homedir, platform } from "node:os";
 import { join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { grantToolPermissions, claudeSettingsFile, cursorCliConfigFile } from "./grants.js";
@@ -23,26 +23,52 @@ export function launcher(force) {
         ? { command: "pantheon", args: ["mcp"], portable: true }
         : { command: process.execPath, args: [resolve(HERE, "cli.js"), "mcp"], portable: false };
 }
-function mergeMcpJson(file, entry) {
-    let doc = {};
-    if (existsSync(file)) {
-        try {
-            doc = JSON.parse(readFileSync(file, "utf8"));
-        }
-        catch {
-            throw new Error(`${file} is not valid JSON — fix or move it, then re-run`);
-        }
+function readConfigJson(file) {
+    if (!existsSync(file))
+        return {};
+    const text = readFileSync(file, "utf8");
+    if (!text.trim())
+        return {};
+    try {
+        const doc = JSON.parse(text);
+        if (doc && typeof doc === "object" && !Array.isArray(doc))
+            return doc;
     }
+    catch { }
+    throw new Error(`${file} is not valid JSON — fix or move it, then re-run`);
+}
+function mergeMcpJson(file, entry, shape = {}) {
+    const doc = readConfigJson(file);
     const existed = existsSync(file);
     doc.mcpServers ??= {};
     const before = JSON.stringify(doc.mcpServers["pantheon"] ?? null);
-    doc.mcpServers["pantheon"] = { ...entry, env: {} };
+    doc.mcpServers["pantheon"] = { ...shape, ...entry, env: {} };
     if (before === JSON.stringify(doc.mcpServers["pantheon"]))
         return "unchanged";
     mkdirSync(dirname(file), { recursive: true });
     writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
     return existed ? "updated" : "created";
 }
+export const COPILOT_ENTRY_SHAPE = { type: "local", tools: ["*"] };
+export function mergeVsCodeMcpJson(file, entry) {
+    const doc = readConfigJson(file);
+    const existed = existsSync(file);
+    doc.servers ??= {};
+    const before = JSON.stringify(doc.servers["pantheon"] ?? null);
+    doc.servers["pantheon"] = { type: "stdio", command: entry.command, args: entry.args };
+    if (before === JSON.stringify(doc.servers["pantheon"]))
+        return "unchanged";
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
+    return existed ? "updated" : "created";
+}
+export const copilotMcpConfigFile = (home = homedir(), env = process.env) => join(env.COPILOT_HOME || join(home, ".copilot"), "mcp-config.json");
+export function vsCodeUserDir(home = homedir(), os = platform(), env = process.env) {
+    const dir = os === "darwin" ? join(home, "Library", "Application Support", "Code", "User")
+        : os === "win32" ? join(env.APPDATA || join(home, "AppData", "Roaming"), "Code", "User")
+            : join(env.XDG_CONFIG_HOME || join(home, ".config"), "Code", "User");
+    return existsSync(dir) ? dir : null;
+}
 const BRIEF_MARK = "<!-- pantheon:begin -->";
 function brief(cfg) {
     return `${BRIEF_MARK}
@@ -95,14 +121,19 @@ export function install(projectDir, cfg, force) {
     const out = [];
     const l = launcher(force);
     const entry = { command: l.command, args: l.args };
-    out.push(`  .mcp.json                 ${mergeMcpJson(join(projectDir, ".mcp.json"), entry)}   (claude code, conductor)`);
+    out.push(`  .mcp.json                 ${mergeMcpJson(join(projectDir, ".mcp.json"), entry)}   (claude code, conductor, copilot cli)`);
     out.push(`  .cursor/mcp.json          ${mergeMcpJson(join(projectDir, ".cursor", "mcp.json"), entry)}   (cursor)`);
+    const vscodeDir = join(projectDir, ".vscode");
+    out.push(existsSync(vscodeDir) || vsCodeUserDir()
+        ? `  .vscode/mcp.json          ${mergeVsCodeMcpJson(join(vscodeDir, "mcp.json"), entry)}   (copilot in vs code)`
+        : `  .vscode/mcp.json          ${"skipped".padEnd(9)} no .vscode/ here and no VS Code on this machine   (a VS Code user runs pantheon install --user)`);
     for (const f of ["CLAUDE.md", "AGENTS.md"]) {
         const p = join(projectDir, f);
         if (existsSync(p) || f === "AGENTS.md")
             out.push(`  ${f.padEnd(25)} ${upsertBrief(p, cfg)}   (the collaboration brief)`);
     }
     out.push("");
+    out.push("  Copilot asks once to trust this folder before it reads the repo's MCP servers and hooks.");
     out.push("  Codex reads ~/.codex/config.toml, which `pantheon join` already wrote at user scope.");
     out.push("  If you need it by hand, this is the block (absolute path so a GUI launch finds it):");
     out.push("");
@@ -172,11 +203,44 @@ function cursorUserScope(entry) {
         return { tool: "cursor", where: file, status: `failed: ${e.message}` };
     }
 }
+function copilotUserScope(entry) {
+    const tool = "copilot";
+    const file = copilotMcpConfigFile();
+    let present = existsSync(dirname(file));
+    if (!present) {
+        try {
+            execFileSync("sh", ["-lc", "command -v copilot"], { stdio: "ignore" });
+            present = true;
+        }
+        catch { }
+    }
+    if (!present)
+        return { tool, where: "-", status: "skipped (copilot not on PATH)" };
+    try {
+        return { tool, where: file, status: mergeMcpJson(file, entry, COPILOT_ENTRY_SHAPE) };
+    }
+    catch (e) {
+        return { tool, where: file, status: `failed: ${e.message}` };
+    }
+}
+function vsCodeUserScope(entry) {
+    const tool = "vs code";
+    const dir = vsCodeUserDir();
+    if (!dir)
+        return { tool, where: "-", status: "skipped (VS Code not found)" };
+    const file = join(dir, "mcp.json");
+    try {
+        return { tool, where: file, status: mergeVsCodeMcpJson(file, entry) };
+    }
+    catch (e) {
+        return { tool, where: file, status: `failed: ${e.message}` };
+    }
+}
 export const CODEX_APPROVAL_LINE = `default_tools_approval_mode = "approve"`;
 export function approvalSummary(approval) {
     return approval === "ask-before-sending"
         ? `your agent asks you before each send, goal or claim in your name; reading and waiting run without a prompt. Unattended runs keep their own per-run approvals — this governs the agent you sit in front of`
-        : `pantheon's ${PANTHEON_TOOL_NAMES.length} tools run without a per-call prompt in Claude Code, Cursor and Codex — your agent coordinates for you without stopping to ask`;
+        : `pantheon's ${PANTHEON_TOOL_NAMES.length} tools run without a per-call prompt in Claude Code, Cursor and Codex — your agent coordinates for you without stopping to ask. Copilot has no allow-list file: it asks once per tool per folder and remembers your answer`;
 }
 export function codexTomlBlock(entry, env = { PANTHEON_AGENT: "codex" }, approval = "approve") {
     const envToml = Object.entries(env)
@@ -374,6 +438,7 @@ export function installForUser(approval = chosenApproval()) {
     const entry = userEntry();
     return [
         claudeUserScope(entry), cursorUserScope(entry), codexUserScope(entry, approval),
+        copilotUserScope(entry), vsCodeUserScope(entry),
         ...grantToolPermissions(approval).map((g) => ({
             tool: g.tool,
             where: g.tool.startsWith("claude") ? claudeSettingsFile() : cursorCliConfigFile(),

package/dist/machine.js

@@ -4,6 +4,7 @@ import { homedir, platform } from "node:os";
 import { join } from "node:path";
 import { CONFIG_DIR } from "./config.js";
 import { plistPath } from "./service.js";
+import { copilotMcpConfigFile, vsCodeUserDir } from "./install.js";
 const sh = (cmd) => {
     try {
         return execFileSync("sh", ["-lc", cmd], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
@@ -109,6 +110,16 @@ export function wiring() {
         tool: "codex",
         state: existsSync(codex) && /\[mcp_servers\.pantheon\]/.test(readFileSync(codex, "utf8")) ? "wired" : "not wired",
     });
+    const copilot = copilotMcpConfigFile();
+    out.push({
+        tool: "copilot",
+        state: existsSync(copilot) && /"pantheon"/.test(readFileSync(copilot, "utf8")) ? "wired" : "not wired",
+    });
+    const vscodeDir = vsCodeUserDir();
+    if (vscodeDir) {
+        const f = join(vscodeDir, "mcp.json");
+        out.push({ tool: "vs code", state: existsSync(f) && /"pantheon"/.test(readFileSync(f, "utf8")) ? "wired" : "not wired" });
+    }
     return out;
 }
 export function logFileFor(kind, proc) {

package/dist/measure.js

@@ -3,7 +3,9 @@ import { existsSync } from "node:fs";
 import { resolve, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { claudeGrantedEffective, cursorGrantedEffective, claudeAllow, cursorAllow, isServerWide } from "./grants.js";
-import { codexApprovalState } from "./install.js";
+import { codexApprovalState, copilotMcpConfigFile } from "./install.js";
+import { existsSync as fileExists, readFileSync } from "node:fs";
+import { dirname as dirOf } from "node:path";
 import { PANTHEON_TOOL_NAMES, WRITE_TOOL_NAMES } from "./tools.js";
 const ROOT = process.env.PANTHEON_MCP_ROOT ?? resolve(dirname(fileURLToPath(import.meta.url)), "..");
 export const HOST_STARTUP_ALLOWANCE_MS = 10_000;
@@ -157,12 +159,24 @@ export function toolsReport(registered, seen, approval, opts = {}) {
             problems.push("Codex's per-tool overrides do not match your choice");
         }
     }
-    const detail = `${head}; ${claude.text}, ${cursor.text}, ${codex}`;
+    const copilot = seen.copilot === undefined || seen.copilot === null ? null
+        : seen.copilot ? "Copilot wired (it asks once per tool per folder and remembers)" : "Copilot has no pantheon entry";
+    const detail = `${head}; ${claude.text}, ${cursor.text}, ${codex}${copilot ? `, ${copilot}` : ""}`;
     if (!problems.length)
         return { level: "pass", detail };
     return { level: "warn", detail, fix: `${problems.join("; ")} — pantheon install --user rewrites every grant in your own settings to match this build and your approval choice; a rule in this repo's .claude/settings*.json or .cursor/cli.json is yours to edit by hand` };
 }
 export function grantsSeen(projectDir = null) {
-    return { claude: claudeGrantedEffective(projectDir), cursor: cursorGrantedEffective(projectDir), codex: codexApprovalState() };
+    return { claude: claudeGrantedEffective(projectDir), cursor: cursorGrantedEffective(projectDir), codex: codexApprovalState(), copilot: copilotWired() };
+}
+export function copilotWired(file = copilotMcpConfigFile()) {
+    if (!fileExists(dirOf(file)))
+        return null;
+    try {
+        return fileExists(file) && /"pantheon"/.test(readFileSync(file, "utf8"));
+    }
+    catch {
+        return false;
+    }
 }
 //# sourceMappingURL=measure.js.map

package/dist/notice.js

@@ -1,10 +1,11 @@
 import { decisionPrompt, decisionTitle } from "./decision-ui.js";
-export const TOOL_LABELS = { "claude-code": "Claude Code", codex: "Codex", cursor: "Cursor", grok: "Grok" };
+export const TOOL_LABELS = { "claude-code": "Claude Code", codex: "Codex", cursor: "Cursor", copilot: "Copilot", grok: "Grok" };
 export const APP_TOOLS = [
     { id: "cursor-app", label: "Cursor app", kind: "app", bundle: "com.todesktop.230313mzl4w4u92", deeplink: "cursor://anysphere.cursor-deeplink/prompt?text={prompt}" },
     { id: "claude-app", label: "Claude app · question copied", kind: "app", bundle: "com.anthropic.claudefordesktop" },
     { id: "chatgpt-app", label: "ChatGPT app · question copied", kind: "app", bundle: "com.openai.chat" },
     { id: "codex-app", label: "Codex app · question copied", kind: "app", bundle: "com.openai.codex" },
+    { id: "vscode-app", label: "VS Code · question copied", kind: "app", bundle: "com.microsoft.VSCode" },
 ];
 export const BUDGET = { who: 60, heading: 40, context: 70, body: 190 };
 const oneLine = (s) => s.replace(/\s+/g, " ").trim();
@@ -64,6 +65,8 @@ const agentLabel = (agent) => {
         return "Codex";
     if (a.includes("cursor"))
         return "Cursor";
+    if (a.includes("copilot"))
+        return "Copilot";
     return null;
 };
 function whoLine(from, agent, ts, now) {

package/dist/notifier.js

@@ -99,6 +99,7 @@ export function installedTools() {
             "claude-app": ["/Applications/Claude.app", join(homedir(), "Applications", "Claude.app")],
             "chatgpt-app": ["/Applications/ChatGPT.app", join(homedir(), "Applications", "ChatGPT.app")],
             "codex-app": ["/Applications/Codex.app", join(homedir(), "Applications", "Codex.app")],
+            "vscode-app": ["/Applications/Visual Studio Code.app", join(homedir(), "Applications", "Visual Studio Code.app")],
         };
         for (const t of APP_TOOLS)
             if ((APP_PATHS[t.id] ?? []).some((p) => existsSync(p)))

package/dist/notify.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { whichPantheon } from "./service.js";
 import { detectForHooks, agentById } from "./agents.js";
-import { codexHookState, cursorHookState, installCodexHooks, installCursorHooks, removeCodexHooks, removeCursorHooks, } from "./hooks-install.js";
+import { codexHookState, cursorHookState, copilotHookState, installCodexHooks, installCursorHooks, installCopilotHooks, removeCodexHooks, removeCursorHooks, removeCopilotHooks, } from "./hooks-install.js";
 export const HOOK_MARKER = "pantheon hook";
 export function settingsPath(scope, projectDir = process.cwd()) {
     return scope === "user"
@@ -93,6 +93,9 @@ export function agentHookStates(projectDir = process.cwd(), only) {
         const cursor = cursorHookState(scope, projectDir);
         if (cursor.installed)
             out.push(cursor);
+        const copilot = copilotHookState(scope, projectDir);
+        if (copilot.installed)
+            out.push(copilot);
     }
     const byAgent = new Map();
     for (const s of out) {
@@ -116,6 +119,8 @@ export function repairHook(home) {
             missing.push(id);
         if (id === "cursor" && !cursorHookState(intent.scope, projectDir).installed)
             missing.push(id);
+        if (id === "copilot" && !copilotHookState(intent.scope, projectDir).installed)
+            missing.push(id);
     }
     if (!missing.length)
         return null;
@@ -165,7 +170,7 @@ export function installHooks(scope, projectDir = process.cwd(), only) {
         ? only.map((id) => agentById(id)).filter((b) => !!b)
         : available;
     if (!pick.length) {
-        throw new Error("no agent found — install claude, codex, or cursor-agent, or open a project that already uses one");
+        throw new Error("no agent found — install claude, codex, cursor-agent, or copilot, or open a project that already uses one");
     }
     const lines = [];
     const agents = [];
@@ -183,6 +188,10 @@ export function installHooks(scope, projectDir = process.cwd(), only) {
             lines.push(...installCursorHooks(bin, scope, projectDir));
             agents.push("cursor");
         }
+        else if (backend.id === "copilot") {
+            lines.push(...installCopilotHooks(bin, scope, projectDir));
+            agents.push("copilot");
+        }
     }
     lines.push(`  effect     when your agent tries to finish, it checks whether a peer is waiting`, `             on you — and keeps going instead of leaving them hanging.`, `             it also reports when a turn starts and ends, so a worker can tell`, `             an idle editor from one you are actually using.`);
     return { lines, agents };
@@ -195,6 +204,7 @@ export function removeHook(projectDir = process.cwd()) {
     out.push(...removeClaudeHook(projectDir));
     out.push(...removeCodexHooks(projectDir));
     out.push(...removeCursorHooks(projectDir));
+    out.push(...removeCopilotHooks(projectDir));
     return out.length ? out : ["  nothing installed"];
 }
 function removeClaudeHook(projectDir = process.cwd()) {

package/dist/persona.js

@@ -170,7 +170,7 @@ export const PERSONA_TEMPLATE = `---
 # wake_by: alice, bob          # only these peers' requests are handled by this persona
 # kinds: ANSWER, ACCEPT        # ANSWER (asks), ACCEPT (verdicts), REVISE (objections), CONTINUE (replies/deliveries)
 # goals: launch-*              # only goals whose id or title matches
-# agent: auto                  # claude-code | codex | cursor | auto
+# agent: auto                  # claude-code | codex | cursor | copilot | auto
 ---
 Say how this worker should behave when it is woken while you are away — what it
 should take on, what it should refuse, and where its judgment ends and yours

package/dist/profile.js

@@ -1,11 +1,12 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { CONFIG_DIR } from "./config.js";
-export const AGENT_SURFACES = ["codex", "claude-code", "cursor"];
+export const AGENT_SURFACES = ["codex", "claude-code", "cursor", "copilot"];
 export const SURFACE_BUNDLE_IDS = {
     codex: "com.openai.codex",
     "claude-code": "com.anthropic.claudefordesktop",
     cursor: "com.todesktop.230313mzl4w4u92",
+    copilot: "com.microsoft.VSCode",
 };
 export const profilePath = (home = CONFIG_DIR) => join(home, "profile.json");
 export function isAgentSurface(value) {
@@ -14,6 +15,8 @@ export function isAgentSurface(value) {
 export function surfaceFromAgent(agent) {
     if (agent && /cursor/i.test(agent))
         return "cursor";
+    if (agent && /copilot/i.test(agent))
+        return "copilot";
     if (agent && /claude/i.test(agent))
         return "claude-code";
     return "codex";

package/dist/run-failure.js

@@ -1,4 +1,11 @@
 import { execFileSync } from "node:child_process";
+export const AUTH_RE = /not (?:logged|signed) in|not authenticated|no (?:github )?(?:authentication|credentials?|token) (?:found|available)|login required|please (?:log|sign) in|run .*login|invalid api key|unauthori[sz]ed|authentication (?:failed|required)|\b401\b|expired (?:token|session)/i;
+export const SIGN_IN_FIX = {
+    "claude-code": "run `claude`, then /login",
+    codex: "run `codex login`",
+    cursor: "run `cursor-agent login`",
+    copilot: "run `copilot login` (or `gh auth login` — copilot uses gh's sign-in too)",
+};
 const sh = (dir, ...args) => execFileSync("git", ["-C", dir, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5_000 }).trim();
 export const gitProbe = {
     isRepo: (dir) => { try {
@@ -42,6 +49,14 @@ catch {
     return fallback;
 } };
 export function diagnoseRun(f, probe = gitProbe) {
+    if (!f.exited && AUTH_RE.test(f.detail)) {
+        const fix = SIGN_IN_FIX[f.agent ?? ""] ?? "sign in to the agent CLI on this machine";
+        return {
+            cause: "not_signed_in",
+            says: `The agent could not start because nobody is signed in to it${f.agent ? ` (${f.agent})` : ""} — ${exitLine(f.detail)}.`,
+            fix: `Sign in once and the next run works: ${fix}. Until then every woken run on this machine fails the same way.`,
+        };
+    }
     if (!f.exited) {
         return {
             cause: "crashed",

package/dist/setup-guide.js

@@ -195,7 +195,7 @@ export async function runGuide(io, ctx, deps = {}, preset = {}) {
                     : "only people you approve by hand (pantheon admit <name> --may-wake)"}`);
         io.say(`  • Alerts: ${shortAlert(a.notifications).toLowerCase()}`);
         io.say(`  • Approval: ${a.approval === "approve"
-            ? "your agent sends to teammates in your name without asking each time (Claude Code, Cursor and Codex)"
+            ? "your agent sends to teammates in your name without asking each time (Claude Code, Cursor and Codex; Copilot asks once per tool per folder)"
             : "your agent asks you before each send, goal and claim; reading and waiting never prompt"}`);
         io.say(`  • Decisions: ${a.decides.length ? `you personally decide ${a.decides.join(", ")}` : "none reserved for you — your agent may decide; add an area when one comes up"}`);
         if (a.wake !== "no" && ctx.project)

package/dist/tray.js

@@ -144,7 +144,7 @@ async function trayStatusOne(cfg) {
     ];
     const profile = loadProfile(cfg);
     const surface = profile.agent.primary_surface;
-    const surfaceName = surface === "claude-code" ? "Claude" : surface === "cursor" ? "Cursor" : "Codex";
+    const surfaceName = surface === "claude-code" ? "Claude" : surface === "cursor" ? "Cursor" : surface === "copilot" ? "Copilot" : "Codex";
     const rawWorkerState = workerState();
     return {
         configured: true,

package/dist/worker.js

@@ -4,7 +4,7 @@ import { mkdirSync, writeFileSync, existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { PantheonClient } from "./client.js";
-import { headlessSpawn, materializeSpawnFiles, resolveAgent } from "./agents.js";
+import { headlessSpawn, materializeSpawnFiles, chooseAgent, describeChoice } from "./agents.js";
 import { VERSION } from "./version.js";
 import { applyAnswer, loadPolicy, mayAsk, needsSelfUpgrade, recordAsk, savePolicy, useGrant, } from "./worker-policy.js";
 import { agentHookStates, repairHook } from "./notify.js";
@@ -191,6 +191,7 @@ export function answerWindow(askSeq, hint, fullScanDue) {
 export class Worker {
     cfg;
     opts;
+    lastAgentSaid = "";
     running = false;
     done = [];
     stopped = false;
@@ -329,8 +330,7 @@ export class Worker {
         const agentLabel = this.opts.agentCmd
             ? this.opts.agentCmd
             : (() => { try {
-                const r = resolveAgent(this.opts.agent);
-                return `${r.backend.label} (${r.binary})`;
+                return describeChoice(chooseAgent(this.opts.agent, { prefer: loadProfile(this.cfg).agent.primary_surface }));
             }
             catch {
                 return "auto";
@@ -580,10 +580,12 @@ export class Worker {
         const startedAt = Date.now();
         writeFileSync(join(worktree, ".pantheon-task.md"), brief);
         let command;
+        let agentId;
         let args;
         let env = { ...process.env };
         try {
             const runHome = this.runHome();
+            agentId = this.opts.agentCmd ? "claude-code" : undefined;
             if (this.opts.agentCmd) {
                 const plan = headlessSpawn({
                     backend: { id: "claude-code", label: "Claude Code", binaries: ["claude"] },
@@ -594,8 +596,14 @@ export class Worker {
                 ({ command, args, env } = { command: plan.command, args: plan.args, env: { ...env, ...plan.env } });
             }
             else {
-                const { backend, binary } = resolveAgent(policy.agent ?? this.opts.agent);
-                const plan = headlessSpawn({ backend, binary, prompt: brief, worktree, cfg: this.cfg, branch, allowBash, runHome });
+                const choice = chooseAgent(policy.agent ?? this.opts.agent, { prefer: loadProfile(this.cfg).agent.primary_surface });
+                agentId = choice.backend.id;
+                const said = describeChoice(choice);
+                if (said !== this.lastAgentSaid) {
+                    this.opts.log(`  agent   ${said}`);
+                    this.lastAgentSaid = said;
+                }
+                const plan = headlessSpawn({ backend: choice.backend, binary: choice.binary, prompt: brief, worktree, cfg: this.cfg, branch, allowBash, runHome });
                 materializeSpawnFiles(worktree, plan);
                 ({ command, args, env } = { command: plan.command, args: plan.args, env: { ...env, ...plan.env } });
                 this.opts.log(`  spawn   ${command} ${args.slice(0, 3).join(" ")}…`);
@@ -629,7 +637,7 @@ export class Worker {
         }, this.opts.home);
         const sent = client.mineSince(startedAt, o.goal);
         const quiet = ok && !requireReply && sent.length === 0;
-        const diagnosis = ok ? undefined : diagnoseRun({ exited, replied, allowBash, branch, project: this.opts.project, worktree, detail, runLog }, this.opts.probe ?? gitProbe);
+        const diagnosis = ok ? undefined : diagnoseRun({ exited, replied, allowBash, branch, project: this.opts.project, worktree, detail, runLog, ...(agentId ? { agent: agentId } : {}) }, this.opts.probe ?? gitProbe);
         if (this.opts.notify && !quiet && (!ok || loadProfile(this.cfg).notifications?.worker_done)) {
             try {
                 const reply = sent[sent.length - 1] ?? null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@join-pantheon/cli",
-  "version": "0.25.3",
+  "version": "0.26.0",
   "description": "Let your coding agent collaborate directly with your teammates' agents — ask, agree an interface, and deliver, without a human relaying messages.",
   "type": "module",
   "bin": {