@sdods/agents 0.19.0 → 0.21.0

package/dist/adapter/copilot.d.ts

@@ -0,0 +1,45 @@
+import { type CliAdapterContext } from './cli-common.js';
+import { type AgentEvent, type CompleteRequest, type CompleteResult, type LlmAdapter, type RunAgentOptions, type RunAgentResult, type TokenUsage } from './types.js';
+/**
+ * Copilot tool permissions the agent never gets, whatever `--allow-all-tools` says (denials win).
+ * `shell` and `write` are Copilot's own kinds for commands and file edits; `url` covers its web
+ * fetches. The review-only sdods tools stay with a person.
+ */
+export declare const COPILOT_DENIED_TOOLS: string[];
+/**
+ * Copilot `--output-format json` events → SDODS events. Every payload sits under `data`
+ * (schema: `copilot-sdk/generated/session-events.d.ts`, Copilot CLI 1.0.105).
+ */
+export declare function normalizeCopilotEvent(ev: Record<string, any>): AgentEvent[];
+/** Sums the per-call `assistant.usage` events into one total. */
+export declare function addCopilotUsage(total: TokenUsage | undefined, d: Record<string, any>): TokenUsage;
+/**
+ * Runs SDODS agent roles through the user's logged-in GitHub Copilot CLI (`copilot -p
+ * --output-format json`). No API key: the Copilot subscription (or COPILOT_GITHUB_TOKEN / GH_TOKEN)
+ * pays. The sdods MCP server goes in with `--additional-mcp-config`; the built-in GitHub MCP
+ * servers are switched off, and shell, file writes and web fetches are denied.
+ *
+ * Copilot has no per-path read rule like Claude Code's `Read(**\/.env)`. Its file access is held to
+ * the working directory, so point `cwd` at the project and keep secrets out of it (`${VAR}`).
+ */
+export declare class CopilotCliAdapter implements LlmAdapter {
+    private readonly ctx;
+    readonly provider: "copilot";
+    readonly defaultModel: string;
+    constructor(ctx?: CliAdapterContext & {
+        model?: string;
+    });
+    /** Copilot has no non-interactive login check; a missing login shows up on the first call. */
+    bin(): string;
+    static loginStatus(bin?: string): {
+        installed: boolean;
+        loggedIn: boolean | null;
+        detail: string;
+    };
+    private baseArgs;
+    private denyArgs;
+    complete(req: CompleteRequest): Promise<CompleteResult>;
+    stream(req: CompleteRequest): AsyncIterable<string>;
+    runAgent(o: RunAgentOptions): Promise<RunAgentResult>;
+}
+//# sourceMappingURL=copilot.d.ts.map

package/dist/adapter/copilot.js

@@ -0,0 +1,257 @@
+import { mcpServerMap, requireCli, removeTempJson, runJsonl, runQuiet, writeTempJson, REVIEW_ONLY_TOOLS, } from './cli-common.js';
+import { cliFailure } from './claude-code.js';
+import { DEFAULT_MODELS, } from './types.js';
+const INSTALL_HINT = 'Install GitHub Copilot CLI (`npm i -g @github/copilot`) and run `copilot login`, or use --adapter claude-code, --adapter codex, or --dry-run.';
+/**
+ * Copilot tool permissions the agent never gets, whatever `--allow-all-tools` says (denials win).
+ * `shell` and `write` are Copilot's own kinds for commands and file edits; `url` covers its web
+ * fetches. The review-only sdods tools stay with a person.
+ */
+export const COPILOT_DENIED_TOOLS = [
+    'shell',
+    'write',
+    'url',
+    ...REVIEW_ONLY_TOOLS.map((t) => `sdods(${t})`),
+];
+/**
+ * Copilot `--output-format json` events → SDODS events. Every payload sits under `data`
+ * (schema: `copilot-sdk/generated/session-events.d.ts`, Copilot CLI 1.0.105).
+ */
+export function normalizeCopilotEvent(ev) {
+    const d = (ev.data ?? {});
+    switch (ev.type) {
+        case 'assistant.message':
+            // sub-agent chatter carries parentToolCallId; keep the transcript to the main agent
+            if (d.parentToolCallId || typeof d.content !== 'string' || !d.content)
+                return [];
+            return [{ type: 'text', text: d.content }];
+        case 'tool.execution_start':
+            return [
+                {
+                    type: 'tool_call',
+                    id: String(d.toolCallId),
+                    name: d.mcpServerName && d.mcpToolName
+                        ? `mcp__${d.mcpServerName}__${d.mcpToolName}`
+                        : String(d.toolName ?? 'tool'),
+                    input: d.arguments ?? null,
+                },
+            ];
+        case 'tool.execution_complete':
+            return [
+                {
+                    type: 'tool_result',
+                    id: String(d.toolCallId),
+                    output: d.result?.content ?? d.error?.message ?? null,
+                    isError: d.success === false,
+                },
+            ];
+        case 'session.error':
+            return [{ type: 'status', message: String(d.message ?? d.errorType ?? 'error') }];
+        case 'session.warning':
+            return d.message ? [{ type: 'status', message: String(d.message) }] : [];
+        default:
+            return [];
+    }
+}
+/** Sums the per-call `assistant.usage` events into one total. */
+export function addCopilotUsage(total, d) {
+    const add = (a, b) => (typeof b === 'number' ? (a ?? 0) + b : a);
+    return {
+        inputTokens: add(total?.inputTokens, d.inputTokens),
+        outputTokens: add(total?.outputTokens, d.outputTokens),
+        cacheReadTokens: add(total?.cacheReadTokens, d.cacheReadTokens),
+        cacheWriteTokens: add(total?.cacheWriteTokens, d.cacheWriteTokens),
+    };
+}
+/**
+ * Runs SDODS agent roles through the user's logged-in GitHub Copilot CLI (`copilot -p
+ * --output-format json`). No API key: the Copilot subscription (or COPILOT_GITHUB_TOKEN / GH_TOKEN)
+ * pays. The sdods MCP server goes in with `--additional-mcp-config`; the built-in GitHub MCP
+ * servers are switched off, and shell, file writes and web fetches are denied.
+ *
+ * Copilot has no per-path read rule like Claude Code's `Read(**\/.env)`. Its file access is held to
+ * the working directory, so point `cwd` at the project and keep secrets out of it (`${VAR}`).
+ */
+export class CopilotCliAdapter {
+    ctx;
+    provider = 'copilot';
+    defaultModel;
+    constructor(ctx = {}) {
+        this.ctx = ctx;
+        this.defaultModel = ctx.model ?? process.env.SDODS_COPILOT_MODEL ?? DEFAULT_MODELS.copilot;
+    }
+    /** Copilot has no non-interactive login check; a missing login shows up on the first call. */
+    bin() {
+        return requireCli(this.ctx.bin ?? 'copilot', INSTALL_HINT);
+    }
+    static loginStatus(bin = 'copilot') {
+        const found = (() => {
+            try {
+                return requireCli(bin, '');
+            }
+            catch {
+                return null;
+            }
+        })();
+        if (!found)
+            return { installed: false, loggedIn: null, detail: 'not installed' };
+        const v = runQuiet(found, ['--version']);
+        const token = Boolean(process.env.COPILOT_GITHUB_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_TOKEN);
+        return {
+            installed: true,
+            loggedIn: token ? true : null,
+            detail: `${v.stdout.trim().split('\n')[0] || 'installed'} · ${token ? 'token in environment' : 'login not verified (run `copilot login` once)'}`,
+        };
+    }
+    baseArgs(o) {
+        const m = o.model ?? this.defaultModel;
+        return [
+            '--output-format',
+            'json',
+            '--no-ask-user',
+            '--no-auto-update',
+            '--no-color',
+            '--disable-builtin-mcps',
+            ...(o.cwd ? ['-C', o.cwd] : []),
+            ...(m && m !== 'default' ? ['--model', m] : []),
+            ...(o.effort ? ['--reasoning-effort', o.effort] : []),
+        ];
+    }
+    denyArgs() {
+        return COPILOT_DENIED_TOOLS.flatMap((t) => ['--deny-tool', t]);
+    }
+    async complete(req) {
+        const bin = this.bin();
+        const prompt = req.system ? `${req.system}\n\n---\n\n${req.prompt}` : req.prompt;
+        let text = '';
+        let usage;
+        let costUsd;
+        let model;
+        const r = await runJsonl(bin, [
+            '-p',
+            prompt,
+            ...this.baseArgs({ model: req.model, effort: req.effort }),
+            '--available-tools',
+            '',
+            '--no-custom-instructions',
+        ], {
+            signal: req.signal,
+            onLine: (line) => {
+                if (typeof line !== 'object' || !line)
+                    return;
+                const ev = line;
+                if (ev.type === 'assistant.usage' && ev.data) {
+                    usage = addCopilotUsage(usage, ev.data);
+                    if (typeof ev.data.cost === 'number')
+                        costUsd = (costUsd ?? 0) + ev.data.cost;
+                    model = ev.data.model ?? model;
+                }
+                for (const e of normalizeCopilotEvent(ev))
+                    if (e.type === 'text')
+                        text += e.text;
+            },
+        });
+        if (r.exitCode !== 0 && !text)
+            throw cliFailure('copilot', r.exitCode, r.stderr);
+        return { text: text.trim(), usage, costUsd, model };
+    }
+    async *stream(req) {
+        const r = await this.complete(req);
+        yield r.text;
+    }
+    async runAgent(o) {
+        const bin = this.bin();
+        const servers = mcpServerMap({ ...this.ctx, rootDir: this.ctx.rootDir ?? o.cwd }, o.mcpServers);
+        // Copilot names stdio servers `local`; http stays `http`.
+        const copilotServers = Object.fromEntries(Object.entries(servers).map(([name, s]) => [
+            name,
+            { ...s, type: s.type === 'stdio' ? 'local' : s.type, tools: ['*'] },
+        ]));
+        const mcpFile = writeTempJson('sdods-copilot-', { mcpServers: copilotServers });
+        const args = [
+            '-p',
+            `${o.system}\n\n---\n\n${o.prompt}`,
+            ...this.baseArgs({ cwd: o.cwd, model: o.model }),
+            '--additional-mcp-config',
+            `@${mcpFile}`,
+            '--allow-all-tools',
+            ...this.denyArgs(),
+        ];
+        let text = '';
+        let turns = 0;
+        let toolCalls = 0;
+        let usage;
+        let costUsd;
+        let exitCode;
+        let sessionError = false;
+        let stoppedAtMaxTurns = false;
+        const controller = new AbortController();
+        const onAbort = () => controller.abort();
+        o.signal?.addEventListener('abort', onAbort, { once: true });
+        const r = await runJsonl(bin, args, {
+            cwd: o.cwd,
+            signal: controller.signal,
+            onLine: (line) => {
+                if (typeof line !== 'object' || !line)
+                    return;
+                const ev = line;
+                if (ev.type === 'assistant.turn_end') {
+                    turns++;
+                    if (o.maxTurns && turns >= o.maxTurns && !stoppedAtMaxTurns) {
+                        stoppedAtMaxTurns = true;
+                        o.onEvent?.({ type: 'status', message: `max turns (${o.maxTurns}) reached` });
+                        controller.abort();
+                    }
+                }
+                if (ev.type === 'assistant.usage' && ev.data) {
+                    usage = addCopilotUsage(usage, ev.data);
+                    if (typeof ev.data.cost === 'number')
+                        costUsd = (costUsd ?? 0) + ev.data.cost;
+                }
+                if (ev.type === 'session.error')
+                    sessionError = true;
+                if (ev.type === 'result' && typeof ev.exitCode === 'number')
+                    exitCode = ev.exitCode;
+                for (const e of normalizeCopilotEvent(ev)) {
+                    if (e.type === 'tool_call')
+                        toolCalls++;
+                    if (e.type === 'text')
+                        text += text ? `\n\n${e.text}` : e.text;
+                    o.onEvent?.(e);
+                }
+            },
+        }).finally(() => {
+            o.signal?.removeEventListener('abort', onAbort);
+            removeTempJson(mcpFile);
+        });
+        const code = exitCode ?? r.exitCode;
+        const isError = !stoppedAtMaxTurns && (sessionError || code !== 0);
+        if (isError && !text)
+            throw cliFailure('copilot', code, r.stderr);
+        if (o.maxBudgetUsd && costUsd && costUsd > o.maxBudgetUsd) {
+            o.onEvent?.({
+                type: 'status',
+                message: `budget exceeded: $${costUsd.toFixed(3)} > $${o.maxBudgetUsd}`,
+            });
+        }
+        const result = {
+            text,
+            usage,
+            costUsd,
+            turns: Math.max(turns, 1),
+            stopReason: stoppedAtMaxTurns ? 'max_turns' : isError ? 'error' : 'end',
+            isError,
+            toolCalls,
+        };
+        o.onEvent?.({
+            type: 'result',
+            usage,
+            costUsd,
+            turns: result.turns,
+            stopReason: result.stopReason,
+            isError,
+        });
+        return result;
+    }
+}
+//# sourceMappingURL=copilot.js.map

package/dist/adapter/factory.d.ts

@@ -20,7 +20,7 @@ export interface CreateAdapterOptions {
 export declare function normalizeProvider(raw: string): Provider;
 /**
  * Detection order when nothing is set explicitly:
- * ANTHROPIC_API_KEY → `claude` CLI → `codex` CLI → OPENAI_API_KEY → Ollama → fake.
+ * ANTHROPIC_API_KEY → `claude` CLI → `codex` CLI → `copilot` CLI → OPENAI_API_KEY → Ollama → fake.
  *
  * A key or a CLI login is a deliberate statement of intent, so those come first; an installed
  * Ollama still beats `fake`, which produces nothing. Detection is synchronous and must not touch

package/dist/adapter/factory.js

@@ -2,6 +2,7 @@ import { ClaudeAdapter } from './claude.js';
 import { ClaudeCodeCliAdapter } from './claude-code.js';
 import { findOnPath } from './cli-common.js';
 import { CodexCliAdapter } from './codex.js';
+import { CopilotCliAdapter } from './copilot.js';
 import { FakeAdapter } from './fake.js';
 import { OllamaAdapter } from './ollama.js';
 import { OpenAiCompatibleAdapter } from './openai-compat.js';
@@ -14,6 +15,8 @@ export function normalizeProvider(raw) {
         return 'claude-code';
     if (p === 'codex' || p === 'codex-cli' || p === 'openai-codex')
         return 'codex';
+    if (p === 'copilot' || p === 'copilot-cli' || p === 'github-copilot' || p === 'gh-copilot')
+        return 'copilot';
     if (p === 'ollama' || p === 'local')
         return 'ollama';
     if (p === 'openai' ||
@@ -24,11 +27,11 @@ export function normalizeProvider(raw) {
         return 'openai-compatible';
     if (p === 'fake' || p === 'dry-run')
         return 'fake';
-    throw new AgentsConfigError(`Unknown LLM provider "${raw}".`, 'Use claude, claude-code, codex, openai-compatible, ollama or fake.');
+    throw new AgentsConfigError(`Unknown LLM provider "${raw}".`, 'Use claude, claude-code, codex, copilot, openai-compatible, ollama or fake.');
 }
 /**
  * Detection order when nothing is set explicitly:
- * ANTHROPIC_API_KEY → `claude` CLI → `codex` CLI → OPENAI_API_KEY → Ollama → fake.
+ * ANTHROPIC_API_KEY → `claude` CLI → `codex` CLI → `copilot` CLI → OPENAI_API_KEY → Ollama → fake.
  *
  * A key or a CLI login is a deliberate statement of intent, so those come first; an installed
  * Ollama still beats `fake`, which produces nothing. Detection is synchronous and must not touch
@@ -42,6 +45,8 @@ export function detectProvider(env = process.env) {
         return { provider: 'claude-code', reason: 'claude CLI found on PATH' };
     if (findOnPath('codex'))
         return { provider: 'codex', reason: 'codex CLI found on PATH' };
+    if (findOnPath('copilot'))
+        return { provider: 'copilot', reason: 'GitHub Copilot CLI found on PATH' };
     if (env.OPENAI_API_KEY)
         return { provider: 'openai-compatible', reason: 'OPENAI_API_KEY is set' };
     if (env.OLLAMA_HOST)
@@ -50,7 +55,7 @@ export function detectProvider(env = process.env) {
         return { provider: 'ollama', reason: 'ollama found on PATH' };
     return {
         provider: 'fake',
-        reason: 'no API key and no claude/codex CLI found; using the fake adapter',
+        reason: 'no API key and no claude/codex/copilot CLI found; using the fake adapter',
     };
 }
 /** Detection plus a short probe of the default Ollama host, for callers that can await. */
@@ -80,6 +85,8 @@ export function createAdapter(opts = {}, projectDefault) {
             return new ClaudeCodeCliAdapter(cliCtx);
         case 'codex':
             return new CodexCliAdapter(cliCtx);
+        case 'copilot':
+            return new CopilotCliAdapter(cliCtx);
         case 'openai-compatible':
             return new OpenAiCompatibleAdapter({
                 model: opts.model,

package/dist/adapter/index.d.ts

@@ -2,6 +2,7 @@ export * from './types.js';
 export * from './claude.js';
 export * from './claude-code.js';
 export * from './codex.js';
+export * from './copilot.js';
 export * from './cli-common.js';
 export * from './mcp-bridge.js';
 export * from './ollama.js';

package/dist/adapter/index.js

@@ -2,6 +2,7 @@ export * from './types.js';
 export * from './claude.js';
 export * from './claude-code.js';
 export * from './codex.js';
+export * from './copilot.js';
 export * from './cli-common.js';
 export * from './mcp-bridge.js';
 export * from './ollama.js';

package/dist/adapter/types.d.ts

@@ -1,10 +1,10 @@
 import type { AgentSdkToolDef } from '@sdods/mcp';
 /**
- * claude / openai-compatible: API keys. claude-code / codex: shell out to the user's logged-in
+ * claude / openai-compatible: API keys. claude-code / codex / copilot: shell out to the user's logged-in
  * CLI (no key needed). ollama: a model running on this machine, no key and no cost.
  * fake: scripted, for tests and --dry-run.
  */
-export type Provider = 'claude' | 'claude-code' | 'codex' | 'openai-compatible' | 'ollama' | 'fake';
+export type Provider = 'claude' | 'claude-code' | 'codex' | 'copilot' | 'openai-compatible' | 'ollama' | 'fake';
 export interface TokenUsage {
     inputTokens?: number;
     outputTokens?: number;
@@ -104,6 +104,6 @@ export declare class AgentsConfigError extends Error {
     readonly code = "AGENTS_CONFIG";
     constructor(message: string, hint?: string | undefined);
 }
-/** `default` means "let the CLI pick its configured model" (claude-code, codex). */
+/** `default` means "let the CLI pick its configured model" (claude-code, codex, copilot). */
 export declare const DEFAULT_MODELS: Record<Provider, string>;
 //# sourceMappingURL=types.d.ts.map

package/dist/adapter/types.js

@@ -7,11 +7,12 @@ export class AgentsConfigError extends Error {
         this.name = 'AgentsConfigError';
     }
 }
-/** `default` means "let the CLI pick its configured model" (claude-code, codex). */
+/** `default` means "let the CLI pick its configured model" (claude-code, codex, copilot). */
 export const DEFAULT_MODELS = {
     claude: 'claude-opus-5',
     'claude-code': 'default',
     codex: 'default',
+    copilot: 'default',
     'openai-compatible': 'gpt-4.1',
     // Small enough to run on a laptop, and the best of that size at tool calls and structured output.
     ollama: 'qwen2.5-coder:7b',

package/dist/claude-code/install.d.ts

@@ -1,4 +1,5 @@
-export type CodingAgentTarget = 'claude' | 'codex' | 'all';
+import { type RoleName } from '@sdods/mcp';
+export type CodingAgentTarget = 'claude' | 'codex' | 'copilot' | 'all';
 export interface InstallCodingAgentsOptions {
     for?: CodingAgentTarget;
     project?: string;
@@ -11,6 +12,8 @@ export interface InstallCodingAgentsOptions {
  * Set up coding-agent CLIs for an SDODS repo:
  * - Claude Code: `.claude/agents/sdods-<role>.md` (one subagent per role) + `CLAUDE.md`
  * - Codex: `AGENTS.md` (Codex reads it as project instructions; roles become sections)
+ * - GitHub Copilot: `.github/agents/sdods-<role>.agent.md` (custom agents) + `AGENTS.md`, which
+ *   Copilot also reads as project instructions
  * - both: `AGENT.md` and `SKILL.md` with the conventions
  * Returns the paths written. Existing files are kept unless `force`.
  */
@@ -26,7 +29,24 @@ export declare function claudeMdContent(opts?: {
     project?: string;
     env?: string;
 }): string;
-/** AGENTS.md: Codex reads this as project instructions; roles become sections. */
+/** A Claude Code subagent (`.claude/agents/sdods-<role>.md`) for one SDODS role. */
+export declare function claudeAgentContent(role: RoleName): string;
+/**
+ * The generated role agent files and what this version would write in each, so `sdods upgrade`
+ * can tell which ones are out of date. Only `sdods-<role>` files count; nothing else is touched.
+ */
+export declare function codingAgentFiles(rootDir: string): Array<{
+    file: string;
+    content: string;
+}>;
+/**
+ * A GitHub Copilot custom agent (`.github/agents/<name>.agent.md`), used by Copilot CLI
+ * (`copilot --agent sdods-healer`), VS Code and the Copilot coding agent. `read` and `search` are
+ * Copilot's file tools; `sdods/*` is every tool on the sdods MCP server. No `edit` or `shell`: the
+ * roles change the repo only through proposals.
+ */
+export declare function copilotAgentContent(role: RoleName): string;
+/** AGENTS.md: Codex and GitHub Copilot read this as project instructions; roles become sections. */
 export declare function agentsMdContent(opts?: {
     project?: string;
     env?: string;

package/dist/claude-code/install.js

@@ -17,6 +17,8 @@ function roleUse(role) {
  * Set up coding-agent CLIs for an SDODS repo:
  * - Claude Code: `.claude/agents/sdods-<role>.md` (one subagent per role) + `CLAUDE.md`
  * - Codex: `AGENTS.md` (Codex reads it as project instructions; roles become sections)
+ * - GitHub Copilot: `.github/agents/sdods-<role>.agent.md` (custom agents) + `AGENTS.md`, which
+ *   Copilot also reads as project instructions
  * - both: `AGENT.md` and `SKILL.md` with the conventions
  * Returns the paths written. Existing files are kept unless `force`.
  */
@@ -33,8 +35,7 @@ export function installCodingAgents(rootDir, opts = {}) {
     if (target === 'claude' || target === 'all') {
         const agentsDir = join(rootDir, '.claude', 'agents');
         for (const role of Object.keys(ROLE_PROMPTS)) {
-            const p = ROLE_PROMPTS[role];
-            writeIfMissing(join(agentsDir, `sdods-${role}.md`), `---\nname: sdods-${role}\ndescription: ${p.description} Use when the user asks SDODS to ${roleUse(role)}.\ntools: Read, Glob, Grep, mcp__sdods__*\n---\n\n${CONVENTIONS}\n\n${p.body}\n`);
+            writeIfMissing(join(agentsDir, `sdods-${role}.md`), claudeAgentContent(role));
         }
         writeIfMissing(join(rootDir, 'CLAUDE.md'), claudeMdContent(opts));
         if (opts.mcp) {
@@ -45,7 +46,13 @@ export function installCodingAgents(rootDir, opts = {}) {
             written.push(mcp.file);
         }
     }
-    if (target === 'codex' || target === 'all') {
+    if (target === 'copilot' || target === 'all') {
+        const agentsDir = join(rootDir, '.github', 'agents');
+        for (const role of Object.keys(ROLE_PROMPTS)) {
+            writeIfMissing(join(agentsDir, `sdods-${role}.agent.md`), copilotAgentContent(role));
+        }
+    }
+    if (target === 'codex' || target === 'copilot' || target === 'all') {
         writeIfMissing(join(rootDir, 'AGENTS.md'), agentsMdContent(opts));
     }
     writeIfMissing(join(rootDir, 'AGENT.md'), agentMdContent());
@@ -89,18 +96,58 @@ ${TAGLINE} Read \`AGENT.md\` for the mental model and \`SKILL.md\` for the comma
 ${CONVENTIONS.split('\n').slice(3).join('\n')}
 `;
 }
-/** AGENTS.md: Codex reads this as project instructions; roles become sections. */
+/** A Claude Code subagent (`.claude/agents/sdods-<role>.md`) for one SDODS role. */
+export function claudeAgentContent(role) {
+    const p = ROLE_PROMPTS[role];
+    return `---\nname: sdods-${role}\ndescription: ${p.description} Use when the user asks SDODS to ${roleUse(role)}.\ntools: Read, Glob, Grep, mcp__sdods__*\n---\n\n${CONVENTIONS}\n\n${p.body}\n`;
+}
+/**
+ * The generated role agent files and what this version would write in each, so `sdods upgrade`
+ * can tell which ones are out of date. Only `sdods-<role>` files count; nothing else is touched.
+ */
+export function codingAgentFiles(rootDir) {
+    return Object.keys(ROLE_PROMPTS).flatMap((role) => [
+        {
+            file: join(rootDir, '.claude', 'agents', `sdods-${role}.md`),
+            content: claudeAgentContent(role),
+        },
+        {
+            file: join(rootDir, '.github', 'agents', `sdods-${role}.agent.md`),
+            content: copilotAgentContent(role),
+        },
+    ]);
+}
+/**
+ * A GitHub Copilot custom agent (`.github/agents/<name>.agent.md`), used by Copilot CLI
+ * (`copilot --agent sdods-healer`), VS Code and the Copilot coding agent. `read` and `search` are
+ * Copilot's file tools; `sdods/*` is every tool on the sdods MCP server. No `edit` or `shell`: the
+ * roles change the repo only through proposals.
+ */
+export function copilotAgentContent(role) {
+    const p = ROLE_PROMPTS[role];
+    return `---
+name: sdods-${role}
+description: ${p.description} Use when the user asks SDODS to ${roleUse(role)}.
+tools: ['read', 'search', 'sdods/*']
+---
+
+${CONVENTIONS}
+
+${p.body}
+`;
+}
+/** AGENTS.md: Codex and GitHub Copilot read this as project instructions; roles become sections. */
 export function agentsMdContent(opts = {}) {
     const roles = Object.keys(ROLE_PROMPTS)
         .map((role) => `### sdods-${role}\n\n${ROLE_PROMPTS[role].description}\n\n${ROLE_PROMPTS[role].body}`)
         .join('\n\n');
-    return `# AGENTS.md — SDODS instructions for Codex
+    return `# AGENTS.md — SDODS instructions for coding agents
 
-${TAGLINE} This file is read by the OpenAI Codex CLI. \`AGENT.md\` holds the mental model and \`SKILL.md\` the command reference.
+${TAGLINE} This file is read by the OpenAI Codex CLI, GitHub Copilot and other agents that follow AGENTS.md. \`AGENT.md\` holds the mental model and \`SKILL.md\` the command reference.
 
 ## Tools
 
-- The SDODS MCP server is registered as \`sdods\` (\`sdods mcp install codex\` re-registers it in \`~/.codex/config.toml\`); use its tools for projects, features, steps, runs, results, proposals.
+- The SDODS MCP server is registered as \`sdods\` (\`sdods mcp install codex\` re-registers it in \`~/.codex/config.toml\`, \`sdods mcp install copilot\` in \`~/.copilot/mcp-config.json\`); use its tools for projects, features, steps, runs, results, proposals.
 - Drive a browser with the \`browser_*\` tools on the \`sdods\` server (\`browser_session_open\`, then \`browser_navigate\`, \`browser_snapshot\`, \`browser_click\`). They are the upstream Playwright MCP tools bound to the project and environment, so the page carries the right test-id attribute and login state.
 - Commands: \`sdods lint${projectFlags(opts)}\`, \`sdods run${projectEnvFlags(opts)} -l api\`, \`sdods run${projectEnvFlags(opts)} -l ui -b chromium -t @smoke\`, \`sdods steps list${projectFlags(opts)}\`, \`sdods proposals list|show|accept\`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdods/agents",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "SDODS AI agents: planner, generator, healer, upgrader and reviewer over a provider-agnostic adapter.",
   "license": "Apache-2.0",
   "funding": "https://sdods.com/sponsor/",
@@ -26,8 +26,8 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.314",
     "@anthropic-ai/sdk": "^1.3.0",
-    "@sdods/contracts": "0.19.0",
-    "@sdods/mcp": "0.19.0",
+    "@sdods/contracts": "0.21.0",
+    "@sdods/mcp": "0.21.0",
     "zod": "^4.6.7",
     "@modelcontextprotocol/client": "^2.4.0"
   },