@saadnvd1/agent-os 0.3.527 → 0.3.528

package/README.md

@@ -126,7 +126,8 @@ You need Node.js 20+, tmux, and at least one agent CLI:
 Pi,
 [Kilo Code CLI](https://kilo.ai/docs/cli),
 [Gemini CLI](https://github.com/google-gemini/gemini-cli),
-[Aider](https://aider.chat/), [Cursor CLI](https://cursor.com/cli) or Amp.
+[Aider](https://aider.chat/), [Cursor CLI](https://cursor.com/cli), Amp or
+[GitHub Copilot CLI](https://github.com/github/copilot-cli).
 
 ```bash
 npm install -g @saadnvd1/agent-os
@@ -229,18 +230,19 @@ CLI) with the fix for anything missing (`/api/doctor`).
 
 ### Supported agents
 
-| Agent       | Chat | Resume | Fork | Auto-approve                                 |
-| ----------- | ---- | ------ | ---- | -------------------------------------------- |
-| Claude Code | ✅   | ✅     | ✅   | `--dangerously-skip-permissions`             |
-| Codex       | ✅   | ✅     | ✅   | `--dangerously-bypass-approvals-and-sandbox` |
-| OpenCode    | ✅   | ✅     | ✅   | `--auto`                                     |
-| Pi          | ✅   | ✅     | ✅   | Never asks                                   |
-| Kilo Code   | ❌   | ✅     | ✅   | Config file                                  |
-| Gemini CLI  | ❌   | ❌     | ❌   | `--yolo`                                     |
-| Aider       | ❌   | ❌     | ❌   | `--yes`                                      |
-| Cursor CLI  | ❌   | ✅     | ❌   | `--force`                                    |
-| Amp         | ❌   | ✅     | ❌   | `--dangerously-allow-all`                    |
-| Oh My Pi    | ❌   | ❌     | ❌   | N/A                                          |
+| Agent          | Chat | Resume | Fork | Auto-approve                                 |
+| -------------- | ---- | ------ | ---- | -------------------------------------------- |
+| Claude Code    | ✅   | ✅     | ✅   | `--dangerously-skip-permissions`             |
+| Codex          | ✅   | ✅     | ✅   | `--dangerously-bypass-approvals-and-sandbox` |
+| OpenCode       | ✅   | ✅     | ✅   | `--auto`                                     |
+| Pi             | ✅   | ✅     | ✅   | Never asks                                   |
+| Kilo Code      | ❌   | ✅     | ✅   | Config file                                  |
+| Gemini CLI     | ❌   | ❌     | ❌   | `--yolo`                                     |
+| Aider          | ❌   | ❌     | ❌   | `--yes`                                      |
+| Cursor CLI     | ❌   | ✅     | ❌   | `--force`                                    |
+| Amp            | ❌   | ✅     | ❌   | `--dangerously-allow-all`                    |
+| Oh My Pi       | ❌   | ❌     | ❌   | N/A                                          |
+| GitHub Copilot | ✅   | ✅     | ❌   | `--allow-all`                                |
 
 Agents without chat run in the terminal. The new-session picker says when an
 agent isn't installed or needs a sign-in first, and what to run.
@@ -275,10 +277,16 @@ agent as the terminal, with your own logins: Claude Code through the Agent
 SDK, Codex through `codex app-server`, OpenCode through its own `opencode
 serve` (loopback only, behind a per-conversation password) and Pi through its
 RPC mode. Pi never asks before a tool, so AgentOS loads a small Pi extension
-that asks the chat as the access setting says. The **Chat /
+that asks the chat as the access setting says. GitHub Copilot runs through
+`copilot --acp` (the Agent Client Protocol): its permission prompts become
+approval cards under the same access setting, and a conversation resumes with
+`session/load` after a restart. It signs in with `copilot login` or a
+`COPILOT_GITHUB_TOKEN`, `GH_TOKEN` or `GITHUB_TOKEN`; it has no plan mode,
+undo or in-chat model list yet, so it runs on its own default model unless one
+is named. The **Chat /
 Terminal** switch in the tab bar hands the same conversation between the two:
 the terminal resumes it (`claude --resume`, `codex resume`, `opencode
---session`, `pi --session`), and switching back closes the
+--session`, `pi --session`, `copilot --resume`), and switching back closes the
 terminal so only one side drives it. Each chat conversation runs in its own
 worker process (in tmux, like terminal sessions), so restarting or updating
 AgentOS never cuts off a turn: the server reconnects to running workers when
@@ -491,7 +499,10 @@ orchestrator's `start_task` with `after`) holds a task until a named task
 finishes, or until any task still working now does (a running task whose PR
 was closed or merged doesn't count; with none, it starts at once). The
 orchestrator's `drop` removes a queued task by its id. Pause stops automatic starts,
-and the orchestrator's brakes still apply when its queued tasks start. The
+and the orchestrator's brakes still apply when its queued tasks start. A task runs on Claude Code unless
+`POST /api/tasks` names another `agent` (`"copilot"`): that one runs as a chat on
+this machine, with no plan-first step or role models, and is never picked for
+you. The
 line is kept in the database across restarts (`GET /api/tasks/queue`; start
 now, move up or down, or remove with `/api/tasks/queue/<id>`). The sidebar
 shows them under **Queued** with their place in line or what they wait on,

package/app/api/tasks/route.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { NextRequest } from "next/server";
+import { POST } from "./route";
+
+const post = (body: object) =>
+  POST(
+    new NextRequest("http://localhost/api/tasks", {
+      method: "POST",
+      body: JSON.stringify({ projectId: "none", prompt: "x", ...body }),
+    })
+  );
+
+describe("POST /api/tasks with another agent's model", () => {
+  it.each(["--allow-all-tools", "-m", "a b", "x\ny", "m".repeat(101), 7])(
+    "refuses %j before anything is queued",
+    async (model) => {
+      const res = await post({ agent: "copilot", model });
+      expect(res.status).toBe(400);
+      expect((await res.json()).error).toBe("Bad model name");
+    }
+  );
+});

package/app/api/tasks/route.ts

@@ -6,6 +6,8 @@ import { TASK_CAPABILITIES } from "@/lib/tasks/remote";
 import { ensureProject, type ProjectRef } from "@/lib/tasks/project-ref";
 import { isSessionId, statusFor } from "@/lib/tasks/move-bundle";
 import { startView } from "@/lib/sessions/launch";
+import { isValidAgentType } from "@/lib/providers";
+import { isAgentModelName } from "@/lib/providers/registry";
 
 // moved and capabilities are for another machine that mirrors these tasks.
 export async function GET() {
@@ -34,6 +36,7 @@ export async function POST(request: NextRequest) {
       baseBranch,
       after,
       view,
+      agent,
       plan,
       plan_reason,
       plan_only,
@@ -43,11 +46,20 @@ export async function POST(request: NextRequest) {
       project && typeof project === "object"
         ? (await ensureProject(project as ProjectRef)).id
         : projectId;
+    if (agent !== undefined && !isValidAgentType(agent))
+      throw new Error("Unknown agent");
+    if (agent && agent !== "claude" && model != null && model !== "")
+      if (!isAgentModelName(model)) throw new Error("Bad model name");
     const opts = {
       projectId: pid,
       prompt: String(prompt ?? ""),
-      // Checked now, so a queued task can't fail on it later.
-      model: parseOverride(model) ?? undefined,
+      agent: agent && agent !== "claude" ? agent : undefined,
+      // Checked now, so a queued task can't fail on it later. Another
+      // agent's model is its own name for one.
+      model:
+        agent && agent !== "claude" && typeof model === "string"
+          ? model
+          : (parseOverride(model) ?? undefined),
       plan: typeof plan === "boolean" ? plan : undefined,
       planOnly: plan_only === true ? true : undefined,
       planReason:

package/lib/agent-options.ts

@@ -12,6 +12,7 @@ export const AGENT_OPTIONS: { value: AgentType; label: string }[] = [
   { value: "amp", label: "Amp" },
   { value: "pi", label: "Pi" },
   { value: "omp", label: "Oh My Pi" },
+  { value: "copilot", label: "GitHub Copilot" },
 ];
 
 export const agentLabel = (agent: AgentType) =>

package/lib/agents/probe.ts

@@ -116,6 +116,27 @@ const AUTH: Partial<Record<ProviderId, { check: AuthCheck; hint: string }>> = {
         : "needs-login",
     hint: "Run `pi` in a terminal and use /login, or set a provider API key",
   },
+  // The CLI also signs in through the GitHub CLI's login, which no file of
+  // its own shows: without a trace of a sign-in, it's not known to need one.
+  copilot: {
+    check: (_cli, env) => {
+      if (anyEnv(env, ["COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"]))
+        return "ready";
+      try {
+        const config = fs.readFileSync(
+          path.join(
+            env.COPILOT_HOME?.trim() || home(".copilot"),
+            "config.json"
+          ),
+          "utf8"
+        );
+        return /logged.?in.?user/i.test(config) ? "ready" : "unknown";
+      } catch {
+        return "unknown";
+      }
+    },
+    hint: "Run `copilot login` in a terminal",
+  },
   gemini: {
     check: (_cli, env) =>
       fs.existsSync(home(".gemini", "oauth_creds.json")) ||

package/lib/agents/setup-commands.ts

@@ -30,6 +30,10 @@ export const SETUP_COMMANDS: Partial<Record<ProviderId, SetupCommands>> = {
   cursor: { signIn: "cursor-agent login", docs: "https://cursor.com/cli" },
   amp: { signIn: "amp login", docs: "https://ampcode.com" },
   pi: { signIn: "pi" },
+  copilot: {
+    install: "npm install -g @github/copilot",
+    signIn: "copilot login",
+  },
   // No installer line we can vouch for from here; its own site has it.
   opencode: { docs: "https://opencode.ai/docs" },
 };

package/lib/chat/capabilities.ts

@@ -1,6 +1,12 @@
 // Agent types that can run as chat. Safe to import from the browser: the
 // drivers themselves (and their SDKs) live in lib/chat/drivers.
-export const CHAT_AGENT_TYPES = ["claude", "codex", "opencode", "pi"] as const;
+export const CHAT_AGENT_TYPES = [
+  "claude",
+  "codex",
+  "opencode",
+  "pi",
+  "copilot",
+] as const;
 
 export function supportsChat(agentType: string | null | undefined): boolean {
   return (

package/lib/chat/drivers/copilot-approvals.ts

@@ -0,0 +1,99 @@
+import type { ChatAccess, DriverEvent, FileDiff } from "../events";
+import { unifiedToDiff } from "../diff";
+import { toolTitle } from "../tools";
+import { PendingApprovals } from "./pending-approvals";
+
+type P = Record<string, unknown>;
+const str = (v: unknown) => (typeof v === "string" ? v : "");
+
+// What an "edits" access lets through without asking: reading, searching
+// and changing files, never a command or a fetch.
+const EDITS_KINDS = new Set(["read", "search", "edit", "delete", "move"]);
+
+const WANT = {
+  allow: "allow_once",
+  always: "allow_always",
+  deny: "reject_once",
+} as const;
+
+interface Option {
+  optionId: string;
+  kind: string;
+}
+
+// The kind of tool Copilot asks about, as the chat's tool names.
+export function permissionTool(kind: string): string {
+  switch (kind) {
+    case "execute":
+      return "Bash";
+    case "edit":
+    case "delete":
+    case "move":
+      return "Edit";
+    case "fetch":
+      return "WebFetch";
+    case "read":
+      return "Read";
+    default:
+      return "Permissions";
+  }
+}
+
+export function permissionDiff(input: P): FileDiff | undefined {
+  const diff = str(input.diff);
+  const file = str(input.fileName);
+  if (!diff || !file) return undefined;
+  return unifiedToDiff(file, diff, /^create file mode/m.test(diff));
+}
+
+// Copilot's permission prompts as approval cards, and the cards' answers as
+// the option it offered for each.
+export class CopilotApprovals {
+  readonly pending: PendingApprovals;
+
+  constructor(
+    emit: (e: DriverEvent) => void,
+    public access: ChatAccess
+  ) {
+    this.pending = new PendingApprovals(emit);
+  }
+
+  // The reply to one session/request_permission.
+  async handle(p: P): Promise<unknown> {
+    const options = (p.options as Option[]) ?? [];
+    const call = (p.toolCall ?? {}) as P;
+    const kind = str(call.kind);
+    const pick = (want: string) =>
+      options.find((o) => o.kind === want)?.optionId;
+    const selected = (id: string | undefined) =>
+      id
+        ? { outcome: { outcome: "selected", optionId: id } }
+        : { outcome: { outcome: "cancelled" } };
+
+    if (
+      this.access === "full" ||
+      (this.access === "edits" && EDITS_KINDS.has(kind))
+    )
+      return selected(pick("allow_once"));
+
+    const input = (call.rawInput ?? {}) as P;
+    const name = permissionTool(kind);
+    const command = str(input.command);
+    const file = str(input.fileName) || str((call.locations as P[])?.[0]?.path);
+    const o = await this.pending.ask({
+      id: `approval-${str(call.toolCallId)}`,
+      toolName: name,
+      title:
+        toolTitle(name, { command, file_path: file, url: input.url }) ||
+        str(call.title) ||
+        "Allow this",
+      input: command ? { command } : { file, title: str(call.title) },
+      diff: permissionDiff(input),
+      canAlways: !!pick("allow_always"),
+    });
+    if (o.decision === "allow" || o.decision === "always")
+      return selected(pick(WANT[o.decision]) ?? pick("allow_once"));
+    if (o.decision === "deny") return selected(pick("reject_once"));
+    return selected(undefined);
+  }
+}

package/lib/chat/drivers/copilot-mapper.ts

@@ -0,0 +1,203 @@
+import type { ChatContext, DriverEvent, UsageTotals } from "../events";
+import { toolTitle } from "../tools";
+import { TurnItems, type ToolStart } from "./turn-items";
+
+type P = Record<string, unknown>;
+const str = (v: unknown) => (typeof v === "string" ? v : "");
+
+const TODO_STATUS = {
+  pending: "pending",
+  in_progress: "in_progress",
+  completed: "completed",
+} as const;
+
+// "*** Update File: f.txt" in an apply_patch the agent made.
+const patchFile = (patch: string) =>
+  patch.match(/^\*\*\* (?:Update|Add|Delete) File: (.+)$/m)?.[1]?.trim();
+
+export function toolStart(update: P): ToolStart {
+  const raw = update.rawInput;
+  const input = (typeof raw === "object" && raw ? raw : {}) as P;
+  const file =
+    str(input.path) ||
+    str(input.fileName) ||
+    str((update.locations as P[] | undefined)?.[0]?.path) ||
+    (typeof raw === "string" ? patchFile(raw) : undefined) ||
+    "";
+  const title = str(update.title);
+  switch (str(update.kind)) {
+    case "execute": {
+      const command = str(input.command);
+      return {
+        name: "Bash",
+        title: toolTitle("Bash", { command, description: input.description }),
+        input: { command, description: input.description },
+      };
+    }
+    case "edit":
+    case "delete":
+    case "move":
+      return {
+        name: "Edit",
+        title: file ? toolTitle("Edit", { file_path: file }) : title,
+        input: { file_path: file },
+      };
+    case "read":
+      if (input.pattern)
+        return {
+          name: "Glob",
+          title: toolTitle("Glob", { pattern: input.pattern }),
+          input,
+        };
+      return {
+        name: "Read",
+        title: toolTitle("Read", { file_path: file }),
+        input: { file_path: file },
+      };
+    case "search":
+      return {
+        name: "Grep",
+        title: toolTitle("Grep", { pattern: input.pattern ?? input.query }),
+        input,
+      };
+    case "fetch":
+      return {
+        name: "WebFetch",
+        title: toolTitle("WebFetch", { url: input.url }),
+        input,
+      };
+    default:
+      return { name: title || "Tool", title: title || "Tool", input: raw };
+  }
+}
+
+function contentText(update: P): string {
+  const parts = (update.content as P[] | undefined) ?? [];
+  const text = parts
+    .map((c) => (c.type === "content" ? str((c.content as P)?.text) : ""))
+    .filter(Boolean)
+    .join("\n");
+  if (text) return text;
+  const raw = (update.rawOutput ?? {}) as P;
+  return str(raw.content);
+}
+
+// Copilot's session updates as chat items. One per conversation.
+export class CopilotMapper {
+  readonly items: TurnItems;
+  readonly totals: UsageTotals = {
+    costUsd: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+  };
+  // Text before and after a tool call are separate bubbles.
+  private block = 0;
+  // A resumed conversation replays its history before it's ready: not ours.
+  replaying = false;
+
+  constructor(private emit: (e: DriverEvent) => void) {
+    this.items = new TurnItems(emit);
+  }
+
+  map(update: P): void {
+    if (this.replaying) return;
+    const text = str((update.content as P | undefined)?.text);
+    switch (str(update.sessionUpdate)) {
+      case "agent_message_chunk":
+        this.items.startTurn();
+        return this.items.delta(`m${this.block}`, "assistant", text);
+      case "agent_thought_chunk":
+        this.items.startTurn();
+        return this.items.delta(`r${this.block}`, "reasoning", text);
+      case "tool_call":
+        return this.started(update);
+      case "tool_call_update":
+        return this.updated(update);
+      case "plan":
+        return this.items.todos(
+          ((update.entries as P[]) ?? []).map((e) => ({
+            text: str(e.content),
+            status:
+              TODO_STATUS[str(e.status) as keyof typeof TODO_STATUS] ??
+              "pending",
+          }))
+        );
+      case "usage_update":
+        return this.context(update);
+    }
+  }
+
+  private close(): void {
+    this.items.finishText(`m${this.block}`, "assistant");
+    this.items.finishText(`r${this.block}`, "reasoning");
+    this.block++;
+  }
+
+  private started(update: P): void {
+    this.items.startTurn();
+    this.close();
+    this.items.tool(str(update.toolCallId), toolStart(update));
+  }
+
+  private updated(update: P): void {
+    const id = str(update.toolCallId);
+    const status = str(update.status);
+    if (status !== "completed" && status !== "failed") return;
+    const start = toolStart(update);
+    if (!this.items.hasTool(id)) this.items.tool(id, start);
+    const diff = ((update.content as P[]) ?? []).find((c) => c.type === "diff");
+    const changed = diff
+      ? {
+          path: str(diff.path),
+          before: str(diff.oldText),
+          after: str(diff.newText),
+        }
+      : undefined;
+    this.items.toolDone(
+      id,
+      status === "failed" ? "error" : "done",
+      contentText(update),
+      changed
+        ? {
+            name: "Edit",
+            title: toolTitle("Edit", { file_path: changed.path }),
+            diff: changed,
+          }
+        : undefined
+    );
+  }
+
+  private context(update: P): void {
+    const used = Number(update.used);
+    const max = Number(update.size);
+    if (!max || !Number.isFinite(used)) return;
+    const context: ChatContext = {
+      usedTokens: used,
+      maxTokens: max,
+      percentage: Math.round((used / max) * 1000) / 10,
+      categories: [],
+      at: Date.now(),
+    };
+    this.emit({ type: "context", context });
+  }
+
+  // What a finished prompt spent. The CLI counts cached tokens in its input.
+  spent(usage: P | undefined): void {
+    if (!usage) return;
+    const read = Number(usage.cachedReadTokens) || 0;
+    const written = Number(usage.cachedWriteTokens) || 0;
+    const input = Number(usage.inputTokens) || 0;
+    this.totals.inputTokens += Math.max(0, input - read - written);
+    this.totals.outputTokens += Number(usage.outputTokens) || 0;
+    this.totals.cacheReadTokens += read;
+    this.totals.cacheWriteTokens += written;
+  }
+
+  endTurn(end: { interrupted?: boolean; error?: string }): void {
+    this.close();
+    this.emit({ type: "usage", totals: { ...this.totals } });
+    this.items.endTurn(end);
+  }
+}

package/lib/chat/drivers/copilot-rpc.ts

@@ -0,0 +1,126 @@
+import { AgentChild } from "./child";
+
+export interface AcpMessage {
+  id?: number | string;
+  method?: string;
+  params?: Record<string, unknown>;
+  result?: unknown;
+  error?: { code?: number; message?: string };
+}
+
+const REQUEST_MS = 60_000;
+
+// The GitHub Copilot CLI as an Agent Client Protocol server: JSON-RPC 2.0
+// over the stdio of `copilot --acp`. Its own requests to us (permission
+// prompts) count their ids separately from ours.
+export class CopilotRpc {
+  private child: AgentChild;
+  private nextId = 1;
+  private calls = new Map<
+    number,
+    { resolve: (r: unknown) => void; reject: (e: Error) => void }
+  >();
+
+  constructor(
+    args: string[],
+    options: { cwd: string; env: NodeJS.ProcessEnv },
+    handlers: {
+      notify: (method: string, params: Record<string, unknown>) => void;
+      request: (
+        id: number | string,
+        method: string,
+        params: Record<string, unknown>
+      ) => void;
+      exit: (error: string) => void;
+    }
+  ) {
+    this.child = new AgentChild(
+      "copilot",
+      ["--acp", "--no-auto-update", ...args],
+      {
+        ...options,
+        onRecord: (r) => {
+          const m = r as AcpMessage;
+          if (m.method && m.id !== undefined)
+            handlers.request(m.id, m.method, m.params ?? {});
+          else if (m.method) handlers.notify(m.method, m.params ?? {});
+          else if (typeof m.id === "number") this.settle(m);
+        },
+        onExit: (code, error) => {
+          const why =
+            error ??
+            `GitHub Copilot stopped (exit ${code ?? "signal"})${this.child.errorTail ? `: ${this.child.errorTail}` : ""}`;
+          for (const call of this.calls.values()) call.reject(new Error(why));
+          this.calls.clear();
+          handlers.exit(why);
+        },
+      }
+    );
+  }
+
+  private settle(m: AcpMessage): void {
+    const call = this.calls.get(m.id as number);
+    if (!call) return;
+    this.calls.delete(m.id as number);
+    if (m.error)
+      call.reject(new Error(m.error.message ?? "GitHub Copilot error"));
+    else call.resolve(m.result);
+  }
+
+  // A timeout of 0 waits as long as it takes (a prompt runs a whole turn).
+  request<T>(
+    method: string,
+    params: unknown = {},
+    timeoutMs = REQUEST_MS
+  ): Promise<T> {
+    const id = this.nextId++;
+    return new Promise<T>((resolve, reject) => {
+      const timer = timeoutMs
+        ? setTimeout(() => {
+            this.calls.delete(id);
+            reject(new Error(`GitHub Copilot didn't answer ${method}`));
+          }, timeoutMs)
+        : undefined;
+      this.calls.set(id, {
+        resolve: (r) => {
+          clearTimeout(timer);
+          resolve(r as T);
+        },
+        reject: (e) => {
+          clearTimeout(timer);
+          reject(e);
+        },
+      });
+      this.child.write({ jsonrpc: "2.0", id, method, params });
+    });
+  }
+
+  notify(method: string, params?: unknown): void {
+    this.child.write({ jsonrpc: "2.0", method, params });
+  }
+
+  reply(id: number | string, result: unknown): void {
+    this.child.write({ jsonrpc: "2.0", id, result });
+  }
+
+  replyError(id: number | string, message: string): void {
+    this.child.write({
+      jsonrpc: "2.0",
+      id,
+      error: { code: -32601, message },
+    });
+  }
+
+  // No file or terminal access offered: the agent uses its own.
+  async initialize(): Promise<void> {
+    await this.request("initialize", {
+      protocolVersion: 1,
+      clientCapabilities: {},
+      clientInfo: { name: "agentos", title: "AgentOS", version: "1.0.0" },
+    });
+  }
+
+  close(): void {
+    this.child.kill();
+  }
+}

package/lib/chat/drivers/copilot.ts

@@ -0,0 +1,174 @@
+import type { ChatConversation, ChatDriver, ChatStartOptions } from "../driver";
+import type { ChatImage, DriverEvent } from "../events";
+import { InputQueue } from "../queue";
+import { AGENT_DEFAULT_MODEL } from "../../providers/registry";
+import { CopilotApprovals } from "./copilot-approvals";
+import { CopilotMapper } from "./copilot-mapper";
+import { CopilotRpc } from "./copilot-rpc";
+
+type P = Record<string, unknown>;
+
+export function copilotArgs(o: ChatStartOptions): string[] {
+  const args: string[] = [];
+  if (o.model && o.model !== AGENT_DEFAULT_MODEL) args.push("--model", o.model);
+  return args;
+}
+
+export function copilotPrompt(text: string, images?: ChatImage[]) {
+  return [
+    { type: "text", text },
+    ...(images ?? []).map((i) => ({
+      type: "image",
+      data: i.data,
+      mimeType: i.mediaType,
+    })),
+  ];
+}
+
+// The GitHub Copilot CLI over the Agent Client Protocol (`copilot --acp`).
+// It has no system prompt to append to, so the instructions go ahead of the
+// first message of a new conversation.
+export const copilotDriver: ChatDriver = {
+  id: "copilot",
+  plan: false,
+  inProcessTools: false,
+  atRest: false,
+
+  // The ACP server lists no models or commands without a session; the agent
+  // picks its own model unless one is chosen.
+  async discover() {
+    return { commands: [], models: [] };
+  },
+
+  start(options): ChatConversation {
+    const out = new InputQueue<DriverEvent>();
+    const emit = (e: DriverEvent) => out.push(e);
+    const mapper = new CopilotMapper(emit);
+    const approvals = new CopilotApprovals(emit, options.access);
+    let sessionId: string | null = null;
+    let busy = false;
+    let intro = options.resumeId ? "" : (options.systemAppend ?? "").trim();
+    // Messages that can't join the running turn wait for it to end, in order.
+    const held: { text: string; images?: ChatImage[] }[] = [];
+    const rpc: CopilotRpc = new CopilotRpc(
+      copilotArgs(options),
+      { cwd: options.cwd, env: { ...process.env, ...options.env } },
+      {
+        notify(method, params) {
+          if (method === "session/update")
+            mapper.map((params.update ?? {}) as P);
+        },
+        request(id, method, params) {
+          if (method !== "session/request_permission")
+            return rpc.replyError(id, `${method} isn't supported`);
+          void approvals.handle(params).then((result) => rpc.reply(id, result));
+        },
+        exit(error) {
+          approvals.pending.expireAll();
+          mapper.endTurn({ error });
+          out.end();
+        },
+      }
+    );
+    emit({ type: "usage_start", totals: { ...mapper.totals } });
+
+    const ready = rpc.initialize().then(async () => {
+      const params = { cwd: options.cwd, mcpServers: [] };
+      if (options.resumeId) {
+        mapper.replaying = true;
+        try {
+          await rpc.request("session/load", {
+            ...params,
+            sessionId: options.resumeId,
+          });
+          sessionId = options.resumeId;
+        } catch {
+          mapper.items.error(
+            "That conversation is gone, so this one starts over"
+          );
+          intro = (options.systemAppend ?? "").trim();
+        } finally {
+          mapper.replaying = false;
+        }
+      }
+      if (!sessionId)
+        sessionId = (
+          await rpc.request<{ sessionId: string }>("session/new", params)
+        ).sessionId;
+      emit({ type: "resume_id", id: sessionId });
+    });
+    ready.catch((error: Error) => {
+      mapper.items.error(`GitHub Copilot couldn't start: ${error.message}`);
+      mapper.endTurn({});
+      out.end();
+      rpc.close();
+    });
+
+    async function run(text: string, images?: ChatImage[]) {
+      busy = true;
+      mapper.items.startTurn();
+      let end: { interrupted?: boolean; error?: string } = {};
+      try {
+        await ready;
+        const first = intro ? `${intro}\n\n${text}` : text;
+        intro = "";
+        const r = await rpc.request<P>(
+          "session/prompt",
+          { sessionId, prompt: copilotPrompt(first, images) },
+          0
+        );
+        mapper.spent(r.usage as P | undefined);
+        end = { interrupted: r.stopReason === "cancelled" };
+      } catch (error) {
+        end = { error: (error as Error).message };
+      }
+      busy = false;
+      mapper.endTurn(end);
+      const next = held.shift();
+      if (next) void run(next.text, next.images);
+    }
+
+    function stop() {
+      approvals.pending.expireAll();
+      if (busy && sessionId) rpc.notify("session/cancel", { sessionId });
+    }
+
+    return {
+      send(text, images, sendOptions) {
+        if (!busy) void run(text, images);
+        else {
+          held.push({ text, images });
+          if (sendOptions?.now) stop();
+        }
+        return undefined;
+      },
+      // Stops the turn only: a message already sent still goes after it.
+      async interrupt() {
+        stop();
+      },
+      // The model is chosen when the CLI starts.
+      async setModel() {},
+      async setAccess(next) {
+        approvals.access = next;
+      },
+      async setPlan() {},
+      respond(id, answer) {
+        approvals.pending.respond(id, answer);
+      },
+      async stopTask() {},
+      async undo() {
+        return {
+          canUndo: false,
+          error: "GitHub Copilot can't undo from chat",
+          files: [],
+        };
+      },
+      close() {
+        approvals.pending.expireAll();
+        rpc.close();
+        out.end();
+      },
+      events: out,
+    };
+  },
+};

package/lib/chat/drivers/index.ts

@@ -4,6 +4,7 @@ import { claudeDriver } from "./claude";
 import { codexDriver } from "./codex";
 import { openCodeDriver } from "./opencode";
 import { piDriver } from "./pi";
+import { copilotDriver } from "./copilot";
 import { demoDriver } from "./demo";
 import { demoMode } from "../../security/demo";
 
@@ -14,6 +15,7 @@ const DRIVERS: Record<(typeof CHAT_AGENT_TYPES)[number], ChatDriver> = {
   codex: codexDriver,
   pi: piDriver,
   opencode: openCodeDriver,
+  copilot: copilotDriver,
 };
 
 export function chatDriverFor(agentType: string): ChatDriver | null {

package/lib/db/migrations.ts

@@ -1819,6 +1819,17 @@ const migrations: Migration[] = [
       installChangeTriggers(db, TABLES_WATCHED_78);
     },
   },
+  {
+    id: 79,
+    name: "task_queue_agent",
+    up: (db) => {
+      // The agent CLI a queued task runs with; null is Claude Code.
+      const has = (
+        db.prepare(`PRAGMA table_info(task_queue)`).all() as { name: string }[]
+      ).some((c) => c.name === "agent_type");
+      if (!has) db.exec(`ALTER TABLE task_queue ADD COLUMN agent_type TEXT`);
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/providers/registry.ts

@@ -15,6 +15,7 @@ export const PROVIDER_IDS = [
   "amp",
   "pi",
   "omp",
+  "copilot",
   "shell",
 ] as const;
 
@@ -57,6 +58,11 @@ export interface ProviderDefinition {
 // The model value that means "whatever the agent itself defaults to".
 export const AGENT_DEFAULT_MODEL = "default";
 
+// A model name handed to another agent's CLI as an argument: printable, no
+// leading dash (it would read as a flag), bounded.
+export const isAgentModelName = (v: unknown): v is string =>
+  typeof v === "string" && /^[A-Za-z0-9][A-Za-z0-9._:/@+-]{0,99}$/.test(v);
+
 /**
  * Provider Registry
  * All supported agent providers with their configurations
@@ -192,6 +198,19 @@ export const PROVIDERS: ProviderDefinition[] = [
     modelFlag: "--model",
     initialPromptFlag: "", // Positional argument
   },
+  {
+    id: "copilot",
+    name: "GitHub Copilot",
+    description: "GitHub's Copilot CLI",
+    cli: "copilot",
+    configDir: "~/.copilot",
+    autoApproveFlag: "--allow-all",
+    supportsResume: true,
+    supportsFork: false,
+    resumeArgs: (id) => [`--resume=${id}`],
+    modelFlag: "--model",
+    initialPromptFlag: "-i",
+  },
   {
     id: "shell",
     name: "Terminal",

package/lib/providers/resume-ids.ts

@@ -154,6 +154,35 @@ export function opencodeResumeId(cwd: string, now = Date.now()): string | null {
   }
 }
 
+// ~/.copilot/session-state/<id>/workspace.yaml, whose `cwd:` line names the
+// folder the conversation ran in.
+export function copilotResumeId(cwd: string, now = Date.now()): string | null {
+  const root = path.join(
+    process.env.COPILOT_HOME || path.join(os.homedir(), ".copilot"),
+    "session-state"
+  );
+  let ids: string[];
+  try {
+    ids = fs.readdirSync(root);
+  } catch {
+    return null;
+  }
+  let best: { id: string; mtimeMs: number } | null = null;
+  for (const id of ids) {
+    if (!/^[0-9a-f-]{36}$/.test(id)) continue;
+    const file = path.join(root, id, "workspace.yaml");
+    try {
+      const { mtimeMs } = fs.statSync(file);
+      if (!recent(mtimeMs, now) || (best && best.mtimeMs >= mtimeMs)) continue;
+      const folder = fs.readFileSync(file, "utf8").match(/^cwd: (.+)$/m)?.[1];
+      if (folder?.trim() === cwd) best = { id, mtimeMs };
+    } catch {
+      // Gone since the listing.
+    }
+  }
+  return best?.id ?? null;
+}
+
 const FINDERS: Partial<
   Record<ProviderId, (cwd: string, now?: number) => string | null>
 > = {
@@ -161,6 +190,7 @@ const FINDERS: Partial<
   codex: codexResumeId,
   pi: piResumeId,
   opencode: opencodeResumeId,
+  copilot: copilotResumeId,
 };
 
 export function findResumeId(agent: ProviderId, cwd: string): string | null {

package/lib/tasks/code-review.ts

@@ -19,15 +19,18 @@ const FENCE = /^ {0,3}(`{3,}|~{3,})/;
 // prose that quotes the footer ("the 'Generated with Claude Code' footer")
 // isn't one.
 export const ATTRIBUTION =
-  /^(?:co-authored-by:.*(?:claude|anthropic)|claude-session:|🤖 generated with)|(?:^|[^\p{L}\p{N}"'`])generated (?:with|by) \[?claude code/iu;
+  /^(?:co-authored-by:.*(?:claude|anthropic|copilot)|claude-session:|🤖 generated with)|(?:^|[^\p{L}\p{N}"'`])generated (?:with|by) \[?claude code/iu;
 export type AttributionKind =
   | "a Co-Authored-By trailer naming Claude"
+  | "a Co-Authored-By trailer naming GitHub Copilot"
   | "a Claude-Session link"
   | 'a "Generated with" AI footer';
 function attributionKind(line: string): AttributionKind | undefined {
   if (!ATTRIBUTION.test(line)) return;
   if (/^co-authored-by:/i.test(line))
-    return "a Co-Authored-By trailer naming Claude";
+    return /^co-authored-by:.*(?:claude|anthropic)/i.test(line)
+      ? "a Co-Authored-By trailer naming Claude"
+      : "a Co-Authored-By trailer naming GitHub Copilot";
   if (/^claude-session:/i.test(line)) return "a Claude-Session link";
   return 'a "Generated with" AI footer';
 }

package/lib/tasks/index.ts

@@ -28,7 +28,10 @@ import {
   isBranchName,
   slugify,
 } from "../git";
-import { getProvider } from "../providers";
+import { getProvider, type AgentType } from "../providers";
+import { agentLabel } from "../agent-options";
+import { supportsChat } from "../chat/capabilities";
+import { AGENT_DEFAULT_MODEL } from "../providers/registry";
 import { statusDetector } from "../status-detector";
 import { buildTaskBrief, type StackedOn } from "./brief";
 import {
@@ -140,6 +143,11 @@ export async function createTask(opts: {
   base?: { branch: string; tip: string; stack: StackedOn };
   // Cut from this branch instead of the default one.
   baseBranch?: string;
+  // The agent CLI that does the work (Claude Code unless a person picks
+  // another). Another agent runs as a chat on this machine, on its own
+  // default model unless `model` names one, without plan-first or role
+  // models: those are Claude Code's.
+  agent?: AgentType;
   // Called once the session row exists, before the agent launches.
   onCreated?: (sessionId: string) => void;
   // Run it on this machine (another one's own AgentOS); default: the project's.
@@ -201,6 +209,17 @@ async function startTask(
   if (!project || project.is_uncategorized) throw new Error("Pick a project");
   const hostId = opts.hostId ?? project.host_id;
   const view = opts.view ?? DEFAULT_START_VIEW;
+  const agent = opts.agent ?? "claude";
+  if (agent !== "claude") {
+    if (!supportsChat(agent))
+      throw new Error(`${agentLabel(agent)} can't run a task yet`);
+    if (view !== "chat")
+      throw new Error(`${agentLabel(agent)} runs a task as a chat`);
+    if (opts.plan || opts.planOnly)
+      throw new Error(`${agentLabel(agent)} doesn't plan first yet`);
+    if (isRemoteHost(hostId))
+      throw new Error(`${agentLabel(agent)} tasks run on this machine for now`);
+  }
   if (isRemoteHost(hostId)) {
     if (opts.planOnly)
       throw new Error("A plan-only task runs on this machine for now");
@@ -228,13 +247,16 @@ async function startTask(
     );
   if (opts.planOnly && view !== "chat")
     throw new Error("A plan-only task needs a chat, not a terminal");
-  const routing = taskRouting(
-    project.workspace_id,
-    view,
-    opts.model,
-    opts.plan,
-    opts.planOnly
-  );
+  const routing =
+    agent === "claude"
+      ? taskRouting(
+          project.workspace_id,
+          view,
+          opts.model,
+          opts.plan,
+          opts.planOnly
+        )
+      : otherAgentRouting(opts.model);
   const projectPath = expandHome(project.working_directory);
   const naming = await nameFor(prompt, projectPath, opts.name);
   const feature = `${slugify(naming.name.split(/\s+/).slice(0, 6).join(" "))}-${id.slice(0, 4)}`;
@@ -253,7 +275,7 @@ async function startTask(
     startPoint: opts.base?.tip,
   });
 
-  const provider = getProvider("claude");
+  const provider = getProvider(agent);
   const model = routing.first.model;
   const tmuxName = `${provider.id}-${id}`;
 
@@ -268,7 +290,7 @@ async function startTask(
       model,
       null,
       "sessions",
-      "claude",
+      agent,
       1,
       project.id,
       "local"
@@ -453,6 +475,19 @@ export async function listTasks(): Promise<TaskView[]> {
   );
 }
 
+// Another agent's task: its own model (or its default), never planned first.
+function otherAgentRouting(model: unknown) {
+  return {
+    override: null,
+    plan: false,
+    planOnly: false,
+    first: {
+      model: typeof model === "string" && model ? model : AGENT_DEFAULT_MODEL,
+      provider: { id: ANTHROPIC },
+    },
+  };
+}
+
 // The model a task starts on, and whether it plans first: only as a chat,
 // where the handoff can follow the end of its plan turn, and only when
 // planning and implementing are on different models. Both roles resolve

package/lib/tasks/queue.ts

@@ -12,6 +12,7 @@
  */
 
 import type { ModelOverride } from "../models/resolve";
+import type { AgentType } from "../providers";
 import { randomUUID } from "crypto";
 import { db, type Session } from "../db";
 import { getProject } from "../projects";
@@ -51,6 +52,7 @@ export interface QueueRow {
   plan_only: number | null;
   started_by: string | null;
   view: "chat" | "terminal" | null;
+  agent_type: string | null;
   base_branch: string | null;
   host_id: string | null;
   // A task (or queued task) it waits on, by id.
@@ -226,6 +228,7 @@ export interface QueueRequest {
   planOnly?: boolean;
   startedBy?: string | null;
   view?: "chat" | "terminal";
+  agent?: AgentType;
   baseBranch?: string;
   hostId?: string;
   // A task's id or name, or "any" for whichever running task finishes first.
@@ -279,9 +282,9 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
   if (!req.prompt.trim()) throw new Error("Describe the task");
   const id = randomUUID();
   db.prepare(
-    `INSERT INTO task_queue (id, project_id, prompt, name, model, model_overrides, plan, plan_reason, plan_only, started_by, view, base_branch,
+    `INSERT INTO task_queue (id, project_id, prompt, name, model, model_overrides, plan, plan_reason, plan_only, started_by, view, agent_type, base_branch,
        host_id, after_task, after_any, origin_workspace_id, position)
-     VALUES (@id, @project_id, @prompt, @name, @model, @model_overrides, @plan, @plan_reason, @plan_only, @started_by, @view, @base_branch,
+     VALUES (@id, @project_id, @prompt, @name, @model, @model_overrides, @plan, @plan_reason, @plan_only, @started_by, @view, @agent_type, @base_branch,
        @host_id, @after_task, @after_any, @origin,
        (SELECT COALESCE(MAX(position), 0) + 1 FROM task_queue))`
   ).run({
@@ -299,6 +302,7 @@ export function queueIfNeeded(req: QueueRequest): QueuedTaskView | null {
     plan_only: req.planOnly ? 1 : null,
     started_by: req.startedBy ?? null,
     view: req.view ?? null,
+    agent_type: req.agent ?? null,
     base_branch: req.baseBranch || null,
     host_id: req.hostId || null,
     after_task: afterTask,
@@ -478,6 +482,7 @@ async function startRow(
     planOnly: !!r.plan_only,
     startedBy: r.started_by,
     view: r.view ?? undefined,
+    agent: (r.agent_type as AgentType | null) ?? undefined,
     baseBranch: r.base_branch ?? undefined,
     hostId: r.host_id ?? undefined,
     reclaim: true,

package/lib/worktree-hooks.ts

@@ -28,7 +28,7 @@ const git = (cwd: string, args: string[]) =>
 // same rule as lib/tasks/code-review.ts's ATTRIBUTION for PR bodies; a test
 // keeps the two agreeing.
 export const ATTRIBUTION_ERE =
-  "^[[:space:]]*(co-authored-by:.*(claude|anthropic)|claude-session:|🤖 generated with)|(^|[^[:alnum:]\"'`])generated (with|by) \\[?claude code";
+  "^[[:space:]]*(co-authored-by:.*(claude|anthropic|copilot)|claude-session:|🤖 generated with)|(^|[^[:alnum:]\"'`])generated (with|by) \\[?claude code";
 
 // The hooks husky installs; a project's own hook of any of these keeps
 // running. Not post-index-change or reference-transaction: those run on

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.527",
+  "version": "0.3.528",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/scripts/setup.sh

@@ -29,7 +29,7 @@ echo "tmux: $(tmux -V)"
 
 # Check AI coding CLI
 AI_CLI_FOUND=""
-for cli in claude codex opencode kilo gemini aider cursor-agent amp pi omp; do
+for cli in claude codex opencode kilo gemini aider cursor-agent amp pi omp copilot; do
     if command -v "$cli" &> /dev/null; then
         AI_CLI_FOUND="$AI_CLI_FOUND $cli"
     fi